for (item = (head)->first; \
(guint8 *)(item) < (guint8 *)(head) + (head)->size; \
item = KDBUS_ITEM_NEXT(item))
+#define KDBUS_FOREACH(iter, first, _size) \
+ for (iter = (first); \
+ ((guint8 *)(iter) < (guint8 *)(first) + (_size)) && \
+ ((guint8 *)(iter) >= (guint8 *)(first)); \
+ iter = (void*)(((guint8 *)iter) + KDBUS_ALIGN8((iter)->size)))
#define g_alloca0(x) memset(g_alloca(x), '\0', (x))
{0xf2,0x77,0xe9,0x6f,0x93,0xb5,0x4e,0x71,0x9a,0x0c,0x34,0x88,0x39,0x25,0xbf,0x35}
};
+enum {
+ MATCH_ELEMENT_TYPE,
+ MATCH_ELEMENT_SENDER,
+ MATCH_ELEMENT_INTERFACE,
+ MATCH_ELEMENT_MEMBER,
+ MATCH_ELEMENT_PATH,
+ MATCH_ELEMENT_PATH_NAMESPACE,
+ MATCH_ELEMENT_DESTINATION,
+ MATCH_ELEMENT_ARG0NAMESPACE,
+ MATCH_ELEMENT_EAVESDROP,
+ MATCH_ELEMENT_ARGN,
+ MATCH_ELEMENT_ARGNPATH,
+};
+
+/* MatchElement struct */
+typedef struct {
+ guint16 type;
+ guint16 arg;
+ char *value;
+} MatchElement;
+
+/* Match struct */
+typedef struct {
+ int n_elements;
+ MatchElement *elements;
+} Match;
+
+
+/**
+ * is_key()
+ *
+ */
+static gboolean
+is_key (const char *key_start, const char *key_end, char *value)
+{
+ gsize len = strlen (value);
+
+ if (len != key_end - key_start)
+ return FALSE;
+
+ return strncmp (key_start, value, len) == 0;
+}
+
+
+/**
+ * parse_key()
+ *
+ */
+static gboolean
+parse_key (MatchElement *element, const char *key_start, const char *key_end)
+{
+ gboolean res = TRUE;
+
+ if (is_key (key_start, key_end, "type"))
+ {
+ element->type = MATCH_ELEMENT_TYPE;
+ }
+ else if (is_key (key_start, key_end, "sender"))
+ {
+ element->type = MATCH_ELEMENT_SENDER;
+ }
+ else if (is_key (key_start, key_end, "interface"))
+ {
+ element->type = MATCH_ELEMENT_INTERFACE;
+ }
+ else if (is_key (key_start, key_end, "member"))
+ {
+ element->type = MATCH_ELEMENT_MEMBER;
+ }
+ else if (is_key (key_start, key_end, "path"))
+ {
+ element->type = MATCH_ELEMENT_PATH;
+ }
+ else if (is_key (key_start, key_end, "path_namespace"))
+ {
+ element->type = MATCH_ELEMENT_PATH_NAMESPACE;
+ }
+ else if (is_key (key_start, key_end, "destination"))
+ {
+ element->type = MATCH_ELEMENT_DESTINATION;
+ }
+ else if (is_key (key_start, key_end, "arg0namespace"))
+ {
+ element->type = MATCH_ELEMENT_ARG0NAMESPACE;
+ }
+ else if (is_key (key_start, key_end, "eavesdrop"))
+ {
+ element->type = MATCH_ELEMENT_EAVESDROP;
+ }
+ else if (key_end - key_start > 3 && is_key (key_start, key_start + 3, "arg"))
+ {
+ const char *digits = key_start + 3;
+ const char *end_digits = digits;
+
+ while (end_digits < key_end && g_ascii_isdigit (*end_digits))
+ end_digits++;
+
+ if (end_digits == key_end) /* argN */
+ {
+ element->type = MATCH_ELEMENT_ARGN;
+ element->arg = atoi (digits);
+ }
+ else if (is_key (end_digits, key_end, "path")) /* argNpath */
+ {
+ element->type = MATCH_ELEMENT_ARGNPATH;
+ element->arg = atoi (digits);
+ }
+ else
+ res = FALSE;
+ }
+ else
+ res = FALSE;
+
+ return res;
+}
+
+
+/**
+ * parse_value()
+ *
+ */
+static const char *
+parse_value (MatchElement *element, const char *s)
+{
+ char quote_char;
+ GString *value;
+
+ value = g_string_new ("");
+
+ quote_char = 0;
+
+ for (;*s; s++)
+ {
+ if (quote_char == 0)
+ {
+ switch (*s)
+ {
+ case '\'':
+ quote_char = '\'';
+ break;
+
+ case ',':
+ s++;
+ goto out;
+
+ case '\\':
+ quote_char = '\\';
+ break;
+
+ default:
+ g_string_append_c (value, *s);
+ break;
+ }
+ }
+ else if (quote_char == '\\')
+ {
+ /* \ only counts as an escape if escaping a quote mark */
+ if (*s != '\'')
+ g_string_append_c (value, '\\');
+
+ g_string_append_c (value, *s);
+ quote_char = 0;
+ }
+ else /* quote_char == ' */
+ {
+ if (*s == '\'')
+ quote_char = 0;
+ else
+ g_string_append_c (value, *s);
+ }
+ }
+
+ out:
+ if (quote_char == '\\')
+ g_string_append_c (value, '\\');
+ else if (quote_char == '\'')
+ {
+ g_string_free (value, TRUE);
+ return NULL;
+ }
+
+ element->value = g_string_free (value, FALSE);
+ return s;
+}
+
+
+/**
+ * match_new()
+ *
+ */
+static Match *
+match_new (const char *str)
+{
+ Match *match;
+ GArray *elements;
+ const char *p;
+ const char *key_start;
+ const char *key_end;
+ MatchElement element;
+ int i;
+
+ elements = g_array_new (TRUE, TRUE, sizeof (MatchElement));
+
+ p = str;
+
+ while (*p != 0)
+ {
+ memset (&element, 0, sizeof (element));
+
+ /* Skip initial whitespace */
+ while (*p && g_ascii_isspace (*p))
+ p++;
+
+ key_start = p;
+
+ /* Read non-whitespace non-equals chars */
+ while (*p && *p != '=' && !g_ascii_isspace (*p))
+ p++;
+
+ key_end = p;
+
+ /* Skip any whitespace after key */
+ while (*p && g_ascii_isspace (*p))
+ p++;
+
+ if (key_start == key_end)
+ continue; /* Allow trailing whitespace */
+ if (*p != '=')
+ goto error;
+
+ ++p;
+
+ if (!parse_key (&element, key_start, key_end))
+ goto error;
+
+ p = parse_value (&element, p);
+ if (p == NULL)
+ goto error;
+
+ g_array_append_val (elements, element);
+ }
+
+ match = g_new0 (Match, 1);
+ match->n_elements = elements->len;
+ match->elements = (MatchElement *)g_array_free (elements, FALSE);
+
+ return match;
+
+ error:
+ for (i = 0; i < elements->len; i++)
+ g_free (g_array_index (elements, MatchElement, i).value);
+ g_array_free (elements, TRUE);
+ return NULL;
+}
+
+
+/**
+ * match_free()
+ *
+ */
+static void
+match_free (Match *match)
+{
+ int i;
+ for (i = 0; i < match->n_elements; i++)
+ g_free (match->elements[i].value);
+ g_free (match->elements);
+ g_free (match);
+}
+
+
/**
* g_kdbus_finalize:
*
g_kdbus_free_data (GKDBusWorker *kdbus,
guint64 offset)
{
- struct kdbus_cmd_free cmd;
+ struct kdbus_cmd_free cmd = {
+ .size = sizeof(cmd),
+ .offset = offset,
+ .flags = 0
+ };
int ret;
- cmd.offset = offset;
- cmd.flags = 0;
-
ret = ioctl (kdbus->fd, KDBUS_CMD_FREE, &cmd);
if (ret < 0)
return FALSE;
_g_kdbus_Hello (GKDBusWorker *worker,
GError **error)
{
- struct kdbus_cmd_hello *hello;
+ struct kdbus_cmd_hello *cmd;
struct kdbus_item *item;
gchar *conn_name;
size = KDBUS_ALIGN8 (G_STRUCT_OFFSET (struct kdbus_cmd_hello, items)) +
KDBUS_ALIGN8 (G_STRUCT_OFFSET (struct kdbus_item, str) + conn_name_size + 1);
- hello = g_alloca0 (size);
- hello->flags = worker->flags;
- hello->attach_flags_send = worker->attach_flags_send;
- hello->attach_flags_recv = worker->attach_flags_recv;
- hello->size = size;
- hello->pool_size = KDBUS_POOL_SIZE;
+ cmd = g_alloca0 (size);
+ cmd->flags = worker->flags;
+ cmd->attach_flags_send = worker->attach_flags_send;
+ cmd->attach_flags_recv = worker->attach_flags_recv;
+ cmd->size = size;
+ cmd->pool_size = KDBUS_POOL_SIZE;
- item = hello->items;
+ item = cmd->items;
item->size = G_STRUCT_OFFSET (struct kdbus_item, str) + conn_name_size + 1;
item->type = KDBUS_ITEM_CONN_DESCRIPTION;
memcpy (item->str, conn_name, conn_name_size+1);
item = KDBUS_ITEM_NEXT (item);
- if (ioctl(worker->fd, KDBUS_CMD_HELLO, hello))
+ if (ioctl(worker->fd, KDBUS_CMD_HELLO, cmd))
{
g_set_error (error, G_IO_ERROR,
g_io_error_from_errno (errno),
return NULL;
}
- if (hello->bus_flags > 0xFFFFFFFFULL)
+ if (cmd->bus_flags > 0xFFFFFFFFULL)
{
g_set_error_literal (error,
G_IO_ERROR,
return NULL;
}
- memcpy (worker->bus_id, hello->id128, 16);
+ memcpy (worker->bus_id, cmd->id128, 16);
- worker->unique_id = hello->id;
- asprintf(&worker->unique_name, ":1.%llu", (unsigned long long) hello->id);
+ worker->unique_id = cmd->id;
+ asprintf(&worker->unique_name, ":1.%llu", (unsigned long long) cmd->id);
/* read bloom filters parameters */
- //worker->bloom_size = (gsize) hello->bloom.size;
- //worker->bloom_n_hash = (guint) hello->bloom.n_hash;
+ //worker->bloom_size = (gsize) cmd->bloom.size;
+ //worker->bloom_n_hash = (guint) cmd->bloom.n_hash;
return g_variant_new ("(s)", worker->unique_name);
}
GError **error)
{
GVariant *result;
- struct kdbus_cmd_name *kdbus_name;
+ struct kdbus_cmd *cmd;
guint64 kdbus_flags;
gssize len, size;
gint status, ret;
g_kdbus_translate_nameowner_flags (flags, &kdbus_flags);
len = strlen(name) + 1;
- size = G_STRUCT_OFFSET (struct kdbus_cmd_name, items) + KDBUS_ITEM_SIZE(len);
- kdbus_name = g_alloca0 (size);
- kdbus_name->size = size;
- kdbus_name->items[0].size = KDBUS_ITEM_HEADER_SIZE + len;
- kdbus_name->items[0].type = KDBUS_ITEM_NAME;
- kdbus_name->flags = kdbus_flags;
- memcpy (kdbus_name->items[0].str, name, len);
-
- ret = ioctl(worker->fd, KDBUS_CMD_NAME_ACQUIRE, kdbus_name);
+ size = G_STRUCT_OFFSET (struct kdbus_cmd, items) + KDBUS_ITEM_SIZE(len);
+ cmd = g_alloca0 (size);
+ cmd->size = size;
+ cmd->items[0].size = KDBUS_ITEM_HEADER_SIZE + len;
+ cmd->items[0].type = KDBUS_ITEM_NAME;
+ cmd->flags = kdbus_flags;
+ memcpy (cmd->items[0].str, name, len);
+
+ ret = ioctl(worker->fd, KDBUS_CMD_NAME_ACQUIRE, cmd);
if (ret < 0)
{
if (errno == EEXIST)
}
}
- if (kdbus_name->flags & KDBUS_NAME_IN_QUEUE)
+ if (cmd->flags & KDBUS_NAME_IN_QUEUE)
status = G_BUS_REQUEST_NAME_FLAGS_IN_QUEUE;
result = g_variant_new ("(u)", status);
GError **error)
{
GVariant *result;
- struct kdbus_cmd_name *kdbus_name;
+ struct kdbus_cmd *cmd;
gssize len, size;
gint status, ret;
}
len = strlen(name) + 1;
- size = G_STRUCT_OFFSET (struct kdbus_cmd_name, items) + KDBUS_ITEM_SIZE(len);
- kdbus_name = g_alloca0 (size);
- kdbus_name->size = size;
- kdbus_name->items[0].size = KDBUS_ITEM_HEADER_SIZE + len;
- kdbus_name->items[0].type = KDBUS_ITEM_NAME;
- memcpy (kdbus_name->items[0].str, name, len);
-
- ret = ioctl(worker->fd, KDBUS_CMD_NAME_RELEASE, kdbus_name);
+ size = G_STRUCT_OFFSET (struct kdbus_cmd, items) + KDBUS_ITEM_SIZE(len);
+ cmd = g_alloca0 (size);
+ cmd->size = size;
+ cmd->items[0].size = KDBUS_ITEM_HEADER_SIZE + len;
+ cmd->items[0].type = KDBUS_ITEM_NAME;
+ memcpy (cmd->items[0].str, name, len);
+
+ ret = ioctl(worker->fd, KDBUS_CMD_NAME_RELEASE, cmd);
if (ret < 0)
{
if (errno == ESRCH)
{
GVariant *result;
GVariantBuilder *builder;
-
- struct kdbus_cmd_name_list cmd = {};
- struct kdbus_name_list *name_list;
- struct kdbus_name_info *name;
+ struct kdbus_info *name_list, *name;
+ struct kdbus_cmd_list cmd = {
+ .size = sizeof(cmd)
+ };
guint64 prev_id;
gint ret;
prev_id = 0;
if (list_name_type)
- cmd.flags = KDBUS_NAME_LIST_ACTIVATORS; /* ListActivatableNames */
+ cmd.flags = KDBUS_LIST_ACTIVATORS; /* ListActivatableNames */
else
- cmd.flags = KDBUS_NAME_LIST_UNIQUE | KDBUS_NAME_LIST_NAMES; /* ListNames */
+ cmd.flags = KDBUS_LIST_UNIQUE | KDBUS_LIST_NAMES; /* ListNames */
- ret = ioctl(worker->fd, KDBUS_CMD_NAME_LIST, &cmd);
+ ret = ioctl(worker->fd, KDBUS_CMD_LIST, &cmd);
if (ret < 0)
{
g_set_error (error,
return NULL;
}
- name_list = (struct kdbus_name_list *) ((guint8 *) worker->kdbus_buffer + cmd.offset);
+ name_list = (struct kdbus_info *) ((guint8 *) worker->kdbus_buffer + cmd.offset);
builder = g_variant_builder_new (G_VARIANT_TYPE ("as"));
- KDBUS_ITEM_FOREACH(name, name_list, names)
+ KDBUS_FOREACH(name, name_list, cmd.list_size)
{
struct kdbus_item *item;
const gchar *item_name = "";
- if ((cmd.flags & KDBUS_NAME_LIST_UNIQUE) && name->owner_id != prev_id)
+ if ((cmd.flags & KDBUS_LIST_UNIQUE) && name->id != prev_id)
{
GString *unique_name;
unique_name = g_string_new (NULL);
- g_string_printf (unique_name, ":1.%llu", name->owner_id);
+ g_string_printf (unique_name, ":1.%llu", name->id);
g_variant_builder_add (builder, "s", unique_name->str);
g_string_free (unique_name,TRUE);
- prev_id = name->owner_id;
+ prev_id = name->id;
}
KDBUS_ITEM_FOREACH(item, name, items)
*/
GVariant *
_g_kdbus_GetListQueuedOwners (GKDBusWorker *worker,
- const gchar *name,
- GError **error)
+ const gchar *name,
+ GError **error)
{
GVariant *result;
GVariantBuilder *builder;
GString *unique_name;
gint ret;
- struct kdbus_cmd_name_list cmd = {};
- struct kdbus_name_list *name_list;
- struct kdbus_name_info *kname;
+ struct kdbus_info *name_list, *kname;
+ struct kdbus_cmd_list cmd = {
+ .size = sizeof(cmd),
+ .flags = KDBUS_LIST_QUEUED
+ };
if (!g_dbus_is_name (name))
{
return NULL;
}
- cmd.flags = KDBUS_NAME_LIST_QUEUED;
- ret = ioctl(worker->fd, KDBUS_CMD_NAME_LIST, &cmd);
+ ret = ioctl(worker->fd, KDBUS_CMD_LIST, &cmd);
if (ret < 0)
{
g_set_error (error,
return NULL;
}
- name_list = (struct kdbus_name_list *) ((guint8 *) worker->kdbus_buffer + cmd.offset);
+ name_list = (struct kdbus_info *) ((guint8 *) worker->kdbus_buffer + cmd.offset);
unique_name = g_string_new (NULL);
builder = g_variant_builder_new (G_VARIANT_TYPE ("as"));
- KDBUS_ITEM_FOREACH(kname, name_list, names)
+ KDBUS_FOREACH(kname, name_list, cmd.list_size)
{
struct kdbus_item *item;
const char *item_name = "";
if (strcmp(item_name, name))
continue;
- g_string_printf (unique_name, ":1.%llu", kname->owner_id);
+ g_string_printf (unique_name, ":1.%llu", kname->id);
g_variant_builder_add (builder, "s", item_name);
}
/**
- * _g_kdbus_match_remove:
+ * g_kdbus_bloom_add_data:
+ * 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_bloom_add_data (GKDBusWorker *worker,
+ guint64 bloom_data [],
+ const void *data,
+ gsize n)
+{
+ guint8 hash[8];
+ guint64 bit_num;
+ guint bytes_num = 0;
+ guint cnt_1, cnt_2;
+
+ guint c = 0;
+ guint64 p = 0;
+
+ bit_num = worker->bloom_size * 8;
+
+ if (bit_num > 1)
+ bytes_num = ((__builtin_clzll(bit_num) ^ 63U) + 7) / 8;
+
+ for (cnt_1 = 0; cnt_1 < (worker->bloom_n_hash); cnt_1++)
+ {
+ for (cnt_2 = 0; cnt_2 < bytes_num; cnt_2++)
+ {
+ if (c <= 0)
+ {
+ g_siphash24(hash, data, n, hash_keys[cnt_1++]);
+ c += 8;
+ }
+
+ p = (p << 8ULL) | (guint64) hash[8 - c];
+ c--;
+ }
+
+ p &= bit_num - 1;
+ bloom_data[p >> 6] |= 1ULL << (p & 63);
+ }
+}
+
+
+/**
+ * g_kdbus_bloom_add_pair:
*
*/
static void
-_g_kdbus_match_remove (GKDBusWorker *worker,
- guint cookie)
+g_kdbus_bloom_add_pair (GKDBusWorker *worker,
+ guint64 bloom_data [],
+ const gchar *parameter,
+ const gchar *value)
{
- struct kdbus_cmd_match cmd_match = {};
- gint ret;
+ gchar buf[1024];
+ gsize size;
+
+ size = strlen(parameter) + strlen(value) + 1;
+ if (size > 1024)
+ return;
+
+ strcpy(stpcpy(stpcpy(buf, parameter), ":"), value);
+ g_kdbus_bloom_add_data(worker, bloom_data, buf, size);
+}
+
+
+/**
+ * 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);
- cmd_match.size = sizeof (cmd_match);
- cmd_match.cookie = cookie;
+ 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;
- ret = ioctl(worker->fd, KDBUS_CMD_MATCH_REMOVE, &cmd_match);
+ 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_warning ("ERROR - %d\n", (int) errno);
+ 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);
}
guint cookie)
{
struct kdbus_item *item;
- struct kdbus_cmd_match *cmd_match;
+ struct kdbus_cmd_match *cmd;
gssize size, len;
gint ret;
guint64 old_id = 0; /* XXX why? */
G_STRUCT_OFFSET (struct kdbus_item, name_change) +
G_STRUCT_OFFSET (struct kdbus_notify_name_change, name) + len);
- cmd_match = g_alloca0 (size);
- cmd_match->size = size;
- cmd_match->cookie = cookie;
- item = cmd_match->items;
+ cmd = g_alloca0 (size);
+ cmd->size = size;
+ cmd->cookie = cookie;
+ item = cmd->items;
if (old_name[0] == 0)
{
return;
}
- cmd_match = g_alloca0 (size);
- cmd_match->size = size;
- cmd_match->cookie = cookie;
- item = cmd_match->items;
+ cmd = g_alloca0 (size);
+ cmd->size = size;
+ cmd->cookie = cookie;
+ item = cmd->items;
/* KDBUS_ITEM_NAME_CHANGE */
item->type = 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_match);
+ ret = ioctl(worker->fd, KDBUS_CMD_MATCH_ADD, cmd);
if (ret < 0)
g_warning ("ERROR - %d\n", (int) errno);
}
const gchar *name)
{
struct kdbus_item *item;
- struct kdbus_cmd_match *cmd_match;
+ struct kdbus_cmd_match *cmd;
gssize size, len;
guint64 cookie;
gint ret;
G_STRUCT_OFFSET (struct kdbus_notify_name_change, name) + len);
cookie = 0xbeefbeefbeefbeef;
- cmd_match = g_alloca0 (size);
- cmd_match->size = size;
- cmd_match->cookie = cookie;
- item = cmd_match->items;
+ cmd = g_alloca0 (size);
+ cmd->size = size;
+ cmd->cookie = cookie;
+ item = cmd->items;
/* KDBUS_ITEM_NAME_ADD */
item->type = KDBUS_ITEM_NAME_ADD;
G_STRUCT_OFFSET(struct kdbus_notify_name_change, name) + len;
item = KDBUS_ITEM_NEXT(item);
- ret = ioctl(worker->fd, KDBUS_CMD_MATCH_ADD, cmd_match);
+ ret = ioctl(worker->fd, KDBUS_CMD_MATCH_ADD, cmd);
if (ret < 0)
g_warning ("ERROR - %d\n", (int) errno);
const gchar *name)
{
struct kdbus_item *item;
- struct kdbus_cmd_match *cmd_match;
+ struct kdbus_cmd_match *cmd;
gssize size, len;
guint64 cookie;
gint ret;
G_STRUCT_OFFSET (struct kdbus_notify_name_change, name) + len);
cookie = 0xdeafdeafdeafdeaf;
- cmd_match = g_alloca0 (size);
- cmd_match->size = size;
- cmd_match->cookie = cookie;
- item = cmd_match->items;
+ cmd = g_alloca0 (size);
+ cmd->size = size;
+ cmd->cookie = cookie;
+ item = cmd->items;
/* KDBUS_ITEM_NAME_REMOVE */
item->type = KDBUS_ITEM_NAME_REMOVE;
G_STRUCT_OFFSET(struct kdbus_notify_name_change, name) + len;
item = KDBUS_ITEM_NEXT(item);
- ret = ioctl(worker->fd, KDBUS_CMD_MATCH_ADD, cmd_match);
+ ret = ioctl(worker->fd, KDBUS_CMD_MATCH_ADD, cmd);
if (ret < 0)
g_warning ("ERROR - %d\n", (int) errno);
guint64 cookie;
cookie = 0xbeefbeefbeefbeef;
- _g_kdbus_match_remove (worker, cookie);
+ _g_kdbus_RemoveMatch (worker, cookie);
}
guint64 cookie;
cookie = 0xdeafdeafdeafdeaf;
- _g_kdbus_match_remove (worker, cookie);
+ _g_kdbus_RemoveMatch (worker, cookie);
}
/**
- * g_kdbus_bloom_add_data:
- * 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_bloom_add_data (GKDBusWorker *worker,
- guint64 bloom_data [],
- const void *data,
- gsize n)
-{
- guint8 hash[8];
- guint64 bit_num;
- guint bytes_num = 0;
- guint cnt_1, cnt_2;
-
- guint c = 0;
- guint64 p = 0;
-
- bit_num = worker->bloom_size * 8;
-
- if (bit_num > 1)
- bytes_num = ((__builtin_clzll(bit_num) ^ 63U) + 7) / 8;
-
- for (cnt_1 = 0; cnt_1 < (worker->bloom_n_hash); cnt_1++)
- {
- for (cnt_2 = 0; cnt_2 < bytes_num; cnt_2++)
- {
- if (c <= 0)
- {
- g_siphash24(hash, data, n, hash_keys[cnt_1++]);
- c += 8;
- }
-
- p = (p << 8ULL) | (guint64) hash[8 - c];
- c--;
- }
-
- p &= bit_num - 1;
- bloom_data[p >> 6] |= 1ULL << (p & 63);
- }
-}
-
-
-/**
- * g_kdbus_bloom_add_pair:
- *
- */
-static void
-g_kdbus_bloom_add_pair (GKDBusWorker *worker,
- guint64 bloom_data [],
- const gchar *parameter,
- const gchar *value)
-{
- GString *data = g_string_new (NULL);
-
- g_string_printf (data,"%s:%s",parameter,value);
- g_kdbus_bloom_add_data(worker, bloom_data, data->str, data->len);
- g_string_free (data, TRUE);
-}
-
-
-/**
- * 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)
-{
- GString *data = g_string_new (NULL);
-
- g_string_printf (data,"%s:%s",parameter,value);
-
- for (;;)
- {
- gchar *last_sep;
- last_sep = strrchr(data->str, separator);
- if (!last_sep || last_sep == data->str)
- break;
-
- *last_sep = 0;
- g_kdbus_bloom_add_data(worker, bloom_data, data->str, last_sep-(data->str));
- }
- g_string_free (data, TRUE);
-}
-
-
-/**
* 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
flavour = body_size & 7;
g_assert ((item->vec.offset & 7) == flavour);
- vector.gbytes = g_bytes_new (((guchar *) worker->kdbus_buffer) + item->vec.offset - flavour, item->vec.size + 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_print ("but sometimes that's okay\n");
- msg = (struct kdbus_msg *)((guint8 *)kdbus->kdbus_buffer + recv.reply.offset);
+ 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);
return -1;
}
- ioctl(kdbus->fd, KDBUS_CMD_FREE, &recv.reply.offset);
+ ioctl(kdbus->fd, KDBUS_CMD_FREE, &recv.msg.offset);
return 0;
}