Remove using global variables

Change-Id: I3c64c6809f280613f97a3af45486b2615063c144
Signed-off-by: Sangyoon Jang <jeremy.jang@samsung.com>

diff --git a/src/pkg_cleardata.c b/src/pkg_cleardata.c
index de1f341..0ba2f59 100644 (file)
--- a/src/pkg_cleardata.c
+++ b/src/pkg_cleardata.c
@@ -48,17 +48,6 @@
 #define LOG_TAG "PKGMGR_CLEARDATA"
 #endif                         /* LOG_TAG */
 
-const char short_options[] = "cdhn:u:";
-
-const struct option long_options[] = {
-       {"cache", 0, NULL, 'c'},
-       {"data", 0, NULL, 'd'},
-       {"help", 0, NULL, 'h'},
-       {"pkgid", 1, NULL, 'n'},
-       {"uid", 1, NULL, 'u'},
-       {0, 0, 0, 0}            /* sentinel */
-};
-
 static uid_t uid;
 
 static pkgmgr_installer *pi;
@@ -406,6 +395,15 @@ int main(int argc, char *argv[])
        char pkgid[MAX_PKG_NAME_LEN] = { 0, };
        bool clear_cache = false;
        bool clear_data = false;
+       const char short_options[] = "cdhn:u:";
+       const struct option long_options[] = {
+               {"cache", 0, NULL, 'c'},
+               {"data", 0, NULL, 'd'},
+               {"help", 0, NULL, 'h'},
+               {"pkgid", 1, NULL, 'n'},
+               {"uid", 1, NULL, 'u'},
+               {0, 0, 0, 0}            /* sentinel */
+       };
 
        if (argc < 3) {
                print_usage();

diff --git a/src/pkg_cmd.c b/src/pkg_cmd.c
index e7e70ff..51ead2d 100644 (file)
--- a/src/pkg_cmd.c
+++ b/src/pkg_cmd.c
@@ -57,54 +57,10 @@
 #define OPTVAL_CLEAR_ALL 1001
 #define OPTVAL_UID 1002
 
-static int __process_request(uid_t uid);
-static void __print_usage();
 static int __is_app_installed(char *pkgid, uid_t uid);
 static int __return_cb(uid_t target_uid, int req_id, const char *pkg_type,
                       const char *pkgid, const char *key, const char *val,
                       const void *pmsg, void *data);
-static int __convert_to_absolute_path(char *path);
-
-/* Supported options */
-/* Note: 'G' is reserved */
-const char *short_options = "iurwmcgxCkaADL:lsd:p:t:n:T:e:M:X:Y:Z:qhGS";
-const struct option long_options[] = {
-       {"install", 0, NULL, 'i'},
-       {"uninstall", 0, NULL, 'u'},
-       {"reinstall", 0, NULL, 'r'},
-       {"mount-install", 0, NULL, 'w'},
-       {"move", 0, NULL, 'm'},
-       {"clear", 0, NULL, 'c'},
-       {"clear-all", 0, NULL, OPTVAL_CLEAR_ALL},
-       {"getsize", 0, NULL, 'g'},
-       {"activate", 0, NULL, 'A'},
-       {"deactivate", 0, NULL, 'D'},
-       {"activate with Label", 1, NULL, 'L'},
-       {"check", 0, NULL, 'C'},
-       {"kill", 0, NULL, 'k'},
-       {"app-path", 0, NULL, 'a'},
-       {"list", 0, NULL, 'l'},
-       {"show", 0, NULL, 's'},
-       {"descriptor", 1, NULL, 'd'},
-       {"package-path", 1, NULL, 'p'},
-       {"old_pkg", 1, NULL, 'X'},
-       {"new_pkg", 1, NULL, 'Y'},
-       {"delta_pkg", 1, NULL, 'Z'},
-       {"package-type", 1, NULL, 't'},
-       {"package-name", 1, NULL, 'n'},
-       {"move-type", 1, NULL, 'T'},
-       {"getsize-type", 1, NULL, 'T'},
-       {"tep-path", 1, NULL, 'e'},
-       {"tep-move", 1, NULL, 'M'},
-       {"global", 0, NULL, OPTVAL_GLOBAL},
-       {"quiet", 0, NULL, 'q'},
-       {"help", 0, NULL, 'h'},
-       {"debug-mode", 0, NULL, 'G'},
-       {"getsizeinfo", 0, NULL, 'x'},
-       {"uid", 1, NULL, OPTVAL_UID},
-       {"skip-optimization", 0, NULL, 'S'},
-       {0, 0, 0, 0}            /* sentinel */
-};
 
 enum pm_tool_request_e {
        INSTALL_REQ = 1,
@@ -122,14 +78,11 @@ enum pm_tool_request_e {
        KILLAPP_REQ,
        LIST_REQ,
        SHOW_REQ,
-       HELP_REQ,
        CREATE_DELTA,
        GET_PKG_SIZE_INFO_REQ
 };
 typedef enum pm_tool_request_e req_type;
 
-typedef int (*dispatch_func)(uid_t target_uid);
-
 struct pm_tool_args_t {
        req_type request;
        char pkg_path[PATH_MAX];
@@ -154,18 +107,19 @@ struct pm_tool_args_t {
        bool skip_optimization;
 };
 typedef struct pm_tool_args_t pm_tool_args;
-pm_tool_args data;
+
+typedef int (*dispatch_func)(pm_tool_args *data, uid_t target_uid);
 
 static GMainLoop *main_loop = NULL;
 
-static void __free_data()
+static void __free_data(pm_tool_args *data)
 {
-       if (data.resolved_path_pkg_old)
-               free(data.resolved_path_pkg_old);
-       if (data.resolved_path_pkg_new)
-               free(data.resolved_path_pkg_new);
-       if (data.resolved_path_delta_pkg)
-               free(data.resolved_path_delta_pkg);
+       if (data->resolved_path_pkg_old)
+               free(data->resolved_path_pkg_old);
+       if (data->resolved_path_pkg_new)
+               free(data->resolved_path_pkg_new);
+       if (data->resolved_path_delta_pkg)
+               free(data->resolved_path_delta_pkg);
 }
 
 static void __error_no_to_string(int errnumber, char **errstr)
@@ -277,10 +231,11 @@ static int __return_cb(uid_t target_uid, int req_id, const char *pkg_type,
        int ret_val;
        char delims[] = ":";
        char *ret_result = NULL;
+       pm_tool_args *data = (pm_tool_args *)priv_data;
 
        if (strncmp(key, "error", strlen("error")) == 0) {
                ret_val = atoi(val);
-               data.result = ret_val;
+               data->result = ret_val;
 
                ret_result = strstr((char *)val, delims);
                if (ret_result)
@@ -295,8 +250,8 @@ static int __return_cb(uid_t target_uid, int req_id, const char *pkg_type,
                           req_id, pkg_type, pkgid, key, val);
 
        if (strncmp(key, "end", strlen("end")) == 0) {
-               if ((strncmp(val, "fail", strlen("fail")) == 0) && data.result == 0)
-                       data.result = PKGMGR_INSTALLER_ERRCODE_ERROR;
+               if ((strncmp(val, "fail", strlen("fail")) == 0) && data->result == 0)
+                       data->result = PKGMGR_INSTALLER_ERRCODE_ERROR;
                g_main_loop_quit(main_loop);
        }
 
@@ -308,10 +263,11 @@ static int __app_return_cb(uid_t target_uid, int req_id, const char *pkg_type,
                       const void *pmsg, void *priv_data)
 {
        int ret_val;
+       pm_tool_args *data = (pm_tool_args *)priv_data;
 
        if (strncmp(key, "error", strlen("error")) == 0) {
                ret_val = atoi(val);
-               data.result = ret_val;
+               data->result = ret_val;
        }
 
        printf("__app_return_cb req_id[%d] pkg_type[%s] pkgid[%s] appid[%s] " \
@@ -319,75 +275,75 @@ static int __app_return_cb(uid_t target_uid, int req_id, const char *pkg_type,
                                req_id, pkg_type, pkgid, appid, key, val);
 
        if (strncmp(key, "end", strlen("end")) == 0) {
-               if ((strncmp(val, "fail", strlen("fail")) == 0) && data.result == 0)
-                       data.result = PKGMGR_INSTALLER_ERRCODE_ERROR;
+               if ((strncmp(val, "fail", strlen("fail")) == 0) && data->result == 0)
+                       data->result = PKGMGR_INSTALLER_ERRCODE_ERROR;
                g_main_loop_quit(main_loop);
        }
 
        return 0;
 }
 
-static int __convert_to_absolute_path(char *path)
+static int __convert_to_absolute_path(pm_tool_args *data)
 {
        char abs[PKG_NAME_STRING_LEN_MAX] = {'\0'};
        char temp[PKG_NAME_STRING_LEN_MAX] = {'\0'};
        char *ptr = NULL;
-       if (path == NULL) {
+       if (data->pkg_path[0] == '\0') {
                printf("path is NULL\n");
                return -1;
        }
-       strncpy(temp, path, PKG_NAME_STRING_LEN_MAX - 1);
-       if (strchr(path, '/') == NULL) {
+       strncpy(temp, data->pkg_path, PKG_NAME_STRING_LEN_MAX - 1);
+       if (strchr(data->pkg_path, '/') == NULL) {
                if (getcwd(abs, PKG_NAME_STRING_LEN_MAX - 1) == NULL) {
                        printf("getcwd() failed\n");
                        return -1;
                }
-               memset(data.pkg_path, '\0', PKG_NAME_STRING_LEN_MAX);
-               snprintf(data.pkg_path, PKG_NAME_STRING_LEN_MAX - 1, "%s/%s", abs, temp);
+               memset(data->pkg_path, '\0', PKG_NAME_STRING_LEN_MAX);
+               snprintf(data->pkg_path, PKG_NAME_STRING_LEN_MAX - 1, "%s/%s", abs, temp);
                return 0;
        }
-       if (strncmp(path, "./", 2) == 0) {
+       if (strncmp(data->pkg_path, "./", 2) == 0) {
                ptr = temp;
                if (getcwd(abs, PKG_NAME_STRING_LEN_MAX - 1) == NULL) {
                        printf("getcwd() failed\n");
                        return -1;
                }
                ptr = ptr + 2;
-               memset(data.pkg_path, '\0', PKG_NAME_STRING_LEN_MAX);
-               snprintf(data.pkg_path, PKG_NAME_STRING_LEN_MAX - 1, "%s/%s", abs, ptr);
+               memset(data->pkg_path, '\0', PKG_NAME_STRING_LEN_MAX);
+               snprintf(data->pkg_path, PKG_NAME_STRING_LEN_MAX - 1, "%s/%s", abs, ptr);
                return 0;
        }
        return 0;
 }
 
-static int __convert_to_absolute_tep_path(char *path)
+static int __convert_to_absolute_tep_path(pm_tool_args *data)
 {
        char abs[PATH_MAX] = {'\0'};
        char temp[PATH_MAX] = {'\0'};
        char *ptr = NULL;
-       if (path == NULL) {
+       if (data->tep_path[0] == '\0') {
                printf("path is NULL\n");
                return -1;
        }
-       strncpy(temp, path, PATH_MAX - 1);
-       if (strchr(path, '/') == NULL) {
+       strncpy(temp, data->tep_path, PATH_MAX - 1);
+       if (strchr(data->tep_path, '/') == NULL) {
                if (getcwd(abs, PATH_MAX - 1) == NULL || abs[0] == '\0') {
                        printf("getcwd() failed\n");
                        return -1;
                }
-               memset(data.tep_path, '\0', PATH_MAX);
-               snprintf(data.tep_path, PATH_MAX - 1, "%s/%s", abs, temp);
+               memset(data->tep_path, '\0', PATH_MAX);
+               snprintf(data->tep_path, PATH_MAX - 1, "%s/%s", abs, temp);
                return 0;
        }
-       if (strncmp(path, "./", 2) == 0) {
+       if (strncmp(data->tep_path, "./", 2) == 0) {
                ptr = temp;
                if (getcwd(abs, PATH_MAX - 1) == NULL || abs[0] == '\0') {
                        printf("getcwd() failed\n");
                        return -1;
                }
                ptr = ptr + 2;
-               memset(data.tep_path, '\0', PATH_MAX);
-               snprintf(data.tep_path, PATH_MAX - 1, "%s/%s", abs, ptr);
+               memset(data->tep_path, '\0', PATH_MAX);
+               snprintf(data->tep_path, PATH_MAX - 1, "%s/%s", abs, ptr);
                return 0;
        }
        return 0;
@@ -481,7 +437,6 @@ static void __print_usage()
        printf("pkgcmd -D -t app -n org.example.helloapp --global\n");
 
        printf("\n");
-       __free_data();
        exit(0);
 }
 
@@ -581,6 +536,7 @@ static int __pkgmgr_list_clear_cb(const pkgmgrinfo_pkginfo_h handle, void *user_
        int ret = -1;
        char *pkgid = NULL;
        char *pkg_type = NULL;
+       pm_tool_args *data = (pm_tool_args *)user_data;
 
        ret = pkgmgrinfo_pkginfo_get_pkgid(handle, &pkgid);
        if (ret == -1) {
@@ -604,235 +560,235 @@ static int __pkgmgr_list_clear_cb(const pkgmgrinfo_pkginfo_h handle, void *user_
        ret = pkgmgr_client_usr_clear_user_data(pc, pkg_type, pkgid, PM_QUIET,
                                                uid);
        if (ret >= 0)
-               ret = data.result;
+               ret = data->result;
        pkgmgr_client_free(pc);
 
        return ret;
 }
 
-static void __invalid_arg_handler(void)
+static void __invalid_arg_handler(pm_tool_args *data)
 {
        printf("Please provide the arguments.\n");
        printf("use -h option to see usage\n");
-       data.result = PKGMGR_INSTALLER_ERRCODE_INVALID_VALUE;
+       data->result = PKGMGR_INSTALLER_ERRCODE_INVALID_VALUE;
 }
 
-static int __install_req_dispatcher(uid_t target_uid)
+static int __install_req_dispatcher(pm_tool_args *data, uid_t target_uid)
 {
        int ret;
        pkgmgr_client *pc;
 
-       if (data.pkg_path[0] == '\0') {
-               __invalid_arg_handler();
+       if (data->pkg_path[0] == '\0') {
+               __invalid_arg_handler(data);
                return -1;
        }
        main_loop = g_main_loop_new(NULL, FALSE);
        pc = pkgmgr_client_new(PC_REQUEST);
        if (pc == NULL) {
                printf("PkgMgr Client Creation Failed\n");
-               data.result = PKGMGR_INSTALLER_ERRCODE_ERROR;
+               data->result = PKGMGR_INSTALLER_ERRCODE_ERROR;
                return -1;
        }
 
-       if (data.debug_mode)
+       if (data->debug_mode)
                pkgmgr_client_set_debug_mode(pc, true);
 
-       if (data.skip_optimization)
+       if (data->skip_optimization)
                pkgmgr_client_set_skip_optimization(pc, true);
 
-       if (data.tep_path[0] != '\0')
-               pkgmgr_client_set_tep_path(pc, data.tep_path, data.tep_move);
+       if (data->tep_path[0] != '\0')
+               pkgmgr_client_set_tep_path(pc, data->tep_path, data->tep_move);
 
-       if (data.des_path[0] == '\0')
+       if (data->des_path[0] == '\0')
                ret = pkgmgr_client_usr_install(pc,
-                               data.pkg_type[0] != '\0' ? data.pkg_type : NULL,
-                               NULL, data.pkg_path, NULL, PM_QUIET,
-                               __return_cb, pc, target_uid);
+                               data->pkg_type[0] != '\0' ? data->pkg_type : NULL,
+                               NULL, data->pkg_path, NULL, PM_QUIET,
+                               __return_cb, data, target_uid);
        else
                ret = pkgmgr_client_usr_install(pc,
-                               data.pkg_type[0] != '\0' ? data.pkg_type : NULL,
-                               data.des_path, data.pkg_path,
-                               NULL, PM_QUIET, __return_cb, pc, target_uid);
+                               data->pkg_type[0] != '\0' ? data->pkg_type : NULL,
+                               data->des_path, data->pkg_path,
+                               NULL, PM_QUIET, __return_cb, data, target_uid);
 
        if (ret < 0) {
-               data.result = PKGMGR_INSTALLER_ERRCODE_ERROR;
-               if (access(data.pkg_path, F_OK) != 0)
-                       data.result = PKGMGR_INSTALLER_ERRCODE_PACKAGE_NOT_FOUND;
+               data->result = PKGMGR_INSTALLER_ERRCODE_ERROR;
+               if (access(data->pkg_path, F_OK) != 0)
+                       data->result = PKGMGR_INSTALLER_ERRCODE_PACKAGE_NOT_FOUND;
                pkgmgr_client_free(pc);
                return ret;
        }
        g_main_loop_run(main_loop);
        pkgmgr_client_free(pc);
-       return data.result;
+       return data->result;
 }
 
-static int __uninstall_req_dispatcher(uid_t target_uid)
+static int __uninstall_req_dispatcher(pm_tool_args *data, uid_t target_uid)
 {
        int ret;
        pkgmgr_client *pc;
 
-       if (data.pkgid[0] == '\0') {
-               __invalid_arg_handler();
+       if (data->pkgid[0] == '\0') {
+               __invalid_arg_handler(data);
                return -1;
        }
        main_loop = g_main_loop_new(NULL, FALSE);
        pc = pkgmgr_client_new(PC_REQUEST);
        if (pc == NULL) {
                printf("PkgMgr Client Creation Failed\n");
-               data.result = PKGMGR_INSTALLER_ERRCODE_ERROR;
+               data->result = PKGMGR_INSTALLER_ERRCODE_ERROR;
                return -1;
        }
 
-       ret = __is_app_installed(data.pkgid, target_uid);
+       ret = __is_app_installed(data->pkgid, target_uid);
        if (ret == -1) {
                printf("package is not installed\n");
                pkgmgr_client_free(pc);
                return ret;
        }
 
-       ret = pkgmgr_client_usr_uninstall(pc, data.pkg_type, data.pkgid,
-                       PM_QUIET, __return_cb, NULL, target_uid);
+       ret = pkgmgr_client_usr_uninstall(pc, data->pkg_type, data->pkgid,
+                       PM_QUIET, __return_cb, data, target_uid);
        if (ret < 0) {
-               data.result = PKGMGR_INSTALLER_ERRCODE_ERROR;
-               if (access(data.pkg_path, F_OK) != 0)
-                       data.result = PKGMGR_INSTALLER_ERRCODE_PACKAGE_NOT_FOUND;
+               data->result = PKGMGR_INSTALLER_ERRCODE_ERROR;
+               if (access(data->pkg_path, F_OK) != 0)
+                       data->result = PKGMGR_INSTALLER_ERRCODE_PACKAGE_NOT_FOUND;
                pkgmgr_client_free(pc);
                return ret;
        }
        g_main_loop_run(main_loop);
        pkgmgr_client_free(pc);
-       return data.result;
+       return data->result;
 }
 
-static int __reinstall_req_dispatcher(uid_t target_uid)
+static int __reinstall_req_dispatcher(pm_tool_args *data, uid_t target_uid)
 {
        int ret;
        pkgmgr_client *pc;
 
-       if (data.pkgid[0] == '\0') {
-               __invalid_arg_handler();
+       if (data->pkgid[0] == '\0') {
+               __invalid_arg_handler(data);
                return -1;
        }
        main_loop = g_main_loop_new(NULL, FALSE);
        pc = pkgmgr_client_new(PC_REQUEST);
        if (pc == NULL) {
                printf("PkgMgr Client Creation Failed\n");
-               data.result = PKGMGR_INSTALLER_ERRCODE_ERROR;
+               data->result = PKGMGR_INSTALLER_ERRCODE_ERROR;
                return -1;
        }
 
-       if (data.debug_mode)
+       if (data->debug_mode)
                pkgmgr_client_set_debug_mode(pc, true);
 
-       if (data.skip_optimization)
+       if (data->skip_optimization)
                pkgmgr_client_set_skip_optimization(pc, true);
 
        ret = pkgmgr_client_usr_reinstall(pc, NULL,
-                       data.pkgid, NULL, PM_QUIET, __return_cb, pc, target_uid);
+                       data->pkgid, NULL, PM_QUIET, __return_cb, data, target_uid);
        if (ret < 0) {
-               data.result = PKGMGR_INSTALLER_ERRCODE_ERROR;
-               if (access(data.pkg_path, F_OK) != 0)
-                       data.result = PKGMGR_INSTALLER_ERRCODE_PACKAGE_NOT_FOUND;
+               data->result = PKGMGR_INSTALLER_ERRCODE_ERROR;
+               if (access(data->pkg_path, F_OK) != 0)
+                       data->result = PKGMGR_INSTALLER_ERRCODE_PACKAGE_NOT_FOUND;
                pkgmgr_client_free(pc);
                return ret;
        }
        g_main_loop_run(main_loop);
        pkgmgr_client_free(pc);
-       return data.result;
+       return data->result;
 }
 
-static int __mount_install_req_dispatcher(uid_t target_uid)
+static int __mount_install_req_dispatcher(pm_tool_args *data, uid_t target_uid)
 {
        int ret;
        pkgmgr_client *pc;
 
-       if (data.pkg_path[0] == '\0') {
-               __invalid_arg_handler();
+       if (data->pkg_path[0] == '\0') {
+               __invalid_arg_handler(data);
                return -1;
        }
        main_loop = g_main_loop_new(NULL, FALSE);
        pc = pkgmgr_client_new(PC_REQUEST);
        if (pc == NULL) {
                printf("PkgMgr Client Creation Failed\n");
-               data.result = PKGMGR_INSTALLER_ERRCODE_ERROR;
+               data->result = PKGMGR_INSTALLER_ERRCODE_ERROR;
                return -1;
        }
 
-       if (data.debug_mode)
+       if (data->debug_mode)
                pkgmgr_client_set_debug_mode(pc, true);
 
-       if (data.skip_optimization)
+       if (data->skip_optimization)
                pkgmgr_client_set_skip_optimization(pc, true);
 
-       if (data.tep_path[0] != '\0')
-               pkgmgr_client_set_tep_path(pc, data.tep_path, data.tep_move);
+       if (data->tep_path[0] != '\0')
+               pkgmgr_client_set_tep_path(pc, data->tep_path, data->tep_move);
 
-       if (data.des_path[0] == '\0')
+       if (data->des_path[0] == '\0')
                ret = pkgmgr_client_usr_mount_install(pc,
-                               data.pkg_type[0] != '\0' ? data.pkg_type : NULL,
-                               NULL, data.pkg_path, NULL, PM_QUIET,
-                               __return_cb, pc, target_uid);
+                               data->pkg_type[0] != '\0' ? data->pkg_type : NULL,
+                               NULL, data->pkg_path, NULL, PM_QUIET,
+                               __return_cb, data, target_uid);
        else
                ret = pkgmgr_client_usr_mount_install(pc,
-                               data.pkg_type[0] != '\0' ? data.pkg_type : NULL,
-                               data.des_path, data.pkg_path,
-                               NULL, PM_QUIET, __return_cb, pc, target_uid);
+                               data->pkg_type[0] != '\0' ? data->pkg_type : NULL,
+                               data->des_path, data->pkg_path,
+                               NULL, PM_QUIET, __return_cb, data, target_uid);
 
        if (ret < 0) {
-               data.result = PKGMGR_INSTALLER_ERRCODE_ERROR;
-               if (access(data.pkg_path, F_OK) != 0)
-                       data.result = PKGMGR_INSTALLER_ERRCODE_PACKAGE_NOT_FOUND;
+               data->result = PKGMGR_INSTALLER_ERRCODE_ERROR;
+               if (access(data->pkg_path, F_OK) != 0)
+                       data->result = PKGMGR_INSTALLER_ERRCODE_PACKAGE_NOT_FOUND;
                pkgmgr_client_free(pc);
                return ret;
        }
        g_main_loop_run(main_loop);
        pkgmgr_client_free(pc);
-       return data.result;
+       return data->result;
 }
 
-static int __getsize_req_dispatcher(uid_t target_uid)
+static int __getsize_req_dispatcher(pm_tool_args *data, uid_t target_uid)
 {
        int ret;
        pkgmgr_client *pc;
 
-       if (data.pkgid[0] == '\0') {
-               __invalid_arg_handler();
+       if (data->pkgid[0] == '\0') {
+               __invalid_arg_handler(data);
                return -1;
        }
 
        pc = pkgmgr_client_new(PC_REQUEST);
        if (pc == NULL) {
                printf("PkgMgr Client Creation Failed\n");
-               data.result = PKGMGR_INSTALLER_ERRCODE_ERROR;
+               data->result = PKGMGR_INSTALLER_ERRCODE_ERROR;
                return -1;
        }
 
-       if (data.type == 9) {
+       if (data->type == 9) {
                ret = pkgmgrinfo_pkginfo_get_usr_list(__pkg_list_cb,
                                (void *)(pc), target_uid);
                pkgmgr_client_free(pc);
                return ret;
        }
-       ret = pkgmgr_client_usr_request_service(PM_REQUEST_GET_SIZE, data.type,
-                       pc, NULL, data.pkgid, target_uid, NULL, NULL, NULL);
+       ret = pkgmgr_client_usr_request_service(PM_REQUEST_GET_SIZE, data->type,
+                       pc, NULL, data->pkgid, target_uid, NULL, NULL, NULL);
        if (ret < 0) {
-               data.result = PKGMGR_INSTALLER_ERRCODE_ERROR;
+               data->result = PKGMGR_INSTALLER_ERRCODE_ERROR;
                pkgmgr_client_free(pc);
                return ret;
        }
 
-       printf("pkg[%s] size = %d\n", data.pkgid, ret);
+       printf("pkg[%s] size = %d\n", data->pkgid, ret);
        pkgmgr_client_free(pc);
-       return data.result;
+       return data->result;
 }
 
-static int __clear_req_dispatcher(uid_t target_uid)
+static int __clear_req_dispatcher(pm_tool_args *data, uid_t target_uid)
 {
        int ret;
        pkgmgr_client *pc;
 
-       if (data.pkg_type[0] == '\0' || data.pkgid[0] == '\0') {
-               __invalid_arg_handler();
+       if (data->pkg_type[0] == '\0' || data->pkgid[0] == '\0') {
+               __invalid_arg_handler(data);
                return -1;
        }
 
@@ -841,29 +797,29 @@ static int __clear_req_dispatcher(uid_t target_uid)
                printf("PkgMgr Client Creation Failed\n");
                return -1;
        }
-       ret = __is_app_installed(data.pkgid, target_uid);
+       ret = __is_app_installed(data->pkgid, target_uid);
        if (ret == -1) {
                printf("package is not installed\n");
                pkgmgr_client_free(pc);
                return ret;
        }
-       ret = pkgmgr_client_usr_clear_user_data(pc, data.pkg_type,
-                       data.pkgid, PM_QUIET, target_uid);
+       ret = pkgmgr_client_usr_clear_user_data(pc, data->pkg_type,
+                       data->pkgid, PM_QUIET, target_uid);
        if (ret < 0) {
                pkgmgr_client_free(pc);
                return ret;
        }
        pkgmgr_client_free(pc);
-       return data.result;
+       return data->result;
 }
 
-static int __clear_all_req_dispatcher(uid_t target_uid)
+static int __clear_all_req_dispatcher(pm_tool_args *data, uid_t target_uid)
 {
        int ret;
 
-       if (data.pkg_type[0] == '\0') {
+       if (data->pkg_type[0] == '\0') {
                ret = pkgmgrinfo_pkginfo_get_usr_list(__pkgmgr_list_clear_cb,
-                       NULL, target_uid);
+                       data, target_uid);
                if (ret == -1)
                        printf("no packages found\n");
                return ret;
@@ -877,7 +833,7 @@ static int __clear_all_req_dispatcher(uid_t target_uid)
        }
 
        ret = pkgmgrinfo_pkginfo_filter_add_string(handle,
-               PMINFO_PKGINFO_PROP_PACKAGE_TYPE, data.pkg_type);
+               PMINFO_PKGINFO_PROP_PACKAGE_TYPE, data->pkg_type);
        if (ret == -1) {
                printf("Failed to add package type filter\n");
                pkgmgrinfo_pkginfo_filter_destroy(handle);
@@ -885,7 +841,7 @@ static int __clear_all_req_dispatcher(uid_t target_uid)
        }
 
        ret = pkgmgrinfo_pkginfo_usr_filter_foreach_pkginfo(handle,
-               __pkgmgr_list_clear_cb, NULL, target_uid);
+               __pkgmgr_list_clear_cb, data, target_uid);
        if (ret != PMINFO_R_OK)
                printf("no package filter list\n");
 
@@ -893,16 +849,16 @@ static int __clear_all_req_dispatcher(uid_t target_uid)
        return ret;
 }
 
-static int __move_req_dispatcher(uid_t target_uid)
+static int __move_req_dispatcher(pm_tool_args *data, uid_t target_uid)
 {
        int ret;
        pkgmgr_client *pc;
 
-       if (data.pkg_type[0] == '\0' || data.pkgid[0] == '\0') {
-               __invalid_arg_handler();
+       if (data->pkg_type[0] == '\0' || data->pkgid[0] == '\0') {
+               __invalid_arg_handler(data);
                return -1;
        }
-       if (data.type < 0 || data.type > 2) {
+       if (data->type < 0 || data->type > 2) {
                printf("Invalid move type...See usage\n");
                return -1;
        }
@@ -913,14 +869,14 @@ static int __move_req_dispatcher(uid_t target_uid)
                printf("PkgMgr Client Creation Failed\n");
                return -1;
        }
-       ret = __is_app_installed(data.pkgid, target_uid);
+       ret = __is_app_installed(data->pkgid, target_uid);
        if (ret == -1) {
                printf("package is not installed\n");
                pkgmgr_client_free(pc);
                return ret;
        }
-       ret = pkgmgr_client_usr_request_service(PM_REQUEST_MOVE, data.type, pc,
-                       data.pkg_type, data.pkgid, target_uid, NULL, __return_cb, NULL);
+       ret = pkgmgr_client_usr_request_service(PM_REQUEST_MOVE, data->type, pc,
+                       data->pkg_type, data->pkgid, target_uid, NULL, __return_cb, data);
 
        if (ret < 0) {
                pkgmgr_client_free(pc);
@@ -929,18 +885,18 @@ static int __move_req_dispatcher(uid_t target_uid)
 
        g_main_loop_run(main_loop);
        pkgmgr_client_free(pc);
-       return data.result;
+       return data->result;
 }
 
-static int __activate_req_dispatcher(uid_t target_uid)
+static int __activate_req_dispatcher(pm_tool_args *data, uid_t target_uid)
 {
        int ret;
        pkgmgrinfo_appinfo_h appinfo_h;
        pkgmgr_client *pc;
        pkgmgr_client *listen_pc = NULL;
 
-       if (data.pkg_type[0] == '\0' || data.pkgid[0] == '\0') {
-               __invalid_arg_handler();
+       if (data->pkg_type[0] == '\0' || data->pkgid[0] == '\0') {
+               __invalid_arg_handler(data);
                return -1;
        }
 
@@ -951,11 +907,11 @@ static int __activate_req_dispatcher(uid_t target_uid)
                return -1;
        }
 
-       if (strlen(data.label) != 0) {
-               printf("requested label = %s\n", data.label);
+       if (strlen(data->label) != 0) {
+               printf("requested label = %s\n", data->label);
 
-               ret = pkgmgr_client_usr_set_app_label(pc, data.pkgid,
-                       data.label, target_uid);
+               ret = pkgmgr_client_usr_set_app_label(pc, data->pkgid,
+                       data->label, target_uid);
                if (ret < 0) {
                        printf("set_app_label is failed\n");
                        pkgmgr_client_free(pc);
@@ -965,37 +921,37 @@ static int __activate_req_dispatcher(uid_t target_uid)
                printf("set_app_label is done\n");
        }
 
-       if (strcmp(data.pkg_type, "app") == 0) {
-               if (data.global && data.uid != -1) {
-                       if (data.uid != __get_current_user_id()) {
-                               printf("Invalid uid : %d\n", data.uid);
+       if (strcmp(data->pkg_type, "app") == 0) {
+               if (data->global && data->uid != -1) {
+                       if (data->uid != __get_current_user_id()) {
+                               printf("Invalid uid : %d\n", data->uid);
                                pkgmgr_client_free(pc);
                                return -1;
                        }
-                       target_uid = data.uid;
+                       target_uid = data->uid;
                }
-               ret = pkgmgrinfo_appinfo_get_usr_disabled_appinfo(data.pkgid,
+               ret = pkgmgrinfo_appinfo_get_usr_disabled_appinfo(data->pkgid,
                                target_uid, &appinfo_h);
                if (ret != PMINFO_R_OK) {
-                       printf("Failed to get appinfo[%s]\n", data.pkgid);
+                       printf("Failed to get appinfo[%s]\n", data->pkgid);
                        pkgmgr_client_free(pc);
                        return -1;
                }
 
-               if (data.global) {
-                       if (data.uid != -1)
+               if (data->global) {
+                       if (data->uid != -1)
                                /* enable global app for this user only */
                                ret = pkgmgr_client_activate_global_app_for_uid(pc,
-                                               data.pkgid, __app_return_cb, NULL,
+                                               data->pkgid, __app_return_cb, data,
                                                __get_current_user_id());
                        else
                                /* enable global app for all user */
-                               ret = pkgmgr_client_usr_activate_app(pc, data.pkgid,
-                                               __app_return_cb, NULL, GLOBAL_USER);
+                               ret = pkgmgr_client_usr_activate_app(pc, data->pkgid,
+                                               __app_return_cb, data, GLOBAL_USER);
                } else {
                        /* enable local app */
-                       ret = pkgmgr_client_usr_activate_app(pc, data.pkgid,
-                                       __app_return_cb, NULL, target_uid);
+                       ret = pkgmgr_client_usr_activate_app(pc, data->pkgid,
+                                       __app_return_cb, data, target_uid);
                }
                pkgmgrinfo_appinfo_destroy_appinfo(appinfo_h);
        } else {
@@ -1005,14 +961,14 @@ static int __activate_req_dispatcher(uid_t target_uid)
                        pkgmgr_client_free(pc);
                        return -1;
                }
-               ret = pkgmgr_client_listen_status(listen_pc, __return_cb, NULL);
+               ret = pkgmgr_client_listen_status(listen_pc, __return_cb, data);
                if (ret < 0) {
                        printf("Failed to set callback[%d]\n", ret);
                        pkgmgr_client_free(pc);
                        pkgmgr_client_free(listen_pc);
                        return ret;
                }
-               ret = pkgmgr_client_usr_activate(pc, data.pkg_type, data.pkgid,
+               ret = pkgmgr_client_usr_activate(pc, data->pkg_type, data->pkgid,
                                target_uid);
        }
        if (ret < 0) {
@@ -1027,18 +983,18 @@ static int __activate_req_dispatcher(uid_t target_uid)
        pkgmgr_client_free(pc);
        if (listen_pc)
                pkgmgr_client_free(listen_pc);
-       return data.result;
+       return data->result;
 }
 
-static int __deactivate_req_dispatcher(uid_t target_uid)
+static int __deactivate_req_dispatcher(pm_tool_args *data, uid_t target_uid)
 {
        int ret;
        pkgmgrinfo_appinfo_h appinfo_h;
        pkgmgr_client *pc;
        pkgmgr_client *listen_pc = NULL;
 
-       if (data.pkg_type[0] == '\0' || data.pkgid[0] == '\0') {
-               __invalid_arg_handler();
+       if (data->pkg_type[0] == '\0' || data->pkgid[0] == '\0') {
+               __invalid_arg_handler(data);
                return -1;
        }
 
@@ -1049,34 +1005,34 @@ static int __deactivate_req_dispatcher(uid_t target_uid)
                return -1;
        }
 
-       if (strcmp(data.pkg_type, "app") == 0) {
-               ret = pkgmgrinfo_appinfo_get_usr_appinfo(data.pkgid,
+       if (strcmp(data->pkg_type, "app") == 0) {
+               ret = pkgmgrinfo_appinfo_get_usr_appinfo(data->pkgid,
                                target_uid, &appinfo_h);
                if (ret != PMINFO_R_OK) {
-                       printf("Failed to get appinfo[%s]\n", data.pkgid);
+                       printf("Failed to get appinfo[%s]\n", data->pkgid);
                        pkgmgr_client_free(pc);
                        return -1;
                }
 
-               if (data.global) {
-                       if (data.uid != -1 && data.uid != getuid()) {
-                               printf("Invalid uid : %d\n", data.uid);
+               if (data->global) {
+                       if (data->uid != -1 && data->uid != getuid()) {
+                               printf("Invalid uid : %d\n", data->uid);
                                pkgmgrinfo_appinfo_destroy_appinfo(appinfo_h);
                                pkgmgr_client_free(pc);
                                return -1;
                        }
-                       if (data.uid != -1)
+                       if (data->uid != -1)
                                /* disable global app for this user only */
                                ret = pkgmgr_client_deactivate_global_app_for_uid(pc,
-                                               data.pkgid, __app_return_cb, NULL,
+                                               data->pkgid, __app_return_cb, NULL,
                                                __get_current_user_id());
                        else
                                /* disable global app for all user */
-                               ret = pkgmgr_client_usr_deactivate_app(pc, data.pkgid,
+                               ret = pkgmgr_client_usr_deactivate_app(pc, data->pkgid,
                                                __app_return_cb, NULL, GLOBAL_USER);
                } else {
                        /* disable local app */
-                       ret = pkgmgr_client_usr_deactivate_app(pc, data.pkgid,
+                       ret = pkgmgr_client_usr_deactivate_app(pc, data->pkgid,
                                        __app_return_cb, NULL, target_uid);
                }
 
@@ -1088,14 +1044,14 @@ static int __deactivate_req_dispatcher(uid_t target_uid)
                        pkgmgr_client_free(pc);
                        return -1;
                }
-               ret = pkgmgr_client_listen_status(listen_pc, __return_cb, NULL);
+               ret = pkgmgr_client_listen_status(listen_pc, __return_cb, data);
                if (ret < 0) {
                        printf("Failed to set callback[%d]\n", ret);
                        pkgmgr_client_free(pc);
                        pkgmgr_client_free(listen_pc);
                        return ret;
                }
-               ret = pkgmgr_client_usr_deactivate(pc, data.pkg_type, data.pkgid,
+               ret = pkgmgr_client_usr_deactivate(pc, data->pkg_type, data->pkgid,
                                target_uid);
        }
        if (ret < 0) {
@@ -1110,29 +1066,29 @@ static int __deactivate_req_dispatcher(uid_t target_uid)
        pkgmgr_client_free(pc);
        if (listen_pc)
                pkgmgr_client_free(listen_pc);
-       return data.result;
+       return data->result;
 }
 
-static int __apppath_req_dispatcher(uid_t target_uid)
+static int __apppath_req_dispatcher(pm_tool_args *data, uid_t target_uid)
 {
        char buf[1024];
 
-       if (data.pkg_type[0] == '\0' && data.pkgid[0] == '\0') {
+       if (data->pkg_type[0] == '\0' && data->pkgid[0] == '\0') {
                printf("Tizen Application Installation Path: %s\n",
                        APP_INSTALLATION_PATH_RW);
                return 0;
        }
-       if ((data.pkg_type[0] == '\0') || (data.pkgid[0] == '\0')) {
+       if ((data->pkg_type[0] == '\0') || (data->pkgid[0] == '\0')) {
                printf("Use -h option to see usage\n");
                return -1;
        }
-       if (strncmp(data.pkg_type, "wgt", PKG_TYPE_STRING_LEN_MAX - 1) == 0) {
+       if (strncmp(data->pkg_type, "wgt", PKG_TYPE_STRING_LEN_MAX - 1) == 0) {
                snprintf(buf, 1023, "%s/%s/res/wgt",
-                       APP_INSTALLATION_PATH_RW, data.pkgid);
+                       APP_INSTALLATION_PATH_RW, data->pkgid);
                printf("Tizen Application Installation Path: %s\n", buf);
                return 0;
-       } else if (strncmp(data.pkg_type, "tpk", PKG_TYPE_STRING_LEN_MAX - 1) == 0) {
-               snprintf(buf, 1023, "%s/%s", APP_INSTALLATION_PATH_RW, data.pkgid);
+       } else if (strncmp(data->pkg_type, "tpk", PKG_TYPE_STRING_LEN_MAX - 1) == 0) {
+               snprintf(buf, 1023, "%s/%s", APP_INSTALLATION_PATH_RW, data->pkgid);
                printf("Tizen Application Installation Path: %s\n", buf);
                return 0;
        } else {
@@ -1142,107 +1098,107 @@ static int __apppath_req_dispatcher(uid_t target_uid)
        }
 }
 
-static int __checkapp_req_dispatcher(uid_t target_uid)
+static int __checkapp_req_dispatcher(pm_tool_args *data, uid_t target_uid)
 {
        int ret;
        int pid = -1;
        pkgmgr_client *pc;
 
-       if (data.pkgid[0] == '\0') {
-               __invalid_arg_handler();
+       if (data->pkgid[0] == '\0') {
+               __invalid_arg_handler(data);
                return -1;
        }
 
        pc = pkgmgr_client_new(PC_REQUEST);
        if (pc == NULL) {
                printf("PkgMgr Client Creation Failed\n");
-               data.result = PKGMGR_INSTALLER_ERRCODE_ERROR;
+               data->result = PKGMGR_INSTALLER_ERRCODE_ERROR;
                return -1;
        }
 
-       if (data.request == KILLAPP_REQ) {
+       if (data->request == KILLAPP_REQ) {
                ret = pkgmgr_client_usr_request_service(PM_REQUEST_KILL_APP, 0, pc,
-                       NULL, data.pkgid, target_uid, NULL, NULL, &pid);
+                       NULL, data->pkgid, target_uid, NULL, NULL, &pid);
                if (ret < 0) {
-                       data.result = PKGMGR_INSTALLER_ERRCODE_ERROR;
+                       data->result = PKGMGR_INSTALLER_ERRCODE_ERROR;
                        pkgmgr_client_free(pc);
                        return ret;
                }
                if (pid)
-                       printf("Pkgid: %s is Terminated\n", data.pkgid);
+                       printf("Pkgid: %s is Terminated\n", data->pkgid);
                else
-                       printf("Pkgid: %s is already Terminated\n", data.pkgid);
-       } else if (data.request == CHECKAPP_REQ) {
+                       printf("Pkgid: %s is already Terminated\n", data->pkgid);
+       } else if (data->request == CHECKAPP_REQ) {
                ret = pkgmgr_client_usr_request_service(PM_REQUEST_CHECK_APP, 0, pc,
-                       NULL, data.pkgid, target_uid, NULL, NULL, &pid);
+                       NULL, data->pkgid, target_uid, NULL, NULL, &pid);
                if (ret < 0) {
-                       data.result = PKGMGR_INSTALLER_ERRCODE_ERROR;
+                       data->result = PKGMGR_INSTALLER_ERRCODE_ERROR;
                        pkgmgr_client_free(pc);
                        return ret;
                }
 
                if (pid)
-                       printf("Pkgid: %s is Running\n", data.pkgid);
+                       printf("Pkgid: %s is Running\n", data->pkgid);
                else
-                       printf("Pkgid: %s is Not Running\n", data.pkgid);
+                       printf("Pkgid: %s is Not Running\n", data->pkgid);
        }
        pkgmgr_client_free(pc);
-       return data.result;
+       return data->result;
 }
 
-static int __killapp_req_dispatcher(uid_t target_uid)
+static int __killapp_req_dispatcher(pm_tool_args *data, uid_t target_uid)
 {
        int ret;
        int pid = -1;
        pkgmgr_client *pc;
 
-       if (data.pkgid[0] == '\0') {
-               __invalid_arg_handler();
+       if (data->pkgid[0] == '\0') {
+               __invalid_arg_handler(data);
                return -1;
        }
 
        pc = pkgmgr_client_new(PC_REQUEST);
        if (pc == NULL) {
                printf("PkgMgr Client Creation Failed\n");
-               data.result = PKGMGR_INSTALLER_ERRCODE_ERROR;
+               data->result = PKGMGR_INSTALLER_ERRCODE_ERROR;
                return -1;
        }
 
-       if (data.request == KILLAPP_REQ) {
+       if (data->request == KILLAPP_REQ) {
                ret = pkgmgr_client_usr_request_service(PM_REQUEST_KILL_APP, 0, pc,
-                       NULL, data.pkgid, target_uid, NULL, NULL, &pid);
+                       NULL, data->pkgid, target_uid, NULL, NULL, &pid);
                if (ret < 0) {
-                       data.result = PKGMGR_INSTALLER_ERRCODE_ERROR;
+                       data->result = PKGMGR_INSTALLER_ERRCODE_ERROR;
                        pkgmgr_client_free(pc);
                        return ret;
                }
                if (pid)
-                       printf("Pkgid: %s is Terminated\n", data.pkgid);
+                       printf("Pkgid: %s is Terminated\n", data->pkgid);
                else
-                       printf("Pkgid: %s is already Terminated\n", data.pkgid);
-       } else if (data.request == CHECKAPP_REQ) {
+                       printf("Pkgid: %s is already Terminated\n", data->pkgid);
+       } else if (data->request == CHECKAPP_REQ) {
                ret = pkgmgr_client_usr_request_service(PM_REQUEST_CHECK_APP, 0, pc,
-                       NULL, data.pkgid, target_uid, NULL, NULL, &pid);
+                       NULL, data->pkgid, target_uid, NULL, NULL, &pid);
                if (ret < 0) {
-                       data.result = PKGMGR_INSTALLER_ERRCODE_ERROR;
+                       data->result = PKGMGR_INSTALLER_ERRCODE_ERROR;
                        pkgmgr_client_free(pc);
                        return ret;
                }
 
                if (pid)
-                       printf("Pkgid: %s is Running\n", data.pkgid);
+                       printf("Pkgid: %s is Running\n", data->pkgid);
                else
-                       printf("Pkgid: %s is Not Running\n", data.pkgid);
+                       printf("Pkgid: %s is Not Running\n", data->pkgid);
        }
        pkgmgr_client_free(pc);
-       return data.result;
+       return data->result;
 }
 
-static int __list_req_dispatcher(uid_t target_uid)
+static int __list_req_dispatcher(pm_tool_args *data, uid_t target_uid)
 {
        int ret;
 
-       if (data.pkg_type[0] == '\0') {
+       if (data->pkg_type[0] == '\0') {
                ret = pkgmgrinfo_pkginfo_get_usr_list(__pkgmgr_list_cb,
                        NULL, target_uid);
                if (ret == -1)
@@ -1258,7 +1214,7 @@ static int __list_req_dispatcher(uid_t target_uid)
        }
 
        ret = pkgmgrinfo_pkginfo_filter_add_string(handle,
-               PMINFO_PKGINFO_PROP_PACKAGE_TYPE, data.pkg_type);
+               PMINFO_PKGINFO_PROP_PACKAGE_TYPE, data->pkg_type);
        if (ret == -1) {
                printf("Failed to add package type filter\n");
                pkgmgrinfo_pkginfo_filter_destroy(handle);
@@ -1275,36 +1231,30 @@ static int __list_req_dispatcher(uid_t target_uid)
 }
 
 /* unsupported */
-static int __show_req_dispatcher(uid_t target_uid)
+static int __show_req_dispatcher(pm_tool_args *data, uid_t target_uid)
 {
        return -1;
 }
 
-static int __help_req_dispatcher(uid_t target_uid)
-{
-       __print_usage();
-       return 0;
-}
-
-static int __create_delta_dispatcher(uid_t target_uid)
+static int __create_delta_dispatcher(pm_tool_args *data, uid_t target_uid)
 {
        int ret;
        char pkg_old[PATH_MAX];
        char pkg_new[PATH_MAX];
 
        printf("CREATE_DELTA\n");
-       if (data.pkg_old[0] == '\0' || data.pkg_new[0] == '\0') {
+       if (data->pkg_old[0] == '\0' || data->pkg_new[0] == '\0') {
                printf("tpk pkg missing\n");
                return -1;
        }
-       if (data.delta_pkg[0] == '\0') {
-               data.resolved_path_delta_pkg = strdup("/tmp/delta_pkg");
+       if (data->delta_pkg[0] == '\0') {
+               data->resolved_path_delta_pkg = strdup("/tmp/delta_pkg");
                printf("output file will be /tmp/delta_pkg.delta\n");
        }
        const char *unzip_argv[] = {"sh",
                "/etc/package-manager/pkgmgr-unzip-pkg.sh", "-a",
-                       data.resolved_path_pkg_old, "-b", data.resolved_path_pkg_new, "-p",
-                       data.resolved_path_delta_pkg, NULL};
+                       data->resolved_path_pkg_old, "-b", data->resolved_path_pkg_new, "-p",
+                       data->resolved_path_delta_pkg, NULL};
        ret = __xsystem(unzip_argv);
        if (ret != 0) {
                printf("unzip is fail .\n");
@@ -1312,7 +1262,7 @@ static int __create_delta_dispatcher(uid_t target_uid)
        }
        printf("unzip is success .\n");
        char *ptr_old_pkg = NULL;
-       ptr_old_pkg = strrchr(data.resolved_path_pkg_old, '/');
+       ptr_old_pkg = strrchr(data->resolved_path_pkg_old, '/');
 
        if (!ptr_old_pkg) {
                printf("not able to extract package name.\n");
@@ -1320,7 +1270,7 @@ static int __create_delta_dispatcher(uid_t target_uid)
        }
        ptr_old_pkg++;
        char *ptr_new_pkg = NULL;
-       ptr_new_pkg = strrchr(data.resolved_path_pkg_new, '/');
+       ptr_new_pkg = strrchr(data->resolved_path_pkg_new, '/');
 
        if (!ptr_new_pkg) {
                printf("not able to extract package name.\n");
@@ -1336,8 +1286,8 @@ static int __create_delta_dispatcher(uid_t target_uid)
 
        const char *delta_argv[] = {"sh",
                "/etc/package-manager/pkgmgr-create-delta.sh", "-a",
-               data.resolved_path_pkg_old, "-b", data.resolved_path_pkg_new, "-p",
-               data.resolved_path_delta_pkg, NULL};
+               data->resolved_path_pkg_old, "-b", data->resolved_path_pkg_new, "-p",
+               data->resolved_path_delta_pkg, NULL};
        ret = __xsystem(delta_argv);
        if (ret != 0) {
                printf("create delta script fail .\n");
@@ -1347,13 +1297,13 @@ static int __create_delta_dispatcher(uid_t target_uid)
        return ret;
 }
 
-static int __get_pkg_size_info_req_dispatcher(uid_t target_uid)
+static int __get_pkg_size_info_req_dispatcher(pm_tool_args *data, uid_t target_uid)
 {
        int ret;
        pkgmgr_client *pc;
 
-       if (data.pkgid[0] == '\0') {
-               __invalid_arg_handler();
+       if (data->pkgid[0] == '\0') {
+               __invalid_arg_handler(data);
                return -1;
        }
 
@@ -1361,30 +1311,30 @@ static int __get_pkg_size_info_req_dispatcher(uid_t target_uid)
        pc = pkgmgr_client_new(PC_REQUEST);
        if (pc == NULL) {
                printf("PkgMgr Client Creation Failed\n");
-               data.result = PKGMGR_INSTALLER_ERR_FATAL_ERROR;
+               data->result = PKGMGR_INSTALLER_ERR_FATAL_ERROR;
                return -1;
        }
 
-       if (strcmp(data.pkgid, PKG_SIZE_INFO_TOTAL) == 0)
+       if (strcmp(data->pkgid, PKG_SIZE_INFO_TOTAL) == 0)
                ret = pkgmgr_client_usr_get_total_package_size_info(pc,
                        __total_pkg_size_info_recv_cb, NULL,
                        target_uid);
        else
                ret = pkgmgr_client_usr_get_package_size_info(pc,
-                       data.pkgid, __pkg_size_info_recv_cb, NULL,
+                       data->pkgid, __pkg_size_info_recv_cb, NULL,
                        target_uid);
 
        if (ret < 0) {
-               data.result = PKGMGR_INSTALLER_ERR_FATAL_ERROR;
+               data->result = PKGMGR_INSTALLER_ERR_FATAL_ERROR;
                pkgmgr_client_free(pc);
                return ret;
        }
 
-       printf("pkg[%s] ret: %d\n", data.pkgid, ret);
+       printf("pkg[%s] ret: %d\n", data->pkgid, ret);
 
        g_main_loop_run(main_loop);
        pkgmgr_client_free(pc);
-       return data.result;
+       return data->result;
 }
 
 static dispatch_func __process_request_func_ptr[] = {
@@ -1403,12 +1353,11 @@ static dispatch_func __process_request_func_ptr[] = {
        [KILLAPP_REQ] = __killapp_req_dispatcher,
        [LIST_REQ] = __list_req_dispatcher,
        [SHOW_REQ] = __show_req_dispatcher,
-       [HELP_REQ] = __help_req_dispatcher,
        [CREATE_DELTA] = __create_delta_dispatcher,
        [GET_PKG_SIZE_INFO_REQ] = __get_pkg_size_info_req_dispatcher,
 };
 
-static int __process_request(uid_t target_uid)
+static int __process_request(pm_tool_args *data, uid_t target_uid)
 {
        int ret;
 
@@ -1418,11 +1367,11 @@ static int __process_request(uid_t target_uid)
        size_t req_size =
                sizeof(__process_request_func_ptr) / sizeof(dispatch_func);
 
-       if (data.request >= req_size || data.request == 0) {
+       if (data->request >= req_size || data->request == 0) {
                printf("Wrong Request\n");
                return -1;
        }
-       ret = __process_request_func_ptr[data.request](target_uid);
+       ret = __process_request_func_ptr[data->request](data, target_uid);
 
        return ret;
 }
@@ -1438,6 +1387,47 @@ int main(int argc, char *argv[])
        long endtime;
        struct timeval tv;
        bool is_root_cmd = false;
+       pm_tool_args data = { 0 };
+       /* Supported options */
+       /* Note: 'G' is reserved */
+       const char *short_options = "iurwmcgxCkaADL:lsd:p:t:n:T:e:M:X:Y:Z:qhGS";
+       const struct option long_options[] = {
+               {"install", 0, NULL, 'i'},
+               {"uninstall", 0, NULL, 'u'},
+               {"reinstall", 0, NULL, 'r'},
+               {"mount-install", 0, NULL, 'w'},
+               {"move", 0, NULL, 'm'},
+               {"clear", 0, NULL, 'c'},
+               {"clear-all", 0, NULL, OPTVAL_CLEAR_ALL},
+               {"getsize", 0, NULL, 'g'},
+               {"activate", 0, NULL, 'A'},
+               {"deactivate", 0, NULL, 'D'},
+               {"activate with Label", 1, NULL, 'L'},
+               {"check", 0, NULL, 'C'},
+               {"kill", 0, NULL, 'k'},
+               {"app-path", 0, NULL, 'a'},
+               {"list", 0, NULL, 'l'},
+               {"show", 0, NULL, 's'},
+               {"descriptor", 1, NULL, 'd'},
+               {"package-path", 1, NULL, 'p'},
+               {"old_pkg", 1, NULL, 'X'},
+               {"new_pkg", 1, NULL, 'Y'},
+               {"delta_pkg", 1, NULL, 'Z'},
+               {"package-type", 1, NULL, 't'},
+               {"package-name", 1, NULL, 'n'},
+               {"move-type", 1, NULL, 'T'},
+               {"getsize-type", 1, NULL, 'T'},
+               {"tep-path", 1, NULL, 'e'},
+               {"tep-move", 1, NULL, 'M'},
+               {"global", 0, NULL, OPTVAL_GLOBAL},
+               {"quiet", 0, NULL, 'q'},
+               {"help", 0, NULL, 'h'},
+               {"debug-mode", 0, NULL, 'G'},
+               {"getsizeinfo", 0, NULL, 'x'},
+               {"uid", 1, NULL, OPTVAL_UID},
+               {"skip-optimization", 0, NULL, 'S'},
+               {0, 0, 0, 0}            /* sentinel */
+       };
 
        if (argc == 1)
                __print_usage();
@@ -1546,10 +1536,10 @@ int main(int argc, char *argv[])
                        if (optarg)
                                snprintf(data.pkg_path, sizeof(data.pkg_path),
                                                "%s", optarg);
-                       ret = __convert_to_absolute_path(data.pkg_path);
+                       ret = __convert_to_absolute_path(&data);
                        if (ret == -1) {
                                printf("conversion of relative path to absolute path failed\n");
-                               __free_data();
+                               __free_data(&data);
                                return -1;
                        }
                        printf("path is %s\n", data.pkg_path);
@@ -1564,7 +1554,7 @@ int main(int argc, char *argv[])
                        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();
+                               __free_data(&data);
                                return -1;
                        }
                        printf("pkg_old abs path is %s\n", data.resolved_path_pkg_old);
@@ -1577,7 +1567,7 @@ int main(int argc, char *argv[])
                        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();
+                               __free_data(&data);
                                return -1;
                        }
                        printf("pkg_new abs path is %s\n", data.resolved_path_pkg_new);
@@ -1592,7 +1582,7 @@ int main(int argc, char *argv[])
                        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();
+                               __free_data(&data);
                                return -1;
                        }
                        printf("delta_pkg abs path is %s\n", data.resolved_path_delta_pkg);
@@ -1613,10 +1603,10 @@ int main(int argc, char *argv[])
                        if (optarg)
                                strncpy(data.tep_path, optarg,
                                        PATH_MAX - 1);
-                       ret = __convert_to_absolute_tep_path(data.tep_path);
+                       ret = __convert_to_absolute_tep_path(&data);
                        if (ret == -1) {
                                printf("conversion of relative tep path to absolute path failed\n");
-                               __free_data();
+                               __free_data(&data);
                                return -1;
                        }
                        printf("TEP path is %s\n", data.tep_path);
@@ -1638,7 +1628,8 @@ int main(int argc, char *argv[])
                        break;
 
                case 'h':  /* help */
-                       data.request = HELP_REQ;
+                       __free_data(&data);
+                       __print_usage();
                        break;
 
                case 'q':  /* quiet mode is removed */
@@ -1654,6 +1645,7 @@ int main(int argc, char *argv[])
 
                        /* Otherwise */
                case '?':  /* Not an option */
+                       __free_data(&data);
                        __print_usage();
                        break;
 
@@ -1673,7 +1665,7 @@ 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();
+               __free_data(&data);
                return -1;
        }
 
@@ -1683,7 +1675,7 @@ int main(int argc, char *argv[])
        if (data.global == 1)
                uid = GLOBAL_USER;
 
-       ret = __process_request(uid);
+       ret = __process_request(&data, uid);
        if ((ret < 0) && (data.result == 0)) {
                printf("Undefined error(%d)", ret);
                data.result = PKGMGR_INSTALLER_ERRCODE_UNDEFINED_ERROR;
@@ -1697,7 +1689,7 @@ int main(int argc, char *argv[])
        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();
+       __free_data(&data);
 
        return data.result;
 }

diff --git a/src/pkg_rsc_slice.c b/src/pkg_rsc_slice.c
index e6d45c6..520981b 100644 (file)
--- a/src/pkg_rsc_slice.c
+++ b/src/pkg_rsc_slice.c
@@ -42,7 +42,6 @@
 #define RSC_TOOL_VERSION       "0.1"
 #define BUF_SIZE 1024
 
-static int __process_slice(void);
 static void __print_usage();
 
 struct rsc_tool_args_t {
@@ -53,42 +52,35 @@ struct rsc_tool_args_t {
        char width_range[BUF_SIZE];
        char screen_large[BUF_SIZE];
        char platform_version[BUF_SIZE];
+       GHashTable *valid_file_list;
 };
 
 typedef struct rsc_tool_args_t rsc_tool_args;
-rsc_tool_args data;
-GHashTable *valid_file_list;
 
-const char *short_options = "p:d:";
-
-const struct option long_options[] = {
-       {"path", 1, NULL, 'p'},
-       {"screen-dpi", 1, NULL, 'd'},
-       {0, 0, 0, 0}            /* sentinel */
-};
-
-
-static int __convert_to_abs_path(char *path)
+static int __convert_to_abs_path(rsc_tool_args *data)
 {
+       char tmp[BUF_SIZE];
        char abs[BUF_SIZE] = {'\0'};
        char cwd[BUF_SIZE] = {'\0'};
        char *buf = NULL;
        int ret = -1;
 
-       if (path == NULL) {
+       if (data->res_path[0] == '\0') {
                printf("invalid path\n");
                return -1;
        }
 
+       snprintf(tmp, sizeof(tmp), "%s", data->res_path);
+
        buf = getcwd(cwd, BUF_SIZE - 1);
        if (buf == NULL) {
                printf("failed to get cwd\n");
                return -1;
        }
 
-       ret = chdir(path);
+       ret = chdir(tmp);
        if (ret < 0) {
-               printf("failed to change dir[%s]\n", path);
+               printf("failed to change dir[%s]\n", tmp);
                return -1;
        }
 
@@ -98,11 +90,11 @@ static int __convert_to_abs_path(char *path)
                return -1;
        }
 
-       memset(data.res_path, '\0', BUF_SIZE);
-       snprintf(data.res_path, BUF_SIZE - 1, "%s/", abs);
+       memset(data->res_path, '\0', BUF_SIZE);
+       snprintf(data->res_path, BUF_SIZE - 1, "%s/", abs);
        ret = chdir(cwd);
        if (ret < 0) {
-               printf("failed to change dir[%s]\n", path);
+               printf("failed to change dir[%s]\n", tmp);
                return -1;
        }
 
@@ -126,7 +118,7 @@ static void __print_usage()
        exit(0);
 }
 
-static void __del_file(char *path)
+static void __del_file(GHashTable *valid_file_list, char *path)
 {
        struct dirent **items;
        struct stat fstat;
@@ -154,7 +146,7 @@ static void __del_file(char *path)
                        return;
                }
                if ((fstat.st_mode & S_IFDIR) == S_IFDIR) {
-                       __del_file(abs_path);
+                       __del_file(valid_file_list, abs_path);
                } else {
                        tmp = g_hash_table_lookup(valid_file_list, abs_path);
                        if (tmp == NULL) {
@@ -169,37 +161,37 @@ static void __del_file(char *path)
        }
 }
 
-static int __process_slice(void)
+static int __process_slice(rsc_tool_args *data)
 {
        int ret = -1;
        bundle *b = NULL;
        char dpi_value[1024] = {0, };
 
-       if (data.res_path[0] == '\0')
+       if (data->res_path[0] == '\0')
                return -1;
 
        b = bundle_create();
-       if (data.dpi != 0) {
-               snprintf(dpi_value, 1024 - 1, "%d", data.dpi);
+       if (data->dpi != 0) {
+               snprintf(dpi_value, 1024 - 1, "%d", data->dpi);
                bundle_add_str(b, "screen-dpi", dpi_value);
        }
 
        /* other attributes will be added here*/
 
-       ret = aul_resource_manager_init_slice(data.res_path, b);
+       ret = aul_resource_manager_init_slice(data->res_path, b);
        if (ret < 0) {
                printf("failed to init rsc manager\n");
                goto catch;
        }
 
-       ret = aul_resource_manager_get_path_list(&valid_file_list);
+       ret = aul_resource_manager_get_path_list(&data->valid_file_list);
        if (ret < 0) {
                printf("failed to init rsc manager\n");
                goto catch;
        }
 
        /* remove useless resources and empty directories */
-       __del_file(data.res_path);
+       __del_file(data->valid_file_list, data->res_path);
 
 
 catch:
@@ -220,6 +212,13 @@ int main(int argc, char *argv[])
        long endtime;
        int i = 0;
        struct timeval tv;
+       const char *short_options = "p:d:";
+       const struct option long_options[] = {
+               {"path", 1, NULL, 'p'},
+               {"screen-dpi", 1, NULL, 'd'},
+               {0, 0, 0, 0}            /* sentinel */
+       };
+       rsc_tool_args data = { 0 };
 
        if (argc == 1)
                __print_usage();
@@ -245,7 +244,7 @@ int main(int argc, char *argv[])
                        if (optarg)
                                strncpy(data.res_path, optarg, PATH_MAX - 1);
 
-                       ret = __convert_to_abs_path(data.res_path);
+                       ret = __convert_to_abs_path(&data);
                        if (ret == -1) {
                                printf("conversion of relative path to absolute path failed\n");
                                return -1;
@@ -270,7 +269,7 @@ int main(int argc, char *argv[])
                }
        }
 
-       ret = __process_slice();
+       ret = __process_slice(&data);
 
        gettimeofday(&tv, NULL);
        endtime = tv.tv_sec * 1000l + tv.tv_usec / 1000l;