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