Fix static analysis issue

- Remove the use of large stack

Change-Id: Ic24d7d09d3423043dd6d3dbe68657b05a0b29923
Signed-off-by: Ilho Kim <ilho159.kim@samsung.com>

diff --git a/src/pkgcmd/pkg_cmd.c b/src/pkgcmd/pkg_cmd.c
index 0a9ee9b..291ce0b 100644 (file)
--- a/src/pkgcmd/pkg_cmd.c
+++ b/src/pkgcmd/pkg_cmd.c
@@ -117,6 +117,8 @@ static GMainLoop *main_loop = NULL;
 
 static void __free_data(pm_tool_args *data)
 {
+       if (!data)
+               return;
        if (data->resolved_path_pkg_old)
                free(data->resolved_path_pkg_old);
        if (data->resolved_path_pkg_new)
@@ -125,6 +127,7 @@ static void __free_data(pm_tool_args *data)
                free(data->resolved_path_delta_pkg);
        if (data->pkgs)
                g_list_free_full(data->pkgs, free);
+       free(data);
 }
 
 static void __error_no_to_string(int errnumber, char **errstr)
@@ -1554,7 +1557,7 @@ int main(int argc, char *argv[])
        long endtime;
        struct timeval tv;
        bool is_root_cmd = false;
-       pm_tool_args data = { 0 };
+       pm_tool_args *data;
        GList *list;
        /* Supported options */
        /* Note: 'G' is reserved */
@@ -1603,25 +1606,15 @@ int main(int argc, char *argv[])
        gettimeofday(&tv, NULL);
        starttime = tv.tv_sec * 1000l + tv.tv_usec / 1000l;
 
-       data.request = -1;
-       memset(data.des_path, '\0', PATH_MAX);
-       memset(data.pkg_path, '\0', PATH_MAX);
-       memset(data.pkgid, '\0', PKG_NAME_STRING_LEN_MAX);
-       memset(data.pkg_old, '\0', PATH_MAX);
-       memset(data.pkg_new, '\0', PATH_MAX);
-       memset(data.delta_pkg, '\0', PATH_MAX);
-       memset(data.pkg_type, '\0', PKG_TYPE_STRING_LEN_MAX);
-       memset(data.label, '\0', PKG_TYPE_STRING_LEN_MAX);
-       memset(data.tep_path, '\0', PATH_MAX);
-
-       data.tep_move = 0;
-       data.global = 0; /* By default pkg_cmd will manage for the current user */
-       data.result = 0;
-       data.type = -1;
-       data.uid = -1;
-       data.pkgs = NULL;
-       data.start_count = 0;
-       data.end_count = 0;
+       data = calloc(1, sizeof(pm_tool_args));
+       if (data == NULL) {
+               printf("Out of memory\n");
+               return -1;
+       }
+
+       data->request = -1;
+       data->type = -1;
+       data->uid = -1;
 
        while (1) {
                c = getopt_long(argc, argv, short_options, long_options,
@@ -1630,213 +1623,213 @@ int main(int argc, char *argv[])
                        break;  /* Parse end */
                switch (c) {
                case OPTVAL_GLOBAL:  /* global mode */
-                       data.global = 1;
+                       data->global = 1;
                        break;
 
                case 'i':  /* install */
-                       data.request = INSTALL_REQ;
+                       data->request = INSTALL_REQ;
                        break;
 
                case 'u':  /* uninstall */
-                       data.request = UNINSTALL_REQ;
+                       data->request = UNINSTALL_REQ;
                        break;
 
                case 'r':  /* reinstall */
-                       data.request = REINSTALL_REQ;
+                       data->request = REINSTALL_REQ;
                        break;
 
                case 'w':  /* mount install */
-                       data.request = MOUNT_INSTALL_REQ;
+                       data->request = MOUNT_INSTALL_REQ;
                        break;
 
                case 'c':  /* clear */
-                       data.request = CLEAR_REQ;
+                       data->request = CLEAR_REQ;
                        break;
 
                case OPTVAL_CLEAR_ALL:  /* clear all */
-                       data.request = CLEAR_ALL_REQ;
+                       data->request = CLEAR_ALL_REQ;
                        break;
 
                case 'g':  /* get pkg size */
-                       data.request = GETSIZE_REQ;
+                       data->request = GETSIZE_REQ;
                        break;
 
                case 'x':  /* get pkg size info */
-                       data.request = GET_PKG_SIZE_INFO_REQ;
+                       data->request = GET_PKG_SIZE_INFO_REQ;
                        break;
 
                case 'm':  /* move */
-                       data.request = MOVE_REQ;
+                       data->request = MOVE_REQ;
                        break;
 
                case 'A':  /* activate */
-                       data.request = ACTIVATE_REQ;
+                       data->request = ACTIVATE_REQ;
                        break;
 
                case 'D':  /* deactivate */
-                       data.request = DEACTIVATE_REQ;
+                       data->request = DEACTIVATE_REQ;
                        break;
 
                case 'L':  /* activate with Label */
-                       data.request = ACTIVATE_REQ;
+                       data->request = ACTIVATE_REQ;
                        if (optarg)
-                               snprintf(data.label, sizeof(data.label),
+                               snprintf(data->label, sizeof(data->label),
                                                "%s", optarg);
                        break;
 
                case 'a':  /* app installation path */
-                       data.request = APPPATH_REQ;
+                       data->request = APPPATH_REQ;
                        break;
 
                case 'k':  /* Terminate applications of a package */
-                       data.request = KILLAPP_REQ;
+                       data->request = KILLAPP_REQ;
                        break;
 
                case 'C':  /* Check running status of applications of a package */
-                       data.request = CHECKAPP_REQ;
+                       data->request = CHECKAPP_REQ;
                        break;
 
                case 'l':  /* list */
-                       data.request = LIST_REQ;
+                       data->request = LIST_REQ;
                        break;
 
                case 's':  /* show */
-                       data.request = SHOW_REQ;
+                       data->request = SHOW_REQ;
                        break;
 
                case 'p':  /* package path */
                        if (optarg)
-                               snprintf(data.pkg_path, sizeof(data.pkg_path),
+                               snprintf(data->pkg_path, sizeof(data->pkg_path),
                                                "%s", optarg);
-                       __parse_multiple_pkgs(&data, argc, argv);
-                       ret = __convert_to_absolute_path(&data);
+                       __parse_multiple_pkgs(data, argc, argv);
+                       ret = __convert_to_absolute_path(data);
                        if (ret == -1)
                                printf("conversion of relative path to absolute path failed\n");
                        printf("path is ");
-                       if (g_list_length(data.pkgs)) {
-                               for (list = data.pkgs; list;
+                       if (g_list_length(data->pkgs)) {
+                               for (list = data->pkgs; list;
                                                list = list->next) {
                                        printf("%s ", (char *)list->data);
                                }
                                printf("\n");
                        } else {
-                               printf("%s\n", data.pkg_path);
+                               printf("%s\n", data->pkg_path);
                        }
                        break;
 
                case 'X':  /* old_tpk */
-                       data.request = CREATE_DELTA;
+                       data->request = CREATE_DELTA;
                        is_root_cmd = true;
                        if (optarg)
-                               strncpy(data.pkg_old, optarg, PATH_MAX - 1);
+                               strncpy(data->pkg_old, optarg, PATH_MAX - 1);
 
-                       data.resolved_path_pkg_old = realpath(data.pkg_old, NULL);
-                       if (data.resolved_path_pkg_old == NULL) {
+                       data->resolved_path_pkg_old = realpath(data->pkg_old, NULL);
+                       if (data->resolved_path_pkg_old == NULL) {
                                printf("failed to set realpath\n");
-                               __free_data(&data);
+                               __free_data(data);
                                return -1;
                        }
-                       printf("pkg_old abs path is %s\n", data.resolved_path_pkg_old);
+                       printf("pkg_old abs path is %s\n", data->resolved_path_pkg_old);
                        break;
 
                case 'Y':  /* new_tpk */
                        if (optarg)
-                               strncpy(data.pkg_new, optarg, PATH_MAX - 1);
+                               strncpy(data->pkg_new, optarg, PATH_MAX - 1);
 
-                       data.resolved_path_pkg_new = realpath(data.pkg_new, NULL);
-                       if (data.resolved_path_pkg_new == NULL) {
+                       data->resolved_path_pkg_new = realpath(data->pkg_new, NULL);
+                       if (data->resolved_path_pkg_new == NULL) {
                                printf("failed to set realpath\n");
-                               __free_data(&data);
+                               __free_data(data);
                                return -1;
                        }
-                       printf("pkg_new abs path is %s\n", data.resolved_path_pkg_new);
+                       printf("pkg_new abs path is %s\n", data->resolved_path_pkg_new);
                        break;
 
                case 'Z':  /* delta_tpk */
                        if (optarg)
-                               strncpy(data.delta_pkg, optarg, PATH_MAX - 1);
+                               strncpy(data->delta_pkg, optarg, PATH_MAX - 1);
 
-                       printf("delta_pkg is %s\n", data.delta_pkg);
+                       printf("delta_pkg is %s\n", data->delta_pkg);
 
-                       data.resolved_path_delta_pkg = realpath(data.delta_pkg, NULL);
-                       if (data.resolved_path_delta_pkg == NULL) {
+                       data->resolved_path_delta_pkg = realpath(data->delta_pkg, NULL);
+                       if (data->resolved_path_delta_pkg == NULL) {
                                printf("failed to set realpath\n");
-                               __free_data(&data);
+                               __free_data(data);
                                return -1;
                        }
-                       printf("delta_pkg abs path is %s\n", data.resolved_path_delta_pkg);
+                       printf("delta_pkg abs path is %s\n", data->resolved_path_delta_pkg);
                        break;
                case 'd':  /* descriptor path */
                        if (optarg)
-                               snprintf(data.des_path, sizeof(data.des_path),
+                               snprintf(data->des_path, sizeof(data->des_path),
                                                "%s", optarg);
                        break;
 
                case 'n':  /* package name */
                        if (optarg)
-                               snprintf(data.pkgid, sizeof(data.pkgid),
+                               snprintf(data->pkgid, sizeof(data->pkgid),
                                                "%s", optarg);
 
-                       __parse_multiple_pkgs(&data, argc, argv);
+                       __parse_multiple_pkgs(data, argc, argv);
                        break;
 
                case 'e':  /* tep name */
                        if (optarg)
-                               strncpy(data.tep_path, optarg,
+                               strncpy(data->tep_path, optarg,
                                        PATH_MAX - 1);
-                       ret = __convert_to_absolute_tep_path(&data);
+                       ret = __convert_to_absolute_tep_path(data);
                        if (ret == -1) {
                                printf("conversion of relative tep path to absolute path failed\n");
-                               __free_data(&data);
+                               __free_data(data);
                                return -1;
                        }
-                       printf("TEP path is %s\n", data.tep_path);
+                       printf("TEP path is %s\n", data->tep_path);
                        break;
 
                case 'M':  /*tep move*/
                        if (optarg)
-                               data.tep_move = (atoi(optarg) == 1) ? true : false;
+                               data->tep_move = (atoi(optarg) == 1) ? true : false;
                        break;
 
                case 't':  /* package type */
                        if (optarg)
-                               snprintf(data.pkg_type, sizeof(data.pkg_type),
+                               snprintf(data->pkg_type, sizeof(data->pkg_type),
                                                "%s", optarg);
                        break;
 
                case 'T':  /* move type */
                        if (optarg)
-                               data.type = atoi(optarg);
+                               data->type = atoi(optarg);
                        break;
 
                case 'h':  /* help */
-                       __free_data(&data);
+                       __free_data(data);
                        __print_usage();
-                       break;
+                       return 0;
 
                case 'q':  /* quiet mode is removed */
                        break;
 
                case 'G':  /* debug mode */
-                       data.debug_mode = true;
+                       data->debug_mode = true;
                        break;
 
                case 'S':  /* skip optimization */
-                       data.skip_optimization = true;
+                       data->skip_optimization = true;
                        break;
 
                        /* Otherwise */
                case '?':  /* Not an option */
-                       __free_data(&data);
+                       __free_data(data);
                        __print_usage();
-                       break;
+                       return 0;
 
                case ':':  /* */
                        break;
 
                case OPTVAL_UID: /* specify target user id */
                        if (optarg)
-                               data.uid = atoi(optarg);
+                               data->uid = atoi(optarg);
                        break;
 
                default:
@@ -1848,31 +1841,32 @@ int main(int argc, char *argv[])
        uid_t uid = getuid();
        if (is_root_cmd && uid != OWNER_ROOT) {
                printf("This cmd is allowed for only root user\n");
-               __free_data(&data);
+               __free_data(data);
                return -1;
        }
 
        if (uid == OWNER_ROOT)
                uid = DEFAULT_USER;
 
-       if (data.global == 1)
+       if (data->global == 1)
                uid = GLOBAL_USER;
 
-       ret = __process_request(&data, uid);
-       if ((ret < 0) && (data.result == 0)) {
+       ret = __process_request(data, uid);
+       if ((ret < 0) && (data->result == 0)) {
                printf("Undefined error(%d)", ret);
-               data.result = PKGMGR_INSTALLER_ERRCODE_UNDEFINED_ERROR;
+               data->result = PKGMGR_INSTALLER_ERRCODE_UNDEFINED_ERROR;
        }
 
        if (ret != 0) {
-               __error_no_to_string(data.result, &errstr);
-               printf("processing result : %s [%d] failed\n", errstr, data.result);
+               __error_no_to_string(data->result, &errstr);
+               printf("processing result : %s [%d] failed\n", errstr, data->result);
        }
 
        gettimeofday(&tv, NULL);
        endtime = tv.tv_sec * 1000l + tv.tv_usec / 1000l;
        printf("spend time for pkgcmd is [%d]ms\n", (int)(endtime - starttime));
-       __free_data(&data);
+       ret = data->result;
+       __free_data(data);
 
-       return data.result;
+       return ret;
 }