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