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