Add command hash table for deallocate memory properly

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

diff --git a/src/mdg-manager/include/mdgd_context.h b/src/mdg-manager/include/mdgd_context.h
old mode 100644 (file)
new mode 100755 (executable)
index c49d356..be29909
--- a/src/mdg-manager/include/mdgd_context.h
+++ b/src/mdg-manager/include/mdgd_context.h
@@ -28,6 +28,11 @@ int mdgd_context_create();
 int mdgd_context_destroy();
 void mdgd_context_mutex_lock();
 void mdgd_context_mutex_unlock();
+void mdgd_context_cmd_lock();
+void mdgd_context_cmd_unlock();
+int mdgd_context_add_command(mdgd_command_t *cmd);
+mdgd_command_t *mdgd_context_get_command(int cmd_id);
+bool mdgd_context_remove_command(int cmd_id);
 
 mdgd_context_t *mdgd_context_get_context();
 

diff --git a/src/mdg-manager/include/mdgd_iot.h b/src/mdg-manager/include/mdgd_iot.h
old mode 100644 (file)
new mode 100755 (executable)
index abe3bc0..53a9820
--- a/src/mdg-manager/include/mdgd_iot.h
+++ b/src/mdg-manager/include/mdgd_iot.h
@@ -40,7 +40,7 @@ int mdgd_iot_initialize();
 int mdgd_iot_add_resource(mdgd_resource_type_e resource_type, const char *uri);
 int mdgd_iot_delete_resource(mdgd_resource_type_e resource_type, const char *uri);
 int mdgd_iot_discovery_resource(mdgd_resource_type_e resource_type, void *user_data);
-int mdgd_iot_get_device_description(mdgd_command_t *cmd, char *host_addr, int conn_type);
+int mdgd_iot_get_device_description(char *host_addr, int conn_type, int cmd_id);
 int mdgd_iot_send_response(char *sender, char *uuid, char *channel_id,
                           int msg_id, unsigned char *data, int len, bool timeout);
 int mdgd_iot_set_preconfigured_pin(char *pin);

diff --git a/src/mdg-manager/include/mdgd_typedef.h b/src/mdg-manager/include/mdgd_typedef.h
index bda0591..61a67f6 100755 (executable)
--- a/src/mdg-manager/include/mdgd_typedef.h
+++ b/src/mdg-manager/include/mdgd_typedef.h
@@ -151,6 +151,7 @@ typedef struct {
 typedef struct {
        GMainLoop *main_loop;
        GHashTable *channel;
+       GHashTable *command;
        GSList *receive_data;
        GSList *send_data;
        int ref_count;
@@ -182,6 +183,7 @@ typedef struct {
        int conn_type;
        void *user_data;
        int msg_id;
+       int timeout_id;
 } mdgd_command_t;
 
 typedef struct {

diff --git a/src/mdg-manager/src/mdgd_context.c b/src/mdg-manager/src/mdgd_context.c
old mode 100644 (file)
new mode 100755 (executable)
index 020d285..8743e6b
--- a/src/mdg-manager/src/mdgd_context.c
+++ b/src/mdg-manager/src/mdgd_context.c
@@ -18,6 +18,8 @@
 #include <mdgd_context.h>
 
 static pthread_mutex_t context_lock = PTHREAD_MUTEX_INITIALIZER;
+static pthread_mutex_t cmd_lock = PTHREAD_MUTEX_INITIALIZER;
+
 static mdgd_context_t *mdgd_ctx;
 
 static void __on_destroy(gpointer data)
@@ -26,6 +28,12 @@ static void __on_destroy(gpointer data)
                g_free(data);
 }
 
+static void __on_command_destroy(gpointer data)
+{
+       if (data != NULL)
+               mdgd_clean_user_data(data);
+}
+
 int mdgd_context_create()
 {
        mdgd_ctx = g_new0(mdgd_context_t, 1);
@@ -35,6 +43,7 @@ int mdgd_context_create()
        }
 
        mdgd_ctx->channel = g_hash_table_new_full(g_str_hash, g_str_equal, __on_destroy, __on_destroy);
+       mdgd_ctx->command = g_hash_table_new_full(g_direct_hash, g_direct_equal, NULL, __on_command_destroy);
 
        return MDGD_ERROR_NONE;
 }
@@ -51,6 +60,18 @@ void mdgd_context_mutex_unlock()
        pthread_mutex_unlock(&context_lock);
 }
 
+void mdgd_context_cmd_lock()
+{
+       LOG_DEBUG("cmd mutex lock");
+       pthread_mutex_lock(&cmd_lock);
+}
+
+void mdgd_context_cmd_unlock()
+{
+       LOG_DEBUG("cmd mutex unlock");
+       pthread_mutex_unlock(&cmd_lock);
+}
+
 int mdgd_context_destroy()
 {
        return MDGD_ERROR_NONE;
@@ -60,3 +81,36 @@ mdgd_context_t *mdgd_context_get_context()
 {
        return mdgd_ctx;
 }
+
+static inline gboolean _timeout_cb(gpointer data)
+{
+       if (data != NULL)
+               mdgd_context_remove_command(GPOINTER_TO_INT(data));
+
+       return G_SOURCE_REMOVE;
+}
+
+int mdgd_context_add_command(mdgd_command_t *cmd)
+{
+       int cmd_id = mdgd_util_get_msg_id();
+
+       cmd->timeout_id = g_timeout_add_seconds(60, _timeout_cb, GINT_TO_POINTER(cmd_id));
+
+       g_hash_table_insert(mdgd_ctx->command, GINT_TO_POINTER(cmd_id), cmd);
+
+       return cmd_id;
+}
+
+mdgd_command_t *mdgd_context_get_command(int cmd_id)
+{
+       return (mdgd_command_t *)g_hash_table_lookup(mdgd_ctx->command, GINT_TO_POINTER(cmd_id));
+}
+
+bool mdgd_context_remove_command(int cmd_id)
+{
+       mdgd_context_cmd_lock();
+       g_hash_table_remove(mdgd_ctx->command, GINT_TO_POINTER(cmd_id));
+       mdgd_context_cmd_unlock();
+
+       return true;
+}

diff --git a/src/mdg-manager/src/mdgd_group.c b/src/mdg-manager/src/mdgd_group.c
index a7d7846..ec6bffa 100755 (executable)
--- a/src/mdg-manager/src/mdgd_group.c
+++ b/src/mdg-manager/src/mdgd_group.c
@@ -97,22 +97,37 @@ int mdgd_group_delete(char *name)
 static gboolean __timeout_cb(gpointer data)
 {
        int ret = MDGD_ERROR_NONE;
-       mdgd_command_t *cmd = (mdgd_command_t *)data;
-       if (!cmd) {
+
+       if (!data) {
                LOG_ERR("cmd is null");
                return false;
        }
 
        LOG_BEGIN();
 
+       int cmd_id = GPOINTER_TO_INT(data);
+
+       mdgd_context_cmd_lock();
+
+       mdgd_command_t *cmd = mdgd_context_get_command(cmd_id);
+       if (cmd == NULL) {
+               LOG_ERR("cmd not exists");
+               mdgd_context_mutex_unlock();
+               return false;
+       }
+
        if (cmd->resource_type == MDGD_RESOURCE_TYPE_GROUP)
                mdgd_group_notify_event(cmd->sender, MDGD_EVENT_GROUP_FIND_FINISH, ret, NULL);
        else if (cmd->resource_type == MDGD_RESOURCE_TYPE_DEVICE)
                mdgd_group_notify_event(cmd->sender, MDGD_EVENT_DEVICE_FIND_FINISH, ret, NULL);
+       else if (cmd->resource_type == MDGD_RESOURCE_TYPE_DATA)
+               LOG_DEBUG("Resource type : DATA");
        else
                LOG_ERR("Unknown Resource Type");
 
-       mdgd_clean_user_data(cmd);
+       mdgd_context_cmd_unlock();
+
+       mdgd_context_remove_command(cmd_id);
 
        LOG_END();
 
@@ -131,27 +146,23 @@ int mdgd_group_find(char *sender, int timeout)
        cmd->resource_type = MDGD_RESOURCE_TYPE_GROUP;
        cmd->sender = g_strdup(sender);
        if (cmd->sender == NULL) {
-               ret = MDGD_ERROR_OUT_OF_MEMORY;
-               goto ERR;
+               mdgd_clean_user_data(cmd);
+               return MDGD_ERROR_OUT_OF_MEMORY;
        }
 
-       ret = mdgd_iot_discovery_resource(MDGD_RESOURCE_TYPE_GROUP, cmd);
-       if (ret != MDGD_ERROR_NONE)
-               goto ERR;
-
-       g_timeout_add_seconds(timeout + 1, __timeout_cb, cmd);
-
-       LOG_END();
+       int cmd_id = mdgd_context_add_command(cmd);
 
-       return MDGD_ERROR_NONE;
-ERR:
-       mdgd_clean_user_data(cmd);
+       ret = mdgd_iot_discovery_resource(MDGD_RESOURCE_TYPE_GROUP, GINT_TO_POINTER(cmd_id));
+       if (ret != MDGD_ERROR_NONE) {
+               mdgd_context_remove_command(cmd_id);
+               return ret;
+       }
 
-       LOG_ERR("%s failed error=%s", __func__, mdgd_log_get_error_string(ret));
+       g_timeout_add_seconds(timeout + 1, __timeout_cb, GINT_TO_POINTER(cmd_id));
 
        LOG_END();
 
-       return ret;
+       return MDGD_ERROR_NONE;
 }
 
 int mdgd_group_find_device(char *sender, int timeout, bool is_invited)
@@ -166,27 +177,23 @@ int mdgd_group_find_device(char *sender, int timeout, bool is_invited)
        cmd->resource_type = MDGD_RESOURCE_TYPE_DEVICE;
        cmd->sender = g_strdup(sender);
        if (cmd->sender == NULL) {
-               ret = MDGD_ERROR_OUT_OF_MEMORY;
-               goto ERR;
+               mdgd_clean_user_data(cmd);
+               return MDGD_ERROR_OUT_OF_MEMORY;
        }
 
+       int cmd_id = mdgd_context_add_command(cmd);
+
        ret = mdgd_iot_find_devices(sender, timeout, is_invited);
-       if (ret != MDGD_ERROR_NONE)
-               goto ERR;
+       if (ret != MDGD_ERROR_NONE) {
+               mdgd_context_remove_command(cmd_id);
+               return ret;
+       }
 
-       g_timeout_add_seconds(timeout + 1, __timeout_cb, cmd);
+       g_timeout_add_seconds(timeout + 1, __timeout_cb, GINT_TO_POINTER(cmd_id));
 
        LOG_END();
 
        return MDGD_ERROR_NONE;
-ERR:
-       mdgd_clean_user_data(cmd);
-
-       LOG_ERR("%s failed error=%s", __func__, mdgd_log_get_error_string(ret));
-
-       LOG_END();
-
-       return ret;
 }
 
 #define FULL_PERMISSION 31
@@ -304,26 +311,26 @@ int mdgd_group_send_data(char *sender, char *uuid, char *channel_id,
        cmd->type = MDGD_REQ_SEND_DATA;
        cmd->uuid = g_strdup(uuid);
        if (cmd->uuid == NULL) {
-               ret = MDGD_ERROR_OUT_OF_MEMORY;
-               goto ERR;
+               mdgd_clean_user_data(cmd);
+               return MDGD_ERROR_OUT_OF_MEMORY;
        }
 
        cmd->sender = g_strdup(sender);
        if (cmd->sender == NULL) {
-               ret = MDGD_ERROR_OUT_OF_MEMORY;
-               goto ERR;
+               mdgd_clean_user_data(cmd);
+               return MDGD_ERROR_OUT_OF_MEMORY;
        }
 
        cmd->arg1 = g_strdup(channel_id);
        if (cmd->arg1 == NULL) {
-               ret = MDGD_ERROR_OUT_OF_MEMORY;
-               goto ERR;
+               mdgd_clean_user_data(cmd);
+               return MDGD_ERROR_OUT_OF_MEMORY;
        }
 
        cmd->data = g_try_malloc0(len + 1);
        if (NULL == cmd->data) {
-               ret = MDGD_ERROR_OUT_OF_MEMORY;
-               goto ERR;
+               mdgd_clean_user_data(cmd);
+               return MDGD_ERROR_OUT_OF_MEMORY;
        }
 
        memcpy(cmd->data, data, len);
@@ -332,23 +339,19 @@ int mdgd_group_send_data(char *sender, char *uuid, char *channel_id,
        *msg_id = mdgd_util_get_msg_id();
        cmd->msg_id = *msg_id;
 
-       ret = mdgd_iot_discovery_resource(cmd->resource_type, cmd);
-       if (ret != MDGD_ERROR_NONE)
-               goto ERR;
+       int cmd_id = mdgd_context_add_command(cmd);
 
-       g_timeout_add_seconds(DEFAULT_TIMEOUT_VALUE, __timeout_cb, cmd);
-
-       LOG_END();
-
-       return MDGD_ERROR_NONE;
-ERR:
-       mdgd_clean_user_data(cmd);
+       ret = mdgd_iot_discovery_resource(cmd->resource_type, GINT_TO_POINTER(cmd_id));
+       if (ret != MDGD_ERROR_NONE) {
+               mdgd_context_remove_command(cmd_id);
+               return ret;
+       }
 
-       LOG_ERR("%s failed error=%s", __func__, mdgd_log_get_error_string(ret));
+       g_timeout_add_seconds(DEFAULT_TIMEOUT_VALUE, __timeout_cb, GINT_TO_POINTER(cmd_id));
 
        LOG_END();
 
-       return ret;
+       return MDGD_ERROR_NONE;
 }
 
 int mdgd_group_send_response(char *sender, char *uuid, char *channel_id,
@@ -384,57 +387,53 @@ int mdgd_group_request(mdgd_request_type_e type, char *sender, char *uuid,
        cmd->type = type;
        cmd->uuid = g_strdup(uuid);
        if (cmd->uuid == NULL) {
-               ret = MDGD_ERROR_OUT_OF_MEMORY;
-               goto ERR;
+               mdgd_clean_user_data(cmd);
+               return MDGD_ERROR_OUT_OF_MEMORY;
        }
 
        cmd->sender = g_strdup(sender);
        if (cmd->sender == NULL) {
-               ret = MDGD_ERROR_OUT_OF_MEMORY;
-               goto ERR;
+               mdgd_clean_user_data(cmd);
+               return MDGD_ERROR_OUT_OF_MEMORY;
        }
 
        if (arg1 != NULL) {
                cmd->arg1 = g_strdup(arg1);
                if (cmd->arg1 == NULL) {
-                       ret = MDGD_ERROR_OUT_OF_MEMORY;
-                       goto ERR;
+                       mdgd_clean_user_data(cmd);
+                       return MDGD_ERROR_OUT_OF_MEMORY;
                }
        }
        if (arg2 != NULL) {
                cmd->arg2 = g_strdup(arg2);
                if (cmd->arg2 == NULL) {
-                       ret = MDGD_ERROR_OUT_OF_MEMORY;
-                       goto ERR;
+                       mdgd_clean_user_data(cmd);
+                       return MDGD_ERROR_OUT_OF_MEMORY;
                }
        }
        if (arg3 != NULL) {
                cmd->arg3 = g_strdup(arg3);
                if (cmd->arg3 == NULL) {
-                       ret = MDGD_ERROR_OUT_OF_MEMORY;
-                       goto ERR;
+                       mdgd_clean_user_data(cmd);
+                       return MDGD_ERROR_OUT_OF_MEMORY;
                }
        }
 
        cmd->user_data = user_data;
 
-       ret = mdgd_iot_discovery_resource(cmd->resource_type, cmd);
-       if (ret != MDGD_ERROR_NONE)
-               goto ERR;
-
-       g_timeout_add_seconds(DEFAULT_TIMEOUT_VALUE, __timeout_cb, cmd);
-
-       LOG_END();
+       int cmd_id = mdgd_context_add_command(cmd);
 
-       return MDGD_ERROR_NONE;
-ERR:
-       mdgd_clean_user_data(cmd);
+       ret = mdgd_iot_discovery_resource(cmd->resource_type, GINT_TO_POINTER(cmd_id));
+       if (ret != MDGD_ERROR_NONE) {
+               mdgd_context_remove_command(cmd_id);
+               return ret;
+       }
 
-       LOG_ERR("%s failed error=%s", __func__, mdgd_log_get_error_string(ret));
+       g_timeout_add_seconds(DEFAULT_TIMEOUT_VALUE, __timeout_cb, GINT_TO_POINTER(cmd_id));
 
        LOG_END();
 
-       return ret;
+       return MDGD_ERROR_NONE;
 }
 
 int mdgd_group_notify_event(char *sender, mdgd_event_type_e type, int result, void *user_data)

diff --git a/src/mdg-manager/src/mdgd_iot.cpp b/src/mdg-manager/src/mdgd_iot.cpp
index e9a8c58..8120b24 100755 (executable)
--- a/src/mdg-manager/src/mdgd_iot.cpp
+++ b/src/mdg-manager/src/mdgd_iot.cpp
@@ -379,7 +379,9 @@ int mdgd_iot_find_devices(char *sender, int timeout, bool is_invited)
                cmd->sender = g_strdup(sender);
                cmd->user_data = (void *)device;
 
-               mdgd_iot_get_device_description(cmd, host_addr, conn_type);
+               int cmd_id = mdgd_context_add_command(cmd);
+
+               mdgd_iot_get_device_description(host_addr, conn_type, cmd_id);
 
                g_free(addr);
                g_free(host_addr);
@@ -476,15 +478,14 @@ static void _mot_cb(PMResultList_t *result, int has_error)
 
 static gboolean __timeout_cb(gpointer data)
 {
-       mdgd_command_t *cmd = (mdgd_command_t *)data;
-       if (!cmd) {
+       if (!data) {
                LOG_ERR("cmd is null");
                return false;
        }
 
        LOG_BEGIN();
 
-       mdgd_clean_user_data(cmd);
+       mdgd_context_remove_command(GPOINTER_TO_INT(data));
 
        LOG_END();
 
@@ -503,6 +504,7 @@ int mdgd_iot_pair(char *group_name, char *pin, char *target1, char *subject1, ch
        OCStackResult ret = OC_STACK_OK;
 #endif
        mdgd_command_t *cmd = NULL;
+       int cmd_id = 0;
 
        OicUuid_t *uuid_1 = NULL;
        OicUuid_t *uuid_2 = NULL;
@@ -607,21 +609,24 @@ int mdgd_iot_pair(char *group_name, char *pin, char *target1, char *subject1, ch
        cmd->uuid = g_strdup(subject1);
        if (cmd->uuid == NULL) {
                result = MDGD_ERROR_OUT_OF_MEMORY;
+               mdgd_clean_user_data(cmd);
                goto PV_PAIR_END;
        }
        cmd->arg1 = g_strdup(group_name);
        if (cmd->arg1 == NULL) {
                result = MDGD_ERROR_OUT_OF_MEMORY;
+               mdgd_clean_user_data(cmd);
                goto PV_PAIR_END;
        }
        cmd->type = MDGD_REQ_EVENT_INVITED;
 
-       mdgd_iot_discovery_resource(MDGD_RESOURCE_TYPE_DEVICE, cmd);
+       cmd_id = mdgd_context_add_command(cmd);
+
+       mdgd_iot_discovery_resource(MDGD_RESOURCE_TYPE_DEVICE, GINT_TO_POINTER(cmd_id));
 
-       g_timeout_add_seconds(DEFAULT_TIMEOUT_VALUE, __timeout_cb, cmd);
+       g_timeout_add_seconds(DEFAULT_TIMEOUT_VALUE, __timeout_cb, GINT_TO_POINTER(cmd_id));
 
 PV_PAIR_END:
-       mdgd_clean_user_data(cmd);
 
        /* Restore MOT enabled devices */
        if (src_dev)
@@ -664,6 +669,7 @@ int mdgd_iot_unpair(char *group_name, char *subowned_id)
        int result = MDGD_ERROR_NONE;
        OCStackResult ret = OC_STACK_OK;
        mdgd_command_t *cmd = NULL;
+       int cmd_id = 0;
 
        if (NULL == subowned_id) {
                LOG_ERR("dev2 is NULL");
@@ -711,9 +717,11 @@ int mdgd_iot_unpair(char *group_name, char *subowned_id)
                goto PV_UNPAIR_END;
        }
 
-       mdgd_iot_discovery_resource(MDGD_RESOURCE_TYPE_DEVICE, cmd);
+       cmd_id = mdgd_context_add_command(cmd);
+
+       mdgd_iot_discovery_resource(MDGD_RESOURCE_TYPE_DEVICE, GINT_TO_POINTER(cmd_id));
 
-       g_timeout_add_seconds(DEFAULT_TIMEOUT_VALUE, __timeout_cb, cmd);
+       g_timeout_add_seconds(DEFAULT_TIMEOUT_VALUE, __timeout_cb, GINT_TO_POINTER(cmd_id));
 
        return MDGD_ERROR_NONE;
 

diff --git a/src/mdg-manager/src/mdgd_iot_client.cpp b/src/mdg-manager/src/mdgd_iot_client.cpp
index e6c281c..0dcdc87 100755 (executable)
--- a/src/mdg-manager/src/mdgd_iot_client.cpp
+++ b/src/mdg-manager/src/mdgd_iot_client.cpp
@@ -209,7 +209,17 @@ static void __request_finish(const HeaderOptions &,
        int ret = MDGD_ERROR_NONE;
 
        mdgd_check_null_ret("user_data", user_data);
-       mdgd_command_t *cmd = (mdgd_command_t *)user_data;
+
+       int cmd_id = GPOINTER_TO_INT(user_data);
+
+       mdgd_context_cmd_lock();
+
+       mdgd_command_t *cmd = mdgd_context_get_command(cmd_id);
+       if (cmd == NULL) {
+               LOG_ERR("cmd not exists");
+               mdgd_context_cmd_unlock();
+               return;
+       }
 
        LOG_BEGIN();
 
@@ -243,8 +253,9 @@ static void __request_finish(const HeaderOptions &,
        } catch (std::exception &e) {
                LOG_ERR("Exception %s in on get", e.what());
        }
+       mdgd_context_cmd_unlock();
 
-       mdgd_clean_user_data(cmd);
+       mdgd_context_remove_command(cmd_id);
 
        LOG_END();
 }
@@ -257,7 +268,18 @@ static bool _found_resource(std::shared_ptr<OCResource> resource,
        OCRepresentation rep;
 
        mdgd_check_null_ret_error("user_data", user_data, TRUE);
-       mdgd_command_t *cmd = (mdgd_command_t *)user_data;
+
+       int cmd_id = GPOINTER_TO_INT(user_data);
+
+       mdgd_context_cmd_lock();
+
+       mdgd_command_t *cmd = mdgd_context_get_command(cmd_id);
+       if (cmd == NULL) {
+               LOG_ERR("cmd not exists");
+               mdgd_context_cmd_unlock();
+               return TRUE;
+       }
+
        mdgd_context_t *mdgd_ctx = mdgd_context_get_context();
 
        LOG_BEGIN();
@@ -443,10 +465,11 @@ static bool _found_resource(std::shared_ptr<OCResource> resource,
                                                break;
                                        default:
                                                LOG_ERR("Invalid command %d", cmd->type);
-                                               return FALSE;
+                                               goto END;
                                        }
-
-                                       resource->post(rep, QueryParamsMap(), std::bind(&__request_finish, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3, second_cmd));
+                                       int second_cmd_id = mdgd_context_add_command(second_cmd);
+                                       resource->post(rep, QueryParamsMap(), std::bind(&__request_finish,
+                                               std::placeholders::_1, std::placeholders::_2, std::placeholders::_3, GINT_TO_POINTER(second_cmd_id)));
                                }
                        }
                } else {
@@ -459,6 +482,8 @@ static bool _found_resource(std::shared_ptr<OCResource> resource,
 END:
        LOG_END();
 
+       mdgd_context_cmd_unlock();
+
        return TRUE;
 }
 
@@ -469,14 +494,13 @@ int mdgd_iot_discovery_resource(mdgd_resource_type_e resource_type,
        std::ostringstream requestURI;
 
        mdgd_check_null_ret_error("user_data", user_data, MDGD_ERROR_INVALID_PARAMETER);
-       mdgd_command_t *cmd = (mdgd_command_t *)user_data;
 
        LOG_BEGIN();
 
        try {
                requestURI << OC_RSRVD_WELL_KNOWN_URI << "?rt=" << mdgd_resource_get_type(resource_type);
 
-               auto found_cb = std::bind(&_found_resource, std::placeholders::_1, cmd);
+               auto found_cb = std::bind(&_found_resource, std::placeholders::_1, user_data);
 
                ret = OCPlatform::findResource("", requestURI.str(), (OCConnectivityType)(CT_ADAPTER_IP | CT_IP_USE_V4), found_cb);
 
@@ -492,76 +516,22 @@ int mdgd_iot_discovery_resource(mdgd_resource_type_e resource_type,
        return ret;
 }
 
-static void __clear_mdgd_command_t(mdgd_command_t *cmd)
+void __get_device_description(const HeaderOptions &headerOptions,
+                             const OCRepresentation &rep, const int eCode, void *user_data)
 {
-       mdgd_check_null_ret("cmd", cmd);
+       mdgd_check_null_ret("user_data", user_data);
 
-       if (cmd->uuid) {
-               g_free(cmd->uuid);
-               cmd->uuid = NULL;
-       }
-       if (cmd->addr) {
-               g_free(cmd->addr);
-               cmd->addr = NULL;
-       }
-       if (cmd->sender) {
-               g_free(cmd->sender);
-               cmd->sender = NULL;
-       }
-       if (cmd->arg1) {
-               g_free(cmd->arg1);
-               cmd->arg1 = NULL;
-       }
-       if (cmd->arg2) {
-               g_free(cmd->arg2);
-               cmd->arg2 = NULL;
-       }
-       if (cmd->arg3) {
-               g_free(cmd->arg3);
-               cmd->arg3 = NULL;
-       }
-       g_free(cmd);
-       cmd = NULL;
-}
+       int cmd_id = GPOINTER_TO_INT(user_data);
 
-void __clear_mdgd_device_t(mdgd_device_t *device)
-{
-       mdgd_check_null_ret("device", device);
+       mdgd_context_cmd_lock();
 
-       if (device->device_id) {
-               g_free(device->device_id);
-               device->device_id = NULL;
-       }
-       if (device->model_name) {
-               g_free(device->model_name);
-               device->model_name = NULL;
-       }
-       if (device->platform_ver) {
-               g_free(device->platform_ver);
-               device->platform_ver = NULL;
-       }
-       if (device->profile) {
-               g_free(device->profile);
-               device->profile = NULL;
-       }
-       if (device->device_name) {
-               g_free(device->device_name);
-               device->device_name = NULL;
+       mdgd_command_t *cmd = mdgd_context_get_command(cmd_id);
+       if (cmd == NULL) {
+               LOG_ERR("cmd not exists");
+               mdgd_context_cmd_unlock();
+               return;
        }
-       if (device->vendor_id) {
-               g_free(device->vendor_id);
-               device->vendor_id = NULL;
-       }
-       g_free(device);
-       device = NULL;
-}
-
-void __get_device_description(const HeaderOptions &headerOptions,
-                             const OCRepresentation &rep, const int eCode, void *user_data)
-{
-       mdgd_check_null_ret("user_data", user_data);
 
-       mdgd_command_t *cmd = (mdgd_command_t *)user_data;
        mdgd_device_t *device = (mdgd_device_t *)cmd->user_data;
 
        LOG_BEGIN();
@@ -600,13 +570,15 @@ void __get_device_description(const HeaderOptions &headerOptions,
                LOG_ERR("Exception %s in on get", e.what());
        }
 
-       __clear_mdgd_device_t(device);
-       __clear_mdgd_command_t(cmd);
+       mdgd_context_cmd_unlock();
+
+       mdgd_clean_device(device);
+       mdgd_context_remove_command(cmd_id);
 
        LOG_END();
 }
 
-int mdgd_iot_get_device_description(mdgd_command_t *cmd, char *host_addr, int conn_type)
+int mdgd_iot_get_device_description(char *host_addr, int conn_type, int cmd_id)
 {
        int ret;
        std::string uri_path;
@@ -620,8 +592,8 @@ int mdgd_iot_get_device_description(mdgd_command_t *cmd, char *host_addr, int co
        OCResource::Ptr device_resource = OCPlatform::constructResourceObject(std::string(host_addr),
                                                                              uri_path, (OCConnectivityType)conn_type, false, resource_types, ifaces);
 
-       ret = device_resource->get(QueryParamsMap(), std::bind(&__get_device_description, std::placeholders::_1,
-                                                              std::placeholders::_2, std::placeholders::_3, cmd));
+       ret = device_resource->get(QueryParamsMap(),
+               std::bind(&__get_device_description, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3, GINT_TO_POINTER(cmd_id)));
 
        LOG_END();
 

diff --git a/src/mdg-manager/src/mdgd_util.c b/src/mdg-manager/src/mdgd_util.c
index 095bc89..6f05865 100755 (executable)
--- a/src/mdg-manager/src/mdgd_util.c
+++ b/src/mdg-manager/src/mdgd_util.c
@@ -356,6 +356,9 @@ void mdgd_clean_user_data(void *user_data)
        }
 #endif
 
+       if (cmd->timeout_id != 0)
+               g_source_remove(cmd->timeout_id);
+
        g_free(cmd);
        cmd = NULL;
 }