client/src/pkgmgr.c

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