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 75 /** 76 * @defgroup DBusMarshal marshaling and unmarshaling 77 * @ingroup DBusInternals 78 * @brief functions to marshal/unmarshal data from the wire 79 * 80 * Types and functions related to converting primitive data types from 81 * wire format to native machine format, and vice versa. 82 * 83 * A signature is just a string with multiple types one after the other. 84 * for example a type is "i" or "(ii)", a signature is "i(ii)" 85 * where i is int and (ii) is struct { int; int; } 86 * 87 * @{ 88 */ 89 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 134 /** 135 * Packs a 32 bit unsigned integer into a data pointer. 136 * 137 * @param value the value 138 * @param byte_order the byte order to use 139 * @param data the data pointer 140 */ 141 void 142 _dbus_pack_uint32 (dbus_uint32_t value, 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 /** 210 * Unpacks a 16 bit unsigned integer from a data pointer 211 * 212 * @param byte_order The byte order to use 213 * @param data the data pointer 214 * @returns the integer 215 */ 216 dbus_uint16_t 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 /** 231 * Unpacks a 32 bit unsigned integer from a data pointer 232 * 233 * @param byte_order The byte order to use 234 * @param data the data pointer 235 * @returns the integer 236 */ 237 dbus_uint32_t 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 298 /** 299 * Sets the 4 bytes at the given offset to a marshaled unsigned 300 * integer, replacing anything found there previously. 301 * 302 * @param str the string to write the marshalled int to 303 * @param pos the byte offset where int should be written 304 * @param value the value 305 * @param byte_order the byte order to use 306 * 307 */ 308 void 309 _dbus_marshal_set_uint32 (DBusString *str, 310 int pos, 311 dbus_uint32_t value, 312 int byte_order) 313 { 314 set_4_octets (str, pos, value, byte_order); 315 } 316 317 /** 318 * Sets the existing marshaled string at the given offset with 319 * a new marshaled string. The given offset must point to 320 * an existing string or the wrong length will be deleted 321 * and replaced with the new string. 322 * 323 * Note: no attempt is made by this function to re-align 324 * any data which has been already marshalled after this 325 * string. Use with caution. 326 * 327 * @param str the string to write the marshalled string to 328 * @param pos the position of the marshaled string length 329 * @param value the value 330 * @param byte_order the byte order to use 331 * @param old_end_pos place to store byte after the nul byte of the old value 332 * @param new_end_pos place to store byte after the nul byte of the new value 333 * @returns #TRUE on success, #FALSE if no memory 334 * 335 */ 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 369 /** 370 * Sets the existing marshaled signature at the given offset to a new 371 * marshaled signature. Same basic ideas as set_string(). 372 * 373 * @param str the string to write the marshalled signature to 374 * @param pos the position of the marshaled signature length 375 * @param value the value 376 * @param byte_order the byte order to use 377 * @param old_end_pos place to store byte after the nul byte of the old value 378 * @param new_end_pos place to store byte after the nul byte of the new value 379 * @returns #TRUE on success, #FALSE if no memory 380 * 381 */ 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 412 /** 413 * Sets an existing basic type value to a new value. 414 * Arguments work the same way as _dbus_marshal_basic_type(). 415 * 416 * @param str the string 417 * @param pos location of the current value 418 * @param type the type of the current and new values 419 * @param value the address of the new value 420 * @param byte_order byte order for marshaling 421 * @param old_end_pos location to store end position of the old value, or #NULL 422 * @param new_end_pos location to store end position of the new value, or #NULL 423 * @returns #FALSE if no memory 424 */ 425 dbus_bool_t 426 _dbus_marshal_set_basic (DBusString *str, 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: 482 case DBUS_TYPE_OBJECT_PATH: 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 500 /** 501 * Convenience function to demarshal a 32 bit unsigned integer. 502 * 503 * @param str the string containing the data 504 * @param byte_order the byte order 505 * @param pos the position in the string 506 * @param new_pos the new position of the string 507 * @returns the demarshaled integer. 508 */ 509 dbus_uint32_t 510 _dbus_marshal_read_uint32 (const DBusString *str, 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 526 /** 527 * Demarshals a basic-typed value. The "value" pointer is always 528 * the address of a variable of the basic type. So e.g. 529 * if the basic type is "double" then the pointer is 530 * a double*, and if it's "char*" then the pointer is 531 * a "char**". 532 * 533 * A value of type #DBusBasicValue is guaranteed to be large enough to 534 * hold any of the types that may be returned, which is handy if you 535 * are trying to do things generically. For example you can pass 536 * a DBusBasicValue* in to this function, and then pass the same 537 * DBusBasicValue* in to _dbus_marshal_basic_type() in order to 538 * move a value from one place to another. 539 * 540 * @param str the string containing the data 541 * @param pos position in the string 542 * @param type type of value to demarshal 543 * @param value pointer to return value data 544 * @param byte_order the byte order 545 * @param new_pos pointer to update with new position, or #NULL 546 **/ 547 void 548 _dbus_marshal_read_basic (const DBusString *str, 549 int pos, 550 int type, 551 void *value, 552 int byte_order, 553 int *new_pos) 554 { 555 const char *str_data; 556 557 _dbus_assert (dbus_type_is_basic (type)); 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: 617 case DBUS_TYPE_OBJECT_PATH: 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 { 772 _dbus_assert (data_len <= DBUS_MAXIMUM_SIGNATURE_LENGTH); 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 838 /** 839 * Marshals a basic-typed value. The "value" pointer is always the 840 * address of a variable containing the basic type value. 841 * So for example for int32 it will be dbus_int32_t*, and 842 * for string it will be const char**. This is for symmetry 843 * with _dbus_marshal_read_basic() and to have a simple 844 * consistent rule. 845 * 846 * @param str string to marshal to 847 * @param insert_at where to insert the value 848 * @param type type of value 849 * @param value pointer to a variable containing the value 850 * @param byte_order byte order 851 * @param pos_after #NULL or the position after the type 852 * @returns #TRUE on success 853 **/ 854 dbus_bool_t 855 _dbus_marshal_write_basic (DBusString *str, 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 864 _dbus_assert (dbus_type_is_basic (type)); 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: 899 case DBUS_TYPE_OBJECT_PATH: 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 941 /** 942 * Swaps the elements of an array to the opposite byte order 943 * 944 * @param data start of array 945 * @param n_elements number of elements 946 * @param alignment size of each element 947 */ 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 1045 _dbus_string_init_const_len (&t, 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 1067 /** 1068 * Marshals a block of values of fixed-length type all at once, as an 1069 * optimization. dbus_type_is_fixed() returns #TRUE for fixed-length 1070 * types, which are the basic types minus the string-like types. 1071 * 1072 * The value argument should be the adddress of an 1073 * array, so e.g. "const dbus_uint32_t**" 1074 * 1075 * @param str string to marshal to 1076 * @param insert_at where to insert the value 1077 * @param element_type type of array elements 1078 * @param value address of an array to marshal 1079 * @param n_elements number of elements in the array 1080 * @param byte_order byte order 1081 * @param pos_after #NULL or the position after the type 1082 * @returns #TRUE on success 1083 **/ 1084 dbus_bool_t 1085 _dbus_marshal_write_fixed_multi (DBusString *str, 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 1132 /** 1133 * Skips over a basic-typed value, reporting the following position. 1134 * 1135 * @param str the string containing the data 1136 * @param type type of value to read 1137 * @param byte_order the byte order 1138 * @param pos pointer to position in the string, 1139 * updated on return to new position 1140 **/ 1141 void 1142 _dbus_marshal_skip_basic (const DBusString *str, 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 1200 /** 1201 * Skips an array, returning the next position. 1202 * 1203 * @param str the string containing the data 1204 * @param element_type the type of array elements 1205 * @param byte_order the byte order 1206 * @param pos pointer to position in the string, 1207 * updated on return to new position 1208 */ 1209 void 1210 _dbus_marshal_skip_array (const DBusString *str, 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 1230 /** 1231 * Gets the alignment requirement for the given type; 1232 * will be 1, 4, or 8. 1233 * 1234 * @param typecode the type 1235 * @returns alignment of 1, 4, or 8 1236 */ 1237 int 1238 _dbus_type_get_alignment (int typecode) 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 1277 /** 1278 * Returns a string describing the given type. 1279 * 1280 * @param typecode the type to describe 1281 * @returns a constant string describing the type 1282 */ 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"; 1322 case DBUS_STRUCT_BEGIN_CHAR: 1323 return "begin_struct"; 1324 case DBUS_STRUCT_END_CHAR: 1325 return "end_struct"; 1326 case DBUS_DICT_ENTRY_BEGIN_CHAR: 1327 return "begin_dict_entry"; 1328 case DBUS_DICT_ENTRY_END_CHAR: 1329 return "end_dict_entry"; 1330 case DBUS_TYPE_UNIX_FD: 1331 return "unix_fd"; 1332 default: 1333 return "unknown"; 1334 } 1335 } 1336 1337 /** 1338 * If in verbose mode, print a block of binary data. 1339 * 1340 * @param data the data 1341 * @param len the length of the data 1342 * @param offset where to start counting for byte indexes 1343 */ 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 1417 /** 1418 * Dump the given part of the string to verbose log. 1419 * 1420 * @param str the string 1421 * @param start the start of range to dump 1422 * @param len length of range 1423 */ 1424 void 1425 _dbus_verbose_bytes_of_string (const DBusString *str, 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 { 1464 _dbus_assert (t != DBUS_STRUCT_END_CHAR); 1465 _dbus_assert (t != DBUS_DICT_ENTRY_END_CHAR); 1466 return t; 1467 } 1468 } 1469 1470 /** 1471 * Get the first type in the signature. The difference between this 1472 * and just getting the first byte of the signature is that you won't 1473 * get DBUS_STRUCT_BEGIN_CHAR, you'll get DBUS_TYPE_STRUCT 1474 * instead. 1475 * 1476 * @param str string containing signature 1477 * @param pos where the signature starts 1478 * @returns the first type in the signature 1479 */ 1480 int 1481 _dbus_first_type_in_signature (const DBusString *str, 1482 int pos) 1483 { 1484 return map_type_char_to_type (_dbus_string_get_byte (str, pos)); 1485 } 1486 1487 /** 1488 * Similar to #_dbus_first_type_in_signature, but operates 1489 * on a C string buffer. 1490 * 1491 * @param str a C string buffer 1492 * @param pos where the signature starts 1493 * @returns the first type in the signature 1494 */ 1495 int 1496 _dbus_first_type_in_signature_c_str (const char *str, 1497 int pos) 1498 { 1499 return map_type_char_to_type (str[pos]); 1500 } 1501 1502 /** @} */ 1503 1504 #ifdef DBUS_BUILD_TESTS 1505 #include "dbus-test.h" 1506 #include <stdio.h> 1507 1508 /** 1509 * Reads a block of fixed-length basic values, as an optimization 1510 * vs. reading each one individually into a new buffer. 1511 * 1512 * This function returns the data in-place; it does not make a copy, 1513 * and it does not swap the bytes. 1514 * 1515 * If you ask for #DBUS_TYPE_DOUBLE you will get a "const double*" back 1516 * and the "value" argument should be a "const double**" and so on. 1517 * 1518 * @param str the string to read from 1519 * @param pos position to read from 1520 * @param element_type type of array elements 1521 * @param value place to return the array 1522 * @param n_elements number of array elements to read 1523 * @param byte_order the byte order, used to read the array length 1524 * @param new_pos #NULL or location to store a position after the elements 1525 */ 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 1668 dbus_bool_t 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), 1821 DBUS_LITTLE_ENDIAN, 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), 1830 DBUS_BIG_ENDIAN, 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), 1855 DBUS_LITTLE_ENDIAN, 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), 1864 DBUS_BIG_ENDIAN, 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, 1893 DBUS_LITTLE_ENDIAN, 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, 1902 DBUS_BIG_ENDIAN, 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 */ 1910 _dbus_marshal_set_uint32 (&str, 1911 0, 0x123456, 1912 DBUS_LITTLE_ENDIAN); 1913 1914 _dbus_assert (0x123456 == 1915 _dbus_unpack_uint32 (DBUS_LITTLE_ENDIAN, 1916 _dbus_string_get_const_data (&str))); 1917 1918 /* unsigned big */ 1919 _dbus_marshal_set_uint32 (&str, 1920 0, 0x123456, 1921 DBUS_BIG_ENDIAN); 1922 1923 _dbus_assert (0x123456 == 1924 _dbus_unpack_uint32 (DBUS_BIG_ENDIAN, 1925 _dbus_string_get_const_data (&str))); 1926 1927 /* unsigned little pack */ 1928 _dbus_pack_uint32 (0x123456, 1929 DBUS_LITTLE_ENDIAN, 1930 _dbus_string_get_data (&str)); 1931 1932 _dbus_assert (0x123456 == 1933 _dbus_unpack_uint32 (DBUS_LITTLE_ENDIAN, 1934 _dbus_string_get_const_data (&str))); 1935 1936 /* unsigned big pack */ 1937 _dbus_pack_uint32 (0x123456, 1938 DBUS_BIG_ENDIAN, 1939 _dbus_string_get_data (&str)); 1940 1941 _dbus_assert (0x123456 == 1942 _dbus_unpack_uint32 (DBUS_BIG_ENDIAN, 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); 1963 _dbus_marshal_set_basic (&str, 0, DBUS_TYPE_STRING, 1964 &v_STRING, byte_order, NULL, NULL); 1965 1966 _dbus_marshal_read_basic (&str, 0, DBUS_TYPE_STRING, 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); 1975 _dbus_marshal_set_basic (&str, 0, DBUS_TYPE_STRING, 1976 &v_STRING, byte_order, NULL, NULL); 1977 _dbus_marshal_read_basic (&str, 0, DBUS_TYPE_STRING, 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 */ 1996
