--- /dev/null
+From 43d5579bb0a0394f16c655616ab32adcadc38e4a Mon Sep 17 00:00:00 2001
+From: Karol Lewandowski <k.lewandowsk@samsung.com>
+Date: Tue, 6 Feb 2024 16:00:05 +0100
+Subject: [PATCH] tizen: Import glib & gio adjustments needed for kdbus
+ upstream
+
+This commit imports multiple squashed glib core code needed to support kdbus.
+Originally, the code has been authored by Ryan Lortie and Daving King and
+can be found at:
+
+ https://git.gnome.org/browse/glib/log/?h=wip/kdbus-junk
+
+Original commit logs can be found below (for identification purspose).
+
+.
+
+commit 52ca5a3d8fc7c6a0407f24158c7c5de57aac564b
+Author: Ryan Lortie <desrt@desrt.ca>
+Date: Fri Aug 21 16:26:03 2015 +0200
+
+ gvariant: substantial rework for kdbus purposes
+
+ This patch is 'squashed' version of Ryan Lortie's patches from
+ wip/kdbus-junk branch [1].
+
+ Main changes:
+ - add GVariantVectors utility struct,
+ - support serialising/deserialising to/from GVariantVectors,
+ - support for single precision floats,
+ - GVariantVectors serialisation tests,
+
+ [1] https://git.gnome.org/browse/glib/log/?h=wip/kdbus-junk
+
+ https://bugzilla.gnome.org/show_bug.cgi?id=721861
+
+ Change-Id: If70bd22337b5a9cddac545dce45474eba542d0de
+
+commit 5fa9680246ae47f5a2cdb62a672fcc3ddc0a629e
+Author: Ryan Lortie <desrt@desrt.ca>
+Date: Fri Aug 21 16:15:25 2015 +0200
+
+ glib-unix: add new internal header glib-linux.h
+
+ This defines some constants and syscall wrappers for features which may
+ not yet have appeared in the libc.
+
+ https://bugzilla.gnome.org/show_bug.cgi?id=721861
+
+ Change-Id: I7e83dadf8be9121f91fa0743bb8c1c612f923e13
+
+commit 6bc456e19258c081a65bdf7d6de27a967300c00c
+Author: David King <dking@redhat.com>
+Date: Fri Aug 21 16:10:59 2015 +0200
+
+ glib-unix: add function to ensure an fd is sealed
+
+ Add a function that checks if a fd is sealed and, if it's not, seals it.
+
+ On Linux this is more or less an operation on memfd. On other systems,
+ it currently always returns FALSE.
+
+ https://bugzilla.gnome.org/show_bug.cgi?id=721861
+
+ Change-Id: I021e40249c2cdd0f1137f6f9f3813f5d4e5083c5
+
+commit e3bcd736dbf8ac67440d839f767d4720450fa686
+Author: Ryan Lortie <desrt@desrt.ca>
+Date: Fri Aug 21 16:06:15 2015 +0200
+
+ gbytes: substantial rework for kdbus purposes
+
+ This patch is 'squashed' version of Ryan Lortie's patches from
+ wip/kdbus-junk branch [1].
+
+ Main changes:
+
+ - introduce a new type of GBytes: 'inline' - this allows us to
+ make a single allocation instead of two in the g_bytes_new() case,
+
+ - new g_bytes_take_zero_copy_fd() function - function takes a memfd,
+ seals it, and creates a GBytes based on it,
+
+ - add g_bytes_get_zero_copy_fd() function - add a way to get the
+ zero-copy fd back out of a GBytes that was created from one.
+
+ [1] https://git.gnome.org/browse/glib/log/?h=wip/kdbus-junk
+
+ https://bugzilla.gnome.org/show_bug.cgi?id=721861
+
+---
+ docs/reference/glib/glib-sections.txt.in | 6 +
+ docs/reference/glib/gvariant-text.xml | 7 +-
+ glib/gbytes.c | 380 +++++++++---
+ glib/gbytes.h | 12 +
+ glib/glib-linux.h | 129 ++++
+ glib/glib-private.c | 4 +
+ glib/glib-private.h | 17 +
+ glib/glib-unix.c | 90 +++
+ glib/glib-unix.h | 3 +
+ glib/gmessages.h | 84 ++-
+ glib/gtestutils.c | 19 +
+ glib/gtestutils.h | 2 +
+ glib/gvariant-core.c | 722 ++++++++++++++---------
+ glib/gvariant-core.h | 12 +-
+ glib/gvariant-parser.c | 38 +-
+ glib/gvariant-serialiser.c | 555 +++++++++++++++--
+ glib/gvariant-serialiser.h | 28 +-
+ glib/gvariant-vectors.c | 248 ++++++++
+ glib/gvariant-vectors.h | 63 ++
+ glib/gvariant.c | 233 ++++++--
+ glib/gvariant.h | 5 +
+ glib/gvarianttype.c | 13 +-
+ glib/gvarianttype.h | 9 +
+ glib/gvarianttypeinfo.c | 4 +-
+ glib/meson.build | 1 +
+ glib/tests/bytes.c | 52 +-
+ glib/tests/gvariant.c | 168 +++++-
+ 27 files changed, 2404 insertions(+), 500 deletions(-)
+ create mode 100644 glib/glib-linux.h
+ create mode 100644 glib/gvariant-vectors.c
+ create mode 100644 glib/gvariant-vectors.h
+
+diff --git a/docs/reference/glib/glib-sections.txt.in b/docs/reference/glib/glib-sections.txt.in
+index 5258544..8b5efd4 100644
+--- a/docs/reference/glib/glib-sections.txt.in
++++ b/docs/reference/glib/glib-sections.txt.in
+@@ -1129,6 +1129,8 @@ g_set_printerr_handler
+ <SUBSECTION>
+ g_return_if_fail
+ g_return_val_if_fail
++g_return_if_fail_se
++g_return_val_if_fail_se
+ g_return_if_reached
+ g_return_val_if_reached
+ g_warn_if_fail
+@@ -2304,6 +2306,7 @@ GUnixFDSourceFunc
+ g_unix_fd_add
+ g_unix_fd_add_full
+ g_unix_fd_source_new
++g_unix_fd_ensure_zero_copy_safe
+
+ <SUBSECTION>
+ g_unix_get_passwd_entry
+@@ -2784,12 +2787,14 @@ g_byte_array_free_to_bytes
+ GBytes
+ g_bytes_new
+ g_bytes_new_take
++g_bytes_new_take_zero_copy_fd
+ g_bytes_new_static
+ g_bytes_new_with_free_func
+ g_bytes_new_from_bytes
+ g_bytes_get_data
+ g_bytes_get_region
+ g_bytes_get_size
++g_bytes_get_zero_copy_fd
+ g_bytes_hash
+ g_bytes_equal
+ g_bytes_compare
+@@ -3368,6 +3373,7 @@ g_test_rand_double
+ g_test_rand_double_range
+
+ g_assert
++g_assert_se
+ g_assert_not_reached
+
+ g_assert_cmpstr
+diff --git a/docs/reference/glib/gvariant-text.xml b/docs/reference/glib/gvariant-text.xml
+index 55d476e..51e9567 100644
+--- a/docs/reference/glib/gvariant-text.xml
++++ b/docs/reference/glib/gvariant-text.xml
+@@ -224,6 +224,7 @@
+ <literal>handle</literal>,
+ <literal>int64</literal>,
+ <literal>uint64</literal>,
++ <literal>float</literal>,
+ <literal>double</literal>,
+ <literal>string</literal>,
+ <literal>objectpath</literal>,
+@@ -534,9 +535,9 @@
+ Type keywords can be seen as more verbose (and more legible) versions of a common subset of the type codes.
+ The type keywords <literal>boolean</literal>, <literal>byte</literal>, <literal>int16</literal>,
+ <literal>uint16</literal>, <literal>int32</literal>, <literal>uint32</literal>, <literal>handle</literal>,
+- <literal>int64</literal>, <literal>uint64</literal>, <literal>double</literal>, <literal>string</literal>,
+- <literal>objectpath</literal> and literal <literal>signature</literal> are each exactly equivalent to their
+- corresponding type code.
++ <literal>int64</literal>, <literal>uint64</literal>, <literal>float</literal>, <literal>double</literal>,
++ <literal>string</literal>, <literal>objectpath</literal> and literal <literal>signature</literal> are each
++ exactly equivalent to their corresponding type code.
+ </para>
+ <para>
+ Type codes are an <literal>@</literal> ("at" sign) followed by a definite GVariant type string. Some
+diff --git a/glib/gbytes.c b/glib/gbytes.c
+index 380e39f..72fa764 100644
+--- a/glib/gbytes.c
++++ b/glib/gbytes.c
+@@ -35,6 +35,14 @@
+ #include <glib/grefcount.h>
+
+ #include <string.h>
++#include <errno.h>
++#include <sys/stat.h>
++#include <sys/types.h>
++
++#ifdef G_OS_UNIX
++#include "glib-unix.h"
++#include <sys/mman.h>
++#endif
+
+ /**
+ * GBytes:
+@@ -70,13 +78,75 @@
+ /* Keep in sync with glib/tests/bytes.c */
+ struct _GBytes
+ {
+- gconstpointer data; /* may be NULL iff (size == 0) */
+- gsize size; /* may be 0 */
++ gsize size;
+ gatomicrefcount ref_count;
+- GDestroyNotify free_func;
+- gpointer user_data;
++ gint type_or_fd;
+ };
+
++typedef struct
++{
++ GBytes bytes;
++#if GLIB_SIZEOF_SIZE_T == 4
++ guint pad;
++#endif
++
++ guchar data[1];
++} GBytesInline;
++
++/* important: the ->data field of GBytesInline should always be 'nicely
++ * aligned'.
++ */
++G_STATIC_ASSERT (G_STRUCT_OFFSET (GBytesInline, data) % (2 * sizeof (gpointer)) == 0);
++G_STATIC_ASSERT (G_STRUCT_OFFSET (GBytesInline, data) % 8 == 0);
++
++
++typedef struct
++{
++ GBytes bytes;
++
++ gpointer data;
++} GBytesData;
++
++typedef struct
++{
++ GBytesData data_bytes;
++
++ GDestroyNotify notify;
++ gpointer user_data;
++} GBytesNotify;
++
++#define G_BYTES_TYPE_INLINE (-1)
++#define G_BYTES_TYPE_STATIC (-2)
++#define G_BYTES_TYPE_FREE (-3)
++#define G_BYTES_TYPE_NOTIFY (-4)
++
++/* All bytes are either inline or subtypes of GBytesData */
++#define G_BYTES_IS_INLINE(bytes) ((bytes)->type_or_fd == G_BYTES_TYPE_INLINE)
++#define G_BYTES_IS_DATA(bytes) (!G_BYTES_IS_INLINE(bytes))
++
++/* More specific subtypes of GBytesData */
++#define G_BYTES_IS_STATIC(bytes) ((bytes)->type_or_fd == G_BYTES_TYPE_STATIC)
++#define G_BYTES_IS_FREE(bytes) ((bytes)->type_or_fd == G_BYTES_TYPE_FREE)
++#define G_BYTES_IS_NOTIFY(bytes) ((bytes)->type_or_fd == G_BYTES_TYPE_NOTIFY)
++
++/* we have a memfd if type_or_fd >= 0 */
++#define G_BYTES_IS_MEMFD(bytes) ((bytes)->type_or_fd >= 0)
++
++static gpointer
++g_bytes_allocate (guint struct_size,
++ guint type_or_fd,
++ gsize data_size)
++{
++ GBytes *bytes;
++
++ bytes = g_slice_alloc (struct_size);
++ bytes->size = data_size;
++ g_atomic_ref_count_init (&bytes->ref_count);
++ bytes->type_or_fd = type_or_fd;
++
++ return bytes;
++}
++
+ /**
+ * g_bytes_new:
+ * @data: (transfer none) (array length=size) (element-type guint8) (nullable):
+@@ -95,11 +165,75 @@ GBytes *
+ g_bytes_new (gconstpointer data,
+ gsize size)
+ {
++ GBytesInline *bytes;
++
+ g_return_val_if_fail (data != NULL || size == 0, NULL);
+
+- return g_bytes_new_take (g_memdup2 (data, size), size);
++ bytes = g_bytes_allocate (G_STRUCT_OFFSET (GBytesInline, data[size]), G_BYTES_TYPE_INLINE, size);
++ memcpy (bytes->data, data, size);
++
++ return (GBytes *) bytes;
++}
++
++/**
++ * g_bytes_new_take_zero_copy_fd:
++ * @fd: a file descriptor capable of being zero-copy-safe
++ *
++ * Creates a new #GBytes from @fd.
++ *
++ * @fd must be capable of being made zero-copy-safe. In concrete terms,
++ * this means that a call to g_unix_fd_ensure_zero_copy_safe() on @fd
++ * will succeed. This call will be made before returning.
++ *
++ * This call consumes @fd, transferring ownership to the returned
++ * #GBytes.
++ *
++ * Returns: (transfer full): a new #GBytes
++ *
++ */
++#ifdef G_OS_UNIX
++GBytes *
++g_bytes_new_take_zero_copy_fd (gint fd)
++{
++ GBytes *bytes;
++ struct stat buf;
++
++ /* We already checked this is a memfd... */
++ g_assert_se (fstat (fd, &buf) == 0);
++
++ bytes = g_bytes_new_take_zero_copy_fd_size(fd, buf.st_size);
++
++ if (buf.st_size == 0)
++ {
++ g_assert_se (close (fd) == 0);
++ }
++
++ return bytes;
+ }
+
++GBytes *
++g_bytes_new_take_zero_copy_fd_size (gint fd, gsize size)
++{
++ GBytesData *bytes;
++
++ g_return_val_if_fail_se (g_unix_fd_ensure_zero_copy_safe (fd), NULL);
++
++ /* We already checked this is a memfd... */
++ if (size == 0)
++ {
++ return g_bytes_new (NULL, 0);
++ }
++
++ bytes = g_bytes_allocate (sizeof (GBytesData), fd, size);
++ bytes->data = mmap (NULL, size, PROT_READ, MAP_PRIVATE, fd, 0);
++ if (bytes->data == MAP_FAILED)
++ /* this is similar to malloc() failing, so do the same... */
++ g_error ("mmap() on memfd failed: %s\n", g_strerror (errno));
++
++ return (GBytes *) bytes;
++}
++#endif /* G_OS_UNIX */
++
+ /**
+ * g_bytes_new_take:
+ * @data: (transfer full) (array length=size) (element-type guint8) (nullable):
+@@ -125,9 +259,13 @@ GBytes *
+ g_bytes_new_take (gpointer data,
+ gsize size)
+ {
+- return g_bytes_new_with_free_func (data, size, g_free, data);
+-}
++ GBytesData *bytes;
++
++ bytes = g_bytes_allocate (sizeof (GBytesData), G_BYTES_TYPE_FREE, size);
++ bytes->data = data;
+
++ return (GBytes *) bytes;
++}
+
+ /**
+ * g_bytes_new_static: (skip)
+@@ -148,7 +286,14 @@ GBytes *
+ g_bytes_new_static (gconstpointer data,
+ gsize size)
+ {
+- return g_bytes_new_with_free_func (data, size, NULL, NULL);
++ GBytesData *bytes;
++
++ g_return_val_if_fail (data != NULL || size == 0, NULL);
++
++ bytes = g_bytes_allocate (sizeof (GBytesData), G_BYTES_TYPE_STATIC, size);
++ bytes->data = (gpointer) data;
++
++ return (GBytes *) bytes;
+ }
+
+ /**
+@@ -179,18 +324,17 @@ g_bytes_new_with_free_func (gconstpointer data,
+ GDestroyNotify free_func,
+ gpointer user_data)
+ {
+- GBytes *bytes;
++ GBytesNotify *bytes;
+
+- g_return_val_if_fail (data != NULL || size == 0, NULL);
++ if (!free_func)
++ return g_bytes_new_static (data, size);
+
+- bytes = g_slice_new (GBytes);
+- bytes->data = data;
+- bytes->size = size;
+- bytes->free_func = free_func;
++ bytes = g_bytes_allocate (sizeof (GBytesNotify), G_BYTES_TYPE_NOTIFY, size);
++ bytes->data_bytes.data = (gpointer) data;
++ bytes->notify = free_func;
+ bytes->user_data = user_data;
+- g_atomic_ref_count_init (&bytes->ref_count);
+
+- return (GBytes *)bytes;
++ return (GBytes *) bytes;
+ }
+
+ /**
+@@ -221,6 +365,7 @@ g_bytes_new_from_bytes (GBytes *bytes,
+ gsize length)
+ {
+ gchar *base;
++ gchar *data;
+
+ /* Note that length may be 0. */
+ g_return_val_if_fail (bytes != NULL, NULL);
+@@ -231,18 +376,19 @@ g_bytes_new_from_bytes (GBytes *bytes,
+ if (offset == 0 && length == bytes->size)
+ return g_bytes_ref (bytes);
+
+- base = (gchar *)bytes->data + offset;
++ base = (gchar *)g_bytes_get_data (bytes, NULL) + offset;
+
+ /* Avoid referencing intermediate GBytes. In practice, this should
+ * only loop once.
+ */
+- while (bytes->free_func == (gpointer)g_bytes_unref)
+- bytes = bytes->user_data;
++ while (((GBytesNotify*)bytes)->notify == (gpointer)g_bytes_unref)
++ bytes = ((GBytesNotify*)bytes)->user_data;
+
++ data = (gchar *)g_bytes_get_data (bytes, NULL);
+ g_return_val_if_fail (bytes != NULL, NULL);
+- g_return_val_if_fail (base >= (gchar *)bytes->data, NULL);
+- g_return_val_if_fail (base <= (gchar *)bytes->data + bytes->size, NULL);
+- g_return_val_if_fail (base + length <= (gchar *)bytes->data + bytes->size, NULL);
++ g_return_val_if_fail (base >= data, NULL);
++ g_return_val_if_fail (base <= data + bytes->size, NULL);
++ g_return_val_if_fail (base + length <= data + bytes->size, NULL);
+
+ return g_bytes_new_with_free_func (base, length,
+ (GDestroyNotify)g_bytes_unref, g_bytes_ref (bytes));
+@@ -268,12 +414,27 @@ g_bytes_new_from_bytes (GBytes *bytes,
+ */
+ gconstpointer
+ g_bytes_get_data (GBytes *bytes,
+- gsize *size)
++ gsize *size)
+ {
+ g_return_val_if_fail (bytes != NULL, NULL);
++
+ if (size)
+ *size = bytes->size;
+- return bytes->data;
++
++ if (G_BYTES_IS_DATA (bytes))
++ {
++ GBytesData *data_bytes = (GBytesData *) bytes;
++
++ return data_bytes->data;
++ }
++ else if (G_BYTES_IS_INLINE (bytes))
++ {
++ GBytesInline *inline_bytes = (GBytesInline *) bytes;
++
++ return inline_bytes->data;
++ }
++ else
++ g_assert_not_reached ();
+ }
+
+ /**
+@@ -295,6 +456,35 @@ g_bytes_get_size (GBytes *bytes)
+ return bytes->size;
+ }
+
++/**
++ * g_bytes_get_zero_copy_fd:
++ * @bytes: a #GBytes
++ *
++ * Gets the zero-copy fd from a #GBytes, if it has one.
++ *
++ * Returns -1 if @bytes was not created from a zero-copy fd.
++ *
++ * A #GBytes created with a zero-copy fd may have been internally
++ * converted into another type of #GBytes for any reason at all. This
++ * function may therefore return -1 at any time, even for a #GBytes that
++ * was created with g_bytes_new_take_zero_copy_fd().
++ *
++ * The returned file descriptor belongs to @bytes. Do not close it.
++ *
++ * Returns: a file descriptor, or -1
++ *
++ * Since: 2.44
++ */
++gint
++g_bytes_get_zero_copy_fd (GBytes *bytes)
++{
++ g_return_val_if_fail (bytes != NULL, -1);
++
++ if (G_BYTES_IS_MEMFD (bytes))
++ return bytes->type_or_fd;
++ else
++ return -1;
++}
+
+ /**
+ * g_bytes_ref:
+@@ -333,9 +523,52 @@ g_bytes_unref (GBytes *bytes)
+
+ if (g_atomic_ref_count_dec (&bytes->ref_count))
+ {
+- if (bytes->free_func != NULL)
+- bytes->free_func (bytes->user_data);
+- g_slice_free (GBytes, bytes);
++ switch (bytes->type_or_fd)
++ {
++ case G_BYTES_TYPE_STATIC:
++ /* data does not need to be freed */
++ g_slice_free (GBytesData, (GBytesData *) bytes);
++ break;
++
++ case G_BYTES_TYPE_INLINE:
++ /* data will be freed along with struct */
++ g_slice_free1 (G_STRUCT_OFFSET (GBytesInline, data[bytes->size]), bytes);
++ break;
++
++ case G_BYTES_TYPE_FREE:
++ {
++ GBytesData *data_bytes = (GBytesData *) bytes;
++
++ g_free (data_bytes->data);
++
++ g_slice_free (GBytesData, data_bytes);
++ break;
++ }
++
++ case G_BYTES_TYPE_NOTIFY:
++ {
++ GBytesNotify *notify_bytes = (GBytesNotify *) bytes;
++
++ /* We don't create GBytesNotify if callback was NULL */
++ (* notify_bytes->notify) (notify_bytes->user_data);
++
++ g_slice_free (GBytesNotify, notify_bytes);
++ break;
++ }
++
++ default:
++ {
++ GBytesData *data_bytes = (GBytesData *) bytes;
++
++ g_assert (bytes->type_or_fd >= 0);
++
++ g_assert_se (munmap (data_bytes->data, bytes->size) == 0);
++ g_assert_se (close (bytes->type_or_fd) == 0);
++
++ g_slice_free (GBytesData, data_bytes);
++ break;
++ }
++ }
+ }
+ }
+
+@@ -358,14 +591,22 @@ gboolean
+ g_bytes_equal (gconstpointer bytes1,
+ gconstpointer bytes2)
+ {
+- const GBytes *b1 = bytes1;
+- const GBytes *b2 = bytes2;
++ gconstpointer d1, d2;
++ gsize s1, s2;
+
+ g_return_val_if_fail (bytes1 != NULL, FALSE);
+ g_return_val_if_fail (bytes2 != NULL, FALSE);
+
+- return b1->size == b2->size &&
+- (b1->size == 0 || memcmp (b1->data, b2->data, b1->size) == 0);
++ d1 = g_bytes_get_data ((GBytes *) bytes1, &s1);
++ d2 = g_bytes_get_data ((GBytes *) bytes2, &s2);
++
++ if (s1 != s2)
++ return FALSE;
++
++ if (d1 == d2)
++ return TRUE;
++
++ return memcmp (d1, d2, s1) == 0;
+ }
+
+ /**
+@@ -384,14 +625,18 @@ g_bytes_equal (gconstpointer bytes1,
+ guint
+ g_bytes_hash (gconstpointer bytes)
+ {
+- const GBytes *a = bytes;
+- const signed char *p, *e;
++ const guchar *data;
++ const guchar *end;
++ gsize size;
+ guint32 h = 5381;
+
+ g_return_val_if_fail (bytes != NULL, 0);
+
+- for (p = (signed char *)a->data, e = (signed char *)a->data + a->size; p != e; p++)
+- h = (h << 5) + h + *p;
++ data = g_bytes_get_data ((GBytes *) bytes, &size);
++ end = data + size;
++
++ while (data != end)
++ h = (h << 5) + h + *(data++);
+
+ return h;
+ }
+@@ -422,43 +667,23 @@ gint
+ g_bytes_compare (gconstpointer bytes1,
+ gconstpointer bytes2)
+ {
+- const GBytes *b1 = bytes1;
+- const GBytes *b2 = bytes2;
++ gconstpointer d1, d2;
++ gsize s1, s2;
+ gint ret;
+
+ g_return_val_if_fail (bytes1 != NULL, 0);
+ g_return_val_if_fail (bytes2 != NULL, 0);
+
+- ret = memcmp (b1->data, b2->data, MIN (b1->size, b2->size));
+- if (ret == 0 && b1->size != b2->size)
+- ret = b1->size < b2->size ? -1 : 1;
+- return ret;
+-}
+-
+-static gpointer
+-try_steal_and_unref (GBytes *bytes,
+- GDestroyNotify free_func,
+- gsize *size)
+-{
+- gpointer result;
+-
+- if (bytes->free_func != free_func || bytes->data == NULL ||
+- bytes->user_data != bytes->data)
+- return NULL;
++ d1 = g_bytes_get_data ((GBytes *) bytes1, &s1);
++ d2 = g_bytes_get_data ((GBytes *) bytes2, &s2);
+
+- /* Are we the only reference? */
+- if (g_atomic_ref_count_compare (&bytes->ref_count, 1))
+- {
+- *size = bytes->size;
+- result = (gpointer)bytes->data;
+- g_slice_free (GBytes, bytes);
+- return result;
+- }
++ ret = memcmp (d1, d2, MIN (s1, s2));
++ if (ret == 0 && s1 != s2)
++ ret = s1 < s2 ? -1 : 1;
+
+- return NULL;
++ return ret;
+ }
+
+-
+ /**
+ * g_bytes_unref_to_data:
+ * @bytes: (transfer full): a #GBytes
+@@ -487,20 +712,26 @@ g_bytes_unref_to_data (GBytes *bytes,
+ g_return_val_if_fail (bytes != NULL, NULL);
+ g_return_val_if_fail (size != NULL, NULL);
+
++
+ /*
+ * Optimal path: if this is was the last reference, then we can return
+ * the data from this GBytes without copying.
+ */
+-
+- result = try_steal_and_unref (bytes, g_free, size);
+- if (result == NULL)
++ if (G_BYTES_IS_FREE(bytes) && g_atomic_int_get (&bytes->ref_count) == 1)
+ {
+- /*
+- * Copy: Non g_malloc (or compatible) allocator, or static memory,
+- * so we have to copy, and then unref.
+- */
+- result = g_memdup2 (bytes->data, bytes->size);
++ GBytesData *data_bytes = (GBytesData *) bytes;
++
++ result = data_bytes->data;
+ *size = bytes->size;
++
++ g_slice_free (GBytesData, data_bytes);
++ }
++ else
++ {
++ gconstpointer data;
++
++ data = g_bytes_get_data (bytes, size);
++ result = g_memdup (data, *size);
+ g_bytes_unref (bytes);
+ }
+
+@@ -608,5 +839,8 @@ g_bytes_get_region (GBytes *bytes,
+ * 0 <= offset <= end_offset <= bytes->size
+ */
+
+- return ((guchar *) bytes->data) + offset;
+-}
+\ No newline at end of file
++ /* NB: The following line has been adapted to the kdbus rework by Mateusz
++ * and not by a competent programmer. Tread with caution!
++ */
++ return ((guchar *) g_bytes_get_data (bytes, NULL)) + offset;
++}
+diff --git a/glib/gbytes.h b/glib/gbytes.h
+index d934989..9cec5de 100644
+--- a/glib/gbytes.h
++++ b/glib/gbytes.h
+@@ -41,6 +41,15 @@ GLIB_AVAILABLE_IN_ALL
+ GBytes * g_bytes_new_take (gpointer data,
+ gsize size);
+
++#ifdef G_OS_UNIX
++GLIB_AVAILABLE_IN_2_44
++GBytes * g_bytes_new_take_zero_copy_fd (gint fd);
++
++GLIB_AVAILABLE_IN_2_44
++GBytes * g_bytes_new_take_zero_copy_fd_size (gint fd,
++ gsize size);
++#endif
++
+ GLIB_AVAILABLE_IN_ALL
+ GBytes * g_bytes_new_static (gconstpointer data,
+ gsize size);
+@@ -63,6 +72,9 @@ gconstpointer g_bytes_get_data (GBytes *bytes,
+ GLIB_AVAILABLE_IN_ALL
+ gsize g_bytes_get_size (GBytes *bytes);
+
++GLIB_AVAILABLE_IN_2_44
++gint g_bytes_get_zero_copy_fd (GBytes *bytes);
++
+ GLIB_AVAILABLE_IN_ALL
+ GBytes * g_bytes_ref (GBytes *bytes);
+
+diff --git a/glib/glib-linux.h b/glib/glib-linux.h
+new file mode 100644
+index 0000000..8f8882c
+--- /dev/null
++++ b/glib/glib-linux.h
+@@ -0,0 +1,129 @@
++/*
++ * Copyright © 2014 Canonical Limited
++ *
++ * This library is free software; you can redistribute it and/or
++ * modify it under the terms of the GNU Lesser General Public
++ * License as published by the Free Software Foundation; either
++ * version 2 of the licence, or (at your option) any later version.
++ *
++ * This library is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
++ * Lesser General Public License for more details.
++ *
++ * You should have received a copy of the GNU Lesser General Public
++ * License along with this library; if not, see <http://www.gnu.org/licenses/>.
++ *
++ * Author: Ryan Lortie <desrt@desrt.ca>
++ */
++
++#ifndef __GLIB_LINUX_H__
++#define __GLIB_LINUX_H__
++
++#include <errno.h>
++
++/* If we know that we are on Linux, add some features, even if they are
++ * not (yet) advertised in the glibc or kernel headers.
++ *
++ * This allows us to use functionality regardless of if it was available
++ * when GLib was compiled or not.
++ *
++ * We take care not to define these things on non-Linux systems where
++ * certain numeric values could mean something different.
++ *
++ * This file is populated on an as-needed basis.
++ *
++ * As things in this file filter into glibc and the distributions we can
++ * remove them from this file and add unconditional dependencies. Never
++ * add a configure.ac check in order to remove something from this file.
++ *
++ * import: include this header LAST
++ */
++
++#ifdef __linux__
++
++#define GLIB_LINUX
++
++#include <sys/syscall.h>
++
++static inline int
++glib_linux_enosys (void)
++{
++ errno = ENOSYS;
++ return -1;
++}
++
++/* futex */
++#include <linux/futex.h>
++
++static inline int
++glib_linux_futex (int *uaddr,
++ int op,
++ int val,
++ const struct timespec *timeout,
++ int *uaddr2,
++ int val3)
++{
++ return syscall (__NR_futex, uaddr, op, val, timeout, uaddr2, val3);
++}
++
++/* memfd */
++#ifndef MFD_CLOEXEC
++#define MFD_CLOEXEC 0x0001U
++#endif
++
++#ifndef MFD_ALLOW_SEALING
++#define MFD_ALLOW_SEALING 0x0002U
++#endif
++
++#ifndef __NR_memfd_create
++# if defined __x86_64__
++# define __NR_memfd_create 319
++# elif defined i386
++# define __NR_memfd_create 356
++# elif defined __arm__
++# define __NR_memfd_create 385
++# elif defined __aarch64__
++# define __NR_memfd_create 279
++# elif defined _MIPS_SIM
++# if _MIPS_SIM == _MIPS_SIM_ABI32
++# define __NR_memfd_create 4354
++# endif
++# if _MIPS_SIM == _MIPS_SIM_NABI32
++# define __NR_memfd_create 6318
++# endif
++# if _MIPS_SIM == _MIPS_SIM_ABI64
++# define __NR_memfd_create 5314
++# endif
++# endif
++#endif
++
++static inline int
++glib_linux_memfd_create (const char *name,
++ unsigned int flags)
++{
++#ifdef __NR_memfd_create
++ return syscall (__NR_memfd_create, name, flags);
++#else
++ return glib_linux_enosys ();
++#endif
++}
++
++/* Linux-specific fcntl() operations */
++#ifndef F_LINUX_SPECIFIC_BASE
++#define F_LINUX_SPECIFIC_BASE 1024
++#endif
++
++#ifndef F_ADD_SEALS
++#define F_ADD_SEALS (F_LINUX_SPECIFIC_BASE + 9)
++#define F_GET_SEALS (F_LINUX_SPECIFIC_BASE + 10)
++
++#define F_SEAL_SEAL 0x0001 /* prevent further seals from being set */
++#define F_SEAL_SHRINK 0x0002 /* prevent file from shrinking */
++#define F_SEAL_GROW 0x0004 /* prevent file from growing */
++#define F_SEAL_WRITE 0x0008 /* prevent writes */
++#endif
++
++#endif /* __linux __ */
++
++#endif /* __GLIB_LINUX_H__ */
+diff --git a/glib/glib-private.c b/glib/glib-private.c
+index 9f4887a..cceaf73 100644
+--- a/glib/glib-private.c
++++ b/glib/glib-private.c
+@@ -53,6 +53,10 @@ glib__private__ (void)
+ g_dir_open_with_errno,
+ g_dir_new_from_dirp,
+
++ g_variant_to_vectors,
++ g_variant_from_vectors,
++ g_variant_vectors_deinit,
++
+ glib_init,
+
+ #ifdef G_OS_WIN32
+diff --git a/glib/glib-private.h b/glib/glib-private.h
+index f49e38f..eb1ee50 100644
+--- a/glib/glib-private.h
++++ b/glib/glib-private.h
+@@ -22,6 +22,7 @@
+
+ #include <glib.h>
+ #include "gwakeup.h"
++#include "gvariant-vectors.h"
+ #include "gstdioprivate.h"
+
+ /* gcc defines __SANITIZE_ADDRESS__, clang sets the address_sanitizer
+@@ -120,6 +121,13 @@ g_end_ignore_leaks (void)
+ GMainContext * g_get_worker_context (void);
+ gboolean g_check_setuid (void);
+ GMainContext * g_main_context_new_with_next_id (guint next_id);
++void g_variant_to_vectors (GVariant *value,
++ GVariantVectors *vectors);
++GVariant * g_variant_from_vectors (const GVariantType *type,
++ GVariantVector *vectors,
++ gsize n_vectors,
++ gsize size,
++ gboolean trusted);
+
+ #if (defined (HAVE__SET_THREAD_LOCAL_INVALID_PARAMETER_HANDLER) || \
+ defined (HAVE__SET_INVALID_PARAMETER_HANDLER)) && \
+@@ -182,6 +190,15 @@ typedef struct {
+ guint flags);
+ GDir * (* g_dir_new_from_dirp) (gpointer dirp);
+
++ void (* g_variant_to_vectors) (GVariant *value,
++ GVariantVectors *vectors);
++ GVariant * (* g_variant_from_vectors) (const GVariantType *type,
++ GVariantVector *vectors,
++ gsize n_vectors,
++ gsize size,
++ gboolean trusted);
++ void (* g_variant_vectors_deinit) (GVariantVectors *vectors);
++
+ /* See glib-init.c */
+ void (* glib_init) (void);
+
+diff --git a/glib/glib-unix.c b/glib/glib-unix.c
+index df5726c..505923c 100644
+--- a/glib/glib-unix.c
++++ b/glib/glib-unix.c
+@@ -43,6 +43,37 @@ G_STATIC_ASSERT (G_ALIGNOF (GPid) == G_ALIGNOF (pid_t));
+ * might not be true everywhere. */
+ G_STATIC_ASSERT (O_NONBLOCK != FD_CLOEXEC);
+
++#include <fcntl.h>
++#include <sys/syscall.h>
++#include <unistd.h>
++
++#ifdef __linux__
++
++/* We want to support these features of Linux even when building GLib
++ * against older versions of system headers. This will allow us to
++ * 'automatically' start supporting a particular feature when GLib is
++ * used with a newer kernel, without recompile.
++ *
++ * This means that we're not changing functionality of GLib simply based
++ * on the set of headers we happen to compile against...
++ */
++
++#ifndef F_LINUX_SPECIFIC_BASE
++#define F_LINUX_SPECIFIC_BASE 1024
++#endif
++
++#ifndef F_ADD_SEALS
++#define F_ADD_SEALS (F_LINUX_SPECIFIC_BASE + 9)
++#define F_GET_SEALS (F_LINUX_SPECIFIC_BASE + 10)
++
++#define F_SEAL_SEAL 0x0001 /* prevent further seals from being set */
++#define F_SEAL_SHRINK 0x0002 /* prevent file from shrinking */
++#define F_SEAL_GROW 0x0004 /* prevent file from growing */
++#define F_SEAL_WRITE 0x0008 /* prevent writes */
++#endif
++
++#endif
++
+ /**
+ * SECTION:gunix
+ * @title: UNIX-specific utilities and integration
+@@ -404,6 +435,65 @@ g_unix_fd_add (gint fd,
+ return g_unix_fd_add_full (G_PRIORITY_DEFAULT, fd, condition, function, user_data, NULL);
+ }
+
++/**
++ * g_unix_fd_ensure_zero_copy_safe:
++ * @fd: a file descriptor
++ *
++ * Checks whether @fd can be use in zero-copy mode. On Linux, this checks that
++ * the descriptor is a memfd, created with memfd_create(), and tries to apply
++ * seals to it so that it can be safely consumed by another process. On other
++ * Unix systems, this function will fail.
++ *
++ * Returns: whether the fd is safe to use in zero-copy mode. Sealing of memfds
++ * is required for the @fd to be considered safe. If sealing fails, or
++ * memfds are not available, or the @fd is not a memfd, returns %FALSE
++ *
++ * Since: 2.44
++ **/
++gboolean
++g_unix_fd_ensure_zero_copy_safe (gint fd)
++{
++#ifdef F_GET_SEALS
++ gint seals;
++ const gint IMMUTABLE_SEALS = F_SEAL_WRITE |
++ F_SEAL_SHRINK |
++ F_SEAL_GROW |
++ F_SEAL_SEAL;
++
++ g_return_val_if_fail (fd >= 0, FALSE);
++
++ /* Seal the fd if possible (only on Linux 3.17+, and if the fd was created
++ * with memfd_create()). */
++ seals = fcntl (fd, F_GET_SEALS);
++ if (seals == -1)
++ {
++ g_debug ("Retrieving fd seals failed: %s", g_strerror (errno));
++ return FALSE;
++ }
++
++ /* Seal the fd, if it is not already. */
++ if ((seals & (IMMUTABLE_SEALS)) >= IMMUTABLE_SEALS)
++ {
++ g_debug ("%s", "fd already sealed");
++ }
++ else
++ {
++ gint error;
++
++ error = fcntl (fd, F_ADD_SEALS, IMMUTABLE_SEALS);
++ if (error == -1)
++ {
++ g_debug ("fd sealing failed: %s", g_strerror (errno));
++ return FALSE;
++ }
++ }
++
++ return TRUE;
++#else
++ return FALSE;
++#endif
++}
++
+ /**
+ * g_unix_get_passwd_entry:
+ * @user_name: the username to get the passwd file entry for
+diff --git a/glib/glib-unix.h b/glib/glib-unix.h
+index 7cf4f0d..205c9af 100644
+--- a/glib/glib-unix.h
++++ b/glib/glib-unix.h
+@@ -116,6 +116,9 @@ guint g_unix_fd_add (gint fd,
+ GUnixFDSourceFunc function,
+ gpointer user_data);
+
++GLIB_AVAILABLE_IN_2_44
++gboolean g_unix_fd_ensure_zero_copy_safe (gint fd);
++
+ GLIB_AVAILABLE_IN_2_64
+ struct passwd *g_unix_get_passwd_entry (const gchar *user_name,
+ GError **error);
+diff --git a/glib/gmessages.h b/glib/gmessages.h
+index eab6d06..825a587 100644
+--- a/glib/gmessages.h
++++ b/glib/gmessages.h
+@@ -606,13 +606,52 @@ GPrintFunc g_set_printerr_handler (GPrintFunc func);
+ * the result is usually that a critical message is logged and @val is
+ * returned from the current function.
+ *
+- * If `G_DISABLE_CHECKS` is defined then the check is not performed. You
+- * should therefore not depend on any side effects of @expr.
++ * If G_DISABLE_CHECKS is defined then the check is not performed. You
++ * should therefore not depend on any side effects of @expr. See
++ * g_return_if_fail_se() for a version that guarantees side effects.
+ *
+ * See g_return_if_fail() for guidance on how to debug failure of this check.
+ */
+ #define g_return_val_if_fail(expr,val) G_STMT_START{ (void)0; }G_STMT_END
+
++/**
++ * g_return_if_fail_se:
++ * @expr: the expression to check
++ *
++ * Verifies that the expression @expr, usually representing a
++ * precondition, evaluates to %TRUE.
++ *
++ * This is the same as g_return_if_fail() except that @expr is
++ * guaranteed to be evaluated, so it may contain side effects.
++ *
++ * Note: it is still undefined if this function will actually return or
++ * not, or if any side effects of @val will be evaluated. There is only
++ * a guarantee with respect to side effects of @expr.
++ *
++ * Since: 2.44
++ */
++#define g_return_if_fail_se(expr) ((void) (expr))
++
++/**
++ * g_return_val_if_fail_se:
++ * @expr: the expression to check
++ * @val: the value to return from the current function
++ * if the expression is not true
++ *
++ * Verifies that the expression @expr, usually representing a
++ * precondition, evaluates to %TRUE.
++ *
++ * This is the same as g_return_val_if_fail() except that @expr is
++ * guaranteed to be evaluated, so it may contain side effects.
++ *
++ * Note: it is still undefined if this function will actually return or
++ * not, or if any side effects of @val will be evaluated. There is only
++ * a guarantee with respect to side effects of @expr.
++ *
++ * Since: 2.44
++ */
++#define g_return_val_if_fail_se(expr,val) ((void) (expr))
++
+ /**
+ * g_return_if_reached:
+ *
+@@ -661,27 +700,26 @@ GPrintFunc g_set_printerr_handler (GPrintFunc func);
+ } \
+ } G_STMT_END
+
+-#define g_return_if_reached() \
+- G_STMT_START { \
+- g_log (G_LOG_DOMAIN, \
+- G_LOG_LEVEL_CRITICAL, \
+- "file %s: line %d (%s): should not be reached", \
+- __FILE__, \
+- __LINE__, \
+- G_STRFUNC); \
+- return; \
+- } G_STMT_END
+-
+-#define g_return_val_if_reached(val) \
+- G_STMT_START { \
+- g_log (G_LOG_DOMAIN, \
+- G_LOG_LEVEL_CRITICAL, \
+- "file %s: line %d (%s): should not be reached", \
+- __FILE__, \
+- __LINE__, \
+- G_STRFUNC); \
+- return (val); \
+- } G_STMT_END
++#define g_return_if_fail_se(expr) g_return_if_fail((expr))
++#define g_return_val_if_fail_se(expr,val) g_return_val_if_fail((expr), (val))
++
++#define g_return_if_reached() G_STMT_START{ \
++ g_log (G_LOG_DOMAIN, \
++ G_LOG_LEVEL_CRITICAL, \
++ "file %s: line %d (%s): should not be reached", \
++ __FILE__, \
++ __LINE__, \
++ G_STRFUNC); \
++ return; }G_STMT_END
++
++#define g_return_val_if_reached(val) G_STMT_START{ \
++ g_log (G_LOG_DOMAIN, \
++ G_LOG_LEVEL_CRITICAL, \
++ "file %s: line %d (%s): should not be reached", \
++ __FILE__, \
++ __LINE__, \
++ G_STRFUNC); \
++ return (val); }G_STMT_END
+
+ #endif /* !G_DISABLE_CHECKS */
+
+diff --git a/glib/gtestutils.c b/glib/gtestutils.c
+index 483275a..becb4a8 100644
+--- a/glib/gtestutils.c
++++ b/glib/gtestutils.c
+@@ -482,6 +482,25 @@
+ * in unit tests, otherwise the unit tests will be ineffective if compiled with
+ * `G_DISABLE_ASSERT`. Use g_assert_true() and related macros in unit tests
+ * instead.
++ *
++ * For a version which is guaranteed to evaluate side effects in @expr,
++ * see g_assert_se().
++ */
++
++/**
++ * g_assert_se:
++ * @expr: the expression to check
++ *
++ * Debugging macro to terminate the application if the assertion
++ * fails. If the assertion fails (i.e. the expression is not true),
++ * an error message is logged and the application is terminated.
++ *
++ * The check can be turned off in final releases of code by defining
++ * `G_DISABLE_ASSERT` when compiling the application.
++ *
++ * Unlike g_assert(), this macro is guaranteed to evaluate side effects
++ * of @expr, even if checks are disabled. It is still undefined if the
++ * program will actually be aborted or not.
+ */
+
+ /**
+diff --git a/glib/gtestutils.h b/glib/gtestutils.h
+index 30ede25..385ae42 100644
+--- a/glib/gtestutils.h
++++ b/glib/gtestutils.h
+@@ -270,6 +270,7 @@ typedef void (*GTestFixtureFunc) (gpointer fixture,
+ #endif
+
+ #define g_assert(expr) G_STMT_START { (void) 0; } G_STMT_END
++#define g_assert_se(expr) ((void) (expr))
+ #else /* !G_DISABLE_ASSERT */
+ #define g_assert_not_reached() G_STMT_START { g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, NULL); } G_STMT_END
+ #define g_assert(expr) G_STMT_START { \
+@@ -277,6 +278,7 @@ typedef void (*GTestFixtureFunc) (gpointer fixture,
+ g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \
+ #expr); \
+ } G_STMT_END
++#define g_assert_se(expr) g_assert((expr))
+ #endif /* !G_DISABLE_ASSERT */
+
+ GLIB_AVAILABLE_IN_ALL
+diff --git a/glib/gvariant-core.c b/glib/gvariant-core.c
+index 06e857b..7bd2ff3 100644
+--- a/glib/gvariant-core.c
++++ b/glib/gvariant-core.c
+@@ -22,6 +22,7 @@
+ #include "config.h"
+
+ #include <glib/gvariant-core.h>
++#include "glib-private.h"
+
+ #include <glib/gvariant-internal.h>
+ #include <glib/gvariant-serialiser.h>
+@@ -115,21 +116,11 @@ struct _GVariant
+ * The type_info field never changes during the life of the
+ * instance, so it can be accessed without a lock.
+ *
+- * size: this is the size of the serialized form for the instance, if it
+- * is known. If the instance is in serialized form then it is, by
+- * definition, known. If the instance is in tree form then it may
+- * be unknown (in which case it is -1). It is possible for the
+- * size to be known when in tree form if, for example, the user
+- * has called g_variant_get_size() without calling
+- * g_variant_get_data(). Additionally, even when the user calls
+- * g_variant_get_data() the size of the data must first be
+- * determined so that a large enough buffer can be allocated for
+- * the data.
+- *
+- * Once the size is known, it can never become unknown again.
+- * g_variant_ensure_size() is used to ensure that the size is in
+- * the known state -- it calculates the size if needed. After
+- * that, the size field can be accessed without a lock.
++ * size: this is the size of the serialised form for the instance. It
++ * is known for serialised instances and also tree-form instances
++ * (for which it is calculated at construction time, from the
++ * known sizes of the children used). After construction, it
++ * never changes and therefore can be accessed without a lock.
+ *
+ * contents: a union containing either the information associated with
+ * holding a value in serialized form or holding a value in
+@@ -309,7 +300,32 @@ g_variant_release_children (GVariant *value)
+ g_free (value->contents.tree.children);
+ }
+
+-/* This begins the main body of the recursive serializer.
++/* < private >
++ * g_variant_lock_in_tree_form:
++ * @value: a #GVariant
++ *
++ * Locks @value if it is in tree form.
++ *
++ * Returns: %TRUE if @value is now in tree form with the lock acquired
++ */
++static gboolean
++g_variant_lock_in_tree_form (GVariant *value)
++{
++ if (g_atomic_int_get (&value->state) & STATE_SERIALISED)
++ return FALSE;
++
++ g_variant_lock (value);
++
++ if (value->state & STATE_SERIALISED)
++ {
++ g_variant_unlock (value);
++ return FALSE;
++ }
++
++ return TRUE;
++}
++
++/* This begins the main body of the recursive serialiser.
+ *
+ * There are 3 functions here that work as a team with the serializer to
+ * get things done. g_variant_store() has a trivial role, but as a
+@@ -326,31 +342,19 @@ g_variant_release_children (GVariant *value)
+ * instances are always in serialized form. For these instances,
+ * storing their serialized form merely involves a memcpy().
+ *
+- * Serialization is a two-step process. First, the size of the
+- * serialized data must be calculated so that an appropriately-sized
+- * buffer can be allocated. Second, the data is written into the
+- * buffer.
++ * Converting to serialised form:
+ *
+- * Determining the size:
+- * The process of determining the size is triggered by a call to
+- * g_variant_ensure_size() on a container. This invokes the
+- * serializer code to determine the size. The serializer is passed
+- * g_variant_fill_gvs() as a callback.
+- *
+- * g_variant_fill_gvs() is called by the serializer on each child of
+- * the container which, in turn, calls g_variant_ensure_size() on
+- * itself and fills in the result of its own size calculation.
+- *
+- * The serializer uses the size information from the children to
+- * calculate the size needed for the entire container.
++ * The first step in the process of converting a GVariant to
++ * serialised form is to allocate a buffer. The size of the buffer is
++ * always known because we computed at construction time of the
++ * GVariant.
+ *
+- * Writing the data:
+ * After the buffer has been allocated, g_variant_serialise() is
+- * called on the container. This invokes the serializer code to write
+- * the bytes to the container. The serializer is, again, passed
++ * called on the container. This invokes the serialiser code to write
++ * the bytes to the container. The serialiser is passed
+ * g_variant_fill_gvs() as a callback.
+ *
+- * This time, when g_variant_fill_gvs() is called for each child, the
++ * At the time that g_variant_fill_gvs() is called for each child, the
+ * child is given a pointer to a sub-region of the allocated buffer
+ * where it should write its data. This is done by calling
+ * g_variant_store(). In the event that the instance is in serialized
+@@ -363,34 +367,6 @@ g_variant_release_children (GVariant *value)
+ */
+ static void g_variant_fill_gvs (GVariantSerialised *, gpointer);
+
+-/* < private >
+- * g_variant_ensure_size:
+- * @value: a #GVariant
+- *
+- * Ensures that the ->size field of @value is filled in properly. This
+- * must be done as a precursor to any serialization of the value in
+- * order to know how large of a buffer is needed to store the data.
+- *
+- * The current thread must hold the lock on @value.
+- */
+-static void
+-g_variant_ensure_size (GVariant *value)
+-{
+- g_assert (value->state & STATE_LOCKED);
+-
+- if (value->size == (gsize) -1)
+- {
+- gpointer *children;
+- gsize n_children;
+-
+- children = (gpointer *) value->contents.tree.children;
+- n_children = value->contents.tree.n_children;
+- value->size = g_variant_serialiser_needed_size (value->type_info,
+- g_variant_fill_gvs,
+- children, n_children);
+- }
+-}
+-
+ /* < private >
+ * g_variant_to_serialised:
+ * @value: a #GVariant
+@@ -462,9 +438,12 @@ g_variant_serialise (GVariant *value,
+ *
+ * - reporting its type
+ *
+- * - reporting its serialized size (requires knowing the size first)
++ * - reporting its serialised size
+ *
+- * - possibly storing its serialized form into the provided buffer
++ * - possibly storing its serialised form into the provided buffer
++ *
++ * This callback is also used during g_variant_new_from_children() in
++ * order to discover the size and type of each child.
+ */
+ static void
+ g_variant_fill_gvs (GVariantSerialised *serialised,
+@@ -472,10 +451,6 @@ g_variant_fill_gvs (GVariantSerialised *serialised,
+ {
+ GVariant *value = data;
+
+- g_variant_lock (value);
+- g_variant_ensure_size (value);
+- g_variant_unlock (value);
+-
+ if (serialised->type_info == NULL)
+ serialised->type_info = value->type_info;
+ g_assert (serialised->type_info == value->type_info);
+@@ -511,26 +486,20 @@ g_variant_fill_gvs (GVariantSerialised *serialised,
+ *
+ * Ensures that @value is in serialized form.
+ *
+- * If @value is in tree form then this function ensures that the
+- * serialized size is known and then allocates a buffer of that size and
+- * serializes the instance into the buffer. The 'children' array is
+- * then released and the instance is set to serialized form based on the
+- * contents of the buffer.
+- *
+- * The current thread must hold the lock on @value.
++ * If @value is in tree form then this function allocates a buffer of
++ * that size and serialises the instance into the buffer. The
++ * 'children' array is then released and the instance is set to
++ * serialised form based on the contents of the buffer.
+ */
+ static void
+ g_variant_ensure_serialised (GVariant *value)
+ {
+- g_assert (value->state & STATE_LOCKED);
+-
+- if (~value->state & STATE_SERIALISED)
++ if (g_variant_lock_in_tree_form (value))
+ {
+ GBytes *bytes;
+ gpointer data;
+
+ TRACE(GLIB_VARIANT_START_SERIALISE(value, value->type_info));
+- g_variant_ensure_size (value);
+ data = g_malloc (value->size);
+ g_variant_serialise (value, data);
+
+@@ -543,12 +512,69 @@ g_variant_ensure_serialised (GVariant *value)
+ value->contents.serialised.checked_offsets_up_to = G_MAXSIZE;
+ value->state |= STATE_SERIALISED;
+ TRACE(GLIB_VARIANT_END_SERIALISE(value, value->type_info));
++
++ g_variant_unlock (value);
++ }
++}
++
++/* Now we have the code to recursively serialise a GVariant into a
++ * GVariantVectors structure.
++ *
++ * We want to do this in cases where the GVariant contains large chunks
++ * of serialised data in order to avoid having to copy this data.
++ *
++ * This generally works the same as normal serialising (co-recursion
++ * with the serialiser) but instead of using a callback we just hard-code
++ * the callback with the name g_variant_callback_write_to_vectors().
++ *
++ * This is a private API that will be used by GDBus.
++ */
++gsize
++g_variant_callback_write_to_vectors (GVariantVectors *vectors,
++ gpointer data,
++ GVariantTypeInfo **type_info)
++{
++ GVariant *value = data;
++
++ if (g_variant_lock_in_tree_form (value))
++ {
++ g_variant_serialiser_write_to_vectors (vectors, value->type_info, value->size,
++ (gpointer *) value->contents.tree.children,
++ value->contents.tree.n_children);
++
++ g_variant_unlock (value);
+ }
++ else
++ g_variant_vectors_append_gbytes (vectors, value->contents.serialised.bytes,
++ value->contents.serialised.data, value->size);
++
++ if (type_info)
++ *type_info = value->type_info;
++
++ return value->size;
++}
++
++/* < private >
++ * g_variant_serialise_to_vectors:
++ * @value: a #GVariant
++ * @vectors: (out): the result
++ *
++ * Serialises @value into @vectors.
++ *
++ * The caller must free @vectors.
++ */
++void
++g_variant_to_vectors (GVariant *value,
++ GVariantVectors *vectors)
++{
++ g_variant_vectors_init (vectors);
++
++ g_variant_callback_write_to_vectors (vectors, value, NULL);
+ }
+
+ /* < private >
+ * g_variant_alloc:
+- * @type: the type of the new instance
++ * @type_info: (transfer full) the type info of the new instance
+ * @serialised: if the instance will be in serialised form
+ * @trusted: if the instance will be trusted
+ *
+@@ -559,73 +585,105 @@ g_variant_ensure_serialised (GVariant *value)
+ * Returns: a new #GVariant with a floating reference
+ */
+ static GVariant *
+-g_variant_alloc (const GVariantType *type,
+- gboolean serialised,
+- gboolean trusted)
++g_variant_alloc (GVariantTypeInfo *type_info,
++ gboolean serialised,
++ gboolean trusted)
+ {
+ GVariant *value;
+
+ value = g_slice_new (GVariant);
+- value->type_info = g_variant_type_info_get (type);
++ value->type_info = type_info;
+ value->state = (serialised ? STATE_SERIALISED : 0) |
+ (trusted ? STATE_TRUSTED : 0) |
+ STATE_FLOATING;
+- value->size = (gssize) -1;
+ g_atomic_ref_count_init (&value->ref_count);
+ value->depth = 0;
+
+ return value;
+ }
+
+-/**
+- * g_variant_new_from_bytes:
+- * @type: a #GVariantType
+- * @bytes: a #GBytes
+- * @trusted: if the contents of @bytes are trusted
++/* -- internal -- */
++
++/* < internal >
++ * g_variant_new_from_children:
++ * @type_info: (transfer full) a #GVariantTypeInfo
++ * @children: an array of #GVariant pointers. Consumed.
++ * @n_children: the length of @children
++ * @trusted: %TRUE if every child in @children in trusted
++ *
++ * Constructs a new tree-mode #GVariant instance. This is the inner
++ * interface for creation of new tree-mode values that gets called from
++ * various functions in gvariant.c.
+ *
+- * Constructs a new serialized-mode #GVariant instance. This is the
+- * inner interface for creation of new serialized values that gets
+- * called from various functions in gvariant.c.
++ * @children is consumed by this function. g_free() will be called on
++ * it some time later.
++ *
++ * Returns: a new #GVariant with a floating reference
++ */
++GVariant *
++g_variant_new_from_children (GVariantTypeInfo *type_info,
++ GVariant **children,
++ gsize n_children,
++ gboolean trusted)
++{
++ GVariant *value;
++
++ value = g_variant_alloc (type_info, FALSE, trusted);
++ value->contents.tree.children = children;
++ value->contents.tree.n_children = n_children;
++ value->size = g_variant_serialiser_needed_size (value->type_info, g_variant_fill_gvs,
++ (gpointer *) children, n_children);
++ TRACE(GLIB_VARIANT_FROM_CHILDREN(value, value->type_info, value->ref_count, value->state));
++
++ return value;
++}
++
++/* < internal >
++ * g_variant_new_serialised:
++ * @type_info: (transfer full): a #GVariantTypeInfo
++ * @bytes: (transfer full): the #GBytes holding @data
++ * @data: a pointer to the serialised data
++ * @size: the size of @data, in bytes
++ * @trusted: %TRUE if @data is trusted
++ *
++ * Constructs a new serialised #GVariant instance. This is the inner
++ * interface for creation of new serialised values that gets called from
++ * various functions in gvariant.c.
+ *
+- * A reference is taken on @bytes.
++ * @bytes is consumed by this function. g_bytes_unref() will be called
++ * on it some time later.
+ *
+ * The data in @bytes must be aligned appropriately for the @type being loaded.
+ * Otherwise this function will internally create a copy of the memory (since
+ * GLib 2.60) or (in older versions) fail and exit the process.
+ *
+- * Returns: (transfer none): a new #GVariant with a floating reference
+- *
+- * Since: 2.36
++ * Returns: a new #GVariant with a floating reference
+ */
+ GVariant *
+-g_variant_new_from_bytes (const GVariantType *type,
+- GBytes *bytes,
+- gboolean trusted)
++g_variant_new_serialised (GVariantTypeInfo *type_info,
++ GBytes *bytes,
++ gconstpointer data,
++ gsize size,
++ gboolean trusted)
+ {
+ GVariant *value;
+ guint alignment;
+- gsize size;
++ gsize fixed_size;
+ GBytes *owned_bytes = NULL;
+- GVariantSerialised serialised;
+
+- value = g_variant_alloc (type, TRUE, trusted);
++ value = g_variant_alloc (type_info, TRUE, trusted);
++ value->contents.serialised.data = data;
++ value->size = size;
+
+ g_variant_type_info_query (value->type_info,
+- &alignment, &size);
+-
++ &alignment, &fixed_size);
+ /* Ensure the alignment is correct. This is a huge performance hit if it’s
+ * not correct, but that’s better than aborting if a caller provides data
+ * with the wrong alignment (which is likely to happen very occasionally, and
+ * only cause an abort on some architectures — so is unlikely to be caught
+ * in testing). Callers can always actively ensure they use the correct
+ * alignment to avoid the performance hit. */
+- serialised.type_info = value->type_info;
+- serialised.data = (guchar *) g_bytes_get_data (bytes, &serialised.size);
+- serialised.depth = 0;
+- serialised.ordered_offsets_up_to = trusted ? G_MAXSIZE : 0;
+- serialised.checked_offsets_up_to = trusted ? G_MAXSIZE : 0;
+-
+- if (!g_variant_serialised_check (serialised))
++ if ((alignment & (gsize) g_bytes_get_data (bytes, NULL)) != 0)
+ {
+ #ifdef HAVE_POSIX_MEMALIGN
+ gpointer aligned_data = NULL;
+@@ -641,37 +699,43 @@ g_variant_new_from_bytes (const GVariantType *type,
+ if (aligned_size != 0)
+ memcpy (aligned_data, g_bytes_get_data (bytes, NULL), aligned_size);
+
+- bytes = owned_bytes = g_bytes_new_with_free_func (aligned_data,
+- aligned_size,
+- free, aligned_data);
++ owned_bytes = g_bytes_new_with_free_func (aligned_data,
++ aligned_size,
++ free, aligned_data);
+ aligned_data = NULL;
+ #else
+ /* NOTE: there may be platforms that lack posix_memalign() and also
+ * have malloc() that returns non-8-aligned. if so, we need to try
+ * harder here.
+ */
+- bytes = owned_bytes = g_bytes_new (g_bytes_get_data (bytes, NULL),
+- g_bytes_get_size (bytes));
++ owned_bytes = g_bytes_new (g_bytes_get_data (bytes, NULL),
++ g_bytes_get_size (bytes));
+ #endif
++ g_bytes_unref (bytes);
++ bytes = g_bytes_ref (owned_bytes);
+ }
+
+- value->contents.serialised.bytes = g_bytes_ref (bytes);
++ value->contents.serialised.bytes = bytes;
+
+- if (size && g_bytes_get_size (bytes) != size)
++ if G_UNLIKELY (fixed_size && size != fixed_size)
+ {
+ /* Creating a fixed-sized GVariant with a bytes of the wrong
+ * size.
+ *
+ * We should do the equivalent of pulling a fixed-sized child out
+- * of a brozen container (ie: data is NULL size is equal to the correct
++ * of a broken container (ie: data is NULL size is equal to the correct
+ * fixed size).
++ *
++ * This really ought not to happen if the data is trusted...
++ */
++ if (trusted)
++ g_error ("Attempting to create a trusted GVariant instance out of invalid data");
++
++ /* We hang on to the GBytes (even though we don't use it anymore)
++ * because every GVariant must have a GBytes.
+ */
+ value->contents.serialised.data = NULL;
+- value->size = size;
+- }
+- else
+- {
+- value->contents.serialised.data = g_bytes_get_data (bytes, &value->size);
++ value->size = fixed_size;
+ }
+
+ value->contents.serialised.ordered_offsets_up_to = trusted ? G_MAXSIZE : 0;
+@@ -684,40 +748,6 @@ g_variant_new_from_bytes (const GVariantType *type,
+ return value;
+ }
+
+-/* -- internal -- */
+-
+-/* < internal >
+- * g_variant_new_from_children:
+- * @type: a #GVariantType
+- * @children: an array of #GVariant pointers. Consumed.
+- * @n_children: the length of @children
+- * @trusted: %TRUE if every child in @children is trusted
+- *
+- * Constructs a new tree-mode #GVariant instance. This is the inner
+- * interface for creation of new serialized values that gets called from
+- * various functions in gvariant.c.
+- *
+- * @children is consumed by this function. g_free() will be called on
+- * it some time later.
+- *
+- * Returns: a new #GVariant with a floating reference
+- */
+-GVariant *
+-g_variant_new_from_children (const GVariantType *type,
+- GVariant **children,
+- gsize n_children,
+- gboolean trusted)
+-{
+- GVariant *value;
+-
+- value = g_variant_alloc (type, FALSE, trusted);
+- value->contents.tree.children = children;
+- value->contents.tree.n_children = n_children;
+- TRACE(GLIB_VARIANT_FROM_CHILDREN(value, value->type_info, value->ref_count, value->state));
+-
+- return value;
+-}
+-
+ /* < internal >
+ * g_variant_get_type_info:
+ * @value: a #GVariant
+@@ -756,6 +786,191 @@ g_variant_is_trusted (GVariant *value)
+ return (value->state & STATE_TRUSTED) != 0;
+ }
+
++/* < internal >
++ * g_variant_get_serialised:
++ * @value: a #GVariant
++ * @bytes: (out) (transfer none): a location to store the #GBytes
++ * @size: (out): a location to store the size of the returned data
++ *
++ * Ensures that @value is in serialised form and returns information
++ * about it. This is called from various APIs in gvariant.c
++ *
++ * Returns: data, of length @size
++ */
++gconstpointer
++g_variant_get_serialised (GVariant *value,
++ GBytes **bytes,
++ gsize *size)
++{
++ g_variant_ensure_serialised (value);
++
++ if (bytes)
++ *bytes = value->contents.serialised.bytes;
++
++ *size = value->size;
++
++ return value->contents.serialised.data;
++}
++
++static GVariant *
++g_variant_vector_deserialise (GVariantTypeInfo *type_info,
++ GVariantVector *first_vector,
++ GVariantVector *last_vector,
++ gsize size,
++ gboolean trusted,
++ GArray *unpacked_children)
++{
++ g_assert (size > 0);
++
++ if (first_vector < last_vector)
++ {
++ GVariantVector *vector = first_vector;
++ const guchar *end_pointer;
++ GVariant **children;
++ guint save_point;
++ guint n_children;
++ gboolean failed;
++ guint i;
++
++ end_pointer = last_vector->data.pointer + last_vector->size;
++ save_point = unpacked_children->len;
++
++ if (!g_variant_serialiser_unpack_all (type_info, end_pointer, last_vector->size, size, unpacked_children))
++ {
++ for (i = save_point; i < unpacked_children->len; i++)
++ g_variant_type_info_unref (g_array_index (unpacked_children, GVariantUnpacked, i).type_info);
++ g_array_set_size (unpacked_children, save_point);
++
++ g_variant_type_info_unref (type_info);
++
++ return NULL;
++ }
++
++ n_children = unpacked_children->len - save_point;
++ children = g_new (GVariant *, n_children);
++ failed = FALSE;
++
++ for (i = 0; i < n_children; i++)
++ {
++ GVariantUnpacked *unpacked = &g_array_index (unpacked_children, GVariantUnpacked, save_point + i);
++ const guchar *resume_at_data;
++ gsize resume_at_size;
++ GVariantVector *fv;
++
++ /* Skip the alignment.
++ *
++ * We can destroy vectors because we won't be going back.
++ *
++ * We do a >= compare because we want to go to the next vector
++ * if it is the start of our child.
++ */
++ while (unpacked->skip >= vector->size)
++ {
++ unpacked->skip -= vector->size;
++ vector++;
++ }
++ g_assert (vector <= last_vector);
++
++ fv = vector;
++ fv->data.pointer += unpacked->skip;
++ fv->size -= unpacked->skip;
++
++ if (unpacked->size == 0)
++ {
++ children[i] = g_variant_new_serialised (unpacked->type_info, g_bytes_new (NULL, 0), NULL, 0, trusted);
++ g_variant_ref_sink (children[i]);
++ continue;
++ }
++
++ /* Now skip to the end, according to 'size'.
++ *
++ * We cannot destroy everything here because we will probably
++ * end up reusing the last one.
++ *
++ * We do a > compare because we want to stay on this vector if
++ * it is the end of our child.
++ */
++ size = unpacked->size;
++ while (unpacked->size > vector->size)
++ {
++ unpacked->size -= vector->size;
++ vector++;
++ }
++ g_assert (vector <= last_vector);
++
++ /* We have to modify the vectors for the benefit of the
++ * recursive step. We also have to remember where we left
++ * off, keeping in mind that the recursive step may itself
++ * modify the vectors.
++ */
++ resume_at_data = vector->data.pointer + unpacked->size;
++ resume_at_size = vector->size - unpacked->size;
++ vector->size = unpacked->size;
++
++ children[i] = g_variant_vector_deserialise (unpacked->type_info, fv, vector,
++ size, trusted, unpacked_children);
++
++ vector->data.pointer = resume_at_data;
++ vector->size = resume_at_size;
++
++ if (children[i])
++ g_variant_ref_sink (children[i]);
++ else
++ failed = TRUE;
++ }
++
++ /* We consumed all the type infos */
++ g_array_set_size (unpacked_children, save_point);
++
++ if G_UNLIKELY (failed)
++ {
++ for (i = 0; i < n_children; i++)
++ if (children[i])
++ g_variant_unref (children[i]);
++
++ g_variant_type_info_unref (type_info);
++ g_free (children);
++
++ return NULL;
++ }
++
++ return g_variant_new_from_children (type_info, children, n_children, trusted);
++ }
++ else
++ {
++ g_assert (first_vector == last_vector);
++ g_assert (size == first_vector->size);
++
++ return g_variant_new_serialised (type_info, g_bytes_ref (first_vector->gbytes),
++ first_vector->data.pointer, size, trusted);
++ }
++}
++
++GVariant *
++g_variant_from_vectors (const GVariantType *type,
++ GVariantVector *vectors,
++ gsize n_vectors,
++ gsize size,
++ gboolean trusted)
++{
++ GVariant *result;
++ GArray *tmp;
++
++ g_return_val_if_fail (vectors != NULL || n_vectors == 0, NULL);
++
++ if (size == 0)
++ return g_variant_new_serialised (g_variant_type_info_get (type), g_bytes_new (NULL, 0), NULL, 0, trusted);
++
++ tmp = g_array_new (FALSE, FALSE, sizeof (GVariantUnpacked));
++ result = g_variant_vector_deserialise (g_variant_type_info_get (type),
++ vectors, vectors + n_vectors - 1, size, trusted, tmp);
++ if (result)
++ g_variant_ref_sink (result);
++ g_array_free (tmp, TRUE);
++
++ return result;
++}
++
+ /* < internal >
+ * g_variant_get_depth:
+ * @value: a #GVariant
+@@ -982,10 +1197,6 @@ g_variant_is_floating (GVariant *value)
+ gsize
+ g_variant_get_size (GVariant *value)
+ {
+- g_variant_lock (value);
+- g_variant_ensure_size (value);
+- g_variant_unlock (value);
+-
+ return value->size;
+ }
+
+@@ -1026,56 +1237,11 @@ g_variant_get_size (GVariant *value)
+ gconstpointer
+ g_variant_get_data (GVariant *value)
+ {
+- g_variant_lock (value);
+ g_variant_ensure_serialised (value);
+- g_variant_unlock (value);
+
+ return value->contents.serialised.data;
+ }
+
+-/**
+- * g_variant_get_data_as_bytes:
+- * @value: a #GVariant
+- *
+- * Returns a pointer to the serialized form of a #GVariant instance.
+- * The semantics of this function are exactly the same as
+- * g_variant_get_data(), except that the returned #GBytes holds
+- * a reference to the variant data.
+- *
+- * Returns: (transfer full): A new #GBytes representing the variant data
+- *
+- * Since: 2.36
+- */
+-GBytes *
+-g_variant_get_data_as_bytes (GVariant *value)
+-{
+- const gchar *bytes_data;
+- const gchar *data;
+- gsize bytes_size;
+- gsize size;
+-
+- g_variant_lock (value);
+- g_variant_ensure_serialised (value);
+- g_variant_unlock (value);
+-
+- bytes_data = g_bytes_get_data (value->contents.serialised.bytes, &bytes_size);
+- data = value->contents.serialised.data;
+- size = value->size;
+-
+- if (data == NULL)
+- {
+- g_assert (size == 0);
+- data = bytes_data;
+- }
+-
+- if (data == bytes_data && size == bytes_size)
+- return g_bytes_ref (value->contents.serialised.bytes);
+- else
+- return g_bytes_new_from_bytes (value->contents.serialised.bytes,
+- data - bytes_data, size);
+-}
+-
+-
+ /**
+ * g_variant_n_children:
+ * @value: a container #GVariant
+@@ -1101,15 +1267,14 @@ g_variant_n_children (GVariant *value)
+ {
+ gsize n_children;
+
+- g_variant_lock (value);
+-
+- if (value->state & STATE_SERIALISED)
++ if (g_variant_lock_in_tree_form (value))
++ {
++ n_children = value->contents.tree.n_children;
++ g_variant_unlock (value);
++ }
++ else
+ n_children = g_variant_serialised_n_children (
+ g_variant_to_serialised (value));
+- else
+- n_children = value->contents.tree.n_children;
+-
+- g_variant_unlock (value);
+
+ return n_children;
+ }
+@@ -1151,75 +1316,63 @@ GVariant *
+ g_variant_get_child_value (GVariant *value,
+ gsize index_)
+ {
++ GVariant *child;
++
+ g_return_val_if_fail (value->depth < G_MAXSIZE, NULL);
+
+- if (~g_atomic_int_get (&value->state) & STATE_SERIALISED)
++ if (g_variant_lock_in_tree_form (value))
+ {
+- /* g_variant_serialised_get_child() does its own checks on index_ */
+- g_return_val_if_fail (index_ < g_variant_n_children (value), NULL);
++ /*
++ * g_variant_serialised_get_child() does its own checks on index_.
++ * Additionally, it would be preferable to use g_variant_n_children.
++ * However, it would try to lock the value again.
++ */
++ g_return_val_if_fail (index_ < value->contents.tree.n_children, NULL);
+
+- g_variant_lock (value);
++ child = g_variant_ref (value->contents.tree.children[index_]);
++ g_variant_unlock (value);
++ }
++ else
++ {
++ GVariantSerialised serialised = g_variant_to_serialised (value);
++ GVariantSerialised s_child;
+
+- if (~value->state & STATE_SERIALISED)
++ /* get the serialiser to extract the serialised data for the child
++ * from the serialised data for the container
++ */
++ s_child = g_variant_serialised_get_child (serialised, index_);
++
++ /* Update the cached ordered_offsets_up_to, since @serialised will be thrown away when this function exits */
++ value->contents.serialised.ordered_offsets_up_to = MAX (value->contents.serialised.ordered_offsets_up_to, serialised.ordered_offsets_up_to);
++ value->contents.serialised.checked_offsets_up_to = MAX (value->contents.serialised.checked_offsets_up_to, serialised.checked_offsets_up_to);
++
++ /* Check whether this would cause nesting too deep. If so, return a fake
++ * child. The only situation we expect this to happen in is with a variant,
++ * as all other deeply-nested types have a static type, and hence should
++ * have been rejected earlier. In the case of a variant whose nesting plus
++ * the depth of its child is too great, return a unit variant () instead of
++ * the real child. */
++ if (!(value->state & STATE_TRUSTED) &&
++ g_variant_type_info_query_depth (s_child.type_info) >=
++ G_VARIANT_MAX_RECURSION_DEPTH - value->depth)
+ {
+- GVariant *child;
+-
+- child = g_variant_ref (value->contents.tree.children[index_]);
+- g_variant_unlock (value);
+-
+- return child;
++ g_assert (g_variant_is_of_type (value, G_VARIANT_TYPE_VARIANT));
++ g_variant_type_info_unref (s_child.type_info);
++ return g_variant_new_tuple (NULL, 0);
+ }
+
+- g_variant_unlock (value);
++ /* create a new serialised instance out of it */
++ child = g_variant_new_serialised (s_child.type_info,
++ g_bytes_ref (value->contents.serialised.bytes),
++ s_child.data, s_child.size,
++ value->state & STATE_TRUSTED);
++ child->state &= ~STATE_FLOATING;
++ child->depth = value->depth + 1;
+ }
+
+- {
+- GVariantSerialised serialised = g_variant_to_serialised (value);
+- GVariantSerialised s_child;
+- GVariant *child;
+-
+- /* get the serializer to extract the serialized data for the child
+- * from the serialized data for the container
+- */
+- s_child = g_variant_serialised_get_child (serialised, index_);
+-
+- /* Update the cached ordered_offsets_up_to, since @serialised will be thrown away when this function exits */
+- value->contents.serialised.ordered_offsets_up_to = MAX (value->contents.serialised.ordered_offsets_up_to, serialised.ordered_offsets_up_to);
+- value->contents.serialised.checked_offsets_up_to = MAX (value->contents.serialised.checked_offsets_up_to, serialised.checked_offsets_up_to);
+-
+- /* Check whether this would cause nesting too deep. If so, return a fake
+- * child. The only situation we expect this to happen in is with a variant,
+- * as all other deeply-nested types have a static type, and hence should
+- * have been rejected earlier. In the case of a variant whose nesting plus
+- * the depth of its child is too great, return a unit variant () instead of
+- * the real child. */
+- if (!(value->state & STATE_TRUSTED) &&
+- g_variant_type_info_query_depth (s_child.type_info) >=
+- G_VARIANT_MAX_RECURSION_DEPTH - value->depth)
+- {
+- g_assert (g_variant_is_of_type (value, G_VARIANT_TYPE_VARIANT));
+- g_variant_type_info_unref (s_child.type_info);
+- return g_variant_new_tuple (NULL, 0);
+- }
++ TRACE(GLIB_VARIANT_FROM_PARENT(child, child->type_info, child->ref_count, child->state, value));
+
+- /* create a new serialized instance out of it */
+- child = g_slice_new (GVariant);
+- child->type_info = s_child.type_info;
+- child->state = (value->state & STATE_TRUSTED) |
+- STATE_SERIALISED;
+- child->size = s_child.size;
+- g_atomic_ref_count_init (&child->ref_count);
+- child->depth = value->depth + 1;
+- child->contents.serialised.bytes =
+- g_bytes_ref (value->contents.serialised.bytes);
+- child->contents.serialised.data = s_child.data;
+- child->contents.serialised.ordered_offsets_up_to = (value->state & STATE_TRUSTED) ? G_MAXSIZE : s_child.ordered_offsets_up_to;
+- child->contents.serialised.checked_offsets_up_to = (value->state & STATE_TRUSTED) ? G_MAXSIZE : s_child.checked_offsets_up_to;
+-
+- TRACE(GLIB_VARIANT_FROM_PARENT(child, child->type_info, child->ref_count, child->state, value));
+-
+- return child;
+- }
++ return child;
+ }
+
+ /**
+@@ -1316,19 +1469,18 @@ void
+ g_variant_store (GVariant *value,
+ gpointer data)
+ {
+- g_variant_lock (value);
+-
+- if (value->state & STATE_SERIALISED)
++ if (g_variant_lock_in_tree_form (value))
++ {
++ g_variant_serialise (value, data);
++ g_variant_unlock (value);
++ }
++ else
+ {
+ if (value->contents.serialised.data != NULL)
+ memcpy (data, value->contents.serialised.data, value->size);
+ else
+ memset (data, 0, value->size);
+ }
+- else
+- g_variant_serialise (value, data);
+-
+- g_variant_unlock (value);
+ }
+
+ /**
+@@ -1356,9 +1508,13 @@ g_variant_store (GVariant *value,
+ gboolean
+ g_variant_is_normal_form (GVariant *value)
+ {
+- if (value->state & STATE_TRUSTED)
++ if (g_atomic_int_get (&value->state) & STATE_TRUSTED)
+ return TRUE;
+
++ /* We always take the lock here because we expect to find that the
++ * value is in normal form and in that case, we need to update the
++ * state, which requires holding the lock.
++ */
+ g_variant_lock (value);
+
+ if (value->depth >= G_VARIANT_MAX_RECURSION_DEPTH)
+diff --git a/glib/gvariant-core.h b/glib/gvariant-core.h
+index fb5f4bf..b09ac1b 100644
+--- a/glib/gvariant-core.h
++++ b/glib/gvariant-core.h
+@@ -27,15 +27,25 @@
+
+ /* gvariant-core.c */
+
+-GVariant * g_variant_new_from_children (const GVariantType *type,
++GVariant * g_variant_new_from_children (GVariantTypeInfo *type_info,
+ GVariant **children,
+ gsize n_children,
+ gboolean trusted);
+
++GVariant * g_variant_new_serialised (GVariantTypeInfo *type_info,
++ GBytes *bytes,
++ gconstpointer data,
++ gsize size,
++ gboolean trusted);
++
+ gboolean g_variant_is_trusted (GVariant *value);
+
+ GVariantTypeInfo * g_variant_get_type_info (GVariant *value);
+
++gconstpointer g_variant_get_serialised (GVariant *value,
++ GBytes **bytes,
++ gsize *size);
++
+ gsize g_variant_get_depth (GVariant *value);
+
+ GVariant * g_variant_maybe_get_child_value (GVariant *value,
+diff --git a/glib/gvariant-parser.c b/glib/gvariant-parser.c
+index 7973ecf..fe7ef4e 100644
+--- a/glib/gvariant-parser.c
++++ b/glib/gvariant-parser.c
+@@ -470,7 +470,13 @@ pattern_coalesce (const gchar *left,
+ (*one)++;
+ }
+
+- else if (**one == 'N' && strchr ("ynqiuxthd", **the_other))
++ else if (**one == 'N' && strchr ("ynqiuxthfd", **the_other))
++ {
++ *out++ = *(*the_other)++;
++ (*one)++;
++ }
++
++ else if (**one == 'D' && (**the_other == 'f' || **the_other == 'd'))
+ {
+ *out++ = *(*the_other)++;
+ (*one)++;
+@@ -631,6 +637,10 @@ ast_resolve (AST *ast,
+ pattern[j++] = 'i';
+ break;
+
++ case 'D':
++ pattern[j++] = 'd';
++ break;
++
+ default:
+ pattern[j++] = pattern[i];
+ break;
+@@ -1342,7 +1352,7 @@ dictionary_get_pattern (AST *ast,
+ /* the basic types,
+ * plus undetermined number type and undetermined string type.
+ */
+- if (!strchr ("bynqiuxthdsogNS", key_char))
++ if (!strchr ("bynqiuxthfdsogNDS", key_char))
+ {
+ ast_set_error (ast, error, NULL,
+ G_VARIANT_PARSE_ERROR_BASIC_TYPE_EXPECTED,
+@@ -1909,7 +1919,7 @@ number_get_pattern (AST *ast,
+ (!g_str_has_prefix (number->token, "0x") && strchr (number->token, 'e')) ||
+ strstr (number->token, "inf") ||
+ strstr (number->token, "nan"))
+- return g_strdup ("Md");
++ return g_strdup ("MD");
+
+ return g_strdup ("MN");
+ }
+@@ -1934,17 +1944,16 @@ number_get_value (AST *ast,
+ Number *number = (Number *) ast;
+ const gchar *token;
+ gboolean negative;
+- gboolean floating;
+ guint64 abs_val;
+ gdouble dbl_val;
++ gchar typechar;
+ gchar *end;
+
++ typechar = *g_variant_type_peek_string (type);
+ token = number->token;
+
+- if (g_variant_type_equal (type, G_VARIANT_TYPE_DOUBLE))
++ if (typechar == 'f' || typechar == 'd')
+ {
+- floating = TRUE;
+-
+ errno = 0;
+ dbl_val = g_ascii_strtod (token, &end);
+ if (dbl_val != 0.0 && errno == ERANGE)
+@@ -1961,7 +1970,6 @@ number_get_value (AST *ast,
+ }
+ else
+ {
+- floating = FALSE;
+ negative = token[0] == '-';
+ if (token[0] == '-')
+ token++;
+@@ -1997,10 +2005,7 @@ number_get_value (AST *ast,
+ return NULL;
+ }
+
+- if (floating)
+- return g_variant_new_double (dbl_val);
+-
+- switch (*g_variant_type_peek_string (type))
++ switch (typechar)
+ {
+ case 'y':
+ if (negative || abs_val > G_MAXUINT8)
+@@ -2054,6 +2059,12 @@ number_get_value (AST *ast,
+ return g_variant_new_handle (negative ?
+ -((gint32) abs_val) : ((gint32) abs_val));
+
++ case 'f':
++ return g_variant_new_float (dbl_val);
++
++ case 'd':
++ return g_variant_new_double (dbl_val);
++
+ default:
+ return ast_type_error (ast, type, error);
+ }
+@@ -2350,6 +2361,9 @@ typedecl_parse (TokenStream *stream,
+ else if (token_stream_consume (stream, "uint64"))
+ type = g_variant_type_copy (G_VARIANT_TYPE_UINT64);
+
++ else if (token_stream_consume (stream, "float"))
++ type = g_variant_type_copy (G_VARIANT_TYPE_FLOAT);
++
+ else if (token_stream_consume (stream, "double"))
+ type = g_variant_type_copy (G_VARIANT_TYPE_DOUBLE);
+
+diff --git a/glib/gvariant-serialiser.c b/glib/gvariant-serialiser.c
+index 4e4a73a..40a891a 100644
+--- a/glib/gvariant-serialiser.c
++++ b/glib/gvariant-serialiser.c
+@@ -278,6 +278,27 @@ gvs_fixed_sized_maybe_get_child (GVariantSerialised value,
+ return value;
+ }
+
++static gboolean
++gvs_fixed_sized_maybe_unpack_all (GVariantTypeInfo *type_info,
++ const guchar *end_pointer,
++ gsize end_size,
++ gsize total_size,
++ GArray *unpacked_children)
++{
++ if (total_size)
++ {
++ GVariantUnpacked unpacked;
++
++ unpacked.type_info = g_variant_type_info_ref (g_variant_type_info_element (type_info));
++ unpacked.skip = 0;
++ unpacked.size = total_size;
++
++ g_array_append_val (unpacked_children, unpacked);
++ }
++
++ return TRUE;
++}
++
+ static gsize
+ gvs_fixed_sized_maybe_needed_size (GVariantTypeInfo *type_info,
+ GVariantSerialisedFiller gvs_filler,
+@@ -311,6 +332,19 @@ gvs_fixed_sized_maybe_serialise (GVariantSerialised value,
+ }
+ }
+
++static gsize
++gvs_fixed_sized_maybe_write_to_vectors (GVariantVectors *vectors,
++ GVariantTypeInfo *type_info,
++ gsize size,
++ const gpointer *children,
++ gsize n_children)
++{
++ if (!n_children)
++ return 0;
++
++ return g_variant_callback_write_to_vectors (vectors, children[0], NULL);
++}
++
+ static gboolean
+ gvs_fixed_sized_maybe_is_normal (GVariantSerialised value)
+ {
+@@ -376,6 +410,27 @@ gvs_variable_sized_maybe_get_child (GVariantSerialised value,
+ return value;
+ }
+
++static gboolean
++gvs_variable_sized_maybe_unpack_all (GVariantTypeInfo *type_info,
++ const guchar *end_pointer,
++ gsize end_size,
++ gsize total_size,
++ GArray *unpacked_children)
++{
++ if (total_size)
++ {
++ GVariantUnpacked unpacked;
++
++ unpacked.type_info = g_variant_type_info_ref (g_variant_type_info_element (type_info));
++ unpacked.skip = 0;
++ unpacked.size = total_size - 1;
++
++ g_array_append_val (unpacked_children, unpacked);
++ }
++
++ return TRUE;
++}
++
+ static gsize
+ gvs_variable_sized_maybe_needed_size (GVariantTypeInfo *type_info,
+ GVariantSerialisedFiller gvs_filler,
+@@ -410,6 +465,20 @@ gvs_variable_sized_maybe_serialise (GVariantSerialised value,
+ }
+ }
+
++static void
++gvs_variable_sized_maybe_write_to_vectors (GVariantVectors *vectors,
++ GVariantTypeInfo *type_info,
++ gsize size,
++ const gpointer *children,
++ gsize n_children)
++{
++ if (n_children)
++ {
++ g_variant_callback_write_to_vectors (vectors, children[0], NULL);
++ g_variant_vectors_append_copy (vectors, "", 1);
++ }
++}
++
+ static gboolean
+ gvs_variable_sized_maybe_is_normal (GVariantSerialised value)
+ {
+@@ -479,6 +548,39 @@ gvs_fixed_sized_array_get_child (GVariantSerialised value,
+ return child;
+ }
+
++static gboolean
++gvs_fixed_sized_array_unpack_all (GVariantTypeInfo *type_info,
++ const guchar *end_pointer,
++ gsize end_size,
++ gsize total_size,
++ GArray *unpacked_children)
++{
++ GVariantTypeInfo *element;
++ gsize element_fixed_size;
++ gsize i, n;
++
++ element = g_variant_type_info_element (type_info);
++ g_variant_type_info_query (element, NULL, &element_fixed_size);
++
++ if (total_size % element_fixed_size)
++ return FALSE;
++
++ n = total_size / element_fixed_size;
++
++ for (i = 0; i < n; i++)
++ {
++ GVariantUnpacked unpacked;
++
++ unpacked.type_info = g_variant_type_info_ref (element);
++ unpacked.skip = 0;
++ unpacked.size = element_fixed_size;
++
++ g_array_append_val (unpacked_children, unpacked);
++ }
++
++ return TRUE;
++}
++
+ static gsize
+ gvs_fixed_sized_array_needed_size (GVariantTypeInfo *type_info,
+ GVariantSerialisedFiller gvs_filler,
+@@ -513,6 +615,19 @@ gvs_fixed_sized_array_serialise (GVariantSerialised value,
+ }
+ }
+
++static void
++gvs_fixed_sized_array_write_to_vectors (GVariantVectors *vectors,
++ GVariantTypeInfo *type_info,
++ gsize size,
++ const gpointer *children,
++ gsize n_children)
++{
++ gsize i;
++
++ for (i = 0; i < n_children; i++)
++ g_variant_callback_write_to_vectors (vectors, children[i], NULL);
++}
++
+ static gboolean
+ gvs_fixed_sized_array_is_normal (GVariantSerialised value)
+ {
+@@ -828,6 +943,80 @@ gvs_variable_sized_array_get_child (GVariantSerialised value,
+ return child;
+ }
+
++static gboolean
++gvs_variable_sized_array_unpack_all (GVariantTypeInfo *type_info,
++ const guchar *end_pointer,
++ gsize end_size,
++ gsize total_size,
++ GArray *unpacked_children)
++{
++ GVariantTypeInfo *element;
++ guint element_alignment;
++ const guchar *offsets;
++ gsize offset_size;
++ gsize offsets_array_size;
++ gsize prev_end;
++ gsize last_end;
++ gsize i, n;
++
++ if (total_size == 0)
++ return TRUE;
++
++ element = g_variant_type_info_element (type_info);
++ g_variant_type_info_query (element, &element_alignment, NULL);
++
++ offset_size = gvs_get_offset_size (total_size);
++
++ if (offset_size > end_size)
++ return FALSE;
++
++ last_end = gvs_read_unaligned_le (end_pointer - offset_size, offset_size);
++
++ if (last_end > total_size)
++ return 0;
++
++ offsets_array_size = total_size - last_end;
++
++ if (offsets_array_size > end_size)
++ return FALSE;
++
++ offsets = end_pointer - offsets_array_size;
++
++ if (offsets_array_size % offset_size)
++ return FALSE;
++
++ n = offsets_array_size / offset_size;
++
++ if (n == 0)
++ return FALSE;
++
++ prev_end = 0;
++
++ for (i = 0; i < n; i++)
++ {
++ GVariantUnpacked unpacked;
++ gsize start;
++ gsize end;
++
++ start = prev_end + ((-prev_end) & element_alignment);
++ end = gvs_read_unaligned_le (offsets, offset_size);
++ offsets += offset_size;
++
++ if (start < prev_end || end < start || end > last_end)
++ return FALSE;
++
++ unpacked.type_info = g_variant_type_info_ref (element);
++ unpacked.skip = start - prev_end;
++ unpacked.size = end - start;
++
++ g_array_append_val (unpacked_children, unpacked);
++
++ prev_end = end;
++ }
++
++ return TRUE;
++}
++
+ static gsize
+ gvs_variable_sized_array_needed_size (GVariantTypeInfo *type_info,
+ GVariantSerialisedFiller gvs_filler,
+@@ -887,6 +1076,38 @@ gvs_variable_sized_array_serialise (GVariantSerialised value,
+ }
+ }
+
++static void
++gvs_variable_sized_array_write_to_vectors (GVariantVectors *vectors,
++ GVariantTypeInfo *type_info,
++ gsize size,
++ const gpointer *children,
++ gsize n_children)
++{
++ guint offset_key;
++ guint alignment;
++ gsize offset;
++ gsize i;
++
++ if (n_children == 0)
++ return;
++
++ offset_key = g_variant_vectors_reserve_offsets (vectors, n_children, gvs_get_offset_size (size));
++ g_variant_type_info_query (type_info, &alignment, NULL);
++ offset = 0;
++
++ for (i = 0; i < n_children; i++)
++ {
++ if ((-offset) & alignment)
++ offset += g_variant_vectors_append_pad (vectors, (-offset) & alignment);
++
++ offset += g_variant_callback_write_to_vectors (vectors, children[i], NULL);
++
++ g_variant_vectors_write_to_offsets (vectors, i, offset, offset_key);
++ }
++
++ g_variant_vectors_commit_offsets (vectors, offset_key);
++}
++
+ static gboolean
+ gvs_variable_sized_array_is_normal (GVariantSerialised value)
+ {
+@@ -1126,6 +1347,86 @@ gvs_tuple_get_child (GVariantSerialised value,
+ return child;
+ }
+
++static gboolean
++gvs_tuple_unpack_all (GVariantTypeInfo *type_info,
++ const guchar *end_pointer,
++ gsize end_size,
++ gsize total_size,
++ GArray *unpacked_children)
++{
++ gsize offset_size;
++ gsize prev_end;
++ gsize i, n;
++
++ n = g_variant_type_info_n_members (type_info);
++
++ /* An empty tuple (n = 0) is always encoded as a single byte, which
++ * means that we should not be attempting to unpack it from multiple
++ * vectors.
++ */
++ if (n == 0)
++ return FALSE;
++
++ offset_size = gvs_get_offset_size (total_size);
++
++ prev_end = 0;
++
++ for (i = 0; i < n; i++)
++ {
++ const GVariantMemberInfo *member_info;
++ GVariantUnpacked unpacked;
++ gsize fixed_size;
++ guint alignment;
++ gsize start;
++ gsize end;
++
++ member_info = g_variant_type_info_member_info (type_info, i);
++ g_variant_type_info_query (member_info->type_info, &alignment, &fixed_size);
++
++ start = prev_end + ((-prev_end) & alignment);
++
++ switch (member_info->ending_type)
++ {
++ case G_VARIANT_MEMBER_ENDING_FIXED:
++ end = start + fixed_size;
++ break;
++
++ case G_VARIANT_MEMBER_ENDING_LAST:
++ end = total_size;
++ break;
++
++ case G_VARIANT_MEMBER_ENDING_OFFSET:
++ if (end_size < offset_size)
++ return FALSE;
++
++ end_pointer -= offset_size;
++ total_size -= offset_size;
++ end_size -= offset_size;
++
++ end = gvs_read_unaligned_le (end_pointer, offset_size);
++ break;
++
++ default:
++ g_assert_not_reached ();
++ }
++
++ if (start < prev_end || end < start || end > total_size)
++ return FALSE;
++
++ unpacked.type_info = g_variant_type_info_ref (member_info->type_info);
++ unpacked.skip = start - prev_end;
++ unpacked.size = end - start;
++
++ g_array_append_val (unpacked_children, unpacked);
++
++ prev_end = end;
++ }
++
++ g_assert (prev_end == total_size);
++
++ return TRUE;
++}
++
+ static gsize
+ gvs_tuple_needed_size (GVariantTypeInfo *type_info,
+ GVariantSerialisedFiller gvs_filler,
+@@ -1212,6 +1513,95 @@ gvs_tuple_serialise (GVariantSerialised value,
+ value.data[offset++] = '\0';
+ }
+
++
++static void
++gvs_tuple_write_to_vectors (GVariantVectors *vectors,
++ GVariantTypeInfo *type_info,
++ gsize size,
++ const gpointer *children,
++ gsize n_children)
++{
++ const GVariantMemberInfo *member_info = NULL;
++ gsize fixed_size;
++ gsize offset;
++ gsize i;
++
++ if (n_children == 0)
++ {
++ g_variant_vectors_append_copy (vectors, "", 1);
++ return;
++ }
++
++ g_variant_type_info_query (type_info, NULL, &fixed_size);
++ offset = 0;
++
++ if (!fixed_size)
++ {
++ gsize n_offsets;
++
++ member_info = g_variant_type_info_member_info (type_info, n_children - 1);
++ n_offsets = member_info->i + 1;
++
++ if (n_offsets)
++ {
++ gsize offset_key = 0;
++
++ offset_key = g_variant_vectors_reserve_offsets (vectors, n_offsets, gvs_get_offset_size (size));
++
++ for (i = 0; i < n_children; i++)
++ {
++ guint alignment;
++
++ member_info = g_variant_type_info_member_info (type_info, i);
++ g_variant_type_info_query (member_info->type_info, &alignment, NULL);
++
++ if ((-offset) & alignment)
++ offset += g_variant_vectors_append_pad (vectors, (-offset) & alignment);
++
++ offset += g_variant_callback_write_to_vectors (vectors, children[i], NULL);
++
++ if (member_info->ending_type == G_VARIANT_MEMBER_ENDING_OFFSET)
++ g_variant_vectors_write_to_offsets (vectors, --n_offsets, offset, offset_key);
++ }
++
++ g_variant_vectors_commit_offsets (vectors, offset_key);
++ }
++ else
++ {
++ for (i = 0; i < n_children; i++)
++ {
++ guint alignment;
++
++ member_info = g_variant_type_info_member_info (type_info, i);
++ g_variant_type_info_query (member_info->type_info, &alignment, NULL);
++
++ if ((-offset) & alignment)
++ offset += g_variant_vectors_append_pad (vectors, (-offset) & alignment);
++
++ offset += g_variant_callback_write_to_vectors (vectors, children[i], NULL);
++ }
++ }
++ }
++ else
++ {
++ for (i = 0; i < n_children; i++)
++ {
++ guint alignment;
++
++ member_info = g_variant_type_info_member_info (type_info, i);
++ g_variant_type_info_query (member_info->type_info, &alignment, NULL);
++
++ if ((-offset) & alignment)
++ offset += g_variant_vectors_append_pad (vectors, (-offset) & alignment);
++
++ offset += g_variant_callback_write_to_vectors (vectors, children[i], NULL);
++ }
++
++ g_assert (fixed_size - offset < 8);
++ g_variant_vectors_append_pad (vectors, fixed_size - offset);
++ }
++}
++
+ static gboolean
+ gvs_tuple_is_normal (GVariantSerialised value)
+ {
+@@ -1358,66 +1748,100 @@ gvs_variant_n_children (GVariantSerialised value)
+ return 1;
+ }
+
+-static inline GVariantSerialised
+-gvs_variant_get_child (GVariantSerialised value,
+- gsize index_)
++static GVariantTypeInfo *
++gvs_variant_find_type (const guchar *end_pointer,
++ gsize end_size,
++ gsize total_size,
++ gsize *child_size,
++ gsize depth)
+ {
+- GVariantSerialised child = { 0, };
++ gsize i;
+
+- /* NOTE: not O(1) and impossible for it to be... */
+- if (value.size)
+- {
+- /* find '\0' character */
+- for (child.size = value.size - 1; child.size; child.size--)
+- if (value.data[child.size] == '\0')
+- break;
++ for (i = 1; i <= end_size; i++)
++ if (end_pointer[-i] == '\0')
++ {
++ const gchar *type_string = (gchar *) end_pointer - i + 1;
++ const gchar *limit = (gchar *) end_pointer;
++ const gchar *end;
+
+- /* ensure we didn't just hit the start of the string */
+- if (value.data[child.size] == '\0')
+- {
+- const gchar *type_string = (gchar *) &value.data[child.size + 1];
+- const gchar *limit = (gchar *) &value.data[value.size];
+- const gchar *end;
++ /* We may have a type string of length 'i'. Check for validity. */
++ if (g_variant_type_string_scan (type_string, limit, &end) && end == limit)
++ {
++ const GVariantType *type = (GVariantType *) type_string;
+
+- if (g_variant_type_string_scan (type_string, limit, &end) &&
+- end == limit)
+- {
+- const GVariantType *type = (GVariantType *) type_string;
++ if (g_variant_type_is_definite (type))
++ {
++ GVariantTypeInfo *type_info;
++ gsize fixed_size;
++ gsize child_type_depth;
+
+- if (g_variant_type_is_definite (type))
+- {
+- gsize fixed_size;
+- gsize child_type_depth;
++ type_info = g_variant_type_info_get (type);
+
+- child.type_info = g_variant_type_info_get (type);
+- child.depth = value.depth + 1;
++ g_variant_type_info_query (type_info, NULL, &fixed_size);
++ child_type_depth = g_variant_type_info_query_depth (type_info);
+
+- if (child.size != 0)
+- /* only set to non-%NULL if size > 0 */
+- child.data = value.data;
++ if ((!fixed_size || fixed_size == total_size - i) &&
++ depth < G_VARIANT_MAX_RECURSION_DEPTH - child_type_depth)
++ {
++ *child_size = total_size - i;
+
+- g_variant_type_info_query (child.type_info,
+- NULL, &fixed_size);
+- child_type_depth = g_variant_type_info_query_depth (child.type_info);
++ return type_info;
++ }
+
+- if ((!fixed_size || fixed_size == child.size) &&
+- value.depth < G_VARIANT_MAX_RECURSION_DEPTH - child_type_depth)
+- return child;
++ g_variant_type_info_unref (type_info);
++ }
++ }
+
+- g_variant_type_info_unref (child.type_info);
+- }
+- }
+- }
++ /* No sense in trying other lengths if we already failed */
++ break;
++ }
++
++ return NULL;
++}
++
++static inline GVariantSerialised
++gvs_variant_get_child (GVariantSerialised value,
++ gsize index_)
++{
++ GVariantSerialised child = { 0, };
++
++ if ((child.type_info = gvs_variant_find_type (value.data + value.size, value.size, value.size, &child.size, value.depth)))
++ {
++ if (child.size != 0)
++ child.data = value.data;
++ }
++ else
++ {
++ child.type_info = g_variant_type_info_get (G_VARIANT_TYPE_UNIT);
++ child.size = 1;
+ }
+
+- child.type_info = g_variant_type_info_get (G_VARIANT_TYPE_UNIT);
+- child.data = NULL;
+- child.size = 1;
+ child.depth = value.depth + 1;
+
+ return child;
+ }
+
++static gboolean
++gvs_variant_unpack_all (GVariantTypeInfo *type_info,
++ const guchar *end_pointer,
++ gsize end_size,
++ gsize total_size,
++ GArray *unpacked_children)
++{
++ GVariantUnpacked unpacked;
++
++ if ((unpacked.type_info = gvs_variant_find_type (end_pointer, end_size, total_size, &unpacked.size, 0)))
++ {
++ unpacked.skip = 0;
++
++ g_array_append_val (unpacked_children, unpacked);
++
++ return TRUE;
++ }
++
++ return FALSE;
++}
++
+ static inline gsize
+ gvs_variant_needed_size (GVariantTypeInfo *type_info,
+ GVariantSerialisedFiller gvs_filler,
+@@ -1450,6 +1874,23 @@ gvs_variant_serialise (GVariantSerialised value,
+ memcpy (value.data + child.size + 1, type_string, strlen (type_string));
+ }
+
++static void
++gvs_variant_write_to_vectors (GVariantVectors *vectors,
++ GVariantTypeInfo *type_info,
++ gsize size,
++ const gpointer *children,
++ gsize n_children)
++{
++ GVariantTypeInfo *child_type_info;
++ const gchar *type_string;
++
++ g_variant_callback_write_to_vectors (vectors, children[0], &child_type_info);
++ type_string = g_variant_type_info_get_type_string (child_type_info);
++
++ g_variant_vectors_append_copy (vectors, "", 1);
++ g_variant_vectors_append_copy (vectors, type_string, strlen (type_string));
++}
++
+ static inline gboolean
+ gvs_variant_is_normal (GVariantSerialised value)
+ {
+@@ -1662,7 +2103,35 @@ g_variant_serialiser_needed_size (GVariantTypeInfo *type_info,
+
+ return gvs_/**/,/**/_needed_size (type_info, gvs_filler,
+ children, n_children);
++ )
++ g_assert_not_reached ();
++}
++
++gboolean
++g_variant_serialiser_unpack_all (GVariantTypeInfo *type_info,
++ const guchar *end_pointer,
++ gsize end_size,
++ gsize total_size,
++ GArray *unpacked_children)
++{
++ DISPATCH_CASES (type_info,
++ return gvs_/**/,/**/_unpack_all (type_info, end_pointer, end_size, total_size, unpacked_children);
++ )
++
++ /* We are here because type_info is not a container type */
++ return FALSE;
++}
+
++void
++g_variant_serialiser_write_to_vectors (GVariantVectors *vectors,
++ GVariantTypeInfo *type_info,
++ gsize size,
++ const gpointer *children,
++ gsize n_children)
++{
++ DISPATCH_CASES (type_info,
++ gvs_/**/,/**/_write_to_vectors (vectors, type_info, size, children, n_children);
++ return;
+ )
+ g_assert_not_reached ();
+ }
+diff --git a/glib/gvariant-serialiser.h b/glib/gvariant-serialiser.h
+index eb74fe7..c8b59d9 100644
+--- a/glib/gvariant-serialiser.h
++++ b/glib/gvariant-serialiser.h
+@@ -24,6 +24,7 @@
+ #define __G_VARIANT_SERIALISER_H__
+
+ #include "gvarianttypeinfo.h"
++#include "gvariant-vectors.h"
+
+ typedef struct
+ {
+@@ -54,14 +55,27 @@ typedef struct
+ gsize checked_offsets_up_to;
+ } GVariantSerialised;
+
+-/* deserialization */
++typedef struct
++{
++ GVariantTypeInfo *type_info;
++ gsize skip;
++ gsize size;
++} GVariantUnpacked;
++
++/* deserialisation */
+ GLIB_AVAILABLE_IN_ALL
+ gsize g_variant_serialised_n_children (GVariantSerialised container);
+ GLIB_AVAILABLE_IN_ALL
+ GVariantSerialised g_variant_serialised_get_child (GVariantSerialised container,
+ gsize index);
+
+-/* serialization */
++gboolean g_variant_serialiser_unpack_all (GVariantTypeInfo *type_info,
++ const guchar *end_pointer,
++ gsize end_size,
++ gsize total_size,
++ GArray *unpacked_children);
++
++/* serialisation */
+ typedef void (*GVariantSerialisedFiller) (GVariantSerialised *serialised,
+ gpointer data);
+
+@@ -96,4 +110,14 @@ GLIB_AVAILABLE_IN_ALL
+ gboolean g_variant_serialiser_is_signature (gconstpointer data,
+ gsize size);
+
++
++gsize g_variant_callback_write_to_vectors (GVariantVectors *vectors,
++ gpointer data,
++ GVariantTypeInfo **type_info);
++void g_variant_serialiser_write_to_vectors (GVariantVectors *items,
++ GVariantTypeInfo *type_info,
++ gsize size,
++ const gpointer *children,
++ gsize n_children);
++
+ #endif /* __G_VARIANT_SERIALISER_H__ */
+diff --git a/glib/gvariant-vectors.c b/glib/gvariant-vectors.c
+new file mode 100644
+index 0000000..5e07786
+--- /dev/null
++++ b/glib/gvariant-vectors.c
+@@ -0,0 +1,248 @@
++#include "config.h"
++
++#include "gvariant-vectors.h"
++#include "gtestutils.h"
++
++static void
++append_zeros (GByteArray *array,
++ guint n)
++{
++ guchar zeros[8] = "";
++
++ g_byte_array_append (array, zeros, n);
++}
++
++void
++g_variant_vectors_init (GVariantVectors *vectors)
++{
++
++ /* The first 8 bytes of 'extra_bytes' is always 0. We use this for
++ * inserting padding in between two GBytes records.
++ */
++ vectors->extra_bytes = g_byte_array_new ();
++ append_zeros (vectors->extra_bytes, 8);
++
++ vectors->vectors = g_array_new (FALSE, FALSE, sizeof (GVariantVector));
++
++ vectors->offsets = g_byte_array_new ();
++}
++
++void
++g_variant_vectors_deinit (GVariantVectors *vectors)
++{
++ int i;
++ for (i = 0; i < vectors->vectors->len; i++)
++ {
++ GVariantVector *v = &g_array_index (vectors->vectors, GVariantVector, i);
++ g_bytes_unref (v->gbytes);
++ }
++ g_byte_array_unref (vectors->extra_bytes);
++ g_array_unref (vectors->vectors);
++ g_byte_array_unref (vectors->offsets);
++}
++
++gsize
++g_variant_vectors_append_pad (GVariantVectors *vectors,
++ gsize padding)
++{
++ /* If the last vector that we stored was 'pad' or 'copy' then we will
++ * expand it instead of adding a new one.
++ */
++ if (vectors->vectors->len)
++ {
++ GVariantVector *expand_vector = &g_array_index (vectors->vectors, GVariantVector, vectors->vectors->len - 1);
++
++ if (expand_vector->gbytes == NULL)
++ {
++ expand_vector->size += padding;
++
++ /* If the vector points to data, we need to add the padding to
++ * the end of that data. If it points to the zero bytes at
++ * the start then we can just grow it (but we must ensure that
++ * it doesn't get too large).
++ */
++ if (expand_vector->data.offset)
++ append_zeros (vectors->extra_bytes, padding);
++ else
++ g_assert (expand_vector->size < 8);
++
++ return padding;
++ }
++
++ /* If the last vector was a GBytes then fall through */
++ }
++
++ /* Otherwise, record a new vector pointing to the padding bytes at the
++ * start.
++ */
++ {
++ GVariantVector v;
++
++ v.gbytes = NULL;
++ v.data.offset = 0;
++ v.size = padding;
++
++ g_array_append_val (vectors->vectors, v);
++ }
++
++ return padding;
++}
++
++void
++g_variant_vectors_append_copy (GVariantVectors *vectors,
++ gconstpointer data,
++ gsize size)
++{
++ /* If the last vector that we stored was 'pad' or 'copy' then we will
++ * expand it instead of adding a new one.
++ */
++ if (vectors->vectors->len)
++ {
++ GVariantVector *expand_vector = &g_array_index (vectors->vectors, GVariantVector, vectors->vectors->len - 1);
++
++ if (expand_vector->gbytes == NULL)
++ {
++ /* If this was a padding vector then we must convert it to
++ * data first.
++ */
++ if (expand_vector->data.offset == 0)
++ {
++ expand_vector->data.offset = vectors->extra_bytes->len;
++ append_zeros (vectors->extra_bytes, expand_vector->size);
++ }
++
++ /* We have a vector pointing to data at the end of the
++ * extra_bytes array, so just append there and grow the
++ * vector.
++ */
++ g_byte_array_append (vectors->extra_bytes, data, size);
++ expand_vector->size += size;
++ return;
++ }
++
++ /* If the last vector was a GBytes then fall through */
++ }
++
++ /* Otherwise, copy the data and record a new vector. */
++ {
++ GVariantVector v;
++
++ v.gbytes = NULL;
++ v.data.offset = vectors->extra_bytes->len;
++ v.size = size;
++
++ g_byte_array_append (vectors->extra_bytes, data, size);
++ g_array_append_val (vectors->vectors, v);
++ }
++}
++
++void
++g_variant_vectors_append_gbytes (GVariantVectors *vectors,
++ GBytes *gbytes,
++ gconstpointer data,
++ gsize size)
++{
++ GVariantVector v;
++
++ /* Some very rough profiling has indicated that the trade-off for
++ * overhead on the atomic operations involved in the ref/unref on the
++ * GBytes is larger than the cost of the copy at ~128 bytes.
++ */
++ if (size < 128)
++ {
++ g_variant_vectors_append_copy (vectors, data, size);
++ return;
++ }
++
++ v.gbytes = g_bytes_ref (gbytes);
++ v.data.pointer = data;
++ v.size = size;
++
++ g_array_append_val (vectors->vectors, v);
++}
++
++typedef void (* WriteFunction) (gpointer base, gsize offset, gsize value);
++static void write_1 (gpointer base, gsize offset, gsize value) { ((guint8 *) base)[offset] = value; }
++static void write_2 (gpointer base, gsize offset, gsize value) { ((guint16 *) base)[offset] = GUINT16_TO_LE (value); }
++static void write_4 (gpointer base, gsize offset, gsize value) { ((guint32 *) base)[offset] = GUINT32_TO_LE (value); }
++static void write_8 (gpointer base, gsize offset, gsize value) { ((guint64 *) base)[offset] = GUINT64_TO_LE (value); }
++
++typedef struct
++{
++ gsize size;
++ WriteFunction func;
++} OffsetsHeader;
++
++gsize
++g_variant_vectors_reserve_offsets (GVariantVectors *vectors,
++ guint n_offsets,
++ guint offset_size)
++{
++ OffsetsHeader *header;
++ gsize total_size;
++ gsize add_size;
++ guint key;
++
++ total_size = n_offsets * offset_size;
++
++ /* Add room for the metadata and round up to multiple of 8 */
++ add_size = (sizeof (OffsetsHeader) + total_size + 7) & ~7ull;
++ key = vectors->offsets->len;
++ g_byte_array_set_size (vectors->offsets, key + add_size);
++ header = (OffsetsHeader *) (vectors->offsets->data + key);
++ key += sizeof (OffsetsHeader);
++ header->size = total_size;
++
++ switch (offset_size)
++ {
++ case 1:
++ header->func = write_1;
++ break;
++
++ case 2:
++ header->func = write_2;
++ break;
++
++ case 4:
++ header->func = write_4;
++ break;
++
++ case 8:
++ header->func = write_8;
++ break;
++
++ default:
++ g_assert_not_reached ();
++ }
++
++ return key;
++}
++
++void
++g_variant_vectors_write_to_offsets (GVariantVectors *vectors,
++ gsize offset,
++ gsize value,
++ gsize key)
++{
++ OffsetsHeader *header;
++ guchar *offsets;
++
++ offsets = vectors->offsets->data + key;
++ header = (OffsetsHeader *) (offsets - sizeof (OffsetsHeader));
++
++ header->func (offsets, offset, value);
++}
++
++void
++g_variant_vectors_commit_offsets (GVariantVectors *vectors,
++ gsize key)
++{
++ OffsetsHeader *header;
++ guchar *offsets;
++
++ offsets = vectors->offsets->data + key;
++ header = (OffsetsHeader *) (offsets - sizeof (OffsetsHeader));
++
++ g_variant_vectors_append_copy (vectors, offsets, header->size);
++ g_byte_array_set_size (vectors->offsets, key - sizeof (OffsetsHeader));
++}
+diff --git a/glib/gvariant-vectors.h b/glib/gvariant-vectors.h
+new file mode 100644
+index 0000000..05e2258
+--- /dev/null
++++ b/glib/gvariant-vectors.h
+@@ -0,0 +1,63 @@
++
++#ifndef __G_VARIANT_VECTORS_H__
++#define __G_VARIANT_VECTORS_H__
++
++#include <glib/garray.h>
++
++typedef struct
++{
++ GByteArray *extra_bytes;
++ GArray *vectors;
++ GByteArray *offsets;
++} GVariantVectors;
++
++
++/* If ->bytes is NULL then offset/size point inside of extra_bytes,
++ * otherwise pointer/size point to memory owned by the GBytes.
++ */
++typedef struct
++{
++ GBytes *gbytes;
++ union {
++ const guchar *pointer;
++ gsize offset;
++ } data;
++ gsize size;
++} GVariantVector;
++
++void g_variant_vectors_init (GVariantVectors *vectors);
++
++
++void g_variant_vectors_deinit (GVariantVectors *vectors);
++
++
++gsize g_variant_vectors_append_pad (GVariantVectors *vectors,
++ gsize padding);
++
++
++void g_variant_vectors_append_copy (GVariantVectors *vectors,
++ gconstpointer data,
++ gsize size);
++
++
++void g_variant_vectors_append_gbytes (GVariantVectors *vectors,
++ GBytes *gbytes,
++ gconstpointer data,
++ gsize size);
++
++
++gsize g_variant_vectors_reserve_offsets (GVariantVectors *vectors,
++ guint n_offsets,
++ guint offset_size);
++
++
++void g_variant_vectors_write_to_offsets (GVariantVectors *vectors,
++ gsize offset,
++ gsize value,
++ gsize offset_key);
++
++
++void g_variant_vectors_commit_offsets (GVariantVectors *vectors,
++ gsize offset_key);
++
++#endif /* __G_GVARIANT_VECTORS_H__ */
+diff --git a/glib/gvariant.c b/glib/gvariant.c
+index b7e4241..b1838e2 100644
+--- a/glib/gvariant.c
++++ b/glib/gvariant.c
+@@ -139,7 +139,7 @@
+ * endianness, or of the length or type of the top-level variant.
+ *
+ * The amount of memory required to store a boolean is 1 byte. 16,
+- * 32 and 64 bit integers and double precision floating point numbers
++ * 32 and 64 bit integers and floating point numbers
+ * use their "natural" size. Strings (including object path and
+ * signature strings) are stored with a nul terminator, and as such
+ * use the length of the string plus 1 byte.
+@@ -225,7 +225,7 @@
+ *
+ * This means that in total, for our "a{sv}" example, 91 bytes of
+ * type information would be allocated.
+- *
++ *
+ * The type information cache, additionally, uses a #GHashTable to
+ * store and look up the cached items and stores a pointer to this
+ * hash table in static storage. The hash table is freed when there
+@@ -320,14 +320,10 @@ g_variant_new_from_trusted (const GVariantType *type,
+ gconstpointer data,
+ gsize size)
+ {
+- GVariant *value;
+- GBytes *bytes;
+-
+- bytes = g_bytes_new (data, size);
+- value = g_variant_new_from_bytes (type, bytes, TRUE);
+- g_bytes_unref (bytes);
++ gpointer mydata = g_memdup (data, size);
+
+- return value;
++ return g_variant_new_serialised (g_variant_type_info_get (type),
++ g_bytes_new_take (mydata, size), mydata, size, TRUE);
+ }
+
+ /**
+@@ -374,7 +370,7 @@ g_variant_get_boolean (GVariant *value)
+ }
+
+ /* the constructors and accessors for byte, int{16,32,64}, handles and
+- * doubles all look pretty much exactly the same, so we reduce
++ * floats all look pretty much exactly the same, so we reduce
+ * copy/pasting here.
+ */
+ #define NUMERIC_TYPE(TYPE, type, ctype) \
+@@ -598,6 +594,31 @@ NUMERIC_TYPE (UINT64, uint64, guint64)
+ **/
+ NUMERIC_TYPE (HANDLE, handle, gint32)
+
++/**
++ * g_variant_new_float:
++ * @value: a #gfloat floating point value
++ *
++ * Creates a new float #GVariant instance.
++ *
++ * Returns: (transfer none): a floating reference to a new float #GVariant instance
++ *
++ * Since: 2.44
++ **/
++/**
++ * g_variant_get_float:
++ * @value: a float #GVariant instance
++ *
++ * Returns the single precision floating point value of @value.
++ *
++ * It is an error to call this function with a @value of any type
++ * other than %G_VARIANT_TYPE_FLOAT.
++ *
++ * Returns: a #gfloat
++ *
++ * Since: 2.44
++ **/
++NUMERIC_TYPE (FLOAT, float, gfloat)
++
+ /**
+ * g_variant_new_double:
+ * @value: a #gdouble floating point value
+@@ -648,8 +669,8 @@ GVariant *
+ g_variant_new_maybe (const GVariantType *child_type,
+ GVariant *child)
+ {
++ GVariantTypeInfo *type_info;
+ GVariantType *maybe_type;
+- GVariant *value;
+
+ g_return_val_if_fail (child_type == NULL || g_variant_type_is_definite
+ (child_type), 0);
+@@ -662,6 +683,8 @@ g_variant_new_maybe (const GVariantType *child_type,
+ child_type = g_variant_get_type (child);
+
+ maybe_type = g_variant_type_new_maybe (child_type);
++ type_info = g_variant_type_info_get (maybe_type);
++ g_variant_type_free (maybe_type);
+
+ if (child != NULL)
+ {
+@@ -672,14 +695,10 @@ g_variant_new_maybe (const GVariantType *child_type,
+ children[0] = g_variant_ref_sink (child);
+ trusted = g_variant_is_trusted (children[0]);
+
+- value = g_variant_new_from_children (maybe_type, children, 1, trusted);
++ return g_variant_new_from_children (type_info, children, 1, trusted);
+ }
+ else
+- value = g_variant_new_from_children (maybe_type, NULL, 0, TRUE);
+-
+- g_variant_type_free (maybe_type);
+-
+- return value;
++ return g_variant_new_from_children (type_info, NULL, 0, TRUE);
+ }
+
+ /**
+@@ -725,7 +744,7 @@ g_variant_new_variant (GVariant *value)
+
+ g_variant_ref_sink (value);
+
+- return g_variant_new_from_children (G_VARIANT_TYPE_VARIANT,
++ return g_variant_new_from_children (g_variant_type_info_get (G_VARIANT_TYPE_VARIANT),
+ g_memdup2 (&value, sizeof value),
+ 1, g_variant_is_trusted (value));
+ }
+@@ -781,10 +800,10 @@ g_variant_new_array (const GVariantType *child_type,
+ GVariant * const *children,
+ gsize n_children)
+ {
++ GVariantTypeInfo *type_info;
+ GVariantType *array_type;
+ GVariant **my_children;
+ gboolean trusted;
+- GVariant *value;
+ gsize i;
+
+ g_return_val_if_fail (n_children > 0 || child_type != NULL, NULL);
+@@ -798,6 +817,8 @@ g_variant_new_array (const GVariantType *child_type,
+ if (child_type == NULL)
+ child_type = g_variant_get_type (children[0]);
+ array_type = g_variant_type_new_array (child_type);
++ type_info = g_variant_type_info_get (array_type);
++ g_variant_type_free (array_type);
+
+ for (i = 0; i < n_children; i++)
+ {
+@@ -813,11 +834,7 @@ g_variant_new_array (const GVariantType *child_type,
+ trusted &= g_variant_is_trusted (children[i]);
+ }
+
+- value = g_variant_new_from_children (array_type, my_children,
+- n_children, trusted);
+- g_variant_type_free (array_type);
+-
+- return value;
++ return g_variant_new_from_children (type_info, my_children, n_children, trusted);
+ }
+
+ /*< private >
+@@ -868,10 +885,10 @@ GVariant *
+ g_variant_new_tuple (GVariant * const *children,
+ gsize n_children)
+ {
++ GVariantTypeInfo *type_info;
+ GVariantType *tuple_type;
+ GVariant **my_children;
+ gboolean trusted;
+- GVariant *value;
+ gsize i;
+
+ g_return_val_if_fail (n_children == 0 || children != NULL, NULL);
+@@ -886,11 +903,10 @@ g_variant_new_tuple (GVariant * const *children,
+ }
+
+ tuple_type = g_variant_make_tuple_type (children, n_children);
+- value = g_variant_new_from_children (tuple_type, my_children,
+- n_children, trusted);
++ type_info = g_variant_type_info_get (tuple_type);
+ g_variant_type_free (tuple_type);
+
+- return value;
++ return g_variant_new_from_children (type_info, my_children, n_children, trusted);
+ }
+
+ /*< private >
+@@ -928,6 +944,7 @@ GVariant *
+ g_variant_new_dict_entry (GVariant *key,
+ GVariant *value)
+ {
++ GVariantTypeInfo *type_info;
+ GVariantType *dict_type;
+ GVariant **children;
+ gboolean trusted;
+@@ -941,10 +958,10 @@ g_variant_new_dict_entry (GVariant *key,
+ trusted = g_variant_is_trusted (key) && g_variant_is_trusted (value);
+
+ dict_type = g_variant_make_dict_entry_type (key, value);
+- value = g_variant_new_from_children (dict_type, children, 2, trusted);
++ type_info = g_variant_type_info_get (dict_type);
+ g_variant_type_free (dict_type);
+
+- return value;
++ return g_variant_new_from_children (type_info, children, 2, trusted);
+ }
+
+ /**
+@@ -1120,6 +1137,7 @@ g_variant_lookup_value (GVariant *dictionary,
+ * - %G_VARIANT_TYPE_BOOLEAN: #guchar (not #gboolean!)
+ * - %G_VARIANT_TYPE_BYTE: #guint8
+ * - %G_VARIANT_TYPE_HANDLE: #guint32
++ * - %G_VARIANT_TYPE_FLOAT: #gfloat
+ * - %G_VARIANT_TYPE_DOUBLE: #gdouble
+ *
+ * For example, if calling this function for an array of 32-bit integers,
+@@ -1577,7 +1595,7 @@ g_variant_new_strv (const gchar * const *strv,
+ for (i = 0; i < length_unsigned; i++)
+ strings[i] = g_variant_ref_sink (g_variant_new_string (strv[i]));
+
+- return g_variant_new_from_children (G_VARIANT_TYPE_STRING_ARRAY,
++ return g_variant_new_from_children (g_variant_type_info_get (G_VARIANT_TYPE_STRING_ARRAY),
+ strings, length_unsigned, TRUE);
+ }
+
+@@ -1714,7 +1732,7 @@ g_variant_new_objv (const gchar * const *strv,
+ for (i = 0; i < length_unsigned; i++)
+ strings[i] = g_variant_ref_sink (g_variant_new_object_path (strv[i]));
+
+- return g_variant_new_from_children (G_VARIANT_TYPE_OBJECT_PATH_ARRAY,
++ return g_variant_new_from_children (g_variant_type_info_get (G_VARIANT_TYPE_OBJECT_PATH_ARRAY),
+ strings, length_unsigned, TRUE);
+ }
+
+@@ -1955,7 +1973,7 @@ g_variant_new_bytestring_array (const gchar * const *strv,
+ for (i = 0; i < length_unsigned; i++)
+ strings[i] = g_variant_ref_sink (g_variant_new_bytestring (strv[i]));
+
+- return g_variant_new_from_children (G_VARIANT_TYPE_BYTESTRING_ARRAY,
++ return g_variant_new_from_children (g_variant_type_info_get (G_VARIANT_TYPE_BYTESTRING_ARRAY),
+ strings, length_unsigned, TRUE);
+ }
+
+@@ -2166,6 +2184,8 @@ g_variant_is_container (GVariant *value)
+ * @G_VARIANT_CLASS_UINT64: The #GVariant is an unsigned 64 bit integer.
+ * @G_VARIANT_CLASS_HANDLE: The #GVariant is a file handle index.
+ * @G_VARIANT_CLASS_DOUBLE: The #GVariant is a double precision floating
++ * @G_VARIANT_CLASS_FLOAT: The #GVariant is a single precision floating
++ * point value.
+ * point value.
+ * @G_VARIANT_CLASS_STRING: The #GVariant is a normal string.
+ * @G_VARIANT_CLASS_OBJECT_PATH: The #GVariant is a D-Bus object path
+@@ -2587,6 +2607,32 @@ g_variant_print_string (GVariant *value,
+ g_variant_get_uint64 (value));
+ break;
+
++ case G_VARIANT_CLASS_FLOAT:
++ {
++ gchar buffer[100];
++ gint i;
++
++ g_ascii_dtostr (buffer, sizeof buffer, g_variant_get_float (value));
++
++ for (i = 0; buffer[i]; i++)
++ if (buffer[i] == '.' || buffer[i] == 'e' ||
++ buffer[i] == 'n' || buffer[i] == 'N')
++ break;
++
++ /* if there is no '.' or 'e' in the float then add one */
++ if (buffer[i] == '\0')
++ {
++ buffer[i++] = '.';
++ buffer[i++] = '0';
++ buffer[i++] = '\0';
++ }
++
++ if (type_annotate)
++ g_string_append (string, "float ");
++ g_string_append (string, buffer);
++ }
++ break;
++
+ case G_VARIANT_CLASS_DOUBLE:
+ {
+ gchar buffer[100];
+@@ -2711,6 +2757,7 @@ g_variant_hash (gconstpointer value_)
+ case G_VARIANT_CLASS_INT32:
+ case G_VARIANT_CLASS_UINT32:
+ case G_VARIANT_CLASS_HANDLE:
++ case G_VARIANT_CLASS_FLOAT:
+ {
+ const guint *ptr;
+
+@@ -2833,7 +2880,7 @@ g_variant_equal (gconstpointer one,
+ * two values that have types that are not exactly equal. For example,
+ * you cannot compare a 32-bit signed integer with a 32-bit unsigned
+ * integer. Also note that this function is not particularly
+- * well-behaved when it comes to comparison of doubles; in particular,
++ * well-behaved when it comes to comparison of floats; in particular,
+ * the handling of incomparable values (ie: NaN) is undefined.
+ *
+ * If you only require an equality comparison, g_variant_equal() is more
+@@ -2904,6 +2951,14 @@ g_variant_compare (gconstpointer one,
+ return (a_val == b_val) ? 0 : (a_val > b_val) ? 1 : -1;
+ }
+
++ case G_VARIANT_CLASS_FLOAT:
++ {
++ gfloat a_val = g_variant_get_float (a);
++ gfloat b_val = g_variant_get_float (b);
++
++ return (a_val == b_val) ? 0 : (a_val > b_val) ? 1 : -1;
++ }
++
+ case G_VARIANT_CLASS_DOUBLE:
+ {
+ gdouble a_val = g_variant_get_double (a);
+@@ -3109,7 +3164,7 @@ g_variant_iter_free (GVariantIter *iter)
+ * you no longer need it.
+ *
+ * Here is an example for iterating with g_variant_iter_next_value():
+- * |[<!-- language="C" -->
++ * |[<!-- language="C" -->
+ * // recursively iterate a container
+ * void
+ * iterate_container_recursive (GVariant *container)
+@@ -3773,7 +3828,7 @@ g_variant_builder_end (GVariantBuilder *builder)
+ else
+ g_assert_not_reached ();
+
+- value = g_variant_new_from_children (my_type,
++ value = g_variant_new_from_children (g_variant_type_info_get (my_type),
+ g_renew (GVariant *,
+ GVSB(builder)->children,
+ GVSB(builder)->offset),
+@@ -4374,8 +4429,8 @@ g_variant_format_string_scan (const gchar *string,
+ switch (next_char())
+ {
+ case 'b': case 'y': case 'n': case 'q': case 'i': case 'u':
+- case 'x': case 't': case 'h': case 'd': case 's': case 'o':
+- case 'g': case 'v': case '*': case '?': case 'r':
++ case 'x': case 't': case 'h': case 'f': case 'd': case 's':
++ case 'o': case 'g': case 'v': case '*': case '?': case 'r':
+ break;
+
+ case 'm':
+@@ -5052,6 +5107,7 @@ g_variant_valist_skip_leaf (const gchar **str,
+ va_arg (*app, guint64);
+ return;
+
++ case 'f':
+ case 'd':
+ va_arg (*app, gdouble);
+ return;
+@@ -5097,6 +5153,9 @@ g_variant_valist_new_leaf (const gchar **str,
+ case 'h':
+ return g_variant_new_handle (va_arg (*app, gint));
+
++ case 'f':
++ return g_variant_new_float (va_arg (*app, gdouble));
++
+ case 'd':
+ return g_variant_new_double (va_arg (*app, gdouble));
+
+@@ -5107,6 +5166,7 @@ g_variant_valist_new_leaf (const gchar **str,
+
+ /* The code below assumes this */
+ G_STATIC_ASSERT (sizeof (gboolean) == sizeof (guint32));
++G_STATIC_ASSERT (sizeof (gfloat) == sizeof (guint32));
+ G_STATIC_ASSERT (sizeof (gdouble) == sizeof (guint64));
+
+ static void
+@@ -5180,6 +5240,10 @@ g_variant_valist_get_leaf (const gchar **str,
+ *(gint32 *) ptr = g_variant_get_handle (value);
+ return;
+
++ case 'f':
++ *(gfloat *) ptr = g_variant_get_float (value);
++ return;
++
+ case 'd':
+ *(gdouble *) ptr = g_variant_get_double (value);
+ return;
+@@ -5202,6 +5266,7 @@ g_variant_valist_get_leaf (const gchar **str,
+ case 'u':
+ case 'h':
+ case 'b':
++ case 'f':
+ *(guint32 *) ptr = 0;
+ return;
+
+@@ -6011,6 +6076,9 @@ g_variant_deep_copy (GVariant *value,
+ else
+ return g_variant_new_handle (g_variant_get_handle (value));
+
++ case G_VARIANT_CLASS_FLOAT:
++ return g_variant_new_float (g_variant_get_float (value));
++
+ case G_VARIANT_CLASS_DOUBLE:
+ if (byteswap)
+ {
+@@ -6096,8 +6164,7 @@ g_variant_get_normal_form (GVariant *value)
+ * Performs a byteswapping operation on the contents of @value. The
+ * result is that all multi-byte numeric data contained in @value is
+ * byteswapped. That includes 16, 32, and 64bit signed and unsigned
+- * integers as well as file handles and double precision floating point
+- * values.
++ * integers as well as file handles and floating point values.
+ *
+ * This function is an identity mapping on any value that does not
+ * contain multi-byte numeric data. That include strings, booleans,
+@@ -6211,21 +6278,99 @@ g_variant_new_from_data (const GVariantType *type,
+ GDestroyNotify notify,
+ gpointer user_data)
+ {
+- GVariant *value;
+ GBytes *bytes;
+
+ g_return_val_if_fail (g_variant_type_is_definite (type), NULL);
+ g_return_val_if_fail (data != NULL || size == 0, NULL);
+
++ if (size == 0)
++ {
++ if (notify)
++ {
++ (* notify) (user_data);
++ notify = NULL;
++ }
++
++ data = NULL;
++ }
++
+ if (notify)
+ bytes = g_bytes_new_with_free_func (data, size, notify, user_data);
+ else
+ bytes = g_bytes_new_static (data, size);
+
+- value = g_variant_new_from_bytes (type, bytes, trusted);
+- g_bytes_unref (bytes);
++ return g_variant_new_serialised (g_variant_type_info_get (type), bytes, data, size, trusted);
++}
+
+- return value;
++/**
++ * g_variant_new_from_bytes:
++ * @type: a #GVariantType
++ * @bytes: a #GBytes
++ * @trusted: if the contents of @bytes are trusted
++ *
++ * Constructs a new serialised-mode #GVariant instance. This is the
++ * inner interface for creation of new serialised values that gets
++ * called from various functions in gvariant.c.
++ *
++ * A reference is taken on @bytes.
++ *
++ * Returns: (transfer none): a new #GVariant with a floating reference
++ *
++ * Since: 2.36
++ */
++GVariant *
++g_variant_new_from_bytes (const GVariantType *type,
++ GBytes *bytes,
++ gboolean trusted)
++{
++ gconstpointer data;
++ gsize size;
++
++ g_return_val_if_fail (g_variant_type_is_definite (type), NULL);
++
++ data = g_bytes_get_data (bytes, &size);
++
++ return g_variant_new_serialised (g_variant_type_info_get (type), g_bytes_ref (bytes), data, size, trusted);
++}
++
++/**
++ * g_variant_get_data_as_bytes:
++ * @value: a #GVariant
++ *
++ * Returns a pointer to the serialised form of a #GVariant instance.
++ * The semantics of this function are exactly the same as
++ * g_variant_get_data(), except that the returned #GBytes holds
++ * a reference to the variant data.
++ *
++ * Returns: (transfer full): A new #GBytes representing the variant data
++ *
++ * Since: 2.36
++ */
++GBytes *
++g_variant_get_data_as_bytes (GVariant *value)
++{
++ gconstpointer data;
++ GBytes *bytes;
++ gsize size;
++ gconstpointer bytes_data;
++ gsize bytes_size;
++
++ data = g_variant_get_serialised (value, &bytes, &size);
++ bytes_data = g_bytes_get_data (bytes, &bytes_size);
++
++ /* Try to reuse the GBytes held internally by GVariant, if it exists
++ * and is covering exactly the correct range.
++ */
++ if (data == bytes_data && size == bytes_size)
++ return g_bytes_ref (bytes);
++
++ /* See g_variant_get_data() about why it can return NULL... */
++ else if (data == NULL)
++ return g_bytes_new_take (g_malloc0 (size), size);
++
++ /* Otherwise, make a new GBytes with reference to the old. */
++ else
++ return g_bytes_new_with_free_func (data, size, (GDestroyNotify) g_bytes_unref, g_bytes_ref (bytes));
+ }
+
+ /* Epilogue {{{1 */
+diff --git a/glib/gvariant.h b/glib/gvariant.h
+index bdc3795..852376a 100644
+--- a/glib/gvariant.h
++++ b/glib/gvariant.h
+@@ -46,6 +46,7 @@ typedef enum
+ G_VARIANT_CLASS_INT64 = 'x',
+ G_VARIANT_CLASS_UINT64 = 't',
+ G_VARIANT_CLASS_HANDLE = 'h',
++ G_VARIANT_CLASS_FLOAT = 'f',
+ G_VARIANT_CLASS_DOUBLE = 'd',
+ G_VARIANT_CLASS_STRING = 's',
+ G_VARIANT_CLASS_OBJECT_PATH = 'o',
+@@ -97,6 +98,8 @@ GLIB_AVAILABLE_IN_ALL
+ GVariant * g_variant_new_uint64 (guint64 value);
+ GLIB_AVAILABLE_IN_ALL
+ GVariant * g_variant_new_handle (gint32 value);
++GLIB_AVAILABLE_IN_2_44
++GVariant * g_variant_new_float (gfloat value);
+ GLIB_AVAILABLE_IN_ALL
+ GVariant * g_variant_new_double (gdouble value);
+ GLIB_AVAILABLE_IN_ALL
+@@ -150,6 +153,8 @@ GLIB_AVAILABLE_IN_ALL
+ guint64 g_variant_get_uint64 (GVariant *value);
+ GLIB_AVAILABLE_IN_ALL
+ gint32 g_variant_get_handle (GVariant *value);
++GLIB_AVAILABLE_IN_2_44
++gfloat g_variant_get_float (GVariant *value);
+ GLIB_AVAILABLE_IN_ALL
+ gdouble g_variant_get_double (GVariant *value);
+ GLIB_AVAILABLE_IN_ALL
+diff --git a/glib/gvarianttype.c b/glib/gvarianttype.c
+index 58a4a59..2959da5 100644
+--- a/glib/gvarianttype.c
++++ b/glib/gvarianttype.c
+@@ -113,7 +113,7 @@
+ * A basic type string describes a basic type (as per
+ * g_variant_type_is_basic()) and is always a single character in length.
+ * The valid basic type strings are "b", "y", "n", "q", "i", "u", "x", "t",
+- * "h", "d", "s", "o", "g" and "?".
++ * "h", "f", "d", "s", "o", "g" and "?".
+ *
+ * The above definition is recursive to arbitrary depth. "aaaaai" and
+ * "(ui(nq((y)))s)" are both valid type strings, as is
+@@ -134,6 +134,8 @@
+ * - `h`: the type string of %G_VARIANT_TYPE_HANDLE; a signed 32 bit value
+ * that, by convention, is used as an index into an array of file
+ * descriptors that are sent alongside a D-Bus message.
++ * - `f`: the type string of %G_VARIANT_TYPE_FLOAT; a single precision
++ * floating point value.
+ * - `d`: the type string of %G_VARIANT_TYPE_DOUBLE; a double precision
+ * floating point value.
+ * - `s`: the type string of %G_VARIANT_TYPE_STRING; a string.
+@@ -234,7 +236,7 @@ variant_type_string_scan_internal (const gchar *string,
+ case '{':
+ if (depth_limit == 0 ||
+ string == limit || *string == '\0' || /* { */
+- !strchr ("bynqihuxtdsog?", *string++) || /* key */
++ !strchr ("bynqihuxtfdsog?", *string++) || /* key */
+ !variant_type_string_scan_internal (string, limit, &string,
+ &child_depth, depth_limit - 1) || /* value */
+ string == limit || *string++ != '}') /* } */
+@@ -254,7 +256,7 @@ variant_type_string_scan_internal (const gchar *string,
+
+ case 'b': case 'y': case 'n': case 'q': case 'i': case 'u':
+ case 'x': case 't': case 'd': case 's': case 'o': case 'g':
+- case 'v': case 'r': case '*': case '?': case 'h':
++ case 'v': case 'r': case '*': case '?': case 'h': case 'f':
+ max_depth = MAX (max_depth, 1);
+ break;
+
+@@ -600,8 +602,8 @@ g_variant_type_is_container (const GVariantType *type)
+ *
+ * Determines if the given @type is a basic type.
+ *
+- * Basic types are booleans, bytes, integers, doubles, strings, object
+- * paths and signatures.
++ * Basic types are booleans, bytes, integers, floats, doubles, strings,
++ * object paths and signatures.
+ *
+ * Only a basic type may be used as the key of a dictionary entry.
+ *
+@@ -631,6 +633,7 @@ g_variant_type_is_basic (const GVariantType *type)
+ case 'u':
+ case 't':
+ case 'x':
++ case 'f':
+ case 'd':
+ case 's':
+ case 'o':
+diff --git a/glib/gvarianttype.h b/glib/gvarianttype.h
+index 6374957..c613c5a 100644
+--- a/glib/gvarianttype.h
++++ b/glib/gvarianttype.h
+@@ -105,6 +105,15 @@ typedef struct _GVariantType GVariantType;
+ **/
+ #define G_VARIANT_TYPE_UINT64 ((const GVariantType *) "t")
+
++/**
++ * G_VARIANT_TYPE_FLOAT:
++ *
++ * The type of a single precision IEEE754 floating point number. You
++ * can store a number as large as 3.40e38 in these (plus and minus) but
++ * there are some gaps on the way.
++ **/
++#define G_VARIANT_TYPE_FLOAT ((const GVariantType *) "f")
++
+ /**
+ * G_VARIANT_TYPE_DOUBLE:
+ *
+diff --git a/glib/gvarianttypeinfo.c b/glib/gvarianttypeinfo.c
+index d2df7fd..466055d 100644
+--- a/glib/gvarianttypeinfo.c
++++ b/glib/gvarianttypeinfo.c
+@@ -120,7 +120,7 @@ static const GVariantTypeInfo g_variant_type_info_basic_table[24] = {
+ /* 'c' */ { not_a_type },
+ /* 'd' */ { fixed_aligned(8) }, /* double */
+ /* 'e' */ { not_a_type },
+- /* 'f' */ { not_a_type },
++ /* 'f' */ { fixed_aligned(4) }, /* float */
+ /* 'g' */ { unaligned }, /* signature string */
+ /* 'h' */ { fixed_aligned(4) }, /* file handle (int32) */
+ /* 'i' */ { fixed_aligned(4) }, /* int32 */
+@@ -152,7 +152,7 @@ static const GVariantTypeInfo g_variant_type_info_basic_table[24] = {
+ * GVariantTypeInfo itself, we save a bunch of relocations.
+ */
+ static const char g_variant_type_info_basic_chars[24][2] = {
+- "b", " ", "d", " ", " ", "g", "h", "i", " ", " ", " ", " ",
++ "b", " ", "d", " ", "f", "g", "h", "i", " ", " ", " ", " ",
+ "n", "o", " ", "q", " ", "s", "t", "u", "v", " ", "x", "y"
+ };
+
+diff --git a/glib/meson.build b/glib/meson.build
+index c26a35e..6703deb 100644
+--- a/glib/meson.build
++++ b/glib/meson.build
+@@ -344,6 +344,7 @@ glib_sources += files(
+ 'gvariant-core.c',
+ 'gvariant-parser.c',
+ 'gvariant-serialiser.c',
++ 'gvariant-vectors.c',
+ 'gvarianttypeinfo.c',
+ 'gvarianttype.c',
+ 'gversion.c',
+diff --git a/glib/tests/bytes.c b/glib/tests/bytes.c
+index e81a5f4..cd87734 100644
+--- a/glib/tests/bytes.c
++++ b/glib/tests/bytes.c
+@@ -16,7 +16,12 @@
+ #include <stdio.h>
+ #include <stdlib.h>
+ #include <string.h>
++#include <errno.h>
++#include <unistd.h>
+ #include "glib.h"
++#include "glib-unix.h"
++
++#include "glib-linux.h"
+
+ /* Keep in sync with glib/gbytes.c */
+ struct _GBytes
+@@ -271,7 +276,7 @@ test_to_data_transferred (void)
+ GBytes *bytes;
+
+ /* Memory transferred: one reference, and allocated with g_malloc */
+- bytes = g_bytes_new (NYAN, N_NYAN);
++ bytes = g_bytes_new_take (g_memdup (NYAN, N_NYAN), N_NYAN);
+ memory = g_bytes_get_data (bytes, NULL);
+ data = g_bytes_unref_to_data (bytes, &size);
+ g_assert_true (data == memory);
+@@ -349,7 +354,7 @@ test_to_array_transferred (void)
+ GBytes *bytes;
+
+ /* Memory transferred: one reference, and allocated with g_malloc */
+- bytes = g_bytes_new (NYAN, N_NYAN);
++ bytes = g_bytes_new_take (g_memdup (NYAN, N_NYAN), N_NYAN);
+ memory = g_bytes_get_data (bytes, NULL);
+ array = g_bytes_unref_to_array (bytes);
+ g_assert_nonnull (array);
+@@ -483,6 +488,46 @@ test_unref_null (void)
+ g_bytes_unref (NULL);
+ }
+
++#ifdef GLIB_LINUX
++static void
++test_memfd (void)
++{
++ GBytes *bytes;
++ gint fd;
++
++ fd = glib_linux_memfd_create ("", MFD_CLOEXEC);
++ if (fd == -1 && errno == EINVAL)
++ {
++ g_test_skip ("missing kernel memfd support");
++ return;
++ }
++
++ /* We should not be able to seal this one */
++ g_assert (!g_unix_fd_ensure_zero_copy_safe (fd));
++ close (fd);
++
++ /* but this one will work */
++ fd = glib_linux_memfd_create ("", MFD_CLOEXEC | MFD_ALLOW_SEALING);
++ bytes = g_bytes_new_take_zero_copy_fd (fd);
++ g_assert_cmpint (g_bytes_get_size (bytes), ==, 0);
++ g_bytes_unref (bytes);
++
++ /* try with real data */
++ fd = glib_linux_memfd_create ("", MFD_CLOEXEC | MFD_ALLOW_SEALING);
++ g_assert_se (write (fd, NYAN, N_NYAN) == N_NYAN);
++ bytes = g_bytes_new_take_zero_copy_fd (fd);
++ g_assert_cmpint (g_bytes_get_size (bytes), ==, N_NYAN);
++ g_assert (memcmp (g_bytes_get_data (bytes, NULL), NYAN, N_NYAN) == 0);
++ g_assert (g_bytes_get_zero_copy_fd (bytes) == fd);
++
++ /* ensure that we cannot modify the fd further */
++ g_assert_se (write (fd, NYAN, N_NYAN) == -1);
++
++ /* that's enough for now */
++ g_bytes_unref (bytes);
++}
++#endif
++
+ int
+ main (int argc, char *argv[])
+ {
+@@ -507,6 +552,9 @@ main (int argc, char *argv[])
+ g_test_add_func ("/bytes/to-array/two-refs", test_to_array_two_refs);
+ g_test_add_func ("/bytes/to-array/non-malloc", test_to_array_non_malloc);
+ g_test_add_func ("/bytes/null", test_null);
++#ifdef GLIB_LINUX
++ g_test_add_func ("/bytes/memfd", test_memfd);
++#endif
+ g_test_add_func ("/bytes/get-region", test_get_region);
+ g_test_add_func ("/bytes/unref-null", test_unref_null);
+
+diff --git a/glib/tests/gvariant.c b/glib/tests/gvariant.c
+index c8f1336..3dc781c 100644
+--- a/glib/tests/gvariant.c
++++ b/glib/tests/gvariant.c
+@@ -18,14 +18,15 @@
+ #include "config.h"
+
+ #include <glib/gvariant-internal.h>
++#include <glib/glib-private.h>
+ #include <string.h>
+ #include <stdlib.h>
+ #include <glib.h>
+
+-#define BASIC "bynqiuxthdsog?"
++#define BASIC "bynqiuxthfdsog?"
+ #define N_BASIC (G_N_ELEMENTS (BASIC) - 1)
+
+-#define INVALIDS "cefjklpwz&@^$"
++#define INVALIDS "cejklpwz&@^$"
+ #define N_INVALIDS (G_N_ELEMENTS (INVALIDS) - 1)
+
+ /* see comment in gvariant-serialiser.c about this madness.
+@@ -85,6 +86,8 @@ append_type_string (GString *string,
+ return g_variant_type_copy (G_VARIANT_TYPE_UINT64);
+ case 'h':
+ return g_variant_type_copy (G_VARIANT_TYPE_HANDLE);
++ case 'f':
++ return g_variant_type_copy (G_VARIANT_TYPE_FLOAT);
+ case 'd':
+ return g_variant_type_copy (G_VARIANT_TYPE_DOUBLE);
+ case 's':
+@@ -452,6 +455,8 @@ describe_type (const GVariantType *type)
+ result = g_strdup ("t");
+ else if (g_variant_type_equal (type, G_VARIANT_TYPE_HANDLE))
+ result = g_strdup ("h");
++ else if (g_variant_type_equal (type, G_VARIANT_TYPE_FLOAT))
++ result = g_strdup ("f");
+ else if (g_variant_type_equal (type, G_VARIANT_TYPE_DOUBLE))
+ result = g_strdup ("d");
+ else if (g_variant_type_equal (type, G_VARIANT_TYPE_STRING))
+@@ -807,6 +812,7 @@ calculate_type_info (const GVariantType *type,
+
+ else if (g_variant_type_equal (type, G_VARIANT_TYPE_INT32) ||
+ g_variant_type_equal (type, G_VARIANT_TYPE_UINT32) ||
++ g_variant_type_equal (type, G_VARIANT_TYPE_FLOAT) ||
+ g_variant_type_equal (type, G_VARIANT_TYPE_HANDLE))
+ {
+ al = fs = 4;
+@@ -1960,6 +1966,7 @@ struct _TreeInstance
+
+ union {
+ guint64 integer;
++ gfloat single;
+ gdouble floating;
+ gchar string[200];
+ } data;
+@@ -2074,6 +2081,11 @@ tree_instance_new (const GVariantType *type,
+ instance->data_size = 8;
+ break;
+
++ case 'f':
++ instance->data.single = g_test_rand_double ();
++ instance->data_size = 4;
++ break;
++
+ case 'd':
+ instance->data.floating = g_test_rand_double ();
+ instance->data_size = 8;
+@@ -2597,6 +2609,10 @@ tree_instance_get_gvariant (TreeInstance *tree)
+ result = g_variant_new_handle (tree->data.integer);
+ break;
+
++ case 'f':
++ result = g_variant_new_float (tree->data.single);
++ break;
++
+ case 'd':
+ result = g_variant_new_double (tree->data.floating);
+ break;
+@@ -2620,6 +2636,19 @@ tree_instance_get_gvariant (TreeInstance *tree)
+ return result;
+ }
+
++static GVariant *
++create_random_gvariant (guint depth)
++{
++ TreeInstance *tree;
++ GVariant *value;
++
++ tree = tree_instance_new (NULL, depth);
++ value = g_variant_take_ref (tree_instance_get_gvariant (tree));
++ tree_instance_free (tree);
++
++ return value;
++}
++
+ static gboolean
+ tree_instance_check_gvariant (TreeInstance *tree,
+ GVariant *value)
+@@ -2724,6 +2753,13 @@ tree_instance_check_gvariant (TreeInstance *tree,
+ case 'h':
+ return g_variant_get_handle (value) == (gint32) tree->data.integer;
+
++ case 'f':
++ {
++ gfloat floating = g_variant_get_float (value);
++
++ return memcmp (&floating, &tree->data.single, sizeof floating) == 0;
++ }
++
+ case 'd':
+ {
+ gdouble floating = g_variant_get_double (value);
+@@ -3897,6 +3933,7 @@ test_gv_byteswap_non_normal_non_aligned (void)
+ static void
+ test_parser (void)
+ {
++ GError *error = NULL;
+ TreeInstance *tree;
+ GVariant *parsed;
+ GVariant *value;
+@@ -3910,16 +3947,19 @@ test_parser (void)
+ pt = g_variant_print (value, TRUE);
+ p = g_variant_print (value, FALSE);
+
+- parsed = g_variant_parse (NULL, pt, NULL, NULL, NULL);
++ parsed = g_variant_parse (NULL, pt, NULL, NULL, &error);
++ g_assert_no_error (error);
+ res = g_variant_print (parsed, FALSE);
+- g_assert_cmpstr (p, ==, res);
++ if (!strstr (pt, "float")) /* FIXME: need reliable round-trip for floats */
++ g_assert_cmpstr (p, ==, res);
+ g_variant_unref (parsed);
+ g_free (res);
+
+- parsed = g_variant_parse (g_variant_get_type (value), p,
+- NULL, NULL, NULL);
++ parsed = g_variant_parse (g_variant_get_type (value), p, NULL, NULL, &error);
++ g_assert_no_error (error);
+ res = g_variant_print (parsed, TRUE);
+- g_assert_cmpstr (pt, ==, res);
++ if (!strstr (pt, "float")) /* FIXME: need reliable round-trip for floats */
++ g_assert_cmpstr (pt, ==, res);
+ g_variant_unref (parsed);
+ g_free (res);
+
+@@ -4925,10 +4965,13 @@ test_gbytes (void)
+ {
+ GVariant *a;
+ GVariant *tuple;
++ GVariant *b;
++ GVariant *c;
+ GBytes *bytes;
+ GBytes *bytes2;
+ const guint8 values[5] = { 1, 2, 3, 4, 5 };
+ const guint8 *elts;
++ gchar *tmp;
+ gsize n_elts;
+ gsize i;
+
+@@ -4959,6 +5002,41 @@ test_gbytes (void)
+ g_bytes_unref (bytes2);
+ g_variant_unref (a);
+ g_variant_unref (tuple);
++
++ /* Feed in some non-normal data... make sure it's aligned.
++ *
++ * Here we have an array of three elements. The first and last are
++ * normal ints ('iiii') and array-of-bytes data ('ayay'). The middle
++ * element is zero-bytes wide, which will present a problem when
++ * fetching the fixed-size integer out of it.
++ * */
++ tmp = g_strdup ("iiiiayayiiiisayay\x08\x08\x10");
++ bytes = g_bytes_new_take (tmp, strlen (tmp));
++ a = g_variant_new_from_bytes (G_VARIANT_TYPE ("a(iay)"), bytes, FALSE);
++ g_bytes_unref (bytes);
++
++ /* The middle tuple is zero bytes */
++ b = g_variant_get_child_value (a, 1);
++ g_assert_cmpint (g_variant_get_size (b), ==, 0);
++
++ /* But we're going to pull a 4-byte child out of it... */
++ c = g_variant_get_child_value (b, 0);
++ g_assert_cmpint (g_variant_get_size (c), ==, 4);
++
++ /* g_variant_get_data() is allowed to fail in this case.
++ * NB: if someone finds a way to avoid this then that's fine too...
++ */
++ g_assert (g_variant_get_data (c) == NULL);
++
++ /* but since it's four bytes, it ought to have data... */
++ bytes = g_variant_get_data_as_bytes (c);
++ g_assert_cmpint (g_bytes_get_size (bytes), ==, 4);
++ g_assert (memcmp (g_bytes_get_data (bytes, NULL), "\0\0\0\0", 4) == 0);
++ g_bytes_unref (bytes);
++
++ g_variant_unref (c);
++ g_variant_unref (b);
++ g_variant_unref (a);
+ }
+
+ typedef struct {
+@@ -5002,6 +5080,81 @@ G_GNUC_BEGIN_IGNORE_DEPRECATIONS
+ G_GNUC_END_IGNORE_DEPRECATIONS
+ }
+
++static GByteArray *
++flatten_vectors (GVariantVectors *v)
++{
++ GByteArray *result;
++ guint i;
++
++ result = g_byte_array_new ();
++
++ for (i = 0; i < v->vectors->len; i++)
++ {
++ GVariantVector vec = g_array_index (v->vectors, GVariantVector, i);
++
++ if (vec.gbytes)
++ g_byte_array_append (result, vec.data.pointer, vec.size);
++ else
++ g_byte_array_append (result, v->extra_bytes->data + vec.data.offset, vec.size);
++ }
++
++ return result;
++}
++
++static void
++test_vector_serialiser (void)
++{
++ GVariantVectors vectors;
++ GByteArray *flattened;
++ GVariant *value;
++ guint i;
++
++ for (i = 0; i < 100; i++)
++ {
++ guint j;
++
++ value = create_random_gvariant (2);
++ //g_print (">>> %s\n", g_variant_print (value, TRUE));
++
++ GLIB_PRIVATE_CALL(g_variant_to_vectors) (value, &vectors);
++ for (j = 0; j < vectors.vectors->len; j++)
++ {
++ GVariantVector *v = &g_array_index (vectors.vectors, GVariantVector, j);
++
++ if (!v->gbytes)
++ {
++ v->gbytes = g_bytes_new (NULL, 0);
++ v->data.pointer = v->data.offset + vectors.extra_bytes->data;
++ }
++
++ //g_print (" V %p %p %d\n", v, v->data.pointer, (guint) v->size);
++ }
++ GLIB_PRIVATE_CALL(g_variant_from_vectors) (g_variant_get_type (value), (GVariantVector *) vectors.vectors->data, vectors.vectors->len, g_variant_get_size (value), TRUE);
++ continue;
++ flattened = flatten_vectors (&vectors);
++ g_byte_array_free (vectors.extra_bytes, TRUE);
++ g_byte_array_free (vectors.offsets, TRUE);
++ g_array_free (vectors.vectors, TRUE);
++
++#if 0
++ if (flattened->len != g_variant_get_size (value) ||
++ memcmp (flattened->data, g_variant_get_data (value), flattened->len) != 0)
++ {
++ g_file_set_contents ("flattened", flattened->data, flattened->len, NULL);
++ g_file_set_contents ("serialised", g_variant_get_data (value), g_variant_get_size (value), NULL);
++ g_print ("type is %s\n", g_variant_get_type_string (value));
++ g_assert_not_reached ();
++ }
++#endif
++
++ g_assert_cmpint (flattened->len, ==, g_variant_get_size (value));
++ g_assert (memcmp (flattened->data, g_variant_get_data (value), flattened->len) == 0);
++
++ g_byte_array_free (flattened, TRUE);
++ g_variant_unref (value);
++ }
++}
++
+ static void
+ test_stack_builder_init (void)
+ {
+@@ -5866,6 +6019,7 @@ main (int argc, char **argv)
+ g_test_add_func ("/gvariant/gbytes", test_gbytes);
+ g_test_add_func ("/gvariant/print-context", test_print_context);
+ g_test_add_func ("/gvariant/error-quark", test_error_quark);
++ g_test_add_func ("/gvariant/vector-serialiser", test_vector_serialiser);
+
+ g_test_add_func ("/gvariant/stack-builder-init", test_stack_builder_init);
+ g_test_add_func ("/gvariant/stack-dict-init", test_stack_dict_init);
+--
+2.25.1
+
--- /dev/null
+From 3800128928e1df0df28629e1d16250f342a6cfff Mon Sep 17 00:00:00 2001
+From: Karol Lewandowski <k.lewandowsk@samsung.com>
+Date: Tue, 6 Feb 2024 16:00:27 +0100
+Subject: [PATCH] tizen: Add kdbus
+
+This commit provides kdbus originally from upstream but later long
+maintained and significantly improved for Tizen project by Lukasz Skalski,
+Adrian Szyndela, Hyotaek Shim, Insun Pyo and Michal Eljasiewicz.
+
+See tizen_8.0 and older branches for complete history. The commits below
+list only the start of kdbus history (for identifiaction purposes).
+
+.
+
+commit f8c5231931f3a0d7b0508598e3f51e5cef13017f
+Author: Lukasz Skalski <l.skalski@samsung.com>
+Date: Fri Aug 21 17:42:53 2015 +0200
+
+ gdbus: integrate kdbus into GDBus core
+
+ Patch includes also changes made by Ryan Lortie <desrt@desrt.ca>
+
+ https://bugzilla.gnome.org/show_bug.cgi?id=721861
+
+ Change-Id: I6bab6fee34787816efeb42d8e3e60c4c551a8a2b
+
+commit d2e6e8fd848d104a4ae83af5eced5cf009b5f29c
+Author: Lukasz Skalski <l.skalski@samsung.com>
+Date: Fri Aug 21 17:41:27 2015 +0200
+
+ gdbus: add kdbus core files
+
+ Patch includes also changes made by Ryan Lortie <desrt@desrt.ca>
+ and Adrian Szyndela <a.szyndela@samsung.com>
+
+ https://bugzilla.gnome.org/show_bug.cgi?id=721861
+
+ Change-Id: Ie90076a28c611320cd9b5ed6f2123d0ef85c6326
+
+commit 2eae20f44d0300b3d151ae8a1f260bf122da702a
+Author: Lukasz Skalski <l.skalski@samsung.com>
+Date: Fri Aug 21 16:47:05 2015 +0200
+
+ gdbus: import kdbus interface header
+
+ kdbus.h taken from https://github.com/systemd/kdbus, commit 9c04b6b989c9.
+
+ Hosting of our own copy of the kdbus header is temporary solution.
+ In the future, we should include it from the system kernel headers.
+
+ https://bugzilla.gnome.org/show_bug.cgi?id=721861
+
+ Change-Id: I2a42c91648b10c7c14f4df9ce2755f7c60524903
+
+---
+ gio/gdbusaddress.c | 107 +-
+ gio/gdbusconnection.c | 1376 ++++++++--
+ gio/gdbusconnection.h | 42 +
+ gio/gdbusmessage.c | 7 +
+ gio/gdbusmethodinvocation.c | 38 +
+ gio/gdbusmethodinvocation.h | 5 +
+ gio/gdbusnameowning.c | 19 +-
+ gio/gdbusnamewatching.c | 24 +-
+ gio/gdbusobjectmanagerclient.c | 34 +-
+ gio/gdbusprivate.c | 202 +-
+ gio/gdbusprivate.h | 20 +-
+ gio/gdbusproxy.c | 20 +-
+ gio/gdbusutils.c | 9 +
+ gio/gioenums.h | 60 +
+ gio/gkdbus.c | 4356 ++++++++++++++++++++++++++++++++
+ gio/gkdbus.h | 203 ++
+ gio/gkdbusfakedaemon.c | 694 +++++
+ gio/gkdbusfakedaemon.h | 39 +
+ gio/gunixfdlist.h | 3 +
+ gio/meson.build | 19 +-
+ meson_options.txt | 10 +
+ 21 files changed, 6936 insertions(+), 351 deletions(-)
+ mode change 100644 => 100755 gio/gdbusconnection.c
+ mode change 100644 => 100755 gio/gdbusnamewatching.c
+ create mode 100755 gio/gkdbus.c
+ create mode 100644 gio/gkdbus.h
+ create mode 100644 gio/gkdbusfakedaemon.c
+ create mode 100644 gio/gkdbusfakedaemon.h
+
+diff --git a/gio/gdbusaddress.c b/gio/gdbusaddress.c
+index b73ff0d..e23dff8 100644
+--- a/gio/gdbusaddress.c
++++ b/gio/gdbusaddress.c
+@@ -42,6 +42,9 @@
+ #include "gdbusprivate.h"
+ #include "gstdio.h"
+
++#ifdef G_OS_UNIX
++#include "gkdbus.h"
++#endif
+ #ifdef HAVE_UNISTD_H
+ #include <unistd.h>
+ #endif
+@@ -550,8 +553,9 @@ out:
+
+ /* ---------------------------------------------------------------------------------------------------- */
+
+-static GIOStream *
++static GObject *
+ g_dbus_address_try_connect_one (const gchar *address_entry,
++ gboolean kdbus_okay,
+ gchar **out_guid,
+ GCancellable *cancellable,
+ GError **error);
+@@ -561,14 +565,15 @@ g_dbus_address_try_connect_one (const gchar *address_entry,
+ * point. That way we can implement a D-Bus transport over X11 without
+ * making libgio link to libX11...
+ */
+-static GIOStream *
++static GObject *
+ g_dbus_address_connect (const gchar *address_entry,
+ const gchar *transport_name,
++ gboolean kdbus_okay,
+ GHashTable *key_value_pairs,
+ GCancellable *cancellable,
+ GError **error)
+ {
+- GIOStream *ret;
++ GObject *ret;
+ GSocketConnectable *connectable;
+ const gchar *nonce_file;
+
+@@ -576,7 +581,35 @@ g_dbus_address_connect (const gchar *address_entry,
+ ret = NULL;
+ nonce_file = NULL;
+
+- if (g_strcmp0 (transport_name, "unix") == 0)
++ if (FALSE)
++ {
++ }
++#if defined (G_OS_UNIX) && defined (KDBUS)
++ else if (kdbus_okay && g_str_equal (transport_name, "kernel"))
++ {
++ GKDBusWorker *worker;
++ const gchar *path;
++
++ path = g_hash_table_lookup (key_value_pairs, "path");
++
++ if (path == NULL)
++ {
++ g_set_error (error, G_IO_ERROR, G_IO_ERROR_INVALID_ARGUMENT,
++ _("Error in address '%s' - the kernel transport requires a path"),
++ address_entry);
++ }
++ else
++ {
++ worker = _g_kdbus_worker_new (path, error);
++
++ if (worker == NULL)
++ return NULL;
++
++ return G_OBJECT (worker);
++ }
++ }
++#endif
++ else if (g_strcmp0 (transport_name, "unix") == 0)
+ {
+ const gchar *path;
+ const gchar *abstract;
+@@ -665,7 +698,7 @@ g_dbus_address_connect (const gchar *address_entry,
+ autolaunch_address = get_session_address_dbus_launch (error);
+ if (autolaunch_address != NULL)
+ {
+- ret = g_dbus_address_try_connect_one (autolaunch_address, NULL, cancellable, error);
++ ret = g_dbus_address_try_connect_one (autolaunch_address, kdbus_okay, NULL, cancellable, error);
+ g_free (autolaunch_address);
+ goto out;
+ }
+@@ -707,7 +740,7 @@ g_dbus_address_connect (const gchar *address_entry,
+ if (connection == NULL)
+ goto out;
+
+- ret = G_IO_STREAM (connection);
++ ret = G_OBJECT (connection);
+
+ if (nonce_file != NULL)
+ {
+@@ -763,7 +796,7 @@ g_dbus_address_connect (const gchar *address_entry,
+ }
+ fclose (f);
+
+- if (!g_output_stream_write_all (g_io_stream_get_output_stream (ret),
++ if (!g_output_stream_write_all (g_io_stream_get_output_stream (G_IO_STREAM (connection)),
+ nonce_contents,
+ 16,
+ NULL,
+@@ -783,13 +816,14 @@ g_dbus_address_connect (const gchar *address_entry,
+ return ret;
+ }
+
+-static GIOStream *
++static GObject *
+ g_dbus_address_try_connect_one (const gchar *address_entry,
++ gboolean kdbus_okay,
+ gchar **out_guid,
+ GCancellable *cancellable,
+ GError **error)
+ {
+- GIOStream *ret;
++ GObject *ret;
+ GHashTable *key_value_pairs;
+ gchar *transport_name;
+ const gchar *guid;
+@@ -806,6 +840,7 @@ g_dbus_address_try_connect_one (const gchar *address_entry,
+
+ ret = g_dbus_address_connect (address_entry,
+ transport_name,
++ kdbus_okay,
+ key_value_pairs,
+ cancellable,
+ error);
+@@ -969,7 +1004,25 @@ g_dbus_address_get_stream_sync (const gchar *address,
+ GCancellable *cancellable,
+ GError **error)
+ {
+- GIOStream *ret;
++ GObject *result;
++
++ result = g_dbus_address_get_stream_internal (address, FALSE, out_guid, cancellable, error);
++ g_assert (result == NULL || G_IS_IO_STREAM (result));
++
++ if (result)
++ return G_IO_STREAM (result);
++
++ return NULL;
++}
++
++GObject *
++g_dbus_address_get_stream_internal (const gchar *address,
++ gboolean kdbus_okay,
++ gchar **out_guid,
++ GCancellable *cancellable,
++ GError **error)
++{
++ GObject *ret;
+ gchar **addr_array;
+ guint n;
+ GError *last_error;
+@@ -996,6 +1049,7 @@ g_dbus_address_get_stream_sync (const gchar *address,
+
+ this_error = NULL;
+ ret = g_dbus_address_try_connect_one (addr,
++ kdbus_okay,
+ out_guid,
+ cancellable,
+ &this_error);
+@@ -1071,6 +1125,30 @@ out:
+ #endif
+ }
+
++static gchar *
++get_session_address_kdbus (void)
++{
++#ifdef G_OS_UNIX
++ gchar *ret = NULL;
++ gchar *bus;
++ GStatBuf buf;
++
++ bus = g_strdup_printf ("/sys/fs/kdbus/%d-user/bus", getuid());
++
++ /* if ENOENT, EPERM, etc., quietly don't use it */
++ if (g_stat (bus, &buf) < 0)
++ goto out;
++
++ ret = g_strconcat ("kernel:path=", bus, NULL);
++
++out:
++ g_free (bus);
++ return ret;
++#else
++ return NULL;
++#endif
++}
++
+ /* ---------------------------------------------------------------------------------------------------- */
+
+ #ifdef G_OS_UNIX
+@@ -1299,6 +1377,7 @@ g_dbus_address_get_for_bus_sync (GBusType bus_type,
+ if (G_UNLIKELY (_g_dbus_debug_address ()))
+ {
+ guint n;
++ gchar *s;
+ _g_dbus_debug_print_lock ();
+ s = _g_dbus_enum_to_string (G_TYPE_BUS_TYPE, bus_type);
+ g_print ("GDBus-debug:Address: In g_dbus_address_get_for_bus_sync() for bus type '%s'\n",
+@@ -1342,7 +1421,7 @@ g_dbus_address_get_for_bus_sync (GBusType bus_type,
+ * https://dbus.freedesktop.org/doc/dbus-specification.html#ftn.id-1.13.6.4.3.3
+ * or, on systems where /run is the same as /var/run, runstatedir:
+ * https://gitlab.freedesktop.org/dbus/dbus/-/merge_requests/209 */
+- ret = g_strdup ("unix:path=" GLIB_RUNSTATEDIR "/dbus/system_bus_socket");
++ ret = g_strdup ("kernel:path=/sys/fs/kdbus/0-system/bus;unix:path=" GLIB_RUNSTATEDIR "/dbus/system_bus_socket");
+ }
+ break;
+
+@@ -1354,7 +1433,11 @@ g_dbus_address_get_for_bus_sync (GBusType bus_type,
+
+ if (ret == NULL)
+ {
+- ret = get_session_address_platform_specific (&local_error);
++ ret = get_session_address_kdbus ();
++ if (ret == NULL)
++ ret = get_session_address_platform_specific (&local_error);
++ if (ret == NULL)
++ goto out;
+ }
+ break;
+
+diff --git a/gio/gdbusconnection.c b/gio/gdbusconnection.c
+old mode 100644
+new mode 100755
+index 1ee2ab4..960a83c
+--- a/gio/gdbusconnection.c
++++ b/gio/gdbusconnection.c
+@@ -116,6 +116,9 @@
+ #include "gmarshal-internal.h"
+
+ #ifdef G_OS_UNIX
++#ifdef KDBUS
++#include "gkdbus.h"
++#endif
+ #include "gunixconnection.h"
+ #include "gunixfdmessage.h"
+ #endif
+@@ -365,6 +368,12 @@ struct _GDBusConnection
+ */
+ GDBusWorker *worker;
+
++#ifdef G_OS_UNIX
++#ifdef KDBUS
++ GKDBusWorker *kdbus_worker;
++#endif
++#endif
++
+ /* If connected to a message bus, this contains the unique name assigned to
+ * us by the bus (e.g. ":1.42").
+ * Read-only after initable_init(), so it may be read if you either
+@@ -603,6 +612,7 @@ g_dbus_connection_dispose (GObject *object)
+
+ G_LOCK (message_bus_lock);
+ CONNECTION_LOCK (connection);
++
+ if (connection->worker != NULL)
+ {
+ _g_dbus_worker_stop (connection->worker);
+@@ -610,6 +620,17 @@ g_dbus_connection_dispose (GObject *object)
+ if (alive_connections != NULL)
+ g_warn_if_fail (g_hash_table_remove (alive_connections, connection));
+ }
++#ifdef G_OS_UNIX
++#ifdef KDBUS
++ else if (connection->kdbus_worker != NULL)
++ {
++ _g_kdbus_worker_stop (connection->kdbus_worker);
++ connection->kdbus_worker = NULL;
++ if (alive_connections != NULL)
++ g_warn_if_fail (g_hash_table_remove (alive_connections, connection));
++ }
++#endif
++#endif
+ else
+ {
+ if (alive_connections != NULL)
+@@ -1096,6 +1117,19 @@ g_dbus_connection_init (GDBusConnection *connection)
+ connection->filters = g_ptr_array_new ();
+ }
+
++#ifdef G_OS_UNIX
++#ifdef KDBUS
++gboolean
++_g_dbus_connection_is_kdbus (GDBusConnection *connection)
++{
++ if (connection->kdbus_worker)
++ return TRUE;
++ else
++ return FALSE;
++}
++#endif
++#endif
++
+ /**
+ * g_dbus_connection_get_stream:
+ * @connection: a #GDBusConnection
+@@ -1142,8 +1176,16 @@ g_dbus_connection_start_message_processing (GDBusConnection *connection)
+ if (!check_initialized (connection))
+ return;
+
+- g_assert (connection->worker != NULL);
+- _g_dbus_worker_unfreeze (connection->worker);
++ if (connection->worker)
++ _g_dbus_worker_unfreeze (connection->worker);
++#ifdef G_OS_UNIX
++#ifdef KDBUS
++ else if (connection->kdbus_worker)
++ _g_kdbus_worker_unfreeze (connection->kdbus_worker);
++#endif
++#endif
++ else
++ g_assert_not_reached ();
+ }
+
+ /**
+@@ -1334,11 +1376,22 @@ g_dbus_connection_flush_sync (GDBusConnection *connection,
+ if (!check_unclosed (connection, 0, error))
+ goto out;
+
+- g_assert (connection->worker != NULL);
+-
+- ret = _g_dbus_worker_flush_sync (connection->worker,
+- cancellable,
+- error);
++ if (connection->worker != NULL)
++ {
++ ret = _g_dbus_worker_flush_sync (connection->worker,
++ cancellable,
++ error);
++ }
++#ifdef G_OS_UNIX
++#ifdef KDBUS
++ else if (connection->kdbus_worker != NULL)
++ {
++ ret = _g_kdbus_worker_flush_sync (connection->kdbus_worker);
++ }
++#endif
++#endif
++ else
++ g_assert_not_reached();
+
+ out:
+ return ret;
+@@ -1438,7 +1491,7 @@ schedule_closed_unlocked (GDBusConnection *connection,
+ * of the thread that @connection was constructed in.
+ *
+ * This is an asynchronous method. When the operation is finished,
+- * @callback will be invoked in the
++ * @callback will be invoked in the
+ * [thread-default main context][g-main-context-push-thread-default]
+ * of the thread you are calling this method from. You can
+ * then call g_dbus_connection_close_finish() to get the result of the
+@@ -1457,108 +1510,763 @@ g_dbus_connection_close (GDBusConnection *connection,
+
+ g_return_if_fail (G_IS_DBUS_CONNECTION (connection));
+
+- /* do not use g_return_val_if_fail(), we want the memory barrier */
+- if (!check_initialized (connection))
+- return;
++ /* do not use g_return_val_if_fail(), we want the memory barrier */
++ if (!check_initialized (connection))
++ return;
++
++ task = g_task_new (connection, cancellable, callback, user_data);
++ g_task_set_source_tag (task, g_dbus_connection_close);
++ if (connection->worker)
++ {
++ _g_dbus_worker_close (connection->worker, task);
++ }
++#ifdef G_OS_UNIX
++#ifdef KDBUS
++ else if (connection->kdbus_worker)
++ {
++ _g_kdbus_worker_close (connection->kdbus_worker, task);
++ }
++#endif
++#endif
++ else
++ g_assert_not_reached();
++ g_object_unref (task);
++}
++
++/**
++ * g_dbus_connection_close_finish:
++ * @connection: a #GDBusConnection
++ * @res: a #GAsyncResult obtained from the #GAsyncReadyCallback passed
++ * to g_dbus_connection_close()
++ * @error: return location for error or %NULL
++ *
++ * Finishes an operation started with g_dbus_connection_close().
++ *
++ * Returns: %TRUE if the operation succeeded, %FALSE if @error is set
++ *
++ * Since: 2.26
++ */
++gboolean
++g_dbus_connection_close_finish (GDBusConnection *connection,
++ GAsyncResult *res,
++ GError **error)
++{
++ g_return_val_if_fail (G_IS_DBUS_CONNECTION (connection), FALSE);
++ g_return_val_if_fail (g_task_is_valid (res, connection), FALSE);
++ g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
++
++ return g_task_propagate_boolean (G_TASK (res), error);
++}
++
++typedef struct {
++ GMainLoop *loop;
++ GAsyncResult *result;
++} SyncCloseData;
++
++/* Can be called by any thread, without the connection lock */
++static void
++sync_close_cb (GObject *source_object,
++ GAsyncResult *res,
++ gpointer user_data)
++{
++ SyncCloseData *data = user_data;
++
++ data->result = g_object_ref (res);
++ g_main_loop_quit (data->loop);
++}
++
++/**
++ * g_dbus_connection_close_sync:
++ * @connection: a #GDBusConnection
++ * @cancellable: (nullable): a #GCancellable or %NULL
++ * @error: return location for error or %NULL
++ *
++ * Synchronously closes @connection. The calling thread is blocked
++ * until this is done. See g_dbus_connection_close() for the
++ * asynchronous version of this method and more details about what it
++ * does.
++ *
++ * Returns: %TRUE if the operation succeeded, %FALSE if @error is set
++ *
++ * Since: 2.26
++ */
++gboolean
++g_dbus_connection_close_sync (GDBusConnection *connection,
++ GCancellable *cancellable,
++ GError **error)
++{
++ gboolean ret;
++
++ g_return_val_if_fail (G_IS_DBUS_CONNECTION (connection), FALSE);
++ g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
++
++ ret = FALSE;
++
++ if (check_unclosed (connection, 0, error))
++ {
++ GMainContext *context;
++ SyncCloseData data;
++
++ context = g_main_context_new ();
++ g_main_context_push_thread_default (context);
++ data.loop = g_main_loop_new (context, TRUE);
++ data.result = NULL;
++
++ g_dbus_connection_close (connection, cancellable, sync_close_cb, &data);
++ g_main_loop_run (data.loop);
++ ret = g_dbus_connection_close_finish (connection, data.result, error);
++
++ g_object_unref (data.result);
++ g_main_loop_unref (data.loop);
++ g_main_context_pop_thread_default (context);
++ g_main_context_unref (context);
++ }
++
++ return ret;
++}
++
++/* ---------------------------------------------------------------------------------------------------- */
++
++/**
++ * g_dbus_request_name:
++ * @connection: a #GDBusConnection
++ * @name: well-known bus name (name to request)
++ * @flags: a set of flags from the GBusNameOwnerFlags enumeration
++ * @error: return location for error or %NULL
++ *
++ * Synchronously acquires name on the bus and returns status code
++ * from the #GBusRequestNameReplyFlags enumeration.
++ *
++ * The calling thread is blocked until a reply is received.
++ *
++ * Returns: status code or %G_BUS_REQUEST_NAME_FLAGS_ERROR
++ * if @error is set.
++ *
++ * Since: 2.44
++ */
++GBusRequestNameReplyFlags
++g_dbus_request_name (GDBusConnection *connection,
++ const gchar *name,
++ GBusNameOwnerFlags flags,
++ GError **error)
++{
++ GVariant *result;
++ guint32 request_name_reply;
++
++ g_return_val_if_fail (G_IS_DBUS_CONNECTION (connection), G_BUS_RELEASE_NAME_FLAGS_ERROR);
++ g_return_val_if_fail (g_dbus_is_name (name) && !g_dbus_is_unique_name (name), G_BUS_RELEASE_NAME_FLAGS_ERROR);
++ g_return_val_if_fail (error == NULL || *error == NULL, G_BUS_RELEASE_NAME_FLAGS_ERROR);
++
++#ifdef G_OS_UNIX
++#ifdef KDBUS
++ if (connection->kdbus_worker)
++ return _g_kdbus_RequestName (connection->kdbus_worker, name, flags, error);
++#endif
++#endif
++
++ result = g_dbus_connection_call_sync (connection, "org.freedesktop.DBus", "/org/freedesktop/DBus",
++ "org.freedesktop.DBus", "RequestName",
++ g_variant_new ("(su)", name, flags), G_VARIANT_TYPE ("(u)"),
++ G_DBUS_CALL_FLAGS_NONE, -1, NULL, error);
++ if (result != NULL)
++ {
++ g_variant_get (result, "(u)", &request_name_reply);
++ g_variant_unref (result);
++ }
++ else
++ request_name_reply = G_BUS_REQUEST_NAME_FLAGS_ERROR;
++
++ return (GBusRequestNameReplyFlags) request_name_reply;
++}
++
++/**
++ * g_dbus_release_name:
++ * @connection: a #GDBusConnection
++ * @name: well-known bus name (name to release)
++ * @error: return location for error or %NULL
++ *
++ * Synchronously releases name on the bus and returns status code
++ * from the #GBusReleaseNameReplyFlags enumeration.
++ *
++ * The calling thread is blocked until a reply is received.
++ *
++ * Returns: status code or %G_BUS_RELEASE_NAME_FLAGS_ERROR
++ * if @error is set.
++ *
++ * Since: 2.44
++ */
++GBusReleaseNameReplyFlags
++g_dbus_release_name (GDBusConnection *connection,
++ const gchar *name,
++ GError **error)
++{
++ GVariant *result;
++ guint32 release_name_reply;
++
++ g_return_val_if_fail (G_IS_DBUS_CONNECTION (connection), G_BUS_RELEASE_NAME_FLAGS_ERROR);
++ g_return_val_if_fail (g_dbus_is_name (name) && !g_dbus_is_unique_name (name), G_BUS_RELEASE_NAME_FLAGS_ERROR);
++ g_return_val_if_fail (error == NULL || *error == NULL, G_BUS_RELEASE_NAME_FLAGS_ERROR);
++
++#ifdef G_OS_UNIX
++#ifdef KDBUS
++ if (connection->kdbus_worker)
++ return _g_kdbus_ReleaseName (connection->kdbus_worker, name, error);
++#endif
++#endif
++
++ result = g_dbus_connection_call_sync (connection, "org.freedesktop.DBus", "/org/freedesktop/DBus",
++ "org.freedesktop.DBus", "ReleaseName",
++ g_variant_new ("(s)", name), G_VARIANT_TYPE ("(u)"),
++ G_DBUS_CALL_FLAGS_NONE, -1, NULL, error);
++ if (result != NULL)
++ {
++ g_variant_get (result, "(u)", &release_name_reply);
++ g_variant_unref (result);
++ }
++ else
++ release_name_reply = G_BUS_RELEASE_NAME_FLAGS_ERROR;
++
++ return (GBusReleaseNameReplyFlags) release_name_reply;
++}
++
++/**
++ * g_dbus_add_match:
++ * @connection: a #GDBusConnection
++ * @match_rule: match rule to add to the @connection
++ * @error: return location for error or %NULL
++ *
++ * Synchronously adds a match rule to match messages.
++ *
++ * The calling thread is blocked until a reply is received.
++ *
++ * Returns: %TRUE if the operation succeeded, %FALSE
++ * if @error is set.
++ *
++ * Since: 2.44
++ */
++gboolean
++g_dbus_add_match (GDBusConnection *connection,
++ const gchar *match_rule,
++ GError **error)
++{
++ GVariant *result;
++ gboolean ret;
++
++ g_return_val_if_fail (G_IS_DBUS_CONNECTION (connection), FALSE);
++ g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
++
++ result = NULL;
++ ret = FALSE;
++
++ if (match_rule[0] == '-')
++ return ret;
++
++#ifdef G_OS_UNIX
++#ifdef KDBUS
++ if (connection->kdbus_worker)
++ return _g_kdbus_AddMatch (connection->kdbus_worker, match_rule, error);
++#endif
++#endif
++
++ result = g_dbus_connection_call_sync (connection, "org.freedesktop.DBus", "/org/freedesktop/DBus",
++ "org.freedesktop.DBus", "AddMatch",
++ g_variant_new ("(s)", match_rule), NULL,
++ G_DBUS_CALL_FLAGS_NONE, -1, NULL, error);
++ if (result != NULL)
++ {
++ ret = TRUE;
++ g_variant_unref (result);
++ }
++
++ return ret;
++}
++
++/**
++ * g_dbus_remove_match:
++ * @connection: a #GDBusConnection
++ * @match_rule: match rule to remove from the @connection
++ * @error: return location for error or %NULL
++ *
++ * Synchronously removes the first rule that matches.
++ *
++ * The calling thread is blocked until a reply is received.
++ *
++ * Returns: %TRUE if the operation succeeded, %FALSE
++ * if @error is set.
++ *
++ * Since: 2.44
++ */
++gboolean
++g_dbus_remove_match (GDBusConnection *connection,
++ const gchar *match_rule,
++ GError **error)
++{
++ GVariant *result;
++ gboolean ret;
++
++ g_return_val_if_fail (G_IS_DBUS_CONNECTION (connection), FALSE);
++ g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
++
++ result = NULL;
++ ret = FALSE;
++
++ if (match_rule[0] == '-')
++ return ret;
++
++#ifdef G_OS_UNIX
++#ifdef KDBUS
++ if (connection->kdbus_worker)
++ return _g_kdbus_RemoveMatch (connection->kdbus_worker, match_rule, error);
++#endif
++#endif
++
++ result = g_dbus_connection_call_sync (connection, "org.freedesktop.DBus", "/org/freedesktop/DBus",
++ "org.freedesktop.DBus", "RemoveMatch",
++ g_variant_new ("(s)", match_rule), NULL,
++ G_DBUS_CALL_FLAGS_NONE, -1, NULL, error);
++ if (result != NULL)
++ {
++ ret = TRUE;
++ g_variant_unref (result);
++ }
++
++ return ret;
++}
++
++/**
++ * g_dbus_get_bus_id:
++ * @connection: a #GDBusConnection
++ * @error: return location for error or %NULL
++ *
++ * Synchronously returns the unique ID of the bus.
++ *
++ * The calling thread is blocked until a reply is received.
++ *
++ * Returns: the unique ID of the bus or %NULL if @error is set.
++ * Free with g_free().
++ *
++ * Since: 2.44
++ */
++gchar *
++g_dbus_get_bus_id (GDBusConnection *connection,
++ GError **error)
++{
++ GVariant *result;
++ gchar *bus_id;
++
++ g_return_val_if_fail (G_IS_DBUS_CONNECTION (connection), NULL);
++ g_return_val_if_fail (error == NULL || *error == NULL, NULL);
++
++ result = NULL;
++ bus_id = NULL;
++
++#ifdef G_OS_UNIX
++#ifdef KDBUS
++ if (connection->kdbus_worker)
++ return _g_kdbus_GetBusId (connection->kdbus_worker, error);
++#endif
++#endif
++
++ result = g_dbus_connection_call_sync (connection, "org.freedesktop.DBus", "/",
++ "org.freedesktop.DBus", "GetId",
++ NULL, G_VARIANT_TYPE ("(s)"),
++ G_DBUS_CALL_FLAGS_NONE, -1, NULL, error);
++ if (result != NULL)
++ {
++ g_variant_get (result, "(s)", &bus_id);
++ g_variant_unref (result);
++ }
++
++ return bus_id;
++}
++
++typedef enum
++{
++ LIST_NAMES,
++ LIST_ACTIVATABLE_NAMES,
++ LIST_QUEUED_OWNERS
++} GDBusListNameType;
++
++static gchar **
++_g_dbus_get_list_internal (GDBusConnection *connection,
++ const gchar *name,
++ GDBusListNameType list_name_type,
++ GError **error)
++{
++ gchar **strv;
++ GVariant *result;
++ GVariantIter *iter;
++ gchar *str;
++ gsize n, i;
++
++ result = NULL;
++ strv = NULL;
++
++ if (list_name_type == LIST_QUEUED_OWNERS)
++ {
++#ifdef G_OS_UNIX
++#ifdef KDBUS
++ if (connection->kdbus_worker)
++ return _g_kdbus_GetListQueuedOwners (connection->kdbus_worker, name, error);
++#endif
++#endif
++
++ result = g_dbus_connection_call_sync (connection, "org.freedesktop.DBus", "/",
++ "org.freedesktop.DBus", "ListQueuedOwners",
++ g_variant_new ("(s)", name), G_VARIANT_TYPE ("(as)"),
++ G_DBUS_CALL_FLAGS_NONE, -1, NULL, error);
++ }
++ else
++ {
++ gchar *method_name;
++
++ if (list_name_type == LIST_NAMES)
++ method_name = "ListNames";
++ else
++ method_name = "ListActivatableNames";
++
++#ifdef G_OS_UNIX
++#ifdef KDBUS
++ if (connection->kdbus_worker)
++ return _g_kdbus_GetListNames (connection->kdbus_worker, list_name_type, error);
++#endif
++#endif
++
++ result = g_dbus_connection_call_sync (connection, "org.freedesktop.DBus", "/",
++ "org.freedesktop.DBus", method_name,
++ NULL, G_VARIANT_TYPE ("(as)"),
++ G_DBUS_CALL_FLAGS_NONE, -1, NULL, error);
++ }
++
++ if (result != NULL)
++ {
++ g_variant_get (result, "(as)", &iter);
++ n = g_variant_iter_n_children (iter);
++ strv = g_new (gchar *, n + 1);
++
++ i = 0;
++ while (g_variant_iter_loop (iter, "s", &str))
++ {
++ strv[i] = g_strdup (str);
++ i++;
++ }
++ strv[i] = NULL;
++
++ g_variant_iter_free (iter);
++ g_variant_unref (result);
++ }
++
++ return strv;
++}
++
++/**
++ * g_dbus_get_list_names:
++ * @connection: a #GDBusConnection
++ * @error: return location for error or %NULL
++ *
++ * Synchronously returns a list of all currently-owned names on the bus.
++ *
++ * The calling thread is blocked until a reply is received.
++ *
++ * Returns: a list of all currently-owned names on the bus or %NULL if
++ * @error is set. Free with g_strfreev().
++ *
++ * Since: 2.44
++ */
++gchar **
++g_dbus_get_list_names (GDBusConnection *connection,
++ GError **error)
++{
++ gchar **strv;
++
++ g_return_val_if_fail (G_IS_DBUS_CONNECTION (connection), NULL);
++ g_return_val_if_fail (error == NULL || *error == NULL, NULL);
++
++ strv = _g_dbus_get_list_internal (connection, NULL, LIST_NAMES, error);
++
++ return strv;
++}
++
++/**
++ * g_dbus_get_list_activatable_names:
++ * @connection: a #GDBusConnection
++ * @error: return location for error or %NULL
++ *
++ * Synchronously returns a list of all names that can be activated on the bus.
++ *
++ * The calling thread is blocked until a reply is received.
++ *
++ * Returns: a list of all names that can be activated on the bus or %NULL if
++ * @error is set. Free with g_strfreev().
++ *
++ * Since: 2.44
++ */
++gchar **
++g_dbus_get_list_activatable_names (GDBusConnection *connection,
++ GError **error)
++{
++ gchar **strv;
++
++ g_return_val_if_fail (G_IS_DBUS_CONNECTION (connection), NULL);
++ g_return_val_if_fail (error == NULL || *error == NULL, NULL);
++
++ strv = _g_dbus_get_list_internal (connection, NULL, LIST_ACTIVATABLE_NAMES, error);
++
++ return strv;
++}
++
++/**
++ * g_dbus_get_list_queued_names:
++ * @connection: a #GDBusConnection
++ * @name: a unique or well-known bus name
++ * @error: return location for error or %NULL
++ *
++ * Synchronously returns the unique bus names of connections currently queued
++ * for the @name.
++ *
++ * If @name contains a value not compatible with the D-Bus syntax and naming
++ * conventions for bus names, the operation returns %NULL and @error is set.
++ *
++ * The calling thread is blocked until a reply is received.
++ *
++ * Returns: the unique bus names of connections currently queued for the @name
++ * or %NULL if @error is set. Free with g_strfreev().
++ *
++ * Since: 2.44
++ */
++gchar **
++g_dbus_get_list_queued_owners (GDBusConnection *connection,
++ const gchar *name,
++ GError **error)
++{
++ gchar **strv;
++
++ g_return_val_if_fail (G_IS_DBUS_CONNECTION (connection), NULL);
++ g_return_val_if_fail (name == NULL || g_dbus_is_name (name), NULL);
++ g_return_val_if_fail (error == NULL || *error == NULL, NULL);
++
++ strv = _g_dbus_get_list_internal (connection, name, LIST_QUEUED_OWNERS, error);
++
++ return strv;
++}
++
++/**
++ * g_dbus_get_name_owner:
++ * @connection: a #GDBusConnection
++ * @name: well-known bus name to get the owner of
++ * @error: return location for error or %NULL
++ *
++ * Synchronously returns the unique connection name of the primary owner of
++ * the name given. If the requested name doesn't have an owner, an @error is
++ * returned.
++ *
++ * If @name contains a value not compatible with the D-Bus syntax and naming
++ * conventions for bus names, the operation returns %NULL and @error is set.
++ *
++ * The calling thread is blocked until a reply is received.
++ *
++ * Returns: the unique connection name of the primary owner of the
++ * name given. If the requested name doesn't have an owner, function
++ * returns %NULL and @error is set. Free with g_free().
++ *
++ * Since: 2.44
++ */
++gchar *
++g_dbus_get_name_owner (GDBusConnection *connection,
++ const gchar *name,
++ GError **error)
++{
++ GVariant *result;
++ gchar *name_owner;
++
++ g_return_val_if_fail (G_IS_DBUS_CONNECTION (connection), NULL);
++ g_return_val_if_fail (name == NULL || g_dbus_is_name (name), NULL);
++ g_return_val_if_fail (error == NULL || *error == NULL, NULL);
++
++ name_owner = NULL;
++ result = NULL;
++
++#ifdef G_OS_UNIX
++#ifdef KDBUS
++ if (connection->kdbus_worker)
++ return _g_kdbus_GetNameOwner (connection->kdbus_worker, name, error);
++#endif
++#endif
++
++ result = g_dbus_connection_call_sync (connection, "org.freedesktop.DBus", "/",
++ "org.freedesktop.DBus", "GetNameOwner",
++ g_variant_new ("(s)", name), G_VARIANT_TYPE ("(s)"),
++ G_DBUS_CALL_FLAGS_NONE, -1, NULL, error);
++ if (result != NULL)
++ {
++ g_variant_get (result, "(s)", &name_owner);
++ g_variant_unref (result);
++ }
++ else
++ name_owner = NULL;
++
++ return name_owner;
++}
++
++/**
++ * g_dbus_get_connection_pid:
++ * @connection: a #GDBusConnection
++ * @name: a unique or well-known bus name of the connection to query
++ * @error: return location for error or %NULL
++ *
++ * Synchronously returns the Unix process ID of the process connected to the
++ * bus. If unable to determine it, an @error is returned.
++ *
++ * If @name contains a value not compatible with the D-Bus syntax and naming
++ * conventions for bus names, the operation returns -1 and @error is set.
++ *
++ * The calling thread is blocked until a reply is received.
++ *
++ * Returns: the Unix process ID of the process connected to the bus or -1
++ * if @error is set.
++ *
++ * Since: 2.44
++ */
++pid_t
++g_dbus_get_connection_pid (GDBusConnection *connection,
++ const gchar *name,
++ GError **error)
++{
++ GVariant *result;
++ pid_t pid;
++
++ g_return_val_if_fail (G_IS_DBUS_CONNECTION (connection), -1);
++ g_return_val_if_fail (name == NULL || g_dbus_is_name (name), -1);
++ g_return_val_if_fail (error == NULL || *error == NULL, -1);
++
++ result = NULL;
++ pid = -1;
++
++#ifdef G_OS_UNIX
++#ifdef KDBUS
++ if (connection->kdbus_worker)
++ return _g_kdbus_GetConnectionUnixProcessID (connection->kdbus_worker, name, error);
++#endif
++#endif
+
+- g_assert (connection->worker != NULL);
++ result = g_dbus_connection_call_sync (connection, "org.freedesktop.DBus", "/",
++ "org.freedesktop.DBus", "GetConnectionUnixProcessID",
++ g_variant_new ("(s)", name), G_VARIANT_TYPE ("(u)"),
++ G_DBUS_CALL_FLAGS_NONE, -1, NULL, error);
++ if (result != NULL)
++ {
++ g_variant_get (result, "(u)", &pid);
++ g_variant_unref (result);
++ }
+
+- task = g_task_new (connection, cancellable, callback, user_data);
+- g_task_set_source_tag (task, g_dbus_connection_close);
+- _g_dbus_worker_close (connection->worker, task);
+- g_object_unref (task);
++ return pid;
+ }
+
+ /**
+- * g_dbus_connection_close_finish:
++ * g_dbus_get_connection_uid:
+ * @connection: a #GDBusConnection
+- * @res: a #GAsyncResult obtained from the #GAsyncReadyCallback passed
+- * to g_dbus_connection_close()
++ * @name: a unique or well-known bus name of the connection to query
+ * @error: return location for error or %NULL
+ *
+- * Finishes an operation started with g_dbus_connection_close().
++ * Synchronously returns the Unix user ID of the process connected to the
++ * bus. If unable to determine it, an @error is returned.
+ *
+- * Returns: %TRUE if the operation succeeded, %FALSE if @error is set
++ * If @name contains a value not compatible with the D-Bus syntax and naming
++ * conventions for bus names, the operation returns -1 and @error is set.
+ *
+- * Since: 2.26
++ * The calling thread is blocked until a reply is received.
++ *
++ * Returns: the Unix user ID of the process connected to the bus or -1
++ * if @error is set.
++ *
++ * Since: 2.44
+ */
+-gboolean
+-g_dbus_connection_close_finish (GDBusConnection *connection,
+- GAsyncResult *res,
+- GError **error)
++uid_t
++g_dbus_get_connection_uid (GDBusConnection *connection,
++ const gchar *name,
++ GError **error)
+ {
+- g_return_val_if_fail (G_IS_DBUS_CONNECTION (connection), FALSE);
+- g_return_val_if_fail (g_task_is_valid (res, connection), FALSE);
+- g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
++ GVariant *result;
++ uid_t uid;
+
+- return g_task_propagate_boolean (G_TASK (res), error);
+-}
++ g_return_val_if_fail (G_IS_DBUS_CONNECTION (connection), -1);
++ g_return_val_if_fail (name == NULL || g_dbus_is_name (name), -1);
++ g_return_val_if_fail (error == NULL || *error == NULL, -1);
+
+-typedef struct {
+- GMainLoop *loop;
+- GAsyncResult *result;
+-} SyncCloseData;
++ result = NULL;
++ uid = -1;
+
+-/* Can be called by any thread, without the connection lock */
+-static void
+-sync_close_cb (GObject *source_object,
+- GAsyncResult *res,
+- gpointer user_data)
+-{
+- SyncCloseData *data = user_data;
++#ifdef G_OS_UNIX
++#ifdef KDBUS
++ if (connection->kdbus_worker)
++ return _g_kdbus_GetConnectionUnixUser (connection->kdbus_worker, name, error);
++#endif
++#endif
+
+- data->result = g_object_ref (res);
+- g_main_loop_quit (data->loop);
++ result = g_dbus_connection_call_sync (connection, "org.freedesktop.DBus", "/",
++ "org.freedesktop.DBus", "GetConnectionUnixUser",
++ g_variant_new ("(s)", name), G_VARIANT_TYPE ("(u)"),
++ G_DBUS_CALL_FLAGS_NONE, -1, NULL, error);
++ if (result != NULL)
++ {
++ g_variant_get (result, "(u)", &uid);
++ g_variant_unref (result);
++ }
++
++ return uid;
+ }
+
+ /**
+- * g_dbus_connection_close_sync:
++ * g_dbus_start_service_by_name:
+ * @connection: a #GDBusConnection
+- * @cancellable: (nullable): a #GCancellable or %NULL
++ * @name: name of the service to start
++ * @flags: (currently not used)
+ * @error: return location for error or %NULL
+ *
+- * Synchronously closes @connection. The calling thread is blocked
+- * until this is done. See g_dbus_connection_close() for the
+- * asynchronous version of this method and more details about what it
+- * does.
++ * Synchronously tries to launch the executable associated
++ * with a @name.
+ *
+- * Returns: %TRUE if the operation succeeded, %FALSE if @error is set
++ * The calling thread is blocked until a reply is received.
+ *
+- * Since: 2.26
++ * Returns: status code or %G_BUS_START_SERVICE_REPLY_ERROR
++ * if @error is set.
++ *
++ * Since: 2.44
+ */
+-gboolean
+-g_dbus_connection_close_sync (GDBusConnection *connection,
+- GCancellable *cancellable,
++GBusStartServiceReplyFlags
++g_dbus_start_service_by_name (GDBusConnection *connection,
++ const gchar *name,
++ guint32 flags,
+ GError **error)
+ {
+- gboolean ret;
+-
+- g_return_val_if_fail (G_IS_DBUS_CONNECTION (connection), FALSE);
+- g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
+-
+- ret = FALSE;
++ GVariant *result;
++ guint32 ret;
+
+- if (check_unclosed (connection, 0, error))
+- {
+- GMainContext *context;
+- SyncCloseData data;
++ g_return_val_if_fail (G_IS_DBUS_CONNECTION (connection), -1);
++ g_return_val_if_fail (name == NULL || g_dbus_is_name (name), -1);
++ g_return_val_if_fail (error == NULL || *error == NULL, -1);
+
+- context = g_main_context_new ();
+- g_main_context_push_thread_default (context);
+- data.loop = g_main_loop_new (context, TRUE);
+- data.result = NULL;
++ result = NULL;
++ ret = G_BUS_START_SERVICE_REPLY_ERROR;
+
+- g_dbus_connection_close (connection, cancellable, sync_close_cb, &data);
+- g_main_loop_run (data.loop);
+- ret = g_dbus_connection_close_finish (connection, data.result, error);
++#ifdef G_OS_UNIX
++#ifdef KDBUS
++ if (connection->kdbus_worker)
++ return _g_kdbus_StartServiceByName (connection->kdbus_worker, name, flags, NULL, error);
++#endif
++#endif
+
+- g_object_unref (data.result);
+- g_main_loop_unref (data.loop);
+- g_main_context_pop_thread_default (context);
+- g_main_context_unref (context);
++ result = g_dbus_connection_call_sync (connection, "org.freedesktop.DBus", "/",
++ "org.freedesktop.DBus", "StartServiceByName",
++ g_variant_new ("(su)", name, flags), G_VARIANT_TYPE ("(u)"),
++ G_DBUS_CALL_FLAGS_NONE, -1, NULL, error);
++ if (result != NULL)
++ {
++ g_variant_get (result, "(u)", &ret);
++ g_variant_unref (result);
+ }
+
+- return ret;
++ return (GBusStartServiceReplyFlags) ret;
+ }
+
+ /* ---------------------------------------------------------------------------------------------------- */
+@@ -1601,11 +2309,13 @@ g_dbus_connection_send_message_unlocked (GDBusConnection *connection,
+ GDBusMessage *message,
+ GDBusSendMessageFlags flags,
+ guint32 *out_serial,
+- GError **error)
++ GError **error,
++ gint timeout_msec)
+ {
+ guchar *blob;
+ gsize blob_size;
+ guint32 serial_to_use;
++ gboolean ret;
+
+ CONNECTION_ENSURE_LOCK (connection);
+
+@@ -1614,6 +2324,9 @@ g_dbus_connection_send_message_unlocked (GDBusConnection *connection,
+
+ /* TODO: check all necessary headers are present */
+
++ ret = FALSE;
++ blob = NULL;
++
+ if (out_serial != NULL)
+ *out_serial = 0;
+
+@@ -1625,33 +2338,41 @@ g_dbus_connection_send_message_unlocked (GDBusConnection *connection,
+ if (!check_unclosed (connection,
+ (flags & SEND_MESSAGE_FLAGS_INITIALIZING) ? MAY_BE_UNINITIALIZED : 0,
+ error))
+- return FALSE;
++ goto out;
+
+- blob = g_dbus_message_to_blob (message,
+- &blob_size,
+- connection->capabilities,
+- error);
+- if (blob == NULL)
+- return FALSE;
++ if (!(flags & G_DBUS_SEND_MESSAGE_FLAGS_PRESERVE_SERIAL))
++ g_dbus_message_set_serial (message, ++connection->last_serial);
+
+- if (flags & G_DBUS_SEND_MESSAGE_FLAGS_PRESERVE_SERIAL)
+- serial_to_use = g_dbus_message_get_serial (message);
+- else
+- serial_to_use = ++connection->last_serial; /* TODO: handle overflow */
++ serial_to_use = g_dbus_message_get_serial (message);
+
+- switch (blob[0])
++ /*
++ * serializes message to a blob
++ */
++ if (connection->worker)
+ {
+- case 'l':
+- ((guint32 *) blob)[2] = GUINT32_TO_LE (serial_to_use);
+- break;
+- case 'B':
+- ((guint32 *) blob)[2] = GUINT32_TO_BE (serial_to_use);
+- break;
+- default:
+- g_assert_not_reached ();
+- break;
++ blob = g_dbus_message_to_blob (message,
++ &blob_size,
++ connection->capabilities,
++ error);
++ if (blob == NULL)
++ goto out;
++
++ switch (blob[0])
++ {
++ case 'l':
++ ((guint32 *) blob)[2] = GUINT32_TO_LE (serial_to_use);
++ break;
++ case 'B':
++ ((guint32 *) blob)[2] = GUINT32_TO_BE (serial_to_use);
++ break;
++ default:
++ g_assert_not_reached ();
++ break;
++ }
+ }
+
++ g_dbus_message_lock (message);
++
+ #if 0
+ g_printerr ("Writing message of %" G_GSIZE_FORMAT " bytes (serial %d) on %p:\n",
+ blob_size, serial_to_use, connection);
+@@ -1674,17 +2395,32 @@ g_dbus_connection_send_message_unlocked (GDBusConnection *connection,
+ g_thread_self (),
+ GUINT_TO_POINTER (serial_to_use));
+
+- if (!(flags & G_DBUS_SEND_MESSAGE_FLAGS_PRESERVE_SERIAL))
+- g_dbus_message_set_serial (message, serial_to_use);
++ ret = TRUE;
+
+- g_dbus_message_lock (message);
++ if (connection->worker)
++ {
++ _g_dbus_worker_send_message (connection->worker,
++ message,
++ (gchar*) blob,
++ blob_size);
++ }
++#ifdef G_OS_UNIX
++#ifdef KDBUS
++ else if (connection->kdbus_worker)
++ {
++ ret = _g_kdbus_worker_send_message (connection->kdbus_worker, message, timeout_msec, error);
++ }
++#endif
++#endif
++ else
++ g_assert_not_reached ();
+
+- _g_dbus_worker_send_message (connection->worker,
+- message,
+- (gchar*) blob, /* transfer ownership */
+- blob_size);
++ blob = NULL; /* since _g_dbus_worker_send_message() steals the blob */
+
+- return TRUE;
++ out:
++ g_free (blob);
++
++ return ret;
+ }
+
+ /**
+@@ -1738,7 +2474,7 @@ g_dbus_connection_send_message (GDBusConnection *connection,
+ g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
+
+ CONNECTION_LOCK (connection);
+- ret = g_dbus_connection_send_message_unlocked (connection, message, flags, (guint32 *) out_serial, error);
++ ret = g_dbus_connection_send_message_unlocked (connection, message, flags, (guint32 *) out_serial, error, -1);
+ CONNECTION_UNLOCK (connection);
+ return ret;
+ }
+@@ -1921,9 +2657,6 @@ g_dbus_connection_send_message_with_reply_unlocked (GDBusConnection *connect
+ if (out_serial == NULL)
+ out_serial = &serial;
+
+- if (timeout_msec == -1)
+- timeout_msec = 25 * 1000;
+-
+ data = g_slice_new0 (SendMessageData);
+ task = g_task_new (connection, cancellable, callback, user_data);
+ g_task_set_source_tag (task,
+@@ -1936,7 +2669,7 @@ g_dbus_connection_send_message_with_reply_unlocked (GDBusConnection *connect
+ return;
+ }
+
+- if (!g_dbus_connection_send_message_unlocked (connection, message, flags, out_serial, &error))
++ if (!g_dbus_connection_send_message_unlocked (connection, message, flags, out_serial, &error, timeout_msec))
+ {
+ g_task_return_error (task, error);
+ g_object_unref (task);
+@@ -1952,9 +2685,16 @@ g_dbus_connection_send_message_with_reply_unlocked (GDBusConnection *connect
+ g_object_unref);
+ }
+
+- if (timeout_msec != G_MAXINT)
++ if (timeout_msec != G_MAXINT
++#ifdef G_OS_UNIX
++#ifdef KDBUS
++ /* Userspace timeouts unnecessary on unix/kdbus - kdbus handles timeouts. */
++ && !connection->kdbus_worker
++#endif
++#endif
++ )
+ {
+- data->timeout_source = g_timeout_source_new (timeout_msec);
++ data->timeout_source = g_timeout_source_new (timeout_msec == -1 ? DBUS_DEFAULT_TIMEOUT_MSEC : timeout_msec);
+ g_source_set_static_name (data->timeout_source, "[gio] send_message_with_reply_unlocked");
+ g_task_attach_source (task, data->timeout_source,
+ (GSourceFunc) send_message_with_reply_timeout_cb);
+@@ -1996,7 +2736,7 @@ g_dbus_connection_send_message_with_reply_unlocked (GDBusConnection *connect
+ * the operation fails with %G_IO_ERROR_INVALID_ARGUMENT.
+ *
+ * This is an asynchronous method. When the operation is finished, @callback
+- * will be invoked in the
++ * will be invoked in the
+ * [thread-default main context][g-main-context-push-thread-default]
+ * of the thread you are calling this method from. You can then call
+ * g_dbus_connection_send_message_with_reply_finish() to get the result of the operation.
+@@ -2158,32 +2898,102 @@ g_dbus_connection_send_message_with_reply_sync (GDBusConnection *connecti
+ g_return_val_if_fail (timeout_msec >= 0 || timeout_msec == -1, NULL);
+ g_return_val_if_fail (error == NULL || *error == NULL, NULL);
+
+- data.res = NULL;
+- data.context = g_main_context_new ();
+- data.loop = g_main_loop_new (data.context, FALSE);
++ if (connection->worker)
++ {
++ data.res = NULL;
++ data.context = g_main_context_new ();
++ data.loop = g_main_loop_new (data.context, FALSE);
+
+- g_main_context_push_thread_default (data.context);
++ g_main_context_push_thread_default (data.context);
+
+- g_dbus_connection_send_message_with_reply (connection,
+- message,
+- flags,
+- timeout_msec,
+- out_serial,
+- cancellable,
+- (GAsyncReadyCallback) send_message_with_reply_sync_cb,
+- &data);
+- g_main_loop_run (data.loop);
+- reply = g_dbus_connection_send_message_with_reply_finish (connection,
+- data.res,
+- error);
++ g_dbus_connection_send_message_with_reply (connection,
++ message,
++ flags,
++ timeout_msec,
++ out_serial,
++ cancellable,
++ (GAsyncReadyCallback) send_message_with_reply_sync_cb,
++ &data);
++ g_main_loop_run (data.loop);
++ reply = g_dbus_connection_send_message_with_reply_finish (connection,
++ data.res,
++ error);
++
++ g_main_context_pop_thread_default (data.context);
++
++ g_main_context_unref (data.context);
++ g_main_loop_unref (data.loop);
++ if (data.res)
++ g_object_unref (data.res);
++ }
++#ifdef G_OS_UNIX
++#ifdef KDBUS
++ else if (connection->kdbus_worker)
++ {
++ /* kdbus supports blocking synchronous calls, so let's use them instead of mainloops */
++
++ volatile guint32 serial;
++ guint32 serial_to_use;
++
++ reply = NULL;
++
++ CONNECTION_LOCK (connection);
++
++ if (out_serial == NULL)
++ out_serial = &serial;
++ else
++ *out_serial = 0;
++
++ /*
++ * Check that we never actually send a message if the GCancellable
++ * is already cancelled
++ */
++ if (g_cancellable_is_cancelled (cancellable))
++ {
++ g_set_error_literal (error,
++ G_IO_ERROR,
++ G_IO_ERROR_CANCELLED,
++ _("Operation was cancelled"));
++ CONNECTION_UNLOCK (connection);
++ goto out;
++ }
++
++ if (!check_unclosed (connection,
++ (flags & SEND_MESSAGE_FLAGS_INITIALIZING) ? MAY_BE_UNINITIALIZED : 0,
++ error))
++ {
++ CONNECTION_UNLOCK (connection);
++ goto out;
++ }
++
++ if (!(flags & G_DBUS_SEND_MESSAGE_FLAGS_PRESERVE_SERIAL))
++ g_dbus_message_set_serial (message, ++connection->last_serial);
++
++ serial_to_use = g_dbus_message_get_serial (message);
+
+- g_main_context_pop_thread_default (data.context);
++ g_dbus_message_lock (message);
++
++ if (out_serial != NULL)
++ *out_serial = serial_to_use;
++
++ CONNECTION_UNLOCK (connection);
+
+- g_main_context_unref (data.context);
+- g_main_loop_unref (data.loop);
+- if (data.res)
+- g_object_unref (data.res);
++ /* Reference is still kept for the connection, so there is no worry
++ * that it will be freed. Same for connection->kdbus_worker - by reference
++ * from the connection. Inside _g_kdbus_worker_send_message_sync only
++ * initialized-once, read-only fields from kdbus_worker are used, except
++ * 'matches', which now has got its own mutex.
++ */
++ _g_kdbus_worker_send_message_sync (connection->kdbus_worker, message,
++ &reply, timeout_msec, cancellable, error);
++
++ }
++#endif /* G_OS_UNIX */
++#endif /* G_OS_UNIX */
++ else
++ g_assert_not_reached ();
+
++out:
+ return reply;
+ }
+
+@@ -2252,8 +3062,7 @@ free_filter_list (FilterData **filters)
+
+ /* Called in GDBusWorker's thread - we must not block - with no lock held */
+ static void
+-on_worker_message_received (GDBusWorker *worker,
+- GDBusMessage *message,
++on_worker_message_received (GDBusMessage *message,
+ gpointer user_data)
+ {
+ GDBusConnection *connection;
+@@ -2272,7 +3081,25 @@ on_worker_message_received (GDBusWorker *worker,
+ g_object_ref (connection);
+ G_UNLOCK (message_bus_lock);
+
+- //g_debug ("in on_worker_message_received");
++#ifdef G_OS_UNIX
++#ifdef KDBUS
++ if (_g_dbus_connection_is_kdbus (connection))
++ {
++ if (G_UNLIKELY (_g_dbus_debug_message ()))
++ {
++ gchar *s;
++ _g_dbus_debug_print_lock ();
++ g_print ("========================================================================\n"
++ "GDBus-debug:Message:\n"
++ " <<<< RECEIVED D-Bus message\n");
++ s = g_dbus_message_print (message, 2);
++ g_print ("%s", s);
++ g_free (s);
++ _g_dbus_debug_print_unlock ();
++ }
++ }
++#endif
++#endif
+
+ g_object_ref (message);
+ g_dbus_message_lock (message);
+@@ -2350,8 +3177,7 @@ on_worker_message_received (GDBusWorker *worker,
+
+ /* Called in GDBusWorker's thread, lock is not held */
+ static GDBusMessage *
+-on_worker_message_about_to_be_sent (GDBusWorker *worker,
+- GDBusMessage *message,
++on_worker_message_about_to_be_sent (GDBusMessage *message,
+ gpointer user_data)
+ {
+ GDBusConnection *connection;
+@@ -2424,10 +3250,9 @@ cancel_method_on_close (gpointer key, gpointer value, gpointer user_data)
+
+ /* Called in GDBusWorker's thread - we must not block - without lock held */
+ static void
+-on_worker_closed (GDBusWorker *worker,
+- gboolean remote_peer_vanished,
+- GError *error,
+- gpointer user_data)
++on_worker_closed (gboolean remote_peer_vanished,
++ GError *error,
++ gpointer user_data)
+ {
+ GDBusConnection *connection;
+ gboolean alive;
+@@ -2489,6 +3314,7 @@ initable_init (GInitable *initable,
+ GError **error)
+ {
+ GDBusConnection *connection = G_DBUS_CONNECTION (initable);
++ gboolean initially_frozen;
+ gboolean ret;
+
+ /* This method needs to be idempotent to work with the singleton
+@@ -2526,6 +3352,8 @@ initable_init (GInitable *initable,
+ */
+ if (connection->address != NULL)
+ {
++ GObject *ret;
++
+ g_assert (connection->stream == NULL);
+
+ if ((connection->flags & G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_SERVER) ||
+@@ -2539,12 +3367,22 @@ initable_init (GInitable *initable,
+ goto out;
+ }
+
+- connection->stream = g_dbus_address_get_stream_sync (connection->address,
+- NULL, /* TODO: out_guid */
+- cancellable,
+- &connection->initialization_error);
+- if (connection->stream == NULL)
++ ret = g_dbus_address_get_stream_internal (connection->address, TRUE,
++ NULL, /* TODO: out_guid */
++ cancellable, &connection->initialization_error);
++ if (ret == NULL)
+ goto out;
++
++ if (G_IS_IO_STREAM (ret))
++ connection->stream = G_IO_STREAM (ret);
++#ifdef G_OS_UNIX
++#ifdef KDBUS
++ else if (G_IS_KDBUS_WORKER (ret))
++ connection->kdbus_worker = G_KDBUS_WORKER (ret);
++#endif
++#endif
++ else
++ g_assert_not_reached ();
+ }
+ else if (connection->stream != NULL)
+ {
+@@ -2555,6 +3393,22 @@ initable_init (GInitable *initable,
+ g_assert_not_reached ();
+ }
+
++#ifdef G_OS_UNIX
++#ifdef KDBUS
++ /* Skip authentication process for kdbus transport */
++ if (connection->kdbus_worker)
++ {
++ if (!_g_kdbus_can_connect (connection->kdbus_worker,
++ &connection->initialization_error))
++ goto out;
++
++ /* kdbus connection always supports exchanging UNIX file descriptors with the remote peer */
++ connection->capabilities |= G_DBUS_CAPABILITY_FLAGS_UNIX_FD_PASSING;
++ goto authenticated;
++ }
++#endif
++#endif
++
+ /* Authenticate the connection */
+ if (connection->flags & G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_SERVER)
+ {
+@@ -2595,6 +3449,8 @@ initable_init (GInitable *initable,
+ connection->authentication_observer = NULL;
+ }
+
++authenticated:
++
+ //g_output_stream_flush (G_SOCKET_CONNECTION (connection->stream)
+
+ //g_debug ("haz unix fd passing powers: %d", connection->capabilities & G_DBUS_CAPABILITY_FLAGS_UNIX_FD_PASSING);
+@@ -2615,13 +3471,34 @@ initable_init (GInitable *initable,
+ g_hash_table_add (alive_connections, connection);
+ G_UNLOCK (message_bus_lock);
+
+- connection->worker = _g_dbus_worker_new (connection->stream,
+- connection->capabilities,
+- ((connection->flags & G_DBUS_CONNECTION_FLAGS_DELAY_MESSAGE_PROCESSING) != 0),
+- on_worker_message_received,
+- on_worker_message_about_to_be_sent,
+- on_worker_closed,
+- connection);
++ initially_frozen = (connection->flags & G_DBUS_CONNECTION_FLAGS_DELAY_MESSAGE_PROCESSING) != 0;
++
++ if (0)
++ {
++ }
++#ifdef G_OS_UNIX
++#ifdef KDBUS
++ else if (connection->kdbus_worker)
++ {
++ _g_kdbus_worker_associate (connection->kdbus_worker,
++ connection->capabilities,
++ on_worker_message_received,
++ on_worker_message_about_to_be_sent,
++ on_worker_closed,
++ connection);
++ }
++#endif
++#endif
++ else
++ {
++ connection->worker = _g_dbus_worker_new (connection->stream,
++ connection->capabilities,
++ initially_frozen,
++ on_worker_message_received,
++ on_worker_message_about_to_be_sent,
++ on_worker_closed,
++ connection);
++ }
+
+ /* if a bus connection, call org.freedesktop.DBus.Hello - this is how we're getting a name */
+ if (connection->flags & G_DBUS_CONNECTION_FLAGS_MESSAGE_BUS_CONNECTION)
+@@ -2638,25 +3515,50 @@ initable_init (GInitable *initable,
+ goto out;
+ }
+
+- hello_result = g_dbus_connection_call_sync (connection,
+- "org.freedesktop.DBus", /* name */
+- "/org/freedesktop/DBus", /* path */
+- "org.freedesktop.DBus", /* interface */
+- "Hello",
+- NULL, /* parameters */
+- G_VARIANT_TYPE ("(s)"),
+- CALL_FLAGS_INITIALIZING,
+- -1,
+- NULL, /* TODO: cancellable */
+- &connection->initialization_error);
+- if (hello_result == NULL)
+- goto out;
++ if (connection->worker)
++ {
++ hello_result = g_dbus_connection_call_sync (connection,
++ "org.freedesktop.DBus", /* name */
++ "/org/freedesktop/DBus", /* path */
++ "org.freedesktop.DBus", /* interface */
++ "Hello",
++ NULL, /* parameters */
++ G_VARIANT_TYPE ("(s)"),
++ CALL_FLAGS_INITIALIZING,
++ -1,
++ NULL, /* TODO: cancellable */
++ &connection->initialization_error);
++ if (hello_result == NULL)
++ goto out;
++
++ g_variant_get (hello_result, "(s)", &connection->bus_unique_name);
++ g_variant_unref (hello_result);
++ }
++#ifdef G_OS_UNIX
++#ifdef KDBUS
++ else if (connection->kdbus_worker)
++ {
++ const gchar *unique_name;
++
++ unique_name = _g_kdbus_Hello (connection->kdbus_worker, &connection->initialization_error);
++ if (unique_name == NULL)
++ goto out;
+
+- g_variant_get (hello_result, "(s)", &connection->bus_unique_name);
+- g_variant_unref (hello_result);
+- //g_debug ("unique name is '%s'", connection->bus_unique_name);
++ connection->bus_unique_name = g_strdup (unique_name);
++ }
++#endif
++#endif
++ else
++ g_assert_not_reached ();
+ }
+
++#ifdef G_OS_UNIX
++#ifdef KDBUS
++ if (connection->kdbus_worker && !initially_frozen)
++ _g_kdbus_worker_unfreeze (connection->kdbus_worker);
++#endif
++#endif
++
+ ret = TRUE;
+ out:
+ if (!ret)
+@@ -3376,7 +4278,8 @@ add_match_rule (GDBusConnection *connection,
+ message,
+ G_DBUS_SEND_MESSAGE_FLAGS_NONE,
+ NULL,
+- &error))
++ &error,
++ -1))
+ {
+ g_critical ("Error while sending AddMatch() message: %s", error->message);
+ g_error_free (error);
+@@ -3408,7 +4311,8 @@ remove_match_rule (GDBusConnection *connection,
+ message,
+ G_DBUS_SEND_MESSAGE_FLAGS_NONE,
+ NULL,
+- &error))
++ &error,
++ -1))
+ {
+ /* If we could get G_IO_ERROR_CLOSED here, it wouldn't be reasonable to
+ * critical; but we're holding the lock, and our caller checked whether
+@@ -3455,7 +4359,7 @@ is_signal_data_for_name_lost_or_acquired (SignalData *signal_data)
+ * subscription is removed or %NULL
+ *
+ * Subscribes to signals on @connection and invokes @callback whenever
+- * the signal is received. Note that @callback will be invoked in the
++ * the signal is received. Note that @callback will be invoked in the
+ * [thread-default main context][g-main-context-push-thread-default]
+ * of the thread you are calling this method from.
+ *
+@@ -3603,8 +4507,60 @@ g_dbus_connection_signal_subscribe (GDBusConnection *connection,
+ */
+ if (connection->flags & G_DBUS_CONNECTION_FLAGS_MESSAGE_BUS_CONNECTION)
+ {
+- if (!is_signal_data_for_name_lost_or_acquired (signal_data))
+- add_match_rule (connection, signal_data->rule);
++ if (connection->worker)
++ {
++ if (!is_signal_data_for_name_lost_or_acquired (signal_data))
++ add_match_rule (connection, signal_data->rule);
++ }
++#ifdef G_OS_UNIX
++#ifdef KDBUS
++ else if (connection->kdbus_worker)
++ {
++ gboolean special_rule = FALSE;
++ /* rule for special message */
++ if (!signal_data->sender_unique_name[0] || g_strcmp0 (signal_data->sender_unique_name, "org.freedesktop.DBus") == 0)
++ {
++ if (signal_data->sender_unique_name[0]) /* So, this is org.freedesktop.DBus */
++ special_rule = TRUE;
++ if (!signal_data->object_path || g_strcmp0 (signal_data->object_path, "/org/freedesktop/DBus") == 0)
++ {
++ if (!signal_data->interface_name || g_strcmp0 (signal_data->interface_name, "org.freedesktop.DBus") == 0)
++ {
++ /* By https://dbus.freedesktop.org/doc/dbus-specification.html, org.freedesktop.DBus
++ * has three signal types: NameAcquired, NameLost, NameOwnerChanged (all covered below).
++ *
++ * 1. if sender is NULL and other parameters are matched with special rule, add BOTH special and standard,
++ * - (NULL, NULL or DBUS, NULL or DBUS, NULL or Special Name)
++ *
++ * if other parameters are NOT matched with special rule, add standard rule
++ * - (NULL, X, X, "NotSpecial")
++ *
++ * 2. if sender is 'org.freedesktop.DBus' and other parameters are matched with special rule, add special rule
++ * - (org.freedesktop.DBus, NULL or DBUS, NULL or DBUS, NULL or Special Name)
++ *
++ * if other parameters are NOT matched with special rule, then ignore
++ * - (org.freedesktop.DBus, X, X, "NotSpecial")
++ *
++ * for every other cases, add standard rule,
++ */
++
++ if (g_strcmp0 (signal_data->member, "NameAcquired") == 0)
++ _g_kdbus_subscribe_name_acquired (connection->kdbus_worker, signal_data->rule, arg0, NULL);
++ else if (g_strcmp0 (signal_data->member, "NameLost") == 0)
++ _g_kdbus_subscribe_name_lost (connection->kdbus_worker, signal_data->rule, arg0, NULL);
++ else if (!signal_data->member || g_strcmp0 (signal_data->member, "NameOwnerChanged") == 0)
++ _g_kdbus_subscribe_name_owner_changed (connection->kdbus_worker, signal_data->rule, arg0, NULL);
++ }
++ }
++ }
++ /* standard rule */
++ if (!special_rule)
++ _g_kdbus_AddMatch (connection->kdbus_worker, signal_data->rule, NULL);
++ }
++#endif
++#endif
++ else
++ g_assert_not_reached ();
+ }
+
+ signal_data_array = g_hash_table_lookup (connection->map_sender_unique_name_to_signal_data_array,
+@@ -3683,7 +4639,6 @@ unsubscribe_id_internal (GDBusConnection *connection,
+
+ /* remove the match rule from the bus unless NameLost or NameAcquired (see subscribe()) */
+ if ((connection->flags & G_DBUS_CONNECTION_FLAGS_MESSAGE_BUS_CONNECTION) &&
+- !is_signal_data_for_name_lost_or_acquired (signal_data) &&
+ !g_dbus_connection_is_closed (connection) &&
+ !connection->finalizing)
+ {
+@@ -3693,7 +4648,21 @@ unsubscribe_id_internal (GDBusConnection *connection,
+ * so on_worker_closed() can't happen between the check we just
+ * did, and releasing the lock later.
+ */
+- remove_match_rule (connection, signal_data->rule);
++ if (connection->worker)
++ {
++ if (!is_signal_data_for_name_lost_or_acquired (signal_data))
++ remove_match_rule (connection, signal_data->rule);
++ }
++#ifdef G_OS_UNIX
++#ifdef KDBUS
++ else if (connection->kdbus_worker)
++ {
++ _g_kdbus_RemoveMatch (connection->kdbus_worker, signal_data->rule, NULL);
++ }
++#endif
++#endif
++ else
++ g_assert_not_reached ();
+ }
+
+ signal_data_free (signal_data);
+@@ -3777,7 +4746,7 @@ emit_signal_instance_in_idle_cb (gpointer data)
+ }
+ else
+ {
+- g_variant_ref_sink (parameters);
++ g_variant_ref (parameters);
+ }
+
+ #if 0
+@@ -4421,7 +5390,7 @@ validate_and_maybe_schedule_property_getset (GDBusConnection *connect
+ "org.freedesktop.DBus.Error.InvalidArgs",
+ _("No such property “%s”"),
+ property_name);
+- g_dbus_connection_send_message_unlocked (connection, reply, G_DBUS_SEND_MESSAGE_FLAGS_NONE, NULL, NULL);
++ g_dbus_connection_send_message_unlocked (connection, reply, G_DBUS_SEND_MESSAGE_FLAGS_NONE, NULL, NULL, -1);
+ g_object_unref (reply);
+ handled = TRUE;
+ goto out;
+@@ -4433,7 +5402,7 @@ validate_and_maybe_schedule_property_getset (GDBusConnection *connect
+ "org.freedesktop.DBus.Error.InvalidArgs",
+ _("Property “%s” is not readable"),
+ property_name);
+- g_dbus_connection_send_message_unlocked (connection, reply, G_DBUS_SEND_MESSAGE_FLAGS_NONE, NULL, NULL);
++ g_dbus_connection_send_message_unlocked (connection, reply, G_DBUS_SEND_MESSAGE_FLAGS_NONE, NULL, NULL, -1);
+ g_object_unref (reply);
+ handled = TRUE;
+ goto out;
+@@ -4444,7 +5413,7 @@ validate_and_maybe_schedule_property_getset (GDBusConnection *connect
+ "org.freedesktop.DBus.Error.InvalidArgs",
+ _("Property “%s” is not writable"),
+ property_name);
+- g_dbus_connection_send_message_unlocked (connection, reply, G_DBUS_SEND_MESSAGE_FLAGS_NONE, NULL, NULL);
++ g_dbus_connection_send_message_unlocked (connection, reply, G_DBUS_SEND_MESSAGE_FLAGS_NONE, NULL, NULL, -1);
+ g_object_unref (reply);
+ handled = TRUE;
+ goto out;
+@@ -4465,7 +5434,7 @@ validate_and_maybe_schedule_property_getset (GDBusConnection *connect
+ _("Error setting property “%s”: Expected type “%s” but got “%s”"),
+ property_name, property_info->signature,
+ g_variant_get_type_string (value));
+- g_dbus_connection_send_message_unlocked (connection, reply, G_DBUS_SEND_MESSAGE_FLAGS_NONE, NULL, NULL);
++ g_dbus_connection_send_message_unlocked (connection, reply, G_DBUS_SEND_MESSAGE_FLAGS_NONE, NULL, NULL, -1);
+ g_variant_unref (value);
+ g_object_unref (reply);
+ handled = TRUE;
+@@ -4569,7 +5538,7 @@ handle_getset_property (GDBusConnection *connection,
+ "org.freedesktop.DBus.Error.InvalidArgs",
+ _("No such interface “%s”"),
+ interface_name);
+- g_dbus_connection_send_message_unlocked (eo->connection, reply, G_DBUS_SEND_MESSAGE_FLAGS_NONE, NULL, NULL);
++ g_dbus_connection_send_message_unlocked (eo->connection, reply, G_DBUS_SEND_MESSAGE_FLAGS_NONE, NULL, NULL, -1);
+ g_object_unref (reply);
+ handled = TRUE;
+ goto out;
+@@ -4784,7 +5753,7 @@ handle_get_all_properties (GDBusConnection *connection,
+ "org.freedesktop.DBus.Error.InvalidArgs",
+ _("No such interface “%s”"),
+ interface_name);
+- g_dbus_connection_send_message_unlocked (eo->connection, reply, G_DBUS_SEND_MESSAGE_FLAGS_NONE, NULL, NULL);
++ g_dbus_connection_send_message_unlocked (eo->connection, reply, G_DBUS_SEND_MESSAGE_FLAGS_NONE, NULL, NULL, -1);
+ g_object_unref (reply);
+ handled = TRUE;
+ goto out;
+@@ -4968,7 +5937,7 @@ handle_introspect (GDBusConnection *connection,
+
+ reply = g_dbus_message_new_method_reply (message);
+ g_dbus_message_set_body (reply, g_variant_new ("(s)", s->str));
+- g_dbus_connection_send_message_unlocked (connection, reply, G_DBUS_SEND_MESSAGE_FLAGS_NONE, NULL, NULL);
++ g_dbus_connection_send_message_unlocked (connection, reply, G_DBUS_SEND_MESSAGE_FLAGS_NONE, NULL, NULL, -1);
+ g_object_unref (reply);
+ g_string_free (s, TRUE);
+
+@@ -5101,7 +6070,7 @@ validate_and_maybe_schedule_method_call (GDBusConnection *connection,
+ "org.freedesktop.DBus.Error.UnknownMethod",
+ _("No such method “%s”"),
+ g_dbus_message_get_member (message));
+- g_dbus_connection_send_message_unlocked (connection, reply, G_DBUS_SEND_MESSAGE_FLAGS_NONE, NULL, NULL);
++ g_dbus_connection_send_message_unlocked (connection, reply, G_DBUS_SEND_MESSAGE_FLAGS_NONE, NULL, NULL, -1);
+ g_object_unref (reply);
+ handled = TRUE;
+ goto out;
+@@ -5133,7 +6102,7 @@ validate_and_maybe_schedule_method_call (GDBusConnection *connection,
+ _("Type of message, “%s”, does not match expected type “%s”"),
+ g_variant_get_type_string (parameters),
+ type_string);
+- g_dbus_connection_send_message_unlocked (connection, reply, G_DBUS_SEND_MESSAGE_FLAGS_NONE, NULL, NULL);
++ g_dbus_connection_send_message_unlocked (connection, reply, G_DBUS_SEND_MESSAGE_FLAGS_NONE, NULL, NULL, -1);
+ g_variant_type_free (in_type);
+ g_variant_unref (parameters);
+ g_object_unref (reply);
+@@ -5250,7 +6219,7 @@ obj_message_func (GDBusConnection *connection,
+ * D-Bus interface that is described in @interface_info.
+ *
+ * Calls to functions in @vtable (and @user_data_free_func) will happen
+- * in the
++ * in the
+ * [thread-default main context][g-main-context-push-thread-default]
+ * of the thread you are calling this method from.
+ *
+@@ -5818,6 +6787,16 @@ decode_method_reply (GDBusMessage *reply,
+
+ case G_DBUS_MESSAGE_TYPE_ERROR:
+ g_dbus_message_to_gerror (reply, error);
++ if (error == NULL || *error == NULL)
++ break;
++ if ((*error)->code == G_DBUS_ERROR_NO_REPLY)
++ {
++ g_clear_error(error);
++ g_set_error (error,
++ G_IO_ERROR,
++ G_IO_ERROR_TIMED_OUT,
++ _("Timeout was reached"));
++ }
+ break;
+
+ default:
+@@ -7076,7 +8055,7 @@ handle_generic_ping_unlocked (GDBusConnection *connection,
+ {
+ GDBusMessage *reply;
+ reply = g_dbus_message_new_method_reply (message);
+- g_dbus_connection_send_message_unlocked (connection, reply, G_DBUS_SEND_MESSAGE_FLAGS_NONE, NULL, NULL);
++ g_dbus_connection_send_message_unlocked (connection, reply, G_DBUS_SEND_MESSAGE_FLAGS_NONE, NULL, NULL, -1);
+ g_object_unref (reply);
+ }
+
+@@ -7109,7 +8088,7 @@ handle_generic_get_machine_id_unlocked (GDBusConnection *connection,
+ reply = g_dbus_message_new_method_reply (message);
+ g_dbus_message_set_body (reply, g_variant_new ("(s)", connection->machine_id));
+ }
+- g_dbus_connection_send_message_unlocked (connection, reply, G_DBUS_SEND_MESSAGE_FLAGS_NONE, NULL, NULL);
++ g_dbus_connection_send_message_unlocked (connection, reply, G_DBUS_SEND_MESSAGE_FLAGS_NONE, NULL, NULL, -1);
+ g_object_unref (reply);
+ }
+
+@@ -7136,7 +8115,7 @@ handle_generic_introspect_unlocked (GDBusConnection *connection,
+
+ reply = g_dbus_message_new_method_reply (message);
+ g_dbus_message_set_body (reply, g_variant_new ("(s)", s->str));
+- g_dbus_connection_send_message_unlocked (connection, reply, G_DBUS_SEND_MESSAGE_FLAGS_NONE, NULL, NULL);
++ g_dbus_connection_send_message_unlocked (connection, reply, G_DBUS_SEND_MESSAGE_FLAGS_NONE, NULL, NULL, -1);
+ g_object_unref (reply);
+ g_string_free (s, TRUE);
+ }
+@@ -7288,7 +8267,7 @@ distribute_method_call (GDBusConnection *connection,
+ path);
+ }
+
+- g_dbus_connection_send_message_unlocked (connection, reply, G_DBUS_SEND_MESSAGE_FLAGS_NONE, NULL, NULL);
++ g_dbus_connection_send_message_unlocked (connection, reply, G_DBUS_SEND_MESSAGE_FLAGS_NONE, NULL, NULL, -1);
+ g_object_unref (reply);
+
+ out:
+@@ -7602,3 +8581,10 @@ g_bus_get_finish (GAsyncResult *res,
+ }
+
+ /* ---------------------------------------------------------------------------------------------------- */
++#ifdef _TIZEN_DBUS_TOUCH
++static void __attribute__((constructor)) glib_type_dbus_connection_gc( void )
++{
++ GObject* temp = g_type_class_ref(G_TYPE_DBUS_CONNECTION);
++ g_type_class_unref(temp);
++}
++#endif
+diff --git a/gio/gdbusconnection.h b/gio/gdbusconnection.h
+index feda7c0..b4452b3 100644
+--- a/gio/gdbusconnection.h
++++ b/gio/gdbusconnection.h
+@@ -32,6 +32,8 @@
+
+ G_BEGIN_DECLS
+
++#define DBUS_DEFAULT_TIMEOUT_MSEC 25000U
++
+ #define G_TYPE_DBUS_CONNECTION (g_dbus_connection_get_type ())
+ #define G_DBUS_CONNECTION(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), G_TYPE_DBUS_CONNECTION, GDBusConnection))
+ #define G_IS_DBUS_CONNECTION(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), G_TYPE_DBUS_CONNECTION))
+@@ -94,6 +96,46 @@ GDBusConnection *g_dbus_connection_new_for_address_sync (const gchar
+
+ /* ---------------------------------------------------------------------------------------------------- */
+
++gboolean _g_dbus_connection_is_kdbus (GDBusConnection *connection) TIZEN_PUBLIC_DEPRECATED_API;
++
++GBusRequestNameReplyFlags g_dbus_request_name (GDBusConnection *connection,
++ const gchar *name,
++ GBusNameOwnerFlags flags,
++ GError **error) TIZEN_PUBLIC_DEPRECATED_API;
++GBusReleaseNameReplyFlags g_dbus_release_name (GDBusConnection *connection,
++ const gchar *name,
++ GError **error) TIZEN_PUBLIC_DEPRECATED_API;
++gboolean g_dbus_add_match (GDBusConnection *connection,
++ const gchar *match_rule,
++ GError **error) TIZEN_PUBLIC_DEPRECATED_API;
++gboolean g_dbus_remove_match (GDBusConnection *connection,
++ const gchar *match_rule,
++ GError **error) TIZEN_PUBLIC_DEPRECATED_API;
++gchar *g_dbus_get_bus_id (GDBusConnection *connection,
++ GError **error) TIZEN_PUBLIC_DEPRECATED_API;
++gchar **g_dbus_get_list_names (GDBusConnection *connection,
++ GError **error) TIZEN_PUBLIC_DEPRECATED_API;
++gchar **g_dbus_get_list_activatable_names (GDBusConnection *connection,
++ GError **error) TIZEN_PUBLIC_DEPRECATED_API;
++gchar **g_dbus_get_list_queued_owners (GDBusConnection *connection,
++ const gchar *name,
++ GError **error) TIZEN_PUBLIC_DEPRECATED_API;
++gchar *g_dbus_get_name_owner (GDBusConnection *connection,
++ const gchar *name,
++ GError **error) TIZEN_PUBLIC_DEPRECATED_API;
++pid_t g_dbus_get_connection_pid (GDBusConnection *connection,
++ const gchar *name,
++ GError **error) TIZEN_PUBLIC_DEPRECATED_API;
++uid_t g_dbus_get_connection_uid (GDBusConnection *connection,
++ const gchar *name,
++ GError **error) TIZEN_PUBLIC_DEPRECATED_API;
++GBusStartServiceReplyFlags g_dbus_start_service_by_name (GDBusConnection *connection,
++ const gchar *name,
++ guint32 flags,
++ GError **error) TIZEN_PUBLIC_DEPRECATED_API;
++
++/* ---------------------------------------------------------------------------------------------------- */
++
+ GIO_AVAILABLE_IN_ALL
+ void g_dbus_connection_start_message_processing (GDBusConnection *connection) TIZEN_PUBLIC_DEPRECATED_API;
+ GIO_AVAILABLE_IN_ALL
+diff --git a/gio/gdbusmessage.c b/gio/gdbusmessage.c
+index adddb31..3894d19 100644
+--- a/gio/gdbusmessage.c
++++ b/gio/gdbusmessage.c
+@@ -3868,3 +3868,10 @@ g_dbus_message_copy (GDBusMessage *message,
+ #endif
+ return ret;
+ }
++
++void
++g_dbus_message_init_header_iter (GDBusMessage *message,
++ GHashTableIter *iter)
++{
++ g_hash_table_iter_init (iter, message->headers);
++}
+diff --git a/gio/gdbusmethodinvocation.c b/gio/gdbusmethodinvocation.c
+index e5a9166..cd210c2 100644
+--- a/gio/gdbusmethodinvocation.c
++++ b/gio/gdbusmethodinvocation.c
+@@ -310,6 +310,44 @@ g_dbus_method_invocation_get_parameters (GDBusMethodInvocation *invocation)
+ return invocation->parameters;
+ }
+
++/**
++ * g_dbus_method_invocation_peek_unix_fd:
++ * @invocation: A #GDBusMethodInvocation.
++ * @index_: the index
++ *
++ * Gets the fd associated with @index in the method invocation.
++ *
++ * If there is no file descriptor at the given index, -1 is returned.
++ *
++ * The returned file descriptor is owned by the message and must not be
++ * closed by the caller. Use dup() if you want your own copy.
++ *
++ * Returns: the file descriptor, or -1
++ */
++#ifdef G_OS_UNIX
++gint
++g_dbus_method_invocation_peek_unix_fd (GDBusMethodInvocation *invocation,
++ guint index_)
++{
++ GUnixFDList *fd_list;
++
++ fd_list = g_dbus_message_get_unix_fd_list (invocation->message);
++
++ if (fd_list)
++ {
++ const gint *fds;
++ gint n_fds;
++
++ fds = g_unix_fd_list_peek_fds (fd_list, &n_fds);
++
++ if (index_ < (guint) n_fds)
++ return fds[index_];
++ }
++
++ return -1;
++}
++#endif
++
+ /**
+ * g_dbus_method_invocation_get_user_data: (skip)
+ * @invocation: A #GDBusMethodInvocation.
+diff --git a/gio/gdbusmethodinvocation.h b/gio/gdbusmethodinvocation.h
+index eecef03..bbfa190 100644
+--- a/gio/gdbusmethodinvocation.h
++++ b/gio/gdbusmethodinvocation.h
+@@ -91,6 +91,11 @@ GIO_AVAILABLE_IN_ALL
+ GDBusMessage *g_dbus_method_invocation_get_message (GDBusMethodInvocation *invocation) TIZEN_PUBLIC_DEPRECATED_API;
+ GIO_AVAILABLE_IN_ALL
+ GVariant *g_dbus_method_invocation_get_parameters (GDBusMethodInvocation *invocation) TIZEN_PUBLIC_DEPRECATED_API;
++#ifdef G_OS_UNIX
++GIO_AVAILABLE_IN_2_44
++gint g_dbus_method_invocation_peek_unix_fd (GDBusMethodInvocation *invocation,
++ guint index_) TIZEN_PUBLIC_DEPRECATED_API;
++#endif
+ GIO_AVAILABLE_IN_ALL
+ gpointer g_dbus_method_invocation_get_user_data (GDBusMethodInvocation *invocation) TIZEN_PUBLIC_DEPRECATED_API;
+
+diff --git a/gio/gdbusnameowning.c b/gio/gdbusnameowning.c
+index 289ea03..5090d26 100644
+--- a/gio/gdbusnameowning.c
++++ b/gio/gdbusnameowning.c
+@@ -926,6 +926,19 @@ g_bus_unown_name (guint owner_id)
+ /* do callback without holding lock */
+ if (client != NULL)
+ {
++ /* Kdbus sends NameLost after replying to ReleaseName,
++ * contrary to dbus-daemon. Let's disable subscriptions now,
++ * as we're no longer interested in them, anyway. It prevents
++ * a race condition with receiving NameLost after
++ * an unowned name gets owned again.
++ */
++ if (client->name_lost_subscription_id > 0)
++ g_dbus_connection_signal_unsubscribe (client->connection, client->name_lost_subscription_id);
++ if (client->name_acquired_subscription_id > 0)
++ g_dbus_connection_signal_unsubscribe (client->connection, client->name_acquired_subscription_id);
++ client->name_acquired_subscription_id = 0;
++ client->name_lost_subscription_id = 0;
++
+ /* Release the name if needed */
+ if (client->needs_release &&
+ client->connection != NULL &&
+@@ -975,13 +988,7 @@ g_bus_unown_name (guint owner_id)
+
+ if (client->disconnected_signal_handler_id > 0)
+ g_signal_handler_disconnect (client->connection, client->disconnected_signal_handler_id);
+- if (client->name_acquired_subscription_id > 0)
+- g_dbus_connection_signal_unsubscribe (client->connection, client->name_acquired_subscription_id);
+- if (client->name_lost_subscription_id > 0)
+- g_dbus_connection_signal_unsubscribe (client->connection, client->name_lost_subscription_id);
+ client->disconnected_signal_handler_id = 0;
+- client->name_acquired_subscription_id = 0;
+- client->name_lost_subscription_id = 0;
+ if (client->connection != NULL)
+ {
+ g_object_unref (client->connection);
+diff --git a/gio/gdbusnamewatching.c b/gio/gdbusnamewatching.c
+old mode 100644
+new mode 100755
+index c834fe1..fc230a8
+--- a/gio/gdbusnamewatching.c
++++ b/gio/gdbusnamewatching.c
+@@ -353,9 +353,6 @@ on_name_owner_changed (GDBusConnection *connection,
+ if (client == NULL)
+ return;
+
+- if (!client->initialized)
+- goto out;
+-
+ if (g_strcmp0 (object_path, "/org/freedesktop/DBus") != 0 ||
+ g_strcmp0 (interface_name, "org.freedesktop.DBus") != 0 ||
+ g_strcmp0 (sender_name, "org.freedesktop.DBus") != 0)
+@@ -371,7 +368,7 @@ on_name_owner_changed (GDBusConnection *connection,
+ if (g_strcmp0 (name, client->name) != 0)
+ goto out;
+
+- if ((old_owner != NULL && strlen (old_owner) > 0) && client->name_owner != NULL)
++ if (old_owner != NULL && strlen (old_owner) > 0)
+ {
+ g_free (client->name_owner);
+ client->name_owner = NULL;
+@@ -380,12 +377,18 @@ on_name_owner_changed (GDBusConnection *connection,
+
+ if (new_owner != NULL && strlen (new_owner) > 0)
+ {
+- g_warn_if_fail (client->name_owner == NULL);
+ g_free (client->name_owner);
+ client->name_owner = g_strdup (new_owner);
+ call_appeared_handler (client);
+ }
+
++ /* initialized set to TRUE means that signal was delivered and processed.
++ * Now, if we receive a reply to GetNameOwner call, we may just ignore it as it carries the same
++ * information as the current signal, or if something changed in the meantime we will
++ * get next signal very soon.
++ */
++ client->initialized = TRUE;
++
+ out:
+ client_unref (client);
+ }
+@@ -407,6 +410,13 @@ get_name_owner_cb (GObject *source_object,
+ result = g_dbus_connection_call_finish (client->connection,
+ res,
+ NULL);
++ /* In case we already received NameOwnerChanged signal, we don't need to
++ * process GetNameOwner answer, because all the information we needed was already
++ * delivered with the signal and processed by the signal handler.
++ */
++ if (client->initialized)
++ goto out;
++
+ if (result != NULL)
+ {
+ g_variant_get (result, "(&s)", &name_owner);
+@@ -423,10 +433,10 @@ get_name_owner_cb (GObject *source_object,
+ call_vanished_handler (client);
+ }
+
+- client->initialized = TRUE;
+-
++ out:
+ if (result != NULL)
+ g_variant_unref (result);
++
+ client_unref (client);
+ }
+
+diff --git a/gio/gdbusobjectmanagerclient.c b/gio/gdbusobjectmanagerclient.c
+index b6b3b21..8997e8c 100644
+--- a/gio/gdbusobjectmanagerclient.c
++++ b/gio/gdbusobjectmanagerclient.c
+@@ -1133,7 +1133,6 @@ subscribe_signals (GDBusObjectManagerClient *manager,
+ const gchar *name_owner)
+ {
+ GError *error = NULL;
+- GVariant *ret;
+
+ g_return_if_fail (G_IS_DBUS_OBJECT_MANAGER_CLIENT (manager));
+ g_return_if_fail (manager->priv->signal_subscription_id == 0);
+@@ -1159,22 +1158,7 @@ subscribe_signals (GDBusObjectManagerClient *manager,
+
+ /* The bus daemon may not implement path_namespace so gracefully
+ * handle this by using a fallback triggered if @error is set. */
+- ret = g_dbus_connection_call_sync (manager->priv->connection,
+- "org.freedesktop.DBus",
+- "/org/freedesktop/DBus",
+- "org.freedesktop.DBus",
+- "AddMatch",
+- g_variant_new ("(s)",
+- manager->priv->match_rule),
+- NULL, /* reply_type */
+- G_DBUS_CALL_FLAGS_NONE,
+- -1, /* default timeout */
+- NULL, /* TODO: Cancellable */
+- &error);
+-
+- /* yay, bus daemon supports path_namespace */
+- if (ret != NULL)
+- g_variant_unref (ret);
++ g_dbus_add_match (manager->priv->connection, manager->priv->match_rule, &error);
+ }
+
+ if (error == NULL)
+@@ -1244,19 +1228,9 @@ maybe_unsubscribe_signals (GDBusObjectManagerClient *manager)
+ /* Since the AddMatch call succeeded this is guaranteed to not
+ * fail - therefore, don't bother checking the return value
+ */
+- g_dbus_connection_call (manager->priv->connection,
+- "org.freedesktop.DBus",
+- "/org/freedesktop/DBus",
+- "org.freedesktop.DBus",
+- "RemoveMatch",
+- g_variant_new ("(s)",
+- manager->priv->match_rule),
+- NULL, /* reply_type */
+- G_DBUS_CALL_FLAGS_NONE,
+- -1, /* default timeout */
+- NULL, /* GCancellable */
+- NULL, /* GAsyncReadyCallback */
+- NULL); /* user data */
++ g_dbus_remove_match (manager->priv->connection,
++ manager->priv->match_rule,
++ NULL);
+ g_free (manager->priv->match_rule);
+ manager->priv->match_rule = NULL;
+ }
+diff --git a/gio/gdbusprivate.c b/gio/gdbusprivate.c
+index 2c9238c..4132e82 100644
+--- a/gio/gdbusprivate.c
++++ b/gio/gdbusprivate.c
+@@ -63,6 +63,10 @@
+
+ #include "glibintl.h"
+
++#define READ_BUFFER_MIN_READ_SIZE_FOR_HEADER 16
++/* TODO: 4096 is randomly chosen; might want a better chosen default minimum */
++#define READ_BUFFER_MIN_BUFFER_SIZE 4096
++
+ static gboolean _g_dbus_worker_do_initial_read (gpointer data);
+ static void schedule_pending_close (GDBusWorker *worker);
+
+@@ -481,7 +485,7 @@ _g_dbus_worker_emit_disconnected (GDBusWorker *worker,
+ GError *error)
+ {
+ if (!g_atomic_int_get (&worker->stopped))
+- worker->disconnected_callback (worker, remote_peer_vanished, error, worker->user_data);
++ worker->disconnected_callback (remote_peer_vanished, error, worker->user_data);
+ }
+
+ static void
+@@ -489,7 +493,7 @@ _g_dbus_worker_emit_message_received (GDBusWorker *worker,
+ GDBusMessage *message)
+ {
+ if (!g_atomic_int_get (&worker->stopped))
+- worker->message_received_callback (worker, message, worker->user_data);
++ worker->message_received_callback (message, worker->user_data);
+ }
+
+ static GDBusMessage *
+@@ -498,7 +502,7 @@ _g_dbus_worker_emit_message_about_to_be_sent (GDBusWorker *worker,
+ {
+ GDBusMessage *ret;
+ if (!g_atomic_int_get (&worker->stopped))
+- ret = worker->message_about_to_be_sent_callback (worker, g_steal_pointer (&message), worker->user_data);
++ ret = worker->message_about_to_be_sent_callback (g_steal_pointer (&message), worker->user_data);
+ else
+ ret = g_steal_pointer (&message);
+ return ret;
+@@ -567,6 +571,36 @@ _g_dbus_worker_unfreeze (GDBusWorker *worker)
+
+ static void _g_dbus_worker_do_read_unlocked (GDBusWorker *worker);
+
++static gssize _g_dbus_worker_buffer_get_next_full_message_length (GDBusWorker *worker)
++{
++ GError *error;
++
++ if (worker->read_buffer == NULL)
++ return 0;
++
++ if (worker->read_buffer_cur_size >= READ_BUFFER_MIN_READ_SIZE_FOR_HEADER)
++ {
++ gssize message_len;
++ /* OK, got the header - determine how many more bytes are needed */
++ error = NULL;
++ message_len = g_dbus_message_bytes_needed ((guchar *) worker->read_buffer,
++ READ_BUFFER_MIN_READ_SIZE_FOR_HEADER,
++ &error);
++ if (message_len == -1)
++ {
++ g_warning ("_g_dbus_worker_do_read_cb: error determining bytes needed: %s", error->message);
++ _g_dbus_worker_emit_disconnected (worker, FALSE, error);
++ g_error_free (error);
++ return -1;
++ }
++ if (message_len <= worker->read_buffer_cur_size)
++ return message_len;
++
++ worker->read_buffer_bytes_wanted = message_len;
++ }
++ return 0;
++}
++
+ /* called in private thread shared by all GDBusConnection instances (without read-lock held) */
+ static void
+ _g_dbus_worker_do_read_cb (GInputStream *input_stream,
+@@ -576,6 +610,7 @@ _g_dbus_worker_do_read_cb (GInputStream *input_stream,
+ GDBusWorker *worker = user_data;
+ GError *error;
+ gssize bytes_read;
++ gssize message_len;
+
+ g_mutex_lock (&worker->read_lock);
+
+@@ -722,97 +757,106 @@ _g_dbus_worker_do_read_cb (GInputStream *input_stream,
+ read_message_print_transport_debug (bytes_read, worker);
+
+ worker->read_buffer_cur_size += bytes_read;
+- if (worker->read_buffer_bytes_wanted == worker->read_buffer_cur_size)
++
++ while ((message_len = _g_dbus_worker_buffer_get_next_full_message_length (worker) ) > 0)
+ {
+ /* OK, got what we asked for! */
+- if (worker->read_buffer_bytes_wanted == 16)
+- {
+- gssize message_len;
+- /* OK, got the header - determine how many more bytes are needed */
+- error = NULL;
+- message_len = g_dbus_message_bytes_needed ((guchar *) worker->read_buffer,
+- 16,
+- &error);
+- if (message_len == -1)
+- {
+- g_warning ("_g_dbus_worker_do_read_cb: error determining bytes needed: %s", error->message);
+- _g_dbus_worker_emit_disconnected (worker, FALSE, error);
+- g_error_free (error);
+- goto out;
+- }
++ GDBusMessage *message;
++ error = NULL;
+
+- worker->read_buffer_bytes_wanted = message_len;
+- _g_dbus_worker_do_read_unlocked (worker);
++ /* TODO: use connection->priv->auth to decode the message */
++
++ message = g_dbus_message_new_from_blob ((guchar *) worker->read_buffer,
++ message_len,
++ worker->capabilities,
++ &error);
++ if (message == NULL)
++ {
++ gchar *s;
++ s = _g_dbus_hexdump (worker->read_buffer, message_len, 2);
++ g_warning ("Error decoding D-Bus message of %" G_GSIZE_FORMAT " bytes\n"
++ "The error is: %s\n"
++ "The payload is as follows:\n"
++ "%s",
++ message_len,
++ error->message,
++ s);
++ g_free (s);
++ _g_dbus_worker_emit_disconnected (worker, FALSE, error);
++ g_error_free (error);
++ goto out;
+ }
+- else
++
++#ifdef G_OS_UNIX
++ if (worker->read_fd_list != NULL)
+ {
+- GDBusMessage *message;
+- error = NULL;
++ guint fds_needed;
++ GUnixFDList *fd_list_for_message;
+
+- /* TODO: use connection->priv->auth to decode the message */
++ fds_needed = g_dbus_message_get_num_unix_fds (message);
+
+- message = g_dbus_message_new_from_blob ((guchar *) worker->read_buffer,
+- worker->read_buffer_cur_size,
+- worker->capabilities,
+- &error);
+- if (message == NULL)
++ if ((guint)g_unix_fd_list_get_length (worker->read_fd_list) > fds_needed)
+ {
+- gchar *s;
+- s = _g_dbus_hexdump (worker->read_buffer, worker->read_buffer_cur_size, 2);
+- g_warning ("Error decoding D-Bus message of %" G_GSIZE_FORMAT " bytes\n"
+- "The error is: %s\n"
+- "The payload is as follows:\n"
+- "%s",
+- worker->read_buffer_cur_size,
+- error->message,
+- s);
+- g_free (s);
+- _g_dbus_worker_emit_disconnected (worker, FALSE, error);
+- g_error_free (error);
+- goto out;
+- }
++ gint num_fds;
++ GUnixFDList *old_worker_read_fd_list;
++ gint *fds;
+
+-#ifdef G_OS_UNIX
+- if (worker->read_fd_list != NULL)
++ old_worker_read_fd_list = worker->read_fd_list;
++ fds = g_unix_fd_list_steal_fds (old_worker_read_fd_list, &num_fds);
++ fd_list_for_message = g_unix_fd_list_new_from_array (fds, fds_needed);
++ worker->read_fd_list = g_unix_fd_list_new_from_array (fds + fds_needed, num_fds - fds_needed);
++ g_object_unref (old_worker_read_fd_list);
++ g_free (fds);
++ }
++ else
+ {
+- g_dbus_message_set_unix_fd_list (message, worker->read_fd_list);
+- g_object_unref (worker->read_fd_list);
++ fd_list_for_message = worker->read_fd_list;
+ worker->read_fd_list = NULL;
+ }
++
++ if (fds_needed > 0)
++ g_dbus_message_set_unix_fd_list (message, fd_list_for_message);
++ g_object_unref (fd_list_for_message);
++ }
+ #endif
+
+- if (G_UNLIKELY (_g_dbus_debug_message ()))
++ if (G_UNLIKELY (_g_dbus_debug_message ()))
++ {
++ gchar *s;
++ _g_dbus_debug_print_lock ();
++ g_print ("========================================================================\n"
++ "GDBus-debug:Message:\n"
++ " <<<< RECEIVED D-Bus message (%" G_GSIZE_FORMAT " bytes)\n",
++ message_len);
++ s = g_dbus_message_print (message, 2);
++ g_print ("%s", s);
++ g_free (s);
++ if (G_UNLIKELY (_g_dbus_debug_payload ()))
+ {
+- gchar *s;
+- _g_dbus_debug_print_lock ();
+- g_print ("========================================================================\n"
+- "GDBus-debug:Message:\n"
+- " <<<< RECEIVED D-Bus message (%" G_GSIZE_FORMAT " bytes)\n",
+- worker->read_buffer_cur_size);
+- s = g_dbus_message_print (message, 2);
+- g_print ("%s", s);
++ s = _g_dbus_hexdump (worker->read_buffer, message_len, 2);
++ g_print ("%s\n", s);
+ g_free (s);
+- if (G_UNLIKELY (_g_dbus_debug_payload ()))
+- {
+- s = _g_dbus_hexdump (worker->read_buffer, worker->read_buffer_cur_size, 2);
+- g_print ("%s\n", s);
+- g_free (s);
+- }
+- _g_dbus_debug_print_unlock ();
+ }
++ _g_dbus_debug_print_unlock ();
++ }
+
+- /* yay, got a message, go deliver it */
+- _g_dbus_worker_queue_or_deliver_received_message (worker, g_steal_pointer (&message));
++ /* yay, got a message, go deliver it */
++ _g_dbus_worker_queue_or_deliver_received_message (worker, g_steal_pointer (&message));
+
+- /* start reading another message! */
+- worker->read_buffer_bytes_wanted = 0;
+- worker->read_buffer_cur_size = 0;
+- _g_dbus_worker_do_read_unlocked (worker);
++ /* set up reading another message */
++ if (worker->read_buffer_cur_size > message_len)
++ {
++ memmove (worker->read_buffer,
++ worker->read_buffer + message_len,
++ worker->read_buffer_cur_size - message_len);
+ }
++ worker->read_buffer_cur_size -= message_len;
++ worker->read_buffer_bytes_wanted = 0;
+ }
+- else
++
++ if (message_len == 0)
+ {
+- /* didn't get all the bytes we requested - so repeat the request... */
++ /* start reading another message or repeat the request to get all the bytes */
+ _g_dbus_worker_do_read_unlocked (worker);
+ }
+
+@@ -837,15 +881,21 @@ _g_dbus_worker_do_read_unlocked (GDBusWorker *worker)
+ /* if bytes_wanted is zero, it means start reading a message */
+ if (worker->read_buffer_bytes_wanted == 0)
+ {
+- worker->read_buffer_cur_size = 0;
+- worker->read_buffer_bytes_wanted = 16;
++ if (worker->socket != NULL)
++ {
++ worker->read_buffer_bytes_wanted = READ_BUFFER_MIN_BUFFER_SIZE;
++ }
++ else
++ {
++ worker->read_buffer_cur_size = 0;
++ worker->read_buffer_bytes_wanted = READ_BUFFER_MIN_READ_SIZE_FOR_HEADER;
++ }
+ }
+
+ /* ensure we have a (big enough) buffer */
+ if (worker->read_buffer == NULL || worker->read_buffer_bytes_wanted > worker->read_buffer_allocated_size)
+ {
+- /* TODO: 4096 is randomly chosen; might want a better chosen default minimum */
+- worker->read_buffer_allocated_size = MAX (worker->read_buffer_bytes_wanted, 4096);
++ worker->read_buffer_allocated_size = MAX (worker->read_buffer_bytes_wanted, READ_BUFFER_MIN_BUFFER_SIZE);
+ worker->read_buffer = g_realloc (worker->read_buffer, worker->read_buffer_allocated_size);
+ }
+
+diff --git a/gio/gdbusprivate.h b/gio/gdbusprivate.h
+index e7a5bfa..898b11d 100644
+--- a/gio/gdbusprivate.h
++++ b/gio/gdbusprivate.h
+@@ -31,16 +31,13 @@ G_BEGIN_DECLS
+
+ typedef struct GDBusWorker GDBusWorker;
+
+-typedef void (*GDBusWorkerMessageReceivedCallback) (GDBusWorker *worker,
+- GDBusMessage *message,
++typedef void (*GDBusWorkerMessageReceivedCallback) (GDBusMessage *message,
+ gpointer user_data);
+
+-typedef GDBusMessage *(*GDBusWorkerMessageAboutToBeSentCallback) (GDBusWorker *worker,
+- GDBusMessage *message,
++typedef GDBusMessage *(*GDBusWorkerMessageAboutToBeSentCallback) (GDBusMessage *message,
+ gpointer user_data);
+
+-typedef void (*GDBusWorkerDisconnectedCallback) (GDBusWorker *worker,
+- gboolean remote_peer_vanished,
++typedef void (*GDBusWorkerDisconnectedCallback) (gboolean remote_peer_vanished,
+ GError *error,
+ gpointer user_data);
+
+@@ -158,6 +155,17 @@ gchar *_g_dbus_hexencode (const gchar *str,
+ GDBusConnection *_g_bus_get_singleton_if_exists (GBusType bus_type);
+ void _g_bus_forget_singleton (GBusType bus_type);
+
++void g_dbus_message_init_header_iter (GDBusMessage *message,
++ GHashTableIter *iter);
++
++GObject *
++g_dbus_address_get_stream_internal (const gchar *address,
++ gboolean kdbus_okay,
++ gchar **out_uuid,
++ GCancellable *cancellable,
++ GError **error);
++
++
+ G_END_DECLS
+
+ #endif /* __G_DBUS_PRIVATE_H__ */
+diff --git a/gio/gdbusproxy.c b/gio/gdbusproxy.c
+index afc6fe9..3166dd6 100644
+--- a/gio/gdbusproxy.c
++++ b/gio/gdbusproxy.c
+@@ -2598,26 +2598,10 @@ out:
+ static const gchar *
+ get_destination_for_call (GDBusProxy *proxy)
+ {
+- const gchar *ret;
+-
+- ret = NULL;
+-
+- /* If proxy->priv->name is a unique name, then proxy->priv->name_owner
+- * is never NULL and always the same as proxy->priv->name. We use this
+- * knowledge to avoid checking if proxy->priv->name is a unique or
+- * well-known name.
+- */
+- ret = proxy->priv->name_owner;
+- if (ret != NULL)
+- goto out;
+-
+ if (proxy->priv->flags & G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START)
+- goto out;
+-
+- ret = proxy->priv->name;
++ return proxy->priv->name_owner;
+
+- out:
+- return ret;
++ return proxy->priv->name;
+ }
+
+ /* ---------------------------------------------------------------------------------------------------- */
+diff --git a/gio/gdbusutils.c b/gio/gdbusutils.c
+index 4b4b7e1..7fb3305 100644
+--- a/gio/gdbusutils.c
++++ b/gio/gdbusutils.c
+@@ -453,6 +453,11 @@ g_dbus_gvariant_to_gvalue (GVariant *value,
+ g_value_set_uint64 (out_gvalue, g_variant_get_uint64 (value));
+ break;
+
++ case G_VARIANT_CLASS_FLOAT:
++ g_value_init (out_gvalue, G_TYPE_FLOAT);
++ g_value_set_float (out_gvalue, g_variant_get_float (value));
++ break;
++
+ case G_VARIANT_CLASS_DOUBLE:
+ g_value_init (out_gvalue, G_TYPE_DOUBLE);
+ g_value_set_double (out_gvalue, g_variant_get_double (value));
+@@ -627,6 +632,10 @@ g_dbus_gvalue_to_gvariant (const GValue *gvalue,
+ ret = g_variant_ref_sink (g_variant_new_uint64 (g_value_get_uint64 (gvalue)));
+ break;
+
++ case G_VARIANT_CLASS_FLOAT:
++ ret = g_variant_ref_sink (g_variant_new_float (g_value_get_float (gvalue)));
++ break;
++
+ case G_VARIANT_CLASS_DOUBLE:
+ ret = g_variant_ref_sink (g_variant_new_double (g_value_get_double (gvalue)));
+ break;
+diff --git a/gio/gioenums.h b/gio/gioenums.h
+index c820cd3..c8b9eb1 100644
+--- a/gio/gioenums.h
++++ b/gio/gioenums.h
+@@ -999,6 +999,66 @@ typedef enum
+ /* When adding new flags, their numeric values must currently match those
+ * used in the D-Bus Specification. */
+
++/**
++ * GBusRequestNameReplyFlags:
++ * @G_BUS_REQUEST_NAME_FLAGS_ERROR: Error flag.
++ * @G_BUS_REQUEST_NAME_FLAGS_PRIMARY_OWNER: Caller is now the primary owner of the name, replacing
++ * any previous owner.
++ * @G_BUS_REQUEST_NAME_FLAGS_IN_QUEUE: The name already had an owner, the application will be
++ * placed in a queue.
++ * @G_BUS_REQUEST_NAME_FLAGS_EXISTS: The name already has an owner.
++ * @G_BUS_REQUEST_NAME_FLAGS_ALREADY_OWNER: The application trying to request ownership of a name
++ * is already the owner of it.
++ *
++ * Flags used in g_dbus_request_name().
++ *
++ * Since: 2.44
++ */
++typedef enum
++{
++ G_BUS_REQUEST_NAME_FLAGS_ERROR = 0,
++ G_BUS_REQUEST_NAME_FLAGS_PRIMARY_OWNER = 1,
++ G_BUS_REQUEST_NAME_FLAGS_IN_QUEUE = 2,
++ G_BUS_REQUEST_NAME_FLAGS_EXISTS = 3,
++ G_BUS_REQUEST_NAME_FLAGS_ALREADY_OWNER = 4
++} GBusRequestNameReplyFlags;
++
++/**
++ * GBusReleaseNameReplyFlags:
++ * @G_BUS_RELEASE_NAME_FLAGS_ERROR: Error flag.
++ * @G_BUS_RELEASE_NAME_FLAGS_RELEASED: The caller has released his claim on the given name.
++ * @G_BUS_RELEASE_NAME_FLAGS_NON_EXISTENT: The given name does not exist on this bus.
++ * @G_BUS_RELEASE_NAME_FLAGS_NOT_OWNER: The caller not waiting in the queue to own this name.
++ *
++ * Flags used in g_dbus_release_name().
++ *
++ * Since: 2.44
++ */
++typedef enum
++{
++ G_BUS_RELEASE_NAME_FLAGS_ERROR = 0,
++ G_BUS_RELEASE_NAME_FLAGS_RELEASED = 1,
++ G_BUS_RELEASE_NAME_FLAGS_NON_EXISTENT = 2,
++ G_BUS_RELEASE_NAME_FLAGS_NOT_OWNER = 3
++} GBusReleaseNameReplyFlags;
++
++/**
++ * GBusStartServiceReplyFlags:
++ * @G_BUS_START_SERVICE_REPLY_ERROR: Error flag.
++ * @G_BUS_START_SERVICE_REPLY_SUCCESS: The service was successfully started.
++ * @G_BUS_START_SERVICE_REPLY_ALREADY_RUNNING: A connection already owns the given name.
++ *
++ * Flags used in g_dbus_start_service_by_name().
++ *
++ * Since: 2.44
++ */
++typedef enum
++{
++ G_BUS_START_SERVICE_REPLY_ERROR = 0,
++ G_BUS_START_SERVICE_REPLY_SUCCESS = 1,
++ G_BUS_START_SERVICE_REPLY_ALREADY_RUNNING = 2
++} GBusStartServiceReplyFlags;
++
+ /**
+ * GBusNameWatcherFlags:
+ * @G_BUS_NAME_WATCHER_FLAGS_NONE: No flags set.
+diff --git a/gio/gkdbus.c b/gio/gkdbus.c
+new file mode 100755
+index 0000000..aeb4408
+--- /dev/null
++++ b/gio/gkdbus.c
+@@ -0,0 +1,4356 @@
++/* GIO - GLib Input, Output and Streaming Library
++ *
++ * Copyright (C) 2015 Samsung Electronics
++ *
++ * This library is free software; you can redistribute it and/or
++ * modify it under the terms of the GNU Lesser General Public
++ * License as published by the Free Software Foundation; either
++ * version 2 of the License, or (at your option) any later version.
++ *
++ * This library is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
++ * Lesser General Public License for more details.
++ *
++ * You should have received a copy of the GNU Lesser General
++ * Public License along with this library; if not, write to the
++ * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
++ * Boston, MA 02111-1307, USA.
++ *
++ * Author: Lukasz Skalski <l.skalski@samsung.com>
++ * Author: Adrian Szyndela <adrian.s@samsung.com>
++ * Author: Michal Eljasiewicz <m.eljasiewic@samsung.com>
++ */
++
++#include "config.h"
++#include "gdbusconnection.h" /* DBUS_DEFAULT_TIMEOUT_MSEC */
++#include "gkdbus.h"
++#include "glib-unix.h"
++#include "glib-linux.h"
++#include "glibintl.h"
++#include "gvariant-serialiser.h"
++#include <linux/kdbus.h>
++
++#include <gio/gio.h>
++#include <errno.h>
++#include <string.h>
++#include <sys/mman.h>
++#include <sys/ioctl.h>
++#include <stdio.h>
++#include <stdint.h>
++
++#ifdef HAVE_SYS_FILIO_H
++#include <sys/filio.h>
++#endif
++
++#ifdef HAVE_SYS_UIO_H
++#include <sys/uio.h>
++#endif
++
++#ifdef LIBDBUSPOLICY
++#include <dbuspolicy/libdbuspolicy1.h>
++#endif
++
++#define DBUS_DAEMON_EMULATION
++#ifdef DBUS_DAEMON_EMULATION
++#include "gkdbusfakedaemon.h"
++#endif
++
++#include <glib/gstdio.h>
++#include <glib/glib-private.h>
++#include <gio/gio.h>
++#include <gio/gunixfdlist.h>
++
++#include "glibintl.h"
++#include "gunixfdmessage.h"
++
++#define KDBUS_MSG_MAX_SIZE 8192
++#define KDBUS_INFINITE_TIMEOUT_NS 0x3fffffffffffffffLLU
++
++#define RECEIVE_POOL_SIZE_DEFAULT_SIZE (16 * 1024LU * 1024LU)
++#define RECEIVE_POOL_SIZE_ENV_VAR_NAME "KDBUS_MEMORY_POOL_SIZE"
++#define RECEIVE_POOL_SIZE_MAX_MBYTES 64
++#define RECEIVE_POOL_SIZE_MIN_KBYTES 16
++
++#define KDBUS_MEMFD_THRESHOLD (512 * 1024LU)
++#define KDBUS_MSG_MAX_PAYLOAD_VEC_SIZE 0x00200000 /* maximum size of message header and items */
++
++#define KDBUS_ALIGN8(l) (((l) + 7) & ~7)
++#define KDBUS_ALIGN8_PTR(p) ((void*) (uintptr_t)(p))
++
++#define KDBUS_ITEM_HEADER_SIZE G_STRUCT_OFFSET(struct kdbus_item, data)
++#define KDBUS_ITEM_SIZE(s) KDBUS_ALIGN8((s) + KDBUS_ITEM_HEADER_SIZE)
++
++#define KDBUS_ITEM_NEXT(item) \
++ (typeof(item))(((guint8 *)item) + KDBUS_ALIGN8((item)->size))
++#define KDBUS_ITEM_FOREACH(item, head, first) \
++ 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))
++
++struct dbus_fixed_header {
++ guint8 endian;
++ guint8 type;
++ guint8 flags;
++ guint8 version;
++ guint32 reserved;
++ guint64 serial;
++};
++
++#define DBUS_FIXED_HEADER_TYPE ((const GVariantType *) "(yyyyut)")
++#define DBUS_EXTENDED_HEADER_TYPE ((const GVariantType *) "a{tv}")
++#define DBUS_MESSAGE_TYPE ((const GVariantType *) "((yyyyut)a{tv}v)")
++
++/*
++ * Macros for SipHash algorithm
++ */
++
++#define ROTL(x,b) (guint64)( ((x) << (b)) | ( (x) >> (64 - (b))) )
++
++#define U32TO8_LE(p, v) \
++ (p)[0] = (guint8)((v) ); (p)[1] = (guint8)((v) >> 8); \
++ (p)[2] = (guint8)((v) >> 16); (p)[3] = (guint8)((v) >> 24);
++
++#define U64TO8_LE(p, v) \
++ U32TO8_LE((p), (guint32)((v) )); \
++ U32TO8_LE((p) + 4, (guint32)((v) >> 32));
++
++#define U8TO64_LE(p) \
++ (((guint64)((p)[0]) ) | \
++ ((guint64)((p)[1]) << 8) | \
++ ((guint64)((p)[2]) << 16) | \
++ ((guint64)((p)[3]) << 24) | \
++ ((guint64)((p)[4]) << 32) | \
++ ((guint64)((p)[5]) << 40) | \
++ ((guint64)((p)[6]) << 48) | \
++ ((guint64)((p)[7]) << 56))
++
++#define SIPROUND \
++ do { \
++ v0 += v1; v1=ROTL(v1,13); v1 ^= v0; v0=ROTL(v0,32); \
++ v2 += v3; v3=ROTL(v3,16); v3 ^= v2; \
++ v0 += v3; v3=ROTL(v3,21); v3 ^= v0; \
++ v2 += v1; v1=ROTL(v1,17); v1 ^= v2; v2=ROTL(v2,32); \
++ } while(0)
++
++typedef GObjectClass GKDBusWorkerClass;
++
++struct _GKDBusWorker
++{
++ GObject parent_instance;
++
++ const gchar *address;
++ gint fd;
++
++ GMainContext *context;
++ GMainLoop *loop;
++ GThread *thread;
++ GSource *source;
++
++ gchar *kdbus_buffer;
++ guint64 receive_pool_size;
++ gchar *unique_name;
++ guint64 unique_id;
++
++ guint64 flags;
++ guint64 attach_flags_send;
++ guint64 attach_flags_recv;
++
++ gsize bloom_size;
++ guint bloom_n_hash;
++
++ guint closed : 1;
++ guint inited : 1;
++ guint timeout;
++ guint timed_out : 1;
++
++ guchar bus_id[16];
++
++ GMutex matches_mutex;
++ GList *matches;
++
++#ifdef LIBDBUSPOLICY
++ void *dbuspolicy;
++#endif
++
++ GDBusCapabilityFlags capabilities;
++ GDBusWorkerMessageReceivedCallback message_received_callback;
++ GDBusWorkerMessageAboutToBeSentCallback message_about_to_be_sent_callback;
++ GDBusWorkerDisconnectedCallback disconnected_callback;
++ gpointer user_data;
++};
++
++static gboolean _g_kdbus_send (GKDBusWorker *worker,
++ GDBusMessage *message,
++ GDBusMessage **reply,
++ gint timeout_msec,
++ GCancellable *cancellable,
++ GError **error);
++
++static void _g_kdbus_receive (GKDBusWorker *worker,
++ GError **error);
++
++G_DEFINE_TYPE (GKDBusWorker, g_kdbus_worker, G_TYPE_OBJECT)
++
++/* Hash keys for bloom filters*/
++const guint8 hash_keys[8][16] =
++{
++ {0xb9,0x66,0x0b,0xf0,0x46,0x70,0x47,0xc1,0x88,0x75,0xc4,0x9c,0x54,0xb9,0xbd,0x15},
++ {0xaa,0xa1,0x54,0xa2,0xe0,0x71,0x4b,0x39,0xbf,0xe1,0xdd,0x2e,0x9f,0xc5,0x4a,0x3b},
++ {0x63,0xfd,0xae,0xbe,0xcd,0x82,0x48,0x12,0xa1,0x6e,0x41,0x26,0xcb,0xfa,0xa0,0xc8},
++ {0x23,0xbe,0x45,0x29,0x32,0xd2,0x46,0x2d,0x82,0x03,0x52,0x28,0xfe,0x37,0x17,0xf5},
++ {0x56,0x3b,0xbf,0xee,0x5a,0x4f,0x43,0x39,0xaf,0xaa,0x94,0x08,0xdf,0xf0,0xfc,0x10},
++ {0x31,0x80,0xc8,0x73,0xc7,0xea,0x46,0xd3,0xaa,0x25,0x75,0x0f,0x9e,0x4c,0x09,0x29},
++ {0x7d,0xf7,0x18,0x4b,0x7b,0xa4,0x44,0xd5,0x85,0x3c,0x06,0xe0,0x65,0x53,0x96,0x6d},
++ {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,
++};
++
++static guint64 _global_match_cookie = 1;
++
++/* MatchElement struct */
++typedef struct {
++ guint16 type;
++ guint16 arg;
++ char *value;
++} MatchElement;
++
++/* Match struct */
++typedef struct {
++ int n_elements;
++ MatchElement *elements;
++ guint64 cookie;
++} Match;
++
++
++/*
++ * SipHash algorithm
++ */
++static void
++_g_siphash24 (guint8 out[8],
++ const void *_in,
++ gsize inlen,
++ const guint8 k[16])
++{
++ /* "somepseudorandomlygeneratedbytes" */
++ guint64 v0 = 0x736f6d6570736575ULL;
++ guint64 v1 = 0x646f72616e646f6dULL;
++ guint64 v2 = 0x6c7967656e657261ULL;
++ guint64 v3 = 0x7465646279746573ULL;
++ guint64 b;
++ guint64 k0 = U8TO64_LE (k);
++ guint64 k1 = U8TO64_LE (k + 8);
++ guint64 m;
++ const guint8 *in = _in;
++ const guint8 *end = in + inlen - (inlen % sizeof(guint64));
++ const int left = inlen & 7;
++ b = ((guint64) inlen) << 56;
++ v3 ^= k1;
++ v2 ^= k0;
++ v1 ^= k1;
++ v0 ^= k0;
++
++ for (; in != end; in += 8)
++ {
++ m = U8TO64_LE (in);
++ v3 ^= m;
++ SIPROUND;
++ SIPROUND;
++ v0 ^= m;
++ }
++
++ switch (left)
++ {
++ case 7: b |= ((guint64) in[6]) << 48;
++ case 6: b |= ((guint64) in[5]) << 40;
++ case 5: b |= ((guint64) in[4]) << 32;
++ case 4: b |= ((guint64) in[3]) << 24;
++ case 3: b |= ((guint64) in[2]) << 16;
++ case 2: b |= ((guint64) in[1]) << 8;
++ case 1: b |= ((guint64) in[0]); break;
++ case 0: break;
++ }
++
++ v3 ^= b;
++ SIPROUND;
++ SIPROUND;
++ v0 ^= b;
++
++ v2 ^= 0xff;
++ SIPROUND;
++ SIPROUND;
++ SIPROUND;
++ SIPROUND;
++ b = v0 ^ v1 ^ v2 ^ v3;
++ U64TO8_LE (out, b);
++}
++
++/* ---------------------------------------------------------------------------------------------------- */
++
++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;
++}
++
++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;
++}
++
++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;
++}
++
++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);
++ match->cookie = _global_match_cookie++;
++
++ 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;
++}
++
++static gboolean
++match_equal (Match *a, Match *b)
++{
++ int i;
++
++ if (a->n_elements != b->n_elements)
++ return FALSE;
++
++ for (i = 0; i < a->n_elements; i++)
++ {
++ if (a->elements[i].type != b->elements[i].type ||
++ a->elements[i].arg != b->elements[i].arg ||
++ strcmp (a->elements[i].value, b->elements[i].value) != 0)
++ return FALSE;
++ }
++
++ return TRUE;
++}
++
++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_open
++ */
++gboolean
++_g_kdbus_open (GKDBusWorker *worker,
++ const gchar *address,
++ GError **error)
++{
++ g_return_val_if_fail (G_IS_KDBUS_WORKER (worker), FALSE);
++ g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
++
++ worker->fd = g_open(address, O_RDWR|O_NOCTTY|O_CLOEXEC, 0);
++ if (worker->fd<0)
++ {
++ g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_FAILED, _("Cannot open kdbus endpoint"));
++ return FALSE;
++ }
++
++ worker->address = g_strdup(address);
++ worker->closed = FALSE;
++ return TRUE;
++}
++
++static gboolean
++_g_kdbus_quit_loop (gpointer loop)
++{
++ g_main_loop_quit ((GMainLoop*)loop);
++ return FALSE;
++}
++
++gboolean
++_g_kdbus_can_connect (GKDBusWorker *worker,
++ GError **error)
++{
++#ifdef LIBDBUSPOLICY
++ worker->dbuspolicy = dbuspolicy1_init_shared (worker->address, worker->fd);
++ if (worker->dbuspolicy == NULL)
++ {
++ g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_FAILED, _("Cannot load dbus policy for kdbus transport or access to bus denied by security policy"));
++ return FALSE;
++ }
++#endif
++ return TRUE;
++}
++
++/*
++ * _g_kdbus_close
++ */
++gboolean
++_g_kdbus_close (GKDBusWorker *worker)
++{
++ g_return_val_if_fail (G_IS_KDBUS_WORKER (worker), FALSE);
++
++ if (worker->closed)
++ return TRUE;
++
++ g_main_context_invoke (worker->context, _g_kdbus_quit_loop, worker->loop);
++
++ g_main_context_unref (worker->context);
++ worker->context = NULL;
++
++ g_main_loop_unref (worker->loop);
++
++ g_thread_unref(worker->thread);
++
++ worker->thread = NULL;
++
++ g_free ((char*)worker->address);
++
++ close (worker->fd);
++ worker->fd = -1;
++
++ worker->closed = TRUE;
++ return TRUE;
++}
++
++/*
++ * _g_kdbus_is_closed
++ */
++gboolean
++_g_kdbus_is_closed (GKDBusWorker *worker)
++{
++ g_return_val_if_fail (G_IS_KDBUS_WORKER (worker), FALSE);
++
++ return worker->closed;
++}
++
++static void
++g_kdbus_free_data (GKDBusWorker *worker,
++ guint64 offset)
++{
++ struct kdbus_cmd_free cmd = {
++ .size = sizeof(cmd),
++ .offset = offset,
++ .flags = 0
++ };
++
++ if (ioctl (worker->fd, KDBUS_CMD_FREE, &cmd) < 0)
++ {
++ g_error ("kdbus: invalid KDBUS_CMD_FREE ioctl : %" G_GUINT64_FORMAT " offset\n", offset);
++ }
++}
++
++static void
++g_kdbus_close_msg (GKDBusWorker *worker,
++ struct kdbus_msg *msg)
++{
++ guint64 offset;
++
++ offset = (guint8 *)msg - (guint8 *)worker->kdbus_buffer;
++ g_kdbus_free_data (worker, offset);
++}
++
++
++/*
++ * g_kdbus_translate_nameowner_flags
++ */
++static void
++g_kdbus_translate_nameowner_flags (GBusNameOwnerFlags flags,
++ guint64 *kdbus_flags)
++{
++ guint64 new_flags;
++
++ new_flags = 0;
++
++ if (flags & G_BUS_NAME_OWNER_FLAGS_ALLOW_REPLACEMENT)
++ new_flags |= KDBUS_NAME_ALLOW_REPLACEMENT;
++
++ if (flags & G_BUS_NAME_OWNER_FLAGS_REPLACE)
++ new_flags |= KDBUS_NAME_REPLACE_EXISTING;
++
++ if (!(flags & G_BUS_NAME_OWNER_FLAGS_DO_NOT_QUEUE))
++ new_flags |= KDBUS_NAME_QUEUE;
++
++ *kdbus_flags = new_flags;
++}
++
++/* ---------------------------------------------------------------------------------------------------- */
++
++/* < internal >
++ *
++ * _g_kdbus_Hello:
++ *
++ * Gets the unique name.
++ *
++ * Returns: the unique name or NULL. Do not free this string,
++ * it is owned by GKDBusWorker.
++ */
++const gchar *
++_g_kdbus_Hello (GKDBusWorker *worker,
++ GError **error)
++{
++ struct kdbus_cmd_hello *cmd;
++ struct kdbus_bloom_parameter *bloom;
++ struct kdbus_item *item, *items;
++
++ gchar *conn_name;
++ size_t size, conn_name_size;
++
++ const gchar *env_pool;
++ guint64 receive_pool_size = RECEIVE_POOL_SIZE_DEFAULT_SIZE;
++
++ conn_name = "gdbus-kdbus";
++ conn_name_size = strlen (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);
++
++ 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;
++
++ env_pool = getenv (RECEIVE_POOL_SIZE_ENV_VAR_NAME);
++ if(env_pool)
++ {
++ guint64 size;
++ guint32 multiply = 1;
++ gint64 page_size;
++
++ page_size = sysconf(_SC_PAGESIZE);
++ if(page_size == -1)
++ {
++ size = 0;
++ goto finish;
++ }
++
++ errno = 0;
++ size = strtoul(env_pool, (char**)&env_pool, 10);
++ if(errno == EINVAL || size == 0)
++ {
++ size = 0;
++ goto finish;
++ }
++
++ if(*env_pool == 'k')
++ {
++ multiply = 1024;
++ env_pool++;
++ }
++ else if (*env_pool == 'M')
++ {
++ multiply = 1024 * 1024;
++ env_pool++;
++ }
++
++ if(*env_pool != '\0')
++ {
++ size = 0;
++ goto finish;
++ }
++
++ receive_pool_size = size * multiply;
++
++ if((receive_pool_size > RECEIVE_POOL_SIZE_MAX_MBYTES * 1024 * 1024) ||
++ (receive_pool_size < RECEIVE_POOL_SIZE_MIN_KBYTES * 1024) ||
++ ((receive_pool_size & (page_size - 1)) != 0))
++ size = 0;
++
++ finish:
++ if(size == 0)
++ {
++ g_warning ("%s value is invalid, default value %luB will be used.", RECEIVE_POOL_SIZE_ENV_VAR_NAME,
++ RECEIVE_POOL_SIZE_DEFAULT_SIZE);
++ g_warning ("Correct value must be between %ukB and %uMB and must be aligned to page size: %" G_GINT64_FORMAT "B.",
++ RECEIVE_POOL_SIZE_MIN_KBYTES, RECEIVE_POOL_SIZE_MAX_MBYTES, page_size);
++
++ receive_pool_size = RECEIVE_POOL_SIZE_DEFAULT_SIZE;
++ }
++ }
++
++ g_debug ("[KDBUS] receive pool size set to %" G_GUINT64_FORMAT "\n", receive_pool_size);
++ worker->receive_pool_size = receive_pool_size;
++ cmd->pool_size = worker->receive_pool_size;
++
++ item = cmd->items;
++ item->size = (guint64) 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 (worker->unique_id != -1)
++ {
++ g_set_error (error, G_DBUS_ERROR,
++ G_DBUS_ERROR_FAILED,
++ "Already handled an Hello message");
++ return NULL;
++ }
++
++ if (ioctl(worker->fd, KDBUS_CMD_HELLO, cmd))
++ {
++ g_set_error (error, G_IO_ERROR,
++ g_io_error_from_errno (errno),
++ _("Failed to send HELLO: %s"),
++ g_strerror (errno));
++ return NULL;
++ }
++
++ worker->kdbus_buffer = mmap(NULL, worker->receive_pool_size, PROT_READ, MAP_SHARED, worker->fd, 0);
++ if (worker->kdbus_buffer == MAP_FAILED)
++ {
++ g_set_error (error, G_IO_ERROR,
++ g_io_error_from_errno (errno),
++ _("mmap error: %s"),
++ g_strerror (errno));
++ return NULL;
++ }
++
++ if (cmd->bus_flags > 0xFFFFFFFFULL)
++ {
++ g_set_error_literal (error,
++ G_IO_ERROR,
++ G_IO_ERROR_FAILED,
++ _("Incompatible HELLO flags"));
++ return NULL;
++ }
++
++ memcpy (worker->bus_id, cmd->id128, 16);
++
++ worker->unique_id = cmd->id;
++ if (asprintf (&worker->unique_name, ":1.%llu", (unsigned long long) cmd->id) < 0)
++ {
++ g_set_error (error,
++ G_IO_ERROR,
++ G_IO_ERROR_UNKNOWN,
++ "asprintf error: %s",
++ g_strerror(errno));
++ return NULL;
++ }
++
++ /* read bloom filters parameters */
++ bloom = NULL;
++ items = (void*)(worker->kdbus_buffer + cmd->offset);
++ KDBUS_FOREACH(item, items, cmd->items_size)
++ {
++ switch (item->type)
++ {
++ case KDBUS_ITEM_BLOOM_PARAMETER:
++ bloom = &item->bloom_parameter;
++ break;
++ }
++ }
++
++ if (bloom != NULL)
++ {
++ worker->bloom_size = (gsize) bloom->size;
++ worker->bloom_n_hash = (guint) bloom->n_hash;
++ }
++ else
++ {
++ g_set_error_literal (error,
++ G_IO_ERROR,
++ G_IO_ERROR_FAILED,
++ _("Can't read bloom filter parameters"));
++ return NULL;
++ }
++
++ g_kdbus_free_data (worker, cmd->offset);
++
++#ifdef LIBDBUSPOLICY
++ dbuspolicy1_init_set_pool (worker->dbuspolicy, worker->kdbus_buffer);
++#endif
++
++ return worker->unique_name;
++}
++
++
++/* < internal >
++ *
++ * _g_kdbus_RequestName:
++ *
++ * Synchronously acquires name on the bus and returns status code
++ * from the GBusRequestNameReplyFlags enumeration.
++ *
++ * Returns: status code or G_BUS_REQUEST_NAME_FLAGS_ERROR
++ * if error is set.
++ */
++GBusRequestNameReplyFlags
++_g_kdbus_RequestName (GKDBusWorker *worker,
++ const gchar *name,
++ GBusNameOwnerFlags flags,
++ GError **error)
++{
++ GBusRequestNameReplyFlags status;
++ struct kdbus_cmd *cmd;
++ guint64 kdbus_flags;
++ gsize len, size;
++ gint ret;
++
++ status = G_BUS_REQUEST_NAME_FLAGS_PRIMARY_OWNER;
++
++ if (!g_dbus_is_name (name))
++ {
++ g_set_error (error,
++ G_DBUS_ERROR,
++ G_DBUS_ERROR_INVALID_ARGS,
++ "Given bus name \"%s\" is not valid", name);
++ return G_BUS_REQUEST_NAME_FLAGS_ERROR;
++ }
++
++ if (g_strcmp0 (name, "org.freedesktop.DBus") == 0)
++ {
++ g_set_error (error,
++ G_DBUS_ERROR,
++ G_DBUS_ERROR_INVALID_ARGS,
++ "Cannot acquire a service named '%s', because that is reserved", name);
++ return G_BUS_REQUEST_NAME_FLAGS_ERROR;
++ }
++
++ if (*name == ':')
++ {
++ g_set_error (error,
++ G_DBUS_ERROR,
++ G_DBUS_ERROR_INVALID_ARGS,
++ "Cannot acquire a service starting with ':' such as \"%s\"", name);
++ return G_BUS_REQUEST_NAME_FLAGS_ERROR;
++ }
++
++#ifdef LIBDBUSPOLICY
++ if (worker->dbuspolicy != NULL)
++ {
++ if (dbuspolicy1_can_own (worker->dbuspolicy, name) != 1)
++ {
++ g_set_error (error,
++ G_DBUS_ERROR,
++ G_DBUS_ERROR_ACCESS_DENIED,
++ "Connection \"%s\" is not allowed to own the "
++ "service \"%s\" due to security policies", worker->unique_name, name);
++ return G_BUS_REQUEST_NAME_FLAGS_ERROR;
++ }
++ }
++#endif
++
++ g_kdbus_translate_nameowner_flags (flags, &kdbus_flags);
++
++ len = strlen(name) + 1;
++ size = (gulong) 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)
++ status = G_BUS_REQUEST_NAME_FLAGS_EXISTS;
++ else if (errno == EALREADY)
++ status = G_BUS_REQUEST_NAME_FLAGS_ALREADY_OWNER;
++ else
++ {
++ g_set_error (error, G_IO_ERROR,
++ g_io_error_from_errno (errno),
++ _("Error while acquiring name: %s"),
++ g_strerror (errno));
++ return G_BUS_REQUEST_NAME_FLAGS_ERROR;
++ }
++ }
++ else if ((cmd->return_flags & KDBUS_NAME_PRIMARY)
++ && !(cmd->return_flags & KDBUS_NAME_ACQUIRED))
++ status = G_BUS_REQUEST_NAME_FLAGS_ALREADY_OWNER;
++
++ if (cmd->return_flags & KDBUS_NAME_IN_QUEUE)
++ status = G_BUS_REQUEST_NAME_FLAGS_IN_QUEUE;
++
++ return status;
++}
++
++
++/* < internal >
++ *
++ * _g_kdbus_ReleaseName:
++ *
++ * Synchronously releases name on the bus and returns status code
++ * from the GBusReleaseNameReplyFlags enumeration.
++ *
++ * Returns: status code or G_BUS_RELEASE_NAME_FLAGS_ERROR
++ * if error is set.
++ */
++GBusReleaseNameReplyFlags
++_g_kdbus_ReleaseName (GKDBusWorker *worker,
++ const gchar *name,
++ GError **error)
++{
++ GBusReleaseNameReplyFlags status;
++ struct kdbus_cmd *cmd;
++ gsize len, size;
++ gint ret;
++
++ status = G_BUS_RELEASE_NAME_FLAGS_RELEASED;
++
++ if (!g_dbus_is_name (name))
++ {
++ g_set_error (error,
++ G_DBUS_ERROR,
++ G_DBUS_ERROR_INVALID_ARGS,
++ "Given bus name \"%s\" is not valid", name);
++ return G_BUS_RELEASE_NAME_FLAGS_ERROR;
++ }
++
++ if (g_strcmp0 (name, "org.freedesktop.DBus") == 0)
++ {
++ g_set_error (error,
++ G_DBUS_ERROR,
++ G_DBUS_ERROR_INVALID_ARGS,
++ "Cannot release a service named '%s', because that is owned by the bus", name);
++ return G_BUS_RELEASE_NAME_FLAGS_ERROR;
++ }
++
++ if (*name == ':')
++ {
++ g_set_error (error,
++ G_DBUS_ERROR,
++ G_DBUS_ERROR_INVALID_ARGS,
++ "Cannot release a service starting with ':' such as \"%s\"", name);
++ return G_BUS_RELEASE_NAME_FLAGS_ERROR;
++ }
++
++ len = strlen(name) + 1;
++ size = (gulong) 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)
++ status = G_BUS_RELEASE_NAME_FLAGS_NON_EXISTENT;
++ else if (errno == EADDRINUSE)
++ status = G_BUS_RELEASE_NAME_FLAGS_NOT_OWNER;
++ else
++ {
++ g_set_error (error, G_IO_ERROR,
++ g_io_error_from_errno (errno),
++ _("Error while releasing name: %s"),
++ g_strerror (errno));
++ return G_BUS_RELEASE_NAME_FLAGS_ERROR;
++ }
++ }
++
++ return status;
++}
++
++
++/* < internal >
++ *
++ * _g_kdbus_GetBusId:
++ *
++ * Synchronously returns the unique ID of the bus.
++ *
++ * Returns: the unique ID of the bus or NULL if error is set.
++ * Free with g_free().
++ */
++gchar *
++_g_kdbus_GetBusId (GKDBusWorker *worker,
++ GError **error)
++{
++ GString *result;
++ guint cnt;
++
++ result = g_string_new (NULL);
++
++ for (cnt=0; cnt<16; cnt++)
++ g_string_append_printf (result, "%02x", worker->bus_id[cnt]);
++
++ return g_string_free (result, FALSE);
++}
++
++
++static void
++expand_strv (gchar ***strv_ptr,
++ gchar *value)
++{
++ gchar **strv;
++ guint strv_len;
++
++ if (!value)
++ return;
++
++ strv = *strv_ptr;
++ strv_len = g_strv_length (strv);
++
++ strv = g_renew (gchar *, strv, strv_len + 2);
++ strv[strv_len] = value;
++ strv[strv_len + 1] = NULL;
++
++ *strv_ptr = strv;
++}
++
++
++/* < internal >
++ *
++ * _g_kdbus_GetListNames:
++ *
++ * Synchronously returns a list of:
++ * - all currently-owned names on the bus (activatable = FALSE),
++ * - all names that can be activated on the bus (activatable = TRUE),
++ *
++ * or NULL if error is set. Free with g_strfreev().
++ */
++gchar **
++_g_kdbus_GetListNames (GKDBusWorker *worker,
++ gboolean activatable,
++ GError **error)
++{
++ struct kdbus_info *name_list, *name;
++ struct kdbus_cmd_list cmd = {
++ .size = sizeof(cmd)
++ };
++
++ gchar **listnames;
++ guint64 prev_id;
++ gint ret;
++
++ prev_id = 0;
++
++ if (activatable)
++ cmd.flags = KDBUS_LIST_ACTIVATORS; /* ListActivatableNames */
++ else
++ cmd.flags = KDBUS_LIST_UNIQUE | KDBUS_LIST_NAMES; /* ListNames */
++
++ ret = ioctl(worker->fd, KDBUS_CMD_LIST, &cmd);
++ if (ret < 0)
++ {
++ g_set_error (error,
++ G_DBUS_ERROR,
++ G_DBUS_ERROR_FAILED,
++ _("Error listing names"));
++ return NULL;
++ }
++
++ listnames = g_new0 (gchar *, 1);
++ name_list = (struct kdbus_info *) ((guint8 *) worker->kdbus_buffer + cmd.offset);
++
++ KDBUS_FOREACH (name, name_list, cmd.list_size)
++ {
++ struct kdbus_item *item;
++
++ if ((cmd.flags & KDBUS_LIST_UNIQUE) && name->id != prev_id)
++ {
++ gchar *unique_name;
++
++ if (asprintf (&unique_name, ":1.%llu", name->id) < 0)
++ {
++ g_set_error (error,
++ G_IO_ERROR,
++ G_IO_ERROR_UNKNOWN,
++ "asprintf error: %s",
++ g_strerror(errno));
++ goto error;
++ }
++
++ expand_strv (&listnames, unique_name);
++ prev_id = name->id;
++ }
++
++ KDBUS_ITEM_FOREACH (item, name, items)
++ {
++ if (item->type == KDBUS_ITEM_OWNED_NAME)
++ {
++ if (g_dbus_is_name (item->name.name))
++ expand_strv (&listnames, g_strdup (item->name.name));
++ }
++ }
++ }
++
++ /* org.freedesktop.DBus.ListNames */
++ if (!activatable)
++ expand_strv (&listnames, g_strdup ("org.freedesktop.DBus"));
++
++ g_kdbus_free_data (worker, cmd.offset);
++
++ return listnames;
++
++error:
++ g_strfreev(listnames);
++ return NULL;
++}
++
++
++static gboolean
++g_kdbus_NameHasOwner_internal (GKDBusWorker *worker,
++ const gchar *name)
++{
++ struct kdbus_cmd_info *cmd;
++ struct kdbus_info *conn_info;
++ gsize size, len;
++ gint ret;
++
++ if (g_dbus_is_unique_name(name))
++ {
++ size = (gulong) G_STRUCT_OFFSET (struct kdbus_cmd_info, items);
++ cmd = g_alloca0 (size);
++ cmd->id = g_ascii_strtoull (name+3, NULL, 10);
++ }
++ else
++ {
++ len = strlen(name) + 1;
++ size = (gulong) G_STRUCT_OFFSET (struct kdbus_cmd_info, items) + KDBUS_ITEM_SIZE(len);
++ cmd = g_alloca0 (size);
++ cmd->items[0].size = KDBUS_ITEM_HEADER_SIZE + len;
++ cmd->items[0].type = KDBUS_ITEM_NAME;
++ memcpy (cmd->items[0].str, name, len);
++ }
++ cmd->size = size;
++
++ ret = ioctl(worker->fd, KDBUS_CMD_CONN_INFO, cmd);
++ if (ret < 0)
++ return FALSE;
++
++ conn_info = (struct kdbus_info *) ((guint8 *) worker->kdbus_buffer + cmd->offset);
++
++ if (conn_info->flags & KDBUS_HELLO_ACTIVATOR)
++ ret = -1;
++
++ g_kdbus_free_data (worker, cmd->offset);
++
++ if (ret < 0)
++ return FALSE;
++ else
++ return TRUE;
++}
++
++
++/* < internal >
++ *
++ * _g_kdbus_GetListQueuedOwners:
++ *
++ * Synchronously returns the unique bus names of connections currently
++ * queued for the name.
++ *
++ * Returns: the unique bus names of connections currently queued for the
++ * 'name' or NULL if error is set. Free with g_strfreev().
++ */
++gchar **
++_g_kdbus_GetListQueuedOwners (GKDBusWorker *worker,
++ const gchar *name,
++ GError **error)
++{
++ struct kdbus_info *name_list, *kname;
++ struct kdbus_cmd_list cmd = {
++ .size = sizeof(cmd),
++ .flags = KDBUS_LIST_QUEUED
++ };
++
++ gchar **queued_owners;
++ gint ret;
++
++ if (!g_dbus_is_name (name))
++ {
++ g_set_error (error,
++ G_DBUS_ERROR,
++ G_DBUS_ERROR_INVALID_ARGS,
++ "Given bus name \"%s\" is not valid", name);
++ return NULL;
++ }
++
++ if (!g_kdbus_NameHasOwner_internal (worker, name))
++ {
++ g_set_error (error,
++ G_DBUS_ERROR,
++ G_DBUS_ERROR_NAME_HAS_NO_OWNER,
++ "Could not get owner of name '%s': no such name", name);
++ return NULL;
++ }
++
++ ret = ioctl(worker->fd, KDBUS_CMD_LIST, &cmd);
++ if (ret < 0)
++ {
++ g_set_error (error,
++ G_DBUS_ERROR,
++ G_DBUS_ERROR_FAILED,
++ _("Error listing names"));
++ return NULL;
++ }
++
++ queued_owners = g_new0 (gchar *, 1);
++ name_list = (struct kdbus_info *) ((guint8 *) worker->kdbus_buffer + cmd.offset);
++
++ KDBUS_FOREACH(kname, name_list, cmd.list_size)
++ {
++ struct kdbus_item *item;
++
++ KDBUS_ITEM_FOREACH(item, kname, items)
++ {
++ if (item->type == KDBUS_ITEM_OWNED_NAME)
++ {
++ gchar *unique_name;
++
++ if (strcmp(item->name.name, name))
++ continue;
++
++ if (asprintf (&unique_name, ":1.%llu", kname->id) != -1)
++ expand_strv (&queued_owners, unique_name);
++ }
++ }
++ }
++
++ g_kdbus_free_data (worker, cmd.offset);
++
++ return queued_owners;
++}
++
++
++/* < internal >
++ *
++ * _g_kdbus_NameHasOwner:
++ *
++ * Checks if the specified name exists (currently has an owner).
++ *
++ * Returns: TRUE if the name exists and FALSE when name doesn't exists
++ * or error is set.
++ */
++gboolean
++_g_kdbus_NameHasOwner (GKDBusWorker *worker,
++ const gchar *name,
++ GError **error)
++{
++ if (!g_dbus_is_name (name))
++ {
++ g_set_error (error,
++ G_DBUS_ERROR,
++ G_DBUS_ERROR_INVALID_ARGS,
++ "Given bus name \"%s\" is not valid", name);
++ return FALSE;
++ }
++
++ if (g_strcmp0 (name, "org.freedesktop.DBus") == 0)
++ return TRUE;
++
++ if (!g_kdbus_NameHasOwner_internal (worker, name))
++ return FALSE; /* Don't make g_set_error, otherwise NameHasOwner will fail. */
++ else
++ return TRUE;
++}
++
++
++GDBusCredentials *
++_g_kdbus_GetConnInfo (GKDBusWorker *worker,
++ const gchar *name,
++ guint flags,
++ GError **error)
++{
++ GDBusCredentials *creds;
++ struct kdbus_cmd_info *cmd;
++ struct kdbus_info *conn_info;
++ struct kdbus_item *item;
++ gsize size, len;
++ gint ret;
++
++ creds = g_new0 (GDBusCredentials, 1);
++
++ if (!g_dbus_is_name (name))
++ {
++ g_set_error (error,
++ G_DBUS_ERROR,
++ G_DBUS_ERROR_INVALID_ARGS,
++ "Given bus name \"%s\" is not valid", name);
++ goto error;
++ }
++
++ if (!g_kdbus_NameHasOwner_internal (worker, name))
++ {
++ g_set_error (error,
++ G_DBUS_ERROR,
++ G_DBUS_ERROR_NAME_HAS_NO_OWNER,
++ "Could not get owner of name '%s': no such name", name);
++ goto error;
++ }
++
++ if (g_dbus_is_unique_name(name))
++ {
++ size = (gulong) G_STRUCT_OFFSET (struct kdbus_cmd_info, items);
++ cmd = g_alloca0 (size);
++ cmd->id = g_ascii_strtoull (name+3, NULL, 10);
++ }
++ else
++ {
++ len = strlen(name) + 1;
++ size = (gulong) G_STRUCT_OFFSET (struct kdbus_cmd_info, items) + KDBUS_ITEM_SIZE(len);
++ cmd = g_alloca0 (size);
++ cmd->items[0].size = KDBUS_ITEM_HEADER_SIZE + len;
++ cmd->items[0].type = KDBUS_ITEM_NAME;
++ memcpy (cmd->items[0].str, name, len);
++ }
++
++ cmd->attach_flags = _KDBUS_ATTACH_ALL;
++ cmd->size = size;
++
++ ret = ioctl(worker->fd, KDBUS_CMD_CONN_INFO, cmd);
++ if (ret < 0)
++ {
++ g_set_error (error,
++ G_DBUS_ERROR,
++ G_DBUS_ERROR_FAILED,
++ _("Could not get connection info"));
++ goto error;
++ }
++
++ conn_info = (struct kdbus_info *) ((guint8 *) worker->kdbus_buffer + cmd->offset);
++
++ if (flags & G_DBUS_CREDS_UNIQUE_NAME)
++ {
++ if (asprintf (&creds->unique_name, ":1.%llu", (unsigned long long) conn_info->id) < 0)
++ {
++ g_set_error (error,
++ G_DBUS_ERROR,
++ G_DBUS_ERROR_FAILED,
++ "asprintf error: %s",
++ g_strerror(errno));
++ goto error;
++ }
++ }
++
++ KDBUS_ITEM_FOREACH(item, conn_info, items)
++ {
++ switch (item->type)
++ {
++ case KDBUS_ITEM_PIDS:
++ if (flags & G_DBUS_CREDS_PID)
++ creds->pid = item->pids.pid;
++ break;
++
++ case KDBUS_ITEM_CREDS:
++ if (flags & G_DBUS_CREDS_UID)
++ creds->uid = item->creds.uid;
++ break;
++
++ case KDBUS_ITEM_SECLABEL:
++ if (flags & G_DBUS_CREDS_SEC_LABEL)
++ creds->sec_label = g_strdup (item->str);
++ break;
++
++ 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_CAPS:
++ case KDBUS_ITEM_AUDIT:
++ case KDBUS_ITEM_CONN_DESCRIPTION:
++ case KDBUS_ITEM_AUXGROUPS:
++ case KDBUS_ITEM_OWNED_NAME:
++ break;
++ }
++ }
++
++ g_kdbus_free_data (worker, cmd->offset);
++ return creds;
++
++error:
++ g_free (creds->unique_name);
++ g_free (creds->sec_label);
++ g_free (creds);
++ return NULL;
++}
++
++
++/* < internal >
++ *
++ * _g_kdbus_GetNameOwner:
++ *
++ * Synchronously returns the unique connection name of the primary owner of
++ * the name given. If the requested name doesn't have an owner, an error is
++ * returned.
++ *
++ * Returns: the unique connection name of the primary owner of the
++ * name given. If the requested name doesn't have an owner, function
++ * returns NULL and error is set. Free with g_free().
++ */
++gchar *
++_g_kdbus_GetNameOwner (GKDBusWorker *worker,
++ const gchar *name,
++ GError **error)
++{
++ GDBusCredentials *creds;
++ gchar *unique_name;
++ guint flags;
++
++ creds = NULL;
++ unique_name = NULL;
++
++ if (g_strcmp0 (name, "org.freedesktop.DBus") == 0)
++ return g_strdup (name);
++
++ flags = G_DBUS_CREDS_UNIQUE_NAME;
++ creds = _g_kdbus_GetConnInfo (worker,
++ name,
++ flags,
++ error);
++ if (creds != NULL)
++ {
++ unique_name = creds->unique_name;
++ g_free (creds);
++ }
++
++ return unique_name;
++}
++
++
++/* < internal >
++ *
++ * _g_kdbus_GetConnectionUnixProcessID:
++ *
++ * Synchronously returns the Unix process ID of the process connected to the
++ * bus. If unable to determine it, an error is returned.
++ *
++ * If name contains a value not compatible with the D-Bus syntax and naming
++ * conventions for bus names, the operation returns -1 and error is set.
++ *
++ * Returns: the Unix process ID of the process connected to the bus or -1
++ * if error is set.
++ */
++pid_t
++_g_kdbus_GetConnectionUnixProcessID (GKDBusWorker *worker,
++ const gchar *name,
++ GError **error)
++{
++ GDBusCredentials *creds;
++ guint flags;
++ pid_t pid;
++
++ creds = NULL;
++ pid = -1;
++
++ flags = G_DBUS_CREDS_PID;
++ creds = _g_kdbus_GetConnInfo (worker,
++ name,
++ flags,
++ error);
++ if (creds != NULL)
++ {
++ pid = creds->pid;
++ g_free (creds);
++ }
++
++ return pid;
++}
++
++
++/* < internal >
++ *
++ * _g_kdbus_GetConnectionUnixUser:
++ *
++ * Synchronously returns the Unix user ID of the process connected to the
++ * bus. If unable to determine it, an error is returned.
++ *
++ * If name contains a value not compatible with the D-Bus syntax and naming
++ * conventions for bus names, the operation returns -1 and error is set.
++ *
++ * Returns: the Unix user ID of the process connected to the bus or -1
++ * if error is set.
++ */
++uid_t
++_g_kdbus_GetConnectionUnixUser (GKDBusWorker *worker,
++ const gchar *name,
++ GError **error)
++{
++ GDBusCredentials *creds;
++ guint flags;
++ uid_t uid;
++
++ creds = NULL;
++ uid = -1;
++
++ flags = G_DBUS_CREDS_UID;
++ creds = _g_kdbus_GetConnInfo (worker,
++ name,
++ flags,
++ error);
++ if (creds != NULL)
++ {
++ uid = creds->uid;
++ g_free (creds);
++ }
++
++ return uid;
++}
++
++
++/* < internal >
++ *
++ * _g_kdbus_GetConnectionSecurityLabel:
++ *
++ * Synchronously returns security label of the process connected to the bus.
++ *
++ * If name contains a value not compatible with the D-Bus syntax and naming
++ * conventions for bus names, the operation returns -1 and error is set.
++ *
++ * Returns: security label of the process connected to the bus or -1
++ */
++gchar *
++_g_kdbus_GetConnectionSecurityLabel (GKDBusWorker *worker,
++ const gchar *name,
++ GError **error)
++{
++ GDBusCredentials *creds;
++ gchar *sec_label;
++ guint flags;
++
++ creds = NULL;
++ sec_label = NULL;
++
++ flags = G_DBUS_CREDS_SEC_LABEL;
++ creds = _g_kdbus_GetConnInfo (worker,
++ name,
++ flags,
++ error);
++ if (creds != NULL)
++ {
++ sec_label = creds->sec_label;
++ g_free (creds);
++ }
++
++ return sec_label;
++}
++
++typedef struct
++{
++ GKDBusWorker *worker;
++ GDBusMessage *message;
++} SyntheticReplyData;
++
++static gboolean
++deliver_synthetic_reply (gpointer user_data)
++{
++ SyntheticReplyData *data;
++ GKDBusWorker *worker;
++ GDBusMessage *message;
++
++ data = user_data;
++ worker = data->worker;
++ message = data->message;
++
++ (* worker->message_received_callback) (message, worker->user_data);
++
++ g_object_unref (message);
++ g_free (data);
++
++ return FALSE;
++}
++
++static void
++send_synthetic_message (GKDBusWorker *worker,
++ GDBusMessage *message)
++{
++ SyntheticReplyData *reply_data;
++ reply_data = g_new0 (SyntheticReplyData, 1);
++ reply_data->worker = worker;
++ reply_data->message = message;
++ g_main_context_invoke (worker->context, deliver_synthetic_reply, reply_data);
++}
++
++static GBusStartServiceReplyFlags
++_g_kdbus_send_Ping (GKDBusWorker *worker,
++ const gchar *name,
++ GError **error)
++{
++ GDBusMessage *ping_message;
++ GDBusMessage *reply = NULL;
++ gboolean ret;
++
++ ping_message = g_dbus_message_new_method_call (name, "/", "org.freedesktop.DBus.Peer", "Ping");
++ g_dbus_message_set_serial (ping_message, -1);
++
++ ret = _g_kdbus_send (worker, ping_message, &reply, 25000, NULL, NULL);
++ g_object_unref (ping_message);
++ if (reply)
++ g_object_unref (reply);
++
++ if (!ret)
++ {
++ g_set_error (error,
++ G_DBUS_ERROR,
++ G_DBUS_ERROR_SERVICE_UNKNOWN,
++ "The name %s was not provided by any .service files", name);
++ return G_BUS_START_SERVICE_REPLY_ERROR;
++ }
++ return G_BUS_START_SERVICE_REPLY_SUCCESS;
++}
++
++static void
++_g_kdbus_send_Ping_thread (GTask *task,
++ gpointer source_object,
++ gpointer task_data,
++ GCancellable *cancellable)
++{
++ GKDBusWorker *worker = source_object;
++ GDBusMessage *message = task_data;
++ const gchar *name = NULL;
++ GError *error = NULL;
++
++ GBusStartServiceReplyFlags status;
++
++ g_variant_get (g_dbus_message_get_body (message), "(su)", &name, NULL);
++
++ status = _g_kdbus_send_Ping (worker, name, &error);
++ g_free ((gchar*) name);
++
++ if (status == G_BUS_START_SERVICE_REPLY_SUCCESS)
++ g_task_return_int (task, G_BUS_START_SERVICE_REPLY_SUCCESS);
++ else
++ g_task_return_error (task, error);
++
++}
++
++static void
++_g_kdbus_send_Ping_finish (GKDBusWorker *worker,
++ GAsyncResult *result,
++ gpointer user_data)
++{
++ GDBusMessage *message = user_data;
++ GDBusMessage *synthetic_reply = NULL;
++ GError *error = NULL;
++ gssize status = g_task_propagate_int (G_TASK (result), &error);
++ if (status != -1)
++ {
++ synthetic_reply = g_dbus_message_new_method_reply (message);
++ g_dbus_message_set_body (synthetic_reply, g_variant_new ("(u)", status));
++ }
++ else
++ {
++ gchar *dbus_error_name = g_dbus_error_encode_gerror (error);
++ synthetic_reply = g_dbus_message_new_method_error (message, dbus_error_name, "%s", error->message);
++ g_free (dbus_error_name);
++ g_error_free (error);
++ }
++ g_object_unref (message);
++ g_dbus_message_set_serial (synthetic_reply, -1);
++ send_synthetic_message (worker, synthetic_reply);
++}
++
++/* < internal >
++ *
++ * _g_kdbus_StartServiceByName:
++ *
++ * Synchronously tries to launch the executable associated
++ * with a name.
++ *
++ * Returns: status code or G_BUS_START_SERVICE_REPLY_ERROR
++ if error is set.
++ */
++GBusStartServiceReplyFlags
++_g_kdbus_StartServiceByName (GKDBusWorker *worker,
++ const gchar *name,
++ guint32 flags,
++ GDBusMessage *message,
++ GError **error)
++{
++ if (!g_dbus_is_name (name))
++ {
++ g_set_error (error,
++ G_DBUS_ERROR,
++ G_DBUS_ERROR_INVALID_ARGS,
++ "Given bus name \"%s\" is not valid", name);
++ return G_BUS_START_SERVICE_REPLY_ERROR;
++ }
++
++ if (g_strcmp0 (name, "org.freedesktop.DBus") == 0)
++ return G_BUS_START_SERVICE_REPLY_ALREADY_RUNNING;
++
++ if (!g_kdbus_NameHasOwner_internal (worker, name))
++ {
++ if (!message)
++ {
++ return _g_kdbus_send_Ping(worker, name, error);
++ }
++ else
++ {
++ GTask *task;
++ task = g_task_new (worker,
++ NULL,
++ (GAsyncReadyCallback) _g_kdbus_send_Ping_finish,
++ g_object_ref(message));
++ g_task_set_task_data (task, message, NULL);
++ g_task_run_in_thread (task, _g_kdbus_send_Ping_thread);
++ g_object_unref (task);
++ return G_BUS_START_SERVICE_REPLY_SUCCESS;
++ }
++ }
++ else
++ {
++ return G_BUS_START_SERVICE_REPLY_ALREADY_RUNNING;
++ }
++}
++
++
++/*
++ * 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 hash_index = 0;
++
++ guint c = 0;
++
++ bit_num = (guint64)worker->bloom_size * 8;
++
++ if (bit_num > 1)
++ bytes_num = ((__builtin_clzll(bit_num) ^ 63U) + 7) / 8;
++
++ for (cnt_1 = 0, hash_index = 0; cnt_1 < (worker->bloom_n_hash); cnt_1++)
++ {
++ guint64 p = 0;
++ for (cnt_2 = 0; cnt_2 < bytes_num; cnt_2++)
++ {
++ if (c <= 0)
++ {
++ _g_siphash24(hash, data, n, hash_keys[hash_index++]);
++ c += 8;
++ }
++
++ p = (p << 8ULL) | (guint64) hash[8 - c];
++ c--;
++ }
++
++ p &= bit_num - 1;
++ bloom_data[p >> 6] |= 1ULL << (p & 63);
++ }
++}
++
++static void
++g_kdbus_bloom_add_pair (GKDBusWorker *worker,
++ guint64 bloom_data[],
++ const gchar *parameter,
++ const gchar *value)
++{
++ 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);
++}
++
++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);
++ }
++}
++
++
++/* < internal >
++ *
++ * _g_kdbus_AddMatch:
++ *
++ * Synchronously adds a match rule to match messages.
++ *
++ * Returns: TRUE if the operation succeeded, FALSE
++ * if error is set.
++ *
++ */
++gboolean
++_g_kdbus_AddMatch (GKDBusWorker *worker,
++ const gchar *match_rule,
++ GError **error)
++{
++ 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] == '-')
++ {
++ g_set_error (error,
++ G_DBUS_ERROR,
++ G_DBUS_ERROR_MATCH_RULE_INVALID,
++ "Invalid rule: %s", match_rule);
++ return FALSE;
++ }
++
++ match = match_new (match_rule);
++ if (!match)
++ {
++ g_set_error (error,
++ G_DBUS_ERROR,
++ G_DBUS_ERROR_MATCH_RULE_INVALID,
++ "Invalid rule: %s", match_rule);
++ return FALSE;
++ }
++
++ 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));
++
++ 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_set_error (error,
++ G_DBUS_ERROR,
++ G_DBUS_ERROR_MATCH_RULE_INVALID,
++ "Invalid rule: %s", match_rule);
++ match_free (match);
++ return FALSE;
++ }
++ 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:
++ if (asprintf (&type, "arg%u", element->arg) < 0)
++ {
++ g_set_error (error,
++ G_DBUS_ERROR,
++ G_DBUS_ERROR_FAILED,
++ "asprintf failed: %s", g_strerror(errno));
++ match_free (match);
++ return FALSE;
++ }
++ else
++ {
++ g_kdbus_bloom_add_pair (worker, bloom, type, element->value);
++ free (type);
++ }
++ break;
++
++ case MATCH_ELEMENT_ARGNPATH:
++ if (asprintf (&type, "arg%u-slash-prefix", element->arg) < 0)
++ {
++ g_set_error (error,
++ G_DBUS_ERROR,
++ G_DBUS_ERROR_FAILED,
++ "asprintf failed: %s", g_strerror(errno));
++ match_free (match);
++ return FALSE;
++ }
++ else
++ {
++ 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 = match->cookie;
++
++ item = cmd->items;
++ item->size = (guint64) 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 = (guint64) 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 = (guint64) 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_set_error (error,
++ G_DBUS_ERROR,
++ G_DBUS_ERROR_FAILED,
++ "Error while adding a match");
++ match_free (match);
++ return FALSE;
++ }
++
++ g_mutex_lock (&worker->matches_mutex);
++ worker->matches = g_list_prepend (worker->matches, match);
++ g_mutex_unlock (&worker->matches_mutex);
++ return TRUE;
++}
++
++
++/* < internal >
++ *
++ * _g_kdbus_RemoveMatch:
++ *
++ * Synchronously removes the first rule that matches.
++ *
++ * Returns: TRUE if the operation succeeded, FALSE
++ * if error is set.
++ */
++gboolean
++_g_kdbus_RemoveMatch (GKDBusWorker *worker,
++ const gchar *match_rule,
++ GError **error)
++{
++ Match *match, *other_match;
++ GList *matches;
++ guint64 cookie;
++
++ if (match_rule[0] == '-')
++ {
++ g_set_error (error,
++ G_DBUS_ERROR,
++ G_DBUS_ERROR_MATCH_RULE_INVALID,
++ "Invalid rule: %s", match_rule);
++ return FALSE;
++ }
++
++ match = match_new (match_rule);
++ if (!match)
++ {
++ g_set_error (error,
++ G_DBUS_ERROR,
++ G_DBUS_ERROR_MATCH_RULE_INVALID,
++ "Invalid rule: %s", match_rule);
++ return FALSE;
++ }
++
++ g_mutex_lock (&worker->matches_mutex);
++ for (matches = worker->matches; matches != NULL; matches = matches->next)
++ {
++ other_match = matches->data;
++ if (match_equal (match, other_match))
++ {
++ cookie = other_match->cookie;
++ match_free (other_match);
++ worker->matches = g_list_delete_link (worker->matches, matches);
++ break;
++ }
++ }
++ g_mutex_unlock (&worker->matches_mutex);
++
++ if (matches == NULL)
++ {
++ g_set_error (error,
++ G_DBUS_ERROR,
++ G_DBUS_ERROR_MATCH_RULE_NOT_FOUND,
++ "The given match rule wasn't found and can't be removed");
++ match_free (match);
++ return FALSE;
++ }
++ else
++ {
++ struct kdbus_cmd_match cmd = {
++ .size = sizeof(cmd),
++ .cookie = cookie
++ };
++ gint ret;
++
++ ret = ioctl(worker->fd, KDBUS_CMD_MATCH_REMOVE, &cmd);
++ if (ret < 0)
++ {
++ if (errno == EBADSLT)
++ {
++ g_set_error (error, G_DBUS_ERROR, G_DBUS_ERROR_MATCH_RULE_NOT_FOUND,
++ "A match entry with the given cookie could not be found");
++ }
++ else
++ {
++ g_set_error (error, G_DBUS_ERROR, G_DBUS_ERROR_FAILED,
++ "Error while removing a match");
++ }
++ match_free (match);
++ return FALSE;
++ }
++ }
++
++ match_free (match);
++ return TRUE;
++}
++
++
++/*
++ * _g_kdbus_subscribe_name_owner_changed_internal
++ */
++static gboolean
++_g_kdbus_subscribe_name_owner_changed_internal (GKDBusWorker *worker,
++ const gchar *name,
++ const gchar *old_name,
++ const gchar *new_name,
++ guint64 cookie,
++ GError **error)
++{
++ struct kdbus_item *item;
++ struct kdbus_cmd_match *cmd;
++ gsize size, len;
++ gint ret;
++ guint64 old_id = 0;
++ guint64 new_id = KDBUS_MATCH_ID_ANY;
++
++ if (name)
++ len = strlen(name) + 1;
++ else
++ len = 0;
++
++ 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 == NULL)
++ {
++ old_id = KDBUS_MATCH_ID_ANY;
++ }
++ else
++ {
++ if (g_dbus_is_unique_name(old_name))
++ old_id = strtoull (old_name + 3, NULL, 10);
++ else
++ return TRUE;
++ }
++
++ if (new_name == NULL)
++ {
++ new_id = KDBUS_MATCH_ID_ANY;
++ }
++ else
++ {
++ if (g_dbus_is_unique_name(new_name))
++ new_id = strtoull (new_name + 3, NULL, 10);
++ else
++ return TRUE;
++ }
++
++ cmd = g_alloca0 (size);
++ cmd->size = size;
++ cmd->cookie = cookie;
++ item = cmd->items;
++
++ item->type = KDBUS_ITEM_NAME_CHANGE;
++ item->name_change.old_id.id = old_id;
++ item->name_change.new_id.id = new_id;
++
++ if (name)
++ memcpy(item->name_change.name, name, len);
++
++ item->size = (guint64) G_STRUCT_OFFSET (struct kdbus_item, name_change) +
++ (guint64) 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_set_error (error,
++ G_DBUS_ERROR,
++ G_DBUS_ERROR_FAILED,
++ "Error while adding a match");
++ return FALSE;
++ }
++
++ return TRUE;
++}
++
++
++/*
++ * _g_kdbus_subscribe_name_acquired
++ */
++gboolean
++_g_kdbus_subscribe_name_acquired (GKDBusWorker *worker,
++ const gchar *match_rule,
++ const gchar *name,
++ GError **error)
++{
++ Match *match;
++ struct kdbus_item *item;
++ struct kdbus_cmd_match *cmd;
++ gsize size, len;
++ gint ret;
++
++ if (match_rule[0] == '-')
++ {
++ g_set_error (error,
++ G_DBUS_ERROR,
++ G_DBUS_ERROR_MATCH_RULE_INVALID,
++ "Invalid rule: %s", match_rule);
++ return FALSE;
++ }
++
++ if (name != NULL)
++ {
++ if (!g_dbus_is_name (name))
++ {
++ g_set_error (error,
++ G_DBUS_ERROR,
++ G_DBUS_ERROR_MATCH_RULE_INVALID,
++ "Invalid rule: %s", match_rule);
++ return FALSE;
++ }
++ }
++
++ match = match_new (match_rule);
++ if (!match)
++ {
++ g_set_error (error,
++ G_DBUS_ERROR,
++ G_DBUS_ERROR_MATCH_RULE_INVALID,
++ "Invalid rule: %s", match_rule);
++ return FALSE;
++ }
++
++ if (name)
++ len = strlen(name) + 1;
++ else
++ len = 0;
++
++ 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 = match->cookie;
++ item = cmd->items;
++
++ 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;
++
++ if (name)
++ memcpy(item->name_change.name, name, len);
++
++ item->size = (guint64) G_STRUCT_OFFSET (struct kdbus_item, name_change) +
++ (guint64) 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_set_error (error,
++ G_DBUS_ERROR,
++ G_DBUS_ERROR_FAILED,
++ "Error while adding a match");
++ match_free (match);
++ return FALSE;
++ }
++
++ if (!_g_kdbus_subscribe_name_owner_changed_internal (worker, name, NULL, worker->unique_name, match->cookie, error))
++ {
++ match_free (match);
++ return FALSE;
++ }
++
++ g_mutex_lock (&worker->matches_mutex);
++ worker->matches = g_list_prepend (worker->matches, match);
++ g_mutex_unlock (&worker->matches_mutex);
++ return TRUE;
++}
++
++
++/*
++ * _g_kdbus_subscribe_name_lost
++ */
++gboolean
++_g_kdbus_subscribe_name_lost (GKDBusWorker *worker,
++ const gchar *match_rule,
++ const gchar *name,
++ GError **error)
++{
++ Match *match;
++ struct kdbus_item *item;
++ struct kdbus_cmd_match *cmd;
++ gsize size, len;
++ gint ret;
++
++ if (match_rule[0] == '-')
++ {
++ g_set_error (error,
++ G_DBUS_ERROR,
++ G_DBUS_ERROR_MATCH_RULE_INVALID,
++ "Invalid rule: %s", match_rule);
++ return FALSE;
++ }
++
++ if (name != NULL)
++ {
++ if (!g_dbus_is_name (name))
++ {
++ g_set_error (error,
++ G_DBUS_ERROR,
++ G_DBUS_ERROR_MATCH_RULE_INVALID,
++ "Invalid rule: %s", match_rule);
++ return FALSE;
++ }
++ }
++
++ match = match_new (match_rule);
++ if (!match)
++ {
++ g_set_error (error,
++ G_DBUS_ERROR,
++ G_DBUS_ERROR_MATCH_RULE_INVALID,
++ "Invalid rule: %s", match_rule);
++ return FALSE;
++ }
++
++ if (name)
++ len = strlen(name) + 1;
++ else
++ len = 0;
++
++ 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 = match->cookie;
++ item = cmd->items;
++
++ 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;
++
++ if (name)
++ memcpy(item->name_change.name, name, len);
++
++ item->size = (guint64) G_STRUCT_OFFSET (struct kdbus_item, name_change) +
++ (guint64) 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_set_error (error,
++ G_DBUS_ERROR,
++ G_DBUS_ERROR_FAILED,
++ "Error while adding a match");
++ match_free (match);
++ return FALSE;
++ }
++
++ if (!_g_kdbus_subscribe_name_owner_changed_internal (worker, name, worker->unique_name, NULL, match->cookie, error))
++ {
++ match_free (match);
++ return FALSE;
++ }
++
++ g_mutex_lock (&worker->matches_mutex);
++ worker->matches = g_list_prepend (worker->matches, match);
++ g_mutex_unlock (&worker->matches_mutex);
++ return TRUE;
++}
++
++
++/*
++ * _g_kdbus_subscribe_name_owner_changed
++ */
++gboolean
++_g_kdbus_subscribe_name_owner_changed (GKDBusWorker *worker,
++ const gchar *match_rule,
++ const gchar *name,
++ GError **error)
++{
++ Match *match;
++ struct kdbus_item *item;
++ struct kdbus_cmd_match *cmd;
++ gsize size, len;
++ gint ret;
++
++ if (match_rule[0] == '-')
++ {
++ g_set_error (error,
++ G_DBUS_ERROR,
++ G_DBUS_ERROR_MATCH_RULE_INVALID,
++ "Invalid rule: %s", match_rule);
++ return FALSE;
++ }
++
++ if (name != NULL)
++ {
++ if (!g_dbus_is_name (name))
++ {
++ g_set_error (error,
++ G_DBUS_ERROR,
++ G_DBUS_ERROR_INVALID_ARGS,
++ "Invalid dbus name: %s", name);
++ return FALSE;
++ }
++ }
++
++ match = match_new (match_rule);
++ if (!match)
++ {
++ g_set_error (error,
++ G_DBUS_ERROR,
++ G_DBUS_ERROR_MATCH_RULE_INVALID,
++ "Invalid rule: %s", match_rule);
++ return FALSE;
++ }
++
++ /* 'name' argument is missing or is a unique name */
++ if (name == NULL || g_dbus_is_unique_name (name))
++ {
++ size = KDBUS_ALIGN8(G_STRUCT_OFFSET (struct kdbus_cmd_match, items) +
++ G_STRUCT_OFFSET (struct kdbus_item, id_change) +
++ sizeof (struct kdbus_notify_id_change));
++
++ cmd = g_alloca0 (size);
++ cmd->size = size;
++ cmd->cookie = match->cookie;
++ item = cmd->items;
++
++ if (name)
++ item->id_change.id = strtoull (name + 3, NULL, 10);
++ else
++ item->id_change.id = KDBUS_MATCH_ID_ANY;
++
++ item->size = (guint64) G_STRUCT_OFFSET (struct kdbus_item, id_change) +
++ sizeof (struct kdbus_notify_id_change);
++
++ item->type = KDBUS_ITEM_ID_ADD;
++ ret = ioctl(worker->fd, KDBUS_CMD_MATCH_ADD, cmd);
++ if (ret < 0)
++ {
++ g_set_error (error,
++ G_DBUS_ERROR,
++ G_DBUS_ERROR_FAILED,
++ "Error while adding a match");
++ match_free (match);
++ return FALSE;
++ }
++
++ item->type = KDBUS_ITEM_ID_REMOVE;
++ ret = ioctl(worker->fd, KDBUS_CMD_MATCH_ADD, cmd);
++ if (ret < 0)
++ {
++ g_set_error (error,
++ G_DBUS_ERROR,
++ G_DBUS_ERROR_FAILED,
++ "Error while adding a match");
++ match_free (match);
++ return FALSE;
++ }
++ }
++
++ /* 'name' argument is missing or is a well-known name */
++ if (name == NULL || !g_dbus_is_unique_name (name))
++ {
++ if (name)
++ len = strlen(name) + 1;
++ else
++ len = 0;
++
++ 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 = match->cookie;
++ item = cmd->items;
++
++ item->name_change.old_id.id = KDBUS_MATCH_ID_ANY;
++ item->name_change.new_id.id = KDBUS_MATCH_ID_ANY;
++ item->size = (guint64) G_STRUCT_OFFSET (struct kdbus_item, name_change) +
++ (guint64) G_STRUCT_OFFSET (struct kdbus_notify_name_change, name) + len;
++
++ if (name)
++ memcpy(item->name_change.name, name, len);
++
++ item->type = KDBUS_ITEM_NAME_ADD;
++ ret = ioctl(worker->fd, KDBUS_CMD_MATCH_ADD, cmd);
++ if (ret < 0)
++ {
++ g_set_error (error,
++ G_DBUS_ERROR,
++ G_DBUS_ERROR_FAILED,
++ "Error while adding a match");
++ match_free (match);
++ return FALSE;
++ }
++
++ item->type = KDBUS_ITEM_NAME_REMOVE;
++ ret = ioctl(worker->fd, KDBUS_CMD_MATCH_ADD, cmd);
++ if (ret < 0)
++ {
++ g_set_error (error,
++ G_DBUS_ERROR,
++ G_DBUS_ERROR_FAILED,
++ "Error while adding a match");
++ match_free (match);
++ return FALSE;
++ }
++
++ item->type = KDBUS_ITEM_NAME_CHANGE;
++ ret = ioctl(worker->fd, KDBUS_CMD_MATCH_ADD, cmd);
++ if (ret < 0)
++ {
++ g_set_error (error,
++ G_DBUS_ERROR,
++ G_DBUS_ERROR_FAILED,
++ "Error while adding a match");
++ match_free (match);
++ return FALSE;
++ }
++ }
++
++ g_mutex_lock (&worker->matches_mutex);
++ worker->matches = g_list_prepend (worker->matches, match);
++ g_mutex_unlock (&worker->matches_mutex);
++ return 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
++ */
++static void
++g_kdbus_setup_bloom (GKDBusWorker *worker,
++ GDBusMessage *dbus_msg,
++ struct kdbus_bloom_filter *bloom_filter)
++{
++ GVariant *body;
++ 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);
++ }
++ }
++ g_free (message_type);
++}
++
++
++/*
++ * g_kdbus_translate_id_change
++ */
++static void
++g_kdbus_translate_id_change (GKDBusWorker *worker,
++ struct kdbus_item *item)
++{
++ GDBusMessage *signal_message;
++ gchar *name;
++
++ signal_message = g_dbus_message_new_signal ("/org/freedesktop/DBus",
++ "org.freedesktop.DBus",
++ "NameOwnerChanged");
++
++ name = g_strdup_printf (":1.%"G_GUINT64_FORMAT, (guint64) item->id_change.id);
++
++ g_dbus_message_set_sender (signal_message, "org.freedesktop.DBus");
++ g_dbus_message_set_body (signal_message,
++ g_variant_new ("(sss)",
++ name,
++ item->type == KDBUS_ITEM_ID_ADD ? "" : name,
++ item->type == KDBUS_ITEM_ID_ADD ? name : ""));
++
++ (* worker->message_received_callback) (signal_message, worker->user_data);
++
++ g_free (name);
++ g_object_unref (signal_message);
++}
++
++
++/*
++ * g_kdbus_translate_name_change
++ */
++static void
++g_kdbus_translate_name_change (GKDBusWorker *worker,
++ struct kdbus_item *item)
++{
++ GDBusMessage *signal_message;
++
++ signal_message = NULL;
++
++ /* NameAcquired */
++ if ((item->type == KDBUS_ITEM_NAME_ADD) ||
++ (item->type == KDBUS_ITEM_NAME_CHANGE && ((guint64)item->name_change.new_id.id == worker->unique_id)))
++ {
++ signal_message = g_dbus_message_new_signal ("/org/freedesktop/DBus",
++ "org.freedesktop.DBus",
++ "NameAcquired");
++
++ g_dbus_message_set_sender (signal_message, "org.freedesktop.DBus");
++ g_dbus_message_set_body (signal_message,
++ g_variant_new ("(s)", item->name_change.name));
++
++ (* worker->message_received_callback) (signal_message, worker->user_data);
++ g_object_unref (signal_message);
++ }
++
++ /* NameLost */
++ if ((item->type == KDBUS_ITEM_NAME_REMOVE) ||
++ (item->type == KDBUS_ITEM_NAME_CHANGE && ((guint64)item->name_change.old_id.id == worker->unique_id)))
++ {
++ signal_message = g_dbus_message_new_signal ("/org/freedesktop/DBus",
++ "org.freedesktop.DBus",
++ "NameLost");
++
++ g_dbus_message_set_sender (signal_message, "org.freedesktop.DBus");
++ g_dbus_message_set_body (signal_message,
++ g_variant_new ("(s)", item->name_change.name));
++
++ (* worker->message_received_callback) (signal_message, worker->user_data);
++ g_object_unref (signal_message);
++ }
++
++ /* NameOwnerChanged */
++ if (1)
++ {
++ gchar *old_name;
++ gchar *new_name;
++
++ old_name = NULL;
++ new_name = NULL;
++
++ /* old_name */
++ if (!(item->type == KDBUS_ITEM_NAME_ADD || (item->name_change.old_id.flags & (KDBUS_NAME_IN_QUEUE|KDBUS_NAME_ACTIVATOR))))
++ old_name = g_strdup_printf (":1.%"G_GUINT64_FORMAT, (guint64) item->name_change.old_id.id);
++
++ /* new_name */
++ if (!(item->type == KDBUS_ITEM_NAME_REMOVE || (item->name_change.new_id.flags & (KDBUS_NAME_IN_QUEUE|KDBUS_NAME_ACTIVATOR))))
++ new_name = g_strdup_printf (":1.%"G_GUINT64_FORMAT, (guint64) item->name_change.new_id.id);
++ else
++ if (old_name == NULL)
++ return;
++
++ /* send signal */
++ signal_message = g_dbus_message_new_signal ("/org/freedesktop/DBus",
++ "org.freedesktop.DBus",
++ "NameOwnerChanged");
++ g_dbus_message_set_sender (signal_message, "org.freedesktop.DBus");
++ g_dbus_message_set_body (signal_message,
++ g_variant_new ("(sss)",
++ item->name_change.name,
++ old_name ? old_name : "",
++ new_name ? new_name : ""));
++
++ (* worker->message_received_callback) (signal_message, worker->user_data);
++
++ g_free (old_name);
++ g_free (new_name);
++ g_object_unref (signal_message);
++ }
++}
++
++
++/*
++ * g_kdbus_translate_kernel_reply
++ */
++static void
++g_kdbus_translate_kernel_reply (GKDBusWorker *worker,
++ struct kdbus_msg *msg,
++ struct kdbus_item *item)
++{
++ GDBusMessage *message;
++
++ message = g_dbus_message_new ();
++
++ g_dbus_message_set_message_type (message, G_DBUS_MESSAGE_TYPE_ERROR);
++ g_dbus_message_set_flags (message, G_DBUS_MESSAGE_FLAGS_NO_REPLY_EXPECTED);
++ g_dbus_message_set_reply_serial (message, (guint32) msg->cookie_reply);
++
++ g_dbus_message_set_sender (message, "org.freedesktop.DBus");
++ g_dbus_message_set_destination (message, worker->unique_name);
++
++ g_dbus_message_set_error_name (message, "org.freedesktop.DBus.Error.NoReply");
++
++ if (item->type == KDBUS_ITEM_REPLY_TIMEOUT)
++ g_dbus_message_set_body (message, g_variant_new ("(s)", "Method call timed out"));
++ else
++ g_dbus_message_set_body (message, g_variant_new ("(s)", "Method call peer died"));
++
++ (* worker->message_received_callback) (message, worker->user_data);
++
++ g_object_unref (message);
++}
++
++
++/*
++ * 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:
++ g_kdbus_translate_id_change (worker, item);
++ break;
++
++ case KDBUS_ITEM_NAME_ADD:
++ case KDBUS_ITEM_NAME_REMOVE:
++ case KDBUS_ITEM_NAME_CHANGE:
++ g_kdbus_translate_name_change (worker, item);
++ break;
++
++ case KDBUS_ITEM_REPLY_TIMEOUT:
++ case KDBUS_ITEM_REPLY_DEAD:
++ g_kdbus_translate_kernel_reply (worker, msg, item);
++ break;
++
++ case KDBUS_ITEM_TIMESTAMP:
++ break;
++
++ default:
++ g_warning ("kdbus: unknown field in kernel message - %lld", item->type);
++ }
++ }
++}
++
++#define DEFINE_READ_FUNCTION(name, type) \
++ static inline type \
++ read_ ## name (GVariantSerialised data) \
++ { \
++ if (data.size < sizeof(type)) \
++ return 0; \
++ return *(type *)data.data; \
++ }
++
++DEFINE_READ_FUNCTION (byte, guchar)
++DEFINE_READ_FUNCTION (uint64, guint64)
++DEFINE_READ_FUNCTION (uint32, guint32)
++
++static const gchar *
++check_str (GVariantSerialised data)
++{
++ const gchar *str = (gchar *)data.data;
++ if (str[data.size] == '\0')
++ return str;
++ return "";
++}
++
++/*
++ * g_kdbus_decode_dbus_msg
++ */
++static GKDBusMessage *
++g_kdbus_decode_dbus_msg (GKDBusWorker *worker,
++ struct kdbus_msg *msg)
++{
++ GKDBusMessage *kmsg;
++ struct kdbus_item *item;
++ gssize data_size = 0;
++ GArray *body_vectors;
++ gsize body_size;
++ GVariant *body;
++ gchar *sender;
++ guint i;
++ GVariant *parts[2];
++ GString *owned_name;
++ guint8 type = 0, flags = 0;
++ guint64 serial = 0;
++ GVariantSerialised gvs = { 0, };
++
++ kmsg = g_new0 (GKDBusMessage, 1);
++ kmsg->message = g_dbus_message_new();
++ kmsg->sender_euid = (uid_t) -1;
++ kmsg->sender_egid = (gid_t) -1;
++ kmsg->sender_seclabel = NULL;
++ kmsg->sender_names = NULL;
++
++ body_vectors = g_array_new (FALSE, FALSE, sizeof (GVariantVector));
++
++ item = msg->items;
++ body_size = 0;
++ owned_name = NULL;
++
++ KDBUS_ITEM_FOREACH(item, msg, items)
++ {
++ if (item->size < KDBUS_ITEM_HEADER_SIZE)
++ g_error("kdbus: %llu bytes - invalid data record", item->size);
++
++ data_size = item->size - KDBUS_ITEM_HEADER_SIZE;
++
++ switch (item->type)
++ {
++ 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;
++
++ 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;
++
++ case KDBUS_ITEM_PAYLOAD_MEMFD:
++ {
++ GVariantVector vector;
++ const guchar *data;
++ gsize size;
++
++ vector.gbytes = g_bytes_new_take_zero_copy_fd_size (item->memfd.fd, item->memfd.size);
++ data = g_bytes_get_data (vector.gbytes, &size);
++
++ g_assert (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;
++
++ 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 (kmsg->message, fd_list);
++ g_object_unref (fd_list);
++ }
++ break;
++
++ /* [libdbuspolicy] read euid and egid values */
++ case KDBUS_ITEM_CREDS:
++
++ if ((uid_t) item->creds.euid != (uid_t) -1)
++ kmsg->sender_euid = (uid_t) item->creds.euid;
++
++ if ((gid_t) item->creds.egid != (gid_t) -1)
++ kmsg->sender_egid = (gid_t) item->creds.egid;
++
++ break;
++
++ /* [libdbuspolicy] read security label value */
++ case KDBUS_ITEM_SECLABEL:
++
++ /*if (item->str != NULL)*/
++ kmsg->sender_seclabel = g_strdup (item->str);
++
++ break;
++
++ /* [libdbuspolicy] read all owned well-known names */
++ case KDBUS_ITEM_OWNED_NAME:
++
++ if (g_dbus_is_name (item->name.name))
++ {
++ if (owned_name == NULL)
++ owned_name = g_string_new (item->name.name);
++ else
++ g_string_append_printf (owned_name, " %s", item->name.name);
++ }
++
++ break;
++
++ case KDBUS_ITEM_TIMESTAMP:
++ 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_CONN_DESCRIPTION:
++ case KDBUS_ITEM_AUXGROUPS:
++ case KDBUS_ITEM_NAME:
++ case KDBUS_ITEM_DST_ID:
++ case KDBUS_ITEM_BLOOM_FILTER:
++ break;
++
++ default:
++ g_warning ("kdbus: 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);
++
++ parts[0] = g_variant_get_child_value (body, 0);
++ gvs.type_info = g_variant_type_info_get (G_VARIANT_TYPE ("(yyyyuta{tv})"));
++ gvs.data = (guchar *)g_variant_get_data (parts[0]);
++ gvs.size = g_variant_get_size (parts[0]);
++ gvs.depth = 0;
++ gvs.ordered_offsets_up_to = 0;
++ gvs.checked_offsets_up_to = 0;
++
++ type = read_byte (g_variant_serialised_get_child(gvs, 1));
++ flags = read_byte (g_variant_serialised_get_child(gvs, 2));
++ serial = read_uint64 (g_variant_serialised_get_child(gvs, 5));
++
++ {
++ guint8 i = 0;
++ gsize n_children;
++ GVariantSerialised gvsc;
++
++ gvsc = g_variant_serialised_get_child(gvs, 6);
++ n_children = g_variant_serialised_n_children(gvsc);
++
++ for (i = 0; i < n_children; i++) {
++ GVariantSerialised item;
++ GVariantSerialised variant;
++ guint64 key;
++ GVariantSerialised variant_value;
++
++ item = g_variant_serialised_get_child (gvsc, i);
++ key = read_uint64 (g_variant_serialised_get_child (item, 0));
++ variant = g_variant_serialised_get_child (item, 1);
++ variant_value = g_variant_serialised_get_child (variant, 0); /* strip variant */
++
++ switch (key) {
++ case G_DBUS_MESSAGE_HEADER_FIELD_REPLY_SERIAL:
++ {
++ guint64 val = read_uint64 (variant_value);
++ g_dbus_message_set_reply_serial (kmsg->message, (guint32)val);
++ }
++ break;
++ case G_DBUS_MESSAGE_HEADER_FIELD_NUM_UNIX_FDS:
++ g_dbus_message_set_header (kmsg->message, key, g_variant_new_uint32 (read_uint32 (variant_value)));
++ break;
++ case G_DBUS_MESSAGE_HEADER_FIELD_PATH:
++ g_dbus_message_set_header (kmsg->message, key, g_variant_new_object_path (check_str (variant_value)));
++ break;
++ case G_DBUS_MESSAGE_HEADER_FIELD_SIGNATURE:
++ g_dbus_message_set_header (kmsg->message, key, g_variant_new_signature (check_str (variant_value)));
++ break;
++ default:
++ g_dbus_message_set_header (kmsg->message, key, g_variant_new_string (check_str (variant_value)));
++ break;
++ }
++ }
++ }
++
++ parts[1] = g_variant_get_child_value (body, 1);
++ g_variant_unref (body);
++
++ g_variant_unref (parts[0]);
++
++ 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);
++
++ g_dbus_message_set_flags (kmsg->message, flags);
++ g_dbus_message_set_serial (kmsg->message, serial);
++ g_dbus_message_set_message_type (kmsg->message, type);
++
++ body = g_variant_get_variant (parts[1]);
++ if (!g_variant_is_of_type (body, G_VARIANT_TYPE ("()")))
++ g_dbus_message_set_body (kmsg->message, body);
++ else
++ g_dbus_message_set_body (kmsg->message, NULL);
++
++ g_variant_unref (body);
++ g_variant_unref (parts[1]);
++
++ /* set 'sender' field */
++ sender = g_strdup_printf (":1.%"G_GUINT64_FORMAT, (guint64) msg->src_id);
++ g_dbus_message_set_sender (kmsg->message, sender);
++ g_free (sender);
++
++ /* owned name */
++ if (owned_name != NULL)
++ kmsg->sender_names = g_string_free (owned_name, FALSE);
++
++ return kmsg;
++}
++
++
++/*
++ * _g_kdbus_receive
++ */
++static void
++_g_kdbus_receive (GKDBusWorker *worker,
++ GError **error)
++{
++ struct kdbus_cmd_recv recv;
++ struct kdbus_msg *msg;
++ gboolean can_receive;
++ gint ret = 0;
++
++ can_receive = TRUE;
++ memset (&recv, 0, sizeof recv);
++ recv.size = sizeof (recv);
++
++again:
++ ret = ioctl (worker->fd, KDBUS_CMD_RECV, &recv);
++ if (ret < 0)
++ ret = errno;
++
++ if (recv.return_flags & KDBUS_RECV_RETURN_DROPPED_MSGS)
++ g_warning ("kdbus: %lld dropped broadcast messages", recv.dropped_msgs);
++
++ if (ret != 0)
++ {
++ if (ret == EINTR)
++ goto again;
++
++ if (ret == EAGAIN)
++ return;
++
++ g_set_error (error, G_IO_ERROR,
++ g_io_error_from_errno (ret),
++ _("Error while receiving message: %s"),
++ g_strerror (ret));
++ return;
++ }
++
++ msg = (struct kdbus_msg *)((guint8 *)worker->kdbus_buffer + recv.msg.offset);
++
++ if (msg->payload_type == KDBUS_PAYLOAD_DBUS)
++ {
++ GKDBusMessage *kmsg;
++
++ kmsg = g_kdbus_decode_dbus_msg (worker, msg);
++
++#ifdef LIBDBUSPOLICY
++ if (worker->dbuspolicy != NULL)
++ {
++ if (g_dbus_message_get_message_type (kmsg->message) == G_DBUS_MESSAGE_TYPE_METHOD_CALL ||
++ g_dbus_message_get_message_type (kmsg->message) == G_DBUS_MESSAGE_TYPE_SIGNAL)
++ {
++ if ((kmsg->sender_euid != (uid_t) -1) && (kmsg->sender_egid != (gid_t) -1) &&
++ (kmsg->sender_seclabel != NULL))
++ {
++ gint check;
++ const gchar *destination = g_dbus_message_get_destination (kmsg->message);
++ if (!destination)
++ destination = worker->unique_name;
++
++ check = dbuspolicy1_check_in (worker->dbuspolicy,
++ destination,
++ kmsg->sender_names,
++ kmsg->sender_seclabel,
++ kmsg->sender_euid,
++ kmsg->sender_egid,
++ g_dbus_message_get_path (kmsg->message),
++ g_dbus_message_get_interface (kmsg->message),
++ g_dbus_message_get_member (kmsg->message),
++ g_dbus_message_get_message_type (kmsg->message),
++ NULL, 0, 0);
++ if (check != 1)
++ {
++ can_receive = FALSE;
++ }
++ }
++ else
++ {
++ can_receive = FALSE;
++ }
++ }
++ }
++#endif
++
++ if (can_receive)
++ (* worker->message_received_callback) (kmsg->message, worker->user_data);
++
++ if (kmsg->sender_seclabel != NULL)
++ g_free (kmsg->sender_seclabel);
++
++ if (kmsg->sender_names != NULL)
++ g_free (kmsg->sender_names);
++
++ g_object_unref (kmsg->message);
++ g_free (kmsg);
++ }
++ else if (msg->payload_type == KDBUS_PAYLOAD_KERNEL)
++ g_kdbus_decode_kernel_msg (worker, msg);
++ else
++ {
++ g_set_error (error,
++ G_DBUS_ERROR,
++ G_DBUS_ERROR_FAILED,
++ _("Received unknown payload type"));
++ }
++
++ g_kdbus_close_msg (worker, msg);
++ return;
++}
++
++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);
++
++ 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)
++{
++ gboolean ok = TRUE;
++ do {
++ struct kdbus_vec vec = {
++ .size = size <= KDBUS_MSG_MAX_PAYLOAD_VEC_SIZE ? size : KDBUS_MSG_MAX_PAYLOAD_VEC_SIZE,
++ .address = (gsize) data
++ };
++ ok = g_kdbus_msg_append_item (msg, KDBUS_ITEM_PAYLOAD_VEC, &vec, sizeof vec);
++ data = (char*)data + vec.size;
++ size -= vec.size;
++ } while (size > 0 && ok);
++ return ok;
++}
++
++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);
++}
++
++static struct kdbus_bloom_filter *
++g_kdbus_msg_append_bloom (struct kdbus_msg *msg,
++ gsize size)
++{
++ struct kdbus_item *bloom_item;
++ gsize bloom_item_size;
++
++ bloom_item_size = (gulong) G_STRUCT_OFFSET (struct kdbus_item, bloom_filter) +
++ (gulong) G_STRUCT_OFFSET (struct kdbus_bloom_filter, data) +
++ size;
++
++ msg->size += (-msg->size) & 7;
++ bloom_item = (struct kdbus_item *) ((guchar *) msg + msg->size);
++
++ bloom_item->size = bloom_item_size;
++ bloom_item->type = KDBUS_ITEM_BLOOM_FILTER;
++
++ msg->size += bloom_item->size;
++ return &bloom_item->bloom_filter;
++}
++
++/*
++ * Returns header size.
++ */
++static gsize
++prepare_body_vectors (GKDBusWorker *worker,
++ GDBusMessage *message,
++ GVariantVectors *body_vectors,
++ gboolean *lg_h_field_exist)
++{
++ struct dbus_fixed_header fh;
++ GHashTableIter header_iter;
++ GVariantBuilder builder;
++ gpointer key, value;
++ GVariant *parts[3];
++ GVariant *body;
++ gsize header_size;
++
++ *lg_h_field_exist = FALSE;
++
++ 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_assert_nonnull (parts[0]);
++
++ 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, worker->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_REPLY_SERIAL:
++ g_variant_builder_add (&builder, "{tv}", key_int, g_variant_new_uint64 (g_dbus_message_get_reply_serial(message)));
++ continue;
++
++
++ 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_DESTINATION:
++ case G_DBUS_MESSAGE_HEADER_FIELD_NUM_UNIX_FDS:
++ 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.
++ *
++ * Anyway, kdbus does not check it, and libraries handle it...
++ */
++
++ if (g_variant_get_size (value) >= 128)
++ *lg_h_field_exist = TRUE;
++
++ 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:
++ continue;
++
++ default:
++ g_assert_not_reached ();
++ }
++ }
++ parts[1] = g_variant_builder_end (&builder);
++ g_assert_nonnull (parts[1]);
++
++ body = g_dbus_message_get_body (message);
++ if (!body)
++ body = g_variant_new ("()");
++ parts[2] = g_variant_new_variant (body);
++ g_assert_nonnull (parts[2]);
++
++ header_size = g_variant_get_size (parts[0]) + g_variant_get_size (parts[1]);
++
++ 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; this
++ * condition must be assured later, during composing kdbus vectors.
++ */
++ g_assert_cmpint (body_vectors->vectors->len, >, 0);
++
++ g_variant_unref (body);
++
++ return header_size;
++}
++
++static void
++make_single_header_vector (GVariantVectors *body_vectors,
++ gsize header_size,
++ gboolean lg_h_field_exist)
++{
++ guint i = 0;
++ gsize added_vectors_size = 0;
++ GVariantVector *first_vector;
++
++ /* Merge all header vectors into single vector */
++ first_vector = &g_array_index (body_vectors->vectors, GVariantVector, 0);
++ if (first_vector->size < header_size)
++ {
++ /* There are multiple header vectors, we have to join them together into a single one */
++ GByteArray *header = g_byte_array_sized_new (header_size);
++ gsize dummy_size;
++
++ g_assert_nonnull (header);
++ g_assert_true (lg_h_field_exist);
++
++ while (added_vectors_size < header_size && i < body_vectors->vectors->len)
++ {
++ GVariantVector *vector = &g_array_index (body_vectors->vectors, GVariantVector, i);
++
++ if (vector->gbytes)
++ {
++ g_byte_array_append (header, vector->data.pointer, vector->size);
++ g_bytes_unref (vector->gbytes);
++ }
++ else
++ {
++ g_byte_array_append (header, body_vectors->extra_bytes->data + vector->data.offset, vector->size);
++ }
++
++ added_vectors_size += vector->size;
++ i++;
++ }
++
++ /* Sanity check if the first vector contains at least the complete header */
++ g_assert_cmpint (added_vectors_size, >=, header_size);
++
++ first_vector->gbytes = g_byte_array_free_to_bytes (header);
++ first_vector->data.pointer = g_bytes_get_data (first_vector->gbytes, &dummy_size);
++ first_vector->size = added_vectors_size;
++
++ g_array_remove_range (body_vectors->vectors, 1, i-1);
++ }
++ /* else: If there is only a single header vector, then just go */
++}
++
++static gboolean
++add_message_destination_item (struct kdbus_msg *msg,
++ GDBusMessage *message,
++ GError **error)
++{
++ 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);
++ }
++ 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;
++
++ return TRUE;
++}
++
++static void
++add_file_descriptors_item (struct kdbus_msg *msg,
++ GDBusMessage *message)
++{
++ 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);
++ }
++}
++
++static gboolean
++add_body_vectors (struct kdbus_msg *msg,
++ GVariantVectors *body_vectors,
++ gint *memfd_fd)
++{
++ guint i = 0;
++
++ /* Add all the vectors to the kdbus message */
++ for (; i < body_vectors->vectors->len; i++)
++ {
++ GVariantVector vector = g_array_index (body_vectors->vectors, GVariantVector, i);
++
++ if (vector.gbytes)
++ {
++ const guchar *bytes_data;
++ gboolean use_memfd;
++ gsize bytes_size;
++
++ use_memfd = FALSE;
++ bytes_data = g_bytes_get_data (vector.gbytes, &bytes_size);
++
++ /* check whether we can and should use memfd */
++ if ((msg->dst_id != KDBUS_DST_ID_BROADCAST) && (bytes_size > KDBUS_MEMFD_THRESHOLD))
++ use_memfd = TRUE;
++
++ if (use_memfd)
++ {
++ const guchar *bytes_data_wr;
++ gint64 wr;
++
++ /* create memfd object */
++ *memfd_fd = glib_linux_memfd_create ("glib-kdbus-memfd", MFD_CLOEXEC | MFD_ALLOW_SEALING);
++ if (*memfd_fd == -1)
++ {
++ g_warning ("kdbus: missing kernel memfd support");
++ use_memfd = FALSE; /* send as PAYLOAD_VEC item */
++ }
++ else
++ {
++ /* write data to memfd */
++ bytes_data_wr = bytes_data;
++ while (bytes_size)
++ {
++ wr = write (*memfd_fd, bytes_data_wr, bytes_size);
++ if (wr < 0)
++ g_warning ("kdbus: writing to memfd failed: (%d) %m", errno);
++
++ bytes_size -= wr;
++ bytes_data_wr += wr;
++ }
++
++ /* seal memfd */
++ if (!g_unix_fd_ensure_zero_copy_safe (*memfd_fd))
++ {
++ g_warning ("kdbus: memfd sealing failed");
++ use_memfd = FALSE; /* send as PAYLOAD_VEC item */
++ }
++ else
++ {
++ /* attach memfd item */
++ if (!g_kdbus_msg_append_payload_memfd (msg, *memfd_fd, vector.data.pointer - bytes_data, vector.size))
++ return FALSE;
++ }
++ } /* *memfd_fd == -1 */
++ } /* use_memfd */
++
++ if (!use_memfd)
++ if (!g_kdbus_msg_append_payload_vec (msg, vector.data.pointer, vector.size))
++ return FALSE;
++ }
++ else
++ if (!g_kdbus_msg_append_payload_vec (msg, body_vectors->extra_bytes->data + vector.data.offset, vector.size))
++ return FALSE;
++ }
++ return TRUE;
++}
++
++static gboolean
++add_bloom_item (struct kdbus_msg *msg,
++ GDBusMessage *message,
++ GKDBusWorker *worker)
++{
++ struct kdbus_bloom_filter *bloom_filter;
++
++ if (g_dbus_message_get_message_type (message) == G_DBUS_MESSAGE_TYPE_SIGNAL)
++ {
++ msg->flags |= KDBUS_MSG_SIGNAL;
++ bloom_filter = g_kdbus_msg_append_bloom (msg, worker->bloom_size);
++ if (bloom_filter == NULL)
++ return FALSE;
++ g_kdbus_setup_bloom (worker, message, bloom_filter);
++ }
++ return TRUE;
++}
++
++static gsize
++compute_msg_size (GDBusMessage *message,
++ GKDBusWorker *worker,
++ GVariantVectors *body_vectors)
++{
++ gsize items_size = 0;
++ GUnixFDList *fd_list;
++ const gchar *dst_name;
++ guint i;
++ GDBusMessageType msg_type = g_dbus_message_get_message_type (message);
++
++ /* payload - check which vectors will become memfds */
++ for (i = 0; i < body_vectors->vectors->len; i++)
++ {
++ GVariantVector vector = g_array_index (body_vectors->vectors, GVariantVector, i);
++ gsize payload_size;
++ gsize kdbus_num_vectors;
++
++ if (vector.gbytes)
++ {
++ payload_size = g_bytes_get_size (vector.gbytes);
++ if (msg_type != G_DBUS_MESSAGE_TYPE_SIGNAL && payload_size > KDBUS_MEMFD_THRESHOLD)
++ {
++ /* We can do this because we know that struct kdbus_memfd is larger or equal than
++ struct kdbus_vec. struct kdbus_vec is fallback option if memfd does not work */
++ items_size += KDBUS_ITEM_SIZE (sizeof (struct kdbus_memfd));
++ continue;
++ }
++ }
++ else
++ {
++ payload_size = vector.size;
++ }
++
++ kdbus_num_vectors = (payload_size + KDBUS_MSG_MAX_PAYLOAD_VEC_SIZE - 1) / KDBUS_MSG_MAX_PAYLOAD_VEC_SIZE;
++ items_size += KDBUS_ITEM_SIZE (sizeof (struct kdbus_vec)) * kdbus_num_vectors;
++ }
++
++ /* file descriptors */
++ fd_list = g_dbus_message_get_unix_fd_list (message);
++ if (fd_list != NULL)
++ items_size += KDBUS_ITEM_SIZE (g_unix_fd_list_get_length (fd_list) * sizeof(gint));
++
++ /* destination */
++ dst_name = g_dbus_message_get_destination (message);
++ if (dst_name != NULL)
++ items_size += KDBUS_ITEM_SIZE (strlen (dst_name) + 1);
++
++ /* bloom filters */
++ if (msg_type == G_DBUS_MESSAGE_TYPE_SIGNAL)
++ items_size += KDBUS_ITEM_SIZE (sizeof (struct kdbus_bloom_filter) + worker->bloom_size);
++
++ return sizeof (struct kdbus_msg) + items_size;
++}
++
++#ifdef LIBDBUSPOLICY
++static GDBusMessage*
++create_access_error_reply (GDBusMessage *message,
++ const GQuark domain,
++ const gint code,
++ const gchar *format,
++ ...)
++{
++ gchar *error_text;
++ GError *access_error;
++ gchar *dbus_error_name;
++ GDBusMessage *error_reply;
++ va_list args;
++
++ va_start (args, format);
++ error_text = g_strdup_vprintf (format, args);
++ va_end (args);
++
++ access_error = NULL;
++ g_set_error (&access_error, domain, code, "%s", error_text);
++ dbus_error_name = g_dbus_error_encode_gerror (access_error);
++ g_error_free (access_error);
++
++ error_reply = g_dbus_message_new_method_error (message, dbus_error_name, "%s", error_text);
++ g_free (dbus_error_name);
++ g_free (error_text);
++ return error_reply;
++}
++#endif
++
++#ifdef LIBDBUSPOLICY
++static GDBusMessage*
++check_result_to_error_reply (GDBusMessage *message,
++ const gint check_result)
++{
++ switch (check_result)
++ {
++ case DBUSPOLICY_RESULT_DENY:
++ return create_access_error_reply (message, G_DBUS_ERROR, G_DBUS_ERROR_ACCESS_DENIED,
++ "Cannot send message - message rejected due to XML security policies");
++
++ case DBUSPOLICY_RESULT_DEST_NOT_AVAILABLE:
++ if (g_dbus_message_get_flags (message) & G_DBUS_MESSAGE_FLAGS_NO_AUTO_START)
++ return create_access_error_reply (message, G_DBUS_ERROR, G_DBUS_ERROR_NAME_HAS_NO_OWNER,
++ "Name \"%s\" does not exist", g_dbus_message_get_destination (message));
++ else
++ return create_access_error_reply (message, G_DBUS_ERROR, G_DBUS_ERROR_SERVICE_UNKNOWN,
++ "Cannot send message - destination '%s' not known", g_dbus_message_get_destination (message));
++
++ case DBUSPOLICY_RESULT_KDBUS_ERROR:
++ return create_access_error_reply (message, G_DBUS_ERROR, G_DBUS_ERROR_ACCESS_DENIED,
++ "Cannot send message - message rejected due to internal libdbuspolicy error (kdbus)");
++
++ case DBUSPOLICY_RESULT_CYNARA_ERROR:
++ return create_access_error_reply (message, G_DBUS_ERROR, G_DBUS_ERROR_ACCESS_DENIED,
++ "Cannot send message - message rejected due to internal libdbuspolicy error (Cynara)");
++
++ default:
++ return create_access_error_reply (message, G_DBUS_ERROR, G_DBUS_ERROR_ACCESS_DENIED,
++ "Cannot send message - unknown libdbuspolicy error");
++ }
++}
++#endif
++
++/*
++ * _g_kdbus_send
++ */
++static gboolean
++_g_kdbus_send (GKDBusWorker *worker,
++ GDBusMessage *message,
++ GDBusMessage **out_reply,
++ gint timeout_msec,
++ GCancellable *cancellable,
++ GError **error)
++{
++ struct kdbus_msg *msg;
++ GVariantVectors body_vectors;
++ struct kdbus_cmd_send *send;
++ gsize send_size;
++ gboolean result = FALSE;
++ gboolean lg_h_field_exist = FALSE;
++
++ gint memfd_fd;
++ gint cancel_fd;
++
++ gsize header_size;
++ gsize msg_size;
++
++ g_return_val_if_fail (G_IS_KDBUS_WORKER (worker), FALSE);
++
++ send = NULL;
++ send_size = sizeof(*send);
++
++ /* Prepare message body - it is needed for kdbus msg size computation */
++ header_size = prepare_body_vectors (worker, message, &body_vectors, &lg_h_field_exist);
++ make_single_header_vector (&body_vectors, header_size, lg_h_field_exist);
++
++ /* We precompute needed size for the message to allocate exact space instead
++ of some arbitrary amount */
++ msg_size = compute_msg_size (message, worker, &body_vectors);
++ if (msg_size <= KDBUS_MSG_MAX_SIZE)
++ {
++ msg = g_alloca (msg_size);
++ memset (msg, 0, msg_size);
++ }
++ else
++ {
++ msg = g_malloc0 (msg_size);
++ }
++ g_assert_nonnull (msg);
++
++ memfd_fd = -1;
++ cancel_fd = -1;
++
++ /* fill in as we go... */
++ msg->size = sizeof (struct kdbus_msg);
++ msg->payload_type = KDBUS_PAYLOAD_DBUS;
++ msg->cookie = g_dbus_message_get_serial(message);
++
++ /* Message destination */
++ if (!add_message_destination_item (msg, message, error))
++ goto out;
++
++ /* File descriptors */
++ add_file_descriptors_item (msg, message);
++
++ if (!add_body_vectors (msg, &body_vectors, &memfd_fd))
++ {
++ g_set_error (error, G_DBUS_ERROR, G_DBUS_ERROR_FAILED,
++ "message serialisation error: body vectors");
++ g_warning ("kdbus: message serialisation error: body vectors");
++ goto out;
++ }
++
++ /*
++ * 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 = 1U | ( /* ensure nonzero */
++ 1000U * g_get_monotonic_time() + (
++ timeout_msec == -1 ? DBUS_DEFAULT_TIMEOUT_MSEC * 1000000LLU :
++ timeout_msec == G_MAXINT ? KDBUS_INFINITE_TIMEOUT_NS :
++ (guint64)timeout_msec * 1000000U
++ )
++ );
++ else
++ msg->cookie_reply = g_dbus_message_get_reply_serial(message);
++
++ /*
++ * append bloom filter item for broadcast signals
++ */
++ if (!add_bloom_item (msg, message, worker))
++ {
++ g_set_error (error, G_DBUS_ERROR, G_DBUS_ERROR_FAILED,
++ "message serialisation error: bloom filters");
++ g_warning ("kdbus: message serialisation error: bloom filters");
++ goto out;
++ }
++
++ if (out_reply != NULL && cancellable)
++ {
++ cancel_fd = g_cancellable_get_fd (cancellable);
++ if (cancel_fd != -1)
++ send_size += KDBUS_ITEM_SIZE (sizeof(cancel_fd));
++ }
++
++ g_assert_cmpuint (msg->size, <=, msg_size);
++
++ send = g_alloca0 (send_size);
++ send->size = send_size;
++ send->msg_address = (gsize) msg;
++
++ if (out_reply != NULL)
++ {
++ /* synchronous call */
++ send->flags = KDBUS_SEND_SYNC_REPLY;
++
++ if (cancel_fd != -1)
++ {
++ struct kdbus_item *item;
++
++ item = send->items;
++ item->type = KDBUS_ITEM_CANCEL_FD;
++ item->size = KDBUS_ITEM_HEADER_SIZE + sizeof(cancel_fd);
++ item->fds[0] = cancel_fd;
++ }
++ }
++ else
++ {
++ /* asynchronous call */
++ send->flags = 0;
++ }
++
++ /*
++ * show debug
++ */
++ if (G_UNLIKELY (_g_dbus_debug_message ()))
++ {
++ gchar *s;
++ _g_dbus_debug_print_lock ();
++ g_print ("========================================================================\n"
++ "GDBus-debug:Message:\n"
++ " >>>> SENT D-Bus/kdbus message\n");
++ s = g_dbus_message_print (message, 2);
++ g_print ("%s", s);
++ g_free (s);
++ _g_dbus_debug_print_unlock ();
++ }
++
++ /*
++ * check policy
++ */
++#ifdef LIBDBUSPOLICY
++ if (worker->dbuspolicy != NULL)
++ {
++ if (g_dbus_message_get_message_type (message) == G_DBUS_MESSAGE_TYPE_METHOD_CALL ||
++ (g_dbus_message_get_message_type (message) == G_DBUS_MESSAGE_TYPE_SIGNAL &&
++ g_dbus_message_get_destination (message) != NULL))
++ {
++ gint check;
++
++ check = dbuspolicy1_check_out (worker->dbuspolicy,
++ g_dbus_message_get_destination (message),
++ worker->unique_name,
++ g_dbus_message_get_path (message),
++ g_dbus_message_get_interface (message),
++ g_dbus_message_get_member (message),
++ g_dbus_message_get_message_type (message),
++ NULL, 0, 0);
++ if (check != DBUSPOLICY_RESULT_ALLOW)
++ {
++ GDBusMessage *access_error_message;
++ access_error_message = check_result_to_error_reply (message, check);
++ result = TRUE;
++ if (out_reply != NULL)
++ {
++ *out_reply = access_error_message;
++ }
++ else
++ {
++ send_synthetic_message (worker, access_error_message);
++ }
++
++ goto out;
++ }
++ }
++ }
++#endif
++
++ /*
++ * send message
++ */
++ if (ioctl(worker->fd, KDBUS_CMD_SEND, send))
++ {
++ int ret = errno;
++ gchar *info;
++ if (asprintf (&info, "sender=%s destination=%s path=%s interface=%s member=%s type=%d",
++ g_dbus_message_get_sender (message),
++ g_dbus_message_get_destination (message),
++ g_dbus_message_get_path (message),
++ g_dbus_message_get_interface (message),
++ g_dbus_message_get_member (message),
++ g_dbus_message_get_message_type (message)) < 0)
++ {
++ g_set_error (error, G_DBUS_ERROR, G_DBUS_ERROR_FAILED, "%s", g_strerror(errno));
++ /* If asprintf fails, we lose the ioctl errno,
++ * but without info, we can't give a useful error message.
++ * In practice though, asprintf failure is exceedingly rare.
++ */
++ }
++ else
++ {
++ errno = ret;
++ if (errno == ENXIO || errno == ESRCH)
++ {
++ if (g_dbus_message_get_flags (message) & G_DBUS_MESSAGE_FLAGS_NO_AUTO_START)
++ g_set_error (error, G_DBUS_ERROR, G_DBUS_ERROR_NAME_HAS_NO_OWNER,
++ "Name \"%s\" does not exist, %s", g_dbus_message_get_destination (message), info);
++ else
++ g_set_error (error, G_DBUS_ERROR, G_DBUS_ERROR_SERVICE_UNKNOWN,
++ "Destination '%s' not known, %s", g_dbus_message_get_destination (message), info);
++ }
++ else if (errno == EADDRNOTAVAIL)
++ {
++ g_set_error (error, G_DBUS_ERROR, G_DBUS_ERROR_SERVICE_UNKNOWN,
++ "No support for activation for name: %s, %s", g_dbus_message_get_destination (message), info);
++ }
++ else if (errno == EXFULL)
++ {
++ g_set_error (error, G_DBUS_ERROR, G_DBUS_ERROR_LIMITS_EXCEEDED,
++ "The memory pool of the receiver is full, %s", info);
++ }
++ else if (errno == ENOBUFS)
++ {
++ g_set_error (error, G_DBUS_ERROR, G_DBUS_ERROR_LIMITS_EXCEEDED,
++ "Too many pending messages on the receiver side, %s", info);
++ }
++ else if (errno == EMSGSIZE)
++ {
++ g_set_error (error, G_DBUS_ERROR, G_DBUS_ERROR_LIMITS_EXCEEDED,
++ "The size of the message is excessive, %s", info);
++ }
++ else if (errno == EMLINK)
++ {
++ g_set_error (error, G_DBUS_ERROR, G_DBUS_ERROR_LIMITS_EXCEEDED,
++ "The maximum number of pending replies per connection has been reached, %s", info);
++ }
++ else if (errno == ECANCELED)
++ {
++ g_set_error (error, G_IO_ERROR, G_IO_ERROR_CANCELLED,
++ "Operation was cancelled, %s", info);
++ }
++ else if (errno == ETIMEDOUT)
++ {
++ g_set_error (error, G_IO_ERROR, G_IO_ERROR_TIMED_OUT,
++ "Timeout was reached, %s", info);
++ }
++ else if (errno == EPERM)
++ {
++ g_set_error (error, G_IO_ERROR, G_IO_ERROR_PERMISSION_DENIED,
++ "Permission denied, %s", info);
++ }
++ else
++ {
++ g_set_error (error, G_DBUS_ERROR, G_DBUS_ERROR_FAILED, "%s, %s", g_strerror(errno), info);
++ g_warning ("kdbus: %s, %s", g_strerror(errno), info);
++ }
++ free(info);
++ }
++ }
++ else
++ {
++ result = TRUE;
++ if (out_reply != NULL)
++ {
++ GKDBusMessage *kmsg;
++ struct kdbus_msg *kdbus_msg;
++
++ kdbus_msg = (struct kdbus_msg *)((guint8 *)worker->kdbus_buffer + send->reply.offset);
++
++ kmsg = g_kdbus_decode_dbus_msg (worker, kdbus_msg);
++ g_kdbus_close_msg (worker, kdbus_msg);
++
++ *out_reply = kmsg->message;
++
++ if (kmsg->sender_seclabel != NULL)
++ g_free (kmsg->sender_seclabel);
++
++ if (kmsg->sender_names != NULL)
++ g_free (kmsg->sender_names);
++
++ g_free (kmsg);
++
++ if (G_UNLIKELY (_g_dbus_debug_message ()))
++ {
++ gchar *s;
++ _g_dbus_debug_print_lock ();
++ g_print ("========================================================================\n"
++ "GDBus-debug:Message:\n"
++ " <<<< RECEIVED D-Bus message\n");
++ s = g_dbus_message_print (*out_reply, 2);
++ g_print ("%s", s);
++ g_free (s);
++ _g_dbus_debug_print_unlock ();
++ }
++ }
++ }
++
++out:
++ if (msg_size > KDBUS_MSG_MAX_SIZE)
++ g_free (msg);
++
++ if (cancel_fd != -1)
++ g_cancellable_release_fd (cancellable);
++
++ if (memfd_fd != -1)
++ close (memfd_fd);
++
++ GLIB_PRIVATE_CALL(g_variant_vectors_deinit) (&body_vectors);
++
++ return result;
++}
++
++/* ---------------------------------------------------------------------------------------------------- */
++
++static void
++g_kdbus_worker_finalize (GObject *object)
++{
++ GKDBusWorker *worker;
++ GList *match;
++
++ worker = G_KDBUS_WORKER (object);
++
++ if (worker->kdbus_buffer != NULL)
++ {
++ munmap (worker->kdbus_buffer, worker->receive_pool_size);
++ worker->kdbus_buffer = NULL;
++ worker->receive_pool_size = 0;
++ }
++
++ if (worker->unique_name != NULL)
++ g_free (worker->unique_name);
++ worker->unique_name = NULL;
++
++ for (match = worker->matches; match != NULL; match = match->next)
++ match_free (match->data);
++ g_list_free (worker->matches);
++ g_mutex_clear (&worker->matches_mutex);
++
++#ifdef LIBDBUSPOLICY
++ if (worker->dbuspolicy != NULL)
++ dbuspolicy1_free (worker->dbuspolicy);
++#endif
++
++ if (worker->fd != -1 && !worker->closed)
++ _g_kdbus_close (worker);
++
++ G_OBJECT_CLASS (g_kdbus_worker_parent_class)->finalize (object);
++}
++
++static void
++g_kdbus_worker_class_init (GKDBusWorkerClass *class)
++{
++ class->finalize = g_kdbus_worker_finalize;
++}
++
++static void
++g_kdbus_worker_init (GKDBusWorker *worker)
++{
++ worker->fd = -1;
++
++ worker->context = NULL;
++ worker->loop = NULL;
++ worker->thread = NULL;
++ worker->source = 0;
++
++ worker->kdbus_buffer = NULL;
++ worker->receive_pool_size = 0;
++ worker->unique_name = NULL;
++ worker->unique_id = -1;
++
++ worker->flags = KDBUS_HELLO_ACCEPT_FD;
++ worker->attach_flags_send = _KDBUS_ATTACH_ALL;
++ /* Attach items we really use only. Each collected item brings unneccessary overhead.
++ *
++ * The flags are used by libdbuspolicy library which uses these to apply dbus policy
++ * to each received message.
++ */
++ worker->attach_flags_recv = KDBUS_ATTACH_PIDS | KDBUS_ATTACH_CREDS | KDBUS_ATTACH_SECLABEL;
++
++ worker->bloom_size = 0;
++ worker->bloom_n_hash = 0;
++ worker->matches = NULL;
++ g_mutex_init (&worker->matches_mutex);
++
++#ifdef LIBDBUSPOLICY
++ worker->dbuspolicy = NULL;
++#endif
++}
++
++static gpointer
++_g_kdbus_worker_thread (gpointer _data)
++{
++ GMainLoop *loop = (GMainLoop *) _data;
++
++ g_main_loop_run (loop);
++
++ g_main_loop_unref (loop);
++
++ return NULL;
++}
++
++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;
++ }
++
++ worker->context = g_main_context_new ();
++ worker->loop = g_main_loop_new (worker->context, FALSE);
++ worker->thread = g_thread_new ("gkdbus", _g_kdbus_worker_thread, g_main_loop_ref(worker->loop));
++
++ 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;
++}
++
++static gboolean
++g_kdbus_ready (gint fd,
++ GIOCondition condition,
++ gpointer user_data)
++{
++ GKDBusWorker *worker;
++ GError *error;
++
++ worker = user_data;
++ error = NULL;
++
++ _g_kdbus_receive (worker, &error);
++ g_assert_no_error (error);
++
++ return G_SOURCE_CONTINUE;
++}
++
++void
++_g_kdbus_worker_unfreeze (GKDBusWorker *worker)
++{
++ gchar *name;
++
++ if (worker->source != NULL)
++ return;
++
++ worker->source = g_unix_fd_source_new (worker->fd, G_IO_IN);
++
++ g_source_set_callback (worker->source, (GSourceFunc) g_kdbus_ready,
++ g_object_ref (worker), g_object_unref);
++ 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,
++ gint timeout_msec,
++ GError **error)
++{
++#ifdef DBUS_DAEMON_EMULATION
++ if (_is_message_to_dbus_daemon (message))
++ {
++ GDBusMessage *reply = NULL;
++ reply = _dbus_daemon_synthetic_reply (worker, message, FALSE);
++
++ if (reply)
++ {
++ SyntheticReplyData *data;
++
++ data = g_new0 (SyntheticReplyData, 1);
++
++ data->worker = worker;
++ data->message = reply;
++
++ g_main_context_invoke (worker->context, deliver_synthetic_reply, data);
++ }
++
++ return TRUE;
++ }
++#endif /* DBUS_DAEMON_EMULATION */
++
++ return _g_kdbus_send (worker, message, NULL, timeout_msec, NULL, error);
++}
++
++gboolean
++_g_kdbus_worker_send_message_sync (GKDBusWorker *worker,
++ GDBusMessage *message,
++ GDBusMessage **out_reply,
++ gint timeout_msec,
++ GCancellable *cancellable,
++ GError **error)
++{
++#ifdef DBUS_DAEMON_EMULATION
++ if (_is_message_to_dbus_daemon (message))
++ {
++ *out_reply = _dbus_daemon_synthetic_reply (worker, message, TRUE);
++ return TRUE;
++ }
++#endif /* DBUS_DAEMON_EMULATION */
++
++ return _g_kdbus_send (worker, message, out_reply, timeout_msec, cancellable, error);
++}
++
++gboolean
++_g_kdbus_worker_flush_sync (GKDBusWorker *worker)
++{
++ return TRUE;
++}
++
++void
++_g_kdbus_worker_stop (GKDBusWorker *worker)
++{
++ g_source_destroy (worker->source);
++ g_source_unref (worker->source);
++ worker->source = 0;
++
++ g_object_unref (worker);
++}
++
++void
++_g_kdbus_worker_close (GKDBusWorker *worker,
++ GTask *task)
++{
++ worker->disconnected_callback (FALSE, NULL, worker->user_data);
++ g_task_return_boolean (task, TRUE);
++}
+diff --git a/gio/gkdbus.h b/gio/gkdbus.h
+new file mode 100644
+index 0000000..acbc0d5
+--- /dev/null
++++ b/gio/gkdbus.h
+@@ -0,0 +1,203 @@
++/* GIO - GLib Input, Output and Streaming Library
++ *
++ * Copyright (C) 2015 Samsung Electronics
++ *
++ * This library is free software; you can redistribute it and/or
++ * modify it under the terms of the GNU Lesser General Public
++ * License as published by the Free Software Foundation; either
++ * version 2 of the License, or (at your option) any later version.
++ *
++ * This library is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
++ * Lesser General Public License for more details.
++ *
++ * You should have received a copy of the GNU Lesser General
++ * Public License along with this library; if not, write to the
++ * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
++ * Boston, MA 02111-1307, USA.
++ *
++ * Author: Lukasz Skalski <l.skalski@samsung.com>
++ * Author: Michal Eljasiewicz <m.eljasiewic@samsung.com>
++ */
++
++#ifndef __G_KDBUS_H__
++#define __G_KDBUS_H__
++
++#if !defined (GIO_COMPILATION)
++#error "gkdbus.h is a private header file."
++#endif
++
++#include <gio/giotypes.h>
++#include "gdbusprivate.h"
++
++#define G_TYPE_KDBUS_WORKER (g_kdbus_worker_get_type ())
++#define G_KDBUS_WORKER(inst) (G_TYPE_CHECK_INSTANCE_CAST ((inst), \
++ G_TYPE_KDBUS_WORKER, GKDBusWorker))
++#define G_KDBUS_WORKER_CLASS(class) (G_TYPE_CHECK_CLASS_CAST ((class), \
++ G_TYPE_KDBUS_WORKER, GKDBusWorkerClass))
++#define G_IS_KDBUS_WORKER(inst) (G_TYPE_CHECK_INSTANCE_TYPE ((inst), \
++ G_TYPE_KDBUS_WORKER))
++#define G_IS_KDBUS_WORKER_CLASS(class) (G_TYPE_CHECK_CLASS_TYPE ((class), \
++ G_TYPE_KDBUS_WORKER))
++#define G_KDBUS_WORKER_GET_CLASS(inst) (G_TYPE_INSTANCE_GET_CLASS ((inst), \
++ G_TYPE_KDBUS_WORKER, GKDBusWorkerClass))
++typedef enum {
++ G_DBUS_CREDS_NONE = 0,
++ G_DBUS_CREDS_PID = (1<<0),
++ G_DBUS_CREDS_UID = (1<<1),
++ G_DBUS_CREDS_UNIQUE_NAME = (1<<2),
++ G_DBUS_CREDS_SEC_LABEL = (1<<3)
++} GDBusCredentialsFlags;
++
++typedef struct
++{
++ guint pid;
++ guint uid;
++ gchar *unique_name;
++ gchar *sec_label;
++} GDBusCredentials;
++
++typedef struct
++{
++ GDBusMessage *message;
++ uid_t sender_euid;
++ gid_t sender_egid;
++ gchar *sender_seclabel;
++ gchar *sender_names;
++} GKDBusMessage;
++
++typedef struct _GKDBusWorker GKDBusWorker;
++
++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);
++
++GType g_kdbus_worker_get_type (void);
++
++GKDBusWorker * _g_kdbus_worker_new (const gchar *address,
++ GError **error);
++
++void _g_kdbus_worker_unfreeze (GKDBusWorker *worker);
++
++gboolean _g_kdbus_worker_send_message (GKDBusWorker *worker,
++ GDBusMessage *message,
++ gint timeout_msec,
++ GError **error);
++
++gboolean _g_kdbus_worker_send_message_sync (GKDBusWorker *worker,
++ GDBusMessage *message,
++ GDBusMessage **out_reply,
++ gint timeout_msec,
++ GCancellable *cancellable,
++ GError **error);
++
++void _g_kdbus_worker_stop (GKDBusWorker *worker);
++
++gboolean _g_kdbus_worker_flush_sync (GKDBusWorker *worker);
++
++void _g_kdbus_worker_close (GKDBusWorker *worker,
++ GTask *task);
++
++/* ---------------------------------------------------------------------------------------------------- */
++
++gboolean _g_kdbus_open (GKDBusWorker *worker,
++ const gchar *address,
++ GError **error);
++
++gboolean _g_kdbus_can_connect (GKDBusWorker *worker,
++ GError **error);
++
++gboolean _g_kdbus_close (GKDBusWorker *worker);
++
++gboolean _g_kdbus_is_closed (GKDBusWorker *worker);
++
++/* ---------------------------------------------------------------------------------------------------- */
++
++const gchar * _g_kdbus_Hello (GKDBusWorker *worker,
++ GError **error);
++
++gchar * _g_kdbus_GetBusId (GKDBusWorker *worker,
++ GError **error);
++
++GBusRequestNameReplyFlags _g_kdbus_RequestName (GKDBusWorker *worker,
++ const gchar *name,
++ GBusNameOwnerFlags flags,
++ GError **error);
++
++GBusReleaseNameReplyFlags _g_kdbus_ReleaseName (GKDBusWorker *worker,
++ const gchar *name,
++ GError **error);
++
++gchar ** _g_kdbus_GetListNames (GKDBusWorker *worker,
++ gboolean activatable,
++ GError **error);
++
++gchar ** _g_kdbus_GetListQueuedOwners (GKDBusWorker *worker,
++ const gchar *name,
++ GError **error);
++
++gboolean _g_kdbus_NameHasOwner (GKDBusWorker *connection,
++ const gchar *name,
++ GError **error);
++
++gchar * _g_kdbus_GetNameOwner (GKDBusWorker *worker,
++ const gchar *name,
++ GError **error);
++
++pid_t _g_kdbus_GetConnectionUnixProcessID (GKDBusWorker *worker,
++ const gchar *name,
++ GError **error);
++
++uid_t _g_kdbus_GetConnectionUnixUser (GKDBusWorker *worker,
++ const gchar *name,
++ GError **error);
++
++gchar * _g_kdbus_GetConnectionSecurityLabel (GKDBusWorker *worker,
++ const gchar *name,
++ GError **error);
++
++GBusStartServiceReplyFlags _g_kdbus_StartServiceByName (GKDBusWorker *worker,
++ const gchar *name,
++ guint32 flags,
++ GDBusMessage *message,
++ GError **error);
++
++gboolean _g_kdbus_AddMatch (GKDBusWorker *worker,
++ const gchar *match_rule,
++ GError **error);
++
++gboolean _g_kdbus_RemoveMatch (GKDBusWorker *worker,
++ const gchar *match_rule,
++ GError **error);
++
++GDBusCredentials * _g_kdbus_GetConnInfo (GKDBusWorker *worker,
++ const gchar *name,
++ guint flags,
++ GError **error);
++
++/* ---------------------------------------------------------------------------------------------------- */
++
++gboolean _g_kdbus_subscribe_name_acquired (GKDBusWorker *worker,
++ const gchar *match_rule,
++ const gchar *name,
++ GError **error);
++
++gboolean _g_kdbus_subscribe_name_lost (GKDBusWorker *worker,
++ const gchar *match_rule,
++ const gchar *name,
++ GError **error);
++
++gboolean _g_kdbus_subscribe_name_owner_changed (GKDBusWorker *worker,
++ const gchar *match_rule,
++ const gchar *name,
++ GError **error);
++
++/* ---------------------------------------------------------------------------------------------------- */
++
++G_END_DECLS
++
++#endif /* __G_KDBUS_H__ */
+diff --git a/gio/gkdbusfakedaemon.c b/gio/gkdbusfakedaemon.c
+new file mode 100644
+index 0000000..04272f3
+--- /dev/null
++++ b/gio/gkdbusfakedaemon.c
+@@ -0,0 +1,694 @@
++/* GIO - GLib Input, Output and Streaming Library
++ *
++ * Copyright (C) 2015 Samsung Electronics
++ *
++ * This library is free software; you can redistribute it and/or
++ * modify it under the terms of the GNU Lesser General Public
++ * License as published by the Free Software Foundation; either
++ * version 2 of the License, or (at your option) any later version.
++ *
++ * This library is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
++ * Lesser General Public License for more details.
++ *
++ * You should have received a copy of the GNU Lesser General
++ * Public License along with this library; if not, write to the
++ * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
++ * Boston, MA 02111-1307, USA.
++ *
++ * Author: Lukasz Skalski <l.skalski@samsung.com>
++ */
++
++#include "config.h"
++#include "gkdbus.h"
++#include "gkdbusfakedaemon.h"
++
++#include <gio/gio.h>
++#include <string.h>
++
++static gchar *introspect =
++ "<!DOCTYPE node PUBLIC \"-//freedesktop//DTD D-BUS Object Introspection 1.0//EN\" "
++ "\"http://www.freedesktop.org/standards/dbus/1.0/introspect.dtd\">\n"
++ "<node>\n"
++ " <interface name=\"org.freedesktop.DBus.Introspectable\">\n"
++ " <method name=\"Introspect\">\n"
++ " <arg name=\"data\" type=\"s\" direction=\"out\"/>\n"
++ " </method>\n"
++ " </interface>\n"
++ " <interface name=\"org.freedesktop.DBus\">\n"
++ " <method name=\"AddMatch\">\n"
++ " <arg type=\"s\" direction=\"in\"/>\n"
++ " </method>\n"
++ " <method name=\"RemoveMatch\">\n"
++ " <arg type=\"s\" direction=\"in\"/>\n"
++ " </method>\n"
++ " <method name=\"GetConnectionCredentials\">\n"
++ " <arg type=\"s\" direction=\"in\"/>\n"
++ " <arg type=\"a{sv}\" direction=\"out\"/>\n"
++ " </method>\n"
++ " <method name=\"GetConnectionSELinuxSecurityContext\">\n"
++ " <arg type=\"s\" direction=\"in\"/>\n"
++ " <arg type=\"ay\" direction=\"out\"/>\n"
++ " </method>\n"
++ " <method name=\"GetConnectionUnixProcessID\">\n"
++ " <arg type=\"s\" direction=\"in\"/>\n"
++ " <arg type=\"u\" direction=\"out\"/>\n"
++ " </method>\n"
++ " <method name=\"GetConnectionUnixUser\">\n"
++ " <arg type=\"s\" direction=\"in\"/>\n"
++ " <arg type=\"u\" direction=\"out\"/>\n"
++ " </method>\n"
++ " <method name=\"GetId\">\n"
++ " <arg type=\"s\" direction=\"out\"/>\n"
++ " </method>\n"
++ " <method name=\"GetNameOwner\">\n"
++ " <arg type=\"s\" direction=\"in\"/>\n"
++ " <arg type=\"s\" direction=\"out\"/>\n"
++ " </method>\n"
++ " <method name=\"Hello\">\n"
++ " <arg type=\"s\" direction=\"out\"/>\n"
++ " </method>\n"
++ " <method name=\"ListActivatableNames\">\n"
++ " <arg type=\"as\" direction=\"out\"/>\n"
++ " </method>\n"
++ " <method name=\"ListNames\">\n"
++ " <arg type=\"as\" direction=\"out\"/>\n"
++ " </method>\n"
++ " <method name=\"ListQueuedOwners\">\n"
++ " <arg type=\"s\" direction=\"in\"/>\n"
++ " <arg type=\"as\" direction=\"out\"/>\n"
++ " </method>\n"
++ " <method name=\"NameHasOwner\">\n"
++ " <arg type=\"s\" direction=\"in\"/>\n"
++ " <arg type=\"b\" direction=\"out\"/>\n"
++ " </method>\n"
++ " <method name=\"ReleaseName\">\n"
++ " <arg type=\"s\" direction=\"in\"/>\n"
++ " <arg type=\"u\" direction=\"out\"/>\n"
++ " </method>\n"
++ " <method name=\"ReloadConfig\">\n"
++ " </method>\n"
++ " <method name=\"RequestName\">\n"
++ " <arg type=\"s\" direction=\"in\"/>\n"
++ " <arg type=\"u\" direction=\"in\"/>\n"
++ " <arg type=\"u\" direction=\"out\"/>\n"
++ " </method>\n"
++ " <method name=\"StartServiceByName\">\n"
++ " <arg type=\"s\" direction=\"in\"/>\n"
++ " <arg type=\"u\" direction=\"in\"/>\n"
++ " <arg type=\"u\" direction=\"out\"/>\n"
++ " </method>\n"
++ " <method name=\"UpdateActivationEnvironment\">\n"
++ " <arg type=\"a{ss}\" direction=\"in\"/>\n"
++ " </method>\n"
++ " <signal name=\"NameAcquired\">\n"
++ " <arg type=\"s\"/>\n"
++ " </signal>\n"
++ " <signal name=\"NameLost\">\n"
++ " <arg type=\"s\"/>\n"
++ " </signal>\n"
++ " <signal name=\"NameOwnerChanged\">\n"
++ " <arg type=\"s\"/>\n"
++ " <arg type=\"s\"/>\n"
++ " <arg type=\"s\"/>\n"
++ " </signal>\n"
++ " </interface>\n"
++ "</node>\n";
++
++static gboolean
++_mac_smack_use (void)
++{
++ static int cached_use = -1;
++
++ if (cached_use < 0)
++ cached_use = access("/sys/fs/smackfs/", F_OK) >= 0;
++
++ return cached_use;
++}
++
++/**
++ * _is_message_to_dbus_daemon()
++ */
++gboolean
++_is_message_to_dbus_daemon (GDBusMessage *message)
++{
++ return g_strcmp0 (g_dbus_message_get_destination (message), "org.freedesktop.DBus") == 0 &&
++ (g_strcmp0 (g_dbus_message_get_interface (message), "org.freedesktop.DBus") == 0 ||
++ g_strcmp0 (g_dbus_message_get_interface (message), "org.freedesktop.DBus.Introspectable") == 0) &&
++ (g_strcmp0 (g_dbus_message_get_path (message), "/org/freedesktop/DBus") == 0 ||
++ g_strcmp0 (g_dbus_message_get_path (message), "/") == 0);
++}
++
++
++/**
++ * _dbus_daemon_synthetic_reply()
++ */
++GDBusMessage *
++_dbus_daemon_synthetic_reply (GKDBusWorker *worker,
++ GDBusMessage *message,
++ gboolean sync)
++{
++ GDBusMessage *reply;
++ GVariant *reply_body;
++ GVariant *body;
++ GError *local_error;
++ const gchar *member;
++
++ reply = NULL;
++ reply_body = NULL;
++ local_error = NULL;
++
++ member = g_dbus_message_get_member (message);
++ body = g_dbus_message_get_body (message);
++
++ /* show debug */
++ if (G_UNLIKELY (_g_dbus_debug_message ()))
++ {
++ gchar *s;
++ _g_dbus_debug_print_lock ();
++ g_print ("========================================================================\n"
++ "GDBus-debug:Message:\n"
++ " >>>> SENT D-Bus/kdbus message\n");
++ s = g_dbus_message_print (message, 2);
++ g_print ("%s", s);
++ g_free (s);
++ _g_dbus_debug_print_unlock ();
++ }
++
++ /*
++ * Introspect
++ */
++ if (!g_strcmp0 (member, "Introspect"))
++ {
++ reply_body = g_variant_new ("(s)", introspect);
++ }
++
++ /*
++ * AddMatch
++ */
++ else if (!g_strcmp0 (member, "AddMatch"))
++ {
++ if (body != NULL && g_variant_is_of_type (body, G_VARIANT_TYPE ("(s)")))
++ {
++ gchar *rule;
++
++ g_variant_get (body, "(&s)", &rule);
++
++ _g_kdbus_AddMatch (worker, rule, &local_error);
++ if (local_error == NULL)
++ reply_body = g_variant_new ("()", NULL);
++ }
++ else
++ g_set_error (&local_error, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS,
++ "Call to 'AddMatch' has wrong args (expected s)");
++ }
++
++ /*
++ * RemoveMatch
++ */
++ else if (!g_strcmp0 (member, "RemoveMatch"))
++ {
++ if (body != NULL && g_variant_is_of_type (body, G_VARIANT_TYPE ("(s)")))
++ {
++ gchar *rule;
++
++ g_variant_get (body, "(&s)", &rule);
++
++ _g_kdbus_RemoveMatch (worker, rule, &local_error);
++ if (local_error == NULL)
++ reply_body = g_variant_new ("()", NULL);
++ }
++ else
++ g_set_error (&local_error, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS,
++ "Call to 'RemoveMatch' has wrong args (expected s)");
++ }
++
++ /*
++ * GetConnectionCredentials
++ */
++ else if (!g_strcmp0 (member, "GetConnectionCredentials"))
++ {
++ if (body != NULL && g_variant_is_of_type (body, G_VARIANT_TYPE ("(s)")))
++ {
++ GDBusCredentials *creds;
++ gchar *name;
++ guint flags;
++
++ creds = NULL;
++ flags = G_DBUS_CREDS_PID | G_DBUS_CREDS_UID | G_DBUS_CREDS_SEC_LABEL;
++
++ g_variant_get (body, "(&s)", &name);
++
++ creds = _g_kdbus_GetConnInfo (worker,
++ name,
++ flags,
++ &local_error);
++ if (local_error == NULL)
++ {
++ GVariantBuilder builder;
++
++ g_variant_builder_init (&builder, G_VARIANT_TYPE ("(a{sv})"));
++ g_variant_builder_open (&builder, G_VARIANT_TYPE ("a{sv}"));
++
++ g_variant_builder_add (&builder, "{sv}", "UnixUserID", g_variant_new_uint32 (creds->uid));
++ g_variant_builder_add (&builder, "{sv}", "ProcessID", g_variant_new_uint32 (creds->pid));
++
++ if (creds->sec_label != NULL)
++ {
++ GVariantBuilder *label_builder;
++ gint counter;
++ gint label_size;
++
++ label_size = strlen (creds->sec_label);
++ label_builder = g_variant_builder_new (G_VARIANT_TYPE ("ay"));
++ for (counter = 0 ; counter < label_size + 1; counter++) /* label_size + 1 : include the \0 in the payload, for zero-copy reading. From dbus/bus/driver.c */
++ g_variant_builder_add (label_builder, "y", creds->sec_label[counter]);
++
++ g_variant_builder_add (&builder, "{sv}", "LinuxSecurityLabel", g_variant_new ("ay", label_builder));
++
++ g_variant_builder_unref (label_builder);
++ g_free (creds->sec_label);
++ }
++
++ g_variant_builder_close (&builder);
++ reply_body = g_variant_builder_end (&builder);
++ g_free (creds);
++ }
++ }
++ else
++ g_set_error (&local_error, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS,
++ "Call to 'GetConnectionCredentials' has wrong args (expected s)");
++ }
++
++ /*
++ * GetConnectionSELinuxSecurityContext
++ */
++ else if (!g_strcmp0 (member, "GetConnectionSELinuxSecurityContext"))
++ {
++ if (body != NULL && g_variant_is_of_type (body, G_VARIANT_TYPE ("(s)")))
++ {
++ gchar *name;
++ gchar *label;
++
++ g_variant_get (body, "(&s)", &name);
++
++ label = _g_kdbus_GetConnectionSecurityLabel (worker, name, &local_error);
++ if (label == NULL && local_error == NULL)
++ g_set_error (&local_error, G_DBUS_ERROR, G_DBUS_ERROR_NOT_SUPPORTED, "Operation not supported");
++ else if (local_error == NULL)
++ {
++ /* 'label' (KDBUS_ITEM_SECLABEL item) contains valid LSM security label... */
++ if (_mac_smack_use())
++ {
++ /* but if we are using SMACK - to keep compatibility with legacy dbus1 - return error */
++ g_set_error (&local_error, G_DBUS_ERROR, G_DBUS_ERROR_SELINUX_SECURITY_CONTEXT_UNKNOWN,
++ "Could not determine security context for '%s'", name);
++ }
++ else
++ {
++ /* if it is not SMACK - let's assume that it's SELinux label */
++ GVariantBuilder builder;
++ gint counter;
++
++ g_variant_builder_init (&builder, G_VARIANT_TYPE ("(ay)"));
++ g_variant_builder_open (&builder, G_VARIANT_TYPE ("ay"));
++
++ for (counter = 0 ; counter < strlen (label) ; counter++)
++ g_variant_builder_add (&builder, "y", label[counter]);
++
++ g_variant_builder_close (&builder);
++ reply_body = g_variant_builder_end (&builder);
++ }
++ g_free (label);
++ }
++ }
++ else
++ g_set_error (&local_error, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS,
++ "Call to 'GetConnectionSELinuxSecurityContext' has wrong args (expected s)");
++ }
++
++ /*
++ * GetConnectionUnixProcessID
++ */
++ else if (!g_strcmp0 (member, "GetConnectionUnixProcessID"))
++ {
++ if (body != NULL && g_variant_is_of_type (body, G_VARIANT_TYPE ("(s)")))
++ {
++ gchar *name;
++ pid_t pid;
++
++ g_variant_get (body, "(&s)", &name);
++ pid = _g_kdbus_GetConnectionUnixProcessID (worker, name, &local_error);
++ if (local_error == NULL)
++ reply_body = g_variant_new ("(u)", pid);
++ }
++ else
++ g_set_error (&local_error, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS,
++ "Call to 'GetConnectionUnixProcessID' has wrong args (expected s)");
++ }
++
++ /*
++ * GetConnectionUnixUser
++ */
++ else if (!g_strcmp0 (member, "GetConnectionUnixUser"))
++ {
++ if (body != NULL && g_variant_is_of_type (body, G_VARIANT_TYPE ("(s)")))
++ {
++ gchar *name;
++ uid_t uid;
++
++ g_variant_get (body, "(&s)", &name);
++ uid = _g_kdbus_GetConnectionUnixUser (worker, name, &local_error);
++ if (local_error == NULL)
++ reply_body = g_variant_new ("(u)", uid);
++ }
++ else
++ g_set_error (&local_error, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS,
++ "Call to 'GetConnectionUnixUser' has wrong args (expected s)");
++ }
++
++ /*
++ * GetId
++ */
++ else if (!g_strcmp0 (member, "GetId"))
++ {
++ if ((body == NULL) || g_variant_is_of_type (body, G_VARIANT_TYPE ("()")))
++ {
++ gchar *bus_id;
++
++ bus_id = _g_kdbus_GetBusId (worker, NULL);
++ reply_body = g_variant_new ("(s)", bus_id);
++
++ g_free (bus_id);
++ }
++ else
++ g_set_error (&local_error, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS,
++ "Call to 'GetId' has wrong args");
++ }
++
++ /*
++ * GetNameOwner
++ */
++ else if (!g_strcmp0 (member, "GetNameOwner"))
++ {
++ if (body != NULL && g_variant_is_of_type (body, G_VARIANT_TYPE ("(s)")))
++ {
++ gchar *unique_name;
++ gchar *name;
++
++ g_variant_get (body, "(&s)", &name);
++
++ unique_name = _g_kdbus_GetNameOwner (worker, name, &local_error);
++ if (local_error == NULL)
++ reply_body = g_variant_new ("(s)", unique_name);
++ g_free (unique_name);
++ }
++ else
++ g_set_error (&local_error, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS,
++ "Call to 'GetNameOwner' has wrong args (expected s)");
++ }
++
++ /*
++ * Hello
++ */
++ else if (!g_strcmp0 (member, "Hello"))
++ {
++ if ((body == NULL) || g_variant_is_of_type (body, G_VARIANT_TYPE ("()")))
++ {
++ const gchar *unique_name;
++
++ unique_name = _g_kdbus_Hello (worker, &local_error);
++ if (local_error == NULL)
++ reply_body = g_variant_new ("(s)", unique_name);
++ }
++ else
++ g_set_error (&local_error, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS,
++ "Call to 'Hello' has wrong args");
++ }
++
++ /*
++ * ListActivatableNames
++ */
++ else if (!g_strcmp0 (member, "ListActivatableNames"))
++ {
++ if ((body == NULL) || g_variant_is_of_type (body, G_VARIANT_TYPE ("()")))
++ {
++ gchar **strv;
++ gint cnt;
++
++ cnt = 0;
++
++ strv = _g_kdbus_GetListNames (worker, TRUE, &local_error);
++ if (local_error == NULL)
++ {
++ GVariantBuilder *builder;
++
++ builder = g_variant_builder_new (G_VARIANT_TYPE ("as"));
++
++ while (strv[cnt])
++ g_variant_builder_add (builder, "s", strv[cnt++]);
++
++ reply_body = g_variant_new ("(as)", builder);
++
++ g_variant_builder_unref (builder);
++ }
++ g_strfreev (strv);
++ }
++ else
++ g_set_error (&local_error, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS,
++ "Call to 'ListActivatableNames' has wrong args");
++ }
++
++ /*
++ * ListNames
++ */
++ else if (!g_strcmp0 (member, "ListNames"))
++ {
++ if ((body == NULL) || g_variant_is_of_type (body, G_VARIANT_TYPE ("()")))
++ {
++ gchar **strv;
++ gint cnt;
++
++ cnt = 0;
++
++ strv = _g_kdbus_GetListNames (worker, FALSE, &local_error);
++ if (local_error == NULL)
++ {
++ GVariantBuilder *builder;
++
++ builder = g_variant_builder_new (G_VARIANT_TYPE ("as"));
++
++ while (strv[cnt])
++ g_variant_builder_add (builder, "s", strv[cnt++]);
++
++ reply_body = g_variant_new ("(as)", builder);
++
++ g_variant_builder_unref (builder);
++ }
++ g_strfreev (strv);
++ }
++ else
++ g_set_error (&local_error, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS,
++ "Call to 'ListNames' has wrong args");
++ }
++
++ /*
++ * ListQueuedOwners
++ */
++ else if (!g_strcmp0 (member, "ListQueuedOwners"))
++ {
++ if (body != NULL && g_variant_is_of_type (body, G_VARIANT_TYPE ("(s)")))
++ {
++ gchar **strv;
++ gchar *name;
++ gint cnt;
++
++ cnt = 0;
++
++ g_variant_get (body, "(&s)", &name);
++ strv = _g_kdbus_GetListQueuedOwners (worker, name, &local_error);
++ if (local_error == NULL)
++ {
++ GVariantBuilder *builder;
++
++ builder = g_variant_builder_new (G_VARIANT_TYPE ("as"));
++
++ while (strv[cnt])
++ g_variant_builder_add (builder, "s", strv[cnt++]);
++
++ reply_body = g_variant_new ("(as)", builder);
++
++ g_variant_builder_unref (builder);
++ }
++ g_strfreev (strv);
++ }
++ else
++ g_set_error (&local_error, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS,
++ "Call to 'ListQueuedOwners' has wrong args (expected s)");
++ }
++
++ /*
++ * NameHasOwner
++ */
++ else if (!g_strcmp0 (member, "NameHasOwner"))
++ {
++ if (body != NULL && g_variant_is_of_type (body, G_VARIANT_TYPE ("(s)")))
++ {
++ gboolean ret;
++ gchar *name;
++
++ g_variant_get (body, "(&s)", &name);
++
++ ret = _g_kdbus_NameHasOwner (worker, name, &local_error);
++ if (local_error == NULL)
++ {
++ if (ret)
++ reply_body = g_variant_new ("(b)", TRUE);
++ else
++ reply_body = g_variant_new ("(b)", FALSE);
++ }
++ }
++ else
++ g_set_error (&local_error, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS,
++ "Call to 'NameHasOwner' has wrong args (expected s)");
++ }
++
++ /*
++ * ReleaseName
++ */
++ else if (!g_strcmp0 (member, "ReleaseName"))
++ {
++ if (body != NULL && g_variant_is_of_type (body, G_VARIANT_TYPE ("(s)")))
++ {
++ GBusReleaseNameReplyFlags status;
++ gchar *name;
++
++ g_variant_get (body, "(&s)", &name);
++
++ status = _g_kdbus_ReleaseName (worker, name, &local_error);
++ if (local_error == NULL)
++ reply_body = g_variant_new ("(u)", status);
++ }
++ else
++ g_set_error (&local_error, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS,
++ "Call to 'ReleaseName' has wrong args (expected s)");
++ }
++
++ /*
++ * ReloadConfig
++ */
++ else if (!g_strcmp0 (member, "ReloadConfig"))
++ {
++ if ((body == NULL) || g_variant_is_of_type (body, G_VARIANT_TYPE ("()")))
++ reply_body = g_variant_new ("()", NULL);
++ else
++ g_set_error (&local_error, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS,
++ "Call to 'ReloadConfig' has wrong args");
++ }
++
++ /*
++ * RequestName
++ */
++ else if (!g_strcmp0 (member, "RequestName"))
++ {
++ if (body != NULL && g_variant_is_of_type (body, G_VARIANT_TYPE ("(su)")))
++ {
++ GBusRequestNameReplyFlags status;
++ guint32 flags;
++ gchar *name;
++
++ g_variant_get (body, "(&su)", &name, &flags);
++
++ status = _g_kdbus_RequestName (worker, name, flags, &local_error);
++ if (local_error == NULL)
++ reply_body = g_variant_new ("(u)", status);
++ }
++ else
++ g_set_error (&local_error, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS,
++ "Call to 'RequestName' has wrong args (expected su)");
++ }
++
++ /*
++ * StartServiceByName
++ */
++ else if (!g_strcmp0 (member, "StartServiceByName"))
++ {
++ if (body != NULL && g_variant_is_of_type (body, G_VARIANT_TYPE ("(su)")))
++ {
++ GBusStartServiceReplyFlags status;
++ gchar *name;
++ guint32 flags;
++
++ g_variant_get (body, "(&su)", &name, &flags);
++
++ if (sync)
++ status = _g_kdbus_StartServiceByName (worker, name, flags, NULL, &local_error);
++ else
++ status = _g_kdbus_StartServiceByName (worker, name, flags, message, &local_error);
++
++ if (local_error == NULL)
++ {
++ if (status == G_BUS_START_SERVICE_REPLY_ALREADY_RUNNING || sync)
++ reply_body = g_variant_new ("(u)", status);
++ else
++ return NULL;
++ }
++ }
++ else
++ g_set_error (&local_error, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS,
++ "Call to 'StartServiceByName' has wrong args (expected su)");
++ }
++
++ /*
++ * UpdateActivationEnvironment
++ */
++ else if (!g_strcmp0 (member, "UpdateActivationEnvironment"))
++ {
++ g_set_error (&local_error, G_DBUS_ERROR, G_DBUS_ERROR_NOT_SUPPORTED,
++ "'%s' method not supported", member);
++ }
++
++ /*
++ * Method not supported
++ */
++ else
++ {
++ g_set_error (&local_error, G_DBUS_ERROR, G_DBUS_ERROR_UNKNOWN_METHOD,
++ "org.freedesktop.DBus does not understand message %s", member);
++ }
++
++ if (reply_body == NULL && local_error)
++ {
++ gchar *dbus_error_name;
++
++ dbus_error_name = g_dbus_error_encode_gerror (local_error);
++ reply = g_dbus_message_new_method_error (message, dbus_error_name, "%s", local_error->message);
++ g_free (dbus_error_name);
++ }
++ else
++ {
++ reply = g_dbus_message_new_method_reply (message);
++ g_dbus_message_set_body (reply, reply_body);
++ }
++
++ g_dbus_message_set_serial (reply, -1);
++
++ if (local_error)
++ g_error_free (local_error);
++
++ if (G_UNLIKELY (_g_dbus_debug_message ()))
++ {
++ gchar *s;
++ _g_dbus_debug_print_lock ();
++ g_print ("========================================================================\n"
++ "GDBus-debug:Message:\n"
++ " <<<< RECEIVED synthetic D-Bus message\n");
++ s = g_dbus_message_print (reply, 2);
++ g_print ("%s", s);
++ g_free (s);
++ _g_dbus_debug_print_unlock ();
++ }
++
++ return reply;
++}
+diff --git a/gio/gkdbusfakedaemon.h b/gio/gkdbusfakedaemon.h
+new file mode 100644
+index 0000000..969b7b5
+--- /dev/null
++++ b/gio/gkdbusfakedaemon.h
+@@ -0,0 +1,39 @@
++/* GIO - GLib Input, Output and Streaming Library
++ *
++ * Copyright (C) 2015 Samsung Electronics
++ *
++ * This library is free software; you can redistribute it and/or
++ * modify it under the terms of the GNU Lesser General Public
++ * License as published by the Free Software Foundation; either
++ * version 2 of the License, or (at your option) any later version.
++ *
++ * This library is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
++ * Lesser General Public License for more details.
++ *
++ * You should have received a copy of the GNU Lesser General
++ * Public License along with this library; if not, write to the
++ * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
++ * Boston, MA 02111-1307, USA.
++ *
++ * Author: Lukasz Skalski <l.skalski@samsung.com>
++ */
++
++#ifndef __G_KDBUSFAKEDAEMON_H__
++#define __G_KDBUSFAKEDAEMON_H__
++
++#if !defined (GIO_COMPILATION)
++#error "gkdbusfakedaemon.h is a private header file."
++#endif
++
++#include <gio/giotypes.h>
++
++gboolean _is_message_to_dbus_daemon (GDBusMessage *message);
++
++GDBusMessage * _dbus_daemon_synthetic_reply (GKDBusWorker *worker,
++ GDBusMessage *message,
++ gboolean sync);
++G_END_DECLS
++
++#endif /* __G_KDBUSFAKEDAEMON_H__ */
+diff --git a/gio/gunixfdlist.h b/gio/gunixfdlist.h
+index df5587e..d5a9e8e 100644
+--- a/gio/gunixfdlist.h
++++ b/gio/gunixfdlist.h
+@@ -71,6 +71,9 @@ GIO_AVAILABLE_IN_ALL
+ GUnixFDList * g_unix_fd_list_new_from_array (const gint *fds,
+ gint n_fds);
+
++GIO_AVAILABLE_IN_2_44
++void g_unix_fd_list_lock (GUnixFDList *list);
++
+ GIO_AVAILABLE_IN_ALL
+ gint g_unix_fd_list_append (GUnixFDList *list,
+ gint fd,
+diff --git a/gio/meson.build b/gio/meson.build
+index a4e9b30..f230c05 100644
+--- a/gio/meson.build
++++ b/gio/meson.build
+@@ -231,6 +231,13 @@ gdbus_sources = files(
+ 'gtestdbus.c',
+ )
+
++if get_option('kdbus')
++gdbus_sources += files(
++ 'gkdbus.c',
++ 'gkdbusfakedaemon.c',
++)
++endif
++
+ # Generate gdbus-codegen
+ subdir('gdbus-2.0/codegen')
+
+@@ -837,6 +844,16 @@ else
+ gio_dtrace_hdr = []
+ endif
+
++if get_option('kdbus')
++ gio_c_args += '-DKDBUS'
++endif
++
++libdbuspolicy_dep = dependency('', required : false)
++if get_option('libdbuspolicy')
++ libdbuspolicy_dep = dependency('libdbuspolicy1', version : '>=1', required : true)
++ gio_c_args += '-DLIBDBUSPOLICY'
++endif
++
+ libgio = library('gio-2.0',
+ gioenumtypes_h, gioenumtypes_c, gnetworking_h, gio_sources,
+ gio_dtrace_hdr, gio_dtrace_obj,
+@@ -849,7 +866,7 @@ libgio = library('gio-2.0',
+ link_with: internal_deps,
+ dependencies : [libz_dep, libdl_dep, libmount_dep, libglib_dep,
+ libgobject_dep, libgmodule_dep, selinux_dep, xattr_dep,
+- platform_deps, network_libs, libsysprof_capture_dep,
++ platform_deps, network_libs, libdbuspolicy_dep, libsysprof_capture_dep,
+ gioenumtypes_dep, gvdb_dep],
+ c_args : [gio_c_args, gio_c_args_internal],
+ objc_args : [gio_c_args, gio_c_args_internal],
+diff --git a/meson_options.txt b/meson_options.txt
+index 517d575..7c95d03 100644
+--- a/meson_options.txt
++++ b/meson_options.txt
+@@ -93,6 +93,16 @@ option('nls',
+ yield: true,
+ description : 'Enable native language support (translations)')
+
++option('kdbus',
++ type : 'boolean',
++ value : false,
++ description : 'enable kdbus transport')
++
++option('libdbuspolicy',
++ type : 'boolean',
++ value : false,
++ description : 'enable libdbuspolicy for kdbus transport')
++
+ option('oss_fuzz',
+ type : 'feature',
+ value : 'disabled',
+--
+2.25.1
+
projects / platform / upstream / glib.git / commitdiff