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