client/src/pkgmgr.c

   1 /*
   2  * slp-pkgmgr
   3  *
   4  * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Contact: Jayoun Lee <airjany@samsung.com>, Sewook Park <sewook7.park@samsung.com>,
   7  * Jaeho Lee <jaeho81.lee@samsung.com>, Shobhit Srivastava <shobhit.s@samsung.com>
   8  *
   9  * Licensed under the Apache License, Version 2.0 (the "License");
  10  * you may not use this file except in compliance with the License.
  11  * You may obtain a copy of the License at
  12  *
  13  * http://www.apache.org/licenses/LICENSE-2.0
  14  *
  15  * Unless required by applicable law or agreed to in writing, software
  16  * distributed under the License is distributed on an "AS IS" BASIS,
  17  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  18  * See the License for the specific language governing permissions and
  19  * limitations under the License.
  20  *
  21  */
  22
  23 #include <stdio.h>
  24 #include <stdlib.h>
  25 #include <string.h>
  26 #include <unistd.h>
  27 #include <dlfcn.h>
  28 #include <dirent.h>
  29 #include <fcntl.h>
  30 #include <sys/wait.h>
  31 #include <sys/time.h>
  32 #include <dbus/dbus.h>
  33 #include <dbus/dbus-glib-lowlevel.h>
  34 #include <ail.h>
  35 #include <aul.h>
  36 #include <vconf.h>
  37 #include <db-util.h>
  38 #include <pkgmgr-info.h>
  39 #include <iniparser.h>
  40
  41 #include "package-manager.h"
  42 #include "pkgmgr-internal.h"
  43 #include "pkgmgr-debug.h"
  44 #include "pkgmgr-api.h"
  45 #include "comm_client.h"
  46 #include "comm_status_broadcast_server.h"
  47
  48 #undef LOG_TAG
  49 #ifndef LOG_TAG
  50 #define LOG_TAG "PKGMGR"
  51 #endif                          /* LOG_TAG */
  52
  53 #define PKG_TMP_PATH "/opt/usr/apps/tmp"
  54
  55 static int _get_request_id()
  56 {
  57         static int internal_req_id = 1;
  58
  59         return internal_req_id++;
  60 }
  61
  62 typedef struct _req_cb_info {
  63         int request_id;
  64         char *req_key;
  65         pkgmgr_handler event_cb;
  66         void *data;
  67         struct _req_cb_info *next;
  68 } req_cb_info;
  69
  70 typedef struct _listen_cb_info {
  71         int request_id;
  72         pkgmgr_handler event_cb;
  73         void *data;
  74         struct _listen_cb_info *next;
  75 } listen_cb_info;
  76
  77 typedef struct _pkgmgr_client_t {
  78         client_type ctype;
  79         union {
  80                 struct _request {
  81                         comm_client *cc;
  82                         req_cb_info *rhead;
  83                 } request;
  84                 struct _listening {
  85                         comm_client *cc;
  86                         listen_cb_info *lhead;
  87                 } listening;
  88                 struct _broadcast {
  89                         DBusConnection *bc;
  90                 } broadcast;
  91         } info;
  92 } pkgmgr_client_t;
  93
  94 typedef struct _iter_data {
  95         pkgmgr_iter_fn iter_fn;
  96         void *data;
  97 } iter_data;
  98
  99 static int __xsystem(const char *argv[])
 100 {
 101         int status = 0;
 102         pid_t pid;
 103         pid = fork();
 104         switch (pid) {
 105         case -1:
 106                 perror("fork failed");
 107                 return -1;
 108         case 0:
 109                 /* child */
 110                 execvp(argv[0], (char *const *)argv);
 111                 _exit(-1);
 112         default:
 113                 /* parent */
 114                 break;
 115         }
 116         if (waitpid(pid, &status, 0) == -1) {
 117                 perror("waitpid failed");
 118                 return -1;
 119         }
 120         if (WIFSIGNALED(status)) {
 121                 perror("signal");
 122                 return -1;
 123         }
 124         if (!WIFEXITED(status)) {
 125                 /* shouldn't happen */
 126                 perror("should not happen");
 127                 return -1;
 128         }
 129         return WEXITSTATUS(status);
 130 }
 131
 132 static void __error_to_string(int errnumber, char **errstr)
 133 {
 134         if (errstr == NULL)
 135                 return;
 136         switch (errnumber) {
 137         case PKGCMD_ERR_PACKAGE_NOT_FOUND:
 138                 *errstr = PKGCMD_ERR_PACKAGE_NOT_FOUND_STR;
 139                 break;
 140         case PKGCMD_ERR_PACKAGE_INVALID:
 141                 *errstr = PKGCMD_ERR_PACKAGE_INVALID_STR;
 142                 break;
 143         case PKGCMD_ERR_PACKAGE_LOWER_VERSION:
 144                 *errstr = PKGCMD_ERR_PACKAGE_LOWER_VERSION_STR;
 145                 break;
 146         case PKGCMD_ERR_PACKAGE_EXECUTABLE_NOT_FOUND:
 147                 *errstr = PKGCMD_ERR_PACKAGE_EXECUTABLE_NOT_FOUND_STR;
 148                 break;
 149         case PKGCMD_ERR_MANIFEST_INVALID:
 150                 *errstr = PKGCMD_ERR_MANIFEST_INVALID_STR;
 151                 break;
 152         case PKGCMD_ERR_CONFIG_NOT_FOUND:
 153                 *errstr = PKGCMD_ERR_CONFIG_NOT_FOUND_STR;
 154                 break;
 155         case PKGCMD_ERR_CONFIG_INVALID:
 156                 *errstr = PKGCMD_ERR_CONFIG_INVALID_STR;
 157                 break;
 158         case PKGCMD_ERR_SIGNATURE_NOT_FOUND:
 159                 *errstr = PKGCMD_ERR_SIGNATURE_NOT_FOUND_STR;
 160                 break;
 161         case PKGCMD_ERR_SIGNATURE_INVALID:
 162                 *errstr = PKGCMD_ERR_SIGNATURE_INVALID_STR;
 163                 break;
 164         case PKGCMD_ERR_SIGNATURE_VERIFICATION_FAILED:
 165                 *errstr = PKGCMD_ERR_SIGNATURE_VERIFICATION_FAILED_STR;
 166                 break;
 167         case PKGCMD_ERR_ROOT_CERTIFICATE_NOT_FOUND:
 168                 *errstr = PKGCMD_ERR_ROOT_CERTIFICATE_NOT_FOUND_STR;
 169                 break;
 170         case PKGCMD_ERR_CERTIFICATE_INVALID:
 171                 *errstr = PKGCMD_ERR_CERTIFICATE_INVALID_STR;
 172                 break;
 173         case PKGCMD_ERR_CERTIFICATE_CHAIN_VERIFICATION_FAILED:
 174                 *errstr = PKGCMD_ERR_CERTIFICATE_CHAIN_VERIFICATION_FAILED_STR;
 175                 break;
 176         case PKGCMD_ERR_CERTIFICATE_EXPIRED:
 177                 *errstr = PKGCMD_ERR_CERTIFICATE_EXPIRED_STR;
 178                 break;
 179         case PKGCMD_ERR_INVALID_PRIVILEGE:
 180                 *errstr = PKGCMD_ERR_INVALID_PRIVILEGE_STR;
 181                 break;
 182         case PKGCMD_ERR_MENU_ICON_NOT_FOUND:
 183                 *errstr = PKGCMD_ERR_MENU_ICON_NOT_FOUND_STR;
 184                 break;
 185         case PKGCMD_ERR_FATAL_ERROR:
 186                 *errstr = PKGCMD_ERR_FATAL_ERROR_STR;
 187                 break;
 188         case PKGCMD_ERR_OUT_OF_STORAGE:
 189                 *errstr = PKGCMD_ERR_OUT_OF_STORAGE_STR;
 190                 break;
 191         case PKGCMD_ERR_OUT_OF_MEMORY:
 192                 *errstr = PKGCMD_ERR_OUT_OF_MEMORY_STR;
 193                 break;
 194         case PKGCMD_ERR_ARGUMENT_INVALID:
 195                 *errstr = PKGCMD_ERR_ARGUMENT_INVALID_STR;
 196                 break;
 197         default:
 198                 *errstr = PKGCMD_ERR_UNKNOWN_STR;
 199                 break;
 200         }
 201 }
 202
 203 static void __add_op_cbinfo(pkgmgr_client_t * pc, int request_id,
 204                             const char *req_key, pkgmgr_handler event_cb,
 205                             void *data)
 206 {
 207         req_cb_info *cb_info;
 208         req_cb_info *current;
 209         req_cb_info *prev;
 210
 211         cb_info = (req_cb_info *) calloc(1, sizeof(req_cb_info));
 212         if (cb_info == NULL) {
 213                 _LOGD("calloc failed");
 214                 return;
 215         }
 216         cb_info->request_id = request_id;
 217         cb_info->req_key = strdup(req_key);
 218         cb_info->event_cb = event_cb;
 219         cb_info->data = data;
 220         cb_info->next = NULL;
 221
 222         if (pc->info.request.rhead == NULL)
 223                 pc->info.request.rhead = cb_info;
 224         else {
 225                 current = prev = pc->info.request.rhead;
 226                 while (current) {
 227                         prev = current;
 228                         current = current->next;
 229                 }
 230
 231                 prev->next = cb_info;
 232         }
 233 }
 234
 235 static req_cb_info *__find_op_cbinfo(pkgmgr_client_t *pc, const char *req_key)
 236 {
 237         req_cb_info *tmp;
 238
 239         tmp = pc->info.request.rhead;
 240
 241         if (tmp == NULL) {
 242                 _LOGE("tmp is NULL");
 243                 return NULL;
 244         }
 245
 246         _LOGD("tmp->req_key %s, req_key %s", tmp->req_key, req_key);
 247
 248         while (tmp) {
 249                 if (strncmp(tmp->req_key, req_key, strlen(tmp->req_key)) == 0)
 250                         return tmp;
 251                 tmp = tmp->next;
 252         }
 253         return NULL;
 254 }
 255
 256 static void __remove_op_cbinfo(pkgmgr_client_t *pc, req_cb_info *info)
 257 {
 258         req_cb_info *tmp;
 259
 260         if (pc == NULL || pc->info.request.rhead == NULL || info == NULL)
 261                 return;
 262
 263         tmp = pc->info.request.rhead;
 264         while (tmp) {
 265                 if (tmp->next == info) {
 266                         tmp->next = info->next;
 267                         free(info);
 268                         return;
 269                 }
 270                 tmp = tmp->next;
 271         }
 272 }
 273
 274
 275 static void __add_stat_cbinfo(pkgmgr_client_t *pc, int request_id,
 276                               pkgmgr_handler event_cb, void *data)
 277 {
 278         listen_cb_info *cb_info;
 279         listen_cb_info *current;
 280         listen_cb_info *prev;
 281
 282         cb_info = (listen_cb_info *) calloc(1, sizeof(listen_cb_info));
 283         if (cb_info == NULL) {
 284                 _LOGD("calloc failed");
 285                 return;
 286         }
 287         cb_info->request_id = request_id;
 288         cb_info->event_cb = event_cb;
 289         cb_info->data = data;
 290         cb_info->next = NULL;
 291
 292         /* TODO - check the order of callback - FIFO or LIFO => Should be changed to LIFO */
 293         if (pc->info.listening.lhead == NULL)
 294                 pc->info.listening.lhead = cb_info;
 295         else {
 296                 current = prev = pc->info.listening.lhead;
 297                 while (current) {
 298                         prev = current;
 299                         current = current->next;
 300                 }
 301
 302                 prev->next = cb_info;
 303         }
 304 }
 305
 306 static void __operation_callback(void *cb_data, const char *req_id,
 307                                  const char *pkg_type, const char *pkgid,
 308                                  const char *key, const char *val)
 309 {
 310         pkgmgr_client_t *pc;
 311         req_cb_info *cb_info;
 312
 313         _LOGD("__operation_callback() req_id[%s] pkg_type[%s] pkgid[%s]"
 314               "key[%s] val[%s]\n", req_id, pkg_type, pkgid, key, val);
 315
 316         pc = (pkgmgr_client_t *) cb_data;
 317
 318         /* find callback info */
 319         cb_info = __find_op_cbinfo(pc, req_id);
 320         if (cb_info == NULL)
 321                 return;
 322
 323         _LOGD("__find_op_cbinfo");
 324
 325         /* call callback */
 326         if (cb_info->event_cb) {
 327                 cb_info->event_cb(cb_info->request_id, pkg_type, pkgid, key,
 328                                   val, NULL, cb_info->data);
 329                 _LOGD("event_cb is called");
 330         }
 331
 332         /*remove callback for last call
 333            if (strcmp(key, "end") == 0) {
 334            __remove_op_cbinfo(pc, cb_info);
 335            _LOGD("__remove_op_cbinfo");
 336            }
 337          */
 338
 339         return;
 340 }
 341
 342 static void __status_callback(void *cb_data, const char *req_id,
 343                               const char *pkg_type, const char *pkgid,
 344                               const char *key, const char *val)
 345 {
 346         pkgmgr_client_t *pc;
 347         listen_cb_info *tmp;
 348
 349         _LOGD("__status_callback() req_id[%s] pkg_type[%s] pkgid[%s]"
 350               "key[%s] val[%s]\n", req_id, pkg_type, pkgid, key, val);
 351
 352         pc = (pkgmgr_client_t *) cb_data;
 353
 354         tmp = pc->info.listening.lhead;
 355         while (tmp) {
 356                 if (tmp->event_cb(tmp->request_id, pkg_type, pkgid, key, val,
 357                                   NULL, tmp->data) != 0)
 358                         break;
 359                 tmp = tmp->next;
 360         }
 361
 362         return;
 363 }
 364
 365 static char *__get_req_key(const char *pkg_path)
 366 {
 367         struct timeval tv;
 368         long curtime;
 369         char timestr[PKG_STRING_LEN_MAX];
 370         char *str_req_key;
 371         int size;
 372
 373         gettimeofday(&tv, NULL);
 374         curtime = tv.tv_sec * 1000000 + tv.tv_usec;
 375         snprintf(timestr, sizeof(timestr), "%ld", curtime);
 376
 377         size = strlen(pkg_path) + strlen(timestr) + 2;
 378         str_req_key = (char *)calloc(size, sizeof(char));
 379         if (str_req_key == NULL) {
 380                 _LOGD("calloc failed");
 381                 return NULL;
 382         }
 383         snprintf(str_req_key, size, "%s_%s", pkg_path, timestr);
 384
 385         return str_req_key;
 386 }
 387
 388 static char *__get_type_from_path(const char *pkg_path)
 389 {
 390         int ret;
 391         char mimetype[255] = { '\0', };
 392         char extlist[256] = { '\0', };
 393         char *pkg_type;
 394
 395         ret = _get_mime_from_file(pkg_path, mimetype, sizeof(mimetype));
 396         if (ret) {
 397                 _LOGE("_get_mime_from_file() failed - error code[%d]\n",
 398                       ret);
 399                 return NULL;
 400         }
 401
 402         ret = _get_mime_extension(mimetype, extlist, sizeof(extlist));
 403         if (ret) {
 404                 _LOGE("_get_mime_extension() failed - error code[%d]\n",
 405                       ret);
 406                 return NULL;
 407         }
 408
 409         if (strlen(extlist) == 0)
 410                 return NULL;
 411
 412         if (strchr(extlist, ',')) {
 413                 extlist[strlen(extlist) - strlen(strchr(extlist, ','))] = '\0';
 414         }
 415         pkg_type = strchr(extlist, '.') + 1;
 416         return strdup(pkg_type);
 417 }
 418
 419 static inline int __pkgmgr_read_proc(const char *path, char *buf, int size)
 420 {
 421         int fd;
 422         int ret;
 423
 424         if (buf == NULL || path == NULL)
 425                 return -1;
 426
 427         fd = open(path, O_RDONLY);
 428         if (fd < 0)
 429                 return -1;
 430
 431         ret = read(fd, buf, size - 1);
 432         if (ret <= 0) {
 433                 close(fd);
 434                 return -1;
 435         } else
 436                 buf[ret] = 0;
 437
 438         close(fd);
 439
 440         return ret;
 441 }
 442
 443 static inline int __pkgmgr_find_pid_by_cmdline(const char *dname,
 444                                       const char *cmdline, const char *apppath)
 445 {
 446         int pid = 0;
 447
 448         if (strncmp(cmdline, apppath, PKG_STRING_LEN_MAX-1) == 0) {
 449                 pid = atoi(dname);
 450                 if (pid != getpgid(pid))
 451                         pid = 0;
 452         }
 453
 454         return pid;
 455 }
 456
 457
 458 static int __pkgmgr_proc_iter_kill_cmdline(const char *apppath)
 459 {
 460         DIR *dp;
 461         struct dirent *dentry;
 462         int pid;
 463         int ret;
 464         char buf[PKG_STRING_LEN_MAX];
 465
 466         dp = opendir("/proc");
 467         if (dp == NULL) {
 468                 return -1;
 469         }
 470
 471         while ((dentry = readdir(dp)) != NULL) {
 472                 if (!isdigit(dentry->d_name[0]))
 473                         continue;
 474
 475                 snprintf(buf, sizeof(buf), "/proc/%s/cmdline", dentry->d_name);
 476                 ret = __pkgmgr_read_proc(buf, buf, sizeof(buf));
 477                 if (ret <= 0)
 478                         continue;
 479
 480                 pid = __pkgmgr_find_pid_by_cmdline(dentry->d_name, buf, apppath);
 481
 482                 if (pid > 0) {
 483                         int pgid;
 484
 485                         pgid = getpgid(pid);
 486                         if (pgid <= 1) {
 487                                 closedir(dp);
 488                                 return -1;
 489                         }
 490
 491                         if (killpg(pgid, SIGKILL) < 0) {
 492                                 closedir(dp);
 493                                 return -1;
 494                         }
 495                 }
 496         }
 497
 498         closedir(dp);
 499         return 0;
 500 }
 501
 502
 503 static int __app_list_cb (const pkgmgr_appinfo_h handle,
 504                                                 void *user_data)
 505 {
 506         char *exec = NULL;
 507         pkgmgr_appinfo_get_exec(handle, &exec);
 508
 509         __pkgmgr_proc_iter_kill_cmdline(exec);
 510
 511         return 0;
 512 }
 513
 514 static int __sync_process(char *req_key)
 515 {
 516         int ret =0;
 517         char info_file[PKG_STRING_LEN_MAX] = {'\0', };
 518         int result = 0;
 519         int check_cnt = 0;
 520         FILE *fp;
 521         char buffer[PKG_ARGC_MAX] = {'\0', };
 522
 523         snprintf(info_file, PKG_STRING_LEN_MAX, "%s/%s", PKG_TMP_PATH, req_key);
 524         while(1)
 525         {
 526                 check_cnt ++;
 527                 if (access(info_file, F_OK) != 0) {
 528                         _LOGD("file is not generated yet.... wait\n", info_file);
 529                         usleep(10 * 1000);      /* 10ms sleep*/
 530                 } else {
 531                         fp = fopen(info_file, "r");
 532                         if (fp == NULL) {
 533                                 _LOGE("fopen failed\n");
 534                                 break;
 535                         }
 536                         fread(&buffer, sizeof(buffer), 1, fp);
 537                         fclose(fp);
 538
 539                         result = atoi(buffer);
 540                         _LOGD("info_file file is generated, result = %d. \n", result);
 541                         break;
 542                 }
 543
 544                 if (check_cnt > 500) {  /* 5s time over*/
 545                         _LOGD("wait time over!!\n");
 546                         break;
 547                 }
 548         }
 549
 550         const char *rm_argv[] = { "/bin/rm", "-rf", info_file, NULL };
 551         ret = __xsystem(rm_argv);
 552         if (ret < 0)
 553                 _LOGE("__xsystem failed, ret=%d\n", ret);
 554
 555         return result;
 556 }
 557 static int __csc_process(const char *csc_path, char *result_path)
 558 {
 559         int ret = 0;
 560         int cnt = 0;
 561         int count = 0;
 562         int csc_fail = 0;
 563         int fd = 0;
 564         char *pkgtype = NULL;
 565         char *des = NULL;
 566         char buf[PKG_STRING_LEN_MAX] = {0,};
 567         char type_buf[1024] = { 0 };
 568         char des_buf[1024] = { 0 };
 569         dictionary *csc = NULL;
 570         FILE* file = NULL;
 571
 572         csc = iniparser_load(csc_path);
 573         retvm_if(csc == NULL, PKGMGR_R_EINVAL, "cannot open parse file [%s]", csc_path);
 574
 575         file = fopen(result_path, "w");
 576         tryvm_if(file == NULL, ret = PKGMGR_R_EINVAL, "cannot open result file [%s]", result_path);
 577
 578         count = iniparser_getint(csc, "csc packages:count", -1);
 579         tryvm_if(count == 0, ret = PKGMGR_R_ERROR, "csc [%s] dont have packages", csc_path);
 580
 581         snprintf(buf, PKG_STRING_LEN_MAX, "[result]\n");
 582         fwrite(buf, 1, strlen(buf), file);
 583         snprintf(buf, PKG_STRING_LEN_MAX, "count = %d\n", count);
 584         fwrite(buf, 1, strlen(buf), file);
 585
 586         for(cnt = 1 ; cnt <= count ; cnt++)
 587         {
 588                 snprintf(type_buf, PKG_STRING_LEN_MAX - 1, "csc packages:type_%03d", cnt);
 589                 snprintf(des_buf, PKG_STRING_LEN_MAX - 1, "csc packages:description_%03d", cnt);
 590
 591                 pkgtype = iniparser_getstr(csc, type_buf);
 592                 des = iniparser_getstr(csc, des_buf);
 593                 ret = 0;
 594
 595                 if (pkgtype == NULL) {
 596                         csc_fail++;
 597                         snprintf(buf, PKG_STRING_LEN_MAX, "%s = Fail to get pkgtype\n", type_buf);
 598                         fwrite(buf, 1, strlen(buf), file);
 599                         continue;
 600                 } else if (des == NULL) {
 601                         csc_fail++;
 602                         snprintf(buf, PKG_STRING_LEN_MAX, "%s = Fail to get description\n", des_buf);
 603                         fwrite(buf, 1, strlen(buf), file);
 604                         continue;
 605                 }
 606
 607                 snprintf(buf, PKG_STRING_LEN_MAX, "type_%03d = %s\n", cnt, pkgtype);
 608                 fwrite(buf, 1, strlen(buf), file);
 609                 snprintf(buf, PKG_STRING_LEN_MAX, "description_%03d = %s\n", cnt, des);
 610                 fwrite(buf, 1, strlen(buf), file);
 611
 612                 if (strcmp(pkgtype, "tpk") == 0) {
 613                         const char *ospinstaller_argv[] = { "/usr/bin/osp-installer", "-c", des, NULL };
 614                         ret = __xsystem(ospinstaller_argv);
 615                 } else if (strcmp(pkgtype, "wgt")== 0) {
 616                         const char *wrtinstaller_argv[] = { "/usr/bin/wrt-installer", "-c", des, NULL };
 617                         ret = __xsystem(wrtinstaller_argv);
 618                 } else {
 619                         csc_fail++;
 620                         ret = -1;
 621                 }
 622
 623                 if (ret != 0) {
 624                         char *errstr = NULL;
 625                         __error_to_string(ret, &errstr);
 626                         snprintf(buf, PKG_STRING_LEN_MAX, "result_%03d = fail[%s]\n", cnt, errstr);
 627                 }
 628                 else
 629                         snprintf(buf, PKG_STRING_LEN_MAX, "result_%03d = success\n", cnt);
 630
 631                 fwrite(buf, 1, strlen(buf), file);
 632         }
 633
 634 catch:
 635         iniparser_freedict(csc);
 636         if (file != NULL) {
 637                 fflush(file);
 638                 fd = fileno(file);
 639                 fsync(fd);
 640                 fclose(file);
 641         }
 642         return ret;
 643 }
 644
 645 static int __get_size_process(pkgmgr_client * pc, const char *pkgid, pkgmgr_getsize_type get_type, pkgmgr_handler event_cb, void *data)
 646 {
 647         char *req_key = NULL;
 648         int req_id = 0;
 649         int ret =0;
 650         pkgmgrinfo_pkginfo_h handle;
 651         char *pkgtype = NULL;
 652         char *installer_path = NULL;
 653         char *argv[PKG_ARGC_MAX] = { NULL, };
 654         char *args = NULL;
 655         int argcnt = 0;
 656         int len = 0;
 657         char *temp = NULL;
 658         int i = 0;
 659         char buf[128] = {'\0'};
 660
 661         pkgmgr_client_t *mpc = (pkgmgr_client_t *) pc;
 662         retvm_if(mpc->ctype != PC_REQUEST, PKGMGR_R_EINVAL, "mpc->ctype is not PC_REQUEST\n");
 663
 664         ret = pkgmgrinfo_pkginfo_get_pkginfo(pkgid, &handle);
 665         retvm_if(ret < 0, PKGMGR_R_ERROR, "pkgmgr_pkginfo_get_pkginfo failed");
 666
 667         ret = pkgmgrinfo_pkginfo_get_type(handle, &pkgtype);
 668         tryvm_if(ret < 0, ret = PKGMGR_R_ERROR, "pkgmgr_pkginfo_get_type failed");
 669
 670         installer_path = _get_backend_path_with_type(pkgtype);
 671         req_key = __get_req_key(pkgid);
 672         req_id = _get_request_id();
 673
 674         snprintf(buf, 128, "%d", get_type);
 675         argv[argcnt++] = installer_path;
 676         /* argv[1] */
 677         argv[argcnt++] = strdup("-k");
 678         /* argv[2] */
 679         argv[argcnt++] = req_key;
 680         /* argv[3] */
 681         argv[argcnt++] = strdup("-d");
 682         /* argv[4] */
 683         argv[argcnt++] = strdup(pkgid);
 684         /* argv[5] */
 685         argv[argcnt++] = strdup("-t");
 686         /* argv[6] */
 687         argv[argcnt++] = strdup(buf);
 688
 689         /*** add quote in all string for special charactor like '\n'***   FIX */
 690         for (i = 0; i < argcnt; i++) {
 691                 temp = g_shell_quote(argv[i]);
 692                 len += (strlen(temp) + 1);
 693                 g_free(temp);
 694         }
 695
 696         args = (char *)calloc(len, sizeof(char));
 697         tryvm_if(args == NULL, ret = PKGMGR_R_EINVAL, "installer_path fail");
 698
 699         strncpy(args, argv[0], len - 1);
 700
 701         for (i = 1; i < argcnt; i++) {
 702                 strncat(args, " ", strlen(" "));
 703                 temp = g_shell_quote(argv[i]);
 704                 strncat(args, temp, strlen(temp));
 705                 g_free(temp);
 706         }
 707         _LOGD("[args] %s [len] %d\n", args, len);
 708
 709         /* request */
 710         ret = comm_client_request(mpc->info.request.cc, req_key, COMM_REQ_GET_SIZE, pkgtype, pkgid, args, NULL, 1);
 711         if (ret < 0)
 712                 _LOGE("comm_client_request failed, ret=%d\n", ret);
 713
 714         ret = __sync_process(req_key);
 715         if (ret < 0)
 716                 _LOGE("get size failed, ret=%d\n", ret);
 717
 718 catch:
 719         for (i = 0; i < argcnt; i++)
 720                 free(argv[i]);
 721
 722         if(args)
 723                 free(args);
 724
 725         pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
 726         return ret;
 727 }
 728
 729 static int __move_pkg_process(pkgmgr_client * pc, const char *pkgid, pkgmgr_move_type move_type, pkgmgr_handler event_cb, void *data)
 730 {
 731         char *req_key = NULL;
 732         int req_id = 0;
 733         int ret =0;
 734         pkgmgrinfo_pkginfo_h handle;
 735         char *pkgtype = NULL;
 736         char *installer_path = NULL;
 737         char *argv[PKG_ARGC_MAX] = { NULL, };
 738         char *args = NULL;
 739         int argcnt = 0;
 740         int len = 0;
 741         char *temp = NULL;
 742         int i = 0;
 743         char buf[128] = {'\0'};
 744
 745         pkgmgr_client_t *mpc = (pkgmgr_client_t *) pc;
 746         retvm_if(mpc->ctype != PC_REQUEST, PKGMGR_R_EINVAL, "mpc->ctype is not PC_REQUEST\n");
 747
 748         ret = pkgmgrinfo_pkginfo_get_pkginfo(pkgid, &handle);
 749         retvm_if(ret < 0, PKGMGR_R_ERROR, "pkgmgr_pkginfo_get_pkginfo failed");
 750
 751         ret = pkgmgrinfo_pkginfo_get_type(handle, &pkgtype);
 752         tryvm_if(ret < 0, ret = PKGMGR_R_ERROR, "pkgmgr_pkginfo_get_type failed");
 753
 754         installer_path = _get_backend_path_with_type(pkgtype);
 755         req_key = __get_req_key(pkgid);
 756         req_id = _get_request_id();
 757
 758         /* generate argv */
 759         snprintf(buf, 128, "%d", move_type);
 760         /* argv[0] installer path */
 761         argv[argcnt++] = installer_path;
 762         /* argv[1] */
 763         argv[argcnt++] = strdup("-k");
 764         /* argv[2] */
 765         argv[argcnt++] = req_key;
 766         /* argv[3] */
 767         argv[argcnt++] = strdup("-m");
 768         /* argv[4] */
 769         argv[argcnt++] = strdup(pkgid);
 770         /* argv[5] */
 771         argv[argcnt++] = strdup("-t");
 772         /* argv[6] */
 773         argv[argcnt++] = strdup(buf);
 774         /* argv[7] */
 775         argv[argcnt++] = strdup("-q");
 776
 777         /*** add quote in all string for special charactor like '\n'***   FIX */
 778         for (i = 0; i < argcnt; i++) {
 779                 temp = g_shell_quote(argv[i]);
 780                 len += (strlen(temp) + 1);
 781                 g_free(temp);
 782         }
 783
 784         args = (char *)calloc(len, sizeof(char));
 785         tryvm_if(args == NULL, ret = PKGMGR_R_EINVAL, "installer_path fail");
 786
 787         strncpy(args, argv[0], len - 1);
 788
 789         for (i = 1; i < argcnt; i++) {
 790                 strncat(args, " ", strlen(" "));
 791                 temp = g_shell_quote(argv[i]);
 792                 strncat(args, temp, strlen(temp));
 793                 g_free(temp);
 794         }
 795         _LOGD("[args] %s [len] %d\n", args, len);
 796
 797         /* 6. request */
 798         ret = comm_client_request(mpc->info.request.cc, req_key, COMM_REQ_TO_MOVER, pkgtype, pkgid, args, NULL, 1);
 799         if (ret < 0)
 800                 _LOGE("comm_client_request failed, ret=%d\n", ret);
 801
 802         ret = __sync_process(pkgid);
 803         if (ret != 0)
 804                 _LOGE("move pkg failed, ret=%d\n", ret);
 805
 806 catch:
 807         for (i = 0; i < argcnt; i++)
 808                 free(argv[i]);
 809
 810         if(args)
 811                 free(args);
 812
 813         pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
 814         return ret;
 815 }
 816
 817 static int __kill_app_process(pkgmgr_client * pc, const char *pkgid)
 818 {
 819         const char *pkgtype;
 820         char *req_key;
 821         char *cookie = NULL;
 822         int ret;
 823         pkgmgrinfo_pkginfo_h handle;
 824
 825         /* Check for NULL value of pc */
 826         pkgmgr_client_t *mpc = (pkgmgr_client_t *) pc;
 827         retvm_if(mpc->ctype != PC_REQUEST, PKGMGR_R_EINVAL, "mpc->ctype is not PC_REQUEST\n");
 828
 829         ret = pkgmgrinfo_pkginfo_get_pkginfo(pkgid, &handle);
 830         retvm_if(ret < 0, PKGMGR_R_ERROR, "pkgmgr_pkginfo_get_pkginfo failed");
 831
 832         ret = pkgmgrinfo_pkginfo_get_type(handle, &pkgtype);
 833         tryvm_if(ret < 0, ret = PKGMGR_R_ERROR, "pkgmgr_pkginfo_get_type failed");
 834
 835         /* 2. generate req_key */
 836         req_key = __get_req_key(pkgid);
 837
 838         /* 3. request activate */
 839         ret = comm_client_request(mpc->info.request.cc, req_key, COMM_REQ_KILL_APP, pkgtype, pkgid, NULL, NULL, 1);
 840         if (ret < 0)
 841                 _LOGE("request failed, ret=%d\n", ret);
 842
 843 catch:
 844         free(req_key);
 845         pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
 846
 847         return ret;
 848
 849 }
 850
 851 API pkgmgr_client *pkgmgr_client_new(client_type ctype)
 852 {
 853         pkgmgr_client_t *pc = NULL;
 854         int ret = -1;
 855
 856         if (ctype != PC_REQUEST && ctype != PC_LISTENING
 857             && ctype != PC_BROADCAST)
 858                 return NULL;
 859
 860         /* Allocate memory for ADT:pkgmgr_client */
 861         pc = calloc(1, sizeof(pkgmgr_client_t));
 862         if (pc == NULL) {
 863                 _LOGE("No memory");
 864                 return NULL;
 865         }
 866
 867         /* Manage pc */
 868         pc->ctype = ctype;
 869
 870         if (pc->ctype == PC_REQUEST) {
 871                 pc->info.request.cc = comm_client_new();
 872                 if (pc->info.request.cc == NULL) {
 873                         _LOGE("client creation failed");
 874                         goto err;
 875                 }
 876                 ret = comm_client_set_status_callback(pc->info.request.cc,
 877                                                       __operation_callback, pc);
 878                 if (ret < 0) {
 879                         _LOGE("comm_client_set_status_callback() failed - %d",
 880                               ret);
 881                         goto err;
 882                 }
 883         } else if (pc->ctype == PC_LISTENING) {
 884                 pc->info.listening.cc = comm_client_new();
 885                 if (pc->info.listening.cc == NULL) {
 886                         _LOGE("client creation failed");
 887                         goto err;
 888                 }
 889                 ret = comm_client_set_status_callback(pc->info.listening.cc,
 890                                                       __status_callback, pc);
 891                 if (ret < 0) {
 892                         _LOGE("comm_client_set_status_callback() failed - %d",
 893                               ret);
 894                         goto err;
 895                 }
 896         } else if (pc->ctype == PC_BROADCAST) {
 897                 pc->info.broadcast.bc = comm_status_broadcast_server_connect();
 898                 if (pc->info.broadcast.bc == NULL) {
 899                         _LOGE("client creation failed");
 900                         goto err;
 901                 }
 902                 ret = 0;
 903         }
 904
 905         return (pkgmgr_client *) pc;
 906
 907  err:
 908         if (pc)
 909                 free(pc);
 910         return NULL;
 911 }
 912
 913 API int pkgmgr_client_free(pkgmgr_client *pc)
 914 {
 915         int ret = -1;
 916         pkgmgr_client_t *mpc = (pkgmgr_client_t *) pc;
 917
 918         if (mpc == NULL) {
 919                 _LOGE("Invalid argument");
 920                 return PKGMGR_R_EINVAL;
 921         }
 922
 923         if (mpc->ctype == PC_REQUEST) {
 924                 req_cb_info *tmp;
 925                 req_cb_info *prev;
 926                 for (tmp = mpc->info.request.rhead; tmp;) {
 927                         prev = tmp;
 928                         tmp = tmp->next;
 929                         free(prev);
 930                 }
 931
 932                 ret = comm_client_free(mpc->info.request.cc);
 933                 if (ret < 0) {
 934                         _LOGE("comm_client_free() failed - %d", ret);
 935                         goto err;
 936                 }
 937         } else if (mpc->ctype == PC_LISTENING) {
 938                 listen_cb_info *tmp;
 939                 listen_cb_info *prev;
 940                 for (tmp = mpc->info.listening.lhead; tmp;) {
 941                         prev = tmp;
 942                         tmp = tmp->next;
 943                         free(prev);
 944                 }
 945
 946                 ret = comm_client_free(mpc->info.listening.cc);
 947                 if (ret < 0) {
 948                         _LOGE("comm_client_free() failed - %d", ret);
 949                         goto err;
 950                 }
 951         } else if (mpc->ctype == PC_BROADCAST) {
 952                 comm_status_broadcast_server_disconnect(mpc->info.broadcast.bc);
 953                 ret = 0;
 954         } else {
 955                 _LOGE("Invalid client type\n");
 956                 return PKGMGR_R_EINVAL;
 957         }
 958
 959         free(mpc);
 960         mpc = NULL;
 961         return PKGMGR_R_OK;
 962
 963  err:
 964         if (mpc) {
 965                 free(mpc);
 966                 mpc = NULL;
 967         }
 968         return PKGMGR_R_ERROR;
 969 }
 970
 971 API int pkgmgr_client_install(pkgmgr_client * pc, const char *pkg_type,
 972                               const char *descriptor_path, const char *pkg_path,
 973                               const char *optional_file, pkgmgr_mode mode,
 974                               pkgmgr_handler event_cb, void *data)
 975 {
 976         char *pkgtype;
 977         char *installer_path;
 978         char *req_key;
 979         int req_id;
 980         int i = 0;
 981         char *argv[PKG_ARGC_MAX] = { NULL, };
 982         char *args = NULL;
 983         int argcnt = 0;
 984         int len = 0;
 985         char *temp = NULL;
 986         int ret;
 987         char *cookie = NULL;
 988
 989         /* Check for NULL value of pc */
 990         if (pc == NULL) {
 991                 _LOGD("package manager client handle is NULL\n");
 992                 return PKGMGR_R_EINVAL;
 993         }
 994         pkgmgr_client_t *mpc = (pkgmgr_client_t *) pc;
 995
 996         /* 0. check the pc type */
 997         if (mpc->ctype != PC_REQUEST)
 998                 return PKGMGR_R_EINVAL;
 999
1000         /* 1. check argument */
1001         if (descriptor_path) {
1002                 if (strlen(descriptor_path) >= PKG_STRING_LEN_MAX)
1003                         return PKGMGR_R_EINVAL;
1004
1005                 if (access(descriptor_path, F_OK) != 0)
1006                         return PKGMGR_R_EINVAL;
1007         }
1008
1009         if (pkg_path == NULL)
1010                 return PKGMGR_R_EINVAL;
1011         else {
1012                 if (strlen(pkg_path) >= PKG_STRING_LEN_MAX)
1013                         return PKGMGR_R_EINVAL;
1014
1015                 if (access(pkg_path, F_OK) != 0)
1016                         return PKGMGR_R_EINVAL;
1017         }
1018
1019         if (optional_file) {
1020                 if (strlen(optional_file) >= PKG_STRING_LEN_MAX)
1021                         return PKGMGR_R_EINVAL;
1022         }
1023
1024         /* 2. get installer path using pkg_path */
1025         if (pkg_type) {
1026                 installer_path = _get_backend_path_with_type(pkg_type);
1027                 pkgtype = strdup(pkg_type);
1028         } else {
1029                 installer_path = _get_backend_path(pkg_path);
1030                 pkgtype = __get_type_from_path(pkg_path);
1031         }
1032
1033         if (installer_path == NULL) {
1034                 free(pkgtype);
1035                 return PKGMGR_R_EINVAL;
1036         }
1037
1038         /* 3. generate req_key */
1039         req_key = __get_req_key(pkg_path);
1040
1041         /* 4. add callback info - add callback info to pkgmgr_client */
1042         req_id = _get_request_id();
1043         __add_op_cbinfo(mpc, req_id, req_key, event_cb, data);
1044
1045         /* 5. generate argv */
1046
1047         /*  argv[0] installer path */
1048         argv[argcnt++] = installer_path;
1049         /* argv[1] */
1050         argv[argcnt++] = strdup("-k");
1051         /* argv[2] */
1052         argv[argcnt++] = req_key;
1053         /* argv[3] */
1054         argv[argcnt++] = strdup("-i");
1055         /* argv[(4)] if exists */
1056         if (descriptor_path)
1057                 argv[argcnt++] = strdup(descriptor_path);
1058         /* argv[4] */
1059         argv[argcnt++] = strdup(pkg_path);
1060         /* argv[(5)] if exists */
1061         if (optional_file){
1062                 argv[argcnt++] = strdup("-o");
1063                 argv[argcnt++] = strdup(optional_file);
1064         }
1065         /* argv[6] -q option should be located at the end of command !! */
1066         if (mode == PM_QUIET)
1067                 argv[argcnt++] = strdup("-q");
1068
1069         /*** add quote in all string for special charactor like '\n'***   FIX */
1070         for (i = 0; i < argcnt; i++) {
1071                 temp = g_shell_quote(argv[i]);
1072                 len += (strlen(temp) + 1);
1073                 g_free(temp);
1074         }
1075
1076         args = (char *)calloc(len, sizeof(char));
1077         if (args == NULL) {
1078                 _LOGD("calloc failed");
1079
1080                 for (i = 0; i < argcnt; i++)
1081                         free(argv[i]);
1082
1083                 free(pkgtype);
1084                 return PKGMGR_R_ERROR;
1085         }
1086         strncpy(args, argv[0], len - 1);
1087
1088         for (i = 1; i < argcnt; i++) {
1089                 strncat(args, " ", strlen(" "));
1090                 temp = g_shell_quote(argv[i]);
1091                 strncat(args, temp, strlen(temp));
1092                 g_free(temp);
1093         }
1094         _LOGD("[args] %s [len] %d\n", args, len);
1095         /******************* end of quote ************************/
1096
1097         /* 6. request install */
1098         ret = comm_client_request(mpc->info.request.cc, req_key,
1099                                   COMM_REQ_TO_INSTALLER, pkgtype, pkg_path,
1100                                   args, cookie, 1);
1101         if (ret < 0) {
1102                 _LOGE("request failed, ret=%d\n", ret);
1103
1104                 for (i = 0; i < argcnt; i++)
1105                         free(argv[i]);
1106                 free(args);
1107                 free(pkgtype);
1108                 return PKGMGR_R_ECOMM;
1109         }
1110
1111         for (i = 0; i < argcnt; i++)
1112                 free(argv[i]);
1113
1114         free(args);
1115         free(pkgtype);
1116
1117         return req_id;
1118 }
1119
1120 API int pkgmgr_client_reinstall(pkgmgr_client * pc, const char *pkg_type, const char *pkgid,
1121                                   const char *optional_file, pkgmgr_mode mode,
1122                               pkgmgr_handler event_cb, void *data)
1123 {
1124         char *pkgtype = NULL;
1125         char *installer_path = NULL;
1126         char *req_key = NULL;
1127         int req_id = 0;
1128         int i = 0;
1129         char *argv[PKG_ARGC_MAX] = { NULL, };
1130         char *args = NULL;
1131         int argcnt = 0;
1132         int len = 0;
1133         char *temp = NULL;
1134         int ret = 0;
1135         char *cookie = NULL;
1136
1137         /* Check for NULL value of pc */
1138         retvm_if(pc == NULL, PKGMGR_R_EINVAL, "package manager client handle is NULL\n");
1139
1140         pkgmgr_client_t *mpc = (pkgmgr_client_t *) pc;
1141
1142         /* 0. check the pc type */
1143         retv_if(mpc->ctype != PC_REQUEST, PKGMGR_R_EINVAL);
1144
1145
1146         /* 1. check argument */
1147         retv_if(pkgid == NULL, PKGMGR_R_EINVAL);
1148         retv_if(strlen(pkgid) >= PKG_STRING_LEN_MAX, PKGMGR_R_EINVAL);
1149         if (optional_file) {
1150                 if (strlen(optional_file) >= PKG_STRING_LEN_MAX)
1151                         return PKGMGR_R_EINVAL;
1152         }
1153
1154         /* 2. get installer path using pkg_path */
1155         installer_path = _get_backend_path_with_type(pkg_type);
1156         pkgtype = strdup(pkg_type);
1157         tryvm_if(installer_path == NULL, ret = PKGMGR_R_EINVAL, "installer_path is null");
1158
1159         /* 3. generate req_key */
1160         req_key = __get_req_key(pkgid);
1161
1162         /* 4. add callback info - add callback info to pkgmgr_client */
1163         req_id = _get_request_id();
1164         __add_op_cbinfo(mpc, req_id, req_key, event_cb, data);
1165
1166         /* 5. generate argv */
1167
1168         /*  argv[0] installer path */
1169         argv[argcnt++] = installer_path;
1170         /* argv[1] */
1171         argv[argcnt++] = strdup("-k");
1172         /* argv[2] */
1173         argv[argcnt++] = req_key;
1174         /* argv[3] */
1175         argv[argcnt++] = strdup("-r");
1176         /* argv[4] */
1177         argv[argcnt++] = strdup(pkgid);
1178         /* argv[(5)] if exists */
1179         if (optional_file){
1180                 argv[argcnt++] = strdup("-o");
1181                 argv[argcnt++] = strdup(optional_file);
1182         }
1183
1184         /* argv[5] -q option should be located at the end of command !! */
1185         if (mode == PM_QUIET)
1186                 argv[argcnt++] = strdup("-q");
1187
1188         /*** add quote in all string for special charactor like '\n'***   FIX */
1189         for (i = 0; i < argcnt; i++) {
1190                 temp = g_shell_quote(argv[i]);
1191                 len += (strlen(temp) + 1);
1192                 g_free(temp);
1193         }
1194
1195         args = (char *)calloc(len, sizeof(char));
1196         tryvm_if(args == NULL, ret = PKGMGR_R_ERROR, "calloc failed");
1197
1198         strncpy(args, argv[0], len - 1);
1199
1200         for (i = 1; i < argcnt; i++) {
1201                 strncat(args, " ", strlen(" "));
1202                 temp = g_shell_quote(argv[i]);
1203                 strncat(args, temp, strlen(temp));
1204                 g_free(temp);
1205         }
1206         _LOGD("[args] %s [len] %d\n", args, len);
1207         /******************* end of quote ************************/
1208
1209         /* 6. request install */
1210         ret = comm_client_request(mpc->info.request.cc, req_key, COMM_REQ_TO_INSTALLER, pkgtype, pkgid, args, cookie, 1);
1211         tryvm_if(ret < 0, ret = PKGMGR_R_ECOMM, "request failed");
1212
1213         ret = req_id;
1214
1215 catch:
1216         for (i = 0; i < argcnt; i++)
1217                 free(argv[i]);
1218
1219         free(args);
1220         free(pkgtype);
1221
1222         return ret;
1223 }
1224
1225 API int pkgmgr_client_uninstall(pkgmgr_client *pc, const char *pkg_type,
1226                                 const char *pkgid, pkgmgr_mode mode,
1227                                 pkgmgr_handler event_cb, void *data)
1228 {
1229         char *pkgtype;
1230         char *installer_path;
1231         char *req_key;
1232         int req_id;
1233         int i = 0;
1234         char *argv[PKG_ARGC_MAX] = { NULL, };
1235         char *args = NULL;
1236         int argcnt = 0;
1237         int len = 0;
1238         char *temp = NULL;
1239         int ret = -1;
1240         char *cookie = NULL;
1241
1242         /* Check for NULL value of pc */
1243         retvm_if(pc == NULL, PKGMGR_R_EINVAL, "package manager client handle is NULL\n");
1244
1245         pkgmgr_client_t *mpc = (pkgmgr_client_t *) pc;
1246
1247         /* 0. check the pc type */
1248         retv_if(mpc->ctype != PC_REQUEST, PKGMGR_R_EINVAL);
1249
1250         /* 1. check argument */
1251         retv_if(pkgid == NULL, PKGMGR_R_EINVAL);
1252
1253         pkgmgr_pkginfo_h handle;
1254         ret = pkgmgr_pkginfo_get_pkginfo(pkgid, &handle);
1255
1256         /*check package id      */
1257         tryvm_if(ret < 0, ret = PKGMGR_R_EINVAL, "pkgmgr_pkginfo_get_pkginfo fail");
1258         tryvm_if(handle == NULL, ret = PKGMGR_R_EINVAL, "Pkgid(%s) can not find in installed pkg DB! \n", pkgid);
1259
1260         /*check running app , terminate app if it is running*/
1261         ret = pkgmgr_appinfo_get_list(handle, PM_UI_APP, __app_list_cb, NULL);
1262         tryvm_if(ret < 0, ret = PKGMGR_R_EINVAL, "pkgmgr_appinfo_get_list : PM_UI_APP fail");
1263
1264         /*check running app , terminate app if it is running*/
1265         ret = pkgmgr_appinfo_get_list(handle, PM_SVC_APP, __app_list_cb, NULL);
1266         tryvm_if(ret < 0, ret = PKGMGR_R_EINVAL, "pkgmgr_appinfo_get_list : PM_SVC_APP fail");
1267
1268         /*check type    */
1269         ret = pkgmgr_pkginfo_get_type(handle, &pkgtype);
1270         tryvm_if(ret < 0, ret = PKGMGR_R_EINVAL, "pkgmgr_pkginfo_get_type fail");
1271         tryvm_if(pkgtype == NULL, ret = PKGMGR_R_ERROR, "pkgtype is NULL");
1272
1273         /*check pkgid length    */
1274         tryvm_if(strlen(pkgid) >= PKG_STRING_LEN_MAX, ret = PKGMGR_R_EINVAL, "pkgid is too long");
1275
1276         /* 2. get installer path using pkgtype */
1277         installer_path = _get_backend_path_with_type(pkgtype);
1278         tryvm_if(installer_path == NULL, ret = PKGMGR_R_EINVAL, "installer_path fail");
1279
1280         /* 3. generate req_key */
1281         req_key = __get_req_key(pkgid);
1282
1283         /* 4. add callback info - add callback info to pkgmgr_client */
1284         req_id = _get_request_id();
1285         __add_op_cbinfo(mpc, req_id, req_key, event_cb, data);
1286
1287         /* 5. generate argv */
1288
1289         /* argv[0] installer path */
1290         argv[argcnt++] = installer_path;
1291         /* argv[1] */
1292         argv[argcnt++] = strdup("-k");
1293         /* argv[2] */
1294         argv[argcnt++] = req_key;
1295         /* argv[3] */
1296         argv[argcnt++] = strdup("-d");
1297         /* argv[4] */
1298         argv[argcnt++] = strdup(pkgid);
1299         /* argv[5] -q option should be located at the end of command !! */
1300         if (mode == PM_QUIET)
1301                 argv[argcnt++] = strdup("-q");
1302
1303         /*** add quote in all string for special charactor like '\n'***   FIX */
1304         for (i = 0; i < argcnt; i++) {
1305                 temp = g_shell_quote(argv[i]);
1306                 len += (strlen(temp) + 1);
1307                 g_free(temp);
1308         }
1309
1310         args = (char *)calloc(len, sizeof(char));
1311         tryvm_if(args == NULL, ret = PKGMGR_R_ERROR, "calloc failed");
1312
1313         strncpy(args, argv[0], len - 1);
1314
1315         for (i = 1; i < argcnt; i++) {
1316                 strncat(args, " ", strlen(" "));
1317                 temp = g_shell_quote(argv[i]);
1318                 strncat(args, temp, strlen(temp));
1319                 g_free(temp);
1320         }
1321         _LOGD("[args] %s [len] %d\n", args, len);
1322         /******************* end of quote ************************/
1323
1324         /* 6. request install */
1325         ret = comm_client_request(mpc->info.request.cc, req_key, COMM_REQ_TO_INSTALLER, pkgtype, pkgid, args, cookie, 1);
1326         tryvm_if(ret < 0, ret = PKGMGR_R_ECOMM, "calloc failed");
1327
1328         for (i = 0; i < argcnt; i++)
1329                 free(argv[i]);
1330
1331         free(args);
1332
1333         pkgmgr_pkginfo_destroy_pkginfo(handle);
1334         return req_id;
1335
1336 catch:
1337         for (i = 0; i < argcnt; i++)
1338                 free(argv[i]);
1339
1340         if(args)
1341                 free(args);
1342
1343         pkgmgr_pkginfo_destroy_pkginfo(handle);
1344         PKGMGR_END();\
1345         return ret;
1346 }
1347
1348 API int pkgmgr_client_move(pkgmgr_client *pc, const char *pkg_type,
1349                                 const char *pkgid, pkgmgr_move_type move_type, pkgmgr_mode mode)
1350 {
1351         const char *pkgtype = NULL;
1352         char *installer_path = NULL;
1353         char *req_key = NULL;
1354         int i = 0;
1355         char *argv[PKG_ARGC_MAX] = { NULL, };
1356         char *args = NULL;
1357         int argcnt = 0;
1358         int len = 0;
1359         char *temp = NULL;
1360         int ret = 0;
1361         int req_id = 0;
1362         char *cookie = NULL;
1363         char buf[128] = {'\0'};
1364
1365         /* Check for NULL value of pc */
1366         if (pc == NULL) {
1367                 _LOGD("package manager client handle is NULL\n");
1368                 return PKGMGR_R_EINVAL;
1369         }
1370         pkgmgr_client_t *mpc = (pkgmgr_client_t *) pc;
1371         /*check the pc type */
1372         if (mpc->ctype != PC_REQUEST)
1373                 return PKGMGR_R_EINVAL;
1374
1375         /*check argument */
1376         if (pkgid == NULL)
1377                 return PKGMGR_R_EINVAL;
1378
1379         if (pkg_type == NULL) {
1380                 pkgtype = _get_pkg_type_from_desktop_file(pkgid);
1381                 if (pkgtype == NULL)
1382                         return PKGMGR_R_EINVAL;
1383         } else
1384                 pkgtype = pkg_type;
1385
1386         if (strlen(pkgid) >= PKG_STRING_LEN_MAX)
1387                 return PKGMGR_R_EINVAL;
1388
1389         if ((move_type < PM_MOVE_TO_INTERNAL) || (move_type > PM_MOVE_TO_SDCARD))
1390                 return PKGMGR_R_EINVAL;
1391
1392         /* get installer path using pkg_path */
1393         installer_path = _get_backend_path_with_type(pkgtype);
1394         if (installer_path == NULL)
1395                 return PKGMGR_R_EINVAL;
1396
1397         /* generate req_key */
1398         req_key = __get_req_key(pkgid);
1399         req_id = _get_request_id();
1400
1401         /* generate argv */
1402         snprintf(buf, 128, "%d", move_type);
1403         /* argv[0] installer path */
1404         argv[argcnt++] = installer_path;
1405         /* argv[1] */
1406         argv[argcnt++] = strdup("-k");
1407         /* argv[2] */
1408         argv[argcnt++] = req_key;
1409         /* argv[3] */
1410         argv[argcnt++] = strdup("-m");
1411         /* argv[4] */
1412         argv[argcnt++] = strdup(pkgid);
1413         /* argv[5] */
1414         argv[argcnt++] = strdup("-t");
1415         /* argv[6] */
1416         argv[argcnt++] = strdup(buf);
1417         /* argv[7] -q option should be located at the end of command !! */
1418         if (mode == PM_QUIET)
1419                 argv[argcnt++] = strdup("-q");
1420
1421         /*** add quote in all string for special charactor like '\n'***   FIX */
1422         for (i = 0; i < argcnt; i++) {
1423                 temp = g_shell_quote(argv[i]);
1424                 len += (strlen(temp) + 1);
1425                 g_free(temp);
1426         }
1427
1428         args = (char *)calloc(len, sizeof(char));
1429         if (args == NULL) {
1430                 _LOGD("calloc failed");
1431
1432                 for (i = 0; i < argcnt; i++)
1433                         free(argv[i]);
1434
1435                 return PKGMGR_R_ERROR;
1436         }
1437         strncpy(args, argv[0], len - 1);
1438
1439         for (i = 1; i < argcnt; i++) {
1440                 strncat(args, " ", strlen(" "));
1441                 temp = g_shell_quote(argv[i]);
1442                 strncat(args, temp, strlen(temp));
1443                 g_free(temp);
1444         }
1445         _LOGD("[args] %s [len] %d\n", args, len);
1446         /******************* end of quote ************************/
1447
1448         /* 6. request install */
1449         ret = comm_client_request(mpc->info.request.cc, req_key,
1450                                   COMM_REQ_TO_MOVER, pkgtype, pkgid,
1451                                   args, cookie, 1);
1452         if (ret < 0) {
1453                 _LOGE("request failed, ret=%d\n", ret);
1454
1455                 for (i = 0; i < argcnt; i++)
1456                         free(argv[i]);
1457
1458                 free(args);
1459                 return PKGMGR_R_ECOMM;
1460         }
1461
1462         for (i = 0; i < argcnt; i++)
1463                 free(argv[i]);
1464
1465         free(args);
1466
1467         return req_id;
1468 }
1469
1470 API int pkgmgr_client_activate(pkgmgr_client * pc, const char *pkg_type,
1471                                const char *pkgid)
1472 {
1473         const char *pkgtype;
1474         char *req_key;
1475         char *cookie = NULL;
1476         int ret;
1477         /* Check for NULL value of pc */
1478         if (pc == NULL) {
1479                 _LOGD("package manager client handle is NULL\n");
1480                 return PKGMGR_R_EINVAL;
1481         }
1482         pkgmgr_client_t *mpc = (pkgmgr_client_t *) pc;
1483
1484         /* 0. check the pc type */
1485         if (mpc->ctype != PC_REQUEST)
1486                 return PKGMGR_R_EINVAL;
1487
1488         /* 1. check argument */
1489         if (pkgid == NULL)
1490                 return PKGMGR_R_EINVAL;
1491
1492         if (pkg_type == NULL) {
1493                 pkgtype = _get_pkg_type_from_desktop_file(pkgid);
1494                 if (pkgtype == NULL)
1495                         return PKGMGR_R_EINVAL;
1496         } else
1497                 pkgtype = pkg_type;
1498
1499         if (strlen(pkgid) >= PKG_STRING_LEN_MAX)
1500                 return PKGMGR_R_EINVAL;
1501
1502         /* 2. generate req_key */
1503         req_key = __get_req_key(pkgid);
1504
1505         /* 3. request activate */
1506         ret = comm_client_request(mpc->info.request.cc, req_key,
1507                                   COMM_REQ_TO_ACTIVATOR, pkgtype,
1508                                   pkgid, "1 PKG", cookie, 1);
1509         if (ret < 0) {
1510                 _LOGE("request failed, ret=%d\n", ret);
1511                 free(req_key);
1512                 return PKGMGR_R_ECOMM;
1513         }
1514
1515         free(req_key);
1516
1517         return PKGMGR_R_OK;
1518 }
1519
1520 API int pkgmgr_client_deactivate(pkgmgr_client *pc, const char *pkg_type,
1521                                  const char *pkgid)
1522 {
1523         const char *pkgtype;
1524         char *req_key;
1525         char *cookie = NULL;
1526         int ret;
1527         /* Check for NULL value of pc */
1528         if (pc == NULL) {
1529                 _LOGD("package manager client handle is NULL\n");
1530                 return PKGMGR_R_EINVAL;
1531         }
1532         pkgmgr_client_t *mpc = (pkgmgr_client_t *) pc;
1533
1534         /* 0. check the pc type */
1535         if (mpc->ctype != PC_REQUEST)
1536                 return PKGMGR_R_EINVAL;
1537
1538         /* 1. check argument */
1539         if (pkgid == NULL)
1540                 return PKGMGR_R_EINVAL;
1541
1542         if (pkg_type == NULL) {
1543                 pkgtype = _get_pkg_type_from_desktop_file(pkgid);
1544                 if (pkgtype == NULL)
1545                         return PKGMGR_R_EINVAL;
1546         } else
1547                 pkgtype = pkg_type;
1548
1549         if (strlen(pkgid) >= PKG_STRING_LEN_MAX)
1550                 return PKGMGR_R_EINVAL;
1551
1552         /* 2. generate req_key */
1553         req_key = __get_req_key(pkgid);
1554
1555         /* 3. request activate */
1556         ret = comm_client_request(mpc->info.request.cc, req_key,
1557                                   COMM_REQ_TO_ACTIVATOR, pkgtype,
1558                                   pkgid, "0 PKG", cookie, 1);
1559         if (ret < 0) {
1560                 _LOGE("request failed, ret=%d\n", ret);
1561                 free(req_key);
1562                 return PKGMGR_R_ECOMM;
1563         }
1564
1565         free(req_key);
1566
1567         return PKGMGR_R_OK;
1568 }
1569
1570 API int pkgmgr_client_activate_app(pkgmgr_client * pc, const char *appid)
1571 {
1572         const char *pkgtype;
1573         char *req_key;
1574         char *cookie = NULL;
1575         int ret;
1576         /* Check for NULL value of pc */
1577         if (pc == NULL) {
1578                 _LOGD("package manager client handle is NULL\n");
1579                 return PKGMGR_R_EINVAL;
1580         }
1581         pkgmgr_client_t *mpc = (pkgmgr_client_t *) pc;
1582
1583         /* 0. check the pc type */
1584         if (mpc->ctype != PC_REQUEST)
1585                 return PKGMGR_R_EINVAL;
1586
1587         /* 1. check argument */
1588         if (appid == NULL)
1589                 return PKGMGR_R_EINVAL;
1590
1591         if (strlen(appid) >= PKG_STRING_LEN_MAX)
1592                 return PKGMGR_R_EINVAL;
1593
1594         pkgtype = _get_pkg_type_from_desktop_file(appid);
1595
1596         /* 2. generate req_key */
1597         req_key = __get_req_key(appid);
1598
1599         /* 3. request activate */
1600         ret = comm_client_request(mpc->info.request.cc, req_key,
1601                                   COMM_REQ_TO_ACTIVATOR, pkgtype,
1602                                   appid, "1 APP", cookie, 1);
1603         if (ret < 0) {
1604                 _LOGE("request failed, ret=%d\n", ret);
1605                 free(req_key);
1606                 return PKGMGR_R_ECOMM;
1607         }
1608
1609         free(req_key);
1610
1611         return PKGMGR_R_OK;
1612 }
1613
1614 API int pkgmgr_client_activate_appv(pkgmgr_client * pc, const char *appid, char *const argv[])
1615 {
1616         const char *pkgtype;
1617         char *req_key;
1618         char *cookie = NULL;
1619         int ret;
1620         int i = 0;
1621         char *temp = NULL;
1622         int len = 0;
1623         int argcnt = 0;
1624         char *args = NULL;
1625         char *argsr = NULL;
1626         /* Check for NULL value of pc */
1627         if (pc == NULL) {
1628                 _LOGD("package manager client handle is NULL\n");
1629                 return PKGMGR_R_EINVAL;
1630         }
1631         pkgmgr_client_t *mpc = (pkgmgr_client_t *) pc;
1632
1633         /* 0. check the pc type */
1634         if (mpc->ctype != PC_REQUEST)
1635                 return PKGMGR_R_EINVAL;
1636
1637         /* 1. check argument */
1638         if (appid == NULL)
1639                 return PKGMGR_R_EINVAL;
1640
1641         if (strlen(appid) >= PKG_STRING_LEN_MAX)
1642                 return PKGMGR_R_EINVAL;
1643
1644         pkgtype = _get_pkg_type_from_desktop_file(appid);
1645
1646         /* 2. generate req_key */
1647         req_key = __get_req_key(appid);
1648
1649         /*** add quote in all string for special charactor like '\n'***   FIX */
1650         if (argv) {
1651                 for (i = 0; argv[i]; i++) {
1652                         temp = g_shell_quote(argv[i]);
1653                         len += (strlen(temp) + 1);
1654                         g_free(temp);
1655                         argcnt++;
1656                 }
1657
1658                 if (argcnt) {
1659                         args = (char *)calloc(len, sizeof(char));
1660                         if (args == NULL) {
1661                                 _LOGE("calloc failed");
1662                                 free(req_key);
1663                                 return PKGMGR_R_ERROR;
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                 }
1674         }
1675
1676         argsr = (char *)calloc(strlen("1 APP")+2+len, sizeof(char));
1677         if (argsr == NULL) {
1678                 _LOGE("calloc failed");
1679                 free(req_key);
1680                 free(args);
1681                 return PKGMGR_R_ERROR;
1682         }
1683         strncpy(argsr, "1 APP", strlen("1 APP"));
1684         if (argcnt) {
1685                 strncat(argsr, " ", strlen(" "));
1686                 strncat(argsr, args, strlen(args));
1687         }
1688
1689         _LOGD("argsr [%s]\n", argsr);
1690         /******************* end of quote ************************/
1691
1692         /* 3. request activate */
1693         ret = comm_client_request(mpc->info.request.cc, req_key,
1694                                   COMM_REQ_TO_ACTIVATOR, pkgtype,
1695                                   appid, argsr, cookie, 1);
1696         if (ret < 0) {
1697                 _LOGE("request failed, ret=%d\n", ret);
1698                 free(req_key);
1699                 free(args);
1700                 free(argsr);
1701                 return PKGMGR_R_ECOMM;
1702         }
1703
1704         free(req_key);
1705         free(args);
1706         free(argsr);
1707
1708         return PKGMGR_R_OK;
1709 }
1710
1711 API int pkgmgr_client_deactivate_app(pkgmgr_client *pc, const char *appid)
1712 {
1713         const char *pkgtype;
1714         char *req_key;
1715         char *cookie = NULL;
1716         int ret;
1717         /* Check for NULL value of pc */
1718         if (pc == NULL) {
1719                 _LOGD("package manager client handle is NULL\n");
1720                 return PKGMGR_R_EINVAL;
1721         }
1722         pkgmgr_client_t *mpc = (pkgmgr_client_t *) pc;
1723
1724         /* 0. check the pc type */
1725         if (mpc->ctype != PC_REQUEST)
1726                 return PKGMGR_R_EINVAL;
1727
1728         /* 1. check argument */
1729         if (appid == NULL)
1730                 return PKGMGR_R_EINVAL;
1731
1732         if (strlen(appid) >= PKG_STRING_LEN_MAX)
1733                 return PKGMGR_R_EINVAL;
1734
1735         pkgtype = _get_pkg_type_from_desktop_file(appid);
1736
1737         /* 2. generate req_key */
1738         req_key = __get_req_key(appid);
1739
1740         /* 3. request activate */
1741         ret = comm_client_request(mpc->info.request.cc, req_key,
1742                                   COMM_REQ_TO_ACTIVATOR, pkgtype,
1743                                   appid, "0 APP", cookie, 1);
1744         if (ret < 0) {
1745                 _LOGE("request failed, ret=%d\n", ret);
1746                 free(req_key);
1747                 return PKGMGR_R_ECOMM;
1748         }
1749
1750         free(req_key);
1751
1752         return PKGMGR_R_OK;
1753 }
1754
1755
1756 API int pkgmgr_client_clear_user_data(pkgmgr_client *pc, const char *pkg_type,
1757                                       const char *appid, pkgmgr_mode mode)
1758 {
1759         const char *pkgtype;
1760         char *installer_path;
1761         char *req_key;
1762         int i = 0;
1763         char *argv[PKG_ARGC_MAX] = { NULL, };
1764         char *args = NULL;
1765         int argcnt = 0;
1766         int len = 0;
1767         char *temp = NULL;
1768         int ret;
1769         char *cookie = NULL;
1770
1771         /* Check for NULL value of pc */
1772         if (pc == NULL) {
1773                 _LOGD("package manager client handle is NULL\n");
1774                 return PKGMGR_R_EINVAL;
1775         }
1776         pkgmgr_client_t *mpc = (pkgmgr_client_t *) pc;
1777
1778         /* 0. check the pc type */
1779         if (mpc->ctype != PC_REQUEST)
1780                 return PKGMGR_R_EINVAL;
1781
1782         /* 1. check argument */
1783         if (appid == NULL)
1784                 return PKGMGR_R_EINVAL;
1785
1786
1787         if (pkg_type == NULL) {
1788                 pkgtype = _get_pkg_type_from_desktop_file(appid);
1789                 if (pkgtype == NULL)
1790                         return PKGMGR_R_EINVAL;
1791         } else
1792                 pkgtype = pkg_type;
1793
1794         if (strlen(appid) >= PKG_STRING_LEN_MAX)
1795                 return PKGMGR_R_EINVAL;
1796
1797         /* 2. get installer path using pkg_path */
1798         installer_path = _get_backend_path_with_type(pkgtype);
1799         if (installer_path == NULL)
1800                 return PKGMGR_R_EINVAL;
1801
1802         /* 3. generate req_key */
1803         req_key = __get_req_key(appid);
1804
1805         /* 4. generate argv */
1806
1807         /* argv[0] installer path */
1808         argv[argcnt++] = installer_path;
1809         /* argv[1] */
1810         argv[argcnt++] = strdup("-k");
1811         /* argv[2] */
1812         argv[argcnt++] = req_key;
1813         /* argv[3] */
1814         argv[argcnt++] = strdup("-c");
1815         /* argv[4] */
1816         argv[argcnt++] = strdup(appid);
1817         /* argv[5] -q option should be located at the end of command !! */
1818         if (mode == PM_QUIET)
1819                 argv[argcnt++] = strdup("-q");
1820
1821         /*** add quote in all string for special charactor like '\n'***   FIX */
1822         for (i = 0; i < argcnt; i++) {
1823                 temp = g_shell_quote(argv[i]);
1824                 len += (strlen(temp) + 1);
1825                 g_free(temp);
1826         }
1827
1828         args = (char *)calloc(len, sizeof(char));
1829         if (args == NULL) {
1830                 _LOGD("calloc failed");
1831
1832                 for (i = 0; i < argcnt; i++)
1833                         free(argv[i]);
1834
1835                 return PKGMGR_R_ERROR;
1836         }
1837         strncpy(args, argv[0], len - 1);
1838
1839         for (i = 1; i < argcnt; i++) {
1840                 strncat(args, " ", strlen(" "));
1841                 temp = g_shell_quote(argv[i]);
1842                 strncat(args, temp, strlen(temp));
1843                 g_free(temp);
1844         }
1845         _LOGD("[args] %s [len] %d\n", args, len);
1846         /******************* end of quote ************************/
1847
1848         /* 6. request clear */
1849         ret = comm_client_request(mpc->info.request.cc, req_key,
1850                                   COMM_REQ_TO_CLEARER, pkgtype, appid,
1851                                   args, cookie, 1);
1852         if (ret < 0) {
1853                 _LOGE("request failed, ret=%d\n", ret);
1854
1855                 for (i = 0; i < argcnt; i++)
1856                         free(argv[i]);
1857
1858                 free(args);
1859                 return PKGMGR_R_ECOMM;
1860         }
1861
1862         for (i = 0; i < argcnt; i++)
1863                 free(argv[i]);
1864
1865         free(args);
1866
1867         return PKGMGR_R_OK;
1868 }
1869
1870 API int pkgmgr_client_listen_status(pkgmgr_client *pc, pkgmgr_handler event_cb,
1871                                     void *data)
1872 {
1873         int req_id;
1874         /* Check for NULL value of pc */
1875         if (pc == NULL) {
1876                 _LOGD("package manager client handle is NULL\n");
1877                 return PKGMGR_R_EINVAL;
1878         }
1879         pkgmgr_client_t *mpc = (pkgmgr_client_t *) pc;
1880
1881         /* 0. check the pc type */
1882         if (mpc->ctype != PC_LISTENING)
1883                 return PKGMGR_R_EINVAL;
1884
1885         /* 1. check argument */
1886         if (event_cb == NULL)
1887                 return PKGMGR_R_EINVAL;
1888
1889         /* 2. add callback info to pkgmgr_client */
1890         req_id = _get_request_id();
1891         __add_stat_cbinfo(mpc, req_id, event_cb, data);
1892
1893         return req_id;
1894 }
1895
1896 API int pkgmgr_client_broadcast_status(pkgmgr_client *pc, const char *pkg_type,
1897                                        const char *pkgid, const char *key,
1898                                        const char *val)
1899 {
1900         /* Check for NULL value of pc */
1901         if (pc == NULL) {
1902                 _LOGD("package manager client handle is NULL\n");
1903                 return PKGMGR_R_EINVAL;
1904         }
1905         /* Check for valid arguments. NULL parameter causes DBUS to abort */
1906         if (pkgid == NULL || pkg_type == NULL || key == NULL || val == NULL) {
1907                 _LOGD("Argument supplied is NULL\n");
1908                 return PKGMGR_R_EINVAL;
1909         }
1910         pkgmgr_client_t *mpc = (pkgmgr_client_t *) pc;
1911
1912         /* 0. check the pc type */
1913         if (mpc->ctype != PC_BROADCAST)
1914                 return PKGMGR_R_EINVAL;
1915
1916         comm_status_broadcast_server_send_signal(mpc->info.broadcast.bc,
1917                                                  PKG_STATUS, pkg_type,
1918                                                  pkgid, key, val);
1919
1920         return PKGMGR_R_OK;
1921 }
1922
1923 API pkgmgr_info *pkgmgr_client_check_pkginfo_from_file(const char *pkg_path)
1924 {
1925         return pkgmgr_info_new_from_file(NULL, pkg_path);
1926 }
1927
1928 API int pkgmgr_client_free_pkginfo(pkgmgr_info * pkg_info)
1929 {
1930         if (pkg_info == NULL)
1931                 return PKGMGR_R_EINVAL;
1932
1933         package_manager_pkg_detail_info_t *info = (package_manager_pkg_detail_info_t *)pkg_info;
1934
1935         if (info->icon_buf)
1936                 free(info->icon_buf);
1937
1938         free(info);
1939         info = NULL;
1940
1941         return PKGMGR_R_OK;
1942 }
1943
1944 API int pkgmgr_client_request_service(pkgmgr_request_service_type service_type, int service_mode,
1945                                   pkgmgr_client * pc, const char *pkg_type, const char *pkgid,
1946                               const char *custom_info, pkgmgr_handler event_cb, void *data)
1947 {
1948         int ret =0;
1949
1950         /* Check for NULL value of service type */
1951         retvm_if(service_type > PM_REQUEST_MAX, PKGMGR_R_EINVAL, "service type is not defined\n");
1952         retvm_if(service_type < 0, PKGMGR_R_EINVAL, "service type is error\n");
1953
1954         switch (service_type) {
1955         case PM_REQUEST_CSC:
1956                 tryvm_if(custom_info == NULL, ret = PKGMGR_R_EINVAL, "custom_info is NULL\n");
1957                 tryvm_if(strlen(custom_info) >= PKG_STRING_LEN_MAX, ret = PKGMGR_R_EINVAL, "optional_file over PKG_STRING_LEN_MAX");
1958                 tryvm_if(data == NULL, ret = PKGMGR_R_EINVAL, "data is NULL\n");
1959
1960                 ret = __csc_process(custom_info, (char *)data);
1961                 if (ret < 0)
1962                         _LOGE("__csc_process fail \n");
1963                 else
1964                         ret = PKGMGR_R_OK;
1965
1966                 break;
1967
1968         case PM_REQUEST_MOVE:
1969                 tryvm_if(pkgid == NULL, ret = PKGMGR_R_EINVAL, "pkgid is NULL\n");
1970                 tryvm_if(pc == NULL, ret = PKGMGR_R_EINVAL, "pc is NULL\n");
1971                 tryvm_if((service_mode < PM_MOVE_TO_INTERNAL) || (service_mode > PM_MOVE_TO_SDCARD), ret = PKGMGR_R_EINVAL, "service_mode is wrong\n");
1972
1973                 ret = __move_pkg_process(pc, pkgid, (pkgmgr_move_type)service_mode, event_cb, data);
1974                 break;
1975
1976         case PM_REQUEST_GET_SIZE:
1977                 tryvm_if(pkgid == NULL, ret = PKGMGR_R_EINVAL, "pkgid is NULL\n");
1978                 tryvm_if(pc == NULL, ret = PKGMGR_R_EINVAL, "pc is NULL\n");
1979                 tryvm_if((service_mode < PM_GET_TOTAL_SIZE) || (service_mode > PM_GET_DATA_SIZE), ret = PKGMGR_R_EINVAL, "service_mode is wrong\n");
1980
1981                 ret = __get_size_process(pc, pkgid, (pkgmgr_getsize_type)service_mode, event_cb, data);
1982                 break;
1983
1984         case PM_REQUEST_KILL_APP:
1985                 tryvm_if(pkgid == NULL, ret = PKGMGR_R_EINVAL, "pkgid is NULL\n");
1986                 tryvm_if(pc == NULL, ret = PKGMGR_R_EINVAL, "pc is NULL\n");
1987
1988                 ret = __kill_app_process(pc, pkgid);
1989                 if (ret < 0)
1990                         _LOGE("__kill_app_process fail \n");
1991                 else
1992                         ret = PKGMGR_R_OK;
1993
1994                 break;
1995
1996         default:
1997                 _LOGE("Wrong Request\n");
1998                 ret = -1;
1999                 break;
2000         }
2001
2002 catch:
2003
2004         return ret;
2005 }
2006
2007
2008 #define __START_OF_OLD_API
2009 ail_cb_ret_e __appinfo_func(const ail_appinfo_h appinfo, void *user_data)
2010 {
2011         char *type;
2012         char *package;
2013         char *version;
2014
2015         iter_data *udata = (iter_data *) user_data;
2016
2017         ail_appinfo_get_str(appinfo, AIL_PROP_X_SLP_PACKAGETYPE_STR, &type);
2018         if (type == NULL)
2019                 type = "";
2020         ail_appinfo_get_str(appinfo, AIL_PROP_PACKAGE_STR, &package);
2021         if (package == NULL)
2022                 package = "";
2023         ail_appinfo_get_str(appinfo, AIL_PROP_VERSION_STR, &version);
2024         if (version == NULL)
2025                 version = "";
2026
2027         if (udata->iter_fn(type, package, version, udata->data) != 0)
2028                 return AIL_CB_RET_CANCEL;
2029
2030         return AIL_CB_RET_CONTINUE;
2031 }
2032
2033 API int pkgmgr_get_pkg_list(pkgmgr_iter_fn iter_fn, void *data)
2034 {
2035         int cnt = -1;
2036         ail_filter_h filter;
2037         ail_error_e ret;
2038
2039         if (iter_fn == NULL)
2040                 return PKGMGR_R_EINVAL;
2041
2042         ret = ail_filter_new(&filter);
2043         if (ret != AIL_ERROR_OK) {
2044                 return PKGMGR_R_ERROR;
2045         }
2046
2047         ret = ail_filter_add_str(filter, AIL_PROP_TYPE_STR, "Application");
2048         if (ret != AIL_ERROR_OK) {
2049                 ail_filter_destroy(filter);
2050                 return PKGMGR_R_ERROR;
2051         }
2052
2053         ret = ail_filter_add_bool(filter, AIL_PROP_X_SLP_REMOVABLE_BOOL, true);
2054         if (ret != AIL_ERROR_OK) {
2055                 ail_filter_destroy(filter);
2056                 return PKGMGR_R_ERROR;
2057         }
2058
2059         ret = ail_filter_count_appinfo(filter, &cnt);
2060         if (ret != AIL_ERROR_OK) {
2061                 ail_filter_destroy(filter);
2062                 return PKGMGR_R_ERROR;
2063         }
2064
2065         iter_data *udata = calloc(1, sizeof(iter_data));
2066         if (udata == NULL) {
2067                 _LOGE("calloc failed");
2068                 ail_filter_destroy(filter);
2069
2070                 return PKGMGR_R_ERROR;
2071         }
2072         udata->iter_fn = iter_fn;
2073         udata->data = data;
2074
2075         ail_filter_list_appinfo_foreach(filter, __appinfo_func, udata);
2076
2077         free(udata);
2078
2079         ret = ail_filter_destroy(filter);
2080         if (ret != AIL_ERROR_OK) {
2081                 return PKGMGR_R_ERROR;
2082         }
2083
2084         return PKGMGR_R_OK;
2085 }
2086
2087 API pkgmgr_info *pkgmgr_info_new(const char *pkg_type, const char *pkgid)
2088 {
2089         const char *pkgtype;
2090         pkg_plugin_set *plugin_set = NULL;
2091         package_manager_pkg_detail_info_t *pkg_detail_info = NULL;
2092
2093         /* 1. check argument */
2094         if (pkgid == NULL)
2095                 return NULL;
2096
2097         if (pkg_type == NULL) {
2098                 pkgtype = _get_pkg_type_from_desktop_file(pkgid);
2099                 if (pkgtype == NULL)
2100                         return NULL;
2101         } else
2102                 pkgtype = pkg_type;
2103
2104         if (strlen(pkgid) >= PKG_STRING_LEN_MAX)
2105                 return NULL;
2106
2107         pkg_detail_info = calloc(1, sizeof(package_manager_pkg_detail_info_t));
2108         if (pkg_detail_info == NULL) {
2109                 _LOGE("*** Failed to alloc package_handler_info.\n");
2110                 return NULL;
2111         }
2112
2113         plugin_set = _package_manager_load_library(pkgtype);
2114         if (plugin_set == NULL) {
2115                 _LOGE("*** Failed to load library");
2116                 free(pkg_detail_info);
2117                 return NULL;
2118         }
2119
2120         if (plugin_set->pkg_is_installed) {
2121                 if (plugin_set->pkg_is_installed(pkgid) != 0) {
2122                         _LOGE("*** Failed to call pkg_is_installed()");
2123                         free(pkg_detail_info);
2124                         return NULL;
2125                 }
2126
2127                 if (plugin_set->get_pkg_detail_info) {
2128                         if (plugin_set->get_pkg_detail_info(pkgid,
2129                                                             pkg_detail_info) != 0) {
2130                                 _LOGE("*** Failed to call get_pkg_detail_info()");
2131                                 free(pkg_detail_info);
2132                                 return NULL;
2133                         }
2134                 }
2135         }
2136
2137         return (pkgmgr_info *) pkg_detail_info;
2138 }
2139
2140 API char * pkgmgr_info_get_string(pkgmgr_info * pkg_info, const char *key)
2141 {
2142         package_manager_pkg_detail_info_t *pkg_detail_info;
2143
2144         if (pkg_info == NULL)
2145                 return NULL;
2146         if (key == NULL)
2147                 return NULL;
2148
2149         pkg_detail_info = (package_manager_pkg_detail_info_t *) pkg_info;
2150
2151         return _get_info_string(key, pkg_detail_info);
2152 }
2153
2154 API pkgmgr_info *pkgmgr_info_new_from_file(const char *pkg_type,
2155                                            const char *pkg_path)
2156 {
2157         pkg_plugin_set *plugin_set = NULL;
2158         package_manager_pkg_detail_info_t *pkg_detail_info = NULL;
2159         char *pkgtype;
2160         if (pkg_path == NULL) {
2161                 _LOGE("pkg_path is NULL\n");
2162                 return NULL;
2163         }
2164
2165         if (strlen(pkg_path) > PKG_URL_STRING_LEN_MAX) {
2166                 _LOGE("length of pkg_path is too long - %d.\n",
2167                       strlen(pkg_path));
2168                 return NULL;
2169         }
2170
2171         pkg_detail_info = calloc(1, sizeof(package_manager_pkg_detail_info_t));
2172         if (pkg_detail_info == NULL) {
2173                 _LOGE("*** Failed to alloc package_handler_info.\n");
2174                 return NULL;
2175         }
2176
2177         if (pkg_type == NULL)
2178                 pkgtype = __get_type_from_path(pkg_path);
2179         else
2180                 pkgtype = strdup(pkg_type);
2181
2182         plugin_set = _package_manager_load_library(pkgtype);
2183         if (plugin_set == NULL) {
2184                 free(pkg_detail_info);
2185                 free(pkgtype);
2186                 return NULL;
2187         }
2188
2189         if (plugin_set->get_pkg_detail_info_from_package) {
2190                 if (plugin_set->get_pkg_detail_info_from_package(pkg_path,
2191                                                                  pkg_detail_info) != 0) {
2192                         free(pkg_detail_info);
2193                         free(pkgtype);
2194                         return NULL;
2195                 }
2196         }
2197
2198         free(pkgtype);
2199         return (pkgmgr_info *) pkg_detail_info;
2200 }
2201
2202 API int pkgmgr_info_free(pkgmgr_info * pkg_info)
2203 {
2204         if (pkg_info == NULL)
2205                 return PKGMGR_R_EINVAL;
2206
2207         free(pkg_info);
2208         pkg_info = NULL;
2209
2210         return 0;
2211 }
2212
2213 #define __END_OF_OLD_API
2214
2215 API int pkgmgr_pkginfo_get_list(pkgmgr_info_pkg_list_cb pkg_list_cb, void *user_data)
2216 {
2217         int ret = 0;
2218         ret = pkgmgrinfo_pkginfo_get_list(pkg_list_cb, user_data);
2219         return ret;
2220 }
2221
2222 API int pkgmgr_pkginfo_get_pkginfo(const char *pkgid, pkgmgr_pkginfo_h *handle)
2223 {
2224         int ret = 0;
2225         ret = pkgmgrinfo_pkginfo_get_pkginfo(pkgid, handle);
2226         return ret;
2227 }
2228
2229 API int pkgmgr_pkginfo_get_pkgname(pkgmgr_pkginfo_h handle, char **pkg_name)
2230 {
2231         int ret = 0;
2232         ret = pkgmgrinfo_pkginfo_get_pkgname(handle, pkg_name);
2233         return ret;
2234 }
2235
2236
2237 API int pkgmgr_pkginfo_get_pkgid(pkgmgr_pkginfo_h handle, char **pkgid)
2238 {
2239         int ret = 0;
2240         ret = pkgmgrinfo_pkginfo_get_pkgid(handle, pkgid);
2241         return ret;
2242 }
2243
2244 API int pkgmgr_pkginfo_get_type(pkgmgr_pkginfo_h handle, char **type)
2245 {
2246         int ret = 0;
2247         ret = pkgmgrinfo_pkginfo_get_type(handle, type);
2248         return ret;
2249 }
2250
2251 API int pkgmgr_pkginfo_get_version(pkgmgr_pkginfo_h handle, char **version)
2252 {
2253         int ret = 0;
2254         ret = pkgmgrinfo_pkginfo_get_version(handle, version);
2255         return ret;
2256 }
2257
2258 API int pkgmgr_pkginfo_get_install_location(pkgmgr_pkginfo_h handle, pkgmgr_install_location *location)
2259 {
2260         int ret = 0;
2261         pkgmgrinfo_install_location loc;
2262         ret = pkgmgrinfo_pkginfo_get_install_location(handle, &loc);
2263         *location = loc;
2264         return ret;
2265 }
2266
2267 API int pkgmgr_pkginfo_get_package_size(pkgmgr_pkginfo_h handle, int *size)
2268 {
2269         int ret = 0;
2270         ret = pkgmgrinfo_pkginfo_get_package_size(handle, size);
2271         return ret;
2272 }
2273
2274 API int pkgmgr_pkginfo_get_icon(pkgmgr_pkginfo_h handle, char **icon)
2275 {
2276         int ret = 0;
2277         ret = pkgmgrinfo_pkginfo_get_icon(handle, icon);
2278         return ret;
2279 }
2280
2281 API int pkgmgr_pkginfo_get_label(pkgmgr_pkginfo_h handle, char **label)
2282 {
2283         int ret = 0;
2284         ret = pkgmgrinfo_pkginfo_get_label(handle, label);
2285         return ret;
2286 }
2287
2288 API int pkgmgr_pkginfo_get_description(pkgmgr_pkginfo_h handle, char **description)
2289 {
2290         int ret = 0;
2291         ret = pkgmgrinfo_pkginfo_get_description(handle, description);
2292         return ret;
2293 }
2294
2295 API int pkgmgr_pkginfo_get_author_name(pkgmgr_pkginfo_h handle, char **author_name)
2296 {
2297         int ret = 0;
2298         ret = pkgmgrinfo_pkginfo_get_author_name(handle, author_name);
2299         return ret;
2300 }
2301
2302 API int pkgmgr_pkginfo_get_author_email(pkgmgr_pkginfo_h handle, char **author_email)
2303 {
2304         int ret = 0;
2305         ret = pkgmgrinfo_pkginfo_get_author_email(handle, author_email);
2306         return ret;
2307 }
2308
2309 API int pkgmgr_pkginfo_get_author_href(pkgmgr_pkginfo_h handle, char **author_href)
2310 {
2311         int ret = 0;
2312         ret = pkgmgrinfo_pkginfo_get_author_href(handle, author_href);
2313         return ret;
2314 }
2315
2316 API int pkgmgr_pkginfo_is_removable(pkgmgr_pkginfo_h handle, bool *removable)
2317 {
2318         int ret = 0;
2319         ret = pkgmgrinfo_pkginfo_is_removable(handle, removable);
2320         return ret;
2321 }
2322
2323 API int pkgmgr_pkginfo_is_preload(pkgmgr_pkginfo_h handle, bool *preload)
2324 {
2325         int ret = 0;
2326         ret = pkgmgrinfo_pkginfo_is_preload(handle, preload);
2327         return ret;
2328 }
2329
2330 API int pkgmgr_pkginfo_is_readonly(pkgmgr_pkginfo_h handle, bool *readonly)
2331 {
2332         int ret = 0;
2333         ret = pkgmgrinfo_pkginfo_is_readonly(handle, readonly);
2334         return ret;
2335 }
2336
2337 API int pkgmgr_pkginfo_is_accessible(pkgmgr_pkginfo_h handle, bool *accessible)
2338 {
2339         int ret = 0;
2340         ret = pkgmgrinfo_pkginfo_is_accessible(handle, accessible);
2341         return ret;
2342 }
2343
2344 API int pkgmgr_pkginfo_destroy_pkginfo(pkgmgr_pkginfo_h handle)
2345 {
2346         int ret = 0;
2347         ret = pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
2348         return ret;
2349 }
2350
2351 API int pkgmgr_pkginfo_get_installed_storage(pkgmgr_pkginfo_h handle, pkgmgr_installed_storage *storage)
2352 {
2353         int ret = 0;
2354         pkgmgrinfo_installed_storage sto;
2355         ret = pkgmgrinfo_pkginfo_get_installed_storage(handle, &sto);
2356         *storage = sto;
2357         return ret;
2358 }
2359
2360 API int pkgmgr_pkginfo_get_installed_time(pkgmgr_pkginfo_h handle, int *installed_time)
2361 {
2362         int ret = 0;
2363         ret = pkgmgrinfo_pkginfo_get_installed_time(handle, installed_time);
2364         return ret;
2365 }
2366
2367 API int pkgmgr_appinfo_get_list(pkgmgr_pkginfo_h handle, pkgmgr_app_component component,
2368                                                         pkgmgr_info_app_list_cb app_func, void *user_data)
2369 {
2370         int ret = 0;
2371         ret = pkgmgrinfo_appinfo_get_list(handle, component, app_func, user_data);
2372         return ret;
2373 }
2374
2375 API int pkgmgr_appinfo_foreach_category(pkgmgr_appinfo_h handle, pkgmgr_info_app_category_list_cb category_func,
2376                                                         void *user_data)
2377 {
2378         int ret = 0;
2379         ret = pkgmgrinfo_appinfo_foreach_category(handle, category_func, user_data);
2380         return ret;
2381 }
2382
2383 API int pkgmgr_appinfo_get_appinfo(const char *appid, pkgmgr_appinfo_h *handle)
2384 {
2385         int ret = 0;
2386         ret = pkgmgrinfo_appinfo_get_appinfo(appid, handle);
2387         return ret;
2388 }
2389
2390 API int pkgmgr_appinfo_get_appid(pkgmgr_appinfo_h  handle, char **appid)
2391 {
2392         int ret = 0;
2393         ret = pkgmgrinfo_appinfo_get_appid(handle, appid);
2394         return ret;
2395 }
2396
2397 API int pkgmgr_appinfo_get_pkgname(pkgmgr_appinfo_h  handle, char **pkg_name)
2398 {
2399         int ret = 0;
2400         ret = pkgmgrinfo_appinfo_get_pkgname(handle, pkg_name);
2401         return ret;
2402 }
2403
2404 API int pkgmgr_appinfo_get_pkgid(pkgmgr_appinfo_h  handle, char **pkgid)
2405 {
2406         int ret = 0;
2407         ret = pkgmgrinfo_appinfo_get_pkgid(handle, pkgid);
2408         return ret;
2409 }
2410
2411 API int pkgmgr_appinfo_get_icon(pkgmgr_appinfo_h handle, char **icon)
2412 {
2413         int ret = 0;
2414         ret = pkgmgrinfo_appinfo_get_icon(handle, icon);
2415         return ret;
2416 }
2417
2418 API int pkgmgr_appinfo_get_label(pkgmgr_appinfo_h handle, char **label)
2419 {
2420         int ret = 0;
2421         ret = pkgmgrinfo_appinfo_get_label(handle, label);
2422         return ret;
2423 }
2424
2425 API int pkgmgr_appinfo_get_exec(pkgmgr_appinfo_h  handle, char **exec)
2426 {
2427         int ret = 0;
2428         ret = pkgmgrinfo_appinfo_get_exec(handle, exec);
2429         return ret;
2430 }
2431
2432 API int pkgmgr_appinfo_get_component(pkgmgr_appinfo_h  handle, pkgmgr_app_component *component)
2433 {
2434         int ret = 0;
2435         pkgmgrinfo_app_component comp;
2436         ret = pkgmgrinfo_appinfo_get_component(handle, &comp);
2437         *component = comp;
2438         return ret;
2439 }
2440
2441 API int pkgmgr_appinfo_get_apptype(pkgmgr_appinfo_h  handle, char **app_type)
2442 {
2443         int ret = 0;
2444         ret = pkgmgrinfo_appinfo_get_apptype(handle, app_type);
2445         return ret;
2446 }
2447
2448 API int pkgmgr_appinfo_is_nodisplay(pkgmgr_appinfo_h  handle, bool *nodisplay)
2449 {
2450         int ret = 0;
2451         ret = pkgmgrinfo_appinfo_is_nodisplay(handle, nodisplay);
2452         return ret;
2453 }
2454
2455 API int pkgmgr_appinfo_is_multiple(pkgmgr_appinfo_h  handle, bool *multiple)
2456 {
2457         int ret = 0;
2458         ret = pkgmgrinfo_appinfo_is_multiple(handle, multiple);
2459         return ret;
2460 }
2461
2462 API int pkgmgr_appinfo_is_taskmanage(pkgmgr_appinfo_h  handle, bool *taskmanage)
2463 {
2464         int ret = 0;
2465         ret = pkgmgrinfo_appinfo_is_taskmanage(handle, taskmanage);
2466         return ret;
2467 }
2468
2469 API int pkgmgr_appinfo_get_hwacceleration(pkgmgr_appinfo_h  handle, pkgmgr_hwacceleration_type *hwacceleration)
2470 {
2471         int ret = 0;
2472         pkgmgrinfo_app_hwacceleration hwacc;
2473         ret = pkgmgrinfo_appinfo_get_hwacceleration(handle, &hwacc);
2474         *hwacceleration = hwacc;
2475         return ret;
2476 }
2477
2478 API int pkgmgr_appinfo_is_onboot(pkgmgr_appinfo_h  handle, bool *onboot)
2479 {
2480         int ret = 0;
2481         ret = pkgmgrinfo_appinfo_is_onboot(handle, onboot);
2482         return ret;
2483 }
2484
2485 API int pkgmgr_appinfo_is_autorestart(pkgmgr_appinfo_h  handle, bool *autorestart)
2486 {
2487         int ret = 0;
2488         ret = pkgmgrinfo_appinfo_is_autorestart(handle, autorestart);
2489         return ret;
2490 }
2491
2492 API int pkgmgr_appinfo_destroy_appinfo(pkgmgr_appinfo_h  handle)
2493 {
2494         int ret = 0;
2495         ret = pkgmgrinfo_appinfo_destroy_appinfo(handle);
2496         return ret;
2497 }
2498
2499 API int pkgmgr_pkginfo_create_certinfo(pkgmgr_certinfo_h *handle)
2500 {
2501         int ret = 0;
2502         ret = pkgmgrinfo_pkginfo_create_certinfo(handle);
2503         return ret;
2504 }
2505
2506 API int pkgmgr_pkginfo_load_certinfo(const char *pkgid, pkgmgr_certinfo_h handle)
2507 {
2508         int ret = 0;
2509         ret = pkgmgrinfo_pkginfo_load_certinfo(pkgid, handle);
2510         return ret;
2511 }
2512
2513 API int pkgmgr_pkginfo_get_cert_value(pkgmgr_certinfo_h handle, pkgmgr_cert_type cert_type, const char **cert_value)
2514 {
2515         int ret = 0;
2516         ret = pkgmgrinfo_pkginfo_get_cert_value(handle, cert_type, cert_value);
2517         return ret;
2518 }
2519
2520 API int pkgmgr_pkginfo_destroy_certinfo(pkgmgr_certinfo_h handle)
2521 {
2522         int ret = 0;
2523         ret = pkgmgrinfo_pkginfo_destroy_certinfo(handle);
2524         return ret;
2525 }
2526
2527 API int pkgmgr_datacontrol_get_info(const char *providerid, const char * type, char **appid, char **access)
2528 {
2529         int ret = 0;
2530         ret = pkgmgrinfo_datacontrol_get_info(providerid, type, appid, access);
2531         return ret;
2532 }