1 /* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
26 #include "dbus-internals.h"
27 #include "dbus-marshal-basic.h"
28 #include "dbus-signature.h"
32 #if defined(__GNUC__) && (__GNUC__ >= 4)
33 # define _DBUS_ASSERT_ALIGNMENT(type, op, val) \
34 _DBUS_STATIC_ASSERT (__extension__ __alignof__ (type) op val)
36 /* not gcc, so probably no alignof operator: just use a no-op statement
37 * that's valid in the same contexts */
38 # define _DBUS_ASSERT_ALIGNMENT(type, op, val) \
39 _DBUS_STATIC_ASSERT (TRUE)
42 /* True by definition, but just for completeness... */
43 _DBUS_STATIC_ASSERT (sizeof (char) == 1);
44 _DBUS_ASSERT_ALIGNMENT (char, ==, 1);
46 _DBUS_STATIC_ASSERT (sizeof (dbus_int16_t) == 2);
47 _DBUS_ASSERT_ALIGNMENT (dbus_int16_t, <=, 2);
48 _DBUS_STATIC_ASSERT (sizeof (dbus_uint16_t) == 2);
49 _DBUS_ASSERT_ALIGNMENT (dbus_uint16_t, <=, 2);
51 _DBUS_STATIC_ASSERT (sizeof (dbus_int32_t) == 4);
52 _DBUS_ASSERT_ALIGNMENT (dbus_int32_t, <=, 4);
53 _DBUS_STATIC_ASSERT (sizeof (dbus_uint32_t) == 4);
54 _DBUS_ASSERT_ALIGNMENT (dbus_uint32_t, <=, 4);
55 _DBUS_STATIC_ASSERT (sizeof (dbus_bool_t) == 4);
56 _DBUS_ASSERT_ALIGNMENT (dbus_bool_t, <=, 4);
58 _DBUS_STATIC_ASSERT (sizeof (double) == 8);
59 _DBUS_ASSERT_ALIGNMENT (double, <=, 8);
61 #ifdef DBUS_HAVE_INT64
62 _DBUS_STATIC_ASSERT (sizeof (dbus_int64_t) == 8);
63 _DBUS_ASSERT_ALIGNMENT (dbus_int64_t, <=, 8);
64 _DBUS_STATIC_ASSERT (sizeof (dbus_uint64_t) == 8);
65 _DBUS_ASSERT_ALIGNMENT (dbus_uint64_t, <=, 8);
69 * @defgroup DBusMarshal marshaling and unmarshaling
70 * @ingroup DBusInternals
71 * @brief functions to marshal/unmarshal data from the wire
73 * Types and functions related to converting primitive data types from
74 * wire format to native machine format, and vice versa.
76 * A signature is just a string with multiple types one after the other.
77 * for example a type is "i" or "(ii)", a signature is "i(ii)"
78 * where i is int and (ii) is struct { int; int; }
84 pack_2_octets (dbus_uint16_t value,
88 _dbus_assert (_DBUS_ALIGN_ADDRESS (data, 2) == data);
90 if ((byte_order) == DBUS_LITTLE_ENDIAN)
91 *((dbus_uint16_t*)(data)) = DBUS_UINT16_TO_LE (value);
93 *((dbus_uint16_t*)(data)) = DBUS_UINT16_TO_BE (value);
97 pack_4_octets (dbus_uint32_t value,
101 _dbus_assert (_DBUS_ALIGN_ADDRESS (data, 4) == data);
103 if ((byte_order) == DBUS_LITTLE_ENDIAN)
104 *((dbus_uint32_t*)(data)) = DBUS_UINT32_TO_LE (value);
106 *((dbus_uint32_t*)(data)) = DBUS_UINT32_TO_BE (value);
110 pack_8_octets (DBusBasicValue value,
114 _dbus_assert (_DBUS_ALIGN_ADDRESS (data, 8) == data);
116 #ifdef DBUS_HAVE_INT64
117 if ((byte_order) == DBUS_LITTLE_ENDIAN)
118 *((dbus_uint64_t*)(data)) = DBUS_UINT64_TO_LE (value.u64);
120 *((dbus_uint64_t*)(data)) = DBUS_UINT64_TO_BE (value.u64);
122 *(DBus8ByteStruct*)data = value.u64;
123 swap_8_octets ((DBusBasicValue*)data, byte_order);
128 * Packs a 32 bit unsigned integer into a data pointer.
130 * @param value the value
131 * @param byte_order the byte order to use
132 * @param data the data pointer
135 _dbus_pack_uint32 (dbus_uint32_t value,
139 pack_4_octets (value, byte_order, data);
142 #ifndef DBUS_HAVE_INT64
145 swap_bytes (unsigned char *data,
148 unsigned char *p1 = data;
149 unsigned char *p2 = data + len - 1;
153 unsigned char tmp = *p1;
161 #endif /* !DBUS_HAVE_INT64 */
164 swap_8_octets (DBusBasicValue *value,
167 if (byte_order != DBUS_COMPILER_BYTE_ORDER)
169 #ifdef DBUS_HAVE_INT64
170 value->u64 = DBUS_UINT64_SWAP_LE_BE (value->u64);
172 swap_bytes ((unsigned char *)value, 8);
178 static DBusBasicValue
179 unpack_8_octets (int byte_order,
180 const unsigned char *data)
184 _dbus_assert (_DBUS_ALIGN_ADDRESS (data, 8) == data);
185 _dbus_assert (sizeof (r) == 8);
187 #ifdef DBUS_HAVE_INT64
188 if (byte_order == DBUS_LITTLE_ENDIAN)
189 r.u64 = DBUS_UINT64_FROM_LE (*(dbus_uint64_t*)data);
191 r.u64 = DBUS_UINT64_FROM_BE (*(dbus_uint64_t*)data);
193 r.u64 = *(DBus8ByteStruct*)data;
194 swap_8_octets (&r, byte_order);
201 #ifndef _dbus_unpack_uint16
203 * Unpacks a 16 bit unsigned integer from a data pointer
205 * @param byte_order The byte order to use
206 * @param data the data pointer
207 * @returns the integer
210 _dbus_unpack_uint16 (int byte_order,
211 const unsigned char *data)
213 _dbus_assert (_DBUS_ALIGN_ADDRESS (data, 2) == data);
215 if (byte_order == DBUS_LITTLE_ENDIAN)
216 return DBUS_UINT16_FROM_LE (*(dbus_uint16_t*)data);
218 return DBUS_UINT16_FROM_BE (*(dbus_uint16_t*)data);
220 #endif /* _dbus_unpack_uint16 */
222 #ifndef _dbus_unpack_uint32
224 * Unpacks a 32 bit unsigned integer from a data pointer
226 * @param byte_order The byte order to use
227 * @param data the data pointer
228 * @returns the integer
231 _dbus_unpack_uint32 (int byte_order,
232 const unsigned char *data)
234 _dbus_assert (_DBUS_ALIGN_ADDRESS (data, 4) == data);
236 if (byte_order == DBUS_LITTLE_ENDIAN)
237 return DBUS_UINT32_FROM_LE (*(dbus_uint32_t*)data);
239 return DBUS_UINT32_FROM_BE (*(dbus_uint32_t*)data);
241 #endif /* _dbus_unpack_uint32 */
244 set_2_octets (DBusString *str,
251 _dbus_assert (byte_order == DBUS_LITTLE_ENDIAN ||
252 byte_order == DBUS_BIG_ENDIAN);
254 data = _dbus_string_get_data_len (str, offset, 2);
256 pack_2_octets (value, byte_order, data);
260 set_4_octets (DBusString *str,
267 _dbus_assert (byte_order == DBUS_LITTLE_ENDIAN ||
268 byte_order == DBUS_BIG_ENDIAN);
270 data = _dbus_string_get_data_len (str, offset, 4);
272 pack_4_octets (value, byte_order, data);
276 set_8_octets (DBusString *str,
278 DBusBasicValue value,
283 _dbus_assert (byte_order == DBUS_LITTLE_ENDIAN ||
284 byte_order == DBUS_BIG_ENDIAN);
286 data = _dbus_string_get_data_len (str, offset, 8);
288 pack_8_octets (value, byte_order, data);
292 * Sets the 4 bytes at the given offset to a marshaled unsigned
293 * integer, replacing anything found there previously.
295 * @param str the string to write the marshalled int to
296 * @param pos the byte offset where int should be written
297 * @param value the value
298 * @param byte_order the byte order to use
302 _dbus_marshal_set_uint32 (DBusString *str,
307 set_4_octets (str, pos, value, byte_order);
311 * Sets the existing marshaled string at the given offset with
312 * a new marshaled string. The given offset must point to
313 * an existing string or the wrong length will be deleted
314 * and replaced with the new string.
316 * Note: no attempt is made by this function to re-align
317 * any data which has been already marshalled after this
318 * string. Use with caution.
320 * @param str the string to write the marshalled string to
321 * @param pos the position of the marshaled string length
322 * @param value the value
323 * @param byte_order the byte order to use
324 * @param old_end_pos place to store byte after the nul byte of the old value
325 * @param new_end_pos place to store byte after the nul byte of the new value
326 * @returns #TRUE on success, #FALSE if no memory
330 set_string (DBusString *str,
337 int old_len, new_len;
340 _dbus_string_init_const (&dstr, value);
342 _dbus_assert (_DBUS_ALIGN_VALUE (pos, 4) == (unsigned) pos);
343 old_len = _dbus_unpack_uint32 (byte_order,
344 _dbus_string_get_const_data_len (str, pos, 4));
346 new_len = _dbus_string_get_length (&dstr);
348 if (!_dbus_string_replace_len (&dstr, 0, new_len,
349 str, pos + 4, old_len))
352 _dbus_marshal_set_uint32 (str, pos, new_len, byte_order);
355 *old_end_pos = pos + 4 + old_len + 1;
357 *new_end_pos = pos + 4 + new_len + 1;
363 * Sets the existing marshaled signature at the given offset to a new
364 * marshaled signature. Same basic ideas as set_string().
366 * @param str the string to write the marshalled signature to
367 * @param pos the position of the marshaled signature length
368 * @param value the value
369 * @param byte_order the byte order to use
370 * @param old_end_pos place to store byte after the nul byte of the old value
371 * @param new_end_pos place to store byte after the nul byte of the new value
372 * @returns #TRUE on success, #FALSE if no memory
376 set_signature (DBusString *str,
383 int old_len, new_len;
386 _dbus_string_init_const (&dstr, value);
388 old_len = _dbus_string_get_byte (str, pos);
389 new_len = _dbus_string_get_length (&dstr);
391 if (!_dbus_string_replace_len (&dstr, 0, new_len,
392 str, pos + 1, old_len))
395 _dbus_string_set_byte (str, pos, new_len);
398 *old_end_pos = pos + 1 + old_len + 1;
400 *new_end_pos = pos + 1 + new_len + 1;
406 * Sets an existing basic type value to a new value.
407 * Arguments work the same way as _dbus_marshal_basic_type().
409 * @param str the string
410 * @param pos location of the current value
411 * @param type the type of the current and new values
412 * @param value the address of the new value
413 * @param byte_order byte order for marshaling
414 * @param old_end_pos location to store end position of the old value, or #NULL
415 * @param new_end_pos location to store end position of the new value, or #NULL
416 * @returns #FALSE if no memory
419 _dbus_marshal_set_basic (DBusString *str,
427 const DBusBasicValue *vp;
434 _dbus_string_set_byte (str, pos, vp->byt);
436 *old_end_pos = pos + 1;
438 *new_end_pos = pos + 1;
441 case DBUS_TYPE_INT16:
442 case DBUS_TYPE_UINT16:
443 pos = _DBUS_ALIGN_VALUE (pos, 2);
444 set_2_octets (str, pos, vp->u16, byte_order);
446 *old_end_pos = pos + 2;
448 *new_end_pos = pos + 2;
451 case DBUS_TYPE_BOOLEAN:
452 case DBUS_TYPE_INT32:
453 case DBUS_TYPE_UINT32:
454 case DBUS_TYPE_UNIX_FD:
455 pos = _DBUS_ALIGN_VALUE (pos, 4);
456 set_4_octets (str, pos, vp->u32, byte_order);
458 *old_end_pos = pos + 4;
460 *new_end_pos = pos + 4;
463 case DBUS_TYPE_INT64:
464 case DBUS_TYPE_UINT64:
465 case DBUS_TYPE_DOUBLE:
466 pos = _DBUS_ALIGN_VALUE (pos, 8);
467 set_8_octets (str, pos, *vp, byte_order);
469 *old_end_pos = pos + 8;
471 *new_end_pos = pos + 8;
474 case DBUS_TYPE_STRING:
475 case DBUS_TYPE_OBJECT_PATH:
476 pos = _DBUS_ALIGN_VALUE (pos, 4);
477 _dbus_assert (vp->str != NULL);
478 return set_string (str, pos, vp->str, byte_order,
479 old_end_pos, new_end_pos);
481 case DBUS_TYPE_SIGNATURE:
482 _dbus_assert (vp->str != NULL);
483 return set_signature (str, pos, vp->str, byte_order,
484 old_end_pos, new_end_pos);
487 _dbus_assert_not_reached ("not a basic type");
494 * Convenience function to demarshal a 32 bit unsigned integer.
496 * @param str the string containing the data
497 * @param byte_order the byte order
498 * @param pos the position in the string
499 * @param new_pos the new position of the string
500 * @returns the demarshaled integer.
503 _dbus_marshal_read_uint32 (const DBusString *str,
508 pos = _DBUS_ALIGN_VALUE (pos, 4);
513 _dbus_assert (pos + 4 <= _dbus_string_get_length (str));
515 return _dbus_unpack_uint32 (byte_order,
516 _dbus_string_get_const_data (str) + pos);
520 * Demarshals a basic-typed value. The "value" pointer is always
521 * the address of a variable of the basic type. So e.g.
522 * if the basic type is "double" then the pointer is
523 * a double*, and if it's "char*" then the pointer is
526 * A value of type #DBusBasicValue is guaranteed to be large enough to
527 * hold any of the types that may be returned, which is handy if you
528 * are trying to do things generically. For example you can pass
529 * a DBusBasicValue* in to this function, and then pass the same
530 * DBusBasicValue* in to _dbus_marshal_basic_type() in order to
531 * move a value from one place to another.
533 * @param str the string containing the data
534 * @param pos position in the string
535 * @param type type of value to demarshal
536 * @param value pointer to return value data
537 * @param byte_order the byte order
538 * @param new_pos pointer to update with new position, or #NULL
541 _dbus_marshal_read_basic (const DBusString *str,
548 const char *str_data;
550 _dbus_assert (dbus_type_is_basic (type));
552 str_data = _dbus_string_get_const_data (str);
554 /* Below we volatile types to avoid aliasing issues;
555 * see http://bugs.freedesktop.org/show_bug.cgi?id=20137
562 volatile unsigned char *vp = value;
563 *vp = (unsigned char) _dbus_string_get_byte (str, pos);
567 case DBUS_TYPE_INT16:
568 case DBUS_TYPE_UINT16:
570 volatile dbus_uint16_t *vp = value;
571 pos = _DBUS_ALIGN_VALUE (pos, 2);
572 *vp = *(dbus_uint16_t *)(str_data + pos);
573 if (byte_order != DBUS_COMPILER_BYTE_ORDER)
574 *vp = DBUS_UINT16_SWAP_LE_BE (*vp);
578 case DBUS_TYPE_INT32:
579 case DBUS_TYPE_UINT32:
580 case DBUS_TYPE_BOOLEAN:
581 case DBUS_TYPE_UNIX_FD:
583 volatile dbus_uint32_t *vp = value;
584 pos = _DBUS_ALIGN_VALUE (pos, 4);
585 *vp = *(dbus_uint32_t *)(str_data + pos);
586 if (byte_order != DBUS_COMPILER_BYTE_ORDER)
587 *vp = DBUS_UINT32_SWAP_LE_BE (*vp);
591 case DBUS_TYPE_INT64:
592 case DBUS_TYPE_UINT64:
593 case DBUS_TYPE_DOUBLE:
595 volatile dbus_uint64_t *vp = value;
596 pos = _DBUS_ALIGN_VALUE (pos, 8);
597 #ifdef DBUS_HAVE_INT64
598 if (byte_order != DBUS_COMPILER_BYTE_ORDER)
599 *vp = DBUS_UINT64_SWAP_LE_BE (*(dbus_uint64_t*)(str_data + pos));
601 *vp = *(dbus_uint64_t*)(str_data + pos);
603 *vp = *(DBus8ByteStruct*) (str_data + pos);
604 swap_8_octets (vp, byte_order);
609 case DBUS_TYPE_STRING:
610 case DBUS_TYPE_OBJECT_PATH:
613 volatile char **vp = value;
615 len = _dbus_marshal_read_uint32 (str, pos, byte_order, &pos);
617 *vp = (char*) str_data + pos;
619 pos += len + 1; /* length plus nul */
622 case DBUS_TYPE_SIGNATURE:
625 volatile char **vp = value;
627 len = _dbus_string_get_byte (str, pos);
630 *vp = (char*) str_data + pos;
632 pos += len + 1; /* length plus nul */
636 _dbus_warn_check_failed ("type %s %d not a basic type\n",
637 _dbus_type_to_string (type), type);
638 _dbus_assert_not_reached ("not a basic type");
647 marshal_2_octets (DBusString *str,
656 _dbus_assert (sizeof (value) == 2);
658 if (byte_order != DBUS_COMPILER_BYTE_ORDER)
659 value = DBUS_UINT16_SWAP_LE_BE (value);
661 orig_len = _dbus_string_get_length (str);
663 retval = _dbus_string_insert_2_aligned (str, insert_at,
664 (const unsigned char *)&value);
668 *pos_after = insert_at + (_dbus_string_get_length (str) - orig_len);
669 _dbus_assert (*pos_after <= _dbus_string_get_length (str));
676 marshal_4_octets (DBusString *str,
685 _dbus_assert (sizeof (value) == 4);
687 if (byte_order != DBUS_COMPILER_BYTE_ORDER)
688 value = DBUS_UINT32_SWAP_LE_BE (value);
690 orig_len = _dbus_string_get_length (str);
692 retval = _dbus_string_insert_4_aligned (str, insert_at,
693 (const unsigned char *)&value);
697 *pos_after = insert_at + (_dbus_string_get_length (str) - orig_len);
698 _dbus_assert (*pos_after <= _dbus_string_get_length (str));
705 marshal_8_octets (DBusString *str,
707 DBusBasicValue value,
714 _dbus_assert (sizeof (value) == 8);
716 swap_8_octets (&value, byte_order);
718 orig_len = _dbus_string_get_length (str);
720 retval = _dbus_string_insert_8_aligned (str, insert_at,
721 (const unsigned char *)&value);
724 *pos_after = insert_at + _dbus_string_get_length (str) - orig_len;
732 MARSHAL_AS_SIGNATURE,
733 MARSHAL_AS_BYTE_ARRAY
737 marshal_len_followed_by_bytes (int marshal_as,
740 const unsigned char *value,
741 int data_len, /* doesn't include nul if any */
746 DBusString value_str;
749 _dbus_assert (byte_order == DBUS_LITTLE_ENDIAN || byte_order == DBUS_BIG_ENDIAN);
750 if (insert_at > _dbus_string_get_length (str))
751 _dbus_warn ("insert_at = %d string len = %d data_len = %d\n",
752 insert_at, _dbus_string_get_length (str), data_len);
754 if (marshal_as == MARSHAL_AS_BYTE_ARRAY)
755 value_len = data_len;
757 value_len = data_len + 1; /* value has a nul */
759 _dbus_string_init_const_len (&value_str, value, value_len);
763 if (marshal_as == MARSHAL_AS_SIGNATURE)
765 _dbus_assert (data_len <= DBUS_MAXIMUM_SIGNATURE_LENGTH);
766 _dbus_assert (data_len <= 255); /* same as max sig len right now */
768 if (!_dbus_string_insert_byte (str, pos, data_len))
775 if (!marshal_4_octets (str, pos, data_len,
780 if (!_dbus_string_copy_len (&value_str, 0, value_len,
786 _dbus_assert (_dbus_string_equal_substring (&value_str, 0, value_len,
788 _dbus_verbose_bytes_of_string (str, pos, value_len);
799 /* Delete what we've inserted */
800 _dbus_string_delete (str, insert_at, pos - insert_at);
806 marshal_string (DBusString *str,
812 return marshal_len_followed_by_bytes (MARSHAL_AS_STRING,
813 str, insert_at, value,
815 byte_order, pos_after);
819 marshal_signature (DBusString *str,
824 return marshal_len_followed_by_bytes (MARSHAL_AS_SIGNATURE,
825 str, insert_at, value,
827 DBUS_COMPILER_BYTE_ORDER, /* irrelevant */
832 * Marshals a basic-typed value. The "value" pointer is always the
833 * address of a variable containing the basic type value.
834 * So for example for int32 it will be dbus_int32_t*, and
835 * for string it will be const char**. This is for symmetry
836 * with _dbus_marshal_read_basic() and to have a simple
839 * @param str string to marshal to
840 * @param insert_at where to insert the value
841 * @param type type of value
842 * @param value pointer to a variable containing the value
843 * @param byte_order byte order
844 * @param pos_after #NULL or the position after the type
845 * @returns #TRUE on success
848 _dbus_marshal_write_basic (DBusString *str,
855 const DBusBasicValue *vp;
857 _dbus_assert (dbus_type_is_basic (type));
864 if (!_dbus_string_insert_byte (str, insert_at, vp->byt))
867 *pos_after = insert_at + 1;
870 case DBUS_TYPE_INT16:
871 case DBUS_TYPE_UINT16:
872 return marshal_2_octets (str, insert_at, vp->u16,
873 byte_order, pos_after);
875 case DBUS_TYPE_BOOLEAN:
876 return marshal_4_octets (str, insert_at, vp->u32 != FALSE,
877 byte_order, pos_after);
879 case DBUS_TYPE_INT32:
880 case DBUS_TYPE_UINT32:
881 case DBUS_TYPE_UNIX_FD:
882 return marshal_4_octets (str, insert_at, vp->u32,
883 byte_order, pos_after);
885 case DBUS_TYPE_INT64:
886 case DBUS_TYPE_UINT64:
887 case DBUS_TYPE_DOUBLE:
888 return marshal_8_octets (str, insert_at, *vp, byte_order, pos_after);
891 case DBUS_TYPE_STRING:
892 case DBUS_TYPE_OBJECT_PATH:
893 _dbus_assert (vp->str != NULL);
894 return marshal_string (str, insert_at, vp->str, byte_order, pos_after);
896 case DBUS_TYPE_SIGNATURE:
897 _dbus_assert (vp->str != NULL);
898 return marshal_signature (str, insert_at, vp->str, pos_after);
901 _dbus_assert_not_reached ("not a basic type");
908 marshal_1_octets_array (DBusString *str,
910 const unsigned char *value,
916 DBusString value_str;
918 _dbus_string_init_const_len (&value_str, value, n_elements);
922 if (!_dbus_string_copy_len (&value_str, 0, n_elements,
935 * Swaps the elements of an array to the opposite byte order
937 * @param data start of array
938 * @param n_elements number of elements
939 * @param alignment size of each element
942 _dbus_swap_array (unsigned char *data,
949 _dbus_assert (_DBUS_ALIGN_ADDRESS (data, alignment) == data);
951 /* we use const_data and cast it off so DBusString can be a const string
952 * for the unit tests. don't ask.
955 end = d + (n_elements * alignment);
961 #ifdef DBUS_HAVE_INT64
962 *((dbus_uint64_t*)d) = DBUS_UINT64_SWAP_LE_BE (*((dbus_uint64_t*)d));
964 swap_8_bytes ((DBusBasicValue*) d);
969 else if (alignment == 4)
973 *((dbus_uint32_t*)d) = DBUS_UINT32_SWAP_LE_BE (*((dbus_uint32_t*)d));
979 _dbus_assert (alignment == 2);
983 *((dbus_uint16_t*)d) = DBUS_UINT16_SWAP_LE_BE (*((dbus_uint16_t*)d));
990 swap_array (DBusString *str,
996 _dbus_assert (_DBUS_ALIGN_VALUE (array_start, alignment) == (unsigned) array_start);
998 if (byte_order != DBUS_COMPILER_BYTE_ORDER)
1000 /* we use const_data and cast it off so DBusString can be a const string
1001 * for the unit tests. don't ask.
1003 _dbus_swap_array ((unsigned char*) (_dbus_string_get_const_data (str) + array_start),
1004 n_elements, alignment);
1009 marshal_fixed_multi (DBusString *str,
1011 const DBusBasicValue *value,
1022 _dbus_assert (n_elements <= DBUS_MAXIMUM_ARRAY_LENGTH / alignment);
1024 old_string_len = _dbus_string_get_length (str);
1026 len_in_bytes = n_elements * alignment;
1027 array_start = insert_at;
1029 /* Note that we do alignment padding unconditionally
1030 * even if the array is empty; this means that
1031 * padding + len is always equal to the number of bytes
1035 if (!_dbus_string_insert_alignment (str, &array_start, alignment))
1038 _dbus_string_init_const_len (&t,
1039 (const unsigned char*) value,
1042 if (!_dbus_string_copy (&t, 0,
1046 swap_array (str, array_start, n_elements, byte_order, alignment);
1049 *pos_after = array_start + len_in_bytes;
1054 _dbus_string_delete (str, insert_at,
1055 _dbus_string_get_length (str) - old_string_len);
1061 * Marshals a block of values of fixed-length type all at once, as an
1062 * optimization. dbus_type_is_fixed() returns #TRUE for fixed-length
1063 * types, which are the basic types minus the string-like types.
1065 * The value argument should be the adddress of an
1066 * array, so e.g. "const dbus_uint32_t**"
1068 * @param str string to marshal to
1069 * @param insert_at where to insert the value
1070 * @param element_type type of array elements
1071 * @param value address of an array to marshal
1072 * @param n_elements number of elements in the array
1073 * @param byte_order byte order
1074 * @param pos_after #NULL or the position after the type
1075 * @returns #TRUE on success
1078 _dbus_marshal_write_fixed_multi (DBusString *str,
1086 const void* vp = *(const DBusBasicValue**)value;
1088 _dbus_assert (dbus_type_is_fixed (element_type));
1089 _dbus_assert (n_elements >= 0);
1092 _dbus_verbose ("writing %d elements of %s\n",
1093 n_elements, _dbus_type_to_string (element_type));
1096 switch (element_type)
1098 case DBUS_TYPE_BYTE:
1099 return marshal_1_octets_array (str, insert_at, vp, n_elements, byte_order, pos_after);
1101 case DBUS_TYPE_INT16:
1102 case DBUS_TYPE_UINT16:
1103 return marshal_fixed_multi (str, insert_at, vp, n_elements, byte_order, 2, pos_after);
1104 case DBUS_TYPE_BOOLEAN:
1105 case DBUS_TYPE_INT32:
1106 case DBUS_TYPE_UINT32:
1107 case DBUS_TYPE_UNIX_FD:
1108 return marshal_fixed_multi (str, insert_at, vp, n_elements, byte_order, 4, pos_after);
1110 case DBUS_TYPE_INT64:
1111 case DBUS_TYPE_UINT64:
1112 case DBUS_TYPE_DOUBLE:
1113 return marshal_fixed_multi (str, insert_at, vp, n_elements, byte_order, 8, pos_after);
1117 _dbus_assert_not_reached ("non fixed type in array write");
1126 * Skips over a basic-typed value, reporting the following position.
1128 * @param str the string containing the data
1129 * @param type type of value to read
1130 * @param byte_order the byte order
1131 * @param pos pointer to position in the string,
1132 * updated on return to new position
1135 _dbus_marshal_skip_basic (const DBusString *str,
1140 _dbus_assert (byte_order == DBUS_LITTLE_ENDIAN ||
1141 byte_order == DBUS_BIG_ENDIAN);
1145 case DBUS_TYPE_BYTE:
1148 case DBUS_TYPE_INT16:
1149 case DBUS_TYPE_UINT16:
1150 *pos = _DBUS_ALIGN_VALUE (*pos, 2);
1153 case DBUS_TYPE_BOOLEAN:
1154 case DBUS_TYPE_INT32:
1155 case DBUS_TYPE_UINT32:
1156 case DBUS_TYPE_UNIX_FD:
1157 *pos = _DBUS_ALIGN_VALUE (*pos, 4);
1160 case DBUS_TYPE_INT64:
1161 case DBUS_TYPE_UINT64:
1162 case DBUS_TYPE_DOUBLE:
1163 *pos = _DBUS_ALIGN_VALUE (*pos, 8);
1166 case DBUS_TYPE_STRING:
1167 case DBUS_TYPE_OBJECT_PATH:
1171 len = _dbus_marshal_read_uint32 (str, *pos, byte_order, pos);
1173 *pos += len + 1; /* length plus nul */
1176 case DBUS_TYPE_SIGNATURE:
1180 len = _dbus_string_get_byte (str, *pos);
1182 *pos += len + 2; /* length byte plus length plus nul */
1186 _dbus_warn ("type %s not a basic type\n",
1187 _dbus_type_to_string (type));
1188 _dbus_assert_not_reached ("not a basic type");
1194 * Skips an array, returning the next position.
1196 * @param str the string containing the data
1197 * @param element_type the type of array elements
1198 * @param byte_order the byte order
1199 * @param pos pointer to position in the string,
1200 * updated on return to new position
1203 _dbus_marshal_skip_array (const DBusString *str,
1208 dbus_uint32_t array_len;
1212 i = _DBUS_ALIGN_VALUE (*pos, 4);
1214 array_len = _dbus_marshal_read_uint32 (str, i, byte_order, &i);
1216 alignment = _dbus_type_get_alignment (element_type);
1218 i = _DBUS_ALIGN_VALUE (i, alignment);
1220 *pos = i + array_len;
1224 * Gets the alignment requirement for the given type;
1225 * will be 1, 4, or 8.
1227 * @param typecode the type
1228 * @returns alignment of 1, 4, or 8
1231 _dbus_type_get_alignment (int typecode)
1235 case DBUS_TYPE_BYTE:
1236 case DBUS_TYPE_VARIANT:
1237 case DBUS_TYPE_SIGNATURE:
1239 case DBUS_TYPE_INT16:
1240 case DBUS_TYPE_UINT16:
1242 case DBUS_TYPE_BOOLEAN:
1243 case DBUS_TYPE_INT32:
1244 case DBUS_TYPE_UINT32:
1245 case DBUS_TYPE_UNIX_FD:
1246 /* this stuff is 4 since it starts with a length */
1247 case DBUS_TYPE_STRING:
1248 case DBUS_TYPE_OBJECT_PATH:
1249 case DBUS_TYPE_ARRAY:
1251 case DBUS_TYPE_INT64:
1252 case DBUS_TYPE_UINT64:
1253 case DBUS_TYPE_DOUBLE:
1254 /* struct is 8 since it could contain an 8-aligned item
1255 * and it's simpler to just always align structs to 8;
1256 * we want the amount of padding in a struct of a given
1257 * type to be predictable, not location-dependent.
1258 * DICT_ENTRY is always the same as struct.
1260 case DBUS_TYPE_STRUCT:
1261 case DBUS_TYPE_DICT_ENTRY:
1265 _dbus_assert_not_reached ("unknown typecode in _dbus_type_get_alignment()");
1271 * Returns a string describing the given type.
1273 * @param typecode the type to describe
1274 * @returns a constant string describing the type
1277 _dbus_type_to_string (int typecode)
1281 case DBUS_TYPE_INVALID:
1283 case DBUS_TYPE_BOOLEAN:
1285 case DBUS_TYPE_BYTE:
1287 case DBUS_TYPE_INT16:
1289 case DBUS_TYPE_UINT16:
1291 case DBUS_TYPE_INT32:
1293 case DBUS_TYPE_UINT32:
1295 case DBUS_TYPE_INT64:
1297 case DBUS_TYPE_UINT64:
1299 case DBUS_TYPE_DOUBLE:
1301 case DBUS_TYPE_STRING:
1303 case DBUS_TYPE_OBJECT_PATH:
1304 return "object_path";
1305 case DBUS_TYPE_SIGNATURE:
1307 case DBUS_TYPE_STRUCT:
1309 case DBUS_TYPE_DICT_ENTRY:
1310 return "dict_entry";
1311 case DBUS_TYPE_ARRAY:
1313 case DBUS_TYPE_VARIANT:
1315 case DBUS_STRUCT_BEGIN_CHAR:
1316 return "begin_struct";
1317 case DBUS_STRUCT_END_CHAR:
1318 return "end_struct";
1319 case DBUS_DICT_ENTRY_BEGIN_CHAR:
1320 return "begin_dict_entry";
1321 case DBUS_DICT_ENTRY_END_CHAR:
1322 return "end_dict_entry";
1323 case DBUS_TYPE_UNIX_FD:
1331 * If in verbose mode, print a block of binary data.
1333 * @param data the data
1334 * @param len the length of the data
1335 * @param offset where to start counting for byte indexes
1338 _dbus_verbose_bytes (const unsigned char *data,
1343 const unsigned char *aligned;
1345 _dbus_assert (len >= 0);
1347 if (!_dbus_is_verbose())
1350 /* Print blanks on first row if appropriate */
1351 aligned = _DBUS_ALIGN_ADDRESS (data, 4);
1354 _dbus_assert (aligned <= data);
1356 if (aligned != data)
1358 _dbus_verbose ("%4ld\t%p: ", - (long)(data - aligned), aligned);
1359 while (aligned != data)
1361 _dbus_verbose (" ");
1366 /* now print the bytes */
1370 if (_DBUS_ALIGN_ADDRESS (&data[i], 4) == &data[i])
1372 _dbus_verbose ("%4d\t%p: ",
1373 offset + i, &data[i]);
1376 if (data[i] >= 32 &&
1378 _dbus_verbose (" '%c' ", data[i]);
1380 _dbus_verbose ("0x%s%x ",
1381 data[i] <= 0xf ? "0" : "", data[i]);
1385 if (_DBUS_ALIGN_ADDRESS (&data[i], 4) == &data[i])
1388 _dbus_verbose ("BE: %d LE: %d",
1389 _dbus_unpack_uint32 (DBUS_BIG_ENDIAN, &data[i-4]),
1390 _dbus_unpack_uint32 (DBUS_LITTLE_ENDIAN, &data[i-4]));
1393 _DBUS_ALIGN_ADDRESS (&data[i], 8) == &data[i])
1395 #ifdef DBUS_INT64_PRINTF_MODIFIER
1396 _dbus_verbose (" u64: 0x%" DBUS_INT64_PRINTF_MODIFIER "x",
1397 *(dbus_uint64_t*)&data[i-8]);
1399 _dbus_verbose (" dbl: %g",
1400 *(double*)&data[i-8]);
1403 _dbus_verbose ("\n");
1407 _dbus_verbose ("\n");
1411 * Dump the given part of the string to verbose log.
1413 * @param str the string
1414 * @param start the start of range to dump
1415 * @param len length of range
1418 _dbus_verbose_bytes_of_string (const DBusString *str,
1425 real_len = _dbus_string_get_length (str);
1427 _dbus_assert (start >= 0);
1429 if (start > real_len)
1431 _dbus_verbose (" [%d,%d) is not inside string of length %d\n",
1432 start, len, real_len);
1436 if ((start + len) > real_len)
1438 _dbus_verbose (" [%d,%d) extends outside string of length %d\n",
1439 start, len, real_len);
1440 len = real_len - start;
1443 d = _dbus_string_get_const_data_len (str, start, len);
1445 _dbus_verbose_bytes (d, len, start);
1449 map_type_char_to_type (int t)
1451 if (t == DBUS_STRUCT_BEGIN_CHAR)
1452 return DBUS_TYPE_STRUCT;
1453 else if (t == DBUS_DICT_ENTRY_BEGIN_CHAR)
1454 return DBUS_TYPE_DICT_ENTRY;
1457 _dbus_assert (t != DBUS_STRUCT_END_CHAR);
1458 _dbus_assert (t != DBUS_DICT_ENTRY_END_CHAR);
1464 * Get the first type in the signature. The difference between this
1465 * and just getting the first byte of the signature is that you won't
1466 * get DBUS_STRUCT_BEGIN_CHAR, you'll get DBUS_TYPE_STRUCT
1469 * @param str string containing signature
1470 * @param pos where the signature starts
1471 * @returns the first type in the signature
1474 _dbus_first_type_in_signature (const DBusString *str,
1477 return map_type_char_to_type (_dbus_string_get_byte (str, pos));
1481 * Similar to #_dbus_first_type_in_signature, but operates
1482 * on a C string buffer.
1484 * @param str a C string buffer
1485 * @param pos where the signature starts
1486 * @returns the first type in the signature
1489 _dbus_first_type_in_signature_c_str (const char *str,
1492 return map_type_char_to_type (str[pos]);
1497 #ifdef DBUS_BUILD_TESTS
1498 #include "dbus-test.h"
1502 * Reads a block of fixed-length basic values, as an optimization
1503 * vs. reading each one individually into a new buffer.
1505 * This function returns the data in-place; it does not make a copy,
1506 * and it does not swap the bytes.
1508 * If you ask for #DBUS_TYPE_DOUBLE you will get a "const double*" back
1509 * and the "value" argument should be a "const double**" and so on.
1511 * @param str the string to read from
1512 * @param pos position to read from
1513 * @param element_type type of array elements
1514 * @param value place to return the array
1515 * @param n_elements number of array elements to read
1516 * @param byte_order the byte order, used to read the array length
1517 * @param new_pos #NULL or location to store a position after the elements
1520 _dbus_marshal_read_fixed_multi (const DBusString *str,
1531 _dbus_assert (dbus_type_is_fixed (element_type));
1532 _dbus_assert (dbus_type_is_basic (element_type));
1535 _dbus_verbose ("reading %d elements of %s\n",
1536 n_elements, _dbus_type_to_string (element_type));
1539 alignment = _dbus_type_get_alignment (element_type);
1541 pos = _DBUS_ALIGN_VALUE (pos, alignment);
1543 array_len = n_elements * alignment;
1545 *(const DBusBasicValue**) value = (void*) _dbus_string_get_const_data_len (str, pos, array_len);
1547 *new_pos = pos + array_len;
1551 swap_test_array (void *array,
1561 _dbus_string_init_const_len (&t, array, len_bytes);
1562 swap_array (&t, 0, len_bytes / alignment, byte_order, alignment);
1565 #define MARSHAL_BASIC(typename, byte_order, literal) \
1567 v_##typename = literal; \
1568 if (!_dbus_marshal_write_basic (&str, pos, DBUS_TYPE_##typename, \
1570 byte_order, NULL)) \
1571 _dbus_assert_not_reached ("no memory"); \
1574 #define DEMARSHAL_BASIC(typename, byte_order) \
1576 _dbus_marshal_read_basic (&str, pos, DBUS_TYPE_##typename, &v_##typename, \
1577 byte_order, &pos); \
1580 #define DEMARSHAL_BASIC_AND_CHECK(typename, byte_order, literal) \
1582 DEMARSHAL_BASIC (typename, byte_order); \
1583 if (literal != v_##typename) \
1585 _dbus_verbose_bytes_of_string (&str, dump_pos, \
1586 _dbus_string_get_length (&str) - dump_pos); \
1587 _dbus_assert_not_reached ("demarshaled wrong value"); \
1591 #define MARSHAL_TEST(typename, byte_order, literal) \
1593 MARSHAL_BASIC (typename, byte_order, literal); \
1595 DEMARSHAL_BASIC_AND_CHECK (typename, byte_order, literal); \
1598 #define MARSHAL_TEST_STRCMP(typename, byte_order, literal) \
1600 MARSHAL_BASIC (typename, byte_order, literal); \
1602 DEMARSHAL_BASIC (typename, byte_order); \
1603 if (strcmp (literal, v_##typename) != 0) \
1605 _dbus_verbose_bytes_of_string (&str, dump_pos, \
1606 _dbus_string_get_length (&str) - dump_pos); \
1607 _dbus_warn ("literal '%s'\nvalue '%s'\n", literal, v_##typename); \
1608 _dbus_assert_not_reached ("demarshaled wrong value"); \
1612 #define MARSHAL_FIXED_ARRAY(typename, byte_order, literal) \
1615 v_UINT32 = sizeof(literal); \
1616 if (!_dbus_marshal_write_basic (&str, pos, DBUS_TYPE_UINT32, &v_UINT32, \
1617 byte_order, &next)) \
1618 _dbus_assert_not_reached ("no memory"); \
1619 v_ARRAY_##typename = literal; \
1620 if (!_dbus_marshal_write_fixed_multi (&str, next, DBUS_TYPE_##typename, \
1621 &v_ARRAY_##typename, _DBUS_N_ELEMENTS(literal), \
1622 byte_order, NULL)) \
1623 _dbus_assert_not_reached ("no memory"); \
1626 #define DEMARSHAL_FIXED_ARRAY(typename, byte_order) \
1629 alignment = _dbus_type_get_alignment (DBUS_TYPE_##typename); \
1630 v_UINT32 = _dbus_marshal_read_uint32 (&str, dump_pos, byte_order, &next); \
1631 _dbus_marshal_read_fixed_multi (&str, next, DBUS_TYPE_##typename, &v_ARRAY_##typename, \
1632 v_UINT32/alignment, \
1633 byte_order, NULL); \
1634 swap_test_array (v_ARRAY_##typename, v_UINT32, \
1635 byte_order, alignment); \
1638 #define DEMARSHAL_FIXED_ARRAY_AND_CHECK(typename, byte_order, literal) \
1640 DEMARSHAL_FIXED_ARRAY (typename, byte_order); \
1641 if (memcmp (literal, v_ARRAY_##typename, sizeof (literal) != 0)) \
1643 _dbus_verbose ("MARSHALED DATA\n"); \
1644 _dbus_verbose_bytes_of_string (&str, dump_pos, \
1645 _dbus_string_get_length (&str) - dump_pos); \
1646 _dbus_verbose ("LITERAL DATA\n"); \
1647 _dbus_verbose_bytes ((char*)literal, sizeof (literal), 0); \
1648 _dbus_verbose ("READ DATA\n"); \
1649 _dbus_verbose_bytes ((char*)v_ARRAY_##typename, sizeof (literal), 0); \
1650 _dbus_assert_not_reached ("demarshaled wrong fixed array value"); \
1654 #define MARSHAL_TEST_FIXED_ARRAY(typename, byte_order, literal) \
1656 MARSHAL_FIXED_ARRAY (typename, byte_order, literal); \
1658 DEMARSHAL_FIXED_ARRAY_AND_CHECK (typename, byte_order, literal); \
1662 _dbus_marshal_test (void)
1667 unsigned char array1[5] = { 3, 4, 0, 1, 9 };
1668 dbus_int16_t array2[3] = { 124, 457, 780 };
1669 dbus_int32_t array4[3] = { 123, 456, 789 };
1670 #ifdef DBUS_HAVE_INT64
1671 dbus_int64_t array8[3] = { DBUS_INT64_CONSTANT (0x123ffffffff),
1672 DBUS_INT64_CONSTANT (0x456ffffffff),
1673 DBUS_INT64_CONSTANT (0x789ffffffff) };
1674 dbus_int64_t *v_ARRAY_INT64;
1676 unsigned char *v_ARRAY_BYTE;
1677 dbus_int16_t *v_ARRAY_INT16;
1678 dbus_uint16_t *v_ARRAY_UINT16;
1679 dbus_int32_t *v_ARRAY_INT32;
1680 dbus_uint32_t *v_ARRAY_UINT32;
1684 dbus_int16_t v_INT16;
1685 dbus_uint16_t v_UINT16;
1686 dbus_int32_t v_INT32;
1687 dbus_uint32_t v_UINT32;
1688 dbus_int64_t v_INT64;
1689 dbus_uint64_t v_UINT64;
1690 unsigned char v_BYTE;
1691 dbus_bool_t v_BOOLEAN;
1692 const char *v_STRING;
1693 const char *v_SIGNATURE;
1694 const char *v_OBJECT_PATH;
1697 if (!_dbus_string_init (&str))
1698 _dbus_assert_not_reached ("failed to init string");
1702 /* Marshal doubles */
1703 MARSHAL_BASIC (DOUBLE, DBUS_BIG_ENDIAN, 3.14);
1704 DEMARSHAL_BASIC (DOUBLE, DBUS_BIG_ENDIAN);
1706 if (!_DBUS_DOUBLES_BITWISE_EQUAL (t_DOUBLE, v_DOUBLE))
1707 _dbus_assert_not_reached ("got wrong double value");
1709 MARSHAL_BASIC (DOUBLE, DBUS_LITTLE_ENDIAN, 3.14);
1710 DEMARSHAL_BASIC (DOUBLE, DBUS_LITTLE_ENDIAN);
1712 if (!_DBUS_DOUBLES_BITWISE_EQUAL (t_DOUBLE, v_DOUBLE))
1713 _dbus_assert_not_reached ("got wrong double value");
1715 /* Marshal signed 16 integers */
1716 MARSHAL_TEST (INT16, DBUS_BIG_ENDIAN, -12345);
1717 MARSHAL_TEST (INT16, DBUS_LITTLE_ENDIAN, -12345);
1719 /* Marshal unsigned 16 integers */
1720 MARSHAL_TEST (UINT16, DBUS_BIG_ENDIAN, 0x1234);
1721 MARSHAL_TEST (UINT16, DBUS_LITTLE_ENDIAN, 0x1234);
1723 /* Marshal signed integers */
1724 MARSHAL_TEST (INT32, DBUS_BIG_ENDIAN, -12345678);
1725 MARSHAL_TEST (INT32, DBUS_LITTLE_ENDIAN, -12345678);
1727 /* Marshal unsigned integers */
1728 MARSHAL_TEST (UINT32, DBUS_BIG_ENDIAN, 0x12345678);
1729 MARSHAL_TEST (UINT32, DBUS_LITTLE_ENDIAN, 0x12345678);
1731 #ifdef DBUS_HAVE_INT64
1732 /* Marshal signed integers */
1733 MARSHAL_TEST (INT64, DBUS_BIG_ENDIAN, DBUS_INT64_CONSTANT (-0x123456789abc7));
1734 MARSHAL_TEST (INT64, DBUS_LITTLE_ENDIAN, DBUS_INT64_CONSTANT (-0x123456789abc7));
1736 /* Marshal unsigned integers */
1737 MARSHAL_TEST (UINT64, DBUS_BIG_ENDIAN, DBUS_UINT64_CONSTANT (0x123456789abc7));
1738 MARSHAL_TEST (UINT64, DBUS_LITTLE_ENDIAN, DBUS_UINT64_CONSTANT (0x123456789abc7));
1739 #endif /* DBUS_HAVE_INT64 */
1742 MARSHAL_TEST (BYTE, DBUS_BIG_ENDIAN, 5);
1743 MARSHAL_TEST (BYTE, DBUS_LITTLE_ENDIAN, 5);
1745 /* Marshal all possible bools! */
1746 MARSHAL_TEST (BOOLEAN, DBUS_BIG_ENDIAN, FALSE);
1747 MARSHAL_TEST (BOOLEAN, DBUS_LITTLE_ENDIAN, FALSE);
1748 MARSHAL_TEST (BOOLEAN, DBUS_BIG_ENDIAN, TRUE);
1749 MARSHAL_TEST (BOOLEAN, DBUS_LITTLE_ENDIAN, TRUE);
1751 /* Marshal strings */
1752 MARSHAL_TEST_STRCMP (STRING, DBUS_BIG_ENDIAN, "");
1753 MARSHAL_TEST_STRCMP (STRING, DBUS_LITTLE_ENDIAN, "");
1754 MARSHAL_TEST_STRCMP (STRING, DBUS_BIG_ENDIAN, "This is the dbus test string");
1755 MARSHAL_TEST_STRCMP (STRING, DBUS_LITTLE_ENDIAN, "This is the dbus test string");
1758 MARSHAL_TEST_STRCMP (OBJECT_PATH, DBUS_BIG_ENDIAN, "/a/b/c");
1759 MARSHAL_TEST_STRCMP (OBJECT_PATH, DBUS_LITTLE_ENDIAN, "/a/b/c");
1762 MARSHAL_TEST_STRCMP (SIGNATURE, DBUS_BIG_ENDIAN, "");
1763 MARSHAL_TEST_STRCMP (SIGNATURE, DBUS_LITTLE_ENDIAN, "");
1764 MARSHAL_TEST_STRCMP (SIGNATURE, DBUS_BIG_ENDIAN, "a(ii)");
1765 MARSHAL_TEST_STRCMP (SIGNATURE, DBUS_LITTLE_ENDIAN, "a(ii)");
1768 MARSHAL_TEST_FIXED_ARRAY (INT16, DBUS_BIG_ENDIAN, array2);
1769 MARSHAL_TEST_FIXED_ARRAY (INT16, DBUS_LITTLE_ENDIAN, array2);
1770 MARSHAL_TEST_FIXED_ARRAY (UINT16, DBUS_BIG_ENDIAN, array2);
1771 MARSHAL_TEST_FIXED_ARRAY (UINT16, DBUS_LITTLE_ENDIAN, array2);
1773 MARSHAL_TEST_FIXED_ARRAY (INT32, DBUS_BIG_ENDIAN, array4);
1774 MARSHAL_TEST_FIXED_ARRAY (INT32, DBUS_LITTLE_ENDIAN, array4);
1775 MARSHAL_TEST_FIXED_ARRAY (UINT32, DBUS_BIG_ENDIAN, array4);
1776 MARSHAL_TEST_FIXED_ARRAY (UINT32, DBUS_LITTLE_ENDIAN, array4);
1778 MARSHAL_TEST_FIXED_ARRAY (BYTE, DBUS_BIG_ENDIAN, array1);
1779 MARSHAL_TEST_FIXED_ARRAY (BYTE, DBUS_LITTLE_ENDIAN, array1);
1781 #ifdef DBUS_HAVE_INT64
1782 MARSHAL_TEST_FIXED_ARRAY (INT64, DBUS_BIG_ENDIAN, array8);
1783 MARSHAL_TEST_FIXED_ARRAY (INT64, DBUS_LITTLE_ENDIAN, array8);
1789 * FIXME restore the set/pack tests
1792 #ifdef DBUS_HAVE_INT64
1793 /* set/pack 64-bit integers */
1794 _dbus_string_set_length (&str, 8);
1797 _dbus_marshal_set_int64 (&str, DBUS_LITTLE_ENDIAN,
1798 0, DBUS_INT64_CONSTANT (-0x123456789abc7));
1800 _dbus_assert (DBUS_INT64_CONSTANT (-0x123456789abc7) ==
1801 _dbus_unpack_int64 (DBUS_LITTLE_ENDIAN,
1802 _dbus_string_get_const_data (&str)));
1805 _dbus_marshal_set_int64 (&str, DBUS_BIG_ENDIAN,
1806 0, DBUS_INT64_CONSTANT (-0x123456789abc7));
1808 _dbus_assert (DBUS_INT64_CONSTANT (-0x123456789abc7) ==
1809 _dbus_unpack_int64 (DBUS_BIG_ENDIAN,
1810 _dbus_string_get_const_data (&str)));
1812 /* signed little pack */
1813 _dbus_pack_int64 (DBUS_INT64_CONSTANT (-0x123456789abc7),
1815 _dbus_string_get_data (&str));
1817 _dbus_assert (DBUS_INT64_CONSTANT (-0x123456789abc7) ==
1818 _dbus_unpack_int64 (DBUS_LITTLE_ENDIAN,
1819 _dbus_string_get_const_data (&str)));
1821 /* signed big pack */
1822 _dbus_pack_int64 (DBUS_INT64_CONSTANT (-0x123456789abc7),
1824 _dbus_string_get_data (&str));
1826 _dbus_assert (DBUS_INT64_CONSTANT (-0x123456789abc7) ==
1827 _dbus_unpack_int64 (DBUS_BIG_ENDIAN,
1828 _dbus_string_get_const_data (&str)));
1830 /* unsigned little */
1831 _dbus_marshal_set_uint64 (&str, DBUS_LITTLE_ENDIAN,
1832 0, DBUS_UINT64_CONSTANT (0x123456789abc7));
1834 _dbus_assert (DBUS_UINT64_CONSTANT (0x123456789abc7) ==
1835 _dbus_unpack_uint64 (DBUS_LITTLE_ENDIAN,
1836 _dbus_string_get_const_data (&str)));
1839 _dbus_marshal_set_uint64 (&str, DBUS_BIG_ENDIAN,
1840 0, DBUS_UINT64_CONSTANT (0x123456789abc7));
1842 _dbus_assert (DBUS_UINT64_CONSTANT (0x123456789abc7) ==
1843 _dbus_unpack_uint64 (DBUS_BIG_ENDIAN,
1844 _dbus_string_get_const_data (&str)));
1846 /* unsigned little pack */
1847 _dbus_pack_uint64 (DBUS_UINT64_CONSTANT (0x123456789abc7),
1849 _dbus_string_get_data (&str));
1851 _dbus_assert (DBUS_UINT64_CONSTANT (0x123456789abc7) ==
1852 _dbus_unpack_uint64 (DBUS_LITTLE_ENDIAN,
1853 _dbus_string_get_const_data (&str)));
1855 /* unsigned big pack */
1856 _dbus_pack_uint64 (DBUS_UINT64_CONSTANT (0x123456789abc7),
1858 _dbus_string_get_data (&str));
1860 _dbus_assert (DBUS_UINT64_CONSTANT (0x123456789abc7) ==
1861 _dbus_unpack_uint64 (DBUS_BIG_ENDIAN,
1862 _dbus_string_get_const_data (&str)));
1863 #endif /* DBUS_HAVE_INT64 */
1865 /* set/pack 32-bit integers */
1866 _dbus_string_set_length (&str, 4);
1869 _dbus_marshal_set_int32 (&str, DBUS_LITTLE_ENDIAN,
1872 _dbus_assert (-0x123456 ==
1873 _dbus_unpack_int32 (DBUS_LITTLE_ENDIAN,
1874 _dbus_string_get_const_data (&str)));
1877 _dbus_marshal_set_int32 (&str, DBUS_BIG_ENDIAN,
1880 _dbus_assert (-0x123456 ==
1881 _dbus_unpack_int32 (DBUS_BIG_ENDIAN,
1882 _dbus_string_get_const_data (&str)));
1884 /* signed little pack */
1885 _dbus_pack_int32 (-0x123456,
1887 _dbus_string_get_data (&str));
1889 _dbus_assert (-0x123456 ==
1890 _dbus_unpack_int32 (DBUS_LITTLE_ENDIAN,
1891 _dbus_string_get_const_data (&str)));
1893 /* signed big pack */
1894 _dbus_pack_int32 (-0x123456,
1896 _dbus_string_get_data (&str));
1898 _dbus_assert (-0x123456 ==
1899 _dbus_unpack_int32 (DBUS_BIG_ENDIAN,
1900 _dbus_string_get_const_data (&str)));
1902 /* unsigned little */
1903 _dbus_marshal_set_uint32 (&str,
1905 DBUS_LITTLE_ENDIAN);
1907 _dbus_assert (0x123456 ==
1908 _dbus_unpack_uint32 (DBUS_LITTLE_ENDIAN,
1909 _dbus_string_get_const_data (&str)));
1912 _dbus_marshal_set_uint32 (&str,
1916 _dbus_assert (0x123456 ==
1917 _dbus_unpack_uint32 (DBUS_BIG_ENDIAN,
1918 _dbus_string_get_const_data (&str)));
1920 /* unsigned little pack */
1921 _dbus_pack_uint32 (0x123456,
1923 _dbus_string_get_data (&str));
1925 _dbus_assert (0x123456 ==
1926 _dbus_unpack_uint32 (DBUS_LITTLE_ENDIAN,
1927 _dbus_string_get_const_data (&str)));
1929 /* unsigned big pack */
1930 _dbus_pack_uint32 (0x123456,
1932 _dbus_string_get_data (&str));
1934 _dbus_assert (0x123456 ==
1935 _dbus_unpack_uint32 (DBUS_BIG_ENDIAN,
1936 _dbus_string_get_const_data (&str)));
1938 #endif /* set/pack tests for integers */
1940 /* Strings in-place set */
1941 byte_order = DBUS_LITTLE_ENDIAN;
1945 _dbus_string_set_length (&str, 0);
1947 /* reset pos for the macros */
1950 MARSHAL_TEST_STRCMP (STRING, byte_order, "Hello world");
1952 /* Set it to something longer */
1953 _dbus_string_init_const (&t, "Hello world foo");
1955 v_STRING = _dbus_string_get_const_data (&t);
1956 _dbus_marshal_set_basic (&str, 0, DBUS_TYPE_STRING,
1957 &v_STRING, byte_order, NULL, NULL);
1959 _dbus_marshal_read_basic (&str, 0, DBUS_TYPE_STRING,
1960 &v_STRING, byte_order,
1962 _dbus_assert (strcmp (v_STRING, "Hello world foo") == 0);
1964 /* Set it to something shorter */
1965 _dbus_string_init_const (&t, "Hello");
1967 v_STRING = _dbus_string_get_const_data (&t);
1968 _dbus_marshal_set_basic (&str, 0, DBUS_TYPE_STRING,
1969 &v_STRING, byte_order, NULL, NULL);
1970 _dbus_marshal_read_basic (&str, 0, DBUS_TYPE_STRING,
1971 &v_STRING, byte_order,
1973 _dbus_assert (strcmp (v_STRING, "Hello") == 0);
1975 /* Do the other byte order */
1976 if (byte_order == DBUS_LITTLE_ENDIAN)
1977 byte_order = DBUS_BIG_ENDIAN;
1983 _dbus_string_free (&str);
1988 #endif /* DBUS_BUILD_TESTS */