client/src/pkgmgr.c

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