26 #include "dbus-internals.h" 
   27 #include "dbus-marshal-basic.h" 
   28 #include "dbus-signature.h" 
   32 #if !defined(PRIx64) && defined(DBUS_WIN) 
   36 #if defined(__GNUC__) && (__GNUC__ >= 4) 
   37 # define _DBUS_ASSERT_ALIGNMENT(type, op, val) \ 
   38   _DBUS_STATIC_ASSERT (__extension__ __alignof__ (type) op val) 
   42 # define _DBUS_ASSERT_ALIGNMENT(type, op, val) \ 
   43   _DBUS_STATIC_ASSERT (TRUE) 
   47 _DBUS_STATIC_ASSERT (
sizeof (
char) == 1);
 
   48 _DBUS_ASSERT_ALIGNMENT (
char, ==, 1);
 
   62 _DBUS_STATIC_ASSERT (
sizeof (
double) == 8);
 
   63 _DBUS_ASSERT_ALIGNMENT (
double, <=, 8);
 
  143   pack_4_octets (value, byte_order, data);
 
  150   if (byte_order != DBUS_COMPILER_BYTE_ORDER)
 
  152       value->
u64 = DBUS_UINT64_SWAP_LE_BE (value->
u64);
 
  156 #ifndef _dbus_unpack_uint16 
  166                      const unsigned char *data)
 
  177 #ifndef _dbus_unpack_uint32 
  187                      const unsigned char *data)
 
  211   pack_2_octets (value, byte_order, (
unsigned char *) data);
 
  227   pack_4_octets (value, byte_order, (
unsigned char *) data);
 
  243   pack_8_octets (value, byte_order, (
unsigned char *) data);
 
  262   set_4_octets (str, pos, value, byte_order);
 
  292   int old_len, new_len;
 
  297   _dbus_assert (_DBUS_ALIGN_VALUE (pos, 4) == (
unsigned) pos);
 
  299                                  _dbus_string_get_const_udata_len (str, pos, 4));
 
  301   new_len = _dbus_string_get_length (&dstr);
 
  304                                  str, pos + 4, old_len))
 
  310     *old_end_pos = pos + 4 + old_len + 1;
 
  312     *new_end_pos = pos + 4 + new_len + 1;
 
  338   int old_len, new_len;
 
  343   old_len = _dbus_string_get_byte (str, pos);
 
  344   new_len = _dbus_string_get_length (&dstr);
 
  347                                  str, pos + 1, old_len))
 
  350   _dbus_string_set_byte (str, pos, new_len);
 
  353     *old_end_pos = pos + 1 + old_len + 1;
 
  355     *new_end_pos = pos + 1 + new_len + 1;
 
  389       _dbus_string_set_byte (str, pos, vp->
byt);
 
  391         *old_end_pos = pos + 1;
 
  393         *new_end_pos = pos + 1;
 
  398       pos = _DBUS_ALIGN_VALUE (pos, 2);
 
  399       set_2_octets (str, pos, vp->
u16, byte_order);
 
  401         *old_end_pos = pos + 2;
 
  403         *new_end_pos = pos + 2;
 
  410       pos = _DBUS_ALIGN_VALUE (pos, 4);
 
  411       set_4_octets (str, pos, vp->
u32, byte_order);
 
  413         *old_end_pos = pos + 4;
 
  415         *new_end_pos = pos + 4;
 
  421       pos = _DBUS_ALIGN_VALUE (pos, 8);
 
  422       set_8_octets (str, pos, *vp, byte_order);
 
  424         *old_end_pos = pos + 8;
 
  426         *new_end_pos = pos + 8;
 
  431       pos = _DBUS_ALIGN_VALUE (pos, 4);
 
  433       return set_string (str, pos, vp->
str, byte_order,
 
  434                          old_end_pos, new_end_pos);
 
  438       return set_signature (str, pos, vp->
str, byte_order,
 
  439                             old_end_pos, new_end_pos);
 
  463   pos = _DBUS_ALIGN_VALUE (pos, 4);
 
  468   _dbus_assert (pos + 4 <= _dbus_string_get_length (str));
 
  471                               _dbus_string_get_const_udata (str) + pos);
 
  503   const char *str_data;
 
  507   str_data = _dbus_string_get_const_data (str);
 
  517       volatile unsigned char *vp = value;
 
  518       *vp = (
unsigned char) _dbus_string_get_byte (str, pos);
 
  526       pos = _DBUS_ALIGN_VALUE (pos, 2);
 
  528       if (byte_order != DBUS_COMPILER_BYTE_ORDER)
 
  529         *vp = DBUS_UINT16_SWAP_LE_BE (*vp);
 
  539       pos = _DBUS_ALIGN_VALUE (pos, 4);
 
  541       if (byte_order != DBUS_COMPILER_BYTE_ORDER)
 
  542         *vp = DBUS_UINT32_SWAP_LE_BE (*vp);
 
  551       pos = _DBUS_ALIGN_VALUE (pos, 8);
 
  552       if (byte_order != DBUS_COMPILER_BYTE_ORDER)
 
  553         *vp = DBUS_UINT64_SWAP_LE_BE (*(
dbus_uint64_t*)(str_data + pos));
 
  563         volatile char **vp = value;
 
  567         *vp = (
char*) str_data + pos;
 
  575         volatile char **vp = value;
 
  577         len = _dbus_string_get_byte (str, pos);
 
  580         *vp = (
char*) str_data + pos;
 
  606   _DBUS_STATIC_ASSERT (
sizeof (value) == 2);
 
  608   if (byte_order != DBUS_COMPILER_BYTE_ORDER)
 
  609     value = DBUS_UINT16_SWAP_LE_BE (value);
 
  611   orig_len = _dbus_string_get_length (str);
 
  614                                           (
const unsigned char *)&value);
 
  618       *pos_after = insert_at + (_dbus_string_get_length (str) - orig_len);
 
  619       _dbus_assert (*pos_after <= _dbus_string_get_length (str));
 
  635   _DBUS_STATIC_ASSERT (
sizeof (value) == 4);
 
  637   if (byte_order != DBUS_COMPILER_BYTE_ORDER)
 
  638     value = DBUS_UINT32_SWAP_LE_BE (value);
 
  640   orig_len = _dbus_string_get_length (str);
 
  643                                           (
const unsigned char *)&value);
 
  647       *pos_after = insert_at + (_dbus_string_get_length (str) - orig_len);
 
  648       _dbus_assert (*pos_after <= _dbus_string_get_length (str));
 
  664   _DBUS_STATIC_ASSERT (
sizeof (value) == 8);
 
  666   swap_8_octets (&value, byte_order);
 
  668   orig_len = _dbus_string_get_length (str);
 
  671                                           (
const unsigned char *)&value);
 
  674     *pos_after = insert_at + _dbus_string_get_length (str) - orig_len;
 
  682     MARSHAL_AS_SIGNATURE,
 
  683     MARSHAL_AS_BYTE_ARRAY
 
  687 marshal_len_followed_by_bytes (
int                  marshal_as,
 
  690                                const unsigned char *value,
 
  700   if (insert_at > _dbus_string_get_length (str))
 
  701     _dbus_warn (
"insert_at = %d string len = %d data_len = %d",
 
  702                 insert_at, _dbus_string_get_length (str), data_len);
 
  704   if (marshal_as == MARSHAL_AS_BYTE_ARRAY)
 
  705     value_len = data_len;
 
  707     value_len = data_len + 1; 
 
  713   if (marshal_as == MARSHAL_AS_SIGNATURE)
 
  725       if (!marshal_4_octets (str, pos, data_len,
 
  762   return marshal_len_followed_by_bytes (MARSHAL_AS_STRING,
 
  763                                         str, insert_at, (
const unsigned char *) value,
 
  765                                         byte_order, pos_after);
 
  774   return marshal_len_followed_by_bytes (MARSHAL_AS_SIGNATURE,
 
  775                                         str, insert_at, (
const unsigned char *) value,
 
  777                                         DBUS_COMPILER_BYTE_ORDER, 
 
  817         *pos_after = insert_at + 1;
 
  822       return marshal_2_octets (str, insert_at, vp->
u16,
 
  823                                byte_order, pos_after);
 
  826       return marshal_4_octets (str, insert_at, vp->
u32 != 
FALSE,
 
  827                                byte_order, pos_after);
 
  832       return marshal_4_octets (str, insert_at, vp->
u32,
 
  833                                byte_order, pos_after);
 
  838       return marshal_8_octets (str, insert_at, *vp, byte_order, pos_after);
 
  844       return marshal_string (str, insert_at, vp->
str, byte_order, pos_after);
 
  848       return marshal_signature (str, insert_at, vp->
str, pos_after);
 
  860                         const unsigned char *value,
 
  899   _dbus_assert (_DBUS_ALIGN_ADDRESS (data, alignment) == data);
 
  905   end = d + (n_elements * alignment);
 
  915   else if (alignment == 4)
 
  942   _dbus_assert (_DBUS_ALIGN_VALUE (array_start, alignment) == (
unsigned) array_start);
 
  944   if (byte_order != DBUS_COMPILER_BYTE_ORDER)
 
  949       _dbus_swap_array ((
unsigned char*) (_dbus_string_get_const_data (str) + array_start),
 
  950                         n_elements, alignment);
 
  970   old_string_len = _dbus_string_get_length (str);
 
  972   len_in_bytes = n_elements * alignment;
 
  973   array_start = insert_at;
 
  985                                (
const char *) value,
 
  992   swap_array (str, array_start, n_elements, byte_order, alignment);
 
  995     *pos_after = array_start + len_in_bytes;
 
 1001                        _dbus_string_get_length (str) - old_string_len);
 
 1038   _dbus_verbose (
"writing %d elements of %s\n",
 
 1042   switch (element_type)
 
 1045       return marshal_1_octets_array (str, insert_at, vp, n_elements, byte_order, pos_after);
 
 1049       return marshal_fixed_multi (str, insert_at, vp, n_elements, byte_order, 2, pos_after);
 
 1054       return marshal_fixed_multi (str, insert_at, vp, n_elements, byte_order, 4, pos_after);
 
 1059       return marshal_fixed_multi (str, insert_at, vp, n_elements, byte_order, 8, pos_after);
 
 1096       *pos = _DBUS_ALIGN_VALUE (*pos, 2);
 
 1103       *pos = _DBUS_ALIGN_VALUE (*pos, 4);
 
 1109       *pos = _DBUS_ALIGN_VALUE (*pos, 8);
 
 1126         len = _dbus_string_get_byte (str, *pos);
 
 1158   i = _DBUS_ALIGN_VALUE (*pos, 4);
 
 1164   i = _DBUS_ALIGN_VALUE (i, alignment);
 
 1166   *pos = i + array_len;
 
 1250       return "object_path";
 
 1256       return "dict_entry";
 
 1262       return "begin_struct";
 
 1264       return "end_struct";
 
 1266       return "begin_dict_entry";
 
 1268       return "end_dict_entry";
 
 1289   const unsigned char *aligned;
 
 1293   if (!_dbus_is_verbose())
 
 1297   aligned = _DBUS_ALIGN_ADDRESS (data, 4);
 
 1302   if (aligned != data)
 
 1304       _dbus_verbose (
"%4ld\t%p: ", - (
long)(data - aligned), aligned);
 
 1305       while (aligned != data)
 
 1307           _dbus_verbose (
"    ");
 
 1316       if (_DBUS_ALIGN_ADDRESS (&data[i], 4) == &data[i])
 
 1318           _dbus_verbose (
"%4d\t%p: ",
 
 1319                          offset + i, &data[i]);
 
 1322       if (data[i] >= 32 &&
 
 1324         _dbus_verbose (
" '%c' ", data[i]);
 
 1326         _dbus_verbose (
"0x%s%x ",
 
 1327                        data[i] <= 0xf ? 
"0" : 
"", data[i]);
 
 1331       if (_DBUS_ALIGN_ADDRESS (&data[i], 4) == &data[i])
 
 1334             _dbus_verbose (
"BE: %d LE: %d",
 
 1339               _DBUS_ALIGN_ADDRESS (&data[i], 8) == &data[i])
 
 1341               _dbus_verbose (
" u64: 0x%" PRIx64,
 
 1343               _dbus_verbose (
" dbl: %g",
 
 1344                              *(
double*)&data[i-8]);
 
 1347           _dbus_verbose (
"\n");
 
 1351   _dbus_verbose (
"\n");
 
 1369   real_len = _dbus_string_get_length (str);
 
 1373   if (start > real_len)
 
 1375       _dbus_verbose (
"  [%d,%d) is not inside string of length %d\n",
 
 1376                      start, len, real_len);
 
 1380   if ((start + len) > real_len)
 
 1382       _dbus_verbose (
"  [%d,%d) extends outside string of length %d\n",
 
 1383                      start, len, real_len);
 
 1384       len = real_len - start;
 
 1387   d = _dbus_string_get_const_data_len (str, start, len);
 
 1393 map_type_char_to_type (
int t)
 
 1421   return map_type_char_to_type (_dbus_string_get_byte (str, pos));
 
 1436   return map_type_char_to_type (str[pos]);
 
 1441 #ifdef DBUS_ENABLE_EMBEDDED_TESTS 
 1442 #include "dbus-test.h" 
 1464 _dbus_marshal_read_fixed_multi  (
const DBusString *str,
 
 1479   _dbus_verbose (
"reading %d elements of %s\n",
 
 1485   pos = _DBUS_ALIGN_VALUE (pos, alignment);
 
 1487   array_len = n_elements * alignment;
 
 1489   *(
const DBusBasicValue**) value = (
void*) _dbus_string_get_const_data_len (str, pos, array_len);
 
 1491     *new_pos = pos + array_len;
 
 1495 swap_test_array (
void *array,
 
 1506   swap_array (&t, 0, len_bytes / alignment, byte_order, alignment);
 
 1509 #define MARSHAL_BASIC(typename, byte_order, literal)                    \ 
 1511      v_##typename = literal;                                            \ 
 1512      if (!_dbus_marshal_write_basic (&str, pos, DBUS_TYPE_##typename,   \ 
 1514                                     byte_order, NULL))                  \ 
 1515        _dbus_assert_not_reached ("no memory");                          \ 
 1518 #define DEMARSHAL_BASIC(typename, byte_order)                                   \ 
 1520     _dbus_marshal_read_basic (&str, pos, DBUS_TYPE_##typename, &v_##typename,   \ 
 1521                               byte_order, &pos);                                \ 
 1524 #define DEMARSHAL_BASIC_AND_CHECK(typename, byte_order, literal)                        \ 
 1526     DEMARSHAL_BASIC (typename, byte_order);                                             \ 
 1527     if (literal != v_##typename)                                                        \ 
 1529         _dbus_verbose_bytes_of_string (&str, dump_pos,                                  \ 
 1530                                      _dbus_string_get_length (&str) - dump_pos);        \ 
 1531         _dbus_assert_not_reached ("demarshaled wrong value");                           \ 
 1535 #define MARSHAL_TEST(typename, byte_order, literal)             \ 
 1537     MARSHAL_BASIC (typename, byte_order, literal);              \ 
 1539     DEMARSHAL_BASIC_AND_CHECK (typename, byte_order, literal);  \ 
 1542 #define MARSHAL_TEST_STRCMP(typename, byte_order, literal)                              \ 
 1544     MARSHAL_BASIC (typename, byte_order, literal);                                      \ 
 1546     DEMARSHAL_BASIC (typename, byte_order);                                             \ 
 1547     if (strcmp (literal, v_##typename) != 0)                                            \ 
 1549         _dbus_verbose_bytes_of_string (&str, dump_pos,                                  \ 
 1550                                        _dbus_string_get_length (&str) - dump_pos);      \ 
 1551         _dbus_warn ("literal '%s'\nvalue  '%s'", literal, v_##typename);              \ 
 1552         _dbus_assert_not_reached ("demarshaled wrong value");                           \ 
 1556 #define MARSHAL_FIXED_ARRAY(typename, byte_order, literal)                                      \ 
 1559      v_UINT32 = sizeof(literal);                                                                \ 
 1560      if (!_dbus_marshal_write_basic (&str, pos, DBUS_TYPE_UINT32, &v_UINT32,                    \ 
 1561                                      byte_order, &next))                                        \ 
 1562        _dbus_assert_not_reached ("no memory");                                                  \ 
 1563      v_ARRAY_##typename = literal;                                                              \ 
 1564      if (!_dbus_marshal_write_fixed_multi (&str, next, DBUS_TYPE_##typename,                    \ 
 1565                                            &v_ARRAY_##typename, _DBUS_N_ELEMENTS(literal),      \ 
 1566                                            byte_order, NULL))                                   \ 
 1567        _dbus_assert_not_reached ("no memory");                                                  \ 
 1570 #define DEMARSHAL_FIXED_ARRAY(typename, byte_order)                                             \ 
 1573     alignment = _dbus_type_get_alignment (DBUS_TYPE_##typename);                                \ 
 1574     v_UINT32 = _dbus_marshal_read_uint32 (&str, dump_pos, byte_order, &next);                   \ 
 1575     _dbus_marshal_read_fixed_multi (&str, next, DBUS_TYPE_##typename, &v_ARRAY_##typename,      \ 
 1576                                     v_UINT32/alignment,                                         \ 
 1577                                     byte_order, NULL);                                          \ 
 1578     swap_test_array (v_ARRAY_##typename, v_UINT32,                                              \ 
 1579                      byte_order, alignment);                                                    \ 
 1582 #define DEMARSHAL_FIXED_ARRAY_AND_CHECK(typename, byte_order, literal)                  \ 
 1584     DEMARSHAL_FIXED_ARRAY (typename, byte_order);                                       \ 
 1585     if (memcmp (literal, v_ARRAY_##typename, sizeof (literal)) != 0)                    \ 
 1587         _dbus_verbose ("MARSHALED DATA\n");                                             \ 
 1588         _dbus_verbose_bytes_of_string (&str, dump_pos,                                  \ 
 1589                                       _dbus_string_get_length (&str) - dump_pos);       \ 
 1590         _dbus_verbose ("LITERAL DATA\n");                                               \ 
 1591         _dbus_verbose_bytes ((const unsigned char *) literal, sizeof (literal), 0);                      \ 
 1592         _dbus_verbose ("READ DATA\n");                                                  \ 
 1593         _dbus_verbose_bytes ((const unsigned char *) v_ARRAY_##typename, sizeof (literal), 0);           \ 
 1594         _dbus_assert_not_reached ("demarshaled wrong fixed array value");               \ 
 1598 #define MARSHAL_TEST_FIXED_ARRAY(typename, byte_order, literal)         \ 
 1600     MARSHAL_FIXED_ARRAY (typename, byte_order, literal);                \ 
 1602     DEMARSHAL_FIXED_ARRAY_AND_CHECK (typename, byte_order, literal);    \ 
 1606 _dbus_marshal_test (
void)
 
 1611   unsigned char array1[5] = { 3, 4, 0, 1, 9 };
 
 1620   unsigned char *v_ARRAY_BYTE;
 
 1634   unsigned char v_BYTE;
 
 1636   const char *v_STRING;
 
 1637   const char *v_SIGNATURE;
 
 1638   const char *v_OBJECT_PATH;
 
 1696   MARSHAL_TEST_STRCMP (STRING, 
DBUS_BIG_ENDIAN, 
"This is the dbus test string");
 
 1741                                     _dbus_string_get_const_data (&str)));
 
 1749                                     _dbus_string_get_const_data (&str)));
 
 1754                     _dbus_string_get_data (&str));
 
 1758                                     _dbus_string_get_const_data (&str)));
 
 1763                     _dbus_string_get_data (&str));
 
 1767                                     _dbus_string_get_const_data (&str)));
 
 1775                                      _dbus_string_get_const_data (&str)));
 
 1783                                      _dbus_string_get_const_data (&str)));
 
 1788                      _dbus_string_get_data (&str));
 
 1792                                      _dbus_string_get_const_data (&str)));
 
 1797                      _dbus_string_get_data (&str));
 
 1801                                      _dbus_string_get_const_data (&str)));
 
 1812                                     _dbus_string_get_const_data (&str)));
 
 1820                                     _dbus_string_get_const_data (&str)));
 
 1823   _dbus_pack_int32 (-0x123456,
 
 1825                     _dbus_string_get_data (&str));
 
 1829                                     _dbus_string_get_const_data (&str)));
 
 1832   _dbus_pack_int32 (-0x123456,
 
 1834                     _dbus_string_get_data (&str));
 
 1838                                     _dbus_string_get_const_data (&str)));
 
 1847                                      _dbus_string_get_const_data (&str)));
 
 1856                                      _dbus_string_get_const_data (&str)));
 
 1861                      _dbus_string_get_data (&str));
 
 1865                                      _dbus_string_get_const_data (&str)));
 
 1870                      _dbus_string_get_data (&str));
 
 1874                                      _dbus_string_get_const_data (&str)));
 
 1888       MARSHAL_TEST_STRCMP (STRING, byte_order, 
"Hello world");
 
 1893       v_STRING = _dbus_string_get_const_data (&t);
 
 1895                                &v_STRING, byte_order, 
NULL, 
NULL);
 
 1898                                 &v_STRING, byte_order,
 
 1900       _dbus_assert (strcmp (v_STRING, 
"Hello world foo") == 0);
 
 1905       v_STRING = _dbus_string_get_const_data (&t);
 
 1907                                &v_STRING, byte_order, 
NULL, 
NULL);
 
 1909                                 &v_STRING, byte_order,