1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #include "dbus/message.h" 6 7 #include <string> 8 9 #include "base/basictypes.h" 10 #include "base/format_macros.h" 11 #include "base/logging.h" 12 #include "base/strings/string_util.h" 13 #include "base/strings/stringprintf.h" 14 #include "dbus/object_path.h" 15 16 #if defined(USE_SYSTEM_PROTOBUF) 17 #include <google/protobuf/message_lite.h> 18 #else 19 #include "third_party/protobuf/src/google/protobuf/message_lite.h" 20 #endif 21 22 namespace { 23 24 // Appends the header name and the value to |output|, if the value is 25 // not empty. 26 void AppendStringHeader(const std::string& header_name, 27 const std::string& header_value, 28 std::string* output) { 29 if (!header_value.empty()) { 30 *output += header_name + ": " + header_value + "\n"; 31 } 32 } 33 34 // Appends the header name and the value to |output|, if the value is 35 // nonzero. 36 void AppendUint32Header(const std::string& header_name, 37 uint32 header_value, 38 std::string* output) { 39 if (header_value != 0) { 40 *output += (header_name + ": " + base::StringPrintf("%u", header_value) + 41 "\n"); 42 } 43 } 44 45 } // namespace 46 47 namespace dbus { 48 49 bool IsDBusTypeUnixFdSupported() { 50 int major = 0, minor = 0, micro = 0; 51 dbus_get_version(&major, &minor, µ); 52 return major >= 1 && minor >= 4; 53 } 54 55 Message::Message() 56 : raw_message_(NULL) { 57 } 58 59 Message::~Message() { 60 if (raw_message_) 61 dbus_message_unref(raw_message_); 62 } 63 64 void Message::Init(DBusMessage* raw_message) { 65 DCHECK(!raw_message_); 66 raw_message_ = raw_message; 67 } 68 69 Message::MessageType Message::GetMessageType() { 70 if (!raw_message_) 71 return MESSAGE_INVALID; 72 const int type = dbus_message_get_type(raw_message_); 73 return static_cast<Message::MessageType>(type); 74 } 75 76 std::string Message::GetMessageTypeAsString() { 77 switch (GetMessageType()) { 78 case MESSAGE_INVALID: 79 return "MESSAGE_INVALID"; 80 case MESSAGE_METHOD_CALL: 81 return "MESSAGE_METHOD_CALL"; 82 case MESSAGE_METHOD_RETURN: 83 return "MESSAGE_METHOD_RETURN"; 84 case MESSAGE_SIGNAL: 85 return "MESSAGE_SIGNAL"; 86 case MESSAGE_ERROR: 87 return "MESSAGE_ERROR"; 88 } 89 NOTREACHED(); 90 return std::string(); 91 } 92 93 std::string Message::ToStringInternal(const std::string& indent, 94 MessageReader* reader) { 95 const char* kBrokenMessage = "[broken message]"; 96 std::string output; 97 while (reader->HasMoreData()) { 98 const DataType type = reader->GetDataType(); 99 switch (type) { 100 case BYTE: { 101 uint8 value = 0; 102 if (!reader->PopByte(&value)) 103 return kBrokenMessage; 104 output += indent + "byte " + base::StringPrintf("%d", value) + "\n"; 105 break; 106 } 107 case BOOL: { 108 bool value = false; 109 if (!reader->PopBool(&value)) 110 return kBrokenMessage; 111 output += indent + "bool " + (value ? "true" : "false") + "\n"; 112 break; 113 } 114 case INT16: { 115 int16 value = 0; 116 if (!reader->PopInt16(&value)) 117 return kBrokenMessage; 118 output += indent + "int16 " + base::StringPrintf("%d", value) + "\n"; 119 break; 120 } 121 case UINT16: { 122 uint16 value = 0; 123 if (!reader->PopUint16(&value)) 124 return kBrokenMessage; 125 output += indent + "uint16 " + base::StringPrintf("%d", value) + "\n"; 126 break; 127 } 128 case INT32: { 129 int32 value = 0; 130 if (!reader->PopInt32(&value)) 131 return kBrokenMessage; 132 output += indent + "int32 " + base::StringPrintf("%d", value) + "\n"; 133 break; 134 } 135 case UINT32: { 136 uint32 value = 0; 137 if (!reader->PopUint32(&value)) 138 return kBrokenMessage; 139 output += indent + "uint32 " + base::StringPrintf("%u", value) + "\n"; 140 break; 141 } 142 case INT64: { 143 int64 value = 0; 144 if (!reader->PopInt64(&value)) 145 return kBrokenMessage; 146 output += (indent + "int64 " + 147 base::StringPrintf("%" PRId64, value) + "\n"); 148 break; 149 } 150 case UINT64: { 151 uint64 value = 0; 152 if (!reader->PopUint64(&value)) 153 return kBrokenMessage; 154 output += (indent + "uint64 " + 155 base::StringPrintf("%" PRIu64, value) + "\n"); 156 break; 157 } 158 case DOUBLE: { 159 double value = 0; 160 if (!reader->PopDouble(&value)) 161 return kBrokenMessage; 162 output += indent + "double " + base::StringPrintf("%f", value) + "\n"; 163 break; 164 } 165 case STRING: { 166 std::string value; 167 if (!reader->PopString(&value)) 168 return kBrokenMessage; 169 // Truncate if the string is longer than the limit. 170 const size_t kTruncateLength = 100; 171 if (value.size() < kTruncateLength) { 172 output += indent + "string \"" + value + "\"\n"; 173 } else { 174 std::string truncated; 175 base::TruncateUTF8ToByteSize(value, kTruncateLength, &truncated); 176 base::StringAppendF(&truncated, "... (%" PRIuS " bytes in total)", 177 value.size()); 178 output += indent + "string \"" + truncated + "\"\n"; 179 } 180 break; 181 } 182 case OBJECT_PATH: { 183 ObjectPath value; 184 if (!reader->PopObjectPath(&value)) 185 return kBrokenMessage; 186 output += indent + "object_path \"" + value.value() + "\"\n"; 187 break; 188 } 189 case ARRAY: { 190 MessageReader sub_reader(this); 191 if (!reader->PopArray(&sub_reader)) 192 return kBrokenMessage; 193 output += indent + "array [\n"; 194 output += ToStringInternal(indent + " ", &sub_reader); 195 output += indent + "]\n"; 196 break; 197 } 198 case STRUCT: { 199 MessageReader sub_reader(this); 200 if (!reader->PopStruct(&sub_reader)) 201 return kBrokenMessage; 202 output += indent + "struct {\n"; 203 output += ToStringInternal(indent + " ", &sub_reader); 204 output += indent + "}\n"; 205 break; 206 } 207 case DICT_ENTRY: { 208 MessageReader sub_reader(this); 209 if (!reader->PopDictEntry(&sub_reader)) 210 return kBrokenMessage; 211 output += indent + "dict entry {\n"; 212 output += ToStringInternal(indent + " ", &sub_reader); 213 output += indent + "}\n"; 214 break; 215 } 216 case VARIANT: { 217 MessageReader sub_reader(this); 218 if (!reader->PopVariant(&sub_reader)) 219 return kBrokenMessage; 220 output += indent + "variant "; 221 output += ToStringInternal(indent + " ", &sub_reader); 222 break; 223 } 224 case UNIX_FD: { 225 CHECK(IsDBusTypeUnixFdSupported()); 226 227 FileDescriptor file_descriptor; 228 if (!reader->PopFileDescriptor(&file_descriptor)) 229 return kBrokenMessage; 230 output += indent + "fd#" + 231 base::StringPrintf("%d", file_descriptor.value()) + "\n"; 232 break; 233 } 234 default: 235 LOG(FATAL) << "Unknown type: " << type; 236 } 237 } 238 return output; 239 } 240 241 // The returned string consists of message headers such as 242 // destination if any, followed by a blank line, and the message 243 // payload. For example, a MethodCall's ToString() will look like: 244 // 245 // destination: com.example.Service 246 // path: /com/example/Object 247 // interface: com.example.Interface 248 // member: SomeMethod 249 // 250 // string \"payload\" 251 // ... 252 std::string Message::ToString() { 253 if (!raw_message_) 254 return std::string(); 255 256 // Generate headers first. 257 std::string headers; 258 AppendStringHeader("message_type", GetMessageTypeAsString(), &headers); 259 AppendStringHeader("destination", GetDestination(), &headers); 260 AppendStringHeader("path", GetPath().value(), &headers); 261 AppendStringHeader("interface", GetInterface(), &headers); 262 AppendStringHeader("member", GetMember(), &headers); 263 AppendStringHeader("error_name", GetErrorName(), &headers); 264 AppendStringHeader("sender", GetSender(), &headers); 265 AppendStringHeader("signature", GetSignature(), &headers); 266 AppendUint32Header("serial", GetSerial(), &headers); 267 AppendUint32Header("reply_serial", GetReplySerial(), &headers); 268 269 // Generate the payload. 270 MessageReader reader(this); 271 return headers + "\n" + ToStringInternal(std::string(), &reader); 272 } 273 274 bool Message::SetDestination(const std::string& destination) { 275 return dbus_message_set_destination(raw_message_, destination.c_str()); 276 } 277 278 bool Message::SetPath(const ObjectPath& path) { 279 return dbus_message_set_path(raw_message_, path.value().c_str()); 280 } 281 282 bool Message::SetInterface(const std::string& interface) { 283 return dbus_message_set_interface(raw_message_, interface.c_str()); 284 } 285 286 bool Message::SetMember(const std::string& member) { 287 return dbus_message_set_member(raw_message_, member.c_str()); 288 } 289 290 bool Message::SetErrorName(const std::string& error_name) { 291 return dbus_message_set_error_name(raw_message_, error_name.c_str()); 292 } 293 294 bool Message::SetSender(const std::string& sender) { 295 return dbus_message_set_sender(raw_message_, sender.c_str()); 296 } 297 298 void Message::SetSerial(uint32 serial) { 299 dbus_message_set_serial(raw_message_, serial); 300 } 301 302 void Message::SetReplySerial(uint32 reply_serial) { 303 dbus_message_set_reply_serial(raw_message_, reply_serial); 304 } 305 306 std::string Message::GetDestination() { 307 const char* destination = dbus_message_get_destination(raw_message_); 308 return destination ? destination : ""; 309 } 310 311 ObjectPath Message::GetPath() { 312 const char* path = dbus_message_get_path(raw_message_); 313 return ObjectPath(path ? path : ""); 314 } 315 316 std::string Message::GetInterface() { 317 const char* interface = dbus_message_get_interface(raw_message_); 318 return interface ? interface : ""; 319 } 320 321 std::string Message::GetMember() { 322 const char* member = dbus_message_get_member(raw_message_); 323 return member ? member : ""; 324 } 325 326 std::string Message::GetErrorName() { 327 const char* error_name = dbus_message_get_error_name(raw_message_); 328 return error_name ? error_name : ""; 329 } 330 331 std::string Message::GetSender() { 332 const char* sender = dbus_message_get_sender(raw_message_); 333 return sender ? sender : ""; 334 } 335 336 std::string Message::GetSignature() { 337 const char* signature = dbus_message_get_signature(raw_message_); 338 return signature ? signature : ""; 339 } 340 341 uint32 Message::GetSerial() { 342 return dbus_message_get_serial(raw_message_); 343 } 344 345 uint32 Message::GetReplySerial() { 346 return dbus_message_get_reply_serial(raw_message_); 347 } 348 349 // 350 // MethodCall implementation. 351 // 352 353 MethodCall::MethodCall(const std::string& interface_name, 354 const std::string& method_name) 355 : Message() { 356 Init(dbus_message_new(DBUS_MESSAGE_TYPE_METHOD_CALL)); 357 358 CHECK(SetInterface(interface_name)); 359 CHECK(SetMember(method_name)); 360 } 361 362 MethodCall::MethodCall() : Message() { 363 } 364 365 MethodCall* MethodCall::FromRawMessage(DBusMessage* raw_message) { 366 DCHECK_EQ(DBUS_MESSAGE_TYPE_METHOD_CALL, dbus_message_get_type(raw_message)); 367 368 MethodCall* method_call = new MethodCall; 369 method_call->Init(raw_message); 370 return method_call; 371 } 372 373 // 374 // Signal implementation. 375 // 376 Signal::Signal(const std::string& interface_name, 377 const std::string& method_name) 378 : Message() { 379 Init(dbus_message_new(DBUS_MESSAGE_TYPE_SIGNAL)); 380 381 CHECK(SetInterface(interface_name)); 382 CHECK(SetMember(method_name)); 383 } 384 385 Signal::Signal() : Message() { 386 } 387 388 Signal* Signal::FromRawMessage(DBusMessage* raw_message) { 389 DCHECK_EQ(DBUS_MESSAGE_TYPE_SIGNAL, dbus_message_get_type(raw_message)); 390 391 Signal* signal = new Signal; 392 signal->Init(raw_message); 393 return signal; 394 } 395 396 // 397 // Response implementation. 398 // 399 400 Response::Response() : Message() { 401 } 402 403 scoped_ptr<Response> Response::FromRawMessage(DBusMessage* raw_message) { 404 DCHECK_EQ(DBUS_MESSAGE_TYPE_METHOD_RETURN, 405 dbus_message_get_type(raw_message)); 406 407 scoped_ptr<Response> response(new Response); 408 response->Init(raw_message); 409 return response.Pass(); 410 } 411 412 scoped_ptr<Response> Response::FromMethodCall(MethodCall* method_call) { 413 scoped_ptr<Response> response(new Response); 414 response->Init(dbus_message_new_method_return(method_call->raw_message())); 415 return response.Pass(); 416 } 417 418 scoped_ptr<Response> Response::CreateEmpty() { 419 scoped_ptr<Response> response(new Response); 420 response->Init(dbus_message_new(DBUS_MESSAGE_TYPE_METHOD_RETURN)); 421 return response.Pass(); 422 } 423 424 // 425 // ErrorResponse implementation. 426 // 427 428 ErrorResponse::ErrorResponse() : Response() { 429 } 430 431 scoped_ptr<ErrorResponse> ErrorResponse::FromRawMessage( 432 DBusMessage* raw_message) { 433 DCHECK_EQ(DBUS_MESSAGE_TYPE_ERROR, dbus_message_get_type(raw_message)); 434 435 scoped_ptr<ErrorResponse> response(new ErrorResponse); 436 response->Init(raw_message); 437 return response.Pass(); 438 } 439 440 scoped_ptr<ErrorResponse> ErrorResponse::FromMethodCall( 441 MethodCall* method_call, 442 const std::string& error_name, 443 const std::string& error_message) { 444 scoped_ptr<ErrorResponse> response(new ErrorResponse); 445 response->Init(dbus_message_new_error(method_call->raw_message(), 446 error_name.c_str(), 447 error_message.c_str())); 448 return response.Pass(); 449 } 450 451 // 452 // MessageWriter implementation. 453 // 454 455 MessageWriter::MessageWriter(Message* message) 456 : message_(message), 457 container_is_open_(false) { 458 memset(&raw_message_iter_, 0, sizeof(raw_message_iter_)); 459 if (message) 460 dbus_message_iter_init_append(message_->raw_message(), &raw_message_iter_); 461 } 462 463 MessageWriter::~MessageWriter() { 464 } 465 466 void MessageWriter::AppendByte(uint8 value) { 467 AppendBasic(DBUS_TYPE_BYTE, &value); 468 } 469 470 void MessageWriter::AppendBool(bool value) { 471 // The size of dbus_bool_t and the size of bool are different. The 472 // former is always 4 per dbus-types.h, whereas the latter is usually 1. 473 // dbus_message_iter_append_basic() used in AppendBasic() expects four 474 // bytes for DBUS_TYPE_BOOLEAN, so we must pass a dbus_bool_t, instead 475 // of a bool, to AppendBasic(). 476 dbus_bool_t dbus_value = value; 477 AppendBasic(DBUS_TYPE_BOOLEAN, &dbus_value); 478 } 479 480 void MessageWriter::AppendInt16(int16 value) { 481 AppendBasic(DBUS_TYPE_INT16, &value); 482 } 483 484 void MessageWriter::AppendUint16(uint16 value) { 485 AppendBasic(DBUS_TYPE_UINT16, &value); 486 } 487 488 void MessageWriter::AppendInt32(int32 value) { 489 AppendBasic(DBUS_TYPE_INT32, &value); 490 } 491 492 void MessageWriter::AppendUint32(uint32 value) { 493 AppendBasic(DBUS_TYPE_UINT32, &value); 494 } 495 496 void MessageWriter::AppendInt64(int64 value) { 497 AppendBasic(DBUS_TYPE_INT64, &value); 498 } 499 500 void MessageWriter::AppendUint64(uint64 value) { 501 AppendBasic(DBUS_TYPE_UINT64, &value); 502 } 503 504 void MessageWriter::AppendDouble(double value) { 505 AppendBasic(DBUS_TYPE_DOUBLE, &value); 506 } 507 508 void MessageWriter::AppendString(const std::string& value) { 509 // D-Bus Specification (0.19) says a string "must be valid UTF-8". 510 CHECK(IsStringUTF8(value)); 511 const char* pointer = value.c_str(); 512 AppendBasic(DBUS_TYPE_STRING, &pointer); 513 // TODO(satorux): It may make sense to return an error here, as the 514 // input string can be large. If needed, we could add something like 515 // bool AppendStringWithErrorChecking(). 516 } 517 518 void MessageWriter::AppendObjectPath(const ObjectPath& value) { 519 CHECK(value.IsValid()); 520 const char* pointer = value.value().c_str(); 521 AppendBasic(DBUS_TYPE_OBJECT_PATH, &pointer); 522 } 523 524 // Ideally, client shouldn't need to supply the signature string, but 525 // the underlying D-Bus library requires us to supply this before 526 // appending contents to array and variant. It's technically possible 527 // for us to design API that doesn't require the signature but it will 528 // complicate the implementation so we decided to have the signature 529 // parameter. Hopefully, variants are less used in request messages from 530 // client side than response message from server side, so this should 531 // not be a big issue. 532 void MessageWriter::OpenArray(const std::string& signature, 533 MessageWriter* writer) { 534 DCHECK(!container_is_open_); 535 536 const bool success = dbus_message_iter_open_container( 537 &raw_message_iter_, 538 DBUS_TYPE_ARRAY, 539 signature.c_str(), 540 &writer->raw_message_iter_); 541 CHECK(success) << "Unable to allocate memory"; 542 container_is_open_ = true; 543 } 544 545 void MessageWriter::OpenVariant(const std::string& signature, 546 MessageWriter* writer) { 547 DCHECK(!container_is_open_); 548 549 const bool success = dbus_message_iter_open_container( 550 &raw_message_iter_, 551 DBUS_TYPE_VARIANT, 552 signature.c_str(), 553 &writer->raw_message_iter_); 554 CHECK(success) << "Unable to allocate memory"; 555 container_is_open_ = true; 556 } 557 558 void MessageWriter::OpenStruct(MessageWriter* writer) { 559 DCHECK(!container_is_open_); 560 561 const bool success = dbus_message_iter_open_container( 562 &raw_message_iter_, 563 DBUS_TYPE_STRUCT, 564 NULL, // Signature should be NULL. 565 &writer->raw_message_iter_); 566 CHECK(success) << "Unable to allocate memory"; 567 container_is_open_ = true; 568 } 569 570 void MessageWriter::OpenDictEntry(MessageWriter* writer) { 571 DCHECK(!container_is_open_); 572 573 const bool success = dbus_message_iter_open_container( 574 &raw_message_iter_, 575 DBUS_TYPE_DICT_ENTRY, 576 NULL, // Signature should be NULL. 577 &writer->raw_message_iter_); 578 CHECK(success) << "Unable to allocate memory"; 579 container_is_open_ = true; 580 } 581 582 void MessageWriter::CloseContainer(MessageWriter* writer) { 583 DCHECK(container_is_open_); 584 585 const bool success = dbus_message_iter_close_container( 586 &raw_message_iter_, &writer->raw_message_iter_); 587 CHECK(success) << "Unable to allocate memory"; 588 container_is_open_ = false; 589 } 590 591 void MessageWriter::AppendArrayOfBytes(const uint8* values, size_t length) { 592 DCHECK(!container_is_open_); 593 MessageWriter array_writer(message_); 594 OpenArray("y", &array_writer); 595 const bool success = dbus_message_iter_append_fixed_array( 596 &(array_writer.raw_message_iter_), 597 DBUS_TYPE_BYTE, 598 &values, 599 static_cast<int>(length)); 600 CHECK(success) << "Unable to allocate memory"; 601 CloseContainer(&array_writer); 602 } 603 604 void MessageWriter::AppendArrayOfStrings( 605 const std::vector<std::string>& strings) { 606 DCHECK(!container_is_open_); 607 MessageWriter array_writer(message_); 608 OpenArray("s", &array_writer); 609 for (size_t i = 0; i < strings.size(); ++i) { 610 array_writer.AppendString(strings[i]); 611 } 612 CloseContainer(&array_writer); 613 } 614 615 void MessageWriter::AppendArrayOfObjectPaths( 616 const std::vector<ObjectPath>& object_paths) { 617 DCHECK(!container_is_open_); 618 MessageWriter array_writer(message_); 619 OpenArray("o", &array_writer); 620 for (size_t i = 0; i < object_paths.size(); ++i) { 621 array_writer.AppendObjectPath(object_paths[i]); 622 } 623 CloseContainer(&array_writer); 624 } 625 626 bool MessageWriter::AppendProtoAsArrayOfBytes( 627 const google::protobuf::MessageLite& protobuf) { 628 std::string serialized_proto; 629 if (!protobuf.SerializeToString(&serialized_proto)) { 630 LOG(ERROR) << "Unable to serialize supplied protocol buffer"; 631 return false; 632 } 633 AppendArrayOfBytes(reinterpret_cast<const uint8*>(serialized_proto.data()), 634 serialized_proto.size()); 635 return true; 636 } 637 638 void MessageWriter::AppendVariantOfByte(uint8 value) { 639 AppendVariantOfBasic(DBUS_TYPE_BYTE, &value); 640 } 641 642 void MessageWriter::AppendVariantOfBool(bool value) { 643 // See the comment at MessageWriter::AppendBool(). 644 dbus_bool_t dbus_value = value; 645 AppendVariantOfBasic(DBUS_TYPE_BOOLEAN, &dbus_value); 646 } 647 648 void MessageWriter::AppendVariantOfInt16(int16 value) { 649 AppendVariantOfBasic(DBUS_TYPE_INT16, &value); 650 } 651 652 void MessageWriter::AppendVariantOfUint16(uint16 value) { 653 AppendVariantOfBasic(DBUS_TYPE_UINT16, &value); 654 } 655 656 void MessageWriter::AppendVariantOfInt32(int32 value) { 657 AppendVariantOfBasic(DBUS_TYPE_INT32, &value); 658 } 659 660 void MessageWriter::AppendVariantOfUint32(uint32 value) { 661 AppendVariantOfBasic(DBUS_TYPE_UINT32, &value); 662 } 663 664 void MessageWriter::AppendVariantOfInt64(int64 value) { 665 AppendVariantOfBasic(DBUS_TYPE_INT64, &value); 666 } 667 668 void MessageWriter::AppendVariantOfUint64(uint64 value) { 669 AppendVariantOfBasic(DBUS_TYPE_UINT64, &value); 670 } 671 672 void MessageWriter::AppendVariantOfDouble(double value) { 673 AppendVariantOfBasic(DBUS_TYPE_DOUBLE, &value); 674 } 675 676 void MessageWriter::AppendVariantOfString(const std::string& value) { 677 const char* pointer = value.c_str(); 678 AppendVariantOfBasic(DBUS_TYPE_STRING, &pointer); 679 } 680 681 void MessageWriter::AppendVariantOfObjectPath(const ObjectPath& value) { 682 const char* pointer = value.value().c_str(); 683 AppendVariantOfBasic(DBUS_TYPE_OBJECT_PATH, &pointer); 684 } 685 686 void MessageWriter::AppendBasic(int dbus_type, const void* value) { 687 DCHECK(!container_is_open_); 688 689 const bool success = dbus_message_iter_append_basic( 690 &raw_message_iter_, dbus_type, value); 691 // dbus_message_iter_append_basic() fails only when there is not enough 692 // memory. We don't return this error as there is nothing we can do when 693 // it fails to allocate memory for a byte etc. 694 CHECK(success) << "Unable to allocate memory"; 695 } 696 697 void MessageWriter::AppendVariantOfBasic(int dbus_type, const void* value) { 698 const std::string signature = base::StringPrintf("%c", dbus_type); 699 MessageWriter variant_writer(message_); 700 OpenVariant(signature, &variant_writer); 701 variant_writer.AppendBasic(dbus_type, value); 702 CloseContainer(&variant_writer); 703 } 704 705 void MessageWriter::AppendFileDescriptor(const FileDescriptor& value) { 706 CHECK(IsDBusTypeUnixFdSupported()); 707 708 if (!value.is_valid()) { 709 // NB: sending a directory potentially enables sandbox escape 710 LOG(FATAL) << "Attempt to pass invalid file descriptor"; 711 } 712 int fd = value.value(); 713 AppendBasic(DBUS_TYPE_UNIX_FD, &fd); 714 } 715 716 // 717 // MessageReader implementation. 718 // 719 720 MessageReader::MessageReader(Message* message) 721 : message_(message) { 722 memset(&raw_message_iter_, 0, sizeof(raw_message_iter_)); 723 if (message) 724 dbus_message_iter_init(message_->raw_message(), &raw_message_iter_); 725 } 726 727 728 MessageReader::~MessageReader() { 729 } 730 731 bool MessageReader::HasMoreData() { 732 const int dbus_type = dbus_message_iter_get_arg_type(&raw_message_iter_); 733 return dbus_type != DBUS_TYPE_INVALID; 734 } 735 736 bool MessageReader::PopByte(uint8* value) { 737 return PopBasic(DBUS_TYPE_BYTE, value); 738 } 739 740 bool MessageReader::PopBool(bool* value) { 741 // Like MessageWriter::AppendBool(), we should copy |value| to 742 // dbus_bool_t, as dbus_message_iter_get_basic() used in PopBasic() 743 // expects four bytes for DBUS_TYPE_BOOLEAN. 744 dbus_bool_t dbus_value = FALSE; 745 const bool success = PopBasic(DBUS_TYPE_BOOLEAN, &dbus_value); 746 *value = static_cast<bool>(dbus_value); 747 return success; 748 } 749 750 bool MessageReader::PopInt16(int16* value) { 751 return PopBasic(DBUS_TYPE_INT16, value); 752 } 753 754 bool MessageReader::PopUint16(uint16* value) { 755 return PopBasic(DBUS_TYPE_UINT16, value); 756 } 757 758 bool MessageReader::PopInt32(int32* value) { 759 return PopBasic(DBUS_TYPE_INT32, value); 760 } 761 762 bool MessageReader::PopUint32(uint32* value) { 763 return PopBasic(DBUS_TYPE_UINT32, value); 764 } 765 766 bool MessageReader::PopInt64(int64* value) { 767 return PopBasic(DBUS_TYPE_INT64, value); 768 } 769 770 bool MessageReader::PopUint64(uint64* value) { 771 return PopBasic(DBUS_TYPE_UINT64, value); 772 } 773 774 bool MessageReader::PopDouble(double* value) { 775 return PopBasic(DBUS_TYPE_DOUBLE, value); 776 } 777 778 bool MessageReader::PopString(std::string* value) { 779 char* tmp_value = NULL; 780 const bool success = PopBasic(DBUS_TYPE_STRING, &tmp_value); 781 if (success) 782 value->assign(tmp_value); 783 return success; 784 } 785 786 bool MessageReader::PopObjectPath(ObjectPath* value) { 787 char* tmp_value = NULL; 788 const bool success = PopBasic(DBUS_TYPE_OBJECT_PATH, &tmp_value); 789 if (success) 790 *value = ObjectPath(tmp_value); 791 return success; 792 } 793 794 bool MessageReader::PopArray(MessageReader* sub_reader) { 795 return PopContainer(DBUS_TYPE_ARRAY, sub_reader); 796 } 797 798 bool MessageReader::PopStruct(MessageReader* sub_reader) { 799 return PopContainer(DBUS_TYPE_STRUCT, sub_reader); 800 } 801 802 bool MessageReader::PopDictEntry(MessageReader* sub_reader) { 803 return PopContainer(DBUS_TYPE_DICT_ENTRY, sub_reader); 804 } 805 806 bool MessageReader::PopVariant(MessageReader* sub_reader) { 807 return PopContainer(DBUS_TYPE_VARIANT, sub_reader); 808 } 809 810 bool MessageReader::PopArrayOfBytes(uint8** bytes, size_t* length) { 811 MessageReader array_reader(message_); 812 if (!PopArray(&array_reader)) 813 return false; 814 // An empty array is allowed. 815 if (!array_reader.HasMoreData()) { 816 *length = 0; 817 *bytes = NULL; 818 return true; 819 } 820 if (!array_reader.CheckDataType(DBUS_TYPE_BYTE)) 821 return false; 822 int int_length = 0; 823 dbus_message_iter_get_fixed_array(&array_reader.raw_message_iter_, 824 bytes, 825 &int_length); 826 *length = static_cast<int>(int_length); 827 return true; 828 } 829 830 bool MessageReader::PopArrayOfStrings( 831 std::vector<std::string> *strings) { 832 MessageReader array_reader(message_); 833 if (!PopArray(&array_reader)) 834 return false; 835 while (array_reader.HasMoreData()) { 836 std::string string; 837 if (!array_reader.PopString(&string)) 838 return false; 839 strings->push_back(string); 840 } 841 return true; 842 } 843 844 bool MessageReader::PopArrayOfObjectPaths( 845 std::vector<ObjectPath> *object_paths) { 846 MessageReader array_reader(message_); 847 if (!PopArray(&array_reader)) 848 return false; 849 while (array_reader.HasMoreData()) { 850 ObjectPath object_path; 851 if (!array_reader.PopObjectPath(&object_path)) 852 return false; 853 object_paths->push_back(object_path); 854 } 855 return true; 856 } 857 858 bool MessageReader::PopArrayOfBytesAsProto( 859 google::protobuf::MessageLite* protobuf) { 860 DCHECK(protobuf != NULL); 861 char* serialized_buf = NULL; 862 size_t buf_size = 0; 863 if (!PopArrayOfBytes(reinterpret_cast<uint8**>(&serialized_buf), &buf_size)) { 864 LOG(ERROR) << "Error reading array of bytes"; 865 return false; 866 } 867 if (!protobuf->ParseFromArray(serialized_buf, buf_size)) { 868 LOG(ERROR) << "Failed to parse protocol buffer from array"; 869 return false; 870 } 871 return true; 872 } 873 874 bool MessageReader::PopVariantOfByte(uint8* value) { 875 return PopVariantOfBasic(DBUS_TYPE_BYTE, value); 876 } 877 878 bool MessageReader::PopVariantOfBool(bool* value) { 879 // See the comment at MessageReader::PopBool(). 880 dbus_bool_t dbus_value = FALSE; 881 const bool success = PopVariantOfBasic(DBUS_TYPE_BOOLEAN, &dbus_value); 882 *value = static_cast<bool>(dbus_value); 883 return success; 884 } 885 886 bool MessageReader::PopVariantOfInt16(int16* value) { 887 return PopVariantOfBasic(DBUS_TYPE_INT16, value); 888 } 889 890 bool MessageReader::PopVariantOfUint16(uint16* value) { 891 return PopVariantOfBasic(DBUS_TYPE_UINT16, value); 892 } 893 894 bool MessageReader::PopVariantOfInt32(int32* value) { 895 return PopVariantOfBasic(DBUS_TYPE_INT32, value); 896 } 897 898 bool MessageReader::PopVariantOfUint32(uint32* value) { 899 return PopVariantOfBasic(DBUS_TYPE_UINT32, value); 900 } 901 902 bool MessageReader::PopVariantOfInt64(int64* value) { 903 return PopVariantOfBasic(DBUS_TYPE_INT64, value); 904 } 905 906 bool MessageReader::PopVariantOfUint64(uint64* value) { 907 return PopVariantOfBasic(DBUS_TYPE_UINT64, value); 908 } 909 910 bool MessageReader::PopVariantOfDouble(double* value) { 911 return PopVariantOfBasic(DBUS_TYPE_DOUBLE, value); 912 } 913 914 bool MessageReader::PopVariantOfString(std::string* value) { 915 char* tmp_value = NULL; 916 const bool success = PopVariantOfBasic(DBUS_TYPE_STRING, &tmp_value); 917 if (success) 918 value->assign(tmp_value); 919 return success; 920 } 921 922 bool MessageReader::PopVariantOfObjectPath(ObjectPath* value) { 923 char* tmp_value = NULL; 924 const bool success = PopVariantOfBasic(DBUS_TYPE_OBJECT_PATH, &tmp_value); 925 if (success) 926 *value = ObjectPath(tmp_value); 927 return success; 928 } 929 930 Message::DataType MessageReader::GetDataType() { 931 const int dbus_type = dbus_message_iter_get_arg_type(&raw_message_iter_); 932 return static_cast<Message::DataType>(dbus_type); 933 } 934 935 bool MessageReader::CheckDataType(int dbus_type) { 936 const int actual_type = dbus_message_iter_get_arg_type(&raw_message_iter_); 937 if (actual_type != dbus_type) { 938 VLOG(1) << "Type " << dbus_type << " is expected but got " 939 << actual_type; 940 return false; 941 } 942 return true; 943 } 944 945 bool MessageReader::PopBasic(int dbus_type, void* value) { 946 if (!CheckDataType(dbus_type)) 947 return false; 948 // dbus_message_iter_get_basic() here should always work, as we have 949 // already checked the next item's data type in CheckDataType(). Note 950 // that dbus_message_iter_get_basic() is a void function. 951 dbus_message_iter_get_basic(&raw_message_iter_, value); 952 DCHECK(value); 953 dbus_message_iter_next(&raw_message_iter_); 954 return true; 955 } 956 957 bool MessageReader::PopContainer(int dbus_type, MessageReader* sub_reader) { 958 DCHECK_NE(this, sub_reader); 959 960 if (!CheckDataType(dbus_type)) 961 return false; 962 dbus_message_iter_recurse(&raw_message_iter_, 963 &sub_reader->raw_message_iter_); 964 dbus_message_iter_next(&raw_message_iter_); 965 return true; 966 } 967 968 bool MessageReader::PopVariantOfBasic(int dbus_type, void* value) { 969 MessageReader variant_reader(message_); 970 if (!PopVariant(&variant_reader)) 971 return false; 972 return variant_reader.PopBasic(dbus_type, value); 973 } 974 975 bool MessageReader::PopFileDescriptor(FileDescriptor* value) { 976 CHECK(IsDBusTypeUnixFdSupported()); 977 978 int fd = -1; 979 const bool success = PopBasic(DBUS_TYPE_UNIX_FD, &fd); 980 if (!success) 981 return false; 982 983 value->PutValue(fd); 984 // NB: the caller must check validity before using the value 985 return true; 986 } 987 988 } // namespace dbus 989
