00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025 #include "dbus-internals.h"
00026 #include "dbus-marshal-basic.h"
00027 #include "dbus-signature.h"
00028
00029 #include <string.h>
00030
00046 static void
00047 pack_2_octets (dbus_uint16_t value,
00048 int byte_order,
00049 unsigned char *data)
00050 {
00051 _dbus_assert (_DBUS_ALIGN_ADDRESS (data, 2) == data);
00052
00053 if ((byte_order) == DBUS_LITTLE_ENDIAN)
00054 *((dbus_uint16_t*)(data)) = DBUS_UINT16_TO_LE (value);
00055 else
00056 *((dbus_uint16_t*)(data)) = DBUS_UINT16_TO_BE (value);
00057 }
00058
00059 static void
00060 pack_4_octets (dbus_uint32_t value,
00061 int byte_order,
00062 unsigned char *data)
00063 {
00064 _dbus_assert (_DBUS_ALIGN_ADDRESS (data, 4) == data);
00065
00066 if ((byte_order) == DBUS_LITTLE_ENDIAN)
00067 *((dbus_uint32_t*)(data)) = DBUS_UINT32_TO_LE (value);
00068 else
00069 *((dbus_uint32_t*)(data)) = DBUS_UINT32_TO_BE (value);
00070 }
00071
00072 static void
00073 pack_8_octets (DBusBasicValue value,
00074 int byte_order,
00075 unsigned char *data)
00076 {
00077 _dbus_assert (_DBUS_ALIGN_ADDRESS (data, 8) == data);
00078
00079 #ifdef DBUS_HAVE_INT64
00080 if ((byte_order) == DBUS_LITTLE_ENDIAN)
00081 *((dbus_uint64_t*)(data)) = DBUS_UINT64_TO_LE (value.u64);
00082 else
00083 *((dbus_uint64_t*)(data)) = DBUS_UINT64_TO_BE (value.u64);
00084 #else
00085 *(DBus8ByteStruct*)data = value.u64;
00086 swap_8_octets ((DBusBasicValue*)data, byte_order);
00087 #endif
00088 }
00089
00097 void
00098 _dbus_pack_uint32 (dbus_uint32_t value,
00099 int byte_order,
00100 unsigned char *data)
00101 {
00102 pack_4_octets (value, byte_order, data);
00103 }
00104
00105 #ifndef DBUS_HAVE_INT64
00106
00107 static void
00108 swap_bytes (unsigned char *data,
00109 unsigned int len)
00110 {
00111 unsigned char *p1 = data;
00112 unsigned char *p2 = data + len - 1;
00113
00114 while (p1 < p2)
00115 {
00116 unsigned char tmp = *p1;
00117 *p1 = *p2;
00118 *p2 = tmp;
00119
00120 --p2;
00121 ++p1;
00122 }
00123 }
00124 #endif
00125
00126 static void
00127 swap_8_octets (DBusBasicValue *value,
00128 int byte_order)
00129 {
00130 if (byte_order != DBUS_COMPILER_BYTE_ORDER)
00131 {
00132 #ifdef DBUS_HAVE_INT64
00133 value->u64 = DBUS_UINT64_SWAP_LE_BE (value->u64);
00134 #else
00135 swap_bytes ((unsigned char *)value, 8);
00136 #endif
00137 }
00138 }
00139
00140 #if 0
00141 static DBusBasicValue
00142 unpack_8_octets (int byte_order,
00143 const unsigned char *data)
00144 {
00145 DBusBasicValue r;
00146
00147 _dbus_assert (_DBUS_ALIGN_ADDRESS (data, 8) == data);
00148 _dbus_assert (sizeof (r) == 8);
00149
00150 #ifdef DBUS_HAVE_INT64
00151 if (byte_order == DBUS_LITTLE_ENDIAN)
00152 r.u64 = DBUS_UINT64_FROM_LE (*(dbus_uint64_t*)data);
00153 else
00154 r.u64 = DBUS_UINT64_FROM_BE (*(dbus_uint64_t*)data);
00155 #else
00156 r.u64 = *(DBus8ByteStruct*)data;
00157 swap_8_octets (&r, byte_order);
00158 #endif
00159
00160 return r;
00161 }
00162 #endif
00163
00164 #ifndef _dbus_unpack_uint16
00165
00172 dbus_uint16_t
00173 _dbus_unpack_uint16 (int byte_order,
00174 const unsigned char *data)
00175 {
00176 _dbus_assert (_DBUS_ALIGN_ADDRESS (data, 2) == data);
00177
00178 if (byte_order == DBUS_LITTLE_ENDIAN)
00179 return DBUS_UINT16_FROM_LE (*(dbus_uint16_t*)data);
00180 else
00181 return DBUS_UINT16_FROM_BE (*(dbus_uint16_t*)data);
00182 }
00183 #endif
00184
00185 #ifndef _dbus_unpack_uint32
00186
00193 dbus_uint32_t
00194 _dbus_unpack_uint32 (int byte_order,
00195 const unsigned char *data)
00196 {
00197 _dbus_assert (_DBUS_ALIGN_ADDRESS (data, 4) == data);
00198
00199 if (byte_order == DBUS_LITTLE_ENDIAN)
00200 return DBUS_UINT32_FROM_LE (*(dbus_uint32_t*)data);
00201 else
00202 return DBUS_UINT32_FROM_BE (*(dbus_uint32_t*)data);
00203 }
00204 #endif
00205
00206 static void
00207 set_2_octets (DBusString *str,
00208 int offset,
00209 dbus_uint16_t value,
00210 int byte_order)
00211 {
00212 char *data;
00213
00214 _dbus_assert (byte_order == DBUS_LITTLE_ENDIAN ||
00215 byte_order == DBUS_BIG_ENDIAN);
00216
00217 data = _dbus_string_get_data_len (str, offset, 2);
00218
00219 pack_2_octets (value, byte_order, data);
00220 }
00221
00222 static void
00223 set_4_octets (DBusString *str,
00224 int offset,
00225 dbus_uint32_t value,
00226 int byte_order)
00227 {
00228 char *data;
00229
00230 _dbus_assert (byte_order == DBUS_LITTLE_ENDIAN ||
00231 byte_order == DBUS_BIG_ENDIAN);
00232
00233 data = _dbus_string_get_data_len (str, offset, 4);
00234
00235 pack_4_octets (value, byte_order, data);
00236 }
00237
00238 static void
00239 set_8_octets (DBusString *str,
00240 int offset,
00241 DBusBasicValue value,
00242 int byte_order)
00243 {
00244 char *data;
00245
00246 _dbus_assert (byte_order == DBUS_LITTLE_ENDIAN ||
00247 byte_order == DBUS_BIG_ENDIAN);
00248
00249 data = _dbus_string_get_data_len (str, offset, 8);
00250
00251 pack_8_octets (value, byte_order, data);
00252 }
00253
00264 void
00265 _dbus_marshal_set_uint32 (DBusString *str,
00266 int pos,
00267 dbus_uint32_t value,
00268 int byte_order)
00269 {
00270 set_4_octets (str, pos, value, byte_order);
00271 }
00272
00292 static dbus_bool_t
00293 set_string (DBusString *str,
00294 int pos,
00295 const char *value,
00296 int byte_order,
00297 int *old_end_pos,
00298 int *new_end_pos)
00299 {
00300 int old_len, new_len;
00301 DBusString dstr;
00302
00303 _dbus_string_init_const (&dstr, value);
00304
00305 _dbus_assert (_DBUS_ALIGN_VALUE (pos, 4) == (unsigned) pos);
00306 old_len = _dbus_unpack_uint32 (byte_order,
00307 _dbus_string_get_const_data_len (str, pos, 4));
00308
00309 new_len = _dbus_string_get_length (&dstr);
00310
00311 if (!_dbus_string_replace_len (&dstr, 0, new_len,
00312 str, pos + 4, old_len))
00313 return FALSE;
00314
00315 _dbus_marshal_set_uint32 (str, pos, new_len, byte_order);
00316
00317 if (old_end_pos)
00318 *old_end_pos = pos + 4 + old_len + 1;
00319 if (new_end_pos)
00320 *new_end_pos = pos + 4 + new_len + 1;
00321
00322 return TRUE;
00323 }
00324
00338 static dbus_bool_t
00339 set_signature (DBusString *str,
00340 int pos,
00341 const char *value,
00342 int byte_order,
00343 int *old_end_pos,
00344 int *new_end_pos)
00345 {
00346 int old_len, new_len;
00347 DBusString dstr;
00348
00349 _dbus_string_init_const (&dstr, value);
00350
00351 old_len = _dbus_string_get_byte (str, pos);
00352 new_len = _dbus_string_get_length (&dstr);
00353
00354 if (!_dbus_string_replace_len (&dstr, 0, new_len,
00355 str, pos + 1, old_len))
00356 return FALSE;
00357
00358 _dbus_string_set_byte (str, pos, new_len);
00359
00360 if (old_end_pos)
00361 *old_end_pos = pos + 1 + old_len + 1;
00362 if (new_end_pos)
00363 *new_end_pos = pos + 1 + new_len + 1;
00364
00365 return TRUE;
00366 }
00367
00381 dbus_bool_t
00382 _dbus_marshal_set_basic (DBusString *str,
00383 int pos,
00384 int type,
00385 const void *value,
00386 int byte_order,
00387 int *old_end_pos,
00388 int *new_end_pos)
00389 {
00390 const DBusBasicValue *vp;
00391
00392 vp = value;
00393
00394 switch (type)
00395 {
00396 case DBUS_TYPE_BYTE:
00397 _dbus_string_set_byte (str, pos, vp->byt);
00398 if (old_end_pos)
00399 *old_end_pos = pos + 1;
00400 if (new_end_pos)
00401 *new_end_pos = pos + 1;
00402 return TRUE;
00403 break;
00404 case DBUS_TYPE_INT16:
00405 case DBUS_TYPE_UINT16:
00406 pos = _DBUS_ALIGN_VALUE (pos, 2);
00407 set_2_octets (str, pos, vp->u16, byte_order);
00408 if (old_end_pos)
00409 *old_end_pos = pos + 2;
00410 if (new_end_pos)
00411 *new_end_pos = pos + 2;
00412 return TRUE;
00413 break;
00414 case DBUS_TYPE_BOOLEAN:
00415 case DBUS_TYPE_INT32:
00416 case DBUS_TYPE_UINT32:
00417 pos = _DBUS_ALIGN_VALUE (pos, 4);
00418 set_4_octets (str, pos, vp->u32, byte_order);
00419 if (old_end_pos)
00420 *old_end_pos = pos + 4;
00421 if (new_end_pos)
00422 *new_end_pos = pos + 4;
00423 return TRUE;
00424 break;
00425 case DBUS_TYPE_INT64:
00426 case DBUS_TYPE_UINT64:
00427 case DBUS_TYPE_DOUBLE:
00428 pos = _DBUS_ALIGN_VALUE (pos, 8);
00429 set_8_octets (str, pos, *vp, byte_order);
00430 if (old_end_pos)
00431 *old_end_pos = pos + 8;
00432 if (new_end_pos)
00433 *new_end_pos = pos + 8;
00434 return TRUE;
00435 break;
00436 case DBUS_TYPE_STRING:
00437 case DBUS_TYPE_OBJECT_PATH:
00438 pos = _DBUS_ALIGN_VALUE (pos, 4);
00439 _dbus_assert (vp->str != NULL);
00440 return set_string (str, pos, vp->str, byte_order,
00441 old_end_pos, new_end_pos);
00442 break;
00443 case DBUS_TYPE_SIGNATURE:
00444 _dbus_assert (vp->str != NULL);
00445 return set_signature (str, pos, vp->str, byte_order,
00446 old_end_pos, new_end_pos);
00447 break;
00448 default:
00449 _dbus_assert_not_reached ("not a basic type");
00450 return FALSE;
00451 break;
00452 }
00453 }
00454
00464 dbus_uint32_t
00465 _dbus_marshal_read_uint32 (const DBusString *str,
00466 int pos,
00467 int byte_order,
00468 int *new_pos)
00469 {
00470 pos = _DBUS_ALIGN_VALUE (pos, 4);
00471
00472 if (new_pos)
00473 *new_pos = pos + 4;
00474
00475 _dbus_assert (pos + 4 <= _dbus_string_get_length (str));
00476
00477 return _dbus_unpack_uint32 (byte_order,
00478 _dbus_string_get_const_data (str) + pos);
00479 }
00480
00502 void
00503 _dbus_marshal_read_basic (const DBusString *str,
00504 int pos,
00505 int type,
00506 void *value,
00507 int byte_order,
00508 int *new_pos)
00509 {
00510 const char *str_data;
00511 DBusBasicValue *vp;
00512
00513 _dbus_assert (dbus_type_is_basic (type));
00514
00515 str_data = _dbus_string_get_const_data (str);
00516 vp = value;
00517
00518 switch (type)
00519 {
00520 case DBUS_TYPE_BYTE:
00521 vp->byt = _dbus_string_get_byte (str, pos);
00522 (pos)++;
00523 break;
00524 case DBUS_TYPE_INT16:
00525 case DBUS_TYPE_UINT16:
00526 pos = _DBUS_ALIGN_VALUE (pos, 2);
00527 vp->u16 = *(dbus_uint16_t *)(str_data + pos);
00528 if (byte_order != DBUS_COMPILER_BYTE_ORDER)
00529 vp->u16 = DBUS_UINT16_SWAP_LE_BE (vp->u16);
00530 pos += 2;
00531 break;
00532 case DBUS_TYPE_INT32:
00533 case DBUS_TYPE_UINT32:
00534 case DBUS_TYPE_BOOLEAN:
00535 pos = _DBUS_ALIGN_VALUE (pos, 4);
00536 vp->u32 = *(dbus_uint32_t *)(str_data + pos);
00537 if (byte_order != DBUS_COMPILER_BYTE_ORDER)
00538 vp->u32 = DBUS_UINT32_SWAP_LE_BE (vp->u32);
00539 pos += 4;
00540 break;
00541 case DBUS_TYPE_INT64:
00542 case DBUS_TYPE_UINT64:
00543 case DBUS_TYPE_DOUBLE:
00544 pos = _DBUS_ALIGN_VALUE (pos, 8);
00545 #ifdef DBUS_HAVE_INT64
00546 if (byte_order != DBUS_COMPILER_BYTE_ORDER)
00547 vp->u64 = DBUS_UINT64_SWAP_LE_BE (*(dbus_uint64_t*)(str_data + pos));
00548 else
00549 vp->u64 = *(dbus_uint64_t*)(str_data + pos);
00550 #else
00551 vp->u64 = *(DBus8ByteStruct*) (str_data + pos);
00552 swap_8_octets (vp, byte_order);
00553 #endif
00554 pos += 8;
00555 break;
00556 case DBUS_TYPE_STRING:
00557 case DBUS_TYPE_OBJECT_PATH:
00558 {
00559 int len;
00560
00561 len = _dbus_marshal_read_uint32 (str, pos, byte_order, &pos);
00562
00563 vp->str = (char*) str_data + pos;
00564
00565 pos += len + 1;
00566 }
00567 break;
00568 case DBUS_TYPE_SIGNATURE:
00569 {
00570 int len;
00571
00572 len = _dbus_string_get_byte (str, pos);
00573 pos += 1;
00574
00575 vp->str = (char*) str_data + pos;
00576
00577 pos += len + 1;
00578 }
00579 break;
00580 default:
00581 _dbus_warn_check_failed ("type %s %d not a basic type\n",
00582 _dbus_type_to_string (type), type);
00583 _dbus_assert_not_reached ("not a basic type");
00584 break;
00585 }
00586
00587 if (new_pos)
00588 *new_pos = pos;
00589 }
00590
00591 static dbus_bool_t
00592 marshal_2_octets (DBusString *str,
00593 int insert_at,
00594 dbus_uint16_t value,
00595 int byte_order,
00596 int *pos_after)
00597 {
00598 dbus_bool_t retval;
00599 int orig_len;
00600
00601 _dbus_assert (sizeof (value) == 2);
00602
00603 if (byte_order != DBUS_COMPILER_BYTE_ORDER)
00604 value = DBUS_UINT16_SWAP_LE_BE (value);
00605
00606 orig_len = _dbus_string_get_length (str);
00607
00608 retval = _dbus_string_insert_2_aligned (str, insert_at,
00609 (const unsigned char *)&value);
00610
00611 if (pos_after)
00612 {
00613 *pos_after = insert_at + (_dbus_string_get_length (str) - orig_len);
00614 _dbus_assert (*pos_after <= _dbus_string_get_length (str));
00615 }
00616
00617 return retval;
00618 }
00619
00620 static dbus_bool_t
00621 marshal_4_octets (DBusString *str,
00622 int insert_at,
00623 dbus_uint32_t value,
00624 int byte_order,
00625 int *pos_after)
00626 {
00627 dbus_bool_t retval;
00628 int orig_len;
00629
00630 _dbus_assert (sizeof (value) == 4);
00631
00632 if (byte_order != DBUS_COMPILER_BYTE_ORDER)
00633 value = DBUS_UINT32_SWAP_LE_BE (value);
00634
00635 orig_len = _dbus_string_get_length (str);
00636
00637 retval = _dbus_string_insert_4_aligned (str, insert_at,
00638 (const unsigned char *)&value);
00639
00640 if (pos_after)
00641 {
00642 *pos_after = insert_at + (_dbus_string_get_length (str) - orig_len);
00643 _dbus_assert (*pos_after <= _dbus_string_get_length (str));
00644 }
00645
00646 return retval;
00647 }
00648
00649 static dbus_bool_t
00650 marshal_8_octets (DBusString *str,
00651 int insert_at,
00652 DBusBasicValue value,
00653 int byte_order,
00654 int *pos_after)
00655 {
00656 dbus_bool_t retval;
00657 int orig_len;
00658
00659 _dbus_assert (sizeof (value) == 8);
00660
00661 swap_8_octets (&value, byte_order);
00662
00663 orig_len = _dbus_string_get_length (str);
00664
00665 retval = _dbus_string_insert_8_aligned (str, insert_at,
00666 (const unsigned char *)&value);
00667
00668 if (pos_after)
00669 *pos_after = insert_at + _dbus_string_get_length (str) - orig_len;
00670
00671 return retval;
00672 }
00673
00674 enum
00675 {
00676 MARSHAL_AS_STRING,
00677 MARSHAL_AS_SIGNATURE,
00678 MARSHAL_AS_BYTE_ARRAY
00679 };
00680
00681 static dbus_bool_t
00682 marshal_len_followed_by_bytes (int marshal_as,
00683 DBusString *str,
00684 int insert_at,
00685 const unsigned char *value,
00686 int data_len,
00687 int byte_order,
00688 int *pos_after)
00689 {
00690 int pos;
00691 DBusString value_str;
00692 int value_len;
00693
00694 _dbus_assert (byte_order == DBUS_LITTLE_ENDIAN || byte_order == DBUS_BIG_ENDIAN);
00695 if (insert_at > _dbus_string_get_length (str))
00696 _dbus_warn ("insert_at = %d string len = %d data_len = %d\n",
00697 insert_at, _dbus_string_get_length (str), data_len);
00698
00699 if (marshal_as == MARSHAL_AS_BYTE_ARRAY)
00700 value_len = data_len;
00701 else
00702 value_len = data_len + 1;
00703
00704 _dbus_string_init_const_len (&value_str, value, value_len);
00705
00706 pos = insert_at;
00707
00708 if (marshal_as == MARSHAL_AS_SIGNATURE)
00709 {
00710 _dbus_assert (data_len <= DBUS_MAXIMUM_SIGNATURE_LENGTH);
00711 _dbus_assert (data_len <= 255);
00712
00713 if (!_dbus_string_insert_byte (str, pos, data_len))
00714 goto oom;
00715
00716 pos += 1;
00717 }
00718 else
00719 {
00720 if (!marshal_4_octets (str, pos, data_len,
00721 byte_order, &pos))
00722 goto oom;
00723 }
00724
00725 if (!_dbus_string_copy_len (&value_str, 0, value_len,
00726 str, pos))
00727 goto oom;
00728
00729 #if 0
00730
00731 _dbus_assert (_dbus_string_equal_substring (&value_str, 0, value_len,
00732 str, pos));
00733 _dbus_verbose_bytes_of_string (str, pos, value_len);
00734 #endif
00735
00736 pos += value_len;
00737
00738 if (pos_after)
00739 *pos_after = pos;
00740
00741 return TRUE;
00742
00743 oom:
00744
00745 _dbus_string_delete (str, insert_at, pos - insert_at);
00746
00747 return FALSE;
00748 }
00749
00750 static dbus_bool_t
00751 marshal_string (DBusString *str,
00752 int insert_at,
00753 const char *value,
00754 int byte_order,
00755 int *pos_after)
00756 {
00757 return marshal_len_followed_by_bytes (MARSHAL_AS_STRING,
00758 str, insert_at, value,
00759 strlen (value),
00760 byte_order, pos_after);
00761 }
00762
00763 static dbus_bool_t
00764 marshal_signature (DBusString *str,
00765 int insert_at,
00766 const char *value,
00767 int *pos_after)
00768 {
00769 return marshal_len_followed_by_bytes (MARSHAL_AS_SIGNATURE,
00770 str, insert_at, value,
00771 strlen (value),
00772 DBUS_COMPILER_BYTE_ORDER,
00773 pos_after);
00774 }
00775
00792 dbus_bool_t
00793 _dbus_marshal_write_basic (DBusString *str,
00794 int insert_at,
00795 int type,
00796 const void *value,
00797 int byte_order,
00798 int *pos_after)
00799 {
00800 const DBusBasicValue *vp;
00801
00802 _dbus_assert (dbus_type_is_basic (type));
00803
00804 vp = value;
00805
00806 switch (type)
00807 {
00808 case DBUS_TYPE_BYTE:
00809 if (!_dbus_string_insert_byte (str, insert_at, vp->byt))
00810 return FALSE;
00811 if (pos_after)
00812 *pos_after = insert_at + 1;
00813 return TRUE;
00814 break;
00815 case DBUS_TYPE_INT16:
00816 case DBUS_TYPE_UINT16:
00817 return marshal_2_octets (str, insert_at, vp->u16,
00818 byte_order, pos_after);
00819 break;
00820 case DBUS_TYPE_BOOLEAN:
00821 return marshal_4_octets (str, insert_at, vp->u32 != FALSE,
00822 byte_order, pos_after);
00823 break;
00824 case DBUS_TYPE_INT32:
00825 case DBUS_TYPE_UINT32:
00826 return marshal_4_octets (str, insert_at, vp->u32,
00827 byte_order, pos_after);
00828 break;
00829 case DBUS_TYPE_INT64:
00830 case DBUS_TYPE_UINT64:
00831 case DBUS_TYPE_DOUBLE:
00832 return marshal_8_octets (str, insert_at, *vp, byte_order, pos_after);
00833 break;
00834
00835 case DBUS_TYPE_STRING:
00836 case DBUS_TYPE_OBJECT_PATH:
00837 _dbus_assert (vp->str != NULL);
00838 return marshal_string (str, insert_at, vp->str, byte_order, pos_after);
00839 break;
00840 case DBUS_TYPE_SIGNATURE:
00841 _dbus_assert (vp->str != NULL);
00842 return marshal_signature (str, insert_at, vp->str, pos_after);
00843 break;
00844 default:
00845 _dbus_assert_not_reached ("not a basic type");
00846 return FALSE;
00847 break;
00848 }
00849 }
00850
00851 static dbus_bool_t
00852 marshal_1_octets_array (DBusString *str,
00853 int insert_at,
00854 const unsigned char *value,
00855 int n_elements,
00856 int byte_order,
00857 int *pos_after)
00858 {
00859 int pos;
00860 DBusString value_str;
00861
00862 _dbus_string_init_const_len (&value_str, value, n_elements);
00863
00864 pos = insert_at;
00865
00866 if (!_dbus_string_copy_len (&value_str, 0, n_elements,
00867 str, pos))
00868 return FALSE;
00869
00870 pos += n_elements;
00871
00872 if (pos_after)
00873 *pos_after = pos;
00874
00875 return TRUE;
00876 }
00877
00885 void
00886 _dbus_swap_array (unsigned char *data,
00887 int n_elements,
00888 int alignment)
00889 {
00890 unsigned char *d;
00891 unsigned char *end;
00892
00893 _dbus_assert (_DBUS_ALIGN_ADDRESS (data, alignment) == data);
00894
00895
00896
00897
00898 d = data;
00899 end = d + (n_elements * alignment);
00900
00901 if (alignment == 8)
00902 {
00903 while (d != end)
00904 {
00905 #ifdef DBUS_HAVE_INT64
00906 *((dbus_uint64_t*)d) = DBUS_UINT64_SWAP_LE_BE (*((dbus_uint64_t*)d));
00907 #else
00908 swap_8_bytes ((DBusBasicValue*) d);
00909 #endif
00910 d += 8;
00911 }
00912 }
00913 else if (alignment == 4)
00914 {
00915 while (d != end)
00916 {
00917 *((dbus_uint32_t*)d) = DBUS_UINT32_SWAP_LE_BE (*((dbus_uint32_t*)d));
00918 d += 4;
00919 }
00920 }
00921 else
00922 {
00923 _dbus_assert (alignment == 2);
00924
00925 while (d != end)
00926 {
00927 *((dbus_uint16_t*)d) = DBUS_UINT16_SWAP_LE_BE (*((dbus_uint16_t*)d));
00928 d += 2;
00929 }
00930 }
00931 }
00932
00933 static void
00934 swap_array (DBusString *str,
00935 int array_start,
00936 int n_elements,
00937 int byte_order,
00938 int alignment)
00939 {
00940 _dbus_assert (_DBUS_ALIGN_VALUE (array_start, alignment) == (unsigned) array_start);
00941
00942 if (byte_order != DBUS_COMPILER_BYTE_ORDER)
00943 {
00944
00945
00946
00947 _dbus_swap_array ((unsigned char*) (_dbus_string_get_const_data (str) + array_start),
00948 n_elements, alignment);
00949 }
00950 }
00951
00952 static dbus_bool_t
00953 marshal_fixed_multi (DBusString *str,
00954 int insert_at,
00955 const DBusBasicValue *value,
00956 int n_elements,
00957 int byte_order,
00958 int alignment,
00959 int *pos_after)
00960 {
00961 int old_string_len;
00962 int array_start;
00963 DBusString t;
00964 int len_in_bytes;
00965
00966 _dbus_assert (n_elements <= DBUS_MAXIMUM_ARRAY_LENGTH / alignment);
00967
00968 old_string_len = _dbus_string_get_length (str);
00969
00970 len_in_bytes = n_elements * alignment;
00971 array_start = insert_at;
00972
00973
00974
00975
00976
00977
00978
00979 if (!_dbus_string_insert_alignment (str, &array_start, alignment))
00980 goto error;
00981
00982 _dbus_string_init_const_len (&t,
00983 (const unsigned char*) value,
00984 len_in_bytes);
00985
00986 if (!_dbus_string_copy (&t, 0,
00987 str, array_start))
00988 goto error;
00989
00990 swap_array (str, array_start, n_elements, byte_order, alignment);
00991
00992 if (pos_after)
00993 *pos_after = array_start + len_in_bytes;
00994
00995 return TRUE;
00996
00997 error:
00998 _dbus_string_delete (str, insert_at,
00999 _dbus_string_get_length (str) - old_string_len);
01000
01001 return FALSE;
01002 }
01003
01021 dbus_bool_t
01022 _dbus_marshal_write_fixed_multi (DBusString *str,
01023 int insert_at,
01024 int element_type,
01025 const void *value,
01026 int n_elements,
01027 int byte_order,
01028 int *pos_after)
01029 {
01030 const void* vp = *(const DBusBasicValue**)value;
01031
01032 _dbus_assert (dbus_type_is_fixed (element_type));
01033 _dbus_assert (n_elements >= 0);
01034
01035 #if 0
01036 _dbus_verbose ("writing %d elements of %s\n",
01037 n_elements, _dbus_type_to_string (element_type));
01038 #endif
01039
01040 switch (element_type)
01041 {
01042 case DBUS_TYPE_BYTE:
01043 return marshal_1_octets_array (str, insert_at, vp, n_elements, byte_order, pos_after);
01044 break;
01045 case DBUS_TYPE_INT16:
01046 case DBUS_TYPE_UINT16:
01047 return marshal_fixed_multi (str, insert_at, vp, n_elements, byte_order, 2, pos_after);
01048
01049
01050 case DBUS_TYPE_BOOLEAN:
01051 case DBUS_TYPE_INT32:
01052 case DBUS_TYPE_UINT32:
01053 return marshal_fixed_multi (str, insert_at, vp, n_elements, byte_order, 4, pos_after);
01054 break;
01055 case DBUS_TYPE_INT64:
01056 case DBUS_TYPE_UINT64:
01057 case DBUS_TYPE_DOUBLE:
01058 return marshal_fixed_multi (str, insert_at, vp, n_elements, byte_order, 8, pos_after);
01059 break;
01060
01061 default:
01062 _dbus_assert_not_reached ("non fixed type in array write");
01063 break;
01064 }
01065
01066 return FALSE;
01067 }
01068
01069
01079 void
01080 _dbus_marshal_skip_basic (const DBusString *str,
01081 int type,
01082 int byte_order,
01083 int *pos)
01084 {
01085 _dbus_assert (byte_order == DBUS_LITTLE_ENDIAN ||
01086 byte_order == DBUS_BIG_ENDIAN);
01087
01088 switch (type)
01089 {
01090 case DBUS_TYPE_BYTE:
01091 (*pos)++;
01092 break;
01093 case DBUS_TYPE_INT16:
01094 case DBUS_TYPE_UINT16:
01095 *pos = _DBUS_ALIGN_VALUE (*pos, 2);
01096 *pos += 2;
01097 break;
01098 case DBUS_TYPE_BOOLEAN:
01099 case DBUS_TYPE_INT32:
01100 case DBUS_TYPE_UINT32:
01101 *pos = _DBUS_ALIGN_VALUE (*pos, 4);
01102 *pos += 4;
01103 break;
01104 case DBUS_TYPE_INT64:
01105 case DBUS_TYPE_UINT64:
01106 case DBUS_TYPE_DOUBLE:
01107 *pos = _DBUS_ALIGN_VALUE (*pos, 8);
01108 *pos += 8;
01109 break;
01110 case DBUS_TYPE_STRING:
01111 case DBUS_TYPE_OBJECT_PATH:
01112 {
01113 int len;
01114
01115 len = _dbus_marshal_read_uint32 (str, *pos, byte_order, pos);
01116
01117 *pos += len + 1;
01118 }
01119 break;
01120 case DBUS_TYPE_SIGNATURE:
01121 {
01122 int len;
01123
01124 len = _dbus_string_get_byte (str, *pos);
01125
01126 *pos += len + 2;
01127 }
01128 break;
01129 default:
01130 _dbus_warn ("type %s not a basic type\n",
01131 _dbus_type_to_string (type));
01132 _dbus_assert_not_reached ("not a basic type");
01133 break;
01134 }
01135 }
01136
01146 void
01147 _dbus_marshal_skip_array (const DBusString *str,
01148 int element_type,
01149 int byte_order,
01150 int *pos)
01151 {
01152 dbus_uint32_t array_len;
01153 int i;
01154 int alignment;
01155
01156 i = _DBUS_ALIGN_VALUE (*pos, 4);
01157
01158 array_len = _dbus_marshal_read_uint32 (str, i, byte_order, &i);
01159
01160 alignment = _dbus_type_get_alignment (element_type);
01161
01162 i = _DBUS_ALIGN_VALUE (i, alignment);
01163
01164 *pos = i + array_len;
01165 }
01166
01174 int
01175 _dbus_type_get_alignment (int typecode)
01176 {
01177 switch (typecode)
01178 {
01179 case DBUS_TYPE_BYTE:
01180 case DBUS_TYPE_VARIANT:
01181 case DBUS_TYPE_SIGNATURE:
01182 return 1;
01183 case DBUS_TYPE_INT16:
01184 case DBUS_TYPE_UINT16:
01185 return 2;
01186 case DBUS_TYPE_BOOLEAN:
01187 case DBUS_TYPE_INT32:
01188 case DBUS_TYPE_UINT32:
01189
01190 case DBUS_TYPE_STRING:
01191 case DBUS_TYPE_OBJECT_PATH:
01192 case DBUS_TYPE_ARRAY:
01193 return 4;
01194 case DBUS_TYPE_INT64:
01195 case DBUS_TYPE_UINT64:
01196 case DBUS_TYPE_DOUBLE:
01197
01198
01199
01200
01201
01202
01203 case DBUS_TYPE_STRUCT:
01204 case DBUS_TYPE_DICT_ENTRY:
01205 return 8;
01206
01207 default:
01208 _dbus_assert_not_reached ("unknown typecode in _dbus_type_get_alignment()");
01209 return 0;
01210 }
01211 }
01212
01213
01222 dbus_bool_t
01223 _dbus_type_is_valid (int typecode)
01224 {
01225 switch (typecode)
01226 {
01227 case DBUS_TYPE_BYTE:
01228 case DBUS_TYPE_BOOLEAN:
01229 case DBUS_TYPE_INT16:
01230 case DBUS_TYPE_UINT16:
01231 case DBUS_TYPE_INT32:
01232 case DBUS_TYPE_UINT32:
01233 case DBUS_TYPE_INT64:
01234 case DBUS_TYPE_UINT64:
01235 case DBUS_TYPE_DOUBLE:
01236 case DBUS_TYPE_STRING:
01237 case DBUS_TYPE_OBJECT_PATH:
01238 case DBUS_TYPE_SIGNATURE:
01239 case DBUS_TYPE_ARRAY:
01240 case DBUS_TYPE_STRUCT:
01241 case DBUS_TYPE_DICT_ENTRY:
01242 case DBUS_TYPE_VARIANT:
01243 return TRUE;
01244
01245 default:
01246 return FALSE;
01247 }
01248 }
01249
01256 const char *
01257 _dbus_type_to_string (int typecode)
01258 {
01259 switch (typecode)
01260 {
01261 case DBUS_TYPE_INVALID:
01262 return "invalid";
01263 case DBUS_TYPE_BOOLEAN:
01264 return "boolean";
01265 case DBUS_TYPE_BYTE:
01266 return "byte";
01267 case DBUS_TYPE_INT16:
01268 return "int16";
01269 case DBUS_TYPE_UINT16:
01270 return "uint16";
01271 case DBUS_TYPE_INT32:
01272 return "int32";
01273 case DBUS_TYPE_UINT32:
01274 return "uint32";
01275 case DBUS_TYPE_INT64:
01276 return "int64";
01277 case DBUS_TYPE_UINT64:
01278 return "uint64";
01279 case DBUS_TYPE_DOUBLE:
01280 return "double";
01281 case DBUS_TYPE_STRING:
01282 return "string";
01283 case DBUS_TYPE_OBJECT_PATH:
01284 return "object_path";
01285 case DBUS_TYPE_SIGNATURE:
01286 return "signature";
01287 case DBUS_TYPE_STRUCT:
01288 return "struct";
01289 case DBUS_TYPE_DICT_ENTRY:
01290 return "dict_entry";
01291 case DBUS_TYPE_ARRAY:
01292 return "array";
01293 case DBUS_TYPE_VARIANT:
01294 return "variant";
01295 case DBUS_STRUCT_BEGIN_CHAR:
01296 return "begin_struct";
01297 case DBUS_STRUCT_END_CHAR:
01298 return "end_struct";
01299 case DBUS_DICT_ENTRY_BEGIN_CHAR:
01300 return "begin_dict_entry";
01301 case DBUS_DICT_ENTRY_END_CHAR:
01302 return "end_dict_entry";
01303 default:
01304 return "unknown";
01305 }
01306 }
01307
01315 void
01316 _dbus_verbose_bytes (const unsigned char *data,
01317 int len,
01318 int offset)
01319 {
01320 int i;
01321 const unsigned char *aligned;
01322
01323 _dbus_assert (len >= 0);
01324
01325 if (!_dbus_is_verbose())
01326 return;
01327
01328
01329 aligned = _DBUS_ALIGN_ADDRESS (data, 4);
01330 if (aligned > data)
01331 aligned -= 4;
01332 _dbus_assert (aligned <= data);
01333
01334 if (aligned != data)
01335 {
01336 _dbus_verbose ("%4d\t%p: ", - (data - aligned), aligned);
01337 while (aligned != data)
01338 {
01339 _dbus_verbose (" ");
01340 ++aligned;
01341 }
01342 }
01343
01344
01345 i = 0;
01346 while (i < len)
01347 {
01348 if (_DBUS_ALIGN_ADDRESS (&data[i], 4) == &data[i])
01349 {
01350 _dbus_verbose ("%4d\t%p: ",
01351 offset + i, &data[i]);
01352 }
01353
01354 if (data[i] >= 32 &&
01355 data[i] <= 126)
01356 _dbus_verbose (" '%c' ", data[i]);
01357 else
01358 _dbus_verbose ("0x%s%x ",
01359 data[i] <= 0xf ? "0" : "", data[i]);
01360
01361 ++i;
01362
01363 if (_DBUS_ALIGN_ADDRESS (&data[i], 4) == &data[i])
01364 {
01365 if (i > 3)
01366 _dbus_verbose ("BE: %d LE: %d",
01367 _dbus_unpack_uint32 (DBUS_BIG_ENDIAN, &data[i-4]),
01368 _dbus_unpack_uint32 (DBUS_LITTLE_ENDIAN, &data[i-4]));
01369
01370 if (i > 7 &&
01371 _DBUS_ALIGN_ADDRESS (&data[i], 8) == &data[i])
01372 {
01373 #ifdef DBUS_HAVE_INT64
01374
01375
01376
01377
01378 #if __GNUC__
01379 _dbus_verbose (" u64: 0x%llx",
01380 *(dbus_uint64_t*)&data[i-8]);
01381 #endif
01382 #endif
01383 _dbus_verbose (" dbl: %g",
01384 *(double*)&data[i-8]);
01385 }
01386
01387 _dbus_verbose ("\n");
01388 }
01389 }
01390
01391 _dbus_verbose ("\n");
01392 }
01393
01401 void
01402 _dbus_verbose_bytes_of_string (const DBusString *str,
01403 int start,
01404 int len)
01405 {
01406 const char *d;
01407 int real_len;
01408
01409 real_len = _dbus_string_get_length (str);
01410
01411 _dbus_assert (start >= 0);
01412
01413 if (start > real_len)
01414 {
01415 _dbus_verbose (" [%d,%d) is not inside string of length %d\n",
01416 start, len, real_len);
01417 return;
01418 }
01419
01420 if ((start + len) > real_len)
01421 {
01422 _dbus_verbose (" [%d,%d) extends outside string of length %d\n",
01423 start, len, real_len);
01424 len = real_len - start;
01425 }
01426
01427 d = _dbus_string_get_const_data_len (str, start, len);
01428
01429 _dbus_verbose_bytes (d, len, start);
01430 }
01431
01432 static int
01433 map_type_char_to_type (int t)
01434 {
01435 if (t == DBUS_STRUCT_BEGIN_CHAR)
01436 return DBUS_TYPE_STRUCT;
01437 else if (t == DBUS_DICT_ENTRY_BEGIN_CHAR)
01438 return DBUS_TYPE_DICT_ENTRY;
01439 else
01440 {
01441 _dbus_assert (t != DBUS_STRUCT_END_CHAR);
01442 _dbus_assert (t != DBUS_DICT_ENTRY_END_CHAR);
01443 return t;
01444 }
01445 }
01446
01457 int
01458 _dbus_first_type_in_signature (const DBusString *str,
01459 int pos)
01460 {
01461 return map_type_char_to_type (_dbus_string_get_byte (str, pos));
01462 }
01463
01472 int
01473 _dbus_first_type_in_signature_c_str (const char *str,
01474 int pos)
01475 {
01476 return map_type_char_to_type (str[pos]);
01477 }
01478
01481 #ifdef DBUS_BUILD_TESTS
01482 #include "dbus-test.h"
01483 #include <stdio.h>
01484
01503 void
01504 _dbus_marshal_read_fixed_multi (const DBusString *str,
01505 int pos,
01506 int element_type,
01507 void *value,
01508 int n_elements,
01509 int byte_order,
01510 int *new_pos)
01511 {
01512 int array_len;
01513 int alignment;
01514
01515 _dbus_assert (dbus_type_is_fixed (element_type));
01516 _dbus_assert (dbus_type_is_basic (element_type));
01517
01518 #if 0
01519 _dbus_verbose ("reading %d elements of %s\n",
01520 n_elements, _dbus_type_to_string (element_type));
01521 #endif
01522
01523 alignment = _dbus_type_get_alignment (element_type);
01524
01525 pos = _DBUS_ALIGN_VALUE (pos, alignment);
01526
01527 array_len = n_elements * alignment;
01528
01529 *(const DBusBasicValue**) value = (void*) _dbus_string_get_const_data_len (str, pos, array_len);
01530 if (new_pos)
01531 *new_pos = pos + array_len;
01532 }
01533
01534 static void
01535 swap_test_array (void *array,
01536 int len_bytes,
01537 int byte_order,
01538 int alignment)
01539 {
01540 DBusString t;
01541
01542 if (alignment == 1)
01543 return;
01544
01545 _dbus_string_init_const_len (&t, array, len_bytes);
01546 swap_array (&t, 0, len_bytes / alignment, byte_order, alignment);
01547 }
01548
01549 #define MARSHAL_BASIC(typename, byte_order, literal) \
01550 do { \
01551 v_##typename = literal; \
01552 if (!_dbus_marshal_write_basic (&str, pos, DBUS_TYPE_##typename, \
01553 &v_##typename, \
01554 byte_order, NULL)) \
01555 _dbus_assert_not_reached ("no memory"); \
01556 } while (0)
01557
01558 #define DEMARSHAL_BASIC(typename, byte_order) \
01559 do { \
01560 _dbus_marshal_read_basic (&str, pos, DBUS_TYPE_##typename, &v_##typename, \
01561 byte_order, &pos); \
01562 } while (0)
01563
01564 #define DEMARSHAL_BASIC_AND_CHECK(typename, byte_order, literal) \
01565 do { \
01566 DEMARSHAL_BASIC (typename, byte_order); \
01567 if (literal != v_##typename) \
01568 { \
01569 _dbus_verbose_bytes_of_string (&str, dump_pos, \
01570 _dbus_string_get_length (&str) - dump_pos); \
01571 _dbus_assert_not_reached ("demarshaled wrong value"); \
01572 } \
01573 } while (0)
01574
01575 #define MARSHAL_TEST(typename, byte_order, literal) \
01576 do { \
01577 MARSHAL_BASIC (typename, byte_order, literal); \
01578 dump_pos = pos; \
01579 DEMARSHAL_BASIC_AND_CHECK (typename, byte_order, literal); \
01580 } while (0)
01581
01582 #define MARSHAL_TEST_STRCMP(typename, byte_order, literal) \
01583 do { \
01584 MARSHAL_BASIC (typename, byte_order, literal); \
01585 dump_pos = pos; \
01586 DEMARSHAL_BASIC (typename, byte_order); \
01587 if (strcmp (literal, v_##typename) != 0) \
01588 { \
01589 _dbus_verbose_bytes_of_string (&str, dump_pos, \
01590 _dbus_string_get_length (&str) - dump_pos); \
01591 _dbus_warn ("literal '%s'\nvalue '%s'\n", literal, v_##typename); \
01592 _dbus_assert_not_reached ("demarshaled wrong value"); \
01593 } \
01594 } while (0)
01595
01596 #define MARSHAL_FIXED_ARRAY(typename, byte_order, literal) \
01597 do { \
01598 int next; \
01599 v_UINT32 = sizeof(literal); \
01600 if (!_dbus_marshal_write_basic (&str, pos, DBUS_TYPE_UINT32, &v_UINT32, \
01601 byte_order, &next)) \
01602 _dbus_assert_not_reached ("no memory"); \
01603 v_ARRAY_##typename = literal; \
01604 if (!_dbus_marshal_write_fixed_multi (&str, next, DBUS_TYPE_##typename, \
01605 &v_ARRAY_##typename, _DBUS_N_ELEMENTS(literal), \
01606 byte_order, NULL)) \
01607 _dbus_assert_not_reached ("no memory"); \
01608 } while (0)
01609
01610 #define DEMARSHAL_FIXED_ARRAY(typename, byte_order) \
01611 do { \
01612 int next; \
01613 alignment = _dbus_type_get_alignment (DBUS_TYPE_##typename); \
01614 v_UINT32 = _dbus_marshal_read_uint32 (&str, dump_pos, byte_order, &next); \
01615 _dbus_marshal_read_fixed_multi (&str, next, DBUS_TYPE_##typename, &v_ARRAY_##typename, \
01616 v_UINT32/alignment, \
01617 byte_order, NULL); \
01618 swap_test_array (v_ARRAY_##typename, v_UINT32, \
01619 byte_order, alignment); \
01620 } while (0)
01621
01622 #define DEMARSHAL_FIXED_ARRAY_AND_CHECK(typename, byte_order, literal) \
01623 do { \
01624 DEMARSHAL_FIXED_ARRAY (typename, byte_order); \
01625 if (memcmp (literal, v_ARRAY_##typename, sizeof (literal) != 0)) \
01626 { \
01627 _dbus_verbose ("MARSHALED DATA\n"); \
01628 _dbus_verbose_bytes_of_string (&str, dump_pos, \
01629 _dbus_string_get_length (&str) - dump_pos); \
01630 _dbus_verbose ("LITERAL DATA\n"); \
01631 _dbus_verbose_bytes ((char*)literal, sizeof (literal), 0); \
01632 _dbus_verbose ("READ DATA\n"); \
01633 _dbus_verbose_bytes ((char*)v_ARRAY_##typename, sizeof (literal), 0); \
01634 _dbus_assert_not_reached ("demarshaled wrong fixed array value"); \
01635 } \
01636 } while (0)
01637
01638 #define MARSHAL_TEST_FIXED_ARRAY(typename, byte_order, literal) \
01639 do { \
01640 MARSHAL_FIXED_ARRAY (typename, byte_order, literal); \
01641 dump_pos = pos; \
01642 DEMARSHAL_FIXED_ARRAY_AND_CHECK (typename, byte_order, literal); \
01643 } while (0)
01644
01645 dbus_bool_t
01646 _dbus_marshal_test (void)
01647 {
01648 int alignment;
01649 DBusString str;
01650 int pos, dump_pos;
01651 unsigned char array1[5] = { 3, 4, 0, 1, 9 };
01652 dbus_int16_t array2[3] = { 124, 457, 780 };
01653 dbus_int32_t array4[3] = { 123, 456, 789 };
01654 #ifdef DBUS_HAVE_INT64
01655 dbus_int64_t array8[3] = { DBUS_INT64_CONSTANT (0x123ffffffff),
01656 DBUS_INT64_CONSTANT (0x456ffffffff),
01657 DBUS_INT64_CONSTANT (0x789ffffffff) };
01658 dbus_int64_t *v_ARRAY_INT64;
01659 #endif
01660 unsigned char *v_ARRAY_BYTE;
01661 dbus_int16_t *v_ARRAY_INT16;
01662 dbus_uint16_t *v_ARRAY_UINT16;
01663 dbus_int32_t *v_ARRAY_INT32;
01664 dbus_uint32_t *v_ARRAY_UINT32;
01665 DBusString t;
01666 double v_DOUBLE;
01667 double t_DOUBLE;
01668 dbus_int16_t v_INT16;
01669 dbus_uint16_t v_UINT16;
01670 dbus_int32_t v_INT32;
01671 dbus_uint32_t v_UINT32;
01672 dbus_int64_t v_INT64;
01673 dbus_uint64_t v_UINT64;
01674 unsigned char v_BYTE;
01675 dbus_bool_t v_BOOLEAN;
01676 const char *v_STRING;
01677 const char *v_SIGNATURE;
01678 const char *v_OBJECT_PATH;
01679 int byte_order;
01680
01681 if (!_dbus_string_init (&str))
01682 _dbus_assert_not_reached ("failed to init string");
01683
01684 pos = 0;
01685
01686
01687 MARSHAL_BASIC (DOUBLE, DBUS_BIG_ENDIAN, 3.14);
01688 DEMARSHAL_BASIC (DOUBLE, DBUS_BIG_ENDIAN);
01689 t_DOUBLE = 3.14;
01690 if (!_DBUS_DOUBLES_BITWISE_EQUAL (t_DOUBLE, v_DOUBLE))
01691 _dbus_assert_not_reached ("got wrong double value");
01692
01693 MARSHAL_BASIC (DOUBLE, DBUS_LITTLE_ENDIAN, 3.14);
01694 DEMARSHAL_BASIC (DOUBLE, DBUS_LITTLE_ENDIAN);
01695 t_DOUBLE = 3.14;
01696 if (!_DBUS_DOUBLES_BITWISE_EQUAL (t_DOUBLE, v_DOUBLE))
01697 _dbus_assert_not_reached ("got wrong double value");
01698
01699
01700 MARSHAL_TEST (INT16, DBUS_BIG_ENDIAN, -12345);
01701 MARSHAL_TEST (INT16, DBUS_LITTLE_ENDIAN, -12345);
01702
01703
01704 MARSHAL_TEST (UINT16, DBUS_BIG_ENDIAN, 0x1234);
01705 MARSHAL_TEST (UINT16, DBUS_LITTLE_ENDIAN, 0x1234);
01706
01707
01708 MARSHAL_TEST (INT32, DBUS_BIG_ENDIAN, -12345678);
01709 MARSHAL_TEST (INT32, DBUS_LITTLE_ENDIAN, -12345678);
01710
01711
01712 MARSHAL_TEST (UINT32, DBUS_BIG_ENDIAN, 0x12345678);
01713 MARSHAL_TEST (UINT32, DBUS_LITTLE_ENDIAN, 0x12345678);
01714
01715 #ifdef DBUS_HAVE_INT64
01716
01717 MARSHAL_TEST (INT64, DBUS_BIG_ENDIAN, DBUS_INT64_CONSTANT (-0x123456789abc7));
01718 MARSHAL_TEST (INT64, DBUS_LITTLE_ENDIAN, DBUS_INT64_CONSTANT (-0x123456789abc7));
01719
01720
01721 MARSHAL_TEST (UINT64, DBUS_BIG_ENDIAN, DBUS_UINT64_CONSTANT (0x123456789abc7));
01722 MARSHAL_TEST (UINT64, DBUS_LITTLE_ENDIAN, DBUS_UINT64_CONSTANT (0x123456789abc7));
01723 #endif
01724
01725
01726 MARSHAL_TEST (BYTE, DBUS_BIG_ENDIAN, 5);
01727 MARSHAL_TEST (BYTE, DBUS_LITTLE_ENDIAN, 5);
01728
01729
01730 MARSHAL_TEST (BOOLEAN, DBUS_BIG_ENDIAN, FALSE);
01731 MARSHAL_TEST (BOOLEAN, DBUS_LITTLE_ENDIAN, FALSE);
01732 MARSHAL_TEST (BOOLEAN, DBUS_BIG_ENDIAN, TRUE);
01733 MARSHAL_TEST (BOOLEAN, DBUS_LITTLE_ENDIAN, TRUE);
01734
01735
01736 MARSHAL_TEST_STRCMP (STRING, DBUS_BIG_ENDIAN, "");
01737 MARSHAL_TEST_STRCMP (STRING, DBUS_LITTLE_ENDIAN, "");
01738 MARSHAL_TEST_STRCMP (STRING, DBUS_BIG_ENDIAN, "This is the dbus test string");
01739 MARSHAL_TEST_STRCMP (STRING, DBUS_LITTLE_ENDIAN, "This is the dbus test string");
01740
01741
01742 MARSHAL_TEST_STRCMP (OBJECT_PATH, DBUS_BIG_ENDIAN, "/a/b/c");
01743 MARSHAL_TEST_STRCMP (OBJECT_PATH, DBUS_LITTLE_ENDIAN, "/a/b/c");
01744
01745
01746 MARSHAL_TEST_STRCMP (SIGNATURE, DBUS_BIG_ENDIAN, "");
01747 MARSHAL_TEST_STRCMP (SIGNATURE, DBUS_LITTLE_ENDIAN, "");
01748 MARSHAL_TEST_STRCMP (SIGNATURE, DBUS_BIG_ENDIAN, "a(ii)");
01749 MARSHAL_TEST_STRCMP (SIGNATURE, DBUS_LITTLE_ENDIAN, "a(ii)");
01750
01751
01752 MARSHAL_TEST_FIXED_ARRAY (INT16, DBUS_BIG_ENDIAN, array2);
01753 MARSHAL_TEST_FIXED_ARRAY (INT16, DBUS_LITTLE_ENDIAN, array2);
01754 MARSHAL_TEST_FIXED_ARRAY (UINT16, DBUS_BIG_ENDIAN, array2);
01755 MARSHAL_TEST_FIXED_ARRAY (UINT16, DBUS_LITTLE_ENDIAN, array2);
01756
01757 MARSHAL_TEST_FIXED_ARRAY (INT32, DBUS_BIG_ENDIAN, array4);
01758 MARSHAL_TEST_FIXED_ARRAY (INT32, DBUS_LITTLE_ENDIAN, array4);
01759 MARSHAL_TEST_FIXED_ARRAY (UINT32, DBUS_BIG_ENDIAN, array4);
01760 MARSHAL_TEST_FIXED_ARRAY (UINT32, DBUS_LITTLE_ENDIAN, array4);
01761
01762 MARSHAL_TEST_FIXED_ARRAY (BYTE, DBUS_BIG_ENDIAN, array1);
01763 MARSHAL_TEST_FIXED_ARRAY (BYTE, DBUS_LITTLE_ENDIAN, array1);
01764
01765 #ifdef DBUS_HAVE_INT64
01766 MARSHAL_TEST_FIXED_ARRAY (INT64, DBUS_BIG_ENDIAN, array8);
01767 MARSHAL_TEST_FIXED_ARRAY (INT64, DBUS_LITTLE_ENDIAN, array8);
01768 #endif
01769
01770 #if 0
01771
01772
01773
01774
01775
01776 #ifdef DBUS_HAVE_INT64
01777
01778 _dbus_string_set_length (&str, 8);
01779
01780
01781 _dbus_marshal_set_int64 (&str, DBUS_LITTLE_ENDIAN,
01782 0, DBUS_INT64_CONSTANT (-0x123456789abc7));
01783
01784 _dbus_assert (DBUS_INT64_CONSTANT (-0x123456789abc7) ==
01785 _dbus_unpack_int64 (DBUS_LITTLE_ENDIAN,
01786 _dbus_string_get_const_data (&str)));
01787
01788
01789 _dbus_marshal_set_int64 (&str, DBUS_BIG_ENDIAN,
01790 0, DBUS_INT64_CONSTANT (-0x123456789abc7));
01791
01792 _dbus_assert (DBUS_INT64_CONSTANT (-0x123456789abc7) ==
01793 _dbus_unpack_int64 (DBUS_BIG_ENDIAN,
01794 _dbus_string_get_const_data (&str)));
01795
01796
01797 _dbus_pack_int64 (DBUS_INT64_CONSTANT (-0x123456789abc7),
01798 DBUS_LITTLE_ENDIAN,
01799 _dbus_string_get_data (&str));
01800
01801 _dbus_assert (DBUS_INT64_CONSTANT (-0x123456789abc7) ==
01802 _dbus_unpack_int64 (DBUS_LITTLE_ENDIAN,
01803 _dbus_string_get_const_data (&str)));
01804
01805
01806 _dbus_pack_int64 (DBUS_INT64_CONSTANT (-0x123456789abc7),
01807 DBUS_BIG_ENDIAN,
01808 _dbus_string_get_data (&str));
01809
01810 _dbus_assert (DBUS_INT64_CONSTANT (-0x123456789abc7) ==
01811 _dbus_unpack_int64 (DBUS_BIG_ENDIAN,
01812 _dbus_string_get_const_data (&str)));
01813
01814
01815 _dbus_marshal_set_uint64 (&str, DBUS_LITTLE_ENDIAN,
01816 0, DBUS_UINT64_CONSTANT (0x123456789abc7));
01817
01818 _dbus_assert (DBUS_UINT64_CONSTANT (0x123456789abc7) ==
01819 _dbus_unpack_uint64 (DBUS_LITTLE_ENDIAN,
01820 _dbus_string_get_const_data (&str)));
01821
01822
01823 _dbus_marshal_set_uint64 (&str, DBUS_BIG_ENDIAN,
01824 0, DBUS_UINT64_CONSTANT (0x123456789abc7));
01825
01826 _dbus_assert (DBUS_UINT64_CONSTANT (0x123456789abc7) ==
01827 _dbus_unpack_uint64 (DBUS_BIG_ENDIAN,
01828 _dbus_string_get_const_data (&str)));
01829
01830
01831 _dbus_pack_uint64 (DBUS_UINT64_CONSTANT (0x123456789abc7),
01832 DBUS_LITTLE_ENDIAN,
01833 _dbus_string_get_data (&str));
01834
01835 _dbus_assert (DBUS_UINT64_CONSTANT (0x123456789abc7) ==
01836 _dbus_unpack_uint64 (DBUS_LITTLE_ENDIAN,
01837 _dbus_string_get_const_data (&str)));
01838
01839
01840 _dbus_pack_uint64 (DBUS_UINT64_CONSTANT (0x123456789abc7),
01841 DBUS_BIG_ENDIAN,
01842 _dbus_string_get_data (&str));
01843
01844 _dbus_assert (DBUS_UINT64_CONSTANT (0x123456789abc7) ==
01845 _dbus_unpack_uint64 (DBUS_BIG_ENDIAN,
01846 _dbus_string_get_const_data (&str)));
01847 #endif
01848
01849
01850 _dbus_string_set_length (&str, 4);
01851
01852
01853 _dbus_marshal_set_int32 (&str, DBUS_LITTLE_ENDIAN,
01854 0, -0x123456);
01855
01856 _dbus_assert (-0x123456 ==
01857 _dbus_unpack_int32 (DBUS_LITTLE_ENDIAN,
01858 _dbus_string_get_const_data (&str)));
01859
01860
01861 _dbus_marshal_set_int32 (&str, DBUS_BIG_ENDIAN,
01862 0, -0x123456);
01863
01864 _dbus_assert (-0x123456 ==
01865 _dbus_unpack_int32 (DBUS_BIG_ENDIAN,
01866 _dbus_string_get_const_data (&str)));
01867
01868
01869 _dbus_pack_int32 (-0x123456,
01870 DBUS_LITTLE_ENDIAN,
01871 _dbus_string_get_data (&str));
01872
01873 _dbus_assert (-0x123456 ==
01874 _dbus_unpack_int32 (DBUS_LITTLE_ENDIAN,
01875 _dbus_string_get_const_data (&str)));
01876
01877
01878 _dbus_pack_int32 (-0x123456,
01879 DBUS_BIG_ENDIAN,
01880 _dbus_string_get_data (&str));
01881
01882 _dbus_assert (-0x123456 ==
01883 _dbus_unpack_int32 (DBUS_BIG_ENDIAN,
01884 _dbus_string_get_const_data (&str)));
01885
01886
01887 _dbus_marshal_set_uint32 (&str,
01888 0, 0x123456,
01889 DBUS_LITTLE_ENDIAN);
01890
01891 _dbus_assert (0x123456 ==
01892 _dbus_unpack_uint32 (DBUS_LITTLE_ENDIAN,
01893 _dbus_string_get_const_data (&str)));
01894
01895
01896 _dbus_marshal_set_uint32 (&str,
01897 0, 0x123456,
01898 DBUS_BIG_ENDIAN);
01899
01900 _dbus_assert (0x123456 ==
01901 _dbus_unpack_uint32 (DBUS_BIG_ENDIAN,
01902 _dbus_string_get_const_data (&str)));
01903
01904
01905 _dbus_pack_uint32 (0x123456,
01906 DBUS_LITTLE_ENDIAN,
01907 _dbus_string_get_data (&str));
01908
01909 _dbus_assert (0x123456 ==
01910 _dbus_unpack_uint32 (DBUS_LITTLE_ENDIAN,
01911 _dbus_string_get_const_data (&str)));
01912
01913
01914 _dbus_pack_uint32 (0x123456,
01915 DBUS_BIG_ENDIAN,
01916 _dbus_string_get_data (&str));
01917
01918 _dbus_assert (0x123456 ==
01919 _dbus_unpack_uint32 (DBUS_BIG_ENDIAN,
01920 _dbus_string_get_const_data (&str)));
01921
01922 #endif
01923
01924
01925 byte_order = DBUS_LITTLE_ENDIAN;
01926 while (TRUE)
01927 {
01928
01929 _dbus_string_set_length (&str, 0);
01930
01931
01932 pos = 0;
01933
01934 MARSHAL_TEST_STRCMP (STRING, byte_order, "Hello world");
01935
01936
01937 _dbus_string_init_const (&t, "Hello world foo");
01938
01939 v_STRING = _dbus_string_get_const_data (&t);
01940 _dbus_marshal_set_basic (&str, 0, DBUS_TYPE_STRING,
01941 &v_STRING, byte_order, NULL, NULL);
01942
01943 _dbus_marshal_read_basic (&str, 0, DBUS_TYPE_STRING,
01944 &v_STRING, byte_order,
01945 NULL);
01946 _dbus_assert (strcmp (v_STRING, "Hello world foo") == 0);
01947
01948
01949 _dbus_string_init_const (&t, "Hello");
01950
01951 v_STRING = _dbus_string_get_const_data (&t);
01952 _dbus_marshal_set_basic (&str, 0, DBUS_TYPE_STRING,
01953 &v_STRING, byte_order, NULL, NULL);
01954 _dbus_marshal_read_basic (&str, 0, DBUS_TYPE_STRING,
01955 &v_STRING, byte_order,
01956 NULL);
01957 _dbus_assert (strcmp (v_STRING, "Hello") == 0);
01958
01959
01960 if (byte_order == DBUS_LITTLE_ENDIAN)
01961 byte_order = DBUS_BIG_ENDIAN;
01962 else
01963 break;
01964 }
01965
01966
01967 _dbus_string_free (&str);
01968
01969 return TRUE;
01970 }
01971
01972 #endif
