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