1 files changed, 510 insertions, 0 deletions

diff --git a/src/lib/common/gnunet_dbus_lib_push.c b/src/lib/common/gnunet_dbus_lib_push.c
new file mode 100644
index 0000000..1cb455e
--- /dev/null
+++ b/src/lib/common/gnunet_dbus_lib_push.c
@@ -0,0 +1,510 @@
+#include "config.h"
+
+#include <stdbool.h>
+
+#include <gnunet/platform.h>
+#include <gnunet/gnunet_common.h>
+#include <gnunet/gnunet_strings_lib.h>
+
+#include "gnunet_dbus_lib.h"
+#include "gnunet_crypto_dbus_lib.h"
+
+#define LOG(kind, ...) GNUNET_log_from (kind, "dbus-push", __VA_ARGS__)
+
+static void
+push_basic (
+    DBusMessage *message,
+    DBusMessageIter *iter,
+    int type,
+    const void *value)
+{
+  (void)message;
+  bool success = dbus_message_iter_append_basic (iter, type, value);
+  if (! success)
+  {
+    LOG (GNUNET_ERROR_TYPE_ERROR, "Ran out of memory in dbus_message_iter_append_basic\n");
+    GNUNET_abort_ ();
+  }
+}
+
+void
+GNUNET_DBUS_push_byte (
+    DBusMessage *message,
+    DBusMessageIter *iter,
+    const unsigned char *value)
+{
+  LOG (GNUNET_ERROR_TYPE_DEBUG, "Pushing byte\n");
+  push_basic (message, iter, DBUS_TYPE_BYTE, value);
+}
+
+void
+GNUNET_DBUS_push_boolean (
+    DBusMessage *message,
+    DBusMessageIter *iter,
+    const dbus_bool_t *value)
+{
+  LOG (GNUNET_ERROR_TYPE_DEBUG, "Pushing boolean\n");
+  push_basic (message, iter, DBUS_TYPE_BOOLEAN, value);
+}
+
+void
+GNUNET_DBUS_push_int16 (
+    DBusMessage *message,
+    DBusMessageIter *iter,
+    const dbus_int16_t *value)
+{
+  LOG (GNUNET_ERROR_TYPE_DEBUG, "Pushing int16\n");
+  push_basic (message, iter, DBUS_TYPE_INT16, value);
+}
+
+void
+GNUNET_DBUS_push_uint16 (
+    DBusMessage *message,
+    DBusMessageIter *iter,
+    const dbus_uint16_t *value)
+{
+  LOG (GNUNET_ERROR_TYPE_DEBUG, "Pushing uint16\n");
+  push_basic (message, iter, DBUS_TYPE_UINT16, value);
+}
+
+void
+GNUNET_DBUS_push_int32 (
+    DBusMessage *message,
+    DBusMessageIter *iter,
+    const dbus_int32_t *value)
+{
+  LOG (GNUNET_ERROR_TYPE_DEBUG, "Pushing int32\n");
+  push_basic (message, iter, DBUS_TYPE_INT32, value);
+}
+
+void
+GNUNET_DBUS_push_uint32 (
+    DBusMessage *message,
+    DBusMessageIter *iter,
+    const dbus_uint32_t *value)
+{
+  LOG (GNUNET_ERROR_TYPE_DEBUG, "Pushing uint32\n");
+  push_basic (message, iter, DBUS_TYPE_UINT32, value);
+}
+
+void
+GNUNET_DBUS_push_int64 (
+    DBusMessage *message,
+    DBusMessageIter *iter,
+    const dbus_int64_t *value)
+{
+  LOG (GNUNET_ERROR_TYPE_DEBUG, "Pushing int64\n");
+  push_basic (message, iter, DBUS_TYPE_INT64, value);
+}
+
+void
+GNUNET_DBUS_push_uint64 (
+    DBusMessage *message,
+    DBusMessageIter *iter,
+    const dbus_uint64_t *value)
+{
+  LOG (GNUNET_ERROR_TYPE_DEBUG, "Pushing uint64\n");
+  push_basic (message, iter, DBUS_TYPE_UINT64, value);
+}
+
+void
+GNUNET_DBUS_push_double (
+    DBusMessage *message,
+    DBusMessageIter *iter,
+    const double *value)
+{
+  LOG (GNUNET_ERROR_TYPE_DEBUG, "Pushing double\n");
+  push_basic (message, iter, DBUS_TYPE_DOUBLE, value);
+}
+
+void
+GNUNET_DBUS_push_string (
+    DBusMessage *message,
+    DBusMessageIter *iter,
+    const char *const *value)
+{
+  LOG (GNUNET_ERROR_TYPE_DEBUG, "Pushing string\n");
+  push_basic (message, iter, DBUS_TYPE_STRING, value);
+}
+
+void
+GNUNET_DBUS_push_object_path (
+    DBusMessage *message,
+    DBusMessageIter *iter,
+    const struct GNUNET_DBUS_ObjectPath *path)
+{
+  LOG (GNUNET_ERROR_TYPE_DEBUG, "Pushing object path\n");
+  char *path_as_string = GNUNET_DBUS_object_path_to_string (path);
+  push_basic (message, iter, DBUS_TYPE_OBJECT_PATH, &path_as_string);
+  GNUNET_free (path_as_string);
+}
+
+void
+GNUNET_DBUS_push_signature (
+    DBusMessage *message,
+    DBusMessageIter *iter,
+    const char *const *value)
+{
+  LOG (GNUNET_ERROR_TYPE_DEBUG, "Pushing signature\n");
+  push_basic (message, iter, DBUS_TYPE_SIGNATURE, value);
+}
+
+void
+GNUNET_DBUS_push_unix_fd (
+    DBusMessage *message,
+    DBusMessageIter *iter,
+    const int *value)
+{
+  LOG (GNUNET_ERROR_TYPE_DEBUG, "Pushing unix fd\n");
+  push_basic (message, iter, DBUS_TYPE_UNIX_FD, value);
+}
+
+static void
+push_open_container (
+    DBusMessage *message,
+    DBusMessageIter *iter,
+    DBusMessageIter *iter_sub,
+    int type,
+    const char *signature)
+{
+  (void)message;
+  bool success = dbus_message_iter_open_container (iter, type, signature, iter_sub);
+  if (! success)
+  {
+    LOG (GNUNET_ERROR_TYPE_ERROR, "Ran out of memory in dbus_message_iter_open_container\n");
+    GNUNET_abort_ ();
+  }
+}
+
+void
+GNUNET_DBUS_push_open_array (
+    DBusMessage *message,
+    DBusMessageIter *iter,
+    DBusMessageIter *iter_sub,
+    const char *signature)
+{
+  LOG (GNUNET_ERROR_TYPE_DEBUG, "Opening array\n");
+  push_open_container (message, iter, iter_sub, DBUS_TYPE_ARRAY, signature);
+}
+
+void
+GNUNET_DBUS_push_open_struct (
+    DBusMessage *message,
+    DBusMessageIter *iter,
+    DBusMessageIter *iter_sub)
+{
+  LOG (GNUNET_ERROR_TYPE_DEBUG, "Opening struct\n");
+  push_open_container (message, iter, iter_sub, DBUS_TYPE_STRUCT, NULL);
+}
+
+void
+GNUNET_DBUS_push_open_variant (
+    DBusMessage *message,
+    DBusMessageIter *iter,
+    DBusMessageIter *iter_sub,
+    const char *signature)
+{
+  LOG (GNUNET_ERROR_TYPE_DEBUG, "Opening variant\n");
+  push_open_container (message, iter, iter_sub, DBUS_TYPE_VARIANT, signature);
+}
+
+void
+GNUNET_DBUS_push_open_dict_entry (
+    DBusMessage *message,
+    DBusMessageIter *iter,
+    DBusMessageIter *iter_sub)
+{
+  LOG (GNUNET_ERROR_TYPE_DEBUG, "Opening dict entry\n");
+  push_open_container (message, iter, iter_sub, DBUS_TYPE_DICT_ENTRY, NULL);
+}
+
+static void
+push_close_container (
+    DBusMessage *message,
+    DBusMessageIter *iter,
+    DBusMessageIter *iter_sub)
+{
+  (void)message;
+  bool success = dbus_message_iter_close_container (iter, iter_sub);
+  if (! success)
+  {
+    LOG (GNUNET_ERROR_TYPE_ERROR, "Ran out of memory in dbus_message_iter_close_container\n");
+    GNUNET_abort_ ();
+  }
+}
+
+void
+GNUNET_DBUS_push_close_array (
+    DBusMessage *message,
+    DBusMessageIter *iter,
+    DBusMessageIter *iter_sub)
+{
+  LOG (GNUNET_ERROR_TYPE_DEBUG, "Closing array\n");
+  push_close_container (message, iter, iter_sub);
+}
+
+void
+GNUNET_DBUS_push_close_struct (
+    DBusMessage *message,
+    DBusMessageIter *iter,
+    DBusMessageIter *iter_sub)
+{
+  LOG (GNUNET_ERROR_TYPE_DEBUG, "Closing struct\n");
+  push_close_container (message, iter, iter_sub);
+}
+
+void
+GNUNET_DBUS_push_close_variant (
+    DBusMessage *message,
+    DBusMessageIter *iter,
+    DBusMessageIter *iter_sub)
+{
+  LOG (GNUNET_ERROR_TYPE_DEBUG, "Closing variant\n");
+  push_close_container (message, iter, iter_sub);
+}
+
+void
+GNUNET_DBUS_push_close_dict_entry (
+    DBusMessage *message,
+    DBusMessageIter *iter,
+    DBusMessageIter *iter_sub)
+{
+  LOG (GNUNET_ERROR_TYPE_DEBUG, "Closing dict entry\n");
+  push_close_container (message, iter, iter_sub);
+}
+
+static void
+push_fixed_array (
+    DBusMessage *message,
+    DBusMessageIter *iter,
+    int type,
+    const void *value,
+    size_t value_count)
+{
+  char sig[2] = { (char)type, '\0' };
+  DBusMessageIter iter_sub;
+
+  GNUNET_DBUS_push_open_array (message, iter, &iter_sub, sig);
+  bool success = dbus_message_iter_append_fixed_array (&iter_sub, type, value, (int)value_count);
+  if (! success)
+  {
+    LOG (GNUNET_ERROR_TYPE_ERROR, "Ran out of memory in dbus_message_iter_push_fixed_array\n");
+    GNUNET_abort_ ();
+  }
+  GNUNET_DBUS_push_close_array (message, iter, &iter_sub);
+}
+
+void
+GNUNET_DBUS_push_byte_array (
+    DBusMessage *message,
+    DBusMessageIter *iter,
+    const unsigned char *value,
+    size_t value_count)
+{
+  LOG (GNUNET_ERROR_TYPE_DEBUG, "Pushing byte array\n");
+  push_fixed_array (message, iter, DBUS_TYPE_BYTE, &value, value_count);
+}
+
+void
+GNUNET_DBUS_push_boolean_array (
+    DBusMessage *message,
+    DBusMessageIter *iter,
+    const dbus_bool_t *value,
+    size_t value_count)
+{
+  LOG (GNUNET_ERROR_TYPE_DEBUG, "Pushing boolean array\n");
+  push_fixed_array (message, iter, DBUS_TYPE_BOOLEAN, &value, value_count);
+}
+
+void
+GNUNET_DBUS_push_int16_array (
+    DBusMessage *message,
+    DBusMessageIter *iter,
+    const dbus_int16_t *value,
+    size_t value_count)
+{
+  LOG (GNUNET_ERROR_TYPE_DEBUG, "Pushing int16 array\n");
+  push_fixed_array (message, iter, DBUS_TYPE_INT16, &value, value_count);
+}
+
+void
+GNUNET_DBUS_push_uint16_array (
+    DBusMessage *message,
+    DBusMessageIter *iter,
+    const dbus_uint16_t *value,
+    size_t value_count)
+{
+  LOG (GNUNET_ERROR_TYPE_DEBUG, "Pushing uint16 array\n");
+  push_fixed_array (message, iter, DBUS_TYPE_UINT16, &value, value_count);
+}
+
+void
+GNUNET_DBUS_push_int32_array (
+    DBusMessage *message,
+    DBusMessageIter *iter,
+    const unsigned char *value,
+    size_t value_count)
+{
+  LOG (GNUNET_ERROR_TYPE_DEBUG, "Pushing int32 array\n");
+  push_fixed_array (message, iter, DBUS_TYPE_INT32, &value, value_count);
+}
+
+void
+GNUNET_DBUS_push_uint32_array (
+    DBusMessage *message,
+    DBusMessageIter *iter,
+    const unsigned char *value,
+    size_t value_count)
+{
+  LOG (GNUNET_ERROR_TYPE_DEBUG, "Pushing uint32 array\n");
+  push_fixed_array (message, iter, DBUS_TYPE_UINT32, &value, value_count);
+}
+
+void
+GNUNET_DBUS_push_int64_array (
+    DBusMessage *message,
+    DBusMessageIter *iter,
+    const unsigned char *value,
+    size_t value_count)
+{
+  LOG (GNUNET_ERROR_TYPE_DEBUG, "Pushing int64 array\n");
+  push_fixed_array (message, iter, DBUS_TYPE_INT64, &value, value_count);
+}
+
+void
+GNUNET_DBUS_push_uint64_array (
+    DBusMessage *message,
+    DBusMessageIter *iter,
+    const unsigned char *value,
+    size_t value_count)
+{
+  LOG (GNUNET_ERROR_TYPE_DEBUG, "Pushing uint64 array\n");
+  push_fixed_array (message, iter, DBUS_TYPE_UINT64, &value, value_count);
+}
+
+void
+GNUNET_DBUS_push_double_array (
+    DBusMessage *message,
+    DBusMessageIter *iter,
+    const unsigned char *value,
+    size_t value_count)
+{
+  LOG (GNUNET_ERROR_TYPE_DEBUG, "Pushing double array\n");
+  push_fixed_array (message, iter, DBUS_TYPE_DOUBLE, &value, value_count);
+}
+
+void
+GNUNET_DBUS_push_bitfield (
+    DBusMessage *message,
+    DBusMessageIter *iter,
+    const int *value,
+    const struct GNUNET_DBUS_StringEnumPair *fields)
+{
+  DBusMessageIter iter_sub;
+  if (GNUNET_DBUS_message_get_pretty (message))
+  {
+    DBusMessageIter iter_sub_sub;
+
+    GNUNET_DBUS_push_open_variant (message, iter, &iter_sub, GNUNET_DBUS_SIGNATURE_ARRAY (GNUNET_DBUS_SIGNATURE_STRING));
+    GNUNET_DBUS_push_open_array (message, &iter_sub, &iter_sub_sub, GNUNET_DBUS_SIGNATURE_STRING);
+    const struct GNUNET_DBUS_StringEnumPair *field;
+    for (field = fields; field->name; field++)
+    {
+      if ((*value & field->value) == field->value)
+        GNUNET_DBUS_push_string (message, &iter_sub_sub, &field->name);
+    };
+    GNUNET_DBUS_push_close_array (message, &iter_sub, &iter_sub_sub);
+    GNUNET_DBUS_push_close_variant (message, iter, &iter_sub);
+  }
+  else
+  {
+    uint32_t push_value = (uint32_t)*value;
+    GNUNET_DBUS_push_open_variant (message, iter, &iter_sub, GNUNET_DBUS_SIGNATURE_UINT32);
+    GNUNET_DBUS_push_uint32 (message, &iter_sub, &push_value);
+    GNUNET_DBUS_push_close_variant (message, iter, &iter_sub);
+  };
+};
+
+void
+GNUNET_DBUS_push_enum (
+    DBusMessage *message,
+    DBusMessageIter *iter,
+    const int *value,
+    const struct GNUNET_DBUS_StringEnumPair *names)
+{
+  DBusMessageIter iter_sub;
+  if (GNUNET_DBUS_message_get_pretty (message))
+  {
+    GNUNET_DBUS_push_open_variant (message, iter, &iter_sub, GNUNET_DBUS_SIGNATURE_STRING);
+    const struct GNUNET_DBUS_StringEnumPair *name;
+    for (name = names; name->name; name++)
+    {
+      if (name->value == *value)
+      {
+        GNUNET_DBUS_push_string (message, &iter_sub, &name->name);
+        break;
+      }
+    }
+    GNUNET_DBUS_push_close_variant (message, iter, &iter_sub);
+  }
+  else
+  {
+    uint32_t push_value = (uint32_t)*value;
+    GNUNET_DBUS_push_open_variant (message, iter, &iter_sub, GNUNET_DBUS_SIGNATURE_UINT32);
+    GNUNET_DBUS_push_uint32 (message, &iter_sub, &push_value);
+    GNUNET_DBUS_push_close_variant (message, iter, &iter_sub);
+  };
+};
+
+void
+GNUNET_DBUS_push_data (
+    DBusMessage *message,
+    DBusMessageIter *iter,
+    const void *value,
+    size_t value_size)
+{
+  DBusMessageIter iter_sub;
+  if (GNUNET_DBUS_message_get_pretty (message))
+  {
+    size_t string_size = (value_size * 8 + 4) / 5 + 1;
+    char *string = GNUNET_malloc (string_size);
+    char *end = GNUNET_STRINGS_data_to_string (value, value_size, string, string_size);
+    *end = '\0';
+    const char *string_const = string;
+
+    GNUNET_DBUS_push_open_variant (message, iter, &iter_sub, GNUNET_DBUS_SIGNATURE_STRING);
+    GNUNET_DBUS_push_string (message, &iter_sub, &string_const);
+    GNUNET_DBUS_push_close_variant (message, iter, &iter_sub);
+    GNUNET_free (string);
+  }
+  else
+  {
+    GNUNET_DBUS_push_open_variant (message, iter, &iter_sub, GNUNET_DBUS_SIGNATURE_ARRAY (GNUNET_DBUS_SIGNATURE_BYTE));
+    GNUNET_DBUS_push_byte_array (message, &iter_sub, value, value_size);
+    GNUNET_DBUS_push_close_variant (message, iter, &iter_sub);
+  };
+}
+
+void
+GNUNET_DBUS_push_hashcode (
+    DBusMessage *message,
+    DBusMessageIter *iter,
+    const struct GNUNET_HashCode *value)
+{
+  LOG (GNUNET_ERROR_TYPE_DEBUG, "Pushing GNUNET_HashCode\n");
+  GNUNET_DBUS_push_data (message, iter, value->bits, sizeof (value->bits));
+}
+
+void
+GNUNET_DBUS_push_peer_identity (
+    DBusMessage *message,
+    DBusMessageIter *iter,
+    const struct GNUNET_PeerIdentity *value)
+{
+  LOG (GNUNET_ERROR_TYPE_DEBUG, "Pushing GNUNET_PeerIdentity\n");
+  DBusMessageIter iter_sub;
+  GNUNET_DBUS_push_open_struct (message, iter, &iter_sub);
+  GNUNET_CRYPTO_DBUS_push_eddsa_public_key (message, &iter_sub, &value->public_key);
+  GNUNET_DBUS_push_close_struct (message, iter, &iter_sub);
+}
+