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 #include <dbus/dbus.h>
  33 #include <dbus/dbus-glib-lowlevel.h>
  34 #include <ail.h>
  35 #include <vconf.h>
  36 #include <db-util.h>
  37 #include <pkgmgr-info.h>
  38 #include <iniparser.h>
  39
  40 /* For multi-user support */
  41 #include <tzplatform_config.h>
  42
  43 #include "package-manager.h"
  44 #include "pkgmgr-internal.h"
  45 #include "pkgmgr-debug.h"
  46 #include "pkgmgr-api.h"
  47 #include "comm_client.h"
  48 #include "comm_status_broadcast_server.h"
  49
  50 #define PKG_TMP_PATH tzplatform_mkpath(TZ_USER_APP, "tmp")
  51
  52 #define BINSH_NAME      "/bin/sh"
  53 #define BINSH_SIZE      7
  54
  55 #define GLOBAL_USER tzplatform_getuid(TZ_SYS_GLOBALAPP_USER)
  56
  57 static int _get_request_id()
  58 {
  59         static int internal_req_id = 1;
  60
  61         return internal_req_id++;
  62 }
  63
  64 typedef struct _req_cb_info {
  65         int request_id;
  66         char *req_key;
  67         pkgmgr_handler event_cb;
  68         void *data;
  69         struct _req_cb_info *next;
  70 } req_cb_info;
  71
  72 typedef struct _listen_cb_info {
  73         int request_id;
  74         pkgmgr_handler event_cb;
  75         void *data;
  76         struct _listen_cb_info *next;
  77 } listen_cb_info;
  78
  79 typedef struct _pkgmgr_client_t {
  80         client_type ctype;
  81         int status_type;
  82         union {
  83                 struct _request {
  84                         comm_client *cc;
  85                         req_cb_info *rhead;
  86                 } request;
  87                 struct _listening {
  88                         comm_client *cc;
  89                         listen_cb_info *lhead;
  90                 } listening;
  91                 struct _broadcast {
  92                         DBusConnection *bc;
  93                 } broadcast;
  94         } info;
  95         void *new_event_cb;
  96 } pkgmgr_client_t;
  97
  98 typedef struct _iter_data {
  99         pkgmgr_iter_fn iter_fn;
 100         void *data;
 101 } iter_data;
 102
 103 static int __xsystem(const char *argv[])
 104 {
 105         int status = 0;
 106         pid_t pid;
 107         pid = fork();
 108         switch (pid) {
 109         case -1:
 110                 perror("fork failed");
 111                 return -1;
 112         case 0:
 113                 /* child */
 114                 execvp(argv[0], (char *const *)argv);
 115                 _exit(-1);
 116         default:
 117                 /* parent */
 118                 break;
 119         }
 120         if (waitpid(pid, &status, 0) == -1) {
 121                 perror("waitpid failed");
 122                 return -1;
 123         }
 124         if (WIFSIGNALED(status)) {
 125                 perror("signal");
 126                 return -1;
 127         }
 128         if (!WIFEXITED(status)) {
 129                 /* shouldn't happen */
 130                 perror("should not happen");
 131                 return -1;
 132         }
 133         return WEXITSTATUS(status);
 134 }
 135
 136 static void __error_to_string(int errnumber, char **errstr)
 137 {
 138         if (errstr == NULL)
 139                 return;
 140         switch (errnumber) {
 141         case PKGCMD_ERR_PACKAGE_NOT_FOUND:
 142                 *errstr = PKGCMD_ERR_PACKAGE_NOT_FOUND_STR;
 143                 break;
 144         case PKGCMD_ERR_PACKAGE_INVALID:
 145                 *errstr = PKGCMD_ERR_PACKAGE_INVALID_STR;
 146                 break;
 147         case PKGCMD_ERR_PACKAGE_LOWER_VERSION:
 148                 *errstr = PKGCMD_ERR_PACKAGE_LOWER_VERSION_STR;
 149                 break;
 150         case PKGCMD_ERR_PACKAGE_EXECUTABLE_NOT_FOUND:
 151                 *errstr = PKGCMD_ERR_PACKAGE_EXECUTABLE_NOT_FOUND_STR;
 152                 break;
 153         case PKGCMD_ERR_MANIFEST_INVALID:
 154                 *errstr = PKGCMD_ERR_MANIFEST_INVALID_STR;
 155                 break;
 156         case PKGCMD_ERR_CONFIG_NOT_FOUND:
 157                 *errstr = PKGCMD_ERR_CONFIG_NOT_FOUND_STR;
 158                 break;
 159         case PKGCMD_ERR_CONFIG_INVALID:
 160                 *errstr = PKGCMD_ERR_CONFIG_INVALID_STR;
 161                 break;
 162         case PKGCMD_ERR_SIGNATURE_NOT_FOUND:
 163                 *errstr = PKGCMD_ERR_SIGNATURE_NOT_FOUND_STR;
 164                 break;
 165         case PKGCMD_ERR_SIGNATURE_INVALID:
 166                 *errstr = PKGCMD_ERR_SIGNATURE_INVALID_STR;
 167                 break;
 168         case PKGCMD_ERR_SIGNATURE_VERIFICATION_FAILED:
 169                 *errstr = PKGCMD_ERR_SIGNATURE_VERIFICATION_FAILED_STR;
 170                 break;
 171         case PKGCMD_ERR_ROOT_CERTIFICATE_NOT_FOUND:
 172                 *errstr = PKGCMD_ERR_ROOT_CERTIFICATE_NOT_FOUND_STR;
 173                 break;
 174         case PKGCMD_ERR_CERTIFICATE_INVALID:
 175                 *errstr = PKGCMD_ERR_CERTIFICATE_INVALID_STR;
 176                 break;
 177         case PKGCMD_ERR_CERTIFICATE_CHAIN_VERIFICATION_FAILED:
 178                 *errstr = PKGCMD_ERR_CERTIFICATE_CHAIN_VERIFICATION_FAILED_STR;
 179                 break;
 180         case PKGCMD_ERR_CERTIFICATE_EXPIRED:
 181                 *errstr = PKGCMD_ERR_CERTIFICATE_EXPIRED_STR;
 182                 break;
 183         case PKGCMD_ERR_INVALID_PRIVILEGE:
 184                 *errstr = PKGCMD_ERR_INVALID_PRIVILEGE_STR;
 185                 break;
 186         case PKGCMD_ERR_MENU_ICON_NOT_FOUND:
 187                 *errstr = PKGCMD_ERR_MENU_ICON_NOT_FOUND_STR;
 188                 break;
 189         case PKGCMD_ERR_FATAL_ERROR:
 190                 *errstr = PKGCMD_ERR_FATAL_ERROR_STR;
 191                 break;
 192         case PKGCMD_ERR_OUT_OF_STORAGE:
 193                 *errstr = PKGCMD_ERR_OUT_OF_STORAGE_STR;
 194                 break;
 195         case PKGCMD_ERR_OUT_OF_MEMORY:
 196                 *errstr = PKGCMD_ERR_OUT_OF_MEMORY_STR;
 197                 break;
 198         case PKGCMD_ERR_ARGUMENT_INVALID:
 199                 *errstr = PKGCMD_ERR_ARGUMENT_INVALID_STR;
 200                 break;
 201         default:
 202                 *errstr = PKGCMD_ERR_UNKNOWN_STR;
 203                 break;
 204         }
 205 }
 206
 207 static void __add_op_cbinfo(pkgmgr_client_t * pc, int request_id,
 208                             const char *req_key, pkgmgr_handler event_cb, void *new_event_cb,
 209                             void *data)
 210 {
 211         req_cb_info *cb_info;
 212         req_cb_info *current;
 213         req_cb_info *prev;
 214
 215         cb_info = (req_cb_info *) calloc(1, sizeof(req_cb_info));
 216         if (cb_info == NULL) {
 217                 DBG("calloc failed");
 218                 return;
 219         }
 220         cb_info->request_id = request_id;
 221         cb_info->req_key = strdup(req_key);
 222         cb_info->event_cb = event_cb;
 223         cb_info->data = data;
 224         cb_info->next = NULL;
 225         pc->new_event_cb = new_event_cb;
 226
 227         if (pc->info.request.rhead == NULL)
 228                 pc->info.request.rhead = cb_info;
 229         else {
 230                 current = prev = pc->info.request.rhead;
 231                 while (current) {
 232                         prev = current;
 233                         current = current->next;
 234                 }
 235
 236                 prev->next = cb_info;
 237         }
 238 }
 239
 240 static req_cb_info *__find_op_cbinfo(pkgmgr_client_t *pc, const char *req_key)
 241 {
 242         req_cb_info *tmp;
 243
 244         tmp = pc->info.request.rhead;
 245
 246         if (tmp == NULL) {
 247                 ERR("tmp is NULL");
 248                 return NULL;
 249         }
 250
 251         DBG("tmp->req_key %s, req_key %s", tmp->req_key, req_key);
 252
 253         while (tmp) {
 254                 if (strncmp(tmp->req_key, req_key, strlen(tmp->req_key)) == 0)
 255                         return tmp;
 256                 tmp = tmp->next;
 257         }
 258         return NULL;
 259 }
 260
 261 static void __remove_op_cbinfo(pkgmgr_client_t *pc, req_cb_info *info)
 262 {
 263         req_cb_info *tmp;
 264
 265         if (pc == NULL || pc->info.request.rhead == NULL || info == NULL)
 266                 return;
 267
 268         tmp = pc->info.request.rhead;
 269         while (tmp) {
 270                 if (tmp->next == info) {
 271                         tmp->next = info->next;
 272                         free(info);
 273                         return;
 274                 }
 275                 tmp = tmp->next;
 276         }
 277 }
 278
 279
 280 static void __add_stat_cbinfo(pkgmgr_client_t *pc, int request_id,
 281                               pkgmgr_handler event_cb, void *data)
 282 {
 283         listen_cb_info *cb_info;
 284         listen_cb_info *current;
 285         listen_cb_info *prev;
 286
 287         cb_info = (listen_cb_info *) calloc(1, sizeof(listen_cb_info));
 288         if (cb_info == NULL) {
 289                 DBG("calloc failed");
 290                 return;
 291         }
 292         cb_info->request_id = request_id;
 293         cb_info->event_cb = event_cb;
 294         cb_info->data = data;
 295         cb_info->next = NULL;
 296
 297         /* TODO - check the order of callback - FIFO or LIFO => Should be changed to LIFO */
 298         if (pc->info.listening.lhead == NULL)
 299                 pc->info.listening.lhead = cb_info;
 300         else {
 301                 current = prev = pc->info.listening.lhead;
 302                 while (current) {
 303                         prev = current;
 304                         current = current->next;
 305                 }
 306
 307                 prev->next = cb_info;
 308         }
 309 }
 310
 311 static void __operation_callback(void *cb_data, uid_t target_uid,
 312                                  const char *req_id, const char *pkg_type,
 313                                  const char *pkgid, const char *key,
 314                                  const char *val)
 315 {
 316         pkgmgr_client_t *pc;
 317         req_cb_info *cb_info;
 318
 319         DBG("__operation_callback() target_uid[%u] req_id[%s] pkg_type[%s] "
 320               "pkgid[%s] key[%s] val[%s]\n",
 321               target_uid, req_id, pkg_type, pkgid, key, val);
 322
 323         pc = (pkgmgr_client_t *) cb_data;
 324
 325         /* find callback info */
 326         cb_info = __find_op_cbinfo(pc, req_id);
 327         if (cb_info == NULL)
 328                 return;
 329
 330         DBG("__find_op_cbinfo");
 331
 332         /* call callback */
 333         if (cb_info->event_cb) {
 334                 if (pc->new_event_cb) {
 335                         cb_info->event_cb(target_uid, cb_info->request_id,
 336                                         pkg_type, pkgid, key, val, pc,
 337                                         cb_info->data);
 338                 } else {
 339                         cb_info->event_cb(target_uid, cb_info->request_id,
 340                                         pkg_type, pkgid, key, val, NULL,
 341                                         cb_info->data);
 342                 }
 343                 DBG("event_cb is called");
 344         }
 345
 346         /*remove callback for last call
 347            if (strcmp(key, "end") == 0) {
 348            __remove_op_cbinfo(pc, cb_info);
 349            DBG("__remove_op_cbinfo");
 350            }
 351          */
 352
 353         return;
 354 }
 355
 356 static void __status_callback(void *cb_data, uid_t target_uid,
 357                               const char *req_id, const char *pkg_type,
 358                               const char *pkgid,  const char *key,
 359                               const char *val)
 360 {
 361         pkgmgr_client_t *pc;
 362         listen_cb_info *tmp;
 363
 364         DBG("__status_callback() target_uid[%u] req_id[%s] pkg_type[%s] "
 365               "pkgid[%s] key[%s] val[%s]\n", target_uid, req_id, pkg_type,
 366               pkgid, key, val);
 367
 368         pc = (pkgmgr_client_t *) cb_data;
 369
 370         tmp = pc->info.listening.lhead;
 371         while (tmp) {
 372                 if (tmp->event_cb(target_uid, tmp->request_id, pkg_type, pkgid,
 373                                   key, val, NULL, tmp->data) != 0)
 374                         break;
 375                 tmp = tmp->next;
 376         }
 377
 378         return;
 379 }
 380
 381 static char *__get_req_key(const char *pkg_path)
 382 {
 383         struct timeval tv;
 384         long curtime;
 385         char timestr[PKG_STRING_LEN_MAX];
 386         char *str_req_key;
 387         int size;
 388
 389         gettimeofday(&tv, NULL);
 390         curtime = tv.tv_sec * 1000000 + tv.tv_usec;
 391         snprintf(timestr, sizeof(timestr), "%ld", curtime);
 392
 393         size = strlen(pkg_path) + strlen(timestr) + 2;
 394         str_req_key = (char *)calloc(size, sizeof(char));
 395         if (str_req_key == NULL) {
 396                 DBG("calloc failed");
 397                 return NULL;
 398         }
 399         snprintf(str_req_key, size, "%s_%s", pkg_path, timestr);
 400
 401         return str_req_key;
 402 }
 403
 404 static char *__get_type_from_path(const char *pkg_path)
 405 {
 406         int ret;
 407         char mimetype[255] = { '\0', };
 408         char extlist[256] = { '\0', };
 409         char *pkg_type;
 410
 411         ret = _get_mime_from_file(pkg_path, mimetype, sizeof(mimetype));
 412         if (ret) {
 413                 ERR("_get_mime_from_file() failed - error code[%d]\n",
 414                       ret);
 415                 return NULL;
 416         }
 417
 418         ret = _get_mime_extension(mimetype, extlist, sizeof(extlist));
 419         if (ret) {
 420                 ERR("_get_mime_extension() failed - error code[%d]\n",
 421                       ret);
 422                 return NULL;
 423         }
 424
 425         if (strlen(extlist) == 0)
 426                 return NULL;
 427
 428         if (strchr(extlist, ',')) {
 429                 extlist[strlen(extlist) - strlen(strchr(extlist, ','))] = '\0';
 430         }
 431         pkg_type = strchr(extlist, '.') + 1;
 432         return strdup(pkg_type);
 433 }
 434
 435 static int __get_pkgid_by_appid(const char *appid, char **pkgid)
 436 {
 437         pkgmgrinfo_appinfo_h pkgmgrinfo_appinfo = NULL;
 438         int ret = -1;
 439         char *pkg_id = NULL;
 440         char *pkg_id_dup = NULL;
 441
 442         if (pkgmgrinfo_appinfo_get_appinfo(appid, &pkgmgrinfo_appinfo) != PMINFO_R_OK)
 443                 return -1;
 444
 445         if (pkgmgrinfo_appinfo_get_pkgname(pkgmgrinfo_appinfo, &pkg_id) != PMINFO_R_OK)
 446                 goto err;
 447
 448         pkg_id_dup = strdup(pkg_id);
 449         if (pkg_id_dup == NULL)
 450                 goto err;
 451
 452         *pkgid = pkg_id_dup;
 453         ret = PMINFO_R_OK;
 454
 455 err:
 456         pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
 457
 458         return ret;
 459 }
 460
 461 static inline ail_cb_ret_e __appinfo_cb(const ail_appinfo_h appinfo, void *user_data)
 462 {
 463         char *package;
 464         ail_cb_ret_e ret = AIL_CB_RET_CONTINUE;
 465
 466         ail_appinfo_get_str(appinfo, AIL_PROP_PACKAGE_STR, &package);
 467
 468         if (package) {
 469                 (* (char **) user_data) = strdup(package);
 470                 ret = AIL_CB_RET_CANCEL;
 471         }
 472
 473         return ret;
 474 }
 475
 476 static char *__get_app_info_from_db_by_apppath(const char *apppath, uid_t uid)
 477 {
 478         char *caller_appid = NULL;
 479         ail_filter_h filter;
 480         ail_error_e ret;
 481         int count;
 482
 483         if (apppath == NULL)
 484                 return NULL;
 485
 486         ret = ail_filter_new(&filter);
 487         if (ret != AIL_ERROR_OK) {
 488                 return NULL;
 489         }
 490
 491         ret = ail_filter_add_str(filter, AIL_PROP_X_SLP_EXE_PATH, apppath);
 492         if (ret != AIL_ERROR_OK) {
 493                 ail_filter_destroy(filter);
 494                 return NULL;
 495         }
 496
 497         if(uid != GLOBAL_USER)
 498                 ret = ail_filter_count_usr_appinfo(filter, &count, uid);
 499         else
 500                 ret = ail_filter_count_appinfo(filter, &count);
 501
 502         if (ret != AIL_ERROR_OK) {
 503                 ail_filter_destroy(filter);
 504                 return NULL;
 505         }
 506         if (count < 1) {
 507                 ail_filter_destroy(filter);
 508                 return NULL;
 509         }
 510         if(uid != GLOBAL_USER)
 511                 ail_filter_list_usr_appinfo_foreach(filter, __appinfo_cb, &caller_appid,uid);
 512         else
 513                 ail_filter_list_appinfo_foreach(filter, __appinfo_cb, &caller_appid);
 514
 515         ail_filter_destroy(filter);
 516
 517         return caller_appid;
 518 }
 519
 520 static inline int __read_proc(const char *path, char *buf, int size)
 521 {
 522         int fd = 0;
 523         int ret = 0;
 524
 525         if (buf == NULL || path == NULL)
 526                 return -1;
 527
 528         fd = open(path, O_RDONLY);
 529         if (fd < 0)
 530                 return -1;
 531
 532         ret = read(fd, buf, size - 1);
 533         if (ret <= 0) {
 534                 close(fd);
 535                 return -1;
 536         } else
 537                 buf[ret] = 0;
 538
 539         close(fd);
 540
 541         return ret;
 542 }
 543
 544 char *__proc_get_cmdline_bypid(int pid)
 545 {
 546         char buf[PKG_STRING_LEN_MAX] = {'\0', };
 547         int ret = 0;
 548
 549         snprintf(buf, sizeof(buf), "/proc/%d/cmdline", pid);
 550         ret = __read_proc(buf, buf, sizeof(buf));
 551         if (ret <= 0)
 552                 return NULL;
 553
 554         /* support app launched by shell script*/
 555         if (strncmp(buf, BINSH_NAME, BINSH_SIZE) == 0)
 556                 return strdup(&buf[BINSH_SIZE + 1]);
 557         else
 558                 return strdup(buf);
 559 }
 560
 561 static int __get_appid_bypid(int pid, char *pkgname, int len, uid_t uid)
 562 {
 563         char *cmdline = NULL;
 564         char *caller_appid = NULL;
 565
 566         cmdline = __proc_get_cmdline_bypid(pid);
 567         if (cmdline == NULL)
 568                 return -1;
 569
 570         caller_appid = __get_app_info_from_db_by_apppath(cmdline, uid);
 571         snprintf(pkgname, len, "%s", caller_appid);
 572
 573         free(cmdline);
 574         free(caller_appid);
 575
 576         return 0;
 577 }
 578
 579 static char *__get_caller_pkgid(uid_t uid)
 580 {
 581         char *caller_appid[PKG_STRING_LEN_MAX] = {0, };
 582         char *caller_pkgid = NULL;
 583
 584         if (__get_appid_bypid(getpid(), caller_appid, sizeof(caller_appid), uid) < 0) {
 585                 ERR("get appid fail!!!\n");
 586                 return NULL;
 587         }
 588         if (__get_pkgid_by_appid(caller_appid, &caller_pkgid) < 0){
 589                 ERR("get pkgid fail!!!\n");
 590                 return NULL;
 591         }
 592
 593         return caller_pkgid;
 594 }
 595
 596 static inline int __pkgmgr_read_proc(const char *path, char *buf, int size)
 597 {
 598         int fd;
 599         int ret;
 600
 601         if (buf == NULL || path == NULL)
 602                 return -1;
 603
 604         fd = open(path, O_RDONLY);
 605         if (fd < 0)
 606                 return -1;
 607
 608         ret = read(fd, buf, size - 1);
 609         if (ret <= 0) {
 610                 close(fd);
 611                 return -1;
 612         } else
 613                 buf[ret] = 0;
 614
 615         close(fd);
 616
 617         return ret;
 618 }
 619
 620 static inline int __pkgmgr_find_pid_by_cmdline(const char *dname,
 621                                       const char *cmdline, const char *apppath)
 622 {
 623         int pid = 0;
 624
 625         if (strncmp(cmdline, apppath, PKG_STRING_LEN_MAX-1) == 0) {
 626                 pid = atoi(dname);
 627                 if (pid != getpgid(pid))
 628                         pid = 0;
 629         }
 630
 631         return pid;
 632 }
 633
 634
 635 static int __pkgmgr_proc_iter_kill_cmdline(const char *apppath)
 636 {
 637         DIR *dp;
 638         struct dirent *dentry;
 639         int pid;
 640         int ret;
 641         char buf[PKG_STRING_LEN_MAX];
 642
 643         dp = opendir("/proc");
 644         if (dp == NULL) {
 645                 return -1;
 646         }
 647
 648         while ((dentry = readdir(dp)) != NULL) {
 649                 if (!isdigit(dentry->d_name[0]))
 650                         continue;
 651
 652                 snprintf(buf, sizeof(buf), "/proc/%s/cmdline", dentry->d_name);
 653                 ret = __pkgmgr_read_proc(buf, buf, sizeof(buf));
 654                 if (ret <= 0)
 655                         continue;
 656
 657                 pid = __pkgmgr_find_pid_by_cmdline(dentry->d_name, buf, apppath);
 658
 659                 if (pid > 0) {
 660                         int pgid;
 661
 662                         pgid = getpgid(pid);
 663                         if (pgid <= 1) {
 664                                 closedir(dp);
 665                                 return -1;
 666                         }
 667
 668                         if (killpg(pgid, SIGKILL) < 0) {
 669                                 closedir(dp);
 670                                 return -1;
 671                         }
 672                 }
 673         }
 674
 675         closedir(dp);
 676         return 0;
 677 }
 678
 679
 680 static int __app_list_cb (const pkgmgr_appinfo_h handle,
 681                                                 void *user_data)
 682 {
 683         char *exec = NULL;
 684         pkgmgr_appinfo_get_exec(handle, &exec);
 685
 686         __pkgmgr_proc_iter_kill_cmdline(exec);
 687
 688         return 0;
 689 }
 690
 691 static int __sync_process(char *req_key)
 692 {
 693         char info_file[PKG_STRING_LEN_MAX] = {'\0', };
 694         int result = 0;
 695         int check_cnt = 0;
 696
 697         snprintf(info_file, PKG_STRING_LEN_MAX, "%s/%s", PKG_TMP_PATH, req_key);
 698         while(1)
 699         {
 700                 check_cnt ++;
 701
 702                 vconf_get_int(VCONFKEY_PKGMGR_STATUS, &result);
 703                 if (result < 0) {
 704                         DBG("file is not generated yet.... wait\n");
 705                         usleep(10 * 1000);      /* 10ms sleep*/
 706                 } else {
 707                         DBG("info_file file is generated, result = %d. \n", result);
 708                         break;
 709                 }
 710
 711                 if (check_cnt > 6000) { /* 60s time over*/
 712                         DBG("wait time over!!\n");
 713                         break;
 714                 }
 715         }
 716
 717         vconf_set_int(VCONFKEY_PKGMGR_STATUS, -1);
 718
 719         return result;
 720 }
 721 static int __csc_process(const char *csc_path, char *result_path)
 722 {
 723         int ret = 0;
 724         int cnt = 0;
 725         int count = 0;
 726         int csc_fail = 0;
 727         int fd = 0;
 728         char *pkgtype = NULL;
 729         char *des = NULL;
 730         char buf[PKG_STRING_LEN_MAX] = {0,};
 731         char type_buf[1024] = { 0 };
 732         char des_buf[1024] = { 0 };
 733         dictionary *csc = NULL;
 734         FILE* file = NULL;
 735
 736         csc = iniparser_load(csc_path);
 737         retvm_if(csc == NULL, PKGMGR_R_EINVAL, "cannot open parse file [%s]", csc_path);
 738
 739         file = fopen(result_path, "w");
 740         tryvm_if(file == NULL, ret = PKGMGR_R_EINVAL, "cannot open result file [%s]", result_path);
 741
 742         count = iniparser_getint(csc, "csc packages:count", -1);
 743         tryvm_if(count == 0, ret = PKGMGR_R_ERROR, "csc [%s] dont have packages", csc_path);
 744
 745         snprintf(buf, PKG_STRING_LEN_MAX, "[result]\n");
 746         fwrite(buf, 1, strlen(buf), file);
 747         snprintf(buf, PKG_STRING_LEN_MAX, "count = %d\n", count);
 748         fwrite(buf, 1, strlen(buf), file);
 749
 750         for(cnt = 1 ; cnt <= count ; cnt++)
 751         {
 752                 snprintf(type_buf, PKG_STRING_LEN_MAX - 1, "csc packages:type_%03d", cnt);
 753                 snprintf(des_buf, PKG_STRING_LEN_MAX - 1, "csc packages:description_%03d", cnt);
 754
 755                 pkgtype = iniparser_getstring(csc, type_buf, NULL);
 756                 des = iniparser_getstring(csc, des_buf, NULL);
 757                 ret = 0;
 758
 759                 if (pkgtype == NULL) {
 760                         csc_fail++;
 761                         snprintf(buf, PKG_STRING_LEN_MAX, "%s = Fail to get pkgtype\n", type_buf);
 762                         fwrite(buf, 1, strlen(buf), file);
 763                         continue;
 764                 } else if (des == NULL) {
 765                         csc_fail++;
 766                         snprintf(buf, PKG_STRING_LEN_MAX, "%s = Fail to get description\n", des_buf);
 767                         fwrite(buf, 1, strlen(buf), file);
 768                         continue;
 769                 }
 770
 771                 snprintf(buf, PKG_STRING_LEN_MAX, "type_%03d = %s\n", cnt, pkgtype);
 772                 fwrite(buf, 1, strlen(buf), file);
 773                 snprintf(buf, PKG_STRING_LEN_MAX, "description_%03d = %s\n", cnt, des);
 774                 fwrite(buf, 1, strlen(buf), file);
 775
 776                 if (strcmp(pkgtype, "tpk") == 0) {
 777                         const char *ospinstaller_argv[] = { "/usr/bin/osp-installer", "-c", des, NULL };
 778                         ret = __xsystem(ospinstaller_argv);
 779                 } else if (strcmp(pkgtype, "wgt")== 0) {
 780                         const char *wrtinstaller_argv[] = { "/usr/bin/wrt-installer", "-c", des, NULL };
 781                         ret = __xsystem(wrtinstaller_argv);
 782                 } else {
 783                         csc_fail++;
 784                         ret = -1;
 785                 }
 786
 787                 if (ret != 0) {
 788                         char *errstr = NULL;
 789                         __error_to_string(ret, &errstr);
 790                         snprintf(buf, PKG_STRING_LEN_MAX, "result_%03d = fail[%s]\n", cnt, errstr);
 791                 }
 792                 else
 793                         snprintf(buf, PKG_STRING_LEN_MAX, "result_%03d = success\n", cnt);
 794
 795                 fwrite(buf, 1, strlen(buf), file);
 796         }
 797
 798 catch:
 799         iniparser_freedict(csc);
 800         if (file != NULL) {
 801                 fflush(file);
 802                 fd = fileno(file);
 803                 fsync(fd);
 804                 fclose(file);
 805         }
 806         return ret;
 807 }
 808
 809 static int __get_size_process(pkgmgr_client * pc, const char *pkgid, uid_t uid, pkgmgr_getsize_type get_type, pkgmgr_handler event_cb, void *data)
 810 {
 811         char *req_key = NULL;
 812         int ret =0;
 813         char *pkgtype = "rpm";
 814         char *argv[PKG_ARGC_MAX] = { NULL, };
 815         char *args = NULL;
 816         int argcnt = 0;
 817         int len = 0;
 818         char *temp = NULL;
 819         int i = 0;
 820         char buf[128] = {'\0'};
 821
 822         pkgmgr_client_t *mpc = (pkgmgr_client_t *) pc;
 823         retvm_if(mpc->ctype != PC_REQUEST, PKGMGR_R_EINVAL, "mpc->ctype is not PC_REQUEST\n");
 824
 825         req_key = __get_req_key(pkgid);
 826
 827         snprintf(buf, 128, "%d", get_type);
 828         argv[argcnt++] = strdup(pkgid);
 829         argv[argcnt++] = strdup(buf);
 830
 831         /*** add quote in all string for special charactor like '\n'***   FIX */
 832         for (i = 0; i < argcnt; i++) {
 833                 temp = g_shell_quote(argv[i]);
 834                 len += (strlen(temp) + 1);
 835                 g_free(temp);
 836         }
 837
 838         args = (char *)calloc(len, sizeof(char));
 839         tryvm_if(args == NULL, ret = PKGMGR_R_EINVAL, "installer_path fail");
 840
 841         strncpy(args, argv[0], len - 1);
 842
 843         for (i = 1; i < argcnt; i++) {
 844                 strncat(args, " ", strlen(" "));
 845                 temp = g_shell_quote(argv[i]);
 846                 strncat(args, temp, strlen(temp));
 847                 g_free(temp);
 848         }
 849         DBG("[args] %s [len] %d\n", args, len);
 850
 851         /* request */
 852         ret = comm_client_request(mpc->info.request.cc, req_key, COMM_REQ_GET_SIZE, pkgtype, pkgid, args, uid, 1);
 853         if (ret < 0)
 854                 ERR("comm_client_request failed, ret=%d\n", ret);
 855
 856         ret = __sync_process(req_key);
 857         if (ret < 0)
 858                 ERR("get size failed, ret=%d\n", ret);
 859
 860 catch:
 861         for (i = 0; i < argcnt; i++)
 862                 free(argv[i]);
 863
 864         if(args)
 865                 free(args);
 866
 867         return ret;
 868 }
 869
 870 static int __move_pkg_process(pkgmgr_client * pc, const char *pkgid, uid_t uid, pkgmgr_move_type move_type, pkgmgr_handler event_cb, void *data)
 871 {
 872         char *req_key = NULL;
 873         int req_id = 0;
 874         int ret =0;
 875         pkgmgrinfo_pkginfo_h handle;
 876         char *pkgtype = NULL;
 877         char *installer_path = NULL;
 878         char *argv[PKG_ARGC_MAX] = { NULL, };
 879         char *args = NULL;
 880         int argcnt = 0;
 881         int len = 0;
 882         char *temp = NULL;
 883         int i = 0;
 884         char buf[128] = {'\0'};
 885         char info_file[PKG_STRING_LEN_MAX] = {'\0', };
 886
 887         pkgmgr_client_t *mpc = (pkgmgr_client_t *) pc;
 888         retvm_if(mpc->ctype != PC_REQUEST, PKGMGR_R_EINVAL, "mpc->ctype is not PC_REQUEST\n");
 889
 890         if(uid != GLOBAL_USER)
 891                 ret = pkgmgrinfo_pkginfo_get_usr_pkginfo(pkgid, uid, &handle);
 892         else
 893                 ret = pkgmgrinfo_pkginfo_get_pkginfo(pkgid, &handle);
 894         retvm_if(ret < 0, PKGMGR_R_ERROR, "pkgmgr_pkginfo_get_pkginfo failed");
 895
 896         ret = pkgmgrinfo_pkginfo_get_type(handle, &pkgtype);
 897         tryvm_if(ret < 0, ret = PKGMGR_R_ERROR, "pkgmgr_pkginfo_get_type failed");
 898
 899         installer_path = _get_backend_path_with_type(pkgtype);
 900         req_key = __get_req_key(pkgid);
 901         req_id = _get_request_id();
 902
 903         /* generate argv */
 904         snprintf(buf, 128, "%d", move_type);
 905         /* argv[0] installer path */
 906         argv[argcnt++] = installer_path;
 907         /* argv[1] */
 908         argv[argcnt++] = strdup("-k");
 909         /* argv[2] */
 910         argv[argcnt++] = req_key;
 911         /* argv[3] */
 912         argv[argcnt++] = strdup("-m");
 913         /* argv[4] */
 914         argv[argcnt++] = strdup(pkgid);
 915         /* argv[5] */
 916         argv[argcnt++] = strdup("-t");
 917         /* argv[6] */
 918         argv[argcnt++] = strdup(buf);
 919
 920         /*** add quote in all string for special charactor like '\n'***   FIX */
 921         for (i = 0; i < argcnt; i++) {
 922                 temp = g_shell_quote(argv[i]);
 923                 len += (strlen(temp) + 1);
 924                 g_free(temp);
 925         }
 926
 927         args = (char *)calloc(len, sizeof(char));
 928         tryvm_if(args == NULL, ret = PKGMGR_R_EINVAL, "installer_path fail");
 929
 930         strncpy(args, argv[0], len - 1);
 931
 932         for (i = 1; i < argcnt; i++) {
 933                 strncat(args, " ", strlen(" "));
 934                 temp = g_shell_quote(argv[i]);
 935                 strncat(args, temp, strlen(temp));
 936                 g_free(temp);
 937         }
 938         DBG("[args] %s [len] %d\n", args, len);
 939
 940         /* 6. request */
 941         ret = comm_client_request(mpc->info.request.cc, req_key, COMM_REQ_TO_MOVER, pkgtype, pkgid, args, uid, 1);
 942         if (ret < 0)
 943                 ERR("comm_client_request failed, ret=%d\n", ret);
 944
 945         snprintf(info_file, PKG_STRING_LEN_MAX, "app2sd_%s", pkgid);
 946         ret = __sync_process(info_file);
 947         if (ret != 0)
 948                 ERR("move pkg failed, ret=%d\n", ret);
 949
 950 catch:
 951         for (i = 0; i < argcnt; i++)
 952                 free(argv[i]);
 953
 954         if(args)
 955                 free(args);
 956
 957         pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
 958         return ret;
 959 }
 960
 961 static int __check_app_process(pkgmgr_request_service_type service_type, pkgmgr_client * pc, const char *pkgid, uid_t uid, void *data)
 962 {
 963         const char *pkgtype;
 964         char *req_key;
 965         int ret;
 966         pkgmgrinfo_pkginfo_h handle;
 967         int pid = -1;
 968
 969         /* Check for NULL value of pc */
 970         pkgmgr_client_t *mpc = (pkgmgr_client_t *) pc;
 971         retvm_if(mpc->ctype != PC_REQUEST, PKGMGR_R_EINVAL, "mpc->ctype is not PC_REQUEST\n");
 972
 973         if (uid != GLOBAL_USER)
 974                 ret = pkgmgrinfo_pkginfo_get_usr_pkginfo(pkgid, uid, &handle);
 975         else
 976                 ret = pkgmgrinfo_pkginfo_get_pkginfo(pkgid, &handle);
 977         retvm_if(ret < 0, PKGMGR_R_ERROR, "pkgmgr_pkginfo_get_pkginfo failed");
 978
 979         ret = pkgmgrinfo_pkginfo_get_type(handle, &pkgtype);
 980         tryvm_if(ret < 0, ret = PKGMGR_R_ERROR, "pkgmgr_pkginfo_get_type failed");
 981
 982         /* 2. generate req_key */
 983         req_key = __get_req_key(pkgid);
 984
 985         /* 3. request activate */
 986         if (service_type == PM_REQUEST_KILL_APP)
 987                 ret = comm_client_request(mpc->info.request.cc, req_key, COMM_REQ_KILL_APP, pkgtype, pkgid, NULL, uid, 1);
 988         else if (service_type == PM_REQUEST_CHECK_APP)
 989                 ret = comm_client_request(mpc->info.request.cc, req_key, COMM_REQ_CHECK_APP, pkgtype, pkgid, NULL, uid, 1);
 990
 991         if (ret < 0)
 992                 ERR("request failed, ret=%d\n", ret);
 993
 994         pid  = __sync_process(req_key);
 995         * (int *) data = pid;
 996
 997 catch:
 998         free(req_key);
 999         pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
1000
1001         return ret;
1002
1003 }
1004
1005 static int __request_size_info(pkgmgr_client *pc, uid_t uid)
1006 {
1007         char *req_key = NULL;
1008         int ret =0;
1009         char *pkgtype = "getsize";
1010         char *pkgid = "size_info";
1011         pkgmgr_getsize_type get_type = PM_GET_SIZE_INFO;
1012
1013         char *argv[PKG_ARGC_MAX] = { NULL, };
1014         char *args = NULL;
1015         int argcnt = 0;
1016         int len = 0;
1017         char *temp = NULL;
1018         int i = 0;
1019         char buf[128] = {'\0'};
1020
1021         pkgmgr_client_t *mpc = (pkgmgr_client_t *) pc;
1022         retvm_if(mpc->ctype != PC_REQUEST, PKGMGR_R_EINVAL, "mpc->ctype is not PC_REQUEST\n");
1023
1024         req_key = __get_req_key(pkgid);
1025
1026         snprintf(buf, 128, "%d", get_type);
1027         argv[argcnt++] = strdup(pkgid);
1028         argv[argcnt++] = strdup(buf);
1029         argv[argcnt++] = strdup(buf);
1030
1031         /*** add quote in all string for special charactor like '\n'***   FIX */
1032         for (i = 0; i < argcnt; i++) {
1033                 temp = g_shell_quote(argv[i]);
1034                 len += (strlen(temp) + 1);
1035                 g_free(temp);
1036         }
1037
1038         args = (char *)calloc(len, sizeof(char));
1039         tryvm_if(args == NULL, ret = PKGMGR_R_EINVAL, "installer_path fail");
1040
1041         strncpy(args, argv[0], len - 1);
1042
1043         for (i = 1; i < argcnt; i++) {
1044                 strncat(args, " ", strlen(" "));
1045                 temp = g_shell_quote(argv[i]);
1046                 strncat(args, temp, strlen(temp));
1047                 g_free(temp);
1048         }
1049         DBG("[args] %s [len] %d\n", args, len);
1050
1051         /* request */
1052         ret = comm_client_request(mpc->info.request.cc, req_key, COMM_REQ_GET_SIZE, pkgtype, pkgid, args, uid, 1);
1053         if (ret < 0) {
1054                 ERR("COMM_REQ_GET_SIZE failed, ret=%d\n", ret);
1055         }
1056
1057 catch:
1058         for (i = 0; i < argcnt; i++)
1059                 free(argv[i]);
1060
1061         if(args)
1062                 free(args);
1063
1064         return ret;
1065 }
1066
1067 static int __change_op_cb_for_getsize(pkgmgr_client *pc)
1068 {
1069         int ret = -1;
1070
1071         retvm_if(pc == NULL, PKGMGR_R_EINVAL, "package manager client pc is NULL");
1072         pkgmgr_client_t *mpc = (pkgmgr_client_t *) pc;
1073
1074         /*  free listening head */
1075         req_cb_info *tmp = NULL;
1076         req_cb_info *prev = NULL;
1077         for (tmp = mpc->info.request.rhead; tmp;) {
1078                 prev = tmp;
1079                 tmp = tmp->next;
1080                 free(prev);
1081         }
1082
1083         /* free dbus connection */
1084         ret = comm_client_free(mpc->info.request.cc);
1085         retvm_if(ret < 0, PKGMGR_R_ERROR, "comm_client_free() failed - %d", ret);
1086
1087         /* Manage pc for seperated event */
1088         mpc->ctype = PC_REQUEST;
1089         mpc->status_type = PKGMGR_CLIENT_STATUS_GET_SIZE;
1090
1091
1092         mpc->info.request.cc = comm_client_new();
1093         retvm_if(mpc->info.request.cc == NULL, PKGMGR_R_ERROR, "client creation failed");
1094
1095         ret = comm_client_set_status_callback(COMM_STATUS_BROADCAST_GET_SIZE, mpc->info.request.cc, __operation_callback, pc);
1096         retvm_if(ret < 0, PKGMGR_R_ERROR, "set_status_callback() failed - %d", ret);
1097
1098         return PKGMGR_R_OK;
1099 }
1100
1101 static int __get_package_size_info(pkgmgr_client_t *mpc, char *req_key, const char *pkgid, pkgmgr_getsize_type get_type, uid_t uid)
1102 {
1103         char *argv[PKG_ARGC_MAX] = { NULL, };
1104         char *args = NULL;
1105         int argcnt = 0;
1106         char *pkgtype = "getsize"; //unused
1107         char buf[128] = { 0, };
1108         int len = 0;
1109         char *temp = NULL;
1110         int i = 0;
1111         int ret = 0;
1112
1113         snprintf(buf, 128, "%d", get_type);
1114         argv[argcnt++] = strdup(pkgid);
1115         argv[argcnt++] = strdup(buf);
1116         argv[argcnt++] = strdup("-k");
1117         argv[argcnt++] = req_key;
1118
1119         /*** add quote in all string for special charactor like '\n'***   FIX */
1120         for (i = 0; i < argcnt; i++) {
1121                 temp = g_shell_quote(argv[i]);
1122                 len += (strlen(temp) + 1);
1123                 g_free(temp);
1124         }
1125
1126         args = (char *)calloc(len, sizeof(char));
1127         tryvm_if(args == NULL, ret = PKGMGR_R_EINVAL, "installer_path fail");
1128
1129         strncpy(args, argv[0], len - 1);
1130
1131         for (i = 1; i < argcnt; i++) {
1132                 strncat(args, " ", strlen(" "));
1133                 temp = g_shell_quote(argv[i]);
1134                 strncat(args, temp, strlen(temp));
1135                 g_free(temp);
1136         }
1137         DBG("[args] %s [len] %d\n", args, len);
1138
1139         /* request */
1140         ret = comm_client_request(mpc->info.request.cc, req_key, COMM_REQ_GET_SIZE, pkgtype, pkgid, args, uid, 1);
1141         if (ret < 0)
1142                 ERR("COMM_REQ_GET_SIZE failed, ret=%d\n", ret);
1143
1144 catch:
1145         for (i = 0; i < argcnt; i++)
1146                 free(argv[i]);
1147
1148         if(args)
1149                 free(args);
1150
1151         return ret;
1152 }
1153
1154 static int __get_pkg_size_info_cb(uid_t target_uid, int req_id, const char *req_type,
1155                 const char *pkgid, const char *key,
1156                 const char *value, const void *pc, void *user_data)
1157 {
1158         int ret = 0;
1159         DBG("target_uid: %u, reqid: %d, req type: %s, pkgid: %s, unused key: %s, size info: %s",
1160                         target_uid, req_id, req_type, pkgid, key, value);
1161
1162         pkg_size_info_t *size_info = (pkg_size_info_t *)malloc(sizeof(pkg_size_info_t));
1163         retvm_if(size_info == NULL, -1, "The memory is insufficient.");
1164
1165         char *save_ptr = NULL;
1166         char *token = strtok_r((char*)value, ":", &save_ptr);
1167         size_info->data_size = atoll(token);
1168         token = strtok_r(NULL, ":", &save_ptr);
1169         size_info->cache_size = atoll(token);
1170         token = strtok_r(NULL, ":", &save_ptr);
1171         size_info->app_size = atoll(token);
1172         token = strtok_r(NULL, ":", &save_ptr);
1173         size_info->ext_data_size = atoll(token);
1174         token = strtok_r(NULL, ":", &save_ptr);
1175         size_info->ext_cache_size = atoll(token);
1176         token = strtok_r(NULL, ":", &save_ptr);
1177         size_info->ext_app_size = atoll(token);
1178
1179         DBG("data: %lld, cache: %lld, app: %lld, ext_data: %lld, ext_cache: %lld, ext_app: %lld",
1180                         size_info->data_size, size_info->cache_size, size_info->app_size,
1181                         size_info->ext_data_size, size_info->ext_cache_size, size_info->ext_app_size);
1182
1183         pkgmgr_client_t *pmc = (pkgmgr_client_t *)pc;
1184         tryvm_if(pmc == NULL, ret = -1, "pkgmgr_client instance is null.");
1185
1186         if (strcmp(pkgid, PKG_SIZE_INFO_TOTAL) == 0)
1187         {       // total package size info
1188                 pkgmgr_total_pkg_size_info_receive_cb callback = (pkgmgr_total_pkg_size_info_receive_cb)(pmc->new_event_cb);
1189                 callback((pkgmgr_client *)pc, size_info, user_data);
1190         }
1191         else
1192         {
1193                 pkgmgr_pkg_size_info_receive_cb callback = (pkgmgr_pkg_size_info_receive_cb)(pmc->new_event_cb);
1194                 callback((pkgmgr_client *)pc, pkgid, size_info, user_data);
1195         }
1196
1197 catch:
1198
1199         if(size_info){
1200                 free(size_info);
1201                 size_info = NULL;
1202         }
1203         return ret;
1204 }
1205
1206 API pkgmgr_client *pkgmgr_client_new(client_type ctype)
1207 {
1208         pkgmgr_client_t *pc = NULL;
1209         int ret = -1;
1210
1211         retvm_if(ctype != PC_REQUEST && ctype != PC_LISTENING && ctype != PC_BROADCAST, NULL, "ctype is not client_type");
1212
1213         /* Allocate memory for ADT:pkgmgr_client */
1214         pc = calloc(1, sizeof(pkgmgr_client_t));
1215         retvm_if(pc == NULL, NULL, "No memory");
1216
1217         /* Manage pc */
1218         pc->ctype = ctype;
1219         pc->status_type = PKGMGR_CLIENT_STATUS_ALL;
1220
1221         if (pc->ctype == PC_REQUEST) {
1222                 pc->info.request.cc = comm_client_new();
1223                 trym_if(pc->info.request.cc == NULL, "client creation failed");
1224
1225                 ret = comm_client_set_status_callback(COMM_STATUS_BROADCAST_ALL, pc->info.request.cc, __operation_callback, pc);
1226                 trym_if(ret < 0L, "comm_client_set_status_callback() failed - %d", ret);
1227         } else if (pc->ctype == PC_LISTENING) {
1228                 pc->info.listening.cc = comm_client_new();
1229                 trym_if(pc->info.listening.cc == NULL, "client creation failed");
1230
1231                 ret = comm_client_set_status_callback(COMM_STATUS_BROADCAST_ALL, pc->info.listening.cc, __status_callback, pc);
1232                 trym_if(ret < 0L, "comm_client_set_status_callback() failed - %d", ret);
1233         } else if (pc->ctype == PC_BROADCAST) {
1234                 pc->info.broadcast.bc = comm_status_broadcast_server_connect(COMM_STATUS_BROADCAST_ALL);
1235                 trym_if(pc->info.broadcast.bc == NULL, "client creation failed");
1236         }
1237
1238         return (pkgmgr_client *) pc;
1239
1240  catch:
1241         if (pc)
1242                 free(pc);
1243         return NULL;
1244 }
1245
1246 API int pkgmgr_client_free(pkgmgr_client *pc)
1247 {
1248         int ret = -1;
1249         pkgmgr_client_t *mpc = (pkgmgr_client_t *) pc;
1250         retvm_if(mpc == NULL, PKGMGR_R_EINVAL, "Invalid argument");
1251
1252         if (mpc->ctype == PC_REQUEST) {
1253                 req_cb_info *tmp;
1254                 req_cb_info *prev;
1255                 for (tmp = mpc->info.request.rhead; tmp;) {
1256                         prev = tmp;
1257                         tmp = tmp->next;
1258                         free(prev);
1259                 }
1260
1261                 ret = comm_client_free(mpc->info.request.cc);
1262                 tryvm_if(ret < 0, ret = PKGMGR_R_ERROR, "comm_client_free() failed");
1263         } else if (mpc->ctype == PC_LISTENING) {
1264                         listen_cb_info *tmp;
1265                         listen_cb_info *prev;
1266                         for (tmp = mpc->info.listening.lhead; tmp;) {
1267                                 prev = tmp;
1268                                 tmp = tmp->next;
1269                                 free(prev);
1270                         }
1271
1272                         ret = comm_client_free(mpc->info.listening.cc);
1273                         tryvm_if(ret < 0, ret = PKGMGR_R_ERROR, "comm_client_free() failed");
1274         } else if (mpc->ctype == PC_BROADCAST) {
1275                 comm_status_broadcast_server_disconnect(mpc->info.broadcast.bc);
1276                 ret = 0;
1277         } else {
1278                 ERR("Invalid client type\n");
1279                 return PKGMGR_R_EINVAL;
1280         }
1281
1282         free(mpc);
1283         mpc = NULL;
1284         return PKGMGR_R_OK;
1285
1286  catch:
1287         if (mpc) {
1288                 free(mpc);
1289                 mpc = NULL;
1290         }
1291         return PKGMGR_R_ERROR;
1292 }
1293
1294
1295 API int pkgmgr_client_usr_install(pkgmgr_client * pc, const char *pkg_type,
1296                               const char *descriptor_path, const char *pkg_path,
1297                               const char *optional_file, pkgmgr_mode mode,
1298                               pkgmgr_handler event_cb, void *data, uid_t uid)
1299 {
1300         char *pkgtype = NULL;
1301         char *installer_path = NULL;
1302         char *req_key = NULL;
1303         int req_id = 0;
1304         int i = 0;
1305         char *argv[PKG_ARGC_MAX] = { NULL, };
1306         char *args = NULL;
1307         int argcnt = 0;
1308         int len = 0;
1309         char *temp = NULL;
1310         int ret = 0;
1311         char *caller_pkgid = NULL;
1312
1313         caller_pkgid = __get_caller_pkgid(uid);
1314         if (caller_pkgid == NULL)
1315                 ERR("caller dont have pkgid..\n");
1316
1317         /* Check for NULL value of pc */
1318         retvm_if(pc == NULL, PKGMGR_R_EINVAL, "package manager client handle is NULL");
1319
1320         /* 0. check the pc type */
1321         pkgmgr_client_t *mpc = (pkgmgr_client_t *) pc;
1322         retvm_if(mpc->ctype != PC_REQUEST, PKGMGR_R_EINVAL, "mpc->ctype is not PC_REQUEST");
1323
1324         /* 1. check argument */
1325         if (descriptor_path) {
1326                 retvm_if(strlen(descriptor_path) >= PKG_STRING_LEN_MAX, PKGMGR_R_EINVAL, "descriptor_path over PKG_STRING_LEN_MAX");
1327                 retvm_if(access(descriptor_path, F_OK) != 0, PKGMGR_R_EINVAL, "descriptor_path access fail");
1328         }
1329
1330         retvm_if(pkg_path == NULL, PKGMGR_R_EINVAL, "pkg_path is NULL");
1331         retvm_if(strlen(pkg_path) >= PKG_STRING_LEN_MAX, PKGMGR_R_EINVAL, "pkg_path over PKG_STRING_LEN_MAX");
1332         retvm_if(access(pkg_path, F_OK) != 0, PKGMGR_R_EINVAL, "pkg_path access fail");
1333
1334         if (optional_file)
1335                 retvm_if(strlen(optional_file) >= PKG_STRING_LEN_MAX, PKGMGR_R_EINVAL, "optional_file over PKG_STRING_LEN_MAX");
1336
1337         /* 2. get installer path using pkg_path */
1338         if (pkg_type) {
1339                 installer_path = _get_backend_path_with_type(pkg_type);
1340                 pkgtype = strdup(pkg_type);
1341         } else {
1342                 installer_path = _get_backend_path(pkg_path);
1343                 pkgtype = __get_type_from_path(pkg_path);
1344         }
1345         if (installer_path == NULL) {
1346                 free(pkgtype);
1347                 ERR("installer_path is NULL\n");
1348                 return PKGMGR_R_EINVAL;
1349         }
1350
1351         /* 3. generate req_key */
1352         req_key = __get_req_key(pkg_path);
1353
1354         /* 4. add callback info - add callback info to pkgmgr_client */
1355         req_id = _get_request_id();
1356         __add_op_cbinfo(mpc, req_id, req_key, event_cb, NULL, data);
1357
1358         /* 5. generate argv */
1359
1360         /*  argv[0] installer path */
1361         argv[argcnt++] = installer_path;
1362         /* argv[1] */
1363         argv[argcnt++] = strdup("-k");
1364         /* argv[2] */
1365         argv[argcnt++] = req_key;
1366         /* argv[3] */
1367         argv[argcnt++] = strdup("-i");
1368         /* argv[(4)] if exists */
1369         if (descriptor_path)
1370                 argv[argcnt++] = strdup(descriptor_path);
1371         /* argv[4] */
1372         argv[argcnt++] = strdup(pkg_path);
1373         /* argv[(5)] if exists */
1374         if (optional_file){
1375                 argv[argcnt++] = strdup("-o");
1376                 argv[argcnt++] = strdup(optional_file);
1377         }
1378         if (caller_pkgid) {
1379                 argv[argcnt++] = strdup("-p");
1380                 argv[argcnt++] = strdup(caller_pkgid);
1381         }
1382
1383         /*** add quote in all string for special charactor like '\n'***   FIX */
1384         for (i = 0; i < argcnt; i++) {
1385                 temp = g_shell_quote(argv[i]);
1386                 len += (strlen(temp) + 1);
1387                 g_free(temp);
1388         }
1389
1390         args = (char *)calloc(len, sizeof(char));
1391         tryvm_if(args == NULL, ret = PKGMGR_R_ERROR, "calloc failed");
1392
1393         strncpy(args, argv[0], len - 1);
1394
1395         for (i = 1; i < argcnt; i++) {
1396                 strncat(args, " ", strlen(" "));
1397                 temp = g_shell_quote(argv[i]);
1398                 strncat(args, temp, strlen(temp));
1399                 g_free(temp);
1400         }
1401         DBG("[args] %s [len] %d\n", args, len);
1402
1403         /******************* end of quote ************************/
1404
1405         /* 6. request install */
1406         ret = comm_client_request(mpc->info.request.cc, req_key, COMM_REQ_TO_INSTALLER, pkgtype, pkg_path, args, uid, 1);
1407         tryvm_if(ret < 0, ret = PKGMGR_R_ECOMM, "request failed, ret=%d", ret);
1408
1409         ret = req_id;
1410
1411 catch:
1412         for (i = 0; i < argcnt; i++)
1413                 free(argv[i]);
1414
1415         if (args)
1416                 free(args);
1417         if (pkgtype)
1418                 free(pkgtype);
1419
1420         return ret;
1421 }
1422
1423
1424
1425 API int pkgmgr_client_install(pkgmgr_client * pc, const char *pkg_type,
1426                               const char *descriptor_path, const char *pkg_path,
1427                               const char *optional_file, pkgmgr_mode mode,
1428                               pkgmgr_handler event_cb, void *data)
1429 {
1430
1431
1432         return pkgmgr_client_usr_install(pc, pkg_type,
1433                               descriptor_path, pkg_path, optional_file, mode, event_cb,data,  GLOBAL_USER);
1434 }
1435
1436 API int pkgmgr_client_reinstall(pkgmgr_client * pc, const char *pkg_type, const char *pkgid,
1437                                   const char *optional_file, pkgmgr_mode mode,
1438                               pkgmgr_handler event_cb, void *data)
1439 {
1440         return pkgmgr_client_usr_reinstall(pc, pkg_type, pkgid, optional_file, mode, event_cb, data,GLOBAL_USER);
1441 }
1442
1443 API int pkgmgr_client_usr_reinstall(pkgmgr_client * pc, const char *pkg_type, const char *pkgid,
1444                                   const char *optional_file, pkgmgr_mode mode,
1445                               pkgmgr_handler event_cb, void *data, uid_t uid)
1446 {
1447         char *pkgtype = NULL;
1448         char *installer_path = NULL;
1449         char *req_key = NULL;
1450         int req_id = 0;
1451         int i = 0;
1452         char *argv[PKG_ARGC_MAX] = { NULL, };
1453         char *args = NULL;
1454         int argcnt = 0;
1455         int len = 0;
1456         char *temp = NULL;
1457         int ret = 0;
1458
1459         /* Check for NULL value of pc */
1460         retvm_if(pc == NULL, PKGMGR_R_EINVAL, "package manager client handle is NULL\n");
1461
1462         pkgmgr_client_t *mpc = (pkgmgr_client_t *) pc;
1463
1464         /* 0. check the pc type */
1465         retv_if(mpc->ctype != PC_REQUEST, PKGMGR_R_EINVAL);
1466
1467
1468         /* 1. check argument */
1469         retv_if(pkgid == NULL, PKGMGR_R_EINVAL);
1470         retv_if(strlen(pkgid) >= PKG_STRING_LEN_MAX, PKGMGR_R_EINVAL);
1471         if (optional_file) {
1472                 if (strlen(optional_file) >= PKG_STRING_LEN_MAX)
1473                         return PKGMGR_R_EINVAL;
1474         }
1475
1476         /* 2. get installer path using pkg_path */
1477         installer_path = _get_backend_path_with_type(pkg_type);
1478         pkgtype = strdup(pkg_type);
1479         tryvm_if(installer_path == NULL, ret = PKGMGR_R_EINVAL, "installer_path is null");
1480
1481         /* 3. generate req_key */
1482         req_key = __get_req_key(pkgid);
1483
1484         /* 4. add callback info - add callback info to pkgmgr_client */
1485         req_id = _get_request_id();
1486         __add_op_cbinfo(mpc, req_id, req_key, event_cb, NULL, data);
1487
1488         /* 5. generate argv */
1489
1490         /*  argv[0] installer path */
1491         argv[argcnt++] = installer_path;
1492         /* argv[1] */
1493         argv[argcnt++] = strdup("-k");
1494         /* argv[2] */
1495         argv[argcnt++] = req_key;
1496         /* argv[3] */
1497         argv[argcnt++] = strdup("-r");
1498         /* argv[4] */
1499         argv[argcnt++] = strdup(pkgid);
1500         /* argv[(5)] if exists */
1501         if (optional_file){
1502                 argv[argcnt++] = strdup("-o");
1503                 argv[argcnt++] = strdup(optional_file);
1504         }
1505
1506         /*** add quote in all string for special charactor like '\n'***   FIX */
1507         for (i = 0; i < argcnt; i++) {
1508                 temp = g_shell_quote(argv[i]);
1509                 len += (strlen(temp) + 1);
1510                 g_free(temp);
1511         }
1512
1513         args = (char *)calloc(len, sizeof(char));
1514         tryvm_if(args == NULL, ret = PKGMGR_R_ERROR, "calloc failed");
1515
1516         strncpy(args, argv[0], len - 1);
1517
1518         for (i = 1; i < argcnt; i++) {
1519                 strncat(args, " ", strlen(" "));
1520                 temp = g_shell_quote(argv[i]);
1521                 strncat(args, temp, strlen(temp));
1522                 g_free(temp);
1523         }
1524         DBG("[args] %s [len] %d\n", args, len);
1525
1526         /******************* end of quote ************************/
1527
1528         /* 6. request install */
1529         ret = comm_client_request(mpc->info.request.cc, req_key, COMM_REQ_TO_INSTALLER, pkgtype, pkgid, args, uid, 1);
1530         tryvm_if(ret < 0, ret = PKGMGR_R_ECOMM, "request failed");
1531
1532         ret = req_id;
1533
1534 catch:
1535         for (i = 0; i < argcnt; i++)
1536                 free(argv[i]);
1537
1538         if (args)
1539                 free(args);
1540         if (pkgtype)
1541                 free(pkgtype);
1542
1543         return ret;
1544 }
1545
1546 API int pkgmgr_client_uninstall(pkgmgr_client *pc, const char *pkg_type,
1547                                 const char *pkgid, pkgmgr_mode mode,
1548                                 pkgmgr_handler event_cb, void *data)
1549 {
1550         return pkgmgr_client_usr_uninstall(pc, pkg_type,pkgid, mode, event_cb,  data, GLOBAL_USER);
1551 }
1552 API int pkgmgr_client_usr_uninstall(pkgmgr_client *pc, const char *pkg_type,
1553                                 const char *pkgid, pkgmgr_mode mode,
1554                                 pkgmgr_handler event_cb, void *data, uid_t uid)
1555 {
1556         char *pkgtype;
1557         char *installer_path;
1558         char *req_key;
1559         int req_id;
1560         int i = 0;
1561         char *argv[PKG_ARGC_MAX] = { NULL, };
1562         char *args = NULL;
1563         int argcnt = 0;
1564         int len = 0;
1565         char *temp = NULL;
1566         int ret = -1;
1567         bool removable = false;
1568         char *caller_pkgid = NULL;
1569
1570         caller_pkgid = __get_caller_pkgid(uid);
1571         if (caller_pkgid == NULL)
1572                 DBG("caller dont have pkgid..\n");
1573
1574         /* Check for NULL value of pc */
1575         retvm_if(pc == NULL, PKGMGR_R_EINVAL, "package manager client handle is NULL\n");
1576
1577         pkgmgr_client_t *mpc = (pkgmgr_client_t *) pc;
1578
1579         /* 0. check the pc type */
1580         retv_if(mpc->ctype != PC_REQUEST, PKGMGR_R_EINVAL);
1581
1582         /* 1. check argument */
1583         retv_if(pkgid == NULL, PKGMGR_R_EINVAL);
1584
1585         pkgmgr_pkginfo_h handle;
1586         ret = pkgmgr_pkginfo_get_usr_pkginfo(pkgid, uid, &handle);
1587
1588         /*check package id      */
1589         tryvm_if(ret < 0, ret = PKGMGR_R_EINVAL, "pkgmgr_pkginfo_get_pkginfo fail");
1590         tryvm_if(handle == NULL, ret = PKGMGR_R_EINVAL, "Pkgid(%s) can not find in installed pkg DB! \n", pkgid);
1591
1592   if (uid != GLOBAL_USER) {
1593           /*check running app , terminate app if it is running*/
1594           ret = pkgmgr_appinfo_get_usr_list(handle, PM_UI_APP, __app_list_cb, NULL, uid);
1595           tryvm_if(ret < 0, ret = PKGMGR_R_EINVAL, "pkgmgr_appinfo_get_list : PM_UI_APP fail");
1596
1597           /*check running app , terminate app if it is running*/
1598           ret = pkgmgr_appinfo_get_usr_list(handle, PM_SVC_APP, __app_list_cb, NULL, uid);
1599           tryvm_if(ret < 0, ret = PKGMGR_R_EINVAL, "pkgmgr_appinfo_get_list : PM_SVC_APP fail");
1600   } else {
1601           /*check running app , terminate app if it is running*/
1602           ret = pkgmgr_appinfo_get_list(handle, PM_UI_APP, __app_list_cb, NULL);
1603           tryvm_if(ret < 0, ret = PKGMGR_R_EINVAL, "pkgmgr_appinfo_get_list : PM_UI_APP fail");
1604
1605           /*check running app , terminate app if it is running*/
1606           ret = pkgmgr_appinfo_get_list(handle, PM_SVC_APP, __app_list_cb, NULL);
1607           tryvm_if(ret < 0, ret = PKGMGR_R_EINVAL, "pkgmgr_appinfo_get_list : PM_SVC_APP fail");
1608         }
1609   /*check type  */
1610         ret = pkgmgr_pkginfo_get_type(handle, &pkgtype);
1611         tryvm_if(ret < 0, ret = PKGMGR_R_EINVAL, "pkgmgr_pkginfo_get_type fail");
1612         tryvm_if(pkgtype == NULL, ret = PKGMGR_R_ERROR, "pkgtype is NULL");
1613
1614         /*check removable, execpt "rpm" type    */
1615         if (strcmp(pkgtype, "rpm")) {
1616                 pkgmgr_pkginfo_is_removable(handle, &removable);
1617                 tryvm_if(removable == false, ret = PKGMGR_R_ERROR, "Pkgid(%s) can not be removed, This is non-removalbe package...\n", pkgid);
1618         }
1619
1620         /*check pkgid length    */
1621         tryvm_if(strlen(pkgid) >= PKG_STRING_LEN_MAX, ret = PKGMGR_R_EINVAL, "pkgid is too long");
1622
1623         /* 2. get installer path using pkgtype */
1624         installer_path = _get_backend_path_with_type(pkgtype);
1625         tryvm_if(installer_path == NULL, ret = PKGMGR_R_EINVAL, "installer_path fail");
1626
1627         /* 3. generate req_key */
1628         req_key = __get_req_key(pkgid);
1629
1630         /* 4. add callback info - add callback info to pkgmgr_client */
1631         req_id = _get_request_id();
1632         __add_op_cbinfo(mpc, req_id, req_key, event_cb, NULL, data);
1633
1634         /* 5. generate argv */
1635
1636         /* argv[0] installer path */
1637         argv[argcnt++] = installer_path;
1638         /* argv[1] */
1639         argv[argcnt++] = strdup("-k");
1640         /* argv[2] */
1641         argv[argcnt++] = req_key;
1642         /* argv[3] */
1643         argv[argcnt++] = strdup("-d");
1644         /* argv[4] */
1645         argv[argcnt++] = strdup(pkgid);
1646         if (caller_pkgid) {
1647                 argv[argcnt++] = strdup("-p");
1648                 argv[argcnt++] = caller_pkgid;
1649         }
1650
1651         /*** add quote in all string for special charactor like '\n'***   FIX */
1652         for (i = 0; i < argcnt; i++) {
1653                 temp = g_shell_quote(argv[i]);
1654                 len += (strlen(temp) + 1);
1655                 g_free(temp);
1656         }
1657
1658         args = (char *)calloc(len, sizeof(char));
1659         tryvm_if(args == NULL, ret = PKGMGR_R_ERROR, "calloc failed");
1660
1661         strncpy(args, argv[0], len - 1);
1662
1663         for (i = 1; i < argcnt; i++) {
1664                 strncat(args, " ", strlen(" "));
1665                 temp = g_shell_quote(argv[i]);
1666                 strncat(args, temp, strlen(temp));
1667                 g_free(temp);
1668         }
1669         DBG("[args] %s [len] %d\n", args, len);
1670
1671         /******************* end of quote ************************/
1672
1673         /* 6. request install */
1674         ret = comm_client_request(mpc->info.request.cc, req_key, COMM_REQ_TO_INSTALLER, pkgtype, pkgid, args, uid, 1);
1675         tryvm_if(ret < 0, ret = PKGMGR_R_ECOMM, "calloc failed");
1676
1677         ret = req_id;
1678
1679 catch:
1680         for (i = 0; i < argcnt; i++)
1681                 free(argv[i]);
1682
1683         if(args)
1684                 free(args);
1685
1686         pkgmgr_pkginfo_destroy_pkginfo(handle);
1687         return ret;
1688 }
1689
1690 API int pkgmgr_client_move(pkgmgr_client *pc, const char *pkg_type,
1691                                 const char *pkgid, pkgmgr_move_type move_type, pkgmgr_mode mode)
1692 {
1693         return pkgmgr_client_usr_move( pc,pkg_type, pkgid, move_type, mode, GLOBAL_USER);
1694 }
1695 API int pkgmgr_client_usr_move(pkgmgr_client *pc, const char *pkg_type,
1696                                 const char *pkgid, pkgmgr_move_type move_type, pkgmgr_mode mode, uid_t uid)
1697 {
1698         const char *pkgtype = NULL;
1699         char *installer_path = NULL;
1700         char *req_key = NULL;
1701         int i = 0;
1702         char *argv[PKG_ARGC_MAX] = { NULL, };
1703         char *args = NULL;
1704         int argcnt = 0;
1705         int len = 0;
1706         char *temp = NULL;
1707         int ret = 0;
1708         int req_id = 0;
1709         char buf[128] = {'\0'};
1710
1711         /* Check for NULL value of pc */
1712         if (pc == NULL) {
1713                 DBG("package manager client handle is NULL\n");
1714                 return PKGMGR_R_EINVAL;
1715         }
1716         pkgmgr_client_t *mpc = (pkgmgr_client_t *) pc;
1717         /*check the pc type */
1718         if (mpc->ctype != PC_REQUEST)
1719                 return PKGMGR_R_EINVAL;
1720
1721         /*check argument */
1722         if (pkgid == NULL)
1723                 return PKGMGR_R_EINVAL;
1724
1725         if (pkg_type == NULL) {
1726                 pkgtype = _get_pkg_type_from_desktop_file(pkgid, uid);
1727                 if (pkgtype == NULL)
1728                         return PKGMGR_R_EINVAL;
1729         } else
1730                 pkgtype = pkg_type;
1731
1732         if (strlen(pkgid) >= PKG_STRING_LEN_MAX)
1733                 return PKGMGR_R_EINVAL;
1734
1735         if ((move_type < PM_MOVE_TO_INTERNAL) || (move_type > PM_MOVE_TO_SDCARD))
1736                 return PKGMGR_R_EINVAL;
1737
1738         /* get installer path using pkg_path */
1739         installer_path = _get_backend_path_with_type(pkgtype);
1740         if (installer_path == NULL)
1741                 return PKGMGR_R_EINVAL;
1742
1743         /* generate req_key */
1744         req_key = __get_req_key(pkgid);
1745         req_id = _get_request_id();
1746
1747         /* generate argv */
1748         snprintf(buf, 128, "%d", move_type);
1749         /* argv[0] installer path */
1750         argv[argcnt++] = installer_path;
1751         /* argv[1] */
1752         argv[argcnt++] = strdup("-k");
1753         /* argv[2] */
1754         argv[argcnt++] = req_key;
1755         /* argv[3] */
1756         argv[argcnt++] = strdup("-m");
1757         /* argv[4] */
1758         argv[argcnt++] = strdup(pkgid);
1759         /* argv[5] */
1760         argv[argcnt++] = strdup("-t");
1761         /* argv[6] */
1762         argv[argcnt++] = strdup(buf);
1763
1764         /*** add quote in all string for special charactor like '\n'***   FIX */
1765         for (i = 0; i < argcnt; i++) {
1766                 temp = g_shell_quote(argv[i]);
1767                 len += (strlen(temp) + 1);
1768                 g_free(temp);
1769         }
1770
1771         args = (char *)calloc(len, sizeof(char));
1772         if (args == NULL) {
1773                 DBG("calloc failed");
1774
1775                 for (i = 0; i < argcnt; i++)
1776                         free(argv[i]);
1777
1778                 return PKGMGR_R_ERROR;
1779         }
1780         strncpy(args, argv[0], len - 1);
1781
1782         for (i = 1; i < argcnt; i++) {
1783                 strncat(args, " ", strlen(" "));
1784                 temp = g_shell_quote(argv[i]);
1785                 strncat(args, temp, strlen(temp));
1786                 g_free(temp);
1787         }
1788         DBG("[args] %s [len] %d\n", args, len);
1789         /******************* end of quote ************************/
1790
1791         /* 6. request install */
1792         ret = comm_client_request(mpc->info.request.cc, req_key,
1793                                   COMM_REQ_TO_MOVER, pkgtype, pkgid,
1794                                   args, uid, 1);
1795         if (ret < 0) {
1796                 ERR("request failed, ret=%d\n", ret);
1797
1798                 for (i = 0; i < argcnt; i++)
1799                         free(argv[i]);
1800
1801                 free(args);
1802                 return PKGMGR_R_ECOMM;
1803         }
1804
1805         for (i = 0; i < argcnt; i++)
1806                 free(argv[i]);
1807
1808         if (args)
1809                 free(args);
1810
1811         return req_id;
1812 }
1813
1814 API int pkgmgr_client_move_pkg(pkgmgr_client *pc, const char *pkg_type,
1815                                 const char *pkgid, pkgmgr_move_type move_type, pkgmgr_mode mode,
1816                                 pkgmgr_handler event_cb, void *data)
1817 {
1818         return pkgmgr_client_move_usr_pkg(pc, pkg_type, pkgid, GLOBAL_USER, move_type, mode, event_cb, data);
1819 }
1820
1821 API int pkgmgr_client_move_usr_pkg(pkgmgr_client *pc, const char *pkg_type,
1822                                 const char *pkgid, uid_t uid, pkgmgr_move_type move_type, pkgmgr_mode mode,
1823                                 pkgmgr_handler event_cb, void *data)
1824 {
1825         char *pkgtype;
1826         char *installer_path;
1827         char *req_key;
1828         int req_id;
1829         int i = 0;
1830         char *argv[PKG_ARGC_MAX] = { NULL, };
1831         char *args = NULL;
1832         int argcnt = 0;
1833         int len = 0;
1834         char *temp = NULL;
1835         int ret = -1;
1836         char buf[128] = {'\0'};
1837
1838         /* Check for NULL value of pc */
1839         retvm_if(pc == NULL, PKGMGR_R_EINVAL, "package manager client handle is NULL\n");
1840
1841         pkgmgr_client_t *mpc = (pkgmgr_client_t *) pc;
1842
1843         /* 0. check the pc type */
1844         retv_if(mpc->ctype != PC_REQUEST, PKGMGR_R_EINVAL);
1845
1846         /* 1. check argument */
1847         retv_if(pkgid == NULL, PKGMGR_R_EINVAL);
1848
1849         pkgmgr_pkginfo_h handle;
1850   if (uid != GLOBAL_USER)
1851           ret = pkgmgr_pkginfo_get_usr_pkginfo(pkgid, uid, &handle);
1852   else
1853           ret = pkgmgr_pkginfo_get_pkginfo(pkgid, &handle);
1854
1855         /*check package id      */
1856         tryvm_if(ret < 0, ret = PKGMGR_R_EINVAL, "pkgmgr_pkginfo_get_pkginfo fail");
1857         tryvm_if(handle == NULL, ret = PKGMGR_R_EINVAL, "Pkgid(%s) can not find in installed pkg DB! \n", pkgid);
1858
1859   if (uid != GLOBAL_USER) {
1860           /*check running app , terminate app if it is running*/
1861           ret = pkgmgr_appinfo_get_usr_list(handle, PM_UI_APP, __app_list_cb, NULL, uid);
1862           tryvm_if(ret < 0, ret = PKGMGR_R_EINVAL, "pkgmgr_appinfo_get_list : PM_UI_APP fail");
1863
1864     /*check running app , terminate app if it is running*/
1865           ret = pkgmgr_appinfo_get_usr_list(handle, PM_SVC_APP, __app_list_cb, NULL, uid);
1866           tryvm_if(ret < 0, ret = PKGMGR_R_EINVAL, "pkgmgr_appinfo_get_list : PM_SVC_APP fail");
1867
1868   } else {
1869     /*check running app , terminate app if it is running*/
1870           ret = pkgmgr_appinfo_get_list(handle, PM_UI_APP, __app_list_cb, NULL);
1871           tryvm_if(ret < 0, ret = PKGMGR_R_EINVAL, "pkgmgr_appinfo_get_list : PM_UI_APP fail");
1872     /*check running app , terminate app if it is running*/
1873           ret = pkgmgr_appinfo_get_list(handle, PM_SVC_APP, __app_list_cb, NULL);
1874           tryvm_if(ret < 0, ret = PKGMGR_R_EINVAL, "pkgmgr_appinfo_get_list : PM_SVC_APP fail");
1875   }
1876         /*check type    */
1877         ret = pkgmgr_pkginfo_get_type(handle, &pkgtype);
1878         tryvm_if(ret < 0, ret = PKGMGR_R_EINVAL, "pkgmgr_pkginfo_get_type fail");
1879         tryvm_if(pkgtype == NULL, ret = PKGMGR_R_ERROR, "pkgtype is NULL");
1880
1881         /*check pkgid length    */
1882         tryvm_if(strlen(pkgid) >= PKG_STRING_LEN_MAX, ret = PKGMGR_R_EINVAL, "pkgid is too long");
1883
1884         /*check move_type       */
1885         tryvm_if((move_type < PM_MOVE_TO_INTERNAL) || (move_type > PM_MOVE_TO_SDCARD), ret = PKGMGR_R_EINVAL, "move_type is not supported");
1886
1887         /* 2. get installer path using pkgtype */
1888         installer_path = _get_backend_path_with_type(pkgtype);
1889         tryvm_if(installer_path == NULL, ret = PKGMGR_R_EINVAL, "installer_path fail");
1890
1891         /* 3. generate req_key */
1892         req_key = __get_req_key(pkgid);
1893
1894         /* 4. add callback info - add callback info to pkgmgr_client */
1895         req_id = _get_request_id();
1896         __add_op_cbinfo(mpc, req_id, req_key, event_cb, NULL, data);
1897
1898         /* 5. generate argv */
1899         snprintf(buf, 128, "%d", move_type);
1900         /* argv[0] installer path */
1901         argv[argcnt++] = installer_path;
1902         /* argv[1] */
1903         argv[argcnt++] = strdup("-k");
1904         /* argv[2] */
1905         argv[argcnt++] = req_key;
1906         /* argv[3] */
1907         argv[argcnt++] = strdup("-m");
1908         /* argv[4] */
1909         argv[argcnt++] = strdup(pkgid);
1910         /* argv[5] */
1911         argv[argcnt++] = strdup("-t");
1912         /* argv[6] */
1913         argv[argcnt++] = strdup(buf);
1914
1915         /*** add quote in all string for special charactor like '\n'***   FIX */
1916         for (i = 0; i < argcnt; i++) {
1917                 temp = g_shell_quote(argv[i]);
1918                 len += (strlen(temp) + 1);
1919                 g_free(temp);
1920         }
1921
1922         args = (char *)calloc(len, sizeof(char));
1923         tryvm_if(args == NULL, ret = PKGMGR_R_ERROR, "calloc failed");
1924
1925         strncpy(args, argv[0], len - 1);
1926
1927         for (i = 1; i < argcnt; i++) {
1928                 strncat(args, " ", strlen(" "));
1929                 temp = g_shell_quote(argv[i]);
1930                 strncat(args, temp, strlen(temp));
1931                 g_free(temp);
1932         }
1933         DBG("[args] %s [len] %d\n", args, len);
1934
1935         /******************* end of quote ************************/
1936
1937         /* 6. request install */
1938         ret = comm_client_request(mpc->info.request.cc, req_key, COMM_REQ_TO_MOVER, pkgtype, pkgid, args, uid, 1);
1939         tryvm_if(ret < 0, ret = PKGMGR_R_ECOMM, "calloc failed");
1940
1941         ret = req_id;
1942
1943 catch:
1944         for (i = 0; i < argcnt; i++)
1945                 free(argv[i]);
1946
1947         if(args)
1948                 free(args);
1949
1950         pkgmgr_pkginfo_destroy_pkginfo(handle);
1951         return ret;
1952 }
1953
1954 API int pkgmgr_client_activate(pkgmgr_client * pc, const char *pkg_type,
1955                                const char *pkgid)
1956 {
1957         return pkgmgr_client_usr_activate(pc, pkg_type, pkgid, GLOBAL_USER);
1958 }
1959
1960 API int pkgmgr_client_usr_activate(pkgmgr_client * pc, const char *pkg_type,
1961                                const char *pkgid, uid_t uid)
1962 {
1963         const char *pkgtype;
1964         char *req_key;
1965         int ret;
1966         /* Check for NULL value of pc */
1967         retvm_if(pc == NULL, PKGMGR_R_EINVAL, "package manager client handle is NULL\n");
1968
1969         pkgmgr_client_t *mpc = (pkgmgr_client_t *) pc;
1970
1971         /* 0. check the pc type */
1972         retvm_if(mpc->ctype != PC_REQUEST, PKGMGR_R_EINVAL, "mpc->ctype is not PC_REQUEST");
1973
1974         /* 1. check argument */
1975         retvm_if(pkgid == NULL, PKGMGR_R_EINVAL, "pkgid is NULL");
1976         retvm_if(strlen(pkgid) >= PKG_STRING_LEN_MAX, PKGMGR_R_EINVAL, "pkgid length over PKG_STRING_LEN_MAX ");
1977
1978         if (pkg_type == NULL) {
1979                 pkgtype = _get_pkg_type_from_desktop_file(pkgid, uid);
1980                 retvm_if(pkgtype == NULL, PKGMGR_R_EINVAL, "pkgtype is NULL");
1981         } else
1982                 pkgtype = pkg_type;
1983
1984         /* 2. generate req_key */
1985         req_key = __get_req_key(pkgid);
1986         retvm_if(req_key == NULL, PKGMGR_R_EINVAL, "req_key is NULL");
1987
1988         /* 3. request activate */
1989         ret = comm_client_request(mpc->info.request.cc, req_key, COMM_REQ_TO_ACTIVATOR, pkgtype, pkgid, "1 PKG", uid, 1);
1990         tryvm_if(ret < 0, ret = PKGMGR_R_ECOMM, "request failed, ret=%d", ret);
1991
1992         ret = PKGMGR_R_OK;
1993
1994 catch:
1995         free(req_key);
1996         return ret;
1997 }
1998
1999 API int pkgmgr_client_deactivate(pkgmgr_client *pc, const char *pkg_type,
2000                                  const char *pkgid)
2001 {
2002         return pkgmgr_client_usr_deactivate(pc, pkg_type, pkgid, GLOBAL_USER);
2003 }
2004
2005 API int pkgmgr_client_usr_deactivate(pkgmgr_client *pc, const char *pkg_type,
2006                                  const char *pkgid, uid_t uid)
2007 {
2008         const char *pkgtype;
2009         char *req_key;
2010         int ret;
2011         /* Check for NULL value of pc */
2012         retvm_if(pc == NULL, PKGMGR_R_EINVAL, "package manager client handle is NULL\n");
2013
2014         pkgmgr_client_t *mpc = (pkgmgr_client_t *) pc;
2015
2016         /* 0. check the pc type */
2017         retvm_if(mpc->ctype != PC_REQUEST, PKGMGR_R_EINVAL, "mpc->ctype is not PC_REQUEST");
2018
2019         /* 1. check argument */
2020         retvm_if(pkgid == NULL, PKGMGR_R_EINVAL, "pkgid is NULL");
2021         retvm_if(strlen(pkgid) >= PKG_STRING_LEN_MAX, PKGMGR_R_EINVAL, "pkgid length over PKG_STRING_LEN_MAX ");
2022
2023         if (pkg_type == NULL) {
2024                 pkgtype = _get_pkg_type_from_desktop_file(pkgid, uid);
2025                 if (pkgtype == NULL)
2026                         return PKGMGR_R_EINVAL;
2027         } else
2028                 pkgtype = pkg_type;
2029
2030         /* 2. generate req_key */
2031         req_key = __get_req_key(pkgid);
2032         retvm_if(req_key == NULL, PKGMGR_R_EINVAL, "req_key is NULL");
2033
2034         /* 3. request activate */
2035         ret = comm_client_request(mpc->info.request.cc, req_key, COMM_REQ_TO_ACTIVATOR, pkgtype, pkgid, "0 PKG", uid, 1);
2036         tryvm_if(ret < 0, ret = PKGMGR_R_ECOMM, "request failed, ret=%d", ret);
2037
2038         ret = PKGMGR_R_OK;
2039
2040 catch:
2041         free(req_key);
2042         return ret;
2043 }
2044
2045 API int pkgmgr_client_activate_app(pkgmgr_client * pc, const char *appid)
2046 {
2047         return pkgmgr_client_usr_activate_app(pc,appid, GLOBAL_USER);
2048 }
2049
2050 API int pkgmgr_client_usr_activate_app(pkgmgr_client * pc, const char *appid, uid_t uid)
2051 {
2052         const char *pkgtype;
2053         char *req_key;
2054         int ret;
2055         /* Check for NULL value of pc */
2056         retvm_if(pc == NULL, PKGMGR_R_EINVAL, "package manager client handle is NULL\n");
2057
2058         pkgmgr_client_t *mpc = (pkgmgr_client_t *) pc;
2059
2060         /* 0. check the pc type */
2061         retvm_if(mpc->ctype != PC_REQUEST, PKGMGR_R_EINVAL, "mpc->ctype is not PC_REQUEST");
2062
2063         /* 1. check argument */
2064         retvm_if(appid == NULL, PKGMGR_R_EINVAL, "pkgid is NULL");
2065         retvm_if(strlen(appid) >= PKG_STRING_LEN_MAX, PKGMGR_R_EINVAL, "pkgid length over PKG_STRING_LEN_MAX ");
2066
2067         pkgtype = _get_pkg_type_from_desktop_file(appid, uid);
2068         retvm_if(pkgtype == NULL, PKGMGR_R_EINVAL, "pkgtype is NULL");
2069
2070         /* 2. generate req_key */
2071         req_key = __get_req_key(appid);
2072         retvm_if(req_key == NULL, PKGMGR_R_EINVAL, "req_key is NULL");
2073
2074         /* 3. request activate */
2075         ret = comm_client_request(mpc->info.request.cc, req_key, COMM_REQ_TO_ACTIVATOR, pkgtype, appid, "1 APP", uid, 1);
2076         tryvm_if(ret < 0, ret = PKGMGR_R_ECOMM, "request failed, ret=%d", ret);
2077
2078         ret = PKGMGR_R_OK;
2079
2080 catch:
2081         free(req_key);
2082         return ret;
2083 }
2084
2085 API int pkgmgr_client_activate_appv(pkgmgr_client * pc, const char *appid, char *const argv[])
2086 {
2087         return pkgmgr_client_usr_activate_appv(pc, appid,  argv, GLOBAL_USER);
2088 }
2089
2090 API int pkgmgr_client_usr_activate_appv(pkgmgr_client * pc, const char *appid, char *const argv[], uid_t uid)
2091 {
2092         const char *pkgtype;
2093         char *req_key;
2094         int ret;
2095         int i = 0;
2096         char *temp = NULL;
2097         int len = 0;
2098         int argcnt = 0;
2099         char *args = NULL;
2100         char *argsr = NULL;
2101         /* Check for NULL value of pc */
2102         retvm_if(pc == NULL, PKGMGR_R_EINVAL, "package manager client handle is NULL\n");
2103
2104         pkgmgr_client_t *mpc = (pkgmgr_client_t *) pc;
2105
2106         /* 0. check the pc type */
2107         retvm_if(mpc->ctype != PC_REQUEST, PKGMGR_R_EINVAL, "mpc->ctype is not PC_REQUEST");
2108
2109         /* 1. check argument */
2110         retvm_if(appid == NULL, PKGMGR_R_EINVAL, "pkgid is NULL");
2111         retvm_if(strlen(appid) >= PKG_STRING_LEN_MAX, PKGMGR_R_EINVAL, "pkgid length over PKG_STRING_LEN_MAX ");
2112
2113         pkgtype = _get_pkg_type_from_desktop_file(appid, uid);
2114         retvm_if(pkgtype == NULL, PKGMGR_R_EINVAL, "pkgtype is NULL");
2115
2116         /* 2. generate req_key */
2117         req_key = __get_req_key(appid);
2118         retvm_if(req_key == NULL, PKGMGR_R_EINVAL, "req_key is NULL");
2119
2120         /*** add quote in all string for special charactor like '\n'***   FIX */
2121         if (argv) {
2122                 for (i = 0; argv[i]; i++) {
2123                         temp = g_shell_quote(argv[i]);
2124                         len += (strlen(temp) + 1);
2125                         g_free(temp);
2126                         argcnt++;
2127                 }
2128
2129                 if (argcnt) {
2130                         args = (char *)calloc(len, sizeof(char));
2131                         tryvm_if(args == NULL, ret = PKGMGR_R_ERROR, "calloc failed");
2132                         strncpy(args, argv[0], len - 1);
2133
2134                         for (i = 1; i < argcnt; i++) {
2135                                 strncat(args, " ", strlen(" "));
2136                                 temp = g_shell_quote(argv[i]);
2137                                 strncat(args, temp, strlen(temp));
2138                                 g_free(temp);
2139                         }
2140                 }
2141         }
2142
2143         argsr = (char *)calloc(strlen("1 APP")+2+len, sizeof(char));
2144         tryvm_if(argsr == NULL, ret = PKGMGR_R_ERROR, "calloc failed");
2145
2146         strncpy(argsr, "1 APP", strlen("1 APP"));
2147         if (argcnt) {
2148                 strncat(argsr, " ", strlen(" "));
2149                 strncat(argsr, args, strlen(args));
2150         }
2151
2152         DBG("argsr [%s]\n", argsr);
2153         /******************* end of quote ************************/
2154
2155         /* 3. request activate */
2156         ret = comm_client_request(mpc->info.request.cc, req_key, COMM_REQ_TO_ACTIVATOR, pkgtype, appid, argsr, uid, 1);
2157         tryvm_if(ret < 0, ret = PKGMGR_R_ECOMM, "request failed, ret=%d", ret);
2158
2159         ret = PKGMGR_R_OK;
2160
2161 catch:
2162
2163         free(req_key);
2164         free(args);
2165         free(argsr);
2166
2167         return ret;
2168 }
2169
2170
2171 API int pkgmgr_client_deactivate_app(pkgmgr_client *pc, const char *appid)
2172 {
2173         return pkgmgr_client_usr_deactivate_app(pc, appid, GLOBAL_USER);
2174 }
2175
2176 API int pkgmgr_client_usr_deactivate_app(pkgmgr_client *pc, const char *appid, uid_t uid)
2177 {
2178         const char *pkgtype;
2179         char *req_key;
2180         int ret;
2181         /* Check for NULL value of pc */
2182         retvm_if(pc == NULL, PKGMGR_R_EINVAL, "package manager client handle is NULL\n");
2183
2184         pkgmgr_client_t *mpc = (pkgmgr_client_t *) pc;
2185
2186         /* 0. check the pc type */
2187         retvm_if(mpc->ctype != PC_REQUEST, PKGMGR_R_EINVAL, "mpc->ctype is not PC_REQUEST");
2188
2189         /* 1. check argument */
2190         retvm_if(appid == NULL, PKGMGR_R_EINVAL, "pkgid is NULL");
2191         retvm_if(strlen(appid) >= PKG_STRING_LEN_MAX, PKGMGR_R_EINVAL, "pkgid length over PKG_STRING_LEN_MAX ");
2192
2193         pkgtype = _get_pkg_type_from_desktop_file(appid, uid);
2194         retvm_if(pkgtype == NULL, PKGMGR_R_EINVAL, "pkgtype is NULL");
2195
2196         /* 2. generate req_key */
2197         req_key = __get_req_key(appid);
2198         retvm_if(req_key == NULL, PKGMGR_R_EINVAL, "req_key is NULL");
2199
2200         /* 3. request activate */
2201         ret = comm_client_request(mpc->info.request.cc, req_key, COMM_REQ_TO_ACTIVATOR, pkgtype, appid, "0 APP", uid, 1);
2202         tryvm_if(ret < 0, ret = PKGMGR_R_ECOMM, "request failed, ret=%d", ret);
2203
2204         ret = PKGMGR_R_OK;
2205
2206 catch:
2207         free(req_key);
2208         return ret;
2209 }
2210
2211 API int pkgmgr_client_clear_user_data(pkgmgr_client *pc, const char *pkg_type,
2212                                       const char *appid, pkgmgr_mode mode)
2213 {
2214         return pkgmgr_client_usr_clear_user_data(pc, pkg_type, appid,mode, GLOBAL_USER);
2215 }
2216 API int pkgmgr_client_usr_clear_user_data(pkgmgr_client *pc, const char *pkg_type,
2217                                       const char *appid, pkgmgr_mode mode, uid_t uid)
2218 {
2219         const char *pkgtype;
2220         char *installer_path;
2221         char *req_key;
2222         int i = 0;
2223         char *argv[PKG_ARGC_MAX] = { NULL, };
2224         char *args = NULL;
2225         int argcnt = 0;
2226         int len = 0;
2227         char *temp = NULL;
2228         int ret;
2229
2230         /* Check for NULL value of pc */
2231         if (pc == NULL) {
2232                 DBG("package manager client handle is NULL\n");
2233                 return PKGMGR_R_EINVAL;
2234         }
2235         pkgmgr_client_t *mpc = (pkgmgr_client_t *) pc;
2236
2237         /* 0. check the pc type */
2238         if (mpc->ctype != PC_REQUEST)
2239                 return PKGMGR_R_EINVAL;
2240
2241         /* 1. check argument */
2242         if (appid == NULL)
2243                 return PKGMGR_R_EINVAL;
2244
2245
2246         if (pkg_type == NULL) {
2247                 pkgtype = _get_pkg_type_from_desktop_file(appid, uid);
2248                 if (pkgtype == NULL)
2249                         return PKGMGR_R_EINVAL;
2250         } else
2251                 pkgtype = pkg_type;
2252
2253         if (strlen(appid) >= PKG_STRING_LEN_MAX)
2254                 return PKGMGR_R_EINVAL;
2255
2256         /* 2. get installer path using pkg_path */
2257         installer_path = _get_backend_path_with_type(pkgtype);
2258         if (installer_path == NULL)
2259                 return PKGMGR_R_EINVAL;
2260
2261         /* 3. generate req_key */
2262         req_key = __get_req_key(appid);
2263
2264         /* 4. generate argv */
2265
2266         /* argv[0] installer path */
2267         argv[argcnt++] = installer_path;
2268         /* argv[1] */
2269         argv[argcnt++] = strdup("-k");
2270         /* argv[2] */
2271         argv[argcnt++] = req_key;
2272         /* argv[3] */
2273         argv[argcnt++] = strdup("-c");
2274         /* argv[4] */
2275         argv[argcnt++] = strdup(appid);
2276
2277         /*** add quote in all string for special charactor like '\n'***   FIX */
2278         for (i = 0; i < argcnt; i++) {
2279                 temp = g_shell_quote(argv[i]);
2280                 len += (strlen(temp) + 1);
2281                 g_free(temp);
2282         }
2283
2284         args = (char *)calloc(len, sizeof(char));
2285         if (args == NULL) {
2286                 DBG("calloc failed");
2287
2288                 for (i = 0; i < argcnt; i++)
2289                         free(argv[i]);
2290
2291                 return PKGMGR_R_ERROR;
2292         }
2293         strncpy(args, argv[0], len - 1);
2294
2295         for (i = 1; i < argcnt; i++) {
2296                 strncat(args, " ", strlen(" "));
2297                 temp = g_shell_quote(argv[i]);
2298                 strncat(args, temp, strlen(temp));
2299                 g_free(temp);
2300         }
2301         DBG("[args] %s [len] %d\n", args, len);
2302         /******************* end of quote ************************/
2303
2304         /* 6. request clear */
2305         ret = comm_client_request(mpc->info.request.cc, req_key,
2306                                   COMM_REQ_TO_CLEARER, pkgtype, appid,
2307                                   args, uid, 1);
2308         if (ret < 0) {
2309                 ERR("request failed, ret=%d\n", ret);
2310
2311                 for (i = 0; i < argcnt; i++)
2312                         free(argv[i]);
2313
2314                 free(args);
2315                 return PKGMGR_R_ECOMM;
2316         }
2317
2318         for (i = 0; i < argcnt; i++)
2319                 free(argv[i]);
2320
2321         free(args);
2322
2323         return PKGMGR_R_OK;
2324 }
2325
2326
2327 API int pkgmgr_client_set_status_type(pkgmgr_client *pc, int status_type)
2328 {
2329         int ret = -1;
2330
2331         retvm_if(pc == NULL, PKGMGR_R_EINVAL, "package manager client pc is NULL");
2332         retvm_if(status_type == PKGMGR_CLIENT_STATUS_ALL, PKGMGR_R_OK, "status_type is PKGMGR_CLIENT_STATUS_ALL");
2333         pkgmgr_client_t *mpc = (pkgmgr_client_t *) pc;
2334
2335         /*  free listening head */
2336         listen_cb_info *tmp = NULL;
2337         listen_cb_info *prev = NULL;
2338         for (tmp = mpc->info.listening.lhead; tmp;) {
2339                 prev = tmp;
2340                 tmp = tmp->next;
2341                 free(prev);
2342         }
2343
2344         /* free dbus connection */
2345         ret = comm_client_free(mpc->info.listening.cc);
2346         retvm_if(ret < 0, PKGMGR_R_ERROR, "comm_client_free() failed - %d", ret);
2347
2348         /* Manage pc for seperated event */
2349         mpc->ctype = PC_LISTENING;
2350         mpc->status_type = status_type;
2351
2352         mpc->info.listening.cc = comm_client_new();
2353         retvm_if(mpc->info.listening.cc == NULL, PKGMGR_R_EINVAL, "client creation failed");
2354
2355         if ((mpc->status_type & PKGMGR_CLIENT_STATUS_INSTALL) == PKGMGR_CLIENT_STATUS_INSTALL) {
2356                 ret = comm_client_set_status_callback(COMM_STATUS_BROADCAST_INSTALL, mpc->info.listening.cc, __status_callback, pc);
2357                 retvm_if(ret < 0, PKGMGR_R_ECOMM, "PKGMGR_CLIENT_STATUS_INSTALL failed - %d", ret);
2358         }
2359
2360         if ((mpc->status_type & PKGMGR_CLIENT_STATUS_UNINSTALL) == PKGMGR_CLIENT_STATUS_UNINSTALL) {
2361                 ret = comm_client_set_status_callback(COMM_STATUS_BROADCAST_UNINSTALL, mpc->info.listening.cc, __status_callback, pc);
2362                 retvm_if(ret < 0, PKGMGR_R_ECOMM, "COMM_STATUS_BROADCAST_UNINSTALL failed - %d", ret);
2363         }
2364
2365         if ((mpc->status_type & PKGMGR_CLIENT_STATUS_MOVE) == PKGMGR_CLIENT_STATUS_MOVE) {
2366                 ret = comm_client_set_status_callback(COMM_STATUS_BROADCAST_MOVE, mpc->info.listening.cc, __status_callback, pc);
2367                 retvm_if(ret < 0, PKGMGR_R_ECOMM, "COMM_STATUS_BROADCAST_MOVE failed - %d", ret);
2368         }
2369
2370         if ((mpc->status_type & PKGMGR_CLIENT_STATUS_INSTALL_PROGRESS) == PKGMGR_CLIENT_STATUS_INSTALL_PROGRESS) {
2371                 ret = comm_client_set_status_callback(COMM_STATUS_BROADCAST_INSTALL_PROGRESS, mpc->info.listening.cc, __status_callback, pc);
2372                 retvm_if(ret < 0, PKGMGR_R_ECOMM, "COMM_STATUS_BROADCAST_INSTALL_PROGRESS failed - %d", ret);
2373         }
2374
2375    if ((mpc->status_type & PKGMGR_CLIENT_STATUS_UPGRADE) == PKGMGR_CLIENT_STATUS_UPGRADE) {
2376            ret = comm_client_set_status_callback(COMM_STATUS_BROADCAST_UPGRADE, mpc->info.listening.cc, __status_callback, pc);
2377            retvm_if(ret < 0, PKGMGR_R_ECOMM, "COMM_STATUS_BROADCAST_UPGRADE failed - %d", ret);
2378    }
2379
2380    return PKGMGR_R_OK;
2381 }
2382
2383 API int pkgmgr_client_listen_status(pkgmgr_client *pc, pkgmgr_handler event_cb,
2384                                     void *data)
2385 {
2386         int req_id;
2387         /* Check for NULL value of pc */
2388         retvm_if(pc == NULL, PKGMGR_R_EINVAL, "package manager client pc is NULL");
2389         pkgmgr_client_t *mpc = (pkgmgr_client_t *) pc;
2390
2391         /* 0. check input */
2392         retvm_if(mpc->ctype != PC_LISTENING, PKGMGR_R_EINVAL, "ctype is not PC_LISTENING");
2393         retvm_if(event_cb == NULL, PKGMGR_R_EINVAL, "event_cb is NULL");
2394
2395         /* 1. get id */
2396         req_id = _get_request_id();
2397
2398         /* 2. add callback info to pkgmgr_client */
2399         __add_stat_cbinfo(mpc, req_id, event_cb, data);
2400         return req_id;
2401 }
2402
2403 API int pkgmgr_client_broadcast_status(pkgmgr_client *pc, const char *pkg_type,
2404                                        const char *pkgid, const char *key,
2405                                        const char *val)
2406 {
2407         /* Check for NULL value of pc */
2408         if (pc == NULL) {
2409                 DBG("package manager client handle is NULL\n");
2410                 return PKGMGR_R_EINVAL;
2411         }
2412         /* Check for valid arguments. NULL parameter causes DBUS to abort */
2413         if (pkgid == NULL || pkg_type == NULL || key == NULL || val == NULL) {
2414                 DBG("Argument supplied is NULL\n");
2415                 return PKGMGR_R_EINVAL;
2416         }
2417         pkgmgr_client_t *mpc = (pkgmgr_client_t *) pc;
2418
2419         /* 0. check the pc type */
2420         if (mpc->ctype != PC_BROADCAST)
2421                 return PKGMGR_R_EINVAL;
2422
2423         comm_status_broadcast_server_send_signal(COMM_STATUS_BROADCAST_ALL, mpc->info.broadcast.bc,
2424                                                  getuid(), PKG_STATUS,
2425                                                  pkg_type, pkgid, key, val);
2426
2427         return PKGMGR_R_OK;
2428 }
2429
2430 API pkgmgr_info *pkgmgr_client_check_pkginfo_from_file(const char *pkg_path)
2431 {
2432         return pkgmgr_info_new_from_file(NULL, pkg_path);
2433 }
2434
2435 API int pkgmgr_client_free_pkginfo(pkgmgr_info * pkg_info)
2436 {
2437         if (pkg_info == NULL)
2438                 return PKGMGR_R_EINVAL;
2439
2440         package_manager_pkg_detail_info_t *info = (package_manager_pkg_detail_info_t *)pkg_info;
2441
2442         if (info->icon_buf)
2443                 free(info->icon_buf);
2444
2445         free(info);
2446         info = NULL;
2447
2448         return PKGMGR_R_OK;
2449 }
2450
2451 API int pkgmgr_client_request_service(pkgmgr_request_service_type service_type, int service_mode,
2452                                   pkgmgr_client * pc, const char *pkg_type, const char *pkgid,
2453                               const char *custom_info, pkgmgr_handler event_cb, void *data)
2454 {
2455         return pkgmgr_client_usr_request_service(service_type, service_mode, pc, pkg_type, pkgid, GLOBAL_USER, custom_info, event_cb, data);
2456 }
2457
2458 API int pkgmgr_client_usr_request_service(pkgmgr_request_service_type service_type, int service_mode,
2459                                   pkgmgr_client * pc, const char *pkg_type, const char *pkgid, uid_t uid,
2460                               const char *custom_info, pkgmgr_handler event_cb, void *data)
2461 {
2462         int ret =0;
2463
2464         /* Check for NULL value of service type */
2465         retvm_if(service_type > PM_REQUEST_MAX, PKGMGR_R_EINVAL, "service type is not defined\n");
2466         retvm_if(service_type < 0, PKGMGR_R_EINVAL, "service type is error\n");
2467         vconf_set_int(VCONFKEY_PKGMGR_STATUS, -1);
2468
2469         switch (service_type) {
2470         case PM_REQUEST_CSC:
2471                 tryvm_if(custom_info == NULL, ret = PKGMGR_R_EINVAL, "custom_info is NULL\n");
2472                 tryvm_if(strlen(custom_info) >= PKG_STRING_LEN_MAX, ret = PKGMGR_R_EINVAL, "optional_file over PKG_STRING_LEN_MAX");
2473                 tryvm_if(data == NULL, ret = PKGMGR_R_EINVAL, "data is NULL\n");
2474
2475                 ret = __csc_process(custom_info, (char *)data);
2476                 if (ret < 0)
2477                         ERR("__csc_process fail \n");
2478                 else
2479                         ret = PKGMGR_R_OK;
2480
2481                 break;
2482
2483         case PM_REQUEST_MOVE:
2484                 tryvm_if(pkgid == NULL, ret = PKGMGR_R_EINVAL, "pkgid is NULL\n");
2485                 tryvm_if(pc == NULL, ret = PKGMGR_R_EINVAL, "pc is NULL\n");
2486                 tryvm_if((service_mode < PM_MOVE_TO_INTERNAL) || (service_mode > PM_MOVE_TO_SDCARD), ret = PKGMGR_R_EINVAL, "service_mode is wrong\n");
2487
2488                 ret = __move_pkg_process(pc, pkgid, uid, (pkgmgr_move_type)service_mode, event_cb, data);
2489                 break;
2490
2491         case PM_REQUEST_GET_SIZE:
2492                 tryvm_if(pkgid == NULL, ret = PKGMGR_R_EINVAL, "pkgid is NULL\n");
2493                 tryvm_if(pc == NULL, ret = PKGMGR_R_EINVAL, "pc is NULL\n");
2494                 tryvm_if((service_mode < PM_GET_TOTAL_SIZE) || (service_mode >= PM_GET_MAX), ret = PKGMGR_R_EINVAL, "service_mode is wrong\n");
2495
2496                 ret = __get_size_process(pc, pkgid, uid, (pkgmgr_getsize_type)service_mode, event_cb, data);
2497                 break;
2498
2499         case PM_REQUEST_KILL_APP:
2500         case PM_REQUEST_CHECK_APP:
2501                 tryvm_if(pkgid == NULL, ret = PKGMGR_R_EINVAL, "pkgid is NULL\n");
2502                 tryvm_if(pc == NULL, ret = PKGMGR_R_EINVAL, "pc is NULL\n");
2503
2504                 ret = __check_app_process(service_type, pc, pkgid, uid, data);
2505                 if (ret < 0)
2506                         ERR("__check_app_process fail \n");
2507                 else
2508                         ret = PKGMGR_R_OK;
2509
2510                 break;
2511
2512         default:
2513                 ERR("Wrong Request\n");
2514                 ret = -1;
2515                 break;
2516         }
2517
2518 catch:
2519
2520         return ret;
2521 }
2522
2523
2524 API int pkgmgr_client_usr_request_size_info(uid_t uid)
2525 {
2526         int ret = 0;
2527         pkgmgr_client *pc = NULL;
2528
2529         pc = pkgmgr_client_new(PC_REQUEST);
2530         retvm_if(pc == NULL, PKGMGR_R_EINVAL, "request pc is null\n");
2531
2532         ret = __request_size_info(pc, uid);
2533         if (ret < 0) {
2534                 ERR("__request_size_info fail \n");
2535         }
2536
2537         pkgmgr_client_free(pc);
2538         return ret;
2539 }
2540
2541 API int pkgmgr_client_request_size_info(void) // get all package size (data, total)
2542 {
2543         return pkgmgr_client_usr_request_size_info(GLOBAL_USER);
2544 }
2545
2546 API int pkgmgr_client_usr_clear_cache_dir(const char *pkgid, uid_t uid)
2547 {
2548         retvm_if(pkgid == NULL, PKGMGR_R_EINVAL, "package id is null\n");
2549
2550         int ret = 0;
2551         pkgmgr_client_t *pc = NULL;
2552         char *pkg_type = NULL;
2553         int is_type_malloced = 0;
2554
2555         pkgmgrinfo_pkginfo_h handle = NULL;
2556
2557         pc = pkgmgr_client_new(PC_REQUEST);
2558         retvm_if(pc == NULL, PKGMGR_R_ESYSTEM, "request pc is null\n");
2559
2560         if (strcmp(pkgid, PKG_CLEAR_ALL_CACHE) != 0)
2561         {
2562                 ret = pkgmgrinfo_pkginfo_get_usr_pkginfo(pkgid, uid, &handle);
2563                 tryvm_if(ret < 0, ret = PKGMGR_R_ENOPKG, "pkgmgr_pkginfo_get_pkginfo failed");
2564
2565                 ret = pkgmgrinfo_pkginfo_get_type(handle, &pkg_type);
2566                 tryvm_if(ret < 0, ret = PKGMGR_R_ESYSTEM, "pkgmgr_pkginfo_get_type failed");
2567         }
2568         else
2569         {
2570                 pkg_type = (char *)malloc(strlen("rpm") + 1);
2571                 strcpy(pkg_type, "rpm");
2572                 is_type_malloced = 1;
2573         }
2574
2575         ret = comm_client_request(pc->info.request.cc, NULL, COMM_REQ_CLEAR_CACHE_DIR, pkg_type, pkgid, NULL, uid, 0);
2576         tryvm_if(ret < 0, ret = PKGMGR_R_ERROR, "COMM_REQ_CLEAR_CACHE_DIR failed, ret=%d\n", ret);
2577
2578         ret = PKGMGR_R_OK;
2579 catch:
2580         if (pc)
2581                 pkgmgr_client_free(pc);
2582
2583         if(is_type_malloced)
2584                 free(pkg_type);
2585
2586         pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
2587
2588         return ret;
2589 }
2590
2591 API int pkgmgr_client_clear_cache_dir(const char *pkgid)
2592 {
2593         return pkgmgr_client_usr_clear_cache_dir(pkgid, GLOBAL_USER);
2594 }
2595
2596 API int pkgmgr_client_clear_usr_all_cache_dir(uid_t uid)
2597 {
2598         return pkgmgr_client_usr_clear_cache_dir(PKG_CLEAR_ALL_CACHE, uid);
2599 }
2600
2601 API int pkgmgr_client_clear_all_cache_dir(void)
2602 {
2603         int ret = 0;
2604         ret = pkgmgr_client_usr_clear_cache_dir(PKG_CLEAR_ALL_CACHE, GLOBAL_USER);
2605         return ret;
2606 }
2607
2608 API int pkgmgr_client_get_size(pkgmgr_client * pc, const char *pkgid, pkgmgr_getsize_type get_type, pkgmgr_handler event_cb, void *data)
2609 {
2610         return pkgmgr_client_usr_get_size(pc, pkgid, get_type, event_cb, data, GLOBAL_USER);
2611 }
2612
2613 API int pkgmgr_client_usr_get_size(pkgmgr_client * pc, const char *pkgid, pkgmgr_getsize_type get_type, pkgmgr_handler event_cb, void *data, uid_t uid)
2614 {
2615         char *req_key = NULL;
2616         int ret =0;
2617         char *pkgtype = "rpm";
2618         char *argv[PKG_ARGC_MAX] = { NULL, };
2619         char *args = NULL;
2620         int argcnt = 0;
2621         int len = 0;
2622         char *temp = NULL;
2623         int i = 0;
2624         char buf[128] = {'\0'};
2625         int req_id = 0;
2626
2627         pkgmgr_client_t *mpc = (pkgmgr_client_t *) pc;
2628         retvm_if(mpc->ctype != PC_REQUEST, PKGMGR_R_EINVAL, "mpc->ctype is not PC_REQUEST\n");
2629         retvm_if(event_cb == NULL, PKGMGR_R_EINVAL, "event_cb is NULL\n");
2630         retvm_if(pkgid == NULL, PKGMGR_R_EINVAL, "pkgid is NULL\n");
2631
2632         req_key = __get_req_key(pkgid);
2633         retvm_if(req_key == NULL, PKGMGR_R_EINVAL, "req_key is NULL");
2634
2635         req_id = _get_request_id();
2636         __add_op_cbinfo(mpc, req_id, req_key, event_cb, NULL, data);
2637
2638         snprintf(buf, 128, "%d", get_type);
2639         argv[argcnt++] = strdup(pkgid);
2640         argv[argcnt++] = strdup(buf);
2641         argv[argcnt++] = strdup("-k");
2642         argv[argcnt++] = req_key;
2643
2644         /*** add quote in all string for special charactor like '\n'***   FIX */
2645         for (i = 0; i < argcnt; i++) {
2646                 temp = g_shell_quote(argv[i]);
2647                 len += (strlen(temp) + 1);
2648                 g_free(temp);
2649         }
2650
2651         args = (char *)calloc(len, sizeof(char));
2652         tryvm_if(args == NULL, ret = PKGMGR_R_EINVAL, "installer_path fail");
2653
2654         strncpy(args, argv[0], len - 1);
2655
2656         for (i = 1; i < argcnt; i++) {
2657                 strncat(args, " ", strlen(" "));
2658                 temp = g_shell_quote(argv[i]);
2659                 strncat(args, temp, strlen(temp));
2660                 g_free(temp);
2661         }
2662         DBG("[args] %s [len] %d\n", args, len);
2663
2664         /* request */
2665         ret = comm_client_request(mpc->info.request.cc, req_key, COMM_REQ_GET_SIZE, pkgtype, pkgid, args, uid, 1);
2666         if (ret < 0)
2667                 ERR("comm_client_request failed, ret=%d\n", ret);
2668
2669 catch:
2670         for (i = 0; i < argcnt; i++)
2671                 free(argv[i]);
2672
2673         if(args)
2674                 free(args);
2675
2676         return ret;
2677 }
2678
2679 API int pkgmgr_client_usr_get_package_size_info(pkgmgr_client *pc, const char *pkgid, pkgmgr_pkg_size_info_receive_cb event_cb, void *user_data, uid_t uid)
2680 {
2681         pkgmgrinfo_pkginfo_h pkginfo = NULL;
2682         char *req_key = NULL;
2683         int req_id = 0;
2684         int res = 0;
2685         int type = PM_GET_PKG_SIZE_INFO;
2686
2687         retvm_if(pc == NULL, PKGMGR_R_EINVAL, "The specified pc is NULL.");
2688         retvm_if(pkgid == NULL, PKGMGR_R_EINVAL, "The package id is NULL.");
2689
2690         if (strcmp(pkgid, PKG_SIZE_INFO_TOTAL) == 0)
2691         {       // total package size info
2692                 type = PM_GET_TOTAL_PKG_SIZE_INFO;
2693         }
2694         else
2695         {
2696                 res = pkgmgrinfo_pkginfo_get_usr_pkginfo(pkgid, uid, &pkginfo);
2697                 retvm_if(res != 0, PKGMGR_R_ENOPKG, "The package id is not installed.");
2698
2699                 if (pkginfo) {
2700                         pkgmgrinfo_pkginfo_destroy_pkginfo(pkginfo);
2701                 }
2702         }
2703
2704         pkgmgr_client_t *mpc = (pkgmgr_client_t *)pc;
2705         retvm_if(mpc->ctype != PC_REQUEST, PKGMGR_R_EINVAL, "mpc->ctype is not PC_REQUEST");
2706
2707         res = __change_op_cb_for_getsize(mpc);
2708         retvm_if(res < 0 , PKGMGR_R_ESYSTEM, "__change_op_cb_for_getsize is fail");
2709
2710         req_key = __get_req_key(pkgid);
2711         retvm_if(req_key == NULL, PKGMGR_R_ESYSTEM, "req_key is NULL");
2712
2713         req_id = _get_request_id();
2714         __add_op_cbinfo(mpc, req_id, req_key, __get_pkg_size_info_cb, event_cb, user_data);
2715
2716         res = __get_package_size_info(mpc, req_key, pkgid, type, uid);
2717
2718         return res;
2719 }
2720
2721 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)
2722 {
2723         return pkgmgr_client_usr_get_package_size_info(pc, pkgid, event_cb, user_data, GLOBAL_USER);
2724 }
2725
2726 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)
2727 {       // total package size info
2728         return pkgmgr_client_usr_get_package_size_info(pc, PKG_SIZE_INFO_TOTAL, (pkgmgr_pkg_size_info_receive_cb)event_cb, user_data, uid);
2729 }
2730
2731 API int pkgmgr_client_get_total_package_size_info(pkgmgr_client *pc, pkgmgr_total_pkg_size_info_receive_cb event_cb, void *user_data)
2732 {
2733         return pkgmgr_client_usr_get_package_size_info(pc, PKG_SIZE_INFO_TOTAL, event_cb, user_data, GLOBAL_USER);
2734 }
2735
2736 #define __START_OF_OLD_API
2737 ail_cb_ret_e __appinfo_func(const ail_appinfo_h appinfo, void *user_data)
2738 {
2739         char *type;
2740         char *package;
2741         char *version;
2742
2743         iter_data *udata = (iter_data *) user_data;
2744
2745         ail_appinfo_get_str(appinfo, AIL_PROP_X_SLP_PACKAGETYPE_STR, &type);
2746         if (type == NULL)
2747                 type = "";
2748         ail_appinfo_get_str(appinfo, AIL_PROP_PACKAGE_STR, &package);
2749         if (package == NULL)
2750                 package = "";
2751         ail_appinfo_get_str(appinfo, AIL_PROP_VERSION_STR, &version);
2752         if (version == NULL)
2753                 version = "";
2754
2755         if (udata->iter_fn(type, package, version, udata->data) != 0)
2756                 return AIL_CB_RET_CANCEL;
2757
2758         return AIL_CB_RET_CONTINUE;
2759 }
2760
2761 API int pkgmgr_get_pkg_list(pkgmgr_iter_fn iter_fn, void *data, uid_t uid)
2762 {
2763         int cnt = -1;
2764         ail_filter_h filter;
2765         ail_error_e ret;
2766
2767         if (iter_fn == NULL)
2768                 return PKGMGR_R_EINVAL;
2769
2770         ret = ail_filter_new(&filter);
2771         if (ret != AIL_ERROR_OK) {
2772                 return PKGMGR_R_ERROR;
2773         }
2774
2775         ret = ail_filter_add_str(filter, AIL_PROP_TYPE_STR, "Application");
2776         if (ret != AIL_ERROR_OK) {
2777                 ail_filter_destroy(filter);
2778                 return PKGMGR_R_ERROR;
2779         }
2780
2781         ret = ail_filter_add_bool(filter, AIL_PROP_X_SLP_REMOVABLE_BOOL, true);
2782         if (ret != AIL_ERROR_OK) {
2783                 ail_filter_destroy(filter);
2784                 return PKGMGR_R_ERROR;
2785         }
2786
2787         if(uid != GLOBAL_USER)
2788                 ret = ail_filter_count_usr_appinfo(filter, &cnt, uid);
2789         else
2790                 ret = ail_filter_count_appinfo(filter, &cnt);
2791         if (ret != AIL_ERROR_OK) {
2792                 ail_filter_destroy(filter);
2793                 return PKGMGR_R_ERROR;
2794         }
2795
2796         iter_data *udata = calloc(1, sizeof(iter_data));
2797         if (udata == NULL) {
2798                 ERR("calloc failed");
2799                 ail_filter_destroy(filter);
2800
2801                 return PKGMGR_R_ERROR;
2802         }
2803         udata->iter_fn = iter_fn;
2804         udata->data = data;
2805
2806         if(uid != GLOBAL_USER)
2807                 ail_filter_list_usr_appinfo_foreach(filter, __appinfo_func, udata, uid);
2808         else
2809                 ail_filter_list_appinfo_foreach(filter, __appinfo_func, udata);
2810         free(udata);
2811
2812         ret = ail_filter_destroy(filter);
2813         if (ret != AIL_ERROR_OK) {
2814                 return PKGMGR_R_ERROR;
2815         }
2816
2817         return PKGMGR_R_OK;
2818 }
2819
2820 API pkgmgr_info *pkgmgr_info_new(const char *pkg_type, const char *pkgid)
2821 {
2822         return pkgmgr_info_usr_new(pkg_type, pkgid, GLOBAL_USER);
2823 }
2824 API pkgmgr_info *pkgmgr_info_usr_new(const char *pkg_type, const char *pkgid, uid_t uid)
2825 {
2826         const char *pkgtype;
2827         pkg_plugin_set *plugin_set = NULL;
2828         package_manager_pkg_detail_info_t *pkg_detail_info = NULL;
2829
2830         /* 1. check argument */
2831         if (pkgid == NULL)
2832                 return NULL;
2833
2834         if (pkg_type == NULL) {
2835                 pkgtype = _get_pkg_type_from_desktop_file(pkgid, uid);
2836                 if (pkgtype == NULL)
2837                         return NULL;
2838         } else
2839                 pkgtype = pkg_type;
2840
2841         if (strlen(pkgid) >= PKG_STRING_LEN_MAX)
2842                 return NULL;
2843
2844         pkg_detail_info = calloc(1, sizeof(package_manager_pkg_detail_info_t));
2845         if (pkg_detail_info == NULL) {
2846                 ERR("*** Failed to alloc package_handler_info.\n");
2847                 return NULL;
2848         }
2849
2850         plugin_set = _package_manager_load_library(pkgtype);
2851         if (plugin_set == NULL) {
2852                 ERR("*** Failed to load library");
2853                 free(pkg_detail_info);
2854                 return NULL;
2855         }
2856
2857         if (plugin_set->pkg_is_installed) {
2858                 if (plugin_set->pkg_is_installed(pkgid) != 0) {
2859                         ERR("*** Failed to call pkg_is_installed()");
2860                         free(pkg_detail_info);
2861                         return NULL;
2862                 }
2863
2864                 if (plugin_set->get_pkg_detail_info) {
2865                         if (plugin_set->get_pkg_detail_info(pkgid,
2866                                                             pkg_detail_info) != 0) {
2867                                 ERR("*** Failed to call get_pkg_detail_info()");
2868                                 free(pkg_detail_info);
2869                                 return NULL;
2870                         }
2871                 }
2872         }
2873
2874         return (pkgmgr_info *) pkg_detail_info;
2875 }
2876
2877 API char * pkgmgr_info_get_string(pkgmgr_info * pkg_info, const char *key)
2878 {
2879         package_manager_pkg_detail_info_t *pkg_detail_info;
2880
2881         if (pkg_info == NULL)
2882                 return NULL;
2883         if (key == NULL)
2884                 return NULL;
2885
2886         pkg_detail_info = (package_manager_pkg_detail_info_t *) pkg_info;
2887
2888         return _get_info_string(key, pkg_detail_info);
2889 }
2890
2891 API pkgmgr_info *pkgmgr_info_new_from_file(const char *pkg_type,
2892                                            const char *pkg_path)
2893 {
2894         pkg_plugin_set *plugin_set = NULL;
2895         package_manager_pkg_detail_info_t *pkg_detail_info = NULL;
2896         char *pkgtype;
2897         if (pkg_path == NULL) {
2898                 ERR("pkg_path is NULL\n");
2899                 return NULL;
2900         }
2901
2902         if (strlen(pkg_path) > PKG_URL_STRING_LEN_MAX) {
2903                 ERR("length of pkg_path is too long - %d.\n",
2904                       strlen(pkg_path));
2905                 return NULL;
2906         }
2907
2908         pkg_detail_info = calloc(1, sizeof(package_manager_pkg_detail_info_t));
2909         if (pkg_detail_info == NULL) {
2910                 ERR("*** Failed to alloc package_handler_info.\n");
2911                 return NULL;
2912         }
2913
2914         if (pkg_type == NULL)
2915                 pkgtype = __get_type_from_path(pkg_path);
2916         else
2917                 pkgtype = strdup(pkg_type);
2918
2919         plugin_set = _package_manager_load_library(pkgtype);
2920         if (plugin_set == NULL) {
2921                 free(pkg_detail_info);
2922                 free(pkgtype);
2923                 return NULL;
2924         }
2925
2926         if (plugin_set->get_pkg_detail_info_from_package) {
2927                 if (plugin_set->get_pkg_detail_info_from_package(pkg_path,
2928                                                                  pkg_detail_info) != 0) {
2929                         free(pkg_detail_info);
2930                         free(pkgtype);
2931                         return NULL;
2932                 }
2933         }
2934
2935         free(pkgtype);
2936         return (pkgmgr_info *) pkg_detail_info;
2937 }
2938
2939 API int pkgmgr_info_free(pkgmgr_info * pkg_info)
2940 {
2941         if (pkg_info == NULL)
2942                 return PKGMGR_R_EINVAL;
2943
2944         free(pkg_info);
2945         pkg_info = NULL;
2946
2947         return 0;
2948 }
2949
2950 #define __END_OF_OLD_API
2951
2952 API int pkgmgr_pkginfo_get_list(pkgmgr_info_pkg_list_cb pkg_list_cb, void *user_data)
2953 {
2954         int ret = 0;
2955         ret = pkgmgrinfo_pkginfo_get_list(pkg_list_cb, user_data);
2956         return ret;
2957 }
2958
2959 API int pkgmgr_pkginfo_get_usr_list(pkgmgr_info_pkg_list_cb pkg_list_cb, void *user_data, uid_t uid)
2960 {
2961         int ret = 0;
2962         ret = pkgmgrinfo_pkginfo_get_usr_list(pkg_list_cb, user_data, uid);
2963         return ret;
2964 }
2965
2966
2967 API int pkgmgr_pkginfo_get_usr_pkginfo(const char *pkgid, uid_t uid, pkgmgr_pkginfo_h *handle)
2968 {
2969         int ret = 0;
2970         ret = pkgmgrinfo_pkginfo_get_usr_pkginfo(pkgid, uid, handle);
2971         return ret;
2972 }
2973
2974
2975 API int pkgmgr_pkginfo_get_pkginfo(const char *pkgid, pkgmgr_pkginfo_h *handle)
2976 {
2977         int ret = 0;
2978         ret = pkgmgrinfo_pkginfo_get_pkginfo(pkgid, handle);
2979         return ret;
2980 }
2981
2982
2983
2984 API int pkgmgr_pkginfo_get_pkgname(pkgmgr_pkginfo_h handle, char **pkg_name)
2985 {
2986         int ret = 0;
2987         ret = pkgmgrinfo_pkginfo_get_pkgname(handle, pkg_name);
2988         return ret;
2989 }
2990
2991
2992 API int pkgmgr_pkginfo_get_pkgid(pkgmgr_pkginfo_h handle, char **pkgid)
2993 {
2994         int ret = 0;
2995         ret = pkgmgrinfo_pkginfo_get_pkgid(handle, pkgid);
2996         return ret;
2997 }
2998
2999 API int pkgmgr_pkginfo_get_type(pkgmgr_pkginfo_h handle, char **type)
3000 {
3001         int ret = 0;
3002         ret = pkgmgrinfo_pkginfo_get_type(handle, type);
3003         return ret;
3004 }
3005
3006 API int pkgmgr_pkginfo_get_version(pkgmgr_pkginfo_h handle, char **version)
3007 {
3008         int ret = 0;
3009         ret = pkgmgrinfo_pkginfo_get_version(handle, version);
3010         return ret;
3011 }
3012
3013 API int pkgmgr_pkginfo_get_install_location(pkgmgr_pkginfo_h handle, pkgmgr_install_location *location)
3014 {
3015         int ret = 0;
3016         pkgmgrinfo_install_location loc;
3017         ret = pkgmgrinfo_pkginfo_get_install_location(handle, &loc);
3018         *location = loc;
3019         return ret;
3020 }
3021
3022 API int pkgmgr_pkginfo_get_package_size(pkgmgr_pkginfo_h handle, int *size)
3023 {
3024         int ret = 0;
3025         ret = pkgmgrinfo_pkginfo_get_package_size(handle, size);
3026         return ret;
3027 }
3028
3029 API int pkgmgr_pkginfo_get_icon(pkgmgr_pkginfo_h handle, char **icon)
3030 {
3031         int ret = 0;
3032         ret = pkgmgrinfo_pkginfo_get_icon(handle, icon);
3033         return ret;
3034 }
3035
3036 API int pkgmgr_pkginfo_get_label(pkgmgr_pkginfo_h handle, char **label)
3037 {
3038         int ret = 0;
3039         ret = pkgmgrinfo_pkginfo_get_label(handle, label);
3040         return ret;
3041 }
3042
3043 API int pkgmgr_pkginfo_get_description(pkgmgr_pkginfo_h handle, char **description)
3044 {
3045         int ret = 0;
3046         ret = pkgmgrinfo_pkginfo_get_description(handle, description);
3047         return ret;
3048 }
3049
3050 API int pkgmgr_pkginfo_get_author_name(pkgmgr_pkginfo_h handle, char **author_name)
3051 {
3052         int ret = 0;
3053         ret = pkgmgrinfo_pkginfo_get_author_name(handle, author_name);
3054         return ret;
3055 }
3056
3057 API int pkgmgr_pkginfo_get_author_email(pkgmgr_pkginfo_h handle, char **author_email)
3058 {
3059         int ret = 0;
3060         ret = pkgmgrinfo_pkginfo_get_author_email(handle, author_email);
3061         return ret;
3062 }
3063
3064 API int pkgmgr_pkginfo_get_author_href(pkgmgr_pkginfo_h handle, char **author_href)
3065 {
3066         int ret = 0;
3067         ret = pkgmgrinfo_pkginfo_get_author_href(handle, author_href);
3068         return ret;
3069 }
3070
3071 API int pkgmgr_pkginfo_is_removable(pkgmgr_pkginfo_h handle, bool *removable)
3072 {
3073         int ret = 0;
3074         ret = pkgmgrinfo_pkginfo_is_removable(handle, removable);
3075         return ret;
3076 }
3077
3078 API int pkgmgr_pkginfo_is_preload(pkgmgr_pkginfo_h handle, bool *preload)
3079 {
3080         int ret = 0;
3081         ret = pkgmgrinfo_pkginfo_is_preload(handle, preload);
3082         return ret;
3083 }
3084
3085 API int pkgmgr_pkginfo_is_readonly(pkgmgr_pkginfo_h handle, bool *readonly)
3086 {
3087         int ret = 0;
3088         ret = pkgmgrinfo_pkginfo_is_readonly(handle, readonly);
3089         return ret;
3090 }
3091
3092 API int pkgmgr_pkginfo_is_for_all_users(pkgmgr_pkginfo_h handle, bool *for_all_users)
3093 {
3094         int ret = 0;
3095         ret = pkgmgrinfo_pkginfo_is_for_all_users(handle, for_all_users);
3096         return ret;
3097 }
3098
3099 API int pkgmgr_pkginfo_is_accessible(pkgmgr_pkginfo_h handle, bool *accessible)
3100 {
3101         int ret = 0;
3102         ret = pkgmgrinfo_pkginfo_is_accessible(handle, accessible);
3103         return ret;
3104 }
3105
3106 API int pkgmgr_pkginfo_destroy_pkginfo(pkgmgr_pkginfo_h handle)
3107 {
3108         int ret = 0;
3109         ret = pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
3110         return ret;
3111 }
3112
3113 API int pkgmgr_pkginfo_get_installed_storage(pkgmgr_pkginfo_h handle, pkgmgr_installed_storage *storage)
3114 {
3115         int ret = 0;
3116         pkgmgrinfo_installed_storage sto;
3117         ret = pkgmgrinfo_pkginfo_get_installed_storage(handle, &sto);
3118         *storage = sto;
3119         return ret;
3120 }
3121
3122 API int pkgmgr_pkginfo_get_installed_time(pkgmgr_pkginfo_h handle, int *installed_time)
3123 {
3124         int ret = 0;
3125         ret = pkgmgrinfo_pkginfo_get_installed_time(handle, installed_time);
3126         return ret;
3127 }
3128
3129 API int pkgmgr_appinfo_get_list(pkgmgr_pkginfo_h handle, pkgmgr_app_component component,
3130                                                         pkgmgr_info_app_list_cb app_func, void *user_data)
3131 {
3132         int ret = 0;
3133         ret = pkgmgrinfo_appinfo_get_list(handle, component, app_func, user_data);
3134         return ret;
3135 }
3136
3137 API int pkgmgr_appinfo_get_usr_list(pkgmgr_pkginfo_h handle, pkgmgr_app_component component,
3138                                                         pkgmgr_info_app_list_cb app_func, void *user_data, uid_t uid)
3139 {
3140         int ret = 0;
3141         ret = pkgmgrinfo_appinfo_get_usr_list(handle, component, app_func, user_data, uid);
3142         return ret;
3143 }
3144
3145 API int pkgmgr_appinfo_foreach_category(pkgmgr_appinfo_h handle, pkgmgr_info_app_category_list_cb category_func,
3146                                                         void *user_data)
3147 {
3148         int ret = 0;
3149         ret = pkgmgrinfo_appinfo_foreach_category(handle, category_func, user_data);
3150         return ret;
3151 }
3152
3153 API int pkgmgr_appinfo_get_appinfo(const char *appid, pkgmgr_appinfo_h *handle)
3154 {
3155         int ret = 0;
3156         ret = pkgmgrinfo_appinfo_get_appinfo(appid, handle);
3157         return ret;
3158 }
3159
3160 API int pkgmgr_appinfo_get_appid(pkgmgr_appinfo_h  handle, char **appid)
3161 {
3162         int ret = 0;
3163         ret = pkgmgrinfo_appinfo_get_appid(handle, appid);
3164         return ret;
3165 }
3166
3167 API int pkgmgr_appinfo_get_pkgname(pkgmgr_appinfo_h  handle, char **pkg_name)
3168 {
3169         int ret = 0;
3170         ret = pkgmgrinfo_appinfo_get_pkgname(handle, pkg_name);
3171         return ret;
3172 }
3173
3174 API int pkgmgr_appinfo_get_pkgid(pkgmgr_appinfo_h  handle, char **pkgid)
3175 {
3176         int ret = 0;
3177         ret = pkgmgrinfo_appinfo_get_pkgid(handle, pkgid);
3178         return ret;
3179 }
3180
3181 API int pkgmgr_appinfo_get_icon(pkgmgr_appinfo_h handle, char **icon)
3182 {
3183         int ret = 0;
3184         ret = pkgmgrinfo_appinfo_get_icon(handle, icon);
3185         return ret;
3186 }
3187
3188 API int pkgmgr_appinfo_get_label(pkgmgr_appinfo_h handle, char **label)
3189 {
3190         int ret = 0;
3191         ret = pkgmgrinfo_appinfo_get_label(handle, label);
3192         return ret;
3193 }
3194
3195 API int pkgmgr_appinfo_get_exec(pkgmgr_appinfo_h  handle, char **exec)
3196 {
3197         int ret = 0;
3198         ret = pkgmgrinfo_appinfo_get_exec(handle, exec);
3199         return ret;
3200 }
3201
3202 API int pkgmgr_appinfo_get_component(pkgmgr_appinfo_h  handle, pkgmgr_app_component *component)
3203 {
3204         int ret = 0;
3205         pkgmgrinfo_app_component comp;
3206         ret = pkgmgrinfo_appinfo_get_component(handle, &comp);
3207         *component = comp;
3208         return ret;
3209 }
3210
3211 API int pkgmgr_appinfo_get_apptype(pkgmgr_appinfo_h  handle, char **app_type)
3212 {
3213         int ret = 0;
3214         ret = pkgmgrinfo_appinfo_get_apptype(handle, app_type);
3215         return ret;
3216 }
3217
3218 API int pkgmgr_appinfo_is_nodisplay(pkgmgr_appinfo_h  handle, bool *nodisplay)
3219 {
3220         int ret = 0;
3221         ret = pkgmgrinfo_appinfo_is_nodisplay(handle, nodisplay);
3222         return ret;
3223 }
3224
3225 API int pkgmgr_appinfo_is_multiple(pkgmgr_appinfo_h  handle, bool *multiple)
3226 {
3227         int ret = 0;
3228         ret = pkgmgrinfo_appinfo_is_multiple(handle, multiple);
3229         return ret;
3230 }
3231
3232 API int pkgmgr_appinfo_is_taskmanage(pkgmgr_appinfo_h  handle, bool *taskmanage)
3233 {
3234         int ret = 0;
3235         ret = pkgmgrinfo_appinfo_is_taskmanage(handle, taskmanage);
3236         return ret;
3237 }
3238
3239 API int pkgmgr_appinfo_get_hwacceleration(pkgmgr_appinfo_h  handle, pkgmgr_hwacceleration_type *hwacceleration)
3240 {
3241         int ret = 0;
3242         pkgmgrinfo_app_hwacceleration hwacc;
3243         ret = pkgmgrinfo_appinfo_get_hwacceleration(handle, &hwacc);
3244         *hwacceleration = hwacc;
3245         return ret;
3246 }
3247
3248 API int pkgmgr_appinfo_is_onboot(pkgmgr_appinfo_h  handle, bool *onboot)
3249 {
3250         int ret = 0;
3251         ret = pkgmgrinfo_appinfo_is_onboot(handle, onboot);
3252         return ret;
3253 }
3254
3255 API int pkgmgr_appinfo_is_autorestart(pkgmgr_appinfo_h  handle, bool *autorestart)
3256 {
3257         int ret = 0;
3258         ret = pkgmgrinfo_appinfo_is_autorestart(handle, autorestart);
3259         return ret;
3260 }
3261
3262 API int pkgmgr_appinfo_destroy_appinfo(pkgmgr_appinfo_h  handle)
3263 {
3264         int ret = 0;
3265         ret = pkgmgrinfo_appinfo_destroy_appinfo(handle);
3266         return ret;
3267 }
3268
3269 API int pkgmgr_pkginfo_create_certinfo(pkgmgr_certinfo_h *handle)
3270 {
3271         int ret = 0;
3272         ret = pkgmgrinfo_pkginfo_create_certinfo(handle);
3273         return ret;
3274 }
3275
3276 API int pkgmgr_pkginfo_load_certinfo(const char *pkgid, pkgmgr_certinfo_h handle, uid_t uid)
3277 {
3278         int ret = 0;
3279         ret = pkgmgrinfo_pkginfo_load_certinfo(pkgid, handle, uid);
3280         return ret;
3281 }
3282
3283 API int pkgmgr_pkginfo_get_cert_value(pkgmgr_certinfo_h handle, pkgmgr_cert_type cert_type, const char **cert_value)
3284 {
3285         int ret = 0;
3286         ret = pkgmgrinfo_pkginfo_get_cert_value(handle, cert_type, cert_value);
3287         return ret;
3288 }
3289
3290 API int pkgmgr_pkginfo_destroy_certinfo(pkgmgr_certinfo_h handle)
3291 {
3292         int ret = 0;
3293         ret = pkgmgrinfo_pkginfo_destroy_certinfo(handle);
3294         return ret;
3295 }
3296
3297 API int pkgmgr_datacontrol_get_info(const char *providerid, const char * type, char **appid, char **access)
3298 {
3299         int ret = 0;
3300         ret = pkgmgrinfo_datacontrol_get_info(providerid, type, appid, access);
3301         return ret;
3302 }