client/src/pkgmgr.c

   1 /*
   2  * slp-pkgmgr
   3  *
   4  * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Contact: Jayoun Lee <airjany@samsung.com>, Sewook Park <sewook7.park@samsung.com>,
   7  * Jaeho Lee <jaeho81.lee@samsung.com>, Shobhit Srivastava <shobhit.s@samsung.com>
   8  *
   9  * Licensed under the Apache License, Version 2.0 (the "License");
  10  * you may not use this file except in compliance with the License.
  11  * You may obtain a copy of the License at
  12  *
  13  * http://www.apache.org/licenses/LICENSE-2.0
  14  *
  15  * Unless required by applicable law or agreed to in writing, software
  16  * distributed under the License is distributed on an "AS IS" BASIS,
  17  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  18  * See the License for the specific language governing permissions and
  19  * limitations under the License.
  20  *
  21  */
  22
  23 #include <stdio.h>
  24 #include <stdlib.h>
  25 #include <string.h>
  26 #include <unistd.h>
  27 #include <dlfcn.h>
  28 #include <dirent.h>
  29 #include <fcntl.h>
  30 #include <sys/wait.h>
  31 #include <sys/time.h>
  32
  33 #include <glib.h>
  34
  35 #include <pkgmgr-info.h>
  36 #include <iniparser.h>
  37 /* For multi-user support */
  38 #include <tzplatform_config.h>
  39
  40 #include "package-manager.h"
  41 #include "pkgmgr-internal.h"
  42 #include "pkgmgr-debug.h"
  43 #include "pkgmgr-api.h"
  44 #include "comm_client.h"
  45
  46 #define PKG_TMP_PATH tzplatform_mkpath(TZ_USER_APP, "tmp")
  47
  48 #define BINSH_NAME      "/bin/sh"
  49 #define BINSH_SIZE      7
  50
  51 #define GLOBAL_USER tzplatform_getuid(TZ_SYS_GLOBALAPP_USER)
  52
  53 static int _get_request_id()
  54 {
  55         static int internal_req_id = 1;
  56
  57         return internal_req_id++;
  58 }
  59
  60 typedef struct _req_cb_info {
  61         int request_id;
  62         char *req_key;
  63         pkgmgr_handler event_cb;
  64         void *data;
  65         struct _req_cb_info *next;
  66 } req_cb_info;
  67
  68 typedef struct _listen_cb_info {
  69         int request_id;
  70         pkgmgr_handler event_cb;
  71         void *data;
  72         struct _listen_cb_info *next;
  73 } listen_cb_info;
  74
  75 typedef struct _pkgmgr_client_t {
  76         client_type ctype;
  77         int status_type;
  78         union {
  79                 struct _request {
  80                         comm_client *cc;
  81                         req_cb_info *rhead;
  82                 } request;
  83                 struct _listening {
  84                         comm_client *cc;
  85                         listen_cb_info *lhead;
  86                 } listening;
  87         } info;
  88         void *new_event_cb;
  89 } pkgmgr_client_t;
  90
  91 typedef struct _iter_data {
  92         pkgmgr_iter_fn iter_fn;
  93         void *data;
  94 } iter_data;
  95
  96 static int __xsystem(const char *argv[])
  97 {
  98         int status = 0;
  99         pid_t pid;
 100         pid = fork();
 101         switch (pid) {
 102         case -1:
 103                 perror("fork failed");
 104                 return -1;
 105         case 0:
 106                 /* child */
 107                 execvp(argv[0], (char *const *)argv);
 108                 _exit(-1);
 109         default:
 110                 /* parent */
 111                 break;
 112         }
 113         if (waitpid(pid, &status, 0) == -1) {
 114                 perror("waitpid failed");
 115                 return -1;
 116         }
 117         if (WIFSIGNALED(status)) {
 118                 perror("signal");
 119                 return -1;
 120         }
 121         if (!WIFEXITED(status)) {
 122                 /* shouldn't happen */
 123                 perror("should not happen");
 124                 return -1;
 125         }
 126         return WEXITSTATUS(status);
 127 }
 128
 129 static void __error_to_string(int errnumber, char **errstr)
 130 {
 131         if (errstr == NULL)
 132                 return;
 133         switch (errnumber) {
 134         case PKGCMD_ERR_PACKAGE_NOT_FOUND:
 135                 *errstr = PKGCMD_ERR_PACKAGE_NOT_FOUND_STR;
 136                 break;
 137         case PKGCMD_ERR_PACKAGE_INVALID:
 138                 *errstr = PKGCMD_ERR_PACKAGE_INVALID_STR;
 139                 break;
 140         case PKGCMD_ERR_PACKAGE_LOWER_VERSION:
 141                 *errstr = PKGCMD_ERR_PACKAGE_LOWER_VERSION_STR;
 142                 break;
 143         case PKGCMD_ERR_PACKAGE_EXECUTABLE_NOT_FOUND:
 144                 *errstr = PKGCMD_ERR_PACKAGE_EXECUTABLE_NOT_FOUND_STR;
 145                 break;
 146         case PKGCMD_ERR_MANIFEST_INVALID:
 147                 *errstr = PKGCMD_ERR_MANIFEST_INVALID_STR;
 148                 break;
 149         case PKGCMD_ERR_CONFIG_NOT_FOUND:
 150                 *errstr = PKGCMD_ERR_CONFIG_NOT_FOUND_STR;
 151                 break;
 152         case PKGCMD_ERR_CONFIG_INVALID:
 153                 *errstr = PKGCMD_ERR_CONFIG_INVALID_STR;
 154                 break;
 155         case PKGCMD_ERR_SIGNATURE_NOT_FOUND:
 156                 *errstr = PKGCMD_ERR_SIGNATURE_NOT_FOUND_STR;
 157                 break;
 158         case PKGCMD_ERR_SIGNATURE_INVALID:
 159                 *errstr = PKGCMD_ERR_SIGNATURE_INVALID_STR;
 160                 break;
 161         case PKGCMD_ERR_SIGNATURE_VERIFICATION_FAILED:
 162                 *errstr = PKGCMD_ERR_SIGNATURE_VERIFICATION_FAILED_STR;
 163                 break;
 164         case PKGCMD_ERR_ROOT_CERTIFICATE_NOT_FOUND:
 165                 *errstr = PKGCMD_ERR_ROOT_CERTIFICATE_NOT_FOUND_STR;
 166                 break;
 167         case PKGCMD_ERR_CERTIFICATE_INVALID:
 168                 *errstr = PKGCMD_ERR_CERTIFICATE_INVALID_STR;
 169                 break;
 170         case PKGCMD_ERR_CERTIFICATE_CHAIN_VERIFICATION_FAILED:
 171                 *errstr = PKGCMD_ERR_CERTIFICATE_CHAIN_VERIFICATION_FAILED_STR;
 172                 break;
 173         case PKGCMD_ERR_CERTIFICATE_EXPIRED:
 174                 *errstr = PKGCMD_ERR_CERTIFICATE_EXPIRED_STR;
 175                 break;
 176         case PKGCMD_ERR_INVALID_PRIVILEGE:
 177                 *errstr = PKGCMD_ERR_INVALID_PRIVILEGE_STR;
 178                 break;
 179         case PKGCMD_ERR_MENU_ICON_NOT_FOUND:
 180                 *errstr = PKGCMD_ERR_MENU_ICON_NOT_FOUND_STR;
 181                 break;
 182         case PKGCMD_ERR_FATAL_ERROR:
 183                 *errstr = PKGCMD_ERR_FATAL_ERROR_STR;
 184                 break;
 185         case PKGCMD_ERR_OUT_OF_STORAGE:
 186                 *errstr = PKGCMD_ERR_OUT_OF_STORAGE_STR;
 187                 break;
 188         case PKGCMD_ERR_OUT_OF_MEMORY:
 189                 *errstr = PKGCMD_ERR_OUT_OF_MEMORY_STR;
 190                 break;
 191         case PKGCMD_ERR_ARGUMENT_INVALID:
 192                 *errstr = PKGCMD_ERR_ARGUMENT_INVALID_STR;
 193                 break;
 194         default:
 195                 *errstr = PKGCMD_ERR_UNKNOWN_STR;
 196                 break;
 197         }
 198 }
 199
 200 static void __add_op_cbinfo(pkgmgr_client_t * pc, int request_id,
 201                             const char *req_key, pkgmgr_handler event_cb, void *new_event_cb,
 202                             void *data)
 203 {
 204         req_cb_info *cb_info;
 205         req_cb_info *current;
 206         req_cb_info *prev;
 207
 208         cb_info = (req_cb_info *) calloc(1, sizeof(req_cb_info));
 209         if (cb_info == NULL) {
 210                 DBG("calloc failed");
 211                 return;
 212         }
 213         cb_info->request_id = request_id;
 214         cb_info->req_key = strdup(req_key);
 215         cb_info->event_cb = event_cb;
 216         cb_info->data = data;
 217         cb_info->next = NULL;
 218         pc->new_event_cb = new_event_cb;
 219
 220         if (pc->info.request.rhead == NULL)
 221                 pc->info.request.rhead = cb_info;
 222         else {
 223                 current = prev = pc->info.request.rhead;
 224                 while (current) {
 225                         prev = current;
 226                         current = current->next;
 227                 }
 228
 229                 prev->next = cb_info;
 230         }
 231 }
 232
 233 static req_cb_info *__find_op_cbinfo(pkgmgr_client_t *pc, const char *req_key)
 234 {
 235         req_cb_info *tmp;
 236
 237         tmp = pc->info.request.rhead;
 238
 239         if (tmp == NULL) {
 240                 ERR("tmp is NULL");
 241                 return NULL;
 242         }
 243
 244         DBG("tmp->req_key %s, req_key %s", tmp->req_key, req_key);
 245
 246         while (tmp) {
 247                 if (strncmp(tmp->req_key, req_key, strlen(tmp->req_key)) == 0)
 248                         return tmp;
 249                 tmp = tmp->next;
 250         }
 251         return NULL;
 252 }
 253
 254 static void __add_stat_cbinfo(pkgmgr_client_t *pc, int request_id,
 255                               pkgmgr_handler event_cb, void *data)
 256 {
 257         listen_cb_info *cb_info;
 258         listen_cb_info *current;
 259         listen_cb_info *prev;
 260
 261         cb_info = (listen_cb_info *) calloc(1, sizeof(listen_cb_info));
 262         if (cb_info == NULL) {
 263                 DBG("calloc failed");
 264                 return;
 265         }
 266         cb_info->request_id = request_id;
 267         cb_info->event_cb = event_cb;
 268         cb_info->data = data;
 269         cb_info->next = NULL;
 270
 271         /* TODO - check the order of callback - FIFO or LIFO => Should be changed to LIFO */
 272         if (pc->info.listening.lhead == NULL)
 273                 pc->info.listening.lhead = cb_info;
 274         else {
 275                 current = prev = pc->info.listening.lhead;
 276                 while (current) {
 277                         prev = current;
 278                         current = current->next;
 279                 }
 280
 281                 prev->next = cb_info;
 282         }
 283 }
 284
 285 static void __operation_callback(void *cb_data, uid_t target_uid,
 286                                  const char *req_id, const char *pkg_type,
 287                                  const char *pkgid, const char *key,
 288                                  const char *val)
 289 {
 290         pkgmgr_client_t *pc;
 291         req_cb_info *cb_info;
 292
 293         pc = (pkgmgr_client_t *) cb_data;
 294
 295         /* find callback info */
 296         cb_info = __find_op_cbinfo(pc, req_id);
 297         if (cb_info == NULL) {
 298                 ERR("cannot fint cb_info for req_id:%s", req_id);
 299                 return;
 300         }
 301
 302         /* call callback */
 303         if (cb_info->event_cb) {
 304                 if (pc->new_event_cb)
 305                         cb_info->event_cb(target_uid, cb_info->request_id,
 306                                         pkg_type, pkgid, key, val, pc,
 307                                         cb_info->data);
 308                 else
 309                         cb_info->event_cb(target_uid, cb_info->request_id,
 310                                         pkg_type, pkgid, key, val, NULL,
 311                                         cb_info->data);
 312         }
 313
 314         return;
 315 }
 316
 317 static void __status_callback(void *cb_data, uid_t target_uid,
 318                               const char *req_id, const char *pkg_type,
 319                               const char *pkgid,  const char *key,
 320                               const char *val)
 321 {
 322         pkgmgr_client_t *pc;
 323         listen_cb_info *tmp;
 324
 325         pc = (pkgmgr_client_t *) cb_data;
 326
 327         tmp = pc->info.listening.lhead;
 328         while (tmp) {
 329                 if (tmp->event_cb(target_uid, tmp->request_id, pkg_type, pkgid,
 330                                   key, val, NULL, tmp->data) != 0)
 331                         break;
 332                 tmp = tmp->next;
 333         }
 334
 335         return;
 336 }
 337
 338 static char *__get_req_key(const char *pkg_path)
 339 {
 340         struct timeval tv;
 341         long curtime;
 342         char timestr[PKG_STRING_LEN_MAX];
 343         char *str_req_key;
 344         int size;
 345
 346         gettimeofday(&tv, NULL);
 347         curtime = tv.tv_sec * 1000000 + tv.tv_usec;
 348         snprintf(timestr, sizeof(timestr), "%ld", curtime);
 349
 350         size = strlen(pkg_path) + strlen(timestr) + 2;
 351         str_req_key = (char *)calloc(size, sizeof(char));
 352         if (str_req_key == NULL) {
 353                 DBG("calloc failed");
 354                 return NULL;
 355         }
 356         snprintf(str_req_key, size, "%s_%s", pkg_path, timestr);
 357
 358         return str_req_key;
 359 }
 360
 361 static char *__get_type_from_path(const char *pkg_path)
 362 {
 363         int ret;
 364         char mimetype[255] = { '\0', };
 365         char extlist[256] = { '\0', };
 366         char *pkg_type;
 367
 368         ret = _get_mime_from_file(pkg_path, mimetype, sizeof(mimetype));
 369         if (ret) {
 370                 ERR("_get_mime_from_file() failed - error code[%d]\n",
 371                       ret);
 372                 return NULL;
 373         }
 374
 375         ret = _get_mime_extension(mimetype, extlist, sizeof(extlist));
 376         if (ret) {
 377                 ERR("_get_mime_extension() failed - error code[%d]\n",
 378                       ret);
 379                 return NULL;
 380         }
 381
 382         if (strlen(extlist) == 0)
 383                 return NULL;
 384
 385         if (strchr(extlist, ',')) {
 386                 extlist[strlen(extlist) - strlen(strchr(extlist, ','))] = '\0';
 387         }
 388         pkg_type = strchr(extlist, '.') + 1;
 389         return strdup(pkg_type);
 390 }
 391
 392 static int __get_pkgid_by_appid(const char *appid, char **pkgid)
 393 {
 394         pkgmgrinfo_appinfo_h pkgmgrinfo_appinfo = NULL;
 395         int ret = -1;
 396         char *pkg_id = NULL;
 397         char *pkg_id_dup = NULL;
 398
 399         if (pkgmgrinfo_appinfo_get_appinfo(appid, &pkgmgrinfo_appinfo) != PMINFO_R_OK)
 400                 return -1;
 401
 402         if (pkgmgrinfo_appinfo_get_pkgname(pkgmgrinfo_appinfo, &pkg_id) != PMINFO_R_OK)
 403                 goto err;
 404
 405         pkg_id_dup = strdup(pkg_id);
 406         if (pkg_id_dup == NULL)
 407                 goto err;
 408
 409         *pkgid = pkg_id_dup;
 410         ret = PMINFO_R_OK;
 411
 412 err:
 413         pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
 414
 415         return ret;
 416 }
 417
 418 static int __appinfo_cb(pkgmgrinfo_appinfo_h handle, void *user_data)
 419 {
 420         int ret;
 421         char **appid = (char **)user_data;
 422         char *val;
 423
 424         ret = pkgmgrinfo_appinfo_get_appid(handle, &val);
 425         if (ret != PMINFO_R_OK)
 426                 return ret;
 427
 428         *appid = strdup(val);
 429
 430         return 0;
 431 }
 432
 433 static char *__get_app_info_from_db_by_apppath(const char *apppath, uid_t uid)
 434 {
 435         int ret;
 436         char *caller_appid = NULL;
 437         pkgmgrinfo_appinfo_filter_h filter;
 438
 439         if (apppath == NULL)
 440                 return NULL;
 441
 442         ret = pkgmgrinfo_appinfo_filter_create(&filter) != PMINFO_R_OK;
 443         if (ret != PMINFO_R_OK)
 444                 return NULL;
 445
 446         ret = pkgmgrinfo_appinfo_filter_add_string(filter,
 447                         PMINFO_APPINFO_PROP_APP_EXEC, apppath);
 448         if (ret != PMINFO_R_OK) {
 449                 pkgmgrinfo_appinfo_filter_destroy(filter);
 450                 return NULL;
 451         }
 452
 453         ret = pkgmgrinfo_appinfo_usr_filter_foreach_appinfo(filter,
 454                         __appinfo_cb, &caller_appid, uid);
 455         if (ret != PMINFO_R_OK) {
 456                 pkgmgrinfo_appinfo_filter_destroy(filter);
 457                 return NULL;
 458         }
 459
 460         pkgmgrinfo_appinfo_filter_destroy(filter);
 461
 462         return caller_appid;
 463 }
 464
 465 static inline int __read_proc(const char *path, char *buf, int size)
 466 {
 467         int fd = 0;
 468         int ret = 0;
 469
 470         if (buf == NULL || path == NULL)
 471                 return -1;
 472
 473         fd = open(path, O_RDONLY);
 474         if (fd < 0)
 475                 return -1;
 476
 477         ret = read(fd, buf, size - 1);
 478         if (ret <= 0) {
 479                 close(fd);
 480                 return -1;
 481         } else
 482                 buf[ret] = 0;
 483
 484         close(fd);
 485
 486         return ret;
 487 }
 488
 489 char *__proc_get_cmdline_bypid(int pid)
 490 {
 491         char buf[PKG_STRING_LEN_MAX] = {'\0', };
 492         int ret = 0;
 493
 494         snprintf(buf, sizeof(buf), "/proc/%d/cmdline", pid);
 495         ret = __read_proc(buf, buf, sizeof(buf));
 496         if (ret <= 0)
 497                 return NULL;
 498
 499         /* support app launched by shell script*/
 500         if (strncmp(buf, BINSH_NAME, BINSH_SIZE) == 0)
 501                 return strdup(&buf[BINSH_SIZE + 1]);
 502         else
 503                 return strdup(buf);
 504 }
 505
 506 static int __get_appid_bypid(int pid, char *pkgname, int len, uid_t uid)
 507 {
 508         char *cmdline = NULL;
 509         char *caller_appid = NULL;
 510
 511         cmdline = __proc_get_cmdline_bypid(pid);
 512         if (cmdline == NULL)
 513                 return -1;
 514
 515         caller_appid = __get_app_info_from_db_by_apppath(cmdline, uid);
 516         snprintf(pkgname, len, "%s", caller_appid);
 517
 518         free(cmdline);
 519         free(caller_appid);
 520
 521         return 0;
 522 }
 523
 524 static char *__get_caller_pkgid(uid_t uid)
 525 {
 526         char caller_appid[PKG_STRING_LEN_MAX] = {0, };
 527         char *caller_pkgid = NULL;
 528
 529         if (__get_appid_bypid(getpid(), caller_appid, sizeof(caller_appid), uid) < 0) {
 530                 ERR("get appid fail!!!\n");
 531                 return NULL;
 532         }
 533         if (__get_pkgid_by_appid(caller_appid, &caller_pkgid) < 0){
 534                 ERR("get pkgid fail!!!\n");
 535                 return NULL;
 536         }
 537
 538         return caller_pkgid;
 539 }
 540
 541 static inline int __pkgmgr_read_proc(const char *path, char *buf, int size)
 542 {
 543         int fd;
 544         int ret;
 545
 546         if (buf == NULL || path == NULL)
 547                 return -1;
 548
 549         fd = open(path, O_RDONLY);
 550         if (fd < 0)
 551                 return -1;
 552
 553         ret = read(fd, buf, size - 1);
 554         if (ret <= 0) {
 555                 close(fd);
 556                 return -1;
 557         } else
 558                 buf[ret] = 0;
 559
 560         close(fd);
 561
 562         return ret;
 563 }
 564
 565 static inline int __pkgmgr_find_pid_by_cmdline(const char *dname,
 566                                       const char *cmdline, const char *apppath)
 567 {
 568         int pid = 0;
 569
 570         if (strncmp(cmdline, apppath, PKG_STRING_LEN_MAX-1) == 0) {
 571                 pid = atoi(dname);
 572                 if (pid != getpgid(pid))
 573                         pid = 0;
 574         }
 575
 576         return pid;
 577 }
 578
 579 static int __sync_process(const char *req_key)
 580 {
 581         int ret;
 582         char info_file[PKG_STRING_LEN_MAX] = {'\0', };
 583         int result = -1;
 584         int check_cnt = 0;
 585         FILE *fp;
 586         char buf[PKG_STRING_LEN_MAX] = {0, };
 587
 588         snprintf(info_file, PKG_STRING_LEN_MAX, "%s/%s", PKG_SIZE_INFO_PATH, req_key);
 589         while(1)
 590         {
 591                 check_cnt++;
 592
 593                 if (access(info_file, F_OK) == 0) {
 594                         fp = fopen(info_file, "r");
 595                         if (fp == NULL) {
 596                                 DBG("file is not generated yet.... wait\n");
 597                                 usleep(100 * 1000);     /* 100ms sleep*/
 598                                 continue;
 599                         }
 600
 601                         if (fgets(buf, PKG_STRING_LEN_MAX, fp) == NULL) {
 602                                 ERR("failed to read info file");
 603                                 fclose(fp);
 604                                 break;
 605                         }
 606                         fclose(fp);
 607
 608                         DBG("info_file file is generated, result = %s. \n", buf);
 609                         result = atoi(buf);
 610                         break;
 611                 }
 612
 613                 DBG("file is not generated yet.... wait\n");
 614                 usleep(100 * 1000);     /* 100ms sleep*/
 615
 616                 if (check_cnt > 6000) { /* 60s * 10 time over*/
 617                         ERR("wait time over!!\n");
 618                         break;
 619                 }
 620         }
 621
 622         ret = remove(info_file);
 623         if (ret < 0)
 624                 ERR("file is can not remove[%s, %d]\n", info_file, ret);
 625
 626         return result;
 627 }
 628
 629 static int __csc_process(const char *csc_path, char *result_path)
 630 {
 631         int ret = 0;
 632         int cnt = 0;
 633         int count = 0;
 634         int csc_fail = 0;
 635         int fd = 0;
 636         char *pkgtype = NULL;
 637         char *des = NULL;
 638         char buf[PKG_STRING_LEN_MAX] = {0,};
 639         char type_buf[1024] = { 0 };
 640         char des_buf[1024] = { 0 };
 641         dictionary *csc = NULL;
 642         FILE* file = NULL;
 643
 644         csc = iniparser_load(csc_path);
 645         retvm_if(csc == NULL, PKGMGR_R_EINVAL, "cannot open parse file [%s]", csc_path);
 646
 647         file = fopen(result_path, "w");
 648         tryvm_if(file == NULL, ret = PKGMGR_R_EINVAL, "cannot open result file [%s]", result_path);
 649
 650         count = iniparser_getint(csc, "csc packages:count", -1);
 651         tryvm_if(count == 0, ret = PKGMGR_R_ERROR, "csc [%s] dont have packages", csc_path);
 652
 653         snprintf(buf, PKG_STRING_LEN_MAX, "[result]\n");
 654         fwrite(buf, 1, strlen(buf), file);
 655         snprintf(buf, PKG_STRING_LEN_MAX, "count = %d\n", count);
 656         fwrite(buf, 1, strlen(buf), file);
 657
 658         for(cnt = 1 ; cnt <= count ; cnt++)
 659         {
 660                 snprintf(type_buf, PKG_STRING_LEN_MAX - 1, "csc packages:type_%03d", cnt);
 661                 snprintf(des_buf, PKG_STRING_LEN_MAX - 1, "csc packages:description_%03d", cnt);
 662
 663                 pkgtype = iniparser_getstring(csc, type_buf, NULL);
 664                 des = iniparser_getstring(csc, des_buf, NULL);
 665                 ret = 0;
 666
 667                 if (pkgtype == NULL) {
 668                         csc_fail++;
 669                         snprintf(buf, PKG_STRING_LEN_MAX, "%s = Fail to get pkgtype\n", type_buf);
 670                         fwrite(buf, 1, strlen(buf), file);
 671                         continue;
 672                 } else if (des == NULL) {
 673                         csc_fail++;
 674                         snprintf(buf, PKG_STRING_LEN_MAX, "%s = Fail to get description\n", des_buf);
 675                         fwrite(buf, 1, strlen(buf), file);
 676                         continue;
 677                 }
 678
 679                 snprintf(buf, PKG_STRING_LEN_MAX, "type_%03d = %s\n", cnt, pkgtype);
 680                 fwrite(buf, 1, strlen(buf), file);
 681                 snprintf(buf, PKG_STRING_LEN_MAX, "description_%03d = %s\n", cnt, des);
 682                 fwrite(buf, 1, strlen(buf), file);
 683
 684                 if (strcmp(pkgtype, "tpk") == 0) {
 685                         const char *ospinstaller_argv[] = { "/usr/bin/osp-installer", "-c", des, NULL };
 686                         ret = __xsystem(ospinstaller_argv);
 687                 } else if (strcmp(pkgtype, "wgt")== 0) {
 688                         const char *wrtinstaller_argv[] = { "/usr/bin/wrt-installer", "-c", des, NULL };
 689                         ret = __xsystem(wrtinstaller_argv);
 690                 } else {
 691                         csc_fail++;
 692                         ret = -1;
 693                 }
 694
 695                 if (ret != 0) {
 696                         char *errstr = NULL;
 697                         __error_to_string(ret, &errstr);
 698                         snprintf(buf, PKG_STRING_LEN_MAX, "result_%03d = fail[%s]\n", cnt, errstr);
 699                 }
 700                 else
 701                         snprintf(buf, PKG_STRING_LEN_MAX, "result_%03d = success\n", cnt);
 702
 703                 fwrite(buf, 1, strlen(buf), file);
 704         }
 705
 706 catch:
 707         iniparser_freedict(csc);
 708         if (file != NULL) {
 709                 fflush(file);
 710                 fd = fileno(file);
 711                 fsync(fd);
 712                 fclose(file);
 713         }
 714         return ret;
 715 }
 716
 717 static int __get_size_process(pkgmgr_client * pc, const char *pkgid, uid_t uid, pkgmgr_getsize_type get_type, pkgmgr_handler event_cb, void *data)
 718 {
 719         char *req_key = NULL;
 720         int ret =0;
 721         char *pkgtype = "rpm";
 722         char *argv[PKG_ARGC_MAX] = { NULL, };
 723         char *args = NULL;
 724         int argcnt = 0;
 725         int len = 0;
 726         char *temp = NULL;
 727         int i = 0;
 728         char buf[128] = {'\0'};
 729
 730         pkgmgr_client_t *mpc = (pkgmgr_client_t *) pc;
 731         retvm_if(mpc->ctype != PC_REQUEST, PKGMGR_R_EINVAL, "mpc->ctype is not PC_REQUEST\n");
 732
 733         req_key = __get_req_key(pkgid);
 734
 735         snprintf(buf, 128, "%d", get_type);
 736         argv[argcnt++] = strdup(pkgid);
 737         argv[argcnt++] = strdup(buf);
 738         argv[argcnt++] = strdup("-k");
 739         argv[argcnt++] = strdup(req_key);
 740
 741         /*** add quote in all string for special charactor like '\n'***   FIX */
 742         for (i = 0; i < argcnt; i++) {
 743                 temp = g_shell_quote(argv[i]);
 744                 len += (strlen(temp) + 1);
 745                 g_free(temp);
 746         }
 747
 748         args = (char *)calloc(len, sizeof(char));
 749         tryvm_if(args == NULL, ret = PKGMGR_R_EINVAL, "installer_path fail");
 750
 751         strncpy(args, argv[0], len - 1);
 752
 753         for (i = 1; i < argcnt; i++) {
 754                 strncat(args, " ", strlen(" "));
 755                 temp = g_shell_quote(argv[i]);
 756                 strncat(args, temp, strlen(temp));
 757                 g_free(temp);
 758         }
 759         DBG("[args] %s [len] %d\n", args, len);
 760
 761         /* request */
 762         ret = comm_client_request(mpc->info.request.cc, "getsize",
 763                         g_variant_new("(ssss)", req_key, pkgtype, pkgid, args));
 764         if (ret < 0)
 765                 ERR("comm_client_request failed, ret=%d\n", ret);
 766
 767         ret = __sync_process(req_key);
 768         if (ret < 0)
 769                 ERR("get size failed, ret=%d\n", ret);
 770
 771 catch:
 772         for (i = 0; i < argcnt; i++)
 773                 free(argv[i]);
 774
 775         if(args)
 776                 free(args);
 777
 778         return ret;
 779 }
 780
 781 static int __move_pkg_process(pkgmgr_client * pc, const char *pkgid, uid_t uid, pkgmgr_move_type move_type, pkgmgr_handler event_cb, void *data)
 782 {
 783         char *req_key = NULL;
 784         int ret =0;
 785         pkgmgrinfo_pkginfo_h handle = NULL;
 786         char *pkgtype = NULL;
 787         char *installer_path = NULL;
 788         char *argv[PKG_ARGC_MAX] = { NULL, };
 789         char *args = NULL;
 790         int argcnt = 0;
 791         int len = 0;
 792         char *temp = NULL;
 793         int i = 0;
 794         char buf[128] = {'\0'};
 795
 796         pkgmgr_client_t *mpc = (pkgmgr_client_t *) pc;
 797         retvm_if(mpc->ctype != PC_REQUEST, PKGMGR_R_EINVAL, "mpc->ctype is not PC_REQUEST\n");
 798
 799         if(uid != GLOBAL_USER)
 800                 ret = pkgmgrinfo_pkginfo_get_usr_pkginfo(pkgid, uid, &handle);
 801         else
 802                 ret = pkgmgrinfo_pkginfo_get_pkginfo(pkgid, &handle);
 803         retvm_if(ret < 0, PKGMGR_R_ERROR, "pkgmgrinfo_pkginfo_get_pkginfo failed");
 804
 805         ret = pkgmgrinfo_pkginfo_get_type(handle, &pkgtype);
 806         tryvm_if(ret < 0, ret = PKGMGR_R_ERROR, "pkgmgrinfo_pkginfo_get_type failed");
 807
 808         installer_path = _get_backend_path_with_type(pkgtype);
 809         req_key = __get_req_key(pkgid);
 810
 811         /* generate argv */
 812         snprintf(buf, 128, "%d", move_type);
 813         /* argv[0] installer path */
 814         argv[argcnt++] = installer_path;
 815         /* argv[1] */
 816         argv[argcnt++] = strdup("-k");
 817         /* argv[2] */
 818         argv[argcnt++] = req_key;
 819         /* argv[3] */
 820         argv[argcnt++] = strdup("-m");
 821         /* argv[4] */
 822         argv[argcnt++] = strdup(pkgid);
 823         /* argv[5] */
 824         argv[argcnt++] = strdup("-t");
 825         /* argv[6] */
 826         argv[argcnt++] = strdup(buf);
 827
 828         /*** add quote in all string for special charactor like '\n'***   FIX */
 829         for (i = 0; i < argcnt; i++) {
 830                 temp = g_shell_quote(argv[i]);
 831                 len += (strlen(temp) + 1);
 832                 g_free(temp);
 833         }
 834
 835         args = (char *)calloc(len, sizeof(char));
 836         tryvm_if(args == NULL, ret = PKGMGR_R_EINVAL, "installer_path fail");
 837
 838         strncpy(args, argv[0], len - 1);
 839
 840         for (i = 1; i < argcnt; i++) {
 841                 strncat(args, " ", strlen(" "));
 842                 temp = g_shell_quote(argv[i]);
 843                 strncat(args, temp, strlen(temp));
 844                 g_free(temp);
 845         }
 846         DBG("[args] %s [len] %d\n", args, len);
 847
 848         /* 6. request */
 849         ret = comm_client_request(mpc->info.request.cc, "move",
 850                         g_variant_new("(ssss)", req_key, pkgtype, pkgid, args));
 851         if (ret < 0)
 852                 ERR("comm_client_request failed, ret=%d\n", ret);
 853
 854         ret = __sync_process(pkgid);
 855         if (ret != 0)
 856                 ERR("move pkg failed, ret=%d\n", ret);
 857
 858 catch:
 859         for (i = 0; i < argcnt; i++)
 860                 free(argv[i]);
 861
 862         if(args)
 863                 free(args);
 864
 865         if (handle)
 866                 pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
 867         return ret;
 868 }
 869
 870 static int __check_app_process(pkgmgr_request_service_type service_type, pkgmgr_client * pc, const char *pkgid, uid_t uid, void *data)
 871 {
 872         char *pkgtype;
 873         char *req_key = NULL;
 874         int ret;
 875         pkgmgrinfo_pkginfo_h handle = NULL;
 876         int pid = -1;
 877
 878         /* Check for NULL value of pc */
 879         pkgmgr_client_t *mpc = (pkgmgr_client_t *) pc;
 880         retvm_if(mpc->ctype != PC_REQUEST, PKGMGR_R_EINVAL, "mpc->ctype is not PC_REQUEST\n");
 881
 882         if (uid != GLOBAL_USER)
 883                 ret = pkgmgrinfo_pkginfo_get_usr_pkginfo(pkgid, uid, &handle);
 884         else
 885                 ret = pkgmgrinfo_pkginfo_get_pkginfo(pkgid, &handle);
 886         retvm_if(ret < 0, PKGMGR_R_ERROR, "pkgmgrinfo_pkginfo_get_pkginfo failed");
 887
 888         ret = pkgmgrinfo_pkginfo_get_type(handle, &pkgtype);
 889         tryvm_if(ret < 0, ret = PKGMGR_R_ERROR, "pkgmgrinfo_pkginfo_get_type failed");
 890
 891         /* 2. generate req_key */
 892         req_key = __get_req_key(pkgid);
 893
 894         /* 3. request activate */
 895         if (service_type == PM_REQUEST_KILL_APP)
 896                 ret = comm_client_request(mpc->info.request.cc, "kill",
 897                                 g_variant_new("(sss)", req_key, pkgtype, pkgid));
 898         else if (service_type == PM_REQUEST_CHECK_APP)
 899                 ret = comm_client_request(mpc->info.request.cc, "check",
 900                                 g_variant_new("(sss)", req_key, pkgtype, pkgid));
 901
 902         if (ret < 0)
 903                 ERR("request failed, ret=%d\n", ret);
 904
 905         pid  = __sync_process(pkgid);
 906         * (int *) data = pid;
 907
 908 catch:
 909         if (req_key)
 910                 free(req_key);
 911         if (handle)
 912                 pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
 913
 914         return ret;
 915
 916 }
 917
 918 static int __request_size_info(pkgmgr_client *pc, uid_t uid)
 919 {
 920         char *req_key = NULL;
 921         int ret =0;
 922         char *pkgtype = "getsize";
 923         char *pkgid = "size_info";
 924         pkgmgr_getsize_type get_type = PM_GET_SIZE_INFO;
 925
 926         char *argv[PKG_ARGC_MAX] = { NULL, };
 927         char *args = NULL;
 928         int argcnt = 0;
 929         int len = 0;
 930         char *temp = NULL;
 931         int i = 0;
 932         char buf[128] = {'\0'};
 933
 934         pkgmgr_client_t *mpc = (pkgmgr_client_t *) pc;
 935         retvm_if(mpc->ctype != PC_REQUEST, PKGMGR_R_EINVAL, "mpc->ctype is not PC_REQUEST\n");
 936
 937         req_key = __get_req_key(pkgid);
 938
 939         snprintf(buf, 128, "%d", get_type);
 940         argv[argcnt++] = strdup(pkgid);
 941         argv[argcnt++] = strdup(buf);
 942         argv[argcnt++] = strdup("-k");
 943         argv[argcnt++] = req_key;
 944
 945         /*** add quote in all string for special charactor like '\n'***   FIX */
 946         for (i = 0; i < argcnt; i++) {
 947                 temp = g_shell_quote(argv[i]);
 948                 len += (strlen(temp) + 1);
 949                 g_free(temp);
 950         }
 951
 952         args = (char *)calloc(len, sizeof(char));
 953         tryvm_if(args == NULL, ret = PKGMGR_R_EINVAL, "installer_path fail");
 954
 955         strncpy(args, argv[0], len - 1);
 956
 957         for (i = 1; i < argcnt; i++) {
 958                 strncat(args, " ", strlen(" "));
 959                 temp = g_shell_quote(argv[i]);
 960                 strncat(args, temp, strlen(temp));
 961                 g_free(temp);
 962         }
 963         DBG("[args] %s [len] %d\n", args, len);
 964
 965         /* request */
 966         ret = comm_client_request(mpc->info.request.cc, "getsize",
 967                         g_variant_new("(ssss)", req_key, pkgtype, pkgid, args));
 968         if (ret < 0) {
 969                 ERR("COMM_REQ_GET_SIZE failed, ret=%d\n", ret);
 970         }
 971
 972 catch:
 973         for (i = 0; i < argcnt; i++)
 974                 free(argv[i]);
 975
 976         if(args)
 977                 free(args);
 978
 979         return ret;
 980 }
 981
 982 static int __change_op_cb_for_getsize(pkgmgr_client *pc)
 983 {
 984         int ret = -1;
 985
 986         retvm_if(pc == NULL, PKGMGR_R_EINVAL, "package manager client pc is NULL");
 987         pkgmgr_client_t *mpc = (pkgmgr_client_t *) pc;
 988
 989         /*  free listening head */
 990         req_cb_info *tmp = NULL;
 991         req_cb_info *prev = NULL;
 992         for (tmp = mpc->info.request.rhead; tmp;) {
 993                 prev = tmp;
 994                 tmp = tmp->next;
 995                 free(prev);
 996         }
 997
 998         /* free dbus connection */
 999         ret = comm_client_free(mpc->info.request.cc);
1000         retvm_if(ret < 0, PKGMGR_R_ERROR, "comm_client_free() failed - %d", ret);
1001
1002         /* Manage pc for seperated event */
1003         mpc->ctype = PC_REQUEST;
1004         mpc->status_type = PKGMGR_CLIENT_STATUS_GET_SIZE;
1005
1006
1007         mpc->info.request.cc = comm_client_new();
1008         retvm_if(mpc->info.request.cc == NULL, PKGMGR_R_ERROR, "client creation failed");
1009
1010         ret = comm_client_set_status_callback(COMM_STATUS_BROADCAST_GET_SIZE, mpc->info.request.cc, __operation_callback, pc);
1011         retvm_if(ret < 0, PKGMGR_R_ERROR, "set_status_callback() failed - %d", ret);
1012
1013         return PKGMGR_R_OK;
1014 }
1015
1016 static int __get_package_size_info(pkgmgr_client_t *mpc, char *req_key, const char *pkgid, pkgmgr_getsize_type get_type, uid_t uid)
1017 {
1018         char *argv[PKG_ARGC_MAX] = { NULL, };
1019         char *args = NULL;
1020         int argcnt = 0;
1021         char *pkgtype = "getsize"; //unused
1022         char buf[128] = { 0, };
1023         int len = 0;
1024         char *temp = NULL;
1025         int i = 0;
1026         int ret = 0;
1027
1028         snprintf(buf, 128, "%d", get_type);
1029         argv[argcnt++] = strdup(pkgid);
1030         argv[argcnt++] = strdup(buf);
1031         argv[argcnt++] = strdup("-k");
1032         argv[argcnt++] = req_key;
1033
1034         /*** add quote in all string for special charactor like '\n'***   FIX */
1035         for (i = 0; i < argcnt; i++) {
1036                 temp = g_shell_quote(argv[i]);
1037                 len += (strlen(temp) + 1);
1038                 g_free(temp);
1039         }
1040
1041         args = (char *)calloc(len, sizeof(char));
1042         tryvm_if(args == NULL, ret = PKGMGR_R_EINVAL, "installer_path fail");
1043
1044         strncpy(args, argv[0], len - 1);
1045
1046         for (i = 1; i < argcnt; i++) {
1047                 strncat(args, " ", strlen(" "));
1048                 temp = g_shell_quote(argv[i]);
1049                 strncat(args, temp, strlen(temp));
1050                 g_free(temp);
1051         }
1052         DBG("[args] %s [len] %d\n", args, len);
1053
1054         /* request */
1055         ret = comm_client_request(mpc->info.request.cc, "getsize",
1056                         g_variant_new("(ssss)", req_key, pkgtype, pkgid, args));
1057         if (ret < 0)
1058                 ERR("COMM_REQ_GET_SIZE failed, ret=%d\n", ret);
1059
1060 catch:
1061         for (i = 0; i < argcnt; i++)
1062                 free(argv[i]);
1063
1064         if(args)
1065                 free(args);
1066
1067         return ret;
1068 }
1069
1070 static int __get_pkg_size_info_cb(uid_t target_uid, int req_id, const char *req_type,
1071                 const char *pkgid, const char *key,
1072                 const char *value, const void *pc, void *user_data)
1073 {
1074         int ret = 0;
1075         DBG("target_uid: %u, reqid: %d, req type: %s, pkgid: %s, unused key: %s, size info: %s",
1076                         target_uid, req_id, req_type, pkgid, key, value);
1077
1078         pkg_size_info_t *size_info = (pkg_size_info_t *)malloc(sizeof(pkg_size_info_t));
1079         retvm_if(size_info == NULL, -1, "The memory is insufficient.");
1080
1081         char *save_ptr = NULL;
1082         char *token = strtok_r((char*)value, ":", &save_ptr);
1083         size_info->data_size = atoll(token);
1084         token = strtok_r(NULL, ":", &save_ptr);
1085         size_info->cache_size = atoll(token);
1086         token = strtok_r(NULL, ":", &save_ptr);
1087         size_info->app_size = atoll(token);
1088         token = strtok_r(NULL, ":", &save_ptr);
1089         size_info->ext_data_size = atoll(token);
1090         token = strtok_r(NULL, ":", &save_ptr);
1091         size_info->ext_cache_size = atoll(token);
1092         token = strtok_r(NULL, ":", &save_ptr);
1093         size_info->ext_app_size = atoll(token);
1094
1095         DBG("data: %lld, cache: %lld, app: %lld, ext_data: %lld, ext_cache: %lld, ext_app: %lld",
1096                         size_info->data_size, size_info->cache_size, size_info->app_size,
1097                         size_info->ext_data_size, size_info->ext_cache_size, size_info->ext_app_size);
1098
1099         pkgmgr_client_t *pmc = (pkgmgr_client_t *)pc;
1100         tryvm_if(pmc == NULL, ret = -1, "pkgmgr_client instance is null.");
1101
1102         if (strcmp(pkgid, PKG_SIZE_INFO_TOTAL) == 0)
1103         {       // total package size info
1104                 pkgmgr_total_pkg_size_info_receive_cb callback = (pkgmgr_total_pkg_size_info_receive_cb)(pmc->new_event_cb);
1105                 callback((pkgmgr_client *)pc, size_info, user_data);
1106         }
1107         else
1108         {
1109                 pkgmgr_pkg_size_info_receive_cb callback = (pkgmgr_pkg_size_info_receive_cb)(pmc->new_event_cb);
1110                 callback((pkgmgr_client *)pc, pkgid, size_info, user_data);
1111         }
1112
1113 catch:
1114
1115         if(size_info){
1116                 free(size_info);
1117                 size_info = NULL;
1118         }
1119         return ret;
1120 }
1121
1122 API pkgmgr_client *pkgmgr_client_new(client_type ctype)
1123 {
1124         pkgmgr_client_t *pc = NULL;
1125         int ret = -1;
1126
1127         retvm_if(ctype != PC_REQUEST && ctype != PC_LISTENING && ctype != PC_BROADCAST, NULL, "ctype is not client_type");
1128
1129         /* Allocate memory for ADT:pkgmgr_client */
1130         pc = calloc(1, sizeof(pkgmgr_client_t));
1131         retvm_if(pc == NULL, NULL, "No memory");
1132
1133         /* Manage pc */
1134         pc->ctype = ctype;
1135         pc->status_type = PKGMGR_CLIENT_STATUS_ALL;
1136
1137         if (pc->ctype == PC_REQUEST) {
1138                 pc->info.request.cc = comm_client_new();
1139                 trym_if(pc->info.request.cc == NULL, "client creation failed");
1140
1141                 ret = comm_client_set_status_callback(COMM_STATUS_BROADCAST_ALL, pc->info.request.cc, __operation_callback, pc);
1142                 trym_if(ret < 0L, "comm_client_set_status_callback() failed - %d", ret);
1143         } else if (pc->ctype == PC_LISTENING) {
1144                 pc->info.listening.cc = comm_client_new();
1145                 trym_if(pc->info.listening.cc == NULL, "client creation failed");
1146
1147                 ret = comm_client_set_status_callback(COMM_STATUS_BROADCAST_ALL, pc->info.listening.cc, __status_callback, pc);
1148                 trym_if(ret < 0L, "comm_client_set_status_callback() failed - %d", ret);
1149         } else if (pc->ctype == PC_BROADCAST) {
1150                 /* client cannot broadcast signal */
1151                 return NULL;
1152         }
1153
1154         return (pkgmgr_client *) pc;
1155
1156  catch:
1157         if (pc)
1158                 free(pc);
1159         return NULL;
1160 }
1161
1162 API int pkgmgr_client_free(pkgmgr_client *pc)
1163 {
1164         int ret = -1;
1165         pkgmgr_client_t *mpc = (pkgmgr_client_t *) pc;
1166         retvm_if(mpc == NULL, PKGMGR_R_EINVAL, "Invalid argument");
1167
1168         if (mpc->ctype == PC_REQUEST) {
1169                 req_cb_info *tmp;
1170                 req_cb_info *prev;
1171                 for (tmp = mpc->info.request.rhead; tmp;) {
1172                         prev = tmp;
1173                         tmp = tmp->next;
1174                         free(prev);
1175                 }
1176
1177                 ret = comm_client_free(mpc->info.request.cc);
1178                 tryvm_if(ret < 0, ret = PKGMGR_R_ERROR, "comm_client_free() failed");
1179         } else if (mpc->ctype == PC_LISTENING) {
1180                         listen_cb_info *tmp;
1181                         listen_cb_info *prev;
1182                         for (tmp = mpc->info.listening.lhead; tmp;) {
1183                                 prev = tmp;
1184                                 tmp = tmp->next;
1185                                 free(prev);
1186                         }
1187
1188                         ret = comm_client_free(mpc->info.listening.cc);
1189                         tryvm_if(ret < 0, ret = PKGMGR_R_ERROR, "comm_client_free() failed");
1190         } else if (mpc->ctype == PC_BROADCAST) {
1191                 ret = 0;
1192         } else {
1193                 ERR("Invalid client type\n");
1194                 return PKGMGR_R_EINVAL;
1195         }
1196
1197         free(mpc);
1198         mpc = NULL;
1199         return PKGMGR_R_OK;
1200
1201  catch:
1202         if (mpc) {
1203                 free(mpc);
1204                 mpc = NULL;
1205         }
1206         return PKGMGR_R_ERROR;
1207 }
1208
1209
1210 API int pkgmgr_client_usr_install(pkgmgr_client * pc, const char *pkg_type,
1211                               const char *descriptor_path, const char *pkg_path,
1212                               const char *optional_file, pkgmgr_mode mode,
1213                               pkgmgr_handler event_cb, void *data, uid_t uid)
1214 {
1215         char *pkgtype = NULL;
1216         char *installer_path = NULL;
1217         char *req_key = NULL;
1218         int req_id = 0;
1219         int i = 0;
1220         char *argv[PKG_ARGC_MAX] = { NULL, };
1221         char *args = NULL;
1222         int argcnt = 0;
1223         int len = 0;
1224         char *temp = NULL;
1225         int ret = 0;
1226         char *caller_pkgid = NULL;
1227
1228         caller_pkgid = __get_caller_pkgid(uid);
1229         if (caller_pkgid == NULL)
1230                 ERR("caller dont have pkgid..\n");
1231
1232         /* Check for NULL value of pc */
1233         retvm_if(pc == NULL, PKGMGR_R_EINVAL, "package manager client handle is NULL");
1234
1235         /* 0. check the pc type */
1236         pkgmgr_client_t *mpc = (pkgmgr_client_t *) pc;
1237         retvm_if(mpc->ctype != PC_REQUEST, PKGMGR_R_EINVAL, "mpc->ctype is not PC_REQUEST");
1238
1239         /* 1. check argument */
1240         if (descriptor_path) {
1241                 retvm_if(strlen(descriptor_path) >= PKG_STRING_LEN_MAX, PKGMGR_R_EINVAL, "descriptor_path over PKG_STRING_LEN_MAX");
1242                 retvm_if(access(descriptor_path, F_OK) != 0, PKGMGR_R_EINVAL, "descriptor_path access fail");
1243         }
1244
1245         retvm_if(pkg_path == NULL, PKGMGR_R_EINVAL, "pkg_path is NULL");
1246         retvm_if(strlen(pkg_path) >= PKG_STRING_LEN_MAX, PKGMGR_R_EINVAL, "pkg_path over PKG_STRING_LEN_MAX");
1247         retvm_if(access(pkg_path, F_OK) != 0, PKGMGR_R_EINVAL, "pkg_path access fail");
1248
1249         if (optional_file)
1250                 retvm_if(strlen(optional_file) >= PKG_STRING_LEN_MAX, PKGMGR_R_EINVAL, "optional_file over PKG_STRING_LEN_MAX");
1251
1252         /* 2. get installer path using pkg_path */
1253         if (pkg_type) {
1254                 installer_path = _get_backend_path_with_type(pkg_type);
1255                 pkgtype = strdup(pkg_type);
1256         } else {
1257                 installer_path = _get_backend_path(pkg_path);
1258                 pkgtype = __get_type_from_path(pkg_path);
1259         }
1260         if (installer_path == NULL) {
1261                 free(pkgtype);
1262                 ERR("installer_path is NULL\n");
1263                 return PKGMGR_R_EINVAL;
1264         }
1265
1266         /* 3. generate req_key */
1267         req_key = __get_req_key(pkg_path);
1268
1269         /* 4. add callback info - add callback info to pkgmgr_client */
1270         req_id = _get_request_id();
1271         __add_op_cbinfo(mpc, req_id, req_key, event_cb, NULL, data);
1272
1273         /* 5. generate argv */
1274
1275         /*  argv[0] installer path */
1276         argv[argcnt++] = installer_path;
1277         /* argv[1] */
1278         argv[argcnt++] = strdup("-k");
1279         /* argv[2] */
1280         argv[argcnt++] = req_key;
1281         /* argv[3] */
1282         argv[argcnt++] = strdup("-i");
1283         /* argv[(4)] if exists */
1284         if (descriptor_path)
1285                 argv[argcnt++] = strdup(descriptor_path);
1286         /* argv[4] */
1287         argv[argcnt++] = strdup(pkg_path);
1288         /* argv[(5)] if exists */
1289         if (optional_file){
1290                 argv[argcnt++] = strdup("-o");
1291                 argv[argcnt++] = strdup(optional_file);
1292         }
1293         if (caller_pkgid) {
1294                 argv[argcnt++] = strdup("-p");
1295                 argv[argcnt++] = strdup(caller_pkgid);
1296         }
1297
1298         /*** add quote in all string for special charactor like '\n'***   FIX */
1299         for (i = 0; i < argcnt; i++) {
1300                 temp = g_shell_quote(argv[i]);
1301                 len += (strlen(temp) + 1);
1302                 g_free(temp);
1303         }
1304
1305         args = (char *)calloc(len, sizeof(char));
1306         tryvm_if(args == NULL, ret = PKGMGR_R_ERROR, "calloc failed");
1307
1308         strncpy(args, argv[0], len - 1);
1309
1310         for (i = 1; i < argcnt; i++) {
1311                 strncat(args, " ", strlen(" "));
1312                 temp = g_shell_quote(argv[i]);
1313                 strncat(args, temp, strlen(temp));
1314                 g_free(temp);
1315         }
1316         DBG("[args] %s [len] %d\n", args, len);
1317
1318         /******************* end of quote ************************/
1319
1320         /* 6. request install */
1321         ret = comm_client_request(mpc->info.request.cc, "install",
1322                         g_variant_new("(ssss)", req_key, pkgtype, pkg_path, args));
1323         tryvm_if(ret < 0, ret = PKGMGR_R_ECOMM, "request failed, ret=%d", ret);
1324
1325         ret = req_id;
1326
1327 catch:
1328         for (i = 0; i < argcnt; i++)
1329                 free(argv[i]);
1330
1331         if (args)
1332                 free(args);
1333         if (pkgtype)
1334                 free(pkgtype);
1335
1336         return ret;
1337 }
1338
1339
1340
1341 API int pkgmgr_client_install(pkgmgr_client * pc, const char *pkg_type,
1342                               const char *descriptor_path, const char *pkg_path,
1343                               const char *optional_file, pkgmgr_mode mode,
1344                               pkgmgr_handler event_cb, void *data)
1345 {
1346
1347
1348         return pkgmgr_client_usr_install(pc, pkg_type,
1349                               descriptor_path, pkg_path, optional_file, mode, event_cb,data,  GLOBAL_USER);
1350 }
1351
1352 API int pkgmgr_client_reinstall(pkgmgr_client * pc, const char *pkg_type, const char *pkgid,
1353                                   const char *optional_file, pkgmgr_mode mode,
1354                               pkgmgr_handler event_cb, void *data)
1355 {
1356         return pkgmgr_client_usr_reinstall(pc, pkg_type, pkgid, optional_file, mode, event_cb, data,GLOBAL_USER);
1357 }
1358
1359 API int pkgmgr_client_usr_reinstall(pkgmgr_client * pc, const char *pkg_type, const char *pkgid,
1360                                   const char *optional_file, pkgmgr_mode mode,
1361                               pkgmgr_handler event_cb, void *data, uid_t uid)
1362 {
1363         char *pkgtype = NULL;
1364         char *installer_path = NULL;
1365         char *req_key = NULL;
1366         int req_id = 0;
1367         int i = 0;
1368         char *argv[PKG_ARGC_MAX] = { NULL, };
1369         char *args = NULL;
1370         int argcnt = 0;
1371         int len = 0;
1372         char *temp = NULL;
1373         int ret = 0;
1374
1375         /* Check for NULL value of pc */
1376         retvm_if(pc == NULL, PKGMGR_R_EINVAL, "package manager client handle is NULL\n");
1377
1378         pkgmgr_client_t *mpc = (pkgmgr_client_t *) pc;
1379
1380         /* 0. check the pc type */
1381         retv_if(mpc->ctype != PC_REQUEST, PKGMGR_R_EINVAL);
1382
1383
1384         /* 1. check argument */
1385         retv_if(pkgid == NULL, PKGMGR_R_EINVAL);
1386         retv_if(strlen(pkgid) >= PKG_STRING_LEN_MAX, PKGMGR_R_EINVAL);
1387         if (optional_file) {
1388                 if (strlen(optional_file) >= PKG_STRING_LEN_MAX)
1389                         return PKGMGR_R_EINVAL;
1390         }
1391
1392         /* 2. get installer path using pkg_path */
1393         installer_path = _get_backend_path_with_type(pkg_type);
1394         pkgtype = strdup(pkg_type);
1395         tryvm_if(installer_path == NULL, ret = PKGMGR_R_EINVAL, "installer_path is null");
1396
1397         /* 3. generate req_key */
1398         req_key = __get_req_key(pkgid);
1399
1400         /* 4. add callback info - add callback info to pkgmgr_client */
1401         req_id = _get_request_id();
1402         __add_op_cbinfo(mpc, req_id, req_key, event_cb, NULL, data);
1403
1404         /* 5. generate argv */
1405
1406         /*  argv[0] installer path */
1407         argv[argcnt++] = installer_path;
1408         /* argv[1] */
1409         argv[argcnt++] = strdup("-k");
1410         /* argv[2] */
1411         argv[argcnt++] = req_key;
1412         /* argv[3] */
1413         argv[argcnt++] = strdup("-r");
1414         /* argv[4] */
1415         argv[argcnt++] = strdup(pkgid);
1416         /* argv[(5)] if exists */
1417         if (optional_file){
1418                 argv[argcnt++] = strdup("-o");
1419                 argv[argcnt++] = strdup(optional_file);
1420         }
1421
1422         /*** add quote in all string for special charactor like '\n'***   FIX */
1423         for (i = 0; i < argcnt; i++) {
1424                 temp = g_shell_quote(argv[i]);
1425                 len += (strlen(temp) + 1);
1426                 g_free(temp);
1427         }
1428
1429         args = (char *)calloc(len, sizeof(char));
1430         tryvm_if(args == NULL, ret = PKGMGR_R_ERROR, "calloc failed");
1431
1432         strncpy(args, argv[0], len - 1);
1433
1434         for (i = 1; i < argcnt; i++) {
1435                 strncat(args, " ", strlen(" "));
1436                 temp = g_shell_quote(argv[i]);
1437                 strncat(args, temp, strlen(temp));
1438                 g_free(temp);
1439         }
1440         DBG("[args] %s [len] %d\n", args, len);
1441
1442         /******************* end of quote ************************/
1443
1444         /* 6. request install */
1445         ret = comm_client_request(mpc->info.request.cc, "reinstall",
1446                         g_variant_new("(ssss)", req_key, pkgtype, pkgid, args));
1447         tryvm_if(ret < 0, ret = PKGMGR_R_ECOMM, "request failed");
1448
1449         ret = req_id;
1450
1451 catch:
1452         for (i = 0; i < argcnt; i++)
1453                 free(argv[i]);
1454
1455         if (args)
1456                 free(args);
1457         if (pkgtype)
1458                 free(pkgtype);
1459
1460         return ret;
1461 }
1462
1463 API int pkgmgr_client_uninstall(pkgmgr_client *pc, const char *pkg_type,
1464                                 const char *pkgid, pkgmgr_mode mode,
1465                                 pkgmgr_handler event_cb, void *data)
1466 {
1467         return pkgmgr_client_usr_uninstall(pc, pkg_type,pkgid, mode, event_cb,  data, GLOBAL_USER);
1468 }
1469 API int pkgmgr_client_usr_uninstall(pkgmgr_client *pc, const char *pkg_type,
1470                                 const char *pkgid, pkgmgr_mode mode,
1471                                 pkgmgr_handler event_cb, void *data, uid_t uid)
1472 {
1473         char *pkgtype;
1474         char *installer_path;
1475         char *req_key;
1476         int req_id;
1477         int i = 0;
1478         char *argv[PKG_ARGC_MAX] = { NULL, };
1479         char *args = NULL;
1480         int argcnt = 0;
1481         int len = 0;
1482         char *temp = NULL;
1483         int ret = -1;
1484         bool removable = false;
1485         char *caller_pkgid = NULL;
1486
1487         caller_pkgid = __get_caller_pkgid(uid);
1488         if (caller_pkgid == NULL)
1489                 DBG("caller dont have pkgid..\n");
1490
1491         /* Check for NULL value of pc */
1492         retvm_if(pc == NULL, PKGMGR_R_EINVAL, "package manager client handle is NULL\n");
1493
1494         pkgmgr_client_t *mpc = (pkgmgr_client_t *) pc;
1495
1496         /* 0. check the pc type */
1497         retv_if(mpc->ctype != PC_REQUEST, PKGMGR_R_EINVAL);
1498
1499         /* 1. check argument */
1500         retv_if(pkgid == NULL, PKGMGR_R_EINVAL);
1501
1502         pkgmgrinfo_pkginfo_h handle = NULL;
1503         ret = pkgmgrinfo_pkginfo_get_usr_pkginfo(pkgid, uid, &handle);
1504
1505         /*check package id      */
1506         tryvm_if(ret < 0, ret = PKGMGR_R_EINVAL, "pkgmgrinfo_pkginfo_get_pkginfo fail");
1507         tryvm_if(handle == NULL, ret = PKGMGR_R_EINVAL, "Pkgid(%s) can not find in installed pkg DB! \n", pkgid);
1508
1509         /*check type    */
1510         ret = pkgmgrinfo_pkginfo_get_type(handle, &pkgtype);
1511         tryvm_if(ret < 0, ret = PKGMGR_R_EINVAL, "pkgmgrinfo_pkginfo_get_type fail");
1512         tryvm_if(pkgtype == NULL, ret = PKGMGR_R_ERROR, "pkgtype is NULL");
1513
1514         /*check removable, execpt "rpm" type    */
1515         if (strcmp(pkgtype, "rpm")) {
1516                 pkgmgrinfo_pkginfo_is_removable(handle, &removable);
1517                 tryvm_if(removable == false, ret = PKGMGR_R_ERROR, "Pkgid(%s) can not be removed, This is non-removalbe package...\n", pkgid);
1518         }
1519
1520         /*check pkgid length    */
1521         tryvm_if(strlen(pkgid) >= PKG_STRING_LEN_MAX, ret = PKGMGR_R_EINVAL, "pkgid is too long");
1522
1523         /* 2. get installer path using pkgtype */
1524         installer_path = _get_backend_path_with_type(pkgtype);
1525         tryvm_if(installer_path == NULL, ret = PKGMGR_R_EINVAL, "installer_path fail");
1526
1527         /* 3. generate req_key */
1528         req_key = __get_req_key(pkgid);
1529
1530         /* 4. add callback info - add callback info to pkgmgr_client */
1531         req_id = _get_request_id();
1532         __add_op_cbinfo(mpc, req_id, req_key, event_cb, NULL, data);
1533
1534         /* 5. generate argv */
1535
1536         /* argv[0] installer path */
1537         argv[argcnt++] = installer_path;
1538         /* argv[1] */
1539         argv[argcnt++] = strdup("-k");
1540         /* argv[2] */
1541         argv[argcnt++] = req_key;
1542         /* argv[3] */
1543         argv[argcnt++] = strdup("-d");
1544         /* argv[4] */
1545         argv[argcnt++] = strdup(pkgid);
1546         if (caller_pkgid) {
1547                 argv[argcnt++] = strdup("-p");
1548                 argv[argcnt++] = caller_pkgid;
1549         }
1550
1551         /*** add quote in all string for special charactor like '\n'***   FIX */
1552         for (i = 0; i < argcnt; i++) {
1553                 temp = g_shell_quote(argv[i]);
1554                 len += (strlen(temp) + 1);
1555                 g_free(temp);
1556         }
1557
1558         args = (char *)calloc(len, sizeof(char));
1559         tryvm_if(args == NULL, ret = PKGMGR_R_ERROR, "calloc failed");
1560
1561         strncpy(args, argv[0], len - 1);
1562
1563         for (i = 1; i < argcnt; i++) {
1564                 strncat(args, " ", strlen(" "));
1565                 temp = g_shell_quote(argv[i]);
1566                 strncat(args, temp, strlen(temp));
1567                 g_free(temp);
1568         }
1569         DBG("[args] %s [len] %d\n", args, len);
1570
1571         /******************* end of quote ************************/
1572
1573         /* 6. request install */
1574         ret = comm_client_request(mpc->info.request.cc, "uninstall",
1575                         g_variant_new("(ssss)", req_key, pkgtype, pkgid, args));
1576         tryvm_if(ret < 0, ret = PKGMGR_R_ECOMM, "calloc failed");
1577
1578         ret = req_id;
1579
1580 catch:
1581         for (i = 0; i < argcnt; i++)
1582                 free(argv[i]);
1583
1584         if(args)
1585                 free(args);
1586
1587         if (handle)
1588                 pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
1589         return ret;
1590 }
1591
1592 API int pkgmgr_client_move(pkgmgr_client *pc, const char *pkg_type,
1593                                 const char *pkgid, pkgmgr_move_type move_type, pkgmgr_mode mode)
1594 {
1595         return pkgmgr_client_usr_move( pc,pkg_type, pkgid, move_type, mode, GLOBAL_USER);
1596 }
1597 API int pkgmgr_client_usr_move(pkgmgr_client *pc, const char *pkg_type,
1598                                 const char *pkgid, pkgmgr_move_type move_type, pkgmgr_mode mode, uid_t uid)
1599 {
1600         const char *pkgtype = NULL;
1601         char *installer_path = NULL;
1602         char *req_key = NULL;
1603         int i = 0;
1604         char *argv[PKG_ARGC_MAX] = { NULL, };
1605         char *args = NULL;
1606         int argcnt = 0;
1607         int len = 0;
1608         char *temp = NULL;
1609         int ret = 0;
1610         int req_id = 0;
1611         char buf[128] = {'\0'};
1612
1613         /* Check for NULL value of pc */
1614         if (pc == NULL) {
1615                 DBG("package manager client handle is NULL\n");
1616                 return PKGMGR_R_EINVAL;
1617         }
1618         pkgmgr_client_t *mpc = (pkgmgr_client_t *) pc;
1619         /*check the pc type */
1620         if (mpc->ctype != PC_REQUEST)
1621                 return PKGMGR_R_EINVAL;
1622
1623         /*check argument */
1624         if (pkgid == NULL)
1625                 return PKGMGR_R_EINVAL;
1626
1627         if (pkg_type == NULL) {
1628                 pkgtype = _get_pkg_type(pkgid, uid);
1629                 if (pkgtype == NULL)
1630                         return PKGMGR_R_EINVAL;
1631         } else
1632                 pkgtype = pkg_type;
1633
1634         if (strlen(pkgid) >= PKG_STRING_LEN_MAX)
1635                 return PKGMGR_R_EINVAL;
1636
1637         if ((move_type < PM_MOVE_TO_INTERNAL) || (move_type > PM_MOVE_TO_SDCARD))
1638                 return PKGMGR_R_EINVAL;
1639
1640         /* get installer path using pkg_path */
1641         installer_path = _get_backend_path_with_type(pkgtype);
1642         if (installer_path == NULL)
1643                 return PKGMGR_R_EINVAL;
1644
1645         /* generate req_key */
1646         req_key = __get_req_key(pkgid);
1647         req_id = _get_request_id();
1648
1649         /* generate argv */
1650         snprintf(buf, 128, "%d", move_type);
1651         /* argv[0] installer path */
1652         argv[argcnt++] = installer_path;
1653         /* argv[1] */
1654         argv[argcnt++] = strdup("-k");
1655         /* argv[2] */
1656         argv[argcnt++] = req_key;
1657         /* argv[3] */
1658         argv[argcnt++] = strdup("-m");
1659         /* argv[4] */
1660         argv[argcnt++] = strdup(pkgid);
1661         /* argv[5] */
1662         argv[argcnt++] = strdup("-t");
1663         /* argv[6] */
1664         argv[argcnt++] = strdup(buf);
1665
1666         /*** add quote in all string for special charactor like '\n'***   FIX */
1667         for (i = 0; i < argcnt; i++) {
1668                 temp = g_shell_quote(argv[i]);
1669                 len += (strlen(temp) + 1);
1670                 g_free(temp);
1671         }
1672
1673         args = (char *)calloc(len, sizeof(char));
1674         if (args == NULL) {
1675                 DBG("calloc failed");
1676
1677                 for (i = 0; i < argcnt; i++)
1678                         free(argv[i]);
1679
1680                 return PKGMGR_R_ERROR;
1681         }
1682         strncpy(args, argv[0], len - 1);
1683
1684         for (i = 1; i < argcnt; i++) {
1685                 strncat(args, " ", strlen(" "));
1686                 temp = g_shell_quote(argv[i]);
1687                 strncat(args, temp, strlen(temp));
1688                 g_free(temp);
1689         }
1690         DBG("[args] %s [len] %d\n", args, len);
1691         /******************* end of quote ************************/
1692
1693         /* 6. request install */
1694         ret = comm_client_request(mpc->info.request.cc, "move",
1695                         g_variant_new("(ssss)", req_key, pkgtype, pkgid, args));
1696         if (ret < 0) {
1697                 ERR("request failed, ret=%d\n", ret);
1698
1699                 for (i = 0; i < argcnt; i++)
1700                         free(argv[i]);
1701
1702                 free(args);
1703                 return PKGMGR_R_ECOMM;
1704         }
1705
1706         for (i = 0; i < argcnt; i++)
1707                 free(argv[i]);
1708
1709         if (args)
1710                 free(args);
1711
1712         return req_id;
1713 }
1714
1715 API int pkgmgr_client_move_usr_pkg(pkgmgr_client *pc, const char *pkg_type,
1716                                 const char *pkgid, uid_t uid, pkgmgr_move_type move_type, pkgmgr_mode mode,
1717                                 pkgmgr_handler event_cb, void *data)
1718 {
1719         char *pkgtype;
1720         char *installer_path;
1721         char *req_key;
1722         int req_id;
1723         int i = 0;
1724         char *argv[PKG_ARGC_MAX] = { NULL, };
1725         char *args = NULL;
1726         int argcnt = 0;
1727         int len = 0;
1728         char *temp = NULL;
1729         int ret = -1;
1730         char buf[128] = {'\0'};
1731
1732         /* Check for NULL value of pc */
1733         retvm_if(pc == NULL, PKGMGR_R_EINVAL, "package manager client handle is NULL\n");
1734
1735         pkgmgr_client_t *mpc = (pkgmgr_client_t *) pc;
1736
1737         /* 0. check the pc type */
1738         retv_if(mpc->ctype != PC_REQUEST, PKGMGR_R_EINVAL);
1739
1740         /* 1. check argument */
1741         retv_if(pkgid == NULL, PKGMGR_R_EINVAL);
1742
1743         pkgmgrinfo_pkginfo_h handle = NULL;
1744   if (uid != GLOBAL_USER)
1745           ret = pkgmgrinfo_pkginfo_get_usr_pkginfo(pkgid, uid, &handle);
1746   else
1747           ret = pkgmgrinfo_pkginfo_get_pkginfo(pkgid, &handle);
1748
1749         /*check package id      */
1750         tryvm_if(ret < 0, ret = PKGMGR_R_EINVAL, "pkgmgrinfo_pkginfo_get_pkginfo fail");
1751         tryvm_if(handle == NULL, ret = PKGMGR_R_EINVAL, "Pkgid(%s) can not find in installed pkg DB! \n", pkgid);
1752
1753         /*check type    */
1754         ret = pkgmgrinfo_pkginfo_get_type(handle, &pkgtype);
1755         tryvm_if(ret < 0, ret = PKGMGR_R_EINVAL, "pkgmgrinfo_pkginfo_get_type fail");
1756         tryvm_if(pkgtype == NULL, ret = PKGMGR_R_ERROR, "pkgtype is NULL");
1757
1758         /*check pkgid length    */
1759         tryvm_if(strlen(pkgid) >= PKG_STRING_LEN_MAX, ret = PKGMGR_R_EINVAL, "pkgid is too long");
1760
1761         /*check move_type       */
1762         tryvm_if((move_type < PM_MOVE_TO_INTERNAL) || (move_type > PM_MOVE_TO_SDCARD), ret = PKGMGR_R_EINVAL, "move_type is not supported");
1763
1764         /* 2. get installer path using pkgtype */
1765         installer_path = _get_backend_path_with_type(pkgtype);
1766         tryvm_if(installer_path == NULL, ret = PKGMGR_R_EINVAL, "installer_path fail");
1767
1768         /* 3. generate req_key */
1769         req_key = __get_req_key(pkgid);
1770
1771         /* 4. add callback info - add callback info to pkgmgr_client */
1772         req_id = _get_request_id();
1773         __add_op_cbinfo(mpc, req_id, req_key, event_cb, NULL, data);
1774
1775         /* 5. generate argv */
1776         snprintf(buf, 128, "%d", move_type);
1777         /* argv[0] installer path */
1778         argv[argcnt++] = installer_path;
1779         /* argv[1] */
1780         argv[argcnt++] = strdup("-k");
1781         /* argv[2] */
1782         argv[argcnt++] = req_key;
1783         /* argv[3] */
1784         argv[argcnt++] = strdup("-m");
1785         /* argv[4] */
1786         argv[argcnt++] = strdup(pkgid);
1787         /* argv[5] */
1788         argv[argcnt++] = strdup("-t");
1789         /* argv[6] */
1790         argv[argcnt++] = strdup(buf);
1791
1792         /*** add quote in all string for special charactor like '\n'***   FIX */
1793         for (i = 0; i < argcnt; i++) {
1794                 temp = g_shell_quote(argv[i]);
1795                 len += (strlen(temp) + 1);
1796                 g_free(temp);
1797         }
1798
1799         args = (char *)calloc(len, sizeof(char));
1800         tryvm_if(args == NULL, ret = PKGMGR_R_ERROR, "calloc failed");
1801
1802         strncpy(args, argv[0], len - 1);
1803
1804         for (i = 1; i < argcnt; i++) {
1805                 strncat(args, " ", strlen(" "));
1806                 temp = g_shell_quote(argv[i]);
1807                 strncat(args, temp, strlen(temp));
1808                 g_free(temp);
1809         }
1810         DBG("[args] %s [len] %d\n", args, len);
1811
1812         /******************* end of quote ************************/
1813
1814         /* 6. request install */
1815         ret = comm_client_request(mpc->info.request.cc, "move",
1816                         g_variant_new("(ssss)", req_key, pkgtype, pkgid, args));
1817         tryvm_if(ret < 0, ret = PKGMGR_R_ECOMM, "calloc failed");
1818
1819         ret = req_id;
1820
1821 catch:
1822         for (i = 0; i < argcnt; i++)
1823                 free(argv[i]);
1824
1825         if(args)
1826                 free(args);
1827
1828         if (handle)
1829                 pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
1830         return ret;
1831 }
1832
1833 API int pkgmgr_client_move_pkg(pkgmgr_client *pc, const char *pkg_type,
1834                                 const char *pkgid, pkgmgr_move_type move_type, pkgmgr_mode mode,
1835                                 pkgmgr_handler event_cb, void *data)
1836 {
1837         return pkgmgr_client_move_usr_pkg(pc, pkg_type, pkgid, GLOBAL_USER, move_type, mode, event_cb, data);
1838 }
1839
1840 API int pkgmgr_client_usr_activate(pkgmgr_client * pc, const char *pkg_type,
1841                                const char *pkgid, uid_t uid)
1842 {
1843         const char *pkgtype;
1844         char *req_key;
1845         int ret;
1846         /* Check for NULL value of pc */
1847         retvm_if(pc == NULL, PKGMGR_R_EINVAL, "package manager client handle is NULL\n");
1848
1849         pkgmgr_client_t *mpc = (pkgmgr_client_t *) pc;
1850
1851         /* 0. check the pc type */
1852         retvm_if(mpc->ctype != PC_REQUEST, PKGMGR_R_EINVAL, "mpc->ctype is not PC_REQUEST");
1853
1854         /* 1. check argument */
1855         retvm_if(pkgid == NULL, PKGMGR_R_EINVAL, "pkgid is NULL");
1856         retvm_if(strlen(pkgid) >= PKG_STRING_LEN_MAX, PKGMGR_R_EINVAL, "pkgid length over PKG_STRING_LEN_MAX ");
1857
1858         if (pkg_type == NULL) {
1859                 pkgtype = _get_pkg_type(pkgid, uid);
1860                 retvm_if(pkgtype == NULL, PKGMGR_R_EINVAL, "pkgtype is NULL");
1861         } else
1862                 pkgtype = pkg_type;
1863
1864         /* 2. generate req_key */
1865         req_key = __get_req_key(pkgid);
1866         retvm_if(req_key == NULL, PKGMGR_R_EINVAL, "req_key is NULL");
1867
1868         /* 3. request activate */
1869         ret = comm_client_request(mpc->info.request.cc, "activate",
1870                         g_variant_new("(ssss)", req_key, pkgtype, pkgid, "1 PKG"));
1871         tryvm_if(ret < 0, ret = PKGMGR_R_ECOMM, "request failed, ret=%d", ret);
1872
1873         ret = PKGMGR_R_OK;
1874
1875 catch:
1876         free(req_key);
1877         return ret;
1878 }
1879
1880 API int pkgmgr_client_activate(pkgmgr_client * pc, const char *pkg_type,
1881                                const char *pkgid)
1882 {
1883         return pkgmgr_client_usr_activate(pc, pkg_type, pkgid, GLOBAL_USER);
1884 }
1885
1886 API int pkgmgr_client_usr_deactivate(pkgmgr_client *pc, const char *pkg_type,
1887                                  const char *pkgid, uid_t uid)
1888 {
1889         const char *pkgtype;
1890         char *req_key;
1891         int ret;
1892         /* Check for NULL value of pc */
1893         retvm_if(pc == NULL, PKGMGR_R_EINVAL, "package manager client handle is NULL\n");
1894
1895         pkgmgr_client_t *mpc = (pkgmgr_client_t *) pc;
1896
1897         /* 0. check the pc type */
1898         retvm_if(mpc->ctype != PC_REQUEST, PKGMGR_R_EINVAL, "mpc->ctype is not PC_REQUEST");
1899
1900         /* 1. check argument */
1901         retvm_if(pkgid == NULL, PKGMGR_R_EINVAL, "pkgid is NULL");
1902         retvm_if(strlen(pkgid) >= PKG_STRING_LEN_MAX, PKGMGR_R_EINVAL, "pkgid length over PKG_STRING_LEN_MAX ");
1903
1904         if (pkg_type == NULL) {
1905                 pkgtype = _get_pkg_type(pkgid, uid);
1906                 if (pkgtype == NULL)
1907                         return PKGMGR_R_EINVAL;
1908         } else
1909                 pkgtype = pkg_type;
1910
1911         /* 2. generate req_key */
1912         req_key = __get_req_key(pkgid);
1913         retvm_if(req_key == NULL, PKGMGR_R_EINVAL, "req_key is NULL");
1914
1915         /* 3. request activate */
1916         ret = comm_client_request(mpc->info.request.cc, "deactivate",
1917                         g_variant_new("(ssss)", req_key, pkgtype, pkgid, "0 PKG"));
1918         tryvm_if(ret < 0, ret = PKGMGR_R_ECOMM, "request failed, ret=%d", ret);
1919
1920         ret = PKGMGR_R_OK;
1921
1922 catch:
1923         free(req_key);
1924         return ret;
1925 }
1926
1927 API int pkgmgr_client_deactivate(pkgmgr_client *pc, const char *pkg_type,
1928                                  const char *pkgid)
1929 {
1930         return pkgmgr_client_usr_deactivate(pc, pkg_type, pkgid, GLOBAL_USER);
1931 }
1932
1933 API int pkgmgr_client_usr_activate_app(pkgmgr_client * pc, const char *appid, uid_t uid)
1934 {
1935         const char *pkgtype;
1936         char *req_key;
1937         int ret;
1938         /* Check for NULL value of pc */
1939         retvm_if(pc == NULL, PKGMGR_R_EINVAL, "package manager client handle is NULL\n");
1940
1941         pkgmgr_client_t *mpc = (pkgmgr_client_t *) pc;
1942
1943         /* 0. check the pc type */
1944         retvm_if(mpc->ctype != PC_REQUEST, PKGMGR_R_EINVAL, "mpc->ctype is not PC_REQUEST");
1945
1946         /* 1. check argument */
1947         retvm_if(appid == NULL, PKGMGR_R_EINVAL, "pkgid is NULL");
1948         retvm_if(strlen(appid) >= PKG_STRING_LEN_MAX, PKGMGR_R_EINVAL, "pkgid length over PKG_STRING_LEN_MAX ");
1949
1950         pkgtype = _get_pkg_type(appid, uid);
1951         retvm_if(pkgtype == NULL, PKGMGR_R_EINVAL, "pkgtype is NULL");
1952
1953         /* 2. generate req_key */
1954         req_key = __get_req_key(appid);
1955         retvm_if(req_key == NULL, PKGMGR_R_EINVAL, "req_key is NULL");
1956
1957         /* 3. request activate */
1958         ret = comm_client_request(mpc->info.request.cc, "activate",
1959                         g_variant_new("(ssss)", req_key, pkgtype, appid, "1 APP"));
1960         tryvm_if(ret < 0, ret = PKGMGR_R_ECOMM, "request failed, ret=%d", ret);
1961
1962         ret = PKGMGR_R_OK;
1963
1964 catch:
1965         free(req_key);
1966         return ret;
1967 }
1968
1969 API int pkgmgr_client_activate_app(pkgmgr_client * pc, const char *appid)
1970 {
1971         return pkgmgr_client_usr_activate_app(pc,appid, GLOBAL_USER);
1972 }
1973
1974 API int pkgmgr_client_usr_activate_appv(pkgmgr_client * pc, const char *appid, char *const argv[], uid_t uid)
1975 {
1976         const char *pkgtype;
1977         char *req_key;
1978         int ret;
1979         int i = 0;
1980         char *temp = NULL;
1981         int len = 0;
1982         int argcnt = 0;
1983         char *args = NULL;
1984         char *argsr = NULL;
1985         /* Check for NULL value of pc */
1986         retvm_if(pc == NULL, PKGMGR_R_EINVAL, "package manager client handle is NULL\n");
1987
1988         pkgmgr_client_t *mpc = (pkgmgr_client_t *) pc;
1989
1990         /* 0. check the pc type */
1991         retvm_if(mpc->ctype != PC_REQUEST, PKGMGR_R_EINVAL, "mpc->ctype is not PC_REQUEST");
1992
1993         /* 1. check argument */
1994         retvm_if(appid == NULL, PKGMGR_R_EINVAL, "pkgid is NULL");
1995         retvm_if(strlen(appid) >= PKG_STRING_LEN_MAX, PKGMGR_R_EINVAL, "pkgid length over PKG_STRING_LEN_MAX ");
1996
1997         pkgtype = _get_pkg_type(appid, uid);
1998         retvm_if(pkgtype == NULL, PKGMGR_R_EINVAL, "pkgtype is NULL");
1999
2000         /* 2. generate req_key */
2001         req_key = __get_req_key(appid);
2002         retvm_if(req_key == NULL, PKGMGR_R_EINVAL, "req_key is NULL");
2003
2004         /*** add quote in all string for special charactor like '\n'***   FIX */
2005         if (argv) {
2006                 for (i = 0; argv[i]; i++) {
2007                         temp = g_shell_quote(argv[i]);
2008                         len += (strlen(temp) + 1);
2009                         g_free(temp);
2010                         argcnt++;
2011                 }
2012
2013                 if (argcnt) {
2014                         args = (char *)calloc(len, sizeof(char));
2015                         tryvm_if(args == NULL, ret = PKGMGR_R_ERROR, "calloc failed");
2016                         strncpy(args, argv[0], len - 1);
2017
2018                         for (i = 1; i < argcnt; i++) {
2019                                 strncat(args, " ", strlen(" "));
2020                                 temp = g_shell_quote(argv[i]);
2021                                 strncat(args, temp, strlen(temp));
2022                                 g_free(temp);
2023                         }
2024                 }
2025         }
2026
2027         argsr = (char *)calloc(strlen("1 APP")+2+len, sizeof(char));
2028         tryvm_if(argsr == NULL, ret = PKGMGR_R_ERROR, "calloc failed");
2029
2030         strncpy(argsr, "1 APP", strlen("1 APP"));
2031         if (argcnt) {
2032                 strncat(argsr, " ", strlen(" "));
2033                 strncat(argsr, args, strlen(args));
2034         }
2035
2036         DBG("argsr [%s]\n", argsr);
2037         /******************* end of quote ************************/
2038
2039         /* 3. request activate */
2040         ret = comm_client_request(mpc->info.request.cc, "activate",
2041                         g_variant_new("(ssss)", req_key, pkgtype, appid, argsr));
2042         tryvm_if(ret < 0, ret = PKGMGR_R_ECOMM, "request failed, ret=%d", ret);
2043
2044         ret = PKGMGR_R_OK;
2045
2046 catch:
2047
2048         free(req_key);
2049         free(args);
2050         free(argsr);
2051
2052         return ret;
2053 }
2054
2055 API int pkgmgr_client_activate_appv(pkgmgr_client * pc, const char *appid, char *const argv[])
2056 {
2057         return pkgmgr_client_usr_activate_appv(pc, appid,  argv, GLOBAL_USER);
2058 }
2059
2060 API int pkgmgr_client_usr_deactivate_app(pkgmgr_client *pc, const char *appid, uid_t uid)
2061 {
2062         const char *pkgtype;
2063         char *req_key;
2064         int ret;
2065         /* Check for NULL value of pc */
2066         retvm_if(pc == NULL, PKGMGR_R_EINVAL, "package manager client handle is NULL\n");
2067
2068         pkgmgr_client_t *mpc = (pkgmgr_client_t *) pc;
2069
2070         /* 0. check the pc type */
2071         retvm_if(mpc->ctype != PC_REQUEST, PKGMGR_R_EINVAL, "mpc->ctype is not PC_REQUEST");
2072
2073         /* 1. check argument */
2074         retvm_if(appid == NULL, PKGMGR_R_EINVAL, "pkgid is NULL");
2075         retvm_if(strlen(appid) >= PKG_STRING_LEN_MAX, PKGMGR_R_EINVAL, "pkgid length over PKG_STRING_LEN_MAX ");
2076
2077         pkgtype = _get_pkg_type(appid, uid);
2078         retvm_if(pkgtype == NULL, PKGMGR_R_EINVAL, "pkgtype is NULL");
2079
2080         /* 2. generate req_key */
2081         req_key = __get_req_key(appid);
2082         retvm_if(req_key == NULL, PKGMGR_R_EINVAL, "req_key is NULL");
2083
2084         /* 3. request activate */
2085         ret = comm_client_request(mpc->info.request.cc, "deactivate",
2086                         g_variant_new("(ssss)", req_key, pkgtype, appid, "0 APP"));
2087         tryvm_if(ret < 0, ret = PKGMGR_R_ECOMM, "request failed, ret=%d", ret);
2088
2089         ret = PKGMGR_R_OK;
2090
2091 catch:
2092         free(req_key);
2093         return ret;
2094 }
2095
2096 API int pkgmgr_client_deactivate_app(pkgmgr_client *pc, const char *appid)
2097 {
2098         return pkgmgr_client_usr_deactivate_app(pc, appid, GLOBAL_USER);
2099 }
2100
2101 API int pkgmgr_client_usr_clear_user_data(pkgmgr_client *pc, const char *pkg_type,
2102                                       const char *appid, pkgmgr_mode mode, uid_t uid)
2103 {
2104         const char *pkgtype;
2105         char *installer_path;
2106         char *req_key;
2107         int i = 0;
2108         char *argv[PKG_ARGC_MAX] = { NULL, };
2109         char *args = NULL;
2110         int argcnt = 0;
2111         int len = 0;
2112         char *temp = NULL;
2113         int ret;
2114
2115         /* Check for NULL value of pc */
2116         if (pc == NULL) {
2117                 DBG("package manager client handle is NULL\n");
2118                 return PKGMGR_R_EINVAL;
2119         }
2120         pkgmgr_client_t *mpc = (pkgmgr_client_t *) pc;
2121
2122         /* 0. check the pc type */
2123         if (mpc->ctype != PC_REQUEST)
2124                 return PKGMGR_R_EINVAL;
2125
2126         /* 1. check argument */
2127         if (appid == NULL)
2128                 return PKGMGR_R_EINVAL;
2129
2130
2131         if (pkg_type == NULL) {
2132                 pkgtype = _get_pkg_type(appid, uid);
2133                 if (pkgtype == NULL)
2134                         return PKGMGR_R_EINVAL;
2135         } else
2136                 pkgtype = pkg_type;
2137
2138         if (strlen(appid) >= PKG_STRING_LEN_MAX)
2139                 return PKGMGR_R_EINVAL;
2140
2141         /* 2. get installer path using pkg_path */
2142         installer_path = _get_backend_path_with_type(pkgtype);
2143         if (installer_path == NULL)
2144                 return PKGMGR_R_EINVAL;
2145
2146         /* 3. generate req_key */
2147         req_key = __get_req_key(appid);
2148
2149         /* 4. generate argv */
2150
2151         /* argv[0] installer path */
2152         argv[argcnt++] = installer_path;
2153         /* argv[1] */
2154         argv[argcnt++] = strdup("-k");
2155         /* argv[2] */
2156         argv[argcnt++] = req_key;
2157         /* argv[3] */
2158         argv[argcnt++] = strdup("-c");
2159         /* argv[4] */
2160         argv[argcnt++] = strdup(appid);
2161
2162         /*** add quote in all string for special charactor like '\n'***   FIX */
2163         for (i = 0; i < argcnt; i++) {
2164                 temp = g_shell_quote(argv[i]);
2165                 len += (strlen(temp) + 1);
2166                 g_free(temp);
2167         }
2168
2169         args = (char *)calloc(len, sizeof(char));
2170         if (args == NULL) {
2171                 DBG("calloc failed");
2172
2173                 for (i = 0; i < argcnt; i++)
2174                         free(argv[i]);
2175
2176                 return PKGMGR_R_ERROR;
2177         }
2178         strncpy(args, argv[0], len - 1);
2179
2180         for (i = 1; i < argcnt; i++) {
2181                 strncat(args, " ", strlen(" "));
2182                 temp = g_shell_quote(argv[i]);
2183                 strncat(args, temp, strlen(temp));
2184                 g_free(temp);
2185         }
2186         DBG("[args] %s [len] %d\n", args, len);
2187         /******************* end of quote ************************/
2188
2189         /* 6. request clear */
2190         ret = comm_client_request(mpc->info.request.cc, "cleardata",
2191                         g_variant_new("(ssss)", req_key, pkgtype, appid, args));
2192         if (ret < 0) {
2193                 ERR("request failed, ret=%d\n", ret);
2194
2195                 for (i = 0; i < argcnt; i++)
2196                         free(argv[i]);
2197
2198                 free(args);
2199                 return PKGMGR_R_ECOMM;
2200         }
2201
2202         for (i = 0; i < argcnt; i++)
2203                 free(argv[i]);
2204
2205         free(args);
2206
2207         return PKGMGR_R_OK;
2208 }
2209
2210 API int pkgmgr_client_clear_user_data(pkgmgr_client *pc, const char *pkg_type,
2211                                       const char *appid, pkgmgr_mode mode)
2212 {
2213         return pkgmgr_client_usr_clear_user_data(pc, pkg_type, appid,mode, GLOBAL_USER);
2214 }
2215
2216 API int pkgmgr_client_set_status_type(pkgmgr_client *pc, int status_type)
2217 {
2218         int ret = -1;
2219
2220         retvm_if(pc == NULL, PKGMGR_R_EINVAL, "package manager client pc is NULL");
2221         retvm_if(status_type == PKGMGR_CLIENT_STATUS_ALL, PKGMGR_R_OK, "status_type is PKGMGR_CLIENT_STATUS_ALL");
2222         pkgmgr_client_t *mpc = (pkgmgr_client_t *) pc;
2223
2224         /*  free listening head */
2225         listen_cb_info *tmp = NULL;
2226         listen_cb_info *prev = NULL;
2227         for (tmp = mpc->info.listening.lhead; tmp;) {
2228                 prev = tmp;
2229                 tmp = tmp->next;
2230                 free(prev);
2231         }
2232
2233         /* free dbus connection */
2234         ret = comm_client_free(mpc->info.listening.cc);
2235         retvm_if(ret < 0, PKGMGR_R_ERROR, "comm_client_free() failed - %d", ret);
2236
2237         /* Manage pc for seperated event */
2238         mpc->ctype = PC_LISTENING;
2239         mpc->status_type = status_type;
2240
2241         mpc->info.listening.cc = comm_client_new();
2242         retvm_if(mpc->info.listening.cc == NULL, PKGMGR_R_EINVAL, "client creation failed");
2243
2244         if ((mpc->status_type & PKGMGR_CLIENT_STATUS_INSTALL) == PKGMGR_CLIENT_STATUS_INSTALL) {
2245                 ret = comm_client_set_status_callback(COMM_STATUS_BROADCAST_INSTALL, mpc->info.listening.cc, __status_callback, pc);
2246                 retvm_if(ret < 0, PKGMGR_R_ECOMM, "PKGMGR_CLIENT_STATUS_INSTALL failed - %d", ret);
2247         }
2248
2249         if ((mpc->status_type & PKGMGR_CLIENT_STATUS_UNINSTALL) == PKGMGR_CLIENT_STATUS_UNINSTALL) {
2250                 ret = comm_client_set_status_callback(COMM_STATUS_BROADCAST_UNINSTALL, mpc->info.listening.cc, __status_callback, pc);
2251                 retvm_if(ret < 0, PKGMGR_R_ECOMM, "COMM_STATUS_BROADCAST_UNINSTALL failed - %d", ret);
2252         }
2253
2254         if ((mpc->status_type & PKGMGR_CLIENT_STATUS_MOVE) == PKGMGR_CLIENT_STATUS_MOVE) {
2255                 ret = comm_client_set_status_callback(COMM_STATUS_BROADCAST_MOVE, mpc->info.listening.cc, __status_callback, pc);
2256                 retvm_if(ret < 0, PKGMGR_R_ECOMM, "COMM_STATUS_BROADCAST_MOVE failed - %d", ret);
2257         }
2258
2259         if ((mpc->status_type & PKGMGR_CLIENT_STATUS_INSTALL_PROGRESS) == PKGMGR_CLIENT_STATUS_INSTALL_PROGRESS) {
2260                 ret = comm_client_set_status_callback(COMM_STATUS_BROADCAST_INSTALL_PROGRESS, mpc->info.listening.cc, __status_callback, pc);
2261                 retvm_if(ret < 0, PKGMGR_R_ECOMM, "COMM_STATUS_BROADCAST_INSTALL_PROGRESS failed - %d", ret);
2262         }
2263
2264    if ((mpc->status_type & PKGMGR_CLIENT_STATUS_UPGRADE) == PKGMGR_CLIENT_STATUS_UPGRADE) {
2265            ret = comm_client_set_status_callback(COMM_STATUS_BROADCAST_UPGRADE, mpc->info.listening.cc, __status_callback, pc);
2266            retvm_if(ret < 0, PKGMGR_R_ECOMM, "COMM_STATUS_BROADCAST_UPGRADE failed - %d", ret);
2267    }
2268
2269    return PKGMGR_R_OK;
2270 }
2271
2272 API int pkgmgr_client_listen_status(pkgmgr_client *pc, pkgmgr_handler event_cb,
2273                                     void *data)
2274 {
2275         int req_id;
2276         /* Check for NULL value of pc */
2277         retvm_if(pc == NULL, PKGMGR_R_EINVAL, "package manager client pc is NULL");
2278         pkgmgr_client_t *mpc = (pkgmgr_client_t *) pc;
2279
2280         /* 0. check input */
2281         retvm_if(mpc->ctype != PC_LISTENING, PKGMGR_R_EINVAL, "ctype is not PC_LISTENING");
2282         retvm_if(event_cb == NULL, PKGMGR_R_EINVAL, "event_cb is NULL");
2283
2284         /* 1. get id */
2285         req_id = _get_request_id();
2286
2287         /* 2. add callback info to pkgmgr_client */
2288         __add_stat_cbinfo(mpc, req_id, event_cb, data);
2289         return req_id;
2290 }
2291
2292 API int pkgmgr_client_broadcast_status(pkgmgr_client *pc, const char *pkg_type,
2293                                        const char *pkgid, const char *key,
2294                                        const char *val)
2295 {
2296         /* client cannot broadcast signal */
2297         return PKGMGR_R_OK;
2298 }
2299
2300 API int pkgmgr_client_request_service(pkgmgr_request_service_type service_type, int service_mode,
2301                                   pkgmgr_client * pc, const char *pkg_type, const char *pkgid,
2302                               const char *custom_info, pkgmgr_handler event_cb, void *data)
2303 {
2304         return pkgmgr_client_usr_request_service(service_type, service_mode, pc, pkg_type, pkgid, GLOBAL_USER, custom_info, event_cb, data);
2305 }
2306
2307 API int pkgmgr_client_usr_request_service(pkgmgr_request_service_type service_type, int service_mode,
2308                                   pkgmgr_client * pc, const char *pkg_type, const char *pkgid, uid_t uid,
2309                               const char *custom_info, pkgmgr_handler event_cb, void *data)
2310 {
2311         int ret =0;
2312
2313         /* Check for NULL value of service type */
2314         retvm_if(service_type > PM_REQUEST_MAX, PKGMGR_R_EINVAL, "service type is not defined\n");
2315         retvm_if(service_type < 0, PKGMGR_R_EINVAL, "service type is error\n");
2316
2317         switch (service_type) {
2318         case PM_REQUEST_CSC:
2319                 tryvm_if(custom_info == NULL, ret = PKGMGR_R_EINVAL, "custom_info is NULL\n");
2320                 tryvm_if(strlen(custom_info) >= PKG_STRING_LEN_MAX, ret = PKGMGR_R_EINVAL, "optional_file over PKG_STRING_LEN_MAX");
2321                 tryvm_if(data == NULL, ret = PKGMGR_R_EINVAL, "data is NULL\n");
2322
2323                 ret = __csc_process(custom_info, (char *)data);
2324                 if (ret < 0)
2325                         ERR("__csc_process fail \n");
2326                 else
2327                         ret = PKGMGR_R_OK;
2328
2329                 break;
2330
2331         case PM_REQUEST_MOVE:
2332                 tryvm_if(pkgid == NULL, ret = PKGMGR_R_EINVAL, "pkgid is NULL\n");
2333                 tryvm_if(pc == NULL, ret = PKGMGR_R_EINVAL, "pc is NULL\n");
2334                 tryvm_if((service_mode < PM_MOVE_TO_INTERNAL) || (service_mode > PM_MOVE_TO_SDCARD), ret = PKGMGR_R_EINVAL, "service_mode is wrong\n");
2335
2336                 ret = __move_pkg_process(pc, pkgid, uid, (pkgmgr_move_type)service_mode, event_cb, data);
2337                 break;
2338
2339         case PM_REQUEST_GET_SIZE:
2340                 tryvm_if(pkgid == NULL, ret = PKGMGR_R_EINVAL, "pkgid is NULL\n");
2341                 tryvm_if(pc == NULL, ret = PKGMGR_R_EINVAL, "pc is NULL\n");
2342                 tryvm_if((service_mode < PM_GET_TOTAL_SIZE) || (service_mode >= PM_GET_MAX), ret = PKGMGR_R_EINVAL, "service_mode is wrong\n");
2343
2344                 ret = __get_size_process(pc, pkgid, uid, (pkgmgr_getsize_type)service_mode, event_cb, data);
2345                 break;
2346
2347         case PM_REQUEST_KILL_APP:
2348         case PM_REQUEST_CHECK_APP:
2349                 tryvm_if(pkgid == NULL, ret = PKGMGR_R_EINVAL, "pkgid is NULL\n");
2350                 tryvm_if(pc == NULL, ret = PKGMGR_R_EINVAL, "pc is NULL\n");
2351
2352                 ret = __check_app_process(service_type, pc, pkgid, uid, data);
2353                 if (ret < 0)
2354                         ERR("__check_app_process fail \n");
2355                 else
2356                         ret = PKGMGR_R_OK;
2357
2358                 break;
2359
2360         default:
2361                 ERR("Wrong Request\n");
2362                 ret = -1;
2363                 break;
2364         }
2365
2366 catch:
2367
2368         return ret;
2369 }
2370
2371
2372 API int pkgmgr_client_usr_request_size_info(uid_t uid)
2373 {
2374         int ret = 0;
2375         pkgmgr_client *pc = NULL;
2376
2377         pc = pkgmgr_client_new(PC_REQUEST);
2378         retvm_if(pc == NULL, PKGMGR_R_EINVAL, "request pc is null\n");
2379
2380         ret = __request_size_info(pc, uid);
2381         if (ret < 0) {
2382                 ERR("__request_size_info fail \n");
2383         }
2384
2385         pkgmgr_client_free(pc);
2386         return ret;
2387 }
2388
2389 API int pkgmgr_client_request_size_info(void) // get all package size (data, total)
2390 {
2391         return pkgmgr_client_usr_request_size_info(GLOBAL_USER);
2392 }
2393
2394 API int pkgmgr_client_usr_clear_cache_dir(const char *pkgid, uid_t uid)
2395 {
2396         retvm_if(pkgid == NULL, PKGMGR_R_EINVAL, "package id is null\n");
2397
2398         int ret = 0;
2399         pkgmgr_client_t *pc = NULL;
2400         char *pkg_type = NULL;
2401         int is_type_malloced = 0;
2402
2403         pkgmgrinfo_pkginfo_h handle = NULL;
2404
2405         pc = pkgmgr_client_new(PC_REQUEST);
2406         retvm_if(pc == NULL, PKGMGR_R_ESYSTEM, "request pc is null\n");
2407
2408         if (strcmp(pkgid, PKG_CLEAR_ALL_CACHE) != 0)
2409         {
2410                 ret = pkgmgrinfo_pkginfo_get_usr_pkginfo(pkgid, uid, &handle);
2411                 tryvm_if(ret < 0, ret = PKGMGR_R_ENOPKG, "pkgmgrinfo_pkginfo_get_pkginfo failed");
2412
2413                 ret = pkgmgrinfo_pkginfo_get_type(handle, &pkg_type);
2414                 tryvm_if(ret < 0, ret = PKGMGR_R_ESYSTEM, "pkgmgrinfo_pkginfo_get_type failed");
2415         }
2416         else
2417         {
2418                 pkg_type = (char *)malloc(strlen("rpm") + 1);
2419                 strcpy(pkg_type, "rpm");
2420                 is_type_malloced = 1;
2421         }
2422
2423         ret = comm_client_request(pc->info.request.cc, "clearcache",
2424                         g_variant_new("(sss)", "reqkey", pkg_type, pkgid));
2425         tryvm_if(ret < 0, ret = PKGMGR_R_ERROR, "COMM_REQ_CLEAR_CACHE_DIR failed, ret=%d\n", ret);
2426
2427         ret = PKGMGR_R_OK;
2428 catch:
2429         if (pc)
2430                 pkgmgr_client_free(pc);
2431
2432         if(is_type_malloced)
2433                 free(pkg_type);
2434
2435         pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
2436
2437         return ret;
2438 }
2439
2440 API int pkgmgr_client_clear_cache_dir(const char *pkgid)
2441 {
2442         return pkgmgr_client_usr_clear_cache_dir(pkgid, GLOBAL_USER);
2443 }
2444
2445 API int pkgmgr_client_clear_usr_all_cache_dir(uid_t uid)
2446 {
2447         return pkgmgr_client_usr_clear_cache_dir(PKG_CLEAR_ALL_CACHE, uid);
2448 }
2449
2450 API int pkgmgr_client_clear_all_cache_dir(void)
2451 {
2452         int ret = 0;
2453         ret = pkgmgr_client_usr_clear_cache_dir(PKG_CLEAR_ALL_CACHE, GLOBAL_USER);
2454         return ret;
2455 }
2456
2457 API int pkgmgr_client_get_size(pkgmgr_client * pc, const char *pkgid, pkgmgr_getsize_type get_type, pkgmgr_handler event_cb, void *data)
2458 {
2459         return pkgmgr_client_usr_get_size(pc, pkgid, get_type, event_cb, data, GLOBAL_USER);
2460 }
2461
2462 API int pkgmgr_client_usr_get_size(pkgmgr_client * pc, const char *pkgid, pkgmgr_getsize_type get_type, pkgmgr_handler event_cb, void *data, uid_t uid)
2463 {
2464         char *req_key = NULL;
2465         int ret =0;
2466         char *pkgtype = "rpm";
2467         char *argv[PKG_ARGC_MAX] = { NULL, };
2468         char *args = NULL;
2469         int argcnt = 0;
2470         int len = 0;
2471         char *temp = NULL;
2472         int i = 0;
2473         char buf[128] = {'\0'};
2474         int req_id = 0;
2475
2476         pkgmgr_client_t *mpc = (pkgmgr_client_t *) pc;
2477         retvm_if(mpc->ctype != PC_REQUEST, PKGMGR_R_EINVAL, "mpc->ctype is not PC_REQUEST\n");
2478         retvm_if(event_cb == NULL, PKGMGR_R_EINVAL, "event_cb is NULL\n");
2479         retvm_if(pkgid == NULL, PKGMGR_R_EINVAL, "pkgid is NULL\n");
2480
2481         req_key = __get_req_key(pkgid);
2482         retvm_if(req_key == NULL, PKGMGR_R_EINVAL, "req_key is NULL");
2483
2484         req_id = _get_request_id();
2485         __add_op_cbinfo(mpc, req_id, req_key, event_cb, NULL, data);
2486
2487         snprintf(buf, 128, "%d", get_type);
2488         argv[argcnt++] = strdup(pkgid);
2489         argv[argcnt++] = strdup(buf);
2490         argv[argcnt++] = strdup("-k");
2491         argv[argcnt++] = req_key;
2492
2493         /*** add quote in all string for special charactor like '\n'***   FIX */
2494         for (i = 0; i < argcnt; i++) {
2495                 temp = g_shell_quote(argv[i]);
2496                 len += (strlen(temp) + 1);
2497                 g_free(temp);
2498         }
2499
2500         args = (char *)calloc(len, sizeof(char));
2501         tryvm_if(args == NULL, ret = PKGMGR_R_EINVAL, "installer_path fail");
2502
2503         strncpy(args, argv[0], len - 1);
2504
2505         for (i = 1; i < argcnt; i++) {
2506                 strncat(args, " ", strlen(" "));
2507                 temp = g_shell_quote(argv[i]);
2508                 strncat(args, temp, strlen(temp));
2509                 g_free(temp);
2510         }
2511         DBG("[args] %s [len] %d\n", args, len);
2512
2513         /* request */
2514         ret = comm_client_request(mpc->info.request.cc, "getsize",
2515                         g_variant_new("(ssss)", req_key, pkgtype, pkgid, args));
2516         if (ret < 0)
2517                 ERR("comm_client_request failed, ret=%d\n", ret);
2518
2519 catch:
2520         for (i = 0; i < argcnt; i++)
2521                 free(argv[i]);
2522
2523         if(args)
2524                 free(args);
2525
2526         return ret;
2527 }
2528
2529 API int pkgmgr_client_usr_get_package_size_info(pkgmgr_client *pc, const char *pkgid, pkgmgr_pkg_size_info_receive_cb event_cb, void *user_data, uid_t uid)
2530 {
2531         pkgmgrinfo_pkginfo_h pkginfo = NULL;
2532         char *req_key = NULL;
2533         int req_id = 0;
2534         int res = 0;
2535         int type = PM_GET_PKG_SIZE_INFO;
2536
2537         retvm_if(pc == NULL, PKGMGR_R_EINVAL, "The specified pc is NULL.");
2538         retvm_if(pkgid == NULL, PKGMGR_R_EINVAL, "The package id is NULL.");
2539
2540         if (strcmp(pkgid, PKG_SIZE_INFO_TOTAL) == 0)
2541         {       // total package size info
2542                 type = PM_GET_TOTAL_PKG_SIZE_INFO;
2543         }
2544         else
2545         {
2546                 res = pkgmgrinfo_pkginfo_get_usr_pkginfo(pkgid, uid, &pkginfo);
2547                 retvm_if(res != 0, PKGMGR_R_ENOPKG, "The package id is not installed.");
2548
2549                 if (pkginfo) {
2550                         pkgmgrinfo_pkginfo_destroy_pkginfo(pkginfo);
2551                 }
2552         }
2553
2554         pkgmgr_client_t *mpc = (pkgmgr_client_t *)pc;
2555         retvm_if(mpc->ctype != PC_REQUEST, PKGMGR_R_EINVAL, "mpc->ctype is not PC_REQUEST");
2556
2557         res = __change_op_cb_for_getsize(mpc);
2558         retvm_if(res < 0 , PKGMGR_R_ESYSTEM, "__change_op_cb_for_getsize is fail");
2559
2560         req_key = __get_req_key(pkgid);
2561         retvm_if(req_key == NULL, PKGMGR_R_ESYSTEM, "req_key is NULL");
2562
2563         req_id = _get_request_id();
2564         __add_op_cbinfo(mpc, req_id, req_key, __get_pkg_size_info_cb, event_cb, user_data);
2565
2566         res = __get_package_size_info(mpc, req_key, pkgid, type, uid);
2567
2568         return res;
2569 }
2570
2571 API int pkgmgr_client_get_package_size_info(pkgmgr_client *pc, const char *pkgid, pkgmgr_pkg_size_info_receive_cb event_cb, void *user_data)
2572 {
2573         return pkgmgr_client_usr_get_package_size_info(pc, pkgid, event_cb, user_data, GLOBAL_USER);
2574 }
2575
2576 API int pkgmgr_client_usr_get_total_package_size_info(pkgmgr_client *pc, pkgmgr_total_pkg_size_info_receive_cb event_cb, void *user_data, uid_t uid)
2577 {       // total package size info
2578         return pkgmgr_client_usr_get_package_size_info(pc, PKG_SIZE_INFO_TOTAL, (pkgmgr_pkg_size_info_receive_cb)event_cb, user_data, uid);
2579 }
2580
2581 API int pkgmgr_client_get_total_package_size_info(pkgmgr_client *pc, pkgmgr_total_pkg_size_info_receive_cb event_cb, void *user_data)
2582 {
2583         return pkgmgr_client_usr_get_package_size_info(pc, PKG_SIZE_INFO_TOTAL, (pkgmgr_pkg_size_info_receive_cb)event_cb, user_data, GLOBAL_USER);
2584 }