Rearrange the scope of each temporary variables

[platform/core/uifw/voice-control.git] / common / vc_command.c

diff --git a/common/vc_command.c b/common/vc_command.c
index 3f1b32b..e6b5767 100644 (file)
--- a/common/vc_command.c
+++ b/common/vc_command.c
@@ -160,14 +160,18 @@ static int __vc_cmd_check_privilege()
                char uid[32];
                snprintf(uid, 32, "%d", getuid());
                ret = true;
-               ret = __check_privilege(uid, VC_PRIVILEGE);
-               __check_privilege_deinitialize();
+               ret = __check_privilege(uid, VC_PRIVILEGE_RECORDER);
                if (false == ret) {
-                       SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Permission is denied");
+                       //LCOV_EXCL_START
+                       SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Permission is denied(%s)(%s)", VC_PRIVILEGE_RECORDER, uid);
+                       __check_privilege_deinitialize();
                        g_privilege_allowed = false;
                        pthread_mutex_unlock(&g_cynara_mutex);
                        return VC_ERROR_PERMISSION_DENIED;
+                       //LCOV_EXCL_STOP
                }
+
+               __check_privilege_deinitialize();
        }
 
        g_privilege_allowed = true;
@@ -352,16 +356,13 @@ int vc_cmd_list_remove(vc_cmd_list_h vc_cmd_list, vc_cmd_h vc_command)
        return VC_ERROR_NONE;
 }
 
-static void __vc_cmd_list_remove_all_foreach(gpointer data, gpointer user_data)
+static void __vc_cmd_list_remove_all_foreach(gpointer data)
 {
-       vc_cmd_s *temp = NULL;
-       temp = data;
+       vc_cmd_s *temp = (vc_cmd_s *)data;
        if (temp) {
-               SLOG(LOG_DEBUG, TAG_VCCMD, "Free command(%p)", temp);
+               SECURE_SLOG(LOG_DEBUG, TAG_VCCMD, "Free command(%p)", temp);
                vc_cmd_destroy((vc_cmd_h)temp);
-               temp = NULL;
        }
-       return;
 }
 
 int vc_cmd_list_remove_all(vc_cmd_list_h vc_cmd_list, bool release_command)
@@ -380,21 +381,25 @@ int vc_cmd_list_remove_all(vc_cmd_list_h vc_cmd_list, bool release_command)
                return VC_ERROR_INVALID_PARAMETER;
        }
 
-       vc_cmd_list_s* list = NULL;
-       list = (vc_cmd_list_s*)vc_cmd_list;
+       vc_cmd_list_s* cmd_list = (vc_cmd_list_s*)vc_cmd_list;
 
        SLOG(LOG_DEBUG, TAG_VCCMD, "[List] list (%p), release command (%s)"
-                , list, release_command ? "true" : "false");
+                , cmd_list, release_command ? "true" : "false");
+
+       if (NULL == cmd_list->list) {
+               SLOG(LOG_DEBUG, TAG_VCCMD, "@@@ List is already empty.");
+               return VC_ERROR_NONE;
+       }
 
        if (true == release_command) {
-               if (list->list) {
-                       g_slist_foreach(list->list, __vc_cmd_list_remove_all_foreach, NULL);
-                       g_slist_free(list->list);
-                       list->list = NULL;
-               }
-               list->index = -1;
+               g_slist_free_full(cmd_list->list, __vc_cmd_list_remove_all_foreach);
+       } else {
+               g_slist_free(cmd_list->list);
        }
 
+       cmd_list->list = NULL;
+       cmd_list->index = -1;
+
        SLOG(LOG_DEBUG, TAG_VCCMD, "@@@");
 
        return VC_ERROR_NONE;
@@ -409,7 +414,7 @@ int vc_cmd_list_foreach_commands(vc_cmd_list_h vc_cmd_list, vc_cmd_list_cb callb
                return VC_ERROR_PERMISSION_DENIED;
        }
 
-       if (NULL == vc_cmd_list) {
+       if (NULL == vc_cmd_list || NULL == callback) {
                SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Input parameter is NULL");
                return VC_ERROR_INVALID_PARAMETER;
        }
@@ -448,7 +453,7 @@ int vc_cmd_list_filter_by_type(vc_cmd_list_h original, int type, vc_cmd_list_h*
                return VC_ERROR_PERMISSION_DENIED;
        }
 
-       if (NULL == original) {
+       if (NULL == original || NULL == filtered) {
                SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Input parameter is NULL");
                return VC_ERROR_INVALID_PARAMETER;
        }
@@ -594,6 +599,10 @@ int vc_cmd_list_next(vc_cmd_list_h vc_cmd_list)
        list = (vc_cmd_list_s*)vc_cmd_list;
 
        int count = g_slist_length(list->list);
+       if (0 == count) {
+               SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] List is empty");
+               return VC_ERROR_EMPTY;
+       }
 
        if (list->index < count - 1) {
                list->index = list->index + 1;
@@ -623,6 +632,11 @@ int vc_cmd_list_prev(vc_cmd_list_h vc_cmd_list)
        vc_cmd_list_s* list = NULL;
        list = (vc_cmd_list_s*)vc_cmd_list;
 
+       if (0 == g_slist_length(list->list)) {
+               SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] List is empty");
+               return VC_ERROR_EMPTY;
+       }
+
        if (list->index > 0) {
                list->index = list->index - 1;
                SLOG(LOG_DEBUG, TAG_VCCMD, "[DEBUG] List index : %d", list->index);
@@ -801,6 +815,7 @@ int vc_cmd_set_id(vc_cmd_h vc_command, int id)
        return VC_ERROR_NONE;
 }
 
+//LCOV_EXCL_START
 int vc_cmd_get_id(vc_cmd_h vc_command, int* id)
 {
        if (0 != __vc_cmd_get_feature_enabled()) {
@@ -823,6 +838,7 @@ int vc_cmd_get_id(vc_cmd_h vc_command, int* id)
 
        return VC_ERROR_NONE;
 }
+//LCOV_EXCL_STOP
 
 int vc_cmd_set_appid(vc_cmd_h vc_command, const char* appid)
 {
@@ -980,6 +996,7 @@ int vc_cmd_get_unfixed_command(vc_cmd_h vc_command, char** command)
        return VC_ERROR_NONE;
 }
 
+//LCOV_EXCL_START
 int vc_cmd_set_fixed_command(vc_cmd_h vc_command, const char* fixed)
 {
        if (0 != __vc_cmd_get_feature_enabled()) {
@@ -1031,6 +1048,7 @@ int vc_cmd_get_fixed_command(vc_cmd_h vc_command, char** fixed)
 
        return VC_ERROR_NONE;
 }
+//LCOV_EXCL_STOP
 
 int vc_cmd_set_invocation_name(vc_cmd_h vc_command, const char* invocation_name)
 {
@@ -1060,6 +1078,7 @@ int vc_cmd_set_invocation_name(vc_cmd_h vc_command, const char* invocation_name)
        return VC_ERROR_NONE;
 }
 
+//LCOV_EXCL_START
 int vc_cmd_get_invocation_name(vc_cmd_h vc_command, char** invocation_name)
 {
        if (0 != __vc_cmd_get_feature_enabled()) {
@@ -1082,6 +1101,7 @@ int vc_cmd_get_invocation_name(vc_cmd_h vc_command, char** invocation_name)
        SLOG(LOG_DEBUG, TAG_VCCMD, "[Get invocation name][%p] invocation_name(%s)", vc_command, *invocation_name);
        return VC_ERROR_NONE;
 }
+//LCOV_EXCL_STOP
 
 int vc_cmd_set_type(vc_cmd_h vc_command, int type)
 {
@@ -1097,6 +1117,11 @@ int vc_cmd_set_type(vc_cmd_h vc_command, int type)
                return VC_ERROR_INVALID_PARAMETER;
        }
 
+       if (VC_COMMAND_TYPE_NONE >= type || VC_COMMAND_TYPE_EXCLUSIVE < type) {
+               SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid type(%d)", type);
+               return VC_ERROR_INVALID_PARAMETER;
+       }
+
        vc_cmd_s* cmd = NULL;
        cmd = (vc_cmd_s*)vc_command;
 
@@ -1142,6 +1167,11 @@ int vc_cmd_set_format(vc_cmd_h vc_command, int format)
                return VC_ERROR_INVALID_PARAMETER;
        }
 
+       if (VC_COMMAND_FORMAT_FIXED > format || VC_COMMAND_FORMAT_NONFIXED_AND_FIXED < format) {
+               SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid format(%d)", format);
+               return VC_ERROR_INVALID_PARAMETER;
+       }
+
        vc_cmd_s* cmd = NULL;
        cmd = (vc_cmd_s*)vc_command;
 
@@ -1187,6 +1217,11 @@ int vc_cmd_set_pid(vc_cmd_h vc_command, int pid)
                return VC_ERROR_INVALID_PARAMETER;
        }
 
+       if (0 > pid) {
+               SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid pid (%d)", pid);
+               return VC_ERROR_INVALID_PARAMETER;
+       }
+
        vc_cmd_s* cmd = NULL;
        cmd = (vc_cmd_s*)vc_command;
 
@@ -1269,6 +1304,7 @@ int vc_cmd_get_domain(vc_cmd_h vc_command, int* domain)
        return VC_ERROR_NONE;
 }
 
+//LCOV_EXCL_START
 /**
 * @brief Sets key value of command.
 *
@@ -1727,8 +1763,6 @@ static int __vc_cmd_trelative_check(const char *str, struct tm *td, int *exist)
        int hour = -1;
        int min = -1;
 
-       char *tempstr = NULL;
-
        *exist = 0;
        ret = regexec(&reg[3], str, 1, pmatch, 0);
        if (0 == ret) {
@@ -1746,7 +1780,7 @@ static int __vc_cmd_trelative_check(const char *str, struct tm *td, int *exist)
                                SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid string length");
                                return VC_ERROR_OPERATION_FAILED;
                        }
-                       tempstr = strndup(str + pmatch[1].rm_so, (size_t)len);
+                       char *tempstr = strndup(str + pmatch[1].rm_so, (size_t)len);
 
                        if (NULL == tempstr) {
                                SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Memory allocation is failed");
@@ -1772,7 +1806,7 @@ static int __vc_cmd_trelative_check(const char *str, struct tm *td, int *exist)
                                SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid string length");
                                return VC_ERROR_OPERATION_FAILED;
                        }
-                       tempstr = strndup(str + pmatch[1].rm_so, (size_t)len);
+                       char *tempstr = strndup(str + pmatch[1].rm_so, (size_t)len);
 
                        if (NULL == tempstr) {
                                SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Memory allocation is failed");
@@ -1825,7 +1859,6 @@ static int __vc_cmd_tabsolute_check(const char *str, struct tm *td, int *exist)
        int min = -1;
        int sidx = -1;
        int eidx = -1;
-       char *tempstr = NULL;
 
        *exist = 0;
        ret = regexec(&reg[0], str, 5, pmatch, 0);
@@ -1846,7 +1879,7 @@ static int __vc_cmd_tabsolute_check(const char *str, struct tm *td, int *exist)
                        SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid string length");
                        return VC_ERROR_OPERATION_FAILED;
                }
-               tempstr = strndup(str + pmatch[1].rm_so, (size_t)len);
+               char *tempstr = strndup(str + pmatch[1].rm_so, (size_t)len);
 
                if (NULL == tempstr) {
                        SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Memory allocation is failed");
@@ -1886,7 +1919,7 @@ static int __vc_cmd_tabsolute_check(const char *str, struct tm *td, int *exist)
                idx = 1;
                len = pmatch[idx].rm_eo - pmatch[idx].rm_so;
                if (0 < len) {
-                       tempstr = strndup(str + pmatch[idx].rm_so, (size_t)len);
+                       char *tempstr = strndup(str + pmatch[idx].rm_so, (size_t)len);
 
                        if (NULL == tempstr) {
                                SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Memory allocation is failed");
@@ -2317,3 +2350,4 @@ int vc_cmd_get_datetime(const char *text, time_t *result, char **remain)
 
        return VC_ERROR_NONE;
 }
+//LCOV_EXCL_STOP