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