Clean up vc_command file.

Change-Id: If52823d88ae98b95a6ded59e67621d313a6815ab
Signed-off-by: sungrae jo <seongrae.jo@samsung.com>

diff --git a/common/vc_command.c b/common/vc_command.c
index c0dc4967814c138ddfdbe387f607a715b96443a2..2446284116d8d8492d421382c1c3ce23586dad29 100644 (file)
--- a/common/vc_command.c
+++ b/common/vc_command.c
@@ -165,74 +165,6 @@ static int __vc_cmd_check_privilege()
        return VC_ERROR_NONE;
 }
 
-static bool __vc_cmd_is_valid(vc_cmd_h vc_command)
-{
-       if (NULL == g_cmd_list) {
-               SLOG(LOG_WARN, TAG_VCCMD, "[WARNING] cmd_list is not valid");
-               return false;
-       }
-
-       if (g_list_length(g_cmd_list) == 0) {
-               SLOG(LOG_WARN, TAG_VCCMD, "[WARNING] cmd_list is not valid");
-               return false;
-       }
-
-       bool flag = false;
-       vc_cmd_s *command = NULL;
-       command = (vc_cmd_s *)vc_command;
-
-       GList *iter = NULL;
-       iter = g_list_first(g_cmd_list);
-       while (NULL != iter) {
-               vc_cmd_s *data = NULL;
-               data = iter->data;
-               if (NULL != data && command == data) {
-                       flag = true;
-                       break;
-               }
-               iter = g_list_next(iter);
-       }
-
-       if (false == flag)
-               SLOG(LOG_WARN, TAG_VCCMD, "[WARNING] command(%p) is not valid", command);
-
-       return flag;
-}
-
-static bool __vc_cmd_list_is_valid(vc_cmd_list_h vc_cmd_list)
-{
-       if (NULL == g_cmdlist_list) {
-               SLOG(LOG_WARN, TAG_VCCMD, "[WARNING] cmdlist_list is not valid");
-               return false;
-       }
-
-       if (g_list_length(g_cmdlist_list) == 0) {
-               SLOG(LOG_WARN, TAG_VCCMD, "[WARNING] cmdlist_list is not valid");
-               return false;
-       }
-
-       bool flag = false;
-       vc_cmd_list_s *list = NULL;
-       list = (vc_cmd_list_s *)vc_cmd_list;
-
-       GList *iter = NULL;
-       iter = g_list_first(g_cmdlist_list);
-       while (NULL != iter) {
-               vc_cmd_list_s *data = NULL;
-               data = iter->data;
-               if (NULL != data && list == data) {
-                       flag = true;
-                       break;
-               }
-               iter = g_list_next(iter);
-       }
-
-       if (false == flag)
-               SLOG(LOG_WARN, TAG_VCCMD, "[WARNING] list(%p) is not valid", list);
-
-       return flag;
-}
-
 int vc_cmd_list_create(vc_cmd_list_h* vc_cmd_list)
 {
        if (0 != __vc_cmd_get_feature_enabled()) {
@@ -280,11 +212,6 @@ int vc_cmd_list_destroy(vc_cmd_list_h vc_cmd_list, bool release_command)
                return VC_ERROR_INVALID_PARAMETER;
        }
 
-       if (false == __vc_cmd_list_is_valid(vc_cmd_list)) {
-               SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Input parameter is NULL");
-               return VC_ERROR_INVALID_PARAMETER;
-       }
-
        vc_cmd_list_remove_all(vc_cmd_list, release_command);
 
        vc_cmd_list_s* list = NULL;
@@ -293,34 +220,19 @@ int vc_cmd_list_destroy(vc_cmd_list_h vc_cmd_list, bool release_command)
        SLOG(LOG_DEBUG, TAG_VCCMD, "[List] list(%p)", list);
 
        GList *iter = NULL;
-       vc_cmd_list_s *data = NULL;
-
-       /* if list have item */
-       if (g_list_length(g_cmdlist_list) > 0) {
-               /* Get a first item */
-               iter = g_list_first(g_cmdlist_list);
-
-               while (NULL != iter) {
-                       data = iter->data;
-                       if (NULL != data && list == data) {
-                               g_cmdlist_list = g_list_remove_link(g_cmdlist_list, iter);
-
-                               free(data);
-                               data = NULL;
-
-                               SLOG(LOG_DEBUG, TAG_VCCMD, "Client destroy");
-                               g_list_free(iter);
-                               iter = NULL;
-
-                               return VC_ERROR_NONE;
-                       }
-                       /* Next item */
-                       iter = g_list_next(iter);
-               }
+       iter = g_list_find(g_cmdlist_list, list);
+       if (NULL == iter) {
+               SLOG(LOG_ERROR, TAG_VCCMD, "Fail to destroy client : handle is not valid");
+               return VC_ERROR_INVALID_PARAMETER;
        }
-       SLOG(LOG_ERROR, TAG_VCCMD, "Fail to destroy client : handle is not valid");
 
-       return VC_ERROR_INVALID_PARAMETER;
+       g_cmdlist_list = g_list_remove_link(g_cmdlist_list, iter);
+       if (iter->data)
+               free(iter->data);
+       iter->data = NULL;
+       iter = NULL;
+       SLOG(LOG_DEBUG, TAG_VCCMD, "Client destroy");
+       return VC_ERROR_NONE;
 }
 
 int vc_cmd_list_get_count(vc_cmd_list_h vc_cmd_list, int* count)
@@ -400,41 +312,52 @@ int vc_cmd_list_remove(vc_cmd_list_h vc_cmd_list, vc_cmd_h vc_command)
 
        SLOG(LOG_DEBUG, TAG_VCCMD, "[List] list(%p), command(%p)", list, cmd);
 
-       vc_cmd_s* temp_cmd = NULL;
        GSList *iter = NULL;
-
-       iter = g_slist_nth(list->list, 0);
-
-       while (NULL != iter) {
-               temp_cmd = iter->data;
-
-               if (NULL != temp_cmd && cmd == temp_cmd) {
-                       list->list = g_slist_remove(list->list, temp_cmd);
-                       /*
-                       if (true == release_command) {
-                               SLOG(LOG_DEBUG, TAG_VCCMD, "Release command data");
-                               if (NULL != temp_cmd->command)          free(temp_cmd->command);
-                               if (NULL != temp_cmd->parameter)        free(temp_cmd->parameter);
-                               free(temp_cmd);
-                               temp_cmd = NULL;
-                       }
-                       */
-               }
-
-               iter = g_slist_next(iter);
+       iter = g_slist_find(list->list, cmd);
+       if (NULL == iter) {
+               SLOG(LOG_ERROR, TAG_VCCMD, "Fail to destroy command : handle is not valid");
+               return VC_ERROR_INVALID_PARAMETER;
        }
 
-       int count = g_slist_length(list->list);
+       list->list = g_slist_remove_link(list->list, iter);
+       SLOG(LOG_DEBUG, TAG_VCCMD, "destroy command");
 
-       if (0 == count) {
+       int len = g_slist_length(list->list);
+       if (0 == len)
                list->index = -1;
-       } else if (list->index == count) {
-               list->index = count - 1;
-       }
+       else if (list->index == len)
+               list->index = len - 1;
 
        return VC_ERROR_NONE;
 }
 
+static void __vc_cmd_list_remove_all_foreach(gpointer data, gpointer user_data)
+{
+       vc_cmd_s *temp = NULL;
+       temp = data;
+       if (temp) {
+               SLOG(LOG_DEBUG, TAG_VCCMD, "Free command(%p)", temp);
+               if (temp->command)
+                       free(temp->command);
+               temp->command = NULL;
+               if (temp->parameter)
+                       free(temp->parameter);
+               temp->parameter = NULL;
+               if (temp->appid)
+                       free(temp->appid);
+               temp->appid = NULL;
+               if (temp->invocation_name)
+                       free(temp->invocation_name);
+               temp->invocation_name = NULL;
+               if (temp->fixed)
+                       free(temp->fixed);
+               temp->fixed = NULL;
+               free(temp);
+       }
+       temp = NULL;
+       return;
+}
+
 int vc_cmd_list_remove_all(vc_cmd_list_h vc_cmd_list, bool release_command)
 {
        if (0 != __vc_cmd_get_feature_enabled()) {
@@ -457,25 +380,9 @@ int vc_cmd_list_remove_all(vc_cmd_list_h vc_cmd_list, bool release_command)
        SLOG(LOG_DEBUG, TAG_VCCMD, "[List] list (%p), release command (%s)"
                 , list, release_command ? "true" : "false");
 
-       int count = g_slist_length(list->list);
-       for (int i = 0; i < count ; i++) {
-               vc_cmd_s *temp_cmd = g_slist_nth_data(list->list, 0);
-
-               if (NULL != temp_cmd) {
-                       list->list = g_slist_remove(list->list, temp_cmd);
-
-                       if (true == release_command) {
-                               SLOG(LOG_DEBUG, TAG_VCCMD, "Free command(%p)", temp_cmd);
-                               if (NULL != temp_cmd->command)          free(temp_cmd->command);
-                               if (NULL != temp_cmd->parameter)        free(temp_cmd->parameter);
-                               if (NULL != temp_cmd->appid)            free(temp_cmd->appid);
-                               if (NULL != temp_cmd->invocation_name)  free(temp_cmd->invocation_name);
-                               if (NULL != temp_cmd->fixed)            free(temp_cmd->fixed);
-                               free(temp_cmd);
-                               temp_cmd = NULL;
-                       }
-               }
-       }
+       if (true == release_command)
+               g_slist_foreach(list->list, __vc_cmd_list_remove_all_foreach, NULL);
+       g_slist_free(list->list);
        list->list = NULL;
        list->index = -1;
 
@@ -501,28 +408,18 @@ int vc_cmd_list_foreach_commands(vc_cmd_list_h vc_cmd_list, vc_cmd_list_cb callb
        vc_cmd_list_s* list = NULL;
        list = (vc_cmd_list_s*)vc_cmd_list;
 
-       int count = g_slist_length(list->list);
-       int i ;
-
        GSList *iter = NULL;
-       vc_cmd_s *temp_cmd;
-
        iter = g_slist_nth(list->list, 0);
-
-       for (i = 0; i < count; i++) {
-               if (NULL == iter) {
+       while (NULL != iter) {
+               vc_cmd_s *temp_cmd = NULL;
+               temp_cmd = iter->data;
+               if (NULL == temp_cmd) {
                        SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] No command in list");
                        return VC_ERROR_OPERATION_FAILED;
                }
+               if (false == callback((vc_cmd_h)temp_cmd, user_data))
+                       break;
 
-               temp_cmd = iter->data;
-
-               if (NULL != temp_cmd) {
-                       if (false == callback((vc_cmd_h)temp_cmd, user_data)) {
-                               break;
-                       }
-
-               }
                iter = g_slist_next(iter);
        }
 
@@ -561,56 +458,45 @@ int vc_cmd_list_filter_by_type(vc_cmd_list_h original, int type, vc_cmd_list_h*
                return VC_ERROR_OPERATION_FAILED;
        }
 
-       int count = g_slist_length(list->list);
-       int i;
-
        GSList *iter = NULL;
-       vc_cmd_s *iter_cmd;
-
        iter = g_slist_nth(list->list, 0);
-
-       for (i = 0; i < count; i++) {
-               if (NULL == iter) {
+       while (NULL != iter) {
+               vc_cmd_s *iter_cmd = NULL;
+               iter_cmd = iter->data;
+               if (NULL == iter_cmd) {
                        SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] No command in list");
                        return VC_ERROR_OPERATION_FAILED;
                }
-               if (NULL != iter->data) {
-                       iter_cmd = iter->data;
-
-                       if (NULL != iter_cmd) {
-                               int iter_type;
-                               if (0 != vc_cmd_get_type((vc_cmd_h)iter_cmd, &iter_type)) {
-                                       SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Fail to get command type");
-                                       continue;
-                               }
 
-                               if (iter_type == type) {
-                                       vc_cmd_h temp_cmd;
-                                       if (0 != vc_cmd_create(&temp_cmd)) {
-                                               SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Fail to create cmd");
-                                               continue;
-                                       }
-
-                                       memcpy(temp_cmd, iter_cmd, sizeof(vc_cmd_s));
-                                       if (NULL != iter_cmd->command) {
-                                               ((vc_cmd_s*)temp_cmd)->command = strdup(iter_cmd->command);
-                                       }
-                                       if (NULL != iter_cmd->parameter) {
-                                               ((vc_cmd_s*)temp_cmd)->parameter = strdup(iter_cmd->parameter);
-                                       }
-
-                                       if (0 != vc_cmd_list_add(temp_list, temp_cmd)) {
-                                               SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Fail to cmd list add");
-                                               vc_cmd_destroy(temp_cmd);
-                                               continue;
-                                       }
-                               }
+               int iter_type = 0;
+               if (0 != vc_cmd_get_type((vc_cmd_h)iter_cmd, &iter_type)) {
+                       SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Fail to get command type");
+                       continue;
+               }
+
+               if (iter_type == type) {
+                       vc_cmd_h temp_cmd;
+                       if (0 != vc_cmd_create(&temp_cmd)) {
+                               SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Fail to create cmd");
+                               continue;
+                       }
+
+                       memcpy(temp_cmd, iter_cmd, sizeof(vc_cmd_s));
+                       if (NULL != iter_cmd->command)
+                               ((vc_cmd_s *)temp_cmd)->command = strdup(iter_cmd->command);
+                       if (NULL != iter_cmd->parameter)
+                               ((vc_cmd_s *)temp_cmd)->parameter = strdup(iter_cmd->parameter);
+
+                       if (0 != vc_cmd_list_add(temp_list, temp_cmd)) {
+                               SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Fail to cmd list add");
+                               vc_cmd_destroy(temp_cmd);
+                               continue;
                        }
                }
                iter = g_slist_next(iter);
        }
 
-       count = 0;
+       int count = 0;
        if (0 != vc_cmd_list_get_count(temp_list, &count)) {
                SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Fail to get count");
        } else {
@@ -835,67 +721,40 @@ int vc_cmd_destroy(vc_cmd_h vc_command)
                return VC_ERROR_INVALID_PARAMETER;
        }
 
-       if (false == __vc_cmd_is_valid(vc_command)) {
-               SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Input parameter is NULL");
-               return VC_ERROR_INVALID_PARAMETER;
-       }
-
        vc_cmd_s* command = NULL;
        command = (vc_cmd_s*)vc_command;
 
        SLOG(LOG_DEBUG, TAG_VCCMD, "[Destroy command][%p]", command);
 
-       bool flag = false;
        GList *iter = NULL;
-       iter = g_list_first(g_cmd_list);
-       while (NULL != iter) {
-               vc_cmd_s *data = NULL;
-               data = iter->data;
-               if (NULL != data && command == data) {
-                       g_cmd_list = g_list_remove_link(g_cmd_list, iter);
-                       flag = true;
-                       break;
-               }
-               iter = g_list_next(iter);
-       }
-
-       if (false == flag) {
-               SLOG(LOG_ERROR, TAG_VCCMD, "Fail to destroy client : handle is not valid");
+       iter = g_list_find(g_cmd_list, command);
+       if (NULL == iter) {
+               SLOG(LOG_ERROR, TAG_VCCMD, "Fail to command destroy : handle is not valid");
                return VC_ERROR_INVALID_PARAMETER;
        }
 
-       if (iter)
-               g_list_free(iter);
-       iter = NULL;
+       g_cmd_list = g_list_remove_link(g_cmd_list, iter);
 
-       if (NULL != command) {
-               if (NULL != command->command) {
-                       free(command->command);
-                       command->command = NULL;
-               }
-               if (NULL != command->parameter) {
-                       free(command->parameter);
-                       command->parameter = NULL;
-               }
-               if (NULL != command->invocation_name) {
-                       free(command->invocation_name);
-                       command->invocation_name = NULL;
-               }
-               if (NULL != command->appid) {
-                       free(command->appid);
-                       command->appid = NULL;
-               }
-               if (NULL != command->fixed) {
-                       free(command->fixed);
-                       command->fixed = NULL;
-               }
-               if (NULL != command->coordinates) {
-                       free(command->coordinates);
-                       command->coordinates = NULL;
-               }
-               free(command);
-               command = NULL;
-       }
+       if (command->command)
+               free(command->command);
+       command->command = NULL;
+       if (command->parameter)
+               free(command->parameter);
+       command->parameter = NULL;
+       if (command->invocation_name)
+               free(command->invocation_name);
+       command->invocation_name = NULL;
+       if (command->appid)
+               free(command->appid);
+       command->appid = NULL;
+       if (command->fixed)
+               free(command->fixed);
+       command->fixed = NULL;
+       if (command->coordinates)
+               free(command->coordinates);
+       command->coordinates = NULL;
+       free(command);
+       command = NULL;
 
        return VC_ERROR_NONE;
 }
@@ -917,10 +776,8 @@ int vc_cmd_set_id(vc_cmd_h vc_command, int id)
        vc_cmd_s* cmd = NULL;
        cmd = (vc_cmd_s*)vc_command;
 
-       if (NULL != cmd) {
-               cmd->id = id;
-               SLOG(LOG_DEBUG, TAG_VCCMD, "[Set id][%p] id(%d)", vc_command, cmd->id);
-       }
+       cmd->id = id;
+       SLOG(LOG_DEBUG, TAG_VCCMD, "[Set id][%p] id(%d)", vc_command, cmd->id);
 
        return 0;
 }
@@ -942,10 +799,8 @@ int vc_cmd_get_id(vc_cmd_h vc_command, int* id)
        vc_cmd_s* cmd = NULL;
        cmd = (vc_cmd_s*)vc_command;
 
-       if (NULL != cmd) {
-               *id = cmd->id;
-               SLOG(LOG_DEBUG, TAG_VCCMD, "[Get id][%p] id(%d)", vc_command, *id);
-       }
+       *id = cmd->id;
+       SLOG(LOG_DEBUG, TAG_VCCMD, "[Get id][%p] id(%d)", vc_command, *id);
 
        return 0;
 }
@@ -969,11 +824,9 @@ int vc_cmd_set_appid(vc_cmd_h vc_command, const char* appid)
        vc_cmd_s* cmd = NULL;
        cmd = (vc_cmd_s*)vc_command;
 
-       if (NULL != cmd->appid) {
+       if (cmd->appid)
                free(cmd->appid);
-               cmd->appid = NULL;
-       }
-
+       cmd->appid = NULL;
        cmd->appid = strdup(appid);
 
        SLOG(LOG_DEBUG, TAG_VCCMD, "[Set appid][%p] appid(%s)", vc_command, cmd->appid);
@@ -994,11 +847,13 @@ int vc_cmd_get_appid(vc_cmd_h vc_command, char** appid)
        vc_cmd_s* cmd = NULL;
        cmd = (vc_cmd_s*)vc_command;
 
-       if (NULL != cmd->appid) {
+       if (cmd->appid)
                *appid = strdup(gettext(cmd->appid));
-       }
+       else
+               *appid = NULL;
 
        SLOG(LOG_DEBUG, TAG_VCCMD, "[Get appid][%p] appid(%s)", vc_command, *appid);
+
        return 0;
 }
 
@@ -1019,15 +874,10 @@ int vc_cmd_set_command(vc_cmd_h vc_command, const char* command)
        vc_cmd_s* cmd = NULL;
        cmd = (vc_cmd_s*)vc_command;
 
-       if (NULL != cmd->command) {
+       if (cmd->command)
                free(cmd->command);
-       }
-
        cmd->command = NULL;
-
-       if (NULL != command) {
-               cmd->command = strdup(command);
-       }
+       cmd->command = strdup(command);
 
        SLOG(LOG_DEBUG, TAG_VCCMD, "[Set command][%p] Command(%s)", vc_command, cmd->command);
 
@@ -1051,9 +901,10 @@ int vc_cmd_get_command(vc_cmd_h vc_command, char** command)
        vc_cmd_s* cmd = NULL;
        cmd = (vc_cmd_s*)vc_command;
 
-       if (NULL != cmd->command) {
+       if (cmd->command)
                *command = strdup(gettext(cmd->command));
-       }
+       else
+               *command = NULL;
 
        SLOG(LOG_DEBUG, TAG_VCCMD, "[Get command][%p] Command(%s)", vc_command, *command);
 
@@ -1069,7 +920,7 @@ int vc_cmd_set_unfixed_command(vc_cmd_h vc_command, const char* command)
                return VC_ERROR_PERMISSION_DENIED;
        }
 
-       if (NULL == vc_command) {
+       if (NULL == vc_command || NULL == command) {
                SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
                return VC_ERROR_INVALID_PARAMETER;
        }
@@ -1077,16 +928,11 @@ int vc_cmd_set_unfixed_command(vc_cmd_h vc_command, const char* command)
        vc_cmd_s* cmd = NULL;
        cmd = (vc_cmd_s*)vc_command;
 
-       if (NULL != cmd->parameter) {
+       if (cmd->parameter)
                free(cmd->parameter);
-       }
-
        cmd->parameter = NULL;
-
-       if (NULL != command) {
-               cmd->parameter = strdup(command);
-               SLOG(LOG_DEBUG, TAG_VCCMD, "[Set unfixed command][%p] unfixed command(%s)", vc_command, cmd->parameter);
-       }
+       cmd->parameter = strdup(command);
+       SLOG(LOG_DEBUG, TAG_VCCMD, "[Set unfixed command][%p] unfixed command(%s)", vc_command, cmd->parameter);
 
        return 0;
 }
@@ -1105,10 +951,12 @@ int vc_cmd_get_unfixed_command(vc_cmd_h vc_command, char** command)
        vc_cmd_s* cmd = NULL;
        cmd = (vc_cmd_s*)vc_command;
 
-       if (NULL != cmd->parameter) {
+       if (cmd->parameter)
                *command = strdup(gettext(cmd->parameter));
-               SLOG(LOG_DEBUG, TAG_VCCMD, "[Get unfixed command][%p] unfixed command(%s)", vc_command, *command);
-       }
+       else
+               *command = NULL;
+
+       SLOG(LOG_DEBUG, TAG_VCCMD, "[Get unfixed command][%p] unfixed command(%s)", vc_command, *command);
 
        return 0;
 }
@@ -1132,11 +980,9 @@ int vc_cmd_set_fixed_command(vc_cmd_h vc_command, const char* fixed)
        vc_cmd_s* cmd = NULL;
        cmd = (vc_cmd_s*)vc_command;
 
-       if (NULL != cmd->fixed) {
+       if (cmd->fixed)
                free(cmd->fixed);
-               cmd->fixed = NULL;
-       }
-
+       cmd->fixed = NULL;
        cmd->fixed = strdup(fixed);
 
        SLOG(LOG_DEBUG, TAG_VCCMD, "[Set parameter][%p] fixed command(%s)", vc_command, cmd->fixed);
@@ -1157,10 +1003,12 @@ int vc_cmd_get_fixed_command(vc_cmd_h vc_command, char** fixed)
        vc_cmd_s* cmd = NULL;
        cmd = (vc_cmd_s*)vc_command;
 
-       if (NULL != cmd->fixed) {
+       if (cmd->fixed)
                *fixed = strdup(gettext(cmd->fixed));
-               SLOG(LOG_DEBUG, TAG_VCCMD, "[Get fixed command][%p] fixed command(%s)", vc_command, *fixed);
-       }
+       else
+               *fixed = NULL;
+
+       SLOG(LOG_DEBUG, TAG_VCCMD, "[Get fixed command][%p] fixed command(%s)", vc_command, *fixed);
 
        return 0;
 }
@@ -1184,11 +1032,9 @@ int vc_cmd_set_invocation_name(vc_cmd_h vc_command, const char* invocation_name)
        vc_cmd_s* cmd = NULL;
        cmd = (vc_cmd_s*)vc_command;
 
-       if (NULL != cmd->invocation_name) {
+       if (cmd->invocation_name)
                free(cmd->invocation_name);
-               cmd->invocation_name = NULL;
-       }
-
+       cmd->invocation_name = NULL;
        cmd->invocation_name = strdup(invocation_name);
 
        SLOG(LOG_DEBUG, TAG_VCCMD, "[Set invocation name][%p] invocation_name(%s)", vc_command, cmd->invocation_name);
@@ -1209,9 +1055,10 @@ int vc_cmd_get_invocation_name(vc_cmd_h vc_command, char** invocation_name)
        vc_cmd_s* cmd = NULL;
        cmd = (vc_cmd_s*)vc_command;
 
-       if (NULL != cmd->invocation_name) {
+       if (cmd->invocation_name)
                *invocation_name = strdup(gettext(cmd->invocation_name));
-       }
+       else
+               *invocation_name = NULL;
 
        SLOG(LOG_DEBUG, TAG_VCCMD, "[Get invocation name][%p] invocation_name(%s)", vc_command, *invocation_name);
        return 0;
@@ -1483,18 +1330,20 @@ int vc_cmd_print_list(vc_cmd_list_h vc_cmd_list)
        SLOG(LOG_DEBUG, TAG_VCCMD, "@ Command List @");
        SLOG(LOG_DEBUG, TAG_VCCMD, "[List][%p]", list);
 
-       int count = g_slist_length(list->list);
-
-       int i;
-       vc_cmd_s *cmd = NULL;
-
-       for (i = 0; i < count ; i++) {
-               cmd = g_slist_nth_data(list->list, i);
-
-               if (NULL != cmd) {
-                       SLOG(LOG_DEBUG, TAG_VCCMD, "  [%d][%p] PID(%d) ID(%d) Type(%d) Format(%d) Command(%s) Param(%s) Appid(%s) Invocation(%s) Fixed(%s)",
-                        i, cmd, cmd->pid, cmd->index, cmd->type, cmd->format, cmd->command, cmd->parameter, cmd->appid, cmd->invocation_name, cmd->fixed);
+       int i = 0;
+       GSList *iter = NULL;
+       iter = g_slist_nth(list->list, 0);
+       while (NULL != iter) {
+               vc_cmd_s *cmd = NULL;
+               cmd = iter->data;
+               if (NULL == cmd) {
+                       SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] No command in list");
+                       return VC_ERROR_OPERATION_FAILED;
                }
+               SLOG(LOG_DEBUG, TAG_VCCMD, "  [%d][%p] PID(%d) ID(%d) Type(%d) Format(%d) Command(%s) Param(%s) Appid(%s) Invocation(%s) Fixed(%s)",
+                        i++, cmd, cmd->pid, cmd->index, cmd->type, cmd->format, cmd->command, cmd->parameter, cmd->appid, cmd->invocation_name, cmd->fixed);
+
+               iter = g_slist_next(iter);
        }
 
        SLOG(LOG_DEBUG, TAG_VCCMD, "@@@");