+
+/**
+ * g_kdbus_bloom_add_prefixes:
+ *
+ */
+static void
+g_kdbus_bloom_add_prefixes (GKDBusWorker *worker,
+ guint64 bloom_data [],
+ const gchar *parameter,
+ const gchar *value,
+ gchar separator)
+{
+ gchar buf[1024];
+ gsize size;
+
+ size = strlen(parameter) + strlen(value) + 1;
+ if (size > 1024)
+ return;
+
+ strcpy(stpcpy(stpcpy(buf, parameter), ":"), value);
+
+ for (;;)
+ {
+ gchar *last_sep;
+ last_sep = strrchr(buf, separator);
+ if (!last_sep || last_sep == buf)
+ break;
+
+ *last_sep = 0;
+ g_kdbus_bloom_add_data(worker, bloom_data, buf, last_sep-buf);
+ }
+}
+
+
+/**
+ * _g_kdbus_AddMatch:
+ *
+ */
+void
+_g_kdbus_AddMatch (GKDBusWorker *worker,
+ const gchar *match_rule,
+ guint cookie)
+{
+ Match *match;
+ MatchElement *element;
+ const gchar *sender_name;
+ gsize sender_len, size;
+ struct kdbus_cmd_match *cmd;
+ struct kdbus_item *item;
+ guint64 *bloom;
+ guint64 src_id;
+ gchar *type;
+ gint cnt, ret;
+
+ if (match_rule[0] == '-')
+ return;
+
+ match = match_new (match_rule);
+ if (!match)
+ {
+ match_free (match);
+ return;
+ }
+
+ sender_name = NULL;
+ src_id = KDBUS_MATCH_ID_ANY;
+
+ bloom = g_alloca0 (worker->bloom_size);
+ size = KDBUS_ALIGN8 (G_STRUCT_OFFSET (struct kdbus_cmd_match, items));
+ match = match_new (match_rule);
+
+ for (cnt = 0; cnt < match->n_elements; cnt++)
+ {
+ element = &match->elements[cnt];
+ switch (element->type)
+ {
+ case MATCH_ELEMENT_SENDER:
+ if (g_dbus_is_unique_name(element->value))
+ {
+ src_id = g_ascii_strtoull ((element->value)+3, NULL, 10);
+ size += KDBUS_ALIGN8 (G_STRUCT_OFFSET (struct kdbus_item, id) + sizeof(src_id));
+ }
+ else if (g_dbus_is_name (element->value))
+ {
+ sender_name = element->value;
+ sender_len = strlen(element->value) + 1;
+ size += KDBUS_ALIGN8 (G_STRUCT_OFFSET (struct kdbus_item, str) + sender_len);
+ }
+ else
+ {
+ g_critical ("Error while adding a match: %d", cookie);
+ match_free (match);
+ return;
+ }
+ break;
+
+ case MATCH_ELEMENT_TYPE:
+ g_kdbus_bloom_add_pair (worker, bloom, "message-type", element->value);
+ break;
+
+ case MATCH_ELEMENT_INTERFACE:
+ g_kdbus_bloom_add_pair (worker, bloom, "interface", element->value);
+ break;
+
+ case MATCH_ELEMENT_MEMBER:
+ g_kdbus_bloom_add_pair (worker, bloom, "member", element->value);
+ break;
+
+ case MATCH_ELEMENT_PATH:
+ g_kdbus_bloom_add_pair (worker, bloom, "path", element->value);
+ break;
+
+ case MATCH_ELEMENT_PATH_NAMESPACE:
+ if (g_strcmp0 (element->value, "/"))
+ g_kdbus_bloom_add_pair (worker, bloom, "path-slash-prefix", element->value);
+ break;
+
+ case MATCH_ELEMENT_ARGN:
+ asprintf (&type, "arg%u", element->arg);
+ g_kdbus_bloom_add_pair (worker, bloom, type, element->value);
+ free (type);
+ break;
+
+ case MATCH_ELEMENT_ARGNPATH:
+ asprintf (&type, "arg%u-slash-prefix", element->arg);
+ g_kdbus_bloom_add_pair (worker, bloom, type, element->value);
+ free (type);
+ break;
+
+ case MATCH_ELEMENT_ARG0NAMESPACE:
+ g_kdbus_bloom_add_pair (worker, bloom, "arg0-dot-prefix", element->value);
+ break;
+
+ case MATCH_ELEMENT_DESTINATION:
+ case MATCH_ELEMENT_EAVESDROP:
+ break;
+ }
+ }
+
+ size += KDBUS_ALIGN8 (G_STRUCT_OFFSET (struct kdbus_item, data64) + worker->bloom_size);
+ cmd = g_alloca0 (size);
+ cmd->size = size;
+ cmd->cookie = cookie;
+
+ item = cmd->items;
+ item->size = G_STRUCT_OFFSET(struct kdbus_item, data64) + worker->bloom_size;
+ item->type = KDBUS_ITEM_BLOOM_MASK;
+ memcpy(item->data64, bloom, worker->bloom_size);
+ item = KDBUS_ITEM_NEXT(item);
+
+ if (src_id != KDBUS_MATCH_ID_ANY)
+ {
+ item->size = G_STRUCT_OFFSET (struct kdbus_item, id) + sizeof(src_id);
+ item->type = KDBUS_ITEM_ID;
+ item->id = src_id;
+ item = KDBUS_ITEM_NEXT(item);
+ }
+
+ if (sender_name)
+ {
+ item->size = G_STRUCT_OFFSET (struct kdbus_item, str) + sender_len;
+ item->type = KDBUS_ITEM_NAME;
+ memcpy (item->str, sender_name, sender_len);
+ }
+
+ ret = ioctl(worker->fd, KDBUS_CMD_MATCH_ADD, cmd);
+ if (ret < 0)
+ g_critical ("Error while adding a match: %d", cookie);
+
+ match_free (match);
+}
+
+
+/**
+ * _g_kdbus_RemoveMatch:
+ *
+ */
+void
+_g_kdbus_RemoveMatch (GKDBusWorker *worker,
+ guint cookie)
+{
+ struct kdbus_cmd_match cmd = {
+ .size = sizeof(cmd),
+ .cookie = cookie
+ };
+ gint ret;
+
+ ret = ioctl(worker->fd, KDBUS_CMD_MATCH_REMOVE, &cmd);
+ if (ret < 0)
+ g_warning ("Error while removing a match: %d\n", (int) errno);
+}
+
+
+/**
+ * _g_kdbus_subscribe_name_acquired:
+ *
+ */
+static void
+_g_kdbus_subscribe_name_owner_changed (GKDBusWorker *worker,
+ const gchar *name,
+ const gchar *old_name,
+ const gchar *new_name,
+ guint cookie)
+{
+ struct kdbus_item *item;
+ struct kdbus_cmd_match *cmd;
+ gssize size, len;
+ gint ret;
+ guint64 old_id = 0; /* XXX why? */
+ guint64 new_id = KDBUS_MATCH_ID_ANY;
+
+ len = strlen(name) + 1;
+ size = KDBUS_ALIGN8(G_STRUCT_OFFSET (struct kdbus_cmd_match, items) +
+ G_STRUCT_OFFSET (struct kdbus_item, name_change) +
+ G_STRUCT_OFFSET (struct kdbus_notify_name_change, name) + len);
+
+ cmd = g_alloca0 (size);
+ cmd->size = size;
+ cmd->cookie = cookie;
+ item = cmd->items;
+
+ if (old_name[0] == 0)
+ {
+ old_id = KDBUS_MATCH_ID_ANY;
+ }
+ else
+ {
+ if (g_dbus_is_unique_name(old_name))
+ old_id = old_id+3;
+ else
+ return;
+ }
+
+ if (new_name[0] == 0)
+ {
+ new_id = KDBUS_MATCH_ID_ANY;
+ }
+ else
+ {
+ if (g_dbus_is_unique_name(new_name))
+ new_id = new_id+3;
+ else
+ return;
+ }
+
+ cmd = g_alloca0 (size);
+ cmd->size = size;
+ cmd->cookie = cookie;
+ item = cmd->items;
+
+ /* KDBUS_ITEM_NAME_CHANGE */
+ item->type = KDBUS_ITEM_NAME_CHANGE;
+ item->name_change.old_id.id = old_id;
+ item->name_change.new_id.id = new_id;
+ memcpy(item->name_change.name, name, len);
+ item->size = G_STRUCT_OFFSET (struct kdbus_item, name_change) +
+ G_STRUCT_OFFSET(struct kdbus_notify_name_change, name) + len;
+ item = KDBUS_ITEM_NEXT(item);
+
+ ret = ioctl(worker->fd, KDBUS_CMD_MATCH_ADD, cmd);
+ if (ret < 0)
+ g_warning ("ERROR - %d\n", (int) errno);
+}
+
+
+/**
+ * _g_kdbus_subscribe_name_acquired:
+ *
+ */
+void
+_g_kdbus_subscribe_name_acquired (GKDBusWorker *worker,
+ const gchar *name)
+{
+ struct kdbus_item *item;
+ struct kdbus_cmd_match *cmd;
+ gssize size, len;
+ guint64 cookie;
+ gint ret;
+
+ len = strlen(name) + 1;
+ size = KDBUS_ALIGN8(G_STRUCT_OFFSET (struct kdbus_cmd_match, items) +
+ G_STRUCT_OFFSET (struct kdbus_item, name_change) +
+ G_STRUCT_OFFSET (struct kdbus_notify_name_change, name) + len);
+
+ cookie = 0xbeefbeefbeefbeef;
+ cmd = g_alloca0 (size);
+ cmd->size = size;
+ cmd->cookie = cookie;
+ item = cmd->items;
+
+ /* KDBUS_ITEM_NAME_ADD */
+ item->type = KDBUS_ITEM_NAME_ADD;
+ item->name_change.old_id.id = KDBUS_MATCH_ID_ANY;
+ item->name_change.new_id.id = worker->unique_id;
+ memcpy(item->name_change.name, name, len);
+ item->size = G_STRUCT_OFFSET (struct kdbus_item, name_change) +
+ G_STRUCT_OFFSET(struct kdbus_notify_name_change, name) + len;
+ item = KDBUS_ITEM_NEXT(item);
+
+ ret = ioctl(worker->fd, KDBUS_CMD_MATCH_ADD, cmd);
+ if (ret < 0)
+ g_warning ("ERROR - %d\n", (int) errno);
+
+ _g_kdbus_subscribe_name_owner_changed (worker, name, "", worker->unique_name, cookie);
+}
+
+
+/**
+ * _g_kdbus_subscribe_name_lost:
+ *
+ */
+void
+_g_kdbus_subscribe_name_lost (GKDBusWorker *worker,
+ const gchar *name)
+{
+ struct kdbus_item *item;
+ struct kdbus_cmd_match *cmd;
+ gssize size, len;
+ guint64 cookie;
+ gint ret;
+
+ len = strlen(name) + 1;
+ size = KDBUS_ALIGN8(G_STRUCT_OFFSET (struct kdbus_cmd_match, items) +
+ G_STRUCT_OFFSET (struct kdbus_item, name_change) +
+ G_STRUCT_OFFSET (struct kdbus_notify_name_change, name) + len);
+
+ cookie = 0xdeafdeafdeafdeaf;
+ cmd = g_alloca0 (size);
+ cmd->size = size;
+ cmd->cookie = cookie;
+ item = cmd->items;
+
+ /* KDBUS_ITEM_NAME_REMOVE */
+ item->type = KDBUS_ITEM_NAME_REMOVE;
+ item->name_change.old_id.id = worker->unique_id;
+ item->name_change.new_id.id = KDBUS_MATCH_ID_ANY;
+ memcpy(item->name_change.name, name, len);
+ item->size = G_STRUCT_OFFSET (struct kdbus_item, name_change) +
+ G_STRUCT_OFFSET(struct kdbus_notify_name_change, name) + len;
+ item = KDBUS_ITEM_NEXT(item);
+
+ ret = ioctl(worker->fd, KDBUS_CMD_MATCH_ADD, cmd);
+ if (ret < 0)
+ g_warning ("ERROR - %d\n", (int) errno);
+
+ _g_kdbus_subscribe_name_owner_changed (worker, name, worker->unique_name, "", cookie);
+}
+
+
+/**
+ * _g_kdbus_unsubscribe_name_acquired:
+ *
+ */
+void
+_g_kdbus_unsubscribe_name_acquired (GKDBusWorker *worker)
+{
+ guint64 cookie;
+
+ cookie = 0xbeefbeefbeefbeef;
+ _g_kdbus_RemoveMatch (worker, cookie);
+}
+
+
+/**
+ * _g_kdbus_unsubscribe_name_lost:
+ *
+ */
+void
+_g_kdbus_unsubscribe_name_lost (GKDBusWorker *worker)
+{
+ guint64 cookie;
+
+ cookie = 0xdeafdeafdeafdeaf;
+ _g_kdbus_RemoveMatch (worker, cookie);
+}
+
+
+/**
+ * g_kdbus_append_payload_bloom:
+ *
+ */
+static struct kdbus_bloom_filter *
+g_kdbus_append_bloom (struct kdbus_item **item,
+ gsize size)
+{
+ struct kdbus_item *bloom_item;
+
+ bloom_item = KDBUS_ALIGN8_PTR(*item);
+ bloom_item->size = G_STRUCT_OFFSET (struct kdbus_item, bloom_filter) +
+ G_STRUCT_OFFSET (struct kdbus_bloom_filter, data) +
+ size;
+
+ bloom_item->type = KDBUS_ITEM_BLOOM_FILTER;
+
+ *item = KDBUS_ITEM_NEXT(bloom_item);
+ return &bloom_item->bloom_filter;
+}
+
+
+/**
+ * g_kdbus_setup_bloom:
+ * Based on bus-bloom.c from systemd
+ * http://cgit.freedesktop.org/systemd/systemd/tree/src/libsystemd/sd-bus/bus-bloom.c
+ */
+static void
+g_kdbus_setup_bloom (GKDBusWorker *worker,
+ GDBusMessage *dbus_msg,
+ struct kdbus_bloom_filter *bloom_filter)
+{
+ GVariant *body;
+
+ const gchar *message_type;
+ const gchar *interface;
+ const gchar *member;
+ const gchar *path;
+
+ void *bloom_data;
+
+ body = g_dbus_message_get_body (dbus_msg);
+ message_type = _g_dbus_enum_to_string (G_TYPE_DBUS_MESSAGE_TYPE, g_dbus_message_get_message_type (dbus_msg));
+ interface = g_dbus_message_get_interface (dbus_msg);
+ member = g_dbus_message_get_member (dbus_msg);
+ path = g_dbus_message_get_path (dbus_msg);
+
+ bloom_data = bloom_filter->data;
+ memset (bloom_data, 0, worker->bloom_size);
+ bloom_filter->generation = 0;
+
+ g_kdbus_bloom_add_pair(worker, bloom_data, "message-type", message_type);
+
+ if (interface)
+ g_kdbus_bloom_add_pair(worker, bloom_data, "interface", interface);
+
+ if (member)
+ g_kdbus_bloom_add_pair(worker, bloom_data, "member", member);
+
+ if (path)
+ {
+ g_kdbus_bloom_add_pair(worker, bloom_data, "path", path);
+ g_kdbus_bloom_add_pair(worker, bloom_data, "path-slash-prefix", path);
+ g_kdbus_bloom_add_prefixes(worker, bloom_data, "path-slash-prefix", path, '/');
+ }
+
+ if (body != NULL)
+ {
+ const GVariantType *body_type;
+ const GVariantType *arg_type;
+ guint cnt;
+
+ body_type = g_variant_get_type (body);
+
+ for (arg_type = g_variant_type_first (body_type), cnt = 0;
+ arg_type;
+ arg_type = g_variant_type_next (arg_type), cnt++)
+ {
+ gchar type_char = g_variant_type_peek_string (arg_type)[0];
+ gchar buf[sizeof("arg")-1 + 2 + sizeof("-slash-prefix")];
+ const gchar *str;
+ GVariant *child;
+ gchar *e;
+
+ if (type_char != 's' && type_char != 'o')
+ /* XXX: kdbus docs say "stop after first non-string" but I
+ * think they're wrong (vs. dbus-1 compat)...
+ */
+ continue;
+
+ child = g_variant_get_child_value (body, cnt);
+ str = g_variant_get_string (child, NULL);
+
+ e = stpcpy(buf, "arg");
+ if (cnt < 10)
+ *(e++) = '0' + (char) cnt;
+ else
+ {
+ *(e++) = '0' + (char) (cnt / 10);
+ *(e++) = '0' + (char) (cnt % 10);
+ }
+
+ /* We add this one for both strings and object paths */
+ strcpy(e, "-slash-prefix");
+ g_kdbus_bloom_add_prefixes(worker, bloom_data, buf, str, '/');
+
+ /* But the others are only for strings */
+ if (type_char == 's')
+ {
+ strcpy(e, "-dot-prefix");
+ g_kdbus_bloom_add_prefixes(worker, bloom_data, buf, str, '.');
+
+ *e = 0;
+ g_kdbus_bloom_add_pair(worker, bloom_data, buf, str);
+ }
+
+ g_variant_unref (child);
+ }
+ }
+}
+
+
+/*
+ * TODO: g_kdbus_NameOwnerChanged_generate, g_kdbus_KernelMethodError_generate
+ */
+
+/**
+ * g_kdbus_decode_kernel_msg:
+ *
+ */
+static void
+g_kdbus_decode_kernel_msg (GKDBusWorker *worker,
+ struct kdbus_msg *msg)
+{
+ struct kdbus_item *item = NULL;
+
+ KDBUS_ITEM_FOREACH(item, msg, items)
+ {
+ switch (item->type)
+ {
+ case KDBUS_ITEM_ID_ADD:
+ case KDBUS_ITEM_ID_REMOVE:
+ case KDBUS_ITEM_NAME_ADD:
+ case KDBUS_ITEM_NAME_REMOVE:
+ case KDBUS_ITEM_NAME_CHANGE:
+ //size = g_kdbus_NameOwnerChanged_generate (worker, item);
+ g_error ("'NameOwnerChanged'");
+ break;
+
+ case KDBUS_ITEM_REPLY_TIMEOUT:
+ case KDBUS_ITEM_REPLY_DEAD:
+ //size = g_kdbus_KernelMethodError_generate (worker, item);
+ g_error ("'KernelMethodError'");
+ break;
+
+ default:
+ g_warning ("Unknown field in kernel message - %lld", item->type);
+ }
+ }
+
+#if 0
+ /* Override information from the user header with data from the kernel */
+ g_string_printf (worker->msg_sender, "org.freedesktop.DBus");
+
+ /* for destination */
+ if (worker->kmsg->dst_id == KDBUS_DST_ID_BROADCAST)
+ /* for broadcast messages we don't have to set destination */
+ ;
+ else if (worker->kmsg->dst_id == KDBUS_DST_ID_NAME)
+ g_string_printf (worker->msg_destination, ":1.%" G_GUINT64_FORMAT, (guint64) worker->unique_id);
+ else
+ g_string_printf (worker->msg_destination, ":1.%" G_GUINT64_FORMAT, (guint64) worker->kmsg->dst_id);
+
+ return size;
+#endif
+}
+
+
+/**
+ * g_kdbus_decode_dbus_msg:
+ *
+ */
+static GDBusMessage *
+g_kdbus_decode_dbus_msg (GKDBusWorker *worker,
+ struct kdbus_msg *msg)
+{
+ GDBusMessage *message;
+ struct kdbus_item *item;
+ gssize data_size = 0;
+ GArray *body_vectors;
+ gsize body_size;
+ GVariant *body;
+ gchar *tmp;
+ guint i;
+ GVariant *parts[2];
+ GVariantIter *fields_iter;
+ guint8 endianness, type, flags, version;
+ guint64 key;
+ GVariant *value;
+ guint64 serial;
+
+
+ message = g_dbus_message_new ();
+
+ body_vectors = g_array_new (FALSE, FALSE, sizeof (GVariantVector));
+
+ tmp = g_strdup_printf (":1.%"G_GUINT64_FORMAT, (guint64) msg->src_id);
+ g_dbus_message_set_sender (message, tmp);
+ g_free (tmp);
+
+ item = msg->items;
+ body_size = 0;
+
+ KDBUS_ITEM_FOREACH(item, msg, items)
+ {
+ if (item->size <= KDBUS_ITEM_HEADER_SIZE)
+ g_error("[KDBUS] %llu bytes - invalid data record\n", item->size);
+
+ data_size = item->size - KDBUS_ITEM_HEADER_SIZE;
+
+ switch (item->type)
+ {
+ /* KDBUS_ITEM_DST_NAME */
+ case KDBUS_ITEM_DST_NAME:
+ /* Classic D-Bus doesn't make this known to the receiver, so
+ * we don't do it here either (for compatibility with the
+ * fallback case).
+ */
+ break;
+
+ /* KDBUS_ITEM_PALOAD_OFF */
+ case KDBUS_ITEM_PAYLOAD_OFF:
+ {
+ GVariantVector vector;
+ gsize flavour;
+
+ /* We want to make sure the bytes are aligned the same as
+ * they would be if they appeared in a contiguously
+ * allocated chunk of aligned memory.
+ *
+ * We decide what the alignment 'should' be by consulting
+ * body_size, which has been tracking the total size of the
+ * message up to this point.
+ *
+ * We then play around with the pointer by removing as many
+ * bytes as required to get it to the proper alignment (and
+ * copy extra bytes accordingly). This means that we will
+ * grab some extra data in the 'bytes', but it won't be
+ * shared with GVariant (which means there is no chance of
+ * it being accidentally retransmitted).
+ *
+ * The kernel does the same thing, so make sure we get the
+ * expected result. Because of the kernel doing the same,
+ * the result is that we will always be rounding-down to a
+ * multiple of 8 for the pointer, which means that the
+ * pointer will always be valid, assuming the original
+ * address was.
+ *
+ * We could fix this with a new GBytes constructor that took
+ * 'flavour' as a parameter, but it's not worth it...
+ */
+ flavour = body_size & 7;
+ g_assert ((item->vec.offset & 7) == flavour);
+
+ vector.gbytes = g_bytes_new (((guchar *) msg) + item->vec.offset - flavour, item->vec.size + flavour);
+ vector.data.pointer = g_bytes_get_data (vector.gbytes, NULL);
+ vector.data.pointer += flavour;
+ vector.size = item->vec.size;
+
+ g_array_append_val (body_vectors, vector);
+ body_size += vector.size;
+ }
+ break;
+
+ /* KDBUS_ITEM_PAYLOAD_MEMFD */
+ case KDBUS_ITEM_PAYLOAD_MEMFD:
+ {
+ GVariantVector vector;
+ const guchar *data;
+ gsize size;
+
+ vector.gbytes = g_bytes_new_take_zero_copy_fd (item->memfd.fd);
+ data = g_bytes_get_data (vector.gbytes, &size);
+
+ g_assert (item->memfd.start + item->memfd.size <= size);
+
+ vector.data.pointer = data + item->memfd.start;
+ vector.size = item->memfd.size;
+
+ g_array_append_val (body_vectors, vector);
+ body_size += vector.size;
+ }
+ break;
+
+ /* KDBUS_ITEM_FDS */
+ case KDBUS_ITEM_FDS:
+ {
+ GUnixFDList *fd_list;
+
+ fd_list = g_unix_fd_list_new_from_array (item->fds, data_size / sizeof (int));
+ g_dbus_message_set_unix_fd_list (message, fd_list);
+ g_object_unref (fd_list);
+ }
+ break;
+
+ /* All of the following items, like CMDLINE,
+ CGROUP, etc. need some GDBUS API extensions and
+ should be implemented in the future */
+ case KDBUS_ITEM_TIMESTAMP:
+ {
+ g_print ("time: seq %llu mon %llu real %llu\n",
+ item->timestamp.seqnum, item->timestamp.monotonic_ns, item->timestamp.realtime_ns);
+ //g_dbus_message_set_timestamp (message, item->timestamp.monotonic_ns / 1000);
+ //g_dbus_message_set_serial (message, item->timestamp.seqnum);
+ break;
+ }
+
+ case KDBUS_ITEM_CREDS:
+ {
+ g_print ("creds: u%u eu %u su%u fsu%u g%u eg%u sg%u fsg%u\n",
+ item->creds.uid, item->creds.euid, item->creds.suid, item->creds.fsuid,
+ item->creds.gid, item->creds.egid, item->creds.sgid, item->creds.fsgid);
+ break;
+ }
+
+ case KDBUS_ITEM_PIDS:
+ case KDBUS_ITEM_PID_COMM:
+ case KDBUS_ITEM_TID_COMM:
+ case KDBUS_ITEM_EXE:
+ case KDBUS_ITEM_CMDLINE:
+ case KDBUS_ITEM_CGROUP:
+ case KDBUS_ITEM_AUDIT:
+ case KDBUS_ITEM_CAPS:
+ case KDBUS_ITEM_SECLABEL:
+ case KDBUS_ITEM_CONN_DESCRIPTION:
+ case KDBUS_ITEM_AUXGROUPS:
+ case KDBUS_ITEM_OWNED_NAME:
+ case KDBUS_ITEM_NAME:
+ g_print ("unhandled %04x\n", (int) item->type);
+ break;
+
+ default:
+ g_error ("[KDBUS] DBUS_PAYLOAD: Unknown filed - %lld", item->type);
+ break;
+ }
+ }
+
+ body = GLIB_PRIVATE_CALL(g_variant_from_vectors) (G_VARIANT_TYPE ("((yyyyuta{tv})v)"),
+ (GVariantVector *) body_vectors->data,
+ body_vectors->len, body_size, FALSE);
+ g_assert (body);
+
+ for (i = 0; i < body_vectors->len; i++)
+ g_bytes_unref (g_array_index (body_vectors, GVariantVector, i).gbytes);
+
+ g_array_free (body_vectors, TRUE);
+
+ parts[0] = g_variant_get_child_value (body, 0);
+ parts[1] = g_variant_get_child_value (body, 1);
+ g_variant_unref (body);
+
+ body = g_variant_get_variant (parts[1]);
+ g_variant_unref (parts[1]);
+ g_dbus_message_set_body (message, body);
+ g_variant_unref (body);
+
+ g_variant_get (parts[0], "(yyyyuta{tv})", &endianness, &type, &flags, &version, NULL, &serial, &fields_iter);
+ g_variant_unref (parts[0]);
+
+ while (g_variant_iter_loop (fields_iter, "{tv}", &key, &value))
+ g_dbus_message_set_header (message, key, value);
+
+ g_dbus_message_set_flags (message, flags);
+ g_dbus_message_set_serial (message, serial);
+ g_dbus_message_set_message_type (message, type);
+
+ g_print ("Received:\n%s\n", g_dbus_message_print (message, 2));
+
+ (* worker->message_received_callback) (message, worker->user_data);
+
+ g_object_unref (message);
+
+ return 0;
+}
+
+
+/**
+ * _g_kdbus_receive:
+ *
+ */
+static gssize
+_g_kdbus_receive (GKDBusWorker *kdbus,
+ GCancellable *cancellable,
+ GError **error)
+{
+ struct kdbus_cmd_recv recv;
+ struct kdbus_msg *msg;
+
+ memset (&recv, 0, sizeof recv);
+ recv.size = sizeof (recv);
+
+ if (g_cancellable_set_error_if_cancelled (cancellable, error))
+ return -1;
+
+again:
+ if (ioctl(kdbus->fd, KDBUS_CMD_RECV, &recv) < 0)
+ {
+ if (errno == EINTR)
+ goto again;
+
+ if (errno == EAGAIN)
+ return 0;
+
+ g_warning ("in holding pattern over %d %d\n", kdbus->fd, errno);
+ while (1)
+ sleep(1);
+
+ g_set_error (error, G_IO_ERROR,
+ g_io_error_from_errno (errno),
+ _("Error while receiving message: %s"),
+ g_strerror (errno));
+ return -1;
+ }
+
+ g_print ("but sometimes that's okay\n");
+
+ msg = (struct kdbus_msg *)((guint8 *)kdbus->kdbus_buffer + recv.msg.offset);
+
+ if (msg->payload_type == KDBUS_PAYLOAD_DBUS)
+ g_kdbus_decode_dbus_msg (kdbus, msg);
+ else if (msg->payload_type == KDBUS_PAYLOAD_KERNEL)
+ g_kdbus_decode_kernel_msg (kdbus, msg);
+ else
+ {
+ g_set_error (error,
+ G_DBUS_ERROR,
+ G_DBUS_ERROR_FAILED,
+ _("Received unknown payload type"));
+ return -1;
+ }
+
+ ioctl(kdbus->fd, KDBUS_CMD_FREE, &recv.msg.offset);
+
+ return 0;
+}
+
+static gboolean
+g_kdbus_msg_append_item (struct kdbus_msg *msg,
+ gsize type,
+ gconstpointer data,
+ gsize size)
+{
+ struct kdbus_item *item;
+ gsize item_size;
+
+ item_size = size + G_STRUCT_OFFSET(struct kdbus_item, data);
+
+ if (msg->size + item_size > KDBUS_MSG_MAX_SIZE)
+ return FALSE;
+
+ /* align */
+ msg->size += (-msg->size) & 7;
+ item = (struct kdbus_item *) ((guchar *) msg + msg->size);
+ item->type = type;
+ item->size = item_size;
+ memcpy (item->data, data, size);
+
+ msg->size += item_size;
+
+ return TRUE;
+}
+
+static gboolean
+g_kdbus_msg_append_payload_vec (struct kdbus_msg *msg,
+ gconstpointer data,
+ gsize size)
+{
+ struct kdbus_vec vec = {
+ .size = size,
+ .address = (gsize) data
+ };
+
+ return g_kdbus_msg_append_item (msg, KDBUS_ITEM_PAYLOAD_VEC, &vec, sizeof vec);
+}
+
+static gboolean
+g_kdbus_msg_append_payload_memfd (struct kdbus_msg *msg,
+ gint fd,
+ gsize offset,
+ gsize size)
+{
+ struct kdbus_memfd mfd = {
+ .start = offset,
+ .size = size,
+ .fd = fd,
+ };
+
+ return g_kdbus_msg_append_item (msg, KDBUS_ITEM_PAYLOAD_MEMFD, &mfd, sizeof mfd);
+}
+
+#if 0
+#include "dbusheader.h"
+
+void dump_header (gconstpointer data, gsize size) ;
+void
+dump_header (gconstpointer data,
+ gsize size)
+{
+ GDBusMessageHeaderFieldsIterator iter;
+ GDBusMessageHeader header;
+
+ header = g_dbus_message_header_new (data, size);
+ g_print ("header e/%c t/%u f/x%x v/%u s/%"G_GUINT64_FORMAT"\n",
+ g_dbus_message_header_get_endian (header),
+ g_dbus_message_header_get_type (header),
+ g_dbus_message_header_get_flags (header),
+ g_dbus_message_header_get_version (header),
+ g_dbus_message_header_get_serial (header));
+
+ iter = g_dbus_message_header_iterate_fields (header);
+
+ while (g_dbus_message_header_fields_iterator_next (&iter))
+ {
+ const gchar *string;
+ guint64 reply_to;
+ guint64 key;
+
+ key = g_dbus_message_header_fields_iterator_get_key (iter);
+
+ switch (key)
+ {
+ case G_DBUS_MESSAGE_HEADER_FIELD_PATH:
+ if (g_dbus_message_header_fields_iterator_get_value_as_object_path (iter, &string))
+ g_print (" path: %s\n", string);
+ else
+ g_print (" path: <<invalid string>>\n");
+ break;
+
+ case G_DBUS_MESSAGE_HEADER_FIELD_INTERFACE:
+ if (g_dbus_message_header_fields_iterator_get_value_as_string (iter, &string))
+ g_print (" interface: %s\n", string);
+ else
+ g_print (" interface: <<invalid string>>\n");
+ break;
+
+ case G_DBUS_MESSAGE_HEADER_FIELD_MEMBER:
+ if (g_dbus_message_header_fields_iterator_get_value_as_string (iter, &string))
+ g_print (" member: %s\n", string);
+ else
+ g_print (" member: <<invalid string>>\n");
+ break;
+
+ case G_DBUS_MESSAGE_HEADER_FIELD_ERROR_NAME:
+ if (g_dbus_message_header_fields_iterator_get_value_as_string (iter, &string))
+ g_print (" error: %s\n", string);
+ else
+ g_print (" error: <<invalid string>>\n");
+ break;
+
+ case G_DBUS_MESSAGE_HEADER_FIELD_REPLY_SERIAL:
+ if (g_dbus_message_header_fields_iterator_get_value_as_string (iter, &string))
+ g_print (" serial: %s\n", string);
+ else
+ g_print (" serial: <<invalid string>>\n");
+ break;
+
+ case G_DBUS_MESSAGE_HEADER_FIELD_DESTINATION:
+ if (g_dbus_message_header_fields_iterator_get_value_as_string (iter, &string))
+ g_print (" destination: %s\n", string);
+ else
+ g_print (" destination: <<invalid string>>\n");
+ break;
+
+ case G_DBUS_MESSAGE_HEADER_FIELD_SENDER:
+ if (g_dbus_message_header_fields_iterator_get_value_as_string (iter, &string))
+ g_print (" sender: %s\n", string);
+ else
+ g_print (" sender: <<invalid string>>\n");
+ break;
+
+ default:
+ g_print ("unknown field code %"G_GUINT64_FORMAT"\n", key);
+ g_assert_not_reached ();
+ }
+ }
+
+ g_print ("\n");
+
+}
+#endif
+
+/**
+ * _g_kdbus_send:
+ * Returns: size of data sent or -1 when error
+ */
+static gboolean
+_g_kdbus_send (GKDBusWorker *kdbus,
+ GDBusMessage *message,
+ GError **error)
+{
+ struct kdbus_msg *msg = alloca (KDBUS_MSG_MAX_SIZE);
+ GVariantVectors body_vectors;
+ struct kdbus_cmd_send send;
+
+ g_return_val_if_fail (G_IS_KDBUS_WORKER (kdbus), -1);
+
+ /* fill in as we go... */
+ memset (msg, 0, sizeof (struct kdbus_msg));
+ msg->size = sizeof (struct kdbus_msg);
+ msg->payload_type = KDBUS_PAYLOAD_DBUS;
+ msg->src_id = kdbus->unique_id;
+ msg->cookie = g_dbus_message_get_serial(message);
+
+ /* Message destination */
+ {
+ const gchar *dst_name;
+
+ dst_name = g_dbus_message_get_destination (message);
+
+ if (dst_name != NULL)
+ {
+ if (g_dbus_is_unique_name (dst_name))
+ {
+ if (dst_name[1] != '1' || dst_name[2] != '.')
+ {
+ g_set_error (error, G_DBUS_ERROR, G_DBUS_ERROR_NAME_HAS_NO_OWNER,
+ "Invalid unique D-Bus name '%s'", dst_name);
+ return FALSE;
+ }
+
+ /* We already know that it passes the checks for unique
+ * names, so no need to perform error checking on strtoull.
+ */
+ msg->dst_id = strtoull (dst_name + 3, NULL, 10);
+ dst_name = NULL;
+ }
+ else
+ {
+ g_kdbus_msg_append_item (msg, KDBUS_ITEM_DST_NAME, dst_name, strlen (dst_name) + 1);
+ msg->dst_id = KDBUS_DST_ID_NAME;
+ }
+ }
+ else
+ msg->dst_id = KDBUS_DST_ID_BROADCAST;
+ }
+
+ /* File descriptors */
+ {
+ GUnixFDList *fd_list;
+
+ fd_list = g_dbus_message_get_unix_fd_list (message);
+
+ if (fd_list != NULL)
+ {
+ const gint *fds;
+ gint n_fds;
+
+ fds = g_unix_fd_list_peek_fds (fd_list, &n_fds);
+
+ if (n_fds)
+ g_kdbus_msg_append_item (msg, KDBUS_ITEM_FDS, fds, sizeof (gint) * n_fds);
+ }
+ }
+
+ /* Message body */
+ {
+ struct dbus_fixed_header fh;
+ GHashTableIter header_iter;
+ GVariantBuilder builder;
+ gpointer key, value;
+ GVariant *parts[3];
+ GVariant *body;
+
+ fh.endian = (G_BYTE_ORDER == G_LITTLE_ENDIAN) ? 'l': 'B';
+ fh.type = g_dbus_message_get_message_type (message);
+ fh.flags = g_dbus_message_get_flags (message);
+ fh.version = 2;
+ fh.reserved = 0;
+ fh.serial = g_dbus_message_get_serial (message);
+ parts[0] = g_variant_new_from_data (DBUS_FIXED_HEADER_TYPE, &fh, sizeof fh, TRUE, NULL, NULL);
+
+ g_dbus_message_init_header_iter (message, &header_iter);
+ g_variant_builder_init (&builder, DBUS_EXTENDED_HEADER_TYPE);
+
+ /* We set the sender field to the correct value for ourselves */
+ g_variant_builder_add (&builder, "{tv}",
+ (guint64) G_DBUS_MESSAGE_HEADER_FIELD_SENDER,
+ g_variant_new_printf (":1.%"G_GUINT64_FORMAT, kdbus->unique_id));
+
+ while (g_hash_table_iter_next (&header_iter, &key, &value))
+ {
+ guint64 key_int = (gsize) key;
+
+ switch (key_int)
+ {
+ /* These are the normal header fields that get passed
+ * straight through.
+ */
+ case G_DBUS_MESSAGE_HEADER_FIELD_PATH:
+ case G_DBUS_MESSAGE_HEADER_FIELD_INTERFACE:
+ case G_DBUS_MESSAGE_HEADER_FIELD_MEMBER:
+ case G_DBUS_MESSAGE_HEADER_FIELD_ERROR_NAME:
+ case G_DBUS_MESSAGE_HEADER_FIELD_REPLY_SERIAL:
+ case G_DBUS_MESSAGE_HEADER_FIELD_DESTINATION:
+ g_variant_builder_add (&builder, "{tv}", key_int, value);
+ /* This is a little bit gross.
+ *
+ * We must send the header part of the message in a single
+ * vector as per kdbus rules, but the GVariant serialiser
+ * code will split any item >= 128 bytes into its own
+ * vector to save the copy.
+ *
+ * No header field should be that big anyway... right?
+ */
+ g_assert_cmpint (g_variant_get_size (value), <, 128);
+ continue;
+
+ /* We send this one unconditionally, but set it ourselves */
+ case G_DBUS_MESSAGE_HEADER_FIELD_SENDER:
+ continue;
+
+ /* We don't send these at all in GVariant format */
+ case G_DBUS_MESSAGE_HEADER_FIELD_SIGNATURE:
+ case G_DBUS_MESSAGE_HEADER_FIELD_NUM_UNIX_FDS:
+ continue;
+
+ default:
+ g_assert_not_reached ();
+ }
+ }
+ parts[1] = g_variant_builder_end (&builder);
+
+ body = g_dbus_message_get_body (message);
+ if (!body)
+ body = g_variant_new ("()");
+ parts[2] = g_variant_new_variant (body);
+
+ body = g_variant_ref_sink (g_variant_new_tuple (parts, G_N_ELEMENTS (parts)));
+ GLIB_PRIVATE_CALL(g_variant_to_vectors) (body, &body_vectors);
+
+ /* Sanity check to make sure the header is really contiguous:
+ *
+ * - we must have at least one vector in the output
+ * - the first vector must completely contain at least the header
+ */
+ g_assert_cmpint (body_vectors.vectors->len, >, 0);
+ g_assert_cmpint (g_array_index (body_vectors.vectors, GVariantVector, 0).size, >=,
+ g_variant_get_size (parts[0]) + g_variant_get_size (parts[1]));
+
+ g_variant_unref (body);
+ }
+
+ {
+ guint i;
+
+ for (i = 0; i < body_vectors.vectors->len; i++)
+ {
+ GVariantVector vector = g_array_index (body_vectors.vectors, GVariantVector, i);
+
+ if (vector.gbytes)
+ {
+ gint fd;
+
+ fd = g_bytes_get_zero_copy_fd (vector.gbytes);
+
+ if (fd >= 0)
+ {
+ const guchar *bytes_data;
+ gsize bytes_size;
+
+ bytes_data = g_bytes_get_data (vector.gbytes, &bytes_size);
+
+ if (bytes_data <= vector.data.pointer && vector.data.pointer + vector.size <= bytes_data + bytes_size)
+ {
+ if (!g_kdbus_msg_append_payload_memfd (msg, fd, vector.data.pointer - bytes_data, vector.size))
+ goto need_compact;
+ }
+ else
+ {
+ if (!g_kdbus_msg_append_payload_vec (msg, vector.data.pointer, vector.size))
+ goto need_compact;
+ }
+ }
+ else
+ {
+ if (!g_kdbus_msg_append_payload_vec (msg, vector.data.pointer, vector.size))
+ goto need_compact;
+ }
+ }
+ else
+ if (!g_kdbus_msg_append_payload_vec (msg, body_vectors.extra_bytes->data + vector.data.offset, vector.size))
+ goto need_compact;
+ }
+ }
+
+ /*
+ * set message flags
+ */
+ msg->flags = ((g_dbus_message_get_flags (message) & G_DBUS_MESSAGE_FLAGS_NO_REPLY_EXPECTED) ? 0 : KDBUS_MSG_EXPECT_REPLY) |
+ ((g_dbus_message_get_flags (message) & G_DBUS_MESSAGE_FLAGS_NO_AUTO_START) ? KDBUS_MSG_NO_AUTO_START : 0);
+
+ if ((msg->flags) & KDBUS_MSG_EXPECT_REPLY)
+ msg->timeout_ns = 1000LU * g_get_monotonic_time() + KDBUS_TIMEOUT_NS;
+ else
+ msg->cookie_reply = g_dbus_message_get_reply_serial(message);
+
+
+ /*
+ if (dst_id == KDBUS_DST_ID_BROADCAST)
+ {
+ struct kdbus_bloom_filter *bloom_filter;
+
+ bloom_filter = g_kdbus_append_bloom (&item, kdbus->bloom_size);
+ g_kdbus_setup_bloom (kdbus, message, bloom_filter);
+ }
+ */
+
+ send.size = sizeof (send);
+ send.flags = 0;
+ send.msg_address = (gsize) msg;
+
+ /*
+ * send message
+ */
+//again:
+ if (ioctl(kdbus->fd, KDBUS_CMD_SEND, &send))
+ {
+/*
+ GString *error_name;
+ error_name = g_string_new (NULL);
+
+ if(errno == EINTR)
+ {
+ g_string_free (error_name,TRUE);
+ goto again;
+ }
+ else if (errno == ENXIO)
+ {
+ g_string_printf (error_name, "Name %s does not exist", g_dbus_message_get_destination(dbus_msg));
+ g_kdbus_generate_local_error (worker,
+ dbus_msg,
+ g_variant_new ("(s)",error_name->str),
+ G_DBUS_ERROR_SERVICE_UNKNOWN);
+ g_string_free (error_name,TRUE);
+ return 0;
+ }
+ else if ((errno == ESRCH) || (errno == EADDRNOTAVAIL))
+ {
+ if (kmsg->flags & KDBUS_MSG_FLAGS_NO_AUTO_START)
+ {
+ g_string_printf (error_name, "Name %s does not exist", g_dbus_message_get_destination(dbus_msg));
+ g_kdbus_generate_local_error (worker,
+ dbus_msg,
+ g_variant_new ("(s)",error_name->str),
+ G_DBUS_ERROR_SERVICE_UNKNOWN);
+ g_string_free (error_name,TRUE);
+ return 0;
+ }
+ else
+ {
+ g_string_printf (error_name, "The name %s was not provided by any .service files", g_dbus_message_get_destination(dbus_msg));
+ g_kdbus_generate_local_error (worker,
+ dbus_msg,
+ g_variant_new ("(s)",error_name->str),
+ G_DBUS_ERROR_SERVICE_UNKNOWN);
+ g_string_free (error_name,TRUE);
+ return 0;
+ }
+ }
+
+ g_print ("[KDBUS] ioctl error sending kdbus message:%d (%m)\n",errno);
+ g_set_error (error, G_IO_ERROR, g_io_error_from_errno(errno), _("Error sending message - KDBUS_CMD_MSG_SEND error"));
+*/
+ perror("ioctl send");
+ g_error ("IOCTL SEND: %d\n",errno);
+ return FALSE;
+ }
+
+ return TRUE;
+
+need_compact:
+ /* We end up here if:
+ * - too many kdbus_items
+ * - too large kdbus_msg size
+ * - too much vector data
+ *
+ * We need to compact the message before sending it.
+ */
+ g_assert_not_reached ();
+}
+
+GKDBusWorker *
+g_kdbus_worker_new (const gchar *address,
+ GError **error)
+{
+ GKDBusWorker *worker;
+
+ worker = g_object_new (G_TYPE_KDBUS_WORKER, NULL);
+ if (!_g_kdbus_open (worker, address, error))
+ {
+ g_object_unref (worker);
+ return NULL;
+ }
+
+ return worker;
+}
+
+void
+g_kdbus_worker_associate (GKDBusWorker *worker,
+ GDBusCapabilityFlags capabilities,
+ GDBusWorkerMessageReceivedCallback message_received_callback,
+ GDBusWorkerMessageAboutToBeSentCallback message_about_to_be_sent_callback,
+ GDBusWorkerDisconnectedCallback disconnected_callback,
+ gpointer user_data)
+{
+ worker->capabilities = capabilities;
+ worker->message_received_callback = message_received_callback;
+ worker->message_about_to_be_sent_callback = message_about_to_be_sent_callback;
+ worker->disconnected_callback = disconnected_callback;
+ worker->user_data = user_data;
+}
+
+void
+g_kdbus_worker_unfreeze (GKDBusWorker *worker)
+{
+ gchar *name;
+
+ if (worker->source != NULL)
+ return;
+
+ worker->context = g_main_context_ref_thread_default ();
+ worker->source = g_unix_fd_source_new (worker->fd, G_IO_IN);
+
+ g_source_set_callback (worker->source, (GSourceFunc) kdbus_ready, worker, NULL);
+ name = g_strdup_printf ("kdbus worker");
+ g_source_set_name (worker->source, name);
+ g_free (name);
+
+ g_source_attach (worker->source, worker->context);
+}
+
+gboolean
+g_kdbus_worker_send_message (GKDBusWorker *worker,
+ GDBusMessage *message,
+ GError **error)
+{
+ return _g_kdbus_send (worker, message, error);
+}
+
+void
+g_kdbus_worker_stop (GKDBusWorker *worker)
+{
+}
+
+void
+g_kdbus_worker_flush_sync (GKDBusWorker *worker)
+{
+}
+
+void
+g_kdbus_worker_close (GKDBusWorker *worker,
+ GCancellable *cancellable,
+ GSimpleAsyncResult *result)
+{