comp-manger: Send/Receive buffered data instead of string

Application can send buffered data with length, sending it as string
incomplete data would be received. This patch sends data as string after
encoding it to Base64 and on receiver side decodes it before providing
data to upper layer

Signed-off-by: Saurav Babu <saurav.babu@samsung.com>

diff --git a/src/companion-manager/include/comp_gdbus_group.h b/src/companion-manager/include/comp_gdbus_group.h
index 5d8c9f442389a2c688e184d942614b35ba1dc669..6bcf0c06789b03b4909fb9a64b0999e4a9853dd1 100644 (file)
--- a/src/companion-manager/include/comp_gdbus_group.h
+++ b/src/companion-manager/include/comp_gdbus_group.h
@@ -75,7 +75,8 @@ gboolean group_unpair_resource(Group *group, GDBusMethodInvocation *invocation,
        gchar *uuid_dev1, gchar *uuid_dev2, gpointer user_data);
 
 gboolean group_send_data(Group *group, GDBusMethodInvocation *invocation,
-       gchar *uuid_dev, gchar *addr, int port, gchar *data, int len, gpointer user_data);
+       gchar *uuid_dev, gchar *addr, int port, GVariant *params,
+       gpointer user_data);
 
 gboolean group_find_mowned_devices(Group *group,
        GDBusMethodInvocation *invocation, int timeout, gpointer user_data);
@@ -111,8 +112,8 @@ void notify_mowned_device_found(int device_count, GVariant *device_data);
 void notify_mowned_device_find_finish(int ret);
 void notify_group_join(int result);
 void notify_send_data_finish(const char *resp_data, int ret);
-void notify_request_result(const char *cmd, const char *requester_id, char *arg,
-                                                  int ret);
+void notify_request_result(const char *cmd, const char *requester_id,
+                                                  unsigned char *arg, int len, int ret);
 
 #ifdef __cplusplus
 }

diff --git a/src/companion-manager/include/comp_group.h b/src/companion-manager/include/comp_group.h
index aea6b793ad730cc7d3ac73da630d71ebce165bbd..cdc66463b55047ba0924c0fc648d257535498183 100755 (executable)
--- a/src/companion-manager/include/comp_group.h
+++ b/src/companion-manager/include/comp_group.h
@@ -104,7 +104,8 @@ int comp_group_pair_resource(char* target1, char *subject1, char *uri1,
        char *uri2, char *rt2, char *interface2, int permission2);
 
 int comp_group_unpair_resource(gchar *uuid_dev1, gchar *uuid_dev2);
-int comp_group_send_data(gchar *uuid_dev, gchar *addr, int port, gchar *data, int len);
+int comp_group_send_data(gchar *uuid_dev, gchar *addr, int port,
+                                                unsigned char *data, int len);
 
 GVariant *comp_group_get_remote_mot_enabled_devices();
 int comp_group_get_mot_device_count();

diff --git a/src/companion-manager/include/comp_iot.h b/src/companion-manager/include/comp_iot.h
index 957d96fd287115164f7bf642786433ce3d7c5d32..c0b7c774e334bb6564a82a15e8c1c7abab00ce96 100644 (file)
--- a/src/companion-manager/include/comp_iot.h
+++ b/src/companion-manager/include/comp_iot.h
@@ -40,12 +40,13 @@ typedef struct _comp_command_t {
        gchar *uuid; /**< Device UUID */
        gchar *host; /**< Host address + Port */
        gchar *arg1; /**< Arguement #1 */
-#ifdef SUPPORT_BASE64_ENCODING
-       int arg1_len; /**< Arguement #1 length */
-#endif
        gchar *arg2; /**< Arguement #2 */
        gchar *arg3; /**< Arguement #3 */
        gchar *arg4; /**< Arguement #4 */
+#ifdef SUPPORT_BASE64_ENCODING
+       unsigned char *data;
+       int data_len;
+#endif
 } comp_command_t;
 
 int comp_iot_initialize();
@@ -59,4 +60,4 @@ int comp_iot_deinitialize();
 #ifdef __cplusplus
 }
 #endif
-#endif /* __COMP_IOT_H__ */
\ No newline at end of file
+#endif /* __COMP_IOT_H__ */

diff --git a/src/companion-manager/src/comp_gdbus_group.c b/src/companion-manager/src/comp_gdbus_group.c
index 22ffac26eb59d62d2bb5acd82cf66c7ed98b5bcf..8b69917c05d3d6b3edd4a3d5d2fa9e4641fd6842 100644 (file)
--- a/src/companion-manager/src/comp_gdbus_group.c
+++ b/src/companion-manager/src/comp_gdbus_group.c
@@ -227,12 +227,31 @@ gboolean group_unpair_resource(Group *group, GDBusMethodInvocation *invocation,
 }
 
 gboolean group_send_data(Group *group, GDBusMethodInvocation *invocation,
-       gchar *uuid_dev, gchar *addr, int port, gchar *data, int len, gpointer user_data)
+       gchar *uuid_dev, gchar *addr, int port, GVariant *params,
+       gpointer user_data)
 {
        int ret = 0;
+       int length = 0;
+       int len;
+       unsigned char *data;
+       GVariantIter *iter;
 
        LOG_DEBUG("send data called using dbus successful");
 
+       g_variant_get(params, "(iay)", &len, &iter);
+
+       data = g_try_malloc0(len);
+       if (NULL == data) {
+               group_complete_send_data(group, invocation, -1);
+               LOG_ERR("Failed to allocate memory");
+               return TRUE;
+       }
+
+       while (g_variant_iter_loop(iter, "y", &data[length]))
+               length += 1;
+
+       g_variant_iter_free(iter);
+
        ret = comp_group_send_data(uuid_dev, addr, port, data, len);
 
        group_complete_send_data(group, invocation, 0);
@@ -401,10 +420,22 @@ void notify_send_data_finish(const char *resp_data, int ret)
        group_emit_send_data_finish(group_dbus_get_object(), resp_data, ret);
 }
 
-void notify_request_result(const char *cmd, const char *requester_id, char *arg,
-                                                  int ret)
+void notify_request_result(const char *cmd, const char *requester_id,
+                                                  unsigned char *arg, int len, int ret)
 {
-       group_emit_request_result(group_dbus_get_object(), cmd, requester_id, arg,
-                                                         ret);
+       GVariantBuilder *bytearray_builder = NULL;
+       GVariant *params = NULL;
+       int i;
+
+       bytearray_builder = g_variant_builder_new(G_VARIANT_TYPE("ay"));
+
+       for (i = 0; i < len; i++)
+               g_variant_builder_add(bytearray_builder, "y", arg[i]);
+
+       params = g_variant_new("(iay)", len, bytearray_builder);
+       g_variant_builder_unref(bytearray_builder);
+
+       group_emit_request_result(group_dbus_get_object(), cmd, requester_id,
+                                                         params, ret);
 }
 

diff --git a/src/companion-manager/src/comp_group.c b/src/companion-manager/src/comp_group.c
index c3bd8baea1f57fe2fa177ad80ae6dc7fe096deeb..df6bbb8bf9f596f13b011fbfcff71e9f6a532bf5 100755 (executable)
--- a/src/companion-manager/src/comp_group.c
+++ b/src/companion-manager/src/comp_group.c
@@ -654,8 +654,8 @@ static char *_addr2host(char *addr, int port)
                return g_strdup_printf("coaps://%s:%d", ip, port);
 }
 
-int comp_group_send_data(gchar *uuid_dev, gchar *addr, int port, gchar *data,
-                                                int len)
+int comp_group_send_data(gchar *uuid_dev, gchar *addr, int port,
+                                                unsigned char *data, int len)
 {
        int ret;
 
@@ -667,17 +667,18 @@ int comp_group_send_data(gchar *uuid_dev, gchar *addr, int port, gchar *data,
 
        cmd->host = _addr2host(addr, port);
 
-       cmd->arg1 = g_malloc0(len + 1);
-       if (NULL == cmd->arg1) {
+       cmd->data = g_malloc0(len + 1);
+       if (NULL == cmd->data) {
                ret = COMP_ERROR_OUT_OF_MEMORY;
                LOG_ERR("Send Data Fail to uuid = %s host %s error=%s",
                        cmd->uuid, cmd->host, comp_log_get_error_string(ret));
                return ret;
        }
-       memcpy(cmd->arg1, data, len);
 #ifdef SUPPORT_BASE64_ENCODING
-       cmd->arg1_len = len;
+       memcpy(cmd->data, data, len);
+       cmd->data_len = len;
 #else
+       memcpy(cmd->arg1, data, len);
        cmd->arg1[len] = '\0';
 #endif
 

diff --git a/src/companion-manager/src/comp_iot.cpp b/src/companion-manager/src/comp_iot.cpp
index 2f1143e880fd9e2adefbc96ce81797b047c50a97..550082c76ce69aabcda6716ba291872db0be3191 100755 (executable)
--- a/src/companion-manager/src/comp_iot.cpp
+++ b/src/companion-manager/src/comp_iot.cpp
@@ -372,10 +372,17 @@ OCEntityHandlerResult _request_handler(std::shared_ptr<OCResourceRequest> reques
                if (requestFlag & RequestHandlerFlag::RequestFlag) {
                        LOG_DEBUG("requestFlag : Request");
                        auto pResponse = std::make_shared<OC::OCResourceResponse>();
-                       char *arg = NULL;
+                       unsigned char *arg = NULL;
+                       int arg_len = 0;
                        int result;
                        int cmd;
                        std::string requester_id, group_name, uuid, data;
+#ifdef SUPPORT_BASE64_ENCODING
+                       int payload_len;
+                       size_t outSize;
+                       uint8_t *out;
+                       uint32_t len = 0;
+#endif
                        comp_context_t *comp_ctx;
 
                        try {
@@ -399,11 +406,8 @@ OCEntityHandlerResult _request_handler(std::shared_ptr<OCResourceRequest> reques
 
                                switch(cmd) {
                                case COMP_REQ_SEND_DATA:
-#ifdef SUPPORT_BASE64_ENCODING
-                                       int payload_len;
-
                                        LOG_DEBUG("Receive Data");
-
+#ifdef SUPPORT_BASE64_ENCODING
                                        if (!rep.getValue("data", data))
                                                LOG_ERR("data not found");
 
@@ -418,28 +422,31 @@ OCEntityHandlerResult _request_handler(std::shared_ptr<OCResourceRequest> reques
                                        LOG_DEBUG("data = %s payload_len = %d", data.c_str(),
                                                          payload_len);
 
-                                       size_t outSize = B64DECODE_OUT_SAFESIZE(payload_len + 1);
-                                       uint8_t* out = g_malloc0(outSize);
+                                       outSize = B64DECODE_OUT_SAFESIZE(payload_len + 1);
+                                       out = (uint8_t *)g_malloc0(outSize);
                                        if (NULL == out) {
                                                LOG_ERR("Can't allocate memory for base64 str");
-                                               return;
+                                               return OC_EH_OK;
                                        }
-                                       uint32_t len = 0;
 
-                                       if (B64_OK == b64Decode(data.c_str(), payload_len, out,
+                                       if (B64_OK != b64Decode(data.c_str(), payload_len, out,
                                                                                   outSize, &len)) {
                                                LOG_ERR("Base64 decoding failed.");
-                                               return;
+                                               return OC_EH_OK;
                                        }
+
+                                       arg = (unsigned char *) g_try_malloc0(len);
                                        memcpy(arg, out, len);
+                                       arg_len = len;
 
-                                       LOG_DEBUG("successfully decoded to base64. %s", arg);
+                                       LOG_DEBUG("Successfully decoded from base64");
 #else
                                        if (!rep.getValue("data", data))
                                                LOG_ERR("data not found");
 
                                        LOG_DEBUG("Receive Data = %s", data.c_str());
-                                       arg = g_strdup(data.c_str());
+                                       arg = (unsigned char *) g_strdup(data.c_str());
+                                       arg_len = strlen(data.c_str());
 #endif
                                        break;
                                case COMP_REQ_CREATE_GROUP:
@@ -448,7 +455,8 @@ OCEntityHandlerResult _request_handler(std::shared_ptr<OCResourceRequest> reques
                                        if (rep.getValue("name", group_name)) {
                                                LOG_DEBUG("group_name : %s", group_name.c_str());
                                                result = comp_group_create(group_name.c_str());
-                                               arg = g_strdup(group_name.c_str());
+                                               arg = (unsigned char *) g_strdup(group_name.c_str());
+                                               arg_len = strlen(group_name.c_str());
                                        }
                                        break;
                                case COMP_REQ_INVITE_DEVICE:
@@ -464,7 +472,8 @@ OCEntityHandlerResult _request_handler(std::shared_ptr<OCResourceRequest> reques
 
                                        result = comp_group_invite(group_name.c_str(),
                                                                   uuid.c_str(), "12341234");
-                                       arg = g_strdup(uuid.c_str());
+                                       arg = (unsigned char *) g_strdup(uuid.c_str());
+                                       arg_len = strlen(uuid.c_str());
                                        break;
                                case COMP_REQ_EJECT_DEVICE:
                                        LOG_DEBUG("Request eject device");
@@ -482,11 +491,13 @@ OCEntityHandlerResult _request_handler(std::shared_ptr<OCResourceRequest> reques
 
                                        result = comp_group_eject(group_name.c_str(), comp_ctx->device_uuid,
                                                                   uuid.c_str());
-                                       arg = g_strdup(uuid.c_str());
+                                       arg = (unsigned char *) g_strdup(uuid.c_str());
+                                       arg_len = strlen(uuid.c_str());
                                        break;
                                case COMP_REQ_DELETE_GROUP:
                                        LOG_DEBUG("Request delete group");
-                                       arg = g_strdup("DELETED");
+                                       arg = (unsigned char *) g_strdup("DELETED");
+                                       arg_len = strlen("DELETED");
                                        break;
                                default:
                                        LOG_ERR("Unknown request command %d", cmd);
@@ -494,7 +505,7 @@ OCEntityHandlerResult _request_handler(std::shared_ptr<OCResourceRequest> reques
                                }
 
                                notify_request_result(command2string((comp_request_type_e) cmd),
-                                                                         requester_id.c_str(), arg, result);
+                                                                 requester_id.c_str(), arg, arg_len, result);
 
                                g_free(arg);
 
@@ -689,13 +700,13 @@ static bool _found_resource(std::shared_ptr<OCResource> resource,
 #ifdef SUPPORT_BASE64_ENCODING
                                                uint32_t outSize = 0;
                                                size_t b64BufSize = B64ENCODE_OUT_SAFESIZE(
-                                                                               (cmd->arg1_len + 1));
-                                               char* b64Buf = g_malloc0(b64BufSize);
+                                                                          (cmd->data_len + 1));
+                                               char *b64Buf = (char *) g_malloc0(b64BufSize);
                                                if (NULL == b64Buf) {
                                                        _clear_user_data(cmd);
                                                        return TRUE;
                                                }
-                                               b64Encode((const char *)cmd->arg1, cmd->arg1_len,
+                                               b64Encode(cmd->data, cmd->data_len,
                                                                  b64Buf, b64BufSize, &outSize);
                                                b64Buf[b64BufSize] = '\0';
                                                rep.setValue("data", std::string(b64Buf));
@@ -821,9 +832,30 @@ int comp_iot_send_data(comp_resource_type_e resource_type, int timeout,
                comp_context_t *comp_ctx = comp_context_get_context();
                rep.setValue("device_id", std::string(comp_ctx->device_uuid));
 
+#ifdef SUPPORT_BASE64_ENCODING
+               uint32_t outSize = 0;
+               size_t b64BufSize;
+               char *b64Buf;
+#endif
                switch (cmd->command) {
                case COMP_REQ_SEND_DATA:
+#ifdef SUPPORT_BASE64_ENCODING
+                       b64BufSize = B64ENCODE_OUT_SAFESIZE((cmd->data_len + 1));
+                       b64Buf = (char *) g_malloc0(b64BufSize);
+                       if (NULL == b64Buf) {
+                               _clear_user_data(cmd);
+                               return TRUE;
+                       }
+                       b64Encode(cmd->data, cmd->data_len,
+                                         b64Buf, b64BufSize, &outSize);
+                       b64Buf[b64BufSize] = '\0';
+                       rep.setValue("data", std::string(b64Buf));
+                       LOG_DEBUG("b64BufSize =%d outSize = %d b64Buf = %s",
+                                         b64BufSize, outSize, b64Buf);
+                       g_free(b64Buf);
+#else
                        rep.setValue("data", std::string(cmd->arg1));
+#endif
                        break;
                case COMP_REQ_CREATE_GROUP:
                case COMP_REQ_DELETE_GROUP:

diff --git a/src/companion-manager/src/companion_gdbus.xml b/src/companion-manager/src/companion_gdbus.xml
index 8eca1c429e30a7af93aef124dab30edeb75f7536..94e1fa55591b7bf93c1ef4f01634c00025e7fc9b 100644 (file)
--- a/src/companion-manager/src/companion_gdbus.xml
+++ b/src/companion-manager/src/companion_gdbus.xml
@@ -98,8 +98,7 @@
                        <arg type="s" name="uuid" direction="in" />
                        <arg type="s" name="addr" direction="in"/>
                        <arg type="i" name="port" direction="in"/>
-                       <arg type="s" name="data" direction="in"/>
-                       <arg type="i" name="len" direction="in"/>
+                       <arg type="(iay)" name="data" direction="in"/>
                        <arg type="i" name="result" direction="out" />
                </method>
                <method name="FindMownedDevices">
@@ -176,7 +175,7 @@
                <signal name="RequestResult">
                        <arg type="s" name="command" direction="out" />
                        <arg type="s" name="device_id" direction="out" />
-                       <arg type="s" name="arg" direction="out" />
+                       <arg type="(iay)" name="arg" direction="out" />
                        <arg type="i" name="result" direction="out" />
                </signal>
        </interface>