dbus/message.cc

   1 // Copyright (c) 2011 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 "base/basictypes.h"
   8 #include "base/format_macros.h"
   9 #include "base/logging.h"
  10 #include "base/stringprintf.h"
  11
  12 namespace {
  13
  14 // Appends the header name and the value to |output|, if the value is
  15 // not empty.
  16 static void AppendStringHeader(const std::string& header_name,
  17                                const std::string& header_value,
  18                                std::string* output) {
  19   if (!header_value.empty()) {
  20     *output += header_name + ": " + header_value + "\n";
  21   }
  22 }
  23
  24 // Appends the header name and the value to |output|, if the value is
  25 // nonzero.
  26 static void AppendUint32Header(const std::string& header_name,
  27                                uint32 header_value,
  28                                std::string* output) {
  29   if (header_value != 0) {
  30     *output += (header_name + ": " + base::StringPrintf("%u", header_value) +
  31                 "\n");
  32   }
  33 }
  34
  35 }  // namespace
  36
  37 namespace dbus {
  38
  39 Message::Message()
  40     : raw_message_(NULL) {
  41 }
  42
  43 Message::~Message() {
  44   if (raw_message_)
  45     dbus_message_unref(raw_message_);
  46 }
  47
  48 Message::MessageType Message::GetMessageType() {
  49   if (!raw_message_)
  50     return MESSAGE_INVALID;
  51   const int type = dbus_message_get_type(raw_message_);
  52   return static_cast<Message::MessageType>(type);
  53 }
  54
  55 void Message::reset_raw_message(DBusMessage* raw_message) {
  56   if (raw_message_)
  57     dbus_message_unref(raw_message_);
  58   raw_message_ = raw_message;
  59 }
  60
  61 std::string Message::ToStringInternal(const std::string& indent,
  62                                       MessageReader* reader) {
  63   const char* kBrokenMessage = "[broken message]";
  64   std::string output;
  65   while (reader->HasMoreData()) {
  66     const DataType type = reader->GetDataType();
  67     switch (type) {
  68       case BYTE: {
  69         uint8 value = 0;
  70         if (!reader->PopByte(&value))
  71           return kBrokenMessage;
  72         output += indent + "byte " + base::StringPrintf("%d", value) + "\n";
  73         break;
  74       }
  75       case BOOL: {
  76         bool value = false;
  77         if (!reader->PopBool(&value))
  78           return kBrokenMessage;
  79         output += indent + "bool " + (value ? "true" : "false") + "\n";
  80         break;
  81       }
  82       case INT16: {
  83         int16 value = 0;
  84         if (!reader->PopInt16(&value))
  85           return kBrokenMessage;
  86         output += indent + "int16 " + base::StringPrintf("%d", value) + "\n";
  87         break;
  88       }
  89       case UINT16: {
  90         uint16 value = 0;
  91         if (!reader->PopUint16(&value))
  92           return kBrokenMessage;
  93         output += indent + "uint16 " + base::StringPrintf("%d", value) + "\n";
  94         break;
  95       }
  96       case INT32: {
  97         int32 value = 0;
  98         if (!reader->PopInt32(&value))
  99           return kBrokenMessage;
 100         output += indent + "int32 " + base::StringPrintf("%d", value) + "\n";
 101         break;
 102       }
 103       case UINT32: {
 104         uint32 value = 0;
 105         if (!reader->PopUint32(&value))
 106           return kBrokenMessage;
 107         output += indent + "uint32 " + base::StringPrintf("%u", value) + "\n";
 108         break;
 109       }
 110       case INT64: {
 111         int64 value = 0;
 112         if (!reader->PopInt64(&value))
 113           return kBrokenMessage;
 114         output += (indent + "int64 " +
 115                    base::StringPrintf("%" PRId64, value) + "\n");
 116         break;
 117       }
 118       case UINT64: {
 119         uint64 value = 0;
 120         if (!reader->PopUint64(&value))
 121           return kBrokenMessage;
 122         output += (indent + "uint64 " +
 123                    base::StringPrintf("%" PRIu64, value) + "\n");
 124         break;
 125       }
 126       case DOUBLE: {
 127         double value = 0;
 128         if (!reader->PopDouble(&value))
 129           return kBrokenMessage;
 130         output += indent + "double " + base::StringPrintf("%f", value) + "\n";
 131         break;
 132       }
 133       case STRING: {
 134         std::string value;
 135         if (!reader->PopString(&value))
 136           return kBrokenMessage;
 137         output += indent + "string \"" + value + "\"\n";
 138         break;
 139       }
 140       case OBJECT_PATH: {
 141         std::string value;
 142         if (!reader->PopObjectPath(&value))
 143           return kBrokenMessage;
 144         output += indent + "object_path \"" + value + "\"\n";
 145         break;
 146       }
 147       case ARRAY: {
 148         MessageReader sub_reader(this);
 149         if (!reader->PopArray(&sub_reader))
 150           return kBrokenMessage;
 151         output += indent + "array [\n";
 152         output += ToStringInternal(indent + "  ", &sub_reader);
 153         output += indent + "]\n";
 154         break;
 155       }
 156       case STRUCT: {
 157         MessageReader sub_reader(this);
 158         if (!reader->PopStruct(&sub_reader))
 159           return kBrokenMessage;
 160         output += indent + "struct {\n";
 161         output += ToStringInternal(indent + "  ", &sub_reader);
 162         output += indent + "}\n";
 163         break;
 164       }
 165       case DICT_ENTRY: {
 166         MessageReader sub_reader(this);
 167         if (!reader->PopDictEntry(&sub_reader))
 168           return kBrokenMessage;
 169         output += indent + "dict entry {\n";
 170         output += ToStringInternal(indent + "  ", &sub_reader);
 171         output += indent + "}\n";
 172         break;
 173       }
 174       case VARIANT: {
 175         MessageReader sub_reader(this);
 176         if (!reader->PopVariant(&sub_reader))
 177           return kBrokenMessage;
 178         output += indent + "variant ";
 179         output += ToStringInternal(indent + "  ", &sub_reader);
 180         break;
 181       }
 182       default:
 183         LOG(FATAL) << "Unknown type: " << type;
 184     }
 185   }
 186   return output;
 187 }
 188
 189 // The returned string consists of message headers such as
 190 // destination if any, followed by a blank line, and the message
 191 // payload. For example, a MethodCall's ToString() will look like:
 192 //
 193 // destination: com.example.Service
 194 // path: /com/example/Object
 195 // interface: com.example.Interface
 196 // member: SomeMethod
 197 //
 198 // string \"payload\"
 199 // ...
 200 std::string Message::ToString() {
 201   if (!raw_message_)
 202     return "";
 203
 204   // Generate headers first.
 205   std::string headers;
 206   AppendStringHeader("destination", GetDestination(), &headers);
 207   AppendStringHeader("path", GetPath(), &headers);
 208   AppendStringHeader("interface", GetInterface(), &headers);
 209   AppendStringHeader("member", GetMember(), &headers);
 210   AppendStringHeader("error_name", GetErrorName(), &headers);
 211   AppendStringHeader("sender", GetSender(), &headers);
 212   AppendStringHeader("signature", GetSignature(), &headers);
 213   AppendUint32Header("serial", GetSerial(), &headers);
 214   AppendUint32Header("reply_serial", GetReplySerial(), &headers);
 215
 216   // Generate the payload.
 217   MessageReader reader(this);
 218   return headers + "\n" + ToStringInternal("", &reader);
 219 }
 220
 221 void Message::SetDestination(const std::string& destination) {
 222   const bool success = dbus_message_set_destination(raw_message_,
 223                                                     destination.c_str());
 224   CHECK(success) << "Unable to allocate memory";
 225 }
 226
 227 void Message::SetPath(const std::string& path) {
 228   const bool success = dbus_message_set_path(raw_message_,
 229                                              path.c_str());
 230   CHECK(success) << "Unable to allocate memory";
 231 }
 232
 233 void Message::SetInterface(const std::string& interface) {
 234   const bool success = dbus_message_set_interface(raw_message_,
 235                                                   interface.c_str());
 236   CHECK(success) << "Unable to allocate memory";
 237 }
 238
 239 void Message::SetMember(const std::string& member) {
 240   const bool success = dbus_message_set_member(raw_message_,
 241                                                member.c_str());
 242   CHECK(success) << "Unable to allocate memory";
 243 }
 244
 245 void Message::SetErrorName(const std::string& error_name) {
 246   const bool success = dbus_message_set_error_name(raw_message_,
 247                                                    error_name.c_str());
 248   CHECK(success) << "Unable to allocate memory";
 249 }
 250
 251 void Message::SetSender(const std::string& sender) {
 252   const bool success = dbus_message_set_sender(raw_message_,
 253                                                sender.c_str());
 254   CHECK(success) << "Unable to allocate memory";
 255 }
 256
 257 void Message::SetSerial(uint32 serial) {
 258   dbus_message_set_serial(raw_message_, serial);
 259 }
 260
 261 void Message::SetReplySerial(uint32 reply_serial) {
 262   dbus_message_set_reply_serial(raw_message_, reply_serial);
 263 }
 264
 265 std::string Message::GetDestination() {
 266   const char* destination = dbus_message_get_destination(raw_message_);
 267   return destination ? destination : "";
 268 }
 269
 270 std::string Message::GetPath() {
 271   const char* path = dbus_message_get_path(raw_message_);
 272   return path ? path : "";
 273 }
 274
 275 std::string Message::GetInterface() {
 276   const char* interface = dbus_message_get_interface(raw_message_);
 277   return interface ? interface : "";
 278 }
 279
 280 std::string Message::GetMember() {
 281   const char* member = dbus_message_get_member(raw_message_);
 282   return member ? member : "";
 283 }
 284
 285 std::string Message::GetErrorName() {
 286   const char* error_name = dbus_message_get_error_name(raw_message_);
 287   return error_name ? error_name : "";
 288 }
 289
 290 std::string Message::GetSender() {
 291   const char* sender = dbus_message_get_sender(raw_message_);
 292   return sender ? sender : "";
 293 }
 294
 295 std::string Message::GetSignature() {
 296   const char* signature = dbus_message_get_signature(raw_message_);
 297   return signature ? signature : "";
 298 }
 299
 300 uint32 Message::GetSerial() {
 301   return dbus_message_get_serial(raw_message_);
 302 }
 303
 304 uint32 Message::GetReplySerial() {
 305   return dbus_message_get_reply_serial(raw_message_);
 306 }
 307
 308 //
 309 // MethodCall implementation.
 310 //
 311
 312 MethodCall::MethodCall(const std::string& interface_name,
 313                        const std::string& method_name)
 314     : Message() {
 315   reset_raw_message(dbus_message_new(DBUS_MESSAGE_TYPE_METHOD_CALL));
 316
 317   SetInterface(interface_name);
 318   SetMember(method_name);
 319 }
 320
 321 MethodCall* MethodCall::FromRawMessage(DBusMessage* raw_message) {
 322   DCHECK_EQ(DBUS_MESSAGE_TYPE_METHOD_CALL, dbus_message_get_type(raw_message));
 323
 324   const char* interface = dbus_message_get_interface(raw_message);
 325   const char* member = dbus_message_get_member(raw_message);
 326   std::string interface_string = interface ? interface : "";
 327   std::string member_string = member ? member : "";
 328
 329   MethodCall* method_call = new MethodCall(interface_string, member_string);
 330   method_call->reset_raw_message(raw_message);
 331   return method_call;
 332 }
 333
 334 //
 335 // Response implementation.
 336 //
 337
 338 Response::Response() : Message() {
 339 }
 340
 341 Response* Response::FromMethodCall(MethodCall* method_call) {
 342   Response* response = new Response;
 343   response->reset_raw_message(
 344       dbus_message_new_method_return(method_call->raw_message()));
 345   return response;
 346 }
 347
 348 //
 349 // ErrorResponse implementation.
 350 //
 351
 352 ErrorResponse::ErrorResponse() : Message() {
 353 }
 354
 355 ErrorResponse* ErrorResponse::FromMethodCall(
 356     MethodCall* method_call,
 357     const std::string& error_name,
 358     const std::string& error_message) {
 359   ErrorResponse* response = new ErrorResponse;
 360   response->reset_raw_message(
 361       dbus_message_new_error(method_call->raw_message(),
 362                              error_name.c_str(),
 363                              error_message.c_str()));
 364   return response;
 365 }
 366
 367 //
 368 // MessageWriter implementation.
 369 //
 370
 371 MessageWriter::MessageWriter(Message* message) :
 372     message_(message),
 373     container_is_open_(false) {
 374   dbus_message_iter_init_append(message_->raw_message(), &raw_message_iter_);
 375 }
 376
 377 MessageWriter::~MessageWriter() {
 378 }
 379
 380 void MessageWriter::AppendByte(uint8 value) {
 381   AppendBasic(DBUS_TYPE_BYTE, &value);
 382 }
 383
 384 void MessageWriter::AppendBool(bool value) {
 385   // The size of dbus_bool_t and the size of bool are different. The
 386   // former is always 4 per dbus-types.h, whereas the latter is usually 1.
 387   // dbus_message_iter_append_basic() used in AppendBasic() expects four
 388   // bytes for DBUS_TYPE_BOOLEAN, so we must pass a dbus_bool_t, instead
 389   // of a bool, to AppendBasic().
 390   dbus_bool_t dbus_value = value;
 391   AppendBasic(DBUS_TYPE_BOOLEAN, &dbus_value);
 392 }
 393
 394 void MessageWriter::AppendInt16(int16 value) {
 395   AppendBasic(DBUS_TYPE_INT16, &value);
 396 }
 397
 398 void MessageWriter::AppendUint16(uint16 value) {
 399   AppendBasic(DBUS_TYPE_UINT16, &value);
 400 }
 401
 402 void MessageWriter::AppendInt32(int32 value) {
 403   AppendBasic(DBUS_TYPE_INT32, &value);
 404 }
 405
 406 void MessageWriter::AppendUint32(uint32 value) {
 407   AppendBasic(DBUS_TYPE_UINT32, &value);
 408 }
 409
 410 void MessageWriter::AppendInt64(int64 value) {
 411   AppendBasic(DBUS_TYPE_INT64, &value);
 412 }
 413
 414 void MessageWriter::AppendUint64(uint64 value) {
 415   AppendBasic(DBUS_TYPE_UINT64, &value);
 416 }
 417
 418 void MessageWriter::AppendDouble(double value) {
 419   AppendBasic(DBUS_TYPE_DOUBLE, &value);
 420 }
 421
 422 void MessageWriter::AppendString(const std::string& value) {
 423   const char* pointer = value.c_str();
 424   AppendBasic(DBUS_TYPE_STRING, &pointer);
 425   // TODO(satorux): It may make sense to return an error here, as the
 426   // input string can be large. If needed, we could add something like
 427   // bool AppendStringWithErrorChecking().
 428 }
 429
 430 void MessageWriter::AppendObjectPath(const std::string& value) {
 431   const char* pointer = value.c_str();
 432   AppendBasic(DBUS_TYPE_OBJECT_PATH, &pointer);
 433 }
 434
 435 // Ideally, client shouldn't need to supply the signature string, but
 436 // the underlying D-Bus library requires us to supply this before
 437 // appending contents to array and variant. It's technically possible
 438 // for us to design API that doesn't require the signature but it will
 439 // complicate the implementation so we decided to have the signature
 440 // parameter. Hopefully, variants are less used in request messages from
 441 // client side than response message from server side, so this should
 442 // not be a big issue.
 443 void MessageWriter::OpenArray(const std::string& signature,
 444                               MessageWriter* writer) {
 445   DCHECK(!container_is_open_);
 446
 447   const bool success = dbus_message_iter_open_container(
 448       &raw_message_iter_,
 449       DBUS_TYPE_ARRAY,
 450       signature.c_str(),
 451       &writer->raw_message_iter_);
 452   CHECK(success) << "Unable to allocate memory";
 453   container_is_open_ = true;
 454 }
 455
 456 void MessageWriter::OpenVariant(const std::string& signature,
 457                                 MessageWriter* writer) {
 458   DCHECK(!container_is_open_);
 459
 460   const bool success = dbus_message_iter_open_container(
 461       &raw_message_iter_,
 462       DBUS_TYPE_VARIANT,
 463       signature.c_str(),
 464       &writer->raw_message_iter_);
 465   CHECK(success) << "Unable to allocate memory";
 466   container_is_open_ = true;
 467 }
 468
 469 void MessageWriter::OpenStruct(MessageWriter* writer) {
 470   DCHECK(!container_is_open_);
 471
 472   const bool success = dbus_message_iter_open_container(
 473       &raw_message_iter_,
 474       DBUS_TYPE_STRUCT,
 475       NULL,  // Signature should be NULL.
 476       &writer->raw_message_iter_);
 477   CHECK(success) << "Unable to allocate memory";
 478   container_is_open_ = true;
 479 }
 480
 481 void MessageWriter::OpenDictEntry(MessageWriter* writer) {
 482   DCHECK(!container_is_open_);
 483
 484   const bool success = dbus_message_iter_open_container(
 485       &raw_message_iter_,
 486       DBUS_TYPE_DICT_ENTRY,
 487       NULL,  // Signature should be NULL.
 488       &writer->raw_message_iter_);
 489   CHECK(success) << "Unable to allocate memory";
 490   container_is_open_ = true;
 491 }
 492
 493 void MessageWriter::CloseContainer(MessageWriter* writer) {
 494   DCHECK(container_is_open_);
 495
 496   const bool success = dbus_message_iter_close_container(
 497       &raw_message_iter_, &writer->raw_message_iter_);
 498   CHECK(success) << "Unable to allocate memory";
 499   container_is_open_ = false;
 500 }
 501
 502 void MessageWriter::AppendArrayOfBytes(const uint8* values, size_t length) {
 503   DCHECK(!container_is_open_);
 504   MessageWriter array_writer(message_);
 505   OpenArray("y", &array_writer);
 506   const bool success = dbus_message_iter_append_fixed_array(
 507       &(array_writer.raw_message_iter_),
 508       DBUS_TYPE_BYTE,
 509       &values,
 510       static_cast<int>(length));
 511   CHECK(success) << "Unable to allocate memory";
 512   CloseContainer(&array_writer);
 513 }
 514
 515 void MessageWriter::AppendVariantOfByte(uint8 value) {
 516   AppendVariantOfBasic(DBUS_TYPE_BYTE, &value);
 517 }
 518
 519 void MessageWriter::AppendVariantOfBool(bool value) {
 520   // See the comment at MessageWriter::AppendBool().
 521   dbus_bool_t dbus_value = value;
 522   AppendVariantOfBasic(DBUS_TYPE_BOOLEAN, &dbus_value);
 523 }
 524
 525 void MessageWriter::AppendVariantOfInt16(int16 value) {
 526   AppendVariantOfBasic(DBUS_TYPE_INT16, &value);
 527 }
 528
 529 void MessageWriter::AppendVariantOfUint16(uint16 value) {
 530   AppendVariantOfBasic(DBUS_TYPE_UINT16, &value);
 531 }
 532
 533 void MessageWriter::AppendVariantOfInt32(int32 value) {
 534   AppendVariantOfBasic(DBUS_TYPE_INT32, &value);
 535 }
 536
 537 void MessageWriter::AppendVariantOfUint32(uint32 value) {
 538   AppendVariantOfBasic(DBUS_TYPE_UINT32, &value);
 539 }
 540
 541 void MessageWriter::AppendVariantOfInt64(int64 value) {
 542   AppendVariantOfBasic(DBUS_TYPE_INT64, &value);
 543 }
 544
 545 void MessageWriter::AppendVariantOfUint64(uint64 value) {
 546   AppendVariantOfBasic(DBUS_TYPE_UINT64, &value);
 547 }
 548
 549 void MessageWriter::AppendVariantOfDouble(double value) {
 550   AppendVariantOfBasic(DBUS_TYPE_DOUBLE, &value);
 551 }
 552
 553 void MessageWriter::AppendVariantOfString(const std::string& value) {
 554   const char* pointer = value.c_str();
 555   AppendVariantOfBasic(DBUS_TYPE_STRING, &pointer);
 556 }
 557
 558 void MessageWriter::AppendVariantOfObjectPath(const std::string& value) {
 559   const char* pointer = value.c_str();
 560   AppendVariantOfBasic(DBUS_TYPE_OBJECT_PATH, &pointer);
 561 }
 562
 563 void MessageWriter::AppendBasic(int dbus_type, const void* value) {
 564   DCHECK(!container_is_open_);
 565
 566   const bool success = dbus_message_iter_append_basic(
 567       &raw_message_iter_, dbus_type, value);
 568   // dbus_message_iter_append_basic() fails only when there is not enough
 569   // memory. We don't return this error as there is nothing we can do when
 570   // it fails to allocate memory for a byte etc.
 571   CHECK(success) << "Unable to allocate memory";
 572 }
 573
 574 void MessageWriter::AppendVariantOfBasic(int dbus_type, const void* value) {
 575   const std::string signature = base::StringPrintf("%c", dbus_type);
 576   MessageWriter variant_writer(message_);
 577   OpenVariant(signature, &variant_writer);
 578   variant_writer.AppendBasic(dbus_type, value);
 579   CloseContainer(&variant_writer);
 580 }
 581
 582 //
 583 // MessageReader implementation.
 584 //
 585
 586 MessageReader::MessageReader(Message* message)
 587     : message_(message) {
 588   dbus_message_iter_init(message_->raw_message(), &raw_message_iter_);
 589 }
 590
 591
 592 MessageReader::~MessageReader() {
 593 }
 594
 595 bool MessageReader::HasMoreData() {
 596   const int dbus_type = dbus_message_iter_get_arg_type(&raw_message_iter_);
 597   return dbus_type != DBUS_TYPE_INVALID;
 598 }
 599
 600 bool MessageReader::PopByte(uint8* value) {
 601   return PopBasic(DBUS_TYPE_BYTE, value);
 602 }
 603
 604 bool MessageReader::PopBool(bool* value) {
 605   // Like MessageWriter::AppendBool(), we should copy |value| to
 606   // dbus_bool_t, as dbus_message_iter_get_basic() used in PopBasic()
 607   // expects four bytes for DBUS_TYPE_BOOLEAN.
 608   dbus_bool_t dbus_value = FALSE;
 609   const bool success = PopBasic(DBUS_TYPE_BOOLEAN, &dbus_value);
 610   *value = static_cast<bool>(dbus_value);
 611   return success;
 612 }
 613
 614 bool MessageReader::PopInt16(int16* value) {
 615   return PopBasic(DBUS_TYPE_INT16, value);
 616 }
 617
 618 bool MessageReader::PopUint16(uint16* value) {
 619   return PopBasic(DBUS_TYPE_UINT16, value);
 620 }
 621
 622 bool MessageReader::PopInt32(int32* value) {
 623   return PopBasic(DBUS_TYPE_INT32, value);
 624 }
 625
 626 bool MessageReader::PopUint32(uint32* value) {
 627   return PopBasic(DBUS_TYPE_UINT32, value);
 628 }
 629
 630 bool MessageReader::PopInt64(int64* value) {
 631   return PopBasic(DBUS_TYPE_INT64, value);
 632 }
 633
 634 bool MessageReader::PopUint64(uint64* value) {
 635   return PopBasic(DBUS_TYPE_UINT64, value);
 636 }
 637
 638 bool MessageReader::PopDouble(double* value) {
 639   return PopBasic(DBUS_TYPE_DOUBLE, value);
 640 }
 641
 642 bool MessageReader::PopString(std::string* value) {
 643   char* tmp_value = NULL;
 644   const bool success = PopBasic(DBUS_TYPE_STRING, &tmp_value);
 645   if (success)
 646     value->assign(tmp_value);
 647   return success;
 648 }
 649
 650 bool MessageReader::PopObjectPath(std::string* value) {
 651   char* tmp_value = NULL;
 652   const bool success = PopBasic(DBUS_TYPE_OBJECT_PATH, &tmp_value);
 653   if (success)
 654     value->assign(tmp_value);
 655   return success;
 656 }
 657
 658 bool MessageReader::PopArray(MessageReader* sub_reader) {
 659   return PopContainer(DBUS_TYPE_ARRAY, sub_reader);
 660 }
 661
 662 bool MessageReader::PopStruct(MessageReader* sub_reader) {
 663   return PopContainer(DBUS_TYPE_STRUCT, sub_reader);
 664 }
 665
 666 bool MessageReader::PopDictEntry(MessageReader* sub_reader) {
 667   return PopContainer(DBUS_TYPE_DICT_ENTRY, sub_reader);
 668 }
 669
 670 bool MessageReader::PopVariant(MessageReader* sub_reader) {
 671   return PopContainer(DBUS_TYPE_VARIANT, sub_reader);
 672 }
 673
 674 bool MessageReader::PopArrayOfBytes(uint8** bytes, size_t* length) {
 675   MessageReader array_reader(message_);
 676   if (!PopArray(&array_reader))
 677       return false;
 678   if (!array_reader.CheckDataType(DBUS_TYPE_BYTE))
 679     return false;
 680   int int_length = 0;
 681   dbus_message_iter_get_fixed_array(&array_reader.raw_message_iter_,
 682                                     bytes,
 683                                     &int_length);
 684   *length = static_cast<int>(int_length);
 685   return bytes != NULL;
 686 }
 687
 688 bool MessageReader::PopArrayOfObjectPaths(
 689     std::vector<std::string> *object_paths) {
 690   MessageReader array_reader(message_);
 691   if (!PopArray(&array_reader))
 692       return false;
 693   while (array_reader.HasMoreData()) {
 694     std::string object_path;
 695     if (!array_reader.PopObjectPath(&object_path))
 696       return false;
 697     object_paths->push_back(object_path);
 698   }
 699   return true;
 700 }
 701
 702 bool MessageReader::PopVariantOfByte(uint8* value) {
 703   return PopVariantOfBasic(DBUS_TYPE_BYTE, value);
 704 }
 705
 706 bool MessageReader::PopVariantOfBool(bool* value) {
 707   // See the comment at MessageReader::PopBool().
 708   dbus_bool_t dbus_value = FALSE;
 709   const bool success = PopVariantOfBasic(DBUS_TYPE_BOOLEAN, &dbus_value);
 710   *value = static_cast<bool>(dbus_value);
 711   return success;
 712 }
 713
 714 bool MessageReader::PopVariantOfInt16(int16* value) {
 715   return PopVariantOfBasic(DBUS_TYPE_INT16, value);
 716 }
 717
 718 bool MessageReader::PopVariantOfUint16(uint16* value) {
 719   return PopVariantOfBasic(DBUS_TYPE_UINT16, value);
 720 }
 721
 722 bool MessageReader::PopVariantOfInt32(int32* value) {
 723   return PopVariantOfBasic(DBUS_TYPE_INT32, value);
 724 }
 725
 726 bool MessageReader::PopVariantOfUint32(uint32* value) {
 727   return PopVariantOfBasic(DBUS_TYPE_UINT32, value);
 728 }
 729
 730 bool MessageReader::PopVariantOfInt64(int64* value) {
 731   return PopVariantOfBasic(DBUS_TYPE_INT64, value);
 732 }
 733
 734 bool MessageReader::PopVariantOfUint64(uint64* value) {
 735   return PopVariantOfBasic(DBUS_TYPE_UINT64, value);
 736 }
 737
 738 bool MessageReader::PopVariantOfDouble(double* value) {
 739   return PopVariantOfBasic(DBUS_TYPE_DOUBLE, value);
 740 }
 741
 742 bool MessageReader::PopVariantOfString(std::string* value) {
 743   char* tmp_value = NULL;
 744   const bool success = PopVariantOfBasic(DBUS_TYPE_STRING, &tmp_value);
 745   if (success)
 746     value->assign(tmp_value);
 747   return success;
 748 }
 749
 750 bool MessageReader::PopVariantOfObjectPath(std::string* value) {
 751   char* tmp_value = NULL;
 752   const bool success = PopVariantOfBasic(DBUS_TYPE_OBJECT_PATH, &tmp_value);
 753   if (success)
 754     value->assign(tmp_value);
 755   return success;
 756 }
 757
 758 Message::DataType MessageReader::GetDataType() {
 759   const int dbus_type = dbus_message_iter_get_arg_type(&raw_message_iter_);
 760   return static_cast<Message::DataType>(dbus_type);
 761 }
 762
 763 bool MessageReader::CheckDataType(int dbus_type) {
 764   const int actual_type = dbus_message_iter_get_arg_type(&raw_message_iter_);
 765   if (actual_type != dbus_type) {
 766     VLOG(1) << "Type " << dbus_type  << " is expected but got "
 767             << actual_type;
 768     return false;
 769   }
 770   return true;
 771 }
 772
 773 bool MessageReader::PopBasic(int dbus_type, void* value) {
 774   if (!CheckDataType(dbus_type))
 775     return false;
 776   // dbus_message_iter_get_basic() here should always work, as we have
 777   // already checked the next item's data type in CheckDataType(). Note
 778   // that dbus_message_iter_get_basic() is a void function.
 779   dbus_message_iter_get_basic(&raw_message_iter_, value);
 780   DCHECK(value);
 781   dbus_message_iter_next(&raw_message_iter_);
 782   return true;
 783 }
 784
 785 bool MessageReader::PopContainer(int dbus_type, MessageReader* sub_reader) {
 786   DCHECK_NE(this, sub_reader);
 787
 788   if (!CheckDataType(dbus_type))
 789     return false;
 790   dbus_message_iter_recurse(&raw_message_iter_,
 791                             &sub_reader->raw_message_iter_);
 792   dbus_message_iter_next(&raw_message_iter_);
 793   return true;
 794 }
 795
 796 bool MessageReader::PopVariantOfBasic(int dbus_type, void* value) {
 797   dbus::MessageReader variant_reader(message_);
 798   if (!PopVariant(&variant_reader))
 799     return false;
 800   return variant_reader.PopBasic(dbus_type, value);
 801 }
 802
 803 }  // namespace dbus