D-Bus  1.6.12
dbus-marshal-basic.c
1 /* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
2 /* dbus-marshal-basic.c Marshalling routines for basic (primitive) types
3  *
4  * Copyright (C) 2002 CodeFactory AB
5  * Copyright (C) 2003, 2004, 2005 Red Hat, Inc.
6  *
7  * Licensed under the Academic Free License version 2.1
8  *
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.
13  *
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.
18  *
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
22  *
23  */
24 
25 #include <config.h>
26 #include "dbus-internals.h"
27 #include "dbus-marshal-basic.h"
28 #include "dbus-signature.h"
29 
30 #include <string.h>
31 
32 #if defined(__GNUC__) && (__GNUC__ >= 4)
33 # define _DBUS_ASSERT_ALIGNMENT(type, op, val) \
34  _DBUS_STATIC_ASSERT (__extension__ __alignof__ (type) op val)
35 #else
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)
40 #endif
41 
42 /* True by definition, but just for completeness... */
43 _DBUS_STATIC_ASSERT (sizeof (char) == 1);
44 _DBUS_ASSERT_ALIGNMENT (char, ==, 1);
45 
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);
50 
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);
57 
58 _DBUS_STATIC_ASSERT (sizeof (double) == 8);
59 _DBUS_ASSERT_ALIGNMENT (double, <=, 8);
60 
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);
66 #endif
67 
68 _DBUS_STATIC_ASSERT (sizeof (DBusBasicValue) >= 8);
69 /* The alignment of a DBusBasicValue might conceivably be > 8 because of the
70  * pointer, so we don't assert about it */
71 
72 _DBUS_STATIC_ASSERT (sizeof (DBus8ByteStruct) == 8);
73 _DBUS_ASSERT_ALIGNMENT (DBus8ByteStruct, <=, 8);
74 
90 static void
91 pack_2_octets (dbus_uint16_t value,
92  int byte_order,
93  unsigned char *data)
94 {
95  _dbus_assert (_DBUS_ALIGN_ADDRESS (data, 2) == data);
96 
97  if ((byte_order) == DBUS_LITTLE_ENDIAN)
98  *((dbus_uint16_t*)(data)) = DBUS_UINT16_TO_LE (value);
99  else
100  *((dbus_uint16_t*)(data)) = DBUS_UINT16_TO_BE (value);
101 }
102 
103 static void
104 pack_4_octets (dbus_uint32_t value,
105  int byte_order,
106  unsigned char *data)
107 {
108  _dbus_assert (_DBUS_ALIGN_ADDRESS (data, 4) == data);
109 
110  if ((byte_order) == DBUS_LITTLE_ENDIAN)
111  *((dbus_uint32_t*)(data)) = DBUS_UINT32_TO_LE (value);
112  else
113  *((dbus_uint32_t*)(data)) = DBUS_UINT32_TO_BE (value);
114 }
115 
116 static void
117 pack_8_octets (DBusBasicValue value,
118  int byte_order,
119  unsigned char *data)
120 {
121  _dbus_assert (_DBUS_ALIGN_ADDRESS (data, 8) == data);
122 
123 #ifdef DBUS_HAVE_INT64
124  if ((byte_order) == DBUS_LITTLE_ENDIAN)
125  *((dbus_uint64_t*)(data)) = DBUS_UINT64_TO_LE (value.u64);
126  else
127  *((dbus_uint64_t*)(data)) = DBUS_UINT64_TO_BE (value.u64);
128 #else
129  *(DBus8ByteStruct*)data = value.eight;
130  swap_8_octets ((DBusBasicValue*)data, byte_order);
131 #endif
132 }
133 
141 void
143  int byte_order,
144  unsigned char *data)
145 {
146  pack_4_octets (value, byte_order, data);
147 }
148 
149 #ifndef DBUS_HAVE_INT64
150 /* from ORBit */
151 static void
152 swap_bytes (unsigned char *data,
153  unsigned int len)
154 {
155  unsigned char *p1 = data;
156  unsigned char *p2 = data + len - 1;
157 
158  while (p1 < p2)
159  {
160  unsigned char tmp = *p1;
161  *p1 = *p2;
162  *p2 = tmp;
163 
164  --p2;
165  ++p1;
166  }
167 }
168 #endif /* !DBUS_HAVE_INT64 */
169 
170 static void
171 swap_8_octets (DBusBasicValue *value,
172  int byte_order)
173 {
174  if (byte_order != DBUS_COMPILER_BYTE_ORDER)
175  {
176 #ifdef DBUS_HAVE_INT64
177  value->u64 = DBUS_UINT64_SWAP_LE_BE (value->u64);
178 #else
179  swap_bytes (&value->bytes, 8);
180 #endif
181  }
182 }
183 
184 #if 0
185 static DBusBasicValue
186 unpack_8_octets (int byte_order,
187  const unsigned char *data)
188 {
189  DBusBasicValue r;
190 
191  _dbus_assert (_DBUS_ALIGN_ADDRESS (data, 8) == data);
192  _dbus_assert (sizeof (r) == 8);
193 
194 #ifdef DBUS_HAVE_INT64
195  if (byte_order == DBUS_LITTLE_ENDIAN)
196  r.u64 = DBUS_UINT64_FROM_LE (*(dbus_uint64_t*)data);
197  else
198  r.u64 = DBUS_UINT64_FROM_BE (*(dbus_uint64_t*)data);
199 #else
200  r.eight = *(DBus8ByteStruct*)data;
201  swap_8_octets (&r, byte_order);
202 #endif
203 
204  return r;
205 }
206 #endif
207 
208 #ifndef _dbus_unpack_uint16
209 
217 _dbus_unpack_uint16 (int byte_order,
218  const unsigned char *data)
219 {
220  _dbus_assert (_DBUS_ALIGN_ADDRESS (data, 2) == data);
221 
222  if (byte_order == DBUS_LITTLE_ENDIAN)
223  return DBUS_UINT16_FROM_LE (*(dbus_uint16_t*)data);
224  else
225  return DBUS_UINT16_FROM_BE (*(dbus_uint16_t*)data);
226 }
227 #endif /* _dbus_unpack_uint16 */
228 
229 #ifndef _dbus_unpack_uint32
230 
238 _dbus_unpack_uint32 (int byte_order,
239  const unsigned char *data)
240 {
241  _dbus_assert (_DBUS_ALIGN_ADDRESS (data, 4) == data);
242 
243  if (byte_order == DBUS_LITTLE_ENDIAN)
244  return DBUS_UINT32_FROM_LE (*(dbus_uint32_t*)data);
245  else
246  return DBUS_UINT32_FROM_BE (*(dbus_uint32_t*)data);
247 }
248 #endif /* _dbus_unpack_uint32 */
249 
250 static void
251 set_2_octets (DBusString *str,
252  int offset,
253  dbus_uint16_t value,
254  int byte_order)
255 {
256  char *data;
257 
258  _dbus_assert (byte_order == DBUS_LITTLE_ENDIAN ||
259  byte_order == DBUS_BIG_ENDIAN);
260 
261  data = _dbus_string_get_data_len (str, offset, 2);
262 
263  pack_2_octets (value, byte_order, data);
264 }
265 
266 static void
267 set_4_octets (DBusString *str,
268  int offset,
269  dbus_uint32_t value,
270  int byte_order)
271 {
272  char *data;
273 
274  _dbus_assert (byte_order == DBUS_LITTLE_ENDIAN ||
275  byte_order == DBUS_BIG_ENDIAN);
276 
277  data = _dbus_string_get_data_len (str, offset, 4);
278 
279  pack_4_octets (value, byte_order, data);
280 }
281 
282 static void
283 set_8_octets (DBusString *str,
284  int offset,
285  DBusBasicValue value,
286  int byte_order)
287 {
288  char *data;
289 
290  _dbus_assert (byte_order == DBUS_LITTLE_ENDIAN ||
291  byte_order == DBUS_BIG_ENDIAN);
292 
293  data = _dbus_string_get_data_len (str, offset, 8);
294 
295  pack_8_octets (value, byte_order, data);
296 }
297 
308 void
310  int pos,
311  dbus_uint32_t value,
312  int byte_order)
313 {
314  set_4_octets (str, pos, value, byte_order);
315 }
316 
336 static dbus_bool_t
337 set_string (DBusString *str,
338  int pos,
339  const char *value,
340  int byte_order,
341  int *old_end_pos,
342  int *new_end_pos)
343 {
344  int old_len, new_len;
345  DBusString dstr;
346 
347  _dbus_string_init_const (&dstr, value);
348 
349  _dbus_assert (_DBUS_ALIGN_VALUE (pos, 4) == (unsigned) pos);
350  old_len = _dbus_unpack_uint32 (byte_order,
351  _dbus_string_get_const_data_len (str, pos, 4));
352 
353  new_len = _dbus_string_get_length (&dstr);
354 
355  if (!_dbus_string_replace_len (&dstr, 0, new_len,
356  str, pos + 4, old_len))
357  return FALSE;
358 
359  _dbus_marshal_set_uint32 (str, pos, new_len, byte_order);
360 
361  if (old_end_pos)
362  *old_end_pos = pos + 4 + old_len + 1;
363  if (new_end_pos)
364  *new_end_pos = pos + 4 + new_len + 1;
365 
366  return TRUE;
367 }
368 
382 static dbus_bool_t
383 set_signature (DBusString *str,
384  int pos,
385  const char *value,
386  int byte_order,
387  int *old_end_pos,
388  int *new_end_pos)
389 {
390  int old_len, new_len;
391  DBusString dstr;
392 
393  _dbus_string_init_const (&dstr, value);
394 
395  old_len = _dbus_string_get_byte (str, pos);
396  new_len = _dbus_string_get_length (&dstr);
397 
398  if (!_dbus_string_replace_len (&dstr, 0, new_len,
399  str, pos + 1, old_len))
400  return FALSE;
401 
402  _dbus_string_set_byte (str, pos, new_len);
403 
404  if (old_end_pos)
405  *old_end_pos = pos + 1 + old_len + 1;
406  if (new_end_pos)
407  *new_end_pos = pos + 1 + new_len + 1;
408 
409  return TRUE;
410 }
411 
427  int pos,
428  int type,
429  const void *value,
430  int byte_order,
431  int *old_end_pos,
432  int *new_end_pos)
433 {
434  const DBusBasicValue *vp;
435 
436  vp = value;
437 
438  switch (type)
439  {
440  case DBUS_TYPE_BYTE:
441  _dbus_string_set_byte (str, pos, vp->byt);
442  if (old_end_pos)
443  *old_end_pos = pos + 1;
444  if (new_end_pos)
445  *new_end_pos = pos + 1;
446  return TRUE;
447  break;
448  case DBUS_TYPE_INT16:
449  case DBUS_TYPE_UINT16:
450  pos = _DBUS_ALIGN_VALUE (pos, 2);
451  set_2_octets (str, pos, vp->u16, byte_order);
452  if (old_end_pos)
453  *old_end_pos = pos + 2;
454  if (new_end_pos)
455  *new_end_pos = pos + 2;
456  return TRUE;
457  break;
458  case DBUS_TYPE_BOOLEAN:
459  case DBUS_TYPE_INT32:
460  case DBUS_TYPE_UINT32:
461  case DBUS_TYPE_UNIX_FD:
462  pos = _DBUS_ALIGN_VALUE (pos, 4);
463  set_4_octets (str, pos, vp->u32, byte_order);
464  if (old_end_pos)
465  *old_end_pos = pos + 4;
466  if (new_end_pos)
467  *new_end_pos = pos + 4;
468  return TRUE;
469  break;
470  case DBUS_TYPE_INT64:
471  case DBUS_TYPE_UINT64:
472  case DBUS_TYPE_DOUBLE:
473  pos = _DBUS_ALIGN_VALUE (pos, 8);
474  set_8_octets (str, pos, *vp, byte_order);
475  if (old_end_pos)
476  *old_end_pos = pos + 8;
477  if (new_end_pos)
478  *new_end_pos = pos + 8;
479  return TRUE;
480  break;
481  case DBUS_TYPE_STRING:
483  pos = _DBUS_ALIGN_VALUE (pos, 4);
484  _dbus_assert (vp->str != NULL);
485  return set_string (str, pos, vp->str, byte_order,
486  old_end_pos, new_end_pos);
487  break;
488  case DBUS_TYPE_SIGNATURE:
489  _dbus_assert (vp->str != NULL);
490  return set_signature (str, pos, vp->str, byte_order,
491  old_end_pos, new_end_pos);
492  break;
493  default:
494  _dbus_assert_not_reached ("not a basic type");
495  return FALSE;
496  break;
497  }
498 }
499 
511  int pos,
512  int byte_order,
513  int *new_pos)
514 {
515  pos = _DBUS_ALIGN_VALUE (pos, 4);
516 
517  if (new_pos)
518  *new_pos = pos + 4;
519 
520  _dbus_assert (pos + 4 <= _dbus_string_get_length (str));
521 
522  return _dbus_unpack_uint32 (byte_order,
523  _dbus_string_get_const_data (str) + pos);
524 }
525 
547 void
549  int pos,
550  int type,
551  void *value,
552  int byte_order,
553  int *new_pos)
554 {
555  const char *str_data;
556 
558 
559  str_data = _dbus_string_get_const_data (str);
560 
561  /* Below we volatile types to avoid aliasing issues;
562  * see http://bugs.freedesktop.org/show_bug.cgi?id=20137
563  */
564 
565  switch (type)
566  {
567  case DBUS_TYPE_BYTE:
568  {
569  volatile unsigned char *vp = value;
570  *vp = (unsigned char) _dbus_string_get_byte (str, pos);
571  (pos)++;
572  }
573  break;
574  case DBUS_TYPE_INT16:
575  case DBUS_TYPE_UINT16:
576  {
577  volatile dbus_uint16_t *vp = value;
578  pos = _DBUS_ALIGN_VALUE (pos, 2);
579  *vp = *(dbus_uint16_t *)(str_data + pos);
580  if (byte_order != DBUS_COMPILER_BYTE_ORDER)
581  *vp = DBUS_UINT16_SWAP_LE_BE (*vp);
582  pos += 2;
583  }
584  break;
585  case DBUS_TYPE_INT32:
586  case DBUS_TYPE_UINT32:
587  case DBUS_TYPE_BOOLEAN:
588  case DBUS_TYPE_UNIX_FD:
589  {
590  volatile dbus_uint32_t *vp = value;
591  pos = _DBUS_ALIGN_VALUE (pos, 4);
592  *vp = *(dbus_uint32_t *)(str_data + pos);
593  if (byte_order != DBUS_COMPILER_BYTE_ORDER)
594  *vp = DBUS_UINT32_SWAP_LE_BE (*vp);
595  pos += 4;
596  }
597  break;
598  case DBUS_TYPE_INT64:
599  case DBUS_TYPE_UINT64:
600  case DBUS_TYPE_DOUBLE:
601  {
602  volatile dbus_uint64_t *vp = value;
603  pos = _DBUS_ALIGN_VALUE (pos, 8);
604 #ifdef DBUS_HAVE_INT64
605  if (byte_order != DBUS_COMPILER_BYTE_ORDER)
606  *vp = DBUS_UINT64_SWAP_LE_BE (*(dbus_uint64_t*)(str_data + pos));
607  else
608  *vp = *(dbus_uint64_t*)(str_data + pos);
609 #else
610  *vp = *(DBus8ByteStruct*) (str_data + pos);
611  swap_8_octets (vp, byte_order);
612 #endif
613  pos += 8;
614  }
615  break;
616  case DBUS_TYPE_STRING:
618  {
619  int len;
620  volatile char **vp = value;
621 
622  len = _dbus_marshal_read_uint32 (str, pos, byte_order, &pos);
623 
624  *vp = (char*) str_data + pos;
625 
626  pos += len + 1; /* length plus nul */
627  }
628  break;
629  case DBUS_TYPE_SIGNATURE:
630  {
631  int len;
632  volatile char **vp = value;
633 
634  len = _dbus_string_get_byte (str, pos);
635  pos += 1;
636 
637  *vp = (char*) str_data + pos;
638 
639  pos += len + 1; /* length plus nul */
640  }
641  break;
642  default:
643  _dbus_warn_check_failed ("type %s %d not a basic type\n",
644  _dbus_type_to_string (type), type);
645  _dbus_assert_not_reached ("not a basic type");
646  break;
647  }
648 
649  if (new_pos)
650  *new_pos = pos;
651 }
652 
653 static dbus_bool_t
654 marshal_2_octets (DBusString *str,
655  int insert_at,
656  dbus_uint16_t value,
657  int byte_order,
658  int *pos_after)
659 {
660  dbus_bool_t retval;
661  int orig_len;
662 
663  _dbus_assert (sizeof (value) == 2);
664 
665  if (byte_order != DBUS_COMPILER_BYTE_ORDER)
666  value = DBUS_UINT16_SWAP_LE_BE (value);
667 
668  orig_len = _dbus_string_get_length (str);
669 
670  retval = _dbus_string_insert_2_aligned (str, insert_at,
671  (const unsigned char *)&value);
672 
673  if (pos_after)
674  {
675  *pos_after = insert_at + (_dbus_string_get_length (str) - orig_len);
676  _dbus_assert (*pos_after <= _dbus_string_get_length (str));
677  }
678 
679  return retval;
680 }
681 
682 static dbus_bool_t
683 marshal_4_octets (DBusString *str,
684  int insert_at,
685  dbus_uint32_t value,
686  int byte_order,
687  int *pos_after)
688 {
689  dbus_bool_t retval;
690  int orig_len;
691 
692  _dbus_assert (sizeof (value) == 4);
693 
694  if (byte_order != DBUS_COMPILER_BYTE_ORDER)
695  value = DBUS_UINT32_SWAP_LE_BE (value);
696 
697  orig_len = _dbus_string_get_length (str);
698 
699  retval = _dbus_string_insert_4_aligned (str, insert_at,
700  (const unsigned char *)&value);
701 
702  if (pos_after)
703  {
704  *pos_after = insert_at + (_dbus_string_get_length (str) - orig_len);
705  _dbus_assert (*pos_after <= _dbus_string_get_length (str));
706  }
707 
708  return retval;
709 }
710 
711 static dbus_bool_t
712 marshal_8_octets (DBusString *str,
713  int insert_at,
714  DBusBasicValue value,
715  int byte_order,
716  int *pos_after)
717 {
718  dbus_bool_t retval;
719  int orig_len;
720 
721  _dbus_assert (sizeof (value) == 8);
722 
723  swap_8_octets (&value, byte_order);
724 
725  orig_len = _dbus_string_get_length (str);
726 
727  retval = _dbus_string_insert_8_aligned (str, insert_at,
728  (const unsigned char *)&value);
729 
730  if (pos_after)
731  *pos_after = insert_at + _dbus_string_get_length (str) - orig_len;
732 
733  return retval;
734 }
735 
736 enum
737  {
738  MARSHAL_AS_STRING,
739  MARSHAL_AS_SIGNATURE,
740  MARSHAL_AS_BYTE_ARRAY
741  };
742 
743 static dbus_bool_t
744 marshal_len_followed_by_bytes (int marshal_as,
745  DBusString *str,
746  int insert_at,
747  const unsigned char *value,
748  int data_len, /* doesn't include nul if any */
749  int byte_order,
750  int *pos_after)
751 {
752  int pos;
753  DBusString value_str;
754  int value_len;
755 
756  _dbus_assert (byte_order == DBUS_LITTLE_ENDIAN || byte_order == DBUS_BIG_ENDIAN);
757  if (insert_at > _dbus_string_get_length (str))
758  _dbus_warn ("insert_at = %d string len = %d data_len = %d\n",
759  insert_at, _dbus_string_get_length (str), data_len);
760 
761  if (marshal_as == MARSHAL_AS_BYTE_ARRAY)
762  value_len = data_len;
763  else
764  value_len = data_len + 1; /* value has a nul */
765 
766  _dbus_string_init_const_len (&value_str, value, value_len);
767 
768  pos = insert_at;
769 
770  if (marshal_as == MARSHAL_AS_SIGNATURE)
771  {
773  _dbus_assert (data_len <= 255); /* same as max sig len right now */
774 
775  if (!_dbus_string_insert_byte (str, pos, data_len))
776  goto oom;
777 
778  pos += 1;
779  }
780  else
781  {
782  if (!marshal_4_octets (str, pos, data_len,
783  byte_order, &pos))
784  goto oom;
785  }
786 
787  if (!_dbus_string_copy_len (&value_str, 0, value_len,
788  str, pos))
789  goto oom;
790 
791 #if 0
792  /* too expensive */
793  _dbus_assert (_dbus_string_equal_substring (&value_str, 0, value_len,
794  str, pos));
795  _dbus_verbose_bytes_of_string (str, pos, value_len);
796 #endif
797 
798  pos += value_len;
799 
800  if (pos_after)
801  *pos_after = pos;
802 
803  return TRUE;
804 
805  oom:
806  /* Delete what we've inserted */
807  _dbus_string_delete (str, insert_at, pos - insert_at);
808 
809  return FALSE;
810 }
811 
812 static dbus_bool_t
813 marshal_string (DBusString *str,
814  int insert_at,
815  const char *value,
816  int byte_order,
817  int *pos_after)
818 {
819  return marshal_len_followed_by_bytes (MARSHAL_AS_STRING,
820  str, insert_at, value,
821  strlen (value),
822  byte_order, pos_after);
823 }
824 
825 static dbus_bool_t
826 marshal_signature (DBusString *str,
827  int insert_at,
828  const char *value,
829  int *pos_after)
830 {
831  return marshal_len_followed_by_bytes (MARSHAL_AS_SIGNATURE,
832  str, insert_at, value,
833  strlen (value),
834  DBUS_COMPILER_BYTE_ORDER, /* irrelevant */
835  pos_after);
836 }
837 
856  int insert_at,
857  int type,
858  const void *value,
859  int byte_order,
860  int *pos_after)
861 {
862  const DBusBasicValue *vp;
863 
865 
866  vp = value;
867 
868  switch (type)
869  {
870  case DBUS_TYPE_BYTE:
871  if (!_dbus_string_insert_byte (str, insert_at, vp->byt))
872  return FALSE;
873  if (pos_after)
874  *pos_after = insert_at + 1;
875  return TRUE;
876  break;
877  case DBUS_TYPE_INT16:
878  case DBUS_TYPE_UINT16:
879  return marshal_2_octets (str, insert_at, vp->u16,
880  byte_order, pos_after);
881  break;
882  case DBUS_TYPE_BOOLEAN:
883  return marshal_4_octets (str, insert_at, vp->u32 != FALSE,
884  byte_order, pos_after);
885  break;
886  case DBUS_TYPE_INT32:
887  case DBUS_TYPE_UINT32:
888  case DBUS_TYPE_UNIX_FD:
889  return marshal_4_octets (str, insert_at, vp->u32,
890  byte_order, pos_after);
891  break;
892  case DBUS_TYPE_INT64:
893  case DBUS_TYPE_UINT64:
894  case DBUS_TYPE_DOUBLE:
895  return marshal_8_octets (str, insert_at, *vp, byte_order, pos_after);
896  break;
897 
898  case DBUS_TYPE_STRING:
900  _dbus_assert (vp->str != NULL);
901  return marshal_string (str, insert_at, vp->str, byte_order, pos_after);
902  break;
903  case DBUS_TYPE_SIGNATURE:
904  _dbus_assert (vp->str != NULL);
905  return marshal_signature (str, insert_at, vp->str, pos_after);
906  break;
907  default:
908  _dbus_assert_not_reached ("not a basic type");
909  return FALSE;
910  break;
911  }
912 }
913 
914 static dbus_bool_t
915 marshal_1_octets_array (DBusString *str,
916  int insert_at,
917  const unsigned char *value,
918  int n_elements,
919  int byte_order,
920  int *pos_after)
921 {
922  int pos;
923  DBusString value_str;
924 
925  _dbus_string_init_const_len (&value_str, value, n_elements);
926 
927  pos = insert_at;
928 
929  if (!_dbus_string_copy_len (&value_str, 0, n_elements,
930  str, pos))
931  return FALSE;
932 
933  pos += n_elements;
934 
935  if (pos_after)
936  *pos_after = pos;
937 
938  return TRUE;
939 }
940 
948 void
949 _dbus_swap_array (unsigned char *data,
950  int n_elements,
951  int alignment)
952 {
953  unsigned char *d;
954  unsigned char *end;
955 
956  _dbus_assert (_DBUS_ALIGN_ADDRESS (data, alignment) == data);
957 
958  /* we use const_data and cast it off so DBusString can be a const string
959  * for the unit tests. don't ask.
960  */
961  d = data;
962  end = d + (n_elements * alignment);
963 
964  if (alignment == 8)
965  {
966  while (d != end)
967  {
968 #ifdef DBUS_HAVE_INT64
969  *((dbus_uint64_t*)d) = DBUS_UINT64_SWAP_LE_BE (*((dbus_uint64_t*)d));
970 #else
971  swap_8_bytes ((DBusBasicValue*) d);
972 #endif
973  d += 8;
974  }
975  }
976  else if (alignment == 4)
977  {
978  while (d != end)
979  {
980  *((dbus_uint32_t*)d) = DBUS_UINT32_SWAP_LE_BE (*((dbus_uint32_t*)d));
981  d += 4;
982  }
983  }
984  else
985  {
986  _dbus_assert (alignment == 2);
987 
988  while (d != end)
989  {
990  *((dbus_uint16_t*)d) = DBUS_UINT16_SWAP_LE_BE (*((dbus_uint16_t*)d));
991  d += 2;
992  }
993  }
994 }
995 
996 static void
997 swap_array (DBusString *str,
998  int array_start,
999  int n_elements,
1000  int byte_order,
1001  int alignment)
1002 {
1003  _dbus_assert (_DBUS_ALIGN_VALUE (array_start, alignment) == (unsigned) array_start);
1004 
1005  if (byte_order != DBUS_COMPILER_BYTE_ORDER)
1006  {
1007  /* we use const_data and cast it off so DBusString can be a const string
1008  * for the unit tests. don't ask.
1009  */
1010  _dbus_swap_array ((unsigned char*) (_dbus_string_get_const_data (str) + array_start),
1011  n_elements, alignment);
1012  }
1013 }
1014 
1015 static dbus_bool_t
1016 marshal_fixed_multi (DBusString *str,
1017  int insert_at,
1018  const DBusBasicValue *value,
1019  int n_elements,
1020  int byte_order,
1021  int alignment,
1022  int *pos_after)
1023 {
1024  int old_string_len;
1025  int array_start;
1026  DBusString t;
1027  int len_in_bytes;
1028 
1029  _dbus_assert (n_elements <= DBUS_MAXIMUM_ARRAY_LENGTH / alignment);
1030 
1031  old_string_len = _dbus_string_get_length (str);
1032 
1033  len_in_bytes = n_elements * alignment;
1034  array_start = insert_at;
1035 
1036  /* Note that we do alignment padding unconditionally
1037  * even if the array is empty; this means that
1038  * padding + len is always equal to the number of bytes
1039  * in the array.
1040  */
1041 
1042  if (!_dbus_string_insert_alignment (str, &array_start, alignment))
1043  goto error;
1044 
1046  (const unsigned char*) value,
1047  len_in_bytes);
1048 
1049  if (!_dbus_string_copy (&t, 0,
1050  str, array_start))
1051  goto error;
1052 
1053  swap_array (str, array_start, n_elements, byte_order, alignment);
1054 
1055  if (pos_after)
1056  *pos_after = array_start + len_in_bytes;
1057 
1058  return TRUE;
1059 
1060  error:
1061  _dbus_string_delete (str, insert_at,
1062  _dbus_string_get_length (str) - old_string_len);
1063 
1064  return FALSE;
1065 }
1066 
1086  int insert_at,
1087  int element_type,
1088  const void *value,
1089  int n_elements,
1090  int byte_order,
1091  int *pos_after)
1092 {
1093  const void* vp = *(const DBusBasicValue**)value;
1094 
1095  _dbus_assert (dbus_type_is_fixed (element_type));
1096  _dbus_assert (n_elements >= 0);
1097 
1098 #if 0
1099  _dbus_verbose ("writing %d elements of %s\n",
1100  n_elements, _dbus_type_to_string (element_type));
1101 #endif
1102 
1103  switch (element_type)
1104  {
1105  case DBUS_TYPE_BYTE:
1106  return marshal_1_octets_array (str, insert_at, vp, n_elements, byte_order, pos_after);
1107  break;
1108  case DBUS_TYPE_INT16:
1109  case DBUS_TYPE_UINT16:
1110  return marshal_fixed_multi (str, insert_at, vp, n_elements, byte_order, 2, pos_after);
1111  case DBUS_TYPE_BOOLEAN:
1112  case DBUS_TYPE_INT32:
1113  case DBUS_TYPE_UINT32:
1114  case DBUS_TYPE_UNIX_FD:
1115  return marshal_fixed_multi (str, insert_at, vp, n_elements, byte_order, 4, pos_after);
1116  break;
1117  case DBUS_TYPE_INT64:
1118  case DBUS_TYPE_UINT64:
1119  case DBUS_TYPE_DOUBLE:
1120  return marshal_fixed_multi (str, insert_at, vp, n_elements, byte_order, 8, pos_after);
1121  break;
1122 
1123  default:
1124  _dbus_assert_not_reached ("non fixed type in array write");
1125  break;
1126  }
1127 
1128  return FALSE;
1129 }
1130 
1131 
1141 void
1143  int type,
1144  int byte_order,
1145  int *pos)
1146 {
1147  _dbus_assert (byte_order == DBUS_LITTLE_ENDIAN ||
1148  byte_order == DBUS_BIG_ENDIAN);
1149 
1150  switch (type)
1151  {
1152  case DBUS_TYPE_BYTE:
1153  (*pos)++;
1154  break;
1155  case DBUS_TYPE_INT16:
1156  case DBUS_TYPE_UINT16:
1157  *pos = _DBUS_ALIGN_VALUE (*pos, 2);
1158  *pos += 2;
1159  break;
1160  case DBUS_TYPE_BOOLEAN:
1161  case DBUS_TYPE_INT32:
1162  case DBUS_TYPE_UINT32:
1163  case DBUS_TYPE_UNIX_FD:
1164  *pos = _DBUS_ALIGN_VALUE (*pos, 4);
1165  *pos += 4;
1166  break;
1167  case DBUS_TYPE_INT64:
1168  case DBUS_TYPE_UINT64:
1169  case DBUS_TYPE_DOUBLE:
1170  *pos = _DBUS_ALIGN_VALUE (*pos, 8);
1171  *pos += 8;
1172  break;
1173  case DBUS_TYPE_STRING:
1174  case DBUS_TYPE_OBJECT_PATH:
1175  {
1176  int len;
1177 
1178  len = _dbus_marshal_read_uint32 (str, *pos, byte_order, pos);
1179 
1180  *pos += len + 1; /* length plus nul */
1181  }
1182  break;
1183  case DBUS_TYPE_SIGNATURE:
1184  {
1185  int len;
1186 
1187  len = _dbus_string_get_byte (str, *pos);
1188 
1189  *pos += len + 2; /* length byte plus length plus nul */
1190  }
1191  break;
1192  default:
1193  _dbus_warn ("type %s not a basic type\n",
1194  _dbus_type_to_string (type));
1195  _dbus_assert_not_reached ("not a basic type");
1196  break;
1197  }
1198 }
1199 
1209 void
1211  int element_type,
1212  int byte_order,
1213  int *pos)
1214 {
1215  dbus_uint32_t array_len;
1216  int i;
1217  int alignment;
1218 
1219  i = _DBUS_ALIGN_VALUE (*pos, 4);
1220 
1221  array_len = _dbus_marshal_read_uint32 (str, i, byte_order, &i);
1222 
1223  alignment = _dbus_type_get_alignment (element_type);
1224 
1225  i = _DBUS_ALIGN_VALUE (i, alignment);
1226 
1227  *pos = i + array_len;
1228 }
1229 
1237 int
1239 {
1240  switch (typecode)
1241  {
1242  case DBUS_TYPE_BYTE:
1243  case DBUS_TYPE_VARIANT:
1244  case DBUS_TYPE_SIGNATURE:
1245  return 1;
1246  case DBUS_TYPE_INT16:
1247  case DBUS_TYPE_UINT16:
1248  return 2;
1249  case DBUS_TYPE_BOOLEAN:
1250  case DBUS_TYPE_INT32:
1251  case DBUS_TYPE_UINT32:
1252  case DBUS_TYPE_UNIX_FD:
1253  /* this stuff is 4 since it starts with a length */
1254  case DBUS_TYPE_STRING:
1255  case DBUS_TYPE_OBJECT_PATH:
1256  case DBUS_TYPE_ARRAY:
1257  return 4;
1258  case DBUS_TYPE_INT64:
1259  case DBUS_TYPE_UINT64:
1260  case DBUS_TYPE_DOUBLE:
1261  /* struct is 8 since it could contain an 8-aligned item
1262  * and it's simpler to just always align structs to 8;
1263  * we want the amount of padding in a struct of a given
1264  * type to be predictable, not location-dependent.
1265  * DICT_ENTRY is always the same as struct.
1266  */
1267  case DBUS_TYPE_STRUCT:
1268  case DBUS_TYPE_DICT_ENTRY:
1269  return 8;
1270 
1271  default:
1272  _dbus_assert_not_reached ("unknown typecode in _dbus_type_get_alignment()");
1273  return 0;
1274  }
1275 }
1276 
1283 const char *
1284 _dbus_type_to_string (int typecode)
1285 {
1286  switch (typecode)
1287  {
1288  case DBUS_TYPE_INVALID:
1289  return "invalid";
1290  case DBUS_TYPE_BOOLEAN:
1291  return "boolean";
1292  case DBUS_TYPE_BYTE:
1293  return "byte";
1294  case DBUS_TYPE_INT16:
1295  return "int16";
1296  case DBUS_TYPE_UINT16:
1297  return "uint16";
1298  case DBUS_TYPE_INT32:
1299  return "int32";
1300  case DBUS_TYPE_UINT32:
1301  return "uint32";
1302  case DBUS_TYPE_INT64:
1303  return "int64";
1304  case DBUS_TYPE_UINT64:
1305  return "uint64";
1306  case DBUS_TYPE_DOUBLE:
1307  return "double";
1308  case DBUS_TYPE_STRING:
1309  return "string";
1310  case DBUS_TYPE_OBJECT_PATH:
1311  return "object_path";
1312  case DBUS_TYPE_SIGNATURE:
1313  return "signature";
1314  case DBUS_TYPE_STRUCT:
1315  return "struct";
1316  case DBUS_TYPE_DICT_ENTRY:
1317  return "dict_entry";
1318  case DBUS_TYPE_ARRAY:
1319  return "array";
1320  case DBUS_TYPE_VARIANT:
1321  return "variant";
1323  return "begin_struct";
1324  case DBUS_STRUCT_END_CHAR:
1325  return "end_struct";
1327  return "begin_dict_entry";
1329  return "end_dict_entry";
1330  case DBUS_TYPE_UNIX_FD:
1331  return "unix_fd";
1332  default:
1333  return "unknown";
1334  }
1335 }
1336 
1344 void
1345 _dbus_verbose_bytes (const unsigned char *data,
1346  int len,
1347  int offset)
1348 {
1349  int i;
1350  const unsigned char *aligned;
1351 
1352  _dbus_assert (len >= 0);
1353 
1354  if (!_dbus_is_verbose())
1355  return;
1356 
1357  /* Print blanks on first row if appropriate */
1358  aligned = _DBUS_ALIGN_ADDRESS (data, 4);
1359  if (aligned > data)
1360  aligned -= 4;
1361  _dbus_assert (aligned <= data);
1362 
1363  if (aligned != data)
1364  {
1365  _dbus_verbose ("%4ld\t%p: ", - (long)(data - aligned), aligned);
1366  while (aligned != data)
1367  {
1368  _dbus_verbose (" ");
1369  ++aligned;
1370  }
1371  }
1372 
1373  /* now print the bytes */
1374  i = 0;
1375  while (i < len)
1376  {
1377  if (_DBUS_ALIGN_ADDRESS (&data[i], 4) == &data[i])
1378  {
1379  _dbus_verbose ("%4d\t%p: ",
1380  offset + i, &data[i]);
1381  }
1382 
1383  if (data[i] >= 32 &&
1384  data[i] <= 126)
1385  _dbus_verbose (" '%c' ", data[i]);
1386  else
1387  _dbus_verbose ("0x%s%x ",
1388  data[i] <= 0xf ? "0" : "", data[i]);
1389 
1390  ++i;
1391 
1392  if (_DBUS_ALIGN_ADDRESS (&data[i], 4) == &data[i])
1393  {
1394  if (i > 3)
1395  _dbus_verbose ("BE: %d LE: %d",
1396  _dbus_unpack_uint32 (DBUS_BIG_ENDIAN, &data[i-4]),
1397  _dbus_unpack_uint32 (DBUS_LITTLE_ENDIAN, &data[i-4]));
1398 
1399  if (i > 7 &&
1400  _DBUS_ALIGN_ADDRESS (&data[i], 8) == &data[i])
1401  {
1402 #ifdef DBUS_INT64_PRINTF_MODIFIER
1403  _dbus_verbose (" u64: 0x%" DBUS_INT64_PRINTF_MODIFIER "x",
1404  *(dbus_uint64_t*)&data[i-8]);
1405 #endif
1406  _dbus_verbose (" dbl: %g",
1407  *(double*)&data[i-8]);
1408  }
1409 
1410  _dbus_verbose ("\n");
1411  }
1412  }
1413 
1414  _dbus_verbose ("\n");
1415 }
1416 
1424 void
1426  int start,
1427  int len)
1428 {
1429  const char *d;
1430  int real_len;
1431 
1432  real_len = _dbus_string_get_length (str);
1433 
1434  _dbus_assert (start >= 0);
1435 
1436  if (start > real_len)
1437  {
1438  _dbus_verbose (" [%d,%d) is not inside string of length %d\n",
1439  start, len, real_len);
1440  return;
1441  }
1442 
1443  if ((start + len) > real_len)
1444  {
1445  _dbus_verbose (" [%d,%d) extends outside string of length %d\n",
1446  start, len, real_len);
1447  len = real_len - start;
1448  }
1449 
1450  d = _dbus_string_get_const_data_len (str, start, len);
1451 
1452  _dbus_verbose_bytes (d, len, start);
1453 }
1454 
1455 static int
1456 map_type_char_to_type (int t)
1457 {
1458  if (t == DBUS_STRUCT_BEGIN_CHAR)
1459  return DBUS_TYPE_STRUCT;
1460  else if (t == DBUS_DICT_ENTRY_BEGIN_CHAR)
1461  return DBUS_TYPE_DICT_ENTRY;
1462  else
1463  {
1466  return t;
1467  }
1468 }
1469 
1480 int
1482  int pos)
1483 {
1484  return map_type_char_to_type (_dbus_string_get_byte (str, pos));
1485 }
1486 
1495 int
1497  int pos)
1498 {
1499  return map_type_char_to_type (str[pos]);
1500 }
1501 
1504 #ifdef DBUS_BUILD_TESTS
1505 #include "dbus-test.h"
1506 #include <stdio.h>
1507 
1526 void
1527 _dbus_marshal_read_fixed_multi (const DBusString *str,
1528  int pos,
1529  int element_type,
1530  void *value,
1531  int n_elements,
1532  int byte_order,
1533  int *new_pos)
1534 {
1535  int array_len;
1536  int alignment;
1537 
1538  _dbus_assert (dbus_type_is_fixed (element_type));
1539  _dbus_assert (dbus_type_is_basic (element_type));
1540 
1541 #if 0
1542  _dbus_verbose ("reading %d elements of %s\n",
1543  n_elements, _dbus_type_to_string (element_type));
1544 #endif
1545 
1546  alignment = _dbus_type_get_alignment (element_type);
1547 
1548  pos = _DBUS_ALIGN_VALUE (pos, alignment);
1549 
1550  array_len = n_elements * alignment;
1551 
1552  *(const DBusBasicValue**) value = (void*) _dbus_string_get_const_data_len (str, pos, array_len);
1553  if (new_pos)
1554  *new_pos = pos + array_len;
1555 }
1556 
1557 static void
1558 swap_test_array (void *array,
1559  int len_bytes,
1560  int byte_order,
1561  int alignment)
1562 {
1563  DBusString t;
1564 
1565  if (alignment == 1)
1566  return;
1567 
1568  _dbus_string_init_const_len (&t, array, len_bytes);
1569  swap_array (&t, 0, len_bytes / alignment, byte_order, alignment);
1570 }
1571 
1572 #define MARSHAL_BASIC(typename, byte_order, literal) \
1573  do { \
1574  v_##typename = literal; \
1575  if (!_dbus_marshal_write_basic (&str, pos, DBUS_TYPE_##typename, \
1576  &v_##typename, \
1577  byte_order, NULL)) \
1578  _dbus_assert_not_reached ("no memory"); \
1579  } while (0)
1580 
1581 #define DEMARSHAL_BASIC(typename, byte_order) \
1582  do { \
1583  _dbus_marshal_read_basic (&str, pos, DBUS_TYPE_##typename, &v_##typename, \
1584  byte_order, &pos); \
1585  } while (0)
1586 
1587 #define DEMARSHAL_BASIC_AND_CHECK(typename, byte_order, literal) \
1588  do { \
1589  DEMARSHAL_BASIC (typename, byte_order); \
1590  if (literal != v_##typename) \
1591  { \
1592  _dbus_verbose_bytes_of_string (&str, dump_pos, \
1593  _dbus_string_get_length (&str) - dump_pos); \
1594  _dbus_assert_not_reached ("demarshaled wrong value"); \
1595  } \
1596  } while (0)
1597 
1598 #define MARSHAL_TEST(typename, byte_order, literal) \
1599  do { \
1600  MARSHAL_BASIC (typename, byte_order, literal); \
1601  dump_pos = pos; \
1602  DEMARSHAL_BASIC_AND_CHECK (typename, byte_order, literal); \
1603  } while (0)
1604 
1605 #define MARSHAL_TEST_STRCMP(typename, byte_order, literal) \
1606  do { \
1607  MARSHAL_BASIC (typename, byte_order, literal); \
1608  dump_pos = pos; \
1609  DEMARSHAL_BASIC (typename, byte_order); \
1610  if (strcmp (literal, v_##typename) != 0) \
1611  { \
1612  _dbus_verbose_bytes_of_string (&str, dump_pos, \
1613  _dbus_string_get_length (&str) - dump_pos); \
1614  _dbus_warn ("literal '%s'\nvalue '%s'\n", literal, v_##typename); \
1615  _dbus_assert_not_reached ("demarshaled wrong value"); \
1616  } \
1617  } while (0)
1618 
1619 #define MARSHAL_FIXED_ARRAY(typename, byte_order, literal) \
1620  do { \
1621  int next; \
1622  v_UINT32 = sizeof(literal); \
1623  if (!_dbus_marshal_write_basic (&str, pos, DBUS_TYPE_UINT32, &v_UINT32, \
1624  byte_order, &next)) \
1625  _dbus_assert_not_reached ("no memory"); \
1626  v_ARRAY_##typename = literal; \
1627  if (!_dbus_marshal_write_fixed_multi (&str, next, DBUS_TYPE_##typename, \
1628  &v_ARRAY_##typename, _DBUS_N_ELEMENTS(literal), \
1629  byte_order, NULL)) \
1630  _dbus_assert_not_reached ("no memory"); \
1631  } while (0)
1632 
1633 #define DEMARSHAL_FIXED_ARRAY(typename, byte_order) \
1634  do { \
1635  int next; \
1636  alignment = _dbus_type_get_alignment (DBUS_TYPE_##typename); \
1637  v_UINT32 = _dbus_marshal_read_uint32 (&str, dump_pos, byte_order, &next); \
1638  _dbus_marshal_read_fixed_multi (&str, next, DBUS_TYPE_##typename, &v_ARRAY_##typename, \
1639  v_UINT32/alignment, \
1640  byte_order, NULL); \
1641  swap_test_array (v_ARRAY_##typename, v_UINT32, \
1642  byte_order, alignment); \
1643  } while (0)
1644 
1645 #define DEMARSHAL_FIXED_ARRAY_AND_CHECK(typename, byte_order, literal) \
1646  do { \
1647  DEMARSHAL_FIXED_ARRAY (typename, byte_order); \
1648  if (memcmp (literal, v_ARRAY_##typename, sizeof (literal) != 0)) \
1649  { \
1650  _dbus_verbose ("MARSHALED DATA\n"); \
1651  _dbus_verbose_bytes_of_string (&str, dump_pos, \
1652  _dbus_string_get_length (&str) - dump_pos); \
1653  _dbus_verbose ("LITERAL DATA\n"); \
1654  _dbus_verbose_bytes ((char*)literal, sizeof (literal), 0); \
1655  _dbus_verbose ("READ DATA\n"); \
1656  _dbus_verbose_bytes ((char*)v_ARRAY_##typename, sizeof (literal), 0); \
1657  _dbus_assert_not_reached ("demarshaled wrong fixed array value"); \
1658  } \
1659  } while (0)
1660 
1661 #define MARSHAL_TEST_FIXED_ARRAY(typename, byte_order, literal) \
1662  do { \
1663  MARSHAL_FIXED_ARRAY (typename, byte_order, literal); \
1664  dump_pos = pos; \
1665  DEMARSHAL_FIXED_ARRAY_AND_CHECK (typename, byte_order, literal); \
1666  } while (0)
1667 
1669 _dbus_marshal_test (void)
1670 {
1671  int alignment;
1672  DBusString str;
1673  int pos, dump_pos;
1674  unsigned char array1[5] = { 3, 4, 0, 1, 9 };
1675  dbus_int16_t array2[3] = { 124, 457, 780 };
1676  dbus_int32_t array4[3] = { 123, 456, 789 };
1677 #ifdef DBUS_HAVE_INT64
1678  dbus_int64_t array8[3] = { DBUS_INT64_CONSTANT (0x123ffffffff),
1679  DBUS_INT64_CONSTANT (0x456ffffffff),
1680  DBUS_INT64_CONSTANT (0x789ffffffff) };
1681  dbus_int64_t *v_ARRAY_INT64;
1682 #endif
1683  unsigned char *v_ARRAY_BYTE;
1684  dbus_int16_t *v_ARRAY_INT16;
1685  dbus_uint16_t *v_ARRAY_UINT16;
1686  dbus_int32_t *v_ARRAY_INT32;
1687  dbus_uint32_t *v_ARRAY_UINT32;
1688  DBusString t;
1689  double v_DOUBLE;
1690  double t_DOUBLE;
1691  dbus_int16_t v_INT16;
1692  dbus_uint16_t v_UINT16;
1693  dbus_int32_t v_INT32;
1694  dbus_uint32_t v_UINT32;
1695  dbus_int64_t v_INT64;
1696  dbus_uint64_t v_UINT64;
1697  unsigned char v_BYTE;
1698  dbus_bool_t v_BOOLEAN;
1699  const char *v_STRING;
1700  const char *v_SIGNATURE;
1701  const char *v_OBJECT_PATH;
1702  int byte_order;
1703 
1704  if (!_dbus_string_init (&str))
1705  _dbus_assert_not_reached ("failed to init string");
1706 
1707  pos = 0;
1708 
1709  /* Marshal doubles */
1710  MARSHAL_BASIC (DOUBLE, DBUS_BIG_ENDIAN, 3.14);
1711  DEMARSHAL_BASIC (DOUBLE, DBUS_BIG_ENDIAN);
1712  t_DOUBLE = 3.14;
1713  if (!_DBUS_DOUBLES_BITWISE_EQUAL (t_DOUBLE, v_DOUBLE))
1714  _dbus_assert_not_reached ("got wrong double value");
1715 
1716  MARSHAL_BASIC (DOUBLE, DBUS_LITTLE_ENDIAN, 3.14);
1717  DEMARSHAL_BASIC (DOUBLE, DBUS_LITTLE_ENDIAN);
1718  t_DOUBLE = 3.14;
1719  if (!_DBUS_DOUBLES_BITWISE_EQUAL (t_DOUBLE, v_DOUBLE))
1720  _dbus_assert_not_reached ("got wrong double value");
1721 
1722  /* Marshal signed 16 integers */
1723  MARSHAL_TEST (INT16, DBUS_BIG_ENDIAN, -12345);
1724  MARSHAL_TEST (INT16, DBUS_LITTLE_ENDIAN, -12345);
1725 
1726  /* Marshal unsigned 16 integers */
1727  MARSHAL_TEST (UINT16, DBUS_BIG_ENDIAN, 0x1234);
1728  MARSHAL_TEST (UINT16, DBUS_LITTLE_ENDIAN, 0x1234);
1729 
1730  /* Marshal signed integers */
1731  MARSHAL_TEST (INT32, DBUS_BIG_ENDIAN, -12345678);
1732  MARSHAL_TEST (INT32, DBUS_LITTLE_ENDIAN, -12345678);
1733 
1734  /* Marshal unsigned integers */
1735  MARSHAL_TEST (UINT32, DBUS_BIG_ENDIAN, 0x12345678);
1736  MARSHAL_TEST (UINT32, DBUS_LITTLE_ENDIAN, 0x12345678);
1737 
1738 #ifdef DBUS_HAVE_INT64
1739  /* Marshal signed integers */
1740  MARSHAL_TEST (INT64, DBUS_BIG_ENDIAN, DBUS_INT64_CONSTANT (-0x123456789abc7));
1741  MARSHAL_TEST (INT64, DBUS_LITTLE_ENDIAN, DBUS_INT64_CONSTANT (-0x123456789abc7));
1742 
1743  /* Marshal unsigned integers */
1744  MARSHAL_TEST (UINT64, DBUS_BIG_ENDIAN, DBUS_UINT64_CONSTANT (0x123456789abc7));
1745  MARSHAL_TEST (UINT64, DBUS_LITTLE_ENDIAN, DBUS_UINT64_CONSTANT (0x123456789abc7));
1746 #endif /* DBUS_HAVE_INT64 */
1747 
1748  /* Marshal byte */
1749  MARSHAL_TEST (BYTE, DBUS_BIG_ENDIAN, 5);
1750  MARSHAL_TEST (BYTE, DBUS_LITTLE_ENDIAN, 5);
1751 
1752  /* Marshal all possible bools! */
1753  MARSHAL_TEST (BOOLEAN, DBUS_BIG_ENDIAN, FALSE);
1754  MARSHAL_TEST (BOOLEAN, DBUS_LITTLE_ENDIAN, FALSE);
1755  MARSHAL_TEST (BOOLEAN, DBUS_BIG_ENDIAN, TRUE);
1756  MARSHAL_TEST (BOOLEAN, DBUS_LITTLE_ENDIAN, TRUE);
1757 
1758  /* Marshal strings */
1759  MARSHAL_TEST_STRCMP (STRING, DBUS_BIG_ENDIAN, "");
1760  MARSHAL_TEST_STRCMP (STRING, DBUS_LITTLE_ENDIAN, "");
1761  MARSHAL_TEST_STRCMP (STRING, DBUS_BIG_ENDIAN, "This is the dbus test string");
1762  MARSHAL_TEST_STRCMP (STRING, DBUS_LITTLE_ENDIAN, "This is the dbus test string");
1763 
1764  /* object paths */
1765  MARSHAL_TEST_STRCMP (OBJECT_PATH, DBUS_BIG_ENDIAN, "/a/b/c");
1766  MARSHAL_TEST_STRCMP (OBJECT_PATH, DBUS_LITTLE_ENDIAN, "/a/b/c");
1767 
1768  /* signatures */
1769  MARSHAL_TEST_STRCMP (SIGNATURE, DBUS_BIG_ENDIAN, "");
1770  MARSHAL_TEST_STRCMP (SIGNATURE, DBUS_LITTLE_ENDIAN, "");
1771  MARSHAL_TEST_STRCMP (SIGNATURE, DBUS_BIG_ENDIAN, "a(ii)");
1772  MARSHAL_TEST_STRCMP (SIGNATURE, DBUS_LITTLE_ENDIAN, "a(ii)");
1773 
1774  /* Arrays */
1775  MARSHAL_TEST_FIXED_ARRAY (INT16, DBUS_BIG_ENDIAN, array2);
1776  MARSHAL_TEST_FIXED_ARRAY (INT16, DBUS_LITTLE_ENDIAN, array2);
1777  MARSHAL_TEST_FIXED_ARRAY (UINT16, DBUS_BIG_ENDIAN, array2);
1778  MARSHAL_TEST_FIXED_ARRAY (UINT16, DBUS_LITTLE_ENDIAN, array2);
1779 
1780  MARSHAL_TEST_FIXED_ARRAY (INT32, DBUS_BIG_ENDIAN, array4);
1781  MARSHAL_TEST_FIXED_ARRAY (INT32, DBUS_LITTLE_ENDIAN, array4);
1782  MARSHAL_TEST_FIXED_ARRAY (UINT32, DBUS_BIG_ENDIAN, array4);
1783  MARSHAL_TEST_FIXED_ARRAY (UINT32, DBUS_LITTLE_ENDIAN, array4);
1784 
1785  MARSHAL_TEST_FIXED_ARRAY (BYTE, DBUS_BIG_ENDIAN, array1);
1786  MARSHAL_TEST_FIXED_ARRAY (BYTE, DBUS_LITTLE_ENDIAN, array1);
1787 
1788 #ifdef DBUS_HAVE_INT64
1789  MARSHAL_TEST_FIXED_ARRAY (INT64, DBUS_BIG_ENDIAN, array8);
1790  MARSHAL_TEST_FIXED_ARRAY (INT64, DBUS_LITTLE_ENDIAN, array8);
1791 #endif
1792 
1793 #if 0
1794 
1795  /*
1796  * FIXME restore the set/pack tests
1797  */
1798 
1799 #ifdef DBUS_HAVE_INT64
1800  /* set/pack 64-bit integers */
1801  _dbus_string_set_length (&str, 8);
1802 
1803  /* signed little */
1804  _dbus_marshal_set_int64 (&str, DBUS_LITTLE_ENDIAN,
1805  0, DBUS_INT64_CONSTANT (-0x123456789abc7));
1806 
1807  _dbus_assert (DBUS_INT64_CONSTANT (-0x123456789abc7) ==
1808  _dbus_unpack_int64 (DBUS_LITTLE_ENDIAN,
1809  _dbus_string_get_const_data (&str)));
1810 
1811  /* signed big */
1812  _dbus_marshal_set_int64 (&str, DBUS_BIG_ENDIAN,
1813  0, DBUS_INT64_CONSTANT (-0x123456789abc7));
1814 
1815  _dbus_assert (DBUS_INT64_CONSTANT (-0x123456789abc7) ==
1816  _dbus_unpack_int64 (DBUS_BIG_ENDIAN,
1817  _dbus_string_get_const_data (&str)));
1818 
1819  /* signed little pack */
1820  _dbus_pack_int64 (DBUS_INT64_CONSTANT (-0x123456789abc7),
1822  _dbus_string_get_data (&str));
1823 
1824  _dbus_assert (DBUS_INT64_CONSTANT (-0x123456789abc7) ==
1825  _dbus_unpack_int64 (DBUS_LITTLE_ENDIAN,
1826  _dbus_string_get_const_data (&str)));
1827 
1828  /* signed big pack */
1829  _dbus_pack_int64 (DBUS_INT64_CONSTANT (-0x123456789abc7),
1831  _dbus_string_get_data (&str));
1832 
1833  _dbus_assert (DBUS_INT64_CONSTANT (-0x123456789abc7) ==
1834  _dbus_unpack_int64 (DBUS_BIG_ENDIAN,
1835  _dbus_string_get_const_data (&str)));
1836 
1837  /* unsigned little */
1838  _dbus_marshal_set_uint64 (&str, DBUS_LITTLE_ENDIAN,
1839  0, DBUS_UINT64_CONSTANT (0x123456789abc7));
1840 
1841  _dbus_assert (DBUS_UINT64_CONSTANT (0x123456789abc7) ==
1842  _dbus_unpack_uint64 (DBUS_LITTLE_ENDIAN,
1843  _dbus_string_get_const_data (&str)));
1844 
1845  /* unsigned big */
1846  _dbus_marshal_set_uint64 (&str, DBUS_BIG_ENDIAN,
1847  0, DBUS_UINT64_CONSTANT (0x123456789abc7));
1848 
1849  _dbus_assert (DBUS_UINT64_CONSTANT (0x123456789abc7) ==
1850  _dbus_unpack_uint64 (DBUS_BIG_ENDIAN,
1851  _dbus_string_get_const_data (&str)));
1852 
1853  /* unsigned little pack */
1854  _dbus_pack_uint64 (DBUS_UINT64_CONSTANT (0x123456789abc7),
1856  _dbus_string_get_data (&str));
1857 
1858  _dbus_assert (DBUS_UINT64_CONSTANT (0x123456789abc7) ==
1859  _dbus_unpack_uint64 (DBUS_LITTLE_ENDIAN,
1860  _dbus_string_get_const_data (&str)));
1861 
1862  /* unsigned big pack */
1863  _dbus_pack_uint64 (DBUS_UINT64_CONSTANT (0x123456789abc7),
1865  _dbus_string_get_data (&str));
1866 
1867  _dbus_assert (DBUS_UINT64_CONSTANT (0x123456789abc7) ==
1868  _dbus_unpack_uint64 (DBUS_BIG_ENDIAN,
1869  _dbus_string_get_const_data (&str)));
1870 #endif /* DBUS_HAVE_INT64 */
1871 
1872  /* set/pack 32-bit integers */
1873  _dbus_string_set_length (&str, 4);
1874 
1875  /* signed little */
1876  _dbus_marshal_set_int32 (&str, DBUS_LITTLE_ENDIAN,
1877  0, -0x123456);
1878 
1879  _dbus_assert (-0x123456 ==
1880  _dbus_unpack_int32 (DBUS_LITTLE_ENDIAN,
1881  _dbus_string_get_const_data (&str)));
1882 
1883  /* signed big */
1884  _dbus_marshal_set_int32 (&str, DBUS_BIG_ENDIAN,
1885  0, -0x123456);
1886 
1887  _dbus_assert (-0x123456 ==
1888  _dbus_unpack_int32 (DBUS_BIG_ENDIAN,
1889  _dbus_string_get_const_data (&str)));
1890 
1891  /* signed little pack */
1892  _dbus_pack_int32 (-0x123456,
1894  _dbus_string_get_data (&str));
1895 
1896  _dbus_assert (-0x123456 ==
1897  _dbus_unpack_int32 (DBUS_LITTLE_ENDIAN,
1898  _dbus_string_get_const_data (&str)));
1899 
1900  /* signed big pack */
1901  _dbus_pack_int32 (-0x123456,
1903  _dbus_string_get_data (&str));
1904 
1905  _dbus_assert (-0x123456 ==
1906  _dbus_unpack_int32 (DBUS_BIG_ENDIAN,
1907  _dbus_string_get_const_data (&str)));
1908 
1909  /* unsigned little */
1911  0, 0x123456,
1913 
1914  _dbus_assert (0x123456 ==
1916  _dbus_string_get_const_data (&str)));
1917 
1918  /* unsigned big */
1920  0, 0x123456,
1921  DBUS_BIG_ENDIAN);
1922 
1923  _dbus_assert (0x123456 ==
1925  _dbus_string_get_const_data (&str)));
1926 
1927  /* unsigned little pack */
1928  _dbus_pack_uint32 (0x123456,
1930  _dbus_string_get_data (&str));
1931 
1932  _dbus_assert (0x123456 ==
1934  _dbus_string_get_const_data (&str)));
1935 
1936  /* unsigned big pack */
1937  _dbus_pack_uint32 (0x123456,
1939  _dbus_string_get_data (&str));
1940 
1941  _dbus_assert (0x123456 ==
1943  _dbus_string_get_const_data (&str)));
1944 
1945 #endif /* set/pack tests for integers */
1946 
1947  /* Strings in-place set */
1948  byte_order = DBUS_LITTLE_ENDIAN;
1949  while (TRUE)
1950  {
1951  /* Init a string */
1952  _dbus_string_set_length (&str, 0);
1953 
1954  /* reset pos for the macros */
1955  pos = 0;
1956 
1957  MARSHAL_TEST_STRCMP (STRING, byte_order, "Hello world");
1958 
1959  /* Set it to something longer */
1960  _dbus_string_init_const (&t, "Hello world foo");
1961 
1962  v_STRING = _dbus_string_get_const_data (&t);
1964  &v_STRING, byte_order, NULL, NULL);
1965 
1967  &v_STRING, byte_order,
1968  NULL);
1969  _dbus_assert (strcmp (v_STRING, "Hello world foo") == 0);
1970 
1971  /* Set it to something shorter */
1972  _dbus_string_init_const (&t, "Hello");
1973 
1974  v_STRING = _dbus_string_get_const_data (&t);
1976  &v_STRING, byte_order, NULL, NULL);
1978  &v_STRING, byte_order,
1979  NULL);
1980  _dbus_assert (strcmp (v_STRING, "Hello") == 0);
1981 
1982  /* Do the other byte order */
1983  if (byte_order == DBUS_LITTLE_ENDIAN)
1984  byte_order = DBUS_BIG_ENDIAN;
1985  else
1986  break;
1987  }
1988 
1989  /* Clean up */
1990  _dbus_string_free (&str);
1991 
1992  return TRUE;
1993 }
1994 
1995 #endif /* DBUS_BUILD_TESTS */
dbus_bool_t dbus_type_is_fixed(int typecode)
Tells you whether values of this type can change length if you set them to some other value...
unsigned int dbus_uint32_t
A 32-bit unsigned integer on all platforms.
#define DBUS_TYPE_UINT16
Type code marking a 16-bit unsigned integer.
Definition: dbus-protocol.h:78
void _dbus_marshal_skip_basic(const DBusString *str, int type, int byte_order, int *pos)
Skips over a basic-typed value, reporting the following position.
#define NULL
A null pointer, defined appropriately for C or C++.
void _dbus_marshal_set_uint32(DBusString *str, int pos, dbus_uint32_t value, int byte_order)
Sets the 4 bytes at the given offset to a marshaled unsigned integer, replacing anything found there ...
int _dbus_first_type_in_signature(const DBusString *str, int pos)
Get the first type in the signature.
DBus8ByteStruct eight
as 8-byte struct
Definition: dbus-types.h:169
#define DBUS_TYPE_STRUCT
STRUCT and DICT_ENTRY are sort of special since their codes can&#39;t appear in a type string...
#define DBUS_TYPE_DICT_ENTRY
Type code used to represent a dict entry; however, this type code does not appear in type signatures...
#define DBUS_TYPE_STRING
Type code marking a UTF-8 encoded, nul-terminated Unicode string.
dbus_bool_t _dbus_string_insert_8_aligned(DBusString *str, int insert_at, const unsigned char octets[8])
Inserts 8 bytes aligned on an 8 byte boundary with any alignment padding initialized to 0...
Definition: dbus-string.c:1018
#define _dbus_assert(condition)
Aborts with an error message if the condition is false.
void _dbus_warn_check_failed(const char *format,...)
Prints a &quot;critical&quot; warning to stderr when an assertion fails; differs from _dbus_warn primarily in t...
#define DBUS_TYPE_BYTE
Type code marking an 8-bit unsigned integer.
Definition: dbus-protocol.h:66
void _dbus_swap_array(unsigned char *data, int n_elements, int alignment)
Swaps the elements of an array to the opposite byte order.
unsigned char _dbus_string_get_byte(const DBusString *str, int start)
Gets the byte at the given position.
Definition: dbus-string.c:540
char * _dbus_string_get_data_len(DBusString *str, int start, int len)
Gets a sub-portion of the raw character buffer from the string.
Definition: dbus-string.c:468
dbus_bool_t _dbus_string_init(DBusString *str)
Initializes a string.
Definition: dbus-string.c:175
char * str
as char* (string, object path or signature)
Definition: dbus-types.h:172
dbus_bool_t _dbus_string_copy(const DBusString *source, int start, DBusString *dest, int insert_at)
Like _dbus_string_move(), but does not delete the section of the source string that&#39;s copied to the d...
Definition: dbus-string.c:1280
#define DBUS_DICT_ENTRY_BEGIN_CHAR
Code marking the start of a dict entry type in a type signature.
#define DBUS_STRUCT_END_CHAR
Code marking the end of a struct type in a type signature.
#define DBUS_TYPE_DOUBLE
Type code marking an 8-byte double in IEEE 754 format.
Definition: dbus-protocol.h:98
#define DBUS_TYPE_ARRAY
Type code marking a D-Bus array type.
#define DBUS_TYPE_INT64
Type code marking a 64-bit signed integer.
Definition: dbus-protocol.h:90
dbus_uint32_t _dbus_unpack_uint32(int byte_order, const unsigned char *data)
Unpacks a 32 bit unsigned integer from a data pointer.
int _dbus_first_type_in_signature_c_str(const char *str, int pos)
Similar to _dbus_first_type_in_signature, but operates on a C string buffer.
unsigned char byt
as byte
Definition: dbus-types.h:171
dbus_bool_t dbus_type_is_basic(int typecode)
A &quot;basic type&quot; is a somewhat arbitrary concept, but the intent is to include those types that are ful...
dbus_uint32_t dbus_bool_t
A boolean, valid values are TRUE and FALSE.
Definition: dbus-types.h:35
void _dbus_string_init_const(DBusString *str, const char *value)
Initializes a constant string.
Definition: dbus-string.c:190
char * _dbus_string_get_data(DBusString *str)
Gets the raw character buffer from the string.
Definition: dbus-string.c:429
_DBUS_GNUC_EXTENSION typedef unsigned long long dbus_uint64_t
A 64-bit unsigned integer on all platforms that support it.
dbus_bool_t _dbus_string_replace_len(const DBusString *source, int start, int len, DBusString *dest, int replace_at, int replace_len)
Replaces a segment of dest string with a segment of source string.
Definition: dbus-string.c:1401
void _dbus_marshal_skip_array(const DBusString *str, int element_type, int byte_order, int *pos)
Skips an array, returning the next position.
void _dbus_warn(const char *format,...)
Prints a warning message to stderr.
void _dbus_string_delete(DBusString *str, int start, int len)
Deletes a segment of a DBusString with length len starting at start.
Definition: dbus-string.c:1190
void _dbus_marshal_read_basic(const DBusString *str, int pos, int type, void *value, int byte_order, int *new_pos)
Demarshals a basic-typed value.
dbus_uint16_t _dbus_unpack_uint16(int byte_order, const unsigned char *data)
Unpacks a 16 bit unsigned integer from a data pointer.
#define DBUS_TYPE_INT32
Type code marking a 32-bit signed integer.
Definition: dbus-protocol.h:82
#define DBUS_MAXIMUM_SIGNATURE_LENGTH
This one is 255 so it fits in a byte.
int _dbus_string_get_length(const DBusString *str)
Gets the length of a string (not including nul termination).
Definition: dbus-string.c:717
dbus_uint16_t u16
as int16
Definition: dbus-types.h:161
_DBUS_GNUC_EXTENSION typedef long long dbus_int64_t
A 64-bit signed integer on all platforms that support it.
void _dbus_pack_uint32(dbus_uint32_t value, int byte_order, unsigned char *data)
Packs a 32 bit unsigned integer into a data pointer.
#define DBUS_BIG_ENDIAN
Code marking MSB-first byte order in the wire protocol.
Definition: dbus-protocol.h:54
#define DBUS_TYPE_SIGNATURE
Type code marking a D-Bus type signature.
dbus_bool_t _dbus_string_equal_substring(const DBusString *a, int a_start, int a_len, const DBusString *b, int b_start)
Tests two sub-parts of two DBusString for equality.
Definition: dbus-string.c:2101
#define DBUS_TYPE_UINT64
Type code marking a 64-bit unsigned integer.
Definition: dbus-protocol.h:94
#define DBUS_STRUCT_BEGIN_CHAR
Code marking the start of a struct type in a type signature.
#define DBUS_TYPE_VARIANT
Type code marking a D-Bus variant type.
#define DBUS_TYPE_UINT32
Type code marking a 32-bit unsigned integer.
Definition: dbus-protocol.h:86
dbus_bool_t _dbus_marshal_write_fixed_multi(DBusString *str, int insert_at, int element_type, const void *value, int n_elements, int byte_order, int *pos_after)
Marshals a block of values of fixed-length type all at once, as an optimization.
dbus_bool_t _dbus_string_insert_byte(DBusString *str, int i, unsigned char byte)
Inserts a single byte at the given position.
Definition: dbus-string.c:592
short dbus_int16_t
A 16-bit signed integer on all platforms.
void _dbus_string_free(DBusString *str)
Frees a string created by _dbus_string_init().
Definition: dbus-string.c:242
unsigned char bytes[8]
as 8 individual bytes
Definition: dbus-types.h:159
#define TRUE
Expands to &quot;1&quot;.
#define _dbus_assert_not_reached(explanation)
Aborts with an error message if called.
An 8-byte struct you could use to access int64 without having int64 support.
Definition: dbus-types.h:141
#define DBUS_TYPE_OBJECT_PATH
Type code marking a D-Bus object path.
#define DBUS_TYPE_UNIX_FD
Type code marking a unix file descriptor.
void _dbus_string_set_byte(DBusString *str, int i, unsigned char byte)
Sets the value of the byte at the given position.
Definition: dbus-string.c:516
#define DBUS_TYPE_INVALID
Type code that is never equal to a legitimate type code.
Definition: dbus-protocol.h:60
#define DBUS_INT64_CONSTANT(val)
Declare a 64-bit signed integer constant.
#define DBUS_MAXIMUM_ARRAY_LENGTH
Max length of a marshaled array in bytes (64M, 2^26) We use signed int for lengths so must be INT_MAX...
const char * _dbus_string_get_const_data_len(const DBusString *str, int start, int len)
const version of _dbus_string_get_data_len().
Definition: dbus-string.c:492
#define DBUS_TYPE_INT16
Type code marking a 16-bit signed integer.
Definition: dbus-protocol.h:74
#define DBUS_TYPE_BOOLEAN
Type code marking a boolean.
Definition: dbus-protocol.h:70
A simple value union that lets you access bytes as if they were various types; useful when dealing wi...
Definition: dbus-types.h:157
#define FALSE
Expands to &quot;0&quot;.
dbus_bool_t _dbus_string_insert_4_aligned(DBusString *str, int insert_at, const unsigned char octets[4])
Inserts 4 bytes aligned on a 4 byte boundary with any alignment padding initialized to 0...
Definition: dbus-string.c:994
#define DBUS_DICT_ENTRY_END_CHAR
Code marking the end of a dict entry type in a type signature.
dbus_bool_t _dbus_string_set_length(DBusString *str, int length)
Sets the length of a string.
Definition: dbus-string.c:780
const char * _dbus_type_to_string(int typecode)
Returns a string describing the given type.
dbus_bool_t _dbus_string_copy_len(const DBusString *source, int start, int len, DBusString *dest, int insert_at)
Like _dbus_string_copy(), but can copy a segment from the middle of the source string.
Definition: dbus-string.c:1372
void _dbus_verbose_bytes_of_string(const DBusString *str, int start, int len)
Dump the given part of the string to verbose log.
int dbus_int32_t
A 32-bit signed integer on all platforms.
dbus_bool_t _dbus_string_insert_2_aligned(DBusString *str, int insert_at, const unsigned char octets[4])
Inserts 2 bytes aligned on a 2 byte boundary with any alignment padding initialized to 0...
Definition: dbus-string.c:970
#define DBUS_UINT64_CONSTANT(val)
Declare a 64-bit unsigned integer constant.
int _dbus_type_get_alignment(int typecode)
Gets the alignment requirement for the given type; will be 1, 4, or 8.
dbus_bool_t _dbus_string_insert_alignment(DBusString *str, int *insert_at, int alignment)
Inserts padding at *insert_at such to align it to the given boundary.
Definition: dbus-string.c:1046
const char * _dbus_string_get_const_data(const DBusString *str)
Gets the raw character buffer from a const string.
Definition: dbus-string.c:446
void _dbus_string_init_const_len(DBusString *str, const char *value, int len)
Initializes a constant string with a length.
Definition: dbus-string.c:210
dbus_bool_t _dbus_marshal_set_basic(DBusString *str, int pos, int type, const void *value, int byte_order, int *old_end_pos, int *new_end_pos)
Sets an existing basic type value to a new value.
dbus_uint32_t u32
as int32
Definition: dbus-types.h:163
#define _DBUS_DOUBLES_BITWISE_EQUAL(a, b)
On x86 there is an 80-bit FPU, and if you do &quot;a == b&quot; it may have a or b in an 80-bit register...
Definition: dbus-sysdeps.h:476
unsigned short dbus_uint16_t
A 16-bit unsigned integer on all platforms.
dbus_bool_t _dbus_marshal_write_basic(DBusString *str, int insert_at, int type, const void *value, int byte_order, int *pos_after)
Marshals a basic-typed value.
#define DBUS_LITTLE_ENDIAN
Code marking LSB-first byte order in the wire protocol.
Definition: dbus-protocol.h:53
void _dbus_verbose_bytes(const unsigned char *data, int len, int offset)
If in verbose mode, print a block of binary data.
dbus_uint32_t _dbus_marshal_read_uint32(const DBusString *str, int pos, int byte_order, int *new_pos)
Convenience function to demarshal a 32 bit unsigned integer.