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
  40 #include "package-manager.h"
  41 #include "pkgmgr-internal.h"
  42 #include "pkgmgr-api.h"
  43 #include "comm_client.h"
  44 #include "comm_status_broadcast_server.h"
  45
  46
  47 static int _get_request_id()
  48 {
  49         static int internal_req_id = 1;
  50
  51         return internal_req_id++;
  52 }
  53
  54 typedef struct _req_cb_info {
  55         int request_id;
  56         char *req_key;
  57         pkgmgr_handler event_cb;
  58         void *data;
  59         struct _req_cb_info *next;
  60 } req_cb_info;
  61
  62 typedef struct _listen_cb_info {
  63         int request_id;
  64         pkgmgr_handler event_cb;
  65         void *data;
  66         struct _listen_cb_info *next;
  67 } listen_cb_info;
  68
  69 typedef struct _pkgmgr_client_t {
  70         client_type ctype;
  71         union {
  72                 struct _request {
  73                         comm_client *cc;
  74                         req_cb_info *rhead;
  75                 } request;
  76                 struct _listening {
  77                         comm_client *cc;
  78                         listen_cb_info *lhead;
  79                 } listening;
  80                 struct _broadcast {
  81                         DBusConnection *bc;
  82                 } broadcast;
  83         } info;
  84 } pkgmgr_client_t;
  85
  86 typedef struct _iter_data {
  87         pkgmgr_iter_fn iter_fn;
  88         void *data;
  89 } iter_data;
  90
  91
  92 static void __add_op_cbinfo(pkgmgr_client_t * pc, int request_id,
  93                             const char *req_key, pkgmgr_handler event_cb,
  94                             void *data)
  95 {
  96         req_cb_info *cb_info;
  97         req_cb_info *current;
  98         req_cb_info *prev;
  99
 100         cb_info = (req_cb_info *) calloc(1, sizeof(req_cb_info));
 101         if (cb_info == NULL) {
 102                 _LOGD("calloc failed");
 103                 return;
 104         }
 105         cb_info->request_id = request_id;
 106         cb_info->req_key = strdup(req_key);
 107         cb_info->event_cb = event_cb;
 108         cb_info->data = data;
 109         cb_info->next = NULL;
 110
 111         if (pc->info.request.rhead == NULL)
 112                 pc->info.request.rhead = cb_info;
 113         else {
 114                 current = prev = pc->info.request.rhead;
 115                 while (current) {
 116                         prev = current;
 117                         current = current->next;
 118                 }
 119
 120                 prev->next = cb_info;
 121         }
 122 }
 123
 124 static req_cb_info *__find_op_cbinfo(pkgmgr_client_t *pc, const char *req_key)
 125 {
 126         req_cb_info *tmp;
 127
 128         tmp = pc->info.request.rhead;
 129
 130         if (tmp == NULL) {
 131                 _LOGE("tmp is NULL");
 132                 return NULL;
 133         }
 134
 135         _LOGD("tmp->req_key %s, req_key %s", tmp->req_key, req_key);
 136
 137         while (tmp) {
 138                 if (strncmp(tmp->req_key, req_key, strlen(tmp->req_key)) == 0)
 139                         return tmp;
 140                 tmp = tmp->next;
 141         }
 142         return NULL;
 143 }
 144
 145 static void __remove_op_cbinfo(pkgmgr_client_t *pc, req_cb_info *info)
 146 {
 147         req_cb_info *tmp;
 148
 149         if (pc == NULL || pc->info.request.rhead == NULL || info == NULL)
 150                 return;
 151
 152         tmp = pc->info.request.rhead;
 153         while (tmp) {
 154                 if (tmp->next == info) {
 155                         tmp->next = info->next;
 156                         free(info);
 157                         return;
 158                 }
 159                 tmp = tmp->next;
 160         }
 161 }
 162
 163
 164 static void __add_stat_cbinfo(pkgmgr_client_t *pc, int request_id,
 165                               pkgmgr_handler event_cb, void *data)
 166 {
 167         listen_cb_info *cb_info;
 168         listen_cb_info *current;
 169         listen_cb_info *prev;
 170
 171         cb_info = (listen_cb_info *) calloc(1, sizeof(listen_cb_info));
 172         if (cb_info == NULL) {
 173                 _LOGD("calloc failed");
 174                 return;
 175         }
 176         cb_info->request_id = request_id;
 177         cb_info->event_cb = event_cb;
 178         cb_info->data = data;
 179         cb_info->next = NULL;
 180
 181         /* TODO - check the order of callback - FIFO or LIFO => Should be changed to LIFO */
 182         if (pc->info.listening.lhead == NULL)
 183                 pc->info.listening.lhead = cb_info;
 184         else {
 185                 current = prev = pc->info.listening.lhead;
 186                 while (current) {
 187                         prev = current;
 188                         current = current->next;
 189                 }
 190
 191                 prev->next = cb_info;
 192         }
 193 }
 194
 195 static void __operation_callback(void *cb_data, const char *req_id,
 196                                  const char *pkg_type, const char *pkgid,
 197                                  const char *key, const char *val)
 198 {
 199         pkgmgr_client_t *pc;
 200         req_cb_info *cb_info;
 201
 202         _LOGD("__operation_callback() req_id[%s] pkg_type[%s] pkgid[%s]"
 203               "key[%s] val[%s]\n", req_id, pkg_type, pkgid, key, val);
 204
 205         pc = (pkgmgr_client_t *) cb_data;
 206
 207         /* find callback info */
 208         cb_info = __find_op_cbinfo(pc, req_id);
 209         if (cb_info == NULL)
 210                 return;
 211
 212         _LOGD("__find_op_cbinfo");
 213
 214         /* call callback */
 215         if (cb_info->event_cb) {
 216                 cb_info->event_cb(cb_info->request_id, pkg_type, pkgid, key,
 217                                   val, NULL, cb_info->data);
 218                 _LOGD("event_cb is called");
 219         }
 220
 221         /*remove callback for last call
 222            if (strcmp(key, "end") == 0) {
 223            __remove_op_cbinfo(pc, cb_info);
 224            _LOGD("__remove_op_cbinfo");
 225            }
 226          */
 227
 228         return;
 229 }
 230
 231 static void __status_callback(void *cb_data, const char *req_id,
 232                               const char *pkg_type, const char *pkgid,
 233                               const char *key, const char *val)
 234 {
 235         pkgmgr_client_t *pc;
 236         listen_cb_info *tmp;
 237
 238         _LOGD("__status_callback() req_id[%s] pkg_type[%s] pkgid[%s]"
 239               "key[%s] val[%s]\n", req_id, pkg_type, pkgid, key, val);
 240
 241         pc = (pkgmgr_client_t *) cb_data;
 242
 243         tmp = pc->info.listening.lhead;
 244         while (tmp) {
 245                 if (tmp->event_cb(tmp->request_id, pkg_type, pkgid, key, val,
 246                                   NULL, tmp->data) != 0)
 247                         break;
 248                 tmp = tmp->next;
 249         }
 250
 251         return;
 252 }
 253
 254 API pkgmgr_client *pkgmgr_client_new(client_type ctype)
 255 {
 256         pkgmgr_client_t *pc = NULL;
 257         int ret = -1;
 258
 259         if (ctype != PC_REQUEST && ctype != PC_LISTENING
 260             && ctype != PC_BROADCAST)
 261                 return NULL;
 262
 263         /* Allocate memory for ADT:pkgmgr_client */
 264         pc = calloc(1, sizeof(pkgmgr_client_t));
 265         if (pc == NULL) {
 266                 _LOGE("No memory");
 267                 return NULL;
 268         }
 269
 270         /* Manage pc */
 271         pc->ctype = ctype;
 272
 273         if (pc->ctype == PC_REQUEST) {
 274                 pc->info.request.cc = comm_client_new();
 275                 if (pc->info.request.cc == NULL) {
 276                         _LOGE("client creation failed");
 277                         goto err;
 278                 }
 279                 ret = comm_client_set_status_callback(pc->info.request.cc,
 280                                                       __operation_callback, pc);
 281                 if (ret < 0) {
 282                         _LOGE("comm_client_set_status_callback() failed - %d",
 283                               ret);
 284                         goto err;
 285                 }
 286         } else if (pc->ctype == PC_LISTENING) {
 287                 pc->info.listening.cc = comm_client_new();
 288                 if (pc->info.listening.cc == NULL) {
 289                         _LOGE("client creation failed");
 290                         goto err;
 291                 }
 292                 ret = comm_client_set_status_callback(pc->info.request.cc,
 293                                                       __status_callback, pc);
 294                 if (ret < 0) {
 295                         _LOGE("comm_client_set_status_callback() failed - %d",
 296                               ret);
 297                         goto err;
 298                 }
 299         } else if (pc->ctype == PC_BROADCAST) {
 300                 pc->info.broadcast.bc = comm_status_broadcast_server_connect();
 301                 if (pc->info.broadcast.bc == NULL) {
 302                         _LOGE("client creation failed");
 303                         goto err;
 304                 }
 305                 ret = 0;
 306         }
 307
 308         return (pkgmgr_client *) pc;
 309
 310  err:
 311         if (pc)
 312                 free(pc);
 313         return NULL;
 314 }
 315
 316 API int pkgmgr_client_free(pkgmgr_client *pc)
 317 {
 318         int ret = -1;
 319         pkgmgr_client_t *mpc = (pkgmgr_client_t *) pc;
 320
 321         if (mpc == NULL) {
 322                 _LOGE("Invalid argument");
 323                 return PKGMGR_R_EINVAL;
 324         }
 325
 326         if (mpc->ctype == PC_REQUEST) {
 327                 req_cb_info *tmp;
 328                 req_cb_info *prev;
 329                 for (tmp = mpc->info.request.rhead; tmp;) {
 330                         prev = tmp;
 331                         tmp = tmp->next;
 332                         free(prev);
 333                 }
 334
 335                 ret = comm_client_free(mpc->info.request.cc);
 336                 if (ret < 0) {
 337                         _LOGE("comm_client_free() failed - %d", ret);
 338                         goto err;
 339                 }
 340         } else if (mpc->ctype == PC_LISTENING) {
 341                 listen_cb_info *tmp;
 342                 listen_cb_info *prev;
 343                 for (tmp = mpc->info.listening.lhead; tmp;) {
 344                         prev = tmp;
 345                         tmp = tmp->next;
 346                         free(prev);
 347                 }
 348
 349                 ret = comm_client_free(mpc->info.listening.cc);
 350                 if (ret < 0) {
 351                         _LOGE("comm_client_free() failed - %d", ret);
 352                         goto err;
 353                 }
 354         } else if (mpc->ctype == PC_BROADCAST) {
 355                 comm_status_broadcast_server_disconnect(mpc->info.broadcast.bc);
 356                 ret = 0;
 357         } else {
 358                 _LOGE("Invalid client type\n");
 359                 return PKGMGR_R_EINVAL;
 360         }
 361
 362         free(mpc);
 363         mpc = NULL;
 364         return PKGMGR_R_OK;
 365
 366  err:
 367         if (mpc) {
 368                 free(mpc);
 369                 mpc = NULL;
 370         }
 371         return PKGMGR_R_ERROR;
 372 }
 373
 374 static char *__get_req_key(const char *pkg_path)
 375 {
 376         struct timeval tv;
 377         long curtime;
 378         char timestr[PKG_STRING_LEN_MAX];
 379         char *str_req_key;
 380         int size;
 381
 382         gettimeofday(&tv, NULL);
 383         curtime = tv.tv_sec * 1000000 + tv.tv_usec;
 384         snprintf(timestr, sizeof(timestr), "%ld", curtime);
 385
 386         size = strlen(pkg_path) + strlen(timestr) + 2;
 387         str_req_key = (char *)calloc(size, sizeof(char));
 388         if (str_req_key == NULL) {
 389                 _LOGD("calloc failed");
 390                 return NULL;
 391         }
 392         snprintf(str_req_key, size, "%s_%s", pkg_path, timestr);
 393
 394         return str_req_key;
 395 }
 396
 397 static char *__get_type_from_path(const char *pkg_path)
 398 {
 399         int ret;
 400         char mimetype[255] = { '\0', };
 401         char extlist[256] = { '\0', };
 402         char *pkg_type;
 403
 404         ret = _get_mime_from_file(pkg_path, mimetype, sizeof(mimetype));
 405         if (ret) {
 406                 _LOGE("_get_mime_from_file() failed - error code[%d]\n",
 407                       ret);
 408                 return NULL;
 409         }
 410
 411         ret = _get_mime_extension(mimetype, extlist, sizeof(extlist));
 412         if (ret) {
 413                 _LOGE("_get_mime_extension() failed - error code[%d]\n",
 414                       ret);
 415                 return NULL;
 416         }
 417
 418         if (strlen(extlist) == 0)
 419                 return NULL;
 420
 421         if (strchr(extlist, ',')) {
 422                 extlist[strlen(extlist) - strlen(strchr(extlist, ','))] = '\0';
 423         }
 424         pkg_type = strchr(extlist, '.') + 1;
 425         return strdup(pkg_type);
 426 }
 427
 428 API int pkgmgr_client_install(pkgmgr_client * pc, const char *pkg_type,
 429                               const char *descriptor_path, const char *pkg_path,
 430                               const char *optional_file, pkgmgr_mode mode,
 431                               pkgmgr_handler event_cb, void *data)
 432 {
 433         char *pkgtype;
 434         char *installer_path;
 435         char *req_key;
 436         int req_id;
 437         int i = 0;
 438         char *argv[PKG_ARGC_MAX] = { NULL, };
 439         char *args = NULL;
 440         int argcnt = 0;
 441         int len = 0;
 442         char *temp = NULL;
 443         int ret;
 444         char *cookie = NULL;
 445
 446         /* Check for NULL value of pc */
 447         if (pc == NULL) {
 448                 _LOGD("package manager client handle is NULL\n");
 449                 return PKGMGR_R_EINVAL;
 450         }
 451         pkgmgr_client_t *mpc = (pkgmgr_client_t *) pc;
 452
 453         /* 0. check the pc type */
 454         if (mpc->ctype != PC_REQUEST)
 455                 return PKGMGR_R_EINVAL;
 456
 457         /* 1. check argument */
 458         if (descriptor_path) {
 459                 if (strlen(descriptor_path) >= PKG_STRING_LEN_MAX)
 460                         return PKGMGR_R_EINVAL;
 461
 462                 if (access(descriptor_path, F_OK) != 0)
 463                         return PKGMGR_R_EINVAL;
 464         }
 465
 466         if (pkg_path == NULL)
 467                 return PKGMGR_R_EINVAL;
 468         else {
 469                 if (strlen(pkg_path) >= PKG_STRING_LEN_MAX)
 470                         return PKGMGR_R_EINVAL;
 471
 472                 if (access(pkg_path, F_OK) != 0)
 473                         return PKGMGR_R_EINVAL;
 474         }
 475
 476         if (optional_file) {
 477                 if (strlen(optional_file) >= PKG_STRING_LEN_MAX)
 478                         return PKGMGR_R_EINVAL;
 479         }
 480
 481         /* 2. get installer path using pkg_path */
 482         if (pkg_type) {
 483                 installer_path = _get_backend_path_with_type(pkg_type);
 484                 pkgtype = strdup(pkg_type);
 485         } else {
 486                 installer_path = _get_backend_path(pkg_path);
 487                 pkgtype = __get_type_from_path(pkg_path);
 488         }
 489
 490         if (installer_path == NULL) {
 491                 free(pkgtype);
 492                 return PKGMGR_R_EINVAL;
 493         }
 494
 495         /* 3. generate req_key */
 496         req_key = __get_req_key(pkg_path);
 497
 498         /* 4. add callback info - add callback info to pkgmgr_client */
 499         req_id = _get_request_id();
 500         __add_op_cbinfo(mpc, req_id, req_key, event_cb, data);
 501
 502         /* 5. generate argv */
 503
 504         /*  argv[0] installer path */
 505         argv[argcnt++] = installer_path;
 506         /* argv[1] */
 507         argv[argcnt++] = strdup("-k");
 508         /* argv[2] */
 509         argv[argcnt++] = req_key;
 510         /* argv[3] */
 511         argv[argcnt++] = strdup("-i");
 512         /* argv[(4)] if exists */
 513         if (descriptor_path)
 514                 argv[argcnt++] = strdup(descriptor_path);
 515         /* argv[4] */
 516         argv[argcnt++] = strdup(pkg_path);
 517         /* argv[(5)] if exists */
 518         if (optional_file){
 519                 argv[argcnt++] = strdup("-o");
 520                 argv[argcnt++] = strdup(optional_file);
 521         }
 522         /* argv[6] -q option should be located at the end of command !! */
 523         if (mode == PM_QUIET)
 524                 argv[argcnt++] = strdup("-q");
 525
 526         /*** add quote in all string for special charactor like '\n'***   FIX */
 527         for (i = 0; i < argcnt; i++) {
 528                 temp = g_shell_quote(argv[i]);
 529                 len += (strlen(temp) + 1);
 530                 g_free(temp);
 531         }
 532
 533         args = (char *)calloc(len, sizeof(char));
 534         if (args == NULL) {
 535                 _LOGD("calloc failed");
 536
 537                 for (i = 0; i < argcnt; i++)
 538                         free(argv[i]);
 539
 540                 free(pkgtype);
 541                 return PKGMGR_R_ERROR;
 542         }
 543         strncpy(args, argv[0], len - 1);
 544
 545         for (i = 1; i < argcnt; i++) {
 546                 strncat(args, " ", strlen(" "));
 547                 temp = g_shell_quote(argv[i]);
 548                 strncat(args, temp, strlen(temp));
 549                 g_free(temp);
 550         }
 551         _LOGD("[args] %s [len] %d\n", args, len);
 552         /******************* end of quote ************************/
 553
 554         /* 6. request install */
 555         ret = comm_client_request(mpc->info.request.cc, req_key,
 556                                   COMM_REQ_TO_INSTALLER, pkgtype, pkg_path,
 557                                   args, cookie, 1);
 558         if (ret < 0) {
 559                 _LOGE("request failed, ret=%d\n", ret);
 560
 561                 for (i = 0; i < argcnt; i++)
 562                         free(argv[i]);
 563                 free(args);
 564                 free(pkgtype);
 565                 return PKGMGR_R_ECOMM;
 566         }
 567
 568         for (i = 0; i < argcnt; i++)
 569                 free(argv[i]);
 570
 571         free(args);
 572         free(pkgtype);
 573
 574         return req_id;
 575 }
 576
 577 API int pkgmgr_client_reinstall(pkgmgr_client * pc, const char *pkg_type, const char *pkgid,
 578                                   const char *optional_file, pkgmgr_mode mode,
 579                               pkgmgr_handler event_cb, void *data)
 580 {
 581         char *pkgtype = NULL;
 582         char *installer_path = NULL;
 583         char *req_key = NULL;
 584         int req_id = 0;
 585         int i = 0;
 586         char *argv[PKG_ARGC_MAX] = { NULL, };
 587         char *args = NULL;
 588         int argcnt = 0;
 589         int len = 0;
 590         char *temp = NULL;
 591         int ret = 0;
 592         char *cookie = NULL;
 593
 594         /* Check for NULL value of pc */
 595         retvm_if(pc == NULL, PKGMGR_R_EINVAL, "package manager client handle is NULL\n");
 596
 597         pkgmgr_client_t *mpc = (pkgmgr_client_t *) pc;
 598
 599         /* 0. check the pc type */
 600         retv_if(mpc->ctype != PC_REQUEST, PKGMGR_R_EINVAL);
 601
 602
 603         /* 1. check argument */
 604         retv_if(pkgid == NULL, PKGMGR_R_EINVAL);
 605         retv_if(strlen(pkgid) >= PKG_STRING_LEN_MAX, PKGMGR_R_EINVAL);
 606         if (optional_file) {
 607                 if (strlen(optional_file) >= PKG_STRING_LEN_MAX)
 608                         return PKGMGR_R_EINVAL;
 609         }
 610
 611         /* 2. get installer path using pkg_path */
 612         installer_path = _get_backend_path_with_type(pkg_type);
 613         pkgtype = strdup(pkg_type);
 614         tryvm_if(installer_path == NULL, ret = PKGMGR_R_EINVAL, "installer_path is null");
 615
 616         /* 3. generate req_key */
 617         req_key = __get_req_key(pkgid);
 618
 619         /* 4. add callback info - add callback info to pkgmgr_client */
 620         req_id = _get_request_id();
 621         __add_op_cbinfo(mpc, req_id, req_key, event_cb, data);
 622
 623         /* 5. generate argv */
 624
 625         /*  argv[0] installer path */
 626         argv[argcnt++] = installer_path;
 627         /* argv[1] */
 628         argv[argcnt++] = strdup("-k");
 629         /* argv[2] */
 630         argv[argcnt++] = req_key;
 631         /* argv[3] */
 632         argv[argcnt++] = strdup("-r");
 633         /* argv[4] */
 634         argv[argcnt++] = strdup(pkgid);
 635         /* argv[(5)] if exists */
 636         if (optional_file){
 637                 argv[argcnt++] = strdup("-o");
 638                 argv[argcnt++] = strdup(optional_file);
 639         }
 640
 641         /* argv[5] -q option should be located at the end of command !! */
 642         if (mode == PM_QUIET)
 643                 argv[argcnt++] = strdup("-q");
 644
 645         /*** add quote in all string for special charactor like '\n'***   FIX */
 646         for (i = 0; i < argcnt; i++) {
 647                 temp = g_shell_quote(argv[i]);
 648                 len += (strlen(temp) + 1);
 649                 g_free(temp);
 650         }
 651
 652         args = (char *)calloc(len, sizeof(char));
 653         tryvm_if(args == NULL, ret = PKGMGR_R_ERROR, "calloc failed");
 654
 655         strncpy(args, argv[0], len - 1);
 656
 657         for (i = 1; i < argcnt; i++) {
 658                 strncat(args, " ", strlen(" "));
 659                 temp = g_shell_quote(argv[i]);
 660                 strncat(args, temp, strlen(temp));
 661                 g_free(temp);
 662         }
 663         _LOGD("[args] %s [len] %d\n", args, len);
 664         /******************* end of quote ************************/
 665
 666         /* 6. request install */
 667         ret = comm_client_request(mpc->info.request.cc, req_key, COMM_REQ_TO_INSTALLER, pkgtype, pkgid, args, cookie, 1);
 668         tryvm_if(ret < 0, ret = PKGMGR_R_ECOMM, "request failed");
 669
 670         ret = req_id;
 671
 672 catch:
 673         for (i = 0; i < argcnt; i++)
 674                 free(argv[i]);
 675
 676         free(args);
 677         free(pkgtype);
 678
 679         return ret;
 680 }
 681
 682 static inline int __pkgmgr_read_proc(const char *path, char *buf, int size)
 683 {
 684         int fd;
 685         int ret;
 686
 687         if (buf == NULL || path == NULL)
 688                 return -1;
 689
 690         fd = open(path, O_RDONLY);
 691         if (fd < 0)
 692                 return -1;
 693
 694         ret = read(fd, buf, size - 1);
 695         if (ret <= 0) {
 696                 close(fd);
 697                 return -1;
 698         } else
 699                 buf[ret] = 0;
 700
 701         close(fd);
 702
 703         return ret;
 704 }
 705
 706 static inline int __pkgmgr_find_pid_by_cmdline(const char *dname,
 707                                       const char *cmdline, const char *apppath)
 708 {
 709         int pid = 0;
 710
 711         if (strncmp(cmdline, apppath, PKG_STRING_LEN_MAX-1) == 0) {
 712                 pid = atoi(dname);
 713                 if (pid != getpgid(pid))
 714                         pid = 0;
 715         }
 716
 717         return pid;
 718 }
 719
 720
 721 static int __pkgmgr_proc_iter_kill_cmdline(const char *apppath)
 722 {
 723         DIR *dp;
 724         struct dirent *dentry;
 725         int pid;
 726         int ret;
 727         char buf[PKG_STRING_LEN_MAX];
 728
 729         dp = opendir("/proc");
 730         if (dp == NULL) {
 731                 return -1;
 732         }
 733
 734         while ((dentry = readdir(dp)) != NULL) {
 735                 if (!isdigit(dentry->d_name[0]))
 736                         continue;
 737
 738                 snprintf(buf, sizeof(buf), "/proc/%s/cmdline", dentry->d_name);
 739                 ret = __pkgmgr_read_proc(buf, buf, sizeof(buf));
 740                 if (ret <= 0)
 741                         continue;
 742
 743                 pid = __pkgmgr_find_pid_by_cmdline(dentry->d_name, buf, apppath);
 744
 745                 if (pid > 0) {
 746                         int pgid;
 747
 748                         pgid = getpgid(pid);
 749                         if (pgid <= 1) {
 750                                 closedir(dp);
 751                                 return -1;
 752                         }
 753
 754                         if (killpg(pgid, SIGKILL) < 0) {
 755                                 closedir(dp);
 756                                 return -1;
 757                         }
 758                 }
 759         }
 760
 761         closedir(dp);
 762         return 0;
 763 }
 764
 765
 766 static int __app_list_cb (const pkgmgr_appinfo_h handle,
 767                                                 void *user_data)
 768 {
 769         char *exec = NULL;
 770         pkgmgr_appinfo_get_exec(handle, &exec);
 771
 772         __pkgmgr_proc_iter_kill_cmdline(exec);
 773
 774         return 0;
 775 }
 776
 777
 778 API int pkgmgr_client_uninstall(pkgmgr_client *pc, const char *pkg_type,
 779                                 const char *pkgid, pkgmgr_mode mode,
 780                                 pkgmgr_handler event_cb, void *data)
 781 {
 782         char *pkgtype;
 783         char *installer_path;
 784         char *req_key;
 785         int req_id;
 786         int i = 0;
 787         char *argv[PKG_ARGC_MAX] = { NULL, };
 788         char *args = NULL;
 789         int argcnt = 0;
 790         int len = 0;
 791         char *temp = NULL;
 792         int ret = -1;
 793         char *cookie = NULL;
 794
 795         /* Check for NULL value of pc */
 796         retvm_if(pc == NULL, PKGMGR_R_EINVAL, "package manager client handle is NULL\n");
 797
 798         pkgmgr_client_t *mpc = (pkgmgr_client_t *) pc;
 799
 800         /* 0. check the pc type */
 801         retv_if(mpc->ctype != PC_REQUEST, PKGMGR_R_EINVAL);
 802
 803         /* 1. check argument */
 804         retv_if(pkgid == NULL, PKGMGR_R_EINVAL);
 805
 806         pkgmgr_pkginfo_h handle;
 807         ret = pkgmgr_pkginfo_get_pkginfo(pkgid, &handle);
 808
 809         /*check package id      */
 810         tryvm_if(ret < 0, ret = PKGMGR_R_EINVAL, "pkgmgr_pkginfo_get_pkginfo fail");
 811         tryvm_if(handle == NULL, ret = PKGMGR_R_EINVAL, "Pkgid(%s) can not find in installed pkg DB! \n", pkgid);
 812
 813         /*check running app , terminate app if it is running*/
 814         ret = pkgmgr_appinfo_get_list(handle, PM_UI_APP, __app_list_cb, NULL);
 815         tryvm_if(ret < 0, ret = PKGMGR_R_EINVAL, "pkgmgr_appinfo_get_list : PM_UI_APP fail");
 816
 817         /*check running app , terminate app if it is running*/
 818         ret = pkgmgr_appinfo_get_list(handle, PM_SVC_APP, __app_list_cb, NULL);
 819         tryvm_if(ret < 0, ret = PKGMGR_R_EINVAL, "pkgmgr_appinfo_get_list : PM_SVC_APP fail");
 820
 821         /*check type    */
 822         ret = pkgmgr_pkginfo_get_type(handle, &pkgtype);
 823         tryvm_if(ret < 0, ret = PKGMGR_R_EINVAL, "pkgmgr_pkginfo_get_type fail");
 824         tryvm_if(pkgtype == NULL, ret = PKGMGR_R_ERROR, "pkgtype is NULL");
 825
 826         /*check pkgid length    */
 827         tryvm_if(strlen(pkgid) >= PKG_STRING_LEN_MAX, ret = PKGMGR_R_EINVAL, "pkgid is too long");
 828
 829         /* 2. get installer path using pkgtype */
 830         installer_path = _get_backend_path_with_type(pkgtype);
 831         tryvm_if(installer_path == NULL, ret = PKGMGR_R_EINVAL, "installer_path fail");
 832
 833         /* 3. generate req_key */
 834         req_key = __get_req_key(pkgid);
 835
 836         /* 4. add callback info - add callback info to pkgmgr_client */
 837         req_id = _get_request_id();
 838         __add_op_cbinfo(mpc, req_id, req_key, event_cb, data);
 839
 840         /* 5. generate argv */
 841
 842         /* argv[0] installer path */
 843         argv[argcnt++] = installer_path;
 844         /* argv[1] */
 845         argv[argcnt++] = strdup("-k");
 846         /* argv[2] */
 847         argv[argcnt++] = req_key;
 848         /* argv[3] */
 849         argv[argcnt++] = strdup("-d");
 850         /* argv[4] */
 851         argv[argcnt++] = strdup(pkgid);
 852         /* argv[5] -q option should be located at the end of command !! */
 853         if (mode == PM_QUIET)
 854                 argv[argcnt++] = strdup("-q");
 855
 856         /*** add quote in all string for special charactor like '\n'***   FIX */
 857         for (i = 0; i < argcnt; i++) {
 858                 temp = g_shell_quote(argv[i]);
 859                 len += (strlen(temp) + 1);
 860                 g_free(temp);
 861         }
 862
 863         args = (char *)calloc(len, sizeof(char));
 864         tryvm_if(args == NULL, ret = PKGMGR_R_ERROR, "calloc failed");
 865
 866         strncpy(args, argv[0], len - 1);
 867
 868         for (i = 1; i < argcnt; i++) {
 869                 strncat(args, " ", strlen(" "));
 870                 temp = g_shell_quote(argv[i]);
 871                 strncat(args, temp, strlen(temp));
 872                 g_free(temp);
 873         }
 874         _LOGD("[args] %s [len] %d\n", args, len);
 875         /******************* end of quote ************************/
 876
 877         /* 6. request install */
 878         ret = comm_client_request(mpc->info.request.cc, req_key, COMM_REQ_TO_INSTALLER, pkgtype, pkgid, args, cookie, 1);
 879         tryvm_if(ret < 0, ret = PKGMGR_R_ECOMM, "calloc failed");
 880
 881         for (i = 0; i < argcnt; i++)
 882                 free(argv[i]);
 883
 884         free(args);
 885
 886         pkgmgr_pkginfo_destroy_pkginfo(handle);
 887         return req_id;
 888
 889 catch:
 890         for (i = 0; i < argcnt; i++)
 891                 free(argv[i]);
 892
 893         if(args)
 894                 free(args);
 895
 896         pkgmgr_pkginfo_destroy_pkginfo(handle);
 897         PKGMGR_END();\
 898         return ret;
 899 }
 900
 901 API int pkgmgr_client_move(pkgmgr_client *pc, const char *pkg_type,
 902                                 const char *pkgid, pkgmgr_move_type move_type, pkgmgr_mode mode)
 903 {
 904         const char *pkgtype = NULL;
 905         char *installer_path = NULL;
 906         char *req_key = NULL;
 907         int i = 0;
 908         char *argv[PKG_ARGC_MAX] = { NULL, };
 909         char *args = NULL;
 910         int argcnt = 0;
 911         int len = 0;
 912         char *temp = NULL;
 913         int ret = 0;
 914         int req_id = 0;
 915         char *cookie = NULL;
 916         char buf[128] = {'\0'};
 917
 918         /* Check for NULL value of pc */
 919         if (pc == NULL) {
 920                 _LOGD("package manager client handle is NULL\n");
 921                 return PKGMGR_R_EINVAL;
 922         }
 923         pkgmgr_client_t *mpc = (pkgmgr_client_t *) pc;
 924         /*check the pc type */
 925         if (mpc->ctype != PC_REQUEST)
 926                 return PKGMGR_R_EINVAL;
 927
 928         /*check argument */
 929         if (pkgid == NULL)
 930                 return PKGMGR_R_EINVAL;
 931
 932         if (pkg_type == NULL) {
 933                 pkgtype = _get_pkg_type_from_desktop_file(pkgid);
 934                 if (pkgtype == NULL)
 935                         return PKGMGR_R_EINVAL;
 936         } else
 937                 pkgtype = pkg_type;
 938
 939         if (strlen(pkgid) >= PKG_STRING_LEN_MAX)
 940                 return PKGMGR_R_EINVAL;
 941
 942         if ((move_type < PM_MOVE_TO_INTERNAL) || (move_type > PM_MOVE_TO_SDCARD))
 943                 return PKGMGR_R_EINVAL;
 944
 945         /* get installer path using pkg_path */
 946         installer_path = _get_backend_path_with_type(pkgtype);
 947         if (installer_path == NULL)
 948                 return PKGMGR_R_EINVAL;
 949
 950         /* generate req_key */
 951         req_key = __get_req_key(pkgid);
 952         req_id = _get_request_id();
 953
 954         /* generate argv */
 955         snprintf(buf, 128, "%d", move_type);
 956         /* argv[0] installer path */
 957         argv[argcnt++] = installer_path;
 958         /* argv[1] */
 959         argv[argcnt++] = strdup("-k");
 960         /* argv[2] */
 961         argv[argcnt++] = req_key;
 962         /* argv[3] */
 963         argv[argcnt++] = strdup("-m");
 964         /* argv[4] */
 965         argv[argcnt++] = strdup(pkgid);
 966         /* argv[5] */
 967         argv[argcnt++] = strdup("-t");
 968         /* argv[6] */
 969         argv[argcnt++] = strdup(buf);
 970         /* argv[7] -q option should be located at the end of command !! */
 971         if (mode == PM_QUIET)
 972                 argv[argcnt++] = strdup("-q");
 973
 974         /*** add quote in all string for special charactor like '\n'***   FIX */
 975         for (i = 0; i < argcnt; i++) {
 976                 temp = g_shell_quote(argv[i]);
 977                 len += (strlen(temp) + 1);
 978                 g_free(temp);
 979         }
 980
 981         args = (char *)calloc(len, sizeof(char));
 982         if (args == NULL) {
 983                 _LOGD("calloc failed");
 984
 985                 for (i = 0; i < argcnt; i++)
 986                         free(argv[i]);
 987
 988                 return PKGMGR_R_ERROR;
 989         }
 990         strncpy(args, argv[0], len - 1);
 991
 992         for (i = 1; i < argcnt; i++) {
 993                 strncat(args, " ", strlen(" "));
 994                 temp = g_shell_quote(argv[i]);
 995                 strncat(args, temp, strlen(temp));
 996                 g_free(temp);
 997         }
 998         _LOGD("[args] %s [len] %d\n", args, len);
 999         /******************* end of quote ************************/
1000
1001         /* 6. request install */
1002         ret = comm_client_request(mpc->info.request.cc, req_key,
1003                                   COMM_REQ_TO_MOVER, pkgtype, pkgid,
1004                                   args, cookie, 1);
1005         if (ret < 0) {
1006                 _LOGE("request failed, ret=%d\n", ret);
1007
1008                 for (i = 0; i < argcnt; i++)
1009                         free(argv[i]);
1010
1011                 free(args);
1012                 return PKGMGR_R_ECOMM;
1013         }
1014
1015         for (i = 0; i < argcnt; i++)
1016                 free(argv[i]);
1017
1018         free(args);
1019
1020         return req_id;
1021 }
1022
1023 API int pkgmgr_client_activate(pkgmgr_client * pc, const char *pkg_type,
1024                                const char *pkgid)
1025 {
1026         const char *pkgtype;
1027         char *req_key;
1028         char *cookie = NULL;
1029         int ret;
1030         /* Check for NULL value of pc */
1031         if (pc == NULL) {
1032                 _LOGD("package manager client handle is NULL\n");
1033                 return PKGMGR_R_EINVAL;
1034         }
1035         pkgmgr_client_t *mpc = (pkgmgr_client_t *) pc;
1036
1037         /* 0. check the pc type */
1038         if (mpc->ctype != PC_REQUEST)
1039                 return PKGMGR_R_EINVAL;
1040
1041         /* 1. check argument */
1042         if (pkgid == NULL)
1043                 return PKGMGR_R_EINVAL;
1044
1045         if (pkg_type == NULL) {
1046                 pkgtype = _get_pkg_type_from_desktop_file(pkgid);
1047                 if (pkgtype == NULL)
1048                         return PKGMGR_R_EINVAL;
1049         } else
1050                 pkgtype = pkg_type;
1051
1052         if (strlen(pkgid) >= PKG_STRING_LEN_MAX)
1053                 return PKGMGR_R_EINVAL;
1054
1055         /* 2. generate req_key */
1056         req_key = __get_req_key(pkgid);
1057
1058         /* 3. request activate */
1059         ret = comm_client_request(mpc->info.request.cc, req_key,
1060                                   COMM_REQ_TO_ACTIVATOR, pkgtype,
1061                                   pkgid, "1 PKG", cookie, 1);
1062         if (ret < 0) {
1063                 _LOGE("request failed, ret=%d\n", ret);
1064                 free(req_key);
1065                 return PKGMGR_R_ECOMM;
1066         }
1067
1068         free(req_key);
1069
1070         return PKGMGR_R_OK;
1071 }
1072
1073 API int pkgmgr_client_deactivate(pkgmgr_client *pc, const char *pkg_type,
1074                                  const char *pkgid)
1075 {
1076         const char *pkgtype;
1077         char *req_key;
1078         char *cookie = NULL;
1079         int ret;
1080         /* Check for NULL value of pc */
1081         if (pc == NULL) {
1082                 _LOGD("package manager client handle is NULL\n");
1083                 return PKGMGR_R_EINVAL;
1084         }
1085         pkgmgr_client_t *mpc = (pkgmgr_client_t *) pc;
1086
1087         /* 0. check the pc type */
1088         if (mpc->ctype != PC_REQUEST)
1089                 return PKGMGR_R_EINVAL;
1090
1091         /* 1. check argument */
1092         if (pkgid == NULL)
1093                 return PKGMGR_R_EINVAL;
1094
1095         if (pkg_type == NULL) {
1096                 pkgtype = _get_pkg_type_from_desktop_file(pkgid);
1097                 if (pkgtype == NULL)
1098                         return PKGMGR_R_EINVAL;
1099         } else
1100                 pkgtype = pkg_type;
1101
1102         if (strlen(pkgid) >= PKG_STRING_LEN_MAX)
1103                 return PKGMGR_R_EINVAL;
1104
1105         /* 2. generate req_key */
1106         req_key = __get_req_key(pkgid);
1107
1108         /* 3. request activate */
1109         ret = comm_client_request(mpc->info.request.cc, req_key,
1110                                   COMM_REQ_TO_ACTIVATOR, pkgtype,
1111                                   pkgid, "0 PKG", cookie, 1);
1112         if (ret < 0) {
1113                 _LOGE("request failed, ret=%d\n", ret);
1114                 free(req_key);
1115                 return PKGMGR_R_ECOMM;
1116         }
1117
1118         free(req_key);
1119
1120         return PKGMGR_R_OK;
1121 }
1122
1123 API int pkgmgr_client_activate_app(pkgmgr_client * pc, const char *appid)
1124 {
1125         const char *pkgtype;
1126         char *req_key;
1127         char *cookie = NULL;
1128         int ret;
1129         /* Check for NULL value of pc */
1130         if (pc == NULL) {
1131                 _LOGD("package manager client handle is NULL\n");
1132                 return PKGMGR_R_EINVAL;
1133         }
1134         pkgmgr_client_t *mpc = (pkgmgr_client_t *) pc;
1135
1136         /* 0. check the pc type */
1137         if (mpc->ctype != PC_REQUEST)
1138                 return PKGMGR_R_EINVAL;
1139
1140         /* 1. check argument */
1141         if (appid == NULL)
1142                 return PKGMGR_R_EINVAL;
1143
1144         if (strlen(appid) >= PKG_STRING_LEN_MAX)
1145                 return PKGMGR_R_EINVAL;
1146
1147         pkgtype = _get_pkg_type_from_desktop_file(appid);
1148
1149         /* 2. generate req_key */
1150         req_key = __get_req_key(appid);
1151
1152         /* 3. request activate */
1153         ret = comm_client_request(mpc->info.request.cc, req_key,
1154                                   COMM_REQ_TO_ACTIVATOR, pkgtype,
1155                                   appid, "1 APP", cookie, 1);
1156         if (ret < 0) {
1157                 _LOGE("request failed, ret=%d\n", ret);
1158                 free(req_key);
1159                 return PKGMGR_R_ECOMM;
1160         }
1161
1162         free(req_key);
1163
1164         return PKGMGR_R_OK;
1165 }
1166
1167 API int pkgmgr_client_activate_appv(pkgmgr_client * pc, const char *appid, char *const argv[])
1168 {
1169         const char *pkgtype;
1170         char *req_key;
1171         char *cookie = NULL;
1172         int ret;
1173         int i = 0;
1174         char *temp = NULL;
1175         int len = 0;
1176         int argcnt = 0;
1177         char *args = NULL;
1178         char *argsr = NULL;
1179         /* Check for NULL value of pc */
1180         if (pc == NULL) {
1181                 _LOGD("package manager client handle is NULL\n");
1182                 return PKGMGR_R_EINVAL;
1183         }
1184         pkgmgr_client_t *mpc = (pkgmgr_client_t *) pc;
1185
1186         /* 0. check the pc type */
1187         if (mpc->ctype != PC_REQUEST)
1188                 return PKGMGR_R_EINVAL;
1189
1190         /* 1. check argument */
1191         if (appid == NULL)
1192                 return PKGMGR_R_EINVAL;
1193
1194         if (strlen(appid) >= PKG_STRING_LEN_MAX)
1195                 return PKGMGR_R_EINVAL;
1196
1197         pkgtype = _get_pkg_type_from_desktop_file(appid);
1198
1199         /* 2. generate req_key */
1200         req_key = __get_req_key(appid);
1201
1202         /*** add quote in all string for special charactor like '\n'***   FIX */
1203         if (argv) {
1204                 for (i = 0; argv[i]; i++) {
1205                         temp = g_shell_quote(argv[i]);
1206                         len += (strlen(temp) + 1);
1207                         g_free(temp);
1208                         argcnt++;
1209                 }
1210
1211                 if (argcnt) {
1212                         args = (char *)calloc(len, sizeof(char));
1213                         if (args == NULL) {
1214                                 _LOGE("calloc failed");
1215                                 free(req_key);
1216                                 return PKGMGR_R_ERROR;
1217                         }
1218                         strncpy(args, argv[0], len - 1);
1219
1220                         for (i = 1; i < argcnt; i++) {
1221                                 strncat(args, " ", strlen(" "));
1222                                 temp = g_shell_quote(argv[i]);
1223                                 strncat(args, temp, strlen(temp));
1224                                 g_free(temp);
1225                         }
1226                 }
1227         }
1228
1229         argsr = (char *)calloc(strlen("1 APP")+2+len, sizeof(char));
1230         if (argsr == NULL) {
1231                 _LOGE("calloc failed");
1232                 free(req_key);
1233                 free(args);
1234                 return PKGMGR_R_ERROR;
1235         }
1236         strncpy(argsr, "1 APP", strlen("1 APP"));
1237         if (argcnt) {
1238                 strncat(argsr, " ", strlen(" "));
1239                 strncat(argsr, args, strlen(args));
1240         }
1241
1242         _LOGD("argsr [%s]\n", argsr);
1243         /******************* end of quote ************************/
1244
1245         /* 3. request activate */
1246         ret = comm_client_request(mpc->info.request.cc, req_key,
1247                                   COMM_REQ_TO_ACTIVATOR, pkgtype,
1248                                   appid, argsr, cookie, 1);
1249         if (ret < 0) {
1250                 _LOGE("request failed, ret=%d\n", ret);
1251                 free(req_key);
1252                 free(args);
1253                 free(argsr);
1254                 return PKGMGR_R_ECOMM;
1255         }
1256
1257         free(req_key);
1258         free(args);
1259         free(argsr);
1260
1261         return PKGMGR_R_OK;
1262 }
1263
1264 API int pkgmgr_client_deactivate_app(pkgmgr_client *pc, const char *appid)
1265 {
1266         const char *pkgtype;
1267         char *req_key;
1268         char *cookie = NULL;
1269         int ret;
1270         /* Check for NULL value of pc */
1271         if (pc == NULL) {
1272                 _LOGD("package manager client handle is NULL\n");
1273                 return PKGMGR_R_EINVAL;
1274         }
1275         pkgmgr_client_t *mpc = (pkgmgr_client_t *) pc;
1276
1277         /* 0. check the pc type */
1278         if (mpc->ctype != PC_REQUEST)
1279                 return PKGMGR_R_EINVAL;
1280
1281         /* 1. check argument */
1282         if (appid == NULL)
1283                 return PKGMGR_R_EINVAL;
1284
1285         if (strlen(appid) >= PKG_STRING_LEN_MAX)
1286                 return PKGMGR_R_EINVAL;
1287
1288         pkgtype = _get_pkg_type_from_desktop_file(appid);
1289
1290         /* 2. generate req_key */
1291         req_key = __get_req_key(appid);
1292
1293         /* 3. request activate */
1294         ret = comm_client_request(mpc->info.request.cc, req_key,
1295                                   COMM_REQ_TO_ACTIVATOR, pkgtype,
1296                                   appid, "0 APP", cookie, 1);
1297         if (ret < 0) {
1298                 _LOGE("request failed, ret=%d\n", ret);
1299                 free(req_key);
1300                 return PKGMGR_R_ECOMM;
1301         }
1302
1303         free(req_key);
1304
1305         return PKGMGR_R_OK;
1306 }
1307
1308
1309 API int pkgmgr_client_clear_user_data(pkgmgr_client *pc, const char *pkg_type,
1310                                       const char *appid, pkgmgr_mode mode)
1311 {
1312         const char *pkgtype;
1313         char *installer_path;
1314         char *req_key;
1315         int i = 0;
1316         char *argv[PKG_ARGC_MAX] = { NULL, };
1317         char *args = NULL;
1318         int argcnt = 0;
1319         int len = 0;
1320         char *temp = NULL;
1321         int ret;
1322         char *cookie = NULL;
1323
1324         /* Check for NULL value of pc */
1325         if (pc == NULL) {
1326                 _LOGD("package manager client handle is NULL\n");
1327                 return PKGMGR_R_EINVAL;
1328         }
1329         pkgmgr_client_t *mpc = (pkgmgr_client_t *) pc;
1330
1331         /* 0. check the pc type */
1332         if (mpc->ctype != PC_REQUEST)
1333                 return PKGMGR_R_EINVAL;
1334
1335         /* 1. check argument */
1336         if (appid == NULL)
1337                 return PKGMGR_R_EINVAL;
1338
1339
1340         if (pkg_type == NULL) {
1341                 pkgtype = _get_pkg_type_from_desktop_file(appid);
1342                 if (pkgtype == NULL)
1343                         return PKGMGR_R_EINVAL;
1344         } else
1345                 pkgtype = pkg_type;
1346
1347         if (strlen(appid) >= PKG_STRING_LEN_MAX)
1348                 return PKGMGR_R_EINVAL;
1349
1350         /* 2. get installer path using pkg_path */
1351         installer_path = _get_backend_path_with_type(pkgtype);
1352         if (installer_path == NULL)
1353                 return PKGMGR_R_EINVAL;
1354
1355         /* 3. generate req_key */
1356         req_key = __get_req_key(appid);
1357
1358         /* 4. generate argv */
1359
1360         /* argv[0] installer path */
1361         argv[argcnt++] = installer_path;
1362         /* argv[1] */
1363         argv[argcnt++] = strdup("-k");
1364         /* argv[2] */
1365         argv[argcnt++] = req_key;
1366         /* argv[3] */
1367         argv[argcnt++] = strdup("-c");
1368         /* argv[4] */
1369         argv[argcnt++] = strdup(appid);
1370         /* argv[5] -q option should be located at the end of command !! */
1371         if (mode == PM_QUIET)
1372                 argv[argcnt++] = strdup("-q");
1373
1374         /*** add quote in all string for special charactor like '\n'***   FIX */
1375         for (i = 0; i < argcnt; i++) {
1376                 temp = g_shell_quote(argv[i]);
1377                 len += (strlen(temp) + 1);
1378                 g_free(temp);
1379         }
1380
1381         args = (char *)calloc(len, sizeof(char));
1382         if (args == NULL) {
1383                 _LOGD("calloc failed");
1384
1385                 for (i = 0; i < argcnt; i++)
1386                         free(argv[i]);
1387
1388                 return PKGMGR_R_ERROR;
1389         }
1390         strncpy(args, argv[0], len - 1);
1391
1392         for (i = 1; i < argcnt; i++) {
1393                 strncat(args, " ", strlen(" "));
1394                 temp = g_shell_quote(argv[i]);
1395                 strncat(args, temp, strlen(temp));
1396                 g_free(temp);
1397         }
1398         _LOGD("[args] %s [len] %d\n", args, len);
1399         /******************* end of quote ************************/
1400
1401         /* 6. request clear */
1402         ret = comm_client_request(mpc->info.request.cc, req_key,
1403                                   COMM_REQ_TO_CLEARER, pkgtype, appid,
1404                                   args, cookie, 1);
1405         if (ret < 0) {
1406                 _LOGE("request failed, ret=%d\n", ret);
1407
1408                 for (i = 0; i < argcnt; i++)
1409                         free(argv[i]);
1410
1411                 free(args);
1412                 return PKGMGR_R_ECOMM;
1413         }
1414
1415         for (i = 0; i < argcnt; i++)
1416                 free(argv[i]);
1417
1418         free(args);
1419
1420         return PKGMGR_R_OK;
1421 }
1422
1423 API int pkgmgr_client_listen_status(pkgmgr_client *pc, pkgmgr_handler event_cb,
1424                                     void *data)
1425 {
1426         int req_id;
1427         /* Check for NULL value of pc */
1428         if (pc == NULL) {
1429                 _LOGD("package manager client handle is NULL\n");
1430                 return PKGMGR_R_EINVAL;
1431         }
1432         pkgmgr_client_t *mpc = (pkgmgr_client_t *) pc;
1433
1434         /* 0. check the pc type */
1435         if (mpc->ctype != PC_LISTENING)
1436                 return PKGMGR_R_EINVAL;
1437
1438         /* 1. check argument */
1439         if (event_cb == NULL)
1440                 return PKGMGR_R_EINVAL;
1441
1442         /* 2. add callback info to pkgmgr_client */
1443         req_id = _get_request_id();
1444         __add_stat_cbinfo(mpc, req_id, event_cb, data);
1445
1446         return req_id;
1447 }
1448
1449 API int pkgmgr_client_broadcast_status(pkgmgr_client *pc, const char *pkg_type,
1450                                        const char *pkgid, const char *key,
1451                                        const char *val)
1452 {
1453         /* Check for NULL value of pc */
1454         if (pc == NULL) {
1455                 _LOGD("package manager client handle is NULL\n");
1456                 return PKGMGR_R_EINVAL;
1457         }
1458         /* Check for valid arguments. NULL parameter causes DBUS to abort */
1459         if (pkgid == NULL || pkg_type == NULL || key == NULL || val == NULL) {
1460                 _LOGD("Argument supplied is NULL\n");
1461                 return PKGMGR_R_EINVAL;
1462         }
1463         pkgmgr_client_t *mpc = (pkgmgr_client_t *) pc;
1464
1465         /* 0. check the pc type */
1466         if (mpc->ctype != PC_BROADCAST)
1467                 return PKGMGR_R_EINVAL;
1468
1469         comm_status_broadcast_server_send_signal(mpc->info.broadcast.bc,
1470                                                  PKG_STATUS, pkg_type,
1471                                                  pkgid, key, val);
1472
1473         return PKGMGR_R_OK;
1474 }
1475
1476 API pkgmgr_info *pkgmgr_client_check_pkginfo_from_file(const char *pkg_path)
1477 {
1478         return pkgmgr_info_new_from_file(NULL, pkg_path);
1479 }
1480
1481 API int pkgmgr_client_free_pkginfo(pkgmgr_info * pkg_info)
1482 {
1483         if (pkg_info == NULL)
1484                 return PKGMGR_R_EINVAL;
1485
1486         package_manager_pkg_detail_info_t *info = (package_manager_pkg_detail_info_t *)pkg_info;
1487
1488         if (info->icon_buf)
1489                 free(info->icon_buf);
1490
1491         if (info->privilege_list)
1492                 g_list_free(info->privilege_list);
1493
1494         free(info);
1495         info = NULL;
1496
1497         return PKGMGR_R_OK;
1498 }
1499
1500 ail_cb_ret_e __appinfo_func(const ail_appinfo_h appinfo, void *user_data)
1501 {
1502         char *type;
1503         char *package;
1504         char *version;
1505
1506         iter_data *udata = (iter_data *) user_data;
1507
1508         ail_appinfo_get_str(appinfo, AIL_PROP_X_SLP_PACKAGETYPE_STR, &type);
1509         if (type == NULL)
1510                 type = "";
1511         ail_appinfo_get_str(appinfo, AIL_PROP_PACKAGE_STR, &package);
1512         if (package == NULL)
1513                 package = "";
1514         ail_appinfo_get_str(appinfo, AIL_PROP_VERSION_STR, &version);
1515         if (version == NULL)
1516                 version = "";
1517
1518         if (udata->iter_fn(type, package, version, udata->data) != 0)
1519                 return AIL_CB_RET_CANCEL;
1520
1521         return AIL_CB_RET_CONTINUE;
1522 }
1523
1524
1525
1526 #define __START_OF_OLD_API
1527
1528 API int pkgmgr_get_pkg_list(pkgmgr_iter_fn iter_fn, void *data)
1529 {
1530         int cnt = -1;
1531         ail_filter_h filter;
1532         ail_error_e ret;
1533
1534         if (iter_fn == NULL)
1535                 return PKGMGR_R_EINVAL;
1536
1537         ret = ail_filter_new(&filter);
1538         if (ret != AIL_ERROR_OK) {
1539                 return PKGMGR_R_ERROR;
1540         }
1541
1542         ret = ail_filter_add_str(filter, AIL_PROP_TYPE_STR, "Application");
1543         if (ret != AIL_ERROR_OK) {
1544                 ail_filter_destroy(filter);
1545                 return PKGMGR_R_ERROR;
1546         }
1547
1548         ret = ail_filter_add_bool(filter, AIL_PROP_X_SLP_REMOVABLE_BOOL, true);
1549         if (ret != AIL_ERROR_OK) {
1550                 ail_filter_destroy(filter);
1551                 return PKGMGR_R_ERROR;
1552         }
1553
1554         ret = ail_filter_count_appinfo(filter, &cnt);
1555         if (ret != AIL_ERROR_OK) {
1556                 ail_filter_destroy(filter);
1557                 return PKGMGR_R_ERROR;
1558         }
1559
1560         iter_data *udata = calloc(1, sizeof(iter_data));
1561         if (udata == NULL) {
1562                 _LOGE("calloc failed");
1563                 ail_filter_destroy(filter);
1564
1565                 return PKGMGR_R_ERROR;
1566         }
1567         udata->iter_fn = iter_fn;
1568         udata->data = data;
1569
1570         ail_filter_list_appinfo_foreach(filter, __appinfo_func, udata);
1571
1572         free(udata);
1573
1574         ret = ail_filter_destroy(filter);
1575         if (ret != AIL_ERROR_OK) {
1576                 return PKGMGR_R_ERROR;
1577         }
1578
1579         return PKGMGR_R_OK;
1580 }
1581
1582 API pkgmgr_info *pkgmgr_info_new(const char *pkg_type, const char *pkgid)
1583 {
1584         const char *pkgtype;
1585         pkg_plugin_set *plugin_set = NULL;
1586         package_manager_pkg_detail_info_t *pkg_detail_info = NULL;
1587
1588         /* 1. check argument */
1589         if (pkgid == NULL)
1590                 return NULL;
1591
1592         if (pkg_type == NULL) {
1593                 pkgtype = _get_pkg_type_from_desktop_file(pkgid);
1594                 if (pkgtype == NULL)
1595                         return NULL;
1596         } else
1597                 pkgtype = pkg_type;
1598
1599         if (strlen(pkgid) >= PKG_STRING_LEN_MAX)
1600                 return NULL;
1601
1602         pkg_detail_info = calloc(1, sizeof(package_manager_pkg_detail_info_t));
1603         if (pkg_detail_info == NULL) {
1604                 _LOGE("*** Failed to alloc package_handler_info.\n");
1605                 return NULL;
1606         }
1607
1608         plugin_set = _package_manager_load_library(pkgtype);
1609         if (plugin_set == NULL) {
1610                 _LOGE("*** Failed to load library");
1611                 free(pkg_detail_info);
1612                 return NULL;
1613         }
1614
1615         if (plugin_set->pkg_is_installed) {
1616                 if (plugin_set->pkg_is_installed(pkgid) != 0) {
1617                         _LOGE("*** Failed to call pkg_is_installed()");
1618                         free(pkg_detail_info);
1619                         return NULL;
1620                 }
1621
1622                 if (plugin_set->get_pkg_detail_info) {
1623                         if (plugin_set->get_pkg_detail_info(pkgid,
1624                                                             pkg_detail_info) != 0) {
1625                                 _LOGE("*** Failed to call get_pkg_detail_info()");
1626                                 free(pkg_detail_info);
1627                                 return NULL;
1628                         }
1629                 }
1630         }
1631
1632         return (pkgmgr_info *) pkg_detail_info;
1633 }
1634
1635 API char * pkgmgr_info_get_string(pkgmgr_info * pkg_info, const char *key)
1636 {
1637         package_manager_pkg_detail_info_t *pkg_detail_info;
1638
1639         if (pkg_info == NULL)
1640                 return NULL;
1641         if (key == NULL)
1642                 return NULL;
1643
1644         pkg_detail_info = (package_manager_pkg_detail_info_t *) pkg_info;
1645
1646         return _get_info_string(key, pkg_detail_info);
1647 }
1648
1649 API pkgmgr_info *pkgmgr_info_new_from_file(const char *pkg_type,
1650                                            const char *pkg_path)
1651 {
1652         pkg_plugin_set *plugin_set = NULL;
1653         package_manager_pkg_detail_info_t *pkg_detail_info = NULL;
1654         char *pkgtype;
1655         if (pkg_path == NULL) {
1656                 _LOGE("pkg_path is NULL\n");
1657                 return NULL;
1658         }
1659
1660         if (strlen(pkg_path) > PKG_URL_STRING_LEN_MAX) {
1661                 _LOGE("length of pkg_path is too long - %d.\n",
1662                       strlen(pkg_path));
1663                 return NULL;
1664         }
1665
1666         pkg_detail_info = calloc(1, sizeof(package_manager_pkg_detail_info_t));
1667         if (pkg_detail_info == NULL) {
1668                 _LOGE("*** Failed to alloc package_handler_info.\n");
1669                 return NULL;
1670         }
1671
1672         if (pkg_type == NULL)
1673                 pkgtype = __get_type_from_path(pkg_path);
1674         else
1675                 pkgtype = strdup(pkg_type);
1676
1677         plugin_set = _package_manager_load_library(pkgtype);
1678         if (plugin_set == NULL) {
1679                 free(pkg_detail_info);
1680                 free(pkgtype);
1681                 return NULL;
1682         }
1683
1684         if (plugin_set->get_pkg_detail_info_from_package) {
1685                 if (plugin_set->get_pkg_detail_info_from_package(pkg_path,
1686                                                                  pkg_detail_info) != 0) {
1687                         free(pkg_detail_info);
1688                         free(pkgtype);
1689                         return NULL;
1690                 }
1691         }
1692
1693         free(pkgtype);
1694         return (pkgmgr_info *) pkg_detail_info;
1695 }
1696
1697 API int pkgmgr_info_free(pkgmgr_info * pkg_info)
1698 {
1699         if (pkg_info == NULL)
1700                 return PKGMGR_R_EINVAL;
1701
1702         free(pkg_info);
1703         pkg_info = NULL;
1704
1705         return 0;
1706 }
1707
1708 #define __END_OF_OLD_API
1709
1710 API int pkgmgr_pkginfo_get_list(pkgmgr_info_pkg_list_cb pkg_list_cb, void *user_data)
1711 {
1712         int ret = 0;
1713         ret = pkgmgrinfo_pkginfo_get_list(pkg_list_cb, user_data);
1714         return ret;
1715 }
1716
1717 API int pkgmgr_pkginfo_get_pkginfo(const char *pkgid, pkgmgr_pkginfo_h *handle)
1718 {
1719         int ret = 0;
1720         ret = pkgmgrinfo_pkginfo_get_pkginfo(pkgid, handle);
1721         return ret;
1722 }
1723
1724 API int pkgmgr_pkginfo_get_pkgname(pkgmgr_pkginfo_h handle, char **pkg_name)
1725 {
1726         int ret = 0;
1727         ret = pkgmgrinfo_pkginfo_get_pkgname(handle, pkg_name);
1728         return ret;
1729 }
1730
1731
1732 API int pkgmgr_pkginfo_get_pkgid(pkgmgr_pkginfo_h handle, char **pkgid)
1733 {
1734         int ret = 0;
1735         ret = pkgmgrinfo_pkginfo_get_pkgid(handle, pkgid);
1736         return ret;
1737 }
1738
1739 API int pkgmgr_pkginfo_get_type(pkgmgr_pkginfo_h handle, char **type)
1740 {
1741         int ret = 0;
1742         ret = pkgmgrinfo_pkginfo_get_type(handle, type);
1743         return ret;
1744 }
1745
1746 API int pkgmgr_pkginfo_get_version(pkgmgr_pkginfo_h handle, char **version)
1747 {
1748         int ret = 0;
1749         ret = pkgmgrinfo_pkginfo_get_version(handle, version);
1750         return ret;
1751 }
1752
1753 API int pkgmgr_pkginfo_get_install_location(pkgmgr_pkginfo_h handle, pkgmgr_install_location *location)
1754 {
1755         int ret = 0;
1756         pkgmgrinfo_install_location loc;
1757         ret = pkgmgrinfo_pkginfo_get_install_location(handle, &loc);
1758         *location = loc;
1759         return ret;
1760 }
1761
1762 API int pkgmgr_pkginfo_get_package_size(pkgmgr_pkginfo_h handle, int *size)
1763 {
1764         int ret = 0;
1765         ret = pkgmgrinfo_pkginfo_get_package_size(handle, size);
1766         return ret;
1767 }
1768
1769 API int pkgmgr_pkginfo_get_icon(pkgmgr_pkginfo_h handle, char **icon)
1770 {
1771         int ret = 0;
1772         ret = pkgmgrinfo_pkginfo_get_icon(handle, icon);
1773         return ret;
1774 }
1775
1776 API int pkgmgr_pkginfo_get_label(pkgmgr_pkginfo_h handle, char **label)
1777 {
1778         int ret = 0;
1779         ret = pkgmgrinfo_pkginfo_get_label(handle, label);
1780         return ret;
1781 }
1782
1783 API int pkgmgr_pkginfo_get_description(pkgmgr_pkginfo_h handle, char **description)
1784 {
1785         int ret = 0;
1786         ret = pkgmgrinfo_pkginfo_get_description(handle, description);
1787         return ret;
1788 }
1789
1790 API int pkgmgr_pkginfo_get_author_name(pkgmgr_pkginfo_h handle, char **author_name)
1791 {
1792         int ret = 0;
1793         ret = pkgmgrinfo_pkginfo_get_author_name(handle, author_name);
1794         return ret;
1795 }
1796
1797 API int pkgmgr_pkginfo_get_author_email(pkgmgr_pkginfo_h handle, char **author_email)
1798 {
1799         int ret = 0;
1800         ret = pkgmgrinfo_pkginfo_get_author_email(handle, author_email);
1801         return ret;
1802 }
1803
1804 API int pkgmgr_pkginfo_get_author_href(pkgmgr_pkginfo_h handle, char **author_href)
1805 {
1806         int ret = 0;
1807         ret = pkgmgrinfo_pkginfo_get_author_href(handle, author_href);
1808         return ret;
1809 }
1810
1811 API int pkgmgr_pkginfo_is_removable(pkgmgr_pkginfo_h handle, bool *removable)
1812 {
1813         int ret = 0;
1814         ret = pkgmgrinfo_pkginfo_is_removable(handle, removable);
1815         return ret;
1816 }
1817
1818 API int pkgmgr_pkginfo_is_preload(pkgmgr_pkginfo_h handle, bool *preload)
1819 {
1820         int ret = 0;
1821         ret = pkgmgrinfo_pkginfo_is_preload(handle, preload);
1822         return ret;
1823 }
1824
1825 API int pkgmgr_pkginfo_is_readonly(pkgmgr_pkginfo_h handle, bool *readonly)
1826 {
1827         int ret = 0;
1828         ret = pkgmgrinfo_pkginfo_is_readonly(handle, readonly);
1829         return ret;
1830 }
1831
1832 API int pkgmgr_pkginfo_is_accessible(pkgmgr_pkginfo_h handle, bool *accessible)
1833 {
1834         int ret = 0;
1835         ret = pkgmgrinfo_pkginfo_is_accessible(handle, accessible);
1836         return ret;
1837 }
1838
1839 API int pkgmgr_pkginfo_destroy_pkginfo(pkgmgr_pkginfo_h handle)
1840 {
1841         int ret = 0;
1842         ret = pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
1843         return ret;
1844 }
1845
1846 API int pkgmgr_pkginfo_get_installed_storage(pkgmgr_pkginfo_h handle, pkgmgr_installed_storage *storage)
1847 {
1848         int ret = 0;
1849         pkgmgrinfo_installed_storage sto;
1850         ret = pkgmgrinfo_pkginfo_get_installed_storage(handle, &sto);
1851         *storage = sto;
1852         return ret;
1853 }
1854
1855 API int pkgmgr_pkginfo_get_installed_time(pkgmgr_pkginfo_h handle, int *installed_time)
1856 {
1857         int ret = 0;
1858         ret = pkgmgrinfo_pkginfo_get_installed_time(handle, installed_time);
1859         return ret;
1860 }
1861
1862 API int pkgmgr_appinfo_get_list(pkgmgr_pkginfo_h handle, pkgmgr_app_component component,
1863                                                         pkgmgr_info_app_list_cb app_func, void *user_data)
1864 {
1865         int ret = 0;
1866         ret = pkgmgrinfo_appinfo_get_list(handle, component, app_func, user_data);
1867         return ret;
1868 }
1869
1870 API int pkgmgr_appinfo_foreach_category(pkgmgr_appinfo_h handle, pkgmgr_info_app_category_list_cb category_func,
1871                                                         void *user_data)
1872 {
1873         int ret = 0;
1874         ret = pkgmgrinfo_appinfo_foreach_category(handle, category_func, user_data);
1875         return ret;
1876 }
1877
1878 API int pkgmgr_appinfo_get_appinfo(const char *appid, pkgmgr_appinfo_h *handle)
1879 {
1880         int ret = 0;
1881         ret = pkgmgrinfo_appinfo_get_appinfo(appid, handle);
1882         return ret;
1883 }
1884
1885 API int pkgmgr_appinfo_get_appid(pkgmgr_appinfo_h  handle, char **appid)
1886 {
1887         int ret = 0;
1888         ret = pkgmgrinfo_appinfo_get_appid(handle, appid);
1889         return ret;
1890 }
1891
1892 API int pkgmgr_appinfo_get_pkgname(pkgmgr_appinfo_h  handle, char **pkg_name)
1893 {
1894         int ret = 0;
1895         ret = pkgmgrinfo_appinfo_get_pkgname(handle, pkg_name);
1896         return ret;
1897 }
1898
1899 API int pkgmgr_appinfo_get_pkgid(pkgmgr_appinfo_h  handle, char **pkgid)
1900 {
1901         int ret = 0;
1902         ret = pkgmgrinfo_appinfo_get_pkgid(handle, pkgid);
1903         return ret;
1904 }
1905
1906 API int pkgmgr_appinfo_get_icon(pkgmgr_appinfo_h handle, char **icon)
1907 {
1908         int ret = 0;
1909         ret = pkgmgrinfo_appinfo_get_icon(handle, icon);
1910         return ret;
1911 }
1912
1913 API int pkgmgr_appinfo_get_label(pkgmgr_appinfo_h handle, char **label)
1914 {
1915         int ret = 0;
1916         ret = pkgmgrinfo_appinfo_get_label(handle, label);
1917         return ret;
1918 }
1919
1920 API int pkgmgr_appinfo_get_exec(pkgmgr_appinfo_h  handle, char **exec)
1921 {
1922         int ret = 0;
1923         ret = pkgmgrinfo_appinfo_get_exec(handle, exec);
1924         return ret;
1925 }
1926
1927 API int pkgmgr_appinfo_get_component(pkgmgr_appinfo_h  handle, pkgmgr_app_component *component)
1928 {
1929         int ret = 0;
1930         pkgmgrinfo_app_component comp;
1931         ret = pkgmgrinfo_appinfo_get_component(handle, &comp);
1932         *component = comp;
1933         return ret;
1934 }
1935
1936 API int pkgmgr_appinfo_get_apptype(pkgmgr_appinfo_h  handle, char **app_type)
1937 {
1938         int ret = 0;
1939         ret = pkgmgrinfo_appinfo_get_apptype(handle, app_type);
1940         return ret;
1941 }
1942
1943 API int pkgmgr_appinfo_is_nodisplay(pkgmgr_appinfo_h  handle, bool *nodisplay)
1944 {
1945         int ret = 0;
1946         ret = pkgmgrinfo_appinfo_is_nodisplay(handle, nodisplay);
1947         return ret;
1948 }
1949
1950 API int pkgmgr_appinfo_is_multiple(pkgmgr_appinfo_h  handle, bool *multiple)
1951 {
1952         int ret = 0;
1953         ret = pkgmgrinfo_appinfo_is_multiple(handle, multiple);
1954         return ret;
1955 }
1956
1957 API int pkgmgr_appinfo_is_taskmanage(pkgmgr_appinfo_h  handle, bool *taskmanage)
1958 {
1959         int ret = 0;
1960         ret = pkgmgrinfo_appinfo_is_taskmanage(handle, taskmanage);
1961         return ret;
1962 }
1963
1964 API int pkgmgr_appinfo_get_hwacceleration(pkgmgr_appinfo_h  handle, pkgmgr_hwacceleration_type *hwacceleration)
1965 {
1966         int ret = 0;
1967         pkgmgrinfo_app_hwacceleration hwacc;
1968         ret = pkgmgrinfo_appinfo_get_hwacceleration(handle, &hwacc);
1969         *hwacceleration = hwacc;
1970         return ret;
1971 }
1972
1973 API int pkgmgr_appinfo_is_onboot(pkgmgr_appinfo_h  handle, bool *onboot)
1974 {
1975         int ret = 0;
1976         ret = pkgmgrinfo_appinfo_is_onboot(handle, onboot);
1977         return ret;
1978 }
1979
1980 API int pkgmgr_appinfo_is_autorestart(pkgmgr_appinfo_h  handle, bool *autorestart)
1981 {
1982         int ret = 0;
1983         ret = pkgmgrinfo_appinfo_is_autorestart(handle, autorestart);
1984         return ret;
1985 }
1986
1987 API int pkgmgr_appinfo_destroy_appinfo(pkgmgr_appinfo_h  handle)
1988 {
1989         int ret = 0;
1990         ret = pkgmgrinfo_appinfo_destroy_appinfo(handle);
1991         return ret;
1992 }
1993
1994 API int pkgmgr_pkginfo_create_certinfo(pkgmgr_certinfo_h *handle)
1995 {
1996         int ret = 0;
1997         ret = pkgmgrinfo_pkginfo_create_certinfo(handle);
1998         return ret;
1999 }
2000
2001 API int pkgmgr_pkginfo_load_certinfo(const char *pkgid, pkgmgr_certinfo_h handle)
2002 {
2003         int ret = 0;
2004         ret = pkgmgrinfo_pkginfo_load_certinfo(pkgid, handle);
2005         return ret;
2006 }
2007
2008 API int pkgmgr_pkginfo_get_cert_value(pkgmgr_certinfo_h handle, pkgmgr_cert_type cert_type, const char **cert_value)
2009 {
2010         int ret = 0;
2011         ret = pkgmgrinfo_pkginfo_get_cert_value(handle, cert_type, cert_value);
2012         return ret;
2013 }
2014
2015 API int pkgmgr_pkginfo_destroy_certinfo(pkgmgr_certinfo_h handle)
2016 {
2017         int ret = 0;
2018         ret = pkgmgrinfo_pkginfo_destroy_certinfo(handle);
2019         return ret;
2020 }
2021
2022 API int pkgmgr_datacontrol_get_info(const char *providerid, const char * type, char **appid, char **access)
2023 {
2024         int ret = 0;
2025         ret = pkgmgrinfo_datacontrol_get_info(providerid, type, appid, access);
2026         return ret;
2027 }