Add mdgd send data using channel id

Signed-off-by: Jihoon Jung <jh8801.jung@samsung.com>

diff --git a/src/mdg-manager/include/mdgd_group.h b/src/mdg-manager/include/mdgd_group.h
index fa30d14f3b01114b4704a0eb8ffd5fe4c1d5b6b7..d82cb8d8dc4ee49e6d688abc39fddcc72c7b467a 100755 (executable)
--- a/src/mdg-manager/include/mdgd_group.h
+++ b/src/mdg-manager/include/mdgd_group.h
@@ -36,7 +36,7 @@ int mdgd_group_eject_device(char *sender, const char *group_name, const char *uu
 
 int mdgd_group_regist_channel(char *sender, char *channel_id);
 int mdgd_group_unregist_channel(char *sender, char *channel_id);
-int mdgd_group_send_data(char *sender, gchar *uuid_dev, gchar *addr, int port,
+int mdgd_group_send_data(char *sender, char *uuid, char *addr, int port, char *channel_id,
                                                 unsigned char *data, int len);
 
 /* Group Request to remote */

diff --git a/src/mdg-manager/include/mdgd_typedef.h b/src/mdg-manager/include/mdgd_typedef.h
index 039112eeb99ec3e400eaf1d8892585d05499f2c5..a30d1590fb59323d1f8e8a7cbc42e171cbec40f3 100755 (executable)
--- a/src/mdg-manager/include/mdgd_typedef.h
+++ b/src/mdg-manager/include/mdgd_typedef.h
@@ -116,6 +116,7 @@ typedef enum {
        MDGD_EVENT_REQUEST_FINISH,
        MDGD_EVENT_SEND_DATA_FINISH,
        MDGD_EVENT_REQ_CHANNEL_LIST_FINISH,
+       MDGD_EVENT_RECEIVE_DATA,
 } mdgd_event_type_e;
 
 typedef struct {
@@ -145,6 +146,13 @@ typedef struct {
        char *channel_id;
 } mdgd_channel_t;
 
+typedef struct {
+       char *device_id;
+       char *channel_id;
+       unsigned char *data;
+       int data_length;
+} mdgd_data_t;
+
 typedef struct {
        GMainLoop *main_loop;
        GHashTable *channel;

diff --git a/src/mdg-manager/include/mdgd_util.h b/src/mdg-manager/include/mdgd_util.h
index e6433c781c83678e7b089967800667a962d24036..88d23e15535505c0f26e61c7a1071b75f0101138 100755 (executable)
--- a/src/mdg-manager/include/mdgd_util.h
+++ b/src/mdg-manager/include/mdgd_util.h
@@ -39,6 +39,7 @@ void mdgd_clean_user_data(void *user_data);
 GVariant *mdgd_create_variant_group(mdgd_group_t *group);
 GVariant *mdgd_create_variant_device(mdgd_device_t *device);
 GVariant *mdgd_create_variant_channel(mdgd_channel_t *channel);
+GVariant *mdgd_create_variant_data(mdgd_data_t *data);
 GVariant *mdgd_create_variant_dummy();
 
 

diff --git a/src/mdg-manager/src/mdg_gdbus.xml b/src/mdg-manager/src/mdg_gdbus.xml
index a03aaf6d63dd7027b1ff58f9d69513c423f151b1..cf634b5a9f4960035f1d82c938b1548bff719043 100755 (executable)
--- a/src/mdg-manager/src/mdg_gdbus.xml
+++ b/src/mdg-manager/src/mdg_gdbus.xml
@@ -60,6 +60,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="channel_id" direction="in"/>
                        <arg type="(iay)" name="data" direction="in"/>
                        <arg type="i" name="result" direction="out" />
                </method>

diff --git a/src/mdg-manager/src/mdgd_gdbus.c b/src/mdg-manager/src/mdgd_gdbus.c
index 03695a0ea981fbca803c7b2ea4a9a09f2f1de3e7..b63b47dd4c12ff7ecb8be821bb1d19ae53a5f7ac 100755 (executable)
--- a/src/mdg-manager/src/mdgd_gdbus.c
+++ b/src/mdg-manager/src/mdgd_gdbus.c
@@ -200,7 +200,7 @@ gboolean group_unregist_channel(Group *group, GDBusMethodInvocation *invocation,
 }
 
 gboolean group_send_data(Group *group, GDBusMethodInvocation *invocation,
-       gchar *uuid_dev, gchar *addr, int port, GVariant *params,
+       gchar *uuid, gchar *addr, int port, gchar *channel_id, GVariant *params,
        gpointer user_data)
 {
        int ret = MDGD_ERROR_UNKNOWN;
@@ -227,7 +227,7 @@ gboolean group_send_data(Group *group, GDBusMethodInvocation *invocation,
 
        g_variant_iter_free(iter);
 
-       ret = mdgd_group_send_data(sender, uuid_dev, addr, port, data, len);
+       ret = mdgd_group_send_data(sender, uuid, addr, port, channel_id, data, len);
 
        group_complete_send_data(group, invocation, 0);
 

diff --git a/src/mdg-manager/src/mdgd_group.c b/src/mdg-manager/src/mdgd_group.c
index d26b286728929e7e0a1ba1dfee9ff781f91e019c..c3c635aef09bc3a6fdf7ccd7182bd5023381507c 100755 (executable)
--- a/src/mdg-manager/src/mdgd_group.c
+++ b/src/mdg-manager/src/mdgd_group.c
@@ -239,7 +239,7 @@ int mdgd_group_unregist_channel(char *sender, char *channel_id)
        return ret;
 }
 
-int mdgd_group_send_data(char *sender, gchar *uuid_dev, gchar *addr, int port,
+int mdgd_group_send_data(char *sender, char *uuid, char *addr, int port, char *channel_id,
                                                 unsigned char *data, int len)
 {
        int ret;
@@ -254,10 +254,11 @@ int mdgd_group_send_data(char *sender, gchar *uuid_dev, gchar *addr, int port,
        }
 
        cmd->command = MDGD_REQ_SEND_DATA;
-       cmd->uuid = g_strdup(uuid_dev);
+       cmd->uuid = g_strdup(uuid);
        cmd->sender = g_strdup(sender);
 
        cmd->host = mdgd_addr2host(addr, port, true);
+       cmd->arg1 = g_strdup(channel_id);
 
 #ifdef SUPPORT_BASE64_ENCODING
        cmd->data = g_try_malloc0(len + 1);
@@ -271,7 +272,7 @@ int mdgd_group_send_data(char *sender, gchar *uuid_dev, gchar *addr, int port,
        memcpy(cmd->data, data, len);
        cmd->data_len = len;
 #else
-       cmd->arg1 = g_try_malloc0(len + 1);
+       cmd->arg2 = g_try_malloc0(len + 1);
        if (NULL == cmd->arg1) {
                ret = MDGD_ERROR_OUT_OF_MEMORY;
                LOG_ERR("Send Data Fail to uuid = %s host %s error=%s",
@@ -279,8 +280,8 @@ int mdgd_group_send_data(char *sender, gchar *uuid_dev, gchar *addr, int port,
                return ret;
        }
 
-       memcpy(cmd->arg1, data, len);
-       cmd->arg1[len] = '\0';
+       memcpy(cmd->arg2, data, len);
+       cmd->arg2[len] = '\0';
 #endif
 
        LOG_DEBUG("UUID %s host %s", cmd->uuid, cmd->host);
@@ -426,6 +427,9 @@ int mdgd_group_notify_event(char *sender, mdgd_event_type_e type, int result, vo
        case MDGD_EVENT_REQ_CHANNEL_LIST_FINISH:
                va = mdgd_create_variant_channel((mdgd_channel_t *)user_data);
                break;
+       case MDGD_EVENT_RECEIVE_DATA:
+               va = mdgd_create_variant_data((mdgd_data_t *)user_data);
+               break;
        default:
                LOG_ERR("Unknown event : %d", type);
                break;

diff --git a/src/mdg-manager/src/mdgd_iot_client.cpp b/src/mdg-manager/src/mdgd_iot_client.cpp
index e575eabeb45db1c5e05dd3423f8832ed04b934d9..347ae6faa399717230eb87a6f712573beda06fc0 100755 (executable)
--- a/src/mdg-manager/src/mdgd_iot_client.cpp
+++ b/src/mdg-manager/src/mdgd_iot_client.cpp
@@ -329,6 +329,7 @@ int mdgd_iot_send_data(mdgd_resource_type_e resource_type, mdgd_command_t *cmd)
 #endif
                switch (cmd->command) {
                case MDGD_REQ_SEND_DATA:
+                       rep.setValue("channel_id", std::string(cmd->arg1));
 #ifdef SUPPORT_BASE64_ENCODING
                        b64BufSize = B64ENCODE_OUT_SAFESIZE((cmd->data_len + 1));
                        b64Buf = (char *) g_try_malloc0(b64BufSize + 1);
@@ -339,11 +340,12 @@ int mdgd_iot_send_data(mdgd_resource_type_e resource_type, mdgd_command_t *cmd)
                        b64Encode(cmd->data, cmd->data_len,
                                          b64Buf, b64BufSize, &outSize);
                        rep.setValue("data", std::string(b64Buf));
+                       rep.setValue("data_length", to_string(outSize));
                        LOG_DEBUG("b64BufSize = %d outSize = %d b64Buf = %s",
                                          b64BufSize, outSize, b64Buf);
                        g_free(b64Buf);
 #else
-                       rep.setValue("data", std::string(cmd->arg1));
+                       rep.setValue("data", std::string(cmd->arg2));
 #endif
                        break;
                case MDGD_REQ_CREATE_GROUP:

diff --git a/src/mdg-manager/src/mdgd_iot_server.cpp b/src/mdg-manager/src/mdgd_iot_server.cpp
index 498f974f02978137b5bfe16225315e50e2bd8d43..d9330f3442d8dd2abefba25d708a40b096d3fb41 100755 (executable)
--- a/src/mdg-manager/src/mdgd_iot_server.cpp
+++ b/src/mdg-manager/src/mdgd_iot_server.cpp
@@ -106,11 +106,11 @@ OCEntityHandlerResult _request_handler(std::shared_ptr<OCResourceRequest> reques
                } else if (requestType == "POST") { /* Request Operation */
                        unsigned char *arg = NULL;
                        int arg_len = 0;
-                       int result;
+                       int result = MDGD_ERROR_NONE;
                        int cmd;
-                       std::string requester_id, group_name, uuid, data;
+                       std::string requester_id, group_name, uuid, data, data_length, channel_id;
 #ifdef SUPPORT_BASE64_ENCODING
-                       int payload_len;
+                       int data_len;
                        size_t outSize;
                        uint8_t *out;
                        uint32_t len = 0;
@@ -128,30 +128,36 @@ OCEntityHandlerResult _request_handler(std::shared_ptr<OCResourceRequest> reques
 
                                switch(cmd) {
                                case MDGD_REQ_SEND_DATA:
+                               {
                                        LOG_DEBUG("Receive Data");
+                                       if (!requestRep.getValue("channel_id", channel_id))
+                                               LOG_ERR("channel id not found");
+
+                                       char *sender = (char *)g_hash_table_lookup(mdgd_ctx->channel, channel_id.c_str());
+
 #ifdef SUPPORT_BASE64_ENCODING
                                        if (!requestRep.getValue("data", data))
                                                LOG_ERR("data not found");
 
+                                       if (!requestRep.getValue("data_length", data_length))
+                                               LOG_ERR("data length not found");
+
                                        /*
                                         * BASE64 encoding/decoding system use '=' as padding byte
                                         * But, query parameter does not allow use '=' character.Basically,
                                         * So, in order to use BASE64 as query parameters, we need additioinal length param
                                         * such as 'len=xx'
                                         */
-                                       payload_len = strlen(data.c_str()); /* This data may be cliped the last padding 1~2 bytes ('='/'==') */
-
-                                       LOG_DEBUG("data = %s payload_len = %d", data.c_str(),
-                                                       payload_len);
+                                       data_len = atoi(data_length.c_str());
 
-                                       outSize = B64DECODE_OUT_SAFESIZE(payload_len + 1);
+                                       outSize = B64DECODE_OUT_SAFESIZE(data_len + 1);
                                        out = (uint8_t *)g_try_malloc0(outSize);
                                        if (NULL == out) {
                                                LOG_ERR("Can't allocate memory for base64 str");
                                                return OC_EH_OK;
                                        }
 
-                                       if (B64_OK != b64Decode(data.c_str(), payload_len, out,
+                                       if (B64_OK != b64Decode(data.c_str(), data_len, out,
                                                                                outSize, &len)) {
                                                LOG_ERR("Base64 decoding failed.");
                                                g_free(out);
@@ -164,16 +170,25 @@ OCEntityHandlerResult _request_handler(std::shared_ptr<OCResourceRequest> reques
 
                                        g_free(out);
 
-                                       LOG_DEBUG("Successfully decoded from base64");
+                                       LOG_DEBUG("Successfully decoded from base64 : %s", arg);
 #else
                                        if (!requestRep.getValue("data", data))
                                                LOG_ERR("data not found");
 
                                        LOG_DEBUG("Receive Data = %s", data.c_str());
-                                       arg = (unsigned char *) g_strdup(data.c_str());
+                                       arg = (unsigned char *)g_strdup(data.c_str());
                                        arg_len = strlen(data.c_str());
 #endif
+                                       mdgd_data_t *data_t = g_new0(mdgd_data_t, 1);
+                                       data_t->device_id = g_strdup(requester_id.c_str());
+                                       data_t->data = arg;
+                                       data_t->data_length = arg_len;
+                                       data_t->channel_id = g_strdup(channel_id.c_str());
+
+                                       mdgd_group_notify_event(sender, MDGD_EVENT_RECEIVE_DATA, result, data_t);
+
                                        break;
+                               }
                                case MDGD_REQ_CREATE_GROUP:
                                        LOG_DEBUG("Request create group");
 
@@ -182,8 +197,6 @@ OCEntityHandlerResult _request_handler(std::shared_ptr<OCResourceRequest> reques
                                        if (requestRep.getValue("name", group_name)) {
                                                LOG_DEBUG("group_name : %s", group_name.c_str());
                                                result = mdgd_group_create(group_name.c_str());
-                                               arg = (unsigned char *) g_strdup(group_name.c_str());
-                                               arg_len = strlen(group_name.c_str());
                                        }
                                        break;
                                case MDGD_REQ_INVITE_DEVICE:
@@ -199,8 +212,6 @@ OCEntityHandlerResult _request_handler(std::shared_ptr<OCResourceRequest> reques
 
                                        result = mdgd_group_invite_device("tmp", group_name.c_str(),
                                                uuid.c_str(), "12341234");
-                                       arg = (unsigned char *) g_strdup(uuid.c_str());
-                                       arg_len = strlen(uuid.c_str());
                                        break;
                                case MDGD_REQ_EJECT_DEVICE:
                                        LOG_DEBUG("Request eject device");
@@ -216,8 +227,6 @@ OCEntityHandlerResult _request_handler(std::shared_ptr<OCResourceRequest> reques
 
                                        result = mdgd_group_eject_device("tmp", group_name.c_str(),
                                                uuid.c_str());
-                                       arg = (unsigned char *) g_strdup(uuid.c_str());
-                                       arg_len = strlen(uuid.c_str());
                                        break;
                                case MDGD_REQ_CHANNEL_LIST:
                                        LOG_DEBUG("Request channel list");
@@ -240,7 +249,7 @@ OCEntityHandlerResult _request_handler(std::shared_ptr<OCResourceRequest> reques
 
                                g_free(arg);
                        } catch (std::exception& e) {
-                               LOG_ERR("Exceptioin occured %s", e.what());
+                               LOG_ERR("Exception occured %s", e.what());
                        }
                } else {
                        LOG_ERR("Invalid Request Type");

diff --git a/src/mdg-manager/src/mdgd_util.c b/src/mdg-manager/src/mdgd_util.c
index 13911719a95ef807d1fb7e9d1baa852bd0b8cab5..50964a50ff0efa64e3817db276609720a88f30f3 100755 (executable)
--- a/src/mdg-manager/src/mdgd_util.c
+++ b/src/mdg-manager/src/mdgd_util.c
@@ -500,6 +500,38 @@ GVariant *mdgd_create_variant_channel(mdgd_channel_t *channel)
        return data;
 }
 
+GVariant *mdgd_create_variant_data(mdgd_data_t *data)
+{
+       GVariantBuilder *builder;
+       GVariantBuilder *bytearray_builder = NULL;
+       GVariant *params = NULL;
+
+       bytearray_builder = g_variant_builder_new(G_VARIANT_TYPE("a(y)"));
+       for (int i = 0; i < data->data_length; i++)
+               g_variant_builder_add(bytearray_builder, "(y)", data->data[i]);
+
+       params = g_variant_new("a(y)", bytearray_builder);
+
+       builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
+
+       g_variant_builder_add(builder, "{sv}", "DeviceID",
+                                                       g_variant_new_string(data->device_id));
+       g_variant_builder_add(builder, "{sv}", "ChannelID",
+                                                       g_variant_new_string(data->channel_id));
+       g_variant_builder_add(builder, "{sv}", "Data",
+                                                       g_variant_new_variant(params));
+       g_variant_builder_add(builder, "{sv}", "DataLength",
+                                                       g_variant_new_int32(data->data_length));
+
+       data = g_variant_builder_end(builder);
+
+       g_variant_builder_unref(builder);
+       g_variant_builder_unref(bytearray_builder);
+
+       return data;
+}
+
+
 GVariant *mdgd_create_variant_dummy()
 {
        GVariant *data;