static gboolean
gvs_fixed_sized_maybe_unpack_all (GVariantTypeInfo *type_info,
- const guchar *end,
+ const guchar *end_pointer,
gsize end_size,
gsize total_size,
- GArray *results)
+ GArray *unpacked_children)
{
if (total_size)
{
GVariantUnpacked unpacked;
- unpacked.type_info = g_variant_type_info_element (type_info);
- g_variant_type_info_ref (unpacked.type_info);
+ 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 (results, unpacked);
+ g_array_append_val (unpacked_children, unpacked);
}
return TRUE;
static gboolean
gvs_variable_sized_maybe_unpack_all (GVariantTypeInfo *type_info,
- const guchar *end,
+ const guchar *end_pointer,
gsize end_size,
gsize total_size,
- GArray *results)
+ GArray *unpacked_children)
{
if (total_size)
{
GVariantUnpacked unpacked;
- unpacked.type_info = g_variant_type_info_element (type_info);
- g_variant_type_info_ref (unpacked.type_info);
+ 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 (results, unpacked);
+ g_array_append_val (unpacked_children, unpacked);
}
return TRUE;
static gboolean
gvs_fixed_sized_array_unpack_all (GVariantTypeInfo *type_info,
- const guchar *end,
+ const guchar *end_pointer,
gsize end_size,
gsize total_size,
- GArray *results)
+ GArray *unpacked_children)
{
GVariantTypeInfo *element;
gsize element_fixed_size;
unpacked.skip = 0;
unpacked.size = element_fixed_size;
- g_array_append_val (results, unpacked);
+ g_array_append_val (unpacked_children, unpacked);
}
return TRUE;
static gboolean
gvs_variable_sized_array_unpack_all (GVariantTypeInfo *type_info,
- const guchar *end,
+ const guchar *end_pointer,
gsize end_size,
gsize total_size,
- GArray *results)
+ GArray *unpacked_children)
{
GVariantTypeInfo *element;
guint element_alignment;
if (offset_size > end_size)
return FALSE;
- last_end = gvs_read_unaligned_le (end - offset_size, offset_size);
+ last_end = gvs_read_unaligned_le (end_pointer - offset_size, offset_size);
if (last_end > total_size)
return 0;
if (offsets_array_size > end_size)
return FALSE;
- offsets = end - offsets_array_size;
+ offsets = end_pointer - offsets_array_size;
if (offsets_array_size % offset_size)
return FALSE;
end = gvs_read_unaligned_le (offsets, offset_size);
offsets += offset_size;
- if (start < prev_end || end < start) { g_assert_not_reached ();
- return FALSE; /* XXX free the array and type infos */ }
+ 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 (results, unpacked);
+ g_array_append_val (unpacked_children, unpacked);
+
+ prev_end = end;
}
return TRUE;
static gboolean
gvs_tuple_unpack_all (GVariantTypeInfo *type_info,
- const guchar *end,
+ const guchar *end_pointer,
gsize end_size,
gsize total_size,
- GArray *results)
+ GArray *unpacked_children)
{
- g_assert_not_reached (); /* FIXME */
- return FALSE;
+ 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
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)
{
- 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;
- if (g_variant_type_is_definite (type))
- {
- gsize fixed_size;
+ type_info = g_variant_type_info_get (type);
- child.type_info = g_variant_type_info_get (type);
+ g_variant_type_info_query (type_info, NULL, &fixed_size);
- if (child.size != 0)
- /* only set to non-%NULL if size > 0 */
- child.data = value.data;
+ if (!fixed_size || fixed_size == total_size - i)
+ {
+ *child_size = total_size - i;
- g_variant_type_info_query (child.type_info,
- NULL, &fixed_size);
+ return type_info;
+ }
- if (!fixed_size || fixed_size == child.size)
- 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;
+}
- child.type_info = g_variant_type_info_get (G_VARIANT_TYPE_UNIT);
- child.data = NULL;
- child.size = 1;
+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)))
+ {
+ if (child.size != 0)
+ child.data = value.data;
+ }
+ else
+ {
+ child.type_info = g_variant_type_info_get (G_VARIANT_TYPE_UNIT);
+ child.size = 1;
+ }
return child;
}
static gboolean
gvs_variant_unpack_all (GVariantTypeInfo *type_info,
- const guchar *end,
+ const guchar *end_pointer,
gsize end_size,
gsize total_size,
- GArray *results)
+ GArray *unpacked_children)
{
- g_assert_not_reached (); /* FIXME */
+ GVariantUnpacked unpacked;
+
+ if ((unpacked.type_info = gvs_variant_find_type (end_pointer, end_size, total_size, &unpacked.size)))
+ {
+ unpacked.skip = 0;
+
+ g_array_append_val (unpacked_children, unpacked);
+
+ return TRUE;
+ }
+
return FALSE;
}
gboolean
g_variant_serialiser_unpack_all (GVariantTypeInfo *type_info,
- const guchar *end,
+ const guchar *end_pointer,
gsize end_size,
gsize total_size,
- GArray *results)
+ GArray *unpacked_children)
{
DISPATCH_CASES (type_info,
- return gvs_/**/,/**/_unpack_all (type_info, end, end_size, total_size, results);
+ 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 */
projects / platform / upstream / glib.git / blobdiff