1 /* -*- mode: C; c-file-style: "gnu" -*- */
2 /* dbus-marshal-recursive.c Marshalling routines for recursive types
4 * Copyright (C) 2004, 2005 Red Hat, Inc.
6 * Licensed under the Academic Free License version 2.1
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
24 #include "dbus-marshal-recursive.h"
25 #include "dbus-marshal-basic.h"
26 #include "dbus-internals.h"
29 * @addtogroup DBusMarshal
33 /** turn this on to get deluged in TypeReader verbose spam */
34 #define RECURSIVE_MARSHAL_READ_TRACE 0
36 /** turn this on to get deluged in TypeWriter verbose spam */
37 #define RECURSIVE_MARSHAL_WRITE_TRACE 0
40 free_fixups (DBusList **fixups)
44 link = _dbus_list_get_first_link (fixups);
49 next = _dbus_list_get_next_link (fixups, link);
51 dbus_free (link->data);
52 _dbus_list_free_link (link);
61 apply_and_free_fixups (DBusList **fixups,
62 DBusTypeReader *reader)
66 #if RECURSIVE_MARSHAL_WRITE_TRACE
68 _dbus_verbose (" %d FIXUPS to apply\n",
69 _dbus_list_get_length (fixups));
72 link = _dbus_list_get_first_link (fixups);
77 next = _dbus_list_get_next_link (fixups, link);
85 #if RECURSIVE_MARSHAL_WRITE_TRACE
86 _dbus_verbose (" applying FIXUP to reader %p at pos %d new_len = %d old len %d\n",
87 reader, f->len_pos_in_reader, f->new_len,
88 _dbus_marshal_read_uint32 (reader->value_str,
90 reader->byte_order, NULL));
93 _dbus_marshal_set_uint32 ((DBusString*) reader->value_str,
99 dbus_free (link->data);
100 _dbus_list_free_link (link);
109 * Virtual table for a type reader.
111 struct DBusTypeReaderClass
113 const char *name; /**< name for debugging */
114 int id; /**< index in all_reader_classes */
115 dbus_bool_t types_only; /**< only iterates over types, not values */
116 void (* recurse) (DBusTypeReader *sub,
117 DBusTypeReader *parent); /**< recurse with this reader as sub */
118 dbus_bool_t (* check_finished) (const DBusTypeReader *reader); /**< check whether reader is at the end */
119 void (* next) (DBusTypeReader *reader,
120 int current_type); /**< go to the next value */
121 void (* init_from_mark) (DBusTypeReader *reader,
122 const DBusTypeMark *mark); /**< uncompress from a mark */
126 first_type_in_signature (const DBusString *str,
131 t = _dbus_string_get_byte (str, pos);
133 if (t == DBUS_STRUCT_BEGIN_CHAR)
134 return DBUS_TYPE_STRUCT;
140 element_type_get_alignment (const DBusString *str,
143 return _dbus_type_get_alignment (first_type_in_signature (str, pos));
147 reader_init (DBusTypeReader *reader,
149 const DBusString *type_str,
151 const DBusString *value_str,
154 reader->byte_order = byte_order;
155 reader->finished = FALSE;
156 reader->type_str = type_str;
157 reader->type_pos = type_pos;
158 reader->value_str = value_str;
159 reader->value_pos = value_pos;
163 base_reader_recurse (DBusTypeReader *sub,
164 DBusTypeReader *parent)
166 /* point subreader at the same place as parent */
176 struct_types_only_reader_recurse (DBusTypeReader *sub,
177 DBusTypeReader *parent)
179 base_reader_recurse (sub, parent);
181 _dbus_assert (_dbus_string_get_byte (sub->type_str,
182 sub->type_pos) == DBUS_STRUCT_BEGIN_CHAR);
188 struct_reader_recurse (DBusTypeReader *sub,
189 DBusTypeReader *parent)
191 struct_types_only_reader_recurse (sub, parent);
193 /* struct has 8 byte alignment */
194 sub->value_pos = _DBUS_ALIGN_VALUE (sub->value_pos, 8);
198 array_types_only_reader_recurse (DBusTypeReader *sub,
199 DBusTypeReader *parent)
201 base_reader_recurse (sub, parent);
203 /* point type_pos at the array element type */
206 /* Init with values likely to crash things if misused */
207 sub->u.array.start_pos = _DBUS_INT_MAX;
208 sub->array_len_offset = 7;
211 /** compute position of array length given array_len_offset, which is
212 the offset back from start_pos to end of the len */
213 #define ARRAY_READER_LEN_POS(reader) \
214 ((reader)->u.array.start_pos - ((int)(reader)->array_len_offset) - 4)
217 array_reader_get_array_len (const DBusTypeReader *reader)
219 dbus_uint32_t array_len;
222 len_pos = ARRAY_READER_LEN_POS (reader);
224 _dbus_assert (_DBUS_ALIGN_VALUE (len_pos, 4) == (unsigned) len_pos);
225 array_len = _dbus_unpack_uint32 (reader->byte_order,
226 _dbus_string_get_const_data_len (reader->value_str, len_pos, 4));
228 #if RECURSIVE_MARSHAL_READ_TRACE
229 _dbus_verbose (" reader %p len_pos %d array len %u len_offset %d\n",
230 reader, len_pos, array_len, reader->array_len_offset);
233 _dbus_assert (reader->u.array.start_pos - len_pos - 4 < 8);
239 array_reader_recurse (DBusTypeReader *sub,
240 DBusTypeReader *parent)
245 array_types_only_reader_recurse (sub, parent);
247 sub->value_pos = _DBUS_ALIGN_VALUE (sub->value_pos, 4);
249 len_pos = sub->value_pos;
251 sub->value_pos += 4; /* for the length */
253 alignment = element_type_get_alignment (sub->type_str,
256 sub->value_pos = _DBUS_ALIGN_VALUE (sub->value_pos, alignment);
258 sub->u.array.start_pos = sub->value_pos;
259 _dbus_assert ((sub->u.array.start_pos - (len_pos + 4)) < 8); /* only 3 bits in array_len_offset */
260 sub->array_len_offset = sub->u.array.start_pos - (len_pos + 4);
262 #if RECURSIVE_MARSHAL_READ_TRACE
263 _dbus_verbose (" type reader %p array start = %d len_offset = %d array len = %d array element type = %s\n",
265 sub->u.array.start_pos,
266 sub->array_len_offset,
267 array_reader_get_array_len (sub),
268 _dbus_type_to_string (first_type_in_signature (sub->type_str,
274 variant_reader_recurse (DBusTypeReader *sub,
275 DBusTypeReader *parent)
279 base_reader_recurse (sub, parent);
281 /* Variant is 1 byte sig length (without nul), signature with nul,
282 * padding to 8-boundary, then values
285 sig_len = _dbus_string_get_byte (sub->value_str, sub->value_pos);
287 sub->type_str = sub->value_str;
288 sub->type_pos = sub->value_pos + 1;
290 sub->value_pos = sub->type_pos + sig_len + 1;
292 sub->value_pos = _DBUS_ALIGN_VALUE (sub->value_pos, 8);
294 #if RECURSIVE_MARSHAL_READ_TRACE
295 _dbus_verbose (" type reader %p variant containing '%s'\n",
297 _dbus_string_get_const_data_len (sub->type_str,
303 array_reader_check_finished (const DBusTypeReader *reader)
307 /* return the array element type if elements remain, and
308 * TYPE_INVALID otherwise
311 end_pos = reader->u.array.start_pos + array_reader_get_array_len (reader);
313 _dbus_assert (reader->value_pos <= end_pos);
314 _dbus_assert (reader->value_pos >= reader->u.array.start_pos);
316 return reader->value_pos == end_pos;
319 /* this is written a little oddly to try and overoptimize */
321 skip_one_complete_type (const DBusString *type_str,
324 const unsigned char *p;
325 const unsigned char *start;
327 _dbus_assert (type_str != NULL);
328 _dbus_assert (type_pos != NULL);
330 start = _dbus_string_get_const_data (type_str);
331 p = start + *type_pos;
333 _dbus_assert (*p != DBUS_STRUCT_END_CHAR);
335 while (*p == DBUS_TYPE_ARRAY)
338 _dbus_assert (*p != DBUS_STRUCT_END_CHAR);
340 if (*p == DBUS_STRUCT_BEGIN_CHAR)
348 _dbus_assert (*p != DBUS_TYPE_INVALID);
352 _dbus_assert (*p != DBUS_TYPE_INVALID);
354 if (*p == DBUS_STRUCT_BEGIN_CHAR)
356 else if (*p == DBUS_STRUCT_END_CHAR)
372 *type_pos = (int) (p - start);
376 find_len_of_complete_type (const DBusString *type_str,
383 skip_one_complete_type (type_str, &end);
385 return end - type_pos;
389 base_reader_next (DBusTypeReader *reader,
392 switch (current_type)
394 case DBUS_TYPE_STRUCT:
395 case DBUS_TYPE_VARIANT:
396 /* Scan forward over the entire container contents */
400 if (reader->klass->types_only && current_type == DBUS_TYPE_VARIANT)
404 /* Recurse into the struct or variant */
405 _dbus_type_reader_recurse (reader, &sub);
407 /* Skip everything in this subreader */
408 while (_dbus_type_reader_next (&sub))
413 if (!reader->klass->types_only)
414 reader->value_pos = sub.value_pos;
416 /* Now we are at the end of this container; for variants, the
417 * subreader's type_pos is totally inapplicable (it's in the
418 * value string) but we know that we increment by one past the
421 if (current_type == DBUS_TYPE_VARIANT)
422 reader->type_pos += 1;
424 reader->type_pos = sub.type_pos;
428 case DBUS_TYPE_ARRAY:
430 if (!reader->klass->types_only)
431 _dbus_marshal_skip_array (reader->value_str,
432 first_type_in_signature (reader->type_str,
433 reader->type_pos + 1),
437 skip_one_complete_type (reader->type_str, &reader->type_pos);
442 if (!reader->klass->types_only)
443 _dbus_marshal_skip_basic (reader->value_str,
444 current_type, reader->byte_order,
447 reader->type_pos += 1;
453 struct_reader_next (DBusTypeReader *reader,
458 base_reader_next (reader, current_type);
460 /* for STRUCT containers we return FALSE at the end of the struct,
461 * for INVALID we return FALSE at the end of the signature.
462 * In both cases we arrange for get_current_type() to return INVALID
463 * which is defined to happen iff we're at the end (no more next())
465 t = _dbus_string_get_byte (reader->type_str, reader->type_pos);
466 if (t == DBUS_STRUCT_END_CHAR)
468 reader->type_pos += 1;
469 reader->finished = TRUE;
474 array_types_only_reader_next (DBusTypeReader *reader,
477 /* We have one "element" to be iterated over
478 * in each array, which is its element type.
479 * So the finished flag indicates whether we've
480 * iterated over it yet or not.
482 reader->finished = TRUE;
486 array_reader_next (DBusTypeReader *reader,
489 /* Skip one array element */
492 end_pos = reader->u.array.start_pos + array_reader_get_array_len (reader);
494 #if RECURSIVE_MARSHAL_READ_TRACE
495 _dbus_verbose (" reader %p array next START start_pos = %d end_pos = %d value_pos = %d current_type = %s\n",
497 reader->u.array.start_pos,
498 end_pos, reader->value_pos,
499 _dbus_type_to_string (current_type));
502 _dbus_assert (reader->value_pos < end_pos);
503 _dbus_assert (reader->value_pos >= reader->u.array.start_pos);
505 switch (first_type_in_signature (reader->type_str,
508 case DBUS_TYPE_STRUCT:
509 case DBUS_TYPE_VARIANT:
513 /* Recurse into the struct or variant */
514 _dbus_type_reader_recurse (reader, &sub);
516 /* Skip everything in this element */
517 while (_dbus_type_reader_next (&sub))
522 /* Now we are at the end of this element */
523 reader->value_pos = sub.value_pos;
527 case DBUS_TYPE_ARRAY:
529 _dbus_marshal_skip_array (reader->value_str,
530 first_type_in_signature (reader->type_str,
531 reader->type_pos + 1),
539 _dbus_marshal_skip_basic (reader->value_str,
540 current_type, reader->byte_order,
546 #if RECURSIVE_MARSHAL_READ_TRACE
547 _dbus_verbose (" reader %p array next END start_pos = %d end_pos = %d value_pos = %d current_type = %s\n",
549 reader->u.array.start_pos,
550 end_pos, reader->value_pos,
551 _dbus_type_to_string (current_type));
554 _dbus_assert (reader->value_pos <= end_pos);
556 if (reader->value_pos == end_pos)
558 skip_one_complete_type (reader->type_str,
564 array_init_from_mark (DBusTypeReader *reader,
565 const DBusTypeMark *mark)
567 /* Fill in the array-specific fields from the mark. The general
568 * fields are already filled in.
570 reader->u.array.start_pos = mark->array_start_pos;
571 reader->array_len_offset = mark->array_len_offset;
574 static const DBusTypeReaderClass body_reader_class = {
577 NULL, /* body is always toplevel, so doesn't get recursed into */
583 static const DBusTypeReaderClass body_types_only_reader_class = {
586 NULL, /* body is always toplevel, so doesn't get recursed into */
592 static const DBusTypeReaderClass struct_reader_class = {
595 struct_reader_recurse,
601 static const DBusTypeReaderClass struct_types_only_reader_class = {
604 struct_types_only_reader_recurse,
610 static const DBusTypeReaderClass array_reader_class = {
613 array_reader_recurse,
614 array_reader_check_finished,
619 static const DBusTypeReaderClass array_types_only_reader_class = {
622 array_types_only_reader_recurse,
624 array_types_only_reader_next,
628 static const DBusTypeReaderClass variant_reader_class = {
631 variant_reader_recurse,
637 static const DBusTypeReaderClass const *
638 all_reader_classes[] = {
640 &body_types_only_reader_class,
641 &struct_reader_class,
642 &struct_types_only_reader_class,
644 &array_types_only_reader_class,
645 &variant_reader_class
649 * Initializes a type reader.
651 * @param reader the reader
652 * @param byte_order the byte order of the block to read
653 * @param type_str the signature of the block to read
654 * @param type_pos location of signature
655 * @param value_str the string containing values block
656 * @param value_pos start of values block
659 _dbus_type_reader_init (DBusTypeReader *reader,
661 const DBusString *type_str,
663 const DBusString *value_str,
666 reader->klass = &body_reader_class;
668 reader_init (reader, byte_order, type_str, type_pos,
669 value_str, value_pos);
671 #if RECURSIVE_MARSHAL_READ_TRACE
672 _dbus_verbose (" type reader %p init type_pos = %d value_pos = %d remaining sig '%s'\n",
673 reader, reader->type_pos, reader->value_pos,
674 _dbus_string_get_const_data_len (reader->type_str, reader->type_pos, 0));
679 * Initializes a type reader that's been compressed into a
680 * DBusTypeMark. The args have to be the same as those passed in to
681 * create the original #DBusTypeReader.
683 * @param reader the reader
684 * @param byte_order the byte order of the value block
685 * @param type_str string containing the type signature
686 * @param value_str string containing the values block
687 * @param mark the mark to decompress from
690 _dbus_type_reader_init_from_mark (DBusTypeReader *reader,
692 const DBusString *type_str,
693 const DBusString *value_str,
694 const DBusTypeMark *mark)
696 reader->klass = all_reader_classes[mark->container_type];
698 reader_init (reader, byte_order,
699 mark->type_pos_in_value_str ? value_str : type_str,
701 value_str, mark->value_pos);
703 if (reader->klass->init_from_mark)
704 (* reader->klass->init_from_mark) (reader, mark);
706 #if RECURSIVE_MARSHAL_READ_TRACE
707 _dbus_verbose (" type reader %p init from mark type_pos = %d value_pos = %d remaining sig '%s'\n",
708 reader, reader->type_pos, reader->value_pos,
709 _dbus_string_get_const_data_len (reader->type_str, reader->type_pos, 0));
714 * Like _dbus_type_reader_init() but the iteration is over the
715 * signature, not over values.
717 * @param reader the reader
718 * @param type_str the signature string
719 * @param type_pos location in the signature string
722 _dbus_type_reader_init_types_only (DBusTypeReader *reader,
723 const DBusString *type_str,
726 reader->klass = &body_types_only_reader_class;
728 reader_init (reader, DBUS_COMPILER_BYTE_ORDER /* irrelevant */,
729 type_str, type_pos, NULL, _DBUS_INT_MAX /* crashes if we screw up */);
731 #if RECURSIVE_MARSHAL_READ_TRACE
732 _dbus_verbose (" type reader %p init types only type_pos = %d remaining sig '%s'\n",
733 reader, reader->type_pos,
734 _dbus_string_get_const_data_len (reader->type_str, reader->type_pos, 0));
739 * Like _dbus_type_reader_init_from_mark() but only iterates over
740 * the signature, not the values.
742 * @param reader the reader
743 * @param type_str the signature string
744 * @param mark the mark to decompress from
747 _dbus_type_reader_init_types_only_from_mark (DBusTypeReader *reader,
748 const DBusString *type_str,
749 const DBusTypeMark *mark)
751 reader->klass = all_reader_classes[mark->container_type];
752 _dbus_assert (reader->klass->types_only);
753 _dbus_assert (!mark->type_pos_in_value_str);
755 reader_init (reader, DBUS_COMPILER_BYTE_ORDER, /* irrelevant */
756 type_str, mark->type_pos,
757 NULL, _DBUS_INT_MAX /* crashes if we screw up */);
759 if (reader->klass->init_from_mark)
760 (* reader->klass->init_from_mark) (reader, mark);
762 #if RECURSIVE_MARSHAL_READ_TRACE
763 _dbus_verbose (" type reader %p init types only from mark type_pos = %d remaining sig '%s'\n",
764 reader, reader->type_pos,
765 _dbus_string_get_const_data_len (reader->type_str, reader->type_pos, 0));
770 * Compresses a type reader into a #DBusTypeMark, useful for example
771 * if you want to cache a bunch of positions in a block of values.
773 * @param reader the reader
774 * @param mark the mark to init
777 _dbus_type_reader_save_mark (const DBusTypeReader *reader,
780 mark->type_pos_in_value_str = (reader->type_str == reader->value_str);
781 mark->container_type = reader->klass->id;
782 _dbus_assert (all_reader_classes[reader->klass->id] == reader->klass);
784 mark->type_pos = reader->type_pos;
785 mark->value_pos = reader->value_pos;
787 /* these are just junk if the reader isn't really an array of course */
788 mark->array_len_offset = reader->array_len_offset;
789 mark->array_start_pos = reader->u.array.start_pos;
793 * Gets the type of the value the reader is currently pointing to;
794 * or for a types-only reader gets the type it's currently pointing to.
795 * If the reader is at the end of a block or end of a container such
796 * as an array, returns #DBUS_TYPE_INVALID.
798 * @param reader the reader
801 _dbus_type_reader_get_current_type (const DBusTypeReader *reader)
805 if (reader->finished ||
806 (reader->klass->check_finished &&
807 (* reader->klass->check_finished) (reader)))
808 t = DBUS_TYPE_INVALID;
810 t = first_type_in_signature (reader->type_str,
813 _dbus_assert (t != DBUS_STRUCT_END_CHAR);
814 _dbus_assert (t != DBUS_STRUCT_BEGIN_CHAR);
817 _dbus_verbose (" type reader %p current type_pos = %d type = %s\n",
818 reader, reader->type_pos,
819 _dbus_type_to_string (t));
826 * Gets the type of an element of the array the reader is currently
827 * pointing to. It's an error to call this if
828 * _dbus_type_reader_get_current_type() doesn't return #DBUS_TYPE_ARRAY
831 * @param reader the reader
834 _dbus_type_reader_get_element_type (const DBusTypeReader *reader)
838 _dbus_assert (_dbus_type_reader_get_current_type (reader) == DBUS_TYPE_ARRAY);
840 element_type = first_type_in_signature (reader->type_str,
841 reader->type_pos + 1);
847 * Gets the current position in the value block
848 * @param reader the reader
851 _dbus_type_reader_get_value_pos (const DBusTypeReader *reader)
853 return reader->value_pos;
857 * Get the address of the marshaled value in the data being read. The
858 * address may not be aligned; you have to align it to the type of the
859 * value you want to read. Most of the demarshal routines do this for
862 * @param reader the reader
863 * @param value_location the address of the marshaled value
866 _dbus_type_reader_read_raw (const DBusTypeReader *reader,
867 const unsigned char **value_location)
869 _dbus_assert (!reader->klass->types_only);
871 *value_location = _dbus_string_get_const_data_len (reader->value_str,
877 * Reads a basic-typed value, as with _dbus_marshal_read_basic().
879 * @param reader the reader
880 * @param value the address of the value
883 _dbus_type_reader_read_basic (const DBusTypeReader *reader,
888 _dbus_assert (!reader->klass->types_only);
890 t = _dbus_type_reader_get_current_type (reader);
892 _dbus_marshal_read_basic (reader->value_str,
899 #if RECURSIVE_MARSHAL_READ_TRACE
900 _dbus_verbose (" type reader %p read basic type_pos = %d value_pos = %d remaining sig '%s'\n",
901 reader, reader->type_pos, reader->value_pos,
902 _dbus_string_get_const_data_len (reader->type_str, reader->type_pos, 0));
907 * Reads a block of fixed-length basic values, from the current point
908 * in an array to the end of the array. Does not work for arrays of
909 * string or container types.
911 * This function returns the array in-place; it does not make a copy,
912 * and it does not swap the bytes.
914 * If you ask for #DBUS_TYPE_DOUBLE you will get a "const double*" back
915 * and the "value" argument should be a "const double**" and so on.
917 * @param reader the reader to read from
918 * @param value place to return the array values
919 * @param n_elements place to return number of array elements
922 _dbus_type_reader_read_fixed_multi (const DBusTypeReader *reader,
932 _dbus_assert (!reader->klass->types_only);
933 _dbus_assert (reader->klass == &array_reader_class);
935 element_type = first_type_in_signature (reader->type_str,
938 _dbus_assert (element_type != DBUS_TYPE_INVALID); /* why we don't use get_current_type() */
939 _dbus_assert (_dbus_type_is_fixed (element_type));
941 alignment = _dbus_type_get_alignment (element_type);
943 _dbus_assert (reader->value_pos >= reader->u.array.start_pos);
945 total_len = array_reader_get_array_len (reader);
946 end_pos = reader->u.array.start_pos + total_len;
947 remaining_len = end_pos - reader->value_pos;
949 #if RECURSIVE_MARSHAL_READ_TRACE
950 _dbus_verbose ("end_pos %d total_len %d remaining_len %d value_pos %d\n",
951 end_pos, total_len, remaining_len, reader->value_pos);
954 _dbus_assert (remaining_len <= total_len);
956 if (remaining_len == 0)
957 *(const DBusBasicValue**) value = NULL;
959 *(const DBusBasicValue**) value =
960 (void*) _dbus_string_get_const_data_len (reader->value_str,
964 *n_elements = remaining_len / alignment;
965 _dbus_assert ((remaining_len % alignment) == 0);
967 #if RECURSIVE_MARSHAL_READ_TRACE
968 _dbus_verbose (" type reader %p read fixed array type_pos = %d value_pos = %d remaining sig '%s'\n",
969 reader, reader->type_pos, reader->value_pos,
970 _dbus_string_get_const_data_len (reader->type_str, reader->type_pos, 0));
975 * Initialize a new reader pointing to the first type and
976 * corresponding value that's a child of the current container. It's
977 * an error to call this if the current type is a non-container.
979 * Note that DBusTypeReader traverses values, not types. So if you
980 * have an empty array of array of int, you can't recurse into it. You
981 * can only recurse into each element.
983 * @param reader the reader
984 * @param sub a reader to init pointing to the first child
987 _dbus_type_reader_recurse (DBusTypeReader *reader,
992 t = first_type_in_signature (reader->type_str, reader->type_pos);
996 case DBUS_TYPE_STRUCT:
997 if (reader->klass->types_only)
998 sub->klass = &struct_types_only_reader_class;
1000 sub->klass = &struct_reader_class;
1002 case DBUS_TYPE_ARRAY:
1003 if (reader->klass->types_only)
1004 sub->klass = &array_types_only_reader_class;
1006 sub->klass = &array_reader_class;
1008 case DBUS_TYPE_VARIANT:
1009 if (reader->klass->types_only)
1010 _dbus_assert_not_reached ("can't recurse into variant typecode");
1012 sub->klass = &variant_reader_class;
1015 _dbus_verbose ("recursing into type %s\n", _dbus_type_to_string (t));
1016 #ifndef DBUS_DISABLE_CHECKS
1017 if (t == DBUS_TYPE_INVALID)
1018 _dbus_warn ("You can't recurse into an empty array or off the end of a message body\n");
1019 #endif /* DBUS_DISABLE_CHECKS */
1021 _dbus_assert_not_reached ("don't yet handle recursing into this type");
1024 _dbus_assert (sub->klass == all_reader_classes[sub->klass->id]);
1026 (* sub->klass->recurse) (sub, reader);
1028 #if RECURSIVE_MARSHAL_READ_TRACE
1029 _dbus_verbose (" type reader %p RECURSED type_pos = %d value_pos = %d remaining sig '%s'\n",
1030 sub, sub->type_pos, sub->value_pos,
1031 _dbus_string_get_const_data_len (sub->type_str, sub->type_pos, 0));
1036 * Skip to the next value on this "level". e.g. the next field in a
1037 * struct, the next value in an array. Returns FALSE at the end of the
1038 * current container.
1040 * @param reader the reader
1041 * @returns FALSE if nothing more to read at or below this level
1044 _dbus_type_reader_next (DBusTypeReader *reader)
1048 t = _dbus_type_reader_get_current_type (reader);
1050 #if RECURSIVE_MARSHAL_READ_TRACE
1051 _dbus_verbose (" type reader %p START next() { type_pos = %d value_pos = %d remaining sig '%s' current_type = %s\n",
1052 reader, reader->type_pos, reader->value_pos,
1053 _dbus_string_get_const_data_len (reader->type_str, reader->type_pos, 0),
1054 _dbus_type_to_string (t));
1057 if (t == DBUS_TYPE_INVALID)
1060 (* reader->klass->next) (reader, t);
1062 #if RECURSIVE_MARSHAL_READ_TRACE
1063 _dbus_verbose (" type reader %p END next() type_pos = %d value_pos = %d remaining sig '%s' current_type = %s\n",
1064 reader, reader->type_pos, reader->value_pos,
1065 _dbus_string_get_const_data_len (reader->type_str, reader->type_pos, 0),
1066 _dbus_type_to_string (_dbus_type_reader_get_current_type (reader)));
1069 return _dbus_type_reader_get_current_type (reader) != DBUS_TYPE_INVALID;
1073 * Check whether there's another value on this "level". e.g. the next
1074 * field in a struct, the next value in an array. Returns FALSE at the
1075 * end of the current container.
1077 * You probably don't want to use this; it makes for an awkward for/while
1078 * loop. A nicer one is "while ((current_type = get_current_type()) != INVALID)"
1080 * @param reader the reader
1081 * @returns FALSE if nothing more to read at or below this level
1084 _dbus_type_reader_has_next (const DBusTypeReader *reader)
1086 /* Not efficient but works for now. */
1087 DBusTypeReader copy;
1090 return _dbus_type_reader_next (©);
1094 * Gets the string and range of said string containing the signature
1095 * of the current value. Essentially a more complete version of
1096 * _dbus_type_reader_get_current_type() (returns the full type
1097 * rather than only the outside of the onion).
1099 * Note though that the first byte in a struct signature is
1100 * #DBUS_STRUCT_BEGIN_CHAR while the current type will be
1101 * #DBUS_TYPE_STRUCT so it isn't true that the first byte of the
1102 * signature is always the same as the current type. Another
1103 * difference is that this function will still return a signature when
1104 * inside an empty array; say you recurse into empty array of int32,
1105 * the signature is "i" but the current type will always be
1106 * #DBUS_TYPE_INVALID since there are no elements to be currently
1109 * @param reader the reader
1110 * @param str_p place to return the string with the type in it
1111 * @param start_p place to return start of the type
1112 * @param len_p place to return the length of the type
1115 _dbus_type_reader_get_signature (const DBusTypeReader *reader,
1116 const DBusString **str_p,
1120 *str_p = reader->type_str;
1121 *start_p = reader->type_pos;
1122 *len_p = find_len_of_complete_type (reader->type_str, reader->type_pos);
1127 DBusString replacement;
1132 replacement_block_init (ReplacementBlock *block,
1133 DBusTypeReader *reader)
1135 if (!_dbus_string_init (&block->replacement))
1138 /* % 8 is the padding to have the same align properties in
1139 * our replacement string as we do at the position being replaced
1141 block->padding = reader->value_pos % 8;
1143 if (!_dbus_string_lengthen (&block->replacement, block->padding))
1149 _dbus_string_free (&block->replacement);
1154 replacement_block_replace (ReplacementBlock *block,
1155 DBusTypeReader *reader,
1156 const DBusTypeReader *realign_root)
1158 DBusTypeWriter writer;
1159 DBusTypeReader realign_reader;
1163 _dbus_assert (realign_root != NULL);
1165 orig_len = _dbus_string_get_length (&block->replacement);
1167 realign_reader = *realign_root;
1169 #if RECURSIVE_MARSHAL_WRITE_TRACE
1170 _dbus_verbose ("INITIALIZING replacement block writer %p at value_pos %d\n",
1171 &writer, _dbus_string_get_length (&block->replacement));
1173 _dbus_type_writer_init_values_only (&writer,
1174 realign_reader.byte_order,
1175 realign_reader.type_str,
1176 realign_reader.type_pos,
1177 &block->replacement,
1178 _dbus_string_get_length (&block->replacement));
1180 _dbus_assert (realign_reader.value_pos <= reader->value_pos);
1182 #if RECURSIVE_MARSHAL_WRITE_TRACE
1183 _dbus_verbose ("COPYING from reader at value_pos %d to writer %p starting after value_pos %d\n",
1184 realign_reader.value_pos, &writer, reader->value_pos);
1187 if (!_dbus_type_writer_write_reader_partial (&writer,
1191 _dbus_string_get_length (&block->replacement) - block->padding,
1195 #if RECURSIVE_MARSHAL_WRITE_TRACE
1196 _dbus_verbose ("REPLACEMENT at padding %d len %d\n", block->padding,
1197 _dbus_string_get_length (&block->replacement) - block->padding);
1198 _dbus_verbose_bytes_of_string (&block->replacement, block->padding,
1199 _dbus_string_get_length (&block->replacement) - block->padding);
1200 _dbus_verbose ("TO BE REPLACED at value_pos = %d (align pad %d) len %d realign_reader.value_pos %d\n",
1201 reader->value_pos, reader->value_pos % 8,
1202 realign_reader.value_pos - reader->value_pos,
1203 realign_reader.value_pos);
1204 _dbus_verbose_bytes_of_string (reader->value_str,
1206 realign_reader.value_pos - reader->value_pos);
1209 /* Move the replacement into position
1210 * (realign_reader should now be at the end of the block to be replaced)
1212 if (!_dbus_string_replace_len (&block->replacement, block->padding,
1213 _dbus_string_get_length (&block->replacement) - block->padding,
1214 (DBusString*) reader->value_str,
1216 realign_reader.value_pos - reader->value_pos))
1219 /* Process our fixups now that we can't have an OOM error */
1220 apply_and_free_fixups (&fixups, reader);
1225 _dbus_string_set_length (&block->replacement, orig_len);
1226 free_fixups (&fixups);
1231 replacement_block_free (ReplacementBlock *block)
1233 _dbus_string_free (&block->replacement);
1236 /* In the variable-length case, we have to fix alignment after we insert.
1237 * The strategy is as follows:
1239 * - pad a new string to have the same alignment as the
1240 * start of the current basic value
1241 * - write the new basic value
1242 * - copy from the original reader to the new string,
1243 * which will fix the alignment of types following
1245 * - this copy has to start at realign_root,
1246 * but not really write anything until it
1247 * passes the value being set
1248 * - as an optimization, we can stop copying
1249 * when the source and dest values are both
1250 * on an 8-boundary, since we know all following
1251 * padding and alignment will be identical
1252 * - copy the new string back to the original
1253 * string, replacing the relevant part of the
1255 * - now any arrays in the original string that
1256 * contained the replaced string may have the
1257 * wrong length; so we have to fix that
1260 reader_set_basic_variable_length (DBusTypeReader *reader,
1263 const DBusTypeReader *realign_root)
1266 ReplacementBlock block;
1267 DBusTypeWriter writer;
1269 _dbus_assert (realign_root != NULL);
1273 if (!replacement_block_init (&block, reader))
1276 /* Write the new basic value */
1277 #if RECURSIVE_MARSHAL_WRITE_TRACE
1278 _dbus_verbose ("INITIALIZING writer %p to write basic value at value_pos %d of replacement string\n",
1279 &writer, _dbus_string_get_length (&block.replacement));
1281 _dbus_type_writer_init_values_only (&writer,
1286 _dbus_string_get_length (&block.replacement));
1287 #if RECURSIVE_MARSHAL_WRITE_TRACE
1288 _dbus_verbose ("WRITING basic value to writer %p (replacement string)\n", &writer);
1290 if (!_dbus_type_writer_write_basic (&writer, current_type, value))
1293 if (!replacement_block_replace (&block,
1301 replacement_block_free (&block);
1306 reader_set_basic_fixed_length (DBusTypeReader *reader,
1310 _dbus_marshal_set_basic ((DBusString*) reader->value_str,
1319 * Sets a new value for the basic type value pointed to by the reader,
1320 * leaving the reader valid to continue reading. Any other readers
1321 * will be invalidated if you set a variable-length type such as a
1324 * The provided realign_root is the reader to start from when
1325 * realigning the data that follows the newly-set value. The reader
1326 * parameter must point to a value below the realign_root parameter.
1327 * If the type being set is fixed-length, then realign_root may be
1328 * #NULL. Only values reachable from realign_root will be realigned,
1329 * so if your string contains other values you will need to deal with
1330 * those somehow yourself. It is OK if realign_root is the same
1331 * reader as the reader parameter, though if you aren't setting the
1332 * root it may not be such a good idea.
1334 * @todo DBusTypeReader currently takes "const" versions of the type
1335 * and value strings, and this function modifies those strings by
1336 * casting away the const, which is of course bad if we want to get
1337 * picky. (To be truly clean you'd have an object which contained the
1338 * type and value strings and set_basic would be a method on that
1339 * object... this would also make DBusTypeReader the same thing as
1340 * DBusTypeMark. But since DBusMessage is effectively that object for
1341 * D-BUS it doesn't seem worth creating some random object.)
1343 * @todo optimize this by only rewriting until the old and new values
1344 * are at the same alignment. Frequently this should result in only
1345 * replacing the value that's immediately at hand.
1347 * @param reader reader indicating where to set a new value
1348 * @param value address of the value to set
1349 * @param realign_root realign from here
1350 * @returns #FALSE if not enough memory
1353 _dbus_type_reader_set_basic (DBusTypeReader *reader,
1355 const DBusTypeReader *realign_root)
1359 _dbus_assert (!reader->klass->types_only);
1360 _dbus_assert (reader->value_str == realign_root->value_str);
1361 _dbus_assert (reader->value_pos >= realign_root->value_pos);
1363 current_type = _dbus_type_reader_get_current_type (reader);
1365 #if RECURSIVE_MARSHAL_WRITE_TRACE
1366 _dbus_verbose (" SET BASIC type reader %p type_pos = %d value_pos = %d remaining sig '%s' realign_root = %p with value_pos %d current_type = %s\n",
1367 reader, reader->type_pos, reader->value_pos,
1368 _dbus_string_get_const_data_len (reader->type_str, reader->type_pos, 0),
1370 realign_root ? realign_root->value_pos : -1,
1371 _dbus_type_to_string (current_type));
1372 _dbus_verbose_bytes_of_string (realign_root->value_str, realign_root->value_pos,
1373 _dbus_string_get_length (realign_root->value_str) -
1374 realign_root->value_pos);
1377 _dbus_assert (_dbus_type_is_basic (current_type));
1379 if (_dbus_type_is_fixed (current_type))
1381 reader_set_basic_fixed_length (reader, current_type, value);
1386 _dbus_assert (realign_root != NULL);
1387 return reader_set_basic_variable_length (reader, current_type,
1388 value, realign_root);
1393 * Recursively deletes any value pointed to by the reader, leaving the
1394 * reader valid to continue reading. Any other readers will be
1397 * The provided realign_root is the reader to start from when
1398 * realigning the data that follows the newly-set value.
1399 * See _dbus_type_reader_set_basic() for more details on the
1400 * realign_root paramter.
1402 * @todo for now this does not delete the typecodes associated with
1403 * the value, so this function should only be used for array elements.
1405 * @param reader reader indicating where to delete a value
1406 * @param realign_root realign from here
1407 * @returns #FALSE if not enough memory
1410 _dbus_type_reader_delete (DBusTypeReader *reader,
1411 const DBusTypeReader *realign_root)
1414 ReplacementBlock block;
1416 _dbus_assert (realign_root != NULL);
1417 _dbus_assert (reader->klass == &array_reader_class);
1421 if (!replacement_block_init (&block, reader))
1424 if (!replacement_block_replace (&block,
1432 replacement_block_free (&block);
1437 * Compares two readers, which must be iterating over the same value data.
1438 * Returns #TRUE if the first parameter is further along than the second parameter.
1440 * @param lhs left-hand-side (first) parameter
1441 * @param rhs left-hand-side (first) parameter
1442 * @returns whether lhs is greater than rhs
1445 _dbus_type_reader_greater_than (const DBusTypeReader *lhs,
1446 const DBusTypeReader *rhs)
1448 _dbus_assert (lhs->value_str == rhs->value_str);
1450 return lhs->value_pos > rhs->value_pos;
1463 * Initialize a write iterator, which is used to write out values in
1464 * serialized D-BUS format.
1466 * The type_pos passed in is expected to be inside an already-valid,
1467 * though potentially empty, type signature. This means that the byte
1468 * after type_pos must be either #DBUS_TYPE_INVALID (aka nul) or some
1469 * other valid type. #DBusTypeWriter won't enforce that the signature
1470 * is already valid (you can append the nul byte at the end if you
1471 * like), but just be aware that you need the nul byte eventually and
1472 * #DBusTypeWriter isn't going to write it for you.
1474 * @param writer the writer to init
1475 * @param byte_order the byte order to marshal into
1476 * @param type_str the string to write typecodes into
1477 * @param type_pos where to insert typecodes
1478 * @param value_str the string to write values into
1479 * @param value_pos where to insert values
1483 _dbus_type_writer_init (DBusTypeWriter *writer,
1485 DBusString *type_str,
1487 DBusString *value_str,
1490 writer->byte_order = byte_order;
1491 writer->type_str = type_str;
1492 writer->type_pos = type_pos;
1493 writer->value_str = value_str;
1494 writer->value_pos = value_pos;
1495 writer->container_type = DBUS_TYPE_INVALID;
1496 writer->type_pos_is_expectation = FALSE;
1497 writer->enabled = TRUE;
1499 #if RECURSIVE_MARSHAL_WRITE_TRACE
1500 _dbus_verbose ("writer %p init remaining sig '%s'\n", writer,
1502 _dbus_string_get_const_data_len (writer->type_str, writer->type_pos, 0) :
1508 * Initialize a write iterator, with the signature to be provided
1511 * @param writer the writer to init
1512 * @param byte_order the byte order to marshal into
1513 * @param value_str the string to write values into
1514 * @param value_pos where to insert values
1518 _dbus_type_writer_init_types_delayed (DBusTypeWriter *writer,
1520 DBusString *value_str,
1523 _dbus_type_writer_init (writer, byte_order,
1524 NULL, 0, value_str, value_pos);
1528 * Adds type string to the writer, if it had none.
1530 * @param writer the writer to init
1531 * @param type_str type string to add
1532 * @param type_pos type position
1536 _dbus_type_writer_add_types (DBusTypeWriter *writer,
1537 DBusString *type_str,
1540 if (writer->type_str == NULL) /* keeps us from using this as setter */
1542 writer->type_str = type_str;
1543 writer->type_pos = type_pos;
1548 * Removes type string from the writer.
1550 * @param writer the writer to remove from
1553 _dbus_type_writer_remove_types (DBusTypeWriter *writer)
1555 writer->type_str = NULL;
1556 writer->type_pos = -1;
1560 * Like _dbus_type_writer_init(), except the type string
1561 * passed in should correspond to an existing signature that
1562 * matches what you're going to write out. The writer will
1563 * check what you write vs. this existing signature.
1565 * @param writer the writer to init
1566 * @param byte_order the byte order to marshal into
1567 * @param type_str the string with signature
1568 * @param type_pos start of signature
1569 * @param value_str the string to write values into
1570 * @param value_pos where to insert values
1574 _dbus_type_writer_init_values_only (DBusTypeWriter *writer,
1576 const DBusString *type_str,
1578 DBusString *value_str,
1581 _dbus_type_writer_init (writer, byte_order,
1582 (DBusString*)type_str, type_pos,
1583 value_str, value_pos);
1585 writer->type_pos_is_expectation = TRUE;
1589 _dbus_type_writer_write_basic_no_typecode (DBusTypeWriter *writer,
1593 if (writer->enabled)
1594 return _dbus_marshal_write_basic (writer->value_str,
1599 &writer->value_pos);
1604 /* If our parent is an array, things are a little bit complicated.
1606 * The parent must have a complete element type, such as
1607 * "i" or "aai" or "(ii)" or "a(ii)". There can't be
1608 * unclosed parens, or an "a" with no following type.
1610 * To recurse, the only allowed operation is to recurse into the
1611 * first type in the element type. So for "i" you can't recurse, for
1612 * "ai" you can recurse into the array, for "(ii)" you can recurse
1615 * If you recurse into the array for "ai", then you must specify
1616 * "i" for the element type of the array you recurse into.
1618 * While inside an array at any level, we need to avoid writing to
1619 * type_str, since the type only appears once for the whole array,
1620 * it does not appear for each array element.
1622 * While inside an array type_pos points to the expected next
1623 * typecode, rather than the next place we could write a typecode.
1626 writer_recurse_init_and_check (DBusTypeWriter *writer,
1628 DBusTypeWriter *sub)
1630 _dbus_type_writer_init (sub,
1637 sub->container_type = container_type;
1639 if (writer->type_pos_is_expectation ||
1640 (sub->container_type == DBUS_TYPE_ARRAY || sub->container_type == DBUS_TYPE_VARIANT))
1641 sub->type_pos_is_expectation = TRUE;
1643 sub->type_pos_is_expectation = FALSE;
1645 sub->enabled = writer->enabled;
1647 #ifndef DBUS_DISABLE_CHECKS
1648 if (writer->type_pos_is_expectation && writer->type_str)
1652 expected = first_type_in_signature (writer->type_str, writer->type_pos);
1654 if (expected != sub->container_type)
1656 _dbus_warn ("Writing an element of type %s, but the expected type here is %s\n",
1657 _dbus_type_to_string (sub->container_type),
1658 _dbus_type_to_string (expected));
1659 _dbus_assert_not_reached ("bad array element or variant content written");
1662 #endif /* DBUS_DISABLE_CHECKS */
1664 #if RECURSIVE_MARSHAL_WRITE_TRACE
1665 _dbus_verbose (" type writer %p recurse parent %s type_pos = %d value_pos = %d is_expectation = %d remaining sig '%s' enabled = %d\n",
1667 _dbus_type_to_string (writer->container_type),
1668 writer->type_pos, writer->value_pos, writer->type_pos_is_expectation,
1670 _dbus_string_get_const_data_len (writer->type_str, writer->type_pos, 0) :
1673 _dbus_verbose (" type writer %p recurse sub %s type_pos = %d value_pos = %d is_expectation = %d enabled = %d\n",
1675 _dbus_type_to_string (sub->container_type),
1676 sub->type_pos, sub->value_pos,
1677 sub->type_pos_is_expectation,
1683 write_or_verify_typecode (DBusTypeWriter *writer,
1686 /* A subwriter inside an array or variant will have type_pos
1687 * pointing to the expected typecode; a writer not inside an array
1688 * or variant has type_pos pointing to the next place to insert a
1691 #if RECURSIVE_MARSHAL_WRITE_TRACE
1692 _dbus_verbose (" type writer %p write_or_verify start type_pos = %d remaining sig '%s' enabled = %d\n",
1693 writer, writer->type_pos,
1695 _dbus_string_get_const_data_len (writer->type_str, writer->type_pos, 0) :
1700 if (writer->type_str == NULL)
1703 if (writer->type_pos_is_expectation)
1705 #ifndef DBUS_DISABLE_CHECKS
1709 expected = _dbus_string_get_byte (writer->type_str, writer->type_pos);
1711 if (expected != typecode)
1713 _dbus_warn ("Array or variant type requires that type %s be written, but %s was written\n",
1714 _dbus_type_to_string (expected), _dbus_type_to_string (typecode));
1715 _dbus_assert_not_reached ("bad type inserted somewhere inside an array or variant");
1718 #endif /* DBUS_DISABLE_CHECKS */
1720 /* if immediately inside an array we'd always be appending an element,
1721 * so the expected type doesn't change; if inside a struct or something
1722 * below an array, we need to move through said struct or something.
1724 if (writer->container_type != DBUS_TYPE_ARRAY)
1725 writer->type_pos += 1;
1729 if (!_dbus_string_insert_byte (writer->type_str,
1734 writer->type_pos += 1;
1737 #if RECURSIVE_MARSHAL_WRITE_TRACE
1738 _dbus_verbose (" type writer %p write_or_verify end type_pos = %d remaining sig '%s'\n",
1739 writer, writer->type_pos,
1740 _dbus_string_get_const_data_len (writer->type_str, writer->type_pos, 0));
1747 writer_recurse_struct (DBusTypeWriter *writer,
1748 const DBusString *contained_type,
1749 int contained_type_start,
1750 int contained_type_len,
1751 DBusTypeWriter *sub)
1753 /* FIXME right now contained_type is ignored; we could probably
1754 * almost trivially fix the code so if it's present we
1755 * write it out and then set type_pos_is_expectation
1758 /* Ensure that we'll be able to add alignment padding and the typecode */
1759 if (writer->enabled)
1761 if (!_dbus_string_alloc_space (sub->value_str, 8))
1765 if (!write_or_verify_typecode (sub, DBUS_STRUCT_BEGIN_CHAR))
1766 _dbus_assert_not_reached ("failed to insert struct typecode after prealloc");
1768 if (writer->enabled)
1770 if (!_dbus_string_insert_bytes (sub->value_str,
1772 _DBUS_ALIGN_VALUE (sub->value_pos, 8) - sub->value_pos,
1774 _dbus_assert_not_reached ("should not have failed to insert alignment padding for struct");
1775 sub->value_pos = _DBUS_ALIGN_VALUE (sub->value_pos, 8);
1783 writer_recurse_array (DBusTypeWriter *writer,
1784 const DBusString *contained_type,
1785 int contained_type_start,
1786 int contained_type_len,
1787 DBusTypeWriter *sub,
1788 dbus_bool_t is_array_append)
1790 dbus_uint32_t value = 0;
1794 #ifndef DBUS_DISABLE_CHECKS
1795 if (writer->container_type == DBUS_TYPE_ARRAY &&
1798 if (!_dbus_string_equal_substring (contained_type,
1799 contained_type_start,
1802 writer->u.array.element_type_pos + 1))
1804 _dbus_warn ("Writing an array of '%s' but this is incompatible with the expected type of elements in the parent array\n",
1805 _dbus_string_get_const_data_len (contained_type,
1806 contained_type_start,
1807 contained_type_len));
1808 _dbus_assert_not_reached ("incompatible type for child array");
1811 #endif /* DBUS_DISABLE_CHECKS */
1813 if (writer->enabled && !is_array_append)
1815 /* 3 pad + 4 bytes for the array length, and 4 bytes possible padding
1816 * before array values
1818 if (!_dbus_string_alloc_space (sub->value_str, 3 + 4 + 4))
1822 if (writer->type_str != NULL)
1824 sub->type_pos += 1; /* move to point to the element type, since type_pos
1825 * should be the expected type for further writes
1827 sub->u.array.element_type_pos = sub->type_pos;
1830 if (!writer->type_pos_is_expectation)
1832 /* sub is a toplevel/outermost array so we need to write the type data */
1834 /* alloc space for array typecode, element signature */
1835 if (!_dbus_string_alloc_space (writer->type_str, 1 + contained_type_len))
1838 if (!_dbus_string_insert_byte (writer->type_str,
1841 _dbus_assert_not_reached ("failed to insert array typecode after prealloc");
1843 if (!_dbus_string_copy_len (contained_type,
1844 contained_type_start, contained_type_len,
1846 sub->u.array.element_type_pos))
1847 _dbus_assert_not_reached ("should not have failed to insert array element typecodes");
1850 if (writer->type_str != NULL)
1852 /* If the parent is an array, we hold type_pos pointing at the array element type;
1853 * otherwise advance it to reflect the array value we just recursed into
1855 if (writer->container_type != DBUS_TYPE_ARRAY)
1856 writer->type_pos += 1 + contained_type_len;
1858 _dbus_assert (writer->type_pos_is_expectation); /* because it's an array */
1861 if (writer->enabled)
1863 /* Write (or jump over, if is_array_append) the length */
1864 sub->u.array.len_pos = _DBUS_ALIGN_VALUE (sub->value_pos, 4);
1866 if (is_array_append)
1868 sub->value_pos += 4;
1872 if (!_dbus_type_writer_write_basic_no_typecode (sub, DBUS_TYPE_UINT32,
1874 _dbus_assert_not_reached ("should not have failed to insert array len");
1877 _dbus_assert (sub->u.array.len_pos == sub->value_pos - 4);
1879 /* Write alignment padding for array elements
1880 * Note that we write the padding *even for empty arrays*
1881 * to avoid wonky special cases
1883 alignment = element_type_get_alignment (contained_type, contained_type_start);
1885 aligned = _DBUS_ALIGN_VALUE (sub->value_pos, alignment);
1886 if (aligned != sub->value_pos)
1888 if (!is_array_append)
1890 if (!_dbus_string_insert_bytes (sub->value_str,
1892 aligned - sub->value_pos,
1894 _dbus_assert_not_reached ("should not have failed to insert alignment padding");
1897 sub->value_pos = aligned;
1900 sub->u.array.start_pos = sub->value_pos;
1902 if (is_array_append)
1906 _dbus_assert (_DBUS_ALIGN_VALUE (sub->u.array.len_pos, 4) ==
1907 (unsigned) sub->u.array.len_pos);
1908 len = _dbus_unpack_uint32 (sub->byte_order,
1909 _dbus_string_get_const_data_len (sub->value_str,
1910 sub->u.array.len_pos,
1913 sub->value_pos += len;
1918 /* not enabled, so we won't write the len_pos; set it to -1 to so indicate */
1919 sub->u.array.len_pos = -1;
1920 sub->u.array.start_pos = sub->value_pos;
1923 _dbus_assert (sub->u.array.len_pos < sub->u.array.start_pos);
1924 _dbus_assert (is_array_append || sub->u.array.start_pos == sub->value_pos);
1926 #if RECURSIVE_MARSHAL_WRITE_TRACE
1927 _dbus_verbose (" type writer %p recurse array done remaining sig '%s' array start_pos = %d len_pos = %d value_pos = %d\n", sub,
1929 _dbus_string_get_const_data_len (sub->type_str, sub->type_pos, 0) :
1931 sub->u.array.start_pos, sub->u.array.len_pos, sub->value_pos);
1937 /* Variant value will normally have:
1938 * 1 byte signature length not including nul
1939 * signature typecodes (nul terminated)
1940 * padding to 8-boundary
1941 * body according to signature
1943 * The signature string can only have a single type
1944 * in it but that type may be complex/recursive.
1946 * So a typical variant type with the integer 3 will have these
1948 * 0x1 'i' '\0' [padding to 8-boundary] 0x0 0x0 0x0 0x3
1950 * For an array of 4-byte types stuffed into variants, the padding to
1951 * 8-boundary is only the 1 byte that is required for the 4-boundary
1952 * anyhow for all array elements after the first one. And for single
1953 * variants in isolation, wasting a few bytes is hardly a big deal.
1955 * The main world of hurt for writing out a variant is that the type
1956 * string is the same string as the value string. Which means
1957 * inserting to the type string will move the value_pos; and it means
1958 * that inserting to the type string could break type alignment.
1960 * This type alignment issue is why the body of the variant is always
1961 * 8-aligned. Then we know that re-8-aligning the start of the body
1962 * will always correctly align the full contents of the variant type.
1965 writer_recurse_variant (DBusTypeWriter *writer,
1966 const DBusString *contained_type,
1967 int contained_type_start,
1968 int contained_type_len,
1969 DBusTypeWriter *sub)
1971 if (writer->enabled)
1973 /* Allocate space for the worst case, which is 1 byte sig
1974 * length, nul byte at end of sig, and 7 bytes padding to
1977 if (!_dbus_string_alloc_space (sub->value_str, contained_type_len + 9))
1981 /* write VARIANT typecode to the parent's type string */
1982 if (!write_or_verify_typecode (writer, DBUS_TYPE_VARIANT))
1985 /* If not enabled, mark that we have no type_str anymore ... */
1987 if (!writer->enabled)
1989 sub->type_str = NULL;
1995 /* If we're enabled then continue ... */
1997 if (!_dbus_string_insert_byte (sub->value_str,
1999 contained_type_len))
2000 _dbus_assert_not_reached ("should not have failed to insert variant type sig len");
2002 sub->value_pos += 1;
2004 /* Here we switch over to the expected type sig we're about to write */
2005 sub->type_str = sub->value_str;
2006 sub->type_pos = sub->value_pos;
2008 if (!_dbus_string_copy_len (contained_type, contained_type_start, contained_type_len,
2009 sub->value_str, sub->value_pos))
2010 _dbus_assert_not_reached ("should not have failed to insert variant type sig");
2012 sub->value_pos += contained_type_len;
2014 if (!_dbus_string_insert_byte (sub->value_str,
2017 _dbus_assert_not_reached ("should not have failed to insert variant type nul termination");
2019 sub->value_pos += 1;
2021 if (!_dbus_string_insert_bytes (sub->value_str,
2023 _DBUS_ALIGN_VALUE (sub->value_pos, 8) - sub->value_pos,
2025 _dbus_assert_not_reached ("should not have failed to insert alignment padding for variant body");
2026 sub->value_pos = _DBUS_ALIGN_VALUE (sub->value_pos, 8);
2032 _dbus_type_writer_recurse_contained_len (DBusTypeWriter *writer,
2034 const DBusString *contained_type,
2035 int contained_type_start,
2036 int contained_type_len,
2037 DBusTypeWriter *sub,
2038 dbus_bool_t is_array_append)
2040 writer_recurse_init_and_check (writer, container_type, sub);
2042 switch (container_type)
2044 case DBUS_TYPE_STRUCT:
2045 return writer_recurse_struct (writer,
2046 contained_type, contained_type_start, contained_type_len,
2049 case DBUS_TYPE_ARRAY:
2050 return writer_recurse_array (writer,
2051 contained_type, contained_type_start, contained_type_len,
2052 sub, is_array_append);
2054 case DBUS_TYPE_VARIANT:
2055 return writer_recurse_variant (writer,
2056 contained_type, contained_type_start, contained_type_len,
2060 _dbus_assert_not_reached ("tried to recurse into type that doesn't support that");
2067 * Opens a new container and writes out the initial information for that container.
2069 * @param writer the writer
2070 * @param container_type the type of the container to open
2071 * @param contained_type the array element type or variant content type
2072 * @param contained_type_start position to look for the type
2073 * @param sub the new sub-writer to write container contents
2074 * @returns #FALSE if no memory
2077 _dbus_type_writer_recurse (DBusTypeWriter *writer,
2079 const DBusString *contained_type,
2080 int contained_type_start,
2081 DBusTypeWriter *sub)
2083 int contained_type_len;
2086 contained_type_len = find_len_of_complete_type (contained_type, contained_type_start);
2088 contained_type_len = 0;
2090 return _dbus_type_writer_recurse_contained_len (writer, container_type,
2092 contained_type_start,
2099 * Append to an existing array. Essentially, the writer will read an
2100 * existing length at the write location; jump over that length; and
2101 * write new fields. On unrecurse(), the existing length will be
2104 * @param writer the writer
2105 * @param contained_type element type
2106 * @param contained_type_start position of element type
2107 * @param sub the subwriter to init
2108 * @returns #FALSE if no memory
2111 _dbus_type_writer_append_array (DBusTypeWriter *writer,
2112 const DBusString *contained_type,
2113 int contained_type_start,
2114 DBusTypeWriter *sub)
2116 int contained_type_len;
2119 contained_type_len = find_len_of_complete_type (contained_type, contained_type_start);
2121 contained_type_len = 0;
2123 return _dbus_type_writer_recurse_contained_len (writer, DBUS_TYPE_ARRAY,
2125 contained_type_start,
2132 writer_get_array_len (DBusTypeWriter *writer)
2134 _dbus_assert (writer->container_type == DBUS_TYPE_ARRAY);
2135 return writer->value_pos - writer->u.array.start_pos;
2139 * Closes a container created by _dbus_type_writer_recurse()
2140 * and writes any additional information to the values block.
2142 * @param writer the writer
2143 * @param sub the sub-writer created by _dbus_type_writer_recurse()
2144 * @returns #FALSE if no memory
2147 _dbus_type_writer_unrecurse (DBusTypeWriter *writer,
2148 DBusTypeWriter *sub)
2150 /* type_pos_is_expectation never gets unset once set, or we'd get all hosed */
2151 _dbus_assert (!writer->type_pos_is_expectation ||
2152 (writer->type_pos_is_expectation && sub->type_pos_is_expectation));
2154 #if RECURSIVE_MARSHAL_WRITE_TRACE
2155 _dbus_verbose (" type writer %p unrecurse type_pos = %d value_pos = %d is_expectation = %d container_type = %s\n",
2156 writer, writer->type_pos, writer->value_pos, writer->type_pos_is_expectation,
2157 _dbus_type_to_string (writer->container_type));
2158 _dbus_verbose (" type writer %p unrecurse sub type_pos = %d value_pos = %d is_expectation = %d container_type = %s\n",
2159 sub, sub->type_pos, sub->value_pos,
2160 sub->type_pos_is_expectation,
2161 _dbus_type_to_string (sub->container_type));
2164 if (sub->container_type == DBUS_TYPE_STRUCT)
2166 if (!write_or_verify_typecode (sub, DBUS_STRUCT_END_CHAR))
2169 else if (sub->container_type == DBUS_TYPE_ARRAY)
2171 if (sub->u.array.len_pos >= 0) /* len_pos == -1 if we weren't enabled when we passed it */
2175 /* Set the array length */
2176 len = writer_get_array_len (sub);
2177 _dbus_marshal_set_uint32 (sub->value_str,
2178 sub->u.array.len_pos,
2181 #if RECURSIVE_MARSHAL_WRITE_TRACE
2182 _dbus_verbose (" filled in sub array len to %u at len_pos %d\n",
2183 len, sub->u.array.len_pos);
2186 #if RECURSIVE_MARSHAL_WRITE_TRACE
2189 _dbus_verbose (" not filling in sub array len because we were disabled when we passed the len\n");
2194 /* Now get type_pos right for the parent writer. Here are the cases:
2196 * Cases !writer->type_pos_is_expectation:
2197 * (in these cases we want to update to the new insertion point)
2199 * - if we recursed into a STRUCT then we didn't know in advance
2200 * what the types in the struct would be; so we have to fill in
2201 * that information now.
2202 * writer->type_pos = sub->type_pos
2204 * - if we recursed into anything else, we knew the full array
2205 * type, or knew the single typecode marking VARIANT, so
2206 * writer->type_pos is already correct.
2207 * writer->type_pos should remain as-is
2209 * - note that the parent is never an ARRAY or VARIANT, if it were
2210 * then type_pos_is_expectation would be TRUE. The parent
2211 * is thus known to be a toplevel or STRUCT.
2213 * Cases where writer->type_pos_is_expectation:
2214 * (in these cases we want to update to next expected type to write)
2216 * - we recursed from STRUCT into STRUCT and we didn't increment
2217 * type_pos in the parent just to stay consistent with the
2218 * !writer->type_pos_is_expectation case (though we could
2219 * special-case this in recurse_struct instead if we wanted)
2220 * writer->type_pos = sub->type_pos
2222 * - we recursed from STRUCT into ARRAY or VARIANT and type_pos
2223 * for parent should have been incremented already
2224 * writer->type_pos should remain as-is
2226 * - we recursed from ARRAY into a sub-element, so type_pos in the
2227 * parent is the element type and should remain the element type
2228 * for the benefit of the next child element
2229 * writer->type_pos should remain as-is
2231 * - we recursed from VARIANT into its value, so type_pos in the
2232 * parent makes no difference since there's only one value
2233 * and we just finished writing it and won't use type_pos again
2234 * writer->type_pos should remain as-is
2236 if (writer->type_str != NULL)
2238 if (sub->container_type == DBUS_TYPE_STRUCT &&
2239 (writer->container_type == DBUS_TYPE_STRUCT ||
2240 writer->container_type == DBUS_TYPE_INVALID))
2242 /* Advance the parent to the next struct field */
2243 writer->type_pos = sub->type_pos;
2247 writer->value_pos = sub->value_pos;
2249 #if RECURSIVE_MARSHAL_WRITE_TRACE
2250 _dbus_verbose (" type writer %p unrecursed type_pos = %d value_pos = %d remaining sig '%s'\n",
2251 writer, writer->type_pos, writer->value_pos,
2253 _dbus_string_get_const_data_len (writer->type_str, writer->type_pos, 0) :
2261 * Writes out a basic type.
2263 * @param writer the writer
2264 * @param type the type to write
2265 * @param value the address of the value to write
2266 * @returns #FALSE if no memory
2269 _dbus_type_writer_write_basic (DBusTypeWriter *writer,
2275 /* First ensure that our type realloc will succeed */
2276 if (!writer->type_pos_is_expectation && writer->type_str != NULL)
2278 if (!_dbus_string_alloc_space (writer->type_str, 1))
2284 if (!_dbus_type_writer_write_basic_no_typecode (writer, type, value))
2287 if (!write_or_verify_typecode (writer, type))
2288 _dbus_assert_not_reached ("failed to write typecode after prealloc");
2293 #if RECURSIVE_MARSHAL_WRITE_TRACE
2294 _dbus_verbose (" type writer %p basic type_pos = %d value_pos = %d is_expectation = %d enabled = %d\n",
2295 writer, writer->type_pos, writer->value_pos, writer->type_pos_is_expectation,
2303 * Writes a block of fixed-length basic values, i.e. those that are
2304 * both _dbus_type_is_fixed() and _dbus_type_is_basic(). The block
2305 * must be written inside an array.
2307 * The value parameter should be the address of said array of values,
2308 * so e.g. if it's an array of double, pass in "const double**"
2310 * @param writer the writer
2311 * @param element_type type of stuff in the array
2312 * @param value address of the array
2313 * @param n_elements number of elements in the array
2314 * @returns #FALSE if no memory
2317 _dbus_type_writer_write_fixed_multi (DBusTypeWriter *writer,
2322 _dbus_assert (writer->container_type == DBUS_TYPE_ARRAY);
2323 _dbus_assert (_dbus_type_is_fixed (element_type));
2324 _dbus_assert (writer->type_pos_is_expectation);
2325 _dbus_assert (n_elements >= 0);
2327 #if RECURSIVE_MARSHAL_WRITE_TRACE
2328 _dbus_verbose (" type writer %p entering fixed multi type_pos = %d value_pos = %d n_elements %d\n",
2329 writer, writer->type_pos, writer->value_pos, n_elements);
2332 if (!write_or_verify_typecode (writer, element_type))
2333 _dbus_assert_not_reached ("OOM should not happen if only verifying typecode");
2335 if (writer->enabled)
2337 if (!_dbus_marshal_write_fixed_multi (writer->value_str,
2343 &writer->value_pos))
2347 #if RECURSIVE_MARSHAL_WRITE_TRACE
2348 _dbus_verbose (" type writer %p fixed multi written new type_pos = %d new value_pos = %d n_elements %d\n",
2349 writer, writer->type_pos, writer->value_pos, n_elements);
2356 enable_if_after (DBusTypeWriter *writer,
2357 DBusTypeReader *reader,
2358 const DBusTypeReader *start_after)
2362 if (!writer->enabled && _dbus_type_reader_greater_than (reader, start_after))
2364 _dbus_type_writer_set_enabled (writer, TRUE);
2365 #if RECURSIVE_MARSHAL_WRITE_TRACE
2366 _dbus_verbose ("ENABLING writer %p at %d because reader at value_pos %d is after reader at value_pos %d\n",
2367 writer, writer->value_pos, reader->value_pos, start_after->value_pos);
2371 _dbus_assert ((!writer->enabled && !_dbus_type_reader_greater_than (reader, start_after)) ||
2372 (writer->enabled && _dbus_type_reader_greater_than (reader, start_after)));
2377 append_fixup (DBusList **fixups,
2378 const DBusArrayLenFixup *fixup)
2380 DBusArrayLenFixup *f;
2382 f = dbus_new (DBusArrayLenFixup, 1);
2388 if (!_dbus_list_append (fixups, f))
2394 _dbus_assert (f->len_pos_in_reader == fixup->len_pos_in_reader);
2395 _dbus_assert (f->new_len == fixup->new_len);
2400 /* This loop is trivial if you ignore all the start_after nonsense,
2401 * so if you're trying to figure it out, start by ignoring that
2404 writer_write_reader_helper (DBusTypeWriter *writer,
2405 DBusTypeReader *reader,
2406 const DBusTypeReader *start_after,
2407 int start_after_new_pos,
2408 int start_after_new_len,
2410 dbus_bool_t inside_start_after)
2414 while ((current_type = _dbus_type_reader_get_current_type (reader)) != DBUS_TYPE_INVALID)
2416 if (_dbus_type_is_container (current_type))
2418 DBusTypeReader subreader;
2419 DBusTypeWriter subwriter;
2420 const DBusString *sig_str;
2423 dbus_bool_t enabled_at_recurse;
2424 dbus_bool_t past_start_after;
2425 int reader_array_len_pos;
2426 int reader_array_start_pos;
2427 dbus_bool_t this_is_start_after;
2429 /* type_pos is checked since e.g. in a struct the struct
2430 * and its first field have the same value_pos.
2431 * type_str will differ in reader/start_after for variants
2432 * where type_str is inside the value_str
2434 if (!inside_start_after && start_after &&
2435 reader->value_pos == start_after->value_pos &&
2436 reader->type_str == start_after->type_str &&
2437 reader->type_pos == start_after->type_pos)
2438 this_is_start_after = TRUE;
2440 this_is_start_after = FALSE;
2442 _dbus_type_reader_recurse (reader, &subreader);
2444 if (current_type == DBUS_TYPE_ARRAY)
2446 reader_array_len_pos = ARRAY_READER_LEN_POS (&subreader);
2447 reader_array_start_pos = subreader.u.array.start_pos;
2452 reader_array_len_pos = -1;
2453 reader_array_start_pos = -1;
2456 _dbus_type_reader_get_signature (&subreader, &sig_str,
2457 &sig_start, &sig_len);
2459 #if RECURSIVE_MARSHAL_WRITE_TRACE
2460 _dbus_verbose ("about to recurse into %s reader at %d subreader at %d writer at %d start_after reader at %d write target len %d inside_start_after = %d this_is_start_after = %d\n",
2461 _dbus_type_to_string (current_type),
2463 subreader.value_pos,
2465 start_after ? start_after->value_pos : -1,
2466 _dbus_string_get_length (writer->value_str),
2467 inside_start_after, this_is_start_after);
2470 if (!inside_start_after && !this_is_start_after)
2471 enable_if_after (writer, &subreader, start_after);
2472 enabled_at_recurse = writer->enabled;
2473 if (!_dbus_type_writer_recurse_contained_len (writer, current_type,
2474 sig_str, sig_start, sig_len,
2478 #if RECURSIVE_MARSHAL_WRITE_TRACE
2479 _dbus_verbose ("recursed into subwriter at %d write target len %d\n",
2480 subwriter.value_pos,
2481 _dbus_string_get_length (subwriter.value_str));
2484 if (!writer_write_reader_helper (&subwriter, &subreader, start_after,
2485 start_after_new_pos, start_after_new_len,
2487 inside_start_after ||
2488 this_is_start_after))
2491 #if RECURSIVE_MARSHAL_WRITE_TRACE
2492 _dbus_verbose ("about to unrecurse from %s subreader at %d writer at %d subwriter at %d write target len %d\n",
2493 _dbus_type_to_string (current_type),
2494 subreader.value_pos,
2496 subwriter.value_pos,
2497 _dbus_string_get_length (writer->value_str));
2500 if (!inside_start_after && !this_is_start_after)
2501 enable_if_after (writer, &subreader, start_after);
2502 past_start_after = writer->enabled;
2503 if (!_dbus_type_writer_unrecurse (writer, &subwriter))
2506 /* If we weren't enabled when we recursed, we didn't
2507 * write an array len; if we passed start_after
2508 * somewhere inside the array, then we need to generate
2511 if (start_after != NULL &&
2512 !enabled_at_recurse && past_start_after &&
2513 current_type == DBUS_TYPE_ARRAY &&
2516 DBusArrayLenFixup fixup;
2517 int bytes_written_after_start_after;
2518 int bytes_before_start_after;
2521 /* this subwriter access is moderately unkosher since we
2522 * already unrecursed, but it works as long as unrecurse
2523 * doesn't break us on purpose
2525 bytes_written_after_start_after = writer_get_array_len (&subwriter);
2527 bytes_before_start_after =
2528 start_after->value_pos - reader_array_start_pos;
2530 fixup.len_pos_in_reader = reader_array_len_pos;
2532 bytes_before_start_after +
2533 start_after_new_len +
2534 bytes_written_after_start_after;
2536 _dbus_assert (_DBUS_ALIGN_VALUE (fixup.len_pos_in_reader, 4) ==
2537 (unsigned) fixup.len_pos_in_reader);
2539 old_len = _dbus_unpack_uint32 (reader->byte_order,
2540 _dbus_string_get_const_data_len (reader->value_str,
2541 fixup.len_pos_in_reader, 4));
2543 if (old_len != fixup.new_len && !append_fixup (fixups, &fixup))
2546 #if RECURSIVE_MARSHAL_WRITE_TRACE
2547 _dbus_verbose ("Generated fixup len_pos_in_reader = %d new_len = %d reader_array_start_pos = %d start_after->value_pos = %d bytes_before_start_after = %d start_after_new_len = %d bytes_written_after_start_after = %d\n",
2548 fixup.len_pos_in_reader,
2550 reader_array_start_pos,
2551 start_after->value_pos,
2552 bytes_before_start_after,
2553 start_after_new_len,
2554 bytes_written_after_start_after);
2562 _dbus_assert (_dbus_type_is_basic (current_type));
2564 #if RECURSIVE_MARSHAL_WRITE_TRACE
2565 _dbus_verbose ("Reading basic value %s at %d\n",
2566 _dbus_type_to_string (current_type),
2570 _dbus_type_reader_read_basic (reader, &val);
2572 #if RECURSIVE_MARSHAL_WRITE_TRACE
2573 _dbus_verbose ("Writing basic value %s at %d write target len %d inside_start_after = %d\n",
2574 _dbus_type_to_string (current_type),
2576 _dbus_string_get_length (writer->value_str),
2577 inside_start_after);
2579 if (!inside_start_after)
2580 enable_if_after (writer, reader, start_after);
2581 if (!_dbus_type_writer_write_basic (writer, current_type, &val))
2583 #if RECURSIVE_MARSHAL_WRITE_TRACE
2584 _dbus_verbose ("Wrote basic value %s, new value_pos %d write target len %d\n",
2585 _dbus_type_to_string (current_type),
2587 _dbus_string_get_length (writer->value_str));
2591 _dbus_type_reader_next (reader);
2598 apply_and_free_fixups (fixups, NULL); /* NULL for reader to apply to */
2604 * Iterate through all values in the given reader, writing a copy of
2605 * each value to the writer. The reader will be moved forward to its
2608 * If a reader start_after is provided, it should be a reader for the
2609 * same data as the reader to be written. Only values occurring after
2610 * the value pointed to by start_after will be written to the writer.
2612 * If start_after is provided, then the copy of the reader will be
2613 * partial. This means that array lengths will not have been copied.
2614 * The assumption is that you wrote a new version of the value at
2615 * start_after to the writer. You have to pass in the start position
2616 * and length of the new value. (If you are deleting the value
2617 * at start_after, pass in 0 for the length.)
2619 * If the fixups parameter is non-#NULL, then any array length that
2620 * was read but not written due to start_after will be provided
2621 * as a #DBusArrayLenFixup. The fixup contains the position of the
2622 * array length in the source data, and the correct array length
2623 * assuming you combine the source data before start_after with
2624 * the written data at start_after and beyond.
2626 * @param writer the writer to copy to
2627 * @param reader the reader to copy from
2628 * @param start_after #NULL or a reader showing where to start
2629 * @param start_after_new_pos the position of start_after equivalent in the target data
2630 * @param start_after_new_len the length of start_after equivalent in the target data
2631 * @param fixups list to append #DBusArrayLenFixup if the write was partial
2632 * @returns #FALSE if no memory
2635 _dbus_type_writer_write_reader_partial (DBusTypeWriter *writer,
2636 DBusTypeReader *reader,
2637 const DBusTypeReader *start_after,
2638 int start_after_new_pos,
2639 int start_after_new_len,
2642 DBusTypeWriter orig;
2649 orig_type_len = _dbus_string_get_length (writer->type_str);
2650 orig_value_len = _dbus_string_get_length (writer->value_str);
2651 orig_enabled = writer->enabled;
2654 _dbus_type_writer_set_enabled (writer, FALSE);
2656 if (!writer_write_reader_helper (writer, reader, start_after,
2657 start_after_new_pos,
2658 start_after_new_len,
2662 _dbus_type_writer_set_enabled (writer, orig_enabled);
2666 if (!writer->type_pos_is_expectation)
2668 new_bytes = _dbus_string_get_length (writer->type_str) - orig_type_len;
2669 _dbus_string_delete (writer->type_str, orig.type_pos, new_bytes);
2671 new_bytes = _dbus_string_get_length (writer->value_str) - orig_value_len;
2672 _dbus_string_delete (writer->value_str, orig.value_pos, new_bytes);
2680 * Iterate through all values in the given reader, writing a copy of
2681 * each value to the writer. The reader will be moved forward to its
2684 * @param writer the writer to copy to
2685 * @param reader the reader to copy from
2686 * @returns #FALSE if no memory
2689 _dbus_type_writer_write_reader (DBusTypeWriter *writer,
2690 DBusTypeReader *reader)
2692 return _dbus_type_writer_write_reader_partial (writer, reader, NULL, 0, 0, NULL);
2696 * If disabled, a writer can still be iterated forward and recursed/unrecursed
2697 * but won't write any values. Types will still be written unless the
2698 * writer is a "values only" writer, because the writer needs access to
2699 * a valid signature to be able to iterate.
2701 * @param writer the type writer
2702 * @param enabled #TRUE if values should be written
2705 _dbus_type_writer_set_enabled (DBusTypeWriter *writer,
2706 dbus_bool_t enabled)
2708 writer->enabled = enabled != FALSE;
2711 /** @} */ /* end of DBusMarshal group */
2713 #ifdef DBUS_BUILD_TESTS
2714 #include "dbus-test.h"
2715 #include "dbus-list.h"
2719 /* Whether to do the OOM stuff (only with other expensive tests) */
2720 #define TEST_OOM_HANDLING 0
2721 /* We do start offset 0 through 9, to get various alignment cases. Still this
2722 * obviously makes the test suite run 10x as slow.
2724 #define MAX_INITIAL_OFFSET 9
2726 /* Largest iteration count to test copying, realignment,
2727 * etc. with. i.e. we only test this stuff with some of the smaller
2730 #define MAX_ITERATIONS_FOR_EXPENSIVE_TESTS 1000
2736 DBusString signature;
2746 #define N_FENCE_BYTES 5
2747 #define FENCE_BYTES_STR "abcde"
2748 #define INITIAL_PADDING_BYTE '\0'
2751 data_block_init (DataBlock *block,
2755 if (!_dbus_string_init (&block->signature))
2758 if (!_dbus_string_init (&block->body))
2760 _dbus_string_free (&block->signature);
2764 if (!_dbus_string_insert_bytes (&block->signature, 0, initial_offset,
2765 INITIAL_PADDING_BYTE) ||
2766 !_dbus_string_insert_bytes (&block->body, 0, initial_offset,
2767 INITIAL_PADDING_BYTE) ||
2768 !_dbus_string_append (&block->signature, FENCE_BYTES_STR) ||
2769 !_dbus_string_append (&block->body, FENCE_BYTES_STR))
2771 _dbus_string_free (&block->signature);
2772 _dbus_string_free (&block->body);
2776 block->byte_order = byte_order;
2777 block->initial_offset = initial_offset;
2783 data_block_save (DataBlock *block,
2784 DataBlockState *state)
2786 state->saved_sig_len = _dbus_string_get_length (&block->signature) - N_FENCE_BYTES;
2787 state->saved_body_len = _dbus_string_get_length (&block->body) - N_FENCE_BYTES;
2791 data_block_restore (DataBlock *block,
2792 DataBlockState *state)
2794 _dbus_string_delete (&block->signature,
2795 state->saved_sig_len,
2796 _dbus_string_get_length (&block->signature) - state->saved_sig_len - N_FENCE_BYTES);
2797 _dbus_string_delete (&block->body,
2798 state->saved_body_len,
2799 _dbus_string_get_length (&block->body) - state->saved_body_len - N_FENCE_BYTES);
2803 data_block_verify (DataBlock *block)
2805 if (!_dbus_string_ends_with_c_str (&block->signature,
2810 offset = _dbus_string_get_length (&block->signature) - N_FENCE_BYTES - 8;
2814 _dbus_verbose_bytes_of_string (&block->signature,
2816 _dbus_string_get_length (&block->signature) - offset);
2817 _dbus_assert_not_reached ("block did not verify: bad bytes at end of signature");
2819 if (!_dbus_string_ends_with_c_str (&block->body,
2824 offset = _dbus_string_get_length (&block->body) - N_FENCE_BYTES - 8;
2828 _dbus_verbose_bytes_of_string (&block->body,
2830 _dbus_string_get_length (&block->body) - offset);
2831 _dbus_assert_not_reached ("block did not verify: bad bytes at end of body");
2834 _dbus_assert (_dbus_string_validate_nul (&block->signature,
2835 0, block->initial_offset));
2836 _dbus_assert (_dbus_string_validate_nul (&block->body,
2837 0, block->initial_offset));
2841 data_block_free (DataBlock *block)
2843 data_block_verify (block);
2845 _dbus_string_free (&block->signature);
2846 _dbus_string_free (&block->body);
2850 data_block_reset (DataBlock *block)
2852 data_block_verify (block);
2854 _dbus_string_delete (&block->signature,
2855 block->initial_offset,
2856 _dbus_string_get_length (&block->signature) - N_FENCE_BYTES - block->initial_offset);
2857 _dbus_string_delete (&block->body,
2858 block->initial_offset,
2859 _dbus_string_get_length (&block->body) - N_FENCE_BYTES - block->initial_offset);
2861 data_block_verify (block);
2865 data_block_init_reader_writer (DataBlock *block,
2866 DBusTypeReader *reader,
2867 DBusTypeWriter *writer)
2870 _dbus_type_reader_init (reader,
2873 block->initial_offset,
2875 block->initial_offset);
2878 _dbus_type_writer_init (writer,
2881 _dbus_string_get_length (&block->signature) - N_FENCE_BYTES,
2883 _dbus_string_get_length (&block->body) - N_FENCE_BYTES);
2887 real_check_expected_type (DBusTypeReader *reader,
2889 const char *funcname,
2894 t = _dbus_type_reader_get_current_type (reader);
2898 _dbus_warn ("Read type %s while expecting %s at %s line %d\n",
2899 _dbus_type_to_string (t),
2900 _dbus_type_to_string (expected),
2903 _dbus_assert_not_reached ("read wrong type");
2907 #define check_expected_type(reader, expected) real_check_expected_type (reader, expected, _DBUS_FUNCTION_NAME, __LINE__)
2909 #define NEXT_EXPECTING_TRUE(reader) do { if (!_dbus_type_reader_next (reader)) \
2911 _dbus_warn ("_dbus_type_reader_next() should have returned TRUE at %s %d\n", \
2912 _DBUS_FUNCTION_NAME, __LINE__); \
2913 _dbus_assert_not_reached ("test failed"); \
2917 #define NEXT_EXPECTING_FALSE(reader) do { if (_dbus_type_reader_next (reader)) \
2919 _dbus_warn ("_dbus_type_reader_next() should have returned FALSE at %s %d\n", \
2920 _DBUS_FUNCTION_NAME, __LINE__); \
2921 _dbus_assert_not_reached ("test failed"); \
2923 check_expected_type (reader, DBUS_TYPE_INVALID); \
2926 typedef struct TestTypeNode TestTypeNode;
2927 typedef struct TestTypeNodeClass TestTypeNodeClass;
2928 typedef struct TestTypeNodeContainer TestTypeNodeContainer;
2929 typedef struct TestTypeNodeContainerClass TestTypeNodeContainerClass;
2933 const TestTypeNodeClass *klass;
2936 struct TestTypeNodeContainer
2942 struct TestTypeNodeClass
2948 int subclass_detail; /* a bad hack to avoid a bunch of subclass casting */
2950 dbus_bool_t (* construct) (TestTypeNode *node);
2951 void (* destroy) (TestTypeNode *node);
2953 dbus_bool_t (* write_value) (TestTypeNode *node,
2955 DBusTypeWriter *writer,
2957 dbus_bool_t (* read_value) (TestTypeNode *node,
2958 DBusTypeReader *reader,
2960 dbus_bool_t (* set_value) (TestTypeNode *node,
2961 DBusTypeReader *reader,
2962 DBusTypeReader *realign_root,
2964 dbus_bool_t (* build_signature) (TestTypeNode *node,
2966 dbus_bool_t (* write_multi) (TestTypeNode *node,
2968 DBusTypeWriter *writer,
2971 dbus_bool_t (* read_multi) (TestTypeNode *node,
2972 DBusTypeReader *reader,
2977 struct TestTypeNodeContainerClass
2979 TestTypeNodeClass base;
2982 /* FIXME this could be chilled out substantially by unifying
2983 * the basic types into basic_write_value/basic_read_value
2984 * and by merging read_value and set_value into one function
2985 * taking a flag argument.
2987 static dbus_bool_t int32_write_value (TestTypeNode *node,
2989 DBusTypeWriter *writer,
2991 static dbus_bool_t int32_read_value (TestTypeNode *node,
2992 DBusTypeReader *reader,
2994 static dbus_bool_t int32_set_value (TestTypeNode *node,
2995 DBusTypeReader *reader,
2996 DBusTypeReader *realign_root,
2998 static dbus_bool_t int32_write_multi (TestTypeNode *node,
3000 DBusTypeWriter *writer,
3003 static dbus_bool_t int32_read_multi (TestTypeNode *node,
3004 DBusTypeReader *reader,
3007 static dbus_bool_t int64_write_value (TestTypeNode *node,
3009 DBusTypeWriter *writer,
3011 static dbus_bool_t int64_read_value (TestTypeNode *node,
3012 DBusTypeReader *reader,
3014 static dbus_bool_t int64_set_value (TestTypeNode *node,
3015 DBusTypeReader *reader,
3016 DBusTypeReader *realign_root,
3018 static dbus_bool_t string_write_value (TestTypeNode *node,
3020 DBusTypeWriter *writer,
3022 static dbus_bool_t string_read_value (TestTypeNode *node,
3023 DBusTypeReader *reader,
3025 static dbus_bool_t string_set_value (TestTypeNode *node,
3026 DBusTypeReader *reader,
3027 DBusTypeReader *realign_root,
3029 static dbus_bool_t bool_write_value (TestTypeNode *node,
3031 DBusTypeWriter *writer,
3033 static dbus_bool_t bool_read_value (TestTypeNode *node,
3034 DBusTypeReader *reader,
3036 static dbus_bool_t bool_set_value (TestTypeNode *node,
3037 DBusTypeReader *reader,
3038 DBusTypeReader *realign_root,
3040 static dbus_bool_t byte_write_value (TestTypeNode *node,
3042 DBusTypeWriter *writer,
3044 static dbus_bool_t byte_read_value (TestTypeNode *node,
3045 DBusTypeReader *reader,
3047 static dbus_bool_t byte_set_value (TestTypeNode *node,
3048 DBusTypeReader *reader,
3049 DBusTypeReader *realign_root,
3051 static dbus_bool_t double_write_value (TestTypeNode *node,
3053 DBusTypeWriter *writer,
3055 static dbus_bool_t double_read_value (TestTypeNode *node,
3056 DBusTypeReader *reader,
3058 static dbus_bool_t double_set_value (TestTypeNode *node,
3059 DBusTypeReader *reader,
3060 DBusTypeReader *realign_root,
3062 static dbus_bool_t object_path_write_value (TestTypeNode *node,
3064 DBusTypeWriter *writer,
3066 static dbus_bool_t object_path_read_value (TestTypeNode *node,
3067 DBusTypeReader *reader,
3069 static dbus_bool_t object_path_set_value (TestTypeNode *node,
3070 DBusTypeReader *reader,
3071 DBusTypeReader *realign_root,
3073 static dbus_bool_t signature_write_value (TestTypeNode *node,
3075 DBusTypeWriter *writer,
3077 static dbus_bool_t signature_read_value (TestTypeNode *node,
3078 DBusTypeReader *reader,
3080 static dbus_bool_t signature_set_value (TestTypeNode *node,
3081 DBusTypeReader *reader,
3082 DBusTypeReader *realign_root,
3084 static dbus_bool_t struct_write_value (TestTypeNode *node,
3086 DBusTypeWriter *writer,
3088 static dbus_bool_t struct_read_value (TestTypeNode *node,
3089 DBusTypeReader *reader,
3091 static dbus_bool_t struct_set_value (TestTypeNode *node,
3092 DBusTypeReader *reader,
3093 DBusTypeReader *realign_root,
3095 static dbus_bool_t struct_build_signature (TestTypeNode *node,
3097 static dbus_bool_t array_write_value (TestTypeNode *node,
3099 DBusTypeWriter *writer,
3101 static dbus_bool_t array_read_value (TestTypeNode *node,
3102 DBusTypeReader *reader,
3104 static dbus_bool_t array_set_value (TestTypeNode *node,
3105 DBusTypeReader *reader,
3106 DBusTypeReader *realign_root,
3108 static dbus_bool_t array_build_signature (TestTypeNode *node,
3110 static dbus_bool_t variant_write_value (TestTypeNode *node,
3112 DBusTypeWriter *writer,
3114 static dbus_bool_t variant_read_value (TestTypeNode *node,
3115 DBusTypeReader *reader,
3117 static dbus_bool_t variant_set_value (TestTypeNode *node,
3118 DBusTypeReader *reader,
3119 DBusTypeReader *realign_root,
3121 static void container_destroy (TestTypeNode *node);
3124 static const TestTypeNodeClass int32_class = {
3126 sizeof (TestTypeNode),
3138 static const TestTypeNodeClass uint32_class = {
3140 sizeof (TestTypeNode),
3144 int32_write_value, /* recycle from int32 */
3145 int32_read_value, /* recycle from int32 */
3146 int32_set_value, /* recycle from int32 */
3148 int32_write_multi, /* recycle from int32 */
3149 int32_read_multi /* recycle from int32 */
3152 static const TestTypeNodeClass int64_class = {
3154 sizeof (TestTypeNode),
3166 static const TestTypeNodeClass uint64_class = {
3168 sizeof (TestTypeNode),
3172 int64_write_value, /* recycle from int64 */
3173 int64_read_value, /* recycle from int64 */
3174 int64_set_value, /* recycle from int64 */
3180 static const TestTypeNodeClass string_0_class = {
3182 sizeof (TestTypeNode),
3183 0, /* string length */
3194 static const TestTypeNodeClass string_1_class = {
3196 sizeof (TestTypeNode),
3197 1, /* string length */
3208 /* with nul, a len 3 string should fill 4 bytes and thus is "special" */
3209 static const TestTypeNodeClass string_3_class = {
3211 sizeof (TestTypeNode),
3212 3, /* string length */
3223 /* with nul, a len 8 string should fill 9 bytes and thus is "special" (far-fetched I suppose) */
3224 static const TestTypeNodeClass string_8_class = {
3226 sizeof (TestTypeNode),
3227 8, /* string length */
3238 static const TestTypeNodeClass bool_class = {
3240 sizeof (TestTypeNode),
3252 static const TestTypeNodeClass byte_class = {
3254 sizeof (TestTypeNode),
3266 static const TestTypeNodeClass double_class = {
3268 sizeof (TestTypeNode),
3280 static const TestTypeNodeClass object_path_class = {
3281 DBUS_TYPE_OBJECT_PATH,
3282 sizeof (TestTypeNode),
3286 object_path_write_value,
3287 object_path_read_value,
3288 object_path_set_value,
3294 static const TestTypeNodeClass signature_class = {
3295 DBUS_TYPE_SIGNATURE,
3296 sizeof (TestTypeNode),
3300 signature_write_value,
3301 signature_read_value,
3302 signature_set_value,
3308 static const TestTypeNodeClass struct_1_class = {
3310 sizeof (TestTypeNodeContainer),
3311 1, /* number of times children appear as fields */
3317 struct_build_signature,
3322 static const TestTypeNodeClass struct_2_class = {
3324 sizeof (TestTypeNodeContainer),
3325 2, /* number of times children appear as fields */
3331 struct_build_signature,
3336 static dbus_bool_t arrays_write_fixed_in_blocks = FALSE;
3338 static const TestTypeNodeClass array_0_class = {
3340 sizeof (TestTypeNodeContainer),
3341 0, /* number of array elements */
3347 array_build_signature,
3352 static const TestTypeNodeClass array_1_class = {
3354 sizeof (TestTypeNodeContainer),
3355 1, /* number of array elements */
3361 array_build_signature,
3366 static const TestTypeNodeClass array_2_class = {
3368 sizeof (TestTypeNodeContainer),
3369 2, /* number of array elements */
3375 array_build_signature,
3380 static const TestTypeNodeClass array_9_class = {
3382 sizeof (TestTypeNodeContainer),
3383 9, /* number of array elements */
3389 array_build_signature,
3394 static const TestTypeNodeClass variant_class = {
3396 sizeof (TestTypeNodeContainer),
3400 variant_write_value,
3408 static const TestTypeNodeClass* const
3424 #define N_BASICS (_DBUS_N_ELEMENTS (basic_nodes))
3426 static const TestTypeNodeClass* const
3427 container_nodes[] = {
3434 /* array_9_class is omitted on purpose, it's too slow;
3435 * we only use it in one hardcoded test below
3438 #define N_CONTAINERS (_DBUS_N_ELEMENTS (container_nodes))
3440 static TestTypeNode*
3441 node_new (const TestTypeNodeClass *klass)
3445 node = dbus_malloc0 (klass->instance_size);
3449 node->klass = klass;
3451 if (klass->construct)
3453 if (!(* klass->construct) (node))
3464 node_destroy (TestTypeNode *node)
3466 if (node->klass->destroy)
3467 (* node->klass->destroy) (node);
3472 node_write_value (TestTypeNode *node,
3474 DBusTypeWriter *writer,
3479 retval = (* node->klass->write_value) (node, block, writer, seed);
3482 /* Handy to see where things break, but too expensive to do all the time */
3483 data_block_verify (block);
3490 node_read_value (TestTypeNode *node,
3491 DBusTypeReader *reader,
3495 DBusTypeReader restored;
3497 _dbus_type_reader_save_mark (reader, &mark);
3499 if (!(* node->klass->read_value) (node, reader, seed))
3502 _dbus_type_reader_init_from_mark (&restored,
3508 if (!(* node->klass->read_value) (node, &restored, seed))
3514 /* Warning: if this one fails due to OOM, it has side effects (can
3515 * modify only some of the sub-values). OK in a test suite, but we
3516 * never do this in real code.
3519 node_set_value (TestTypeNode *node,
3520 DBusTypeReader *reader,
3521 DBusTypeReader *realign_root,
3524 if (!(* node->klass->set_value) (node, reader, realign_root, seed))
3531 node_build_signature (TestTypeNode *node,
3534 if (node->klass->build_signature)
3535 return (* node->klass->build_signature) (node, str);
3537 return _dbus_string_append_byte (str, node->klass->typecode);
3541 node_append_child (TestTypeNode *node,
3542 TestTypeNode *child)
3544 TestTypeNodeContainer *container = (TestTypeNodeContainer*) node;
3546 _dbus_assert (node->klass->instance_size >= (int) sizeof (TestTypeNodeContainer));
3548 if (!_dbus_list_append (&container->children, child))
3549 _dbus_assert_not_reached ("no memory"); /* we never check the return value on node_append_child anyhow - it's run from outside the malloc-failure test code */
3555 node_write_multi (TestTypeNode *node,
3557 DBusTypeWriter *writer,
3563 _dbus_assert (node->klass->write_multi != NULL);
3564 retval = (* node->klass->write_multi) (node, block, writer, seed, n_copies);
3567 /* Handy to see where things break, but too expensive to do all the time */
3568 data_block_verify (block);
3575 node_read_multi (TestTypeNode *node,
3576 DBusTypeReader *reader,
3580 _dbus_assert (node->klass->read_multi != NULL);
3582 if (!(* node->klass->read_multi) (node, reader, seed, n_copies))
3588 static int n_iterations_completed_total = 0;
3589 static int n_iterations_completed_this_test = 0;
3590 static int n_iterations_expected_this_test = 0;
3594 const DBusString *signature;
3597 TestTypeNode **nodes;
3599 } NodeIterationData;
3602 run_test_copy (NodeIterationData *nid)
3607 DBusTypeReader reader;
3608 DBusTypeWriter writer;
3610 _dbus_verbose ("%s\n", _DBUS_FUNCTION_NAME);
3616 if (!data_block_init (&dest, src->byte_order, src->initial_offset))
3619 data_block_init_reader_writer (src, &reader, NULL);
3620 data_block_init_reader_writer (&dest, NULL, &writer);
3622 /* DBusTypeWriter assumes it's writing into an existing signature,
3623 * so doesn't add nul on its own. We have to do that.
3625 if (!_dbus_string_insert_byte (&dest.signature,
3626 dest.initial_offset, '\0'))
3629 if (!_dbus_type_writer_write_reader (&writer, &reader))
3632 /* Data blocks should now be identical */
3633 if (!_dbus_string_equal (&src->signature, &dest.signature))
3635 _dbus_verbose ("SOURCE\n");
3636 _dbus_verbose_bytes_of_string (&src->signature, 0,
3637 _dbus_string_get_length (&src->signature));
3638 _dbus_verbose ("DEST\n");
3639 _dbus_verbose_bytes_of_string (&dest.signature, 0,
3640 _dbus_string_get_length (&dest.signature));
3641 _dbus_assert_not_reached ("signatures did not match");
3644 if (!_dbus_string_equal (&src->body, &dest.body))
3646 _dbus_verbose ("SOURCE\n");
3647 _dbus_verbose_bytes_of_string (&src->body, 0,
3648 _dbus_string_get_length (&src->body));
3649 _dbus_verbose ("DEST\n");
3650 _dbus_verbose_bytes_of_string (&dest.body, 0,
3651 _dbus_string_get_length (&dest.body));
3652 _dbus_assert_not_reached ("bodies did not match");
3659 data_block_free (&dest);
3665 run_test_values_only_write (NodeIterationData *nid)
3667 DBusTypeReader reader;
3668 DBusTypeWriter writer;
3673 _dbus_verbose ("%s\n", _DBUS_FUNCTION_NAME);
3677 data_block_reset (nid->block);
3679 sig_len = _dbus_string_get_length (nid->signature);
3681 _dbus_type_writer_init_values_only (&writer,
3682 nid->block->byte_order,
3685 _dbus_string_get_length (&nid->block->body) - N_FENCE_BYTES);
3686 _dbus_type_reader_init (&reader,
3687 nid->block->byte_order,
3690 nid->block->initial_offset);
3693 while (i < nid->n_nodes)
3695 if (!node_write_value (nid->nodes[i], nid->block, &writer, i))
3701 /* if we wrote any typecodes then this would fail */
3702 _dbus_assert (sig_len == _dbus_string_get_length (nid->signature));
3704 /* But be sure we wrote out the values correctly */
3706 while (i < nid->n_nodes)
3708 if (!node_read_value (nid->nodes[i], &reader, i))
3711 if (i + 1 == nid->n_nodes)
3712 NEXT_EXPECTING_FALSE (&reader);
3714 NEXT_EXPECTING_TRUE (&reader);
3722 data_block_reset (nid->block);
3726 /* offset the seed for setting, so we set different numbers than
3727 * we originally wrote. Don't offset by a huge number since in
3728 * some cases it's value = possibilities[seed % n_possibilities]
3729 * and we don't want to wrap around. bool_from_seed
3730 * is just seed % 2 even.
3734 run_test_set_values (NodeIterationData *nid)
3736 DBusTypeReader reader;
3737 DBusTypeReader realign_root;
3741 _dbus_verbose ("%s\n", _DBUS_FUNCTION_NAME);
3745 data_block_init_reader_writer (nid->block,
3748 realign_root = reader;
3751 while (i < nid->n_nodes)
3753 if (!node_set_value (nid->nodes[i],
3754 &reader, &realign_root,
3758 if (i + 1 == nid->n_nodes)
3759 NEXT_EXPECTING_FALSE (&reader);
3761 NEXT_EXPECTING_TRUE (&reader);
3766 /* Check that the new values were set */
3768 reader = realign_root;
3771 while (i < nid->n_nodes)
3773 if (!node_read_value (nid->nodes[i], &reader,
3777 if (i + 1 == nid->n_nodes)
3778 NEXT_EXPECTING_FALSE (&reader);
3780 NEXT_EXPECTING_TRUE (&reader);
3792 run_test_delete_values (NodeIterationData *nid)
3794 DBusTypeReader reader;
3798 _dbus_verbose ("%s\n", _DBUS_FUNCTION_NAME);
3802 data_block_init_reader_writer (nid->block,
3805 while ((t = _dbus_type_reader_get_current_type (&reader)) != DBUS_TYPE_INVALID)
3807 /* Right now, deleting only works on array elements. We delete
3808 * all array elements, and then verify that there aren't any
3811 if (t == DBUS_TYPE_ARRAY)
3813 DBusTypeReader array;
3817 _dbus_type_reader_recurse (&reader, &array);
3819 while (_dbus_type_reader_get_current_type (&array) != DBUS_TYPE_INVALID)
3822 _dbus_type_reader_next (&array);
3825 /* reset to start of array */
3826 _dbus_type_reader_recurse (&reader, &array);
3827 _dbus_verbose ("recursing into deletion loop reader.value_pos = %d array.value_pos = %d array.u.start_pos = %d\n",
3828 reader.value_pos, array.value_pos, array.u.array.start_pos);
3829 while ((elem_type = _dbus_type_reader_get_current_type (&array)) != DBUS_TYPE_INVALID)
3831 /* We don't want to always delete from the same part of the array. */
3832 static int cycle = 0;
3835 _dbus_assert (n_elements > 0);
3838 if (elem == 3 || elem >= n_elements) /* end of array */
3839 elem = n_elements - 1;
3841 _dbus_verbose ("deleting array element %d of %d type %s cycle %d reader pos %d elem pos %d\n",
3842 elem, n_elements, _dbus_type_to_string (elem_type),
3843 cycle, reader.value_pos, array.value_pos);
3846 if (!_dbus_type_reader_next (&array))
3847 _dbus_assert_not_reached ("should have had another element\n");
3851 if (!_dbus_type_reader_delete (&array, &reader))
3857 _dbus_type_reader_recurse (&reader, &array);
3865 _dbus_type_reader_next (&reader);
3868 /* Check that there are no array elements left */
3869 data_block_init_reader_writer (nid->block,
3872 while ((t = _dbus_type_reader_get_current_type (&reader)) != DBUS_TYPE_INVALID)
3874 _dbus_type_reader_next (&reader);
3884 run_test_nodes_iteration (void *data)
3886 NodeIterationData *nid = data;
3887 DBusTypeReader reader;
3888 DBusTypeWriter writer;
3893 * 1. write the value
3894 * 2. strcmp-compare with the signature we built
3896 * 4. type-iterate the signature and the value and see if they are the same type-wise
3900 data_block_init_reader_writer (nid->block,
3903 /* DBusTypeWriter assumes it's writing into an existing signature,
3904 * so doesn't add nul on its own. We have to do that.
3906 if (!_dbus_string_insert_byte (&nid->block->signature,
3907 nid->type_offset, '\0'))
3911 while (i < nid->n_nodes)
3913 if (!node_write_value (nid->nodes[i], nid->block, &writer, i))
3919 if (!_dbus_string_equal_substring (nid->signature, 0, _dbus_string_get_length (nid->signature),
3920 &nid->block->signature, nid->type_offset))
3922 _dbus_warn ("Expected signature '%s' and got '%s' with initial offset %d\n",
3923 _dbus_string_get_const_data (nid->signature),
3924 _dbus_string_get_const_data_len (&nid->block->signature, nid->type_offset, 0),
3926 _dbus_assert_not_reached ("wrong signature");
3930 while (i < nid->n_nodes)
3932 if (!node_read_value (nid->nodes[i], &reader, i))
3935 if (i + 1 == nid->n_nodes)
3936 NEXT_EXPECTING_FALSE (&reader);
3938 NEXT_EXPECTING_TRUE (&reader);
3943 if (n_iterations_expected_this_test <= MAX_ITERATIONS_FOR_EXPENSIVE_TESTS)
3945 /* this set values test uses code from copy and
3946 * values_only_write so would ideally be last so you get a
3947 * simpler test case for problems with copying or values_only
3948 * writing; but it also needs an already-written DataBlock so it
3949 * has to go first. Comment it out if it breaks, and see if the
3950 * later tests also break - debug them first if so.
3952 if (!run_test_set_values (nid))
3955 if (!run_test_delete_values (nid))
3958 if (!run_test_copy (nid))
3961 if (!run_test_values_only_write (nid))
3965 /* FIXME type-iterate both signature and value and compare the resulting
3966 * tree to the node tree perhaps
3973 data_block_reset (nid->block);
3979 run_test_nodes_in_one_configuration (TestTypeNode **nodes,
3981 const DBusString *signature,
3986 NodeIterationData nid;
3988 if (!data_block_init (&block, byte_order, initial_offset))
3989 _dbus_assert_not_reached ("no memory");
3991 nid.signature = signature;
3993 nid.type_offset = initial_offset;
3995 nid.n_nodes = n_nodes;
3997 if (TEST_OOM_HANDLING &&
3998 n_iterations_expected_this_test <= MAX_ITERATIONS_FOR_EXPENSIVE_TESTS)
4000 _dbus_test_oom_handling ("running test node",
4001 run_test_nodes_iteration,
4006 if (!run_test_nodes_iteration (&nid))
4007 _dbus_assert_not_reached ("no memory");
4010 data_block_free (&block);
4014 run_test_nodes (TestTypeNode **nodes,
4018 DBusString signature;
4020 if (!_dbus_string_init (&signature))
4021 _dbus_assert_not_reached ("no memory");
4026 if (! node_build_signature (nodes[i], &signature))
4027 _dbus_assert_not_reached ("no memory");
4032 _dbus_verbose (">>> test nodes with signature '%s'\n",
4033 _dbus_string_get_const_data (&signature));
4036 while (i <= MAX_INITIAL_OFFSET)
4038 run_test_nodes_in_one_configuration (nodes, n_nodes, &signature,
4039 DBUS_LITTLE_ENDIAN, i);
4040 run_test_nodes_in_one_configuration (nodes, n_nodes, &signature,
4041 DBUS_BIG_ENDIAN, i);
4046 n_iterations_completed_this_test += 1;
4047 n_iterations_completed_total += 1;
4049 if (n_iterations_completed_this_test == n_iterations_expected_this_test)
4051 fprintf (stderr, " 100%% %d this test (%d cumulative)\n",
4052 n_iterations_completed_this_test,
4053 n_iterations_completed_total);
4055 /* this happens to turn out well with mod == 1 */
4056 else if ((n_iterations_completed_this_test %
4057 (int)(n_iterations_expected_this_test / 10.0)) == 1)
4059 fprintf (stderr, " %d%% ", (int) (n_iterations_completed_this_test / (double) n_iterations_expected_this_test * 100));
4062 _dbus_string_free (&signature);
4065 #define N_VALUES (N_BASICS * N_CONTAINERS + N_BASICS)
4067 static TestTypeNode*
4068 value_generator (int *ip)
4071 const TestTypeNodeClass *child_klass;
4072 const TestTypeNodeClass *container_klass;
4073 TestTypeNode *child;
4076 _dbus_assert (i <= N_VALUES);
4082 else if (i < N_BASICS)
4084 node = node_new (basic_nodes[i]);
4088 /* imagine an array:
4089 * container 0 of basic 0
4090 * container 0 of basic 1
4091 * container 0 of basic 2
4092 * container 1 of basic 0
4093 * container 1 of basic 1
4094 * container 1 of basic 2
4098 container_klass = container_nodes[i / N_BASICS];
4099 child_klass = basic_nodes[i % N_BASICS];
4101 node = node_new (container_klass);
4102 child = node_new (child_klass);
4104 node_append_child (node, child);
4107 *ip += 1; /* increment the generator */
4113 make_and_run_values_inside_container (const TestTypeNodeClass *container_klass,
4117 TestTypeNode *container;
4118 TestTypeNode *child;
4121 root = node_new (container_klass);
4123 for (i = 1; i < n_nested; i++)
4125 child = node_new (container_klass);
4126 node_append_child (container, child);
4130 /* container should now be the most-nested container */
4133 while ((child = value_generator (&i)))
4135 node_append_child (container, child);
4137 run_test_nodes (&root, 1);
4139 _dbus_list_clear (&((TestTypeNodeContainer*)container)->children);
4140 node_destroy (child);
4143 node_destroy (root);
4147 start_next_test (const char *format,
4150 n_iterations_completed_this_test = 0;
4151 n_iterations_expected_this_test = expected;
4153 fprintf (stderr, ">>> >>> ");
4154 fprintf (stderr, format,
4155 n_iterations_expected_this_test);
4159 make_and_run_test_nodes (void)
4163 /* We try to do this in order of "complicatedness" so that test
4164 * failures tend to show up in the simplest test case that
4165 * demonstrates the failure. There are also some tests that run
4166 * more than once for this reason, first while going through simple
4167 * cases, second while going through a broader range of complex
4170 /* Each basic node. The basic nodes should include:
4172 * - each fixed-size type (in such a way that it has different values each time,
4173 * so we can tell if we mix two of them up)
4174 * - strings of various lengths
4178 /* Each container node. The container nodes should include:
4180 * struct with 1 and 2 copies of the contained item
4181 * array with 0, 1, 2 copies of the contained item
4184 /* Let a "value" be a basic node, or a container containing a single basic node.
4185 * Let n_values be the number of such values i.e. (n_container * n_basic + n_basic)
4186 * When iterating through all values to make combinations, do the basic types
4187 * first and the containers second.
4189 /* Each item is shown with its number of iterations to complete so
4190 * we can keep a handle on this unit test
4193 /* FIXME test just an empty body, no types at all */
4195 start_next_test ("Each value by itself %d iterations\n", N_VALUES);
4199 while ((node = value_generator (&i)))
4201 run_test_nodes (&node, 1);
4203 node_destroy (node);
4207 start_next_test ("Each value by itself with arrays as blocks %d iterations\n", N_VALUES);
4208 arrays_write_fixed_in_blocks = TRUE;
4212 while ((node = value_generator (&i)))
4214 run_test_nodes (&node, 1);
4216 node_destroy (node);
4219 arrays_write_fixed_in_blocks = FALSE;
4221 start_next_test ("All values in one big toplevel %d iteration\n", 1);
4223 TestTypeNode *nodes[N_VALUES];
4226 while ((nodes[i] = value_generator (&i)))
4229 run_test_nodes (nodes, N_VALUES);
4231 for (i = 0; i < N_VALUES; i++)
4232 node_destroy (nodes[i]);
4235 start_next_test ("Each value,value pair combination as toplevel, in both orders %d iterations\n",
4236 N_VALUES * N_VALUES);
4238 TestTypeNode *nodes[2];
4241 while ((nodes[0] = value_generator (&i)))
4244 while ((nodes[1] = value_generator (&j)))
4246 run_test_nodes (nodes, 2);
4248 node_destroy (nodes[1]);
4251 node_destroy (nodes[0]);
4255 start_next_test ("Each container containing each value %d iterations\n",
4256 N_CONTAINERS * N_VALUES);
4257 for (i = 0; i < N_CONTAINERS; i++)
4259 const TestTypeNodeClass *container_klass = container_nodes[i];
4261 make_and_run_values_inside_container (container_klass, 1);
4264 start_next_test ("Each container containing each value with arrays as blocks %d iterations\n",
4265 N_CONTAINERS * N_VALUES);
4266 arrays_write_fixed_in_blocks = TRUE;
4267 for (i = 0; i < N_CONTAINERS; i++)
4269 const TestTypeNodeClass *container_klass = container_nodes[i];
4271 make_and_run_values_inside_container (container_klass, 1);
4273 arrays_write_fixed_in_blocks = FALSE;
4275 start_next_test ("Each container of same container of each value %d iterations\n",
4276 N_CONTAINERS * N_VALUES);
4277 for (i = 0; i < N_CONTAINERS; i++)
4279 const TestTypeNodeClass *container_klass = container_nodes[i];
4281 make_and_run_values_inside_container (container_klass, 2);
4284 start_next_test ("Each container of same container of same container of each value %d iterations\n",
4285 N_CONTAINERS * N_VALUES);
4286 for (i = 0; i < N_CONTAINERS; i++)
4288 const TestTypeNodeClass *container_klass = container_nodes[i];
4290 make_and_run_values_inside_container (container_klass, 3);
4293 start_next_test ("Each value,value pair inside a struct %d iterations\n",
4294 N_VALUES * N_VALUES);
4296 TestTypeNode *val1, *val2;
4299 node = node_new (&struct_1_class);
4302 while ((val1 = value_generator (&i)))
4305 while ((val2 = value_generator (&j)))
4307 TestTypeNodeContainer *container = (TestTypeNodeContainer*) node;
4309 node_append_child (node, val1);
4310 node_append_child (node, val2);
4312 run_test_nodes (&node, 1);
4314 _dbus_list_clear (&container->children);
4315 node_destroy (val2);
4317 node_destroy (val1);
4319 node_destroy (node);
4322 start_next_test ("All values in one big struct %d iteration\n",
4326 TestTypeNode *child;
4328 node = node_new (&struct_1_class);
4331 while ((child = value_generator (&i)))
4332 node_append_child (node, child);
4334 run_test_nodes (&node, 1);
4336 node_destroy (node);
4339 start_next_test ("Each value in a large array %d iterations\n",
4345 node = node_new (&array_9_class);
4348 while ((val = value_generator (&i)))
4350 TestTypeNodeContainer *container = (TestTypeNodeContainer*) node;
4352 node_append_child (node, val);
4354 run_test_nodes (&node, 1);
4356 _dbus_list_clear (&container->children);
4360 node_destroy (node);
4363 start_next_test ("Each container of each container of each value %d iterations\n",
4364 N_CONTAINERS * N_CONTAINERS * N_VALUES);
4365 for (i = 0; i < N_CONTAINERS; i++)
4367 const TestTypeNodeClass *outer_container_klass = container_nodes[i];
4368 TestTypeNode *outer_container = node_new (outer_container_klass);
4370 for (j = 0; j < N_CONTAINERS; j++)
4372 TestTypeNode *child;
4373 const TestTypeNodeClass *inner_container_klass = container_nodes[j];
4374 TestTypeNode *inner_container = node_new (inner_container_klass);
4376 node_append_child (outer_container, inner_container);
4379 while ((child = value_generator (&m)))
4381 node_append_child (inner_container, child);
4383 run_test_nodes (&outer_container, 1);
4385 _dbus_list_clear (&((TestTypeNodeContainer*)inner_container)->children);
4386 node_destroy (child);
4388 _dbus_list_clear (&((TestTypeNodeContainer*)outer_container)->children);
4389 node_destroy (inner_container);
4391 node_destroy (outer_container);
4394 start_next_test ("Each container of each container of each container of each value %d iterations\n",
4395 N_CONTAINERS * N_CONTAINERS * N_CONTAINERS * N_VALUES);
4396 for (i = 0; i < N_CONTAINERS; i++)
4398 const TestTypeNodeClass *outer_container_klass = container_nodes[i];
4399 TestTypeNode *outer_container = node_new (outer_container_klass);
4401 for (j = 0; j < N_CONTAINERS; j++)
4403 const TestTypeNodeClass *inner_container_klass = container_nodes[j];
4404 TestTypeNode *inner_container = node_new (inner_container_klass);
4406 node_append_child (outer_container, inner_container);
4408 for (k = 0; k < N_CONTAINERS; k++)
4410 TestTypeNode *child;
4411 const TestTypeNodeClass *center_container_klass = container_nodes[k];
4412 TestTypeNode *center_container = node_new (center_container_klass);
4414 node_append_child (inner_container, center_container);
4417 while ((child = value_generator (&m)))
4419 node_append_child (center_container, child);
4421 run_test_nodes (&outer_container, 1);
4423 _dbus_list_clear (&((TestTypeNodeContainer*)center_container)->children);
4424 node_destroy (child);
4426 _dbus_list_clear (&((TestTypeNodeContainer*)inner_container)->children);
4427 node_destroy (center_container);
4429 _dbus_list_clear (&((TestTypeNodeContainer*)outer_container)->children);
4430 node_destroy (inner_container);
4432 node_destroy (outer_container);
4436 /* This one takes a really long time, so comment it out for now */
4437 start_next_test ("Each value,value,value triplet combination as toplevel, in all orders %d iterations\n",
4438 N_VALUES * N_VALUES * N_VALUES);
4440 TestTypeNode *nodes[3];
4443 while ((nodes[0] = value_generator (&i)))
4446 while ((nodes[1] = value_generator (&j)))
4449 while ((nodes[2] = value_generator (&k)))
4451 run_test_nodes (nodes, 3);
4453 node_destroy (nodes[2]);
4455 node_destroy (nodes[1]);
4457 node_destroy (nodes[0]);
4460 #endif /* #if 0 expensive test */
4462 fprintf (stderr, "%d total iterations of recursive marshaling tests\n",
4463 n_iterations_completed_total);
4464 fprintf (stderr, "each iteration ran at initial offsets 0 through %d in both big and little endian\n",
4465 MAX_INITIAL_OFFSET);
4466 fprintf (stderr, "out of memory handling %s tested\n",
4467 TEST_OOM_HANDLING ? "was" : "was not");
4471 _dbus_marshal_recursive_test (void)
4473 make_and_run_test_nodes ();
4481 * Implementations of each type node class
4486 #define MAX_MULTI_COUNT 5
4489 #define SAMPLE_INT32 12345678
4490 #define SAMPLE_INT32_ALTERNATE 53781429
4492 int32_from_seed (int seed)
4494 /* Generate an integer value that's predictable from seed. We could
4495 * just use seed itself, but that would only ever touch one byte of
4496 * the int so would miss some kinds of bug.
4500 v = 42; /* just to quiet compiler afaik */
4507 v = SAMPLE_INT32_ALTERNATE;
4521 v *= seed; /* wraps around eventually, which is fine */
4527 int32_write_value (TestTypeNode *node,
4529 DBusTypeWriter *writer,
4532 /* also used for uint32 */
4535 v = int32_from_seed (seed);
4537 return _dbus_type_writer_write_basic (writer,
4538 node->klass->typecode,
4543 int32_read_value (TestTypeNode *node,
4544 DBusTypeReader *reader,
4547 /* also used for uint32 */
4550 check_expected_type (reader, node->klass->typecode);
4552 _dbus_type_reader_read_basic (reader,
4553 (dbus_int32_t*) &v);
4555 _dbus_assert (v == int32_from_seed (seed));
4561 int32_set_value (TestTypeNode *node,
4562 DBusTypeReader *reader,
4563 DBusTypeReader *realign_root,
4566 /* also used for uint32 */
4569 v = int32_from_seed (seed);
4571 return _dbus_type_reader_set_basic (reader,
4577 int32_write_multi (TestTypeNode *node,
4579 DBusTypeWriter *writer,
4583 /* also used for uint32 */
4584 dbus_int32_t values[MAX_MULTI_COUNT];
4585 dbus_int32_t *v_ARRAY_INT32 = values;
4588 for (i = 0; i < count; ++i)
4589 values[i] = int32_from_seed (seed + i);
4591 return _dbus_type_writer_write_fixed_multi (writer,
4592 node->klass->typecode,
4593 &v_ARRAY_INT32, count);
4597 int32_read_multi (TestTypeNode *node,
4598 DBusTypeReader *reader,
4602 /* also used for uint32 */
4603 dbus_int32_t *values;
4607 check_expected_type (reader, node->klass->typecode);
4609 _dbus_type_reader_read_fixed_multi (reader,
4613 if (n_elements != count)
4614 _dbus_warn ("got %d elements expected %d\n", n_elements, count);
4615 _dbus_assert (n_elements == count);
4617 for (i = 0; i < count; i++)
4618 _dbus_assert (_dbus_unpack_int32 (reader->byte_order,
4619 (const unsigned char*)values + (i * 4)) ==
4620 int32_from_seed (seed + i));
4625 #ifdef DBUS_HAVE_INT64
4627 int64_from_seed (int seed)
4632 v32 = int32_from_seed (seed);
4634 v = - (dbus_int32_t) ~ v32;
4635 v |= (((dbus_int64_t)v32) << 32);
4642 int64_write_value (TestTypeNode *node,
4644 DBusTypeWriter *writer,
4647 #ifdef DBUS_HAVE_INT64
4648 /* also used for uint64 */
4651 v = int64_from_seed (seed);
4653 return _dbus_type_writer_write_basic (writer,
4654 node->klass->typecode,
4662 int64_read_value (TestTypeNode *node,
4663 DBusTypeReader *reader,
4666 #ifdef DBUS_HAVE_INT64
4667 /* also used for uint64 */
4670 check_expected_type (reader, node->klass->typecode);
4672 _dbus_type_reader_read_basic (reader,
4673 (dbus_int64_t*) &v);
4675 _dbus_assert (v == int64_from_seed (seed));
4684 int64_set_value (TestTypeNode *node,
4685 DBusTypeReader *reader,
4686 DBusTypeReader *realign_root,
4689 #ifdef DBUS_HAVE_INT64
4690 /* also used for uint64 */
4693 v = int64_from_seed (seed);
4695 return _dbus_type_reader_set_basic (reader,
4703 #define MAX_SAMPLE_STRING_LEN 10
4705 string_from_seed (char *buf,
4712 _dbus_assert (len < MAX_SAMPLE_STRING_LEN);
4714 /* vary the length slightly, though we also have multiple string
4715 * value types for this, varying it here tests the set_value code
4729 v = (unsigned char) ('A' + seed);
4734 if (v < 'A' || v > 'z')
4747 string_write_value (TestTypeNode *node,
4749 DBusTypeWriter *writer,
4752 char buf[MAX_SAMPLE_STRING_LEN];
4753 const char *v_string = buf;
4755 string_from_seed (buf, node->klass->subclass_detail,
4758 return _dbus_type_writer_write_basic (writer,
4759 node->klass->typecode,
4764 string_read_value (TestTypeNode *node,
4765 DBusTypeReader *reader,
4769 char buf[MAX_SAMPLE_STRING_LEN];
4771 check_expected_type (reader, node->klass->typecode);
4773 _dbus_type_reader_read_basic (reader,
4774 (const char **) &v);
4776 string_from_seed (buf, node->klass->subclass_detail,
4779 if (strcmp (buf, v) != 0)
4781 _dbus_warn ("read string '%s' expected '%s'\n",
4783 _dbus_assert_not_reached ("test failed");
4790 string_set_value (TestTypeNode *node,
4791 DBusTypeReader *reader,
4792 DBusTypeReader *realign_root,
4795 char buf[MAX_SAMPLE_STRING_LEN];
4796 const char *v_string = buf;
4798 string_from_seed (buf, node->klass->subclass_detail,
4801 #if RECURSIVE_MARSHAL_WRITE_TRACE
4804 _dbus_type_reader_read_basic (reader, &old);
4805 _dbus_verbose ("SETTING new string '%s' len %d in place of '%s' len %d\n",
4806 v_string, strlen (v_string), old, strlen (old));
4810 return _dbus_type_reader_set_basic (reader,
4815 #define BOOL_FROM_SEED(seed) (seed % 2)
4818 bool_write_value (TestTypeNode *node,
4820 DBusTypeWriter *writer,
4825 v = BOOL_FROM_SEED (seed);
4827 return _dbus_type_writer_write_basic (writer,
4828 node->klass->typecode,
4833 bool_read_value (TestTypeNode *node,
4834 DBusTypeReader *reader,
4839 check_expected_type (reader, node->klass->typecode);
4841 _dbus_type_reader_read_basic (reader,
4842 (unsigned char*) &v);
4844 _dbus_assert (v == BOOL_FROM_SEED (seed));
4850 bool_set_value (TestTypeNode *node,
4851 DBusTypeReader *reader,
4852 DBusTypeReader *realign_root,
4857 v = BOOL_FROM_SEED (seed);
4859 return _dbus_type_reader_set_basic (reader,
4864 #define BYTE_FROM_SEED(seed) ((unsigned char) int32_from_seed (seed))
4867 byte_write_value (TestTypeNode *node,
4869 DBusTypeWriter *writer,
4874 v = BYTE_FROM_SEED (seed);
4876 return _dbus_type_writer_write_basic (writer,
4877 node->klass->typecode,
4882 byte_read_value (TestTypeNode *node,
4883 DBusTypeReader *reader,
4888 check_expected_type (reader, node->klass->typecode);
4890 _dbus_type_reader_read_basic (reader,
4891 (unsigned char*) &v);
4893 _dbus_assert (v == BYTE_FROM_SEED (seed));
4900 byte_set_value (TestTypeNode *node,
4901 DBusTypeReader *reader,
4902 DBusTypeReader *realign_root,
4907 v = BYTE_FROM_SEED (seed);
4909 return _dbus_type_reader_set_basic (reader,
4915 double_from_seed (int seed)
4917 return SAMPLE_INT32 * (double) seed + 0.3;
4921 double_write_value (TestTypeNode *node,
4923 DBusTypeWriter *writer,
4928 v = double_from_seed (seed);
4930 return _dbus_type_writer_write_basic (writer,
4931 node->klass->typecode,
4936 double_read_value (TestTypeNode *node,
4937 DBusTypeReader *reader,
4943 check_expected_type (reader, node->klass->typecode);
4945 _dbus_type_reader_read_basic (reader,
4948 expected = double_from_seed (seed);
4950 if (!_DBUS_DOUBLES_BITWISE_EQUAL (v, expected))
4952 #ifdef DBUS_HAVE_INT64
4953 _dbus_warn ("Expected double %g got %g\n bits = 0x%llx vs.\n bits = 0x%llx)\n",
4955 *(dbus_uint64_t*)(char*)&expected,
4956 *(dbus_uint64_t*)(char*)&v);
4958 _dbus_assert_not_reached ("test failed");
4965 double_set_value (TestTypeNode *node,
4966 DBusTypeReader *reader,
4967 DBusTypeReader *realign_root,
4972 v = double_from_seed (seed);
4974 return _dbus_type_reader_set_basic (reader,
4979 #define MAX_SAMPLE_OBJECT_PATH_LEN 10
4981 object_path_from_seed (char *buf,
4989 _dbus_assert (len < MAX_SAMPLE_OBJECT_PATH_LEN);
4991 v = (unsigned char) ('A' + seed);
4996 if (v < 'A' || v > 'z')
5011 object_path_write_value (TestTypeNode *node,
5013 DBusTypeWriter *writer,
5016 char buf[MAX_SAMPLE_OBJECT_PATH_LEN];
5017 const char *v_string = buf;
5019 object_path_from_seed (buf, seed);
5021 return _dbus_type_writer_write_basic (writer,
5022 node->klass->typecode,
5027 object_path_read_value (TestTypeNode *node,
5028 DBusTypeReader *reader,
5032 char buf[MAX_SAMPLE_OBJECT_PATH_LEN];
5034 check_expected_type (reader, node->klass->typecode);
5036 _dbus_type_reader_read_basic (reader,
5037 (const char **) &v);
5039 object_path_from_seed (buf, seed);
5041 if (strcmp (buf, v) != 0)
5043 _dbus_warn ("read object path '%s' expected '%s'\n",
5045 _dbus_assert_not_reached ("test failed");
5052 object_path_set_value (TestTypeNode *node,
5053 DBusTypeReader *reader,
5054 DBusTypeReader *realign_root,
5057 char buf[MAX_SAMPLE_OBJECT_PATH_LEN];
5058 const char *v_string = buf;
5060 object_path_from_seed (buf, seed);
5062 return _dbus_type_reader_set_basic (reader,
5067 #define MAX_SAMPLE_SIGNATURE_LEN 10
5069 signature_from_seed (char *buf,
5074 /* try to avoid ascending, descending, or alternating length to help find bugs */
5075 const char *sample_signatures[] = {
5084 s = sample_signatures[seed % _DBUS_N_ELEMENTS(sample_signatures)];
5086 for (i = 0; s[i]; i++)
5094 signature_write_value (TestTypeNode *node,
5096 DBusTypeWriter *writer,
5099 char buf[MAX_SAMPLE_SIGNATURE_LEN];
5100 const char *v_string = buf;
5102 signature_from_seed (buf, seed);
5104 return _dbus_type_writer_write_basic (writer,
5105 node->klass->typecode,
5110 signature_read_value (TestTypeNode *node,
5111 DBusTypeReader *reader,
5115 char buf[MAX_SAMPLE_SIGNATURE_LEN];
5117 check_expected_type (reader, node->klass->typecode);
5119 _dbus_type_reader_read_basic (reader,
5120 (const char **) &v);
5122 signature_from_seed (buf, seed);
5124 if (strcmp (buf, v) != 0)
5126 _dbus_warn ("read signature value '%s' expected '%s'\n",
5128 _dbus_assert_not_reached ("test failed");
5136 signature_set_value (TestTypeNode *node,
5137 DBusTypeReader *reader,
5138 DBusTypeReader *realign_root,
5141 char buf[MAX_SAMPLE_SIGNATURE_LEN];
5142 const char *v_string = buf;
5144 signature_from_seed (buf, seed);
5146 return _dbus_type_reader_set_basic (reader,
5152 struct_write_value (TestTypeNode *node,
5154 DBusTypeWriter *writer,
5157 TestTypeNodeContainer *container = (TestTypeNodeContainer*) node;
5158 DataBlockState saved;
5163 n_copies = node->klass->subclass_detail;
5165 _dbus_assert (container->children != NULL);
5167 data_block_save (block, &saved);
5169 if (!_dbus_type_writer_recurse (writer, DBUS_TYPE_STRUCT,
5175 while (i < n_copies)
5179 link = _dbus_list_get_first_link (&container->children);
5180 while (link != NULL)
5182 TestTypeNode *child = link->data;
5183 DBusList *next = _dbus_list_get_next_link (&container->children, link);
5185 if (!node_write_value (child, block, &sub, seed + i))
5187 data_block_restore (block, &saved);
5197 if (!_dbus_type_writer_unrecurse (writer, &sub))
5199 data_block_restore (block, &saved);
5207 struct_read_or_set_value (TestTypeNode *node,
5208 DBusTypeReader *reader,
5209 DBusTypeReader *realign_root,
5212 TestTypeNodeContainer *container = (TestTypeNodeContainer*) node;
5217 n_copies = node->klass->subclass_detail;
5219 check_expected_type (reader, DBUS_TYPE_STRUCT);
5221 _dbus_type_reader_recurse (reader, &sub);
5224 while (i < n_copies)
5228 link = _dbus_list_get_first_link (&container->children);
5229 while (link != NULL)
5231 TestTypeNode *child = link->data;
5232 DBusList *next = _dbus_list_get_next_link (&container->children, link);
5234 if (realign_root == NULL)
5236 if (!node_read_value (child, &sub, seed + i))
5241 if (!node_set_value (child, &sub, realign_root, seed + i))
5245 if (i == (n_copies - 1) && next == NULL)
5246 NEXT_EXPECTING_FALSE (&sub);
5248 NEXT_EXPECTING_TRUE (&sub);
5260 struct_read_value (TestTypeNode *node,
5261 DBusTypeReader *reader,
5264 return struct_read_or_set_value (node, reader, NULL, seed);
5268 struct_set_value (TestTypeNode *node,
5269 DBusTypeReader *reader,
5270 DBusTypeReader *realign_root,
5273 return struct_read_or_set_value (node, reader, realign_root, seed);
5277 struct_build_signature (TestTypeNode *node,
5280 TestTypeNodeContainer *container = (TestTypeNodeContainer*) node;
5285 n_copies = node->klass->subclass_detail;
5287 orig_len = _dbus_string_get_length (str);
5289 if (!_dbus_string_append_byte (str, DBUS_STRUCT_BEGIN_CHAR))
5293 while (i < n_copies)
5297 link = _dbus_list_get_first_link (&container->children);
5298 while (link != NULL)
5300 TestTypeNode *child = link->data;
5301 DBusList *next = _dbus_list_get_next_link (&container->children, link);
5303 if (!node_build_signature (child, str))
5312 if (!_dbus_string_append_byte (str, DBUS_STRUCT_END_CHAR))
5318 _dbus_string_set_length (str, orig_len);
5323 array_write_value (TestTypeNode *node,
5325 DBusTypeWriter *writer,
5328 TestTypeNodeContainer *container = (TestTypeNodeContainer*) node;
5329 DataBlockState saved;
5331 DBusString element_signature;
5335 TestTypeNode *child;
5337 n_copies = node->klass->subclass_detail;
5339 _dbus_assert (container->children != NULL);
5341 data_block_save (block, &saved);
5343 if (!_dbus_string_init (&element_signature))
5346 child = _dbus_list_get_first (&container->children);
5348 if (!node_build_signature (child,
5349 &element_signature))
5352 element_type = first_type_in_signature (&element_signature, 0);
5354 if (!_dbus_type_writer_recurse (writer, DBUS_TYPE_ARRAY,
5355 &element_signature, 0,
5359 if (arrays_write_fixed_in_blocks &&
5360 _dbus_type_is_fixed (element_type) &&
5361 child->klass->write_multi)
5363 if (!node_write_multi (child, block, &sub, seed, n_copies))
5369 while (i < n_copies)
5373 link = _dbus_list_get_first_link (&container->children);
5374 while (link != NULL)
5376 TestTypeNode *child = link->data;
5377 DBusList *next = _dbus_list_get_next_link (&container->children, link);
5379 if (!node_write_value (child, block, &sub, seed + i))
5389 if (!_dbus_type_writer_unrecurse (writer, &sub))
5392 _dbus_string_free (&element_signature);
5396 data_block_restore (block, &saved);
5397 _dbus_string_free (&element_signature);
5402 array_read_or_set_value (TestTypeNode *node,
5403 DBusTypeReader *reader,
5404 DBusTypeReader *realign_root,
5407 TestTypeNodeContainer *container = (TestTypeNodeContainer*) node;
5411 TestTypeNode *child;
5413 n_copies = node->klass->subclass_detail;
5415 check_expected_type (reader, DBUS_TYPE_ARRAY);
5417 child = _dbus_list_get_first (&container->children);
5421 _dbus_type_reader_recurse (reader, &sub);
5423 if (realign_root == NULL && arrays_write_fixed_in_blocks &&
5424 _dbus_type_is_fixed (_dbus_type_reader_get_element_type (reader)) &&
5425 child->klass->read_multi)
5427 if (!node_read_multi (child, &sub, seed, n_copies))
5433 while (i < n_copies)
5437 link = _dbus_list_get_first_link (&container->children);
5438 while (link != NULL)
5440 TestTypeNode *child = link->data;
5441 DBusList *next = _dbus_list_get_next_link (&container->children, link);
5443 _dbus_assert (child->klass->typecode ==
5444 _dbus_type_reader_get_element_type (reader));
5446 if (realign_root == NULL)
5448 if (!node_read_value (child, &sub, seed + i))
5453 if (!node_set_value (child, &sub, realign_root, seed + i))
5457 if (i == (n_copies - 1) && next == NULL)
5458 NEXT_EXPECTING_FALSE (&sub);
5460 NEXT_EXPECTING_TRUE (&sub);
5474 array_read_value (TestTypeNode *node,
5475 DBusTypeReader *reader,
5478 return array_read_or_set_value (node, reader, NULL, seed);
5482 array_set_value (TestTypeNode *node,
5483 DBusTypeReader *reader,
5484 DBusTypeReader *realign_root,
5487 return array_read_or_set_value (node, reader, realign_root, seed);
5491 array_build_signature (TestTypeNode *node,
5494 TestTypeNodeContainer *container = (TestTypeNodeContainer*) node;
5497 orig_len = _dbus_string_get_length (str);
5499 if (!_dbus_string_append_byte (str, DBUS_TYPE_ARRAY))
5502 if (!node_build_signature (_dbus_list_get_first (&container->children),
5509 _dbus_string_set_length (str, orig_len);
5513 /* 10 is random just to add another seed that we use in the suite */
5514 #define VARIANT_SEED 10
5517 variant_write_value (TestTypeNode *node,
5519 DBusTypeWriter *writer,
5522 TestTypeNodeContainer *container = (TestTypeNodeContainer*) node;
5523 DataBlockState saved;
5525 DBusString content_signature;
5526 TestTypeNode *child;
5528 _dbus_assert (container->children != NULL);
5529 _dbus_assert (_dbus_list_length_is_one (&container->children));
5531 child = _dbus_list_get_first (&container->children);
5533 data_block_save (block, &saved);
5535 if (!_dbus_string_init (&content_signature))
5538 if (!node_build_signature (child,
5539 &content_signature))
5542 if (!_dbus_type_writer_recurse (writer, DBUS_TYPE_VARIANT,
5543 &content_signature, 0,
5547 if (!node_write_value (child, block, &sub, seed + VARIANT_SEED))
5550 if (!_dbus_type_writer_unrecurse (writer, &sub))
5553 _dbus_string_free (&content_signature);
5557 data_block_restore (block, &saved);
5558 _dbus_string_free (&content_signature);
5563 variant_read_or_set_value (TestTypeNode *node,
5564 DBusTypeReader *reader,
5565 DBusTypeReader *realign_root,
5568 TestTypeNodeContainer *container = (TestTypeNodeContainer*) node;
5570 TestTypeNode *child;
5572 _dbus_assert (container->children != NULL);
5573 _dbus_assert (_dbus_list_length_is_one (&container->children));
5575 child = _dbus_list_get_first (&container->children);
5577 check_expected_type (reader, DBUS_TYPE_VARIANT);
5579 _dbus_type_reader_recurse (reader, &sub);
5581 if (realign_root == NULL)
5583 if (!node_read_value (child, &sub, seed + VARIANT_SEED))
5588 if (!node_set_value (child, &sub, realign_root, seed + VARIANT_SEED))
5592 NEXT_EXPECTING_FALSE (&sub);
5598 variant_read_value (TestTypeNode *node,
5599 DBusTypeReader *reader,
5602 return variant_read_or_set_value (node, reader, NULL, seed);
5606 variant_set_value (TestTypeNode *node,
5607 DBusTypeReader *reader,
5608 DBusTypeReader *realign_root,
5611 return variant_read_or_set_value (node, reader, realign_root, seed);
5615 container_destroy (TestTypeNode *node)
5617 TestTypeNodeContainer *container = (TestTypeNodeContainer*) node;
5620 link = _dbus_list_get_first_link (&container->children);
5621 while (link != NULL)
5623 TestTypeNode *child = link->data;
5624 DBusList *next = _dbus_list_get_next_link (&container->children, link);
5626 node_destroy (child);
5628 _dbus_list_free_link (link);
5634 #endif /* DBUS_BUILD_TESTS */