1 /* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
25 #include "dbus-marshal-recursive.h"
26 #include "dbus-marshal-basic.h"
27 #include "dbus-signature.h"
28 #include "dbus-internals.h"
31 * @addtogroup DBusMarshal
35 static dbus_bool_t _dbus_type_reader_greater_than (const DBusTypeReader *lhs,
36 const DBusTypeReader *rhs);
38 static void _dbus_type_writer_set_enabled (DBusTypeWriter *writer,
40 static dbus_bool_t _dbus_type_writer_write_reader_partial (DBusTypeWriter *writer,
41 DBusTypeReader *reader,
42 const DBusTypeReader *start_after,
43 int start_after_new_pos,
44 int start_after_new_len,
47 /** turn this on to get deluged in TypeReader verbose spam */
48 #define RECURSIVE_MARSHAL_READ_TRACE 0
50 /** turn this on to get deluged in TypeWriter verbose spam */
51 #define RECURSIVE_MARSHAL_WRITE_TRACE 0
54 free_fixups (DBusList **fixups)
58 link = _dbus_list_get_first_link (fixups);
63 next = _dbus_list_get_next_link (fixups, link);
65 dbus_free (link->data);
66 _dbus_list_free_link (link);
75 apply_and_free_fixups (DBusList **fixups,
76 DBusTypeReader *reader)
80 #if RECURSIVE_MARSHAL_WRITE_TRACE
82 _dbus_verbose (" %d FIXUPS to apply\n",
83 _dbus_list_get_length (fixups));
86 link = _dbus_list_get_first_link (fixups);
91 next = _dbus_list_get_next_link (fixups, link);
99 #if RECURSIVE_MARSHAL_WRITE_TRACE
100 _dbus_verbose (" applying FIXUP to reader %p at pos %d new_len = %d old len %d\n",
101 reader, f->len_pos_in_reader, f->new_len,
102 _dbus_marshal_read_uint32 (reader->value_str,
103 f->len_pos_in_reader,
104 reader->byte_order, NULL));
107 _dbus_marshal_set_uint32 ((DBusString*) reader->value_str,
108 f->len_pos_in_reader,
113 dbus_free (link->data);
114 _dbus_list_free_link (link);
123 * Virtual table for a type reader.
125 struct DBusTypeReaderClass
127 const char *name; /**< name for debugging */
128 int id; /**< index in all_reader_classes */
129 dbus_bool_t types_only; /**< only iterates over types, not values */
130 void (* recurse) (DBusTypeReader *sub,
131 DBusTypeReader *parent); /**< recurse with this reader as sub */
132 dbus_bool_t (* check_finished) (const DBusTypeReader *reader); /**< check whether reader is at the end */
133 void (* next) (DBusTypeReader *reader,
134 int current_type); /**< go to the next value */
138 element_type_get_alignment (const DBusString *str,
141 return _dbus_type_get_alignment (_dbus_first_type_in_signature (str, pos));
145 reader_init (DBusTypeReader *reader,
147 const DBusString *type_str,
149 const DBusString *value_str,
152 reader->byte_order = byte_order;
153 reader->finished = FALSE;
154 reader->type_str = type_str;
155 reader->type_pos = type_pos;
156 reader->value_str = value_str;
157 reader->value_pos = value_pos;
161 base_reader_recurse (DBusTypeReader *sub,
162 DBusTypeReader *parent)
164 /* point subreader at the same place as parent */
174 struct_or_dict_entry_types_only_reader_recurse (DBusTypeReader *sub,
175 DBusTypeReader *parent)
177 base_reader_recurse (sub, parent);
179 _dbus_assert (_dbus_string_get_byte (sub->type_str,
180 sub->type_pos) == DBUS_STRUCT_BEGIN_CHAR ||
181 _dbus_string_get_byte (sub->type_str,
182 sub->type_pos) == DBUS_DICT_ENTRY_BEGIN_CHAR);
188 struct_or_dict_entry_reader_recurse (DBusTypeReader *sub,
189 DBusTypeReader *parent)
191 struct_or_dict_entry_types_only_reader_recurse (sub, parent);
193 /* struct and dict entry have 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 (_dbus_first_type_in_signature (sub->type_str,
274 variant_reader_recurse (DBusTypeReader *sub,
275 DBusTypeReader *parent)
278 int contained_alignment;
280 base_reader_recurse (sub, parent);
282 /* Variant is 1 byte sig length (without nul), signature with nul,
283 * padding to 8-boundary, then values
286 sig_len = _dbus_string_get_byte (sub->value_str, sub->value_pos);
288 sub->type_str = sub->value_str;
289 sub->type_pos = sub->value_pos + 1;
291 sub->value_pos = sub->type_pos + sig_len + 1;
293 contained_alignment = _dbus_type_get_alignment (_dbus_first_type_in_signature (sub->type_str,
296 sub->value_pos = _DBUS_ALIGN_VALUE (sub->value_pos, contained_alignment);
298 #if RECURSIVE_MARSHAL_READ_TRACE
299 _dbus_verbose (" type reader %p variant containing '%s'\n",
301 _dbus_string_get_const_data_len (sub->type_str,
307 array_reader_check_finished (const DBusTypeReader *reader)
311 /* return the array element type if elements remain, and
312 * TYPE_INVALID otherwise
315 end_pos = reader->u.array.start_pos + array_reader_get_array_len (reader);
317 _dbus_assert (reader->value_pos <= end_pos);
318 _dbus_assert (reader->value_pos >= reader->u.array.start_pos);
320 return reader->value_pos == end_pos;
324 skip_one_complete_type (const DBusString *type_str,
327 _dbus_type_signature_next (_dbus_string_get_const_data (type_str),
332 * Skips to the next "complete" type inside a type signature.
333 * The signature is read starting at type_pos, and the next
334 * type position is stored in the same variable.
336 * @param type_str a type signature (must be valid)
337 * @param type_pos an integer position in the type signature (in and out)
340 _dbus_type_signature_next (const char *type_str,
343 const unsigned char *p;
344 const unsigned char *start;
346 _dbus_assert (type_str != NULL);
347 _dbus_assert (type_pos != NULL);
350 p = start + *type_pos;
352 _dbus_assert (*p != DBUS_STRUCT_END_CHAR);
353 _dbus_assert (*p != DBUS_DICT_ENTRY_END_CHAR);
355 while (*p == DBUS_TYPE_ARRAY)
358 _dbus_assert (*p != DBUS_STRUCT_END_CHAR);
359 _dbus_assert (*p != DBUS_DICT_ENTRY_END_CHAR);
361 if (*p == DBUS_STRUCT_BEGIN_CHAR)
369 _dbus_assert (*p != DBUS_TYPE_INVALID);
373 _dbus_assert (*p != DBUS_TYPE_INVALID);
375 if (*p == DBUS_STRUCT_BEGIN_CHAR)
377 else if (*p == DBUS_STRUCT_END_CHAR)
388 else if (*p == DBUS_DICT_ENTRY_BEGIN_CHAR)
396 _dbus_assert (*p != DBUS_TYPE_INVALID);
400 _dbus_assert (*p != DBUS_TYPE_INVALID);
402 if (*p == DBUS_DICT_ENTRY_BEGIN_CHAR)
404 else if (*p == DBUS_DICT_ENTRY_END_CHAR)
420 *type_pos = (int) (p - start);
424 find_len_of_complete_type (const DBusString *type_str,
431 skip_one_complete_type (type_str, &end);
433 return end - type_pos;
437 base_reader_next (DBusTypeReader *reader,
440 switch (current_type)
442 case DBUS_TYPE_DICT_ENTRY:
443 case DBUS_TYPE_STRUCT:
444 case DBUS_TYPE_VARIANT:
445 /* Scan forward over the entire container contents */
449 if (reader->klass->types_only && current_type == DBUS_TYPE_VARIANT)
453 /* Recurse into the struct or variant */
454 _dbus_type_reader_recurse (reader, &sub);
456 /* Skip everything in this subreader */
457 while (_dbus_type_reader_next (&sub))
462 if (!reader->klass->types_only)
463 reader->value_pos = sub.value_pos;
465 /* Now we are at the end of this container; for variants, the
466 * subreader's type_pos is totally inapplicable (it's in the
467 * value string) but we know that we increment by one past the
470 if (current_type == DBUS_TYPE_VARIANT)
471 reader->type_pos += 1;
473 reader->type_pos = sub.type_pos;
477 case DBUS_TYPE_ARRAY:
479 if (!reader->klass->types_only)
480 _dbus_marshal_skip_array (reader->value_str,
481 _dbus_first_type_in_signature (reader->type_str,
482 reader->type_pos + 1),
486 skip_one_complete_type (reader->type_str, &reader->type_pos);
491 if (!reader->klass->types_only)
492 _dbus_marshal_skip_basic (reader->value_str,
493 current_type, reader->byte_order,
496 reader->type_pos += 1;
502 struct_reader_next (DBusTypeReader *reader,
507 base_reader_next (reader, current_type);
509 /* for STRUCT containers we return FALSE at the end of the struct,
510 * for INVALID we return FALSE at the end of the signature.
511 * In both cases we arrange for get_current_type() to return INVALID
512 * which is defined to happen iff we're at the end (no more next())
514 t = _dbus_string_get_byte (reader->type_str, reader->type_pos);
515 if (t == DBUS_STRUCT_END_CHAR)
517 reader->type_pos += 1;
518 reader->finished = TRUE;
523 dict_entry_reader_next (DBusTypeReader *reader,
528 base_reader_next (reader, current_type);
530 /* for STRUCT containers we return FALSE at the end of the struct,
531 * for INVALID we return FALSE at the end of the signature.
532 * In both cases we arrange for get_current_type() to return INVALID
533 * which is defined to happen iff we're at the end (no more next())
535 t = _dbus_string_get_byte (reader->type_str, reader->type_pos);
536 if (t == DBUS_DICT_ENTRY_END_CHAR)
538 reader->type_pos += 1;
539 reader->finished = TRUE;
544 array_types_only_reader_next (DBusTypeReader *reader,
547 /* We have one "element" to be iterated over
548 * in each array, which is its element type.
549 * So the finished flag indicates whether we've
550 * iterated over it yet or not.
552 reader->finished = TRUE;
556 array_reader_next (DBusTypeReader *reader,
559 /* Skip one array element */
562 end_pos = reader->u.array.start_pos + array_reader_get_array_len (reader);
564 #if RECURSIVE_MARSHAL_READ_TRACE
565 _dbus_verbose (" reader %p array next START start_pos = %d end_pos = %d value_pos = %d current_type = %s\n",
567 reader->u.array.start_pos,
568 end_pos, reader->value_pos,
569 _dbus_type_to_string (current_type));
572 _dbus_assert (reader->value_pos < end_pos);
573 _dbus_assert (reader->value_pos >= reader->u.array.start_pos);
575 switch (_dbus_first_type_in_signature (reader->type_str,
578 case DBUS_TYPE_DICT_ENTRY:
579 case DBUS_TYPE_STRUCT:
580 case DBUS_TYPE_VARIANT:
584 /* Recurse into the struct or variant */
585 _dbus_type_reader_recurse (reader, &sub);
587 /* Skip everything in this element */
588 while (_dbus_type_reader_next (&sub))
593 /* Now we are at the end of this element */
594 reader->value_pos = sub.value_pos;
598 case DBUS_TYPE_ARRAY:
600 _dbus_marshal_skip_array (reader->value_str,
601 _dbus_first_type_in_signature (reader->type_str,
602 reader->type_pos + 1),
610 _dbus_marshal_skip_basic (reader->value_str,
611 current_type, reader->byte_order,
617 #if RECURSIVE_MARSHAL_READ_TRACE
618 _dbus_verbose (" reader %p array next END start_pos = %d end_pos = %d value_pos = %d current_type = %s\n",
620 reader->u.array.start_pos,
621 end_pos, reader->value_pos,
622 _dbus_type_to_string (current_type));
625 _dbus_assert (reader->value_pos <= end_pos);
627 if (reader->value_pos == end_pos)
629 skip_one_complete_type (reader->type_str,
634 static const DBusTypeReaderClass body_reader_class = {
637 NULL, /* body is always toplevel, so doesn't get recursed into */
642 static const DBusTypeReaderClass body_types_only_reader_class = {
645 NULL, /* body is always toplevel, so doesn't get recursed into */
650 static const DBusTypeReaderClass struct_reader_class = {
653 struct_or_dict_entry_reader_recurse,
658 static const DBusTypeReaderClass struct_types_only_reader_class = {
661 struct_or_dict_entry_types_only_reader_recurse,
666 static const DBusTypeReaderClass dict_entry_reader_class = {
669 struct_or_dict_entry_reader_recurse,
671 dict_entry_reader_next
674 static const DBusTypeReaderClass dict_entry_types_only_reader_class = {
675 "dict_entry types", 5,
677 struct_or_dict_entry_types_only_reader_recurse,
679 dict_entry_reader_next
682 static const DBusTypeReaderClass array_reader_class = {
685 array_reader_recurse,
686 array_reader_check_finished,
690 static const DBusTypeReaderClass array_types_only_reader_class = {
693 array_types_only_reader_recurse,
695 array_types_only_reader_next
698 static const DBusTypeReaderClass variant_reader_class = {
701 variant_reader_recurse,
706 #ifndef DBUS_DISABLE_ASSERT
707 static const DBusTypeReaderClass * const
708 all_reader_classes[] = {
710 &body_types_only_reader_class,
711 &struct_reader_class,
712 &struct_types_only_reader_class,
713 &dict_entry_reader_class,
714 &dict_entry_types_only_reader_class,
716 &array_types_only_reader_class,
717 &variant_reader_class
722 * Initializes a type reader.
724 * @param reader the reader
725 * @param byte_order the byte order of the block to read
726 * @param type_str the signature of the block to read
727 * @param type_pos location of signature
728 * @param value_str the string containing values block
729 * @param value_pos start of values block
732 _dbus_type_reader_init (DBusTypeReader *reader,
734 const DBusString *type_str,
736 const DBusString *value_str,
739 reader->klass = &body_reader_class;
741 reader_init (reader, byte_order, type_str, type_pos,
742 value_str, value_pos);
744 #if RECURSIVE_MARSHAL_READ_TRACE
745 _dbus_verbose (" type reader %p init type_pos = %d value_pos = %d remaining sig '%s'\n",
746 reader, reader->type_pos, reader->value_pos,
747 _dbus_string_get_const_data_len (reader->type_str, reader->type_pos, 0));
752 * Like _dbus_type_reader_init() but the iteration is over the
753 * signature, not over values.
755 * @param reader the reader
756 * @param type_str the signature string
757 * @param type_pos location in the signature string
760 _dbus_type_reader_init_types_only (DBusTypeReader *reader,
761 const DBusString *type_str,
764 reader->klass = &body_types_only_reader_class;
766 reader_init (reader, DBUS_COMPILER_BYTE_ORDER /* irrelevant */,
767 type_str, type_pos, NULL, _DBUS_INT_MAX /* crashes if we screw up */);
769 #if RECURSIVE_MARSHAL_READ_TRACE
770 _dbus_verbose (" type reader %p init types only type_pos = %d remaining sig '%s'\n",
771 reader, reader->type_pos,
772 _dbus_string_get_const_data_len (reader->type_str, reader->type_pos, 0));
777 * Gets the type of the value the reader is currently pointing to;
778 * or for a types-only reader gets the type it's currently pointing to.
779 * If the reader is at the end of a block or end of a container such
780 * as an array, returns #DBUS_TYPE_INVALID.
782 * @param reader the reader
785 _dbus_type_reader_get_current_type (const DBusTypeReader *reader)
789 if (reader->finished ||
790 (reader->klass->check_finished &&
791 (* reader->klass->check_finished) (reader)))
792 t = DBUS_TYPE_INVALID;
794 t = _dbus_first_type_in_signature (reader->type_str,
797 _dbus_assert (t != DBUS_STRUCT_END_CHAR);
798 _dbus_assert (t != DBUS_STRUCT_BEGIN_CHAR);
799 _dbus_assert (t != DBUS_DICT_ENTRY_END_CHAR);
800 _dbus_assert (t != DBUS_DICT_ENTRY_BEGIN_CHAR);
803 _dbus_verbose (" type reader %p current type_pos = %d type = %s\n",
804 reader, reader->type_pos,
805 _dbus_type_to_string (t));
812 * Gets the type of an element of the array the reader is currently
813 * pointing to. It's an error to call this if
814 * _dbus_type_reader_get_current_type() doesn't return #DBUS_TYPE_ARRAY
817 * @param reader the reader
820 _dbus_type_reader_get_element_type (const DBusTypeReader *reader)
824 _dbus_assert (_dbus_type_reader_get_current_type (reader) == DBUS_TYPE_ARRAY);
826 element_type = _dbus_first_type_in_signature (reader->type_str,
827 reader->type_pos + 1);
833 * Gets the current position in the value block
834 * @param reader the reader
837 _dbus_type_reader_get_value_pos (const DBusTypeReader *reader)
839 return reader->value_pos;
843 * Get the address of the marshaled value in the data being read. The
844 * address may not be aligned; you have to align it to the type of the
845 * value you want to read. Most of the demarshal routines do this for
848 * @param reader the reader
849 * @param value_location the address of the marshaled value
852 _dbus_type_reader_read_raw (const DBusTypeReader *reader,
853 const unsigned char **value_location)
855 _dbus_assert (!reader->klass->types_only);
857 *value_location = _dbus_string_get_const_data_len (reader->value_str,
863 * Reads a basic-typed value, as with _dbus_marshal_read_basic().
865 * @param reader the reader
866 * @param value the address of the value
869 _dbus_type_reader_read_basic (const DBusTypeReader *reader,
874 _dbus_assert (!reader->klass->types_only);
876 t = _dbus_type_reader_get_current_type (reader);
878 _dbus_marshal_read_basic (reader->value_str,
885 #if RECURSIVE_MARSHAL_READ_TRACE
886 _dbus_verbose (" type reader %p read basic type_pos = %d value_pos = %d remaining sig '%s'\n",
887 reader, reader->type_pos, reader->value_pos,
888 _dbus_string_get_const_data_len (reader->type_str, reader->type_pos, 0));
893 * Returns the number of bytes in the array.
895 * @param reader the reader to read from
896 * @returns the number of bytes in the array
899 _dbus_type_reader_get_array_length (const DBusTypeReader *reader)
901 _dbus_assert (!reader->klass->types_only);
902 _dbus_assert (reader->klass == &array_reader_class);
904 return array_reader_get_array_len (reader);
908 * Reads a block of fixed-length basic values, from the current point
909 * in an array to the end of the array. Does not work for arrays of
910 * string or container types.
912 * This function returns the array in-place; it does not make a copy,
913 * and it does not swap the bytes.
915 * If you ask for #DBUS_TYPE_DOUBLE you will get a "const double*" back
916 * and the "value" argument should be a "const double**" and so on.
918 * @param reader the reader to read from
919 * @param value place to return the array values
920 * @param n_elements place to return number of array elements
923 _dbus_type_reader_read_fixed_multi (const DBusTypeReader *reader,
933 _dbus_assert (!reader->klass->types_only);
934 _dbus_assert (reader->klass == &array_reader_class);
936 element_type = _dbus_first_type_in_signature (reader->type_str,
939 _dbus_assert (element_type != DBUS_TYPE_INVALID); /* why we don't use get_current_type() */
940 _dbus_assert (dbus_type_is_fixed (element_type));
942 alignment = _dbus_type_get_alignment (element_type);
944 _dbus_assert (reader->value_pos >= reader->u.array.start_pos);
946 total_len = array_reader_get_array_len (reader);
947 end_pos = reader->u.array.start_pos + total_len;
948 remaining_len = end_pos - reader->value_pos;
950 #if RECURSIVE_MARSHAL_READ_TRACE
951 _dbus_verbose ("end_pos %d total_len %d remaining_len %d value_pos %d\n",
952 end_pos, total_len, remaining_len, reader->value_pos);
955 _dbus_assert (remaining_len <= total_len);
957 if (remaining_len == 0)
958 *(const DBusBasicValue**) value = NULL;
960 *(const DBusBasicValue**) value =
961 (void*) _dbus_string_get_const_data_len (reader->value_str,
965 *n_elements = remaining_len / alignment;
966 _dbus_assert ((remaining_len % alignment) == 0);
968 #if RECURSIVE_MARSHAL_READ_TRACE
969 _dbus_verbose (" type reader %p read fixed array type_pos = %d value_pos = %d remaining sig '%s'\n",
970 reader, reader->type_pos, reader->value_pos,
971 _dbus_string_get_const_data_len (reader->type_str, reader->type_pos, 0));
976 * Initialize a new reader pointing to the first type and
977 * corresponding value that's a child of the current container. It's
978 * an error to call this if the current type is a non-container.
980 * Note that DBusTypeReader traverses values, not types. So if you
981 * have an empty array of array of int, you can't recurse into it. You
982 * can only recurse into each element.
984 * @param reader the reader
985 * @param sub a reader to init pointing to the first child
988 _dbus_type_reader_recurse (DBusTypeReader *reader,
993 t = _dbus_first_type_in_signature (reader->type_str, reader->type_pos);
997 case DBUS_TYPE_STRUCT:
998 if (reader->klass->types_only)
999 sub->klass = &struct_types_only_reader_class;
1001 sub->klass = &struct_reader_class;
1003 case DBUS_TYPE_DICT_ENTRY:
1004 if (reader->klass->types_only)
1005 sub->klass = &dict_entry_types_only_reader_class;
1007 sub->klass = &dict_entry_reader_class;
1009 case DBUS_TYPE_ARRAY:
1010 if (reader->klass->types_only)
1011 sub->klass = &array_types_only_reader_class;
1013 sub->klass = &array_reader_class;
1015 case DBUS_TYPE_VARIANT:
1016 if (reader->klass->types_only)
1017 _dbus_assert_not_reached ("can't recurse into variant typecode");
1019 sub->klass = &variant_reader_class;
1022 _dbus_verbose ("recursing into type %s\n", _dbus_type_to_string (t));
1023 #ifndef DBUS_DISABLE_CHECKS
1024 if (t == DBUS_TYPE_INVALID)
1025 _dbus_warn_check_failed ("You can't recurse into an empty array or off the end of a message body\n");
1026 #endif /* DBUS_DISABLE_CHECKS */
1028 _dbus_assert_not_reached ("don't yet handle recursing into this type");
1031 _dbus_assert (sub->klass == all_reader_classes[sub->klass->id]);
1033 (* sub->klass->recurse) (sub, reader);
1035 #if RECURSIVE_MARSHAL_READ_TRACE
1036 _dbus_verbose (" type reader %p RECURSED type_pos = %d value_pos = %d remaining sig '%s'\n",
1037 sub, sub->type_pos, sub->value_pos,
1038 _dbus_string_get_const_data_len (sub->type_str, sub->type_pos, 0));
1043 * Skip to the next value on this "level". e.g. the next field in a
1044 * struct, the next value in an array. Returns FALSE at the end of the
1045 * current container.
1047 * @param reader the reader
1048 * @returns FALSE if nothing more to read at or below this level
1051 _dbus_type_reader_next (DBusTypeReader *reader)
1055 t = _dbus_type_reader_get_current_type (reader);
1057 #if RECURSIVE_MARSHAL_READ_TRACE
1058 _dbus_verbose (" type reader %p START next() { type_pos = %d value_pos = %d remaining sig '%s' current_type = %s\n",
1059 reader, reader->type_pos, reader->value_pos,
1060 _dbus_string_get_const_data_len (reader->type_str, reader->type_pos, 0),
1061 _dbus_type_to_string (t));
1064 if (t == DBUS_TYPE_INVALID)
1067 (* reader->klass->next) (reader, t);
1069 #if RECURSIVE_MARSHAL_READ_TRACE
1070 _dbus_verbose (" type reader %p END next() type_pos = %d value_pos = %d remaining sig '%s' current_type = %s\n",
1071 reader, reader->type_pos, reader->value_pos,
1072 _dbus_string_get_const_data_len (reader->type_str, reader->type_pos, 0),
1073 _dbus_type_to_string (_dbus_type_reader_get_current_type (reader)));
1076 return _dbus_type_reader_get_current_type (reader) != DBUS_TYPE_INVALID;
1080 * Check whether there's another value on this "level". e.g. the next
1081 * field in a struct, the next value in an array. Returns FALSE at the
1082 * end of the current container.
1084 * You probably don't want to use this; it makes for an awkward for/while
1085 * loop. A nicer one is "while ((current_type = get_current_type()) != INVALID)"
1087 * @param reader the reader
1088 * @returns FALSE if nothing more to read at or below this level
1091 _dbus_type_reader_has_next (const DBusTypeReader *reader)
1093 /* Not efficient but works for now. */
1094 DBusTypeReader copy;
1097 return _dbus_type_reader_next (©);
1101 * Gets the string and range of said string containing the signature
1102 * of the current value. Essentially a more complete version of
1103 * _dbus_type_reader_get_current_type() (returns the full type
1104 * rather than only the outside of the onion).
1106 * Note though that the first byte in a struct signature is
1107 * #DBUS_STRUCT_BEGIN_CHAR while the current type will be
1108 * #DBUS_TYPE_STRUCT so it isn't true that the first byte of the
1109 * signature is always the same as the current type. Another
1110 * difference is that this function will still return a signature when
1111 * inside an empty array; say you recurse into empty array of int32,
1112 * the signature is "i" but the current type will always be
1113 * #DBUS_TYPE_INVALID since there are no elements to be currently
1116 * @param reader the reader
1117 * @param str_p place to return the string with the type in it
1118 * @param start_p place to return start of the type
1119 * @param len_p place to return the length of the type
1122 _dbus_type_reader_get_signature (const DBusTypeReader *reader,
1123 const DBusString **str_p,
1127 *str_p = reader->type_str;
1128 *start_p = reader->type_pos;
1129 *len_p = find_len_of_complete_type (reader->type_str, reader->type_pos);
1134 DBusString replacement; /**< Marshaled value including alignment padding */
1135 int padding; /**< How much of the replacement block is padding */
1139 replacement_block_init (ReplacementBlock *block,
1140 DBusTypeReader *reader)
1142 if (!_dbus_string_init (&block->replacement))
1145 /* % 8 is the padding to have the same align properties in
1146 * our replacement string as we do at the position being replaced
1148 block->padding = reader->value_pos % 8;
1150 if (!_dbus_string_lengthen (&block->replacement, block->padding))
1156 _dbus_string_free (&block->replacement);
1161 replacement_block_replace (ReplacementBlock *block,
1162 DBusTypeReader *reader,
1163 const DBusTypeReader *realign_root)
1165 DBusTypeWriter writer;
1166 DBusTypeReader realign_reader;
1170 _dbus_assert (realign_root != NULL);
1172 orig_len = _dbus_string_get_length (&block->replacement);
1174 realign_reader = *realign_root;
1176 #if RECURSIVE_MARSHAL_WRITE_TRACE
1177 _dbus_verbose ("INITIALIZING replacement block writer %p at value_pos %d\n",
1178 &writer, _dbus_string_get_length (&block->replacement));
1180 _dbus_type_writer_init_values_only (&writer,
1181 realign_reader.byte_order,
1182 realign_reader.type_str,
1183 realign_reader.type_pos,
1184 &block->replacement,
1185 _dbus_string_get_length (&block->replacement));
1187 _dbus_assert (realign_reader.value_pos <= reader->value_pos);
1189 #if RECURSIVE_MARSHAL_WRITE_TRACE
1190 _dbus_verbose ("COPYING from reader at value_pos %d to writer %p starting after value_pos %d\n",
1191 realign_reader.value_pos, &writer, reader->value_pos);
1194 if (!_dbus_type_writer_write_reader_partial (&writer,
1198 _dbus_string_get_length (&block->replacement) - block->padding,
1202 #if RECURSIVE_MARSHAL_WRITE_TRACE
1203 _dbus_verbose ("REPLACEMENT at padding %d len %d\n", block->padding,
1204 _dbus_string_get_length (&block->replacement) - block->padding);
1205 _dbus_verbose_bytes_of_string (&block->replacement, block->padding,
1206 _dbus_string_get_length (&block->replacement) - block->padding);
1207 _dbus_verbose ("TO BE REPLACED at value_pos = %d (align pad %d) len %d realign_reader.value_pos %d\n",
1208 reader->value_pos, reader->value_pos % 8,
1209 realign_reader.value_pos - reader->value_pos,
1210 realign_reader.value_pos);
1211 _dbus_verbose_bytes_of_string (reader->value_str,
1213 realign_reader.value_pos - reader->value_pos);
1216 /* Move the replacement into position
1217 * (realign_reader should now be at the end of the block to be replaced)
1219 if (!_dbus_string_replace_len (&block->replacement, block->padding,
1220 _dbus_string_get_length (&block->replacement) - block->padding,
1221 (DBusString*) reader->value_str,
1223 realign_reader.value_pos - reader->value_pos))
1226 /* Process our fixups now that we can't have an OOM error */
1227 apply_and_free_fixups (&fixups, reader);
1232 _dbus_string_set_length (&block->replacement, orig_len);
1233 free_fixups (&fixups);
1238 replacement_block_free (ReplacementBlock *block)
1240 _dbus_string_free (&block->replacement);
1243 /* In the variable-length case, we have to fix alignment after we insert.
1244 * The strategy is as follows:
1246 * - pad a new string to have the same alignment as the
1247 * start of the current basic value
1248 * - write the new basic value
1249 * - copy from the original reader to the new string,
1250 * which will fix the alignment of types following
1252 * - this copy has to start at realign_root,
1253 * but not really write anything until it
1254 * passes the value being set
1255 * - as an optimization, we can stop copying
1256 * when the source and dest values are both
1257 * on an 8-boundary, since we know all following
1258 * padding and alignment will be identical
1259 * - copy the new string back to the original
1260 * string, replacing the relevant part of the
1262 * - now any arrays in the original string that
1263 * contained the replaced string may have the
1264 * wrong length; so we have to fix that
1267 reader_set_basic_variable_length (DBusTypeReader *reader,
1270 const DBusTypeReader *realign_root)
1273 ReplacementBlock block;
1274 DBusTypeWriter writer;
1276 _dbus_assert (realign_root != NULL);
1280 if (!replacement_block_init (&block, reader))
1283 /* Write the new basic value */
1284 #if RECURSIVE_MARSHAL_WRITE_TRACE
1285 _dbus_verbose ("INITIALIZING writer %p to write basic value at value_pos %d of replacement string\n",
1286 &writer, _dbus_string_get_length (&block.replacement));
1288 _dbus_type_writer_init_values_only (&writer,
1293 _dbus_string_get_length (&block.replacement));
1294 #if RECURSIVE_MARSHAL_WRITE_TRACE
1295 _dbus_verbose ("WRITING basic value to writer %p (replacement string)\n", &writer);
1297 if (!_dbus_type_writer_write_basic (&writer, current_type, value))
1300 if (!replacement_block_replace (&block,
1308 replacement_block_free (&block);
1313 reader_set_basic_fixed_length (DBusTypeReader *reader,
1317 _dbus_marshal_set_basic ((DBusString*) reader->value_str,
1326 * Sets a new value for the basic type value pointed to by the reader,
1327 * leaving the reader valid to continue reading. Any other readers
1328 * will be invalidated if you set a variable-length type such as a
1331 * The provided realign_root is the reader to start from when
1332 * realigning the data that follows the newly-set value. The reader
1333 * parameter must point to a value below the realign_root parameter.
1334 * If the type being set is fixed-length, then realign_root may be
1335 * #NULL. Only values reachable from realign_root will be realigned,
1336 * so if your string contains other values you will need to deal with
1337 * those somehow yourself. It is OK if realign_root is the same
1338 * reader as the reader parameter, though if you aren't setting the
1339 * root it may not be such a good idea.
1341 * @todo DBusTypeReader currently takes "const" versions of the type
1342 * and value strings, and this function modifies those strings by
1343 * casting away the const, which is of course bad if we want to get
1344 * picky. (To be truly clean you'd have an object which contained the
1345 * type and value strings and set_basic would be a method on that
1346 * object... this would also make DBusTypeReader the same thing as
1347 * DBusTypeMark. But since DBusMessage is effectively that object for
1348 * D-Bus it doesn't seem worth creating some random object.)
1350 * @todo optimize this by only rewriting until the old and new values
1351 * are at the same alignment. Frequently this should result in only
1352 * replacing the value that's immediately at hand.
1354 * @param reader reader indicating where to set a new value
1355 * @param value address of the value to set
1356 * @param realign_root realign from here
1357 * @returns #FALSE if not enough memory
1360 _dbus_type_reader_set_basic (DBusTypeReader *reader,
1362 const DBusTypeReader *realign_root)
1366 _dbus_assert (!reader->klass->types_only);
1367 _dbus_assert (reader->value_str == realign_root->value_str);
1368 _dbus_assert (reader->value_pos >= realign_root->value_pos);
1370 current_type = _dbus_type_reader_get_current_type (reader);
1372 #if RECURSIVE_MARSHAL_WRITE_TRACE
1373 _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",
1374 reader, reader->type_pos, reader->value_pos,
1375 _dbus_string_get_const_data_len (reader->type_str, reader->type_pos, 0),
1377 realign_root ? realign_root->value_pos : -1,
1378 _dbus_type_to_string (current_type));
1379 _dbus_verbose_bytes_of_string (realign_root->value_str, realign_root->value_pos,
1380 _dbus_string_get_length (realign_root->value_str) -
1381 realign_root->value_pos);
1384 _dbus_assert (dbus_type_is_basic (current_type));
1386 if (dbus_type_is_fixed (current_type))
1388 reader_set_basic_fixed_length (reader, current_type, value);
1393 _dbus_assert (realign_root != NULL);
1394 return reader_set_basic_variable_length (reader, current_type,
1395 value, realign_root);
1400 * Recursively deletes any value pointed to by the reader, leaving the
1401 * reader valid to continue reading. Any other readers will be
1404 * The provided realign_root is the reader to start from when
1405 * realigning the data that follows the newly-set value.
1406 * See _dbus_type_reader_set_basic() for more details on the
1407 * realign_root paramter.
1409 * @todo for now this does not delete the typecodes associated with
1410 * the value, so this function should only be used for array elements.
1412 * @param reader reader indicating where to delete a value
1413 * @param realign_root realign from here
1414 * @returns #FALSE if not enough memory
1417 _dbus_type_reader_delete (DBusTypeReader *reader,
1418 const DBusTypeReader *realign_root)
1421 ReplacementBlock block;
1423 _dbus_assert (realign_root != NULL);
1424 _dbus_assert (reader->klass == &array_reader_class);
1428 if (!replacement_block_init (&block, reader))
1431 if (!replacement_block_replace (&block,
1439 replacement_block_free (&block);
1444 * Compares two readers, which must be iterating over the same value data.
1445 * Returns #TRUE if the first parameter is further along than the second parameter.
1447 * @param lhs left-hand-side (first) parameter
1448 * @param rhs left-hand-side (first) parameter
1449 * @returns whether lhs is greater than rhs
1452 _dbus_type_reader_greater_than (const DBusTypeReader *lhs,
1453 const DBusTypeReader *rhs)
1455 _dbus_assert (lhs->value_str == rhs->value_str);
1457 return lhs->value_pos > rhs->value_pos;
1470 * Initialize a write iterator, which is used to write out values in
1471 * serialized D-Bus format.
1473 * The type_pos passed in is expected to be inside an already-valid,
1474 * though potentially empty, type signature. This means that the byte
1475 * after type_pos must be either #DBUS_TYPE_INVALID (aka nul) or some
1476 * other valid type. #DBusTypeWriter won't enforce that the signature
1477 * is already valid (you can append the nul byte at the end if you
1478 * like), but just be aware that you need the nul byte eventually and
1479 * #DBusTypeWriter isn't going to write it for you.
1481 * @param writer the writer to init
1482 * @param byte_order the byte order to marshal into
1483 * @param type_str the string to write typecodes into
1484 * @param type_pos where to insert typecodes
1485 * @param value_str the string to write values into
1486 * @param value_pos where to insert values
1490 _dbus_type_writer_init (DBusTypeWriter *writer,
1492 DBusString *type_str,
1494 DBusString *value_str,
1497 writer->byte_order = byte_order;
1498 writer->type_str = type_str;
1499 writer->type_pos = type_pos;
1500 writer->value_str = value_str;
1501 writer->value_pos = value_pos;
1502 writer->container_type = DBUS_TYPE_INVALID;
1503 writer->type_pos_is_expectation = FALSE;
1504 writer->enabled = TRUE;
1506 #if RECURSIVE_MARSHAL_WRITE_TRACE
1507 _dbus_verbose ("writer %p init remaining sig '%s'\n", writer,
1509 _dbus_string_get_const_data_len (writer->type_str, writer->type_pos, 0) :
1515 * Initialize a write iterator, with the signature to be provided
1518 * @param writer the writer to init
1519 * @param byte_order the byte order to marshal into
1520 * @param value_str the string to write values into
1521 * @param value_pos where to insert values
1525 _dbus_type_writer_init_types_delayed (DBusTypeWriter *writer,
1527 DBusString *value_str,
1530 _dbus_type_writer_init (writer, byte_order,
1531 NULL, 0, value_str, value_pos);
1535 * Adds type string to the writer, if it had none.
1537 * @param writer the writer to init
1538 * @param type_str type string to add
1539 * @param type_pos type position
1543 _dbus_type_writer_add_types (DBusTypeWriter *writer,
1544 DBusString *type_str,
1547 if (writer->type_str == NULL) /* keeps us from using this as setter */
1549 writer->type_str = type_str;
1550 writer->type_pos = type_pos;
1555 * Removes type string from the writer.
1557 * @param writer the writer to remove from
1560 _dbus_type_writer_remove_types (DBusTypeWriter *writer)
1562 writer->type_str = NULL;
1563 writer->type_pos = -1;
1567 * Like _dbus_type_writer_init(), except the type string
1568 * passed in should correspond to an existing signature that
1569 * matches what you're going to write out. The writer will
1570 * check what you write vs. this existing signature.
1572 * @param writer the writer to init
1573 * @param byte_order the byte order to marshal into
1574 * @param type_str the string with signature
1575 * @param type_pos start of signature
1576 * @param value_str the string to write values into
1577 * @param value_pos where to insert values
1581 _dbus_type_writer_init_values_only (DBusTypeWriter *writer,
1583 const DBusString *type_str,
1585 DBusString *value_str,
1588 _dbus_type_writer_init (writer, byte_order,
1589 (DBusString*)type_str, type_pos,
1590 value_str, value_pos);
1592 writer->type_pos_is_expectation = TRUE;
1596 _dbus_type_writer_write_basic_no_typecode (DBusTypeWriter *writer,
1600 if (writer->enabled)
1601 return _dbus_marshal_write_basic (writer->value_str,
1606 &writer->value_pos);
1611 /* If our parent is an array, things are a little bit complicated.
1613 * The parent must have a complete element type, such as
1614 * "i" or "aai" or "(ii)" or "a(ii)". There can't be
1615 * unclosed parens, or an "a" with no following type.
1617 * To recurse, the only allowed operation is to recurse into the
1618 * first type in the element type. So for "i" you can't recurse, for
1619 * "ai" you can recurse into the array, for "(ii)" you can recurse
1622 * If you recurse into the array for "ai", then you must specify
1623 * "i" for the element type of the array you recurse into.
1625 * While inside an array at any level, we need to avoid writing to
1626 * type_str, since the type only appears once for the whole array,
1627 * it does not appear for each array element.
1629 * While inside an array type_pos points to the expected next
1630 * typecode, rather than the next place we could write a typecode.
1633 writer_recurse_init_and_check (DBusTypeWriter *writer,
1635 DBusTypeWriter *sub)
1637 _dbus_type_writer_init (sub,
1644 sub->container_type = container_type;
1646 if (writer->type_pos_is_expectation ||
1647 (sub->container_type == DBUS_TYPE_ARRAY || sub->container_type == DBUS_TYPE_VARIANT))
1648 sub->type_pos_is_expectation = TRUE;
1650 sub->type_pos_is_expectation = FALSE;
1652 sub->enabled = writer->enabled;
1654 #ifndef DBUS_DISABLE_CHECKS
1655 if (writer->type_pos_is_expectation && writer->type_str)
1659 expected = _dbus_first_type_in_signature (writer->type_str, writer->type_pos);
1661 if (expected != sub->container_type)
1663 if (expected != DBUS_TYPE_INVALID)
1664 _dbus_warn_check_failed ("Writing an element of type %s, but the expected type here is %s\n"
1665 "The overall signature expected here was '%s' and we are on byte %d of that signature.\n",
1666 _dbus_type_to_string (sub->container_type),
1667 _dbus_type_to_string (expected),
1668 _dbus_string_get_const_data (writer->type_str), writer->type_pos);
1670 _dbus_warn_check_failed ("Writing an element of type %s, but no value is expected here\n"
1671 "The overall signature expected here was '%s' and we are on byte %d of that signature.\n",
1672 _dbus_type_to_string (sub->container_type),
1673 _dbus_string_get_const_data (writer->type_str), writer->type_pos);
1675 _dbus_assert_not_reached ("bad array element or variant content written");
1678 #endif /* DBUS_DISABLE_CHECKS */
1680 #if RECURSIVE_MARSHAL_WRITE_TRACE
1681 _dbus_verbose (" type writer %p recurse parent %s type_pos = %d value_pos = %d is_expectation = %d remaining sig '%s' enabled = %d\n",
1683 _dbus_type_to_string (writer->container_type),
1684 writer->type_pos, writer->value_pos, writer->type_pos_is_expectation,
1686 _dbus_string_get_const_data_len (writer->type_str, writer->type_pos, 0) :
1689 _dbus_verbose (" type writer %p recurse sub %s type_pos = %d value_pos = %d is_expectation = %d enabled = %d\n",
1691 _dbus_type_to_string (sub->container_type),
1692 sub->type_pos, sub->value_pos,
1693 sub->type_pos_is_expectation,
1699 write_or_verify_typecode (DBusTypeWriter *writer,
1702 /* A subwriter inside an array or variant will have type_pos
1703 * pointing to the expected typecode; a writer not inside an array
1704 * or variant has type_pos pointing to the next place to insert a
1707 #if RECURSIVE_MARSHAL_WRITE_TRACE
1708 _dbus_verbose (" type writer %p write_or_verify start type_pos = %d remaining sig '%s' enabled = %d\n",
1709 writer, writer->type_pos,
1711 _dbus_string_get_const_data_len (writer->type_str, writer->type_pos, 0) :
1716 if (writer->type_str == NULL)
1719 if (writer->type_pos_is_expectation)
1721 #ifndef DBUS_DISABLE_CHECKS
1725 expected = _dbus_string_get_byte (writer->type_str, writer->type_pos);
1727 if (expected != typecode)
1729 if (expected != DBUS_TYPE_INVALID)
1730 _dbus_warn_check_failed ("Array or variant type requires that type %s be written, but %s was written.\n"
1731 "The overall signature expected here was '%s' and we are on byte %d of that signature.\n",
1732 _dbus_type_to_string (expected), _dbus_type_to_string (typecode),
1733 _dbus_string_get_const_data (writer->type_str), writer->type_pos);
1735 _dbus_warn_check_failed ("Array or variant type wasn't expecting any more values to be written into it, but a value %s was written.\n"
1736 "The overall signature expected here was '%s' and we are on byte %d of that signature.\n",
1737 _dbus_type_to_string (typecode),
1738 _dbus_string_get_const_data (writer->type_str), writer->type_pos);
1739 _dbus_assert_not_reached ("bad type inserted somewhere inside an array or variant");
1742 #endif /* DBUS_DISABLE_CHECKS */
1744 /* if immediately inside an array we'd always be appending an element,
1745 * so the expected type doesn't change; if inside a struct or something
1746 * below an array, we need to move through said struct or something.
1748 if (writer->container_type != DBUS_TYPE_ARRAY)
1749 writer->type_pos += 1;
1753 if (!_dbus_string_insert_byte (writer->type_str,
1758 writer->type_pos += 1;
1761 #if RECURSIVE_MARSHAL_WRITE_TRACE
1762 _dbus_verbose (" type writer %p write_or_verify end type_pos = %d remaining sig '%s'\n",
1763 writer, writer->type_pos,
1764 _dbus_string_get_const_data_len (writer->type_str, writer->type_pos, 0));
1771 writer_recurse_struct_or_dict_entry (DBusTypeWriter *writer,
1773 const DBusString *contained_type,
1774 int contained_type_start,
1775 int contained_type_len,
1776 DBusTypeWriter *sub)
1778 /* FIXME right now contained_type is ignored; we could probably
1779 * almost trivially fix the code so if it's present we
1780 * write it out and then set type_pos_is_expectation
1783 /* Ensure that we'll be able to add alignment padding and the typecode */
1784 if (writer->enabled)
1786 if (!_dbus_string_alloc_space (sub->value_str, 8))
1790 if (!write_or_verify_typecode (sub, begin_char))
1791 _dbus_assert_not_reached ("failed to insert struct typecode after prealloc");
1793 if (writer->enabled)
1795 if (!_dbus_string_insert_bytes (sub->value_str,
1797 _DBUS_ALIGN_VALUE (sub->value_pos, 8) - sub->value_pos,
1799 _dbus_assert_not_reached ("should not have failed to insert alignment padding for struct");
1800 sub->value_pos = _DBUS_ALIGN_VALUE (sub->value_pos, 8);
1808 writer_recurse_array (DBusTypeWriter *writer,
1809 const DBusString *contained_type,
1810 int contained_type_start,
1811 int contained_type_len,
1812 DBusTypeWriter *sub,
1813 dbus_bool_t is_array_append)
1815 dbus_uint32_t value = 0;
1819 #ifndef DBUS_DISABLE_CHECKS
1820 if (writer->container_type == DBUS_TYPE_ARRAY &&
1823 if (!_dbus_string_equal_substring (contained_type,
1824 contained_type_start,
1827 writer->u.array.element_type_pos + 1))
1829 _dbus_warn_check_failed ("Writing an array of '%s' but this is incompatible with the expected type of elements in the parent array\n",
1830 _dbus_string_get_const_data_len (contained_type,
1831 contained_type_start,
1832 contained_type_len));
1833 _dbus_assert_not_reached ("incompatible type for child array");
1836 #endif /* DBUS_DISABLE_CHECKS */
1838 if (writer->enabled && !is_array_append)
1840 /* 3 pad + 4 bytes for the array length, and 4 bytes possible padding
1841 * before array values
1843 if (!_dbus_string_alloc_space (sub->value_str, 3 + 4 + 4))
1847 if (writer->type_str != NULL)
1849 sub->type_pos += 1; /* move to point to the element type, since type_pos
1850 * should be the expected type for further writes
1852 sub->u.array.element_type_pos = sub->type_pos;
1855 if (!writer->type_pos_is_expectation)
1857 /* sub is a toplevel/outermost array so we need to write the type data */
1859 /* alloc space for array typecode, element signature */
1860 if (!_dbus_string_alloc_space (writer->type_str, 1 + contained_type_len))
1863 if (!_dbus_string_insert_byte (writer->type_str,
1866 _dbus_assert_not_reached ("failed to insert array typecode after prealloc");
1868 if (!_dbus_string_copy_len (contained_type,
1869 contained_type_start, contained_type_len,
1871 sub->u.array.element_type_pos))
1872 _dbus_assert_not_reached ("should not have failed to insert array element typecodes");
1875 if (writer->type_str != NULL)
1877 /* If the parent is an array, we hold type_pos pointing at the array element type;
1878 * otherwise advance it to reflect the array value we just recursed into
1880 if (writer->container_type != DBUS_TYPE_ARRAY)
1881 writer->type_pos += 1 + contained_type_len;
1883 _dbus_assert (writer->type_pos_is_expectation); /* because it's an array */
1886 if (writer->enabled)
1888 /* Write (or jump over, if is_array_append) the length */
1889 sub->u.array.len_pos = _DBUS_ALIGN_VALUE (sub->value_pos, 4);
1891 if (is_array_append)
1893 sub->value_pos += 4;
1897 if (!_dbus_type_writer_write_basic_no_typecode (sub, DBUS_TYPE_UINT32,
1899 _dbus_assert_not_reached ("should not have failed to insert array len");
1902 _dbus_assert (sub->u.array.len_pos == sub->value_pos - 4);
1904 /* Write alignment padding for array elements
1905 * Note that we write the padding *even for empty arrays*
1906 * to avoid wonky special cases
1908 alignment = element_type_get_alignment (contained_type, contained_type_start);
1910 aligned = _DBUS_ALIGN_VALUE (sub->value_pos, alignment);
1911 if (aligned != sub->value_pos)
1913 if (!is_array_append)
1915 if (!_dbus_string_insert_bytes (sub->value_str,
1917 aligned - sub->value_pos,
1919 _dbus_assert_not_reached ("should not have failed to insert alignment padding");
1922 sub->value_pos = aligned;
1925 sub->u.array.start_pos = sub->value_pos;
1927 if (is_array_append)
1931 _dbus_assert (_DBUS_ALIGN_VALUE (sub->u.array.len_pos, 4) ==
1932 (unsigned) sub->u.array.len_pos);
1933 len = _dbus_unpack_uint32 (sub->byte_order,
1934 _dbus_string_get_const_data_len (sub->value_str,
1935 sub->u.array.len_pos,
1938 sub->value_pos += len;
1943 /* not enabled, so we won't write the len_pos; set it to -1 to so indicate */
1944 sub->u.array.len_pos = -1;
1945 sub->u.array.start_pos = sub->value_pos;
1948 _dbus_assert (sub->u.array.len_pos < sub->u.array.start_pos);
1949 _dbus_assert (is_array_append || sub->u.array.start_pos == sub->value_pos);
1951 #if RECURSIVE_MARSHAL_WRITE_TRACE
1952 _dbus_verbose (" type writer %p recurse array done remaining sig '%s' array start_pos = %d len_pos = %d value_pos = %d\n", sub,
1954 _dbus_string_get_const_data_len (sub->type_str, sub->type_pos, 0) :
1956 sub->u.array.start_pos, sub->u.array.len_pos, sub->value_pos);
1962 /* Variant value will normally have:
1963 * 1 byte signature length not including nul
1964 * signature typecodes (nul terminated)
1965 * padding to alignment of contained type
1966 * body according to signature
1968 * The signature string can only have a single type
1969 * in it but that type may be complex/recursive.
1971 * So a typical variant type with the integer 3 will have these
1973 * 0x1 'i' '\0' [1 byte padding to alignment boundary] 0x0 0x0 0x0 0x3
1975 * The main world of hurt for writing out a variant is that the type
1976 * string is the same string as the value string. Which means
1977 * inserting to the type string will move the value_pos; and it means
1978 * that inserting to the type string could break type alignment.
1981 writer_recurse_variant (DBusTypeWriter *writer,
1982 const DBusString *contained_type,
1983 int contained_type_start,
1984 int contained_type_len,
1985 DBusTypeWriter *sub)
1987 int contained_alignment;
1989 if (writer->enabled)
1991 /* Allocate space for the worst case, which is 1 byte sig
1992 * length, nul byte at end of sig, and 7 bytes padding to
1995 if (!_dbus_string_alloc_space (sub->value_str, contained_type_len + 9))
1999 /* write VARIANT typecode to the parent's type string */
2000 if (!write_or_verify_typecode (writer, DBUS_TYPE_VARIANT))
2003 /* If not enabled, mark that we have no type_str anymore ... */
2005 if (!writer->enabled)
2007 sub->type_str = NULL;
2013 /* If we're enabled then continue ... */
2015 if (!_dbus_string_insert_byte (sub->value_str,
2017 contained_type_len))
2018 _dbus_assert_not_reached ("should not have failed to insert variant type sig len");
2020 sub->value_pos += 1;
2022 /* Here we switch over to the expected type sig we're about to write */
2023 sub->type_str = sub->value_str;
2024 sub->type_pos = sub->value_pos;
2026 if (!_dbus_string_copy_len (contained_type, contained_type_start, contained_type_len,
2027 sub->value_str, sub->value_pos))
2028 _dbus_assert_not_reached ("should not have failed to insert variant type sig");
2030 sub->value_pos += contained_type_len;
2032 if (!_dbus_string_insert_byte (sub->value_str,
2035 _dbus_assert_not_reached ("should not have failed to insert variant type nul termination");
2037 sub->value_pos += 1;
2039 contained_alignment = _dbus_type_get_alignment (_dbus_first_type_in_signature (contained_type, contained_type_start));
2041 if (!_dbus_string_insert_bytes (sub->value_str,
2043 _DBUS_ALIGN_VALUE (sub->value_pos, contained_alignment) - sub->value_pos,
2045 _dbus_assert_not_reached ("should not have failed to insert alignment padding for variant body");
2046 sub->value_pos = _DBUS_ALIGN_VALUE (sub->value_pos, contained_alignment);
2052 _dbus_type_writer_recurse_contained_len (DBusTypeWriter *writer,
2054 const DBusString *contained_type,
2055 int contained_type_start,
2056 int contained_type_len,
2057 DBusTypeWriter *sub,
2058 dbus_bool_t is_array_append)
2060 writer_recurse_init_and_check (writer, container_type, sub);
2062 switch (container_type)
2064 case DBUS_TYPE_STRUCT:
2065 return writer_recurse_struct_or_dict_entry (writer,
2066 DBUS_STRUCT_BEGIN_CHAR,
2068 contained_type_start, contained_type_len,
2071 case DBUS_TYPE_DICT_ENTRY:
2072 return writer_recurse_struct_or_dict_entry (writer,
2073 DBUS_DICT_ENTRY_BEGIN_CHAR,
2075 contained_type_start, contained_type_len,
2078 case DBUS_TYPE_ARRAY:
2079 return writer_recurse_array (writer,
2080 contained_type, contained_type_start, contained_type_len,
2081 sub, is_array_append);
2083 case DBUS_TYPE_VARIANT:
2084 return writer_recurse_variant (writer,
2085 contained_type, contained_type_start, contained_type_len,
2089 _dbus_assert_not_reached ("tried to recurse into type that doesn't support that");
2096 * Opens a new container and writes out the initial information for that container.
2098 * @param writer the writer
2099 * @param container_type the type of the container to open
2100 * @param contained_type the array element type or variant content type
2101 * @param contained_type_start position to look for the type
2102 * @param sub the new sub-writer to write container contents
2103 * @returns #FALSE if no memory
2106 _dbus_type_writer_recurse (DBusTypeWriter *writer,
2108 const DBusString *contained_type,
2109 int contained_type_start,
2110 DBusTypeWriter *sub)
2112 int contained_type_len;
2115 contained_type_len = find_len_of_complete_type (contained_type, contained_type_start);
2117 contained_type_len = 0;
2119 return _dbus_type_writer_recurse_contained_len (writer, container_type,
2121 contained_type_start,
2128 * Append to an existing array. Essentially, the writer will read an
2129 * existing length at the write location; jump over that length; and
2130 * write new fields. On unrecurse(), the existing length will be
2133 * @param writer the writer
2134 * @param contained_type element type
2135 * @param contained_type_start position of element type
2136 * @param sub the subwriter to init
2137 * @returns #FALSE if no memory
2140 _dbus_type_writer_append_array (DBusTypeWriter *writer,
2141 const DBusString *contained_type,
2142 int contained_type_start,
2143 DBusTypeWriter *sub)
2145 int contained_type_len;
2148 contained_type_len = find_len_of_complete_type (contained_type, contained_type_start);
2150 contained_type_len = 0;
2152 return _dbus_type_writer_recurse_contained_len (writer, DBUS_TYPE_ARRAY,
2154 contained_type_start,
2161 writer_get_array_len (DBusTypeWriter *writer)
2163 _dbus_assert (writer->container_type == DBUS_TYPE_ARRAY);
2164 return writer->value_pos - writer->u.array.start_pos;
2168 * Closes a container created by _dbus_type_writer_recurse()
2169 * and writes any additional information to the values block.
2171 * @param writer the writer
2172 * @param sub the sub-writer created by _dbus_type_writer_recurse()
2173 * @returns #FALSE if no memory
2176 _dbus_type_writer_unrecurse (DBusTypeWriter *writer,
2177 DBusTypeWriter *sub)
2179 /* type_pos_is_expectation never gets unset once set, or we'd get all hosed */
2180 _dbus_assert (!writer->type_pos_is_expectation ||
2181 (writer->type_pos_is_expectation && sub->type_pos_is_expectation));
2183 #if RECURSIVE_MARSHAL_WRITE_TRACE
2184 _dbus_verbose (" type writer %p unrecurse type_pos = %d value_pos = %d is_expectation = %d container_type = %s\n",
2185 writer, writer->type_pos, writer->value_pos, writer->type_pos_is_expectation,
2186 _dbus_type_to_string (writer->container_type));
2187 _dbus_verbose (" type writer %p unrecurse sub type_pos = %d value_pos = %d is_expectation = %d container_type = %s\n",
2188 sub, sub->type_pos, sub->value_pos,
2189 sub->type_pos_is_expectation,
2190 _dbus_type_to_string (sub->container_type));
2193 if (sub->container_type == DBUS_TYPE_STRUCT)
2195 if (!write_or_verify_typecode (sub, DBUS_STRUCT_END_CHAR))
2198 else if (sub->container_type == DBUS_TYPE_DICT_ENTRY)
2200 if (!write_or_verify_typecode (sub, DBUS_DICT_ENTRY_END_CHAR))
2203 else if (sub->container_type == DBUS_TYPE_ARRAY)
2205 if (sub->u.array.len_pos >= 0) /* len_pos == -1 if we weren't enabled when we passed it */
2209 /* Set the array length */
2210 len = writer_get_array_len (sub);
2211 _dbus_marshal_set_uint32 (sub->value_str,
2212 sub->u.array.len_pos,
2215 #if RECURSIVE_MARSHAL_WRITE_TRACE
2216 _dbus_verbose (" filled in sub array len to %u at len_pos %d\n",
2217 len, sub->u.array.len_pos);
2220 #if RECURSIVE_MARSHAL_WRITE_TRACE
2223 _dbus_verbose (" not filling in sub array len because we were disabled when we passed the len\n");
2228 /* Now get type_pos right for the parent writer. Here are the cases:
2230 * Cases !writer->type_pos_is_expectation:
2231 * (in these cases we want to update to the new insertion point)
2233 * - if we recursed into a STRUCT then we didn't know in advance
2234 * what the types in the struct would be; so we have to fill in
2235 * that information now.
2236 * writer->type_pos = sub->type_pos
2238 * - if we recursed into anything else, we knew the full array
2239 * type, or knew the single typecode marking VARIANT, so
2240 * writer->type_pos is already correct.
2241 * writer->type_pos should remain as-is
2243 * - note that the parent is never an ARRAY or VARIANT, if it were
2244 * then type_pos_is_expectation would be TRUE. The parent
2245 * is thus known to be a toplevel or STRUCT.
2247 * Cases where writer->type_pos_is_expectation:
2248 * (in these cases we want to update to next expected type to write)
2250 * - we recursed from STRUCT into STRUCT and we didn't increment
2251 * type_pos in the parent just to stay consistent with the
2252 * !writer->type_pos_is_expectation case (though we could
2253 * special-case this in recurse_struct instead if we wanted)
2254 * writer->type_pos = sub->type_pos
2256 * - we recursed from STRUCT into ARRAY or VARIANT and type_pos
2257 * for parent should have been incremented already
2258 * writer->type_pos should remain as-is
2260 * - we recursed from ARRAY into a sub-element, so type_pos in the
2261 * parent is the element type and should remain the element type
2262 * for the benefit of the next child element
2263 * writer->type_pos should remain as-is
2265 * - we recursed from VARIANT into its value, so type_pos in the
2266 * parent makes no difference since there's only one value
2267 * and we just finished writing it and won't use type_pos again
2268 * writer->type_pos should remain as-is
2271 * For all these, DICT_ENTRY is the same as STRUCT
2273 if (writer->type_str != NULL)
2275 if ((sub->container_type == DBUS_TYPE_STRUCT ||
2276 sub->container_type == DBUS_TYPE_DICT_ENTRY) &&
2277 (writer->container_type == DBUS_TYPE_STRUCT ||
2278 writer->container_type == DBUS_TYPE_DICT_ENTRY ||
2279 writer->container_type == DBUS_TYPE_INVALID))
2281 /* Advance the parent to the next struct field */
2282 writer->type_pos = sub->type_pos;
2286 writer->value_pos = sub->value_pos;
2288 #if RECURSIVE_MARSHAL_WRITE_TRACE
2289 _dbus_verbose (" type writer %p unrecursed type_pos = %d value_pos = %d remaining sig '%s'\n",
2290 writer, writer->type_pos, writer->value_pos,
2292 _dbus_string_get_const_data_len (writer->type_str, writer->type_pos, 0) :
2300 * Writes out a basic type.
2302 * @param writer the writer
2303 * @param type the type to write
2304 * @param value the address of the value to write
2305 * @returns #FALSE if no memory
2308 _dbus_type_writer_write_basic (DBusTypeWriter *writer,
2314 /* First ensure that our type realloc will succeed */
2315 if (!writer->type_pos_is_expectation && writer->type_str != NULL)
2317 if (!_dbus_string_alloc_space (writer->type_str, 1))
2323 if (!_dbus_type_writer_write_basic_no_typecode (writer, type, value))
2326 if (!write_or_verify_typecode (writer, type))
2327 _dbus_assert_not_reached ("failed to write typecode after prealloc");
2332 #if RECURSIVE_MARSHAL_WRITE_TRACE
2333 _dbus_verbose (" type writer %p basic type_pos = %d value_pos = %d is_expectation = %d enabled = %d\n",
2334 writer, writer->type_pos, writer->value_pos, writer->type_pos_is_expectation,
2342 * Writes a block of fixed-length basic values, i.e. those that are
2343 * both dbus_type_is_fixed() and _dbus_type_is_basic(). The block
2344 * must be written inside an array.
2346 * The value parameter should be the address of said array of values,
2347 * so e.g. if it's an array of double, pass in "const double**"
2349 * @param writer the writer
2350 * @param element_type type of stuff in the array
2351 * @param value address of the array
2352 * @param n_elements number of elements in the array
2353 * @returns #FALSE if no memory
2356 _dbus_type_writer_write_fixed_multi (DBusTypeWriter *writer,
2361 _dbus_assert (writer->container_type == DBUS_TYPE_ARRAY);
2362 _dbus_assert (dbus_type_is_fixed (element_type));
2363 _dbus_assert (writer->type_pos_is_expectation);
2364 _dbus_assert (n_elements >= 0);
2366 #if RECURSIVE_MARSHAL_WRITE_TRACE
2367 _dbus_verbose (" type writer %p entering fixed multi type_pos = %d value_pos = %d n_elements %d\n",
2368 writer, writer->type_pos, writer->value_pos, n_elements);
2371 if (!write_or_verify_typecode (writer, element_type))
2372 _dbus_assert_not_reached ("OOM should not happen if only verifying typecode");
2374 if (writer->enabled)
2376 if (!_dbus_marshal_write_fixed_multi (writer->value_str,
2382 &writer->value_pos))
2386 #if RECURSIVE_MARSHAL_WRITE_TRACE
2387 _dbus_verbose (" type writer %p fixed multi written new type_pos = %d new value_pos = %d n_elements %d\n",
2388 writer, writer->type_pos, writer->value_pos, n_elements);
2395 enable_if_after (DBusTypeWriter *writer,
2396 DBusTypeReader *reader,
2397 const DBusTypeReader *start_after)
2401 if (!writer->enabled && _dbus_type_reader_greater_than (reader, start_after))
2403 _dbus_type_writer_set_enabled (writer, TRUE);
2404 #if RECURSIVE_MARSHAL_WRITE_TRACE
2405 _dbus_verbose ("ENABLING writer %p at %d because reader at value_pos %d is after reader at value_pos %d\n",
2406 writer, writer->value_pos, reader->value_pos, start_after->value_pos);
2410 _dbus_assert ((!writer->enabled && !_dbus_type_reader_greater_than (reader, start_after)) ||
2411 (writer->enabled && _dbus_type_reader_greater_than (reader, start_after)));
2416 append_fixup (DBusList **fixups,
2417 const DBusArrayLenFixup *fixup)
2419 DBusArrayLenFixup *f;
2421 f = dbus_new (DBusArrayLenFixup, 1);
2427 if (!_dbus_list_append (fixups, f))
2433 _dbus_assert (f->len_pos_in_reader == fixup->len_pos_in_reader);
2434 _dbus_assert (f->new_len == fixup->new_len);
2439 /* This loop is trivial if you ignore all the start_after nonsense,
2440 * so if you're trying to figure it out, start by ignoring that
2443 writer_write_reader_helper (DBusTypeWriter *writer,
2444 DBusTypeReader *reader,
2445 const DBusTypeReader *start_after,
2446 int start_after_new_pos,
2447 int start_after_new_len,
2449 dbus_bool_t inside_start_after)
2453 while ((current_type = _dbus_type_reader_get_current_type (reader)) != DBUS_TYPE_INVALID)
2455 if (dbus_type_is_container (current_type))
2457 DBusTypeReader subreader;
2458 DBusTypeWriter subwriter;
2459 const DBusString *sig_str;
2462 dbus_bool_t enabled_at_recurse;
2463 dbus_bool_t past_start_after;
2464 int reader_array_len_pos;
2465 int reader_array_start_pos;
2466 dbus_bool_t this_is_start_after;
2468 /* type_pos is checked since e.g. in a struct the struct
2469 * and its first field have the same value_pos.
2470 * type_str will differ in reader/start_after for variants
2471 * where type_str is inside the value_str
2473 if (!inside_start_after && start_after &&
2474 reader->value_pos == start_after->value_pos &&
2475 reader->type_str == start_after->type_str &&
2476 reader->type_pos == start_after->type_pos)
2477 this_is_start_after = TRUE;
2479 this_is_start_after = FALSE;
2481 _dbus_type_reader_recurse (reader, &subreader);
2483 if (current_type == DBUS_TYPE_ARRAY)
2485 reader_array_len_pos = ARRAY_READER_LEN_POS (&subreader);
2486 reader_array_start_pos = subreader.u.array.start_pos;
2491 reader_array_len_pos = -1;
2492 reader_array_start_pos = -1;
2495 _dbus_type_reader_get_signature (&subreader, &sig_str,
2496 &sig_start, &sig_len);
2498 #if RECURSIVE_MARSHAL_WRITE_TRACE
2499 _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",
2500 _dbus_type_to_string (current_type),
2502 subreader.value_pos,
2504 start_after ? start_after->value_pos : -1,
2505 _dbus_string_get_length (writer->value_str),
2506 inside_start_after, this_is_start_after);
2509 if (!inside_start_after && !this_is_start_after)
2510 enable_if_after (writer, &subreader, start_after);
2511 enabled_at_recurse = writer->enabled;
2512 if (!_dbus_type_writer_recurse_contained_len (writer, current_type,
2513 sig_str, sig_start, sig_len,
2517 #if RECURSIVE_MARSHAL_WRITE_TRACE
2518 _dbus_verbose ("recursed into subwriter at %d write target len %d\n",
2519 subwriter.value_pos,
2520 _dbus_string_get_length (subwriter.value_str));
2523 if (!writer_write_reader_helper (&subwriter, &subreader, start_after,
2524 start_after_new_pos, start_after_new_len,
2526 inside_start_after ||
2527 this_is_start_after))
2530 #if RECURSIVE_MARSHAL_WRITE_TRACE
2531 _dbus_verbose ("about to unrecurse from %s subreader at %d writer at %d subwriter at %d write target len %d\n",
2532 _dbus_type_to_string (current_type),
2533 subreader.value_pos,
2535 subwriter.value_pos,
2536 _dbus_string_get_length (writer->value_str));
2539 if (!inside_start_after && !this_is_start_after)
2540 enable_if_after (writer, &subreader, start_after);
2541 past_start_after = writer->enabled;
2542 if (!_dbus_type_writer_unrecurse (writer, &subwriter))
2545 /* If we weren't enabled when we recursed, we didn't
2546 * write an array len; if we passed start_after
2547 * somewhere inside the array, then we need to generate
2550 if (start_after != NULL &&
2551 !enabled_at_recurse && past_start_after &&
2552 current_type == DBUS_TYPE_ARRAY &&
2555 DBusArrayLenFixup fixup;
2556 int bytes_written_after_start_after;
2557 int bytes_before_start_after;
2560 /* this subwriter access is moderately unkosher since we
2561 * already unrecursed, but it works as long as unrecurse
2562 * doesn't break us on purpose
2564 bytes_written_after_start_after = writer_get_array_len (&subwriter);
2566 bytes_before_start_after =
2567 start_after->value_pos - reader_array_start_pos;
2569 fixup.len_pos_in_reader = reader_array_len_pos;
2571 bytes_before_start_after +
2572 start_after_new_len +
2573 bytes_written_after_start_after;
2575 _dbus_assert (_DBUS_ALIGN_VALUE (fixup.len_pos_in_reader, 4) ==
2576 (unsigned) fixup.len_pos_in_reader);
2578 old_len = _dbus_unpack_uint32 (reader->byte_order,
2579 _dbus_string_get_const_data_len (reader->value_str,
2580 fixup.len_pos_in_reader, 4));
2582 if (old_len != fixup.new_len && !append_fixup (fixups, &fixup))
2585 #if RECURSIVE_MARSHAL_WRITE_TRACE
2586 _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",
2587 fixup.len_pos_in_reader,
2589 reader_array_start_pos,
2590 start_after->value_pos,
2591 bytes_before_start_after,
2592 start_after_new_len,
2593 bytes_written_after_start_after);
2601 _dbus_assert (dbus_type_is_basic (current_type));
2603 #if RECURSIVE_MARSHAL_WRITE_TRACE
2604 _dbus_verbose ("Reading basic value %s at %d\n",
2605 _dbus_type_to_string (current_type),
2609 _dbus_type_reader_read_basic (reader, &val);
2611 #if RECURSIVE_MARSHAL_WRITE_TRACE
2612 _dbus_verbose ("Writing basic value %s at %d write target len %d inside_start_after = %d\n",
2613 _dbus_type_to_string (current_type),
2615 _dbus_string_get_length (writer->value_str),
2616 inside_start_after);
2618 if (!inside_start_after)
2619 enable_if_after (writer, reader, start_after);
2620 if (!_dbus_type_writer_write_basic (writer, current_type, &val))
2622 #if RECURSIVE_MARSHAL_WRITE_TRACE
2623 _dbus_verbose ("Wrote basic value %s, new value_pos %d write target len %d\n",
2624 _dbus_type_to_string (current_type),
2626 _dbus_string_get_length (writer->value_str));
2630 _dbus_type_reader_next (reader);
2637 apply_and_free_fixups (fixups, NULL); /* NULL for reader to apply to */
2643 * Iterate through all values in the given reader, writing a copy of
2644 * each value to the writer. The reader will be moved forward to its
2647 * If a reader start_after is provided, it should be a reader for the
2648 * same data as the reader to be written. Only values occurring after
2649 * the value pointed to by start_after will be written to the writer.
2651 * If start_after is provided, then the copy of the reader will be
2652 * partial. This means that array lengths will not have been copied.
2653 * The assumption is that you wrote a new version of the value at
2654 * start_after to the writer. You have to pass in the start position
2655 * and length of the new value. (If you are deleting the value
2656 * at start_after, pass in 0 for the length.)
2658 * If the fixups parameter is non-#NULL, then any array length that
2659 * was read but not written due to start_after will be provided
2660 * as a #DBusArrayLenFixup. The fixup contains the position of the
2661 * array length in the source data, and the correct array length
2662 * assuming you combine the source data before start_after with
2663 * the written data at start_after and beyond.
2665 * @param writer the writer to copy to
2666 * @param reader the reader to copy from
2667 * @param start_after #NULL or a reader showing where to start
2668 * @param start_after_new_pos the position of start_after equivalent in the target data
2669 * @param start_after_new_len the length of start_after equivalent in the target data
2670 * @param fixups list to append #DBusArrayLenFixup if the write was partial
2671 * @returns #FALSE if no memory
2674 _dbus_type_writer_write_reader_partial (DBusTypeWriter *writer,
2675 DBusTypeReader *reader,
2676 const DBusTypeReader *start_after,
2677 int start_after_new_pos,
2678 int start_after_new_len,
2681 DBusTypeWriter orig;
2688 orig_type_len = _dbus_string_get_length (writer->type_str);
2689 orig_value_len = _dbus_string_get_length (writer->value_str);
2690 orig_enabled = writer->enabled;
2693 _dbus_type_writer_set_enabled (writer, FALSE);
2695 if (!writer_write_reader_helper (writer, reader, start_after,
2696 start_after_new_pos,
2697 start_after_new_len,
2701 _dbus_type_writer_set_enabled (writer, orig_enabled);
2705 if (!writer->type_pos_is_expectation)
2707 new_bytes = _dbus_string_get_length (writer->type_str) - orig_type_len;
2708 _dbus_string_delete (writer->type_str, orig.type_pos, new_bytes);
2710 new_bytes = _dbus_string_get_length (writer->value_str) - orig_value_len;
2711 _dbus_string_delete (writer->value_str, orig.value_pos, new_bytes);
2719 * Iterate through all values in the given reader, writing a copy of
2720 * each value to the writer. The reader will be moved forward to its
2723 * @param writer the writer to copy to
2724 * @param reader the reader to copy from
2725 * @returns #FALSE if no memory
2728 _dbus_type_writer_write_reader (DBusTypeWriter *writer,
2729 DBusTypeReader *reader)
2731 return _dbus_type_writer_write_reader_partial (writer, reader, NULL, 0, 0, NULL);
2735 * If disabled, a writer can still be iterated forward and recursed/unrecursed
2736 * but won't write any values. Types will still be written unless the
2737 * writer is a "values only" writer, because the writer needs access to
2738 * a valid signature to be able to iterate.
2740 * @param writer the type writer
2741 * @param enabled #TRUE if values should be written
2744 _dbus_type_writer_set_enabled (DBusTypeWriter *writer,
2745 dbus_bool_t enabled)
2747 writer->enabled = enabled != FALSE;
2750 /** @} */ /* end of DBusMarshal group */
2752 /* tests in dbus-marshal-recursive-util.c */