client/src/pkgmgr.c

   1 /*
   2  * slp-pkgmgr
   3  *
   4  * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Contact: Jayoun Lee <airjany@samsung.com>, Sewook Park <sewook7.park@samsung.com>,
   7  * Jaeho Lee <jaeho81.lee@samsung.com>, Shobhit Srivastava <shobhit.s@samsung.com>
   8  *
   9  * Licensed under the Apache License, Version 2.0 (the "License");
  10  * you may not use this file except in compliance with the License.
  11  * You may obtain a copy of the License at
  12  *
  13  * http://www.apache.org/licenses/LICENSE-2.0
  14  *
  15  * Unless required by applicable law or agreed to in writing, software
  16  * distributed under the License is distributed on an "AS IS" BASIS,
  17  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  18  * See the License for the specific language governing permissions and
  19  * limitations under the License.
  20  *
  21  */
  22
  23 #include <stdio.h>
  24 #include <stdlib.h>
  25 #include <string.h>
  26 #include <unistd.h>
  27 #include <dlfcn.h>
  28 #include <dirent.h>
  29 #include <fcntl.h>
  30 #include <sys/wait.h>
  31 #include <sys/time.h>
  32
  33 #include <glib.h>
  34
  35 #include <pkgmgr-info.h>
  36 #include <iniparser.h>
  37 /* For multi-user support */
  38 #include <tzplatform_config.h>
  39
  40 #include "package-manager.h"
  41 #include "pkgmgr-internal.h"
  42 #include "pkgmgr-debug.h"
  43 #include "pkgmgr-api.h"
  44 #include "comm_client.h"
  45
  46 #define PKG_TMP_PATH tzplatform_mkpath(TZ_USER_APP, "tmp")
  47
  48 #define BINSH_NAME      "/bin/sh"
  49 #define BINSH_SIZE      7
  50
  51 #define GLOBAL_USER tzplatform_getuid(TZ_SYS_GLOBALAPP_USER)
  52
  53 static int _get_request_id()
  54 {
  55         static int internal_req_id = 1;
  56
  57         return internal_req_id++;
  58 }
  59
  60 typedef struct _req_cb_info {
  61         int request_id;
  62         char *req_key;
  63         pkgmgr_handler event_cb;
  64         void *data;
  65         struct _req_cb_info *next;
  66 } req_cb_info;
  67
  68 typedef struct _listen_cb_info {
  69         int request_id;
  70         pkgmgr_handler event_cb;
  71         void *data;
  72         struct _listen_cb_info *next;
  73 } listen_cb_info;
  74
  75 typedef struct _pkgmgr_client_t {
  76         client_type ctype;
  77         int status_type;
  78         union {
  79                 struct _request {
  80                         comm_client *cc;
  81                         req_cb_info *rhead;
  82                 } request;
  83                 struct _listening {
  84                         comm_client *cc;
  85                         listen_cb_info *lhead;
  86                 } listening;
  87         } info;
  88         void *new_event_cb;
  89         char *tep_path;
  90         char *tep_move;
  91 } pkgmgr_client_t;
  92
  93 typedef struct _iter_data {
  94         pkgmgr_iter_fn iter_fn;
  95         void *data;
  96 } iter_data;
  97
  98 static int __xsystem(const char *argv[])
  99 {
 100         int status = 0;
 101         pid_t pid;
 102         pid = fork();
 103         switch (pid) {
 104         case -1:
 105                 perror("fork failed");
 106                 return -1;
 107         case 0:
 108                 /* child */
 109                 execvp(argv[0], (char *const *)argv);
 110                 _exit(-1);
 111         default:
 112                 /* parent */
 113                 break;
 114         }
 115         if (waitpid(pid, &status, 0) == -1) {
 116                 perror("waitpid failed");
 117                 return -1;
 118         }
 119         if (WIFSIGNALED(status)) {
 120                 perror("signal");
 121                 return -1;
 122         }
 123         if (!WIFEXITED(status)) {
 124                 /* shouldn't happen */
 125                 perror("should not happen");
 126                 return -1;
 127         }
 128         return WEXITSTATUS(status);
 129 }
 130
 131 static void __error_to_string(int errnumber, char **errstr)
 132 {
 133         if (errstr == NULL)
 134                 return;
 135         switch (errnumber) {
 136         case PKGCMD_ERR_PACKAGE_NOT_FOUND:
 137                 *errstr = PKGCMD_ERR_PACKAGE_NOT_FOUND_STR;
 138                 break;
 139         case PKGCMD_ERR_PACKAGE_INVALID:
 140                 *errstr = PKGCMD_ERR_PACKAGE_INVALID_STR;
 141                 break;
 142         case PKGCMD_ERR_PACKAGE_LOWER_VERSION:
 143                 *errstr = PKGCMD_ERR_PACKAGE_LOWER_VERSION_STR;
 144                 break;
 145         case PKGCMD_ERR_PACKAGE_EXECUTABLE_NOT_FOUND:
 146                 *errstr = PKGCMD_ERR_PACKAGE_EXECUTABLE_NOT_FOUND_STR;
 147                 break;
 148         case PKGCMD_ERR_MANIFEST_INVALID:
 149                 *errstr = PKGCMD_ERR_MANIFEST_INVALID_STR;
 150                 break;
 151         case PKGCMD_ERR_CONFIG_NOT_FOUND:
 152                 *errstr = PKGCMD_ERR_CONFIG_NOT_FOUND_STR;
 153                 break;
 154         case PKGCMD_ERR_CONFIG_INVALID:
 155                 *errstr = PKGCMD_ERR_CONFIG_INVALID_STR;
 156                 break;
 157         case PKGCMD_ERR_SIGNATURE_NOT_FOUND:
 158                 *errstr = PKGCMD_ERR_SIGNATURE_NOT_FOUND_STR;
 159                 break;
 160         case PKGCMD_ERR_SIGNATURE_INVALID:
 161                 *errstr = PKGCMD_ERR_SIGNATURE_INVALID_STR;
 162                 break;
 163         case PKGCMD_ERR_SIGNATURE_VERIFICATION_FAILED:
 164                 *errstr = PKGCMD_ERR_SIGNATURE_VERIFICATION_FAILED_STR;
 165                 break;
 166         case PKGCMD_ERR_ROOT_CERTIFICATE_NOT_FOUND:
 167                 *errstr = PKGCMD_ERR_ROOT_CERTIFICATE_NOT_FOUND_STR;
 168                 break;
 169         case PKGCMD_ERR_CERTIFICATE_INVALID:
 170                 *errstr = PKGCMD_ERR_CERTIFICATE_INVALID_STR;
 171                 break;
 172         case PKGCMD_ERR_CERTIFICATE_CHAIN_VERIFICATION_FAILED:
 173                 *errstr = PKGCMD_ERR_CERTIFICATE_CHAIN_VERIFICATION_FAILED_STR;
 174                 break;
 175         case PKGCMD_ERR_CERTIFICATE_EXPIRED:
 176                 *errstr = PKGCMD_ERR_CERTIFICATE_EXPIRED_STR;
 177                 break;
 178         case PKGCMD_ERR_INVALID_PRIVILEGE:
 179                 *errstr = PKGCMD_ERR_INVALID_PRIVILEGE_STR;
 180                 break;
 181         case PKGCMD_ERR_MENU_ICON_NOT_FOUND:
 182                 *errstr = PKGCMD_ERR_MENU_ICON_NOT_FOUND_STR;
 183                 break;
 184         case PKGCMD_ERR_FATAL_ERROR:
 185                 *errstr = PKGCMD_ERR_FATAL_ERROR_STR;
 186                 break;
 187         case PKGCMD_ERR_OUT_OF_STORAGE:
 188                 *errstr = PKGCMD_ERR_OUT_OF_STORAGE_STR;
 189                 break;
 190         case PKGCMD_ERR_OUT_OF_MEMORY:
 191                 *errstr = PKGCMD_ERR_OUT_OF_MEMORY_STR;
 192                 break;
 193         case PKGCMD_ERR_ARGUMENT_INVALID:
 194                 *errstr = PKGCMD_ERR_ARGUMENT_INVALID_STR;
 195                 break;
 196         default:
 197                 *errstr = PKGCMD_ERR_UNKNOWN_STR;
 198                 break;
 199         }
 200 }
 201
 202 static void __add_op_cbinfo(pkgmgr_client_t * pc, int request_id,
 203                             const char *req_key, pkgmgr_handler event_cb, void *new_event_cb,
 204                             void *data)
 205 {
 206         req_cb_info *cb_info;
 207         req_cb_info *current;
 208         req_cb_info *prev;
 209
 210         cb_info = (req_cb_info *) calloc(1, sizeof(req_cb_info));
 211         if (cb_info == NULL) {
 212                 DBG("calloc failed");
 213                 return;
 214         }
 215         cb_info->request_id = request_id;
 216         cb_info->req_key = strdup(req_key);
 217         cb_info->event_cb = event_cb;
 218         cb_info->data = data;
 219         cb_info->next = NULL;
 220         pc->new_event_cb = new_event_cb;
 221
 222         if (pc->info.request.rhead == NULL)
 223                 pc->info.request.rhead = cb_info;
 224         else {
 225                 current = prev = pc->info.request.rhead;
 226                 while (current) {
 227                         prev = current;
 228                         current = current->next;
 229                 }
 230
 231                 prev->next = cb_info;
 232         }
 233 }
 234
 235 static req_cb_info *__find_op_cbinfo(pkgmgr_client_t *pc, const char *req_key)
 236 {
 237         req_cb_info *tmp;
 238
 239         tmp = pc->info.request.rhead;
 240
 241         if (tmp == NULL) {
 242                 ERR("tmp is NULL");
 243                 return NULL;
 244         }
 245
 246         DBG("tmp->req_key %s, req_key %s", tmp->req_key, req_key);
 247
 248         while (tmp) {
 249                 if (strncmp(tmp->req_key, req_key, strlen(tmp->req_key)) == 0)
 250                         return tmp;
 251                 tmp = tmp->next;
 252         }
 253         return NULL;
 254 }
 255
 256 static void __add_stat_cbinfo(pkgmgr_client_t *pc, int request_id,
 257                               pkgmgr_handler event_cb, void *data)
 258 {
 259         listen_cb_info *cb_info;
 260         listen_cb_info *current;
 261         listen_cb_info *prev;
 262
 263         cb_info = (listen_cb_info *) calloc(1, sizeof(listen_cb_info));
 264         if (cb_info == NULL) {
 265                 DBG("calloc failed");
 266                 return;
 267         }
 268         cb_info->request_id = request_id;
 269         cb_info->event_cb = event_cb;
 270         cb_info->data = data;
 271         cb_info->next = NULL;
 272
 273         /* TODO - check the order of callback - FIFO or LIFO => Should be changed to LIFO */
 274         if (pc->info.listening.lhead == NULL)
 275                 pc->info.listening.lhead = cb_info;
 276         else {
 277                 current = prev = pc->info.listening.lhead;
 278                 while (current) {
 279                         prev = current;
 280                         current = current->next;
 281                 }
 282
 283                 prev->next = cb_info;
 284         }
 285 }
 286
 287 static void __operation_callback(void *cb_data, uid_t target_uid,
 288                                  const char *req_id, const char *pkg_type,
 289                                  const char *pkgid, const char *key,
 290                                  const char *val)
 291 {
 292         pkgmgr_client_t *pc;
 293         req_cb_info *cb_info;
 294
 295         pc = (pkgmgr_client_t *) cb_data;
 296
 297         /* find callback info */
 298         cb_info = __find_op_cbinfo(pc, req_id);
 299         if (cb_info == NULL) {
 300                 ERR("cannot fint cb_info for req_id:%s", req_id);
 301                 return;
 302         }
 303
 304         /* call callback */
 305         if (cb_info->event_cb) {
 306                 if (pc->new_event_cb)
 307                         cb_info->event_cb(target_uid, cb_info->request_id,
 308                                         pkg_type, pkgid, key, val, pc,
 309                                         cb_info->data);
 310                 else
 311                         cb_info->event_cb(target_uid, cb_info->request_id,
 312                                         pkg_type, pkgid, key, val, NULL,
 313                                         cb_info->data);
 314         }
 315
 316         return;
 317 }
 318
 319 static void __status_callback(void *cb_data, uid_t target_uid,
 320                               const char *req_id, const char *pkg_type,
 321                               const char *pkgid,  const char *key,
 322                               const char *val)
 323 {
 324         pkgmgr_client_t *pc;
 325         listen_cb_info *tmp;
 326
 327         pc = (pkgmgr_client_t *) cb_data;
 328
 329         tmp = pc->info.listening.lhead;
 330         while (tmp) {
 331                 if (tmp->event_cb(target_uid, tmp->request_id, pkg_type, pkgid,
 332                                   key, val, NULL, tmp->data) != 0)
 333                         break;
 334                 tmp = tmp->next;
 335         }
 336
 337         return;
 338 }
 339
 340 static inline int __read_proc(const char *path, char *buf, int size)
 341 {
 342         int fd = 0;
 343         int ret = 0;
 344
 345         if (buf == NULL || path == NULL)
 346                 return -1;
 347
 348         fd = open(path, O_RDONLY);
 349         if (fd < 0)
 350                 return -1;
 351
 352         ret = read(fd, buf, size - 1);
 353         if (ret <= 0) {
 354                 close(fd);
 355                 return -1;
 356         } else
 357                 buf[ret] = 0;
 358
 359         close(fd);
 360
 361         return ret;
 362 }
 363
 364 char *__proc_get_cmdline_bypid(int pid)
 365 {
 366         char buf[PKG_STRING_LEN_MAX] = {'\0', };
 367         int ret = 0;
 368
 369         snprintf(buf, sizeof(buf), "/proc/%d/cmdline", pid);
 370         ret = __read_proc(buf, buf, sizeof(buf));
 371         if (ret <= 0)
 372                 return NULL;
 373
 374         /* support app launched by shell script*/
 375         if (strncmp(buf, BINSH_NAME, BINSH_SIZE) == 0)
 376                 return strdup(&buf[BINSH_SIZE + 1]);
 377         else
 378                 return strdup(buf);
 379 }
 380
 381 static inline int __pkgmgr_read_proc(const char *path, char *buf, int size)
 382 {
 383         int fd;
 384         int ret;
 385
 386         if (buf == NULL || path == NULL)
 387                 return -1;
 388
 389         fd = open(path, O_RDONLY);
 390         if (fd < 0)
 391                 return -1;
 392
 393         ret = read(fd, buf, size - 1);
 394         if (ret <= 0) {
 395                 close(fd);
 396                 return -1;
 397         } else
 398                 buf[ret] = 0;
 399
 400         close(fd);
 401
 402         return ret;
 403 }
 404
 405 static inline int __pkgmgr_find_pid_by_cmdline(const char *dname,
 406                                       const char *cmdline, const char *apppath)
 407 {
 408         int pid = 0;
 409
 410         if (strncmp(cmdline, apppath, PKG_STRING_LEN_MAX-1) == 0) {
 411                 pid = atoi(dname);
 412                 if (pid != getpgid(pid))
 413                         pid = 0;
 414         }
 415
 416         return pid;
 417 }
 418
 419 static int __sync_process(const char *req_key)
 420 {
 421         int ret;
 422         char info_file[PKG_STRING_LEN_MAX] = {'\0', };
 423         int result = -1;
 424         int check_cnt = 0;
 425         FILE *fp;
 426         char buf[PKG_STRING_LEN_MAX] = {0, };
 427
 428         snprintf(info_file, PKG_STRING_LEN_MAX, "%s/%s", PKG_SIZE_INFO_PATH, req_key);
 429         while(1)
 430         {
 431                 check_cnt++;
 432
 433                 if (access(info_file, F_OK) == 0) {
 434                         fp = fopen(info_file, "r");
 435                         if (fp == NULL) {
 436                                 DBG("file is not generated yet.... wait\n");
 437                                 usleep(100 * 1000);     /* 100ms sleep*/
 438                                 continue;
 439                         }
 440
 441                         if (fgets(buf, PKG_STRING_LEN_MAX, fp) == NULL) {
 442                                 ERR("failed to read info file");
 443                                 fclose(fp);
 444                                 break;
 445                         }
 446                         fclose(fp);
 447
 448                         DBG("info_file file is generated, result = %s. \n", buf);
 449                         result = atoi(buf);
 450                         break;
 451                 }
 452
 453                 DBG("file is not generated yet.... wait\n");
 454                 usleep(100 * 1000);     /* 100ms sleep*/
 455
 456                 if (check_cnt > 6000) { /* 60s * 10 time over*/
 457                         ERR("wait time over!!\n");
 458                         break;
 459                 }
 460         }
 461
 462         ret = remove(info_file);
 463         if (ret < 0)
 464                 ERR("file is can not remove[%s, %d]\n", info_file, ret);
 465
 466         return result;
 467 }
 468
 469 static int __csc_process(const char *csc_path, char *result_path)
 470 {
 471         int ret = 0;
 472         int cnt = 0;
 473         int count = 0;
 474         int csc_fail = 0;
 475         int fd = 0;
 476         char *pkgtype = NULL;
 477         char *des = NULL;
 478         char buf[PKG_STRING_LEN_MAX] = {0,};
 479         char type_buf[1024] = { 0 };
 480         char des_buf[1024] = { 0 };
 481         dictionary *csc = NULL;
 482         FILE* file = NULL;
 483
 484         csc = iniparser_load(csc_path);
 485         retvm_if(csc == NULL, PKGMGR_R_EINVAL, "cannot open parse file [%s]", csc_path);
 486
 487         file = fopen(result_path, "w");
 488         tryvm_if(file == NULL, ret = PKGMGR_R_EINVAL, "cannot open result file [%s]", result_path);
 489
 490         count = iniparser_getint(csc, "csc packages:count", -1);
 491         tryvm_if(count == 0, ret = PKGMGR_R_ERROR, "csc [%s] dont have packages", csc_path);
 492
 493         snprintf(buf, PKG_STRING_LEN_MAX, "[result]\n");
 494         fwrite(buf, 1, strlen(buf), file);
 495         snprintf(buf, PKG_STRING_LEN_MAX, "count = %d\n", count);
 496         fwrite(buf, 1, strlen(buf), file);
 497
 498         for(cnt = 1 ; cnt <= count ; cnt++)
 499         {
 500                 snprintf(type_buf, PKG_STRING_LEN_MAX - 1, "csc packages:type_%03d", cnt);
 501                 snprintf(des_buf, PKG_STRING_LEN_MAX - 1, "csc packages:description_%03d", cnt);
 502
 503                 pkgtype = iniparser_getstring(csc, type_buf, NULL);
 504                 des = iniparser_getstring(csc, des_buf, NULL);
 505                 ret = 0;
 506
 507                 if (pkgtype == NULL) {
 508                         csc_fail++;
 509                         snprintf(buf, PKG_STRING_LEN_MAX, "%s = Fail to get pkgtype\n", type_buf);
 510                         fwrite(buf, 1, strlen(buf), file);
 511                         continue;
 512                 } else if (des == NULL) {
 513                         csc_fail++;
 514                         snprintf(buf, PKG_STRING_LEN_MAX, "%s = Fail to get description\n", des_buf);
 515                         fwrite(buf, 1, strlen(buf), file);
 516                         continue;
 517                 }
 518
 519                 snprintf(buf, PKG_STRING_LEN_MAX, "type_%03d = %s\n", cnt, pkgtype);
 520                 fwrite(buf, 1, strlen(buf), file);
 521                 snprintf(buf, PKG_STRING_LEN_MAX, "description_%03d = %s\n", cnt, des);
 522                 fwrite(buf, 1, strlen(buf), file);
 523
 524                 if (strcmp(pkgtype, "tpk") == 0) {
 525                         const char *ospinstaller_argv[] = { "/usr/bin/osp-installer", "-c", des, NULL };
 526                         ret = __xsystem(ospinstaller_argv);
 527                 } else if (strcmp(pkgtype, "wgt")== 0) {
 528                         const char *wrtinstaller_argv[] = { "/usr/bin/wrt-installer", "-c", des, NULL };
 529                         ret = __xsystem(wrtinstaller_argv);
 530                 } else {
 531                         csc_fail++;
 532                         ret = -1;
 533                 }
 534
 535                 if (ret != 0) {
 536                         char *errstr = NULL;
 537                         __error_to_string(ret, &errstr);
 538                         snprintf(buf, PKG_STRING_LEN_MAX, "result_%03d = fail[%s]\n", cnt, errstr);
 539                 }
 540                 else
 541                         snprintf(buf, PKG_STRING_LEN_MAX, "result_%03d = success\n", cnt);
 542
 543                 fwrite(buf, 1, strlen(buf), file);
 544         }
 545
 546 catch:
 547         iniparser_freedict(csc);
 548         if (file != NULL) {
 549                 fflush(file);
 550                 fd = fileno(file);
 551                 fsync(fd);
 552                 fclose(file);
 553         }
 554         return ret;
 555 }
 556
 557 static int __get_size_process(pkgmgr_client * pc, const char *pkgid, uid_t uid,
 558                 pkgmgr_getsize_type get_type, pkgmgr_handler event_cb,
 559                 void *data)
 560 {
 561         GVariant *result;
 562         int ret = PKGMGR_R_ECOMM;
 563         char *req_key = NULL;
 564         pkgmgr_client_t *mpc = (pkgmgr_client_t *)pc;
 565
 566         if (pc == NULL || pkgid == NULL) {
 567                 ERR("invalid parameter");
 568                 return PKGMGR_R_EINVAL;
 569         }
 570
 571         if (mpc->ctype != PC_REQUEST) {
 572                 ERR("mpc->ctype is not PC_REQUEST");
 573                 return PKGMGR_R_EINVAL;
 574         }
 575         result = comm_client_request(mpc->info.request.cc, "getsize",
 576                         g_variant_new("(si)", pkgid, get_type));
 577         if (result == NULL)
 578                 return PKGMGR_R_ECOMM;
 579
 580         g_variant_get(result, "(i&s)", &ret, &req_key);
 581         if (req_key == NULL) {
 582                 g_variant_unref(result);
 583                 return PKGMGR_R_ECOMM;
 584         }
 585         if (ret != PKGMGR_R_OK) {
 586                 g_variant_unref(result);
 587                 return ret;
 588         }
 589
 590         ret = __sync_process(req_key);
 591         if (ret < 0)
 592                 ERR("get size failed, ret=%d\n", ret);
 593
 594         g_variant_unref(result);
 595
 596         return ret;
 597 }
 598
 599 static int __move_pkg_process(pkgmgr_client *pc, const char *pkgid,
 600                 const char *pkg_type, uid_t uid, pkgmgr_move_type move_type,
 601                 pkgmgr_handler event_cb, void *data)
 602 {
 603         int ret;
 604
 605         ret = pkgmgr_client_usr_move(pc, pkg_type, pkgid, move_type, 0, uid);
 606         if (ret < 0) {
 607                 ERR("move request failed");
 608                 return ret;
 609         }
 610
 611         /* FIXME */
 612         ret = __sync_process(pkgid);
 613         if (ret != 0)
 614                 ERR("move pkg failed, ret=%d\n", ret);
 615
 616         return ret;
 617 }
 618
 619 static int __check_app_process(pkgmgr_request_service_type service_type,
 620                 pkgmgr_client *pc, const char *pkgid, uid_t uid, void *data)
 621 {
 622         GVariant *result = NULL;
 623         int ret = PKGMGR_R_ECOMM;
 624         pkgmgrinfo_pkginfo_h handle;
 625         int pid = -1;
 626         pkgmgr_client_t *mpc = (pkgmgr_client_t *) pc;
 627
 628         retvm_if(mpc->ctype != PC_REQUEST, PKGMGR_R_EINVAL, "mpc->ctype is not PC_REQUEST\n");
 629
 630         if (uid != GLOBAL_USER)
 631                 ret = pkgmgrinfo_pkginfo_get_usr_pkginfo(pkgid, uid, &handle);
 632         else
 633                 ret = pkgmgrinfo_pkginfo_get_pkginfo(pkgid, &handle);
 634         retvm_if(ret < 0, PKGMGR_R_ERROR, "pkgmgrinfo_pkginfo_get_pkginfo failed");
 635
 636         if (service_type == PM_REQUEST_KILL_APP)
 637                 result = comm_client_request(mpc->info.request.cc, "kill",
 638                                 g_variant_new("(s)", pkgid));
 639         else if (service_type == PM_REQUEST_CHECK_APP)
 640                 result = comm_client_request(mpc->info.request.cc, "check",
 641                                 g_variant_new("(s)", pkgid));
 642
 643         if (result == NULL)
 644                 return PKGMGR_R_ECOMM;
 645         g_variant_get(result, "(i)", &ret);
 646         g_variant_unref(result);
 647         if (ret != PKGMGR_R_OK) {
 648                 ERR("request failed, ret=%d", ret);
 649                 return ret;
 650         }
 651
 652         /* FIXME */
 653         pid  = __sync_process(pkgid);
 654         *(int *)data = pid;
 655
 656         pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
 657
 658         return ret;
 659
 660 }
 661
 662 static int __request_size_info(pkgmgr_client *pc, uid_t uid)
 663 {
 664         GVariant *result;
 665         int ret = PKGMGR_R_ECOMM;
 666         char *req_key = NULL;
 667         pkgmgr_client_t *mpc = (pkgmgr_client_t *) pc;
 668
 669         if (pc == NULL) {
 670                 ERR("invalid parameter");
 671                 return PKGMGR_R_EINVAL;
 672         }
 673
 674         if (mpc->ctype != PC_REQUEST) {
 675                 ERR("mpc->ctype is not PC_REQUEST");
 676                 return PKGMGR_R_EINVAL;
 677         }
 678
 679         result = comm_client_request(mpc->info.request.cc, "getsize",
 680                         g_variant_new("(si)", "size_info", PM_GET_SIZE_INFO));
 681         if (result == NULL)
 682                 return PKGMGR_R_ECOMM;
 683
 684         g_variant_get(result, "(i&s)", &ret, &req_key);
 685         if (req_key == NULL) {
 686                 g_variant_unref(result);
 687                 return PKGMGR_R_ECOMM;
 688         }
 689
 690         g_variant_unref(result);
 691
 692         return ret;
 693 }
 694
 695 static int __change_op_cb_for_getsize(pkgmgr_client *pc)
 696 {
 697         int ret = -1;
 698
 699         retvm_if(pc == NULL, PKGMGR_R_EINVAL, "package manager client pc is NULL");
 700         pkgmgr_client_t *mpc = (pkgmgr_client_t *) pc;
 701
 702         /*  free listening head */
 703         req_cb_info *tmp = NULL;
 704         req_cb_info *prev = NULL;
 705         for (tmp = mpc->info.request.rhead; tmp;) {
 706                 prev = tmp;
 707                 tmp = tmp->next;
 708                 free(prev);
 709         }
 710
 711         /* free dbus connection */
 712         ret = comm_client_free(mpc->info.request.cc);
 713         retvm_if(ret < 0, PKGMGR_R_ERROR, "comm_client_free() failed - %d", ret);
 714
 715         /* Manage pc for seperated event */
 716         mpc->ctype = PC_REQUEST;
 717         mpc->status_type = PKGMGR_CLIENT_STATUS_GET_SIZE;
 718
 719
 720         mpc->info.request.cc = comm_client_new();
 721         retvm_if(mpc->info.request.cc == NULL, PKGMGR_R_ERROR, "client creation failed");
 722
 723         ret = comm_client_set_status_callback(COMM_STATUS_BROADCAST_GET_SIZE, mpc->info.request.cc, __operation_callback, pc);
 724         retvm_if(ret < 0, PKGMGR_R_ERROR, "set_status_callback() failed - %d", ret);
 725
 726         return PKGMGR_R_OK;
 727 }
 728
 729 static int __get_pkg_size_info_cb(uid_t target_uid, int req_id, const char *req_type,
 730                 const char *pkgid, const char *key,
 731                 const char *value, const void *pc, void *user_data)
 732 {
 733         int ret = 0;
 734         DBG("target_uid: %u, reqid: %d, req type: %s, pkgid: %s, unused key: %s, size info: %s",
 735                         target_uid, req_id, req_type, pkgid, key, value);
 736
 737         pkg_size_info_t *size_info = (pkg_size_info_t *)malloc(sizeof(pkg_size_info_t));
 738         retvm_if(size_info == NULL, -1, "The memory is insufficient.");
 739
 740         char *save_ptr = NULL;
 741         char *token = strtok_r((char*)value, ":", &save_ptr);
 742         tryvm_if(token == NULL, ret = -1, "failed to parse sizeinfo");
 743         size_info->data_size = atoll(token);
 744         token = strtok_r(NULL, ":", &save_ptr);
 745         tryvm_if(token == NULL, ret = -1, "failed to parse sizeinfo");
 746         size_info->cache_size = atoll(token);
 747         token = strtok_r(NULL, ":", &save_ptr);
 748         tryvm_if(token == NULL, ret = -1, "failed to parse sizeinfo");
 749         size_info->app_size = atoll(token);
 750         token = strtok_r(NULL, ":", &save_ptr);
 751         tryvm_if(token == NULL, ret = -1, "failed to parse sizeinfo");
 752         size_info->ext_data_size = atoll(token);
 753         token = strtok_r(NULL, ":", &save_ptr);
 754         tryvm_if(token == NULL, ret = -1, "failed to parse sizeinfo");
 755         size_info->ext_cache_size = atoll(token);
 756         token = strtok_r(NULL, ":", &save_ptr);
 757         tryvm_if(token == NULL, ret = -1, "failed to parse sizeinfo");
 758         size_info->ext_app_size = atoll(token);
 759
 760         DBG("data: %lld, cache: %lld, app: %lld, ext_data: %lld, ext_cache: %lld, ext_app: %lld",
 761                         size_info->data_size, size_info->cache_size, size_info->app_size,
 762                         size_info->ext_data_size, size_info->ext_cache_size, size_info->ext_app_size);
 763
 764         pkgmgr_client_t *pmc = (pkgmgr_client_t *)pc;
 765         tryvm_if(pmc == NULL, ret = -1, "pkgmgr_client instance is null.");
 766
 767         if (strcmp(pkgid, PKG_SIZE_INFO_TOTAL) == 0)
 768         {       // total package size info
 769                 pkgmgr_total_pkg_size_info_receive_cb callback = (pkgmgr_total_pkg_size_info_receive_cb)(pmc->new_event_cb);
 770                 callback((pkgmgr_client *)pc, size_info, user_data);
 771         }
 772         else
 773         {
 774                 pkgmgr_pkg_size_info_receive_cb callback = (pkgmgr_pkg_size_info_receive_cb)(pmc->new_event_cb);
 775                 callback((pkgmgr_client *)pc, pkgid, size_info, user_data);
 776         }
 777
 778 catch:
 779
 780         if(size_info){
 781                 free(size_info);
 782                 size_info = NULL;
 783         }
 784         return ret;
 785 }
 786
 787 API pkgmgr_client *pkgmgr_client_new(client_type ctype)
 788 {
 789         pkgmgr_client_t *pc = NULL;
 790         int ret = -1;
 791
 792         retvm_if(ctype == PC_BROADCAST, NULL, "broadcast type is not supported");
 793         retvm_if(ctype != PC_REQUEST && ctype != PC_LISTENING, NULL, "ctype is not client_type");
 794
 795         /* Allocate memory for ADT:pkgmgr_client */
 796         pc = calloc(1, sizeof(pkgmgr_client_t));
 797         retvm_if(pc == NULL, NULL, "No memory");
 798
 799         /* Manage pc */
 800         pc->ctype = ctype;
 801         pc->status_type = PKGMGR_CLIENT_STATUS_ALL;
 802         pc->tep_path = NULL;
 803
 804         if (pc->ctype == PC_REQUEST) {
 805                 pc->info.request.cc = comm_client_new();
 806                 trym_if(pc->info.request.cc == NULL, "client creation failed");
 807
 808                 ret = comm_client_set_status_callback(COMM_STATUS_BROADCAST_ALL, pc->info.request.cc, __operation_callback, pc);
 809                 trym_if(ret < 0L, "comm_client_set_status_callback() failed - %d", ret);
 810         } else if (pc->ctype == PC_LISTENING) {
 811                 pc->info.listening.cc = comm_client_new();
 812                 trym_if(pc->info.listening.cc == NULL, "client creation failed");
 813
 814                 ret = comm_client_set_status_callback(COMM_STATUS_BROADCAST_ALL, pc->info.listening.cc, __status_callback, pc);
 815                 trym_if(ret < 0L, "comm_client_set_status_callback() failed - %d", ret);
 816         }
 817
 818         return (pkgmgr_client *) pc;
 819
 820  catch:
 821         if (pc)
 822                 free(pc);
 823         return NULL;
 824 }
 825
 826 API int pkgmgr_client_free(pkgmgr_client *pc)
 827 {
 828         int ret = -1;
 829         pkgmgr_client_t *mpc = (pkgmgr_client_t *) pc;
 830         retvm_if(mpc == NULL, PKGMGR_R_EINVAL, "Invalid argument");
 831
 832         if (mpc->ctype == PC_REQUEST) {
 833                 req_cb_info *tmp;
 834                 req_cb_info *prev;
 835                 for (tmp = mpc->info.request.rhead; tmp;) {
 836                         prev = tmp;
 837                         tmp = tmp->next;
 838                         free(prev);
 839                 }
 840
 841                 ret = comm_client_free(mpc->info.request.cc);
 842                 tryvm_if(ret < 0, ret = PKGMGR_R_ERROR, "comm_client_free() failed");
 843         } else if (mpc->ctype == PC_LISTENING) {
 844                         listen_cb_info *tmp;
 845                         listen_cb_info *prev;
 846                         for (tmp = mpc->info.listening.lhead; tmp;) {
 847                                 prev = tmp;
 848                                 tmp = tmp->next;
 849                                 free(prev);
 850                         }
 851
 852                         ret = comm_client_free(mpc->info.listening.cc);
 853                         tryvm_if(ret < 0, ret = PKGMGR_R_ERROR, "comm_client_free() failed");
 854         } else if (mpc->ctype == PC_BROADCAST) {
 855                 ret = 0;
 856         } else {
 857                 ERR("Invalid client type\n");
 858                 return PKGMGR_R_EINVAL;
 859         }
 860
 861         if (mpc->tep_path) {
 862                 free(mpc->tep_path);
 863                 mpc->tep_path = NULL;
 864         }
 865
 866         if (mpc->tep_move) {
 867                 free(mpc->tep_move);
 868                 mpc->tep_move = NULL;
 869         }
 870
 871         free(mpc);
 872         mpc = NULL;
 873         return PKGMGR_R_OK;
 874
 875  catch:
 876         if (mpc) {
 877                 free(mpc);
 878                 mpc = NULL;
 879         }
 880         return PKGMGR_R_ERROR;
 881 }
 882
 883 static char *__get_type_from_path(const char *pkg_path)
 884 {
 885         int ret;
 886         char mimetype[255] = { '\0', };
 887         char extlist[256] = { '\0', };
 888         char *pkg_type;
 889
 890         ret = _get_mime_from_file(pkg_path, mimetype, sizeof(mimetype));
 891         if (ret) {
 892                 ERR("_get_mime_from_file() failed - error code[%d]\n", ret);
 893                 return NULL;
 894         }
 895
 896         ret = _get_mime_extension(mimetype, extlist, sizeof(extlist));
 897         if (ret) {
 898                 ERR("_get_mime_extension() failed - error code[%d]\n", ret);
 899                 return NULL;
 900         }
 901
 902         if (strlen(extlist) == 0)
 903                 return NULL;
 904
 905         if (strchr(extlist, ','))
 906                 extlist[strlen(extlist) - strlen(strchr(extlist, ','))] = '\0';
 907
 908         pkg_type = strchr(extlist, '.') + 1;
 909         return strdup(pkg_type);
 910 }
 911
 912 API int pkgmgr_client_set_tep_path(pkgmgr_client *pc, char *tep_path, char *tep_move)
 913 {
 914         retvm_if(pc == NULL, PKGMGR_R_EINVAL, "package manager client pc is NULL");
 915         retvm_if(tep_path == NULL, PKGMGR_R_EINVAL, "tep path is NULL");
 916         pkgmgr_client_t *mpc = (pkgmgr_client_t *) pc;
 917
 918         mpc->tep_path = strdup(tep_path);
 919         mpc->tep_move = strdup(tep_move);
 920
 921         return PKGMGR_R_OK;
 922 }
 923
 924 API int pkgmgr_client_usr_install(pkgmgr_client *pc, const char *pkg_type,
 925                 const char *descriptor_path, const char *pkg_path,
 926                 const char *optional_file, pkgmgr_mode mode,
 927                 pkgmgr_handler event_cb, void *data, uid_t uid)
 928 {
 929         GVariant *result;
 930         int ret = PKGMGR_R_ECOMM;
 931         char *req_key = NULL;
 932         GVariantBuilder *builder = NULL;
 933         GVariant *args = NULL;
 934         int req_id;
 935         pkgmgr_client_t *mpc = (pkgmgr_client_t *)pc;
 936         char *pkgtype;
 937         char *temp = NULL;
 938
 939         if (pc == NULL || pkg_path == NULL) {
 940                 ERR("invalid parameter");
 941                 return PKGMGR_R_EINVAL;
 942         }
 943
 944         if (mpc->ctype != PC_REQUEST) {
 945                 ERR("mpc->ctype is not PC_REQUEST");
 946                 return PKGMGR_R_EINVAL;
 947         }
 948
 949         if (access(pkg_path, F_OK) != 0) {
 950                 ERR("failed to access: %s", pkg_path);
 951                 return PKGMGR_R_EINVAL;
 952         }
 953
 954         if (mpc->tep_path != NULL && access(mpc->tep_path, F_OK) != 0) {
 955                 ERR("failed to access: %s", mpc->tep_path);
 956                 return PKGMGR_R_EINVAL;
 957         }
 958
 959         /* TODO: check pkg's type on server-side */
 960         if (pkg_type == NULL)
 961                 pkgtype = __get_type_from_path(pkg_path);
 962         else
 963                 pkgtype = strdup(pkg_type);
 964
 965         /* build arguments */
 966         builder = g_variant_builder_new(G_VARIANT_TYPE("as"));
 967         if (mpc->tep_path) {
 968                 g_variant_builder_add(builder, "s", "-e");
 969                 g_variant_builder_add(builder, "s", mpc->tep_path);
 970                 g_variant_builder_add(builder, "s", "-M");
 971                 g_variant_builder_add(builder, "s", mpc->tep_move);
 972         }
 973
 974         args = g_variant_new("as", builder);
 975         g_variant_builder_unref(builder);
 976
 977         result = comm_client_request(mpc->info.request.cc, "install",
 978                         g_variant_new("(uss@as)", uid, pkgtype, pkg_path, args));
 979
 980         if (result == NULL)
 981                 return PKGMGR_R_ECOMM;
 982         g_variant_get(result, "(i&s)", &ret, &req_key);
 983         if (req_key == NULL) {
 984                 g_variant_unref(result);
 985                 return PKGMGR_R_ECOMM;
 986         }
 987         if (ret != PKGMGR_R_OK) {
 988                 g_variant_unref(result);
 989                 return ret;
 990         }
 991
 992         req_id = _get_request_id();
 993         __add_op_cbinfo(mpc, req_id, req_key, event_cb, NULL, data);
 994
 995         g_variant_unref(result);
 996
 997         return req_id;
 998 }
 999
1000 API int pkgmgr_client_install(pkgmgr_client *pc, const char *pkg_type,
1001                 const char *descriptor_path, const char *pkg_path,
1002                 const char *optional_file, pkgmgr_mode mode,
1003                 pkgmgr_handler event_cb, void *data)
1004 {
1005         return pkgmgr_client_usr_install(pc, pkg_type, descriptor_path,
1006                         pkg_path, optional_file, mode, event_cb,data,
1007                         GLOBAL_USER);
1008 }
1009
1010 API int pkgmgr_client_reinstall(pkgmgr_client *pc, const char *pkg_type,
1011                 const char *pkgid, const char *optional_file, pkgmgr_mode mode,
1012                 pkgmgr_handler event_cb, void *data)
1013 {
1014         return pkgmgr_client_usr_reinstall(pc, pkg_type, pkgid, optional_file,
1015                         mode, event_cb, data,GLOBAL_USER);
1016 }
1017
1018 API int pkgmgr_client_usr_reinstall(pkgmgr_client * pc, const char *pkg_type,
1019                 const char *pkgid, const char *optional_file, pkgmgr_mode mode,
1020                 pkgmgr_handler event_cb, void *data, uid_t uid)
1021 {
1022         GVariant *result;
1023         int ret = PKGMGR_R_ECOMM;
1024         char *req_key = NULL;
1025         int req_id;
1026         pkgmgr_client_t *mpc = (pkgmgr_client_t *)pc;
1027         char *pkgtype;
1028         pkgmgrinfo_pkginfo_h handle;
1029
1030         if (pc == NULL || pkgid == NULL) {
1031                 ERR("invalid parameter");
1032                 return PKGMGR_R_EINVAL;
1033         }
1034
1035         if (mpc->ctype != PC_REQUEST) {
1036                 ERR("mpc->ctype is not PC_REQUEST");
1037                 return PKGMGR_R_EINVAL;
1038         }
1039
1040         ret = pkgmgrinfo_pkginfo_get_usr_pkginfo(pkgid, uid, &handle);
1041         if (ret < 0)
1042                 return PKGMGR_R_EINVAL;
1043
1044         ret = pkgmgrinfo_pkginfo_get_type(handle, &pkgtype);
1045         if (ret < 0) {
1046                 pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
1047                 return PKGMGR_R_ERROR;
1048         }
1049
1050         result = comm_client_request(mpc->info.request.cc, "reinstall",
1051                         g_variant_new("(uss)", uid, pkgtype, pkgid));
1052         pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
1053         if (result == NULL)
1054                 return PKGMGR_R_ECOMM;
1055         g_variant_get(result, "(i&s)", &ret, &req_key);
1056         if (req_key == NULL) {
1057                 g_variant_unref(result);
1058                 return PKGMGR_R_ECOMM;
1059         }
1060         if (ret != PKGMGR_R_OK) {
1061                 g_variant_unref(result);
1062                 return ret;
1063         }
1064
1065         req_id = _get_request_id();
1066         __add_op_cbinfo(mpc, req_id, req_key, event_cb, NULL, data);
1067
1068         g_variant_unref(result);
1069
1070         return req_id;
1071 }
1072
1073 API int pkgmgr_client_uninstall(pkgmgr_client *pc, const char *pkg_type,
1074                 const char *pkgid, pkgmgr_mode mode, pkgmgr_handler event_cb,
1075                 void *data)
1076 {
1077         return pkgmgr_client_usr_uninstall(pc, pkg_type,pkgid, mode, event_cb,
1078                         data, GLOBAL_USER);
1079 }
1080
1081 API int pkgmgr_client_usr_uninstall(pkgmgr_client *pc, const char *pkg_type,
1082                 const char *pkgid, pkgmgr_mode mode, pkgmgr_handler event_cb,
1083                 void *data, uid_t uid)
1084 {
1085         GVariant *result;
1086         int ret = PKGMGR_R_ECOMM;
1087         char *req_key = NULL;
1088         int req_id;
1089         pkgmgr_client_t *mpc = (pkgmgr_client_t *)pc;
1090         char *pkgtype;
1091         pkgmgrinfo_pkginfo_h handle;
1092
1093         if (pc == NULL || pkgid == NULL) {
1094                 ERR("invalid parameter");
1095                 return PKGMGR_R_EINVAL;
1096         }
1097
1098         if (mpc->ctype != PC_REQUEST) {
1099                 ERR("mpc->ctype is not PC_REQUEST");
1100                 return PKGMGR_R_EINVAL;
1101         }
1102
1103         ret = pkgmgrinfo_pkginfo_get_usr_pkginfo(pkgid, uid, &handle);
1104         if (ret < 0)
1105                 return PKGMGR_R_EINVAL;
1106
1107         ret = pkgmgrinfo_pkginfo_get_type(handle, &pkgtype);
1108         if (ret < 0) {
1109                 pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
1110                 return PKGMGR_R_ERROR;
1111         }
1112
1113         /* TODO: check removable ? */
1114
1115         result = comm_client_request(mpc->info.request.cc, "uninstall",
1116                         g_variant_new("(uss)", uid, pkgtype, pkgid));
1117         if (result == NULL) {
1118                 pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
1119                 return PKGMGR_R_ECOMM;
1120         }
1121         g_variant_get(result, "(i&s)", &ret, &req_key);
1122         if (req_key == NULL) {
1123                 g_variant_unref(result);
1124                 pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
1125                 return PKGMGR_R_ECOMM;
1126         }
1127         if (ret != PKGMGR_R_OK) {
1128                 g_variant_unref(result);
1129                 pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
1130                 return ret;
1131         }
1132
1133         req_id = _get_request_id();
1134         __add_op_cbinfo(mpc, req_id, req_key, event_cb, NULL, data);
1135
1136         g_variant_unref(result);
1137         pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
1138
1139         return req_id;
1140 }
1141
1142 API int pkgmgr_client_move(pkgmgr_client *pc, const char *pkg_type,
1143                 const char *pkgid, pkgmgr_move_type move_type, pkgmgr_mode mode)
1144 {
1145         return pkgmgr_client_usr_move(pc, pkg_type, pkgid, move_type, mode,
1146                         GLOBAL_USER);
1147 }
1148 API int pkgmgr_client_usr_move(pkgmgr_client *pc, const char *pkg_type,
1149                 const char *pkgid, pkgmgr_move_type move_type,
1150                 pkgmgr_mode mode, uid_t uid)
1151 {
1152         GVariant *result;
1153         int ret = PKGMGR_R_ECOMM;
1154         pkgmgr_client_t *mpc = (pkgmgr_client_t *)pc;
1155
1156         if (pc == NULL || pkg_type == NULL || pkgid == NULL) {
1157                 ERR("invalid parameter");
1158                 return PKGMGR_R_EINVAL;
1159         }
1160
1161         if ((move_type < PM_MOVE_TO_INTERNAL) || (move_type > PM_MOVE_TO_SDCARD))
1162                 return PKGMGR_R_EINVAL;
1163
1164         if (mpc->ctype != PC_REQUEST) {
1165                 ERR("mpc->ctype is not PC_REQUEST");
1166                 return PKGMGR_R_EINVAL;
1167         }
1168
1169         result = comm_client_request(mpc->info.request.cc, "move",
1170                         g_variant_new("(uss)", uid, pkg_type, pkgid));
1171         if (result == NULL)
1172                 return PKGMGR_R_ECOMM;
1173         g_variant_get(result, "(i)", &ret);
1174         g_variant_unref(result);
1175
1176         return ret;
1177 }
1178
1179 API int pkgmgr_client_usr_activate(pkgmgr_client *pc, const char *pkg_type,
1180                 const char *pkgid, uid_t uid)
1181 {
1182         GVariant *result;
1183         int ret = PKGMGR_R_ECOMM;
1184         pkgmgr_client_t *mpc = (pkgmgr_client_t *)pc;
1185
1186         if (pc == NULL || pkgid == NULL) {
1187                 ERR("invalid parameter");
1188                 return PKGMGR_R_EINVAL;
1189         }
1190
1191         result = comm_client_request(mpc->info.request.cc, "enable_pkg",
1192                         g_variant_new("(us)", uid, pkgid));
1193         if (result == NULL)
1194                 return PKGMGR_R_ECOMM;
1195         g_variant_get(result, "(i)", &ret);
1196         g_variant_unref(result);
1197
1198         return ret;
1199 }
1200
1201 API int pkgmgr_client_activate(pkgmgr_client *pc, const char *pkg_type,
1202                 const char *pkgid)
1203 {
1204         return pkgmgr_client_usr_activate(pc, pkg_type, pkgid, GLOBAL_USER);
1205 }
1206
1207 API int pkgmgr_client_usr_deactivate(pkgmgr_client *pc, const char *pkg_type,
1208                                  const char *pkgid, uid_t uid)
1209 {
1210         GVariant *result;
1211         int ret = PKGMGR_R_ECOMM;
1212         pkgmgr_client_t *mpc = (pkgmgr_client_t *)pc;
1213
1214         if (pc == NULL || pkgid == NULL) {
1215                 ERR("invalid parameter");
1216                 return PKGMGR_R_EINVAL;
1217         }
1218
1219         result = comm_client_request(mpc->info.request.cc, "disable_pkg",
1220                         g_variant_new("(us)", uid, pkgid));
1221         if (result == NULL)
1222                 return PKGMGR_R_ECOMM;
1223         g_variant_get(result, "(i)", &ret);
1224         g_variant_unref(result);
1225
1226         return ret;
1227 }
1228
1229 API int pkgmgr_client_deactivate(pkgmgr_client *pc, const char *pkg_type,
1230                                  const char *pkgid)
1231 {
1232         return pkgmgr_client_usr_deactivate(pc, pkg_type, pkgid, GLOBAL_USER);
1233 }
1234
1235 API int pkgmgr_client_usr_activate_app(pkgmgr_client *pc, const char *appid,
1236                 uid_t uid)
1237 {
1238         GVariant *result;
1239         int ret = PKGMGR_R_ECOMM;
1240         pkgmgr_client_t *mpc = (pkgmgr_client_t *)pc;
1241
1242         if (pc == NULL || appid == NULL) {
1243                 ERR("invalid parameter");
1244                 return PKGMGR_R_EINVAL;
1245         }
1246
1247         result = comm_client_request(mpc->info.request.cc, "enable_app",
1248                         g_variant_new("(us)", uid, appid));
1249         if (result == NULL)
1250                 return PKGMGR_R_ECOMM;
1251         g_variant_get(result, "(i)", &ret);
1252         g_variant_unref(result);
1253
1254         return ret;
1255 }
1256
1257 API int pkgmgr_client_activate_app(pkgmgr_client * pc, const char *appid)
1258 {
1259         return pkgmgr_client_usr_activate_app(pc, appid, GLOBAL_USER);
1260 }
1261
1262 /* TODO: deprecate? */
1263 API int pkgmgr_client_usr_activate_appv(pkgmgr_client *pc, const char *appid,
1264                 char *const argv[], uid_t uid)
1265 {
1266         return pkgmgr_client_usr_activate_app(pc, appid, uid);
1267 }
1268
1269 API int pkgmgr_client_activate_appv(pkgmgr_client *pc, const char *appid,
1270                 char *const argv[])
1271 {
1272         return pkgmgr_client_usr_activate_app(pc, appid, GLOBAL_USER);
1273 }
1274
1275 API int pkgmgr_client_usr_deactivate_app(pkgmgr_client *pc, const char *appid,
1276                 uid_t uid)
1277 {
1278         GVariant *result;
1279         int ret = PKGMGR_R_ECOMM;
1280         pkgmgr_client_t *mpc = (pkgmgr_client_t *)pc;
1281
1282         if (pc == NULL || appid == NULL) {
1283                 ERR("invalid parameter");
1284                 return PKGMGR_R_EINVAL;
1285         }
1286
1287         result = comm_client_request(mpc->info.request.cc, "disable_app",
1288                         g_variant_new("(us)", uid, appid));
1289         if (result == NULL)
1290                 return PKGMGR_R_ECOMM;
1291         g_variant_get(result, "(i)", &ret);
1292         g_variant_unref(result);
1293
1294         return ret;
1295 }
1296
1297 API int pkgmgr_client_deactivate_app(pkgmgr_client *pc, const char *appid)
1298 {
1299         return pkgmgr_client_usr_deactivate_app(pc, appid, GLOBAL_USER);
1300 }
1301
1302 API int pkgmgr_client_usr_clear_user_data(pkgmgr_client *pc,
1303                 const char *pkg_type, const char *appid, pkgmgr_mode mode,
1304                 uid_t uid)
1305 {
1306         GVariant *result;
1307         int ret = PKGMGR_R_ECOMM;
1308         pkgmgr_client_t *mpc = (pkgmgr_client_t *)pc;
1309
1310         if (pc == NULL || pkg_type == NULL || appid == NULL) {
1311                 ERR("invalid parameter");
1312                 return PKGMGR_R_EINVAL;
1313         }
1314
1315         if (mpc->ctype != PC_REQUEST) {
1316                 ERR("mpc->ctype is not PC_REQUEST");
1317                 return PKGMGR_R_EINVAL;
1318         }
1319
1320         result = comm_client_request(mpc->info.request.cc, "cleardata",
1321                         g_variant_new("(uss)", uid, pkg_type, appid));
1322         if (result == NULL)
1323                 return PKGMGR_R_ECOMM;
1324
1325         g_variant_get(result, "(i)", &ret);
1326         g_variant_unref(result);
1327
1328         return ret;
1329 }
1330
1331 API int pkgmgr_client_clear_user_data(pkgmgr_client *pc, const char *pkg_type,
1332                 const char *appid, pkgmgr_mode mode)
1333 {
1334         return pkgmgr_client_usr_clear_user_data(pc, pkg_type, appid, mode,
1335                         GLOBAL_USER);
1336 }
1337
1338 API int pkgmgr_client_set_status_type(pkgmgr_client *pc, int status_type)
1339 {
1340         int ret = -1;
1341
1342         retvm_if(pc == NULL, PKGMGR_R_EINVAL, "package manager client pc is NULL");
1343         retvm_if(status_type == PKGMGR_CLIENT_STATUS_ALL, PKGMGR_R_OK, "status_type is PKGMGR_CLIENT_STATUS_ALL");
1344         pkgmgr_client_t *mpc = (pkgmgr_client_t *) pc;
1345
1346         /*  free listening head */
1347         listen_cb_info *tmp = NULL;
1348         listen_cb_info *prev = NULL;
1349         for (tmp = mpc->info.listening.lhead; tmp;) {
1350                 prev = tmp;
1351                 tmp = tmp->next;
1352                 free(prev);
1353         }
1354
1355         /* free dbus connection */
1356         ret = comm_client_free(mpc->info.listening.cc);
1357         retvm_if(ret < 0, PKGMGR_R_ERROR, "comm_client_free() failed - %d", ret);
1358
1359         /* Manage pc for seperated event */
1360         mpc->ctype = PC_LISTENING;
1361         mpc->status_type = status_type;
1362
1363         mpc->info.listening.cc = comm_client_new();
1364         retvm_if(mpc->info.listening.cc == NULL, PKGMGR_R_EINVAL, "client creation failed");
1365
1366         if ((mpc->status_type & PKGMGR_CLIENT_STATUS_INSTALL) == PKGMGR_CLIENT_STATUS_INSTALL) {
1367                 ret = comm_client_set_status_callback(COMM_STATUS_BROADCAST_INSTALL, mpc->info.listening.cc, __status_callback, pc);
1368                 retvm_if(ret < 0, PKGMGR_R_ECOMM, "PKGMGR_CLIENT_STATUS_INSTALL failed - %d", ret);
1369         }
1370
1371         if ((mpc->status_type & PKGMGR_CLIENT_STATUS_UNINSTALL) == PKGMGR_CLIENT_STATUS_UNINSTALL) {
1372                 ret = comm_client_set_status_callback(COMM_STATUS_BROADCAST_UNINSTALL, mpc->info.listening.cc, __status_callback, pc);
1373                 retvm_if(ret < 0, PKGMGR_R_ECOMM, "COMM_STATUS_BROADCAST_UNINSTALL failed - %d", ret);
1374         }
1375
1376         if ((mpc->status_type & PKGMGR_CLIENT_STATUS_MOVE) == PKGMGR_CLIENT_STATUS_MOVE) {
1377                 ret = comm_client_set_status_callback(COMM_STATUS_BROADCAST_MOVE, mpc->info.listening.cc, __status_callback, pc);
1378                 retvm_if(ret < 0, PKGMGR_R_ECOMM, "COMM_STATUS_BROADCAST_MOVE failed - %d", ret);
1379         }
1380
1381         if ((mpc->status_type & PKGMGR_CLIENT_STATUS_INSTALL_PROGRESS) == PKGMGR_CLIENT_STATUS_INSTALL_PROGRESS) {
1382                 ret = comm_client_set_status_callback(COMM_STATUS_BROADCAST_INSTALL_PROGRESS, mpc->info.listening.cc, __status_callback, pc);
1383                 retvm_if(ret < 0, PKGMGR_R_ECOMM, "COMM_STATUS_BROADCAST_INSTALL_PROGRESS failed - %d", ret);
1384         }
1385
1386    if ((mpc->status_type & PKGMGR_CLIENT_STATUS_UPGRADE) == PKGMGR_CLIENT_STATUS_UPGRADE) {
1387            ret = comm_client_set_status_callback(COMM_STATUS_BROADCAST_UPGRADE, mpc->info.listening.cc, __status_callback, pc);
1388            retvm_if(ret < 0, PKGMGR_R_ECOMM, "COMM_STATUS_BROADCAST_UPGRADE failed - %d", ret);
1389    }
1390
1391    return PKGMGR_R_OK;
1392 }
1393
1394 API int pkgmgr_client_listen_status(pkgmgr_client *pc, pkgmgr_handler event_cb,
1395                                     void *data)
1396 {
1397         int req_id;
1398         /* Check for NULL value of pc */
1399         retvm_if(pc == NULL, PKGMGR_R_EINVAL, "package manager client pc is NULL");
1400         pkgmgr_client_t *mpc = (pkgmgr_client_t *) pc;
1401
1402         /* 0. check input */
1403         retvm_if(mpc->ctype != PC_LISTENING, PKGMGR_R_EINVAL, "ctype is not PC_LISTENING");
1404         retvm_if(event_cb == NULL, PKGMGR_R_EINVAL, "event_cb is NULL");
1405
1406         /* 1. get id */
1407         req_id = _get_request_id();
1408
1409         /* 2. add callback info to pkgmgr_client */
1410         __add_stat_cbinfo(mpc, req_id, event_cb, data);
1411         return req_id;
1412 }
1413
1414 API int pkgmgr_client_broadcast_status(pkgmgr_client *pc, const char *pkg_type,
1415                                        const char *pkgid, const char *key,
1416                                        const char *val)
1417 {
1418         /* client cannot broadcast signal */
1419         return PKGMGR_R_OK;
1420 }
1421
1422 API int pkgmgr_client_request_service(pkgmgr_request_service_type service_type, int service_mode,
1423                                   pkgmgr_client * pc, const char *pkg_type, const char *pkgid,
1424                               const char *custom_info, pkgmgr_handler event_cb, void *data)
1425 {
1426         return pkgmgr_client_usr_request_service(service_type, service_mode, pc, pkg_type, pkgid, GLOBAL_USER, custom_info, event_cb, data);
1427 }
1428
1429 API int pkgmgr_client_usr_request_service(pkgmgr_request_service_type service_type, int service_mode,
1430                                   pkgmgr_client * pc, const char *pkg_type, const char *pkgid, uid_t uid,
1431                               const char *custom_info, pkgmgr_handler event_cb, void *data)
1432 {
1433         int ret =0;
1434
1435         /* Check for NULL value of service type */
1436         retvm_if(service_type > PM_REQUEST_MAX, PKGMGR_R_EINVAL, "service type is not defined\n");
1437         retvm_if(service_type < 0, PKGMGR_R_EINVAL, "service type is error\n");
1438
1439         switch (service_type) {
1440         case PM_REQUEST_CSC:
1441                 tryvm_if(custom_info == NULL, ret = PKGMGR_R_EINVAL, "custom_info is NULL\n");
1442                 tryvm_if(strlen(custom_info) >= PKG_STRING_LEN_MAX, ret = PKGMGR_R_EINVAL, "optional_file over PKG_STRING_LEN_MAX");
1443                 tryvm_if(data == NULL, ret = PKGMGR_R_EINVAL, "data is NULL\n");
1444
1445                 ret = __csc_process(custom_info, (char *)data);
1446                 if (ret < 0)
1447                         ERR("__csc_process fail \n");
1448                 else
1449                         ret = PKGMGR_R_OK;
1450
1451                 break;
1452
1453         case PM_REQUEST_MOVE:
1454                 tryvm_if(pkgid == NULL, ret = PKGMGR_R_EINVAL, "pkgid is NULL\n");
1455                 tryvm_if(pc == NULL, ret = PKGMGR_R_EINVAL, "pc is NULL\n");
1456                 tryvm_if((service_mode < PM_MOVE_TO_INTERNAL) || (service_mode > PM_MOVE_TO_SDCARD), ret = PKGMGR_R_EINVAL, "service_mode is wrong\n");
1457
1458                 ret = __move_pkg_process(pc, pkgid, pkg_type, uid, (pkgmgr_move_type)service_mode, event_cb, data);
1459                 break;
1460
1461         case PM_REQUEST_GET_SIZE:
1462                 tryvm_if(pkgid == NULL, ret = PKGMGR_R_EINVAL, "pkgid is NULL\n");
1463                 tryvm_if(pc == NULL, ret = PKGMGR_R_EINVAL, "pc is NULL\n");
1464                 tryvm_if((service_mode < PM_GET_TOTAL_SIZE) || (service_mode >= PM_GET_MAX), ret = PKGMGR_R_EINVAL, "service_mode is wrong\n");
1465
1466                 ret = __get_size_process(pc, pkgid, uid, (pkgmgr_getsize_type)service_mode, event_cb, data);
1467                 break;
1468
1469         case PM_REQUEST_KILL_APP:
1470         case PM_REQUEST_CHECK_APP:
1471                 tryvm_if(pkgid == NULL, ret = PKGMGR_R_EINVAL, "pkgid is NULL\n");
1472                 tryvm_if(pc == NULL, ret = PKGMGR_R_EINVAL, "pc is NULL\n");
1473
1474                 ret = __check_app_process(service_type, pc, pkgid, uid, data);
1475                 if (ret < 0)
1476                         ERR("__check_app_process fail \n");
1477                 else
1478                         ret = PKGMGR_R_OK;
1479
1480                 break;
1481
1482         default:
1483                 ERR("Wrong Request\n");
1484                 ret = -1;
1485                 break;
1486         }
1487
1488 catch:
1489
1490         return ret;
1491 }
1492
1493
1494 API int pkgmgr_client_usr_request_size_info(uid_t uid)
1495 {
1496         int ret = 0;
1497         pkgmgr_client *pc = NULL;
1498
1499         pc = pkgmgr_client_new(PC_REQUEST);
1500         retvm_if(pc == NULL, PKGMGR_R_EINVAL, "request pc is null\n");
1501
1502         ret = __request_size_info(pc, uid);
1503         if (ret < 0) {
1504                 ERR("__request_size_info fail \n");
1505         }
1506
1507         pkgmgr_client_free(pc);
1508         return ret;
1509 }
1510
1511 API int pkgmgr_client_request_size_info(void) // get all package size (data, total)
1512 {
1513         return pkgmgr_client_usr_request_size_info(GLOBAL_USER);
1514 }
1515
1516 API int pkgmgr_client_usr_clear_cache_dir(const char *pkgid, uid_t uid)
1517 {
1518         GVariant *result;
1519         int ret = PKGMGR_R_ECOMM;
1520         pkgmgr_client_t *pc;
1521
1522         if (pkgid == NULL) {
1523                 ERR("invalid parameter");
1524                 return PKGMGR_R_EINVAL;
1525         }
1526
1527         pc = pkgmgr_client_new(PC_REQUEST);
1528         if (pc == NULL) {
1529                 ERR("out of memory");
1530                 return PKGMGR_R_ESYSTEM;
1531         }
1532
1533         result = comm_client_request(pc->info.request.cc, "clearcache",
1534                         g_variant_new("(us)", uid, pkgid));
1535         if (result == NULL)
1536                 return PKGMGR_R_ECOMM;
1537         g_variant_get(result, "(i)", &ret);
1538         g_variant_unref(result);
1539
1540         return ret;
1541 }
1542
1543 API int pkgmgr_client_clear_cache_dir(const char *pkgid)
1544 {
1545         return pkgmgr_client_usr_clear_cache_dir(pkgid, GLOBAL_USER);
1546 }
1547
1548 API int pkgmgr_client_clear_usr_all_cache_dir(uid_t uid)
1549 {
1550         return pkgmgr_client_usr_clear_cache_dir(PKG_CLEAR_ALL_CACHE, uid);
1551 }
1552
1553 API int pkgmgr_client_clear_all_cache_dir(void)
1554 {
1555         return pkgmgr_client_usr_clear_cache_dir(PKG_CLEAR_ALL_CACHE, GLOBAL_USER);
1556 }
1557
1558 API int pkgmgr_client_get_size(pkgmgr_client * pc, const char *pkgid,
1559                 pkgmgr_getsize_type get_type, pkgmgr_handler event_cb,
1560                 void *data)
1561 {
1562         return pkgmgr_client_usr_get_size(pc, pkgid, get_type, event_cb, data,
1563                         GLOBAL_USER);
1564 }
1565
1566 API int pkgmgr_client_usr_get_size(pkgmgr_client * pc, const char *pkgid,
1567                 pkgmgr_getsize_type get_type, pkgmgr_handler event_cb,
1568                 void *data, uid_t uid)
1569 {
1570         GVariant *result;
1571         int ret = PKGMGR_R_ECOMM;
1572         char *req_key = NULL;
1573         int req_id;
1574         pkgmgr_client_t *mpc = (pkgmgr_client_t *)pc;
1575
1576         if (pc == NULL || pkgid == NULL || event_cb == NULL) {
1577                 ERR("invalid parameter");
1578                 return PKGMGR_R_EINVAL;
1579         }
1580
1581         if (mpc->ctype != PC_REQUEST) {
1582                 ERR("mpc->ctype is not PC_REQUEST");
1583                 return PKGMGR_R_EINVAL;
1584         }
1585
1586         /* FIXME */
1587         if (strcmp(pkgid, PKG_SIZE_INFO_TOTAL) == 0)
1588                 get_type = PM_GET_TOTAL_PKG_SIZE_INFO;
1589         else
1590                 get_type = PM_GET_PKG_SIZE_INFO;
1591         result = comm_client_request(mpc->info.request.cc, "getsize",
1592                         g_variant_new("(usi)", uid, pkgid, get_type));
1593         if (result == NULL)
1594                 return PKGMGR_R_ECOMM;
1595
1596         g_variant_get(result, "(i&s)", &ret, &req_key);
1597         if (req_key == NULL) {
1598                 g_variant_unref(result);
1599                 return PKGMGR_R_ECOMM;
1600         }
1601         if (ret != PKGMGR_R_OK) {
1602                 g_variant_unref(result);
1603                 return ret;
1604         }
1605
1606         req_id = _get_request_id();
1607         __add_op_cbinfo(mpc, req_id, req_key, event_cb, NULL, data);
1608
1609         g_variant_unref(result);
1610
1611         return PKGMGR_R_OK;
1612 }
1613
1614 API int pkgmgr_client_usr_get_package_size_info(pkgmgr_client *pc,
1615                 const char *pkgid, pkgmgr_pkg_size_info_receive_cb event_cb,
1616                 void *user_data, uid_t uid)
1617 {
1618         GVariant *result;
1619         int ret = PKGMGR_R_ECOMM;
1620         char *req_key = NULL;
1621         int req_id;
1622         int get_type;
1623         pkgmgr_client_t *mpc = (pkgmgr_client_t *)pc;
1624
1625         if (pc == NULL || pkgid == NULL || event_cb == NULL) {
1626                 ERR("invalid parameter");
1627                 return PKGMGR_R_EINVAL;
1628         }
1629
1630         if (mpc->ctype != PC_REQUEST) {
1631                 ERR("mpc->ctype is not PC_REQUEST");
1632                 return PKGMGR_R_EINVAL;
1633         }
1634
1635         /* FIXME */
1636         if (__change_op_cb_for_getsize(mpc) < 0) {
1637                 ERR("__change_op_cb_for_getsize failed");
1638                 return PKGMGR_R_ESYSTEM;
1639         }
1640
1641         if (strcmp(pkgid, PKG_SIZE_INFO_TOTAL) == 0)
1642                 get_type = PM_GET_TOTAL_PKG_SIZE_INFO;
1643         else
1644                 get_type = PM_GET_PKG_SIZE_INFO;
1645         result = comm_client_request(mpc->info.request.cc, "getsize",
1646                         g_variant_new("(usi)", uid, pkgid, get_type));
1647         if (result == NULL)
1648                 return PKGMGR_R_ECOMM;
1649
1650         g_variant_get(result, "(i&s)", &ret, &req_key);
1651         if (req_key == NULL) {
1652                 g_variant_unref(result);
1653                 return PKGMGR_R_ECOMM;
1654         }
1655         if (ret != PKGMGR_R_OK) {
1656                 g_variant_unref(result);
1657                 return ret;
1658         }
1659
1660         req_id = _get_request_id();
1661         __add_op_cbinfo(mpc, req_id, req_key, __get_pkg_size_info_cb, event_cb,
1662                         user_data);
1663
1664         g_variant_unref(result);
1665
1666         return PKGMGR_R_OK;
1667 }
1668
1669 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)
1670 {
1671         return pkgmgr_client_usr_get_package_size_info(pc, pkgid, event_cb, user_data, GLOBAL_USER);
1672 }
1673
1674 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)
1675 {       // total package size info
1676         return pkgmgr_client_usr_get_package_size_info(pc, PKG_SIZE_INFO_TOTAL, (pkgmgr_pkg_size_info_receive_cb)event_cb, user_data, uid);
1677 }
1678
1679 API int pkgmgr_client_get_total_package_size_info(pkgmgr_client *pc, pkgmgr_total_pkg_size_info_receive_cb event_cb, void *user_data)
1680 {
1681         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);
1682 }
1683
1684 API int pkgmgr_client_generate_license_request(pkgmgr_client *pc,
1685                 const char *resp_data, char **req_data, char **license_url)
1686 {
1687         GVariant *result;
1688         int ret;
1689         char *data;
1690         char *url;
1691         pkgmgr_client_t *mpc = (pkgmgr_client_t *)pc;
1692
1693         if (pc == NULL || resp_data == NULL || req_data == NULL ||
1694                         license_url == NULL) {
1695                 ERR("invalid parameter");
1696                 return PKGMGR_R_EINVAL;
1697         }
1698
1699         if (mpc->ctype != PC_REQUEST) {
1700                 ERR("mpc->ctype is not PC_REQUEST");
1701                 return PKGMGR_R_EINVAL;
1702         }
1703
1704         result = comm_client_request(mpc->info.request.cc,
1705                         "generate_license_request",
1706                         g_variant_new("(s)", resp_data));
1707         if (result == NULL)
1708                 return PKGMGR_R_ECOMM;
1709
1710         g_variant_get(result, "(i&s&s)", &ret, &data, &url);
1711         if (ret != PKGMGR_R_OK) {
1712                 ERR("generate_license_request failed: %d", ret);
1713                 g_variant_unref(result);
1714                 return ret;
1715         }
1716
1717         *req_data = strdup(data);
1718         *license_url = strdup(url);
1719
1720         g_variant_unref(result);
1721
1722         return PKGMGR_R_OK;
1723 }
1724
1725 API int pkgmgr_client_register_license(pkgmgr_client *pc, const char *resp_data)
1726 {
1727         GVariant *result;
1728         int ret;
1729         pkgmgr_client_t *mpc = (pkgmgr_client_t *)pc;
1730
1731         if (pc == NULL || resp_data == NULL) {
1732                 ERR("invalid parameter");
1733                 return PKGMGR_R_EINVAL;
1734         }
1735
1736         if (mpc->ctype != PC_REQUEST) {
1737                 ERR("mpc->ctype is not PC_REQUEST");
1738                 return PKGMGR_R_EINVAL;
1739         }
1740
1741         result = comm_client_request(mpc->info.request.cc,
1742                         "register_license", g_variant_new("(s)", resp_data));
1743         if (result == NULL)
1744                 return PKGMGR_R_ECOMM;
1745
1746         g_variant_get(result, "(i)", &ret);
1747         g_variant_unref(result);
1748         if (ret != PKGMGR_R_OK) {
1749                 ERR("register license failed: %d", ret);
1750                 return ret;
1751         }
1752
1753         return PKGMGR_R_OK;
1754 }
1755
1756 API int pkgmgr_client_decrypt_package(pkgmgr_client *pc,
1757                 const char *drm_file_path, const char *decrypted_file_path)
1758 {
1759         GVariant *result;
1760         int ret;
1761         pkgmgr_client_t *mpc = (pkgmgr_client_t *)pc;
1762
1763         if (pc == NULL || drm_file_path == NULL ||
1764                         decrypted_file_path == NULL) {
1765                 ERR("invalid parameter");
1766                 return PKGMGR_R_EINVAL;
1767         }
1768
1769         if (mpc->ctype != PC_REQUEST) {
1770                 ERR("mpc->ctype is not PC_REQUEST");
1771                 return PKGMGR_R_EINVAL;
1772         }
1773
1774         result = comm_client_request(mpc->info.request.cc,
1775                         "decrypt_package", g_variant_new("(ss)",
1776                                 drm_file_path, decrypted_file_path));
1777         if (result == NULL)
1778                 return PKGMGR_R_ECOMM;
1779
1780         g_variant_get(result, "(i)", &ret);
1781         g_variant_unref(result);
1782         if (ret != PKGMGR_R_OK) {
1783                 ERR("decrypt_package failed: %d", ret);
1784                 return ret;
1785         }
1786
1787         return PKGMGR_R_OK;
1788 }