25 #include "dbus-marshal-recursive.h"    26 #include "dbus-marshal-basic.h"    27 #include "dbus-signature.h"    28 #include "dbus-internals.h"    43                                                            int                    start_after_new_pos,
    44                                                            int                    start_after_new_len,
    48 #define RECURSIVE_MARSHAL_READ_TRACE  0    51 #define RECURSIVE_MARSHAL_WRITE_TRACE 0    75 apply_and_free_fixups (
DBusList      **fixups,
    80 #if RECURSIVE_MARSHAL_WRITE_TRACE    82     _dbus_verbose (
" %d FIXUPS to apply\n",
    99 #if RECURSIVE_MARSHAL_WRITE_TRACE   100           _dbus_verbose (
" applying FIXUP to reader %p at pos %d new_len = %d old len %d\n",
   138 element_type_get_alignment (
const DBusString *str,
   175 struct_or_dict_entry_types_only_reader_recurse (
DBusTypeReader *sub,
   178   base_reader_recurse (sub, parent);
   182                 _dbus_string_get_byte (sub->
type_str,
   192   struct_or_dict_entry_types_only_reader_recurse (sub, parent);
   202   base_reader_recurse (sub, parent);
   214 #define ARRAY_READER_LEN_POS(reader) \   215   ((reader)->u.array.start_pos - ((int)(reader)->array_len_offset) - 4)   225   _dbus_assert (_DBUS_ALIGN_VALUE (len_pos, 4) == (
unsigned) len_pos);
   227                                    _dbus_string_get_const_udata_len (reader->
value_str, len_pos, 4));
   229 #if RECURSIVE_MARSHAL_READ_TRACE   230   _dbus_verbose (
"   reader %p len_pos %d array len %u len_offset %d\n",
   246   array_types_only_reader_recurse (sub, parent);
   254   alignment = element_type_get_alignment (sub->
type_str,
   263 #if RECURSIVE_MARSHAL_READ_TRACE   264   _dbus_verbose (
"    type reader %p array start = %d len_offset = %d array len = %d array element type = %s\n",
   266                  sub->
u.array.start_pos,
   268                  array_reader_get_array_len (sub),
   279   int contained_alignment;
   281   base_reader_recurse (sub, parent);
   299 #if RECURSIVE_MARSHAL_READ_TRACE   300   _dbus_verbose (
"    type reader %p variant containing '%s'\n",
   302                  _dbus_string_get_const_data_len (sub->
type_str,
   316   end_pos = reader->
u.array.start_pos + array_reader_get_array_len (reader);
   325 skip_one_complete_type (
const DBusString *type_str,
   344   const unsigned char *p;
   345   const unsigned char *start;
   350   start = (
const unsigned char *)type_str;
   351   p = start + *type_pos;
   421   *type_pos = (int) (p - start);
   425 find_len_of_complete_type (
const DBusString *type_str,
   432   skip_one_complete_type (type_str, &end);
   434   return end - type_pos;
   441   switch (current_type)
   508   base_reader_next (reader, current_type);
   529   base_reader_next (reader, current_type);
   563   end_pos = reader->
u.array.start_pos + array_reader_get_array_len (reader);
   565 #if RECURSIVE_MARSHAL_READ_TRACE   566   _dbus_verbose (
"  reader %p array next START start_pos = %d end_pos = %d value_pos = %d current_type = %s\n",
   568                  reader->
u.array.start_pos,
   618 #if RECURSIVE_MARSHAL_READ_TRACE   619   _dbus_verbose (
"  reader %p array next END start_pos = %d end_pos = %d value_pos = %d current_type = %s\n",
   621                  reader->
u.array.start_pos,
   630       skip_one_complete_type (reader->
type_str,
   654   struct_or_dict_entry_reader_recurse,
   662   struct_or_dict_entry_types_only_reader_recurse,
   670   struct_or_dict_entry_reader_recurse,
   672   dict_entry_reader_next
   676   "dict_entry types", 5,
   678   struct_or_dict_entry_types_only_reader_recurse,
   680   dict_entry_reader_next
   686   array_reader_recurse,
   687   array_reader_check_finished,
   694   array_types_only_reader_recurse,
   696   array_types_only_reader_next
   702   variant_reader_recurse,
   707 #ifndef DBUS_DISABLE_ASSERT   709 all_reader_classes[] = {
   711   &body_types_only_reader_class,
   712   &struct_reader_class,
   713   &struct_types_only_reader_class,
   714   &dict_entry_reader_class,
   715   &dict_entry_types_only_reader_class,
   717   &array_types_only_reader_class,
   718   &variant_reader_class
   740   reader_init (reader, byte_order, type_str, type_pos,
   741                value_str, value_pos);
   743   reader->
klass = &body_reader_class;
   745 #if RECURSIVE_MARSHAL_READ_TRACE   746   _dbus_verbose (
"  type reader %p init type_pos = %d value_pos = %d remaining sig '%s'\n",
   765   reader_init (reader, DBUS_COMPILER_BYTE_ORDER ,
   768   reader->
klass = &body_types_only_reader_class;
   770 #if RECURSIVE_MARSHAL_READ_TRACE   771   _dbus_verbose (
"  type reader %p init types only type_pos = %d remaining sig '%s'\n",
   804   _dbus_verbose (
"  type reader %p current type_pos = %d type = %s\n",
   854                             const unsigned char  **value_location)
   858   *value_location = _dbus_string_get_const_udata_len (reader->
value_str,
   886 #if RECURSIVE_MARSHAL_READ_TRACE   887   _dbus_verbose (
"  type reader %p read basic type_pos = %d value_pos = %d remaining sig '%s'\n",
   905   return array_reader_get_array_len (reader);
   947   total_len = array_reader_get_array_len (reader);
   948   end_pos = reader->
u.array.start_pos + total_len;
   949   remaining_len = end_pos - reader->
value_pos;
   951 #if RECURSIVE_MARSHAL_READ_TRACE   952   _dbus_verbose (
"end_pos %d total_len %d remaining_len %d value_pos %d\n",
   953                  end_pos, total_len, remaining_len, reader->
value_pos);
   958   if (remaining_len == 0)
   962       (
void*) _dbus_string_get_const_data_len (reader->
value_str,
   966   *n_elements = remaining_len / alignment;
   969 #if RECURSIVE_MARSHAL_READ_TRACE   970   _dbus_verbose (
"  type reader %p read fixed array type_pos = %d value_pos = %d remaining sig '%s'\n",
  1001         klass = &struct_types_only_reader_class;
  1003         klass = &struct_reader_class;
  1007         klass = &dict_entry_types_only_reader_class;
  1009         klass = &dict_entry_reader_class;
  1013         klass = &array_types_only_reader_class;
  1015         klass = &array_reader_class;
  1021         klass = &variant_reader_class;
  1025 #ifndef DBUS_DISABLE_CHECKS  1036   (* klass->
recurse) (sub, reader);
  1039 #if RECURSIVE_MARSHAL_READ_TRACE  1040   _dbus_verbose (
"  type reader %p RECURSED type_pos = %d value_pos = %d remaining sig '%s'\n",
  1061 #if RECURSIVE_MARSHAL_READ_TRACE  1062   _dbus_verbose (
"  type reader %p START next() { type_pos = %d value_pos = %d remaining sig '%s' current_type = %s\n",
  1073 #if RECURSIVE_MARSHAL_READ_TRACE  1074   _dbus_verbose (
"  type reader %p END next() type_pos = %d value_pos = %d remaining sig '%s' current_type = %s\n",
  1176   orig_len = _dbus_string_get_length (&block->
replacement);
  1178   realign_reader = *realign_root;
  1180 #if RECURSIVE_MARSHAL_WRITE_TRACE  1181   _dbus_verbose (
"INITIALIZING replacement block writer %p at value_pos %d\n",
  1182                  &writer, _dbus_string_get_length (&block->
replacement));
  1193 #if RECURSIVE_MARSHAL_WRITE_TRACE  1194   _dbus_verbose (
"COPYING from reader at value_pos %d to writer %p starting after value_pos %d\n",
  1198   if (!_dbus_type_writer_write_reader_partial (&writer,
  1206 #if RECURSIVE_MARSHAL_WRITE_TRACE  1207   _dbus_verbose (
"REPLACEMENT at padding %d len %d\n", block->
padding,
  1211   _dbus_verbose (
"TO BE REPLACED at value_pos = %d (align pad %d) len %d realign_reader.value_pos %d\n",
  1231   apply_and_free_fixups (&fixups, reader);
  1237   free_fixups (&fixups);
  1284   if (!replacement_block_init (&block, reader))
  1288 #if RECURSIVE_MARSHAL_WRITE_TRACE  1289   _dbus_verbose (
"INITIALIZING writer %p to write basic value at value_pos %d of replacement string\n",
  1290                  &writer, _dbus_string_get_length (&block.
replacement));
  1298 #if RECURSIVE_MARSHAL_WRITE_TRACE  1299   _dbus_verbose (
"WRITING basic value to writer %p (replacement string)\n", &writer);
  1304   if (!replacement_block_replace (&block,
  1312   replacement_block_free (&block);
  1376 #if RECURSIVE_MARSHAL_WRITE_TRACE  1377   _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",
  1381                  realign_root ? realign_root->
value_pos : -1,
  1384                                  _dbus_string_get_length (realign_root->
value_str) -
  1392       reader_set_basic_fixed_length (reader, current_type, value);
  1398       return reader_set_basic_variable_length (reader, current_type,
  1399                                                value, realign_root);
  1432   if (!replacement_block_init (&block, reader))
  1435   if (!replacement_block_replace (&block,
  1443   replacement_block_free (&block);
  1510 #if RECURSIVE_MARSHAL_WRITE_TRACE  1511   _dbus_verbose (
"writer %p init remaining sig '%s'\n", writer,
  1535                           NULL, 0, value_str, value_pos);
  1594                           value_str, value_pos);
  1600 _dbus_type_writer_write_basic_no_typecode (
DBusTypeWriter *writer,
  1658 #ifndef DBUS_DISABLE_CHECKS  1669                                      "The overall signature expected here was '%s' and we are on byte %d of that signature.",
  1675                                      "The overall signature expected here was '%s' and we are on byte %d of that signature.",
  1684 #if RECURSIVE_MARSHAL_WRITE_TRACE  1685   _dbus_verbose (
"  type writer %p recurse parent %s type_pos = %d value_pos = %d is_expectation = %d remaining sig '%s' enabled = %d\n",
  1693   _dbus_verbose (
"  type writer %p recurse sub %s   type_pos = %d value_pos = %d is_expectation = %d enabled = %d\n",
  1711 #if RECURSIVE_MARSHAL_WRITE_TRACE  1712   _dbus_verbose (
"  type writer %p write_or_verify start type_pos = %d remaining sig '%s' enabled = %d\n",
  1725 #ifndef DBUS_DISABLE_CHECKS  1731         if (expected != typecode)
  1735                                        "The overall signature expected here was '%s' and we are on byte %d of that signature.",
  1739               _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"  1740                                        "The overall signature expected here was '%s' and we are on byte %d of that signature.",
  1765 #if RECURSIVE_MARSHAL_WRITE_TRACE  1766   _dbus_verbose (
"  type writer %p write_or_verify end type_pos = %d remaining sig '%s'\n",
  1778                                      int               contained_type_start,
  1779                                      int               contained_type_len,
  1794   if (!write_or_verify_typecode (sub, begin_char))
  1814                       int               contained_type_start,
  1815                       int               contained_type_len,
  1823 #ifndef DBUS_DISABLE_CHECKS  1828                                          contained_type_start,
  1831                                          writer->
u.array.element_type_pos + 1))
  1833           _dbus_warn_check_failed (
"Writing an array of '%s' but this is incompatible with the expected type of elements in the parent array",
  1834                                    _dbus_string_get_const_data_len (contained_type,
  1835                                                                     contained_type_start,
  1836                                                                     contained_type_len));
  1842   if (writer->
enabled && !is_array_append)
  1856       sub->
u.array.element_type_pos = sub->
type_pos;
  1873                                   contained_type_start, contained_type_len,
  1875                                   sub->
u.array.element_type_pos))
  1885         writer->
type_pos += 1 + contained_type_len;
  1893       sub->
u.array.len_pos = _DBUS_ALIGN_VALUE (sub->
value_pos, 4);
  1895       if (is_array_append)
  1912       alignment = element_type_get_alignment (contained_type, contained_type_start);
  1914       aligned = _DBUS_ALIGN_VALUE (sub->
value_pos, alignment);
  1917           if (!is_array_append)
  1931       if (is_array_append)
  1935           _dbus_assert (_DBUS_ALIGN_VALUE (sub->
u.array.len_pos, 4) ==
  1936                         (
unsigned) sub->
u.array.len_pos);
  1938                                      _dbus_string_get_const_udata_len (sub->
value_str,
  1939                                                                       sub->
u.array.len_pos,
  1948       sub->
u.array.len_pos = -1;
  1955 #if RECURSIVE_MARSHAL_WRITE_TRACE  1956       _dbus_verbose (
"  type writer %p recurse array done remaining sig '%s' array start_pos = %d len_pos = %d value_pos = %d\n", sub,
  1960                      sub->
u.array.start_pos, sub->
u.array.len_pos, sub->
value_pos);
  1987                         int               contained_type_start,
  1988                         int               contained_type_len,
  1991   int contained_alignment;
  2021                                  contained_type_len))
  2059                                          int               contained_type_start,
  2060                                          int               contained_type_len,
  2064   writer_recurse_init_and_check (writer, container_type, sub);
  2066   switch (container_type)
  2069       return writer_recurse_struct_or_dict_entry (writer,
  2072                                                   contained_type_start, contained_type_len,
  2076       return writer_recurse_struct_or_dict_entry (writer,
  2079                                                   contained_type_start, contained_type_len,
  2083       return writer_recurse_array (writer,
  2084                                    contained_type, contained_type_start, contained_type_len,
  2085                                    sub, is_array_append);
  2088       return writer_recurse_variant (writer,
  2089                                      contained_type, contained_type_start, contained_type_len,
  2113                            int               contained_type_start,
  2116   int contained_type_len;
  2119     contained_type_len = find_len_of_complete_type (contained_type, contained_type_start);
  2121     contained_type_len = 0;
  2123   return _dbus_type_writer_recurse_contained_len (writer, container_type,
  2125                                                   contained_type_start,
  2146                                 int               contained_type_start,
  2149   int contained_type_len;
  2152     contained_type_len = find_len_of_complete_type (contained_type, contained_type_start);
  2154     contained_type_len = 0;
  2156   return _dbus_type_writer_recurse_contained_len (writer, 
DBUS_TYPE_ARRAY,
  2158                                                   contained_type_start,
  2168   return writer->
value_pos - writer->
u.array.start_pos;
  2187 #if RECURSIVE_MARSHAL_WRITE_TRACE  2188   _dbus_verbose (
"  type writer %p unrecurse type_pos = %d value_pos = %d is_expectation = %d container_type = %s\n",
  2191   _dbus_verbose (
"  type writer %p unrecurse sub type_pos = %d value_pos = %d is_expectation = %d container_type = %s\n",
  2209       if (sub->
u.array.len_pos >= 0) 
  2214           len = writer_get_array_len (sub);
  2216                                     sub->
u.array.len_pos,
  2219 #if RECURSIVE_MARSHAL_WRITE_TRACE  2220           _dbus_verbose (
"    filled in sub array len to %u at len_pos %d\n",
  2221                          len, sub->
u.array.len_pos);
  2224 #if RECURSIVE_MARSHAL_WRITE_TRACE  2227           _dbus_verbose (
"    not filling in sub array len because we were disabled when we passed the len\n");
  2292 #if RECURSIVE_MARSHAL_WRITE_TRACE  2293   _dbus_verbose (
"  type writer %p unrecursed type_pos = %d value_pos = %d remaining sig '%s'\n",
  2327   if (!_dbus_type_writer_write_basic_no_typecode (writer, type, value))
  2330   if (!write_or_verify_typecode (writer, type))
  2336 #if RECURSIVE_MARSHAL_WRITE_TRACE  2337   _dbus_verbose (
"  type writer %p basic type_pos = %d value_pos = %d is_expectation = %d enabled = %d\n",
  2370 #if RECURSIVE_MARSHAL_WRITE_TRACE  2371   _dbus_verbose (
"  type writer %p entering fixed multi type_pos = %d value_pos = %d n_elements %d\n",
  2375   if (!write_or_verify_typecode (writer, element_type))
  2390 #if RECURSIVE_MARSHAL_WRITE_TRACE  2391   _dbus_verbose (
"  type writer %p fixed multi written new type_pos = %d new value_pos = %d n_elements %d\n",
  2405       if (!writer->
enabled && _dbus_type_reader_greater_than (reader, start_after))
  2407           _dbus_type_writer_set_enabled (writer, 
TRUE);
  2408 #if RECURSIVE_MARSHAL_WRITE_TRACE  2409           _dbus_verbose (
"ENABLING writer %p at %d because reader at value_pos %d is after reader at value_pos %d\n",
  2414       _dbus_assert ((!writer->
enabled && !_dbus_type_reader_greater_than (reader, start_after)) ||
  2415                     (writer->
enabled && _dbus_type_reader_greater_than (reader, start_after)));
  2450                             int                   start_after_new_pos,
  2451                             int                   start_after_new_len,
  2468           int reader_array_len_pos;
  2469           int reader_array_start_pos;
  2477           if (!inside_start_after && start_after &&
  2481             this_is_start_after = 
TRUE;
  2483             this_is_start_after = 
FALSE;
  2490               reader_array_start_pos = subreader.
u.array.start_pos;
  2495               reader_array_len_pos = -1;
  2496               reader_array_start_pos = -1;
  2500                                            &sig_start, &sig_len);
  2502 #if RECURSIVE_MARSHAL_WRITE_TRACE  2503           _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",
  2508                          start_after ? start_after->
value_pos : -1,
  2509                          _dbus_string_get_length (writer->
value_str),
  2510                          inside_start_after, this_is_start_after);
  2513           if (!inside_start_after && !this_is_start_after)
  2514             enable_if_after (writer, &subreader, start_after);
  2515           enabled_at_recurse = writer->
enabled;
  2516           if (!_dbus_type_writer_recurse_contained_len (writer, current_type,
  2517                                                         sig_str, sig_start, sig_len,
  2521 #if RECURSIVE_MARSHAL_WRITE_TRACE  2522           _dbus_verbose (
"recursed into subwriter at %d write target len %d\n",
  2524                          _dbus_string_get_length (subwriter.
value_str));
  2527           if (!writer_write_reader_helper (&subwriter, &subreader, start_after,
  2528                                            start_after_new_pos, start_after_new_len,
  2530                                            inside_start_after ||
  2531                                            this_is_start_after))
  2534 #if RECURSIVE_MARSHAL_WRITE_TRACE  2535           _dbus_verbose (
"about to unrecurse from %s subreader at %d writer at %d subwriter at %d  write target len %d\n",
  2540                          _dbus_string_get_length (writer->
value_str));
  2543           if (!inside_start_after && !this_is_start_after)
  2544             enable_if_after (writer, &subreader, start_after);
  2545           past_start_after = writer->
enabled;
  2554           if (start_after != 
NULL &&
  2555               !enabled_at_recurse && past_start_after &&
  2560               int bytes_written_after_start_after;
  2561               int bytes_before_start_after;
  2568               bytes_written_after_start_after = writer_get_array_len (&subwriter);
  2570               bytes_before_start_after =
  2571                 start_after->
value_pos - reader_array_start_pos;
  2575                 bytes_before_start_after +
  2576                 start_after_new_len +
  2577                 bytes_written_after_start_after;
  2583                                              _dbus_string_get_const_udata_len (reader->
value_str,
  2586               if (old_len != fixup.
new_len && !append_fixup (fixups, &fixup))
  2589 #if RECURSIVE_MARSHAL_WRITE_TRACE  2590               _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",
  2593                              reader_array_start_pos,
  2595                              bytes_before_start_after,
  2596                              start_after_new_len,
  2597                              bytes_written_after_start_after);
  2607 #if RECURSIVE_MARSHAL_WRITE_TRACE  2608           _dbus_verbose (
"Reading basic value %s at %d\n",
  2615 #if RECURSIVE_MARSHAL_WRITE_TRACE  2616           _dbus_verbose (
"Writing basic value %s at %d write target len %d inside_start_after = %d\n",
  2619                          _dbus_string_get_length (writer->
value_str),
  2620                          inside_start_after);
  2622           if (!inside_start_after)
  2623             enable_if_after (writer, reader, start_after);
  2626 #if RECURSIVE_MARSHAL_WRITE_TRACE  2627           _dbus_verbose (
"Wrote basic value %s, new value_pos %d write target len %d\n",
  2630                          _dbus_string_get_length (writer->
value_str));
  2641     apply_and_free_fixups (fixups, 
NULL); 
  2681                                         int                   start_after_new_pos,
  2682                                         int                   start_after_new_len,
  2692   orig_type_len = _dbus_string_get_length (writer->
type_str);
  2693   orig_value_len = _dbus_string_get_length (writer->
value_str);
  2694   orig_enabled = writer->
enabled;
  2697     _dbus_type_writer_set_enabled (writer, 
FALSE);
  2699   if (!writer_write_reader_helper (writer, reader, start_after,
  2700                                    start_after_new_pos,
  2701                                    start_after_new_len,
  2705   _dbus_type_writer_set_enabled (writer, orig_enabled);
  2711       new_bytes = _dbus_string_get_length (writer->
type_str) - orig_type_len;
  2714   new_bytes = _dbus_string_get_length (writer->
value_str) - orig_value_len;
  2735   return _dbus_type_writer_write_reader_partial (writer, reader, 
NULL, 0, 0, 
NULL);
 dbus_bool_t dbus_type_is_fixed(int typecode)
Tells you whether values of this type can change length if you set them to some other value...
dbus_bool_t _dbus_string_insert_bytes(DBusString *str, int i, int n_bytes, unsigned char byte)
Inserts a number of bytes of a given value at the given position. 
const DBusString * type_str
string containing signature of block 
void _dbus_type_reader_read_fixed_multi(const DBusTypeReader *reader, void *value, int *n_elements)
Reads a block of fixed-length basic values, from the current point in an array to the end of the arra...
unsigned int dbus_uint32_t
A 32-bit unsigned integer on all platforms. 
void _dbus_marshal_skip_basic(const DBusString *str, int type, int byte_order, int *pos)
Skips over a basic-typed value, reporting the following position. 
#define NULL
A null pointer, defined appropriately for C or C++. 
void _dbus_marshal_set_uint32(DBusString *str, int pos, dbus_uint32_t value, int byte_order)
Sets the 4 bytes at the given offset to a marshaled unsigned integer, replacing anything found there ...
void _dbus_type_writer_remove_types(DBusTypeWriter *writer)
Removes type string from the writer. 
dbus_bool_t _dbus_string_lengthen(DBusString *str, int additional_length)
Makes a string longer by the given number of bytes. 
void dbus_free(void *memory)
Frees a block of memory previously allocated by dbus_malloc() or dbus_malloc0(). 
int _dbus_first_type_in_signature(const DBusString *str, int pos)
Get the first type in the signature. 
The type writer is an iterator for writing to a block of values. 
void _dbus_type_reader_recurse(DBusTypeReader *reader, DBusTypeReader *sub)
Initialize a new reader pointing to the first type and corresponding value that's a child of the curr...
void(* recurse)(DBusTypeReader *sub, DBusTypeReader *parent)
recurse with this reader as sub 
void(* next)(DBusTypeReader *reader, int current_type)
go to the next value 
#define dbus_new(type, count)
Safe macro for using dbus_malloc(). 
dbus_uint32_t finished
marks we're at end iterator for cases where we don't have another way to tell 
#define DBUS_TYPE_STRUCT
STRUCT and DICT_ENTRY are sort of special since their codes can't appear in a type string...
#define DBUS_TYPE_DICT_ENTRY
Type code used to represent a dict entry; however, this type code does not appear in type signatures...
#define _dbus_assert(condition)
Aborts with an error message if the condition is false. 
int type_pos
current position in signature 
void * data
Data stored at this element. 
void _dbus_warn_check_failed(const char *format,...)
Prints a "critical" warning to stderr when an assertion fails; differs from _dbus_warn primarily in t...
void _dbus_type_signature_next(const char *type_str, int *type_pos)
Skips to the next "complete" type inside a type signature. 
dbus_uint32_t type_pos_is_expectation
type_pos can be either an insertion point for or an expected next type 
Virtual table for a type reader. 
int padding
How much of the replacement block is padding. 
dbus_bool_t _dbus_type_writer_write_basic(DBusTypeWriter *writer, int type, const void *value)
Writes out a basic type. 
dbus_bool_t _dbus_string_init(DBusString *str)
Initializes a string. 
void _dbus_type_reader_init_types_only(DBusTypeReader *reader, const DBusString *type_str, int type_pos)
Like _dbus_type_reader_init() but the iteration is over the signature, not over values. 
const char * name
name for debugging 
int new_len
the new value of the length in the written-out block 
#define DBUS_DICT_ENTRY_BEGIN_CHAR
Code marking the start of a dict entry type in a type signature. 
#define DBUS_STRUCT_END_CHAR
Code marking the end of a struct type in a type signature. 
DBusString * value_str
where to write values 
#define _dbus_list_get_next_link(list, link)
Gets the next link in the list, or NULL if there are no more links. 
int type_pos
current pos in type_str 
#define _DBUS_INT_MAX
Maximum value of type "int". 
#define DBUS_TYPE_ARRAY
Type code marking a D-Bus array type. 
DBusString * type_str
where to write typecodes (or read type expectations) 
const DBusTypeReaderClass * klass
the vtable for the reader 
dbus_uint32_t _dbus_unpack_uint32(int byte_order, const unsigned char *data)
Unpacks a 32 bit unsigned integer from a data pointer. 
dbus_bool_t _dbus_type_reader_delete(DBusTypeReader *reader, const DBusTypeReader *realign_root)
Recursively deletes any value pointed to by the reader, leaving the reader valid to continue reading...
void _dbus_type_writer_init_values_only(DBusTypeWriter *writer, int byte_order, const DBusString *type_str, int type_pos, DBusString *value_str, int value_pos)
Like _dbus_type_writer_init(), except the type string passed in should correspond to an existing sign...
dbus_bool_t _dbus_type_reader_set_basic(DBusTypeReader *reader, const void *value, const DBusTypeReader *realign_root)
Sets a new value for the basic type value pointed to by the reader, leaving the reader valid to conti...
void _dbus_type_writer_init_types_delayed(DBusTypeWriter *writer, int byte_order, DBusString *value_str, int value_pos)
Initialize a write iterator, with the signature to be provided later. 
DBusString replacement
Marshaled value including alignment padding. 
dbus_bool_t _dbus_type_writer_unrecurse(DBusTypeWriter *writer, DBusTypeWriter *sub)
Closes a container created by _dbus_type_writer_recurse() and writes any additional information to th...
dbus_bool_t dbus_type_is_basic(int typecode)
A "basic type" is a somewhat arbitrary concept, but the intent is to include those types that are ful...
dbus_uint32_t dbus_bool_t
A boolean, valid values are TRUE and FALSE. 
void _dbus_type_reader_read_basic(const DBusTypeReader *reader, void *value)
Reads a basic-typed value, as with _dbus_marshal_read_basic(). 
dbus_bool_t _dbus_string_replace_len(const DBusString *source, int start, int len, DBusString *dest, int replace_at, int replace_len)
Replaces a segment of dest string with a segment of source string. 
void _dbus_marshal_skip_array(const DBusString *str, int element_type, int byte_order, int *pos)
Skips an array, returning the next position. 
void _dbus_string_delete(DBusString *str, int start, int len)
Deletes a segment of a DBusString with length len starting at start. 
dbus_bool_t _dbus_list_append(DBusList **list, void *data)
Appends a value to the list. 
dbus_bool_t _dbus_type_writer_append_array(DBusTypeWriter *writer, const DBusString *contained_type, int contained_type_start, DBusTypeWriter *sub)
Append to an existing array. 
void _dbus_marshal_read_basic(const DBusString *str, int pos, int type, void *value, int byte_order, int *new_pos)
Demarshals a basic-typed value. 
dbus_bool_t _dbus_type_reader_next(DBusTypeReader *reader)
Skip to the next value on this "level". 
When modifying an existing block of values, array lengths may need to be adjusted; those adjustments ...
dbus_bool_t _dbus_string_equal_substring(const DBusString *a, int a_start, int a_len, const DBusString *b, int b_start)
Tests two sub-parts of two DBusString for equality. 
#define DBUS_STRUCT_BEGIN_CHAR
Code marking the start of a struct type in a type signature. 
dbus_uint32_t enabled
whether to write values 
#define DBUS_TYPE_VARIANT
Type code marking a D-Bus variant type. 
#define DBUS_TYPE_UINT32
Type code marking a 32-bit unsigned integer. 
dbus_bool_t _dbus_marshal_write_fixed_multi(DBusString *str, int insert_at, int element_type, const void *value, int n_elements, int byte_order, int *pos_after)
Marshals a block of values of fixed-length type all at once, as an optimization. 
dbus_uint32_t byte_order
byte order of the block 
dbus_bool_t _dbus_string_insert_byte(DBusString *str, int i, unsigned char byte)
Inserts a single byte at the given position. 
dbus_uint32_t byte_order
byte order to write values with 
void _dbus_string_free(DBusString *str)
Frees a string created by _dbus_string_init(). 
The type reader is an iterator for reading values from a block of values. 
#define TRUE
Expands to "1". 
#define _dbus_assert_not_reached(explanation)
Aborts with an error message if called. 
void _dbus_type_writer_add_types(DBusTypeWriter *writer, DBusString *type_str, int type_pos)
Adds type string to the writer, if it had none. 
void _dbus_list_free_link(DBusList *link)
Frees a linked list node allocated with _dbus_list_alloc_link. 
dbus_bool_t _dbus_type_writer_write_reader(DBusTypeWriter *writer, DBusTypeReader *reader)
Iterate through all values in the given reader, writing a copy of each value to the writer...
#define DBUS_TYPE_INVALID
Type code that is never equal to a legitimate type code. 
dbus_bool_t _dbus_string_alloc_space(DBusString *str, int extra_bytes)
Preallocate extra_bytes such that a future lengthening of the string by extra_bytes is guaranteed to ...
int value_pos
next position to write 
dbus_bool_t types_only
only iterates over types, not values 
void _dbus_type_reader_init(DBusTypeReader *reader, int byte_order, const DBusString *type_str, int type_pos, const DBusString *value_str, int value_pos)
Initializes a type reader. 
union DBusTypeReader::@1 u
class-specific data 
int len_pos_in_reader
where the length was in the original block 
int _dbus_type_reader_get_element_type(const DBusTypeReader *reader)
Gets the type of an element of the array the reader is currently pointing to. 
int _dbus_list_get_length(DBusList **list)
Gets the length of a list. 
void _dbus_type_writer_init(DBusTypeWriter *writer, int byte_order, DBusString *type_str, int type_pos, DBusString *value_str, int value_pos)
Initialize a write iterator, which is used to write out values in serialized D-Bus format...
union DBusTypeWriter::@3 u
class-specific data 
dbus_bool_t _dbus_type_reader_has_next(const DBusTypeReader *reader)
Check whether there's another value on this "level". 
A simple value union that lets you access bytes as if they were various types; useful when dealing wi...
dbus_uint32_t container_type
what are we inside? (e.g. 
int _dbus_type_reader_get_array_length(const DBusTypeReader *reader)
Returns the number of bytes in the array. 
int _dbus_type_reader_get_current_type(const DBusTypeReader *reader)
Gets the type of the value the reader is currently pointing to; or for a types-only reader gets the t...
DBusList * _dbus_list_get_first_link(DBusList **list)
Gets the first link in the list. 
#define FALSE
Expands to "0". 
#define DBUS_DICT_ENTRY_END_CHAR
Code marking the end of a dict entry type in a type signature. 
dbus_bool_t _dbus_string_set_length(DBusString *str, int length)
Sets the length of a string. 
const char * _dbus_type_to_string(int typecode)
Returns a string describing the given type. 
dbus_bool_t _dbus_string_copy_len(const DBusString *source, int start, int len, DBusString *dest, int insert_at)
Like _dbus_string_copy(), but can copy a segment from the middle of the source string. 
void _dbus_type_reader_get_signature(const DBusTypeReader *reader, const DBusString **str_p, int *start_p, int *len_p)
Gets the string and range of said string containing the signature of the current value. 
dbus_bool_t _dbus_type_writer_write_fixed_multi(DBusTypeWriter *writer, int element_type, const void *value, int n_elements)
Writes a block of fixed-length basic values, i.e. 
DBUS_PRIVATE_EXPORT void _dbus_verbose_bytes_of_string(const DBusString *str, int start, int len)
Dump the given part of the string to verbose log. 
#define _DBUS_ZERO(object)
Sets all bits in an object to zero. 
dbus_uint32_t array_len_offset
bytes back from start_pos that len ends 
int value_pos
current position in values 
int _dbus_type_get_alignment(int typecode)
Gets the alignment requirement for the given type; will be 1, 4, or 8. 
const DBusString * value_str
string containing values of block 
#define ARRAY_READER_LEN_POS(reader)
compute position of array length given array_len_offset, which is the offset back from start_pos to e...
dbus_bool_t _dbus_marshal_set_basic(DBusString *str, int pos, int type, const void *value, int byte_order, int *old_end_pos, int *new_end_pos)
Sets an existing basic type value to a new value. 
int id
index in all_reader_classes 
dbus_bool_t _dbus_type_writer_recurse(DBusTypeWriter *writer, int container_type, const DBusString *contained_type, int contained_type_start, DBusTypeWriter *sub)
Opens a new container and writes out the initial information for that container. 
dbus_bool_t(* check_finished)(const DBusTypeReader *reader)
check whether reader is at the end 
dbus_bool_t _dbus_marshal_write_basic(DBusString *str, int insert_at, int type, const void *value, int byte_order, int *pos_after)
Marshals a basic-typed value. 
int _dbus_type_reader_get_value_pos(const DBusTypeReader *reader)
Gets the current position in the value block. 
void _dbus_type_reader_read_raw(const DBusTypeReader *reader, const unsigned char **value_location)
Get the address of the marshaled value in the data being read. 
dbus_bool_t dbus_type_is_container(int typecode)
A "container type" can contain basic types, or nested container types. 
dbus_uint32_t _dbus_marshal_read_uint32(const DBusString *str, int pos, int byte_order, int *new_pos)
Convenience function to demarshal a 32 bit unsigned integer.