26 #include "dbus-internals.h"
27 #include "dbus-marshal-basic.h"
28 #include "dbus-signature.h"
29 #include <dbus/dbus-test-tap.h>
33 #if !defined(PRIx64) && defined(DBUS_WIN)
37 #if defined(__GNUC__) && (__GNUC__ >= 4)
38 # define _DBUS_ASSERT_ALIGNMENT(type, op, val) \
39 _DBUS_STATIC_ASSERT (__extension__ __alignof__ (type) op val)
40 # define _DBUS_ASSERT_CMP_ALIGNMENT(left, op, right) \
41 _DBUS_STATIC_ASSERT (__extension__ __alignof__ (left) op __extension__ __alignof__ (right))
45 # define _DBUS_ASSERT_ALIGNMENT(type, op, val) \
46 _DBUS_STATIC_ASSERT (TRUE)
47 # define _DBUS_ASSERT_CMP_ALIGNMENT(left, op, right) \
48 _DBUS_STATIC_ASSERT (TRUE)
52 _DBUS_STATIC_ASSERT (
sizeof (
char) == 1);
53 _DBUS_ASSERT_ALIGNMENT (
char, ==, 1);
70 _DBUS_STATIC_ASSERT (
sizeof (
double) == 8);
71 _DBUS_ASSERT_ALIGNMENT (
double, <=, 8);
157 pack_4_octets (value, byte_order, data);
164 if (byte_order != DBUS_COMPILER_BYTE_ORDER)
166 *value = DBUS_UINT64_SWAP_LE_BE (*value);
170 #ifndef _dbus_unpack_uint16
180 const unsigned char *data)
191 #ifndef _dbus_unpack_uint32
201 const unsigned char *data)
225 pack_2_octets (value, byte_order, (
unsigned char *) data);
241 pack_4_octets (value, byte_order, (
unsigned char *) data);
257 pack_8_octets (value, byte_order, (
unsigned char *) data);
276 set_4_octets (str, pos, value, byte_order);
306 int old_len, new_len;
311 _dbus_assert (_DBUS_ALIGN_VALUE (pos, 4) == (
unsigned) pos);
313 _dbus_string_get_const_udata_len (str, pos, 4));
315 new_len = _dbus_string_get_length (&dstr);
318 str, pos + 4, old_len))
324 *old_end_pos = pos + 4 + old_len + 1;
326 *new_end_pos = pos + 4 + new_len + 1;
352 int old_len, new_len;
357 old_len = _dbus_string_get_byte (str, pos);
358 new_len = _dbus_string_get_length (&dstr);
361 str, pos + 1, old_len))
364 _dbus_string_set_byte (str, pos, new_len);
367 *old_end_pos = pos + 1 + old_len + 1;
369 *new_end_pos = pos + 1 + new_len + 1;
403 const unsigned char *u8_p;
407 const char *
const *string_p;
413 _dbus_string_set_byte (str, pos, *u8_p);
415 *old_end_pos = pos + 1;
417 *new_end_pos = pos + 1;
423 pos = _DBUS_ALIGN_VALUE (pos, 2);
424 set_2_octets (str, pos, *u16_p, byte_order);
426 *old_end_pos = pos + 2;
428 *new_end_pos = pos + 2;
436 pos = _DBUS_ALIGN_VALUE (pos, 4);
437 set_4_octets (str, pos, *u32_p, byte_order);
439 *old_end_pos = pos + 4;
441 *new_end_pos = pos + 4;
448 pos = _DBUS_ALIGN_VALUE (pos, 8);
449 set_8_octets (str, pos, *u64_p, byte_order);
451 *old_end_pos = pos + 8;
453 *new_end_pos = pos + 8;
459 pos = _DBUS_ALIGN_VALUE (pos, 4);
461 return set_string (str, pos, *string_p, byte_order,
462 old_end_pos, new_end_pos);
467 return set_signature (str, pos, *string_p, byte_order,
468 old_end_pos, new_end_pos);
492 pos = _DBUS_ALIGN_VALUE (pos, 4);
497 _dbus_assert (pos + 4 <= _dbus_string_get_length (str));
500 _dbus_string_get_const_udata (str) + pos);
532 const char *str_data;
536 str_data = _dbus_string_get_const_data (str);
546 volatile unsigned char *vp = value;
547 *vp = (
unsigned char) _dbus_string_get_byte (str, pos);
555 pos = _DBUS_ALIGN_VALUE (pos, 2);
557 if (byte_order != DBUS_COMPILER_BYTE_ORDER)
558 *vp = DBUS_UINT16_SWAP_LE_BE (*vp);
568 pos = _DBUS_ALIGN_VALUE (pos, 4);
570 if (byte_order != DBUS_COMPILER_BYTE_ORDER)
571 *vp = DBUS_UINT32_SWAP_LE_BE (*vp);
580 pos = _DBUS_ALIGN_VALUE (pos, 8);
581 if (byte_order != DBUS_COMPILER_BYTE_ORDER)
582 *vp = DBUS_UINT64_SWAP_LE_BE (*(
dbus_uint64_t*)(str_data + pos));
592 volatile char **vp = value;
596 *vp = (
char*) str_data + pos;
604 volatile char **vp = value;
606 len = _dbus_string_get_byte (str, pos);
609 *vp = (
char*) str_data + pos;
635 _DBUS_STATIC_ASSERT (
sizeof (value) == 2);
637 if (byte_order != DBUS_COMPILER_BYTE_ORDER)
638 value = DBUS_UINT16_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) == 4);
666 if (byte_order != DBUS_COMPILER_BYTE_ORDER)
667 value = DBUS_UINT32_SWAP_LE_BE (value);
669 orig_len = _dbus_string_get_length (str);
672 (
const unsigned char *)&value);
676 *pos_after = insert_at + (_dbus_string_get_length (str) - orig_len);
677 _dbus_assert (*pos_after <= _dbus_string_get_length (str));
693 _DBUS_STATIC_ASSERT (
sizeof (value) == 8);
695 swap_8_octets (&value, byte_order);
697 orig_len = _dbus_string_get_length (str);
700 (
const unsigned char *)&value);
703 *pos_after = insert_at + _dbus_string_get_length (str) - orig_len;
711 MARSHAL_AS_SIGNATURE,
712 MARSHAL_AS_BYTE_ARRAY
716 marshal_len_followed_by_bytes (
int marshal_as,
719 const unsigned char *value,
729 if (insert_at > _dbus_string_get_length (str))
730 _dbus_warn (
"insert_at = %d string len = %d data_len = %d",
731 insert_at, _dbus_string_get_length (str), data_len);
733 if (marshal_as == MARSHAL_AS_BYTE_ARRAY)
734 value_len = data_len;
736 value_len = data_len + 1;
742 if (marshal_as == MARSHAL_AS_SIGNATURE)
754 if (!marshal_4_octets (str, pos, data_len,
791 return marshal_len_followed_by_bytes (MARSHAL_AS_STRING,
792 str, insert_at, (
const unsigned char *) value,
794 byte_order, pos_after);
803 return marshal_len_followed_by_bytes (MARSHAL_AS_SIGNATURE,
804 str, insert_at, (
const unsigned char *) value,
806 DBUS_COMPILER_BYTE_ORDER,
841 const unsigned char *u8_p;
845 const char *
const *string_p;
856 *pos_after = insert_at + 1;
862 return marshal_2_octets (str, insert_at, *u16_p,
863 byte_order, pos_after);
867 return marshal_4_octets (str, insert_at, (*u32_p !=
FALSE),
868 byte_order, pos_after);
874 return marshal_4_octets (str, insert_at, *u32_p,
875 byte_order, pos_after);
881 return marshal_8_octets (str, insert_at, *u64_p, byte_order, pos_after);
888 return marshal_string (str, insert_at, *string_p, byte_order, pos_after);
893 return marshal_signature (str, insert_at, *string_p, pos_after);
905 const unsigned char *value,
944 _dbus_assert (_DBUS_ALIGN_ADDRESS (data, alignment) == data);
950 end = d + (n_elements * alignment);
960 else if (alignment == 4)
987 _dbus_assert (_DBUS_ALIGN_VALUE (array_start, alignment) == (
unsigned) array_start);
989 if (byte_order != DBUS_COMPILER_BYTE_ORDER)
994 _dbus_swap_array ((
unsigned char*) (_dbus_string_get_const_data (str) + array_start),
995 n_elements, alignment);
1015 old_string_len = _dbus_string_get_length (str);
1017 len_in_bytes = n_elements * alignment;
1018 array_start = insert_at;
1030 (
const char *) value,
1037 swap_array (str, array_start, n_elements, byte_order, alignment);
1040 *pos_after = array_start + len_in_bytes;
1046 _dbus_string_get_length (str) - old_string_len);
1084 const unsigned char *
const *u8_pp;
1093 _dbus_verbose (
"writing %d elements of %s\n",
1097 switch (element_type)
1101 return marshal_1_octets_array (str, insert_at, *u8_pp, n_elements, byte_order, pos_after);
1106 return marshal_fixed_multi (str, insert_at, *u16_pp, n_elements, byte_order, 2, pos_after);
1112 return marshal_fixed_multi (str, insert_at, *u32_pp, n_elements, byte_order, 4, pos_after);
1118 return marshal_fixed_multi (str, insert_at, *u64_pp, n_elements, byte_order, 8, pos_after);
1155 *pos = _DBUS_ALIGN_VALUE (*pos, 2);
1162 *pos = _DBUS_ALIGN_VALUE (*pos, 4);
1168 *pos = _DBUS_ALIGN_VALUE (*pos, 8);
1185 len = _dbus_string_get_byte (str, *pos);
1217 i = _DBUS_ALIGN_VALUE (*pos, 4);
1223 i = _DBUS_ALIGN_VALUE (i, alignment);
1225 *pos = i + array_len;
1309 return "object_path";
1315 return "dict_entry";
1321 return "begin_struct";
1323 return "end_struct";
1325 return "begin_dict_entry";
1327 return "end_dict_entry";
1348 const unsigned char *aligned;
1352 if (!_dbus_is_verbose())
1356 aligned = _DBUS_ALIGN_ADDRESS (data, 4);
1361 if (aligned != data)
1363 _dbus_verbose (
"%4ld\t%p: ", - (
long)(data - aligned), aligned);
1364 while (aligned != data)
1366 _dbus_verbose (
" ");
1375 if (_DBUS_ALIGN_ADDRESS (&data[i], 4) == &data[i])
1377 _dbus_verbose (
"%4d\t%p: ",
1378 offset + i, &data[i]);
1381 if (data[i] >= 32 &&
1383 _dbus_verbose (
" '%c' ", data[i]);
1385 _dbus_verbose (
"0x%s%x ",
1386 data[i] <= 0xf ?
"0" :
"", data[i]);
1390 if (_DBUS_ALIGN_ADDRESS (&data[i], 4) == &data[i])
1393 _dbus_verbose (
"BE: %d LE: %d",
1398 _DBUS_ALIGN_ADDRESS (&data[i], 8) == &data[i])
1400 _dbus_verbose (
" u64: 0x%" PRIx64,
1402 _dbus_verbose (
" dbl: %g",
1403 *(
double*)&data[i-8]);
1406 _dbus_verbose (
"\n");
1410 _dbus_verbose (
"\n");
1428 real_len = _dbus_string_get_length (str);
1432 if (start > real_len)
1434 _dbus_verbose (
" [%d,%d) is not inside string of length %d\n",
1435 start, len, real_len);
1439 if ((start + len) > real_len)
1441 _dbus_verbose (
" [%d,%d) extends outside string of length %d\n",
1442 start, len, real_len);
1443 len = real_len - start;
1446 d = _dbus_string_get_const_data_len (str, start, len);
1452 map_type_char_to_type (
int t)
1480 return map_type_char_to_type (_dbus_string_get_byte (str, pos));
1495 return map_type_char_to_type (str[pos]);
1500 #ifdef DBUS_ENABLE_EMBEDDED_TESTS
1501 #include "dbus-test.h"
1523 _dbus_marshal_read_fixed_multi (
const DBusString *str,
1538 _dbus_verbose (
"reading %d elements of %s\n",
1544 pos = _DBUS_ALIGN_VALUE (pos, alignment);
1546 array_len = n_elements * alignment;
1548 *value = _dbus_string_get_const_data_len (str, pos, array_len);
1550 *new_pos = pos + array_len;
1554 swap_test_array (
void *array,
1565 swap_array (&t, 0, len_bytes / alignment, byte_order, alignment);
1568 #define MARSHAL_BASIC(typename, byte_order, literal) \
1570 v_##typename = literal; \
1571 if (!_dbus_marshal_write_basic (&str, pos, DBUS_TYPE_##typename, \
1573 byte_order, NULL)) \
1574 _dbus_test_fatal ("no memory"); \
1577 #define DEMARSHAL_BASIC(typename, byte_order) \
1579 _dbus_marshal_read_basic (&str, pos, DBUS_TYPE_##typename, &v_##typename, \
1580 byte_order, &pos); \
1583 #define DEMARSHAL_BASIC_AND_CHECK(typename, byte_order, literal) \
1585 DEMARSHAL_BASIC (typename, byte_order); \
1586 if (literal != v_##typename) \
1588 _dbus_verbose_bytes_of_string (&str, dump_pos, \
1589 _dbus_string_get_length (&str) - dump_pos); \
1590 _dbus_test_fatal ("demarshaled wrong value"); \
1594 #define MARSHAL_TEST(typename, byte_order, literal) \
1596 MARSHAL_BASIC (typename, byte_order, literal); \
1598 DEMARSHAL_BASIC_AND_CHECK (typename, byte_order, literal); \
1601 #define MARSHAL_TEST_STRCMP(typename, byte_order, literal) \
1603 MARSHAL_BASIC (typename, byte_order, literal); \
1605 DEMARSHAL_BASIC (typename, byte_order); \
1606 if (strcmp (literal, v_##typename) != 0) \
1608 _dbus_verbose_bytes_of_string (&str, dump_pos, \
1609 _dbus_string_get_length (&str) - dump_pos); \
1610 _dbus_warn ("literal '%s'\nvalue '%s'", literal, v_##typename); \
1611 _dbus_test_fatal ("demarshaled wrong value"); \
1615 #define MARSHAL_FIXED_ARRAY(typename, byte_order, literal) \
1618 v_UINT32 = sizeof(literal); \
1619 if (!_dbus_marshal_write_basic (&str, pos, DBUS_TYPE_UINT32, &v_UINT32, \
1620 byte_order, &next)) \
1621 _dbus_test_fatal ("no memory"); \
1622 v_ARRAY_##typename = literal; \
1623 if (!_dbus_marshal_write_fixed_multi (&str, next, DBUS_TYPE_##typename, \
1624 &v_ARRAY_##typename, _DBUS_N_ELEMENTS(literal), \
1625 byte_order, NULL)) \
1626 _dbus_test_fatal ("no memory"); \
1629 #define DEMARSHAL_FIXED_ARRAY(typename, byte_order) \
1632 alignment = _dbus_type_get_alignment (DBUS_TYPE_##typename); \
1633 v_UINT32 = _dbus_marshal_read_uint32 (&str, dump_pos, byte_order, &next); \
1634 _dbus_marshal_read_fixed_multi (&str, next, DBUS_TYPE_##typename, \
1635 (const void **) &v_ARRAY_##typename, \
1636 v_UINT32/alignment, \
1637 byte_order, NULL); \
1638 swap_test_array (v_ARRAY_##typename, v_UINT32, \
1639 byte_order, alignment); \
1642 #define DEMARSHAL_FIXED_ARRAY_AND_CHECK(typename, byte_order, literal) \
1644 DEMARSHAL_FIXED_ARRAY (typename, byte_order); \
1645 if (memcmp (literal, v_ARRAY_##typename, sizeof (literal)) != 0) \
1647 _dbus_verbose ("MARSHALED DATA\n"); \
1648 _dbus_verbose_bytes_of_string (&str, dump_pos, \
1649 _dbus_string_get_length (&str) - dump_pos); \
1650 _dbus_verbose ("LITERAL DATA\n"); \
1651 _dbus_verbose_bytes ((const unsigned char *) literal, sizeof (literal), 0); \
1652 _dbus_verbose ("READ DATA\n"); \
1653 _dbus_verbose_bytes ((const unsigned char *) v_ARRAY_##typename, sizeof (literal), 0); \
1654 _dbus_test_fatal ("demarshaled wrong fixed array value"); \
1658 #define MARSHAL_TEST_FIXED_ARRAY(typename, byte_order, literal) \
1660 MARSHAL_FIXED_ARRAY (typename, byte_order, literal); \
1662 DEMARSHAL_FIXED_ARRAY_AND_CHECK (typename, byte_order, literal); \
1666 _dbus_marshal_test (
const char *test_data_dir _DBUS_GNUC_UNUSED)
1671 unsigned char array1[5] = { 3, 4, 0, 1, 9 };
1680 unsigned char *v_ARRAY_BYTE;
1694 unsigned char v_BYTE;
1696 const char *v_STRING;
1697 const char *v_SIGNATURE;
1698 const char *v_OBJECT_PATH;
1702 _dbus_test_fatal (
"failed to init string");
1711 _dbus_test_fatal (
"got wrong double value");
1717 _dbus_test_fatal (
"got wrong double value");
1756 MARSHAL_TEST_STRCMP (STRING,
DBUS_BIG_ENDIAN,
"This is the dbus test string");
1801 _dbus_string_get_const_data (&str)));
1809 _dbus_string_get_const_data (&str)));
1814 _dbus_string_get_data (&str));
1818 _dbus_string_get_const_data (&str)));
1823 _dbus_string_get_data (&str));
1827 _dbus_string_get_const_data (&str)));
1835 _dbus_string_get_const_data (&str)));
1843 _dbus_string_get_const_data (&str)));
1848 _dbus_string_get_data (&str));
1852 _dbus_string_get_const_data (&str)));
1857 _dbus_string_get_data (&str));
1861 _dbus_string_get_const_data (&str)));
1872 _dbus_string_get_const_data (&str)));
1880 _dbus_string_get_const_data (&str)));
1883 _dbus_pack_int32 (-0x123456,
1885 _dbus_string_get_data (&str));
1889 _dbus_string_get_const_data (&str)));
1892 _dbus_pack_int32 (-0x123456,
1894 _dbus_string_get_data (&str));
1898 _dbus_string_get_const_data (&str)));
1907 _dbus_string_get_const_data (&str)));
1916 _dbus_string_get_const_data (&str)));
1921 _dbus_string_get_data (&str));
1925 _dbus_string_get_const_data (&str)));
1930 _dbus_string_get_data (&str));
1934 _dbus_string_get_const_data (&str)));
1948 MARSHAL_TEST_STRCMP (STRING, byte_order,
"Hello world");
1953 v_STRING = _dbus_string_get_const_data (&t);
1955 &v_STRING, byte_order,
NULL,
NULL);
1958 &v_STRING, byte_order,
1960 _dbus_assert (strcmp (v_STRING,
"Hello world foo") == 0);
1965 v_STRING = _dbus_string_get_const_data (&t);
1967 &v_STRING, byte_order,
NULL,
NULL);
1969 &v_STRING, byte_order,