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