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