glib: Bundle snapshot of glib-2.0

Add a snapshot of the current stable version of glib, glib-2.32.0. Since
we only need the glib library, a lot of files are removed. See the
README and update-glib.sh files in glib-patches for details.

1 files changed, 1689 insertions, 0 deletions

diff --git a/glib/glib/gvariant-serialiser.c b/glib/glib/gvariant-serialiser.c
new file mode 100644
index 0000000..f072511
--- /dev/null
+++ b/glib/glib/gvariant-serialiser.c
@@ -0,0 +1,1689 @@
+/*
+ * Copyright © 2007, 2008 Ryan Lortie
+ * Copyright © 2010 Codethink 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 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: Ryan Lortie <desrt@desrt.ca>
+ */
+
+/* Prologue {{{1 */
+#include "config.h"
+
+#include "gvariant-serialiser.h"
+
+#include <glib/gtestutils.h>
+#include <glib/gstrfuncs.h>
+#include <glib/gtypes.h>
+
+#include <string.h>
+
+
+/* GVariantSerialiser
+ *
+ * After this prologue section, this file has roughly 2 parts.
+ *
+ * The first part is split up into sections according to various
+ * container types.  Maybe, Array, Tuple, Variant.  The Maybe and Array
+ * sections are subdivided for element types being fixed or
+ * variable-sized types.
+ *
+ * Each section documents the format of that particular type of
+ * container and implements 5 functions for dealing with it:
+ *
+ *  n_children:
+ *    - determines (according to serialised data) how many child values
+ *      are inside a particular container value.
+ *
+ *  get_child:
+ *    - gets the type of and the serialised data corresponding to a
+ *      given child value within the container value.
+ *
+ *  needed_size:
+ *    - determines how much space would be required to serialise a
+ *      container of this type, containing the given children so that
+ *      buffers can be preallocated before serialising.
+ *
+ *  serialise:
+ *    - write the serialised data for a container of this type,
+ *      containing the given children, to a buffer.
+ *
+ *  is_normal:
+ *    - check the given data to ensure that it is in normal form.  For a
+ *      given set of child values, there is exactly one normal form for
+ *      the serialised data of a container.  Other forms are possible
+ *      while maintaining the same children (for example, by inserting
+ *      something other than zero bytes as padding) but only one form is
+ *      the normal form.
+ *
+ * The second part contains the main entry point for each of the above 5
+ * functions and logic to dispatch it to the handler for the appropriate
+ * container type code.
+ *
+ * The second part also contains a routine to byteswap serialised
+ * values.  This code makes use of the n_children() and get_child()
+ * functions above to do its work so no extra support is needed on a
+ * per-container-type basis.
+ *
+ * There is also additional code for checking for normal form.  All
+ * numeric types are always in normal form since the full range of
+ * values is permitted (eg: 0 to 255 is a valid byte).  Special checks
+ * need to be performed for booleans (only 0 or 1 allowed), strings
+ * (properly nul-terminated) and object paths and signature strings
+ * (meeting the D-Bus specification requirements).
+ */
+
+/* < private >
+ * GVariantSerialised:
+ * @type_info: the #GVariantTypeInfo of this value
+ * @data: the serialised data of this value, or %NULL
+ * @size: the size of this value
+ *
+ * A structure representing a GVariant in serialised form.  This
+ * structure is used with #GVariantSerialisedFiller functions and as the
+ * primary interface to the serialiser.  See #GVariantSerialisedFiller
+ * for a description of its use there.
+ *
+ * When used with the serialiser API functions, the following invariants
+ * apply to all #GVariantTypeSerialised structures passed to and
+ * returned from the serialiser.
+ *
+ * @type_info must be non-%NULL.
+ *
+ * @data must be properly aligned for the type described by @type_info.
+ *
+ * If @type_info describes a fixed-sized type then @size must always be
+ * equal to the fixed size of that type.
+ *
+ * For fixed-sized types (and only fixed-sized types), @data may be
+ * %NULL even if @size is non-zero.  This happens when a framing error
+ * occurs while attempting to extract a fixed-sized value out of a
+ * variable-sized container.  There is no data to return for the
+ * fixed-sized type, yet @size must be non-zero.  The effect of this
+ * combination should be as if @data were a pointer to an
+ * appropriately-sized zero-filled region.
+ */
+
+/* < private >
+ * g_variant_serialised_check:
+ * @serialised: a #GVariantSerialised struct
+ *
+ * Checks @serialised for validity according to the invariants described
+ * above.
+ */
+static void
+g_variant_serialised_check (GVariantSerialised serialised)
+{
+  gsize fixed_size;
+  guint alignment;
+
+  g_assert (serialised.type_info != NULL);
+  g_variant_type_info_query (serialised.type_info, &alignment, &fixed_size);
+
+  if (fixed_size)
+    g_assert_cmpint (serialised.size, ==, fixed_size);
+  else
+    g_assert (serialised.size == 0 || serialised.data != NULL);
+
+  /* Depending on the native alignment requirements of the machine, the
+   * compiler will insert either 3 or 7 padding bytes after the char.
+   * This will result in the sizeof() the struct being 12 or 16.
+   * Subtract 9 to get 3 or 7 which is a nice bitmask to apply to get
+   * the alignment bits that we "care about" being zero: in the
+   * 4-aligned case, we care about 2 bits, and in the 8-aligned case, we
+   * care about 3 bits.
+   */
+  alignment &= sizeof (struct {
+                         char a;
+                         union {
+                           guint64 x;
+                           void *y;
+                           gdouble z;
+                         } b;
+                       }
+                      ) - 9;
+
+  /* Some OSes (FreeBSD is a known example) have a malloc() that returns
+   * unaligned memory if you request small sizes.  'malloc (1);', for
+   * example, has been seen to return pointers aligned to 6 mod 16.
+   *
+   * Check if this is a small allocation and return without enforcing
+   * the alignment assertion if this is the case.
+   */
+  if (serialised.size <= alignment)
+    return;
+
+  g_assert_cmpint (alignment & (gsize) serialised.data, ==, 0);
+}
+
+/* < private >
+ * GVariantSerialisedFiller:
+ * @serialised: a #GVariantSerialised instance to fill
+ * @data: data from the children array
+ *
+ * This function is called back from g_variant_serialiser_needed_size()
+ * and g_variant_serialiser_serialise().  It fills in missing details
+ * from a partially-complete #GVariantSerialised.
+ *
+ * The @data parameter passed back to the function is one of the items
+ * that was passed to the serialiser in the @children array.  It
+ * represents a single child item of the container that is being
+ * serialised.  The information filled in to @serialised is the
+ * information for this child.
+ *
+ * If the @type_info field of @serialised is %NULL then the callback
+ * function must set it to the type information corresponding to the
+ * type of the child.  No reference should be added.  If it is non-%NULL
+ * then the callback should assert that it is equal to the actual type
+ * of the child.
+ *
+ * If the @size field is zero then the callback must fill it in with the
+ * required amount of space to store the serialised form of the child.
+ * If it is non-zero then the callback should assert that it is equal to
+ * the needed size of the child.
+ *
+ * If @data is non-%NULL then it points to a space that is properly
+ * aligned for and large enough to store the serialised data of the
+ * child.  The callback must store the serialised form of the child at
+ * @data.
+ *
+ * If the child value is another container then the callback will likely
+ * recurse back into the serialiser by calling
+ * g_variant_serialiser_needed_size() to determine @size and
+ * g_variant_serialiser_serialise() to write to @data.
+ */
+
+/* PART 1: Container types {{{1
+ *
+ * This section contains the serialiser implementation functions for
+ * each container type.
+ */
+
+/* Maybe {{{2
+ *
+ * Maybe types are handled depending on if the element type of the maybe
+ * type is a fixed-sized or variable-sized type.  Although all maybe
+ * types themselves are variable-sized types, herein, a maybe value with
+ * a fixed-sized element type is called a "fixed-sized maybe" for
+ * convenience and a maybe value with a variable-sized element type is
+ * called a "variable-sized maybe".
+ */
+
+/* Fixed-sized Maybe {{{3
+ *
+ * The size of a maybe value with a fixed-sized element type is either 0
+ * or equal to the fixed size of its element type.  The case where the
+ * size of the maybe value is zero corresponds to the "Nothing" case and
+ * the case where the size of the maybe value is equal to the fixed size
+ * of the element type corresponds to the "Just" case; in that case, the
+ * serialised data of the child value forms the entire serialised data
+ * of the maybe value.
+ *
+ * In the event that a fixed-sized maybe value is presented with a size
+ * that is not equal to the fixed size of the element type then the
+ * value must be taken to be "Nothing".
+ */
+
+static gsize
+gvs_fixed_sized_maybe_n_children (GVariantSerialised value)
+{
+  gsize element_fixed_size;
+
+  g_variant_type_info_query_element (value.type_info, NULL,
+                                     &element_fixed_size);
+
+  return (element_fixed_size == value.size) ? 1 : 0;
+}
+
+static GVariantSerialised
+gvs_fixed_sized_maybe_get_child (GVariantSerialised value,
+                                 gsize              index_)
+{
+  /* the child has the same bounds as the
+   * container, so just update the type.
+   */
+  value.type_info = g_variant_type_info_element (value.type_info);
+  g_variant_type_info_ref (value.type_info);
+
+  return value;
+}
+
+static gsize
+gvs_fixed_sized_maybe_needed_size (GVariantTypeInfo         *type_info,
+                                   GVariantSerialisedFiller  gvs_filler,
+                                   const gpointer           *children,
+                                   gsize                     n_children)
+{
+  if (n_children)
+    {
+      gsize element_fixed_size;
+
+      g_variant_type_info_query_element (type_info, NULL,
+                                         &element_fixed_size);
+
+      return element_fixed_size;
+    }
+  else
+    return 0;
+}
+
+static void
+gvs_fixed_sized_maybe_serialise (GVariantSerialised        value,
+                                 GVariantSerialisedFiller  gvs_filler,
+                                 const gpointer           *children,
+                                 gsize                     n_children)
+{
+  if (n_children)
+    {
+      GVariantSerialised child = { NULL, value.data, value.size };
+
+      gvs_filler (&child, children[0]);
+    }
+}
+
+static gboolean
+gvs_fixed_sized_maybe_is_normal (GVariantSerialised value)
+{
+  if (value.size > 0)
+    {
+      gsize element_fixed_size;
+
+      g_variant_type_info_query_element (value.type_info,
+                                         NULL, &element_fixed_size);
+
+      if (value.size != element_fixed_size)
+        return FALSE;
+
+      /* proper element size: "Just".  recurse to the child. */
+      value.type_info = g_variant_type_info_element (value.type_info);
+
+      return g_variant_serialised_is_normal (value);
+    }
+
+  /* size of 0: "Nothing" */
+  return TRUE;
+}
+
+/* Variable-sized Maybe
+ *
+ * The size of a maybe value with a variable-sized element type is
+ * either 0 or strictly greater than 0.  The case where the size of the
+ * maybe value is zero corresponds to the "Nothing" case and the case
+ * where the size of the maybe value is greater than zero corresponds to
+ * the "Just" case; in that case, the serialised data of the child value
+ * forms the first part of the serialised data of the maybe value and is
+ * followed by a single zero byte.  This zero byte is always appended,
+ * regardless of any zero bytes that may already be at the end of the
+ * serialised ata of the child value.
+ */
+
+static gsize
+gvs_variable_sized_maybe_n_children (GVariantSerialised value)
+{
+  return (value.size > 0) ? 1 : 0;
+}
+
+static GVariantSerialised
+gvs_variable_sized_maybe_get_child (GVariantSerialised value,
+                                    gsize              index_)
+{
+  /* remove the padding byte and update the type. */
+  value.type_info = g_variant_type_info_element (value.type_info);
+  g_variant_type_info_ref (value.type_info);
+  value.size--;
+
+  /* if it's zero-sized then it may as well be NULL */
+  if (value.size == 0)
+    value.data = NULL;
+
+  return value;
+}
+
+static gsize
+gvs_variable_sized_maybe_needed_size (GVariantTypeInfo         *type_info,
+                                      GVariantSerialisedFiller  gvs_filler,
+                                      const gpointer           *children,
+                                      gsize                     n_children)
+{
+  if (n_children)
+    {
+      GVariantSerialised child = { 0, };
+
+      gvs_filler (&child, children[0]);
+
+      return child.size + 1;
+    }
+  else
+    return 0;
+}
+
+static void
+gvs_variable_sized_maybe_serialise (GVariantSerialised        value,
+                                    GVariantSerialisedFiller  gvs_filler,
+                                    const gpointer           *children,
+                                    gsize                     n_children)
+{
+  if (n_children)
+    {
+      GVariantSerialised child = { NULL, value.data, value.size - 1 };
+
+      /* write the data for the child.  */
+      gvs_filler (&child, children[0]);
+      value.data[child.size] = '\0';
+    }
+}
+
+static gboolean
+gvs_variable_sized_maybe_is_normal (GVariantSerialised value)
+{
+  if (value.size == 0)
+    return TRUE;
+
+  if (value.data[value.size - 1] != '\0')
+    return FALSE;
+
+  value.type_info = g_variant_type_info_element (value.type_info);
+  value.size--;
+
+  return g_variant_serialised_is_normal (value);
+}
+
+/* Arrays {{{2
+ *
+ * Just as with maybe types, array types are handled depending on if the
+ * element type of the array type is a fixed-sized or variable-sized
+ * type.  Similar to maybe types, for convenience, an array value with a
+ * fixed-sized element type is called a "fixed-sized array" and an array
+ * value with a variable-sized element type is called a "variable sized
+ * array".
+ */
+
+/* Fixed-sized Array {{{3
+ *
+ * For fixed sized arrays, the serialised data is simply a concatenation
+ * of the serialised data of each element, in order.  Since fixed-sized
+ * values always have a fixed size that is a multiple of their alignment
+ * requirement no extra padding is required.
+ *
+ * In the event that a fixed-sized array is presented with a size that
+ * is not an integer multiple of the element size then the value of the
+ * array must be taken as being empty.
+ */
+
+static gsize
+gvs_fixed_sized_array_n_children (GVariantSerialised value)
+{
+  gsize element_fixed_size;
+
+  g_variant_type_info_query_element (value.type_info, NULL,
+                                     &element_fixed_size);
+
+  if (value.size % element_fixed_size == 0)
+    return value.size / element_fixed_size;
+
+  return 0;
+}
+
+static GVariantSerialised
+gvs_fixed_sized_array_get_child (GVariantSerialised value,
+                                 gsize              index_)
+{
+  GVariantSerialised child = { 0, };
+
+  child.type_info = g_variant_type_info_element (value.type_info);
+  g_variant_type_info_query (child.type_info, NULL, &child.size);
+  child.data = value.data + (child.size * index_);
+  g_variant_type_info_ref (child.type_info);
+
+  return child;
+}
+
+static gsize
+gvs_fixed_sized_array_needed_size (GVariantTypeInfo         *type_info,
+                                   GVariantSerialisedFiller  gvs_filler,
+                                   const gpointer           *children,
+                                   gsize                     n_children)
+{
+  gsize element_fixed_size;
+
+  g_variant_type_info_query_element (type_info, NULL, &element_fixed_size);
+
+  return element_fixed_size * n_children;
+}
+
+static void
+gvs_fixed_sized_array_serialise (GVariantSerialised        value,
+                                 GVariantSerialisedFiller  gvs_filler,
+                                 const gpointer           *children,
+                                 gsize                     n_children)
+{
+  GVariantSerialised child = { 0, };
+  gsize i;
+
+  child.type_info = g_variant_type_info_element (value.type_info);
+  g_variant_type_info_query (child.type_info, NULL, &child.size);
+  child.data = value.data;
+
+  for (i = 0; i < n_children; i++)
+    {
+      gvs_filler (&child, children[i]);
+      child.data += child.size;
+    }
+}
+
+static gboolean
+gvs_fixed_sized_array_is_normal (GVariantSerialised value)
+{
+  GVariantSerialised child = { 0, };
+
+  child.type_info = g_variant_type_info_element (value.type_info);
+  g_variant_type_info_query (child.type_info, NULL, &child.size);
+
+  if (value.size % child.size != 0)
+    return FALSE;
+
+  for (child.data = value.data;
+       child.data < value.data + value.size;
+       child.data += child.size)
+    {
+      if (!g_variant_serialised_is_normal (child))
+        return FALSE;
+    }
+
+  return TRUE;
+}
+
+/* Variable-sized Array {{{3
+ *
+ * Variable sized arrays, containing variable-sized elements, must be
+ * able to determine the boundaries between the elements.  The items
+ * cannot simply be concatenated.  Additionally, we are faced with the
+ * fact that non-fixed-sized values do not necessarily have a size that
+ * is a multiple of their alignment requirement, so we may need to
+ * insert zero-filled padding.
+ *
+ * While it is possible to find the start of an item by starting from
+ * the end of the item before it and padding for alignment, it is not
+ * generally possible to do the reverse operation.  For this reason, we
+ * record the end point of each element in the array.
+ *
+ * GVariant works in terms of "offsets".  An offset is a pointer to a
+ * boundary between two bytes.  In 4 bytes of serialised data, there
+ * would be 5 possible offsets: one at the start ('0'), one between each
+ * pair of adjacent bytes ('1', '2', '3') and one at the end ('4').
+ *
+ * The numeric value of an offset is an unsigned integer given relative
+ * to the start of the serialised data of the array.  Offsets are always
+ * stored in little endian byte order and are always only as big as they
+ * need to be.  For example, in 255 bytes of serialised data, there are
+ * 256 offsets.  All possibilities can be stored in an 8 bit unsigned
+ * integer.  In 256 bytes of serialised data, however, there are 257
+ * possible offsets so 16 bit integers must be used.  The size of an
+ * offset is always a power of 2.
+ *
+ * The offsets are stored at the end of the serialised data of the
+ * array.  They are simply concatenated on without any particular
+ * alignment.  The size of the offsets is included in the size of the
+ * serialised data for purposes of determining the size of the offsets.
+ * This presents a possibly ambiguity; in certain cases, a particular
+ * value of array could have two different serialised forms.
+ *
+ * Imagine an array containing a single string of 253 bytes in length
+ * (so, 254 bytes including the nul terminator).  Now the offset must be
+ * written.  If an 8 bit offset is written, it will bring the size of
+ * the array's serialised data to 255 -- which means that the use of an
+ * 8 bit offset was valid.  If a 16 bit offset is used then the total
+ * size of the array will be 256 -- which means that the use of a 16 bit
+ * offset was valid.  Although both of these will be accepted by the
+ * deserialiser, only the smaller of the two is considered to be in
+ * normal form and that is the one that the serialiser must produce.
+ */
+
+static inline gsize
+gvs_read_unaligned_le (guchar *bytes,
+                       guint   size)
+{
+  union
+  {
+    guchar bytes[GLIB_SIZEOF_SIZE_T];
+    gsize integer;
+  } tmpvalue;
+
+  tmpvalue.integer = 0;
+  memcpy (&tmpvalue.bytes, bytes, size);
+
+  return GSIZE_FROM_LE (tmpvalue.integer);
+}
+
+static inline void
+gvs_write_unaligned_le (guchar *bytes,
+                        gsize   value,
+                        guint   size)
+{
+  union
+  {
+    guchar bytes[GLIB_SIZEOF_SIZE_T];
+    gsize integer;
+  } tmpvalue;
+
+  tmpvalue.integer = GSIZE_TO_LE (value);
+  memcpy (bytes, &tmpvalue.bytes, size);
+}
+
+static guint
+gvs_get_offset_size (gsize size)
+{
+  if (size > G_MAXUINT32)
+    return 8;
+
+  else if (size > G_MAXUINT16)
+    return 4;
+
+  else if (size > G_MAXUINT8)
+    return 2;
+
+  else if (size > 0)
+    return 1;
+
+  return 0;
+}
+
+static gsize
+gvs_calculate_total_size (gsize body_size,
+                          gsize offsets)
+{
+  if (body_size + 1 * offsets <= G_MAXUINT8)
+    return body_size + 1 * offsets;
+
+  if (body_size + 2 * offsets <= G_MAXUINT16)
+    return body_size + 2 * offsets;
+
+  if (body_size + 4 * offsets <= G_MAXUINT32)
+    return body_size + 4 * offsets;
+
+  return body_size + 8 * offsets;
+}
+
+static gsize
+gvs_variable_sized_array_n_children (GVariantSerialised value)
+{
+  gsize offsets_array_size;
+  gsize offset_size;
+  gsize last_end;
+
+  if (value.size == 0)
+    return 0;
+
+  offset_size = gvs_get_offset_size (value.size);
+
+  last_end = gvs_read_unaligned_le (value.data + value.size -
+                                    offset_size, offset_size);
+
+  if (last_end > value.size)
+    return 0;
+
+  offsets_array_size = value.size - last_end;
+
+  if (offsets_array_size % offset_size)
+    return 0;
+
+  return offsets_array_size / offset_size;
+}
+
+static GVariantSerialised
+gvs_variable_sized_array_get_child (GVariantSerialised value,
+                                    gsize              index_)
+{
+  GVariantSerialised child = { 0, };
+  gsize offset_size;
+  gsize last_end;
+  gsize start;
+  gsize end;
+
+  child.type_info = g_variant_type_info_element (value.type_info);
+  g_variant_type_info_ref (child.type_info);
+
+  offset_size = gvs_get_offset_size (value.size);
+
+  last_end = gvs_read_unaligned_le (value.data + value.size -
+                                    offset_size, offset_size);
+
+  if (index_ > 0)
+    {
+      guint alignment;
+
+      start = gvs_read_unaligned_le (value.data + last_end +
+                                     (offset_size * (index_ - 1)),
+                                     offset_size);
+
+      g_variant_type_info_query (child.type_info, &alignment, NULL);
+      start += (-start) & alignment;
+    }
+  else
+    start = 0;
+
+  end = gvs_read_unaligned_le (value.data + last_end +
+                               (offset_size * index_),
+                               offset_size);
+
+  if (start < end && end <= value.size)
+    {
+      child.data = value.data + start;
+      child.size = end - start;
+    }
+
+  return child;
+}
+
+static gsize
+gvs_variable_sized_array_needed_size (GVariantTypeInfo         *type_info,
+                                      GVariantSerialisedFiller  gvs_filler,
+                                      const gpointer           *children,
+                                      gsize                     n_children)
+{
+  guint alignment;
+  gsize offset;
+  gsize i;
+
+  g_variant_type_info_query (type_info, &alignment, NULL);
+  offset = 0;
+
+  for (i = 0; i < n_children; i++)
+    {
+      GVariantSerialised child = { 0, };
+
+      offset += (-offset) & alignment;
+      gvs_filler (&child, children[i]);
+      offset += child.size;
+    }
+
+  return gvs_calculate_total_size (offset, n_children);
+}
+
+static void
+gvs_variable_sized_array_serialise (GVariantSerialised        value,
+                                    GVariantSerialisedFiller  gvs_filler,
+                                    const gpointer           *children,
+                                    gsize                     n_children)
+{
+  guchar *offset_ptr;
+  gsize offset_size;
+  guint alignment;
+  gsize offset;
+  gsize i;
+
+  g_variant_type_info_query (value.type_info, &alignment, NULL);
+  offset_size = gvs_get_offset_size (value.size);
+  offset = 0;
+
+  offset_ptr = value.data + value.size - offset_size * n_children;
+
+  for (i = 0; i < n_children; i++)
+    {
+      GVariantSerialised child = { 0, };
+
+      while (offset & alignment)
+        value.data[offset++] = '\0';
+
+      child.data = value.data + offset;
+      gvs_filler (&child, children[i]);
+      offset += child.size;
+
+      gvs_write_unaligned_le (offset_ptr, offset, offset_size);
+      offset_ptr += offset_size;
+    }
+}
+
+static gboolean
+gvs_variable_sized_array_is_normal (GVariantSerialised value)
+{
+  GVariantSerialised child = { 0, };
+  gsize offsets_array_size;
+  guchar *offsets_array;
+  guint offset_size;
+  guint alignment;
+  gsize last_end;
+  gsize length;
+  gsize offset;
+  gsize i;
+
+  if (value.size == 0)
+    return TRUE;
+
+  offset_size = gvs_get_offset_size (value.size);
+  last_end = gvs_read_unaligned_le (value.data + value.size -
+                                    offset_size, offset_size);
+
+  if (last_end > value.size)
+    return FALSE;
+
+  offsets_array_size = value.size - last_end;
+
+  if (offsets_array_size % offset_size)
+    return FALSE;
+
+  offsets_array = value.data + value.size - offsets_array_size;
+  length = offsets_array_size / offset_size;
+
+  if (length == 0)
+    return FALSE;
+
+  child.type_info = g_variant_type_info_element (value.type_info);
+  g_variant_type_info_query (child.type_info, &alignment, NULL);
+  offset = 0;
+
+  for (i = 0; i < length; i++)
+    {
+      gsize this_end;
+
+      this_end = gvs_read_unaligned_le (offsets_array + offset_size * i,
+                                        offset_size);
+
+      if (this_end < offset || this_end > last_end)
+        return FALSE;
+
+      while (offset & alignment)
+        {
+          if (!(offset < this_end && value.data[offset] == '\0'))
+            return FALSE;
+          offset++;
+        }
+
+      child.data = value.data + offset;
+      child.size = this_end - offset;
+
+      if (child.size == 0)
+        child.data = NULL;
+
+      if (!g_variant_serialised_is_normal (child))
+        return FALSE;
+
+      offset = this_end;
+    }
+
+  g_assert (offset == last_end);
+
+  return TRUE;
+}
+
+/* Tuples {{{2
+ *
+ * Since tuples can contain a mix of variable- and fixed-sized items,
+ * they are, in terms of serialisation, a hybrid of variable-sized and
+ * fixed-sized arrays.
+ *
+ * Offsets are only stored for variable-sized items.  Also, since the
+ * number of items in a tuple is known from its type, we are able to
+ * know exactly how many offsets to expect in the serialised data (and
+ * therefore how much space is taken up by the offset array).  This
+ * means that we know where the end of the serialised data for the last
+ * item is -- we can just subtract the size of the offset array from the
+ * total size of the tuple.  For this reason, the last item in the tuple
+ * doesn't need an offset stored.
+ *
+ * Tuple offsets are stored in reverse.  This design choice allows
+ * iterator-based deserialisers to be more efficient.
+ *
+ * Most of the "heavy lifting" here is handled by the GVariantTypeInfo
+ * for the tuple.  See the notes in gvarianttypeinfo.h.
+ */
+
+static gsize
+gvs_tuple_n_children (GVariantSerialised value)
+{
+  return g_variant_type_info_n_members (value.type_info);
+}
+
+static GVariantSerialised
+gvs_tuple_get_child (GVariantSerialised value,
+                     gsize              index_)
+{
+  const GVariantMemberInfo *member_info;
+  GVariantSerialised child = { 0, };
+  gsize offset_size;
+  gsize start, end;
+
+  member_info = g_variant_type_info_member_info (value.type_info, index_);
+  child.type_info = g_variant_type_info_ref (member_info->type_info);
+  offset_size = gvs_get_offset_size (value.size);
+
+  /* tuples are the only (potentially) fixed-sized containers, so the
+   * only ones that have to deal with the possibility of having %NULL
+   * data with a non-zero %size if errors occurred elsewhere.
+   */
+  if G_UNLIKELY (value.data == NULL && value.size != 0)
+    {
+      g_variant_type_info_query (child.type_info, NULL, &child.size);
+
+      /* this can only happen in fixed-sized tuples,
+       * so the child must also be fixed sized.
+       */
+      g_assert (child.size != 0);
+      child.data = NULL;
+
+      return child;
+    }
+
+  if (member_info->ending_type == G_VARIANT_MEMBER_ENDING_OFFSET)
+    {
+      if (offset_size * (member_info->i + 2) > value.size)
+        return child;
+    }
+  else
+    {
+      if (offset_size * (member_info->i + 1) > value.size)
+        {
+          /* if the child is fixed size, return its size.
+           * if child is not fixed-sized, return size = 0.
+           */
+          g_variant_type_info_query (child.type_info, NULL, &child.size);
+
+          return child;
+        }
+    }
+
+  if (member_info->i + 1)
+    start = gvs_read_unaligned_le (value.data + value.size -
+                                   offset_size * (member_info->i + 1),
+                                   offset_size);
+  else
+    start = 0;
+
+  start += member_info->a;
+  start &= member_info->b;
+  start |= member_info->c;
+
+  if (member_info->ending_type == G_VARIANT_MEMBER_ENDING_LAST)
+    end = value.size - offset_size * (member_info->i + 1);
+
+  else if (member_info->ending_type == G_VARIANT_MEMBER_ENDING_FIXED)
+    {
+      gsize fixed_size;
+
+      g_variant_type_info_query (child.type_info, NULL, &fixed_size);
+      end = start + fixed_size;
+      child.size = fixed_size;
+    }
+
+  else /* G_VARIANT_MEMEBER_ENDING_OFFSET */
+    end = gvs_read_unaligned_le (value.data + value.size -
+                                 offset_size * (member_info->i + 2),
+                                 offset_size);
+
+  if (start < end && end <= value.size)
+    {
+      child.data = value.data + start;
+      child.size = end - start;
+    }
+
+  return child;
+}
+
+static gsize
+gvs_tuple_needed_size (GVariantTypeInfo         *type_info,
+                       GVariantSerialisedFiller  gvs_filler,
+                       const gpointer           *children,
+                       gsize                     n_children)
+{
+  const GVariantMemberInfo *member_info = NULL;
+  gsize fixed_size;
+  gsize offset;
+  gsize i;
+
+  g_variant_type_info_query (type_info, NULL, &fixed_size);
+
+  if (fixed_size)
+    return fixed_size;
+
+  offset = 0;
+
+  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, &fixed_size);
+      offset += (-offset) & alignment;
+
+      if (fixed_size)
+        offset += fixed_size;
+      else
+        {
+          GVariantSerialised child = { 0, };
+
+          gvs_filler (&child, children[i]);
+          offset += child.size;
+        }
+    }
+
+  return gvs_calculate_total_size (offset, member_info->i + 1);
+}
+
+static void
+gvs_tuple_serialise (GVariantSerialised        value,
+                     GVariantSerialisedFiller  gvs_filler,
+                     const gpointer           *children,
+                     gsize                     n_children)
+{
+  gsize offset_size;
+  gsize offset;
+  gsize i;
+
+  offset_size = gvs_get_offset_size (value.size);
+  offset = 0;
+
+  for (i = 0; i < n_children; i++)
+    {
+      const GVariantMemberInfo *member_info;
+      GVariantSerialised child = { 0, };
+      guint alignment;
+
+      member_info = g_variant_type_info_member_info (value.type_info, i);
+      g_variant_type_info_query (member_info->type_info, &alignment, NULL);
+
+      while (offset & alignment)
+        value.data[offset++] = '\0';
+
+      child.data = value.data + offset;
+      gvs_filler (&child, children[i]);
+      offset += child.size;
+
+      if (member_info->ending_type == G_VARIANT_MEMBER_ENDING_OFFSET)
+        {
+          value.size -= offset_size;
+          gvs_write_unaligned_le (value.data + value.size,
+                                  offset, offset_size);
+        }
+    }
+
+  while (offset < value.size)
+    value.data[offset++] = '\0';
+}
+
+static gboolean
+gvs_tuple_is_normal (GVariantSerialised value)
+{
+  guint offset_size;
+  gsize offset_ptr;
+  gsize length;
+  gsize offset;
+  gsize i;
+
+  offset_size = gvs_get_offset_size (value.size);
+  length = g_variant_type_info_n_members (value.type_info);
+  offset_ptr = value.size;
+  offset = 0;
+
+  for (i = 0; i < length; i++)
+    {
+      const GVariantMemberInfo *member_info;
+      GVariantSerialised child;
+      gsize fixed_size;
+      guint alignment;
+      gsize end;
+
+      member_info = g_variant_type_info_member_info (value.type_info, i);
+      child.type_info = member_info->type_info;
+
+      g_variant_type_info_query (child.type_info, &alignment, &fixed_size);
+
+      while (offset & alignment)
+        {
+          if (offset > value.size || value.data[offset] != '\0')
+            return FALSE;
+          offset++;
+        }
+
+      child.data = value.data + offset;
+
+      switch (member_info->ending_type)
+        {
+        case G_VARIANT_MEMBER_ENDING_FIXED:
+          end = offset + fixed_size;
+          break;
+
+        case G_VARIANT_MEMBER_ENDING_LAST:
+          end = offset_ptr;
+          break;
+
+        case G_VARIANT_MEMBER_ENDING_OFFSET:
+          offset_ptr -= offset_size;
+
+          if (offset_ptr < offset)
+            return FALSE;
+
+          end = gvs_read_unaligned_le (value.data + offset_ptr, offset_size);
+          break;
+
+        default:
+          g_assert_not_reached ();
+        }
+
+      if (end < offset || end > offset_ptr)
+        return FALSE;
+
+      child.size = end - offset;
+
+      if (child.size == 0)
+        child.data = NULL;
+
+      if (!g_variant_serialised_is_normal (child))
+        return FALSE;
+
+      offset = end;
+    }
+
+  {
+    gsize fixed_size;
+    guint alignment;
+
+    g_variant_type_info_query (value.type_info, &alignment, &fixed_size);
+
+    if (fixed_size)
+      {
+        g_assert (fixed_size == value.size);
+        g_assert (offset_ptr == value.size);
+
+        if (i == 0)
+          {
+            if (value.data[offset++] != '\0')
+              return FALSE;
+          }
+        else
+          {
+            while (offset & alignment)
+              if (value.data[offset++] != '\0')
+                return FALSE;
+          }
+
+        g_assert (offset == value.size);
+      }
+  }
+
+  return offset_ptr == offset;
+}
+
+/* Variants {{{2
+ *
+ * Variants are stored by storing the serialised data of the child,
+ * followed by a '\0' character, followed by the type string of the
+ * child.
+ *
+ * In the case that a value is presented that contains no '\0'
+ * character, or doesn't have a single well-formed definite type string
+ * following that character, the variant must be taken as containing the
+ * unit tuple: ().
+ */
+
+static inline gsize
+gvs_variant_n_children (GVariantSerialised value)
+{
+  return 1;
+}
+
+static inline GVariantSerialised
+gvs_variant_get_child (GVariantSerialised value,
+                       gsize              index_)
+{
+  GVariantSerialised child = { 0, };
+
+  /* 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;
+
+      /* 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;
+
+          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))
+                {
+                  gsize fixed_size;
+
+                  child.type_info = g_variant_type_info_get (type);
+
+                  if (child.size != 0)
+                    /* only set to non-%NULL if size > 0 */
+                    child.data = value.data;
+
+                  g_variant_type_info_query (child.type_info,
+                                             NULL, &fixed_size);
+
+                  if (!fixed_size || fixed_size == child.size)
+                    return child;
+
+                  g_variant_type_info_unref (child.type_info);
+                }
+            }
+        }
+    }
+
+  child.type_info = g_variant_type_info_get (G_VARIANT_TYPE_UNIT);
+  child.data = NULL;
+  child.size = 1;
+
+  return child;
+}
+
+static inline gsize
+gvs_variant_needed_size (GVariantTypeInfo         *type_info,
+                         GVariantSerialisedFiller  gvs_filler,
+                         const gpointer           *children,
+                         gsize                     n_children)
+{
+  GVariantSerialised child = { 0, };
+  const gchar *type_string;
+
+  gvs_filler (&child, children[0]);
+  type_string = g_variant_type_info_get_type_string (child.type_info);
+
+  return child.size + 1 + strlen (type_string);
+}
+
+static inline void
+gvs_variant_serialise (GVariantSerialised        value,
+                       GVariantSerialisedFiller  gvs_filler,
+                       const gpointer           *children,
+                       gsize                     n_children)
+{
+  GVariantSerialised child = { 0, };
+  const gchar *type_string;
+
+  child.data = value.data;
+
+  gvs_filler (&child, children[0]);
+  type_string = g_variant_type_info_get_type_string (child.type_info);
+  value.data[child.size] = '\0';
+  memcpy (value.data + child.size + 1, type_string, strlen (type_string));
+}
+
+static inline gboolean
+gvs_variant_is_normal (GVariantSerialised value)
+{
+  GVariantSerialised child;
+  gboolean normal;
+
+  child = gvs_variant_get_child (value, 0);
+
+  normal = (child.data != NULL || child.size == 0) &&
+           g_variant_serialised_is_normal (child);
+
+  g_variant_type_info_unref (child.type_info);
+
+  return normal;
+}
+
+
+
+/* PART 2: Serialiser API {{{1
+ *
+ * This is the implementation of the API of the serialiser as advertised
+ * in gvariant-serialiser.h.
+ */
+
+/* Dispatch Utilities {{{2
+ *
+ * These macros allow a given function (for example,
+ * g_variant_serialiser_serialise) to be dispatched to the appropriate
+ * type-specific function above (fixed/variable-sized maybe,
+ * fixed/variable-sized array, tuple or variant).
+ */
+#define DISPATCH_FIXED(type_info, before, after) \
+  {                                                     \
+    gsize fixed_size;                                   \
+                                                        \
+    g_variant_type_info_query_element (type_info, NULL, \
+                                       &fixed_size);    \
+                                                        \
+    if (fixed_size)                                     \
+      {                                                 \
+        before ## fixed_sized ## after                  \
+      }                                                 \
+    else                                                \
+      {                                                 \
+        before ## variable_sized ## after               \
+      }                                                 \
+  }
+
+#define DISPATCH_CASES(type_info, before, after) \
+  switch (g_variant_type_info_get_type_char (type_info))        \
+    {                                                           \
+      case G_VARIANT_TYPE_INFO_CHAR_MAYBE:                      \
+        DISPATCH_FIXED (type_info, before, _maybe ## after)     \
+                                                                \
+      case G_VARIANT_TYPE_INFO_CHAR_ARRAY:                      \
+        DISPATCH_FIXED (type_info, before, _array ## after)     \
+                                                                \
+      case G_VARIANT_TYPE_INFO_CHAR_DICT_ENTRY:                 \
+      case G_VARIANT_TYPE_INFO_CHAR_TUPLE:                      \
+        {                                                       \
+          before ## tuple ## after                              \
+        }                                                       \
+                                                                \
+      case G_VARIANT_TYPE_INFO_CHAR_VARIANT:                    \
+        {                                                       \
+          before ## variant ## after                            \
+        }                                                       \
+    }
+
+/* Serialiser entry points {{{2
+ *
+ * These are the functions that are called in order for the serialiser
+ * to do its thing.
+ */
+
+/* < private >
+ * g_variant_serialised_n_children:
+ * @serialised: a #GVariantSerialised
+ *
+ * For serialised data that represents a container value (maybes,
+ * tuples, arrays, variants), determine how many child items are inside
+ * that container.
+ *
+ * Returns: the number of children
+ */
+gsize
+g_variant_serialised_n_children (GVariantSerialised serialised)
+{
+  g_variant_serialised_check (serialised);
+
+  DISPATCH_CASES (serialised.type_info,
+
+                  return gvs_/**/,/**/_n_children (serialised);
+
+                 )
+  g_assert_not_reached ();
+}
+
+/* < private >
+ * g_variant_serialised_get_child:
+ * @serialised: a #GVariantSerialised
+ * @index_: the index of the child to fetch
+ *
+ * Extracts a child from a serialised data representing a container
+ * value.
+ *
+ * It is an error to call this function with an index out of bounds.
+ *
+ * If the result .data == %NULL and .size > 0 then there has been an
+ * error extracting the requested fixed-sized value.  This number of
+ * zero bytes needs to be allocated instead.
+ *
+ * In the case that .data == %NULL and .size == 0 then a zero-sized
+ * item of a variable-sized type is being returned.
+ *
+ * .data is never non-%NULL if size is 0.
+ *
+ * Returns: a #GVariantSerialised for the child
+ */
+GVariantSerialised
+g_variant_serialised_get_child (GVariantSerialised serialised,
+                                gsize              index_)
+{
+  GVariantSerialised child;
+
+  g_variant_serialised_check (serialised);
+
+  if G_LIKELY (index_ < g_variant_serialised_n_children (serialised))
+    {
+      DISPATCH_CASES (serialised.type_info,
+
+                      child = gvs_/**/,/**/_get_child (serialised, index_);
+                      g_assert (child.size || child.data == NULL);
+                      g_variant_serialised_check (child);
+                      return child;
+
+                     )
+      g_assert_not_reached ();
+    }
+
+  g_error ("Attempt to access item %"G_GSIZE_FORMAT
+           " in a container with only %"G_GSIZE_FORMAT" items",
+           index_, g_variant_serialised_n_children (serialised));
+}
+
+/* < private >
+ * g_variant_serialiser_serialise:
+ * @serialised: a #GVariantSerialised, properly set up
+ * @gvs_filler: the filler function
+ * @children: an array of child items
+ * @n_children: the size of @children
+ *
+ * Writes data in serialised form.
+ *
+ * The type_info field of @serialised must be filled in to type info for
+ * the type that we are serialising.
+ *
+ * The size field of @serialised must be filled in with the value
+ * returned by a previous call to g_variant_serialiser_needed_size().
+ *
+ * The data field of @serialised must be a pointer to a properly-aligned
+ * memory region large enough to serialise into (ie: at least as big as
+ * the size field).
+ *
+ * This function is only resonsible for serialising the top-level
+ * container.  @gvs_filler is called on each child of the container in
+ * order for all of the data of that child to be filled in.
+ */
+void
+g_variant_serialiser_serialise (GVariantSerialised        serialised,
+                                GVariantSerialisedFiller  gvs_filler,
+                                const gpointer           *children,
+                                gsize                     n_children)
+{
+  g_variant_serialised_check (serialised);
+
+  DISPATCH_CASES (serialised.type_info,
+
+                  gvs_/**/,/**/_serialise (serialised, gvs_filler,
+                                           children, n_children);
+                  return;
+
+                 )
+  g_assert_not_reached ();
+}
+
+/* < private >
+ * g_variant_serialiser_needed_size:
+ * @type_info: the type to serialise for
+ * @gvs_filler: the filler function
+ * @children: an array of child items
+ * @n_children: the size of @children
+ *
+ * Determines how much memory would be needed to serialise this value.
+ *
+ * This function is only resonsible for performing calculations for the
+ * top-level container.  @gvs_filler is called on each child of the
+ * container in order to determine its size.
+ */
+gsize
+g_variant_serialiser_needed_size (GVariantTypeInfo         *type_info,
+                                  GVariantSerialisedFiller  gvs_filler,
+                                  const gpointer           *children,
+                                  gsize                     n_children)
+{
+  DISPATCH_CASES (type_info,
+
+                  return gvs_/**/,/**/_needed_size (type_info, gvs_filler,
+                                                    children, n_children);
+
+                 )
+  g_assert_not_reached ();
+}
+
+/* Byteswapping {{{2 */
+
+/* < private >
+ * g_variant_serialised_byteswap:
+ * @value: a #GVariantSerialised
+ *
+ * Byte-swap serialised data.  The result of this function is only
+ * well-defined if the data is in normal form.
+ */
+void
+g_variant_serialised_byteswap (GVariantSerialised serialised)
+{
+  gsize fixed_size;
+  guint alignment;
+
+  g_variant_serialised_check (serialised);
+
+  if (!serialised.data)
+    return;
+
+  /* the types we potentially need to byteswap are
+   * exactly those with alignment requirements.
+   */
+  g_variant_type_info_query (serialised.type_info, &alignment, &fixed_size);
+  if (!alignment)
+    return;
+
+  /* if fixed size and alignment are equal then we are down
+   * to the base integer type and we should swap it.  the
+   * only exception to this is if we have a tuple with a
+   * single item, and then swapping it will be OK anyway.
+   */
+  if (alignment + 1 == fixed_size)
+    {
+      switch (fixed_size)
+      {
+        case 2:
+          {
+            guint16 *ptr = (guint16 *) serialised.data;
+
+            g_assert_cmpint (serialised.size, ==, 2);
+            *ptr = GUINT16_SWAP_LE_BE (*ptr);
+          }
+          return;
+
+        case 4:
+          {
+            guint32 *ptr = (guint32 *) serialised.data;
+
+            g_assert_cmpint (serialised.size, ==, 4);
+            *ptr = GUINT32_SWAP_LE_BE (*ptr);
+          }
+          return;
+
+        case 8:
+          {
+            guint64 *ptr = (guint64 *) serialised.data;
+
+            g_assert_cmpint (serialised.size, ==, 8);
+            *ptr = GUINT64_SWAP_LE_BE (*ptr);
+          }
+          return;
+
+        default:
+          g_assert_not_reached ();
+      }
+    }
+
+  /* else, we have a container that potentially contains
+   * some children that need to be byteswapped.
+   */
+  else
+    {
+      gsize children, i;
+
+      children = g_variant_serialised_n_children (serialised);
+      for (i = 0; i < children; i++)
+        {
+          GVariantSerialised child;
+
+          child = g_variant_serialised_get_child (serialised, i);
+          g_variant_serialised_byteswap (child);
+          g_variant_type_info_unref (child.type_info);
+        }
+    }
+}
+
+/* Normal form checking {{{2 */
+
+/* < private >
+ * g_variant_serialised_is_normal:
+ * @serialised: a #GVariantSerialised
+ *
+ * Determines, recursively if @serialised is in normal form.  There is
+ * precisely one normal form of serialised data for each possible value.
+ *
+ * It is possible that multiple byte sequences form the serialised data
+ * for a given value if, for example, the padding bytes are filled in
+ * with something other than zeros, but only one form is the normal
+ * form.
+ */
+gboolean
+g_variant_serialised_is_normal (GVariantSerialised serialised)
+{
+  DISPATCH_CASES (serialised.type_info,
+
+                  return gvs_/**/,/**/_is_normal (serialised);
+
+                 )
+
+  if (serialised.data == NULL)
+    return FALSE;
+
+  /* some hard-coded terminal cases */
+  switch (g_variant_type_info_get_type_char (serialised.type_info))
+    {
+    case 'b': /* boolean */
+      return serialised.data[0] < 2;
+
+    case 's': /* string */
+      return g_variant_serialiser_is_string (serialised.data,
+                                             serialised.size);
+
+    case 'o':
+      return g_variant_serialiser_is_object_path (serialised.data,
+                                                  serialised.size);
+
+    case 'g':
+      return g_variant_serialiser_is_signature (serialised.data,
+                                                serialised.size);
+
+    default:
+      /* all of the other types are fixed-sized numerical types for
+       * which all possible values are valid (including various NaN
+       * representations for floating point values).
+       */
+      return TRUE;
+    }
+}
+
+/* Validity-checking functions {{{2
+ *
+ * Checks if strings, object paths and signature strings are valid.
+ */
+
+/* < private >
+ * g_variant_serialiser_is_string:
+ * @data: a possible string
+ * @size: the size of @data
+ *
+ * Ensures that @data is a valid string with a nul terminator at the end
+ * and no nul bytes embedded.
+ */
+gboolean
+g_variant_serialiser_is_string (gconstpointer data,
+                                gsize         size)
+{
+  const gchar *end;
+
+  g_utf8_validate (data, size, &end);
+
+  return data == end - (size - 1);
+}
+
+/* < private >
+ * g_variant_serialiser_is_object_path:
+ * @data: a possible D-Bus object path
+ * @size: the size of @data
+ *
+ * Performs the checks for being a valid string.
+ *
+ * Also, ensures that @data is a valid DBus object path, as per the D-Bus
+ * specification.
+ */
+gboolean
+g_variant_serialiser_is_object_path (gconstpointer data,
+                                     gsize         size)
+{
+  const gchar *string = data;
+  gsize i;
+
+  if (!g_variant_serialiser_is_string (data, size))
+    return FALSE;
+
+  /* The path must begin with an ASCII '/' (integer 47) character */
+  if (string[0] != '/')
+    return FALSE;
+
+  for (i = 1; string[i]; i++)
+    /* Each element must only contain the ASCII characters
+     * "[A-Z][a-z][0-9]_"
+     */
+    if (g_ascii_isalnum (string[i]) || string[i] == '_')
+      ;
+
+    /* must consist of elements separated by slash characters. */
+    else if (string[i] == '/')
+      {
+        /* No element may be the empty string. */
+        /* Multiple '/' characters cannot occur in sequence. */
+        if (string[i - 1] == '/')
+          return FALSE;
+      }
+
+    else
+      return FALSE;
+
+  /* A trailing '/' character is not allowed unless the path is the
+   * root path (a single '/' character).
+   */
+  if (i > 1 && string[i - 1] == '/')
+    return FALSE;
+
+  return TRUE;
+}
+
+/* < private >
+ * g_variant_serialiser_is_signature:
+ * @data: a possible D-Bus signature
+ * @size: the size of @data
+ *
+ * Performs the checks for being a valid string.
+ *
+ * Also, ensures that @data is a valid D-Bus type signature, as per the
+ * D-Bus specification.
+ */
+gboolean
+g_variant_serialiser_is_signature (gconstpointer data,
+                                   gsize         size)
+{
+  const gchar *string = data;
+  gsize first_invalid;
+
+  if (!g_variant_serialiser_is_string (data, size))
+    return FALSE;
+
+  /* make sure no non-definite characters appear */
+  first_invalid = strspn (string, "ybnqiuxthdvasog(){}");
+  if (string[first_invalid])
+    return FALSE;
+
+  /* make sure each type string is well-formed */
+  while (*string)
+    if (!g_variant_type_string_scan (string, NULL, &string))
+      return FALSE;
+
+  return TRUE;
+}
+
+/* Epilogue {{{1 */
+/* vim:set foldmethod=marker: */