1 /* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */ 2 /* dbus-marshal-header.c Managing marshaling/demarshaling of message headers 3 * 4 * Copyright (C) 2005 Red Hat, Inc. 5 * 6 * Licensed under the Academic Free License version 2.1 7 * 8 * This program is free software; you can redistribute it and/or modify 9 * it under the terms of the GNU General Public License as published by 10 * the Free Software Foundation; either version 2 of the License, or 11 * (at your option) any later version. 12 * 13 * This program is distributed in the hope that it will be useful, 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 * GNU General Public License for more details. 17 * 18 * You should have received a copy of the GNU General Public License 19 * along with this program; if not, write to the Free Software 20 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 21 * 22 */ 23 24 #include <config.h> 25 #include "dbus/dbus-shared.h" 26 #include "dbus-marshal-header.h" 27 #include "dbus-marshal-recursive.h" 28 #include "dbus-marshal-byteswap.h" 29 30 /** 31 * @addtogroup DBusMarshal 32 * 33 * @{ 34 */ 35 36 37 /* Not thread locked, but strictly const/read-only so should be OK 38 */ 39 /** Static #DBusString containing the signature of a message header */ 40 _DBUS_STRING_DEFINE_STATIC(_dbus_header_signature_str, DBUS_HEADER_SIGNATURE); 41 /** Static #DBusString containing the local interface */ 42 _DBUS_STRING_DEFINE_STATIC(_dbus_local_interface_str, DBUS_INTERFACE_LOCAL); 43 /** Static #DBusString containing the local path */ 44 _DBUS_STRING_DEFINE_STATIC(_dbus_local_path_str, DBUS_PATH_LOCAL); 45 46 /** Offset from start of _dbus_header_signature_str to the signature of the fields array */ 47 #define FIELDS_ARRAY_SIGNATURE_OFFSET 6 48 /** Offset from start of _dbus_header_signature_str to the signature of an element of the fields array */ 49 #define FIELDS_ARRAY_ELEMENT_SIGNATURE_OFFSET 7 50 51 52 /** Offset to byte order from start of header */ 53 #define BYTE_ORDER_OFFSET 0 54 /** Offset to type from start of header */ 55 #define TYPE_OFFSET 1 56 /** Offset to flags from start of header */ 57 #define FLAGS_OFFSET 2 58 /** Offset to version from start of header */ 59 #define VERSION_OFFSET 3 60 /** Offset to body length from start of header */ 61 #define BODY_LENGTH_OFFSET 4 62 /** Offset to client serial from start of header */ 63 #define SERIAL_OFFSET 8 64 /** Offset to fields array length from start of header */ 65 #define FIELDS_ARRAY_LENGTH_OFFSET 12 66 /** Offset to first field in header */ 67 #define FIRST_FIELD_OFFSET 16 68 69 typedef struct 70 { 71 unsigned char code; /**< the field code */ 72 unsigned char type; /**< the value type */ 73 } HeaderFieldType; 74 75 static const HeaderFieldType 76 _dbus_header_field_types[DBUS_HEADER_FIELD_LAST+1] = { 77 { DBUS_HEADER_FIELD_INVALID, DBUS_TYPE_INVALID }, 78 { DBUS_HEADER_FIELD_PATH, DBUS_TYPE_OBJECT_PATH }, 79 { DBUS_HEADER_FIELD_INTERFACE, DBUS_TYPE_STRING }, 80 { DBUS_HEADER_FIELD_MEMBER, DBUS_TYPE_STRING }, 81 { DBUS_HEADER_FIELD_ERROR_NAME, DBUS_TYPE_STRING }, 82 { DBUS_HEADER_FIELD_REPLY_SERIAL, DBUS_TYPE_UINT32 }, 83 { DBUS_HEADER_FIELD_DESTINATION, DBUS_TYPE_STRING }, 84 { DBUS_HEADER_FIELD_SENDER, DBUS_TYPE_STRING }, 85 { DBUS_HEADER_FIELD_SIGNATURE, DBUS_TYPE_SIGNATURE }, 86 { DBUS_HEADER_FIELD_UNIX_FDS, DBUS_TYPE_UINT32 } 87 }; 88 89 /** Macro to look up the correct type for a field */ 90 #define EXPECTED_TYPE_OF_FIELD(field) (_dbus_header_field_types[field].type) 91 92 /** The most padding we could ever need for a header */ 93 #define MAX_POSSIBLE_HEADER_PADDING 7 94 static dbus_bool_t 95 reserve_header_padding (DBusHeader *header) 96 { 97 _dbus_assert (header->padding <= MAX_POSSIBLE_HEADER_PADDING); 98 99 if (!_dbus_string_lengthen (&header->data, 100 MAX_POSSIBLE_HEADER_PADDING - header->padding)) 101 return FALSE; 102 header->padding = MAX_POSSIBLE_HEADER_PADDING; 103 return TRUE; 104 } 105 106 static void 107 correct_header_padding (DBusHeader *header) 108 { 109 int unpadded_len; 110 111 _dbus_assert (header->padding == 7); 112 113 _dbus_string_shorten (&header->data, header->padding); 114 unpadded_len = _dbus_string_get_length (&header->data); 115 116 if (!_dbus_string_align_length (&header->data, 8)) 117 _dbus_assert_not_reached ("couldn't pad header though enough padding was preallocated"); 118 119 header->padding = _dbus_string_get_length (&header->data) - unpadded_len; 120 } 121 122 /** Compute the end of the header, ignoring padding */ 123 #define HEADER_END_BEFORE_PADDING(header) \ 124 (_dbus_string_get_length (&(header)->data) - (header)->padding) 125 126 /** 127 * Invalidates all fields in the cache. This may be used when the 128 * cache is totally uninitialized (contains junk) so should not 129 * look at what's in there now. 130 * 131 * @param header the header 132 */ 133 static void 134 _dbus_header_cache_invalidate_all (DBusHeader *header) 135 { 136 int i; 137 138 i = 0; 139 while (i <= DBUS_HEADER_FIELD_LAST) 140 { 141 header->fields[i].value_pos = _DBUS_HEADER_FIELD_VALUE_UNKNOWN; 142 ++i; 143 } 144 } 145 146 /** 147 * Caches one field 148 * 149 * @param header the header 150 * @param field_code the field 151 * @param variant_reader the reader for the variant in the field 152 */ 153 static void 154 _dbus_header_cache_one (DBusHeader *header, 155 int field_code, 156 DBusTypeReader *variant_reader) 157 { 158 header->fields[field_code].value_pos = 159 _dbus_type_reader_get_value_pos (variant_reader); 160 161 #if 0 162 _dbus_verbose ("cached value_pos %d for field %d\n", 163 header->fields[field_code].value_pos, field_code) 164 #endif 165 } 166 167 /** 168 * Revalidates the fields cache 169 * 170 * @param header the header 171 */ 172 static void 173 _dbus_header_cache_revalidate (DBusHeader *header) 174 { 175 DBusTypeReader array; 176 DBusTypeReader reader; 177 int i; 178 179 i = 0; 180 while (i <= DBUS_HEADER_FIELD_LAST) 181 { 182 header->fields[i].value_pos = _DBUS_HEADER_FIELD_VALUE_NONEXISTENT; 183 ++i; 184 } 185 186 _dbus_type_reader_init (&reader, 187 header->byte_order, 188 &_dbus_header_signature_str, 189 FIELDS_ARRAY_SIGNATURE_OFFSET, 190 &header->data, 191 FIELDS_ARRAY_LENGTH_OFFSET); 192 193 _dbus_type_reader_recurse (&reader, &array); 194 195 while (_dbus_type_reader_get_current_type (&array) != DBUS_TYPE_INVALID) 196 { 197 DBusTypeReader sub; 198 DBusTypeReader variant; 199 unsigned char field_code; 200 201 _dbus_type_reader_recurse (&array, &sub); 202 203 _dbus_assert (_dbus_type_reader_get_current_type (&sub) == DBUS_TYPE_BYTE); 204 _dbus_type_reader_read_basic (&sub, &field_code); 205 206 /* Unknown fields should be ignored */ 207 if (field_code > DBUS_HEADER_FIELD_LAST) 208 goto next_field; 209 210 _dbus_type_reader_next (&sub); 211 212 _dbus_assert (_dbus_type_reader_get_current_type (&sub) == DBUS_TYPE_VARIANT); 213 _dbus_type_reader_recurse (&sub, &variant); 214 215 _dbus_header_cache_one (header, field_code, &variant); 216 217 next_field: 218 _dbus_type_reader_next (&array); 219 } 220 } 221 222 /** 223 * Checks for a field, updating the cache if required. 224 * 225 * @param header the header 226 * @param field the field to check 227 * @returns #FALSE if the field doesn't exist 228 */ 229 static dbus_bool_t 230 _dbus_header_cache_check (DBusHeader *header, 231 int field) 232 { 233 _dbus_assert (field <= DBUS_HEADER_FIELD_LAST); 234 235 if (header->fields[field].value_pos == _DBUS_HEADER_FIELD_VALUE_UNKNOWN) 236 _dbus_header_cache_revalidate (header); 237 238 if (header->fields[field].value_pos == _DBUS_HEADER_FIELD_VALUE_NONEXISTENT) 239 return FALSE; 240 241 return TRUE; 242 } 243 244 /** 245 * Checks whether a field is known not to exist. It may exist 246 * even if it's not known to exist. 247 * 248 * @param header the header 249 * @param field the field to check 250 * @returns #FALSE if the field definitely doesn't exist 251 */ 252 static dbus_bool_t 253 _dbus_header_cache_known_nonexistent (DBusHeader *header, 254 int field) 255 { 256 _dbus_assert (field <= DBUS_HEADER_FIELD_LAST); 257 258 return (header->fields[field].value_pos == _DBUS_HEADER_FIELD_VALUE_NONEXISTENT); 259 } 260 261 /** 262 * Writes a struct of { byte, variant } with the given basic type. 263 * 264 * @param writer the writer (should be ready to write a struct) 265 * @param type the type of the value 266 * @param value the value as for _dbus_marshal_set_basic() 267 * @returns #FALSE if no memory 268 */ 269 static dbus_bool_t 270 write_basic_field (DBusTypeWriter *writer, 271 int field, 272 int type, 273 const void *value) 274 { 275 DBusTypeWriter sub; 276 DBusTypeWriter variant; 277 int start; 278 int padding; 279 unsigned char field_byte; 280 DBusString contained_type; 281 char buf[2]; 282 283 start = writer->value_pos; 284 padding = _dbus_string_get_length (writer->value_str) - start; 285 286 if (!_dbus_type_writer_recurse (writer, DBUS_TYPE_STRUCT, 287 NULL, 0, &sub)) 288 goto append_failed; 289 290 field_byte = field; 291 if (!_dbus_type_writer_write_basic (&sub, DBUS_TYPE_BYTE, 292 &field_byte)) 293 goto append_failed; 294 295 buf[0] = type; 296 buf[1] = '\0'; 297 _dbus_string_init_const_len (&contained_type, buf, 1); 298 299 if (!_dbus_type_writer_recurse (&sub, DBUS_TYPE_VARIANT, 300 &contained_type, 0, &variant)) 301 goto append_failed; 302 303 if (!_dbus_type_writer_write_basic (&variant, type, value)) 304 goto append_failed; 305 306 if (!_dbus_type_writer_unrecurse (&sub, &variant)) 307 goto append_failed; 308 309 if (!_dbus_type_writer_unrecurse (writer, &sub)) 310 goto append_failed; 311 312 return TRUE; 313 314 append_failed: 315 _dbus_string_delete (writer->value_str, 316 start, 317 _dbus_string_get_length (writer->value_str) - start - padding); 318 return FALSE; 319 } 320 321 /** 322 * Sets a struct of { byte, variant } with the given basic type. 323 * 324 * @param reader the reader (should be iterating over the array pointing at the field to set) 325 * @param type the type of the value 326 * @param value the value as for _dbus_marshal_set_basic() 327 * @param realign_root where to realign from 328 * @returns #FALSE if no memory 329 */ 330 static dbus_bool_t 331 set_basic_field (DBusTypeReader *reader, 332 int field, 333 int type, 334 const void *value, 335 const DBusTypeReader *realign_root) 336 { 337 DBusTypeReader sub; 338 DBusTypeReader variant; 339 340 _dbus_type_reader_recurse (reader, &sub); 341 342 _dbus_assert (_dbus_type_reader_get_current_type (&sub) == DBUS_TYPE_BYTE); 343 #ifndef DBUS_DISABLE_ASSERT 344 { 345 unsigned char v_BYTE; 346 _dbus_type_reader_read_basic (&sub, &v_BYTE); 347 _dbus_assert (((int) v_BYTE) == field); 348 } 349 #endif 350 351 if (!_dbus_type_reader_next (&sub)) 352 _dbus_assert_not_reached ("no variant field?"); 353 354 _dbus_type_reader_recurse (&sub, &variant); 355 _dbus_assert (_dbus_type_reader_get_current_type (&variant) == type); 356 357 if (!_dbus_type_reader_set_basic (&variant, value, realign_root)) 358 return FALSE; 359 360 return TRUE; 361 } 362 363 /** 364 * Gets the type of the message. 365 * 366 * @param header the header 367 * @returns the type 368 */ 369 int 370 _dbus_header_get_message_type (DBusHeader *header) 371 { 372 int type; 373 374 type = _dbus_string_get_byte (&header->data, TYPE_OFFSET); 375 _dbus_assert (type != DBUS_MESSAGE_TYPE_INVALID); 376 377 return type; 378 } 379 380 /** 381 * Sets the serial number of a header. This can only be done once on 382 * a header. 383 * 384 * @param header the header 385 * @param serial the serial 386 */ 387 void 388 _dbus_header_set_serial (DBusHeader *header, 389 dbus_uint32_t serial) 390 { 391 /* we use this function to set the serial on outgoing 392 * messages, and to reset the serial in dbus_message_copy; 393 * this assertion should catch a double-set on outgoing. 394 */ 395 _dbus_assert (_dbus_header_get_serial (header) == 0 || 396 serial == 0); 397 398 _dbus_marshal_set_uint32 (&header->data, 399 SERIAL_OFFSET, 400 serial, 401 header->byte_order); 402 } 403 404 /** 405 * See dbus_message_get_serial() 406 * 407 * @param header the header 408 * @returns the client serial 409 */ 410 dbus_uint32_t 411 _dbus_header_get_serial (DBusHeader *header) 412 { 413 return _dbus_marshal_read_uint32 (&header->data, 414 SERIAL_OFFSET, 415 header->byte_order, 416 NULL); 417 } 418 419 /** 420 * Re-initializes a header that was previously initialized and never 421 * freed. After this, to make the header valid you have to call 422 * _dbus_header_create(). 423 * 424 * @param header header to re-initialize 425 * @param byte_order byte order of the header 426 */ 427 void 428 _dbus_header_reinit (DBusHeader *header, 429 int byte_order) 430 { 431 _dbus_string_set_length (&header->data, 0); 432 433 header->byte_order = byte_order; 434 header->padding = 0; 435 436 _dbus_header_cache_invalidate_all (header); 437 } 438 439 /** 440 * Initializes a header, but doesn't prepare it for use; 441 * to make the header valid, you have to call _dbus_header_create(). 442 * 443 * @param header header to initialize 444 * @param byte_order byte order of the header 445 * @returns #FALSE if not enough memory 446 */ 447 dbus_bool_t 448 _dbus_header_init (DBusHeader *header, 449 int byte_order) 450 { 451 if (!_dbus_string_init_preallocated (&header->data, 32)) 452 return FALSE; 453 454 _dbus_header_reinit (header, byte_order); 455 456 return TRUE; 457 } 458 459 /** 460 * Frees a header. 461 * 462 * @param header the header 463 */ 464 void 465 _dbus_header_free (DBusHeader *header) 466 { 467 _dbus_string_free (&header->data); 468 } 469 470 /** 471 * Initializes dest with a copy of the given header. 472 * Resets the message serial to 0 on the copy. 473 * 474 * @param header header to copy 475 * @param dest destination for copy 476 * @returns #FALSE if not enough memory 477 */ 478 dbus_bool_t 479 _dbus_header_copy (const DBusHeader *header, 480 DBusHeader *dest) 481 { 482 *dest = *header; 483 484 if (!_dbus_string_init_preallocated (&dest->data, 485 _dbus_string_get_length (&header->data))) 486 return FALSE; 487 488 if (!_dbus_string_copy (&header->data, 0, &dest->data, 0)) 489 { 490 _dbus_string_free (&dest->data); 491 return FALSE; 492 } 493 494 /* Reset the serial */ 495 _dbus_header_set_serial (dest, 0); 496 497 return TRUE; 498 } 499 500 /** 501 * Fills in the primary fields of the header, so the header is ready 502 * for use. #NULL may be specified for some or all of the fields to 503 * avoid adding those fields. Some combinations of fields don't make 504 * sense, and passing them in will trigger an assertion failure. 505 * 506 * @param header the header 507 * @param message_type the message type 508 * @param destination destination field or #NULL 509 * @param path path field or #NULL 510 * @param interface interface field or #NULL 511 * @param member member field or #NULL 512 * @param error_name error name or #NULL 513 * @returns #FALSE if not enough memory 514 */ 515 dbus_bool_t 516 _dbus_header_create (DBusHeader *header, 517 int message_type, 518 const char *destination, 519 const char *path, 520 const char *interface, 521 const char *member, 522 const char *error_name) 523 { 524 unsigned char v_BYTE; 525 dbus_uint32_t v_UINT32; 526 DBusTypeWriter writer; 527 DBusTypeWriter array; 528 529 _dbus_assert (((interface || message_type != DBUS_MESSAGE_TYPE_SIGNAL) && member) || 530 (error_name) || 531 !(interface || member || error_name)); 532 _dbus_assert (_dbus_string_get_length (&header->data) == 0); 533 534 if (!reserve_header_padding (header)) 535 return FALSE; 536 537 _dbus_type_writer_init_values_only (&writer, header->byte_order, 538 &_dbus_header_signature_str, 0, 539 &header->data, 540 HEADER_END_BEFORE_PADDING (header)); 541 542 v_BYTE = header->byte_order; 543 if (!_dbus_type_writer_write_basic (&writer, DBUS_TYPE_BYTE, 544 &v_BYTE)) 545 goto oom; 546 547 v_BYTE = message_type; 548 if (!_dbus_type_writer_write_basic (&writer, DBUS_TYPE_BYTE, 549 &v_BYTE)) 550 goto oom; 551 552 v_BYTE = 0; /* flags */ 553 if (!_dbus_type_writer_write_basic (&writer, DBUS_TYPE_BYTE, 554 &v_BYTE)) 555 goto oom; 556 557 v_BYTE = DBUS_MAJOR_PROTOCOL_VERSION; 558 if (!_dbus_type_writer_write_basic (&writer, DBUS_TYPE_BYTE, 559 &v_BYTE)) 560 goto oom; 561 562 v_UINT32 = 0; /* body length */ 563 if (!_dbus_type_writer_write_basic (&writer, DBUS_TYPE_UINT32, 564 &v_UINT32)) 565 goto oom; 566 567 v_UINT32 = 0; /* serial */ 568 if (!_dbus_type_writer_write_basic (&writer, DBUS_TYPE_UINT32, 569 &v_UINT32)) 570 goto oom; 571 572 if (!_dbus_type_writer_recurse (&writer, DBUS_TYPE_ARRAY, 573 &_dbus_header_signature_str, 574 FIELDS_ARRAY_SIGNATURE_OFFSET, 575 &array)) 576 goto oom; 577 578 /* Marshal all the fields (Marshall Fields?) */ 579 580 if (path != NULL) 581 { 582 if (!write_basic_field (&array, 583 DBUS_HEADER_FIELD_PATH, 584 DBUS_TYPE_OBJECT_PATH, 585 &path)) 586 goto oom; 587 } 588 589 if (destination != NULL) 590 { 591 if (!write_basic_field (&array, 592 DBUS_HEADER_FIELD_DESTINATION, 593 DBUS_TYPE_STRING, 594 &destination)) 595 goto oom; 596 } 597 598 if (interface != NULL) 599 { 600 if (!write_basic_field (&array, 601 DBUS_HEADER_FIELD_INTERFACE, 602 DBUS_TYPE_STRING, 603 &interface)) 604 goto oom; 605 } 606 607 if (member != NULL) 608 { 609 if (!write_basic_field (&array, 610 DBUS_HEADER_FIELD_MEMBER, 611 DBUS_TYPE_STRING, 612 &member)) 613 goto oom; 614 } 615 616 if (error_name != NULL) 617 { 618 if (!write_basic_field (&array, 619 DBUS_HEADER_FIELD_ERROR_NAME, 620 DBUS_TYPE_STRING, 621 &error_name)) 622 goto oom; 623 } 624 625 if (!_dbus_type_writer_unrecurse (&writer, &array)) 626 goto oom; 627 628 correct_header_padding (header); 629 630 return TRUE; 631 632 oom: 633 _dbus_string_delete (&header->data, 0, 634 _dbus_string_get_length (&header->data) - header->padding); 635 correct_header_padding (header); 636 637 return FALSE; 638 } 639 640 /** 641 * Given data long enough to contain the length of the message body 642 * and the fields array, check whether the data is long enough to 643 * contain the entire message (assuming the claimed lengths are 644 * accurate). Also checks that the lengths are in sanity parameters. 645 * 646 * @param max_message_length maximum length of a valid message 647 * @param validity return location for why the data is invalid if it is 648 * @param byte_order return location for byte order 649 * @param fields_array_len return location for claimed fields array length 650 * @param header_len return location for claimed header length 651 * @param body_len return location for claimed body length 652 * @param str the data 653 * @param start start of data, 8-aligned 654 * @param len length of data 655 * @returns #TRUE if the data is long enough for the claimed length, and the lengths were valid 656 */ 657 dbus_bool_t 658 _dbus_header_have_message_untrusted (int max_message_length, 659 DBusValidity *validity, 660 int *byte_order, 661 int *fields_array_len, 662 int *header_len, 663 int *body_len, 664 const DBusString *str, 665 int start, 666 int len) 667 668 { 669 dbus_uint32_t header_len_unsigned; 670 dbus_uint32_t fields_array_len_unsigned; 671 dbus_uint32_t body_len_unsigned; 672 673 _dbus_assert (start >= 0); 674 _dbus_assert (start < _DBUS_INT32_MAX / 2); 675 _dbus_assert (len >= 0); 676 677 _dbus_assert (start == (int) _DBUS_ALIGN_VALUE (start, 8)); 678 679 *byte_order = _dbus_string_get_byte (str, start + BYTE_ORDER_OFFSET); 680 681 if (*byte_order != DBUS_LITTLE_ENDIAN && *byte_order != DBUS_BIG_ENDIAN) 682 { 683 *validity = DBUS_INVALID_BAD_BYTE_ORDER; 684 return FALSE; 685 } 686 687 _dbus_assert (FIELDS_ARRAY_LENGTH_OFFSET + 4 <= len); 688 fields_array_len_unsigned = _dbus_marshal_read_uint32 (str, start + FIELDS_ARRAY_LENGTH_OFFSET, 689 *byte_order, NULL); 690 691 if (fields_array_len_unsigned > (unsigned) max_message_length) 692 { 693 *validity = DBUS_INVALID_INSANE_FIELDS_ARRAY_LENGTH; 694 return FALSE; 695 } 696 697 _dbus_assert (BODY_LENGTH_OFFSET + 4 < len); 698 body_len_unsigned = _dbus_marshal_read_uint32 (str, start + BODY_LENGTH_OFFSET, 699 *byte_order, NULL); 700 701 if (body_len_unsigned > (unsigned) max_message_length) 702 { 703 *validity = DBUS_INVALID_INSANE_BODY_LENGTH; 704 return FALSE; 705 } 706 707 header_len_unsigned = FIRST_FIELD_OFFSET + fields_array_len_unsigned; 708 header_len_unsigned = _DBUS_ALIGN_VALUE (header_len_unsigned, 8); 709 710 /* overflow should be impossible since the lengths aren't allowed to 711 * be huge. 712 */ 713 _dbus_assert (max_message_length < _DBUS_INT32_MAX / 2); 714 if (body_len_unsigned + header_len_unsigned > (unsigned) max_message_length) 715 { 716 *validity = DBUS_INVALID_MESSAGE_TOO_LONG; 717 return FALSE; 718 } 719 720 _dbus_assert (body_len_unsigned < (unsigned) _DBUS_INT32_MAX); 721 _dbus_assert (fields_array_len_unsigned < (unsigned) _DBUS_INT32_MAX); 722 _dbus_assert (header_len_unsigned < (unsigned) _DBUS_INT32_MAX); 723 724 *body_len = body_len_unsigned; 725 *fields_array_len = fields_array_len_unsigned; 726 *header_len = header_len_unsigned; 727 728 *validity = DBUS_VALID; 729 730 _dbus_verbose ("have %d bytes, need body %u + header %u = %u\n", 731 len, body_len_unsigned, header_len_unsigned, 732 body_len_unsigned + header_len_unsigned); 733 734 return (body_len_unsigned + header_len_unsigned) <= (unsigned) len; 735 } 736 737 static DBusValidity 738 check_mandatory_fields (DBusHeader *header) 739 { 740 #define REQUIRE_FIELD(name) do { if (header->fields[DBUS_HEADER_FIELD_##name].value_pos < 0) return DBUS_INVALID_MISSING_##name; } while (0) 741 742 switch (_dbus_header_get_message_type (header)) 743 { 744 case DBUS_MESSAGE_TYPE_SIGNAL: 745 REQUIRE_FIELD (INTERFACE); 746 /* FALL THRU - signals also require the path and member */ 747 case DBUS_MESSAGE_TYPE_METHOD_CALL: 748 REQUIRE_FIELD (PATH); 749 REQUIRE_FIELD (MEMBER); 750 break; 751 case DBUS_MESSAGE_TYPE_ERROR: 752 REQUIRE_FIELD (ERROR_NAME); 753 REQUIRE_FIELD (REPLY_SERIAL); 754 break; 755 case DBUS_MESSAGE_TYPE_METHOD_RETURN: 756 REQUIRE_FIELD (REPLY_SERIAL); 757 break; 758 default: 759 /* other message types allowed but ignored */ 760 break; 761 } 762 763 return DBUS_VALID; 764 } 765 766 static DBusValidity 767 load_and_validate_field (DBusHeader *header, 768 int field, 769 DBusTypeReader *variant_reader) 770 { 771 int type; 772 int expected_type; 773 const DBusString *value_str; 774 int value_pos; 775 int str_data_pos; 776 dbus_uint32_t v_UINT32; 777 int bad_string_code; 778 dbus_bool_t (* string_validation_func) (const DBusString *str, 779 int start, int len); 780 781 /* Supposed to have been checked already */ 782 _dbus_assert (field <= DBUS_HEADER_FIELD_LAST); 783 _dbus_assert (field != DBUS_HEADER_FIELD_INVALID); 784 785 /* Before we can cache a field, we need to know it has the right type */ 786 type = _dbus_type_reader_get_current_type (variant_reader); 787 788 _dbus_assert (_dbus_header_field_types[field].code == field); 789 790 expected_type = EXPECTED_TYPE_OF_FIELD (field); 791 if (type != expected_type) 792 { 793 _dbus_verbose ("Field %d should have type %d but has %d\n", 794 field, expected_type, type); 795 return DBUS_INVALID_HEADER_FIELD_HAS_WRONG_TYPE; 796 } 797 798 /* If the field was provided twice, we aren't happy */ 799 if (header->fields[field].value_pos >= 0) 800 { 801 _dbus_verbose ("Header field %d seen a second time\n", field); 802 return DBUS_INVALID_HEADER_FIELD_APPEARS_TWICE; 803 } 804 805 /* Now we can cache and look at the field content */ 806 _dbus_verbose ("initially caching field %d\n", field); 807 _dbus_header_cache_one (header, field, variant_reader); 808 809 string_validation_func = NULL; 810 811 /* make compiler happy that all this is initialized */ 812 v_UINT32 = 0; 813 value_str = NULL; 814 value_pos = -1; 815 str_data_pos = -1; 816 bad_string_code = DBUS_VALID; 817 818 if (expected_type == DBUS_TYPE_UINT32) 819 { 820 _dbus_header_get_field_basic (header, field, expected_type, 821 &v_UINT32); 822 } 823 else if (expected_type == DBUS_TYPE_STRING || 824 expected_type == DBUS_TYPE_OBJECT_PATH || 825 expected_type == DBUS_TYPE_SIGNATURE) 826 { 827 _dbus_header_get_field_raw (header, field, 828 &value_str, &value_pos); 829 str_data_pos = _DBUS_ALIGN_VALUE (value_pos, 4) + 4; 830 } 831 else 832 { 833 _dbus_assert_not_reached ("none of the known fields should have this type"); 834 } 835 836 switch (field) 837 { 838 case DBUS_HEADER_FIELD_DESTINATION: 839 string_validation_func = _dbus_validate_bus_name; 840 bad_string_code = DBUS_INVALID_BAD_DESTINATION; 841 break; 842 case DBUS_HEADER_FIELD_INTERFACE: 843 string_validation_func = _dbus_validate_interface; 844 bad_string_code = DBUS_INVALID_BAD_INTERFACE; 845 846 if (_dbus_string_equal_substring (&_dbus_local_interface_str, 847 0, 848 _dbus_string_get_length (&_dbus_local_interface_str), 849 value_str, str_data_pos)) 850 { 851 _dbus_verbose ("Message is on the local interface\n"); 852 return DBUS_INVALID_USES_LOCAL_INTERFACE; 853 } 854 break; 855 856 case DBUS_HEADER_FIELD_MEMBER: 857 string_validation_func = _dbus_validate_member; 858 bad_string_code = DBUS_INVALID_BAD_MEMBER; 859 break; 860 861 case DBUS_HEADER_FIELD_ERROR_NAME: 862 string_validation_func = _dbus_validate_error_name; 863 bad_string_code = DBUS_INVALID_BAD_ERROR_NAME; 864 break; 865 866 case DBUS_HEADER_FIELD_SENDER: 867 string_validation_func = _dbus_validate_bus_name; 868 bad_string_code = DBUS_INVALID_BAD_SENDER; 869 break; 870 871 case DBUS_HEADER_FIELD_PATH: 872 /* OBJECT_PATH was validated generically due to its type */ 873 string_validation_func = NULL; 874 875 if (_dbus_string_equal_substring (&_dbus_local_path_str, 876 0, 877 _dbus_string_get_length (&_dbus_local_path_str), 878 value_str, str_data_pos)) 879 { 880 _dbus_verbose ("Message is from the local path\n"); 881 return DBUS_INVALID_USES_LOCAL_PATH; 882 } 883 break; 884 885 case DBUS_HEADER_FIELD_REPLY_SERIAL: 886 /* Can't be 0 */ 887 if (v_UINT32 == 0) 888 { 889 return DBUS_INVALID_BAD_SERIAL; 890 } 891 break; 892 893 case DBUS_HEADER_FIELD_UNIX_FDS: 894 /* Every value makes sense */ 895 break; 896 897 case DBUS_HEADER_FIELD_SIGNATURE: 898 /* SIGNATURE validated generically due to its type */ 899 string_validation_func = NULL; 900 break; 901 902 default: 903 _dbus_assert_not_reached ("unknown field shouldn't be seen here"); 904 break; 905 } 906 907 if (string_validation_func) 908 { 909 dbus_uint32_t len; 910 911 _dbus_assert (bad_string_code != DBUS_VALID); 912 913 len = _dbus_marshal_read_uint32 (value_str, value_pos, 914 header->byte_order, NULL); 915 916 #if 0 917 _dbus_verbose ("Validating string header field; code %d if fails\n", 918 bad_string_code); 919 #endif 920 if (!(*string_validation_func) (value_str, str_data_pos, len)) 921 return bad_string_code; 922 } 923 924 return DBUS_VALID; 925 } 926 927 /** 928 * Creates a message header from potentially-untrusted data. The 929 * return value is #TRUE if there was enough memory and the data was 930 * valid. If it returns #TRUE, the header will be created. If it 931 * returns #FALSE and *validity == #DBUS_VALIDITY_UNKNOWN_OOM_ERROR, 932 * then there wasn't enough memory. If it returns #FALSE 933 * and *validity != #DBUS_VALIDITY_UNKNOWN_OOM_ERROR then the data was 934 * invalid. 935 * 936 * The byte_order, fields_array_len, and body_len args should be from 937 * _dbus_header_have_message_untrusted(). Validation performed in 938 * _dbus_header_have_message_untrusted() is assumed to have been 939 * already done. 940 * 941 * @param header the header (must be initialized) 942 * @param mode whether to do validation 943 * @param validity return location for invalidity reason 944 * @param byte_order byte order from header 945 * @param fields_array_len claimed length of fields array 946 * @param body_len claimed length of body 947 * @param header_len claimed length of header 948 * @param str a string 949 * @param start start of header, 8-aligned 950 * @param len length of string to look at 951 * @returns #FALSE if no memory or data was invalid, #TRUE otherwise 952 */ 953 dbus_bool_t 954 _dbus_header_load (DBusHeader *header, 955 DBusValidationMode mode, 956 DBusValidity *validity, 957 int byte_order, 958 int fields_array_len, 959 int header_len, 960 int body_len, 961 const DBusString *str, 962 int start, 963 int len) 964 { 965 int leftover; 966 DBusValidity v; 967 DBusTypeReader reader; 968 DBusTypeReader array_reader; 969 unsigned char v_byte; 970 dbus_uint32_t v_uint32; 971 dbus_uint32_t serial; 972 int padding_start; 973 int padding_len; 974 int i; 975 976 _dbus_assert (start == (int) _DBUS_ALIGN_VALUE (start, 8)); 977 _dbus_assert (header_len <= len); 978 _dbus_assert (_dbus_string_get_length (&header->data) == 0); 979 980 if (!_dbus_string_copy_len (str, start, header_len, &header->data, 0)) 981 { 982 _dbus_verbose ("Failed to copy buffer into new header\n"); 983 *validity = DBUS_VALIDITY_UNKNOWN_OOM_ERROR; 984 return FALSE; 985 } 986 987 if (mode == DBUS_VALIDATION_MODE_WE_TRUST_THIS_DATA_ABSOLUTELY) 988 { 989 leftover = len - header_len - body_len - start; 990 } 991 else 992 { 993 v = _dbus_validate_body_with_reason (&_dbus_header_signature_str, 0, 994 byte_order, 995 &leftover, 996 str, start, len); 997 998 if (v != DBUS_VALID) 999 { 1000 *validity = v; 1001 goto invalid; 1002 } 1003 } 1004 1005 _dbus_assert (leftover < len); 1006 1007 padding_len = header_len - (FIRST_FIELD_OFFSET + fields_array_len); 1008 padding_start = start + FIRST_FIELD_OFFSET + fields_array_len; 1009 _dbus_assert (start + header_len == (int) _DBUS_ALIGN_VALUE (padding_start, 8)); 1010 _dbus_assert (start + header_len == padding_start + padding_len); 1011 1012 if (mode != DBUS_VALIDATION_MODE_WE_TRUST_THIS_DATA_ABSOLUTELY) 1013 { 1014 if (!_dbus_string_validate_nul (str, padding_start, padding_len)) 1015 { 1016 *validity = DBUS_INVALID_ALIGNMENT_PADDING_NOT_NUL; 1017 goto invalid; 1018 } 1019 } 1020 1021 header->padding = padding_len; 1022 1023 if (mode == DBUS_VALIDATION_MODE_WE_TRUST_THIS_DATA_ABSOLUTELY) 1024 { 1025 *validity = DBUS_VALID; 1026 return TRUE; 1027 } 1028 1029 /* We now know the data is well-formed, but we have to check that 1030 * it's valid. 1031 */ 1032 1033 _dbus_type_reader_init (&reader, 1034 byte_order, 1035 &_dbus_header_signature_str, 0, 1036 str, start); 1037 1038 /* BYTE ORDER */ 1039 _dbus_assert (_dbus_type_reader_get_current_type (&reader) == DBUS_TYPE_BYTE); 1040 _dbus_assert (_dbus_type_reader_get_value_pos (&reader) == BYTE_ORDER_OFFSET); 1041 _dbus_type_reader_read_basic (&reader, &v_byte); 1042 _dbus_type_reader_next (&reader); 1043 1044 _dbus_assert (v_byte == byte_order); 1045 header->byte_order = byte_order; 1046 1047 /* MESSAGE TYPE */ 1048 _dbus_assert (_dbus_type_reader_get_current_type (&reader) == DBUS_TYPE_BYTE); 1049 _dbus_assert (_dbus_type_reader_get_value_pos (&reader) == TYPE_OFFSET); 1050 _dbus_type_reader_read_basic (&reader, &v_byte); 1051 _dbus_type_reader_next (&reader); 1052 1053 /* unknown message types are supposed to be ignored, so only validation here is 1054 * that it isn't invalid 1055 */ 1056 if (v_byte == DBUS_MESSAGE_TYPE_INVALID) 1057 { 1058 *validity = DBUS_INVALID_BAD_MESSAGE_TYPE; 1059 goto invalid; 1060 } 1061 1062 /* FLAGS */ 1063 _dbus_assert (_dbus_type_reader_get_current_type (&reader) == DBUS_TYPE_BYTE); 1064 _dbus_assert (_dbus_type_reader_get_value_pos (&reader) == FLAGS_OFFSET); 1065 _dbus_type_reader_read_basic (&reader, &v_byte); 1066 _dbus_type_reader_next (&reader); 1067 1068 /* unknown flags should be ignored */ 1069 1070 /* PROTOCOL VERSION */ 1071 _dbus_assert (_dbus_type_reader_get_current_type (&reader) == DBUS_TYPE_BYTE); 1072 _dbus_assert (_dbus_type_reader_get_value_pos (&reader) == VERSION_OFFSET); 1073 _dbus_type_reader_read_basic (&reader, &v_byte); 1074 _dbus_type_reader_next (&reader); 1075 1076 if (v_byte != DBUS_MAJOR_PROTOCOL_VERSION) 1077 { 1078 *validity = DBUS_INVALID_BAD_PROTOCOL_VERSION; 1079 goto invalid; 1080 } 1081 1082 /* BODY LENGTH */ 1083 _dbus_assert (_dbus_type_reader_get_current_type (&reader) == DBUS_TYPE_UINT32); 1084 _dbus_assert (_dbus_type_reader_get_value_pos (&reader) == BODY_LENGTH_OFFSET); 1085 _dbus_type_reader_read_basic (&reader, &v_uint32); 1086 _dbus_type_reader_next (&reader); 1087 1088 _dbus_assert (body_len == (signed) v_uint32); 1089 1090 /* SERIAL */ 1091 _dbus_assert (_dbus_type_reader_get_current_type (&reader) == DBUS_TYPE_UINT32); 1092 _dbus_assert (_dbus_type_reader_get_value_pos (&reader) == SERIAL_OFFSET); 1093 _dbus_type_reader_read_basic (&reader, &serial); 1094 _dbus_type_reader_next (&reader); 1095 1096 if (serial == 0) 1097 { 1098 *validity = DBUS_INVALID_BAD_SERIAL; 1099 goto invalid; 1100 } 1101 1102 _dbus_assert (_dbus_type_reader_get_current_type (&reader) == DBUS_TYPE_ARRAY); 1103 _dbus_assert (_dbus_type_reader_get_value_pos (&reader) == FIELDS_ARRAY_LENGTH_OFFSET); 1104 1105 _dbus_type_reader_recurse (&reader, &array_reader); 1106 while (_dbus_type_reader_get_current_type (&array_reader) != DBUS_TYPE_INVALID) 1107 { 1108 DBusTypeReader struct_reader; 1109 DBusTypeReader variant_reader; 1110 unsigned char field_code; 1111 1112 _dbus_assert (_dbus_type_reader_get_current_type (&array_reader) == DBUS_TYPE_STRUCT); 1113 1114 _dbus_type_reader_recurse (&array_reader, &struct_reader); 1115 1116 _dbus_assert (_dbus_type_reader_get_current_type (&struct_reader) == DBUS_TYPE_BYTE); 1117 _dbus_type_reader_read_basic (&struct_reader, &field_code); 1118 _dbus_type_reader_next (&struct_reader); 1119 1120 if (field_code == DBUS_HEADER_FIELD_INVALID) 1121 { 1122 _dbus_verbose ("invalid header field code\n"); 1123 *validity = DBUS_INVALID_HEADER_FIELD_CODE; 1124 goto invalid; 1125 } 1126 1127 if (field_code > DBUS_HEADER_FIELD_LAST) 1128 { 1129 _dbus_verbose ("unknown header field code %d, skipping\n", 1130 field_code); 1131 goto next_field; 1132 } 1133 1134 _dbus_assert (_dbus_type_reader_get_current_type (&struct_reader) == DBUS_TYPE_VARIANT); 1135 _dbus_type_reader_recurse (&struct_reader, &variant_reader); 1136 1137 v = load_and_validate_field (header, field_code, &variant_reader); 1138 if (v != DBUS_VALID) 1139 { 1140 _dbus_verbose ("Field %d was invalid\n", field_code); 1141 *validity = v; 1142 goto invalid; 1143 } 1144 1145 next_field: 1146 _dbus_type_reader_next (&array_reader); 1147 } 1148 1149 /* Anything we didn't fill in is now known not to exist */ 1150 i = 0; 1151 while (i <= DBUS_HEADER_FIELD_LAST) 1152 { 1153 if (header->fields[i].value_pos == _DBUS_HEADER_FIELD_VALUE_UNKNOWN) 1154 header->fields[i].value_pos = _DBUS_HEADER_FIELD_VALUE_NONEXISTENT; 1155 ++i; 1156 } 1157 1158 v = check_mandatory_fields (header); 1159 if (v != DBUS_VALID) 1160 { 1161 _dbus_verbose ("Mandatory fields were missing, code %d\n", v); 1162 *validity = v; 1163 goto invalid; 1164 } 1165 1166 *validity = DBUS_VALID; 1167 return TRUE; 1168 1169 invalid: 1170 _dbus_string_set_length (&header->data, 0); 1171 return FALSE; 1172 } 1173 1174 /** 1175 * Fills in the correct body length. 1176 * 1177 * @param header the header 1178 * @param body_len the length of the body 1179 */ 1180 void 1181 _dbus_header_update_lengths (DBusHeader *header, 1182 int body_len) 1183 { 1184 _dbus_marshal_set_uint32 (&header->data, 1185 BODY_LENGTH_OFFSET, 1186 body_len, 1187 header->byte_order); 1188 } 1189 1190 static dbus_bool_t 1191 find_field_for_modification (DBusHeader *header, 1192 int field, 1193 DBusTypeReader *reader, 1194 DBusTypeReader *realign_root) 1195 { 1196 dbus_bool_t retval; 1197 1198 retval = FALSE; 1199 1200 _dbus_type_reader_init (realign_root, 1201 header->byte_order, 1202 &_dbus_header_signature_str, 1203 FIELDS_ARRAY_SIGNATURE_OFFSET, 1204 &header->data, 1205 FIELDS_ARRAY_LENGTH_OFFSET); 1206 1207 _dbus_type_reader_recurse (realign_root, reader); 1208 1209 while (_dbus_type_reader_get_current_type (reader) != DBUS_TYPE_INVALID) 1210 { 1211 DBusTypeReader sub; 1212 unsigned char field_code; 1213 1214 _dbus_type_reader_recurse (reader, &sub); 1215 1216 _dbus_assert (_dbus_type_reader_get_current_type (&sub) == DBUS_TYPE_BYTE); 1217 _dbus_type_reader_read_basic (&sub, &field_code); 1218 1219 if (field_code == (unsigned) field) 1220 { 1221 _dbus_assert (_dbus_type_reader_get_current_type (reader) == DBUS_TYPE_STRUCT); 1222 retval = TRUE; 1223 goto done; 1224 } 1225 1226 _dbus_type_reader_next (reader); 1227 } 1228 1229 done: 1230 return retval; 1231 } 1232 1233 /** 1234 * Sets the value of a field with basic type. If the value is a string 1235 * value, it isn't allowed to be #NULL. If the field doesn't exist, 1236 * it will be created. 1237 * 1238 * @param header the header 1239 * @param field the field to set 1240 * @param type the type of the value 1241 * @param value the value as for _dbus_marshal_set_basic() 1242 * @returns #FALSE if no memory 1243 */ 1244 dbus_bool_t 1245 _dbus_header_set_field_basic (DBusHeader *header, 1246 int field, 1247 int type, 1248 const void *value) 1249 { 1250 _dbus_assert (field <= DBUS_HEADER_FIELD_LAST); 1251 1252 if (!reserve_header_padding (header)) 1253 return FALSE; 1254 1255 /* If the field exists we set, otherwise we append */ 1256 if (_dbus_header_cache_check (header, field)) 1257 { 1258 DBusTypeReader reader; 1259 DBusTypeReader realign_root; 1260 1261 if (!find_field_for_modification (header, field, 1262 &reader, &realign_root)) 1263 _dbus_assert_not_reached ("field was marked present in cache but wasn't found"); 1264 1265 if (!set_basic_field (&reader, field, type, value, &realign_root)) 1266 return FALSE; 1267 } 1268 else 1269 { 1270 DBusTypeWriter writer; 1271 DBusTypeWriter array; 1272 1273 _dbus_type_writer_init_values_only (&writer, 1274 header->byte_order, 1275 &_dbus_header_signature_str, 1276 FIELDS_ARRAY_SIGNATURE_OFFSET, 1277 &header->data, 1278 FIELDS_ARRAY_LENGTH_OFFSET); 1279 1280 /* recurse into array without creating a new length, and jump to 1281 * end of array. 1282 */ 1283 if (!_dbus_type_writer_append_array (&writer, 1284 &_dbus_header_signature_str, 1285 FIELDS_ARRAY_ELEMENT_SIGNATURE_OFFSET, 1286 &array)) 1287 _dbus_assert_not_reached ("recurse into ARRAY should not have used memory"); 1288 1289 _dbus_assert (array.u.array.len_pos == FIELDS_ARRAY_LENGTH_OFFSET); 1290 _dbus_assert (array.u.array.start_pos == FIRST_FIELD_OFFSET); 1291 _dbus_assert (array.value_pos == HEADER_END_BEFORE_PADDING (header)); 1292 1293 if (!write_basic_field (&array, 1294 field, type, value)) 1295 return FALSE; 1296 1297 if (!_dbus_type_writer_unrecurse (&writer, &array)) 1298 _dbus_assert_not_reached ("unrecurse from ARRAY should not have used memory"); 1299 } 1300 1301 correct_header_padding (header); 1302 1303 /* We could be smarter about this (only invalidate fields after the 1304 * one we modified, or even only if the one we modified changed 1305 * length). But this hack is a start. 1306 */ 1307 _dbus_header_cache_invalidate_all (header); 1308 1309 return TRUE; 1310 } 1311 1312 /** 1313 * Gets the value of a field with basic type. If the field 1314 * doesn't exist, returns #FALSE, otherwise returns #TRUE. 1315 * 1316 * @param header the header 1317 * @param field the field to get 1318 * @param type the type of the value 1319 * @param value the value as for _dbus_marshal_read_basic() 1320 * @returns #FALSE if the field doesn't exist 1321 */ 1322 dbus_bool_t 1323 _dbus_header_get_field_basic (DBusHeader *header, 1324 int field, 1325 int type, 1326 void *value) 1327 { 1328 _dbus_assert (field != DBUS_HEADER_FIELD_INVALID); 1329 _dbus_assert (field <= DBUS_HEADER_FIELD_LAST); 1330 _dbus_assert (_dbus_header_field_types[field].code == field); 1331 /* in light of this you might ask why the type is passed in; 1332 * the only rationale I can think of is so the caller has 1333 * to specify its expectation and breaks if we change it 1334 */ 1335 _dbus_assert (type == EXPECTED_TYPE_OF_FIELD (field)); 1336 1337 if (!_dbus_header_cache_check (header, field)) 1338 return FALSE; 1339 1340 _dbus_assert (header->fields[field].value_pos >= 0); 1341 1342 _dbus_marshal_read_basic (&header->data, 1343 header->fields[field].value_pos, 1344 type, value, header->byte_order, 1345 NULL); 1346 1347 return TRUE; 1348 } 1349 1350 /** 1351 * Gets the raw marshaled data for a field. If the field doesn't 1352 * exist, returns #FALSE, otherwise returns #TRUE. Returns the start 1353 * of the marshaled data, i.e. usually the byte where the length 1354 * starts (for strings and arrays) or for basic types just the value 1355 * itself. 1356 * 1357 * @param header the header 1358 * @param field the field to get 1359 * @param str return location for the data string 1360 * @param pos return location for start of field value 1361 * @returns #FALSE if the field doesn't exist 1362 */ 1363 dbus_bool_t 1364 _dbus_header_get_field_raw (DBusHeader *header, 1365 int field, 1366 const DBusString **str, 1367 int *pos) 1368 { 1369 if (!_dbus_header_cache_check (header, field)) 1370 return FALSE; 1371 1372 if (str) 1373 *str = &header->data; 1374 if (pos) 1375 *pos = header->fields[field].value_pos; 1376 1377 return TRUE; 1378 } 1379 1380 /** 1381 * Deletes a field, if it exists. 1382 * 1383 * @param header the header 1384 * @param field the field to delete 1385 * @returns #FALSE if no memory 1386 */ 1387 dbus_bool_t 1388 _dbus_header_delete_field (DBusHeader *header, 1389 int field) 1390 { 1391 DBusTypeReader reader; 1392 DBusTypeReader realign_root; 1393 1394 if (_dbus_header_cache_known_nonexistent (header, field)) 1395 return TRUE; /* nothing to do */ 1396 1397 /* Scan to the field we want, delete and realign, reappend 1398 * padding. Field may turn out not to exist. 1399 */ 1400 if (!find_field_for_modification (header, field, 1401 &reader, &realign_root)) 1402 return TRUE; /* nothing to do */ 1403 1404 if (!reserve_header_padding (header)) 1405 return FALSE; 1406 1407 if (!_dbus_type_reader_delete (&reader, 1408 &realign_root)) 1409 return FALSE; 1410 1411 correct_header_padding (header); 1412 1413 _dbus_header_cache_invalidate_all (header); 1414 1415 _dbus_assert (!_dbus_header_cache_check (header, field)); /* Expensive assertion ... */ 1416 1417 return TRUE; 1418 } 1419 1420 /** 1421 * Toggles a message flag bit, turning on the bit if value = TRUE and 1422 * flipping it off if value = FALSE. 1423 * 1424 * @param header the header 1425 * @param flag the message flag to toggle 1426 * @param value toggle on or off 1427 */ 1428 void 1429 _dbus_header_toggle_flag (DBusHeader *header, 1430 dbus_uint32_t flag, 1431 dbus_bool_t value) 1432 { 1433 unsigned char *flags_p; 1434 1435 flags_p = _dbus_string_get_data_len (&header->data, FLAGS_OFFSET, 1); 1436 1437 if (value) 1438 *flags_p |= flag; 1439 else 1440 *flags_p &= ~flag; 1441 } 1442 1443 /** 1444 * Gets a message flag bit, returning TRUE if the bit is set. 1445 * 1446 * @param header the header 1447 * @param flag the message flag to get 1448 * @returns #TRUE if the flag is set 1449 */ 1450 dbus_bool_t 1451 _dbus_header_get_flag (DBusHeader *header, 1452 dbus_uint32_t flag) 1453 { 1454 const unsigned char *flags_p; 1455 1456 flags_p = _dbus_string_get_const_data_len (&header->data, FLAGS_OFFSET, 1); 1457 1458 return (*flags_p & flag) != 0; 1459 } 1460 1461 /** 1462 * Swaps the header into the given order if required. 1463 * 1464 * @param header the header 1465 * @param new_order the new byte order 1466 */ 1467 void 1468 _dbus_header_byteswap (DBusHeader *header, 1469 int new_order) 1470 { 1471 if (header->byte_order == new_order) 1472 return; 1473 1474 _dbus_marshal_byteswap (&_dbus_header_signature_str, 1475 0, header->byte_order, 1476 new_order, 1477 &header->data, 0); 1478 1479 header->byte_order = new_order; 1480 } 1481 1482 /** @} */ 1483 1484 #ifdef DBUS_BUILD_TESTS 1485 #include "dbus-test.h" 1486 #include <stdio.h> 1487 1488 dbus_bool_t 1489 _dbus_marshal_header_test (void) 1490 { 1491 1492 return TRUE; 1493 } 1494 1495 #endif /* DBUS_BUILD_TESTS */ 1496
