tool/pkg_cmd.c

   1
   2 /*
   3  * slp-pkgmgr
   4  *
   5  * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
   6  *
   7  * Contact: Jayoun Lee <airjany@samsung.com>, Sewook Park <sewook7.park@samsung.com>,
   8  * Jaeho Lee <jaeho81.lee@samsung.com>, Shobhit Srivastava <shobhit.s@samsung.com>
   9  *
  10  * Licensed under the Apache License, Version 2.0 (the "License");
  11  * you may not use this file except in compliance with the License.
  12  * You may obtain a copy of the License at
  13  *
  14  * http://www.apache.org/licenses/LICENSE-2.0
  15  *
  16  * Unless required by applicable law or agreed to in writing, software
  17  * distributed under the License is distributed on an "AS IS" BASIS,
  18  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  19  * See the License for the specific language governing permissions and
  20  * limitations under the License.
  21  *
  22  */
  23
  24 #define _GNU_SOURCE
  25
  26 #include <stdio.h>
  27 #include <string.h>
  28 #include <stdlib.h>
  29 #include <unistd.h>
  30 #include <ctype.h>
  31 #include <getopt.h>
  32 #include <dirent.h>
  33 #include <fcntl.h>
  34 #include <dlfcn.h>
  35 #include <sys/types.h>
  36 #include <glib.h>
  37 #include <ail.h>
  38 #include <glib-object.h>
  39 #include <pkgmgr-info.h>
  40 #include "package-manager.h"
  41 #include "package-manager-types.h"
  42
  43 #define PKG_TOOL_VERSION        "0.1"
  44 #define APP_INSTALLATION_PATH_RW        "/opt/usr/apps"
  45
  46 /* 1 -100 : Package command errors */
  47 /* 101-120 : reserved for Core installer */
  48 /* 121-140 : reserved for Web installer */
  49 /* 141-160 : reserved for Native installer */
  50 #define PKGCMD_ERR_PACKAGE_NOT_FOUND                                    1
  51 #define PKGCMD_ERR_PACKAGE_INVALID                                              2
  52 #define PKGCMD_ERR_PACKAGE_LOWER_VERSION                                3
  53 #define PKGCMD_ERR_PACKAGE_EXECUTABLE_NOT_FOUND                 4
  54 #define PKGCMD_ERR_MANIFEST_NOT_FOUND                                   11
  55 #define PKGCMD_ERR_MANIFEST_INVALID                                             12
  56 #define PKGCMD_ERR_CONFIG_NOT_FOUND                                             13
  57 #define PKGCMD_ERR_CONFIG_INVALID                                               14
  58 #define PKGCMD_ERR_SIGNATURE_NOT_FOUND                                  21
  59 #define PKGCMD_ERR_SIGNATURE_INVALID                                    22
  60 #define PKGCMD_ERR_SIGNATURE_VERIFICATION_FAILED                23
  61 #define PKGCMD_ERR_ROOT_CERTIFICATE_NOT_FOUND                   31
  62 #define PKGCMD_ERR_CERTIFICATE_INVALID                                  32
  63 #define PKGCMD_ERR_CERTIFICATE_CHAIN_VERIFICATION_FAILED        33
  64 #define PKGCMD_ERR_CERTIFICATE_EXPIRED                                  34
  65 #define PKGCMD_ERR_INVALID_PRIVILEGE                                    41
  66 #define PKGCMD_ERR_MENU_ICON_NOT_FOUND                                  51
  67 #define PKGCMD_ERR_FATAL_ERROR                                                  61
  68 #define PKGCMD_ERR_OUT_OF_STORAGE                                               62
  69 #define PKGCMD_ERR_OUT_OF_MEMORY                                                63
  70 #define PKGCMD_ERR_ARGUMENT_INVALID                                             64
  71
  72 #define PKGCMD_ERR_PACKAGE_NOT_FOUND_STR                                        "PACKAGE_NOT_FOUND"
  73 #define PKGCMD_ERR_PACKAGE_INVALID_STR                                          "PACKAGE_INVALID"
  74 #define PKGCMD_ERR_PACKAGE_LOWER_VERSION_STR                            "PACKAGE_LOWER_VERSION"
  75 #define PKGCMD_ERR_PACKAGE_EXECUTABLE_NOT_FOUND_STR                     "PACKAGE_EXECUTABLE_NOT_FOUND"
  76 #define PKGCMD_ERR_MANIFEST_NOT_FOUND_STR                                       "MANIFEST_NOT_FOUND"
  77 #define PKGCMD_ERR_MANIFEST_INVALID_STR                                         "MANIFEST_INVALID"
  78 #define PKGCMD_ERR_CONFIG_NOT_FOUND_STR                                         "CONFIG_NOT_FOUND"
  79 #define PKGCMD_ERR_CONFIG_INVALID_STR                                           "CONFIG_INVALID"
  80 #define PKGCMD_ERR_SIGNATURE_NOT_FOUND_STR                                      "SIGNATURE_NOT_FOUND"
  81 #define PKGCMD_ERR_SIGNATURE_INVALID_STR                                        "SIGNATURE_INVALID"
  82 #define PKGCMD_ERR_SIGNATURE_VERIFICATION_FAILED_STR            "SIGNATURE_VERIFICATION_FAILED"
  83 #define PKGCMD_ERR_ROOT_CERTIFICATE_NOT_FOUND_STR                       "ROOT_CERTIFICATE_NOT_FOUND"
  84 #define PKGCMD_ERR_CERTIFICATE_INVALID_STR                                      "CERTIFICATE_INVALID"
  85 #define PKGCMD_ERR_CERTIFICATE_CHAIN_VERIFICATION_FAILED_STR    "CERTIFICATE_CHAIN_VERIFICATION_FAILED"
  86 #define PKGCMD_ERR_CERTIFICATE_EXPIRED_STR                                      "CERTIFICATE_EXPIRED"
  87 #define PKGCMD_ERR_INVALID_PRIVILEGE_STR                                        "INVALID_PRIVILEGE"
  88 #define PKGCMD_ERR_MENU_ICON_NOT_FOUND_STR                                      "MENU_ICON_NOT_FOUND"
  89 #define PKGCMD_ERR_FATAL_ERROR_STR                                                      "FATAL_ERROR"
  90 #define PKGCMD_ERR_OUT_OF_STORAGE_STR                                           "OUT_OF_STORAGE"
  91 #define PKGCMD_ERR_OUT_OF_MEMORY_STR                                            "OUT_OF_MEMORY"
  92 #define PKGCMD_ERR_ARGUMENT_INVALID_STR                                         "ARGUMENT_INVALID"
  93 #define PKGCMD_ERR_UNKNOWN_STR                                                          "Unknown Error"
  94
  95 static int __process_request();
  96 static void __print_usage();
  97 static int __is_authorized();
  98 static int __is_app_installed(char *pkgid);
  99 static void __print_pkg_info(pkgmgr_info * pkg_info);
 100 static int __return_cb(int req_id, const char *pkg_type, const char *pkgid,
 101                        const char *key, const char *val, const void *pmsg,
 102                        void *data);
 103 static int __convert_to_absolute_path(char *path);
 104 static int __pkgcmd_read_proc(const char *path, char *buf, int size);
 105 static int __pkgcmd_find_pid_by_cmdline(const char *dname,
 106                         const char *cmdline, const char *apppath);
 107 static int __pkgcmd_proc_iter_kill_cmdline(const char *apppath, int option);
 108 static int __app_list_cb(const pkgmgr_appinfo_h handle, void *user_data);
 109
 110 /* Supported options */
 111 const char *short_options = "iurmcCkaADL:lsd:p:t:n:T:S:qh";
 112 const struct option long_options[] = {
 113         {"install", 0, NULL, 'i'},
 114         {"uninstall", 0, NULL, 'u'},
 115         {"reinstall", 0, NULL, 'r'},
 116         {"move", 0, NULL, 'm'},
 117         {"clear", 0, NULL, 'c'},
 118         {"activate", 0, NULL, 'A'},
 119         {"deactivate", 0, NULL, 'D'},
 120         {"activate with Label", 1, NULL, 'L'},
 121         {"check", 0, NULL, 'C'},
 122         {"kill", 0, NULL, 'k'},
 123         {"app-path", 0, NULL, 'a'},
 124         {"list", 0, NULL, 'l'},
 125         {"show", 0, NULL, 's'},
 126         {"descriptor", 1, NULL, 'd'},
 127         {"package-path", 1, NULL, 'p'},
 128         {"package-type", 1, NULL, 't'},
 129         {"package-name", 1, NULL, 'n'},
 130         {"move-type", 1, NULL, 'T'},
 131         {"csc", 1, NULL, 'S'},
 132         {"quiet", 0, NULL, 'q'},
 133         {"help", 0, NULL, 'h'},
 134         {0, 0, 0, 0}            /* sentinel */
 135 };
 136
 137 enum pm_tool_request_e {
 138         INSTALL_REQ = 1,
 139         UNINSTALL_REQ,
 140         REINSTALL_REQ,
 141         CSC_REQ,
 142         CLEAR_REQ,
 143         MOVE_REQ,
 144         ACTIVATE_REQ,
 145         DEACTIVATE_REQ,
 146         APPPATH_REQ,
 147         CHECKAPP_REQ,
 148         KILLAPP_REQ,
 149         LIST_REQ,
 150         SHOW_REQ,
 151         HELP_REQ
 152 };
 153 typedef enum pm_tool_request_e req_type;
 154
 155 struct pm_tool_args_t {
 156         req_type request;
 157         char pkg_path[PKG_NAME_STRING_LEN_MAX];
 158         char pkg_type[PKG_TYPE_STRING_LEN_MAX];
 159         char pkgid[PKG_NAME_STRING_LEN_MAX];
 160         char des_path[PKG_NAME_STRING_LEN_MAX];
 161         char label[PKG_NAME_STRING_LEN_MAX];
 162         int quiet;
 163         int move_type;
 164         int result;
 165 };
 166 typedef struct pm_tool_args_t pm_tool_args;
 167 pm_tool_args data;
 168
 169 static GMainLoop *main_loop = NULL;
 170
 171 static void __error_no_to_string(int errnumber, char **errstr)
 172 {
 173         if (errstr == NULL)
 174                 return;
 175         switch (errnumber) {
 176         case PKGCMD_ERR_PACKAGE_NOT_FOUND:
 177                 *errstr = PKGCMD_ERR_PACKAGE_NOT_FOUND_STR;
 178                 break;
 179         case PKGCMD_ERR_PACKAGE_INVALID:
 180                 *errstr = PKGCMD_ERR_PACKAGE_INVALID_STR;
 181                 break;
 182         case PKGCMD_ERR_PACKAGE_LOWER_VERSION:
 183                 *errstr = PKGCMD_ERR_PACKAGE_LOWER_VERSION_STR;
 184                 break;
 185         case PKGCMD_ERR_PACKAGE_EXECUTABLE_NOT_FOUND:
 186                 *errstr = PKGCMD_ERR_PACKAGE_EXECUTABLE_NOT_FOUND_STR;
 187                 break;
 188         case PKGCMD_ERR_MANIFEST_INVALID:
 189                 *errstr = PKGCMD_ERR_MANIFEST_INVALID_STR;
 190                 break;
 191         case PKGCMD_ERR_CONFIG_NOT_FOUND:
 192                 *errstr = PKGCMD_ERR_CONFIG_NOT_FOUND_STR;
 193                 break;
 194         case PKGCMD_ERR_CONFIG_INVALID:
 195                 *errstr = PKGCMD_ERR_CONFIG_INVALID_STR;
 196                 break;
 197         case PKGCMD_ERR_SIGNATURE_NOT_FOUND:
 198                 *errstr = PKGCMD_ERR_SIGNATURE_NOT_FOUND_STR;
 199                 break;
 200         case PKGCMD_ERR_SIGNATURE_INVALID:
 201                 *errstr = PKGCMD_ERR_SIGNATURE_INVALID_STR;
 202                 break;
 203         case PKGCMD_ERR_SIGNATURE_VERIFICATION_FAILED:
 204                 *errstr = PKGCMD_ERR_SIGNATURE_VERIFICATION_FAILED_STR;
 205                 break;
 206         case PKGCMD_ERR_ROOT_CERTIFICATE_NOT_FOUND:
 207                 *errstr = PKGCMD_ERR_ROOT_CERTIFICATE_NOT_FOUND_STR;
 208                 break;
 209         case PKGCMD_ERR_CERTIFICATE_INVALID:
 210                 *errstr = PKGCMD_ERR_CERTIFICATE_INVALID_STR;
 211                 break;
 212         case PKGCMD_ERR_CERTIFICATE_CHAIN_VERIFICATION_FAILED:
 213                 *errstr = PKGCMD_ERR_CERTIFICATE_CHAIN_VERIFICATION_FAILED_STR;
 214                 break;
 215         case PKGCMD_ERR_CERTIFICATE_EXPIRED:
 216                 *errstr = PKGCMD_ERR_CERTIFICATE_EXPIRED_STR;
 217                 break;
 218         case PKGCMD_ERR_INVALID_PRIVILEGE:
 219                 *errstr = PKGCMD_ERR_INVALID_PRIVILEGE_STR;
 220                 break;
 221         case PKGCMD_ERR_MENU_ICON_NOT_FOUND:
 222                 *errstr = PKGCMD_ERR_MENU_ICON_NOT_FOUND_STR;
 223                 break;
 224         case PKGCMD_ERR_FATAL_ERROR:
 225                 *errstr = PKGCMD_ERR_FATAL_ERROR_STR;
 226                 break;
 227         case PKGCMD_ERR_OUT_OF_STORAGE:
 228                 *errstr = PKGCMD_ERR_OUT_OF_STORAGE_STR;
 229                 break;
 230         case PKGCMD_ERR_OUT_OF_MEMORY:
 231                 *errstr = PKGCMD_ERR_OUT_OF_MEMORY_STR;
 232                 break;
 233         case PKGCMD_ERR_ARGUMENT_INVALID:
 234                 *errstr = PKGCMD_ERR_ARGUMENT_INVALID_STR;
 235                 break;
 236         default:
 237                 *errstr = PKGCMD_ERR_UNKNOWN_STR;
 238                 break;
 239         }
 240 }
 241
 242 static int __return_cb(int req_id, const char *pkg_type,
 243                        const char *pkgid, const char *key, const char *val,
 244                        const void *pmsg, void *priv_data)
 245 {
 246         if (strncmp(key, "error", strlen("error")) == 0) {
 247                 int ret_val;
 248                 char *errstr = NULL;
 249                 char delims[] = ":";
 250                 char *extra_str = NULL;
 251                 char *ret_result = NULL;
 252
 253                 ret_val = atoi(val);
 254                 __error_no_to_string(ret_val, &errstr);
 255                 data.result = ret_val;
 256
 257                 ret_result = strtok(val, delims);
 258                 ret_result = strtok(NULL, delims);
 259                 if (ret_result){
 260                         extra_str = strdup(ret_result);
 261                         printf("__return_cb req_id[%d] pkg_type[%s] pkgid[%s] key[%s] val[%d] error message: %s:%s\n",
 262                                            req_id, pkg_type, pkgid, key, ret_val, errstr, extra_str);
 263                         free(extra_str);
 264                 }
 265                 else
 266                         printf("__return_cb req_id[%d] pkg_type[%s] pkgid[%s] key[%s] val[%d] error message: %s\n",
 267                                            req_id, pkg_type, pkgid, key, ret_val, errstr);
 268         } else
 269                 printf("__return_cb req_id[%d] pkg_type[%s] "
 270                        "pkgid[%s] key[%s] val[%s]\n",
 271                        req_id, pkg_type, pkgid, key, val);
 272
 273         if (strncmp(key, "end", strlen("end")) == 0) {
 274                 if ((strncmp(val, "fail", strlen("fail")) == 0) && data.result == 0){
 275                         data.result = PKGCMD_ERR_FATAL_ERROR;
 276                 }
 277                 g_main_loop_quit(main_loop);
 278         }
 279
 280         return 0;
 281 }
 282
 283 static int __pkgcmd_read_proc(const char *path, char *buf, int size)
 284 {
 285         int fd;
 286         int ret;
 287         if (buf == NULL || path == NULL)
 288                 return -1;
 289         fd = open(path, O_RDONLY);
 290         if (fd < 0)
 291                 return -1;
 292         ret = read(fd, buf, size - 1);
 293         if (ret <= 0) {
 294                 close(fd);
 295                 return -1;
 296         } else
 297                 buf[ret] = 0;
 298         close(fd);
 299         return ret;
 300 }
 301
 302 static int __pkgcmd_find_pid_by_cmdline(const char *dname,
 303                         const char *cmdline, const char *apppath)
 304 {
 305         int pid = 0;
 306
 307         if (strcmp(cmdline, apppath) == 0) {
 308                 pid = atoi(dname);
 309                 if (pid != getpgid(pid))
 310                         pid = 0;
 311         }
 312         return pid;
 313 }
 314
 315 static int __pkgcmd_proc_iter_kill_cmdline(const char *apppath, int option)
 316 {
 317         DIR *dp;
 318         struct dirent *dentry;
 319         int pid;
 320         int ret;
 321         char buf[1024] = {'\0'};
 322         int pgid;
 323
 324         dp = opendir("/proc");
 325         if (dp == NULL) {
 326                 return -1;
 327         }
 328
 329         while ((dentry = readdir(dp)) != NULL) {
 330                 if (!isdigit(dentry->d_name[0]))
 331                         continue;
 332
 333                 snprintf(buf, sizeof(buf), "/proc/%s/cmdline", dentry->d_name);
 334                 ret = __pkgcmd_read_proc(buf, buf, sizeof(buf));
 335                 if (ret <= 0)
 336                         continue;
 337
 338                 pid = __pkgcmd_find_pid_by_cmdline(dentry->d_name, buf, apppath);
 339                 if (pid > 0) {
 340                         if (option == 0) {
 341                                 closedir(dp);
 342                                 return pid;
 343                         }
 344                         pgid = getpgid(pid);
 345                         if (pgid <= 1) {
 346                                 closedir(dp);
 347                                 return -1;
 348                         }
 349                         if (killpg(pgid, SIGKILL) < 0) {
 350                                 closedir(dp);
 351                                 return -1;
 352                         }
 353                         closedir(dp);
 354                         return pid;
 355                 }
 356         }
 357         closedir(dp);
 358         return 0;
 359 }
 360
 361 static int __app_list_cb(const pkgmgr_appinfo_h handle, void *user_data)
 362 {
 363         char *exec = NULL;
 364         char *appid = NULL;
 365         int ret = 0;
 366         int pid = -1;
 367         if (handle == NULL) {
 368                 printf("appinfo handle is NULL\n");
 369                 return -1;
 370         }
 371         ret = pkgmgr_appinfo_get_exec(handle, &exec);
 372         if (ret) {
 373                 printf("Failed to get app exec path\n");
 374                 return -1;
 375         }
 376         ret = pkgmgr_appinfo_get_appid(handle, &appid);
 377         if (ret) {
 378                 printf("Failed to get appid\n");
 379                 return -1;
 380         }
 381         /*option 0 to check and option 1 to kill*/
 382         switch(data.request) {
 383         case CHECKAPP_REQ:
 384                 pid = __pkgcmd_proc_iter_kill_cmdline(exec, 0);
 385                 if (pid) {
 386                         printf("Appid: %s is Running\n", appid);
 387                 } else {
 388                         printf("Appid: %s is Not Running\n", appid);
 389                 }
 390                 break;
 391         case KILLAPP_REQ:
 392                 pid = __pkgcmd_proc_iter_kill_cmdline(exec, 1);
 393                 if (pid > 0)
 394                         printf("Appid: %s is Terminated\n", appid);
 395                 break;
 396         default:
 397                 break;
 398         }
 399         return 0;
 400 }
 401
 402 static int __convert_to_absolute_path(char *path)
 403 {
 404         char abs[PKG_NAME_STRING_LEN_MAX] = {'\0'};
 405         char temp[PKG_NAME_STRING_LEN_MAX] = {'\0'};
 406         char *ptr = NULL;
 407         if (path == NULL) {
 408                 printf("path is NULL\n");
 409                 return -1;
 410         }
 411         strncpy(temp, path, PKG_NAME_STRING_LEN_MAX - 1);
 412         if (strchr(path, '/') == NULL) {
 413                 getcwd(abs, PKG_NAME_STRING_LEN_MAX - 1);
 414                 if (abs[0] == '\0') {
 415                         printf("getcwd() failed\n");
 416                         return -1;
 417                 }
 418                 memset(data.pkg_path, '\0', PKG_NAME_STRING_LEN_MAX);
 419                 snprintf(data.pkg_path, PKG_NAME_STRING_LEN_MAX - 1, "%s/%s", abs, temp);
 420                 return 0;
 421         }
 422         if (strncmp(path, "./", 2) == 0) {
 423                 ptr = temp;
 424                 getcwd(abs, PKG_NAME_STRING_LEN_MAX - 1);
 425                 if (abs[0] == '\0') {
 426                         printf("getcwd() failed\n");
 427                         return -1;
 428                 }
 429                 ptr = ptr + 2;
 430                 memset(data.pkg_path, '\0', PKG_NAME_STRING_LEN_MAX);
 431                 snprintf(data.pkg_path, PKG_NAME_STRING_LEN_MAX - 1, "%s/%s", abs, ptr);
 432                 return 0;
 433         }
 434         return 0;
 435 }
 436
 437 static int __is_app_installed(char *pkgid)
 438 {
 439 #if 0
 440         ail_appinfo_h handle;
 441         ail_error_e ret;
 442         char *str = NULL;
 443         ret = ail_package_get_appinfo(pkgid, &handle);
 444         if (ret != AIL_ERROR_OK) {
 445                 return -1;
 446         }
 447         ret = ail_appinfo_get_str(handle, AIL_PROP_NAME_STR, &str);
 448         if (ret != AIL_ERROR_OK) {
 449                 return -1;
 450         }
 451         ret = ail_package_destroy_appinfo(handle);
 452         if (ret != AIL_ERROR_OK) {
 453                 return -1;
 454         }
 455 //#else
 456         pkgmgr_pkginfo_h handle;
 457         int ret = pkgmgr_pkginfo_get_pkginfo(pkgid, &handle);
 458         if(ret < 0) {
 459                 printf("package is not in pkgmgr_info DB\n");
 460                 return -1;
 461         } else
 462                 pkgmgr_pkginfo_destroy_pkginfo(handle);
 463 #endif
 464
 465         return 0;
 466 }
 467
 468 static void __print_usage()
 469 {
 470         printf("\nPackage Manager Tool Version: %s\n\n", PKG_TOOL_VERSION);
 471         printf("-i, --install           install the package\n");
 472         printf("-u, --uninstall         uninstall the package\n");
 473         printf("-r, --reinstall         reinstall the package\n");
 474         printf("-c, --clear             clear user data\n");
 475         printf("-m, --move              move package\n");
 476         printf("-l, --list              display list of installed packages\n");
 477         printf("-s, --show              show detail package info\n");
 478         printf("-a, --app-path          show app installation path\n");
 479         printf("-C, --check             check if applications belonging to a package are running or not\n");
 480         printf("-k, --kill              terminate applications belonging to a package\n");
 481         printf("-d, --descriptor        provide descriptor path\n");
 482         printf("-p, --package-path      provide package path\n");
 483         printf("-n, --package-name      provide package name\n");
 484         printf("-t, --package-type      provide package type\n");
 485         printf("-T, --move-type provide move type [0 : move to internal /1: move to external]\n");
 486         printf("-q, --quiet             quiet mode operation\n");
 487         printf("-h, --help              print this help\n\n");
 488
 489         printf("Usage: pkgcmd [options] (--quiet)\n");
 490         printf("pkgcmd -i -t <pkg type> (-d <descriptor path>) -p <pkg path> (-q)\n");
 491         printf("pkgcmd -u -t <pkg type> -n <pkgid> (-q)\n");
 492         printf("pkgcmd -r -t <pkg type> -n <pkgid> \n");
 493         printf("pkgcmd -l (-t <pkg type>) \n");
 494         printf("pkgcmd -s -t <pkg type> -p <pkg path> (-q)\n");
 495         printf("pkgcmd -s -t <pkg type> -n <pkg name> (-q)\n");
 496         printf("pkgcmd -m -t <pkg type> -T <move type> -n <pkg name> (-q)\n\n");
 497
 498         printf("Example:\n");
 499         printf("pkgcmd -u -t rpm -n org.tizen.calculator\n");
 500         printf("pkgcmd -i -t rpm -p /mnt/nfs/org.tizen.calculator_0.1.2-95_armel.rpm\n");
 501         printf("pkgcmd -r -t rpm -p org.tizen.calculator\n");
 502         printf("pkgcmd -c -t rpm -n org.tizen.hello\n");
 503         printf("pkgcmd -m -t rpm -T 1 -n org.tizen.hello\n");
 504         printf("pkgcmd -C -t rpm -n org.tizen.hello\n");
 505         printf("pkgcmd -k -t rpm -n org.tizen.hello\n");
 506         printf("pkgcmd -a\n");
 507         printf("pkgcmd -a -t rpm -n org.tizen.hello\n");
 508         printf("pkgcmd -l\n");
 509         printf("pkgcmd -l -t tpk\n");
 510
 511         exit(0);
 512
 513 }
 514
 515 static void __print_pkg_info(pkgmgr_info *pkg_info)
 516 {
 517         char *temp = NULL;
 518
 519         temp = pkgmgr_info_get_string(pkg_info, "pkg_type");
 520         if (temp) {
 521                 printf("pkg_type : %s\n", temp);
 522                 free(temp);
 523         }
 524
 525         temp = pkgmgr_info_get_string(pkg_info, "pkgid");
 526         if (temp) {
 527                 printf("pkgid : %s\n", temp);
 528                 free(temp);
 529         }
 530
 531         temp = pkgmgr_info_get_string(pkg_info, "version");
 532         if (temp) {
 533                 printf("version : %s\n", temp);
 534                 free(temp);
 535         }
 536
 537         temp = pkgmgr_info_get_string(pkg_info, "pkg_vendor");
 538         if (temp) {
 539                 printf("pkg_vendor : %s\n", temp);
 540                 free(temp);
 541         }
 542
 543         temp = pkgmgr_info_get_string(pkg_info, "pkg_description");
 544         if (temp) {
 545                 printf("pkg_description : %s\n", temp);
 546                 free(temp);
 547         }
 548
 549         temp = pkgmgr_info_get_string(pkg_info, "pkg_mimetype");
 550         if (temp) {
 551                 printf("pkg_mimetype : %s\n", temp);
 552                 free(temp);
 553         }
 554
 555         temp = pkgmgr_info_get_string(pkg_info, "pkg_installed_path_package");
 556         if (temp) {
 557                 printf("pkg_installed_path_package : %s\n", temp);
 558                 free(temp);
 559         }
 560
 561         temp =
 562             pkgmgr_info_get_string(pkg_info, "pkg_installed_path_descriptor");
 563         if (temp) {
 564                 printf("pkg_installed_path_descriptor : %s\n", temp);
 565                 free(temp);
 566         }
 567
 568         temp = pkgmgr_info_get_string(pkg_info, "category");
 569         if (temp) {
 570                 printf("category : %s\n", temp);
 571                 free(temp);
 572         }
 573
 574         temp = pkgmgr_info_get_string(pkg_info, "min_platform_version");
 575         if (temp) {
 576                 printf("min_platform_version : %s\n", temp);
 577                 free(temp);
 578         }
 579
 580         temp = pkgmgr_info_get_string(pkg_info, "visible");
 581         if (temp) {
 582                 printf("visible : %s\n", temp);
 583                 free(temp);
 584         }
 585
 586         temp = pkgmgr_info_get_string(pkg_info, "removable");
 587         if (temp) {
 588                 printf("removable : %s\n", temp);
 589                 free(temp);
 590         }
 591
 592         temp = pkgmgr_info_get_string(pkg_info, "installed_size");
 593         if (temp) {
 594                 printf("installed_size : %s\n", temp);
 595                 free(temp);
 596         }
 597
 598         temp = pkgmgr_info_get_string(pkg_info, "installed_time");
 599         if (temp) {
 600                 printf("installed_time : %s\n", temp);
 601                 free(temp);
 602         }
 603
 604         temp = pkgmgr_info_get_string(pkg_info, "data_size");
 605         if (temp) {
 606                 printf("data_size : %s\n", temp);
 607                 free(temp);
 608         }
 609
 610         temp = pkgmgr_info_get_string(pkg_info, "optional_id");
 611         if (temp) {
 612                 printf("optional_id : %s\n", temp);
 613                 free(temp);
 614         }
 615 }
 616
 617 static int __pkgmgr_list_cb (const pkgmgr_pkginfo_h handle, void *user_data)
 618 {
 619         int ret = -1;
 620         char *pkgid = NULL;
 621         char *pkg_type = NULL;
 622         char *pkg_version = NULL;
 623         char *pkg_label = NULL;
 624
 625         ret = pkgmgr_pkginfo_get_pkgid(handle, &pkgid);
 626         if (ret == -1) {
 627                 printf("Failed to get pkgmgr_pkginfo_get_pkgid\n");
 628                 return ret;
 629         }
 630         ret = pkgmgr_pkginfo_get_type(handle, &pkg_type);
 631         if (ret == -1) {
 632                 printf("Failed to get pkgmgr_pkginfo_get_type\n");
 633                 return ret;
 634         }
 635         ret = pkgmgr_pkginfo_get_version(handle, &pkg_version);
 636         if (ret == -1) {
 637                 printf("Failed to get pkgmgr_pkginfo_get_version\n");
 638                 return ret;
 639         }
 640         ret = pkgmgr_pkginfo_get_label(handle, &pkg_label);
 641         if (ret == -1) {
 642                 printf("Failed to get pkgmgr_pkginfo_get_label\n");
 643                 return ret;
 644         }
 645
 646         printf("pkg_type [%s]\tpkgid [%s]\tname [%s]\tversion [%s]\n", pkg_type, pkgid, pkg_label, pkg_version);
 647
 648         return ret;
 649 }
 650
 651 static int __process_request()
 652 {
 653         int ret = -1;
 654         int mode = PM_DEFAULT;
 655         pkgmgr_client *pc = NULL;
 656         char buf[1024] = {'\0'};
 657         switch (data.request) {
 658         case INSTALL_REQ:
 659                 if (data.pkg_type[0] == '\0' || data.pkg_path[0] == '\0') {
 660                         printf("Please provide the arguments.\n");
 661                         printf("use -h option to see usage\n");
 662                         data.result = PKGCMD_ERR_ARGUMENT_INVALID;
 663                         break;
 664                 }
 665                 g_type_init();
 666                 main_loop = g_main_loop_new(NULL, FALSE);
 667                 pc = pkgmgr_client_new(PC_REQUEST);
 668                 if (pc == NULL) {
 669                         printf("PkgMgr Client Creation Failed\n");
 670                         data.result = PKGCMD_ERR_FATAL_ERROR;
 671                         break;
 672                 }
 673                 if (data.quiet == 0)
 674                         mode = PM_DEFAULT;
 675                 else
 676                         mode = PM_QUIET;
 677                 if (data.des_path[0] == '\0')
 678                         ret =
 679                             pkgmgr_client_install(pc, data.pkg_type, NULL,
 680                                                   data.pkg_path, NULL, mode,
 681                                                   __return_cb, pc);
 682                 else
 683                         ret =
 684                             pkgmgr_client_install(pc, data.pkg_type,
 685                                                   data.des_path, data.pkg_path,
 686                                                   NULL, mode, __return_cb, pc);
 687                 if (ret < 0){
 688                         data.result = PKGCMD_ERR_FATAL_ERROR;
 689                         if (access(data.pkg_path, F_OK) != 0)
 690                                 data.result = PKGCMD_ERR_PACKAGE_NOT_FOUND;
 691                         break;
 692                 }
 693                 g_main_loop_run(main_loop);
 694                 ret = data.result;
 695                 break;
 696
 697         case UNINSTALL_REQ:
 698                 if (data.pkg_type[0] == '\0' || data.pkgid[0] == '\0') {
 699                         printf("Please provide the arguments.\n");
 700                         printf("use -h option to see usage\n");
 701                         data.result = PKGCMD_ERR_ARGUMENT_INVALID;
 702                         break;
 703                 }
 704                 g_type_init();
 705                 main_loop = g_main_loop_new(NULL, FALSE);
 706                 pc = pkgmgr_client_new(PC_REQUEST);
 707                 if (pc == NULL) {
 708                         printf("PkgMgr Client Creation Failed\n");
 709                         data.result = PKGCMD_ERR_FATAL_ERROR;
 710                         break;
 711                 }
 712                 if (data.quiet == 0)
 713                         mode = PM_DEFAULT;
 714                 else
 715                         mode = PM_QUIET;
 716
 717                 ret = __is_app_installed(data.pkgid);
 718                 if (ret == -1) {
 719                         printf("package is not installed\n");
 720                         break;
 721                 }
 722
 723                 ret =
 724                     pkgmgr_client_uninstall(pc, data.pkg_type, data.pkgid,
 725                                             mode, __return_cb, NULL);
 726                 if (ret < 0){
 727                         data.result = PKGCMD_ERR_FATAL_ERROR;
 728                         if (access(data.pkg_path, F_OK) != 0)
 729                                 data.result = PKGCMD_ERR_PACKAGE_NOT_FOUND;
 730                         break;
 731                 }
 732                 g_main_loop_run(main_loop);
 733                 ret = data.result;
 734                 break;
 735
 736         case REINSTALL_REQ:
 737                 if (data.pkg_type[0] == '\0' || data.pkgid[0] == '\0') {
 738                         printf("Please provide the arguments.\n");
 739                         printf("use -h option to see usage\n");
 740                         data.result = PKGCMD_ERR_ARGUMENT_INVALID;
 741                         break;
 742                 }
 743                 g_type_init();
 744                 main_loop = g_main_loop_new(NULL, FALSE);
 745                 pc = pkgmgr_client_new(PC_REQUEST);
 746                 if (pc == NULL) {
 747                         printf("PkgMgr Client Creation Failed\n");
 748                         data.result = PKGCMD_ERR_FATAL_ERROR;
 749                         break;
 750                 }
 751
 752                 mode = PM_QUIET;
 753                 ret = pkgmgr_client_reinstall(pc, data.pkg_type, data.pkgid, NULL, mode, __return_cb, pc);
 754                 if (ret < 0){
 755                         data.result = PKGCMD_ERR_FATAL_ERROR;
 756                         if (access(data.pkg_path, F_OK) != 0)
 757                                 data.result = PKGCMD_ERR_PACKAGE_NOT_FOUND;
 758                         break;
 759                 }
 760                 g_main_loop_run(main_loop);
 761                 ret = data.result;
 762                 break;
 763
 764         case CLEAR_REQ:
 765                 if (data.pkg_type[0] == '\0' || data.pkgid[0] == '\0') {
 766                         printf("Please provide the arguments.\n");
 767                         printf("use -h option to see usage\n");
 768                         ret = -1;
 769                         break;
 770                 }
 771
 772                 pc = pkgmgr_client_new(PC_REQUEST);
 773                 if (pc == NULL) {
 774                         printf("PkgMgr Client Creation Failed\n");
 775                         ret = -1;
 776                         break;
 777                 }
 778                 if (data.quiet == 0)
 779                         mode = PM_DEFAULT;
 780                 else
 781                         mode = PM_QUIET;
 782                 ret = __is_app_installed(data.pkgid);
 783                 if (ret == -1) {
 784                         printf("package is not installed\n");
 785                         break;
 786                 }
 787                 ret = pkgmgr_client_clear_user_data(pc, data.pkg_type,
 788                                                     data.pkgid, mode);
 789                 if (ret < 0)
 790                         break;
 791                 ret = data.result;
 792                 break;
 793
 794         case ACTIVATE_REQ:
 795                 if (data.pkg_type[0] == '\0' || data.pkgid[0] == '\0') {
 796                         printf("Please provide the arguments.\n");
 797                         printf("use -h option to see usage\n");
 798                         ret = -1;
 799                         break;
 800                 }
 801
 802                 pc = pkgmgr_client_new(PC_REQUEST);
 803                 if (pc == NULL) {
 804                         printf("PkgMgr Client Creation Failed\n");
 805                         ret = -1;
 806                         break;
 807                 }
 808
 809                 if ( strcmp(data.pkg_type, "app") == 0 ) {
 810                         if (strlen(data.label) == 0) {
 811                                 ret = pkgmgr_client_activate_app(pc, data.pkgid);
 812                                 if (ret < 0)
 813                                         break;
 814                         } else {
 815                                 printf("label [%s]\n", data.label);
 816                                 char *largv[3] = {NULL, };
 817                                 largv[0] = "-l";
 818                                 largv[1] = data.label;
 819                                 ret = pkgmgr_client_activate_appv(pc, data.pkgid, largv);
 820                                 if (ret < 0)
 821                                         break;
 822                         }
 823                 } else {
 824                         ret = pkgmgr_client_activate(pc, data.pkg_type, data.pkgid);
 825                         if (ret < 0)
 826                                 break;
 827                 }
 828                 ret = data.result;
 829
 830                 break;
 831
 832
 833         case DEACTIVATE_REQ:
 834                 if (data.pkg_type[0] == '\0' || data.pkgid[0] == '\0') {
 835                         printf("Please provide the arguments.\n");
 836                         printf("use -h option to see usage\n");
 837                         ret = -1;
 838                         break;
 839                 }
 840
 841                 pc = pkgmgr_client_new(PC_REQUEST);
 842                 if (pc == NULL) {
 843                         printf("PkgMgr Client Creation Failed\n");
 844                         ret = -1;
 845                         break;
 846                 }
 847
 848                 if ( strcmp(data.pkg_type, "app") == 0 ) {
 849                         ret = pkgmgr_client_deactivate_app(pc, data.pkgid);
 850                         if (ret < 0)
 851                                 break;
 852                 } else {
 853                         ret = pkgmgr_client_deactivate(pc, data.pkg_type, data.pkgid);
 854                         if (ret < 0)
 855                                 break;
 856                 }
 857                 ret = data.result;
 858
 859                 break;
 860
 861         case MOVE_REQ:
 862                 if (data.pkg_type[0] == '\0' || data.pkgid[0] == '\0') {
 863                         printf("Please provide the arguments.\n");
 864                         printf("use -h option to see usage\n");
 865                         ret = -1;
 866                         break;
 867                 }
 868                 if (data.move_type < 0 || data.move_type > 1) {
 869                         printf("Invalid move type...See usage\n");
 870                         ret = -1;
 871                         break;
 872                 }
 873                 pc = pkgmgr_client_new(PC_REQUEST);
 874                 if (pc == NULL) {
 875                         printf("PkgMgr Client Creation Failed\n");
 876                         ret = -1;
 877                         break;
 878                 }
 879                 if (data.quiet == 0)
 880                         mode = PM_DEFAULT;
 881                 else
 882                         mode = PM_QUIET;
 883                 ret = __is_app_installed(data.pkgid);
 884                 if (ret == -1) {
 885                         printf("package is not installed\n");
 886                         break;
 887                 }
 888                 ret = pkgmgr_client_move(pc, data.pkg_type, data.pkgid,  data.move_type, mode);
 889                 if (ret < 0)
 890                         break;
 891                 ret = data.result;
 892                 break;
 893
 894         case APPPATH_REQ:
 895                 if (data.pkg_type[0] == '\0' && data.pkgid[0] == '\0') {
 896                         printf("Tizen Application Installation Path: %s\n", APP_INSTALLATION_PATH_RW);
 897                         ret = 0;
 898                         break;
 899                 }
 900                 if ((data.pkg_type[0] == '\0') || (data.pkgid[0] == '\0')) {
 901                         printf("Use -h option to see usage\n");
 902                         ret = -1;
 903                         break;
 904                 }
 905                 if (strncmp(data.pkg_type, "rpm", PKG_TYPE_STRING_LEN_MAX - 1) == 0) {
 906                         snprintf(buf, 1023, "%s/%s", APP_INSTALLATION_PATH_RW, data.pkgid);
 907                         printf("Tizen Application Installation Path: %s\n", buf);
 908                         ret = 0;
 909                         break;
 910                 } else if (strncmp(data.pkg_type, "wgt", PKG_TYPE_STRING_LEN_MAX - 1) == 0) {
 911                         snprintf(buf, 1023, "%s/%s/res/wgt", APP_INSTALLATION_PATH_RW, data.pkgid);
 912                         printf("Tizen Application Installation Path: %s\n", buf);
 913                         ret = 0;
 914                         break;
 915                 } else if (strncmp(data.pkg_type, "tpk", PKG_TYPE_STRING_LEN_MAX - 1) == 0) {
 916                         snprintf(buf, 1023, "%s/%s", APP_INSTALLATION_PATH_RW, data.pkgid);
 917                         printf("Tizen Application Installation Path: %s\n", buf);
 918                         ret = 0;
 919                         break;
 920                 } else {
 921                         printf("Invalid package type.\n");
 922                         printf("use -h option to see usage\n");
 923                         ret = -1;
 924                         break;
 925                 }
 926                 break;
 927
 928         case KILLAPP_REQ:
 929         case CHECKAPP_REQ:
 930                 if (data.pkg_type[0] == '\0' || data.pkgid[0] == '\0') {
 931                         printf("Please provide the arguments.\n");
 932                         printf("use -h option to see usage\n");
 933                         ret = -1;
 934                         break;
 935                 }
 936                 pkgmgr_pkginfo_h handle;
 937                 ret = pkgmgr_pkginfo_get_pkginfo(data.pkgid, &handle);
 938                 if (ret < 0) {
 939                         printf("Failed to get handle\n");
 940                         data.result = PKGCMD_ERR_PACKAGE_NOT_FOUND;
 941                         return  0;
 942                 }
 943                 ret = pkgmgr_appinfo_get_list(handle, PM_UI_APP, __app_list_cb, NULL);
 944                 if (ret < 0) {
 945                         printf("pkgmgr_appinfo_get_list() failed\n");
 946                         pkgmgr_pkginfo_destroy_pkginfo(handle);
 947                         data.result = PKGCMD_ERR_PACKAGE_NOT_FOUND;
 948                         return  0;
 949                 }
 950                 ret = pkgmgr_appinfo_get_list(handle, PM_SVC_APP, __app_list_cb, NULL);
 951                 if (ret < 0) {
 952                         printf("pkgmgr_appinfo_get_list() failed\n");
 953                         pkgmgr_pkginfo_destroy_pkginfo(handle);
 954                         data.result = PKGCMD_ERR_PACKAGE_NOT_FOUND;
 955                         return  0;
 956                 }
 957                 pkgmgr_pkginfo_destroy_pkginfo(handle);
 958                 ret = 0;
 959                 break;
 960
 961         case LIST_REQ:
 962                 if (data.pkg_type[0] == '\0') {
 963                         ret = pkgmgr_pkginfo_get_list(__pkgmgr_list_cb, NULL);
 964                         if (ret == -1) {
 965                                 printf("Failed to get package list\n");
 966                                 break;
 967                         }
 968                         break;
 969                 } else {
 970                         pkgmgrinfo_pkginfo_filter_h handle;
 971                         ret = pkgmgrinfo_pkginfo_filter_create(&handle);
 972                         if (ret == -1) {
 973                                 printf("Failed to get package filter handle\n");
 974                                 break;
 975                         }
 976                         ret = pkgmgrinfo_pkginfo_filter_add_string(handle, PMINFO_PKGINFO_PROP_PACKAGE_TYPE, data.pkg_type);
 977                         if (ret == -1) {
 978                                 printf("Failed to add package type filter\n");
 979                                 pkgmgrinfo_pkginfo_filter_destroy(handle);
 980                                 break;
 981                         }
 982                         ret = pkgmgrinfo_pkginfo_filter_foreach_pkginfo(handle, __pkgmgr_list_cb, NULL);
 983                         if (ret == -1) {
 984                                 printf("Failed to get package filter list\n");
 985                                 pkgmgrinfo_pkginfo_filter_destroy(handle);
 986                                 break;
 987                         }
 988                         pkgmgrinfo_pkginfo_filter_destroy(handle);
 989                         break;
 990                 }
 991
 992         case SHOW_REQ:
 993                 if (data.pkgid[0] != '\0') {
 994                         pkgmgr_info *pkg_info =
 995                             pkgmgr_info_new(data.pkg_type, data.pkgid);
 996                         if (pkg_info == NULL) {
 997                                 printf("Failed to get pkginfo handle\n");
 998                                 ret = -1;
 999                                 break;
1000                         }
1001                         __print_pkg_info(pkg_info);
1002                         ret = pkgmgr_info_free(pkg_info);
1003                         break;
1004                 }
1005                 if (data.pkg_path[0] != '\0') {
1006                         pkgmgr_info *pkg_info =
1007                             pkgmgr_info_new_from_file(data.pkg_type,
1008                                                       data.pkg_path);
1009                         if (pkg_info == NULL) {
1010                                 printf("Failed to get pkginfo handle\n");
1011                                 ret = -1;
1012                                 break;
1013                         }
1014                         __print_pkg_info(pkg_info);
1015                         ret = pkgmgr_info_free(pkg_info);
1016                         break;
1017                 }
1018                 printf("Either pkgid or pkgpath should be supplied\n");
1019                 ret = -1;
1020                 break;
1021
1022         case CSC_REQ:
1023                 ret = pkgmgr_client_request_service(PM_REQUEST_CSC, NULL, NULL, NULL, data.des_path, NULL, NULL, (void *)data.pkg_path);
1024                 if (ret < 0)
1025                         data.result = PKGCMD_ERR_FATAL_ERROR;
1026                 break;
1027
1028         case HELP_REQ:
1029                 __print_usage();
1030                 ret = 0;
1031                 break;
1032
1033         default:
1034                 printf("Wrong Request\n");
1035                 ret = -1;
1036                 break;
1037         }
1038
1039         if (pc) {
1040                 pkgmgr_client_free(pc);
1041                 pc = NULL;
1042         }
1043         return ret;
1044 }
1045
1046 static int __is_authorized()
1047 {
1048         /* pkgcmd needs root or developer privileges.
1049            If launched via fork/exec, the launching program
1050            must be running as root */
1051
1052         uid_t uid = getuid();
1053         if ((uid_t) 0 == uid || (uid_t) 5100 == uid)
1054                 return 1;
1055         else
1056                 return 0;
1057 }
1058
1059 int main(int argc, char *argv[])
1060 {
1061         optind = 1;
1062         int opt_idx = 0;
1063         int c = -1;
1064         int ret = -1;
1065         char *errstr = NULL;
1066         long starttime;
1067         long endtime;
1068         struct timeval tv;
1069
1070         if (!__is_authorized()) {
1071                 printf("You are not an authorized user!\n");
1072                 return PKGCMD_ERR_FATAL_ERROR;
1073         }
1074
1075         if (argc == 1)
1076                 __print_usage();
1077
1078         gettimeofday(&tv, NULL);
1079         starttime = tv.tv_sec * 1000l + tv.tv_usec / 1000l;
1080
1081         data.request = -1;
1082         memset(data.des_path, '\0', PKG_NAME_STRING_LEN_MAX);
1083         memset(data.pkg_path, '\0', PKG_NAME_STRING_LEN_MAX);
1084         memset(data.pkgid, '\0', PKG_NAME_STRING_LEN_MAX);
1085         memset(data.pkg_type, '\0', PKG_TYPE_STRING_LEN_MAX);
1086         memset(data.label, '\0', PKG_TYPE_STRING_LEN_MAX);
1087         data.quiet = 0;
1088         data.result = 0;
1089         data.move_type = -1;
1090         while (1) {
1091                 c = getopt_long(argc, argv, short_options, long_options,
1092                                 &opt_idx);
1093                 if (c == -1)
1094                         break;  /* Parse end */
1095                 switch (c) {
1096                 case 'i':       /* install */
1097                         data.request = INSTALL_REQ;
1098                         break;
1099
1100                 case 'u':       /* uninstall */
1101                         data.request = UNINSTALL_REQ;
1102                         break;
1103
1104                 case 'r':       /* reinstall */
1105                         data.request = REINSTALL_REQ;
1106                         break;
1107
1108                 case 'c':       /* clear */
1109                         data.request = CLEAR_REQ;
1110                         break;
1111
1112                 case 'm':       /* move */
1113                         data.request = MOVE_REQ;
1114                         break;
1115
1116                 case 'S': /* csc packages */
1117                         data.request = CSC_REQ;
1118                         if (optarg)
1119                                 strncpy(data.des_path, optarg, PKG_NAME_STRING_LEN_MAX);
1120                         printf("csc file is %s\n", data.des_path);
1121                         break;
1122
1123                 case 'A':       /* activate */
1124                         data.request = ACTIVATE_REQ;
1125                         break;
1126
1127                 case 'D':       /* deactivate */
1128                         data.request = DEACTIVATE_REQ;
1129                         break;
1130
1131                 case 'L':       /* activate with Label */
1132                         data.request = ACTIVATE_REQ;
1133                         if (optarg)
1134                                 strncpy(data.label, optarg,
1135                                         PKG_NAME_STRING_LEN_MAX);
1136                         break;
1137
1138                 case 'a':       /* app installation path */
1139                         data.request = APPPATH_REQ;
1140                         break;
1141
1142                 case 'k':       /* Terminate applications of a package */
1143                         data.request = KILLAPP_REQ;
1144                         break;
1145
1146                 case 'C':       /* Check running status of applications of a package */
1147                         data.request = CHECKAPP_REQ;
1148                         break;
1149
1150                 case 'l':       /* list */
1151                         data.request = LIST_REQ;
1152                         break;
1153
1154                 case 's':       /* show */
1155                         data.request = SHOW_REQ;
1156                         break;
1157
1158                 case 'p':       /* package path */
1159                         if (optarg)
1160                                 strncpy(data.pkg_path, optarg,
1161                                         PKG_NAME_STRING_LEN_MAX);
1162                         ret = __convert_to_absolute_path(data.pkg_path);
1163                         if (ret == -1) {
1164                                 printf("conversion of relative path to absolute path failed\n");
1165                                 return -1;
1166                         }
1167                         printf("path is %s\n", data.pkg_path);
1168                         break;
1169
1170                 case 'd':       /* descriptor path */
1171                         if (optarg)
1172                                 strncpy(data.des_path, optarg,
1173                                         PKG_NAME_STRING_LEN_MAX);
1174                         break;
1175
1176                 case 'n':       /* package name */
1177                         if (optarg)
1178                                 strncpy(data.pkgid, optarg,
1179                                         PKG_NAME_STRING_LEN_MAX);
1180                         break;
1181
1182                 case 't':       /* package type */
1183                         if (optarg)
1184                                 strncpy(data.pkg_type, optarg,
1185                                         PKG_TYPE_STRING_LEN_MAX);
1186                         break;
1187
1188                 case 'T':       /* move type */
1189                         data.move_type = atoi(optarg);
1190                         break;
1191
1192                 case 'h':       /* help */
1193                         data.request = HELP_REQ;
1194                         break;
1195
1196                 case 'q':       /* quiet mode */
1197                         data.quiet = 1;
1198                         break;
1199
1200                         /* Otherwise */
1201                 case '?':       /* Not an option */
1202                         __print_usage();
1203                         break;
1204
1205                 case ':':       /* */
1206                         break;
1207
1208                 default:
1209                         break;
1210
1211                 }
1212         }
1213         ret = __process_request();
1214         if ((ret == -1) && (data.result != 0))
1215                 data.result = PKGCMD_ERR_ARGUMENT_INVALID;
1216
1217         if (ret != 0) {
1218                 __error_no_to_string(data.result, &errstr);
1219                 printf("processing result : %s [%d] failed\n", errstr, data.result);
1220         } else {
1221                 if (data.request == INSTALL_REQ)
1222                         sleep(2);
1223         }
1224
1225
1226         gettimeofday(&tv, NULL);
1227         endtime = tv.tv_sec * 1000l + tv.tv_usec / 1000l;
1228         printf("spend time for pkgcmd is [%d]ms\n", (int)(endtime - starttime));
1229
1230         return data.result;
1231 }