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