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