client/src/pkgmgr.c

   1 /*
   2  * slp-pkgmgr
   3  *
   4  * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Contact: Jayoun Lee <airjany@samsung.com>, Sewook Park <sewook7.park@samsung.com>,
   7  * Jaeho Lee <jaeho81.lee@samsung.com>, Shobhit Srivastava <shobhit.s@samsung.com>
   8  *
   9  * Licensed under the Apache License, Version 2.0 (the "License");
  10  * you may not use this file except in compliance with the License.
  11  * You may obtain a copy of the License at
  12  *
  13  * http://www.apache.org/licenses/LICENSE-2.0
  14  *
  15  * Unless required by applicable law or agreed to in writing, software
  16  * distributed under the License is distributed on an "AS IS" BASIS,
  17  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  18  * See the License for the specific language governing permissions and
  19  * limitations under the License.
  20  *
  21  */
  22
  23 #include <stdio.h>
  24 #include <stdlib.h>
  25 #include <string.h>
  26 #include <unistd.h>
  27 #include <dlfcn.h>
  28 #include <dirent.h>
  29 #include <fcntl.h>
  30 #include <sys/wait.h>
  31 #include <sys/time.h>
  32
  33 #include <dbus/dbus.h>
  34 #include <dbus/dbus-glib-lowlevel.h>
  35
  36 #include <ail.h>
  37 #include <db-util.h>
  38 #include <pkgmgr-info.h>
  39 #include <iniparser.h>
  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         pc = (pkgmgr_client_t *) cb_data;
 320
 321         /* find callback info */
 322         cb_info = __find_op_cbinfo(pc, req_id);
 323         if (cb_info == NULL) {
 324                 ERR("cannot fint cb_info for req_id:%d", req_id);
 325                 return;
 326         }
 327
 328         /* call callback */
 329         if (cb_info->event_cb) {
 330                 if (pc->new_event_cb)
 331                         cb_info->event_cb(target_uid, cb_info->request_id,
 332                                         pkg_type, pkgid, key, val, pc,
 333                                         cb_info->data);
 334                 else
 335                         cb_info->event_cb(target_uid, cb_info->request_id,
 336                                         pkg_type, pkgid, key, val, NULL,
 337                                         cb_info->data);
 338         }
 339
 340         /*remove callback for last call
 341            if (strcmp(key, "end") == 0) {
 342            __remove_op_cbinfo(pc, cb_info);
 343            DBG("__remove_op_cbinfo");
 344            }
 345          */
 346
 347         return;
 348 }
 349
 350 static void __status_callback(void *cb_data, uid_t target_uid,
 351                               const char *req_id, const char *pkg_type,
 352                               const char *pkgid,  const char *key,
 353                               const char *val)
 354 {
 355         pkgmgr_client_t *pc;
 356         listen_cb_info *tmp;
 357
 358         pc = (pkgmgr_client_t *) cb_data;
 359
 360         tmp = pc->info.listening.lhead;
 361         while (tmp) {
 362                 if (tmp->event_cb(target_uid, tmp->request_id, pkg_type, pkgid,
 363                                   key, val, NULL, tmp->data) != 0)
 364                         break;
 365                 tmp = tmp->next;
 366         }
 367
 368         return;
 369 }
 370
 371 static char *__get_req_key(const char *pkg_path)
 372 {
 373         struct timeval tv;
 374         long curtime;
 375         char timestr[PKG_STRING_LEN_MAX];
 376         char *str_req_key;
 377         int size;
 378
 379         gettimeofday(&tv, NULL);
 380         curtime = tv.tv_sec * 1000000 + tv.tv_usec;
 381         snprintf(timestr, sizeof(timestr), "%ld", curtime);
 382
 383         size = strlen(pkg_path) + strlen(timestr) + 2;
 384         str_req_key = (char *)calloc(size, sizeof(char));
 385         if (str_req_key == NULL) {
 386                 DBG("calloc failed");
 387                 return NULL;
 388         }
 389         snprintf(str_req_key, size, "%s_%s", pkg_path, timestr);
 390
 391         return str_req_key;
 392 }
 393
 394 static char *__get_type_from_path(const char *pkg_path)
 395 {
 396         int ret;
 397         char mimetype[255] = { '\0', };
 398         char extlist[256] = { '\0', };
 399         char *pkg_type;
 400
 401         ret = _get_mime_from_file(pkg_path, mimetype, sizeof(mimetype));
 402         if (ret) {
 403                 ERR("_get_mime_from_file() failed - error code[%d]\n",
 404                       ret);
 405                 return NULL;
 406         }
 407
 408         ret = _get_mime_extension(mimetype, extlist, sizeof(extlist));
 409         if (ret) {
 410                 ERR("_get_mime_extension() failed - error code[%d]\n",
 411                       ret);
 412                 return NULL;
 413         }
 414
 415         if (strlen(extlist) == 0)
 416                 return NULL;
 417
 418         if (strchr(extlist, ',')) {
 419                 extlist[strlen(extlist) - strlen(strchr(extlist, ','))] = '\0';
 420         }
 421         pkg_type = strchr(extlist, '.') + 1;
 422         return strdup(pkg_type);
 423 }
 424
 425 static int __get_pkgid_by_appid(const char *appid, char **pkgid)
 426 {
 427         pkgmgrinfo_appinfo_h pkgmgrinfo_appinfo = NULL;
 428         int ret = -1;
 429         char *pkg_id = NULL;
 430         char *pkg_id_dup = NULL;
 431
 432         if (pkgmgrinfo_appinfo_get_appinfo(appid, &pkgmgrinfo_appinfo) != PMINFO_R_OK)
 433                 return -1;
 434
 435         if (pkgmgrinfo_appinfo_get_pkgname(pkgmgrinfo_appinfo, &pkg_id) != PMINFO_R_OK)
 436                 goto err;
 437
 438         pkg_id_dup = strdup(pkg_id);
 439         if (pkg_id_dup == NULL)
 440                 goto err;
 441
 442         *pkgid = pkg_id_dup;
 443         ret = PMINFO_R_OK;
 444
 445 err:
 446         pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
 447
 448         return ret;
 449 }
 450
 451 static inline ail_cb_ret_e __appinfo_cb(const ail_appinfo_h appinfo, void *user_data)
 452 {
 453         char *package;
 454         ail_cb_ret_e ret = AIL_CB_RET_CONTINUE;
 455
 456         ail_appinfo_get_str(appinfo, AIL_PROP_PACKAGE_STR, &package);
 457
 458         if (package) {
 459                 (* (char **) user_data) = strdup(package);
 460                 ret = AIL_CB_RET_CANCEL;
 461         }
 462
 463         return ret;
 464 }
 465
 466 static char *__get_app_info_from_db_by_apppath(const char *apppath, uid_t uid)
 467 {
 468         char *caller_appid = NULL;
 469         ail_filter_h filter;
 470         ail_error_e ret;
 471         int count;
 472
 473         if (apppath == NULL)
 474                 return NULL;
 475
 476         ret = ail_filter_new(&filter);
 477         if (ret != AIL_ERROR_OK) {
 478                 return NULL;
 479         }
 480
 481         ret = ail_filter_add_str(filter, AIL_PROP_X_SLP_EXE_PATH, apppath);
 482         if (ret != AIL_ERROR_OK) {
 483                 ail_filter_destroy(filter);
 484                 return NULL;
 485         }
 486
 487         if(uid != GLOBAL_USER)
 488                 ret = ail_filter_count_usr_appinfo(filter, &count, uid);
 489         else
 490                 ret = ail_filter_count_appinfo(filter, &count);
 491
 492         if (ret != AIL_ERROR_OK) {
 493                 ail_filter_destroy(filter);
 494                 return NULL;
 495         }
 496         if (count < 1) {
 497                 ail_filter_destroy(filter);
 498                 return NULL;
 499         }
 500         if(uid != GLOBAL_USER)
 501                 ail_filter_list_usr_appinfo_foreach(filter, __appinfo_cb, &caller_appid,uid);
 502         else
 503                 ail_filter_list_appinfo_foreach(filter, __appinfo_cb, &caller_appid);
 504
 505         ail_filter_destroy(filter);
 506
 507         return caller_appid;
 508 }
 509
 510 static inline int __read_proc(const char *path, char *buf, int size)
 511 {
 512         int fd = 0;
 513         int ret = 0;
 514
 515         if (buf == NULL || path == NULL)
 516                 return -1;
 517
 518         fd = open(path, O_RDONLY);
 519         if (fd < 0)
 520                 return -1;
 521
 522         ret = read(fd, buf, size - 1);
 523         if (ret <= 0) {
 524                 close(fd);
 525                 return -1;
 526         } else
 527                 buf[ret] = 0;
 528
 529         close(fd);
 530
 531         return ret;
 532 }
 533
 534 char *__proc_get_cmdline_bypid(int pid)
 535 {
 536         char buf[PKG_STRING_LEN_MAX] = {'\0', };
 537         int ret = 0;
 538
 539         snprintf(buf, sizeof(buf), "/proc/%d/cmdline", pid);
 540         ret = __read_proc(buf, buf, sizeof(buf));
 541         if (ret <= 0)
 542                 return NULL;
 543
 544         /* support app launched by shell script*/
 545         if (strncmp(buf, BINSH_NAME, BINSH_SIZE) == 0)
 546                 return strdup(&buf[BINSH_SIZE + 1]);
 547         else
 548                 return strdup(buf);
 549 }
 550
 551 static int __get_appid_bypid(int pid, char *pkgname, int len, uid_t uid)
 552 {
 553         char *cmdline = NULL;
 554         char *caller_appid = NULL;
 555
 556         cmdline = __proc_get_cmdline_bypid(pid);
 557         if (cmdline == NULL)
 558                 return -1;
 559
 560         caller_appid = __get_app_info_from_db_by_apppath(cmdline, uid);
 561         snprintf(pkgname, len, "%s", caller_appid);
 562
 563         free(cmdline);
 564         free(caller_appid);
 565
 566         return 0;
 567 }
 568
 569 static char *__get_caller_pkgid(uid_t uid)
 570 {
 571         char *caller_appid[PKG_STRING_LEN_MAX] = {0, };
 572         char *caller_pkgid = NULL;
 573
 574         if (__get_appid_bypid(getpid(), caller_appid, sizeof(caller_appid), uid) < 0) {
 575                 ERR("get appid fail!!!\n");
 576                 return NULL;
 577         }
 578         if (__get_pkgid_by_appid(caller_appid, &caller_pkgid) < 0){
 579                 ERR("get pkgid fail!!!\n");
 580                 return NULL;
 581         }
 582
 583         return caller_pkgid;
 584 }
 585
 586 static inline int __pkgmgr_read_proc(const char *path, char *buf, int size)
 587 {
 588         int fd;
 589         int ret;
 590
 591         if (buf == NULL || path == NULL)
 592                 return -1;
 593
 594         fd = open(path, O_RDONLY);
 595         if (fd < 0)
 596                 return -1;
 597
 598         ret = read(fd, buf, size - 1);
 599         if (ret <= 0) {
 600                 close(fd);
 601                 return -1;
 602         } else
 603                 buf[ret] = 0;
 604
 605         close(fd);
 606
 607         return ret;
 608 }
 609
 610 static inline int __pkgmgr_find_pid_by_cmdline(const char *dname,
 611                                       const char *cmdline, const char *apppath)
 612 {
 613         int pid = 0;
 614
 615         if (strncmp(cmdline, apppath, PKG_STRING_LEN_MAX-1) == 0) {
 616                 pid = atoi(dname);
 617                 if (pid != getpgid(pid))
 618                         pid = 0;
 619         }
 620
 621         return pid;
 622 }
 623
 624
 625 static int __pkgmgr_proc_iter_kill_cmdline(const char *apppath)
 626 {
 627         DIR *dp;
 628         struct dirent *dentry;
 629         int pid;
 630         int ret;
 631         char buf[PKG_STRING_LEN_MAX];
 632
 633         dp = opendir("/proc");
 634         if (dp == NULL) {
 635                 return -1;
 636         }
 637
 638         while ((dentry = readdir(dp)) != NULL) {
 639                 if (!isdigit(dentry->d_name[0]))
 640                         continue;
 641
 642                 snprintf(buf, sizeof(buf), "/proc/%s/cmdline", dentry->d_name);
 643                 ret = __pkgmgr_read_proc(buf, buf, sizeof(buf));
 644                 if (ret <= 0)
 645                         continue;
 646
 647                 pid = __pkgmgr_find_pid_by_cmdline(dentry->d_name, buf, apppath);
 648
 649                 if (pid > 0) {
 650                         int pgid;
 651
 652                         pgid = getpgid(pid);
 653                         if (pgid <= 1) {
 654                                 closedir(dp);
 655                                 return -1;
 656                         }
 657
 658                         if (killpg(pgid, SIGKILL) < 0) {
 659                                 closedir(dp);
 660                                 return -1;
 661                         }
 662                 }
 663         }
 664
 665         closedir(dp);
 666         return 0;
 667 }
 668
 669
 670 static int __app_list_cb (const pkgmgrinfo_appinfo_h handle,
 671                                                 void *user_data)
 672 {
 673         char *exec = NULL;
 674         pkgmgrinfo_appinfo_get_exec(handle, &exec);
 675
 676         __pkgmgr_proc_iter_kill_cmdline(exec);
 677
 678         return 0;
 679 }
 680
 681 static int __sync_process(char *req_key)
 682 {
 683         int ret;
 684         char info_file[PKG_STRING_LEN_MAX] = {'\0', };
 685         int result = -1;
 686         int check_cnt = 0;
 687         FILE *fp;
 688         char buf[PKG_STRING_LEN_MAX] = {0, };
 689
 690         snprintf(info_file, PKG_STRING_LEN_MAX, "%s/%s", PKG_SIZE_INFO_PATH, req_key);
 691         while(1)
 692         {
 693                 check_cnt++;
 694
 695                 if (access(info_file, F_OK) == 0) {
 696                         fp = fopen(info_file, "r");
 697                         if (fp == NULL){
 698                                 DBG("file is not generated yet.... wait\n");
 699                                 usleep(100 * 1000);     /* 100ms sleep*/
 700                                 continue;
 701                         }
 702
 703                         fgets(buf, PKG_STRING_LEN_MAX, fp);
 704                         fclose(fp);
 705
 706                         DBG("info_file file is generated, result = %s. \n", buf);
 707                         result = atoi(buf);
 708                         break;
 709                 }
 710
 711                 DBG("file is not generated yet.... wait\n");
 712                 usleep(100 * 1000);     /* 100ms sleep*/
 713
 714                 if (check_cnt > 6000) { /* 60s * 10 time over*/
 715                         ERR("wait time over!!\n");
 716                         break;
 717                 }
 718         }
 719
 720         ret = remove(info_file);
 721         if (ret < 0)
 722                 ERR("file is can not remove[%s, %d]\n", info_file, ret);
 723
 724         return result;
 725 }
 726 static int __csc_process(const char *csc_path, char *result_path)
 727 {
 728         int ret = 0;
 729         int cnt = 0;
 730         int count = 0;
 731         int csc_fail = 0;
 732         int fd = 0;
 733         char *pkgtype = NULL;
 734         char *des = NULL;
 735         char buf[PKG_STRING_LEN_MAX] = {0,};
 736         char type_buf[1024] = { 0 };
 737         char des_buf[1024] = { 0 };
 738         dictionary *csc = NULL;
 739         FILE* file = NULL;
 740
 741         csc = iniparser_load(csc_path);
 742         retvm_if(csc == NULL, PKGMGR_R_EINVAL, "cannot open parse file [%s]", csc_path);
 743
 744         file = fopen(result_path, "w");
 745         tryvm_if(file == NULL, ret = PKGMGR_R_EINVAL, "cannot open result file [%s]", result_path);
 746
 747         count = iniparser_getint(csc, "csc packages:count", -1);
 748         tryvm_if(count == 0, ret = PKGMGR_R_ERROR, "csc [%s] dont have packages", csc_path);
 749
 750         snprintf(buf, PKG_STRING_LEN_MAX, "[result]\n");
 751         fwrite(buf, 1, strlen(buf), file);
 752         snprintf(buf, PKG_STRING_LEN_MAX, "count = %d\n", count);
 753         fwrite(buf, 1, strlen(buf), file);
 754
 755         for(cnt = 1 ; cnt <= count ; cnt++)
 756         {
 757                 snprintf(type_buf, PKG_STRING_LEN_MAX - 1, "csc packages:type_%03d", cnt);
 758                 snprintf(des_buf, PKG_STRING_LEN_MAX - 1, "csc packages:description_%03d", cnt);
 759
 760                 pkgtype = iniparser_getstring(csc, type_buf, NULL);
 761                 des = iniparser_getstring(csc, des_buf, NULL);
 762                 ret = 0;
 763
 764                 if (pkgtype == NULL) {
 765                         csc_fail++;
 766                         snprintf(buf, PKG_STRING_LEN_MAX, "%s = Fail to get pkgtype\n", type_buf);
 767                         fwrite(buf, 1, strlen(buf), file);
 768                         continue;
 769                 } else if (des == NULL) {
 770                         csc_fail++;
 771                         snprintf(buf, PKG_STRING_LEN_MAX, "%s = Fail to get description\n", des_buf);
 772                         fwrite(buf, 1, strlen(buf), file);
 773                         continue;
 774                 }
 775
 776                 snprintf(buf, PKG_STRING_LEN_MAX, "type_%03d = %s\n", cnt, pkgtype);
 777                 fwrite(buf, 1, strlen(buf), file);
 778                 snprintf(buf, PKG_STRING_LEN_MAX, "description_%03d = %s\n", cnt, des);
 779                 fwrite(buf, 1, strlen(buf), file);
 780
 781                 if (strcmp(pkgtype, "tpk") == 0) {
 782                         const char *ospinstaller_argv[] = { "/usr/bin/osp-installer", "-c", des, NULL };
 783                         ret = __xsystem(ospinstaller_argv);
 784                 } else if (strcmp(pkgtype, "wgt")== 0) {
 785                         const char *wrtinstaller_argv[] = { "/usr/bin/wrt-installer", "-c", des, NULL };
 786                         ret = __xsystem(wrtinstaller_argv);
 787                 } else {
 788                         csc_fail++;
 789                         ret = -1;
 790                 }
 791
 792                 if (ret != 0) {
 793                         char *errstr = NULL;
 794                         __error_to_string(ret, &errstr);
 795                         snprintf(buf, PKG_STRING_LEN_MAX, "result_%03d = fail[%s]\n", cnt, errstr);
 796                 }
 797                 else
 798                         snprintf(buf, PKG_STRING_LEN_MAX, "result_%03d = success\n", cnt);
 799
 800                 fwrite(buf, 1, strlen(buf), file);
 801         }
 802
 803 catch:
 804         iniparser_freedict(csc);
 805         if (file != NULL) {
 806                 fflush(file);
 807                 fd = fileno(file);
 808                 fsync(fd);
 809                 fclose(file);
 810         }
 811         return ret;
 812 }
 813
 814 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)
 815 {
 816         char *req_key = NULL;
 817         int ret =0;
 818         char *pkgtype = "rpm";
 819         char *argv[PKG_ARGC_MAX] = { NULL, };
 820         char *args = NULL;
 821         int argcnt = 0;
 822         int len = 0;
 823         char *temp = NULL;
 824         int i = 0;
 825         char buf[128] = {'\0'};
 826
 827         pkgmgr_client_t *mpc = (pkgmgr_client_t *) pc;
 828         retvm_if(mpc->ctype != PC_REQUEST, PKGMGR_R_EINVAL, "mpc->ctype is not PC_REQUEST\n");
 829
 830         req_key = __get_req_key(pkgid);
 831
 832         snprintf(buf, 128, "%d", get_type);
 833         argv[argcnt++] = strdup(pkgid);
 834         argv[argcnt++] = strdup(buf);
 835         argv[argcnt++] = strdup(req_key);
 836
 837         /*** add quote in all string for special charactor like '\n'***   FIX */
 838         for (i = 0; i < argcnt; i++) {
 839                 temp = g_shell_quote(argv[i]);
 840                 len += (strlen(temp) + 1);
 841                 g_free(temp);
 842         }
 843
 844         args = (char *)calloc(len, sizeof(char));
 845         tryvm_if(args == NULL, ret = PKGMGR_R_EINVAL, "installer_path fail");
 846
 847         strncpy(args, argv[0], len - 1);
 848
 849         for (i = 1; i < argcnt; i++) {
 850                 strncat(args, " ", strlen(" "));
 851                 temp = g_shell_quote(argv[i]);
 852                 strncat(args, temp, strlen(temp));
 853                 g_free(temp);
 854         }
 855         DBG("[args] %s [len] %d\n", args, len);
 856
 857         /* request */
 858         ret = comm_client_request(mpc->info.request.cc, req_key, COMM_REQ_GET_SIZE, pkgtype, pkgid, args, uid, 1);
 859         if (ret < 0)
 860                 ERR("comm_client_request failed, ret=%d\n", ret);
 861
 862         ret = __sync_process(req_key);
 863         if (ret < 0)
 864                 ERR("get size failed, ret=%d\n", ret);
 865
 866 catch:
 867         for (i = 0; i < argcnt; i++)
 868                 free(argv[i]);
 869
 870         if(args)
 871                 free(args);
 872
 873         return ret;
 874 }
 875
 876 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)
 877 {
 878         char *req_key = NULL;
 879         int req_id = 0;
 880         int ret =0;
 881         pkgmgrinfo_pkginfo_h handle;
 882         char *pkgtype = NULL;
 883         char *installer_path = NULL;
 884         char *argv[PKG_ARGC_MAX] = { NULL, };
 885         char *args = NULL;
 886         int argcnt = 0;
 887         int len = 0;
 888         char *temp = NULL;
 889         int i = 0;
 890         char buf[128] = {'\0'};
 891
 892         pkgmgr_client_t *mpc = (pkgmgr_client_t *) pc;
 893         retvm_if(mpc->ctype != PC_REQUEST, PKGMGR_R_EINVAL, "mpc->ctype is not PC_REQUEST\n");
 894
 895         if(uid != GLOBAL_USER)
 896                 ret = pkgmgrinfo_pkginfo_get_usr_pkginfo(pkgid, uid, &handle);
 897         else
 898                 ret = pkgmgrinfo_pkginfo_get_pkginfo(pkgid, &handle);
 899         retvm_if(ret < 0, PKGMGR_R_ERROR, "pkgmgrinfo_pkginfo_get_pkginfo failed");
 900
 901         ret = pkgmgrinfo_pkginfo_get_type(handle, &pkgtype);
 902         tryvm_if(ret < 0, ret = PKGMGR_R_ERROR, "pkgmgrinfo_pkginfo_get_type failed");
 903
 904         installer_path = _get_backend_path_with_type(pkgtype);
 905         req_key = __get_req_key(pkgid);
 906         req_id = _get_request_id();
 907
 908         /* generate argv */
 909         snprintf(buf, 128, "%d", move_type);
 910         /* argv[0] installer path */
 911         argv[argcnt++] = installer_path;
 912         /* argv[1] */
 913         argv[argcnt++] = strdup("-k");
 914         /* argv[2] */
 915         argv[argcnt++] = req_key;
 916         /* argv[3] */
 917         argv[argcnt++] = strdup("-m");
 918         /* argv[4] */
 919         argv[argcnt++] = strdup(pkgid);
 920         /* argv[5] */
 921         argv[argcnt++] = strdup("-t");
 922         /* argv[6] */
 923         argv[argcnt++] = strdup(buf);
 924
 925         /*** add quote in all string for special charactor like '\n'***   FIX */
 926         for (i = 0; i < argcnt; i++) {
 927                 temp = g_shell_quote(argv[i]);
 928                 len += (strlen(temp) + 1);
 929                 g_free(temp);
 930         }
 931
 932         args = (char *)calloc(len, sizeof(char));
 933         tryvm_if(args == NULL, ret = PKGMGR_R_EINVAL, "installer_path fail");
 934
 935         strncpy(args, argv[0], len - 1);
 936
 937         for (i = 1; i < argcnt; i++) {
 938                 strncat(args, " ", strlen(" "));
 939                 temp = g_shell_quote(argv[i]);
 940                 strncat(args, temp, strlen(temp));
 941                 g_free(temp);
 942         }
 943         DBG("[args] %s [len] %d\n", args, len);
 944
 945         /* 6. request */
 946         ret = comm_client_request(mpc->info.request.cc, req_key, COMM_REQ_TO_MOVER, pkgtype, pkgid, args, uid, 1);
 947         if (ret < 0)
 948                 ERR("comm_client_request failed, ret=%d\n", ret);
 949
 950         ret = __sync_process(pkgid);
 951         if (ret != 0)
 952                 ERR("move pkg failed, ret=%d\n", ret);
 953
 954 catch:
 955         for (i = 0; i < argcnt; i++)
 956                 free(argv[i]);
 957
 958         if(args)
 959                 free(args);
 960
 961         pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
 962         return ret;
 963 }
 964
 965 static int __check_app_process(pkgmgr_request_service_type service_type, pkgmgr_client * pc, const char *pkgid, uid_t uid, void *data)
 966 {
 967         const char *pkgtype;
 968         char *req_key;
 969         int ret;
 970         pkgmgrinfo_pkginfo_h handle;
 971         int pid = -1;
 972
 973         /* Check for NULL value of pc */
 974         pkgmgr_client_t *mpc = (pkgmgr_client_t *) pc;
 975         retvm_if(mpc->ctype != PC_REQUEST, PKGMGR_R_EINVAL, "mpc->ctype is not PC_REQUEST\n");
 976
 977         if (uid != GLOBAL_USER)
 978                 ret = pkgmgrinfo_pkginfo_get_usr_pkginfo(pkgid, uid, &handle);
 979         else
 980                 ret = pkgmgrinfo_pkginfo_get_pkginfo(pkgid, &handle);
 981         retvm_if(ret < 0, PKGMGR_R_ERROR, "pkgmgrinfo_pkginfo_get_pkginfo failed");
 982
 983         ret = pkgmgrinfo_pkginfo_get_type(handle, &pkgtype);
 984         tryvm_if(ret < 0, ret = PKGMGR_R_ERROR, "pkgmgrinfo_pkginfo_get_type failed");
 985
 986         /* 2. generate req_key */
 987         req_key = __get_req_key(pkgid);
 988
 989         /* 3. request activate */
 990         if (service_type == PM_REQUEST_KILL_APP)
 991                 ret = comm_client_request(mpc->info.request.cc, req_key, COMM_REQ_KILL_APP, pkgtype, pkgid, NULL, uid, 1);
 992         else if (service_type == PM_REQUEST_CHECK_APP)
 993                 ret = comm_client_request(mpc->info.request.cc, req_key, COMM_REQ_CHECK_APP, pkgtype, pkgid, NULL, uid, 1);
 994
 995         if (ret < 0)
 996                 ERR("request failed, ret=%d\n", ret);
 997
 998         pid  = __sync_process(pkgid);
 999         * (int *) data = pid;
1000
1001 catch:
1002         free(req_key);
1003         pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
1004
1005         return ret;
1006
1007 }
1008
1009 static int __request_size_info(pkgmgr_client *pc, uid_t uid)
1010 {
1011         char *req_key = NULL;
1012         int ret =0;
1013         char *pkgtype = "getsize";
1014         char *pkgid = "size_info";
1015         pkgmgr_getsize_type get_type = PM_GET_SIZE_INFO;
1016
1017         char *argv[PKG_ARGC_MAX] = { NULL, };
1018         char *args = NULL;
1019         int argcnt = 0;
1020         int len = 0;
1021         char *temp = NULL;
1022         int i = 0;
1023         char buf[128] = {'\0'};
1024
1025         pkgmgr_client_t *mpc = (pkgmgr_client_t *) pc;
1026         retvm_if(mpc->ctype != PC_REQUEST, PKGMGR_R_EINVAL, "mpc->ctype is not PC_REQUEST\n");
1027
1028         req_key = __get_req_key(pkgid);
1029
1030         snprintf(buf, 128, "%d", get_type);
1031         argv[argcnt++] = strdup(pkgid);
1032         argv[argcnt++] = strdup(buf);
1033         argv[argcnt++] = strdup(buf);
1034
1035         /*** add quote in all string for special charactor like '\n'***   FIX */
1036         for (i = 0; i < argcnt; i++) {
1037                 temp = g_shell_quote(argv[i]);
1038                 len += (strlen(temp) + 1);
1039                 g_free(temp);
1040         }
1041
1042         args = (char *)calloc(len, sizeof(char));
1043         tryvm_if(args == NULL, ret = PKGMGR_R_EINVAL, "installer_path fail");
1044
1045         strncpy(args, argv[0], len - 1);
1046
1047         for (i = 1; i < argcnt; i++) {
1048                 strncat(args, " ", strlen(" "));
1049                 temp = g_shell_quote(argv[i]);
1050                 strncat(args, temp, strlen(temp));
1051                 g_free(temp);
1052         }
1053         DBG("[args] %s [len] %d\n", args, len);
1054
1055         /* request */
1056         ret = comm_client_request(mpc->info.request.cc, req_key, COMM_REQ_GET_SIZE, pkgtype, pkgid, args, uid, 1);
1057         if (ret < 0) {
1058                 ERR("COMM_REQ_GET_SIZE failed, ret=%d\n", ret);
1059         }
1060
1061 catch:
1062         for (i = 0; i < argcnt; i++)
1063                 free(argv[i]);
1064
1065         if(args)
1066                 free(args);
1067
1068         return ret;
1069 }
1070
1071 static int __change_op_cb_for_getsize(pkgmgr_client *pc)
1072 {
1073         int ret = -1;
1074
1075         retvm_if(pc == NULL, PKGMGR_R_EINVAL, "package manager client pc is NULL");
1076         pkgmgr_client_t *mpc = (pkgmgr_client_t *) pc;
1077
1078         /*  free listening head */
1079         req_cb_info *tmp = NULL;
1080         req_cb_info *prev = NULL;
1081         for (tmp = mpc->info.request.rhead; tmp;) {
1082                 prev = tmp;
1083                 tmp = tmp->next;
1084                 free(prev);
1085         }
1086
1087         /* free dbus connection */
1088         ret = comm_client_free(mpc->info.request.cc);
1089         retvm_if(ret < 0, PKGMGR_R_ERROR, "comm_client_free() failed - %d", ret);
1090
1091         /* Manage pc for seperated event */
1092         mpc->ctype = PC_REQUEST;
1093         mpc->status_type = PKGMGR_CLIENT_STATUS_GET_SIZE;
1094
1095
1096         mpc->info.request.cc = comm_client_new();
1097         retvm_if(mpc->info.request.cc == NULL, PKGMGR_R_ERROR, "client creation failed");
1098
1099         ret = comm_client_set_status_callback(COMM_STATUS_BROADCAST_GET_SIZE, mpc->info.request.cc, __operation_callback, pc);
1100         retvm_if(ret < 0, PKGMGR_R_ERROR, "set_status_callback() failed - %d", ret);
1101
1102         return PKGMGR_R_OK;
1103 }
1104
1105 static int __get_package_size_info(pkgmgr_client_t *mpc, char *req_key, const char *pkgid, pkgmgr_getsize_type get_type, uid_t uid)
1106 {
1107         char *argv[PKG_ARGC_MAX] = { NULL, };
1108         char *args = NULL;
1109         int argcnt = 0;
1110         char *pkgtype = "getsize"; //unused
1111         char buf[128] = { 0, };
1112         int len = 0;
1113         char *temp = NULL;
1114         int i = 0;
1115         int ret = 0;
1116
1117         snprintf(buf, 128, "%d", get_type);
1118         argv[argcnt++] = strdup(pkgid);
1119         argv[argcnt++] = strdup(buf);
1120         argv[argcnt++] = strdup("-k");
1121         argv[argcnt++] = req_key;
1122
1123         /*** add quote in all string for special charactor like '\n'***   FIX */
1124         for (i = 0; i < argcnt; i++) {
1125                 temp = g_shell_quote(argv[i]);
1126                 len += (strlen(temp) + 1);
1127                 g_free(temp);
1128         }
1129
1130         args = (char *)calloc(len, sizeof(char));
1131         tryvm_if(args == NULL, ret = PKGMGR_R_EINVAL, "installer_path fail");
1132
1133         strncpy(args, argv[0], len - 1);
1134
1135         for (i = 1; i < argcnt; i++) {
1136                 strncat(args, " ", strlen(" "));
1137                 temp = g_shell_quote(argv[i]);
1138                 strncat(args, temp, strlen(temp));
1139                 g_free(temp);
1140         }
1141         DBG("[args] %s [len] %d\n", args, len);
1142
1143         /* request */
1144         ret = comm_client_request(mpc->info.request.cc, req_key, COMM_REQ_GET_SIZE, pkgtype, pkgid, args, uid, 1);
1145         if (ret < 0)
1146                 ERR("COMM_REQ_GET_SIZE failed, ret=%d\n", ret);
1147
1148 catch:
1149         for (i = 0; i < argcnt; i++)
1150                 free(argv[i]);
1151
1152         if(args)
1153                 free(args);
1154
1155         return ret;
1156 }
1157
1158 static int __get_pkg_size_info_cb(uid_t target_uid, int req_id, const char *req_type,
1159                 const char *pkgid, const char *key,
1160                 const char *value, const void *pc, void *user_data)
1161 {
1162         int ret = 0;
1163         DBG("target_uid: %u, reqid: %d, req type: %s, pkgid: %s, unused key: %s, size info: %s",
1164                         target_uid, req_id, req_type, pkgid, key, value);
1165
1166         pkg_size_info_t *size_info = (pkg_size_info_t *)malloc(sizeof(pkg_size_info_t));
1167         retvm_if(size_info == NULL, -1, "The memory is insufficient.");
1168
1169         char *save_ptr = NULL;
1170         char *token = strtok_r((char*)value, ":", &save_ptr);
1171         size_info->data_size = atoll(token);
1172         token = strtok_r(NULL, ":", &save_ptr);
1173         size_info->cache_size = atoll(token);
1174         token = strtok_r(NULL, ":", &save_ptr);
1175         size_info->app_size = atoll(token);
1176         token = strtok_r(NULL, ":", &save_ptr);
1177         size_info->ext_data_size = atoll(token);
1178         token = strtok_r(NULL, ":", &save_ptr);
1179         size_info->ext_cache_size = atoll(token);
1180         token = strtok_r(NULL, ":", &save_ptr);
1181         size_info->ext_app_size = atoll(token);
1182
1183         DBG("data: %lld, cache: %lld, app: %lld, ext_data: %lld, ext_cache: %lld, ext_app: %lld",
1184                         size_info->data_size, size_info->cache_size, size_info->app_size,
1185                         size_info->ext_data_size, size_info->ext_cache_size, size_info->ext_app_size);
1186
1187         pkgmgr_client_t *pmc = (pkgmgr_client_t *)pc;
1188         tryvm_if(pmc == NULL, ret = -1, "pkgmgr_client instance is null.");
1189
1190         if (strcmp(pkgid, PKG_SIZE_INFO_TOTAL) == 0)
1191         {       // total package size info
1192                 pkgmgr_total_pkg_size_info_receive_cb callback = (pkgmgr_total_pkg_size_info_receive_cb)(pmc->new_event_cb);
1193                 callback((pkgmgr_client *)pc, size_info, user_data);
1194         }
1195         else
1196         {
1197                 pkgmgr_pkg_size_info_receive_cb callback = (pkgmgr_pkg_size_info_receive_cb)(pmc->new_event_cb);
1198                 callback((pkgmgr_client *)pc, pkgid, size_info, user_data);
1199         }
1200
1201 catch:
1202
1203         if(size_info){
1204                 free(size_info);
1205                 size_info = NULL;
1206         }
1207         return ret;
1208 }
1209
1210 API pkgmgr_client *pkgmgr_client_new(client_type ctype)
1211 {
1212         pkgmgr_client_t *pc = NULL;
1213         int ret = -1;
1214
1215         retvm_if(ctype != PC_REQUEST && ctype != PC_LISTENING && ctype != PC_BROADCAST, NULL, "ctype is not client_type");
1216
1217         /* Allocate memory for ADT:pkgmgr_client */
1218         pc = calloc(1, sizeof(pkgmgr_client_t));
1219         retvm_if(pc == NULL, NULL, "No memory");
1220
1221         /* Manage pc */
1222         pc->ctype = ctype;
1223         pc->status_type = PKGMGR_CLIENT_STATUS_ALL;
1224
1225         if (pc->ctype == PC_REQUEST) {
1226                 pc->info.request.cc = comm_client_new();
1227                 trym_if(pc->info.request.cc == NULL, "client creation failed");
1228
1229                 ret = comm_client_set_status_callback(COMM_STATUS_BROADCAST_ALL, pc->info.request.cc, __operation_callback, pc);
1230                 trym_if(ret < 0L, "comm_client_set_status_callback() failed - %d", ret);
1231         } else if (pc->ctype == PC_LISTENING) {
1232                 pc->info.listening.cc = comm_client_new();
1233                 trym_if(pc->info.listening.cc == NULL, "client creation failed");
1234
1235                 ret = comm_client_set_status_callback(COMM_STATUS_BROADCAST_ALL, pc->info.listening.cc, __status_callback, pc);
1236                 trym_if(ret < 0L, "comm_client_set_status_callback() failed - %d", ret);
1237         } else if (pc->ctype == PC_BROADCAST) {
1238                 pc->info.broadcast.bc = comm_status_broadcast_server_connect(COMM_STATUS_BROADCAST_ALL);
1239                 trym_if(pc->info.broadcast.bc == NULL, "client creation failed");
1240         }
1241
1242         return (pkgmgr_client *) pc;
1243
1244  catch:
1245         if (pc)
1246                 free(pc);
1247         return NULL;
1248 }
1249
1250 API int pkgmgr_client_free(pkgmgr_client *pc)
1251 {
1252         int ret = -1;
1253         pkgmgr_client_t *mpc = (pkgmgr_client_t *) pc;
1254         retvm_if(mpc == NULL, PKGMGR_R_EINVAL, "Invalid argument");
1255
1256         if (mpc->ctype == PC_REQUEST) {
1257                 req_cb_info *tmp;
1258                 req_cb_info *prev;
1259                 for (tmp = mpc->info.request.rhead; tmp;) {
1260                         prev = tmp;
1261                         tmp = tmp->next;
1262                         free(prev);
1263                 }
1264
1265                 ret = comm_client_free(mpc->info.request.cc);
1266                 tryvm_if(ret < 0, ret = PKGMGR_R_ERROR, "comm_client_free() failed");
1267         } else if (mpc->ctype == PC_LISTENING) {
1268                         listen_cb_info *tmp;
1269                         listen_cb_info *prev;
1270                         for (tmp = mpc->info.listening.lhead; tmp;) {
1271                                 prev = tmp;
1272                                 tmp = tmp->next;
1273                                 free(prev);
1274                         }
1275
1276                         ret = comm_client_free(mpc->info.listening.cc);
1277                         tryvm_if(ret < 0, ret = PKGMGR_R_ERROR, "comm_client_free() failed");
1278         } else if (mpc->ctype == PC_BROADCAST) {
1279                 comm_status_broadcast_server_disconnect(mpc->info.broadcast.bc);
1280                 ret = 0;
1281         } else {
1282                 ERR("Invalid client type\n");
1283                 return PKGMGR_R_EINVAL;
1284         }
1285
1286         free(mpc);
1287         mpc = NULL;
1288         return PKGMGR_R_OK;
1289
1290  catch:
1291         if (mpc) {
1292                 free(mpc);
1293                 mpc = NULL;
1294         }
1295         return PKGMGR_R_ERROR;
1296 }
1297
1298
1299 API int pkgmgr_client_usr_install(pkgmgr_client * pc, const char *pkg_type,
1300                               const char *descriptor_path, const char *pkg_path,
1301                               const char *optional_file, pkgmgr_mode mode,
1302                               pkgmgr_handler event_cb, void *data, uid_t uid)
1303 {
1304         char *pkgtype = NULL;
1305         char *installer_path = NULL;
1306         char *req_key = NULL;
1307         int req_id = 0;
1308         int i = 0;
1309         char *argv[PKG_ARGC_MAX] = { NULL, };
1310         char *args = NULL;
1311         int argcnt = 0;
1312         int len = 0;
1313         char *temp = NULL;
1314         int ret = 0;
1315         char *caller_pkgid = NULL;
1316
1317         caller_pkgid = __get_caller_pkgid(uid);
1318         if (caller_pkgid == NULL)
1319                 ERR("caller dont have pkgid..\n");
1320
1321         /* Check for NULL value of pc */
1322         retvm_if(pc == NULL, PKGMGR_R_EINVAL, "package manager client handle is NULL");
1323
1324         /* 0. check the pc type */
1325         pkgmgr_client_t *mpc = (pkgmgr_client_t *) pc;
1326         retvm_if(mpc->ctype != PC_REQUEST, PKGMGR_R_EINVAL, "mpc->ctype is not PC_REQUEST");
1327
1328         /* 1. check argument */
1329         if (descriptor_path) {
1330                 retvm_if(strlen(descriptor_path) >= PKG_STRING_LEN_MAX, PKGMGR_R_EINVAL, "descriptor_path over PKG_STRING_LEN_MAX");
1331                 retvm_if(access(descriptor_path, F_OK) != 0, PKGMGR_R_EINVAL, "descriptor_path access fail");
1332         }
1333
1334         retvm_if(pkg_path == NULL, PKGMGR_R_EINVAL, "pkg_path is NULL");
1335         retvm_if(strlen(pkg_path) >= PKG_STRING_LEN_MAX, PKGMGR_R_EINVAL, "pkg_path over PKG_STRING_LEN_MAX");
1336         retvm_if(access(pkg_path, F_OK) != 0, PKGMGR_R_EINVAL, "pkg_path access fail");
1337
1338         if (optional_file)
1339                 retvm_if(strlen(optional_file) >= PKG_STRING_LEN_MAX, PKGMGR_R_EINVAL, "optional_file over PKG_STRING_LEN_MAX");
1340
1341         /* 2. get installer path using pkg_path */
1342         if (pkg_type) {
1343                 installer_path = _get_backend_path_with_type(pkg_type);
1344                 pkgtype = strdup(pkg_type);
1345         } else {
1346                 installer_path = _get_backend_path(pkg_path);
1347                 pkgtype = __get_type_from_path(pkg_path);
1348         }
1349         if (installer_path == NULL) {
1350                 free(pkgtype);
1351                 ERR("installer_path is NULL\n");
1352                 return PKGMGR_R_EINVAL;
1353         }
1354
1355         /* 3. generate req_key */
1356         req_key = __get_req_key(pkg_path);
1357
1358         /* 4. add callback info - add callback info to pkgmgr_client */
1359         req_id = _get_request_id();
1360         __add_op_cbinfo(mpc, req_id, req_key, event_cb, NULL, data);
1361
1362         /* 5. generate argv */
1363
1364         /*  argv[0] installer path */
1365         argv[argcnt++] = installer_path;
1366         /* argv[1] */
1367         argv[argcnt++] = strdup("-k");
1368         /* argv[2] */
1369         argv[argcnt++] = req_key;
1370         /* argv[3] */
1371         argv[argcnt++] = strdup("-i");
1372         /* argv[(4)] if exists */
1373         if (descriptor_path)
1374                 argv[argcnt++] = strdup(descriptor_path);
1375         /* argv[4] */
1376         argv[argcnt++] = strdup(pkg_path);
1377         /* argv[(5)] if exists */
1378         if (optional_file){
1379                 argv[argcnt++] = strdup("-o");
1380                 argv[argcnt++] = strdup(optional_file);
1381         }
1382         if (caller_pkgid) {
1383                 argv[argcnt++] = strdup("-p");
1384                 argv[argcnt++] = strdup(caller_pkgid);
1385         }
1386
1387         /*** add quote in all string for special charactor like '\n'***   FIX */
1388         for (i = 0; i < argcnt; i++) {
1389                 temp = g_shell_quote(argv[i]);
1390                 len += (strlen(temp) + 1);
1391                 g_free(temp);
1392         }
1393
1394         args = (char *)calloc(len, sizeof(char));
1395         tryvm_if(args == NULL, ret = PKGMGR_R_ERROR, "calloc failed");
1396
1397         strncpy(args, argv[0], len - 1);
1398
1399         for (i = 1; i < argcnt; i++) {
1400                 strncat(args, " ", strlen(" "));
1401                 temp = g_shell_quote(argv[i]);
1402                 strncat(args, temp, strlen(temp));
1403                 g_free(temp);
1404         }
1405         DBG("[args] %s [len] %d\n", args, len);
1406
1407         /******************* end of quote ************************/
1408
1409         /* 6. request install */
1410         ret = comm_client_request(mpc->info.request.cc, req_key, COMM_REQ_TO_INSTALLER, pkgtype, pkg_path, args, uid, 1);
1411         tryvm_if(ret < 0, ret = PKGMGR_R_ECOMM, "request failed, ret=%d", ret);
1412
1413         ret = req_id;
1414
1415 catch:
1416         for (i = 0; i < argcnt; i++)
1417                 free(argv[i]);
1418
1419         if (args)
1420                 free(args);
1421         if (pkgtype)
1422                 free(pkgtype);
1423
1424         return ret;
1425 }
1426
1427
1428
1429 API int pkgmgr_client_install(pkgmgr_client * pc, const char *pkg_type,
1430                               const char *descriptor_path, const char *pkg_path,
1431                               const char *optional_file, pkgmgr_mode mode,
1432                               pkgmgr_handler event_cb, void *data)
1433 {
1434
1435
1436         return pkgmgr_client_usr_install(pc, pkg_type,
1437                               descriptor_path, pkg_path, optional_file, mode, event_cb,data,  GLOBAL_USER);
1438 }
1439
1440 API int pkgmgr_client_reinstall(pkgmgr_client * pc, const char *pkg_type, const char *pkgid,
1441                                   const char *optional_file, pkgmgr_mode mode,
1442                               pkgmgr_handler event_cb, void *data)
1443 {
1444         return pkgmgr_client_usr_reinstall(pc, pkg_type, pkgid, optional_file, mode, event_cb, data,GLOBAL_USER);
1445 }
1446
1447 API int pkgmgr_client_usr_reinstall(pkgmgr_client * pc, const char *pkg_type, const char *pkgid,
1448                                   const char *optional_file, pkgmgr_mode mode,
1449                               pkgmgr_handler event_cb, void *data, uid_t uid)
1450 {
1451         char *pkgtype = NULL;
1452         char *installer_path = NULL;
1453         char *req_key = NULL;
1454         int req_id = 0;
1455         int i = 0;
1456         char *argv[PKG_ARGC_MAX] = { NULL, };
1457         char *args = NULL;
1458         int argcnt = 0;
1459         int len = 0;
1460         char *temp = NULL;
1461         int ret = 0;
1462
1463         /* Check for NULL value of pc */
1464         retvm_if(pc == NULL, PKGMGR_R_EINVAL, "package manager client handle is NULL\n");
1465
1466         pkgmgr_client_t *mpc = (pkgmgr_client_t *) pc;
1467
1468         /* 0. check the pc type */
1469         retv_if(mpc->ctype != PC_REQUEST, PKGMGR_R_EINVAL);
1470
1471
1472         /* 1. check argument */
1473         retv_if(pkgid == NULL, PKGMGR_R_EINVAL);
1474         retv_if(strlen(pkgid) >= PKG_STRING_LEN_MAX, PKGMGR_R_EINVAL);
1475         if (optional_file) {
1476                 if (strlen(optional_file) >= PKG_STRING_LEN_MAX)
1477                         return PKGMGR_R_EINVAL;
1478         }
1479
1480         /* 2. get installer path using pkg_path */
1481         installer_path = _get_backend_path_with_type(pkg_type);
1482         pkgtype = strdup(pkg_type);
1483         tryvm_if(installer_path == NULL, ret = PKGMGR_R_EINVAL, "installer_path is null");
1484
1485         /* 3. generate req_key */
1486         req_key = __get_req_key(pkgid);
1487
1488         /* 4. add callback info - add callback info to pkgmgr_client */
1489         req_id = _get_request_id();
1490         __add_op_cbinfo(mpc, req_id, req_key, event_cb, NULL, data);
1491
1492         /* 5. generate argv */
1493
1494         /*  argv[0] installer path */
1495         argv[argcnt++] = installer_path;
1496         /* argv[1] */
1497         argv[argcnt++] = strdup("-k");
1498         /* argv[2] */
1499         argv[argcnt++] = req_key;
1500         /* argv[3] */
1501         argv[argcnt++] = strdup("-r");
1502         /* argv[4] */
1503         argv[argcnt++] = strdup(pkgid);
1504         /* argv[(5)] if exists */
1505         if (optional_file){
1506                 argv[argcnt++] = strdup("-o");
1507                 argv[argcnt++] = strdup(optional_file);
1508         }
1509
1510         /*** add quote in all string for special charactor like '\n'***   FIX */
1511         for (i = 0; i < argcnt; i++) {
1512                 temp = g_shell_quote(argv[i]);
1513                 len += (strlen(temp) + 1);
1514                 g_free(temp);
1515         }
1516
1517         args = (char *)calloc(len, sizeof(char));
1518         tryvm_if(args == NULL, ret = PKGMGR_R_ERROR, "calloc failed");
1519
1520         strncpy(args, argv[0], len - 1);
1521
1522         for (i = 1; i < argcnt; i++) {
1523                 strncat(args, " ", strlen(" "));
1524                 temp = g_shell_quote(argv[i]);
1525                 strncat(args, temp, strlen(temp));
1526                 g_free(temp);
1527         }
1528         DBG("[args] %s [len] %d\n", args, len);
1529
1530         /******************* end of quote ************************/
1531
1532         /* 6. request install */
1533         ret = comm_client_request(mpc->info.request.cc, req_key, COMM_REQ_TO_INSTALLER, pkgtype, pkgid, args, uid, 1);
1534         tryvm_if(ret < 0, ret = PKGMGR_R_ECOMM, "request failed");
1535
1536         ret = req_id;
1537
1538 catch:
1539         for (i = 0; i < argcnt; i++)
1540                 free(argv[i]);
1541
1542         if (args)
1543                 free(args);
1544         if (pkgtype)
1545                 free(pkgtype);
1546
1547         return ret;
1548 }
1549
1550 API int pkgmgr_client_uninstall(pkgmgr_client *pc, const char *pkg_type,
1551                                 const char *pkgid, pkgmgr_mode mode,
1552                                 pkgmgr_handler event_cb, void *data)
1553 {
1554         return pkgmgr_client_usr_uninstall(pc, pkg_type,pkgid, mode, event_cb,  data, GLOBAL_USER);
1555 }
1556 API int pkgmgr_client_usr_uninstall(pkgmgr_client *pc, const char *pkg_type,
1557                                 const char *pkgid, pkgmgr_mode mode,
1558                                 pkgmgr_handler event_cb, void *data, uid_t uid)
1559 {
1560         char *pkgtype;
1561         char *installer_path;
1562         char *req_key;
1563         int req_id;
1564         int i = 0;
1565         char *argv[PKG_ARGC_MAX] = { NULL, };
1566         char *args = NULL;
1567         int argcnt = 0;
1568         int len = 0;
1569         char *temp = NULL;
1570         int ret = -1;
1571         bool removable = false;
1572         char *caller_pkgid = NULL;
1573
1574         caller_pkgid = __get_caller_pkgid(uid);
1575         if (caller_pkgid == NULL)
1576                 DBG("caller dont have pkgid..\n");
1577
1578         /* Check for NULL value of pc */
1579         retvm_if(pc == NULL, PKGMGR_R_EINVAL, "package manager client handle is NULL\n");
1580
1581         pkgmgr_client_t *mpc = (pkgmgr_client_t *) pc;
1582
1583         /* 0. check the pc type */
1584         retv_if(mpc->ctype != PC_REQUEST, PKGMGR_R_EINVAL);
1585
1586         /* 1. check argument */
1587         retv_if(pkgid == NULL, PKGMGR_R_EINVAL);
1588
1589         pkgmgrinfo_pkginfo_h handle;
1590         ret = pkgmgrinfo_pkginfo_get_usr_pkginfo(pkgid, uid, &handle);
1591
1592         /*check package id      */
1593         tryvm_if(ret < 0, ret = PKGMGR_R_EINVAL, "pkgmgrinfo_pkginfo_get_pkginfo fail");
1594         tryvm_if(handle == NULL, ret = PKGMGR_R_EINVAL, "Pkgid(%s) can not find in installed pkg DB! \n", pkgid);
1595
1596   if (uid != GLOBAL_USER) {
1597           /*check running app , terminate app if it is running*/
1598           ret = pkgmgrinfo_appinfo_get_usr_list(handle, PMINFO_UI_APP, __app_list_cb, NULL, uid);
1599           tryvm_if(ret < 0, ret = PKGMGR_R_EINVAL, "pkgmgrinfo_appinfo_get_list : PMINFO_UI_APP fail");
1600
1601           /*check running app , terminate app if it is running*/
1602           ret = pkgmgrinfo_appinfo_get_usr_list(handle, PMINFO_SVC_APP, __app_list_cb, NULL, uid);
1603           tryvm_if(ret < 0, ret = PKGMGR_R_EINVAL, "pkgmgrinfo_appinfo_get_list : PMINFO_SVC_APP fail");
1604   } else {
1605           /*check running app , terminate app if it is running*/
1606           ret = pkgmgrinfo_appinfo_get_list(handle, PMINFO_UI_APP, __app_list_cb, NULL);
1607           tryvm_if(ret < 0, ret = PKGMGR_R_EINVAL, "pkgmgrinfo_appinfo_get_list : PMINFO_UI_APP fail");
1608
1609           /*check running app , terminate app if it is running*/
1610           ret = pkgmgrinfo_appinfo_get_list(handle, PMINFO_SVC_APP, __app_list_cb, NULL);
1611           tryvm_if(ret < 0, ret = PKGMGR_R_EINVAL, "pkgmgrinfo_appinfo_get_list : PMINFO_SVC_APP fail");
1612         }
1613   /*check type  */
1614         ret = pkgmgrinfo_pkginfo_get_type(handle, &pkgtype);
1615         tryvm_if(ret < 0, ret = PKGMGR_R_EINVAL, "pkgmgrinfo_pkginfo_get_type fail");
1616         tryvm_if(pkgtype == NULL, ret = PKGMGR_R_ERROR, "pkgtype is NULL");
1617
1618         /*check removable, execpt "rpm" type    */
1619         if (strcmp(pkgtype, "rpm")) {
1620                 pkgmgrinfo_pkginfo_is_removable(handle, &removable);
1621                 tryvm_if(removable == false, ret = PKGMGR_R_ERROR, "Pkgid(%s) can not be removed, This is non-removalbe package...\n", pkgid);
1622         }
1623
1624         /*check pkgid length    */
1625         tryvm_if(strlen(pkgid) >= PKG_STRING_LEN_MAX, ret = PKGMGR_R_EINVAL, "pkgid is too long");
1626
1627         /* 2. get installer path using pkgtype */
1628         installer_path = _get_backend_path_with_type(pkgtype);
1629         tryvm_if(installer_path == NULL, ret = PKGMGR_R_EINVAL, "installer_path fail");
1630
1631         /* 3. generate req_key */
1632         req_key = __get_req_key(pkgid);
1633
1634         /* 4. add callback info - add callback info to pkgmgr_client */
1635         req_id = _get_request_id();
1636         __add_op_cbinfo(mpc, req_id, req_key, event_cb, NULL, data);
1637
1638         /* 5. generate argv */
1639
1640         /* argv[0] installer path */
1641         argv[argcnt++] = installer_path;
1642         /* argv[1] */
1643         argv[argcnt++] = strdup("-k");
1644         /* argv[2] */
1645         argv[argcnt++] = req_key;
1646         /* argv[3] */
1647         argv[argcnt++] = strdup("-d");
1648         /* argv[4] */
1649         argv[argcnt++] = strdup(pkgid);
1650         if (caller_pkgid) {
1651                 argv[argcnt++] = strdup("-p");
1652                 argv[argcnt++] = caller_pkgid;
1653         }
1654
1655         /*** add quote in all string for special charactor like '\n'***   FIX */
1656         for (i = 0; i < argcnt; i++) {
1657                 temp = g_shell_quote(argv[i]);
1658                 len += (strlen(temp) + 1);
1659                 g_free(temp);
1660         }
1661
1662         args = (char *)calloc(len, sizeof(char));
1663         tryvm_if(args == NULL, ret = PKGMGR_R_ERROR, "calloc failed");
1664
1665         strncpy(args, argv[0], len - 1);
1666
1667         for (i = 1; i < argcnt; i++) {
1668                 strncat(args, " ", strlen(" "));
1669                 temp = g_shell_quote(argv[i]);
1670                 strncat(args, temp, strlen(temp));
1671                 g_free(temp);
1672         }
1673         DBG("[args] %s [len] %d\n", args, len);
1674
1675         /******************* end of quote ************************/
1676
1677         /* 6. request install */
1678         ret = comm_client_request(mpc->info.request.cc, req_key, COMM_REQ_TO_INSTALLER, pkgtype, pkgid, args, uid, 1);
1679         tryvm_if(ret < 0, ret = PKGMGR_R_ECOMM, "calloc failed");
1680
1681         ret = req_id;
1682
1683 catch:
1684         for (i = 0; i < argcnt; i++)
1685                 free(argv[i]);
1686
1687         if(args)
1688                 free(args);
1689
1690         pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
1691         return ret;
1692 }
1693
1694 API int pkgmgr_client_move(pkgmgr_client *pc, const char *pkg_type,
1695                                 const char *pkgid, pkgmgr_move_type move_type, pkgmgr_mode mode)
1696 {
1697         return pkgmgr_client_usr_move( pc,pkg_type, pkgid, move_type, mode, GLOBAL_USER);
1698 }
1699 API int pkgmgr_client_usr_move(pkgmgr_client *pc, const char *pkg_type,
1700                                 const char *pkgid, pkgmgr_move_type move_type, pkgmgr_mode mode, uid_t uid)
1701 {
1702         const char *pkgtype = NULL;
1703         char *installer_path = NULL;
1704         char *req_key = NULL;
1705         int i = 0;
1706         char *argv[PKG_ARGC_MAX] = { NULL, };
1707         char *args = NULL;
1708         int argcnt = 0;
1709         int len = 0;
1710         char *temp = NULL;
1711         int ret = 0;
1712         int req_id = 0;
1713         char buf[128] = {'\0'};
1714
1715         /* Check for NULL value of pc */
1716         if (pc == NULL) {
1717                 DBG("package manager client handle is NULL\n");
1718                 return PKGMGR_R_EINVAL;
1719         }
1720         pkgmgr_client_t *mpc = (pkgmgr_client_t *) pc;
1721         /*check the pc type */
1722         if (mpc->ctype != PC_REQUEST)
1723                 return PKGMGR_R_EINVAL;
1724
1725         /*check argument */
1726         if (pkgid == NULL)
1727                 return PKGMGR_R_EINVAL;
1728
1729         if (pkg_type == NULL) {
1730                 pkgtype = _get_pkg_type_from_desktop_file(pkgid, uid);
1731                 if (pkgtype == NULL)
1732                         return PKGMGR_R_EINVAL;
1733         } else
1734                 pkgtype = pkg_type;
1735
1736         if (strlen(pkgid) >= PKG_STRING_LEN_MAX)
1737                 return PKGMGR_R_EINVAL;
1738
1739         if ((move_type < PM_MOVE_TO_INTERNAL) || (move_type > PM_MOVE_TO_SDCARD))
1740                 return PKGMGR_R_EINVAL;
1741
1742         /* get installer path using pkg_path */
1743         installer_path = _get_backend_path_with_type(pkgtype);
1744         if (installer_path == NULL)
1745                 return PKGMGR_R_EINVAL;
1746
1747         /* generate req_key */
1748         req_key = __get_req_key(pkgid);
1749         req_id = _get_request_id();
1750
1751         /* generate argv */
1752         snprintf(buf, 128, "%d", move_type);
1753         /* argv[0] installer path */
1754         argv[argcnt++] = installer_path;
1755         /* argv[1] */
1756         argv[argcnt++] = strdup("-k");
1757         /* argv[2] */
1758         argv[argcnt++] = req_key;
1759         /* argv[3] */
1760         argv[argcnt++] = strdup("-m");
1761         /* argv[4] */
1762         argv[argcnt++] = strdup(pkgid);
1763         /* argv[5] */
1764         argv[argcnt++] = strdup("-t");
1765         /* argv[6] */
1766         argv[argcnt++] = strdup(buf);
1767
1768         /*** add quote in all string for special charactor like '\n'***   FIX */
1769         for (i = 0; i < argcnt; i++) {
1770                 temp = g_shell_quote(argv[i]);
1771                 len += (strlen(temp) + 1);
1772                 g_free(temp);
1773         }
1774
1775         args = (char *)calloc(len, sizeof(char));
1776         if (args == NULL) {
1777                 DBG("calloc failed");
1778
1779                 for (i = 0; i < argcnt; i++)
1780                         free(argv[i]);
1781
1782                 return PKGMGR_R_ERROR;
1783         }
1784         strncpy(args, argv[0], len - 1);
1785
1786         for (i = 1; i < argcnt; i++) {
1787                 strncat(args, " ", strlen(" "));
1788                 temp = g_shell_quote(argv[i]);
1789                 strncat(args, temp, strlen(temp));
1790                 g_free(temp);
1791         }
1792         DBG("[args] %s [len] %d\n", args, len);
1793         /******************* end of quote ************************/
1794
1795         /* 6. request install */
1796         ret = comm_client_request(mpc->info.request.cc, req_key,
1797                                   COMM_REQ_TO_MOVER, pkgtype, pkgid,
1798                                   args, uid, 1);
1799         if (ret < 0) {
1800                 ERR("request failed, ret=%d\n", ret);
1801
1802                 for (i = 0; i < argcnt; i++)
1803                         free(argv[i]);
1804
1805                 free(args);
1806                 return PKGMGR_R_ECOMM;
1807         }
1808
1809         for (i = 0; i < argcnt; i++)
1810                 free(argv[i]);
1811
1812         if (args)
1813                 free(args);
1814
1815         return req_id;
1816 }
1817
1818 API int pkgmgr_client_move_pkg(pkgmgr_client *pc, const char *pkg_type,
1819                                 const char *pkgid, pkgmgr_move_type move_type, pkgmgr_mode mode,
1820                                 pkgmgr_handler event_cb, void *data)
1821 {
1822         return pkgmgr_client_move_usr_pkg(pc, pkg_type, pkgid, GLOBAL_USER, move_type, mode, event_cb, data);
1823 }
1824
1825 API int pkgmgr_client_move_usr_pkg(pkgmgr_client *pc, const char *pkg_type,
1826                                 const char *pkgid, uid_t uid, pkgmgr_move_type move_type, pkgmgr_mode mode,
1827                                 pkgmgr_handler event_cb, void *data)
1828 {
1829         char *pkgtype;
1830         char *installer_path;
1831         char *req_key;
1832         int req_id;
1833         int i = 0;
1834         char *argv[PKG_ARGC_MAX] = { NULL, };
1835         char *args = NULL;
1836         int argcnt = 0;
1837         int len = 0;
1838         char *temp = NULL;
1839         int ret = -1;
1840         char buf[128] = {'\0'};
1841
1842         /* Check for NULL value of pc */
1843         retvm_if(pc == NULL, PKGMGR_R_EINVAL, "package manager client handle is NULL\n");
1844
1845         pkgmgr_client_t *mpc = (pkgmgr_client_t *) pc;
1846
1847         /* 0. check the pc type */
1848         retv_if(mpc->ctype != PC_REQUEST, PKGMGR_R_EINVAL);
1849
1850         /* 1. check argument */
1851         retv_if(pkgid == NULL, PKGMGR_R_EINVAL);
1852
1853         pkgmgrinfo_pkginfo_h handle;
1854   if (uid != GLOBAL_USER)
1855           ret = pkgmgrinfo_pkginfo_get_usr_pkginfo(pkgid, uid, &handle);
1856   else
1857           ret = pkgmgrinfo_pkginfo_get_pkginfo(pkgid, &handle);
1858
1859         /*check package id      */
1860         tryvm_if(ret < 0, ret = PKGMGR_R_EINVAL, "pkgmgrinfo_pkginfo_get_pkginfo fail");
1861         tryvm_if(handle == NULL, ret = PKGMGR_R_EINVAL, "Pkgid(%s) can not find in installed pkg DB! \n", pkgid);
1862
1863   if (uid != GLOBAL_USER) {
1864           /*check running app , terminate app if it is running*/
1865           ret = pkgmgrinfo_appinfo_get_usr_list(handle, PMINFO_UI_APP, __app_list_cb, NULL, uid);
1866           tryvm_if(ret < 0, ret = PKGMGR_R_EINVAL, "pkgmgrinfo_appinfo_get_list : PMINFO_UI_APP fail");
1867
1868     /*check running app , terminate app if it is running*/
1869           ret = pkgmgrinfo_appinfo_get_usr_list(handle, PMINFO_SVC_APP, __app_list_cb, NULL, uid);
1870           tryvm_if(ret < 0, ret = PKGMGR_R_EINVAL, "pkgmgrinfo_appinfo_get_list : PMINFO_SVC_APP fail");
1871
1872   } else {
1873     /*check running app , terminate app if it is running*/
1874           ret = pkgmgrinfo_appinfo_get_list(handle, PMINFO_UI_APP, __app_list_cb, NULL);
1875           tryvm_if(ret < 0, ret = PKGMGR_R_EINVAL, "pkgmgrinfo_appinfo_get_list : PMINFO_UI_APP fail");
1876     /*check running app , terminate app if it is running*/
1877           ret = pkgmgrinfo_appinfo_get_list(handle, PMINFO_SVC_APP, __app_list_cb, NULL);
1878           tryvm_if(ret < 0, ret = PKGMGR_R_EINVAL, "pkgmgrinfo_appinfo_get_list : PMINFO_SVC_APP fail");
1879   }
1880         /*check type    */
1881         ret = pkgmgrinfo_pkginfo_get_type(handle, &pkgtype);
1882         tryvm_if(ret < 0, ret = PKGMGR_R_EINVAL, "pkgmgrinfo_pkginfo_get_type fail");
1883         tryvm_if(pkgtype == NULL, ret = PKGMGR_R_ERROR, "pkgtype is NULL");
1884
1885         /*check pkgid length    */
1886         tryvm_if(strlen(pkgid) >= PKG_STRING_LEN_MAX, ret = PKGMGR_R_EINVAL, "pkgid is too long");
1887
1888         /*check move_type       */
1889         tryvm_if((move_type < PM_MOVE_TO_INTERNAL) || (move_type > PM_MOVE_TO_SDCARD), ret = PKGMGR_R_EINVAL, "move_type is not supported");
1890
1891         /* 2. get installer path using pkgtype */
1892         installer_path = _get_backend_path_with_type(pkgtype);
1893         tryvm_if(installer_path == NULL, ret = PKGMGR_R_EINVAL, "installer_path fail");
1894
1895         /* 3. generate req_key */
1896         req_key = __get_req_key(pkgid);
1897
1898         /* 4. add callback info - add callback info to pkgmgr_client */
1899         req_id = _get_request_id();
1900         __add_op_cbinfo(mpc, req_id, req_key, event_cb, NULL, data);
1901
1902         /* 5. generate argv */
1903         snprintf(buf, 128, "%d", move_type);
1904         /* argv[0] installer path */
1905         argv[argcnt++] = installer_path;
1906         /* argv[1] */
1907         argv[argcnt++] = strdup("-k");
1908         /* argv[2] */
1909         argv[argcnt++] = req_key;
1910         /* argv[3] */
1911         argv[argcnt++] = strdup("-m");
1912         /* argv[4] */
1913         argv[argcnt++] = strdup(pkgid);
1914         /* argv[5] */
1915         argv[argcnt++] = strdup("-t");
1916         /* argv[6] */
1917         argv[argcnt++] = strdup(buf);
1918
1919         /*** add quote in all string for special charactor like '\n'***   FIX */
1920         for (i = 0; i < argcnt; i++) {
1921                 temp = g_shell_quote(argv[i]);
1922                 len += (strlen(temp) + 1);
1923                 g_free(temp);
1924         }
1925
1926         args = (char *)calloc(len, sizeof(char));
1927         tryvm_if(args == NULL, ret = PKGMGR_R_ERROR, "calloc failed");
1928
1929         strncpy(args, argv[0], len - 1);
1930
1931         for (i = 1; i < argcnt; i++) {
1932                 strncat(args, " ", strlen(" "));
1933                 temp = g_shell_quote(argv[i]);
1934                 strncat(args, temp, strlen(temp));
1935                 g_free(temp);
1936         }
1937         DBG("[args] %s [len] %d\n", args, len);
1938
1939         /******************* end of quote ************************/
1940
1941         /* 6. request install */
1942         ret = comm_client_request(mpc->info.request.cc, req_key, COMM_REQ_TO_MOVER, pkgtype, pkgid, args, uid, 1);
1943         tryvm_if(ret < 0, ret = PKGMGR_R_ECOMM, "calloc failed");
1944
1945         ret = req_id;
1946
1947 catch:
1948         for (i = 0; i < argcnt; i++)
1949                 free(argv[i]);
1950
1951         if(args)
1952                 free(args);
1953
1954         pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
1955         return ret;
1956 }
1957
1958 API int pkgmgr_client_activate(pkgmgr_client * pc, const char *pkg_type,
1959                                const char *pkgid)
1960 {
1961         return pkgmgr_client_usr_activate(pc, pkg_type, pkgid, GLOBAL_USER);
1962 }
1963
1964 API int pkgmgr_client_usr_activate(pkgmgr_client * pc, const char *pkg_type,
1965                                const char *pkgid, uid_t uid)
1966 {
1967         const char *pkgtype;
1968         char *req_key;
1969         int ret;
1970         /* Check for NULL value of pc */
1971         retvm_if(pc == NULL, PKGMGR_R_EINVAL, "package manager client handle is NULL\n");
1972
1973         pkgmgr_client_t *mpc = (pkgmgr_client_t *) pc;
1974
1975         /* 0. check the pc type */
1976         retvm_if(mpc->ctype != PC_REQUEST, PKGMGR_R_EINVAL, "mpc->ctype is not PC_REQUEST");
1977
1978         /* 1. check argument */
1979         retvm_if(pkgid == NULL, PKGMGR_R_EINVAL, "pkgid is NULL");
1980         retvm_if(strlen(pkgid) >= PKG_STRING_LEN_MAX, PKGMGR_R_EINVAL, "pkgid length over PKG_STRING_LEN_MAX ");
1981
1982         if (pkg_type == NULL) {
1983                 pkgtype = _get_pkg_type_from_desktop_file(pkgid, uid);
1984                 retvm_if(pkgtype == NULL, PKGMGR_R_EINVAL, "pkgtype is NULL");
1985         } else
1986                 pkgtype = pkg_type;
1987
1988         /* 2. generate req_key */
1989         req_key = __get_req_key(pkgid);
1990         retvm_if(req_key == NULL, PKGMGR_R_EINVAL, "req_key is NULL");
1991
1992         /* 3. request activate */
1993         ret = comm_client_request(mpc->info.request.cc, req_key, COMM_REQ_TO_ACTIVATOR, pkgtype, pkgid, "1 PKG", uid, 1);
1994         tryvm_if(ret < 0, ret = PKGMGR_R_ECOMM, "request failed, ret=%d", ret);
1995
1996         ret = PKGMGR_R_OK;
1997
1998 catch:
1999         free(req_key);
2000         return ret;
2001 }
2002
2003 API int pkgmgr_client_deactivate(pkgmgr_client *pc, const char *pkg_type,
2004                                  const char *pkgid)
2005 {
2006         return pkgmgr_client_usr_deactivate(pc, pkg_type, pkgid, GLOBAL_USER);
2007 }
2008
2009 API int pkgmgr_client_usr_deactivate(pkgmgr_client *pc, const char *pkg_type,
2010                                  const char *pkgid, uid_t uid)
2011 {
2012         const char *pkgtype;
2013         char *req_key;
2014         int ret;
2015         /* Check for NULL value of pc */
2016         retvm_if(pc == NULL, PKGMGR_R_EINVAL, "package manager client handle is NULL\n");
2017
2018         pkgmgr_client_t *mpc = (pkgmgr_client_t *) pc;
2019
2020         /* 0. check the pc type */
2021         retvm_if(mpc->ctype != PC_REQUEST, PKGMGR_R_EINVAL, "mpc->ctype is not PC_REQUEST");
2022
2023         /* 1. check argument */
2024         retvm_if(pkgid == NULL, PKGMGR_R_EINVAL, "pkgid is NULL");
2025         retvm_if(strlen(pkgid) >= PKG_STRING_LEN_MAX, PKGMGR_R_EINVAL, "pkgid length over PKG_STRING_LEN_MAX ");
2026
2027         if (pkg_type == NULL) {
2028                 pkgtype = _get_pkg_type_from_desktop_file(pkgid, uid);
2029                 if (pkgtype == NULL)
2030                         return PKGMGR_R_EINVAL;
2031         } else
2032                 pkgtype = pkg_type;
2033
2034         /* 2. generate req_key */
2035         req_key = __get_req_key(pkgid);
2036         retvm_if(req_key == NULL, PKGMGR_R_EINVAL, "req_key is NULL");
2037
2038         /* 3. request activate */
2039         ret = comm_client_request(mpc->info.request.cc, req_key, COMM_REQ_TO_ACTIVATOR, pkgtype, pkgid, "0 PKG", uid, 1);
2040         tryvm_if(ret < 0, ret = PKGMGR_R_ECOMM, "request failed, ret=%d", ret);
2041
2042         ret = PKGMGR_R_OK;
2043
2044 catch:
2045         free(req_key);
2046         return ret;
2047 }
2048
2049 API int pkgmgr_client_activate_app(pkgmgr_client * pc, const char *appid)
2050 {
2051         return pkgmgr_client_usr_activate_app(pc,appid, GLOBAL_USER);
2052 }
2053
2054 API int pkgmgr_client_usr_activate_app(pkgmgr_client * pc, const char *appid, uid_t uid)
2055 {
2056         const char *pkgtype;
2057         char *req_key;
2058         int ret;
2059         /* Check for NULL value of pc */
2060         retvm_if(pc == NULL, PKGMGR_R_EINVAL, "package manager client handle is NULL\n");
2061
2062         pkgmgr_client_t *mpc = (pkgmgr_client_t *) pc;
2063
2064         /* 0. check the pc type */
2065         retvm_if(mpc->ctype != PC_REQUEST, PKGMGR_R_EINVAL, "mpc->ctype is not PC_REQUEST");
2066
2067         /* 1. check argument */
2068         retvm_if(appid == NULL, PKGMGR_R_EINVAL, "pkgid is NULL");
2069         retvm_if(strlen(appid) >= PKG_STRING_LEN_MAX, PKGMGR_R_EINVAL, "pkgid length over PKG_STRING_LEN_MAX ");
2070
2071         pkgtype = _get_pkg_type_from_desktop_file(appid, uid);
2072         retvm_if(pkgtype == NULL, PKGMGR_R_EINVAL, "pkgtype is NULL");
2073
2074         /* 2. generate req_key */
2075         req_key = __get_req_key(appid);
2076         retvm_if(req_key == NULL, PKGMGR_R_EINVAL, "req_key is NULL");
2077
2078         /* 3. request activate */
2079         ret = comm_client_request(mpc->info.request.cc, req_key, COMM_REQ_TO_ACTIVATOR, pkgtype, appid, "1 APP", uid, 1);
2080         tryvm_if(ret < 0, ret = PKGMGR_R_ECOMM, "request failed, ret=%d", ret);
2081
2082         ret = PKGMGR_R_OK;
2083
2084 catch:
2085         free(req_key);
2086         return ret;
2087 }
2088
2089 API int pkgmgr_client_activate_appv(pkgmgr_client * pc, const char *appid, char *const argv[])
2090 {
2091         return pkgmgr_client_usr_activate_appv(pc, appid,  argv, GLOBAL_USER);
2092 }
2093
2094 API int pkgmgr_client_usr_activate_appv(pkgmgr_client * pc, const char *appid, char *const argv[], uid_t uid)
2095 {
2096         const char *pkgtype;
2097         char *req_key;
2098         int ret;
2099         int i = 0;
2100         char *temp = NULL;
2101         int len = 0;
2102         int argcnt = 0;
2103         char *args = NULL;
2104         char *argsr = NULL;
2105         /* Check for NULL value of pc */
2106         retvm_if(pc == NULL, PKGMGR_R_EINVAL, "package manager client handle is NULL\n");
2107
2108         pkgmgr_client_t *mpc = (pkgmgr_client_t *) pc;
2109
2110         /* 0. check the pc type */
2111         retvm_if(mpc->ctype != PC_REQUEST, PKGMGR_R_EINVAL, "mpc->ctype is not PC_REQUEST");
2112
2113         /* 1. check argument */
2114         retvm_if(appid == NULL, PKGMGR_R_EINVAL, "pkgid is NULL");
2115         retvm_if(strlen(appid) >= PKG_STRING_LEN_MAX, PKGMGR_R_EINVAL, "pkgid length over PKG_STRING_LEN_MAX ");
2116
2117         pkgtype = _get_pkg_type_from_desktop_file(appid, uid);
2118         retvm_if(pkgtype == NULL, PKGMGR_R_EINVAL, "pkgtype is NULL");
2119
2120         /* 2. generate req_key */
2121         req_key = __get_req_key(appid);
2122         retvm_if(req_key == NULL, PKGMGR_R_EINVAL, "req_key is NULL");
2123
2124         /*** add quote in all string for special charactor like '\n'***   FIX */
2125         if (argv) {
2126                 for (i = 0; argv[i]; i++) {
2127                         temp = g_shell_quote(argv[i]);
2128                         len += (strlen(temp) + 1);
2129                         g_free(temp);
2130                         argcnt++;
2131                 }
2132
2133                 if (argcnt) {
2134                         args = (char *)calloc(len, sizeof(char));
2135                         tryvm_if(args == NULL, ret = PKGMGR_R_ERROR, "calloc failed");
2136                         strncpy(args, argv[0], len - 1);
2137
2138                         for (i = 1; i < argcnt; i++) {
2139                                 strncat(args, " ", strlen(" "));
2140                                 temp = g_shell_quote(argv[i]);
2141                                 strncat(args, temp, strlen(temp));
2142                                 g_free(temp);
2143                         }
2144                 }
2145         }
2146
2147         argsr = (char *)calloc(strlen("1 APP")+2+len, sizeof(char));
2148         tryvm_if(argsr == NULL, ret = PKGMGR_R_ERROR, "calloc failed");
2149
2150         strncpy(argsr, "1 APP", strlen("1 APP"));
2151         if (argcnt) {
2152                 strncat(argsr, " ", strlen(" "));
2153                 strncat(argsr, args, strlen(args));
2154         }
2155
2156         DBG("argsr [%s]\n", argsr);
2157         /******************* end of quote ************************/
2158
2159         /* 3. request activate */
2160         ret = comm_client_request(mpc->info.request.cc, req_key, COMM_REQ_TO_ACTIVATOR, pkgtype, appid, argsr, uid, 1);
2161         tryvm_if(ret < 0, ret = PKGMGR_R_ECOMM, "request failed, ret=%d", ret);
2162
2163         ret = PKGMGR_R_OK;
2164
2165 catch:
2166
2167         free(req_key);
2168         free(args);
2169         free(argsr);
2170
2171         return ret;
2172 }
2173
2174
2175 API int pkgmgr_client_deactivate_app(pkgmgr_client *pc, const char *appid)
2176 {
2177         return pkgmgr_client_usr_deactivate_app(pc, appid, GLOBAL_USER);
2178 }
2179
2180 API int pkgmgr_client_usr_deactivate_app(pkgmgr_client *pc, const char *appid, uid_t uid)
2181 {
2182         const char *pkgtype;
2183         char *req_key;
2184         int ret;
2185         /* Check for NULL value of pc */
2186         retvm_if(pc == NULL, PKGMGR_R_EINVAL, "package manager client handle is NULL\n");
2187
2188         pkgmgr_client_t *mpc = (pkgmgr_client_t *) pc;
2189
2190         /* 0. check the pc type */
2191         retvm_if(mpc->ctype != PC_REQUEST, PKGMGR_R_EINVAL, "mpc->ctype is not PC_REQUEST");
2192
2193         /* 1. check argument */
2194         retvm_if(appid == NULL, PKGMGR_R_EINVAL, "pkgid is NULL");
2195         retvm_if(strlen(appid) >= PKG_STRING_LEN_MAX, PKGMGR_R_EINVAL, "pkgid length over PKG_STRING_LEN_MAX ");
2196
2197         pkgtype = _get_pkg_type_from_desktop_file(appid, uid);
2198         retvm_if(pkgtype == NULL, PKGMGR_R_EINVAL, "pkgtype is NULL");
2199
2200         /* 2. generate req_key */
2201         req_key = __get_req_key(appid);
2202         retvm_if(req_key == NULL, PKGMGR_R_EINVAL, "req_key is NULL");
2203
2204         /* 3. request activate */
2205         ret = comm_client_request(mpc->info.request.cc, req_key, COMM_REQ_TO_ACTIVATOR, pkgtype, appid, "0 APP", uid, 1);
2206         tryvm_if(ret < 0, ret = PKGMGR_R_ECOMM, "request failed, ret=%d", ret);
2207
2208         ret = PKGMGR_R_OK;
2209
2210 catch:
2211         free(req_key);
2212         return ret;
2213 }
2214
2215 API int pkgmgr_client_clear_user_data(pkgmgr_client *pc, const char *pkg_type,
2216                                       const char *appid, pkgmgr_mode mode)
2217 {
2218         return pkgmgr_client_usr_clear_user_data(pc, pkg_type, appid,mode, GLOBAL_USER);
2219 }
2220 API int pkgmgr_client_usr_clear_user_data(pkgmgr_client *pc, const char *pkg_type,
2221                                       const char *appid, pkgmgr_mode mode, uid_t uid)
2222 {
2223         const char *pkgtype;
2224         char *installer_path;
2225         char *req_key;
2226         int i = 0;
2227         char *argv[PKG_ARGC_MAX] = { NULL, };
2228         char *args = NULL;
2229         int argcnt = 0;
2230         int len = 0;
2231         char *temp = NULL;
2232         int ret;
2233
2234         /* Check for NULL value of pc */
2235         if (pc == NULL) {
2236                 DBG("package manager client handle is NULL\n");
2237                 return PKGMGR_R_EINVAL;
2238         }
2239         pkgmgr_client_t *mpc = (pkgmgr_client_t *) pc;
2240
2241         /* 0. check the pc type */
2242         if (mpc->ctype != PC_REQUEST)
2243                 return PKGMGR_R_EINVAL;
2244
2245         /* 1. check argument */
2246         if (appid == NULL)
2247                 return PKGMGR_R_EINVAL;
2248
2249
2250         if (pkg_type == NULL) {
2251                 pkgtype = _get_pkg_type_from_desktop_file(appid, uid);
2252                 if (pkgtype == NULL)
2253                         return PKGMGR_R_EINVAL;
2254         } else
2255                 pkgtype = pkg_type;
2256
2257         if (strlen(appid) >= PKG_STRING_LEN_MAX)
2258                 return PKGMGR_R_EINVAL;
2259
2260         /* 2. get installer path using pkg_path */
2261         installer_path = _get_backend_path_with_type(pkgtype);
2262         if (installer_path == NULL)
2263                 return PKGMGR_R_EINVAL;
2264
2265         /* 3. generate req_key */
2266         req_key = __get_req_key(appid);
2267
2268         /* 4. generate argv */
2269
2270         /* argv[0] installer path */
2271         argv[argcnt++] = installer_path;
2272         /* argv[1] */
2273         argv[argcnt++] = strdup("-k");
2274         /* argv[2] */
2275         argv[argcnt++] = req_key;
2276         /* argv[3] */
2277         argv[argcnt++] = strdup("-c");
2278         /* argv[4] */
2279         argv[argcnt++] = strdup(appid);
2280
2281         /*** add quote in all string for special charactor like '\n'***   FIX */
2282         for (i = 0; i < argcnt; i++) {
2283                 temp = g_shell_quote(argv[i]);
2284                 len += (strlen(temp) + 1);
2285                 g_free(temp);
2286         }
2287
2288         args = (char *)calloc(len, sizeof(char));
2289         if (args == NULL) {
2290                 DBG("calloc failed");
2291
2292                 for (i = 0; i < argcnt; i++)
2293                         free(argv[i]);
2294
2295                 return PKGMGR_R_ERROR;
2296         }
2297         strncpy(args, argv[0], len - 1);
2298
2299         for (i = 1; i < argcnt; i++) {
2300                 strncat(args, " ", strlen(" "));
2301                 temp = g_shell_quote(argv[i]);
2302                 strncat(args, temp, strlen(temp));
2303                 g_free(temp);
2304         }
2305         DBG("[args] %s [len] %d\n", args, len);
2306         /******************* end of quote ************************/
2307
2308         /* 6. request clear */
2309         ret = comm_client_request(mpc->info.request.cc, req_key,
2310                                   COMM_REQ_TO_CLEARER, pkgtype, appid,
2311                                   args, uid, 1);
2312         if (ret < 0) {
2313                 ERR("request failed, ret=%d\n", ret);
2314
2315                 for (i = 0; i < argcnt; i++)
2316                         free(argv[i]);
2317
2318                 free(args);
2319                 return PKGMGR_R_ECOMM;
2320         }
2321
2322         for (i = 0; i < argcnt; i++)
2323                 free(argv[i]);
2324
2325         free(args);
2326
2327         return PKGMGR_R_OK;
2328 }
2329
2330
2331 API int pkgmgr_client_set_status_type(pkgmgr_client *pc, int status_type)
2332 {
2333         int ret = -1;
2334
2335         retvm_if(pc == NULL, PKGMGR_R_EINVAL, "package manager client pc is NULL");
2336         retvm_if(status_type == PKGMGR_CLIENT_STATUS_ALL, PKGMGR_R_OK, "status_type is PKGMGR_CLIENT_STATUS_ALL");
2337         pkgmgr_client_t *mpc = (pkgmgr_client_t *) pc;
2338
2339         /*  free listening head */
2340         listen_cb_info *tmp = NULL;
2341         listen_cb_info *prev = NULL;
2342         for (tmp = mpc->info.listening.lhead; tmp;) {
2343                 prev = tmp;
2344                 tmp = tmp->next;
2345                 free(prev);
2346         }
2347
2348         /* free dbus connection */
2349         ret = comm_client_free(mpc->info.listening.cc);
2350         retvm_if(ret < 0, PKGMGR_R_ERROR, "comm_client_free() failed - %d", ret);
2351
2352         /* Manage pc for seperated event */
2353         mpc->ctype = PC_LISTENING;
2354         mpc->status_type = status_type;
2355
2356         mpc->info.listening.cc = comm_client_new();
2357         retvm_if(mpc->info.listening.cc == NULL, PKGMGR_R_EINVAL, "client creation failed");
2358
2359         if ((mpc->status_type & PKGMGR_CLIENT_STATUS_INSTALL) == PKGMGR_CLIENT_STATUS_INSTALL) {
2360                 ret = comm_client_set_status_callback(COMM_STATUS_BROADCAST_INSTALL, mpc->info.listening.cc, __status_callback, pc);
2361                 retvm_if(ret < 0, PKGMGR_R_ECOMM, "PKGMGR_CLIENT_STATUS_INSTALL failed - %d", ret);
2362         }
2363
2364         if ((mpc->status_type & PKGMGR_CLIENT_STATUS_UNINSTALL) == PKGMGR_CLIENT_STATUS_UNINSTALL) {
2365                 ret = comm_client_set_status_callback(COMM_STATUS_BROADCAST_UNINSTALL, mpc->info.listening.cc, __status_callback, pc);
2366                 retvm_if(ret < 0, PKGMGR_R_ECOMM, "COMM_STATUS_BROADCAST_UNINSTALL failed - %d", ret);
2367         }
2368
2369         if ((mpc->status_type & PKGMGR_CLIENT_STATUS_MOVE) == PKGMGR_CLIENT_STATUS_MOVE) {
2370                 ret = comm_client_set_status_callback(COMM_STATUS_BROADCAST_MOVE, mpc->info.listening.cc, __status_callback, pc);
2371                 retvm_if(ret < 0, PKGMGR_R_ECOMM, "COMM_STATUS_BROADCAST_MOVE failed - %d", ret);
2372         }
2373
2374         if ((mpc->status_type & PKGMGR_CLIENT_STATUS_INSTALL_PROGRESS) == PKGMGR_CLIENT_STATUS_INSTALL_PROGRESS) {
2375                 ret = comm_client_set_status_callback(COMM_STATUS_BROADCAST_INSTALL_PROGRESS, mpc->info.listening.cc, __status_callback, pc);
2376                 retvm_if(ret < 0, PKGMGR_R_ECOMM, "COMM_STATUS_BROADCAST_INSTALL_PROGRESS failed - %d", ret);
2377         }
2378
2379    if ((mpc->status_type & PKGMGR_CLIENT_STATUS_UPGRADE) == PKGMGR_CLIENT_STATUS_UPGRADE) {
2380            ret = comm_client_set_status_callback(COMM_STATUS_BROADCAST_UPGRADE, mpc->info.listening.cc, __status_callback, pc);
2381            retvm_if(ret < 0, PKGMGR_R_ECOMM, "COMM_STATUS_BROADCAST_UPGRADE failed - %d", ret);
2382    }
2383
2384    return PKGMGR_R_OK;
2385 }
2386
2387 API int pkgmgr_client_listen_status(pkgmgr_client *pc, pkgmgr_handler event_cb,
2388                                     void *data)
2389 {
2390         int req_id;
2391         /* Check for NULL value of pc */
2392         retvm_if(pc == NULL, PKGMGR_R_EINVAL, "package manager client pc is NULL");
2393         pkgmgr_client_t *mpc = (pkgmgr_client_t *) pc;
2394
2395         /* 0. check input */
2396         retvm_if(mpc->ctype != PC_LISTENING, PKGMGR_R_EINVAL, "ctype is not PC_LISTENING");
2397         retvm_if(event_cb == NULL, PKGMGR_R_EINVAL, "event_cb is NULL");
2398
2399         /* 1. get id */
2400         req_id = _get_request_id();
2401
2402         /* 2. add callback info to pkgmgr_client */
2403         __add_stat_cbinfo(mpc, req_id, event_cb, data);
2404         return req_id;
2405 }
2406
2407 API int pkgmgr_client_broadcast_status(pkgmgr_client *pc, const char *pkg_type,
2408                                        const char *pkgid, const char *key,
2409                                        const char *val)
2410 {
2411         /* Check for NULL value of pc */
2412         if (pc == NULL) {
2413                 DBG("package manager client handle is NULL\n");
2414                 return PKGMGR_R_EINVAL;
2415         }
2416         /* Check for valid arguments. NULL parameter causes DBUS to abort */
2417         if (pkgid == NULL || pkg_type == NULL || key == NULL || val == NULL) {
2418                 DBG("Argument supplied is NULL\n");
2419                 return PKGMGR_R_EINVAL;
2420         }
2421         pkgmgr_client_t *mpc = (pkgmgr_client_t *) pc;
2422
2423         /* 0. check the pc type */
2424         if (mpc->ctype != PC_BROADCAST)
2425                 return PKGMGR_R_EINVAL;
2426
2427         comm_status_broadcast_server_send_signal(COMM_STATUS_BROADCAST_ALL, mpc->info.broadcast.bc,
2428                                                  getuid(), PKG_STATUS,
2429                                                  pkg_type, pkgid, key, val);
2430
2431         return PKGMGR_R_OK;
2432 }
2433
2434 API pkgmgr_info *pkgmgr_client_check_pkginfo_from_file(const char *pkg_path)
2435 {
2436         return pkgmgr_info_new_from_file(NULL, pkg_path);
2437 }
2438
2439 API int pkgmgr_client_free_pkginfo(pkgmgr_info * pkg_info)
2440 {
2441         if (pkg_info == NULL)
2442                 return PKGMGR_R_EINVAL;
2443
2444         package_manager_pkg_detail_info_t *info = (package_manager_pkg_detail_info_t *)pkg_info;
2445
2446         if (info->icon_buf)
2447                 free(info->icon_buf);
2448
2449         free(info);
2450         info = NULL;
2451
2452         return PKGMGR_R_OK;
2453 }
2454
2455 API int pkgmgr_client_request_service(pkgmgr_request_service_type service_type, int service_mode,
2456                                   pkgmgr_client * pc, const char *pkg_type, const char *pkgid,
2457                               const char *custom_info, pkgmgr_handler event_cb, void *data)
2458 {
2459         return pkgmgr_client_usr_request_service(service_type, service_mode, pc, pkg_type, pkgid, GLOBAL_USER, custom_info, event_cb, data);
2460 }
2461
2462 API int pkgmgr_client_usr_request_service(pkgmgr_request_service_type service_type, int service_mode,
2463                                   pkgmgr_client * pc, const char *pkg_type, const char *pkgid, uid_t uid,
2464                               const char *custom_info, pkgmgr_handler event_cb, void *data)
2465 {
2466         int ret =0;
2467
2468         /* Check for NULL value of service type */
2469         retvm_if(service_type > PM_REQUEST_MAX, PKGMGR_R_EINVAL, "service type is not defined\n");
2470         retvm_if(service_type < 0, PKGMGR_R_EINVAL, "service type is error\n");
2471
2472         switch (service_type) {
2473         case PM_REQUEST_CSC:
2474                 tryvm_if(custom_info == NULL, ret = PKGMGR_R_EINVAL, "custom_info is NULL\n");
2475                 tryvm_if(strlen(custom_info) >= PKG_STRING_LEN_MAX, ret = PKGMGR_R_EINVAL, "optional_file over PKG_STRING_LEN_MAX");
2476                 tryvm_if(data == NULL, ret = PKGMGR_R_EINVAL, "data is NULL\n");
2477
2478                 ret = __csc_process(custom_info, (char *)data);
2479                 if (ret < 0)
2480                         ERR("__csc_process fail \n");
2481                 else
2482                         ret = PKGMGR_R_OK;
2483
2484                 break;
2485
2486         case PM_REQUEST_MOVE:
2487                 tryvm_if(pkgid == NULL, ret = PKGMGR_R_EINVAL, "pkgid is NULL\n");
2488                 tryvm_if(pc == NULL, ret = PKGMGR_R_EINVAL, "pc is NULL\n");
2489                 tryvm_if((service_mode < PM_MOVE_TO_INTERNAL) || (service_mode > PM_MOVE_TO_SDCARD), ret = PKGMGR_R_EINVAL, "service_mode is wrong\n");
2490
2491                 ret = __move_pkg_process(pc, pkgid, uid, (pkgmgr_move_type)service_mode, event_cb, data);
2492                 break;
2493
2494         case PM_REQUEST_GET_SIZE:
2495                 tryvm_if(pkgid == NULL, ret = PKGMGR_R_EINVAL, "pkgid is NULL\n");
2496                 tryvm_if(pc == NULL, ret = PKGMGR_R_EINVAL, "pc is NULL\n");
2497                 tryvm_if((service_mode < PM_GET_TOTAL_SIZE) || (service_mode >= PM_GET_MAX), ret = PKGMGR_R_EINVAL, "service_mode is wrong\n");
2498
2499                 ret = __get_size_process(pc, pkgid, uid, (pkgmgr_getsize_type)service_mode, event_cb, data);
2500                 break;
2501
2502         case PM_REQUEST_KILL_APP:
2503         case PM_REQUEST_CHECK_APP:
2504                 tryvm_if(pkgid == NULL, ret = PKGMGR_R_EINVAL, "pkgid is NULL\n");
2505                 tryvm_if(pc == NULL, ret = PKGMGR_R_EINVAL, "pc is NULL\n");
2506
2507                 ret = __check_app_process(service_type, pc, pkgid, uid, data);
2508                 if (ret < 0)
2509                         ERR("__check_app_process fail \n");
2510                 else
2511                         ret = PKGMGR_R_OK;
2512
2513                 break;
2514
2515         default:
2516                 ERR("Wrong Request\n");
2517                 ret = -1;
2518                 break;
2519         }
2520
2521 catch:
2522
2523         return ret;
2524 }
2525
2526
2527 API int pkgmgr_client_usr_request_size_info(uid_t uid)
2528 {
2529         int ret = 0;
2530         pkgmgr_client *pc = NULL;
2531
2532         pc = pkgmgr_client_new(PC_REQUEST);
2533         retvm_if(pc == NULL, PKGMGR_R_EINVAL, "request pc is null\n");
2534
2535         ret = __request_size_info(pc, uid);
2536         if (ret < 0) {
2537                 ERR("__request_size_info fail \n");
2538         }
2539
2540         pkgmgr_client_free(pc);
2541         return ret;
2542 }
2543
2544 API int pkgmgr_client_request_size_info(void) // get all package size (data, total)
2545 {
2546         return pkgmgr_client_usr_request_size_info(GLOBAL_USER);
2547 }
2548
2549 API int pkgmgr_client_usr_clear_cache_dir(const char *pkgid, uid_t uid)
2550 {
2551         retvm_if(pkgid == NULL, PKGMGR_R_EINVAL, "package id is null\n");
2552
2553         int ret = 0;
2554         pkgmgr_client_t *pc = NULL;
2555         char *pkg_type = NULL;
2556         int is_type_malloced = 0;
2557
2558         pkgmgrinfo_pkginfo_h handle = NULL;
2559
2560         pc = pkgmgr_client_new(PC_REQUEST);
2561         retvm_if(pc == NULL, PKGMGR_R_ESYSTEM, "request pc is null\n");
2562
2563         if (strcmp(pkgid, PKG_CLEAR_ALL_CACHE) != 0)
2564         {
2565                 ret = pkgmgrinfo_pkginfo_get_usr_pkginfo(pkgid, uid, &handle);
2566                 tryvm_if(ret < 0, ret = PKGMGR_R_ENOPKG, "pkgmgrinfo_pkginfo_get_pkginfo failed");
2567
2568                 ret = pkgmgrinfo_pkginfo_get_type(handle, &pkg_type);
2569                 tryvm_if(ret < 0, ret = PKGMGR_R_ESYSTEM, "pkgmgrinfo_pkginfo_get_type failed");
2570         }
2571         else
2572         {
2573                 pkg_type = (char *)malloc(strlen("rpm") + 1);
2574                 strcpy(pkg_type, "rpm");
2575                 is_type_malloced = 1;
2576         }
2577
2578         ret = comm_client_request(pc->info.request.cc, NULL, COMM_REQ_CLEAR_CACHE_DIR, pkg_type, pkgid, NULL, uid, 0);
2579         tryvm_if(ret < 0, ret = PKGMGR_R_ERROR, "COMM_REQ_CLEAR_CACHE_DIR failed, ret=%d\n", ret);
2580
2581         ret = PKGMGR_R_OK;
2582 catch:
2583         if (pc)
2584                 pkgmgr_client_free(pc);
2585
2586         if(is_type_malloced)
2587                 free(pkg_type);
2588
2589         pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
2590
2591         return ret;
2592 }
2593
2594 API int pkgmgr_client_clear_cache_dir(const char *pkgid)
2595 {
2596         return pkgmgr_client_usr_clear_cache_dir(pkgid, GLOBAL_USER);
2597 }
2598
2599 API int pkgmgr_client_clear_usr_all_cache_dir(uid_t uid)
2600 {
2601         return pkgmgr_client_usr_clear_cache_dir(PKG_CLEAR_ALL_CACHE, uid);
2602 }
2603
2604 API int pkgmgr_client_clear_all_cache_dir(void)
2605 {
2606         int ret = 0;
2607         ret = pkgmgr_client_usr_clear_cache_dir(PKG_CLEAR_ALL_CACHE, GLOBAL_USER);
2608         return ret;
2609 }
2610
2611 API int pkgmgr_client_get_size(pkgmgr_client * pc, const char *pkgid, pkgmgr_getsize_type get_type, pkgmgr_handler event_cb, void *data)
2612 {
2613         return pkgmgr_client_usr_get_size(pc, pkgid, get_type, event_cb, data, GLOBAL_USER);
2614 }
2615
2616 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)
2617 {
2618         char *req_key = NULL;
2619         int ret =0;
2620         char *pkgtype = "rpm";
2621         char *argv[PKG_ARGC_MAX] = { NULL, };
2622         char *args = NULL;
2623         int argcnt = 0;
2624         int len = 0;
2625         char *temp = NULL;
2626         int i = 0;
2627         char buf[128] = {'\0'};
2628         int req_id = 0;
2629
2630         pkgmgr_client_t *mpc = (pkgmgr_client_t *) pc;
2631         retvm_if(mpc->ctype != PC_REQUEST, PKGMGR_R_EINVAL, "mpc->ctype is not PC_REQUEST\n");
2632         retvm_if(event_cb == NULL, PKGMGR_R_EINVAL, "event_cb is NULL\n");
2633         retvm_if(pkgid == NULL, PKGMGR_R_EINVAL, "pkgid is NULL\n");
2634
2635         req_key = __get_req_key(pkgid);
2636         retvm_if(req_key == NULL, PKGMGR_R_EINVAL, "req_key is NULL");
2637
2638         req_id = _get_request_id();
2639         __add_op_cbinfo(mpc, req_id, req_key, event_cb, NULL, data);
2640
2641         snprintf(buf, 128, "%d", get_type);
2642         argv[argcnt++] = strdup(pkgid);
2643         argv[argcnt++] = strdup(buf);
2644         argv[argcnt++] = strdup("-k");
2645         argv[argcnt++] = req_key;
2646
2647         /*** add quote in all string for special charactor like '\n'***   FIX */
2648         for (i = 0; i < argcnt; i++) {
2649                 temp = g_shell_quote(argv[i]);
2650                 len += (strlen(temp) + 1);
2651                 g_free(temp);
2652         }
2653
2654         args = (char *)calloc(len, sizeof(char));
2655         tryvm_if(args == NULL, ret = PKGMGR_R_EINVAL, "installer_path fail");
2656
2657         strncpy(args, argv[0], len - 1);
2658
2659         for (i = 1; i < argcnt; i++) {
2660                 strncat(args, " ", strlen(" "));
2661                 temp = g_shell_quote(argv[i]);
2662                 strncat(args, temp, strlen(temp));
2663                 g_free(temp);
2664         }
2665         DBG("[args] %s [len] %d\n", args, len);
2666
2667         /* request */
2668         ret = comm_client_request(mpc->info.request.cc, req_key, COMM_REQ_GET_SIZE, pkgtype, pkgid, args, uid, 1);
2669         if (ret < 0)
2670                 ERR("comm_client_request failed, ret=%d\n", ret);
2671
2672 catch:
2673         for (i = 0; i < argcnt; i++)
2674                 free(argv[i]);
2675
2676         if(args)
2677                 free(args);
2678
2679         return ret;
2680 }
2681
2682 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)
2683 {
2684         pkgmgrinfo_pkginfo_h pkginfo = NULL;
2685         char *req_key = NULL;
2686         int req_id = 0;
2687         int res = 0;
2688         int type = PM_GET_PKG_SIZE_INFO;
2689
2690         retvm_if(pc == NULL, PKGMGR_R_EINVAL, "The specified pc is NULL.");
2691         retvm_if(pkgid == NULL, PKGMGR_R_EINVAL, "The package id is NULL.");
2692
2693         if (strcmp(pkgid, PKG_SIZE_INFO_TOTAL) == 0)
2694         {       // total package size info
2695                 type = PM_GET_TOTAL_PKG_SIZE_INFO;
2696         }
2697         else
2698         {
2699                 res = pkgmgrinfo_pkginfo_get_usr_pkginfo(pkgid, uid, &pkginfo);
2700                 retvm_if(res != 0, PKGMGR_R_ENOPKG, "The package id is not installed.");
2701
2702                 if (pkginfo) {
2703                         pkgmgrinfo_pkginfo_destroy_pkginfo(pkginfo);
2704                 }
2705         }
2706
2707         pkgmgr_client_t *mpc = (pkgmgr_client_t *)pc;
2708         retvm_if(mpc->ctype != PC_REQUEST, PKGMGR_R_EINVAL, "mpc->ctype is not PC_REQUEST");
2709
2710         res = __change_op_cb_for_getsize(mpc);
2711         retvm_if(res < 0 , PKGMGR_R_ESYSTEM, "__change_op_cb_for_getsize is fail");
2712
2713         req_key = __get_req_key(pkgid);
2714         retvm_if(req_key == NULL, PKGMGR_R_ESYSTEM, "req_key is NULL");
2715
2716         req_id = _get_request_id();
2717         __add_op_cbinfo(mpc, req_id, req_key, __get_pkg_size_info_cb, event_cb, user_data);
2718
2719         res = __get_package_size_info(mpc, req_key, pkgid, type, uid);
2720
2721         return res;
2722 }
2723
2724 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)
2725 {
2726         return pkgmgr_client_usr_get_package_size_info(pc, pkgid, event_cb, user_data, GLOBAL_USER);
2727 }
2728
2729 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)
2730 {       // total package size info
2731         return pkgmgr_client_usr_get_package_size_info(pc, PKG_SIZE_INFO_TOTAL, (pkgmgr_pkg_size_info_receive_cb)event_cb, user_data, uid);
2732 }
2733
2734 API int pkgmgr_client_get_total_package_size_info(pkgmgr_client *pc, pkgmgr_total_pkg_size_info_receive_cb event_cb, void *user_data)
2735 {
2736         return pkgmgr_client_usr_get_package_size_info(pc, PKG_SIZE_INFO_TOTAL, event_cb, user_data, GLOBAL_USER);
2737 }
2738
2739 #define __START_OF_OLD_API
2740 ail_cb_ret_e __appinfo_func(const ail_appinfo_h appinfo, void *user_data)
2741 {
2742         char *type;
2743         char *package;
2744         char *version;
2745
2746         iter_data *udata = (iter_data *) user_data;
2747
2748         ail_appinfo_get_str(appinfo, AIL_PROP_X_SLP_PACKAGETYPE_STR, &type);
2749         if (type == NULL)
2750                 type = "";
2751         ail_appinfo_get_str(appinfo, AIL_PROP_PACKAGE_STR, &package);
2752         if (package == NULL)
2753                 package = "";
2754         ail_appinfo_get_str(appinfo, AIL_PROP_VERSION_STR, &version);
2755         if (version == NULL)
2756                 version = "";
2757
2758         if (udata->iter_fn(type, package, version, udata->data) != 0)
2759                 return AIL_CB_RET_CANCEL;
2760
2761         return AIL_CB_RET_CONTINUE;
2762 }
2763
2764 API int pkgmgr_get_pkg_list(pkgmgr_iter_fn iter_fn, void *data, uid_t uid)
2765 {
2766         int cnt = -1;
2767         ail_filter_h filter;
2768         ail_error_e ret;
2769
2770         if (iter_fn == NULL)
2771                 return PKGMGR_R_EINVAL;
2772
2773         ret = ail_filter_new(&filter);
2774         if (ret != AIL_ERROR_OK) {
2775                 return PKGMGR_R_ERROR;
2776         }
2777
2778         ret = ail_filter_add_str(filter, AIL_PROP_TYPE_STR, "Application");
2779         if (ret != AIL_ERROR_OK) {
2780                 ail_filter_destroy(filter);
2781                 return PKGMGR_R_ERROR;
2782         }
2783
2784         ret = ail_filter_add_bool(filter, AIL_PROP_X_SLP_REMOVABLE_BOOL, true);
2785         if (ret != AIL_ERROR_OK) {
2786                 ail_filter_destroy(filter);
2787                 return PKGMGR_R_ERROR;
2788         }
2789
2790         if(uid != GLOBAL_USER)
2791                 ret = ail_filter_count_usr_appinfo(filter, &cnt, uid);
2792         else
2793                 ret = ail_filter_count_appinfo(filter, &cnt);
2794         if (ret != AIL_ERROR_OK) {
2795                 ail_filter_destroy(filter);
2796                 return PKGMGR_R_ERROR;
2797         }
2798
2799         iter_data *udata = calloc(1, sizeof(iter_data));
2800         if (udata == NULL) {
2801                 ERR("calloc failed");
2802                 ail_filter_destroy(filter);
2803
2804                 return PKGMGR_R_ERROR;
2805         }
2806         udata->iter_fn = iter_fn;
2807         udata->data = data;
2808
2809         if(uid != GLOBAL_USER)
2810                 ail_filter_list_usr_appinfo_foreach(filter, __appinfo_func, udata, uid);
2811         else
2812                 ail_filter_list_appinfo_foreach(filter, __appinfo_func, udata);
2813         free(udata);
2814
2815         ret = ail_filter_destroy(filter);
2816         if (ret != AIL_ERROR_OK) {
2817                 return PKGMGR_R_ERROR;
2818         }
2819
2820         return PKGMGR_R_OK;
2821 }
2822
2823 API pkgmgr_info *pkgmgr_info_new(const char *pkg_type, const char *pkgid)
2824 {
2825         return pkgmgr_info_usr_new(pkg_type, pkgid, GLOBAL_USER);
2826 }
2827 API pkgmgr_info *pkgmgr_info_usr_new(const char *pkg_type, const char *pkgid, uid_t uid)
2828 {
2829         const char *pkgtype;
2830         pkg_plugin_set *plugin_set = NULL;
2831         package_manager_pkg_detail_info_t *pkg_detail_info = NULL;
2832
2833         /* 1. check argument */
2834         if (pkgid == NULL)
2835                 return NULL;
2836
2837         if (pkg_type == NULL) {
2838                 pkgtype = _get_pkg_type_from_desktop_file(pkgid, uid);
2839                 if (pkgtype == NULL)
2840                         return NULL;
2841         } else
2842                 pkgtype = pkg_type;
2843
2844         if (strlen(pkgid) >= PKG_STRING_LEN_MAX)
2845                 return NULL;
2846
2847         pkg_detail_info = calloc(1, sizeof(package_manager_pkg_detail_info_t));
2848         if (pkg_detail_info == NULL) {
2849                 ERR("*** Failed to alloc package_handler_info.\n");
2850                 return NULL;
2851         }
2852
2853         plugin_set = _package_manager_load_library(pkgtype);
2854         if (plugin_set == NULL) {
2855                 ERR("*** Failed to load library");
2856                 free(pkg_detail_info);
2857                 return NULL;
2858         }
2859
2860         if (plugin_set->pkg_is_installed) {
2861                 if (plugin_set->pkg_is_installed(pkgid) != 0) {
2862                         ERR("*** Failed to call pkg_is_installed()");
2863                         free(pkg_detail_info);
2864                         return NULL;
2865                 }
2866
2867                 if (plugin_set->get_pkg_detail_info) {
2868                         if (plugin_set->get_pkg_detail_info(pkgid,
2869                                                             pkg_detail_info) != 0) {
2870                                 ERR("*** Failed to call get_pkg_detail_info()");
2871                                 free(pkg_detail_info);
2872                                 return NULL;
2873                         }
2874                 }
2875         }
2876
2877         return (pkgmgr_info *) pkg_detail_info;
2878 }
2879
2880 API char * pkgmgr_info_get_string(pkgmgr_info * pkg_info, const char *key)
2881 {
2882         package_manager_pkg_detail_info_t *pkg_detail_info;
2883
2884         if (pkg_info == NULL)
2885                 return NULL;
2886         if (key == NULL)
2887                 return NULL;
2888
2889         pkg_detail_info = (package_manager_pkg_detail_info_t *) pkg_info;
2890
2891         return _get_info_string(key, pkg_detail_info);
2892 }
2893
2894 API pkgmgr_info *pkgmgr_info_new_from_file(const char *pkg_type,
2895                                            const char *pkg_path)
2896 {
2897         pkg_plugin_set *plugin_set = NULL;
2898         package_manager_pkg_detail_info_t *pkg_detail_info = NULL;
2899         char *pkgtype;
2900         if (pkg_path == NULL) {
2901                 ERR("pkg_path is NULL\n");
2902                 return NULL;
2903         }
2904
2905         if (strlen(pkg_path) > PKG_URL_STRING_LEN_MAX) {
2906                 ERR("length of pkg_path is too long - %d.\n",
2907                       strlen(pkg_path));
2908                 return NULL;
2909         }
2910
2911         pkg_detail_info = calloc(1, sizeof(package_manager_pkg_detail_info_t));
2912         if (pkg_detail_info == NULL) {
2913                 ERR("*** Failed to alloc package_handler_info.\n");
2914                 return NULL;
2915         }
2916
2917         if (pkg_type == NULL)
2918                 pkgtype = __get_type_from_path(pkg_path);
2919         else
2920                 pkgtype = strdup(pkg_type);
2921
2922         plugin_set = _package_manager_load_library(pkgtype);
2923         if (plugin_set == NULL) {
2924                 free(pkg_detail_info);
2925                 free(pkgtype);
2926                 return NULL;
2927         }
2928
2929         if (plugin_set->get_pkg_detail_info_from_package) {
2930                 if (plugin_set->get_pkg_detail_info_from_package(pkg_path,
2931                                                                  pkg_detail_info) != 0) {
2932                         free(pkg_detail_info);
2933                         free(pkgtype);
2934                         return NULL;
2935                 }
2936         }
2937
2938         free(pkgtype);
2939         return (pkgmgr_info *) pkg_detail_info;
2940 }
2941
2942 API int pkgmgr_info_free(pkgmgr_info * pkg_info)
2943 {
2944         if (pkg_info == NULL)
2945                 return PKGMGR_R_EINVAL;
2946
2947         free(pkg_info);
2948         pkg_info = NULL;
2949
2950         return 0;
2951 }
2952
2953 #define __END_OF_OLD_API