Home | History | Annotate | Download | only in dbus
      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, &micro);
     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