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-signature.h"
27 #include "dbus-internals.h"
30 * @addtogroup DBusMarshal
34 /** turn this on to get deluged in TypeReader verbose spam */
35 #define RECURSIVE_MARSHAL_READ_TRACE 0
37 /** turn this on to get deluged in TypeWriter verbose spam */
38 #define RECURSIVE_MARSHAL_WRITE_TRACE 0
41 free_fixups (DBusList **fixups)
45 link = _dbus_list_get_first_link (fixups);
50 next = _dbus_list_get_next_link (fixups, link);
52 dbus_free (link->data);
53 _dbus_list_free_link (link);
62 apply_and_free_fixups (DBusList **fixups,
63 DBusTypeReader *reader)
67 #if RECURSIVE_MARSHAL_WRITE_TRACE
69 _dbus_verbose (" %d FIXUPS to apply\n",
70 _dbus_list_get_length (fixups));
73 link = _dbus_list_get_first_link (fixups);
78 next = _dbus_list_get_next_link (fixups, link);
86 #if RECURSIVE_MARSHAL_WRITE_TRACE
87 _dbus_verbose (" applying FIXUP to reader %p at pos %d new_len = %d old len %d\n",
88 reader, f->len_pos_in_reader, f->new_len,
89 _dbus_marshal_read_uint32 (reader->value_str,
91 reader->byte_order, NULL));
94 _dbus_marshal_set_uint32 ((DBusString*) reader->value_str,
100 dbus_free (link->data);
101 _dbus_list_free_link (link);
110 * Virtual table for a type reader.
112 struct DBusTypeReaderClass
114 const char *name; /**< name for debugging */
115 int id; /**< index in all_reader_classes */
116 dbus_bool_t types_only; /**< only iterates over types, not values */
117 void (* recurse) (DBusTypeReader *sub,
118 DBusTypeReader *parent); /**< recurse with this reader as sub */
119 dbus_bool_t (* check_finished) (const DBusTypeReader *reader); /**< check whether reader is at the end */
120 void (* next) (DBusTypeReader *reader,
121 int current_type); /**< go to the next value */
122 void (* init_from_mark) (DBusTypeReader *reader,
123 const DBusTypeMark *mark); /**< uncompress from a mark */
127 element_type_get_alignment (const DBusString *str,
130 return _dbus_type_get_alignment (_dbus_first_type_in_signature (str, pos));
134 reader_init (DBusTypeReader *reader,
136 const DBusString *type_str,
138 const DBusString *value_str,
141 reader->byte_order = byte_order;
142 reader->finished = FALSE;
143 reader->type_str = type_str;
144 reader->type_pos = type_pos;
145 reader->value_str = value_str;
146 reader->value_pos = value_pos;
150 base_reader_recurse (DBusTypeReader *sub,
151 DBusTypeReader *parent)
153 /* point subreader at the same place as parent */
163 struct_or_dict_entry_types_only_reader_recurse (DBusTypeReader *sub,
164 DBusTypeReader *parent)
166 base_reader_recurse (sub, parent);
168 _dbus_assert (_dbus_string_get_byte (sub->type_str,
169 sub->type_pos) == DBUS_STRUCT_BEGIN_CHAR ||
170 _dbus_string_get_byte (sub->type_str,
171 sub->type_pos) == DBUS_DICT_ENTRY_BEGIN_CHAR);
177 struct_or_dict_entry_reader_recurse (DBusTypeReader *sub,
178 DBusTypeReader *parent)
180 struct_or_dict_entry_types_only_reader_recurse (sub, parent);
182 /* struct and dict entry have 8 byte alignment */
183 sub->value_pos = _DBUS_ALIGN_VALUE (sub->value_pos, 8);
187 array_types_only_reader_recurse (DBusTypeReader *sub,
188 DBusTypeReader *parent)
190 base_reader_recurse (sub, parent);
192 /* point type_pos at the array element type */
195 /* Init with values likely to crash things if misused */
196 sub->u.array.start_pos = _DBUS_INT_MAX;
197 sub->array_len_offset = 7;
200 /** compute position of array length given array_len_offset, which is
201 the offset back from start_pos to end of the len */
202 #define ARRAY_READER_LEN_POS(reader) \
203 ((reader)->u.array.start_pos - ((int)(reader)->array_len_offset) - 4)
206 array_reader_get_array_len (const DBusTypeReader *reader)
208 dbus_uint32_t array_len;
211 len_pos = ARRAY_READER_LEN_POS (reader);
213 _dbus_assert (_DBUS_ALIGN_VALUE (len_pos, 4) == (unsigned) len_pos);
214 array_len = _dbus_unpack_uint32 (reader->byte_order,
215 _dbus_string_get_const_data_len (reader->value_str, len_pos, 4));
217 #if RECURSIVE_MARSHAL_READ_TRACE
218 _dbus_verbose (" reader %p len_pos %d array len %u len_offset %d\n",
219 reader, len_pos, array_len, reader->array_len_offset);
222 _dbus_assert (reader->u.array.start_pos - len_pos - 4 < 8);
228 array_reader_recurse (DBusTypeReader *sub,
229 DBusTypeReader *parent)
234 array_types_only_reader_recurse (sub, parent);
236 sub->value_pos = _DBUS_ALIGN_VALUE (sub->value_pos, 4);
238 len_pos = sub->value_pos;
240 sub->value_pos += 4; /* for the length */
242 alignment = element_type_get_alignment (sub->type_str,
245 sub->value_pos = _DBUS_ALIGN_VALUE (sub->value_pos, alignment);
247 sub->u.array.start_pos = sub->value_pos;
248 _dbus_assert ((sub->u.array.start_pos - (len_pos + 4)) < 8); /* only 3 bits in array_len_offset */
249 sub->array_len_offset = sub->u.array.start_pos - (len_pos + 4);
251 #if RECURSIVE_MARSHAL_READ_TRACE
252 _dbus_verbose (" type reader %p array start = %d len_offset = %d array len = %d array element type = %s\n",
254 sub->u.array.start_pos,
255 sub->array_len_offset,
256 array_reader_get_array_len (sub),
257 _dbus_type_to_string (_dbus_first_type_in_signature (sub->type_str,
263 variant_reader_recurse (DBusTypeReader *sub,
264 DBusTypeReader *parent)
267 int contained_alignment;
269 base_reader_recurse (sub, parent);
271 /* Variant is 1 byte sig length (without nul), signature with nul,
272 * padding to 8-boundary, then values
275 sig_len = _dbus_string_get_byte (sub->value_str, sub->value_pos);
277 sub->type_str = sub->value_str;
278 sub->type_pos = sub->value_pos + 1;
280 sub->value_pos = sub->type_pos + sig_len + 1;
282 contained_alignment = _dbus_type_get_alignment (_dbus_first_type_in_signature (sub->type_str,
285 sub->value_pos = _DBUS_ALIGN_VALUE (sub->value_pos, contained_alignment);
287 #if RECURSIVE_MARSHAL_READ_TRACE
288 _dbus_verbose (" type reader %p variant containing '%s'\n",
290 _dbus_string_get_const_data_len (sub->type_str,
296 array_reader_check_finished (const DBusTypeReader *reader)
300 /* return the array element type if elements remain, and
301 * TYPE_INVALID otherwise
304 end_pos = reader->u.array.start_pos + array_reader_get_array_len (reader);
306 _dbus_assert (reader->value_pos <= end_pos);
307 _dbus_assert (reader->value_pos >= reader->u.array.start_pos);
309 return reader->value_pos == end_pos;
313 skip_one_complete_type (const DBusString *type_str,
316 _dbus_type_signature_next (_dbus_string_get_const_data (type_str),
321 * Skips to the next "complete" type inside a type signature.
322 * The signature is read starting at type_pos, and the next
323 * type position is stored in the same variable.
325 * @param type_str a type signature (must be valid)
326 * @param type_pos an integer position in the type signtaure (in and out)
329 _dbus_type_signature_next (const char *type_str,
332 const unsigned char *p;
333 const unsigned char *start;
335 _dbus_assert (type_str != NULL);
336 _dbus_assert (type_pos != NULL);
339 p = start + *type_pos;
341 _dbus_assert (*p != DBUS_STRUCT_END_CHAR);
342 _dbus_assert (*p != DBUS_DICT_ENTRY_END_CHAR);
344 while (*p == DBUS_TYPE_ARRAY)
347 _dbus_assert (*p != DBUS_STRUCT_END_CHAR);
348 _dbus_assert (*p != DBUS_DICT_ENTRY_END_CHAR);
350 if (*p == DBUS_STRUCT_BEGIN_CHAR)
358 _dbus_assert (*p != DBUS_TYPE_INVALID);
362 _dbus_assert (*p != DBUS_TYPE_INVALID);
364 if (*p == DBUS_STRUCT_BEGIN_CHAR)
366 else if (*p == DBUS_STRUCT_END_CHAR)
377 else if (*p == DBUS_DICT_ENTRY_BEGIN_CHAR)
385 _dbus_assert (*p != DBUS_TYPE_INVALID);
389 _dbus_assert (*p != DBUS_TYPE_INVALID);
391 if (*p == DBUS_DICT_ENTRY_BEGIN_CHAR)
393 else if (*p == DBUS_DICT_ENTRY_END_CHAR)
409 *type_pos = (int) (p - start);
413 find_len_of_complete_type (const DBusString *type_str,
420 skip_one_complete_type (type_str, &end);
422 return end - type_pos;
426 base_reader_next (DBusTypeReader *reader,
429 switch (current_type)
431 case DBUS_TYPE_DICT_ENTRY:
432 case DBUS_TYPE_STRUCT:
433 case DBUS_TYPE_VARIANT:
434 /* Scan forward over the entire container contents */
438 if (reader->klass->types_only && current_type == DBUS_TYPE_VARIANT)
442 /* Recurse into the struct or variant */
443 _dbus_type_reader_recurse (reader, &sub);
445 /* Skip everything in this subreader */
446 while (_dbus_type_reader_next (&sub))
451 if (!reader->klass->types_only)
452 reader->value_pos = sub.value_pos;
454 /* Now we are at the end of this container; for variants, the
455 * subreader's type_pos is totally inapplicable (it's in the
456 * value string) but we know that we increment by one past the
459 if (current_type == DBUS_TYPE_VARIANT)
460 reader->type_pos += 1;
462 reader->type_pos = sub.type_pos;
466 case DBUS_TYPE_ARRAY:
468 if (!reader->klass->types_only)
469 _dbus_marshal_skip_array (reader->value_str,
470 _dbus_first_type_in_signature (reader->type_str,
471 reader->type_pos + 1),
475 skip_one_complete_type (reader->type_str, &reader->type_pos);
480 if (!reader->klass->types_only)
481 _dbus_marshal_skip_basic (reader->value_str,
482 current_type, reader->byte_order,
485 reader->type_pos += 1;
491 struct_reader_next (DBusTypeReader *reader,
496 base_reader_next (reader, current_type);
498 /* for STRUCT containers we return FALSE at the end of the struct,
499 * for INVALID we return FALSE at the end of the signature.
500 * In both cases we arrange for get_current_type() to return INVALID
501 * which is defined to happen iff we're at the end (no more next())
503 t = _dbus_string_get_byte (reader->type_str, reader->type_pos);
504 if (t == DBUS_STRUCT_END_CHAR)
506 reader->type_pos += 1;
507 reader->finished = TRUE;
512 dict_entry_reader_next (DBusTypeReader *reader,
517 base_reader_next (reader, current_type);
519 /* for STRUCT containers we return FALSE at the end of the struct,
520 * for INVALID we return FALSE at the end of the signature.
521 * In both cases we arrange for get_current_type() to return INVALID
522 * which is defined to happen iff we're at the end (no more next())
524 t = _dbus_string_get_byte (reader->type_str, reader->type_pos);
525 if (t == DBUS_DICT_ENTRY_END_CHAR)
527 reader->type_pos += 1;
528 reader->finished = TRUE;
533 array_types_only_reader_next (DBusTypeReader *reader,
536 /* We have one "element" to be iterated over
537 * in each array, which is its element type.
538 * So the finished flag indicates whether we've
539 * iterated over it yet or not.
541 reader->finished = TRUE;
545 array_reader_next (DBusTypeReader *reader,
548 /* Skip one array element */
551 end_pos = reader->u.array.start_pos + array_reader_get_array_len (reader);
553 #if RECURSIVE_MARSHAL_READ_TRACE
554 _dbus_verbose (" reader %p array next START start_pos = %d end_pos = %d value_pos = %d current_type = %s\n",
556 reader->u.array.start_pos,
557 end_pos, reader->value_pos,
558 _dbus_type_to_string (current_type));
561 _dbus_assert (reader->value_pos < end_pos);
562 _dbus_assert (reader->value_pos >= reader->u.array.start_pos);
564 switch (_dbus_first_type_in_signature (reader->type_str,
567 case DBUS_TYPE_DICT_ENTRY:
568 case DBUS_TYPE_STRUCT:
569 case DBUS_TYPE_VARIANT:
573 /* Recurse into the struct or variant */
574 _dbus_type_reader_recurse (reader, &sub);
576 /* Skip everything in this element */
577 while (_dbus_type_reader_next (&sub))
582 /* Now we are at the end of this element */
583 reader->value_pos = sub.value_pos;
587 case DBUS_TYPE_ARRAY:
589 _dbus_marshal_skip_array (reader->value_str,
590 _dbus_first_type_in_signature (reader->type_str,
591 reader->type_pos + 1),
599 _dbus_marshal_skip_basic (reader->value_str,
600 current_type, reader->byte_order,
606 #if RECURSIVE_MARSHAL_READ_TRACE
607 _dbus_verbose (" reader %p array next END start_pos = %d end_pos = %d value_pos = %d current_type = %s\n",
609 reader->u.array.start_pos,
610 end_pos, reader->value_pos,
611 _dbus_type_to_string (current_type));
614 _dbus_assert (reader->value_pos <= end_pos);
616 if (reader->value_pos == end_pos)
618 skip_one_complete_type (reader->type_str,
624 array_init_from_mark (DBusTypeReader *reader,
625 const DBusTypeMark *mark)
627 /* Fill in the array-specific fields from the mark. The general
628 * fields are already filled in.
630 reader->u.array.start_pos = mark->array_start_pos;
631 reader->array_len_offset = mark->array_len_offset;
634 static const DBusTypeReaderClass body_reader_class = {
637 NULL, /* body is always toplevel, so doesn't get recursed into */
643 static const DBusTypeReaderClass body_types_only_reader_class = {
646 NULL, /* body is always toplevel, so doesn't get recursed into */
652 static const DBusTypeReaderClass struct_reader_class = {
655 struct_or_dict_entry_reader_recurse,
661 static const DBusTypeReaderClass struct_types_only_reader_class = {
664 struct_or_dict_entry_types_only_reader_recurse,
670 static const DBusTypeReaderClass dict_entry_reader_class = {
673 struct_or_dict_entry_reader_recurse,
675 dict_entry_reader_next,
679 static const DBusTypeReaderClass dict_entry_types_only_reader_class = {
680 "dict_entry types", 5,
682 struct_or_dict_entry_types_only_reader_recurse,
684 dict_entry_reader_next,
688 static const DBusTypeReaderClass array_reader_class = {
691 array_reader_recurse,
692 array_reader_check_finished,
697 static const DBusTypeReaderClass array_types_only_reader_class = {
700 array_types_only_reader_recurse,
702 array_types_only_reader_next,
706 static const DBusTypeReaderClass variant_reader_class = {
709 variant_reader_recurse,
715 static const DBusTypeReaderClass const *
716 all_reader_classes[] = {
718 &body_types_only_reader_class,
719 &struct_reader_class,
720 &struct_types_only_reader_class,
721 &dict_entry_reader_class,
722 &dict_entry_types_only_reader_class,
724 &array_types_only_reader_class,
725 &variant_reader_class
729 * Initializes a type reader.
731 * @param reader the reader
732 * @param byte_order the byte order of the block to read
733 * @param type_str the signature of the block to read
734 * @param type_pos location of signature
735 * @param value_str the string containing values block
736 * @param value_pos start of values block
739 _dbus_type_reader_init (DBusTypeReader *reader,
741 const DBusString *type_str,
743 const DBusString *value_str,
746 reader->klass = &body_reader_class;
748 reader_init (reader, byte_order, type_str, type_pos,
749 value_str, value_pos);
751 #if RECURSIVE_MARSHAL_READ_TRACE
752 _dbus_verbose (" type reader %p init type_pos = %d value_pos = %d remaining sig '%s'\n",
753 reader, reader->type_pos, reader->value_pos,
754 _dbus_string_get_const_data_len (reader->type_str, reader->type_pos, 0));
759 * Initializes a type reader that's been compressed into a
760 * DBusTypeMark. The args have to be the same as those passed in to
761 * create the original #DBusTypeReader.
763 * @param reader the reader
764 * @param byte_order the byte order of the value block
765 * @param type_str string containing the type signature
766 * @param value_str string containing the values block
767 * @param mark the mark to decompress from
770 _dbus_type_reader_init_from_mark (DBusTypeReader *reader,
772 const DBusString *type_str,
773 const DBusString *value_str,
774 const DBusTypeMark *mark)
776 reader->klass = all_reader_classes[mark->container_type];
778 reader_init (reader, byte_order,
779 mark->type_pos_in_value_str ? value_str : type_str,
781 value_str, mark->value_pos);
783 if (reader->klass->init_from_mark)
784 (* reader->klass->init_from_mark) (reader, mark);
786 #if RECURSIVE_MARSHAL_READ_TRACE
787 _dbus_verbose (" type reader %p init from mark type_pos = %d value_pos = %d remaining sig '%s'\n",
788 reader, reader->type_pos, reader->value_pos,
789 _dbus_string_get_const_data_len (reader->type_str, reader->type_pos, 0));
794 * Like _dbus_type_reader_init() but the iteration is over the
795 * signature, not over values.
797 * @param reader the reader
798 * @param type_str the signature string
799 * @param type_pos location in the signature string
802 _dbus_type_reader_init_types_only (DBusTypeReader *reader,
803 const DBusString *type_str,
806 reader->klass = &body_types_only_reader_class;
808 reader_init (reader, DBUS_COMPILER_BYTE_ORDER /* irrelevant */,
809 type_str, type_pos, NULL, _DBUS_INT_MAX /* crashes if we screw up */);
811 #if RECURSIVE_MARSHAL_READ_TRACE
812 _dbus_verbose (" type reader %p init types only type_pos = %d remaining sig '%s'\n",
813 reader, reader->type_pos,
814 _dbus_string_get_const_data_len (reader->type_str, reader->type_pos, 0));
819 * Like _dbus_type_reader_init_from_mark() but only iterates over
820 * the signature, not the values.
822 * @param reader the reader
823 * @param type_str the signature string
824 * @param mark the mark to decompress from
827 _dbus_type_reader_init_types_only_from_mark (DBusTypeReader *reader,
828 const DBusString *type_str,
829 const DBusTypeMark *mark)
831 reader->klass = all_reader_classes[mark->container_type];
832 _dbus_assert (reader->klass->types_only);
833 _dbus_assert (!mark->type_pos_in_value_str);
835 reader_init (reader, DBUS_COMPILER_BYTE_ORDER, /* irrelevant */
836 type_str, mark->type_pos,
837 NULL, _DBUS_INT_MAX /* crashes if we screw up */);
839 if (reader->klass->init_from_mark)
840 (* reader->klass->init_from_mark) (reader, mark);
842 #if RECURSIVE_MARSHAL_READ_TRACE
843 _dbus_verbose (" type reader %p init types only from mark type_pos = %d remaining sig '%s'\n",
844 reader, reader->type_pos,
845 _dbus_string_get_const_data_len (reader->type_str, reader->type_pos, 0));
850 * Compresses a type reader into a #DBusTypeMark, useful for example
851 * if you want to cache a bunch of positions in a block of values.
853 * @param reader the reader
854 * @param mark the mark to init
857 _dbus_type_reader_save_mark (const DBusTypeReader *reader,
860 mark->type_pos_in_value_str = (reader->type_str == reader->value_str);
861 mark->container_type = reader->klass->id;
862 _dbus_assert (all_reader_classes[reader->klass->id] == reader->klass);
864 mark->type_pos = reader->type_pos;
865 mark->value_pos = reader->value_pos;
867 /* these are just junk if the reader isn't really an array of course */
868 mark->array_len_offset = reader->array_len_offset;
869 mark->array_start_pos = reader->u.array.start_pos;
873 * Gets the type of the value the reader is currently pointing to;
874 * or for a types-only reader gets the type it's currently pointing to.
875 * If the reader is at the end of a block or end of a container such
876 * as an array, returns #DBUS_TYPE_INVALID.
878 * @param reader the reader
881 _dbus_type_reader_get_current_type (const DBusTypeReader *reader)
885 if (reader->finished ||
886 (reader->klass->check_finished &&
887 (* reader->klass->check_finished) (reader)))
888 t = DBUS_TYPE_INVALID;
890 t = _dbus_first_type_in_signature (reader->type_str,
893 _dbus_assert (t != DBUS_STRUCT_END_CHAR);
894 _dbus_assert (t != DBUS_STRUCT_BEGIN_CHAR);
895 _dbus_assert (t != DBUS_DICT_ENTRY_END_CHAR);
896 _dbus_assert (t != DBUS_DICT_ENTRY_BEGIN_CHAR);
899 _dbus_verbose (" type reader %p current type_pos = %d type = %s\n",
900 reader, reader->type_pos,
901 _dbus_type_to_string (t));
908 * Gets the type of an element of the array the reader is currently
909 * pointing to. It's an error to call this if
910 * _dbus_type_reader_get_current_type() doesn't return #DBUS_TYPE_ARRAY
913 * @param reader the reader
916 _dbus_type_reader_get_element_type (const DBusTypeReader *reader)
920 _dbus_assert (_dbus_type_reader_get_current_type (reader) == DBUS_TYPE_ARRAY);
922 element_type = _dbus_first_type_in_signature (reader->type_str,
923 reader->type_pos + 1);
929 * Gets the current position in the value block
930 * @param reader the reader
933 _dbus_type_reader_get_value_pos (const DBusTypeReader *reader)
935 return reader->value_pos;
939 * Get the address of the marshaled value in the data being read. The
940 * address may not be aligned; you have to align it to the type of the
941 * value you want to read. Most of the demarshal routines do this for
944 * @param reader the reader
945 * @param value_location the address of the marshaled value
948 _dbus_type_reader_read_raw (const DBusTypeReader *reader,
949 const unsigned char **value_location)
951 _dbus_assert (!reader->klass->types_only);
953 *value_location = _dbus_string_get_const_data_len (reader->value_str,
959 * Reads a basic-typed value, as with _dbus_marshal_read_basic().
961 * @param reader the reader
962 * @param value the address of the value
965 _dbus_type_reader_read_basic (const DBusTypeReader *reader,
970 _dbus_assert (!reader->klass->types_only);
972 t = _dbus_type_reader_get_current_type (reader);
974 _dbus_marshal_read_basic (reader->value_str,
981 #if RECURSIVE_MARSHAL_READ_TRACE
982 _dbus_verbose (" type reader %p read basic type_pos = %d value_pos = %d remaining sig '%s'\n",
983 reader, reader->type_pos, reader->value_pos,
984 _dbus_string_get_const_data_len (reader->type_str, reader->type_pos, 0));
989 * Reads a block of fixed-length basic values, from the current point
990 * in an array to the end of the array. Does not work for arrays of
991 * string or container types.
993 * This function returns the array in-place; it does not make a copy,
994 * and it does not swap the bytes.
996 * If you ask for #DBUS_TYPE_DOUBLE you will get a "const double*" back
997 * and the "value" argument should be a "const double**" and so on.
999 * @param reader the reader to read from
1000 * @param value place to return the array values
1001 * @param n_elements place to return number of array elements
1004 _dbus_type_reader_read_fixed_multi (const DBusTypeReader *reader,
1014 _dbus_assert (!reader->klass->types_only);
1015 _dbus_assert (reader->klass == &array_reader_class);
1017 element_type = _dbus_first_type_in_signature (reader->type_str,
1020 _dbus_assert (element_type != DBUS_TYPE_INVALID); /* why we don't use get_current_type() */
1021 _dbus_assert (dbus_type_is_fixed (element_type));
1023 alignment = _dbus_type_get_alignment (element_type);
1025 _dbus_assert (reader->value_pos >= reader->u.array.start_pos);
1027 total_len = array_reader_get_array_len (reader);
1028 end_pos = reader->u.array.start_pos + total_len;
1029 remaining_len = end_pos - reader->value_pos;
1031 #if RECURSIVE_MARSHAL_READ_TRACE
1032 _dbus_verbose ("end_pos %d total_len %d remaining_len %d value_pos %d\n",
1033 end_pos, total_len, remaining_len, reader->value_pos);
1036 _dbus_assert (remaining_len <= total_len);
1038 if (remaining_len == 0)
1039 *(const DBusBasicValue**) value = NULL;
1041 *(const DBusBasicValue**) value =
1042 (void*) _dbus_string_get_const_data_len (reader->value_str,
1046 *n_elements = remaining_len / alignment;
1047 _dbus_assert ((remaining_len % alignment) == 0);
1049 #if RECURSIVE_MARSHAL_READ_TRACE
1050 _dbus_verbose (" type reader %p read fixed array type_pos = %d value_pos = %d remaining sig '%s'\n",
1051 reader, reader->type_pos, reader->value_pos,
1052 _dbus_string_get_const_data_len (reader->type_str, reader->type_pos, 0));
1057 * Initialize a new reader pointing to the first type and
1058 * corresponding value that's a child of the current container. It's
1059 * an error to call this if the current type is a non-container.
1061 * Note that DBusTypeReader traverses values, not types. So if you
1062 * have an empty array of array of int, you can't recurse into it. You
1063 * can only recurse into each element.
1065 * @param reader the reader
1066 * @param sub a reader to init pointing to the first child
1069 _dbus_type_reader_recurse (DBusTypeReader *reader,
1070 DBusTypeReader *sub)
1074 t = _dbus_first_type_in_signature (reader->type_str, reader->type_pos);
1078 case DBUS_TYPE_STRUCT:
1079 if (reader->klass->types_only)
1080 sub->klass = &struct_types_only_reader_class;
1082 sub->klass = &struct_reader_class;
1084 case DBUS_TYPE_DICT_ENTRY:
1085 if (reader->klass->types_only)
1086 sub->klass = &dict_entry_types_only_reader_class;
1088 sub->klass = &dict_entry_reader_class;
1090 case DBUS_TYPE_ARRAY:
1091 if (reader->klass->types_only)
1092 sub->klass = &array_types_only_reader_class;
1094 sub->klass = &array_reader_class;
1096 case DBUS_TYPE_VARIANT:
1097 if (reader->klass->types_only)
1098 _dbus_assert_not_reached ("can't recurse into variant typecode");
1100 sub->klass = &variant_reader_class;
1103 _dbus_verbose ("recursing into type %s\n", _dbus_type_to_string (t));
1104 #ifndef DBUS_DISABLE_CHECKS
1105 if (t == DBUS_TYPE_INVALID)
1106 _dbus_warn ("You can't recurse into an empty array or off the end of a message body\n");
1107 #endif /* DBUS_DISABLE_CHECKS */
1109 _dbus_assert_not_reached ("don't yet handle recursing into this type");
1112 _dbus_assert (sub->klass == all_reader_classes[sub->klass->id]);
1114 (* sub->klass->recurse) (sub, reader);
1116 #if RECURSIVE_MARSHAL_READ_TRACE
1117 _dbus_verbose (" type reader %p RECURSED type_pos = %d value_pos = %d remaining sig '%s'\n",
1118 sub, sub->type_pos, sub->value_pos,
1119 _dbus_string_get_const_data_len (sub->type_str, sub->type_pos, 0));
1124 * Skip to the next value on this "level". e.g. the next field in a
1125 * struct, the next value in an array. Returns FALSE at the end of the
1126 * current container.
1128 * @param reader the reader
1129 * @returns FALSE if nothing more to read at or below this level
1132 _dbus_type_reader_next (DBusTypeReader *reader)
1136 t = _dbus_type_reader_get_current_type (reader);
1138 #if RECURSIVE_MARSHAL_READ_TRACE
1139 _dbus_verbose (" type reader %p START next() { type_pos = %d value_pos = %d remaining sig '%s' current_type = %s\n",
1140 reader, reader->type_pos, reader->value_pos,
1141 _dbus_string_get_const_data_len (reader->type_str, reader->type_pos, 0),
1142 _dbus_type_to_string (t));
1145 if (t == DBUS_TYPE_INVALID)
1148 (* reader->klass->next) (reader, t);
1150 #if RECURSIVE_MARSHAL_READ_TRACE
1151 _dbus_verbose (" type reader %p END next() type_pos = %d value_pos = %d remaining sig '%s' current_type = %s\n",
1152 reader, reader->type_pos, reader->value_pos,
1153 _dbus_string_get_const_data_len (reader->type_str, reader->type_pos, 0),
1154 _dbus_type_to_string (_dbus_type_reader_get_current_type (reader)));
1157 return _dbus_type_reader_get_current_type (reader) != DBUS_TYPE_INVALID;
1161 * Check whether there's another value on this "level". e.g. the next
1162 * field in a struct, the next value in an array. Returns FALSE at the
1163 * end of the current container.
1165 * You probably don't want to use this; it makes for an awkward for/while
1166 * loop. A nicer one is "while ((current_type = get_current_type()) != INVALID)"
1168 * @param reader the reader
1169 * @returns FALSE if nothing more to read at or below this level
1172 _dbus_type_reader_has_next (const DBusTypeReader *reader)
1174 /* Not efficient but works for now. */
1175 DBusTypeReader copy;
1178 return _dbus_type_reader_next (©);
1182 * Gets the string and range of said string containing the signature
1183 * of the current value. Essentially a more complete version of
1184 * _dbus_type_reader_get_current_type() (returns the full type
1185 * rather than only the outside of the onion).
1187 * Note though that the first byte in a struct signature is
1188 * #DBUS_STRUCT_BEGIN_CHAR while the current type will be
1189 * #DBUS_TYPE_STRUCT so it isn't true that the first byte of the
1190 * signature is always the same as the current type. Another
1191 * difference is that this function will still return a signature when
1192 * inside an empty array; say you recurse into empty array of int32,
1193 * the signature is "i" but the current type will always be
1194 * #DBUS_TYPE_INVALID since there are no elements to be currently
1197 * @param reader the reader
1198 * @param str_p place to return the string with the type in it
1199 * @param start_p place to return start of the type
1200 * @param len_p place to return the length of the type
1203 _dbus_type_reader_get_signature (const DBusTypeReader *reader,
1204 const DBusString **str_p,
1208 *str_p = reader->type_str;
1209 *start_p = reader->type_pos;
1210 *len_p = find_len_of_complete_type (reader->type_str, reader->type_pos);
1215 DBusString replacement;
1220 replacement_block_init (ReplacementBlock *block,
1221 DBusTypeReader *reader)
1223 if (!_dbus_string_init (&block->replacement))
1226 /* % 8 is the padding to have the same align properties in
1227 * our replacement string as we do at the position being replaced
1229 block->padding = reader->value_pos % 8;
1231 if (!_dbus_string_lengthen (&block->replacement, block->padding))
1237 _dbus_string_free (&block->replacement);
1242 replacement_block_replace (ReplacementBlock *block,
1243 DBusTypeReader *reader,
1244 const DBusTypeReader *realign_root)
1246 DBusTypeWriter writer;
1247 DBusTypeReader realign_reader;
1251 _dbus_assert (realign_root != NULL);
1253 orig_len = _dbus_string_get_length (&block->replacement);
1255 realign_reader = *realign_root;
1257 #if RECURSIVE_MARSHAL_WRITE_TRACE
1258 _dbus_verbose ("INITIALIZING replacement block writer %p at value_pos %d\n",
1259 &writer, _dbus_string_get_length (&block->replacement));
1261 _dbus_type_writer_init_values_only (&writer,
1262 realign_reader.byte_order,
1263 realign_reader.type_str,
1264 realign_reader.type_pos,
1265 &block->replacement,
1266 _dbus_string_get_length (&block->replacement));
1268 _dbus_assert (realign_reader.value_pos <= reader->value_pos);
1270 #if RECURSIVE_MARSHAL_WRITE_TRACE
1271 _dbus_verbose ("COPYING from reader at value_pos %d to writer %p starting after value_pos %d\n",
1272 realign_reader.value_pos, &writer, reader->value_pos);
1275 if (!_dbus_type_writer_write_reader_partial (&writer,
1279 _dbus_string_get_length (&block->replacement) - block->padding,
1283 #if RECURSIVE_MARSHAL_WRITE_TRACE
1284 _dbus_verbose ("REPLACEMENT at padding %d len %d\n", block->padding,
1285 _dbus_string_get_length (&block->replacement) - block->padding);
1286 _dbus_verbose_bytes_of_string (&block->replacement, block->padding,
1287 _dbus_string_get_length (&block->replacement) - block->padding);
1288 _dbus_verbose ("TO BE REPLACED at value_pos = %d (align pad %d) len %d realign_reader.value_pos %d\n",
1289 reader->value_pos, reader->value_pos % 8,
1290 realign_reader.value_pos - reader->value_pos,
1291 realign_reader.value_pos);
1292 _dbus_verbose_bytes_of_string (reader->value_str,
1294 realign_reader.value_pos - reader->value_pos);
1297 /* Move the replacement into position
1298 * (realign_reader should now be at the end of the block to be replaced)
1300 if (!_dbus_string_replace_len (&block->replacement, block->padding,
1301 _dbus_string_get_length (&block->replacement) - block->padding,
1302 (DBusString*) reader->value_str,
1304 realign_reader.value_pos - reader->value_pos))
1307 /* Process our fixups now that we can't have an OOM error */
1308 apply_and_free_fixups (&fixups, reader);
1313 _dbus_string_set_length (&block->replacement, orig_len);
1314 free_fixups (&fixups);
1319 replacement_block_free (ReplacementBlock *block)
1321 _dbus_string_free (&block->replacement);
1324 /* In the variable-length case, we have to fix alignment after we insert.
1325 * The strategy is as follows:
1327 * - pad a new string to have the same alignment as the
1328 * start of the current basic value
1329 * - write the new basic value
1330 * - copy from the original reader to the new string,
1331 * which will fix the alignment of types following
1333 * - this copy has to start at realign_root,
1334 * but not really write anything until it
1335 * passes the value being set
1336 * - as an optimization, we can stop copying
1337 * when the source and dest values are both
1338 * on an 8-boundary, since we know all following
1339 * padding and alignment will be identical
1340 * - copy the new string back to the original
1341 * string, replacing the relevant part of the
1343 * - now any arrays in the original string that
1344 * contained the replaced string may have the
1345 * wrong length; so we have to fix that
1348 reader_set_basic_variable_length (DBusTypeReader *reader,
1351 const DBusTypeReader *realign_root)
1354 ReplacementBlock block;
1355 DBusTypeWriter writer;
1357 _dbus_assert (realign_root != NULL);
1361 if (!replacement_block_init (&block, reader))
1364 /* Write the new basic value */
1365 #if RECURSIVE_MARSHAL_WRITE_TRACE
1366 _dbus_verbose ("INITIALIZING writer %p to write basic value at value_pos %d of replacement string\n",
1367 &writer, _dbus_string_get_length (&block.replacement));
1369 _dbus_type_writer_init_values_only (&writer,
1374 _dbus_string_get_length (&block.replacement));
1375 #if RECURSIVE_MARSHAL_WRITE_TRACE
1376 _dbus_verbose ("WRITING basic value to writer %p (replacement string)\n", &writer);
1378 if (!_dbus_type_writer_write_basic (&writer, current_type, value))
1381 if (!replacement_block_replace (&block,
1389 replacement_block_free (&block);
1394 reader_set_basic_fixed_length (DBusTypeReader *reader,
1398 _dbus_marshal_set_basic ((DBusString*) reader->value_str,
1407 * Sets a new value for the basic type value pointed to by the reader,
1408 * leaving the reader valid to continue reading. Any other readers
1409 * will be invalidated if you set a variable-length type such as a
1412 * The provided realign_root is the reader to start from when
1413 * realigning the data that follows the newly-set value. The reader
1414 * parameter must point to a value below the realign_root parameter.
1415 * If the type being set is fixed-length, then realign_root may be
1416 * #NULL. Only values reachable from realign_root will be realigned,
1417 * so if your string contains other values you will need to deal with
1418 * those somehow yourself. It is OK if realign_root is the same
1419 * reader as the reader parameter, though if you aren't setting the
1420 * root it may not be such a good idea.
1422 * @todo DBusTypeReader currently takes "const" versions of the type
1423 * and value strings, and this function modifies those strings by
1424 * casting away the const, which is of course bad if we want to get
1425 * picky. (To be truly clean you'd have an object which contained the
1426 * type and value strings and set_basic would be a method on that
1427 * object... this would also make DBusTypeReader the same thing as
1428 * DBusTypeMark. But since DBusMessage is effectively that object for
1429 * D-BUS it doesn't seem worth creating some random object.)
1431 * @todo optimize this by only rewriting until the old and new values
1432 * are at the same alignment. Frequently this should result in only
1433 * replacing the value that's immediately at hand.
1435 * @param reader reader indicating where to set a new value
1436 * @param value address of the value to set
1437 * @param realign_root realign from here
1438 * @returns #FALSE if not enough memory
1441 _dbus_type_reader_set_basic (DBusTypeReader *reader,
1443 const DBusTypeReader *realign_root)
1447 _dbus_assert (!reader->klass->types_only);
1448 _dbus_assert (reader->value_str == realign_root->value_str);
1449 _dbus_assert (reader->value_pos >= realign_root->value_pos);
1451 current_type = _dbus_type_reader_get_current_type (reader);
1453 #if RECURSIVE_MARSHAL_WRITE_TRACE
1454 _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",
1455 reader, reader->type_pos, reader->value_pos,
1456 _dbus_string_get_const_data_len (reader->type_str, reader->type_pos, 0),
1458 realign_root ? realign_root->value_pos : -1,
1459 _dbus_type_to_string (current_type));
1460 _dbus_verbose_bytes_of_string (realign_root->value_str, realign_root->value_pos,
1461 _dbus_string_get_length (realign_root->value_str) -
1462 realign_root->value_pos);
1465 _dbus_assert (dbus_type_is_basic (current_type));
1467 if (dbus_type_is_fixed (current_type))
1469 reader_set_basic_fixed_length (reader, current_type, value);
1474 _dbus_assert (realign_root != NULL);
1475 return reader_set_basic_variable_length (reader, current_type,
1476 value, realign_root);
1481 * Recursively deletes any value pointed to by the reader, leaving the
1482 * reader valid to continue reading. Any other readers will be
1485 * The provided realign_root is the reader to start from when
1486 * realigning the data that follows the newly-set value.
1487 * See _dbus_type_reader_set_basic() for more details on the
1488 * realign_root paramter.
1490 * @todo for now this does not delete the typecodes associated with
1491 * the value, so this function should only be used for array elements.
1493 * @param reader reader indicating where to delete a value
1494 * @param realign_root realign from here
1495 * @returns #FALSE if not enough memory
1498 _dbus_type_reader_delete (DBusTypeReader *reader,
1499 const DBusTypeReader *realign_root)
1502 ReplacementBlock block;
1504 _dbus_assert (realign_root != NULL);
1505 _dbus_assert (reader->klass == &array_reader_class);
1509 if (!replacement_block_init (&block, reader))
1512 if (!replacement_block_replace (&block,
1520 replacement_block_free (&block);
1525 * Compares two readers, which must be iterating over the same value data.
1526 * Returns #TRUE if the first parameter is further along than the second parameter.
1528 * @param lhs left-hand-side (first) parameter
1529 * @param rhs left-hand-side (first) parameter
1530 * @returns whether lhs is greater than rhs
1533 _dbus_type_reader_greater_than (const DBusTypeReader *lhs,
1534 const DBusTypeReader *rhs)
1536 _dbus_assert (lhs->value_str == rhs->value_str);
1538 return lhs->value_pos > rhs->value_pos;
1551 * Initialize a write iterator, which is used to write out values in
1552 * serialized D-BUS format.
1554 * The type_pos passed in is expected to be inside an already-valid,
1555 * though potentially empty, type signature. This means that the byte
1556 * after type_pos must be either #DBUS_TYPE_INVALID (aka nul) or some
1557 * other valid type. #DBusTypeWriter won't enforce that the signature
1558 * is already valid (you can append the nul byte at the end if you
1559 * like), but just be aware that you need the nul byte eventually and
1560 * #DBusTypeWriter isn't going to write it for you.
1562 * @param writer the writer to init
1563 * @param byte_order the byte order to marshal into
1564 * @param type_str the string to write typecodes into
1565 * @param type_pos where to insert typecodes
1566 * @param value_str the string to write values into
1567 * @param value_pos where to insert values
1571 _dbus_type_writer_init (DBusTypeWriter *writer,
1573 DBusString *type_str,
1575 DBusString *value_str,
1578 writer->byte_order = byte_order;
1579 writer->type_str = type_str;
1580 writer->type_pos = type_pos;
1581 writer->value_str = value_str;
1582 writer->value_pos = value_pos;
1583 writer->container_type = DBUS_TYPE_INVALID;
1584 writer->type_pos_is_expectation = FALSE;
1585 writer->enabled = TRUE;
1587 #if RECURSIVE_MARSHAL_WRITE_TRACE
1588 _dbus_verbose ("writer %p init remaining sig '%s'\n", writer,
1590 _dbus_string_get_const_data_len (writer->type_str, writer->type_pos, 0) :
1596 * Initialize a write iterator, with the signature to be provided
1599 * @param writer the writer to init
1600 * @param byte_order the byte order to marshal into
1601 * @param value_str the string to write values into
1602 * @param value_pos where to insert values
1606 _dbus_type_writer_init_types_delayed (DBusTypeWriter *writer,
1608 DBusString *value_str,
1611 _dbus_type_writer_init (writer, byte_order,
1612 NULL, 0, value_str, value_pos);
1616 * Adds type string to the writer, if it had none.
1618 * @param writer the writer to init
1619 * @param type_str type string to add
1620 * @param type_pos type position
1624 _dbus_type_writer_add_types (DBusTypeWriter *writer,
1625 DBusString *type_str,
1628 if (writer->type_str == NULL) /* keeps us from using this as setter */
1630 writer->type_str = type_str;
1631 writer->type_pos = type_pos;
1636 * Removes type string from the writer.
1638 * @param writer the writer to remove from
1641 _dbus_type_writer_remove_types (DBusTypeWriter *writer)
1643 writer->type_str = NULL;
1644 writer->type_pos = -1;
1648 * Like _dbus_type_writer_init(), except the type string
1649 * passed in should correspond to an existing signature that
1650 * matches what you're going to write out. The writer will
1651 * check what you write vs. this existing signature.
1653 * @param writer the writer to init
1654 * @param byte_order the byte order to marshal into
1655 * @param type_str the string with signature
1656 * @param type_pos start of signature
1657 * @param value_str the string to write values into
1658 * @param value_pos where to insert values
1662 _dbus_type_writer_init_values_only (DBusTypeWriter *writer,
1664 const DBusString *type_str,
1666 DBusString *value_str,
1669 _dbus_type_writer_init (writer, byte_order,
1670 (DBusString*)type_str, type_pos,
1671 value_str, value_pos);
1673 writer->type_pos_is_expectation = TRUE;
1677 _dbus_type_writer_write_basic_no_typecode (DBusTypeWriter *writer,
1681 if (writer->enabled)
1682 return _dbus_marshal_write_basic (writer->value_str,
1687 &writer->value_pos);
1692 /* If our parent is an array, things are a little bit complicated.
1694 * The parent must have a complete element type, such as
1695 * "i" or "aai" or "(ii)" or "a(ii)". There can't be
1696 * unclosed parens, or an "a" with no following type.
1698 * To recurse, the only allowed operation is to recurse into the
1699 * first type in the element type. So for "i" you can't recurse, for
1700 * "ai" you can recurse into the array, for "(ii)" you can recurse
1703 * If you recurse into the array for "ai", then you must specify
1704 * "i" for the element type of the array you recurse into.
1706 * While inside an array at any level, we need to avoid writing to
1707 * type_str, since the type only appears once for the whole array,
1708 * it does not appear for each array element.
1710 * While inside an array type_pos points to the expected next
1711 * typecode, rather than the next place we could write a typecode.
1714 writer_recurse_init_and_check (DBusTypeWriter *writer,
1716 DBusTypeWriter *sub)
1718 _dbus_type_writer_init (sub,
1725 sub->container_type = container_type;
1727 if (writer->type_pos_is_expectation ||
1728 (sub->container_type == DBUS_TYPE_ARRAY || sub->container_type == DBUS_TYPE_VARIANT))
1729 sub->type_pos_is_expectation = TRUE;
1731 sub->type_pos_is_expectation = FALSE;
1733 sub->enabled = writer->enabled;
1735 #ifndef DBUS_DISABLE_CHECKS
1736 if (writer->type_pos_is_expectation && writer->type_str)
1740 expected = _dbus_first_type_in_signature (writer->type_str, writer->type_pos);
1742 if (expected != sub->container_type)
1744 _dbus_warn ("Writing an element of type %s, but the expected type here is %s\n",
1745 _dbus_type_to_string (sub->container_type),
1746 _dbus_type_to_string (expected));
1747 _dbus_assert_not_reached ("bad array element or variant content written");
1750 #endif /* DBUS_DISABLE_CHECKS */
1752 #if RECURSIVE_MARSHAL_WRITE_TRACE
1753 _dbus_verbose (" type writer %p recurse parent %s type_pos = %d value_pos = %d is_expectation = %d remaining sig '%s' enabled = %d\n",
1755 _dbus_type_to_string (writer->container_type),
1756 writer->type_pos, writer->value_pos, writer->type_pos_is_expectation,
1758 _dbus_string_get_const_data_len (writer->type_str, writer->type_pos, 0) :
1761 _dbus_verbose (" type writer %p recurse sub %s type_pos = %d value_pos = %d is_expectation = %d enabled = %d\n",
1763 _dbus_type_to_string (sub->container_type),
1764 sub->type_pos, sub->value_pos,
1765 sub->type_pos_is_expectation,
1771 write_or_verify_typecode (DBusTypeWriter *writer,
1774 /* A subwriter inside an array or variant will have type_pos
1775 * pointing to the expected typecode; a writer not inside an array
1776 * or variant has type_pos pointing to the next place to insert a
1779 #if RECURSIVE_MARSHAL_WRITE_TRACE
1780 _dbus_verbose (" type writer %p write_or_verify start type_pos = %d remaining sig '%s' enabled = %d\n",
1781 writer, writer->type_pos,
1783 _dbus_string_get_const_data_len (writer->type_str, writer->type_pos, 0) :
1788 if (writer->type_str == NULL)
1791 if (writer->type_pos_is_expectation)
1793 #ifndef DBUS_DISABLE_CHECKS
1797 expected = _dbus_string_get_byte (writer->type_str, writer->type_pos);
1799 if (expected != typecode)
1801 _dbus_warn ("Array or variant type requires that type %s be written, but %s was written\n",
1802 _dbus_type_to_string (expected), _dbus_type_to_string (typecode));
1803 _dbus_assert_not_reached ("bad type inserted somewhere inside an array or variant");
1806 #endif /* DBUS_DISABLE_CHECKS */
1808 /* if immediately inside an array we'd always be appending an element,
1809 * so the expected type doesn't change; if inside a struct or something
1810 * below an array, we need to move through said struct or something.
1812 if (writer->container_type != DBUS_TYPE_ARRAY)
1813 writer->type_pos += 1;
1817 if (!_dbus_string_insert_byte (writer->type_str,
1822 writer->type_pos += 1;
1825 #if RECURSIVE_MARSHAL_WRITE_TRACE
1826 _dbus_verbose (" type writer %p write_or_verify end type_pos = %d remaining sig '%s'\n",
1827 writer, writer->type_pos,
1828 _dbus_string_get_const_data_len (writer->type_str, writer->type_pos, 0));
1835 writer_recurse_struct_or_dict_entry (DBusTypeWriter *writer,
1837 const DBusString *contained_type,
1838 int contained_type_start,
1839 int contained_type_len,
1840 DBusTypeWriter *sub)
1842 /* FIXME right now contained_type is ignored; we could probably
1843 * almost trivially fix the code so if it's present we
1844 * write it out and then set type_pos_is_expectation
1847 /* Ensure that we'll be able to add alignment padding and the typecode */
1848 if (writer->enabled)
1850 if (!_dbus_string_alloc_space (sub->value_str, 8))
1854 if (!write_or_verify_typecode (sub, begin_char))
1855 _dbus_assert_not_reached ("failed to insert struct typecode after prealloc");
1857 if (writer->enabled)
1859 if (!_dbus_string_insert_bytes (sub->value_str,
1861 _DBUS_ALIGN_VALUE (sub->value_pos, 8) - sub->value_pos,
1863 _dbus_assert_not_reached ("should not have failed to insert alignment padding for struct");
1864 sub->value_pos = _DBUS_ALIGN_VALUE (sub->value_pos, 8);
1872 writer_recurse_array (DBusTypeWriter *writer,
1873 const DBusString *contained_type,
1874 int contained_type_start,
1875 int contained_type_len,
1876 DBusTypeWriter *sub,
1877 dbus_bool_t is_array_append)
1879 dbus_uint32_t value = 0;
1883 #ifndef DBUS_DISABLE_CHECKS
1884 if (writer->container_type == DBUS_TYPE_ARRAY &&
1887 if (!_dbus_string_equal_substring (contained_type,
1888 contained_type_start,
1891 writer->u.array.element_type_pos + 1))
1893 _dbus_warn ("Writing an array of '%s' but this is incompatible with the expected type of elements in the parent array\n",
1894 _dbus_string_get_const_data_len (contained_type,
1895 contained_type_start,
1896 contained_type_len));
1897 _dbus_assert_not_reached ("incompatible type for child array");
1900 #endif /* DBUS_DISABLE_CHECKS */
1902 if (writer->enabled && !is_array_append)
1904 /* 3 pad + 4 bytes for the array length, and 4 bytes possible padding
1905 * before array values
1907 if (!_dbus_string_alloc_space (sub->value_str, 3 + 4 + 4))
1911 if (writer->type_str != NULL)
1913 sub->type_pos += 1; /* move to point to the element type, since type_pos
1914 * should be the expected type for further writes
1916 sub->u.array.element_type_pos = sub->type_pos;
1919 if (!writer->type_pos_is_expectation)
1921 /* sub is a toplevel/outermost array so we need to write the type data */
1923 /* alloc space for array typecode, element signature */
1924 if (!_dbus_string_alloc_space (writer->type_str, 1 + contained_type_len))
1927 if (!_dbus_string_insert_byte (writer->type_str,
1930 _dbus_assert_not_reached ("failed to insert array typecode after prealloc");
1932 if (!_dbus_string_copy_len (contained_type,
1933 contained_type_start, contained_type_len,
1935 sub->u.array.element_type_pos))
1936 _dbus_assert_not_reached ("should not have failed to insert array element typecodes");
1939 if (writer->type_str != NULL)
1941 /* If the parent is an array, we hold type_pos pointing at the array element type;
1942 * otherwise advance it to reflect the array value we just recursed into
1944 if (writer->container_type != DBUS_TYPE_ARRAY)
1945 writer->type_pos += 1 + contained_type_len;
1947 _dbus_assert (writer->type_pos_is_expectation); /* because it's an array */
1950 if (writer->enabled)
1952 /* Write (or jump over, if is_array_append) the length */
1953 sub->u.array.len_pos = _DBUS_ALIGN_VALUE (sub->value_pos, 4);
1955 if (is_array_append)
1957 sub->value_pos += 4;
1961 if (!_dbus_type_writer_write_basic_no_typecode (sub, DBUS_TYPE_UINT32,
1963 _dbus_assert_not_reached ("should not have failed to insert array len");
1966 _dbus_assert (sub->u.array.len_pos == sub->value_pos - 4);
1968 /* Write alignment padding for array elements
1969 * Note that we write the padding *even for empty arrays*
1970 * to avoid wonky special cases
1972 alignment = element_type_get_alignment (contained_type, contained_type_start);
1974 aligned = _DBUS_ALIGN_VALUE (sub->value_pos, alignment);
1975 if (aligned != sub->value_pos)
1977 if (!is_array_append)
1979 if (!_dbus_string_insert_bytes (sub->value_str,
1981 aligned - sub->value_pos,
1983 _dbus_assert_not_reached ("should not have failed to insert alignment padding");
1986 sub->value_pos = aligned;
1989 sub->u.array.start_pos = sub->value_pos;
1991 if (is_array_append)
1995 _dbus_assert (_DBUS_ALIGN_VALUE (sub->u.array.len_pos, 4) ==
1996 (unsigned) sub->u.array.len_pos);
1997 len = _dbus_unpack_uint32 (sub->byte_order,
1998 _dbus_string_get_const_data_len (sub->value_str,
1999 sub->u.array.len_pos,
2002 sub->value_pos += len;
2007 /* not enabled, so we won't write the len_pos; set it to -1 to so indicate */
2008 sub->u.array.len_pos = -1;
2009 sub->u.array.start_pos = sub->value_pos;
2012 _dbus_assert (sub->u.array.len_pos < sub->u.array.start_pos);
2013 _dbus_assert (is_array_append || sub->u.array.start_pos == sub->value_pos);
2015 #if RECURSIVE_MARSHAL_WRITE_TRACE
2016 _dbus_verbose (" type writer %p recurse array done remaining sig '%s' array start_pos = %d len_pos = %d value_pos = %d\n", sub,
2018 _dbus_string_get_const_data_len (sub->type_str, sub->type_pos, 0) :
2020 sub->u.array.start_pos, sub->u.array.len_pos, sub->value_pos);
2026 /* Variant value will normally have:
2027 * 1 byte signature length not including nul
2028 * signature typecodes (nul terminated)
2029 * padding to alignment of contained type
2030 * body according to signature
2032 * The signature string can only have a single type
2033 * in it but that type may be complex/recursive.
2035 * So a typical variant type with the integer 3 will have these
2037 * 0x1 'i' '\0' [1 byte padding to alignment boundary] 0x0 0x0 0x0 0x3
2039 * The main world of hurt for writing out a variant is that the type
2040 * string is the same string as the value string. Which means
2041 * inserting to the type string will move the value_pos; and it means
2042 * that inserting to the type string could break type alignment.
2045 writer_recurse_variant (DBusTypeWriter *writer,
2046 const DBusString *contained_type,
2047 int contained_type_start,
2048 int contained_type_len,
2049 DBusTypeWriter *sub)
2051 int contained_alignment;
2053 if (writer->enabled)
2055 /* Allocate space for the worst case, which is 1 byte sig
2056 * length, nul byte at end of sig, and 7 bytes padding to
2059 if (!_dbus_string_alloc_space (sub->value_str, contained_type_len + 9))
2063 /* write VARIANT typecode to the parent's type string */
2064 if (!write_or_verify_typecode (writer, DBUS_TYPE_VARIANT))
2067 /* If not enabled, mark that we have no type_str anymore ... */
2069 if (!writer->enabled)
2071 sub->type_str = NULL;
2077 /* If we're enabled then continue ... */
2079 if (!_dbus_string_insert_byte (sub->value_str,
2081 contained_type_len))
2082 _dbus_assert_not_reached ("should not have failed to insert variant type sig len");
2084 sub->value_pos += 1;
2086 /* Here we switch over to the expected type sig we're about to write */
2087 sub->type_str = sub->value_str;
2088 sub->type_pos = sub->value_pos;
2090 if (!_dbus_string_copy_len (contained_type, contained_type_start, contained_type_len,
2091 sub->value_str, sub->value_pos))
2092 _dbus_assert_not_reached ("should not have failed to insert variant type sig");
2094 sub->value_pos += contained_type_len;
2096 if (!_dbus_string_insert_byte (sub->value_str,
2099 _dbus_assert_not_reached ("should not have failed to insert variant type nul termination");
2101 sub->value_pos += 1;
2103 contained_alignment = _dbus_type_get_alignment (_dbus_first_type_in_signature (contained_type, contained_type_start));
2105 if (!_dbus_string_insert_bytes (sub->value_str,
2107 _DBUS_ALIGN_VALUE (sub->value_pos, contained_alignment) - sub->value_pos,
2109 _dbus_assert_not_reached ("should not have failed to insert alignment padding for variant body");
2110 sub->value_pos = _DBUS_ALIGN_VALUE (sub->value_pos, contained_alignment);
2116 _dbus_type_writer_recurse_contained_len (DBusTypeWriter *writer,
2118 const DBusString *contained_type,
2119 int contained_type_start,
2120 int contained_type_len,
2121 DBusTypeWriter *sub,
2122 dbus_bool_t is_array_append)
2124 writer_recurse_init_and_check (writer, container_type, sub);
2126 switch (container_type)
2128 case DBUS_TYPE_STRUCT:
2129 return writer_recurse_struct_or_dict_entry (writer,
2130 DBUS_STRUCT_BEGIN_CHAR,
2132 contained_type_start, contained_type_len,
2135 case DBUS_TYPE_DICT_ENTRY:
2136 return writer_recurse_struct_or_dict_entry (writer,
2137 DBUS_DICT_ENTRY_BEGIN_CHAR,
2139 contained_type_start, contained_type_len,
2142 case DBUS_TYPE_ARRAY:
2143 return writer_recurse_array (writer,
2144 contained_type, contained_type_start, contained_type_len,
2145 sub, is_array_append);
2147 case DBUS_TYPE_VARIANT:
2148 return writer_recurse_variant (writer,
2149 contained_type, contained_type_start, contained_type_len,
2153 _dbus_assert_not_reached ("tried to recurse into type that doesn't support that");
2160 * Opens a new container and writes out the initial information for that container.
2162 * @param writer the writer
2163 * @param container_type the type of the container to open
2164 * @param contained_type the array element type or variant content type
2165 * @param contained_type_start position to look for the type
2166 * @param sub the new sub-writer to write container contents
2167 * @returns #FALSE if no memory
2170 _dbus_type_writer_recurse (DBusTypeWriter *writer,
2172 const DBusString *contained_type,
2173 int contained_type_start,
2174 DBusTypeWriter *sub)
2176 int contained_type_len;
2179 contained_type_len = find_len_of_complete_type (contained_type, contained_type_start);
2181 contained_type_len = 0;
2183 return _dbus_type_writer_recurse_contained_len (writer, container_type,
2185 contained_type_start,
2192 * Append to an existing array. Essentially, the writer will read an
2193 * existing length at the write location; jump over that length; and
2194 * write new fields. On unrecurse(), the existing length will be
2197 * @param writer the writer
2198 * @param contained_type element type
2199 * @param contained_type_start position of element type
2200 * @param sub the subwriter to init
2201 * @returns #FALSE if no memory
2204 _dbus_type_writer_append_array (DBusTypeWriter *writer,
2205 const DBusString *contained_type,
2206 int contained_type_start,
2207 DBusTypeWriter *sub)
2209 int contained_type_len;
2212 contained_type_len = find_len_of_complete_type (contained_type, contained_type_start);
2214 contained_type_len = 0;
2216 return _dbus_type_writer_recurse_contained_len (writer, DBUS_TYPE_ARRAY,
2218 contained_type_start,
2225 writer_get_array_len (DBusTypeWriter *writer)
2227 _dbus_assert (writer->container_type == DBUS_TYPE_ARRAY);
2228 return writer->value_pos - writer->u.array.start_pos;
2232 * Closes a container created by _dbus_type_writer_recurse()
2233 * and writes any additional information to the values block.
2235 * @param writer the writer
2236 * @param sub the sub-writer created by _dbus_type_writer_recurse()
2237 * @returns #FALSE if no memory
2240 _dbus_type_writer_unrecurse (DBusTypeWriter *writer,
2241 DBusTypeWriter *sub)
2243 /* type_pos_is_expectation never gets unset once set, or we'd get all hosed */
2244 _dbus_assert (!writer->type_pos_is_expectation ||
2245 (writer->type_pos_is_expectation && sub->type_pos_is_expectation));
2247 #if RECURSIVE_MARSHAL_WRITE_TRACE
2248 _dbus_verbose (" type writer %p unrecurse type_pos = %d value_pos = %d is_expectation = %d container_type = %s\n",
2249 writer, writer->type_pos, writer->value_pos, writer->type_pos_is_expectation,
2250 _dbus_type_to_string (writer->container_type));
2251 _dbus_verbose (" type writer %p unrecurse sub type_pos = %d value_pos = %d is_expectation = %d container_type = %s\n",
2252 sub, sub->type_pos, sub->value_pos,
2253 sub->type_pos_is_expectation,
2254 _dbus_type_to_string (sub->container_type));
2257 if (sub->container_type == DBUS_TYPE_STRUCT)
2259 if (!write_or_verify_typecode (sub, DBUS_STRUCT_END_CHAR))
2262 else if (sub->container_type == DBUS_TYPE_DICT_ENTRY)
2264 if (!write_or_verify_typecode (sub, DBUS_DICT_ENTRY_END_CHAR))
2267 else if (sub->container_type == DBUS_TYPE_ARRAY)
2269 if (sub->u.array.len_pos >= 0) /* len_pos == -1 if we weren't enabled when we passed it */
2273 /* Set the array length */
2274 len = writer_get_array_len (sub);
2275 _dbus_marshal_set_uint32 (sub->value_str,
2276 sub->u.array.len_pos,
2279 #if RECURSIVE_MARSHAL_WRITE_TRACE
2280 _dbus_verbose (" filled in sub array len to %u at len_pos %d\n",
2281 len, sub->u.array.len_pos);
2284 #if RECURSIVE_MARSHAL_WRITE_TRACE
2287 _dbus_verbose (" not filling in sub array len because we were disabled when we passed the len\n");
2292 /* Now get type_pos right for the parent writer. Here are the cases:
2294 * Cases !writer->type_pos_is_expectation:
2295 * (in these cases we want to update to the new insertion point)
2297 * - if we recursed into a STRUCT then we didn't know in advance
2298 * what the types in the struct would be; so we have to fill in
2299 * that information now.
2300 * writer->type_pos = sub->type_pos
2302 * - if we recursed into anything else, we knew the full array
2303 * type, or knew the single typecode marking VARIANT, so
2304 * writer->type_pos is already correct.
2305 * writer->type_pos should remain as-is
2307 * - note that the parent is never an ARRAY or VARIANT, if it were
2308 * then type_pos_is_expectation would be TRUE. The parent
2309 * is thus known to be a toplevel or STRUCT.
2311 * Cases where writer->type_pos_is_expectation:
2312 * (in these cases we want to update to next expected type to write)
2314 * - we recursed from STRUCT into STRUCT and we didn't increment
2315 * type_pos in the parent just to stay consistent with the
2316 * !writer->type_pos_is_expectation case (though we could
2317 * special-case this in recurse_struct instead if we wanted)
2318 * writer->type_pos = sub->type_pos
2320 * - we recursed from STRUCT into ARRAY or VARIANT and type_pos
2321 * for parent should have been incremented already
2322 * writer->type_pos should remain as-is
2324 * - we recursed from ARRAY into a sub-element, so type_pos in the
2325 * parent is the element type and should remain the element type
2326 * for the benefit of the next child element
2327 * writer->type_pos should remain as-is
2329 * - we recursed from VARIANT into its value, so type_pos in the
2330 * parent makes no difference since there's only one value
2331 * and we just finished writing it and won't use type_pos again
2332 * writer->type_pos should remain as-is
2335 * For all these, DICT_ENTRY is the same as STRUCT
2337 if (writer->type_str != NULL)
2339 if ((sub->container_type == DBUS_TYPE_STRUCT ||
2340 sub->container_type == DBUS_TYPE_DICT_ENTRY) &&
2341 (writer->container_type == DBUS_TYPE_STRUCT ||
2342 writer->container_type == DBUS_TYPE_DICT_ENTRY ||
2343 writer->container_type == DBUS_TYPE_INVALID))
2345 /* Advance the parent to the next struct field */
2346 writer->type_pos = sub->type_pos;
2350 writer->value_pos = sub->value_pos;
2352 #if RECURSIVE_MARSHAL_WRITE_TRACE
2353 _dbus_verbose (" type writer %p unrecursed type_pos = %d value_pos = %d remaining sig '%s'\n",
2354 writer, writer->type_pos, writer->value_pos,
2356 _dbus_string_get_const_data_len (writer->type_str, writer->type_pos, 0) :
2364 * Writes out a basic type.
2366 * @param writer the writer
2367 * @param type the type to write
2368 * @param value the address of the value to write
2369 * @returns #FALSE if no memory
2372 _dbus_type_writer_write_basic (DBusTypeWriter *writer,
2378 /* First ensure that our type realloc will succeed */
2379 if (!writer->type_pos_is_expectation && writer->type_str != NULL)
2381 if (!_dbus_string_alloc_space (writer->type_str, 1))
2387 if (!_dbus_type_writer_write_basic_no_typecode (writer, type, value))
2390 if (!write_or_verify_typecode (writer, type))
2391 _dbus_assert_not_reached ("failed to write typecode after prealloc");
2396 #if RECURSIVE_MARSHAL_WRITE_TRACE
2397 _dbus_verbose (" type writer %p basic type_pos = %d value_pos = %d is_expectation = %d enabled = %d\n",
2398 writer, writer->type_pos, writer->value_pos, writer->type_pos_is_expectation,
2406 * Writes a block of fixed-length basic values, i.e. those that are
2407 * both dbus_type_is_fixed() and _dbus_type_is_basic(). The block
2408 * must be written inside an array.
2410 * The value parameter should be the address of said array of values,
2411 * so e.g. if it's an array of double, pass in "const double**"
2413 * @param writer the writer
2414 * @param element_type type of stuff in the array
2415 * @param value address of the array
2416 * @param n_elements number of elements in the array
2417 * @returns #FALSE if no memory
2420 _dbus_type_writer_write_fixed_multi (DBusTypeWriter *writer,
2425 _dbus_assert (writer->container_type == DBUS_TYPE_ARRAY);
2426 _dbus_assert (dbus_type_is_fixed (element_type));
2427 _dbus_assert (writer->type_pos_is_expectation);
2428 _dbus_assert (n_elements >= 0);
2430 #if RECURSIVE_MARSHAL_WRITE_TRACE
2431 _dbus_verbose (" type writer %p entering fixed multi type_pos = %d value_pos = %d n_elements %d\n",
2432 writer, writer->type_pos, writer->value_pos, n_elements);
2435 if (!write_or_verify_typecode (writer, element_type))
2436 _dbus_assert_not_reached ("OOM should not happen if only verifying typecode");
2438 if (writer->enabled)
2440 if (!_dbus_marshal_write_fixed_multi (writer->value_str,
2446 &writer->value_pos))
2450 #if RECURSIVE_MARSHAL_WRITE_TRACE
2451 _dbus_verbose (" type writer %p fixed multi written new type_pos = %d new value_pos = %d n_elements %d\n",
2452 writer, writer->type_pos, writer->value_pos, n_elements);
2459 enable_if_after (DBusTypeWriter *writer,
2460 DBusTypeReader *reader,
2461 const DBusTypeReader *start_after)
2465 if (!writer->enabled && _dbus_type_reader_greater_than (reader, start_after))
2467 _dbus_type_writer_set_enabled (writer, TRUE);
2468 #if RECURSIVE_MARSHAL_WRITE_TRACE
2469 _dbus_verbose ("ENABLING writer %p at %d because reader at value_pos %d is after reader at value_pos %d\n",
2470 writer, writer->value_pos, reader->value_pos, start_after->value_pos);
2474 _dbus_assert ((!writer->enabled && !_dbus_type_reader_greater_than (reader, start_after)) ||
2475 (writer->enabled && _dbus_type_reader_greater_than (reader, start_after)));
2480 append_fixup (DBusList **fixups,
2481 const DBusArrayLenFixup *fixup)
2483 DBusArrayLenFixup *f;
2485 f = dbus_new (DBusArrayLenFixup, 1);
2491 if (!_dbus_list_append (fixups, f))
2497 _dbus_assert (f->len_pos_in_reader == fixup->len_pos_in_reader);
2498 _dbus_assert (f->new_len == fixup->new_len);
2503 /* This loop is trivial if you ignore all the start_after nonsense,
2504 * so if you're trying to figure it out, start by ignoring that
2507 writer_write_reader_helper (DBusTypeWriter *writer,
2508 DBusTypeReader *reader,
2509 const DBusTypeReader *start_after,
2510 int start_after_new_pos,
2511 int start_after_new_len,
2513 dbus_bool_t inside_start_after)
2517 while ((current_type = _dbus_type_reader_get_current_type (reader)) != DBUS_TYPE_INVALID)
2519 if (dbus_type_is_container (current_type))
2521 DBusTypeReader subreader;
2522 DBusTypeWriter subwriter;
2523 const DBusString *sig_str;
2526 dbus_bool_t enabled_at_recurse;
2527 dbus_bool_t past_start_after;
2528 int reader_array_len_pos;
2529 int reader_array_start_pos;
2530 dbus_bool_t this_is_start_after;
2532 /* type_pos is checked since e.g. in a struct the struct
2533 * and its first field have the same value_pos.
2534 * type_str will differ in reader/start_after for variants
2535 * where type_str is inside the value_str
2537 if (!inside_start_after && start_after &&
2538 reader->value_pos == start_after->value_pos &&
2539 reader->type_str == start_after->type_str &&
2540 reader->type_pos == start_after->type_pos)
2541 this_is_start_after = TRUE;
2543 this_is_start_after = FALSE;
2545 _dbus_type_reader_recurse (reader, &subreader);
2547 if (current_type == DBUS_TYPE_ARRAY)
2549 reader_array_len_pos = ARRAY_READER_LEN_POS (&subreader);
2550 reader_array_start_pos = subreader.u.array.start_pos;
2555 reader_array_len_pos = -1;
2556 reader_array_start_pos = -1;
2559 _dbus_type_reader_get_signature (&subreader, &sig_str,
2560 &sig_start, &sig_len);
2562 #if RECURSIVE_MARSHAL_WRITE_TRACE
2563 _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",
2564 _dbus_type_to_string (current_type),
2566 subreader.value_pos,
2568 start_after ? start_after->value_pos : -1,
2569 _dbus_string_get_length (writer->value_str),
2570 inside_start_after, this_is_start_after);
2573 if (!inside_start_after && !this_is_start_after)
2574 enable_if_after (writer, &subreader, start_after);
2575 enabled_at_recurse = writer->enabled;
2576 if (!_dbus_type_writer_recurse_contained_len (writer, current_type,
2577 sig_str, sig_start, sig_len,
2581 #if RECURSIVE_MARSHAL_WRITE_TRACE
2582 _dbus_verbose ("recursed into subwriter at %d write target len %d\n",
2583 subwriter.value_pos,
2584 _dbus_string_get_length (subwriter.value_str));
2587 if (!writer_write_reader_helper (&subwriter, &subreader, start_after,
2588 start_after_new_pos, start_after_new_len,
2590 inside_start_after ||
2591 this_is_start_after))
2594 #if RECURSIVE_MARSHAL_WRITE_TRACE
2595 _dbus_verbose ("about to unrecurse from %s subreader at %d writer at %d subwriter at %d write target len %d\n",
2596 _dbus_type_to_string (current_type),
2597 subreader.value_pos,
2599 subwriter.value_pos,
2600 _dbus_string_get_length (writer->value_str));
2603 if (!inside_start_after && !this_is_start_after)
2604 enable_if_after (writer, &subreader, start_after);
2605 past_start_after = writer->enabled;
2606 if (!_dbus_type_writer_unrecurse (writer, &subwriter))
2609 /* If we weren't enabled when we recursed, we didn't
2610 * write an array len; if we passed start_after
2611 * somewhere inside the array, then we need to generate
2614 if (start_after != NULL &&
2615 !enabled_at_recurse && past_start_after &&
2616 current_type == DBUS_TYPE_ARRAY &&
2619 DBusArrayLenFixup fixup;
2620 int bytes_written_after_start_after;
2621 int bytes_before_start_after;
2624 /* this subwriter access is moderately unkosher since we
2625 * already unrecursed, but it works as long as unrecurse
2626 * doesn't break us on purpose
2628 bytes_written_after_start_after = writer_get_array_len (&subwriter);
2630 bytes_before_start_after =
2631 start_after->value_pos - reader_array_start_pos;
2633 fixup.len_pos_in_reader = reader_array_len_pos;
2635 bytes_before_start_after +
2636 start_after_new_len +
2637 bytes_written_after_start_after;
2639 _dbus_assert (_DBUS_ALIGN_VALUE (fixup.len_pos_in_reader, 4) ==
2640 (unsigned) fixup.len_pos_in_reader);
2642 old_len = _dbus_unpack_uint32 (reader->byte_order,
2643 _dbus_string_get_const_data_len (reader->value_str,
2644 fixup.len_pos_in_reader, 4));
2646 if (old_len != fixup.new_len && !append_fixup (fixups, &fixup))
2649 #if RECURSIVE_MARSHAL_WRITE_TRACE
2650 _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",
2651 fixup.len_pos_in_reader,
2653 reader_array_start_pos,
2654 start_after->value_pos,
2655 bytes_before_start_after,
2656 start_after_new_len,
2657 bytes_written_after_start_after);
2665 _dbus_assert (dbus_type_is_basic (current_type));
2667 #if RECURSIVE_MARSHAL_WRITE_TRACE
2668 _dbus_verbose ("Reading basic value %s at %d\n",
2669 _dbus_type_to_string (current_type),
2673 _dbus_type_reader_read_basic (reader, &val);
2675 #if RECURSIVE_MARSHAL_WRITE_TRACE
2676 _dbus_verbose ("Writing basic value %s at %d write target len %d inside_start_after = %d\n",
2677 _dbus_type_to_string (current_type),
2679 _dbus_string_get_length (writer->value_str),
2680 inside_start_after);
2682 if (!inside_start_after)
2683 enable_if_after (writer, reader, start_after);
2684 if (!_dbus_type_writer_write_basic (writer, current_type, &val))
2686 #if RECURSIVE_MARSHAL_WRITE_TRACE
2687 _dbus_verbose ("Wrote basic value %s, new value_pos %d write target len %d\n",
2688 _dbus_type_to_string (current_type),
2690 _dbus_string_get_length (writer->value_str));
2694 _dbus_type_reader_next (reader);
2701 apply_and_free_fixups (fixups, NULL); /* NULL for reader to apply to */
2707 * Iterate through all values in the given reader, writing a copy of
2708 * each value to the writer. The reader will be moved forward to its
2711 * If a reader start_after is provided, it should be a reader for the
2712 * same data as the reader to be written. Only values occurring after
2713 * the value pointed to by start_after will be written to the writer.
2715 * If start_after is provided, then the copy of the reader will be
2716 * partial. This means that array lengths will not have been copied.
2717 * The assumption is that you wrote a new version of the value at
2718 * start_after to the writer. You have to pass in the start position
2719 * and length of the new value. (If you are deleting the value
2720 * at start_after, pass in 0 for the length.)
2722 * If the fixups parameter is non-#NULL, then any array length that
2723 * was read but not written due to start_after will be provided
2724 * as a #DBusArrayLenFixup. The fixup contains the position of the
2725 * array length in the source data, and the correct array length
2726 * assuming you combine the source data before start_after with
2727 * the written data at start_after and beyond.
2729 * @param writer the writer to copy to
2730 * @param reader the reader to copy from
2731 * @param start_after #NULL or a reader showing where to start
2732 * @param start_after_new_pos the position of start_after equivalent in the target data
2733 * @param start_after_new_len the length of start_after equivalent in the target data
2734 * @param fixups list to append #DBusArrayLenFixup if the write was partial
2735 * @returns #FALSE if no memory
2738 _dbus_type_writer_write_reader_partial (DBusTypeWriter *writer,
2739 DBusTypeReader *reader,
2740 const DBusTypeReader *start_after,
2741 int start_after_new_pos,
2742 int start_after_new_len,
2745 DBusTypeWriter orig;
2752 orig_type_len = _dbus_string_get_length (writer->type_str);
2753 orig_value_len = _dbus_string_get_length (writer->value_str);
2754 orig_enabled = writer->enabled;
2757 _dbus_type_writer_set_enabled (writer, FALSE);
2759 if (!writer_write_reader_helper (writer, reader, start_after,
2760 start_after_new_pos,
2761 start_after_new_len,
2765 _dbus_type_writer_set_enabled (writer, orig_enabled);
2769 if (!writer->type_pos_is_expectation)
2771 new_bytes = _dbus_string_get_length (writer->type_str) - orig_type_len;
2772 _dbus_string_delete (writer->type_str, orig.type_pos, new_bytes);
2774 new_bytes = _dbus_string_get_length (writer->value_str) - orig_value_len;
2775 _dbus_string_delete (writer->value_str, orig.value_pos, new_bytes);
2783 * Iterate through all values in the given reader, writing a copy of
2784 * each value to the writer. The reader will be moved forward to its
2787 * @param writer the writer to copy to
2788 * @param reader the reader to copy from
2789 * @returns #FALSE if no memory
2792 _dbus_type_writer_write_reader (DBusTypeWriter *writer,
2793 DBusTypeReader *reader)
2795 return _dbus_type_writer_write_reader_partial (writer, reader, NULL, 0, 0, NULL);
2799 * If disabled, a writer can still be iterated forward and recursed/unrecursed
2800 * but won't write any values. Types will still be written unless the
2801 * writer is a "values only" writer, because the writer needs access to
2802 * a valid signature to be able to iterate.
2804 * @param writer the type writer
2805 * @param enabled #TRUE if values should be written
2808 _dbus_type_writer_set_enabled (DBusTypeWriter *writer,
2809 dbus_bool_t enabled)
2811 writer->enabled = enabled != FALSE;
2814 /** @} */ /* end of DBusMarshal group */
2816 /* tests in dbus-marshal-recursive-util.c */