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