1 /* -*- mode: C; c-file-style: "gnu" -*- */
2 /* dbus-marshal.c Marshalling routines
4 * Copyright (C) 2002 CodeFactory AB
6 * Licensed under the Academic Free License version 1.2
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
24 #include "dbus-marshal.h"
25 #include "dbus-internals.h"
31 swap_bytes (unsigned char *data,
34 unsigned char *p1 = data;
35 unsigned char *p2 = data + len - 1;
39 unsigned char tmp = *p1;
49 * @defgroup DBusMarshal marshaling and unmarshaling
50 * @ingroup DBusInternals
51 * @brief functions to marshal/unmarshal data from the wire
53 * Types and functions related to converting primitive data types from
54 * wire format to native machine format, and vice versa.
60 * Unpacks a 32 bit unsigned integer from a data pointer
62 * @param byte_order The byte order to use
63 * @param data the data pointer
64 * @returns the integer
67 _dbus_unpack_uint32 (int byte_order,
68 const unsigned char *data)
70 _dbus_assert (_DBUS_ALIGN_ADDRESS (data, 4) == data);
72 if (byte_order == DBUS_LITTLE_ENDIAN)
73 return DBUS_UINT32_FROM_LE (*(dbus_uint32_t*)data);
75 return DBUS_UINT32_FROM_BE (*(dbus_uint32_t*)data);
79 * Unpacks a 32 bit signed integer from a data pointer
81 * @param byte_order The byte order to use
82 * @param data the data pointer
83 * @returns the integer
86 _dbus_unpack_int32 (int byte_order,
87 const unsigned char *data)
89 _dbus_assert (_DBUS_ALIGN_ADDRESS (data, 4) == data);
91 if (byte_order == DBUS_LITTLE_ENDIAN)
92 return DBUS_INT32_FROM_LE (*(dbus_int32_t*)data);
94 return DBUS_INT32_FROM_BE (*(dbus_int32_t*)data);
98 * Packs a 32 bit unsigned integer into a data pointer.
100 * @param value the value
101 * @param byte_order the byte order to use
102 * @param data the data pointer
105 _dbus_pack_uint32 (dbus_uint32_t value,
109 _dbus_assert (_DBUS_ALIGN_ADDRESS (data, 4) == data);
111 if ((byte_order) == DBUS_LITTLE_ENDIAN)
112 *((dbus_uint32_t*)(data)) = DBUS_UINT32_TO_LE (value);
114 *((dbus_uint32_t*)(data)) = DBUS_UINT32_TO_BE (value);
118 * Packs a 32 bit signed integer into a data pointer.
120 * @param value the value
121 * @param byte_order the byte order to use
122 * @param data the data pointer
125 _dbus_pack_int32 (dbus_int32_t value,
129 _dbus_assert (_DBUS_ALIGN_ADDRESS (data, 4) == data);
131 if ((byte_order) == DBUS_LITTLE_ENDIAN)
132 *((dbus_int32_t*)(data)) = DBUS_INT32_TO_LE (value);
134 *((dbus_int32_t*)(data)) = DBUS_INT32_TO_BE (value);
138 * Sets the 4 bytes at the given offset to a marshaled signed integer,
139 * replacing anything found there previously.
141 * @param str the string to write the marshalled int to
142 * @param offset the byte offset where int should be written
143 * @param byte_order the byte order to use
144 * @param value the value
148 _dbus_marshal_set_int32 (DBusString *str,
155 _dbus_assert (byte_order == DBUS_LITTLE_ENDIAN ||
156 byte_order == DBUS_BIG_ENDIAN);
158 _dbus_string_get_data_len (str, &data, offset, 4);
160 _dbus_pack_int32 (value, byte_order, data);
164 * Sets the 4 bytes at the given offset to a marshaled unsigned
165 * integer, replacing anything found there previously.
167 * @param str the string to write the marshalled int to
168 * @param offset the byte offset where int should be written
169 * @param byte_order the byte order to use
170 * @param value the value
174 _dbus_marshal_set_uint32 (DBusString *str,
181 _dbus_assert (byte_order == DBUS_LITTLE_ENDIAN ||
182 byte_order == DBUS_BIG_ENDIAN);
184 _dbus_string_get_data_len (str, &data, offset, 4);
186 _dbus_pack_uint32 (value, byte_order, data);
190 * Sets the existing marshaled string at the given offset with
191 * a new marshaled string. The given offset must point to
192 * an existing string or the wrong length will be deleted
193 * and replaced with the new string.
195 * @param str the string to write the marshalled string to
196 * @param offset the byte offset where string should be written
197 * @param byte_order the byte order to use
198 * @param value the value
199 * @returns #TRUE on success
203 _dbus_marshal_set_string (DBusString *str,
206 const DBusString *value)
211 _dbus_assert (byte_order == DBUS_LITTLE_ENDIAN ||
212 byte_order == DBUS_BIG_ENDIAN);
214 old_len = _dbus_demarshal_uint32 (str, byte_order,
217 new_len = _dbus_string_get_length (value);
219 if (!_dbus_string_replace_len (value, 0, new_len,
220 str, offset + 4, old_len))
223 _dbus_marshal_set_uint32 (str, byte_order,
230 * Marshals a double value.
232 * @param str the string to append the marshalled value to
233 * @param byte_order the byte order to use
234 * @param value the value
235 * @returns #TRUE on success
238 _dbus_marshal_double (DBusString *str,
242 _dbus_assert (sizeof (double) == 8);
244 if (!_dbus_string_align_length (str, sizeof (double)))
247 if (byte_order != DBUS_COMPILER_BYTE_ORDER)
248 swap_bytes ((unsigned char *)&value, sizeof (double));
250 return _dbus_string_append_len (str, (const char *)&value, sizeof (double));
254 * Marshals a 32 bit signed integer value.
256 * @param str the string to append the marshalled value to
257 * @param byte_order the byte order to use
258 * @param value the value
259 * @returns #TRUE on success
262 _dbus_marshal_int32 (DBusString *str,
266 if (!_dbus_string_align_length (str, sizeof (dbus_int32_t)))
269 if (byte_order != DBUS_COMPILER_BYTE_ORDER)
270 value = DBUS_INT32_SWAP_LE_BE (value);
272 return _dbus_string_append_len (str, (const char *)&value, sizeof (dbus_int32_t));
276 * Marshals a 32 bit unsigned integer value.
278 * @param str the string to append the marshalled value to
279 * @param byte_order the byte order to use
280 * @param value the value
281 * @returns #TRUE on success
284 _dbus_marshal_uint32 (DBusString *str,
288 if (!_dbus_string_align_length (str, sizeof (dbus_uint32_t)))
291 if (byte_order != DBUS_COMPILER_BYTE_ORDER)
292 value = DBUS_UINT32_SWAP_LE_BE (value);
294 return _dbus_string_append_len (str, (const char *)&value, sizeof (dbus_uint32_t));
298 * Marshals a UTF-8 string
300 * @param str the string to append the marshalled value to
301 * @param byte_order the byte order to use
302 * @param value the string
303 * @returns #TRUE on success
306 _dbus_marshal_string (DBusString *str,
310 int len, old_string_len;
312 old_string_len = _dbus_string_get_length (str);
314 len = strlen (value);
316 if (!_dbus_marshal_uint32 (str, byte_order, len))
318 /* Restore the previous length */
319 _dbus_string_set_length (str, old_string_len);
324 return _dbus_string_append_len (str, value, len + 1);
328 * Marshals a byte array
330 * @param str the string to append the marshalled value to
331 * @param byte_order the byte order to use
332 * @param value the array
333 * @param len number of elements in the array
334 * @returns #TRUE on success
337 _dbus_marshal_byte_array (DBusString *str,
339 const unsigned char *value,
344 old_string_len = _dbus_string_get_length (str);
346 if (!_dbus_marshal_uint32 (str, byte_order, len))
348 /* Restore the previous length */
349 _dbus_string_set_length (str, old_string_len);
354 return _dbus_string_append_len (str, value, len);
358 * Marshals a 32 bit signed integer array
360 * @param str the string to append the marshalled value to
361 * @param byte_order the byte order to use
362 * @param value the array
363 * @param len the length of the array
364 * @returns #TRUE on success
367 _dbus_marshal_int32_array (DBusString *str,
369 const dbus_int32_t *value,
372 int i, old_string_len;
374 old_string_len = _dbus_string_get_length (str);
376 if (!_dbus_marshal_uint32 (str, byte_order, len))
379 for (i = 0; i < len; i++)
380 if (!_dbus_marshal_int32 (str, byte_order, value[i]))
386 /* Restore previous length */
387 _dbus_string_set_length (str, old_string_len);
393 * Marshals a 32 bit unsigned integer array
395 * @param str the string to append the marshalled value to
396 * @param byte_order the byte order to use
397 * @param value the array
398 * @param len the length of the array
399 * @returns #TRUE on success
402 _dbus_marshal_uint32_array (DBusString *str,
404 const dbus_uint32_t *value,
407 int i, old_string_len;
409 old_string_len = _dbus_string_get_length (str);
411 if (!_dbus_marshal_uint32 (str, byte_order, len))
414 for (i = 0; i < len; i++)
415 if (!_dbus_marshal_uint32 (str, byte_order, value[i]))
421 /* Restore previous length */
422 _dbus_string_set_length (str, old_string_len);
428 * Marshals a double array
430 * @param str the string to append the marshalled value to
431 * @param byte_order the byte order to use
432 * @param value the array
433 * @param len the length of the array
434 * @returns #TRUE on success
437 _dbus_marshal_double_array (DBusString *str,
442 int i, old_string_len;
444 old_string_len = _dbus_string_get_length (str);
446 if (!_dbus_marshal_uint32 (str, byte_order, len))
449 for (i = 0; i < len; i++)
450 if (!_dbus_marshal_double (str, byte_order, value[i]))
456 /* Restore previous length */
457 _dbus_string_set_length (str, old_string_len);
463 * Marshals a string array
465 * @param str the string to append the marshalled value to
466 * @param byte_order the byte order to use
467 * @param value the array
468 * @param len the length of the array
469 * @returns #TRUE on success
472 _dbus_marshal_string_array (DBusString *str,
477 int i, old_string_len;
479 old_string_len = _dbus_string_get_length (str);
481 if (!_dbus_marshal_uint32 (str, byte_order, len))
484 for (i = 0; i < len; i++)
485 if (!_dbus_marshal_string (str, byte_order, value[i]))
491 /* Restore previous length */
492 _dbus_string_set_length (str, old_string_len);
498 * Demarshals a double.
500 * @param str the string containing the data
501 * @param byte_order the byte order
502 * @param pos the position in the string
503 * @param new_pos the new position of the string
504 * @returns the demarshaled double.
507 _dbus_demarshal_double (DBusString *str,
515 pos = _DBUS_ALIGN_VALUE (pos, sizeof (double));
517 _dbus_string_get_const_data_len (str, &buffer, pos, sizeof (double));
519 retval = *(double *)buffer;
521 if (byte_order != DBUS_COMPILER_BYTE_ORDER)
522 swap_bytes ((unsigned char *)&retval, sizeof (double));
525 *new_pos = pos + sizeof (double);
531 * Demarshals a 32 bit signed integer.
533 * @param str the string containing the data
534 * @param byte_order the byte order
535 * @param pos the position in the string
536 * @param new_pos the new position of the string
537 * @returns the demarshaled integer.
540 _dbus_demarshal_int32 (DBusString *str,
547 pos = _DBUS_ALIGN_VALUE (pos, sizeof (dbus_int32_t));
549 _dbus_string_get_const_data_len (str, &buffer, pos, sizeof (dbus_int32_t));
552 *new_pos = pos + sizeof (dbus_int32_t);
554 return _dbus_unpack_int32 (byte_order, buffer);
558 * Demarshals a 32 bit unsigned integer.
560 * @param str the string containing the data
561 * @param byte_order the byte order
562 * @param pos the position in the string
563 * @param new_pos the new position of the string
564 * @returns the demarshaled integer.
567 _dbus_demarshal_uint32 (DBusString *str,
574 pos = _DBUS_ALIGN_VALUE (pos, sizeof (dbus_uint32_t));
576 _dbus_string_get_const_data_len (str, &buffer, pos, sizeof (dbus_uint32_t));
579 *new_pos = pos + sizeof (dbus_uint32_t);
581 return _dbus_unpack_uint32 (byte_order, buffer);
585 * Demarshals an UTF-8 string.
587 * @todo Should we check the string to make sure
588 * that it's valid UTF-8, and maybe "fix" the string
591 * @todo Should probably demarshal to a DBusString,
592 * having memcpy() in here is Evil(tm).
594 * @param str the string containing the data
595 * @param byte_order the byte order
596 * @param pos the position in the string
597 * @param new_pos the new position of the string
598 * @returns the demarshaled string.
601 _dbus_demarshal_string (DBusString *str,
610 len = _dbus_demarshal_uint32 (str, byte_order, pos, &pos);
612 retval = dbus_malloc (len + 1);
617 _dbus_string_get_const_data_len (str, &data, pos, len);
622 memcpy (retval, data, len + 1);
625 *new_pos = pos + len + 1;
631 * Demarshals a byte array.
633 * @todo Should probably demarshal to a DBusString,
634 * having memcpy() in here is Evil(tm).
636 * @param str the string containing the data
637 * @param byte_order the byte order
638 * @param pos the position in the string
639 * @param new_pos the new position of the string
640 * @param array_len length of the demarshaled data
641 * @returns the demarshaled data.
644 _dbus_demarshal_byte_array (DBusString *str,
651 unsigned char *retval;
654 len = _dbus_demarshal_uint32 (str, byte_order, pos, &pos);
656 retval = dbus_malloc (len);
661 _dbus_string_get_const_data_len (str, &data, pos, len);
666 memcpy (retval, data, len);
669 *new_pos = pos + len;
678 * Demarshals a 32 bit signed integer array.
680 * @param str the string containing the data
681 * @param byte_order the byte order
682 * @param pos the position in the string
683 * @param new_pos the new position of the string
684 * @param array_len length of the demarshaled data
685 * @returns the demarshaled data.
688 _dbus_demarshal_int32_array (DBusString *str,
695 dbus_int32_t *retval;
697 len = _dbus_demarshal_uint32 (str, byte_order, pos, &pos);
699 retval = dbus_new (dbus_int32_t, len);
704 for (i = 0; i < len; i++)
705 retval[i] = _dbus_demarshal_int32 (str, byte_order, pos, &pos);
717 * Demarshals a 32 bit unsigned integer array.
719 * @param str the string containing the data
720 * @param byte_order the byte order
721 * @param pos the position in the string
722 * @param new_pos the new position of the string
723 * @param array_len length of the demarshaled data
724 * @returns the demarshaled data.
727 _dbus_demarshal_uint32_array (DBusString *str,
734 dbus_uint32_t *retval;
736 len = _dbus_demarshal_uint32 (str, byte_order, pos, &pos);
738 retval = dbus_new (dbus_uint32_t, len);
743 for (i = 0; i < len; i++)
744 retval[i] = _dbus_demarshal_uint32 (str, byte_order, pos, &pos);
756 * Demarshals a double array.
758 * @param str the string containing the data
759 * @param byte_order the byte order
760 * @param pos the position in the string
761 * @param new_pos the new position of the string
762 * @param array_len length of the demarshaled data
763 * @returns the demarshaled data.
766 _dbus_demarshal_double_array (DBusString *str,
775 len = _dbus_demarshal_uint32 (str, byte_order, pos, &pos);
777 retval = dbus_new (double, len);
782 for (i = 0; i < len; i++)
783 retval[i] = _dbus_demarshal_double (str, byte_order, pos, &pos);
795 * Demarshals a string array.
797 * @param str the string containing the data
798 * @param byte_order the byte order
799 * @param pos the position in the string
800 * @param new_pos the new position of the string
801 * @param array_len length of the demarshaled data
802 * @returns the demarshaled data.
805 _dbus_demarshal_string_array (DBusString *str,
814 len = _dbus_demarshal_uint32 (str, byte_order, pos, &pos);
816 retval = dbus_new (char *, len);
821 for (i = 0; i < len; i++)
823 retval[i] = _dbus_demarshal_string (str, byte_order, pos, &pos);
838 for (j = 0; j < i; j++)
839 dbus_free (retval[i]);
846 * Returns the position right after the end position
847 * end position of a field. Validates the field
848 * contents as required (e.g. ensures that
849 * string fields have a valid length and
850 * are nul-terminated).
852 * @todo security: audit the field validation code.
854 * @todo warns on invalid type in a message, but
855 * probably the whole message needs to be dumped,
856 * or we might even drop the connection due
857 * to bad protocol. Needs better error handling.
858 * Possible security issue.
860 * @param str a string
861 * @param byte_order the byte order to use
862 * @param pos the pos where the field starts
863 * @param end_pos pointer where the position right
864 * after the end position will follow
865 * @returns TRUE if more data exists after the field
868 _dbus_marshal_get_field_end_pos (DBusString *str,
875 if (pos >= _dbus_string_get_length (str))
878 _dbus_string_get_const_data_len (str, &data, pos, 1);
882 case DBUS_TYPE_INVALID:
886 case DBUS_TYPE_INT32:
887 *end_pos = _DBUS_ALIGN_VALUE (pos + 1, sizeof (dbus_int32_t)) + sizeof (dbus_int32_t);
891 case DBUS_TYPE_UINT32:
892 *end_pos = _DBUS_ALIGN_VALUE (pos + 1, sizeof (dbus_uint32_t)) + sizeof (dbus_uint32_t);
896 case DBUS_TYPE_DOUBLE:
897 *end_pos = _DBUS_ALIGN_VALUE (pos + 1, sizeof (double)) + sizeof (double);
901 case DBUS_TYPE_STRING:
905 /* Demarshal the length */
906 len = _dbus_demarshal_uint32 (str, byte_order, pos + 1, &pos);
908 *end_pos = pos + len + 1;
910 if (*end_pos > _dbus_string_get_length (str))
912 _dbus_verbose ("string length outside length of the message\n");
916 if (_dbus_string_get_byte (str, pos+len) != '\0')
918 _dbus_verbose ("string field not nul-terminated\n");
925 case DBUS_TYPE_BYTE_ARRAY:
929 /* Demarshal the length */
930 len = _dbus_demarshal_uint32 (str, byte_order, pos + 1, &pos);
932 *end_pos = pos + len;
937 case DBUS_TYPE_INT32_ARRAY:
941 /* Demarshal the length */
942 len = _dbus_demarshal_uint32 (str, byte_order, pos + 1, &new_pos);
944 *end_pos = _DBUS_ALIGN_VALUE (new_pos, sizeof (dbus_int32_t))
945 + (len * sizeof (dbus_int32_t));
950 case DBUS_TYPE_UINT32_ARRAY:
954 /* Demarshal the length */
955 len = _dbus_demarshal_uint32 (str, byte_order, pos + 1, &new_pos);
957 *end_pos = _DBUS_ALIGN_VALUE (new_pos, sizeof (dbus_uint32_t))
958 + (len * sizeof (dbus_uint32_t));
963 case DBUS_TYPE_DOUBLE_ARRAY:
967 /* Demarshal the length */
968 len = _dbus_demarshal_uint32 (str, byte_order, pos + 1, &new_pos);
970 *end_pos = _DBUS_ALIGN_VALUE (new_pos, sizeof (double))
971 + (len * sizeof (double));
976 case DBUS_TYPE_STRING_ARRAY:
980 /* Demarshal the length */
981 len = _dbus_demarshal_uint32 (str, byte_order, pos + 1, &pos);
983 for (i = 0; i < len; i++)
987 /* Demarshal string length */
988 str_len = _dbus_demarshal_uint32 (str, byte_order, pos, &pos);
996 _dbus_warn ("Unknown message field type %d\n", *data);
1000 if (*end_pos > _dbus_string_get_length (str))
1007 * If in verbose mode, print a block of binary data.
1009 * @todo right now it prints even if not in verbose mode
1011 * @param data the data
1012 * @param len the length of the data
1015 _dbus_verbose_bytes (const unsigned char *data,
1019 const unsigned char *aligned;
1021 /* Print blanks on first row if appropriate */
1022 aligned = _DBUS_ALIGN_ADDRESS (data, 4);
1025 _dbus_assert (aligned <= data);
1027 if (aligned != data)
1029 _dbus_verbose ("%5d\t%p: ", - (data - aligned), aligned);
1030 while (aligned != data)
1032 _dbus_verbose (" ");
1037 /* now print the bytes */
1041 if (_DBUS_ALIGN_ADDRESS (&data[i], 4) == &data[i])
1043 _dbus_verbose ("%5d\t%p: ",
1047 if (data[i] >= 32 &&
1049 _dbus_verbose (" '%c' ", data[i]);
1051 _dbus_verbose ("0x%s%x ",
1052 data[i] <= 0xf ? "0" : "", data[i]);
1056 if (_DBUS_ALIGN_ADDRESS (&data[i], 4) == &data[i])
1059 _dbus_verbose ("big: %d little: %d",
1060 _dbus_unpack_uint32 (DBUS_BIG_ENDIAN, &data[i-4]),
1061 _dbus_unpack_uint32 (DBUS_LITTLE_ENDIAN, &data[i-4]));
1063 _dbus_verbose ("\n");
1067 _dbus_verbose ("\n");
1071 * Dump the given part of the string to verbose log.
1073 * @param str the string
1074 * @param start the start of range to dump
1075 * @param len length of range
1078 _dbus_verbose_bytes_of_string (const DBusString *str,
1084 _dbus_string_get_const_data_len (str, &d, start, len);
1086 _dbus_verbose_bytes (d, len);
1091 #ifdef DBUS_BUILD_TESTS
1092 #include "dbus-test.h"
1096 _dbus_marshal_test (void)
1100 dbus_int32_t array1[3] = { 0x123, 0x456, 0x789 }, *array2;
1103 if (!_dbus_string_init (&str, _DBUS_INT_MAX))
1104 _dbus_assert_not_reached ("failed to init string");
1106 /* Marshal doubles */
1107 if (!_dbus_marshal_double (&str, DBUS_BIG_ENDIAN, 3.14))
1108 _dbus_assert_not_reached ("could not marshal double value");
1109 _dbus_assert (_dbus_demarshal_double (&str, DBUS_BIG_ENDIAN, pos, &pos) == 3.14);
1111 if (!_dbus_marshal_double (&str, DBUS_LITTLE_ENDIAN, 3.14))
1112 _dbus_assert_not_reached ("could not marshal double value");
1113 _dbus_assert (_dbus_demarshal_double (&str, DBUS_LITTLE_ENDIAN, pos, &pos) == 3.14);
1115 /* Marshal signed integers */
1116 if (!_dbus_marshal_int32 (&str, DBUS_BIG_ENDIAN, -12345678))
1117 _dbus_assert_not_reached ("could not marshal signed integer value");
1118 _dbus_assert (_dbus_demarshal_int32 (&str, DBUS_BIG_ENDIAN, pos, &pos) == -12345678);
1120 if (!_dbus_marshal_int32 (&str, DBUS_LITTLE_ENDIAN, -12345678))
1121 _dbus_assert_not_reached ("could not marshal signed integer value");
1122 _dbus_assert (_dbus_demarshal_int32 (&str, DBUS_LITTLE_ENDIAN, pos, &pos) == -12345678);
1124 /* Marshal unsigned integers */
1125 if (!_dbus_marshal_uint32 (&str, DBUS_BIG_ENDIAN, 0x12345678))
1126 _dbus_assert_not_reached ("could not marshal signed integer value");
1127 _dbus_assert (_dbus_demarshal_uint32 (&str, DBUS_BIG_ENDIAN, pos, &pos) == 0x12345678);
1129 if (!_dbus_marshal_uint32 (&str, DBUS_LITTLE_ENDIAN, 0x12345678))
1130 _dbus_assert_not_reached ("could not marshal signed integer value");
1131 _dbus_assert (_dbus_demarshal_uint32 (&str, DBUS_LITTLE_ENDIAN, pos, &pos) == 0x12345678);
1133 /* Marshal strings */
1134 tmp1 = "This is the dbus test string";
1135 if (!_dbus_marshal_string (&str, DBUS_BIG_ENDIAN, tmp1))
1136 _dbus_assert_not_reached ("could not marshal string");
1137 tmp2 = _dbus_demarshal_string (&str, DBUS_BIG_ENDIAN, pos, &pos);
1138 _dbus_assert (strcmp (tmp1, tmp2) == 0);
1141 tmp1 = "This is the dbus test string";
1142 if (!_dbus_marshal_string (&str, DBUS_LITTLE_ENDIAN, tmp1))
1143 _dbus_assert_not_reached ("could not marshal string");
1144 tmp2 = _dbus_demarshal_string (&str, DBUS_LITTLE_ENDIAN, pos, &pos);
1145 _dbus_assert (strcmp (tmp1, tmp2) == 0);
1148 /* Marshal signed integer arrays */
1149 if (!_dbus_marshal_int32_array (&str, DBUS_BIG_ENDIAN, array1, 3))
1150 _dbus_assert_not_reached ("could not marshal integer array");
1151 array2 = _dbus_demarshal_int32_array (&str, DBUS_BIG_ENDIAN, pos, &pos, &len);
1152 printf ("length is: %d\n", len);
1154 _dbus_assert_not_reached ("Signed integer array lengths differ!\n");
1159 _dbus_string_free (&str);
1165 #endif /* DBUS_BUILD_TESTS */