libkdbinder: kdbus: return Reply objects

This commit changes all the Connection method to return a Reply object
holding the error code and string. For methods that dequeue a message,
we return a DataReply object with the message instead of using output
arguments.

The concerned API is:

~~~
const Reply queue_message(uint64_t dst_id,
                          const uint8_t *data,
                          uint64_t size,
                          uint64_t cookie = 0) const;

const DataReply dequeue_message() const;
const DataReply dequeue_message_blocking(int timeout_ms = -1) const;

const DataReply transact(uint64_t dst_id,
                         uint64_t cookie,
                         const uint8_t *data,
                         uint64_t size,
                         uint64_t timeout_ms) const;

const Reply reply(uint64_t dst_id,
                  uint64_t cookie,
                  const uint8_t *data,
                  uint64_t size) const;
~~~

Change-Id: I4019ae9f07a248305a8347c87506ef17b65af1d7

1 files changed, 63 insertions, 74 deletions

diff --git a/libs/kdbinder/kdbus/connection.cpp b/libs/kdbinder/kdbus/connection.cpp
index 6b432b3..65ee566 100644
--- a/libs/kdbinder/kdbus/connection.cpp
+++ b/libs/kdbinder/kdbus/connection.cpp
@@ -85,7 +85,8 @@ std::unique_ptr<Connection> Connection::hello(
   return std::unique_ptr<Connection>(new Connection(bus_file, reply.id, buf));
 }
 
-int Connection::acquire_name(const std::string& name, uint64_t flags) const {
+const Reply Connection::acquire_name(const std::string& name,
+                                     uint64_t flags) const {
   // struct kdbus_cmd_name requires a KDBUS_ITEM_NAME.
   auto reply = send_command_name_acquire(bus_file_.get(),
                                          flags,
@@ -98,10 +99,10 @@ int Connection::acquire_name(const std::string& name, uint64_t flags) const {
           reply.error_string.c_str());
   }
 
-  return reply.error_code;;
+  return reply;
 }
 
-int Connection::release_name(const std::string& name) const {
+const Reply Connection::release_name(const std::string& name) const {
   // struct kdbus_cmd_name requires a KDBUS_ITEM_NAME.
   auto reply = send_command_name_release(bus_file_.get(), ItemName(name));
 
@@ -112,7 +113,7 @@ int Connection::release_name(const std::string& name) const {
           reply.error_string.c_str());
   }
 
-  return reply.error_code;;
+  return reply;
 }
 
 std::vector<NameInfo> Connection::name_list(uint64_t flags) const {
@@ -160,17 +161,17 @@ std::vector<NameInfo> Connection::name_list(uint64_t flags) const {
   return list_vector;
 }
 
-int Connection::queue_message(const Connection& dst,
-                              const uint8_t *data,
-                              uint64_t size,
-                              uint64_t cookie) const {
+const Reply Connection::queue_message(const Connection& dst,
+                                      const uint8_t *data,
+                                      uint64_t size,
+                                      uint64_t cookie) const {
   return queue_message(dst.id, data, size, cookie);
 }
 
-int Connection::queue_message(uint64_t dst_id,
-                              const uint8_t *data,
-                              uint64_t size,
-                              uint64_t cookie) const {
+const Reply Connection::queue_message(uint64_t dst_id,
+                                      const uint8_t *data,
+                                      uint64_t size,
+                                      uint64_t cookie) const {
   // When sending a asynchronous message, we do not need to use cookies so we
   // set it to 0. We are using cookies only for messages which expect a reply.
   Message message(dst_id, id, cookie, 0, ItemPayloadVec(data, size));
@@ -183,48 +184,41 @@ int Connection::queue_message(uint64_t dst_id,
           reply.error_string.c_str());
   }
 
-  return reply.error_code;
+  return reply;
 }
 
-int Connection::dequeue_message(uint8_t **data,
-                                uint64_t *size,
-                                uint64_t *src,
-                                uint64_t *cookie) const {
+const DataReply Connection::dequeue_message() const {
   auto reply = send_command_receive_message(bus_file_.get());
   if (reply.error_code < 0) {
     ALOGE("ID %d could not dequeue message: %s\n",
           (int) id,
           reply.error_string.c_str());
-    return reply.error_code;
+    return DataReply(reply);
   }
 
   struct kdbus_msg *msg = reinterpret_cast<struct kdbus_msg *>(
       reinterpret_cast<uint8_t *>(buf_.get()) + reply.offset);
   struct kdbus_item *item = nullptr;
-
-  if (src != nullptr)
-    *src = msg->src_id;
-  if (cookie != nullptr)
-    *cookie = msg->cookie;
+  uint64_t size;
+  uint8_t *data;
 
   // TODO: parse the rest of the items for extra information.
   for_each_item(msg, [&data, this, &size](struct kdbus_item *item) {
-    if (item->type == KDBUS_ITEM_PAYLOAD_OFF) {
-      // This is potentially unsafe, as we are returning a pointer to the buffer
-      // owned by the connection.
-      *size = item->vec.size;
-      *data = reinterpret_cast<uint8_t *>(buf_.get()) + item->vec.offset;
+    switch (item->type) {
+      case KDBUS_ITEM_PAYLOAD_OFF: {
+        // This is potentially unsafe, as we are returning a pointer to the buffer
+        // owned by the connection.
+        size = item->vec.size;
+        data = reinterpret_cast<uint8_t *>(buf_.get()) + item->vec.offset;
+        break;
+      }
     }
   });
 
-  return reply.error_code;
+  return DataReply(reply, data, size, reply.offset, msg->src_id, msg->cookie);
 }
 
-int Connection::dequeue_message_blocking(uint8_t **data,
-                                         uint64_t *size,
-                                         uint64_t *src,
-                                         uint64_t *cookie,
-                                         int timeout_ms) const {
+const DataReply Connection::dequeue_message_blocking(int timeout_ms) const {
   struct pollfd pollfd = {
     .fd = fileno(bus_file_.get()),
     .events = POLLIN | POLLPRI | POLLHUP,
@@ -237,10 +231,10 @@ int Connection::dequeue_message_blocking(uint8_t **data,
     ALOGW("ID %d timed out dequeuing a message: timeout of %d ms\n",
           (int) id,
           timeout_ms);
-    return -ETIMEDOUT;
+    return DataReply(Reply(-ETIMEDOUT, std::string(strerror(-errno))));
   } else if (ret > 0) {
     if (pollfd.revents & POLLIN) {
-      ret = dequeue_message(data, size, src, cookie);
+      return dequeue_message();
     }
 
     if (pollfd.revents & (POLLHUP | POLLERR)) {
@@ -248,39 +242,27 @@ int Connection::dequeue_message_blocking(uint8_t **data,
     }
   }
 
-  rewind(bus_file_.get());
-
-  return ret;
+  return DataReply(Reply(ret, std::string(strerror(-errno))));
 }
 
-int Connection::transact(const Connection& dst,
-                         uint64_t cookie,
-                         const uint8_t *data_in,
-                         uint64_t size_in,
-                         uint8_t **data_out,
-                         uint64_t *size_out,
-                         uint64_t timeout_ms) const {
-  return transact(dst.id,
-                  cookie,
-                  data_in,
-                  size_in,
-                  data_out,
-                  size_out,
-                  timeout_ms);
+const DataReply Connection::transact(const Connection& dst,
+                                     uint64_t cookie,
+                                     const uint8_t *data,
+                                     uint64_t size,
+                                     uint64_t timeout_ms) const {
+  return transact(dst.id, cookie, data, size, timeout_ms);
 }
 
-int Connection::transact(uint64_t dst_id,
-                         uint64_t cookie,
-                         const uint8_t *data_in,
-                         uint64_t size_in,
-                         uint8_t **data_out,
-                         uint64_t *size_out,
-                         uint64_t timeout_ms) const {
+const DataReply Connection::transact(uint64_t dst_id,
+                                     uint64_t cookie,
+                                     const uint8_t *data,
+                                     uint64_t size,
+                                     uint64_t timeout_ms) const {
   MessageSync message(dst_id,
                       id,
                       cookie,
                       timeout_ms,
-                      ItemPayloadVec(data_in, size_in));
+                      ItemPayloadVec(data, size));
 
   auto reply = send_command_transact_message(bus_file_.get(), message);
 
@@ -288,35 +270,42 @@ int Connection::transact(uint64_t dst_id,
     ALOGE("ID %d could not issue transaction: %s\n",
           (int) id,
           reply.error_string.c_str());
-    return reply.error_code;
+    return DataReply(reply);
   }
 
   struct kdbus_msg *msg = reinterpret_cast<struct kdbus_msg *>(
       reinterpret_cast<uint8_t *>(buf_.get()) + reply.offset);
   struct kdbus_item *item = nullptr;
+  uint8_t *data_out;
+  uint64_t size_out;
 
   // TODO: parse the rest of the items for extra information.
   for_each_item(msg, [&data_out, this, &size_out](struct kdbus_item *item) {
     if (item->type == KDBUS_ITEM_PAYLOAD_OFF) {
-      *size_out = item->vec.size;
-      *data_out = reinterpret_cast<uint8_t *>(buf_.get()) + item->vec.offset;
+      size_out = item->vec.size;
+      data_out = reinterpret_cast<uint8_t *>(buf_.get()) + item->vec.offset;
     }
   });
 
-  return reply.error_code;
+  return DataReply(reply,
+                   data_out,
+                   size_out,
+                   reply.offset,
+                   msg->src_id,
+                   msg->cookie);
 }
 
-int Connection::reply(const Connection& dst,
-                      uint64_t cookie,
-                      const uint8_t *data,
-                      uint64_t size) const {
+const Reply Connection::reply(const Connection& dst,
+                              uint64_t cookie,
+                              const uint8_t *data,
+                              uint64_t size) const {
   return reply(dst.id, cookie, data, size);
 }
 
-int Connection::reply(uint64_t dst_id,
-                      uint64_t cookie,
-                      const uint8_t *data,
-                      uint64_t size) const {
+const Reply Connection::reply(uint64_t dst_id,
+                              uint64_t cookie,
+                              const uint8_t *data,
+                              uint64_t size) const {
   MessageReply message(dst_id, id, cookie, ItemPayloadVec(data, size));
 
   auto reply = send_command_send_message(bus_file_.get(), message);
@@ -327,7 +316,7 @@ int Connection::reply(uint64_t dst_id,
           reply.error_string.c_str());
   }
 
-  return reply.error_code;
+  return reply;
 }
 
 }  // namespace kdbus