1 /* -*- mode: C; c-file-style: "gnu" -*- */
2 /* dbus-marshal-basic.c Marshalling routines for basic (primitive) types
4 * Copyright (C) 2002 CodeFactory AB
5 * Copyright (C) 2003, 2004, 2005 Red Hat, Inc.
7 * Licensed under the Academic Free License version 2.1
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the License, or
12 * (at your option) any later version.
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
25 #include "dbus-internals.h"
26 #include "dbus-marshal-basic.h"
31 * @defgroup DBusMarshal marshaling and unmarshaling
32 * @ingroup DBusInternals
33 * @brief functions to marshal/unmarshal data from the wire
35 * Types and functions related to converting primitive data types from
36 * wire format to native machine format, and vice versa.
38 * A signature is just a string with multiple types one after the other.
39 * for example a type is "i" or "(ii)", a signature is "i(ii)"
40 * where i is int and (ii) is struct { int; int; }
46 pack_4_octets (dbus_uint32_t value,
50 _dbus_assert (_DBUS_ALIGN_ADDRESS (data, 4) == data);
52 if ((byte_order) == DBUS_LITTLE_ENDIAN)
53 *((dbus_uint32_t*)(data)) = DBUS_UINT32_TO_LE (value);
55 *((dbus_uint32_t*)(data)) = DBUS_UINT32_TO_BE (value);
59 pack_8_octets (DBusBasicValue value,
63 _dbus_assert (_DBUS_ALIGN_ADDRESS (data, 8) == data);
65 #ifdef DBUS_HAVE_INT64
66 if ((byte_order) == DBUS_LITTLE_ENDIAN)
67 *((dbus_uint64_t*)(data)) = DBUS_UINT64_TO_LE (value.u64);
69 *((dbus_uint64_t*)(data)) = DBUS_UINT64_TO_BE (value.u64);
71 *(DBus8ByteStruct*)data = value.u64;
72 swap_8_octets ((DBusBasicValue*)data, byte_order);
77 * Packs a 32 bit unsigned integer into a data pointer.
79 * @param value the value
80 * @param byte_order the byte order to use
81 * @param data the data pointer
84 _dbus_pack_uint32 (dbus_uint32_t value,
88 pack_4_octets (value, byte_order, data);
91 #ifndef DBUS_HAVE_INT64
94 swap_bytes (unsigned char *data,
97 unsigned char *p1 = data;
98 unsigned char *p2 = data + len - 1;
102 unsigned char tmp = *p1;
110 #endif /* !DBUS_HAVE_INT64 */
113 swap_8_octets (DBusBasicValue *value,
116 if (byte_order != DBUS_COMPILER_BYTE_ORDER)
118 #ifdef DBUS_HAVE_INT64
119 value->u64 = DBUS_UINT64_SWAP_LE_BE (value->u64);
121 swap_bytes ((unsigned char *)value, 8);
127 static DBusBasicValue
128 unpack_8_octets (int byte_order,
129 const unsigned char *data)
133 _dbus_assert (_DBUS_ALIGN_ADDRESS (data, 8) == data);
134 _dbus_assert (sizeof (r) == 8);
136 #ifdef DBUS_HAVE_INT64
137 if (byte_order == DBUS_LITTLE_ENDIAN)
138 r.u64 = DBUS_UINT64_FROM_LE (*(dbus_uint64_t*)data);
140 r.u64 = DBUS_UINT64_FROM_BE (*(dbus_uint64_t*)data);
142 r.u64 = *(DBus8ByteStruct*)data;
143 swap_8_octets (&r, byte_order);
150 #ifndef _dbus_unpack_uint32
152 * Unpacks a 32 bit unsigned integer from a data pointer
154 * @param byte_order The byte order to use
155 * @param data the data pointer
156 * @returns the integer
159 _dbus_unpack_uint32 (int byte_order,
160 const unsigned char *data)
162 _dbus_assert (_DBUS_ALIGN_ADDRESS (data, 4) == data);
164 if (byte_order == DBUS_LITTLE_ENDIAN)
165 return DBUS_UINT32_FROM_LE (*(dbus_uint32_t*)data);
167 return DBUS_UINT32_FROM_BE (*(dbus_uint32_t*)data);
169 #endif /* _dbus_unpack_uint32 */
172 set_4_octets (DBusString *str,
179 _dbus_assert (byte_order == DBUS_LITTLE_ENDIAN ||
180 byte_order == DBUS_BIG_ENDIAN);
182 data = _dbus_string_get_data_len (str, offset, 4);
184 _dbus_pack_uint32 (value, byte_order, data);
188 set_8_octets (DBusString *str,
190 DBusBasicValue value,
195 _dbus_assert (byte_order == DBUS_LITTLE_ENDIAN ||
196 byte_order == DBUS_BIG_ENDIAN);
198 data = _dbus_string_get_data_len (str, offset, 8);
200 pack_8_octets (value, byte_order, data);
204 * Sets the 4 bytes at the given offset to a marshaled unsigned
205 * integer, replacing anything found there previously.
207 * @param str the string to write the marshalled int to
208 * @param pos the byte offset where int should be written
209 * @param value the value
210 * @param byte_order the byte order to use
214 _dbus_marshal_set_uint32 (DBusString *str,
219 set_4_octets (str, pos, value, byte_order);
223 * Sets the existing marshaled string at the given offset with
224 * a new marshaled string. The given offset must point to
225 * an existing string or the wrong length will be deleted
226 * and replaced with the new string.
228 * Note: no attempt is made by this function to re-align
229 * any data which has been already marshalled after this
230 * string. Use with caution.
232 * @param str the string to write the marshalled string to
233 * @param pos the position of the marshaled string length
234 * @param value the value
235 * @param byte_order the byte order to use
236 * @param old_end_pos place to store byte after the nul byte of the old value
237 * @param new_end_pos place to store byte after the nul byte of the new value
238 * @returns #TRUE on success, #FALSE if no memory
242 set_string (DBusString *str,
249 int old_len, new_len;
252 _dbus_string_init_const (&dstr, value);
254 _dbus_assert (_DBUS_ALIGN_VALUE (pos, 4) == (unsigned) pos);
255 old_len = _dbus_unpack_uint32 (byte_order,
256 _dbus_string_get_const_data_len (str, pos, 4));
258 new_len = _dbus_string_get_length (&dstr);
260 if (!_dbus_string_replace_len (&dstr, 0, new_len,
261 str, pos + 4, old_len))
264 _dbus_marshal_set_uint32 (str, pos, new_len, byte_order);
267 *old_end_pos = pos + 4 + old_len + 1;
269 *new_end_pos = pos + 4 + new_len + 1;
275 * Sets the existing marshaled signature at the given offset to a new
276 * marshaled signature. Same basic ideas as set_string().
278 * @param str the string to write the marshalled signature to
279 * @param pos the position of the marshaled signature length
280 * @param value the value
281 * @param byte_order the byte order to use
282 * @param old_end_pos place to store byte after the nul byte of the old value
283 * @param new_end_pos place to store byte after the nul byte of the new value
284 * @returns #TRUE on success, #FALSE if no memory
288 set_signature (DBusString *str,
295 int old_len, new_len;
298 _dbus_string_init_const (&dstr, value);
300 old_len = _dbus_string_get_byte (str, pos);
301 new_len = _dbus_string_get_length (&dstr);
303 if (!_dbus_string_replace_len (&dstr, 0, new_len,
304 str, pos + 1, old_len))
307 _dbus_string_set_byte (str, pos, new_len);
310 *old_end_pos = pos + 1 + old_len + 1;
312 *new_end_pos = pos + 1 + new_len + 1;
318 * Sets an existing basic type value to a new value.
319 * Arguments work the same way as _dbus_marshal_basic_type().
321 * @param str the string
322 * @param pos location of the current value
323 * @param type the type of the current and new values
324 * @param value the address of the new value
325 * @param byte_order byte order for marshaling
326 * @param old_end_pos location to store end position of the old value, or #NULL
327 * @param new_end_pos location to store end position of the new value, or #NULL
328 * @returns #FALSE if no memory
331 _dbus_marshal_set_basic (DBusString *str,
339 const DBusBasicValue *vp;
346 case DBUS_TYPE_BOOLEAN:
347 _dbus_string_set_byte (str, pos, vp->byt);
349 *old_end_pos = pos + 1;
351 *new_end_pos = pos + 1;
354 case DBUS_TYPE_INT32:
355 case DBUS_TYPE_UINT32:
356 pos = _DBUS_ALIGN_VALUE (pos, 4);
357 set_4_octets (str, pos, vp->u32, byte_order);
359 *old_end_pos = pos + 4;
361 *new_end_pos = pos + 4;
364 case DBUS_TYPE_INT64:
365 case DBUS_TYPE_UINT64:
366 case DBUS_TYPE_DOUBLE:
367 pos = _DBUS_ALIGN_VALUE (pos, 8);
368 set_8_octets (str, pos, *vp, byte_order);
370 *old_end_pos = pos + 8;
372 *new_end_pos = pos + 8;
375 case DBUS_TYPE_STRING:
376 case DBUS_TYPE_OBJECT_PATH:
377 pos = _DBUS_ALIGN_VALUE (pos, 4);
378 _dbus_assert (vp->str != NULL);
379 return set_string (str, pos, vp->str, byte_order,
380 old_end_pos, new_end_pos);
382 case DBUS_TYPE_SIGNATURE:
383 _dbus_assert (vp->str != NULL);
384 return set_signature (str, pos, vp->str, byte_order,
385 old_end_pos, new_end_pos);
388 _dbus_assert_not_reached ("not a basic type");
395 * Convenience function to demarshal a 32 bit unsigned integer.
397 * @param str the string containing the data
398 * @param byte_order the byte order
399 * @param pos the position in the string
400 * @param new_pos the new position of the string
401 * @returns the demarshaled integer.
404 _dbus_marshal_read_uint32 (const DBusString *str,
409 pos = _DBUS_ALIGN_VALUE (pos, 4);
414 _dbus_assert (pos + 4 <= _dbus_string_get_length (str));
416 return _dbus_unpack_uint32 (byte_order,
417 _dbus_string_get_const_data (str) + pos);
421 * Demarshals a basic-typed value. The "value" pointer is always
422 * the address of a variable of the basic type. So e.g.
423 * if the basic type is "double" then the pointer is
424 * a double*, and if it's "char*" then the pointer is
427 * A value of type #DBusBasicValue is guaranteed to be large enough to
428 * hold any of the types that may be returned, which is handy if you
429 * are trying to do things generically. For example you can pass
430 * a DBusBasicValue* in to this function, and then pass the same
431 * DBusBasicValue* in to _dbus_marshal_basic_type() in order to
432 * move a value from one place to another.
434 * @param str the string containing the data
435 * @param pos position in the string
436 * @param type type of value to demarshal
437 * @param value pointer to return value data
438 * @param byte_order the byte order
439 * @param new_pos pointer to update with new position, or #NULL
442 _dbus_marshal_read_basic (const DBusString *str,
449 const char *str_data;
452 _dbus_assert (_dbus_type_is_basic (type));
454 str_data = _dbus_string_get_const_data (str);
460 case DBUS_TYPE_BOOLEAN:
461 vp->byt = _dbus_string_get_byte (str, pos);
464 case DBUS_TYPE_INT32:
465 case DBUS_TYPE_UINT32:
466 pos = _DBUS_ALIGN_VALUE (pos, 4);
467 vp->u32 = *(dbus_uint32_t *)(str_data + pos);
468 if (byte_order != DBUS_COMPILER_BYTE_ORDER)
469 vp->u32 = DBUS_UINT32_SWAP_LE_BE (vp->u32);
472 case DBUS_TYPE_INT64:
473 case DBUS_TYPE_UINT64:
474 case DBUS_TYPE_DOUBLE:
475 pos = _DBUS_ALIGN_VALUE (pos, 8);
476 #ifdef DBUS_HAVE_INT64
477 if (byte_order != DBUS_COMPILER_BYTE_ORDER)
478 vp->u64 = DBUS_UINT64_SWAP_LE_BE (*(dbus_uint64_t*)(str_data + pos));
480 vp->u64 = *(dbus_uint64_t*)(str_data + pos);
482 vp->u64 = *(DBus8ByteStruct*) (str_data + pos);
483 swap_8_octets (vp, byte_order);
487 case DBUS_TYPE_STRING:
488 case DBUS_TYPE_OBJECT_PATH:
492 len = _dbus_marshal_read_uint32 (str, pos, byte_order, &pos);
494 vp->str = (char*) str_data + pos;
496 pos += len + 1; /* length plus nul */
499 case DBUS_TYPE_SIGNATURE:
503 len = _dbus_string_get_byte (str, pos);
506 vp->str = (char*) str_data + pos;
508 pos += len + 1; /* length plus nul */
512 _dbus_warn ("type %s not a basic type\n",
513 _dbus_type_to_string (type));
514 _dbus_assert_not_reached ("not a basic type");
523 * Reads a block of fixed-length basic values, as an optimization
524 * vs. reading each one individually into a new buffer.
526 * This function returns the data in-place; it does not make a copy,
527 * and it does not swap the bytes.
529 * If you ask for #DBUS_TYPE_DOUBLE you will get a "const double*" back
530 * and the "value" argument should be a "const double**" and so on.
532 * @todo we aren't using this function (except in the test suite)
534 * @param str the string to read from
535 * @param pos position to read from
536 * @param element_type type of array elements
537 * @param value place to return the array
538 * @param n_elements number of array elements to read
539 * @param byte_order the byte order, used to read the array length
540 * @param new_pos #NULL or location to store a position after the elements
543 _dbus_marshal_read_fixed_multi (const DBusString *str,
554 _dbus_assert (_dbus_type_is_fixed (element_type));
555 _dbus_assert (_dbus_type_is_basic (element_type));
558 _dbus_verbose ("reading %d elements of %s\n",
559 n_elements, _dbus_type_to_string (element_type));
562 alignment = _dbus_type_get_alignment (element_type);
564 pos = _DBUS_ALIGN_VALUE (pos, alignment);
566 array_len = n_elements * alignment;
568 *(const DBusBasicValue**) value = (void*) _dbus_string_get_const_data_len (str, pos, array_len);
570 *new_pos = pos + array_len;
574 marshal_4_octets (DBusString *str,
583 _dbus_assert (sizeof (value) == 4);
585 if (byte_order != DBUS_COMPILER_BYTE_ORDER)
586 value = DBUS_UINT32_SWAP_LE_BE (value);
588 orig_len = _dbus_string_get_length (str);
590 retval = _dbus_string_insert_4_aligned (str, insert_at,
591 (const unsigned char *)&value);
595 *pos_after = insert_at + (_dbus_string_get_length (str) - orig_len);
596 _dbus_assert (*pos_after <= _dbus_string_get_length (str));
603 marshal_8_octets (DBusString *str,
605 DBusBasicValue value,
612 _dbus_assert (sizeof (value) == 8);
614 swap_8_octets (&value, byte_order);
616 orig_len = _dbus_string_get_length (str);
618 retval = _dbus_string_insert_8_aligned (str, insert_at,
619 (const unsigned char *)&value);
622 *pos_after = insert_at + _dbus_string_get_length (str) - orig_len;
630 MARSHAL_AS_SIGNATURE,
631 MARSHAL_AS_BYTE_ARRAY
635 marshal_len_followed_by_bytes (int marshal_as,
638 const unsigned char *value,
639 int data_len, /* doesn't include nul if any */
644 DBusString value_str;
647 _dbus_assert (byte_order == DBUS_LITTLE_ENDIAN || byte_order == DBUS_BIG_ENDIAN);
648 if (insert_at > _dbus_string_get_length (str))
649 _dbus_warn ("insert_at = %d string len = %d data_len = %d\n",
650 insert_at, _dbus_string_get_length (str), data_len);
652 if (marshal_as == MARSHAL_AS_BYTE_ARRAY)
653 value_len = data_len;
655 value_len = data_len + 1; /* value has a nul */
657 _dbus_string_init_const_len (&value_str, value, value_len);
661 if (marshal_as == MARSHAL_AS_SIGNATURE)
663 if (!_dbus_string_insert_byte (str, pos, data_len))
670 if (!marshal_4_octets (str, pos, data_len,
675 if (!_dbus_string_copy_len (&value_str, 0, value_len,
681 _dbus_assert (_dbus_string_equal_substring (&value_str, 0, value_len,
683 _dbus_verbose_bytes_of_string (str, pos, value_len);
694 /* Delete what we've inserted */
695 _dbus_string_delete (str, insert_at, pos - insert_at);
701 marshal_string (DBusString *str,
707 return marshal_len_followed_by_bytes (MARSHAL_AS_STRING,
708 str, insert_at, value,
710 byte_order, pos_after);
714 marshal_signature (DBusString *str,
719 return marshal_len_followed_by_bytes (MARSHAL_AS_SIGNATURE,
720 str, insert_at, value,
722 DBUS_COMPILER_BYTE_ORDER, /* irrelevant */
727 * Marshals a basic-typed value. The "value" pointer is always the
728 * address of a variable containing the basic type value.
729 * So for example for int32 it will be dbus_int32_t*, and
730 * for string it will be const char**. This is for symmetry
731 * with _dbus_marshal_read_basic() and to have a simple
734 * @param str string to marshal to
735 * @param insert_at where to insert the value
736 * @param type type of value
737 * @param value pointer to a variable containing the value
738 * @param byte_order byte order
739 * @param pos_after #NULL or the position after the type
740 * @returns #TRUE on success
743 _dbus_marshal_write_basic (DBusString *str,
750 const DBusBasicValue *vp;
752 _dbus_assert (_dbus_type_is_basic (type));
759 case DBUS_TYPE_BOOLEAN:
760 if (!_dbus_string_insert_byte (str, insert_at, vp->byt))
763 *pos_after = insert_at + 1;
766 case DBUS_TYPE_INT32:
767 case DBUS_TYPE_UINT32:
768 return marshal_4_octets (str, insert_at, vp->u32,
769 byte_order, pos_after);
771 case DBUS_TYPE_INT64:
772 case DBUS_TYPE_UINT64:
773 case DBUS_TYPE_DOUBLE:
774 return marshal_8_octets (str, insert_at, *vp, byte_order, pos_after);
777 case DBUS_TYPE_STRING:
778 case DBUS_TYPE_OBJECT_PATH:
779 _dbus_assert (vp->str != NULL);
780 return marshal_string (str, insert_at, vp->str, byte_order, pos_after);
782 case DBUS_TYPE_SIGNATURE:
783 _dbus_assert (vp->str != NULL);
784 return marshal_signature (str, insert_at, vp->str, pos_after);
787 _dbus_assert_not_reached ("not a basic type");
794 marshal_1_octets_array (DBusString *str,
796 const unsigned char *value,
802 DBusString value_str;
804 _dbus_string_init_const_len (&value_str, value, n_elements);
808 if (!_dbus_string_copy_len (&value_str, 0, n_elements,
821 swap_array (DBusString *str,
827 _dbus_assert (_DBUS_ALIGN_VALUE (array_start, alignment) == (unsigned) array_start);
829 if (byte_order != DBUS_COMPILER_BYTE_ORDER)
834 /* we use const_data and cast it off so DBusString can be a const string
835 * for the unit tests. don't ask.
837 d = (unsigned char*) _dbus_string_get_const_data (str) + array_start;
838 end = d + n_elements * alignment;
844 #ifdef DBUS_HAVE_INT64
845 *((dbus_uint64_t*)d) = DBUS_UINT64_SWAP_LE_BE (*((dbus_uint64_t*)d));
847 swap_8_bytes ((DBusBasicValue*) d);
854 _dbus_assert (alignment == 4);
858 *((dbus_uint32_t*)d) = DBUS_UINT32_SWAP_LE_BE (*((dbus_uint32_t*)d));
866 marshal_fixed_multi (DBusString *str,
868 const DBusBasicValue *value,
879 _dbus_assert (n_elements <= DBUS_MAXIMUM_ARRAY_LENGTH / alignment);
881 old_string_len = _dbus_string_get_length (str);
883 len_in_bytes = n_elements * alignment;
884 array_start = insert_at;
886 /* Note that we do alignment padding unconditionally
887 * even if the array is empty; this means that
888 * padding + len is always equal to the number of bytes
892 if (!_dbus_string_insert_alignment (str, &array_start, alignment))
895 _dbus_string_init_const_len (&t,
896 (const unsigned char*) value,
899 if (!_dbus_string_copy (&t, 0,
903 swap_array (str, array_start, n_elements, byte_order, alignment);
906 *pos_after = array_start + len_in_bytes;
911 _dbus_string_delete (str, insert_at,
912 _dbus_string_get_length (str) - old_string_len);
918 * Marshals a block of values of fixed-length type all at once, as an
919 * optimization. _dbus_type_is_fixed() returns #TRUE for fixed-length
920 * types, which are the basic types minus the string-like types.
922 * The value argument should be the adddress of an
923 * array, so e.g. "const dbus_uint32_t**"
925 * @param str string to marshal to
926 * @param insert_at where to insert the value
927 * @param element_type type of array elements
928 * @param value address of an array to marshal
929 * @param n_elements number of elements in the array
930 * @param byte_order byte order
931 * @param pos_after #NULL or the position after the type
932 * @returns #TRUE on success
935 _dbus_marshal_write_fixed_multi (DBusString *str,
943 const void* vp = *(const DBusBasicValue**)value;
945 _dbus_assert (_dbus_type_is_fixed (element_type));
946 _dbus_assert (n_elements >= 0);
949 _dbus_verbose ("writing %d elements of %s\n",
950 n_elements, _dbus_type_to_string (element_type));
953 switch (element_type)
955 case DBUS_TYPE_BOOLEAN:
956 /* FIXME: we canonicalize to 0 or 1 for the single boolean case
957 * should we here too ? */
959 return marshal_1_octets_array (str, insert_at, vp, n_elements, byte_order, pos_after);
961 case DBUS_TYPE_INT32:
962 case DBUS_TYPE_UINT32:
963 return marshal_fixed_multi (str, insert_at, vp, n_elements, byte_order, 4, pos_after);
965 case DBUS_TYPE_INT64:
966 case DBUS_TYPE_UINT64:
967 case DBUS_TYPE_DOUBLE:
968 return marshal_fixed_multi (str, insert_at, vp, n_elements, byte_order, 8, pos_after);
972 _dbus_assert_not_reached ("non fixed type in array write");
981 * Skips over a basic-typed value, reporting the following position.
983 * @param str the string containing the data
984 * @param type type of value to read
985 * @param byte_order the byte order
986 * @param pos pointer to position in the string,
987 * updated on return to new position
990 _dbus_marshal_skip_basic (const DBusString *str,
995 _dbus_assert (byte_order == DBUS_LITTLE_ENDIAN ||
996 byte_order == DBUS_BIG_ENDIAN);
1000 case DBUS_TYPE_BYTE:
1001 case DBUS_TYPE_BOOLEAN:
1004 case DBUS_TYPE_INT32:
1005 case DBUS_TYPE_UINT32:
1006 *pos = _DBUS_ALIGN_VALUE (*pos, 4);
1009 case DBUS_TYPE_INT64:
1010 case DBUS_TYPE_UINT64:
1011 case DBUS_TYPE_DOUBLE:
1012 *pos = _DBUS_ALIGN_VALUE (*pos, 8);
1015 case DBUS_TYPE_STRING:
1016 case DBUS_TYPE_OBJECT_PATH:
1020 len = _dbus_marshal_read_uint32 (str, *pos, byte_order, pos);
1022 *pos += len + 1; /* length plus nul */
1025 case DBUS_TYPE_SIGNATURE:
1029 len = _dbus_string_get_byte (str, *pos);
1031 *pos += len + 2; /* length byte plus length plus nul */
1035 _dbus_warn ("type %s not a basic type\n",
1036 _dbus_type_to_string (type));
1037 _dbus_assert_not_reached ("not a basic type");
1043 * Skips an array, returning the next position.
1045 * @param str the string containing the data
1046 * @param element_type the type of array elements
1047 * @param byte_order the byte order
1048 * @param pos pointer to position in the string,
1049 * updated on return to new position
1052 _dbus_marshal_skip_array (const DBusString *str,
1057 dbus_uint32_t array_len;
1061 i = _DBUS_ALIGN_VALUE (*pos, 4);
1063 array_len = _dbus_marshal_read_uint32 (str, i, byte_order, &i);
1065 alignment = _dbus_type_get_alignment (element_type);
1067 i = _DBUS_ALIGN_VALUE (i, alignment);
1069 *pos = i + array_len;
1073 * Gets the alignment requirement for the given type;
1074 * will be 1, 4, or 8.
1076 * @param typecode the type
1077 * @returns alignment of 1, 4, or 8
1080 _dbus_type_get_alignment (int typecode)
1084 case DBUS_TYPE_BYTE:
1085 case DBUS_TYPE_BOOLEAN:
1086 case DBUS_TYPE_VARIANT:
1087 case DBUS_TYPE_SIGNATURE:
1089 case DBUS_TYPE_INT32:
1090 case DBUS_TYPE_UINT32:
1091 /* this stuff is 4 since it starts with a length */
1092 case DBUS_TYPE_STRING:
1093 case DBUS_TYPE_OBJECT_PATH:
1094 case DBUS_TYPE_ARRAY:
1096 case DBUS_TYPE_INT64:
1097 case DBUS_TYPE_UINT64:
1098 case DBUS_TYPE_DOUBLE:
1099 /* struct is 8 since it could contain an 8-aligned item
1100 * and it's simpler to just always align structs to 8;
1101 * we want the amount of padding in a struct of a given
1102 * type to be predictable, not location-dependent.
1104 case DBUS_TYPE_STRUCT:
1108 _dbus_assert_not_reached ("unknown typecode in _dbus_type_get_alignment()");
1115 * Return #TRUE if the typecode is a valid typecode.
1116 * #DBUS_TYPE_INVALID surprisingly enough is not considered valid, and
1117 * random unknown bytes aren't either. This function is safe with
1120 * @returns #TRUE if valid
1123 _dbus_type_is_valid (int typecode)
1127 case DBUS_TYPE_BYTE:
1128 case DBUS_TYPE_BOOLEAN:
1129 case DBUS_TYPE_INT32:
1130 case DBUS_TYPE_UINT32:
1131 case DBUS_TYPE_INT64:
1132 case DBUS_TYPE_UINT64:
1133 case DBUS_TYPE_DOUBLE:
1134 case DBUS_TYPE_STRING:
1135 case DBUS_TYPE_OBJECT_PATH:
1136 case DBUS_TYPE_SIGNATURE:
1137 case DBUS_TYPE_ARRAY:
1138 case DBUS_TYPE_STRUCT:
1139 case DBUS_TYPE_VARIANT:
1147 /** macro that checks whether a typecode is a container type */
1148 #define TYPE_IS_CONTAINER(typecode) \
1149 ((typecode) == DBUS_TYPE_STRUCT || \
1150 (typecode) == DBUS_TYPE_VARIANT || \
1151 (typecode) == DBUS_TYPE_ARRAY)
1154 * A "container type" can contain basic types, or nested
1155 * container types. #DBUS_TYPE_INVALID is not a container type.
1156 * This function will crash if passed a typecode that isn't
1157 * in dbus-protocol.h
1159 * @returns #TRUE if type is a container
1162 _dbus_type_is_container (int typecode)
1164 /* only reasonable (non-line-noise) typecodes are allowed */
1165 _dbus_assert (_dbus_type_is_valid (typecode) || typecode == DBUS_TYPE_INVALID);
1166 return TYPE_IS_CONTAINER (typecode);
1170 * A "basic type" is a somewhat arbitrary concept, but the intent
1171 * is to include those types that are fully-specified by a single
1172 * typecode, with no additional type information or nested
1173 * values. So all numbers and strings are basic types and
1174 * structs, arrays, and variants are not basic types.
1175 * #DBUS_TYPE_INVALID is not a basic type.
1177 * This function is defined to return #TRUE for exactly those
1178 * types that can be written with _dbus_marshal_basic_type()
1179 * and read with _dbus_marshal_read_basic().
1181 * This function will crash if passed a typecode that isn't
1182 * in dbus-protocol.h
1184 * @returns #TRUE if type is basic
1187 _dbus_type_is_basic (int typecode)
1189 /* only reasonable (non-line-noise) typecodes are allowed */
1190 _dbus_assert (_dbus_type_is_valid (typecode) || typecode == DBUS_TYPE_INVALID);
1192 /* everything that isn't invalid or a container */
1193 return !(typecode == DBUS_TYPE_INVALID || TYPE_IS_CONTAINER (typecode));
1197 * Tells you whether values of this type can change length if you set
1198 * them to some other value. For this purpose, you assume that the
1199 * first byte of the old and new value would be in the same location,
1200 * so alignment padding is not a factor.
1202 * @returns #FALSE if the type can occupy different lengths
1205 _dbus_type_is_fixed (int typecode)
1209 case DBUS_TYPE_BYTE:
1210 case DBUS_TYPE_BOOLEAN:
1211 case DBUS_TYPE_INT32:
1212 case DBUS_TYPE_UINT32:
1213 case DBUS_TYPE_INT64:
1214 case DBUS_TYPE_UINT64:
1215 case DBUS_TYPE_DOUBLE:
1223 * Returns a string describing the given type.
1225 * @param typecode the type to describe
1226 * @returns a constant string describing the type
1229 _dbus_type_to_string (int typecode)
1233 case DBUS_TYPE_INVALID:
1235 case DBUS_TYPE_BOOLEAN:
1237 case DBUS_TYPE_BYTE:
1239 case DBUS_TYPE_INT32:
1241 case DBUS_TYPE_UINT32:
1243 case DBUS_TYPE_DOUBLE:
1245 case DBUS_TYPE_STRING:
1247 case DBUS_TYPE_OBJECT_PATH:
1248 return "object_path";
1249 case DBUS_TYPE_SIGNATURE:
1251 case DBUS_TYPE_STRUCT:
1253 case DBUS_TYPE_ARRAY:
1255 case DBUS_TYPE_VARIANT:
1257 case DBUS_STRUCT_BEGIN_CHAR:
1258 return "begin_struct";
1259 case DBUS_STRUCT_END_CHAR:
1260 return "end_struct";
1267 * If in verbose mode, print a block of binary data.
1269 * @todo right now it prints even if not in verbose mode
1271 * @param data the data
1272 * @param len the length of the data
1273 * @param offset where to start counting for byte indexes
1276 _dbus_verbose_bytes (const unsigned char *data,
1281 const unsigned char *aligned;
1283 _dbus_assert (len >= 0);
1285 /* Print blanks on first row if appropriate */
1286 aligned = _DBUS_ALIGN_ADDRESS (data, 4);
1289 _dbus_assert (aligned <= data);
1291 if (aligned != data)
1293 _dbus_verbose ("%4d\t%p: ", - (data - aligned), aligned);
1294 while (aligned != data)
1296 _dbus_verbose (" ");
1301 /* now print the bytes */
1305 if (_DBUS_ALIGN_ADDRESS (&data[i], 4) == &data[i])
1307 _dbus_verbose ("%4d\t%p: ",
1308 offset + i, &data[i]);
1311 if (data[i] >= 32 &&
1313 _dbus_verbose (" '%c' ", data[i]);
1315 _dbus_verbose ("0x%s%x ",
1316 data[i] <= 0xf ? "0" : "", data[i]);
1320 if (_DBUS_ALIGN_ADDRESS (&data[i], 4) == &data[i])
1323 _dbus_verbose ("BE: %d LE: %d",
1324 _dbus_unpack_uint32 (DBUS_BIG_ENDIAN, &data[i-4]),
1325 _dbus_unpack_uint32 (DBUS_LITTLE_ENDIAN, &data[i-4]));
1328 _DBUS_ALIGN_ADDRESS (&data[i], 8) == &data[i])
1330 #ifdef DBUS_HAVE_INT64
1331 /* I think I probably mean "GNU libc printf" and not "GNUC"
1332 * but we'll wait until someone complains. If you hit this,
1333 * just turn off verbose mode as a workaround.
1336 _dbus_verbose (" u64: 0x%llx",
1337 *(dbus_uint64_t*)&data[i-8]);
1340 _dbus_verbose (" dbl: %g",
1341 *(double*)&data[i-8]);
1344 _dbus_verbose ("\n");
1348 _dbus_verbose ("\n");
1352 * Dump the given part of the string to verbose log.
1354 * @param str the string
1355 * @param start the start of range to dump
1356 * @param len length of range
1359 _dbus_verbose_bytes_of_string (const DBusString *str,
1366 real_len = _dbus_string_get_length (str);
1368 _dbus_assert (start >= 0);
1370 if (start > real_len)
1372 _dbus_verbose (" [%d,%d) is not inside string of length %d\n",
1373 start, len, real_len);
1377 if ((start + len) > real_len)
1379 _dbus_verbose (" [%d,%d) extends outside string of length %d\n",
1380 start, len, real_len);
1381 len = real_len - start;
1384 d = _dbus_string_get_const_data_len (str, start, len);
1386 _dbus_verbose_bytes (d, len, start);
1391 #ifdef DBUS_BUILD_TESTS
1392 #include "dbus-test.h"
1396 swap_test_array (void *array,
1406 _dbus_string_init_const_len (&t, array, len_bytes);
1407 swap_array (&t, 0, len_bytes / alignment, byte_order, alignment);
1410 #define MARSHAL_BASIC(typename, byte_order, literal) \
1412 v_##typename = literal; \
1413 if (!_dbus_marshal_write_basic (&str, pos, DBUS_TYPE_##typename, \
1415 byte_order, NULL)) \
1416 _dbus_assert_not_reached ("no memory"); \
1419 #define DEMARSHAL_BASIC(typename, byte_order) \
1421 _dbus_marshal_read_basic (&str, pos, DBUS_TYPE_##typename, &v_##typename, \
1422 byte_order, &pos); \
1425 #define DEMARSHAL_BASIC_AND_CHECK(typename, byte_order, literal) \
1427 DEMARSHAL_BASIC (typename, byte_order); \
1428 if (literal != v_##typename) \
1430 _dbus_verbose_bytes_of_string (&str, dump_pos, \
1431 _dbus_string_get_length (&str) - dump_pos); \
1432 _dbus_assert_not_reached ("demarshaled wrong value"); \
1436 #define MARSHAL_TEST(typename, byte_order, literal) \
1438 MARSHAL_BASIC (typename, byte_order, literal); \
1440 DEMARSHAL_BASIC_AND_CHECK (typename, byte_order, literal); \
1443 #define MARSHAL_TEST_STRCMP(typename, byte_order, literal) \
1445 MARSHAL_BASIC (typename, byte_order, literal); \
1447 DEMARSHAL_BASIC (typename, byte_order); \
1448 if (strcmp (literal, v_##typename) != 0) \
1450 _dbus_verbose_bytes_of_string (&str, dump_pos, \
1451 _dbus_string_get_length (&str) - dump_pos); \
1452 _dbus_warn ("literal '%s'\nvalue '%s'\n", literal, v_##typename); \
1453 _dbus_assert_not_reached ("demarshaled wrong value"); \
1457 #define MARSHAL_FIXED_ARRAY(typename, byte_order, literal) \
1460 v_UINT32 = sizeof(literal); \
1461 if (!_dbus_marshal_write_basic (&str, pos, DBUS_TYPE_UINT32, &v_UINT32, \
1462 byte_order, &next)) \
1463 _dbus_assert_not_reached ("no memory"); \
1464 v_ARRAY_##typename = literal; \
1465 if (!_dbus_marshal_write_fixed_multi (&str, next, DBUS_TYPE_##typename, \
1466 &v_ARRAY_##typename, _DBUS_N_ELEMENTS(literal), \
1467 byte_order, NULL)) \
1468 _dbus_assert_not_reached ("no memory"); \
1471 #define DEMARSHAL_FIXED_ARRAY(typename, byte_order) \
1474 alignment = _dbus_type_get_alignment (DBUS_TYPE_##typename); \
1475 v_UINT32 = _dbus_marshal_read_uint32 (&str, dump_pos, byte_order, &next); \
1476 _dbus_marshal_read_fixed_multi (&str, next, DBUS_TYPE_##typename, &v_ARRAY_##typename, \
1477 v_UINT32/alignment, \
1478 byte_order, NULL); \
1479 swap_test_array (v_ARRAY_##typename, v_UINT32, \
1480 byte_order, alignment); \
1483 #define DEMARSHAL_FIXED_ARRAY_AND_CHECK(typename, byte_order, literal) \
1485 DEMARSHAL_FIXED_ARRAY (typename, byte_order); \
1486 if (memcmp (literal, v_ARRAY_##typename, sizeof (literal) != 0)) \
1488 _dbus_verbose ("MARSHALED DATA\n"); \
1489 _dbus_verbose_bytes_of_string (&str, dump_pos, \
1490 _dbus_string_get_length (&str) - dump_pos); \
1491 _dbus_verbose ("LITERAL DATA\n"); \
1492 _dbus_verbose_bytes ((char*)literal, sizeof (literal), 0); \
1493 _dbus_verbose ("READ DATA\n"); \
1494 _dbus_verbose_bytes ((char*)v_ARRAY_##typename, sizeof (literal), 0); \
1495 _dbus_assert_not_reached ("demarshaled wrong fixed array value"); \
1499 #define MARSHAL_TEST_FIXED_ARRAY(typename, byte_order, literal) \
1501 MARSHAL_FIXED_ARRAY (typename, byte_order, literal); \
1503 DEMARSHAL_FIXED_ARRAY_AND_CHECK (typename, byte_order, literal); \
1507 _dbus_marshal_test (void)
1512 unsigned char array1[5] = { 3, 4, 0, 1, 9 };
1513 dbus_int32_t array4[3] = { 123, 456, 789 };
1514 #ifdef DBUS_HAVE_INT64
1515 dbus_int64_t array8[3] = { DBUS_INT64_CONSTANT (0x123ffffffff),
1516 DBUS_INT64_CONSTANT (0x456ffffffff),
1517 DBUS_INT64_CONSTANT (0x789ffffffff) };
1518 dbus_int64_t *v_ARRAY_INT64;
1520 unsigned char *v_ARRAY_BYTE;
1521 dbus_int32_t *v_ARRAY_INT32;
1522 double *v_ARRAY_DOUBLE;
1526 dbus_int32_t v_INT32;
1527 dbus_uint32_t v_UINT32;
1528 dbus_int64_t v_INT64;
1529 dbus_uint64_t v_UINT64;
1530 unsigned char v_BYTE;
1531 unsigned char v_BOOLEAN;
1532 const char *v_STRING;
1533 const char *v_SIGNATURE;
1534 const char *v_OBJECT_PATH;
1537 if (!_dbus_string_init (&str))
1538 _dbus_assert_not_reached ("failed to init string");
1542 /* Marshal doubles */
1543 MARSHAL_BASIC (DOUBLE, DBUS_BIG_ENDIAN, 3.14);
1544 DEMARSHAL_BASIC (DOUBLE, DBUS_BIG_ENDIAN);
1546 if (!_DBUS_DOUBLES_BITWISE_EQUAL (t_DOUBLE, v_DOUBLE))
1547 _dbus_assert_not_reached ("got wrong double value");
1549 MARSHAL_BASIC (DOUBLE, DBUS_LITTLE_ENDIAN, 3.14);
1550 DEMARSHAL_BASIC (DOUBLE, DBUS_LITTLE_ENDIAN);
1552 if (!_DBUS_DOUBLES_BITWISE_EQUAL (t_DOUBLE, v_DOUBLE))
1553 _dbus_assert_not_reached ("got wrong double value");
1555 /* Marshal signed integers */
1556 MARSHAL_TEST (INT32, DBUS_BIG_ENDIAN, -12345678);
1557 MARSHAL_TEST (INT32, DBUS_LITTLE_ENDIAN, -12345678);
1559 /* Marshal unsigned integers */
1560 MARSHAL_TEST (UINT32, DBUS_BIG_ENDIAN, 0x12345678);
1561 MARSHAL_TEST (UINT32, DBUS_LITTLE_ENDIAN, 0x12345678);
1563 #ifdef DBUS_HAVE_INT64
1564 /* Marshal signed integers */
1565 MARSHAL_TEST (INT64, DBUS_BIG_ENDIAN, DBUS_INT64_CONSTANT (-0x123456789abc7));
1566 MARSHAL_TEST (INT64, DBUS_LITTLE_ENDIAN, DBUS_INT64_CONSTANT (-0x123456789abc7));
1568 /* Marshal unsigned integers */
1569 MARSHAL_TEST (UINT64, DBUS_BIG_ENDIAN, DBUS_UINT64_CONSTANT (0x123456789abc7));
1570 MARSHAL_TEST (UINT64, DBUS_LITTLE_ENDIAN, DBUS_UINT64_CONSTANT (0x123456789abc7));
1571 #endif /* DBUS_HAVE_INT64 */
1574 MARSHAL_TEST (BYTE, DBUS_BIG_ENDIAN, 5);
1575 MARSHAL_TEST (BYTE, DBUS_LITTLE_ENDIAN, 5);
1577 /* Marshal all possible bools! */
1578 MARSHAL_TEST (BOOLEAN, DBUS_BIG_ENDIAN, FALSE);
1579 MARSHAL_TEST (BOOLEAN, DBUS_LITTLE_ENDIAN, FALSE);
1580 MARSHAL_TEST (BOOLEAN, DBUS_BIG_ENDIAN, TRUE);
1581 MARSHAL_TEST (BOOLEAN, DBUS_LITTLE_ENDIAN, TRUE);
1583 /* Marshal strings */
1584 MARSHAL_TEST_STRCMP (STRING, DBUS_BIG_ENDIAN, "");
1585 MARSHAL_TEST_STRCMP (STRING, DBUS_LITTLE_ENDIAN, "");
1586 MARSHAL_TEST_STRCMP (STRING, DBUS_BIG_ENDIAN, "This is the dbus test string");
1587 MARSHAL_TEST_STRCMP (STRING, DBUS_LITTLE_ENDIAN, "This is the dbus test string");
1590 MARSHAL_TEST_STRCMP (OBJECT_PATH, DBUS_BIG_ENDIAN, "/a/b/c");
1591 MARSHAL_TEST_STRCMP (OBJECT_PATH, DBUS_LITTLE_ENDIAN, "/a/b/c");
1594 MARSHAL_TEST_STRCMP (SIGNATURE, DBUS_BIG_ENDIAN, "");
1595 MARSHAL_TEST_STRCMP (SIGNATURE, DBUS_LITTLE_ENDIAN, "");
1596 MARSHAL_TEST_STRCMP (SIGNATURE, DBUS_BIG_ENDIAN, "a(ii)");
1597 MARSHAL_TEST_STRCMP (SIGNATURE, DBUS_LITTLE_ENDIAN, "a(ii)");
1600 MARSHAL_TEST_FIXED_ARRAY (INT32, DBUS_BIG_ENDIAN, array4);
1601 MARSHAL_TEST_FIXED_ARRAY (INT32, DBUS_LITTLE_ENDIAN, array4);
1603 MARSHAL_TEST_FIXED_ARRAY (BYTE, DBUS_BIG_ENDIAN, array1);
1604 MARSHAL_TEST_FIXED_ARRAY (BYTE, DBUS_LITTLE_ENDIAN, array1);
1606 #ifdef DBUS_HAVE_INT64
1607 MARSHAL_TEST_FIXED_ARRAY (INT64, DBUS_BIG_ENDIAN, array8);
1608 MARSHAL_TEST_FIXED_ARRAY (INT64, DBUS_LITTLE_ENDIAN, array8);
1614 * FIXME restore the set/pack tests
1617 #ifdef DBUS_HAVE_INT64
1618 /* set/pack 64-bit integers */
1619 _dbus_string_set_length (&str, 8);
1622 _dbus_marshal_set_int64 (&str, DBUS_LITTLE_ENDIAN,
1623 0, DBUS_INT64_CONSTANT (-0x123456789abc7));
1625 _dbus_assert (DBUS_INT64_CONSTANT (-0x123456789abc7) ==
1626 _dbus_unpack_int64 (DBUS_LITTLE_ENDIAN,
1627 _dbus_string_get_const_data (&str)));
1630 _dbus_marshal_set_int64 (&str, DBUS_BIG_ENDIAN,
1631 0, DBUS_INT64_CONSTANT (-0x123456789abc7));
1633 _dbus_assert (DBUS_INT64_CONSTANT (-0x123456789abc7) ==
1634 _dbus_unpack_int64 (DBUS_BIG_ENDIAN,
1635 _dbus_string_get_const_data (&str)));
1637 /* signed little pack */
1638 _dbus_pack_int64 (DBUS_INT64_CONSTANT (-0x123456789abc7),
1640 _dbus_string_get_data (&str));
1642 _dbus_assert (DBUS_INT64_CONSTANT (-0x123456789abc7) ==
1643 _dbus_unpack_int64 (DBUS_LITTLE_ENDIAN,
1644 _dbus_string_get_const_data (&str)));
1646 /* signed big pack */
1647 _dbus_pack_int64 (DBUS_INT64_CONSTANT (-0x123456789abc7),
1649 _dbus_string_get_data (&str));
1651 _dbus_assert (DBUS_INT64_CONSTANT (-0x123456789abc7) ==
1652 _dbus_unpack_int64 (DBUS_BIG_ENDIAN,
1653 _dbus_string_get_const_data (&str)));
1655 /* unsigned little */
1656 _dbus_marshal_set_uint64 (&str, DBUS_LITTLE_ENDIAN,
1657 0, DBUS_UINT64_CONSTANT (0x123456789abc7));
1659 _dbus_assert (DBUS_UINT64_CONSTANT (0x123456789abc7) ==
1660 _dbus_unpack_uint64 (DBUS_LITTLE_ENDIAN,
1661 _dbus_string_get_const_data (&str)));
1664 _dbus_marshal_set_uint64 (&str, DBUS_BIG_ENDIAN,
1665 0, DBUS_UINT64_CONSTANT (0x123456789abc7));
1667 _dbus_assert (DBUS_UINT64_CONSTANT (0x123456789abc7) ==
1668 _dbus_unpack_uint64 (DBUS_BIG_ENDIAN,
1669 _dbus_string_get_const_data (&str)));
1671 /* unsigned little pack */
1672 _dbus_pack_uint64 (DBUS_UINT64_CONSTANT (0x123456789abc7),
1674 _dbus_string_get_data (&str));
1676 _dbus_assert (DBUS_UINT64_CONSTANT (0x123456789abc7) ==
1677 _dbus_unpack_uint64 (DBUS_LITTLE_ENDIAN,
1678 _dbus_string_get_const_data (&str)));
1680 /* unsigned big pack */
1681 _dbus_pack_uint64 (DBUS_UINT64_CONSTANT (0x123456789abc7),
1683 _dbus_string_get_data (&str));
1685 _dbus_assert (DBUS_UINT64_CONSTANT (0x123456789abc7) ==
1686 _dbus_unpack_uint64 (DBUS_BIG_ENDIAN,
1687 _dbus_string_get_const_data (&str)));
1688 #endif /* DBUS_HAVE_INT64 */
1690 /* set/pack 32-bit integers */
1691 _dbus_string_set_length (&str, 4);
1694 _dbus_marshal_set_int32 (&str, DBUS_LITTLE_ENDIAN,
1697 _dbus_assert (-0x123456 ==
1698 _dbus_unpack_int32 (DBUS_LITTLE_ENDIAN,
1699 _dbus_string_get_const_data (&str)));
1702 _dbus_marshal_set_int32 (&str, DBUS_BIG_ENDIAN,
1705 _dbus_assert (-0x123456 ==
1706 _dbus_unpack_int32 (DBUS_BIG_ENDIAN,
1707 _dbus_string_get_const_data (&str)));
1709 /* signed little pack */
1710 _dbus_pack_int32 (-0x123456,
1712 _dbus_string_get_data (&str));
1714 _dbus_assert (-0x123456 ==
1715 _dbus_unpack_int32 (DBUS_LITTLE_ENDIAN,
1716 _dbus_string_get_const_data (&str)));
1718 /* signed big pack */
1719 _dbus_pack_int32 (-0x123456,
1721 _dbus_string_get_data (&str));
1723 _dbus_assert (-0x123456 ==
1724 _dbus_unpack_int32 (DBUS_BIG_ENDIAN,
1725 _dbus_string_get_const_data (&str)));
1727 /* unsigned little */
1728 _dbus_marshal_set_uint32 (&str,
1730 DBUS_LITTLE_ENDIAN);
1732 _dbus_assert (0x123456 ==
1733 _dbus_unpack_uint32 (DBUS_LITTLE_ENDIAN,
1734 _dbus_string_get_const_data (&str)));
1737 _dbus_marshal_set_uint32 (&str,
1741 _dbus_assert (0x123456 ==
1742 _dbus_unpack_uint32 (DBUS_BIG_ENDIAN,
1743 _dbus_string_get_const_data (&str)));
1745 /* unsigned little pack */
1746 _dbus_pack_uint32 (0x123456,
1748 _dbus_string_get_data (&str));
1750 _dbus_assert (0x123456 ==
1751 _dbus_unpack_uint32 (DBUS_LITTLE_ENDIAN,
1752 _dbus_string_get_const_data (&str)));
1754 /* unsigned big pack */
1755 _dbus_pack_uint32 (0x123456,
1757 _dbus_string_get_data (&str));
1759 _dbus_assert (0x123456 ==
1760 _dbus_unpack_uint32 (DBUS_BIG_ENDIAN,
1761 _dbus_string_get_const_data (&str)));
1763 #endif /* set/pack tests for integers */
1765 /* Strings in-place set */
1766 byte_order = DBUS_LITTLE_ENDIAN;
1770 _dbus_string_set_length (&str, 0);
1772 /* reset pos for the macros */
1775 MARSHAL_TEST_STRCMP (STRING, byte_order, "Hello world");
1777 /* Set it to something longer */
1778 _dbus_string_init_const (&t, "Hello world foo");
1780 v_STRING = _dbus_string_get_const_data (&t);
1781 _dbus_marshal_set_basic (&str, 0, DBUS_TYPE_STRING,
1782 &v_STRING, byte_order, NULL, NULL);
1784 _dbus_marshal_read_basic (&str, 0, DBUS_TYPE_STRING,
1785 &v_STRING, byte_order,
1787 _dbus_assert (strcmp (v_STRING, "Hello world foo") == 0);
1789 /* Set it to something shorter */
1790 _dbus_string_init_const (&t, "Hello");
1792 v_STRING = _dbus_string_get_const_data (&t);
1793 _dbus_marshal_set_basic (&str, 0, DBUS_TYPE_STRING,
1794 &v_STRING, byte_order, NULL, NULL);
1795 _dbus_marshal_read_basic (&str, 0, DBUS_TYPE_STRING,
1796 &v_STRING, byte_order,
1798 _dbus_assert (strcmp (v_STRING, "Hello") == 0);
1800 /* Do the other byte order */
1801 if (byte_order == DBUS_LITTLE_ENDIAN)
1802 byte_order = DBUS_BIG_ENDIAN;
1808 _dbus_string_free (&str);
1813 #endif /* DBUS_BUILD_TESTS */