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 5d8c9f4..6bcf0c0 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 aea6b79..cdc6646 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 957d96f..c0b7c77 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 22ffac2..8b69917 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 c3bd8ba..df6bbb8 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 2f1143e..550082c 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 8eca1c4..94e1fa5 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>