Fix Coverity issues

- Resource leaks: 1043630 1043626 1043610 1043604 1043598 1043592 1043591
- Logically dead code : 1053894
- Unchecked return value : 1043631 1043595

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

diff --git a/src/mdg-manager/include/mdgd_typedef.h b/src/mdg-manager/include/mdgd_typedef.h
old mode 100644 (file)
new mode 100755 (executable)
index 2736176..bda0591
--- a/src/mdg-manager/include/mdgd_typedef.h
+++ b/src/mdg-manager/include/mdgd_typedef.h
@@ -36,6 +36,7 @@
 #include <unistd.h>
 
 #define NOTUSED(var) (var = var) /**< It is used to avoid generating build warning */
+#define DEFAULT_TIMEOUT_VALUE 5
 
 #ifndef TIZEN_ERROR_MDG
 #define TIZEN_ERROR_MDG -0x02F50000 /**< Base error code */

diff --git a/src/mdg-manager/include/mdgd_util.h b/src/mdg-manager/include/mdgd_util.h
index e58c9f135cb95f6a420b3fa04c56cc0cbbc4d73d..6c376ab6e4341c0897e9df9c2878d0487f6e6c32 100755 (executable)
--- a/src/mdg-manager/include/mdgd_util.h
+++ b/src/mdg-manager/include/mdgd_util.h
@@ -32,8 +32,10 @@ char *mdgd_get_readable_uuid(const OicUuid_t *uuid);
 char *mdgd_addr2host(char *addr, int port, bool is_secure);
 int mdgd_uuid_to_str(const OicUuid_t *uuid, char **strUuid);
 int mdgd_str_to_uuid(const char *strUuid, OicUuid_t *uuid);
+void mdgd_clean_group(mdgd_group_t *group);
 void mdgd_clean_channel(mdgd_channel_t *channel);
 void mdgd_clean_device(mdgd_device_t *device);
+void mdgd_clean_data(mdgd_data_t *data);
 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);

diff --git a/src/mdg-manager/src/mdgd_gdbus.c b/src/mdg-manager/src/mdgd_gdbus.c
index f778061556718daabdceea92e3b2109bd9b5458d..0dfbd71edc7b9dfc61f10359fb13967f7ad13e79 100644 (file)
--- a/src/mdg-manager/src/mdgd_gdbus.c
+++ b/src/mdg-manager/src/mdgd_gdbus.c
@@ -219,7 +219,8 @@ gboolean group_send_data(Group *group, GDBusMethodInvocation *invocation,
        }
 
        for (int i = 0; i < len; i++) {
-               g_variant_iter_loop(iter, "y", &data[i]);
+               if (!g_variant_iter_loop(iter, "y", &data[i]))
+                       break;
        }
 
        g_variant_iter_free(iter);
@@ -264,7 +265,8 @@ gboolean group_send_response(Group *group, GDBusMethodInvocation *invocation,
        }
 
        for (int i = 0; i < len; i++) {
-               g_variant_iter_loop(iter, "y", &data[i]);
+               if(!g_variant_iter_loop(iter, "y", &data[i]))
+                       break;
        }
 
        g_variant_iter_free(iter);

diff --git a/src/mdg-manager/src/mdgd_group.c b/src/mdg-manager/src/mdgd_group.c
old mode 100644 (file)
new mode 100755 (executable)
index ae659f5..a7d7846
--- a/src/mdg-manager/src/mdgd_group.c
+++ b/src/mdg-manager/src/mdgd_group.c
@@ -112,6 +112,8 @@ static gboolean __timeout_cb(gpointer data)
        else
                LOG_ERR("Unknown Resource Type");
 
+       mdgd_clean_user_data(cmd);
+
        LOG_END();
 
        return G_SOURCE_REMOVE;
@@ -123,19 +125,32 @@ int mdgd_group_find(char *sender, int timeout)
 
        LOG_BEGIN();
 
-       mdgd_command_t *cmd = g_new0(mdgd_command_t, 1);
-       mdgd_check_null_ret_error("cmd", cmd, MDGD_ERROR_INVALID_PARAMETER);
+       mdgd_command_t *cmd = g_try_malloc0(sizeof(mdgd_command_t));
+       mdgd_check_null_ret_error("cmd", cmd, MDGD_ERROR_OUT_OF_MEMORY);
+
        cmd->resource_type = MDGD_RESOURCE_TYPE_GROUP;
        cmd->sender = g_strdup(sender);
+       if (cmd->sender == NULL) {
+               ret = MDGD_ERROR_OUT_OF_MEMORY;
+               goto ERR;
+       }
 
        ret = mdgd_iot_discovery_resource(MDGD_RESOURCE_TYPE_GROUP, cmd);
        if (ret != MDGD_ERROR_NONE)
-               LOG_ERR("Failed to discover resource : %s", mdgd_log_get_error_string(ret));
+               goto ERR;
 
        g_timeout_add_seconds(timeout + 1, __timeout_cb, cmd);
 
        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;
 }
 
@@ -145,21 +160,32 @@ int mdgd_group_find_device(char *sender, int timeout, bool is_invited)
 
        LOG_BEGIN();
 
-       mdgd_command_t *cmd = g_new0(mdgd_command_t, 1);
-       mdgd_check_null_ret_error("cmd", cmd, MDGD_ERROR_INVALID_PARAMETER);
+       mdgd_command_t *cmd = g_try_malloc0(sizeof(mdgd_command_t));
+       mdgd_check_null_ret_error("cmd", cmd, MDGD_ERROR_OUT_OF_MEMORY);
+
        cmd->resource_type = MDGD_RESOURCE_TYPE_DEVICE;
        cmd->sender = g_strdup(sender);
+       if (cmd->sender == NULL) {
+               ret = MDGD_ERROR_OUT_OF_MEMORY;
+               goto ERR;
+       }
 
        ret = mdgd_iot_find_devices(sender, timeout, is_invited);
-       if (ret != MDGD_ERROR_NONE) {
-               LOG_ERR("Failed to find device : %s",
-                       mdgd_log_get_error_string(ret));
-       }
+       if (ret != MDGD_ERROR_NONE)
+               goto ERR;
 
        g_timeout_add_seconds(timeout + 1, __timeout_cb, cmd);
 
        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;
 }
 
@@ -272,33 +298,53 @@ int mdgd_group_send_data(char *sender, char *uuid, char *channel_id,
        LOG_BEGIN();
 
        mdgd_command_t *cmd = g_try_malloc0(sizeof(mdgd_command_t));
-       if (NULL == cmd) {
-               ret = MDGD_ERROR_OUT_OF_MEMORY;
-               LOG_ERR("Failed to alloc memory");
-               return ret;
-       }
-
-       *msg_id = mdgd_util_get_msg_id();
+       mdgd_check_null_ret_error("cmd", cmd, MDGD_ERROR_OUT_OF_MEMORY);
 
        cmd->resource_type = MDGD_RESOURCE_TYPE_DATA;
        cmd->type = MDGD_REQ_SEND_DATA;
        cmd->uuid = g_strdup(uuid);
+       if (cmd->uuid == NULL) {
+               ret = MDGD_ERROR_OUT_OF_MEMORY;
+               goto ERR;
+       }
+
        cmd->sender = g_strdup(sender);
+       if (cmd->sender == NULL) {
+               ret = MDGD_ERROR_OUT_OF_MEMORY;
+               goto ERR;
+       }
+
        cmd->arg1 = g_strdup(channel_id);
-       cmd->msg_id = *msg_id;
+       if (cmd->arg1 == NULL) {
+               ret = MDGD_ERROR_OUT_OF_MEMORY;
+               goto ERR;
+       }
 
        cmd->data = g_try_malloc0(len + 1);
        if (NULL == cmd->data) {
                ret = MDGD_ERROR_OUT_OF_MEMORY;
-               LOG_ERR("Send Data Fail to uuid = %s error=%s",
-                       cmd->uuid, mdgd_log_get_error_string(ret));
-               return ret;
+               goto ERR;
        }
 
        memcpy(cmd->data, data, len);
        cmd->data_len = len;
 
+       *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;
+
+       g_timeout_add_seconds(DEFAULT_TIMEOUT_VALUE, __timeout_cb, cmd);
+
+       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();
 
@@ -332,26 +378,59 @@ int mdgd_group_request(mdgd_request_type_e type, char *sender, char *uuid,
        LOG_BEGIN();
 
        mdgd_command_t *cmd = g_try_malloc0(sizeof(mdgd_command_t));
-       if (NULL == cmd) {
-               ret = MDGD_ERROR_OUT_OF_MEMORY;
-               LOG_ERR("Failed to alloc memory");
-               return ret;
-       }
+       mdgd_check_null_ret_error("cmd", cmd, MDGD_ERROR_OUT_OF_MEMORY);
 
        cmd->resource_type = MDGD_RESOURCE_TYPE_DATA;
        cmd->type = type;
        cmd->uuid = g_strdup(uuid);
+       if (cmd->uuid == NULL) {
+               ret = MDGD_ERROR_OUT_OF_MEMORY;
+               goto ERR;
+       }
+
        cmd->sender = g_strdup(sender);
-       cmd->user_data = user_data;
+       if (cmd->sender == NULL) {
+               ret = MDGD_ERROR_OUT_OF_MEMORY;
+               goto ERR;
+       }
 
-       if (arg1 != NULL)
+       if (arg1 != NULL) {
                cmd->arg1 = g_strdup(arg1);
-       if (arg2 != NULL)
+               if (cmd->arg1 == NULL) {
+                       ret = MDGD_ERROR_OUT_OF_MEMORY;
+                       goto ERR;
+               }
+       }
+       if (arg2 != NULL) {
                cmd->arg2 = g_strdup(arg2);
-       if (arg3 != NULL)
+               if (cmd->arg2 == NULL) {
+                       ret = MDGD_ERROR_OUT_OF_MEMORY;
+                       goto ERR;
+               }
+       }
+       if (arg3 != NULL) {
                cmd->arg3 = g_strdup(arg3);
+               if (cmd->arg3 == NULL) {
+                       ret = MDGD_ERROR_OUT_OF_MEMORY;
+                       goto ERR;
+               }
+       }
+
+       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();
+
+       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();
 

diff --git a/src/mdg-manager/src/mdgd_iot.cpp b/src/mdg-manager/src/mdgd_iot.cpp
old mode 100644 (file)
new mode 100755 (executable)
index df0857f..e9a8c58
--- a/src/mdg-manager/src/mdgd_iot.cpp
+++ b/src/mdg-manager/src/mdgd_iot.cpp
@@ -366,7 +366,7 @@ int mdgd_iot_find_devices(char *sender, int timeout, bool is_invited)
                        return MDGD_ERROR_OUT_OF_MEMORY;
                }
                char *host_addr = mdgd_addr2host(addr, port, false);
-               if (NULL == device) {
+               if (NULL == host_addr) {
                        g_free(cmd);
                        g_free(device);
                        g_free(addr);
@@ -452,7 +452,7 @@ static OicUuid_t *_convert_uuid(gchar *device_id)
 
        return uuid;
 }
-#if MULTIPLE_ONWER == 1
+#if MULTIPLE_OWNER == 1
 static void _mot_cb(PMResultList_t *result, int has_error)
 {
        char *readable_uuid = NULL;
@@ -474,15 +474,32 @@ static void _mot_cb(PMResultList_t *result, int has_error)
 }
 #endif
 
+static gboolean __timeout_cb(gpointer data)
+{
+       mdgd_command_t *cmd = (mdgd_command_t *)data;
+       if (!cmd) {
+               LOG_ERR("cmd is null");
+               return false;
+       }
+
+       LOG_BEGIN();
+
+       mdgd_clean_user_data(cmd);
+
+       LOG_END();
+
+       return G_SOURCE_REMOVE;
+}
+
 int mdgd_iot_pair(char *group_name, char *pin, char *target1, char *subject1, char *uri1,
                  char *rt1, char *interface1, int permission1, char *target2,
                  char *subject2, char *uri2, char *rt2, char *interface2, int permission2)
 {
        int idx1 = -1;
        int idx2 = -1;
-
        int result = MDGD_ERROR_NONE;
-#if MULTIPLE_ONWER == 1
+
+#if MULTIPLE_OWNER == 1
        OCStackResult ret = OC_STACK_OK;
 #endif
        mdgd_command_t *cmd = NULL;
@@ -549,7 +566,7 @@ int mdgd_iot_pair(char *group_name, char *pin, char *target1, char *subject1, ch
        next_dev = src_dev->next;
        src_dev->next = NULL;
 
-#if MULTIPLE_ONWER == 1
+#if MULTIPLE_OWNER == 1
        g_doneCB = false;
 
        LOG_DEBUG("MOT Start...");
@@ -581,16 +598,31 @@ int mdgd_iot_pair(char *group_name, char *pin, char *target1, char *subject1, ch
        g_doneCB = false;
 #endif
        cmd = (mdgd_command_t *)g_try_malloc0(sizeof(mdgd_command_t));
+       if (cmd == NULL) {
+               result = MDGD_ERROR_OUT_OF_MEMORY;
+               goto PV_PAIR_END;
+       }
+
        cmd->resource_type = MDGD_RESOURCE_TYPE_DEVICE;
        cmd->uuid = g_strdup(subject1);
+       if (cmd->uuid == NULL) {
+               result = MDGD_ERROR_OUT_OF_MEMORY;
+               goto PV_PAIR_END;
+       }
        cmd->arg1 = g_strdup(group_name);
-
-       if (result == MDGD_ERROR_NONE) {
-               cmd->type = MDGD_REQ_EVENT_INVITED;
-               mdgd_iot_discovery_resource(MDGD_RESOURCE_TYPE_DEVICE, cmd);
+       if (cmd->arg1 == NULL) {
+               result = MDGD_ERROR_OUT_OF_MEMORY;
+               goto PV_PAIR_END;
        }
+       cmd->type = MDGD_REQ_EVENT_INVITED;
+
+       mdgd_iot_discovery_resource(MDGD_RESOURCE_TYPE_DEVICE, cmd);
+
+       g_timeout_add_seconds(DEFAULT_TIMEOUT_VALUE, __timeout_cb, cmd);
 
 PV_PAIR_END:
+       mdgd_clean_user_data(cmd);
+
        /* Restore MOT enabled devices */
        if (src_dev)
                src_dev->next = next_dev;
@@ -661,16 +693,33 @@ int mdgd_iot_unpair(char *group_name, char *subowned_id)
 
        /* Send Event to remote */
        cmd = (mdgd_command_t *)g_try_malloc0(sizeof(mdgd_command_t));
+       if (cmd == NULL) {
+               result = MDGD_ERROR_OUT_OF_MEMORY;
+               goto PV_UNPAIR_END;
+       }
+
        cmd->resource_type = MDGD_RESOURCE_TYPE_DEVICE;
+       cmd->type = MDGD_REQ_EVENT_EJECTED;
        cmd->uuid = g_strdup(subowned_id);
+       if (cmd->uuid == NULL) {
+               result = MDGD_ERROR_OUT_OF_MEMORY;
+               goto PV_UNPAIR_END;
+       }
        cmd->arg1 = g_strdup(group_name);
-
-       if (result == MDGD_ERROR_NONE) {
-               cmd->type = MDGD_REQ_EVENT_EJECTED;
-               mdgd_iot_discovery_resource(MDGD_RESOURCE_TYPE_DEVICE, cmd);
+       if (cmd->arg1 == NULL) {
+               result = MDGD_ERROR_OUT_OF_MEMORY;
+               goto PV_UNPAIR_END;
        }
 
+       mdgd_iot_discovery_resource(MDGD_RESOURCE_TYPE_DEVICE, cmd);
+
+       g_timeout_add_seconds(DEFAULT_TIMEOUT_VALUE, __timeout_cb, cmd);
+
+       return MDGD_ERROR_NONE;
+
 PV_UNPAIR_END:
+       mdgd_clean_user_data(cmd);
+
        return result;
 }
 
@@ -758,7 +807,7 @@ int mdgd_iot_initialize()
                LOG_ERR("OCInitPM() error = [%d][%s]", ret, get_error_message(ret));
 
        OCProvisionDev_t *motdev_list = NULL;
-#if MULTIPLE_ONWER == 1
+#if MULTIPLE_OWNER == 1
        OCDiscoverMultipleOwnerEnabledDevices(1, &motdev_list);
 #endif
        OCProvisionDev_t *iter = NULL;

diff --git a/src/mdg-manager/src/mdgd_iot_client.cpp b/src/mdg-manager/src/mdgd_iot_client.cpp
old mode 100644 (file)
new mode 100755 (executable)
index d69f2e0..e6c281c
--- a/src/mdg-manager/src/mdgd_iot_client.cpp
+++ b/src/mdg-manager/src/mdgd_iot_client.cpp
@@ -60,11 +60,13 @@ static void __get_group_information(const HeaderOptions &headerOptions,
 {
        LOG_BEGIN();
 
+       mdgd_check_null_ret("user_data", user_data);
+
+       mdgd_group_t *group = (mdgd_group_t *)user_data;
+
        try {
                if (eCode == OC_STACK_OK || eCode == OC_STACK_RESOURCE_CREATED ||
                    eCode == OC_STACK_RESOURCE_CHANGED) {
-                       mdgd_check_null_ret("user_data", user_data);
-                       mdgd_group_t *group = (mdgd_group_t *)user_data;
                        std::vector<std::string> group_list;
                        unsigned int i;
 
@@ -93,6 +95,8 @@ static void __get_group_information(const HeaderOptions &headerOptions,
                LOG_ERR("Exception %s in on get", e.what());
        }
 
+       mdgd_clean_group(group);
+
        LOG_END();
 }
 
@@ -186,6 +190,8 @@ static void __send_data_finish(const HeaderOptions &,
 
                        mdgd_group_notify_event(tmp_data_t->sender, MDGD_EVENT_SEND_DATA_FINISH, ret, tmp_data_t);
 
+                       mdgd_clean_data(tmp_data_t);
+
                        mdgd_ctx->send_data = g_slist_remove_link(mdgd_ctx->send_data, l);
                        break;
                }
@@ -238,6 +244,8 @@ static void __request_finish(const HeaderOptions &,
                LOG_ERR("Exception %s in on get", e.what());
        }
 
+       mdgd_clean_user_data(cmd);
+
        LOG_END();
 }
 
@@ -267,8 +275,22 @@ static bool _found_resource(std::shared_ptr<OCResource> resource,
                        if (g_strcmp0(resource_type,
                                      mdgd_resource_get_type(MDGD_RESOURCE_TYPE_GROUP)) == 0) {
                                mdgd_group_t *group = (mdgd_group_t *)g_try_malloc0(sizeof(mdgd_group_t));
+                               if (group == NULL) {
+                                       LOG_ERR("memory allocation failed");
+                                       goto END;
+                               }
                                group->device_id = g_strdup(resource->sid().c_str());
+                               if (group->device_id == NULL) {
+                                       LOG_ERR("memory allocation failed");
+                                       mdgd_clean_group(group);
+                                       goto END;
+                               }
                                group->sender = g_strdup(cmd->sender);
+                               if (group->sender == NULL) {
+                                       LOG_ERR("memory allocation failed");
+                                       mdgd_clean_group(group);
+                                       goto END;
+                               }
                                if (g_strcmp0(group->device_id, mdgd_ctx->device_uuid) != 0) {
                                        group->type = MDGD_GROUP_TYPE_REMOTE;
                                } else {
@@ -302,12 +324,33 @@ static bool _found_resource(std::shared_ptr<OCResource> resource,
 
                                        rep.setValue("Data", std::string(encoded_data));
                                        rep.setValue("DataLen", encoded_len);
+                                       if (encoded_data != NULL)
+                                               free(encoded_data);
 
                                        /* create structure for store the msgID, channel ID */
                                        mdgd_data_t *send_data = g_new0(mdgd_data_t, 1);
+                                       if (send_data == NULL) {
+                                               LOG_ERR("memory allocation failed");
+                                               goto END;
+                                       }
                                        send_data->sender = g_strdup(cmd->sender);
+                                       if (send_data->sender == NULL) {
+                                               LOG_ERR("memory allocation failed");
+                                               mdgd_clean_data(send_data);
+                                               goto END;
+                                       }
                                        send_data->device_id = g_strdup(cmd->uuid);
+                                       if (send_data->device_id == NULL) {
+                                               LOG_ERR("memory allocation failed");
+                                               mdgd_clean_data(send_data);
+                                               goto END;
+                                       }
                                        send_data->channel_id = g_strdup(cmd->arg1);
+                                       if (send_data->channel_id == NULL) {
+                                               LOG_ERR("memory allocation failed");
+                                               mdgd_clean_data(send_data);
+                                               goto END;
+                                       }
                                        send_data->msg_id = cmd->msg_id;
                                        send_data->tid = g_timeout_add_seconds(7, _send_data_timeout_cb, send_data);
 
@@ -317,31 +360,93 @@ static bool _found_resource(std::shared_ptr<OCResource> resource,
 
                                        resource->post(rep, QueryParamsMap(), std::bind(&__send_data_finish, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3, send_data));
                                } else {
+                                       mdgd_command_t *second_cmd = g_new0(mdgd_command_t, 1);
+                                       if (second_cmd == NULL) {
+                                               LOG_ERR("memory allocation failed");
+                                               goto END;
+                                       }
+
+                                       second_cmd->addr = g_strdup(resource->host().c_str());
+                                       if (second_cmd->addr == NULL) {
+                                               LOG_ERR("memory allocation failed");
+                                               mdgd_clean_user_data(second_cmd);
+                                               goto END;
+                                       }
+
+                                       second_cmd->uuid = g_strdup(cmd->uuid);
+                                       if (second_cmd->uuid == NULL) {
+                                               LOG_ERR("memory allocation failed");
+                                               mdgd_clean_user_data(second_cmd);
+                                               goto END;
+                                       }
+                                       second_cmd->type = cmd->type;
+
                                        switch (cmd->type) {
                                        case MDGD_REQ_CREATE_GROUP:
+                                               second_cmd->arg1 = g_strdup(cmd->arg1);
+                                               if (second_cmd->arg1 == NULL) {
+                                                       LOG_ERR("memory allocation failed");
+                                                       mdgd_clean_user_data(second_cmd);
+                                                       goto END;
+                                               }
                                                rep.setValue("GroupName", std::string(cmd->arg1));
                                                break;
                                        case MDGD_REQ_INVITE_DEVICE:
+                                               second_cmd->arg1 = g_strdup(cmd->arg1);
+                                               if (second_cmd->arg1 == NULL) {
+                                                       LOG_ERR("memory allocation failed");
+                                                       mdgd_clean_user_data(second_cmd);
+                                                       goto END;
+                                               }
+                                               second_cmd->arg2 = g_strdup(cmd->arg2);
+                                               if (second_cmd->arg2 == NULL) {
+                                                       LOG_ERR("memory allocation failed");
+                                                       mdgd_clean_user_data(second_cmd);
+                                                       goto END;
+                                               }
+                                               second_cmd->arg3 = g_strdup(cmd->arg3);
+                                               if (second_cmd->arg3 == NULL) {
+                                                       LOG_ERR("memory allocation failed");
+                                                       mdgd_clean_user_data(second_cmd);
+                                                       goto END;
+                                               }
                                                rep.setValue("GroupName", std::string(cmd->arg1));
                                                rep.setValue("ID", std::string(cmd->arg2));
                                                rep.setValue("PIN", std::string(cmd->arg3));
                                                break;
                                        case MDGD_REQ_EJECT_DEVICE:
+                                               second_cmd->arg1 = g_strdup(cmd->arg1);
+                                               if (second_cmd->arg1 == NULL) {
+                                                       LOG_ERR("memory allocation failed");
+                                                       mdgd_clean_user_data(second_cmd);
+                                                       goto END;
+                                               }
+                                               second_cmd->arg2 = g_strdup(cmd->arg2);
+                                               if (second_cmd->arg2 == NULL) {
+                                                       LOG_ERR("memory allocation failed");
+                                                       mdgd_clean_user_data(second_cmd);
+                                                       goto END;
+                                               }
                                                rep.setValue("GroupName", std::string(cmd->arg1));
                                                rep.setValue("ID", std::string(cmd->arg2));
                                                break;
                                        case MDGD_REQ_CHANNEL_LIST:
                                                break;
                                        case MDGD_REQ_CHANNEL_OPEN:
+                                               second_cmd->arg1 = g_strdup(cmd->arg1);
+                                               if (second_cmd->arg1 == NULL) {
+                                                       LOG_ERR("memory allocation failed");
+                                                       mdgd_clean_user_data(second_cmd);
+                                                       goto END;
+                                               }
                                                rep.setValue("ChannelID", std::string(cmd->arg1));
-                                               cmd->addr = g_strdup(resource->host().c_str());
                                                break;
                                        default:
                                                LOG_ERR("Invalid command %d", cmd->type);
                                                return FALSE;
                                        }
 
-                                       resource->post(rep, QueryParamsMap(), std::bind(&__request_finish, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3, cmd));
+                                       resource->post(rep, QueryParamsMap(), std::bind(&__request_finish, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3, second_cmd));
                                }
                        }
                } else {
@@ -351,6 +456,7 @@ static bool _found_resource(std::shared_ptr<OCResource> resource,
                LOG_ERR("Exception in foundResource: %s", e.what());
        }
 
+END:
        LOG_END();
 
        return TRUE;

diff --git a/src/mdg-manager/src/mdgd_iot_server.cpp b/src/mdg-manager/src/mdgd_iot_server.cpp
index f161e5307c310b163bdc81e314467324f3e8b866..c7b4efed3d3191dec5fb2af33506bc0c0248fff1 100644 (file)
--- a/src/mdg-manager/src/mdgd_iot_server.cpp
+++ b/src/mdg-manager/src/mdgd_iot_server.cpp
@@ -95,6 +95,9 @@ int mdgd_iot_send_response(char *sender, char *uuid, char *channel_id,
                                mdgd_util_data_encode((const char *)data, data_len, &encoded_data, &encoded_len);
 
                                responseRep.setValue("Data", std::string(encoded_data));
+                               if (encoded_data != NULL)
+                                       free(encoded_data);
+
                                responseRep.setValue("DataLen", encoded_len);
                                responseRep.setValue("Timeout", false);
 
@@ -180,6 +183,15 @@ OCEntityHandlerResult _request_handler(std::shared_ptr<OCResourceRequest> reques
                                responseRep.setValue("profile", std::string(profile));
                                responseRep.setValue("device_name", std::string(device_name));
                                responseRep.setValue("vendor_id", std::string("6FFF"));
+
+                               if (device_name != NULL)
+                                       free(device_name);
+                               if (model_name != NULL)
+                                       free(model_name);
+                               if (platform_ver != NULL)
+                                       free(platform_ver);
+                               if (profile != NULL)
+                                       free(profile);
                        } else if (strcmp(resourceUri.c_str(),
                                          mdgd_resource_get_uri_prefix(MDGD_RESOURCE_TYPE_GROUP)) == 0) {
                                int group_count;

diff --git a/src/mdg-manager/src/mdgd_util.c b/src/mdg-manager/src/mdgd_util.c
old mode 100644 (file)
new mode 100755 (executable)
index 78f43cc..095bc89
--- a/src/mdg-manager/src/mdgd_util.c
+++ b/src/mdg-manager/src/mdgd_util.c
@@ -201,6 +201,30 @@ int mdgd_str_to_uuid(const char *strUuid, OicUuid_t *uuid)
        return OC_STACK_OK;
 }
 
+void mdgd_clean_group(mdgd_group_t *group)
+{
+       if (NULL == group)
+               return;
+
+       if (group->device_id) {
+               g_free(group->device_id);
+               group->device_id = NULL;
+       }
+
+       if (group->group_name) {
+               g_free(group->group_name);
+               group->group_name = NULL;
+       }
+
+       if (group->sender) {
+               g_free(group->sender);
+               group->sender = NULL;
+       }
+
+       g_free(group);
+       group = NULL;
+}
+
 void mdgd_clean_device(mdgd_device_t *device)
 {
        if (NULL == device)
@@ -264,6 +288,35 @@ void mdgd_clean_channel(mdgd_channel_t *channel)
        channel = NULL;
 }
 
+void mdgd_clean_data(mdgd_data_t *data)
+{
+       if (NULL == data)
+               return;
+
+       if (data->sender) {
+               g_free(data->sender);
+               data->sender = NULL;
+       }
+
+       if (data->device_id) {
+               g_free(data->device_id);
+               data->device_id = NULL;
+       }
+
+       if (data->channel_id) {
+               g_free(data->channel_id);
+               data->channel_id = NULL;
+       }
+
+       if (data->data) {
+               g_free(data->data);
+               data->data = NULL;
+       }
+
+       g_free(data);
+       data = NULL;
+}
+
 void mdgd_clean_user_data(void *user_data)
 {
        mdgd_command_t *cmd = (mdgd_command_t *)user_data;
@@ -275,6 +328,14 @@ void mdgd_clean_user_data(void *user_data)
                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;