src/package_manager.c

   1 /*
   2  * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the License);
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an AS IS BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include <stdlib.h>
  18 #include <string.h>
  19 #include <glib.h>
  20 #include <unistd.h>
  21
  22 #include <package-manager.h>
  23 #include <pkgmgr_installer.h>
  24 #include <pkgmgr-info.h>
  25 #include <tzplatform_config.h>
  26
  27 #include "package_manager.h"
  28 #include "package_manager_internal.h"
  29
  30 static GHashTable *__cb_table = NULL;
  31
  32 #define GLOBAL_USER tzplatform_getuid(TZ_SYS_GLOBALAPP_USER)
  33 typedef struct _event_info {
  34         int req_id;
  35         package_manager_event_type_e event_type;
  36         package_manager_event_state_e event_state;
  37         struct _event_info *next;
  38 } event_info;
  39
  40 struct package_manager_s {
  41         int handle_id;
  42         client_type ctype;
  43         pkgmgr_client *pc;
  44         pkgmgr_mode mode;
  45         event_info *head;
  46         package_manager_event_cb event_cb;
  47         package_manager_global_event_cb global_event_cb;
  48         void *global_user_data;
  49         void *user_data;
  50 };
  51
  52 struct package_manager_request_s {
  53         int handle_id;
  54         client_type ctype;
  55         pkgmgr_client *pc;
  56         const char *pkg_type;
  57         const char *pkg_path;
  58         const char *pkg_name;
  59         const char *tep_path;
  60         pkgmgr_mode mode;
  61         event_info *head;
  62         package_manager_request_event_cb event_cb;
  63         bool tep_move;
  64         void *user_data;
  65 };
  66
  67 typedef struct package_size_info {
  68         long long data_size;
  69         long long cache_size;
  70         long long app_size;
  71
  72         long long external_data_size;
  73         long long external_cache_size;
  74         long long external_app_size;
  75 } package_size_info_t;
  76
  77 struct package_manager_filter_s {
  78         pkgmgrinfo_pkginfo_filter_h pkgmgrinfo_pkginfo_filter;
  79 };
  80
  81 static int package_manager_request_new_id()
  82 {
  83         static int request_handle_id = 0;
  84         return request_handle_id++;
  85 }
  86
  87 static int package_manager_new_id()
  88 {
  89         static int manager_handle_id = 0;
  90         return manager_handle_id++;
  91 }
  92
  93 API int package_manager_request_create(package_manager_request_h *request)
  94 {
  95         struct package_manager_request_s *package_manager_request;
  96
  97         if (request == NULL) {
  98                 return
  99                     package_manager_error
 100                     (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
 101                      NULL);
 102         }
 103
 104         package_manager_request =
 105             calloc(1, sizeof(struct package_manager_request_s));
 106         if (package_manager_request == NULL) {
 107                 return
 108                     package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY,
 109                                           __FUNCTION__,
 110                                           "failed to create a package_manager handle");
 111         }
 112
 113         package_manager_request->ctype = PC_REQUEST;
 114         package_manager_request->pc = pkgmgr_client_new(PC_REQUEST);
 115         if (package_manager_request->pc == NULL) {
 116                 free(package_manager_request);
 117                 return
 118                     package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY,
 119                                           __FUNCTION__,
 120                                           "failed to create a package_manager client");
 121         }
 122
 123         package_manager_request->handle_id = package_manager_request_new_id();
 124
 125         *request = package_manager_request;
 126
 127         return PACKAGE_MANAGER_ERROR_NONE;
 128 }
 129
 130 static int package_manager_client_validate_handle(package_manager_request_h
 131                                                  request)
 132 {
 133         if (request == NULL || request->pc == NULL)
 134                 return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
 135
 136         return PACKAGE_MANAGER_ERROR_NONE;
 137 }
 138
 139 API int package_manager_request_destroy(package_manager_request_h request)
 140 {
 141         if (package_manager_client_validate_handle(request)) {
 142                 return
 143                     package_manager_error
 144                     (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
 145                      NULL);
 146         }
 147
 148         pkgmgr_client_free(request->pc);
 149         request->pc = NULL;
 150         free(request);
 151
 152         return PACKAGE_MANAGER_ERROR_NONE;
 153 }
 154
 155 API int package_manager_request_set_event_cb(package_manager_request_h request,
 156                                          package_manager_request_event_cb
 157                                          callback, void *user_data)
 158 {
 159
 160         int retval;
 161         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
 162         if (retval != PACKAGE_MANAGER_ERROR_NONE)
 163                 return retval;
 164
 165         if (package_manager_client_validate_handle(request)) {
 166                 return
 167                     package_manager_error
 168                     (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
 169                      NULL);
 170         }
 171
 172         request->event_cb = callback;
 173         request->user_data = user_data;
 174
 175         return PACKAGE_MANAGER_ERROR_NONE;
 176 }
 177
 178 API int package_manager_request_unset_event_cb(package_manager_request_h request)
 179 {
 180         if (package_manager_client_validate_handle(request))
 181                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 182
 183         request->event_cb = NULL;
 184         request->user_data = NULL;
 185
 186         return PACKAGE_MANAGER_ERROR_NONE;
 187 }
 188
 189 API int package_manager_request_set_type(package_manager_request_h request,
 190                                      const char *pkg_type)
 191 {
 192         if (package_manager_client_validate_handle(request)) {
 193                 return
 194                     package_manager_error
 195                     (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
 196                      NULL);
 197         }
 198
 199         request->pkg_type = pkg_type;
 200
 201         return PACKAGE_MANAGER_ERROR_NONE;
 202 }
 203
 204 API int package_manager_request_set_mode(package_manager_request_h request,
 205                                      package_manager_request_mode_e mode)
 206 {
 207         if (package_manager_client_validate_handle(request)) {
 208                 return
 209                     package_manager_error
 210                     (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
 211                      NULL);
 212         }
 213
 214         if (mode == PACKAGE_MANAGER_REQUEST_MODE_QUIET)
 215                 request->mode = PM_QUIET;
 216         else
 217                 request->mode = PM_DEFAULT;
 218
 219         return PACKAGE_MANAGER_ERROR_NONE;
 220 }
 221
 222 int package_manager_request_set_tep(package_manager_request_h request,
 223                                      const char *tep_path)
 224 {
 225         int retval = 0;
 226
 227         if (package_manager_client_validate_handle(request) || tep_path == NULL) {
 228                 return
 229                         package_manager_error
 230                         (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
 231                          NULL);
 232         }
 233
 234         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_ADMIN);
 235         if (retval != PACKAGE_MANAGER_ERROR_NONE)
 236                 return retval;
 237
 238         if (request->tep_path)
 239                 free((void *)request->tep_path);
 240
 241         request->tep_path = strdup(tep_path);
 242         request->tep_move = true;
 243
 244         if (request ->tep_path == NULL)
 245                 return PACKAGE_MANAGER_ERROR_SYSTEM_ERROR;
 246
 247         return PACKAGE_MANAGER_ERROR_NONE;
 248 }
 249
 250 static int package_manager_get_event_type(const char *key,
 251                                           package_manager_event_type_e *
 252                                           event_type)
 253 {
 254         if (key == NULL)
 255                 return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
 256
 257         if (strcasecmp(key, PKGMGR_INSTALLER_INSTALL_EVENT_STR) == 0)
 258                 *event_type = PACKAGE_MANAGER_EVENT_TYPE_INSTALL;
 259         else if (strcasecmp(key, PKGMGR_INSTALLER_UNINSTALL_EVENT_STR) == 0)
 260                 *event_type = PACKAGE_MANAGER_EVENT_TYPE_UNINSTALL;
 261         else if (strcasecmp(key, PKGMGR_INSTALLER_UPGRADE_EVENT_STR) == 0)
 262                 *event_type = PACKAGE_MANAGER_EVENT_TYPE_UPDATE;
 263         else
 264                 return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
 265
 266         return PACKAGE_MANAGER_ERROR_NONE;
 267 }
 268
 269 static int __add_event_info(event_info **head, int req_id,
 270                             package_manager_event_type_e event_type,
 271                             package_manager_event_state_e event_state)
 272 {
 273         event_info *evt_info;
 274         event_info *current;
 275         event_info *prev;
 276
 277         evt_info = (event_info *) calloc(1, sizeof(event_info));
 278         if (evt_info == NULL) {
 279                 _LOGD("calloc failed");
 280                 return -1;
 281         }
 282         evt_info->req_id = req_id;
 283         evt_info->event_type = event_type;
 284         evt_info->next = NULL;
 285
 286         if (*head == NULL)
 287                 *head = evt_info;
 288         else {
 289                 current = prev = *head;
 290                 while (current) {
 291                         prev = current;
 292                         current = current->next;
 293                 }
 294
 295                 prev->next = evt_info;
 296         }
 297
 298         return 0;
 299 }
 300
 301 static int __find_event_info(event_info **head, int req_id,
 302                              package_manager_event_type_e *event_type,
 303                              package_manager_event_state_e *event_state)
 304 {
 305         event_info *tmp;
 306
 307         tmp = *head;
 308
 309         if (tmp == NULL) {
 310                 _LOGE("tmp is NULL");
 311                 return -1;
 312         }
 313
 314         _LOGD("tmp->req_id %d, event_type %d", tmp->req_id, event_type);
 315
 316         while (tmp) {
 317                 if (tmp->req_id == req_id) {
 318                         *event_type = tmp->event_type;
 319                         return 0;
 320                 }
 321                 tmp = tmp->next;
 322         }
 323         return -1;
 324 }
 325
 326 static int __update_event_info(event_info **head, int req_id,
 327                                package_manager_event_type_e event_type,
 328                                package_manager_event_state_e event_state)
 329 {
 330         package_manager_event_type_e evt_type;
 331         package_manager_event_state_e evt_state;
 332         event_info *tmp;
 333
 334         if (__find_event_info(head, req_id, &evt_type, &evt_state) != 0)
 335                 __add_event_info(head, req_id, event_type, event_state);
 336         else {
 337                 tmp = *head;
 338
 339                 if (tmp == NULL) {
 340                         _LOGE("tmp is NULL");
 341                         return -1;
 342                 }
 343
 344                 while (tmp) {
 345                         if (tmp->req_id == req_id) {
 346                                 tmp->event_type = event_type;
 347                                 return 0;
 348                         }
 349                         tmp = tmp->next;
 350                 }
 351         }
 352
 353         return -1;
 354 }
 355
 356 /*
 357 static int __remove_event_info(event_info **head request, int req_id)
 358 {
 359         event_info *current;
 360         event_info *tmp;
 361
 362         if (* == NULL)
 363                 return -1;
 364
 365         current = *head;
 366         while (current) {
 367                 if (current->next) {
 368                         if (current->next->req_id == req_id) {
 369                                 tmp = current->next;
 370                                 current->next = current->next->next;
 371                                 free(tmp);
 372                                 return 0;
 373                         }
 374                 }
 375                 tmp = tmp->next;
 376         }
 377
 378         return -1;
 379 }
 380 */
 381
 382 static int request_event_handler(uid_t target_uid, int req_id, const char *pkg_type,
 383                                  const char *pkg_name, const char *key,
 384                                  const char *val, const void *pmsg, void *data)
 385 {
 386         int ret = -1;
 387         package_manager_event_type_e event_type = -1;
 388         package_manager_event_state_e event_state = -1;
 389
 390         _LOGD("request_event_handler is called");
 391
 392         package_manager_request_h request = data;
 393
 394         if (strcasecmp(key, "start") == 0) {
 395                 ret = package_manager_get_event_type(val, &event_type);
 396                 if (ret != PACKAGE_MANAGER_ERROR_NONE)
 397                         return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
 398
 399                 __add_event_info(&(request->head), req_id, event_type,
 400                                  PACKAGE_MANAGER_EVENT_STATE_STARTED);
 401
 402                 if (request->event_cb)
 403                         request->event_cb(req_id, pkg_type, pkg_name,
 404                                           event_type,
 405                                           PACKAGE_MANAGER_EVENT_STATE_STARTED,
 406                                           0, PACKAGE_MANAGER_ERROR_NONE, request->user_data);
 407
 408         } else if (strcasecmp(key, "install_percent") == 0
 409                    || strcasecmp(key, "progress_percent") == 0) {
 410                 if (__find_event_info
 411                     (&(request->head), req_id, &event_type,
 412                      &event_state) == 0) {
 413                         __update_event_info(&(request->head), req_id,
 414                                             event_type,
 415                                             PACKAGE_MANAGER_EVENT_STATE_PROCESSING);
 416                         if (request->event_cb)
 417                                 request->event_cb(req_id, pkg_type, pkg_name,
 418                                                   event_type,
 419                                                   PACKAGE_MANAGER_EVENT_STATE_PROCESSING,
 420                                                   atoi(val),
 421                                                   PACKAGE_MANAGER_ERROR_NONE,
 422                                                   request->user_data);
 423                 }
 424
 425         } else if (strcasecmp(key, "error") == 0) {
 426                 if (strcasecmp(key, "0") != 0) {
 427                         if (__find_event_info
 428                             (&(request->head), req_id, &event_type,
 429                              &event_state) == 0) {
 430                                 __update_event_info(&(request->head), req_id,
 431                                                     event_type,
 432                                                     PACKAGE_MANAGER_EVENT_STATE_FAILED);
 433                         }
 434
 435                         if (request->event_cb)
 436                                 request->event_cb(req_id, pkg_type,
 437                                                   pkg_name, event_type,
 438                                                   PACKAGE_MANAGER_EVENT_STATE_FAILED,
 439                                                   0,
 440                                                   PACKAGE_MANAGER_ERROR_NONE,
 441                                                   request->user_data);
 442
 443                 }
 444         } else if (strcasecmp(key, "end") == 0) {
 445                 if (__find_event_info
 446                     (&(request->head), req_id, &event_type,
 447                      &event_state) == 0) {
 448                         if (event_state != PACKAGE_MANAGER_EVENT_STATE_FAILED) {
 449                                 if (request->event_cb)
 450                                         request->event_cb(req_id, pkg_type,
 451                                                           pkg_name, event_type,
 452                                                           PACKAGE_MANAGER_EVENT_STATE_COMPLETED,
 453                                                           100,
 454                                                           PACKAGE_MANAGER_ERROR_NONE,
 455                                                           request->user_data);
 456                         }
 457                 } else {
 458                         if (strcasecmp(key, "ok") != 0)
 459                                 if (request->event_cb)
 460                                         request->event_cb(req_id, pkg_type,
 461                                                           pkg_name, event_type,
 462                                                           PACKAGE_MANAGER_EVENT_STATE_FAILED,
 463                                                           0,
 464                                                           PACKAGE_MANAGER_ERROR_NONE,
 465                                                           request->user_data);
 466                 }
 467         }
 468
 469         return PACKAGE_MANAGER_ERROR_NONE;
 470 }
 471
 472 API int package_manager_request_install(package_manager_request_h request,
 473                                     const char *path, int *id)
 474 {
 475
 476         int retval;
 477         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_ADMIN);
 478         if (retval != PACKAGE_MANAGER_ERROR_NONE)
 479                 return retval;
 480
 481         if (package_manager_client_validate_handle(request))
 482                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 483
 484         if (path == NULL)
 485                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 486
 487         int request_id = 0;
 488         request->pkg_path = path;
 489         uid_t uid = getuid();
 490         if (uid != GLOBAL_USER)
 491                 request_id = pkgmgr_client_usr_install(request->pc, request->pkg_type, NULL,
 492                                                         request->pkg_path, NULL,
 493                                                         request->mode, request_event_handler,
 494                                                         request,
 495                                                         uid);
 496         else
 497                 request_id = pkgmgr_client_install(request->pc, request->pkg_type, NULL,
 498                                                         request->pkg_path, NULL,
 499                                                         request->mode, request_event_handler,
 500                                                         request);
 501
 502         if (request_id == PKGMGR_R_EINVAL)
 503                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 504         else if (request_id == PKGMGR_R_ENOPKG)
 505                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
 506         else if (request_id == PKGMGR_R_ENOMEM)
 507                 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
 508         else if (request_id == PKGMGR_R_EIO)
 509                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
 510         else if (request_id == PKGMGR_R_EPRIV)
 511                 return package_manager_error(PACKAGE_MANAGER_ERROR_PERMISSION_DENIED, __FUNCTION__, NULL);
 512         else if (request_id == PKGMGR_R_ESYSTEM || request_id == PKGMGR_R_ECOMM || request_id == PKGMGR_R_ERROR)
 513                 return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
 514
 515         *id = request_id;
 516
 517         return PACKAGE_MANAGER_ERROR_NONE;
 518 }
 519
 520 API int package_manager_request_uninstall(package_manager_request_h request,
 521                                       const char *name, int *id)
 522 {
 523
 524         int retval;
 525         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_ADMIN);
 526         if (retval != PACKAGE_MANAGER_ERROR_NONE)
 527                 return retval;
 528
 529         if (package_manager_client_validate_handle(request))
 530                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 531
 532         if (name == NULL)
 533                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 534
 535         int request_id = 0;
 536         request->pkg_name = name;
 537         uid_t uid = getuid();
 538         if (uid != GLOBAL_USER)
 539                 request_id = pkgmgr_client_usr_uninstall(request->pc, request->pkg_type,
 540                                                                 request->pkg_name, request->mode,
 541                                                                 request_event_handler, request, uid);
 542         else
 543                 request_id = pkgmgr_client_uninstall(request->pc, request->pkg_type,
 544                                                                 request->pkg_name, request->mode,
 545                                                                 request_event_handler, request);
 546
 547         if (request_id == PKGMGR_R_EINVAL)
 548                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 549         else if (request_id == PKGMGR_R_ENOPKG)
 550                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
 551         else if (request_id == PKGMGR_R_ENOMEM)
 552                 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
 553         else if (request_id == PKGMGR_R_EIO)
 554                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
 555         else if (request_id == PKGMGR_R_EPRIV)
 556                 return package_manager_error(PACKAGE_MANAGER_ERROR_PERMISSION_DENIED, __FUNCTION__, NULL);
 557         else if (request_id == PKGMGR_R_ESYSTEM || request_id == PKGMGR_R_ECOMM || request_id == PKGMGR_R_ERROR)
 558                 return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
 559
 560         *id = request_id;
 561
 562         return PACKAGE_MANAGER_ERROR_NONE;
 563 }
 564
 565 API int package_manager_request_move(package_manager_request_h request,
 566                                     const char *name, package_manager_move_type_e move_type)
 567 {
 568
 569         int retval;
 570         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_ADMIN);
 571         if (retval != PACKAGE_MANAGER_ERROR_NONE)
 572                 return retval;
 573
 574         if (package_manager_client_validate_handle(request))
 575                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 576
 577         if (name == NULL)
 578                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 579
 580         int ret = 0;
 581         request->pkg_name = name;
 582         uid_t uid = getuid();
 583         if (uid != GLOBAL_USER)
 584                 ret = pkgmgr_client_usr_move(request->pc, request->pkg_type, request->pkg_name,
 585                                                         move_type, request->mode, uid);
 586         else
 587                 ret = pkgmgr_client_move(request->pc, request->pkg_type, request->pkg_name,
 588                                                         move_type, request->mode);
 589         if (ret == PKGMGR_R_EINVAL)
 590                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 591         else if (ret == PKGMGR_R_ENOPKG)
 592                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
 593         else if (ret == PKGMGR_R_ENOMEM)
 594                 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
 595         else if (ret == PKGMGR_R_EIO)
 596                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
 597         else if (ret == PKGMGR_R_EPRIV)
 598                 return package_manager_error(PACKAGE_MANAGER_ERROR_PERMISSION_DENIED, __FUNCTION__, NULL);
 599         else if (ret == PKGMGR_R_ESYSTEM || ret == PKGMGR_R_ECOMM || ret == PKGMGR_R_ERROR)
 600                 return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
 601
 602         return PACKAGE_MANAGER_ERROR_NONE;
 603 }
 604
 605 API int package_manager_create(package_manager_h *manager)
 606 {
 607
 608         int retval;
 609         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
 610         if (retval != PACKAGE_MANAGER_ERROR_NONE)
 611                 return retval;
 612
 613         struct package_manager_s *package_manager = NULL;
 614
 615         if (manager == NULL) {
 616                 return
 617                     package_manager_error
 618                     (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
 619                      NULL);
 620         }
 621
 622         package_manager = calloc(1, sizeof(struct package_manager_s));
 623         if (package_manager == NULL) {
 624                 return
 625                     package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY,
 626                                           __FUNCTION__,
 627                                           "failed to create a package_manager handle");
 628         }
 629
 630         package_manager->ctype = PC_LISTENING;
 631         package_manager->pc = pkgmgr_client_new(PC_LISTENING);
 632         if (package_manager->pc == NULL) {
 633                 free(package_manager);
 634                 return
 635                     package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY,
 636                                           __FUNCTION__,
 637                                           "failed to create a package_manager client");
 638         }
 639
 640         package_manager->handle_id = package_manager_new_id();
 641
 642         *manager = package_manager;
 643
 644         return PACKAGE_MANAGER_ERROR_NONE;
 645 }
 646
 647 static int package_manager_validate_handle(package_manager_h manager)
 648 {
 649         if (manager == NULL || manager->pc == NULL)
 650                 return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
 651
 652         return PACKAGE_MANAGER_ERROR_NONE;
 653 }
 654
 655 API int package_manager_destroy(package_manager_h manager)
 656 {
 657         if (package_manager_validate_handle(manager)) {
 658                 return
 659                     package_manager_error
 660                     (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
 661                      NULL);
 662         }
 663
 664         pkgmgr_client_free(manager->pc);
 665         manager->pc = NULL;
 666         free(manager);
 667
 668         return PACKAGE_MANAGER_ERROR_NONE;
 669 }
 670
 671 static int __add_event(event_info **head, int req_id,
 672                             package_manager_event_type_e event_type,
 673                             package_manager_event_state_e event_state)
 674 {
 675         event_info *evt_info;
 676
 677         evt_info = (event_info *) calloc(1, sizeof(event_info));
 678         if (evt_info == NULL) {
 679                 _LOGD("calloc failed");
 680                 return -1;
 681         }
 682         evt_info->req_id = req_id;
 683         evt_info->event_type = event_type;
 684         evt_info->next = NULL;
 685
 686         *head = evt_info;
 687
 688         return 0;
 689 }
 690
 691 static int __find_event(event_info **head, int req_id,
 692                              package_manager_event_type_e *event_type,
 693                              package_manager_event_state_e *event_state)
 694 {
 695         event_info *tmp;
 696
 697         tmp = *head;
 698
 699         if (tmp == NULL) {
 700                 _LOGE("tmp is NULL");
 701                 return -1;
 702         }
 703
 704         *event_type = tmp->event_type;
 705         return 0;
 706 }
 707
 708 static int __update_event(event_info **head, int req_id,
 709                                package_manager_event_type_e event_type,
 710                                package_manager_event_state_e event_state)
 711 {
 712         package_manager_event_type_e evt_type;
 713         package_manager_event_state_e evt_state;
 714         event_info *tmp;
 715
 716         if (__find_event_info(head, req_id, &evt_type, &evt_state) != 0)
 717                 __add_event_info(head, req_id, event_type, event_state);
 718         else {
 719                 tmp = *head;
 720
 721                 if (tmp == NULL) {
 722                         _LOGE("tmp is NULL");
 723                         return -1;
 724                 }
 725
 726                 tmp->event_type = event_type;
 727                 return 0;
 728         }
 729
 730         return -1;
 731 }
 732
 733 /* App Event Listening Policy:
 734  * +----------------+------------+---------------+------------------+
 735  * |Listener \ Type |Global Event|My User's Event|Other user's Event|
 736  * +----------------+------------+---------------+------------------+
 737  * |User Process App|   Grant    |     Grant     |      Deny        |
 738  * +----------------+------------+---------------+------------------+
 739  * |Platform module |   Grant    |     Grant     |      Grant       |
 740  * +----------------+------------+---------------+------------------+
 741  * UID assignment policy:
 742  * https://wiki.tizen.org/wiki/Security/User_and_group_ID_assignment_policy
 743  */
 744 #define REGULAR_USER 5000
 745 static int __validate_event_signal(uid_t target_uid)
 746 {
 747         uid_t self = getuid();
 748
 749         if (self == target_uid)
 750                 return 0;
 751
 752         if (self < REGULAR_USER)
 753                 return 0;
 754
 755         return -1;
 756 }
 757
 758 static int global_event_handler(uid_t target_uid, int req_id, const char *pkg_type,
 759                                 const char *pkg_name, const char *key,
 760                                 const char *val, const void *pmsg, void *data)
 761 {
 762         int ret = -1;
 763         package_manager_event_type_e event_type = -1;
 764         package_manager_event_state_e event_state = -1;
 765         uid_t uid = target_uid;
 766
 767         _LOGD("global_event_handler is called");
 768
 769         package_manager_h manager = data;
 770
 771         if (target_uid == GLOBAL_USER)
 772                 uid = getuid();
 773
 774         if (__validate_event_signal(uid))
 775                 return PACKAGE_MANAGER_ERROR_NONE;
 776
 777         if (strcasecmp(key, "start") == 0) {
 778                 ret = package_manager_get_event_type(val, &event_type);
 779                 if (ret != PACKAGE_MANAGER_ERROR_NONE)
 780                         return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
 781
 782                 __add_event(&(manager->head), req_id, event_type,
 783                                  PACKAGE_MANAGER_EVENT_STATE_STARTED);
 784
 785                 if (manager->event_cb && getuid() == uid)
 786                         manager->event_cb(pkg_type, pkg_name,
 787                                           event_type,
 788                                           PACKAGE_MANAGER_EVENT_STATE_STARTED,
 789                                           0, PACKAGE_MANAGER_ERROR_NONE, manager->user_data);
 790                 if (manager->global_event_cb)
 791                         manager->global_event_cb(target_uid, pkg_type, pkg_name,
 792                                           event_type,
 793                                           PACKAGE_MANAGER_EVENT_STATE_STARTED,
 794                                           0, PACKAGE_MANAGER_ERROR_NONE, manager->global_user_data);
 795
 796         } else if (strcasecmp(key, "install_percent") == 0
 797                    || strcasecmp(key, "progress_percent") == 0) {
 798                 if (__find_event
 799                     (&(manager->head), req_id, &event_type,
 800                      &event_state) == 0) {
 801                         __update_event(&(manager->head), req_id,
 802                                             event_type,
 803                                             PACKAGE_MANAGER_EVENT_STATE_PROCESSING);
 804                         if (manager->event_cb && getuid() == uid)
 805                                 manager->event_cb(pkg_type, pkg_name,
 806                                                   event_type,
 807                                                   PACKAGE_MANAGER_EVENT_STATE_PROCESSING,
 808                                                   atoi(val),
 809                                                   PACKAGE_MANAGER_ERROR_NONE,
 810                                                   manager->user_data);
 811                         if (manager->global_event_cb)
 812                                 manager->global_event_cb(target_uid, pkg_type, pkg_name,
 813                                                   event_type,
 814                                                   PACKAGE_MANAGER_EVENT_STATE_PROCESSING,
 815                                                   atoi(val),
 816                                                   PACKAGE_MANAGER_ERROR_NONE,
 817                                                   manager->global_user_data);
 818                 }
 819
 820         } else if (strcasecmp(key, "error") == 0) {
 821                 if (strcasecmp(key, "0") != 0) {
 822                         if (__find_event
 823                             (&(manager->head), req_id, &event_type,
 824                              &event_state) == 0) {
 825                                 __update_event(&(manager->head), req_id,
 826                                                     event_type,
 827                                                     PACKAGE_MANAGER_EVENT_STATE_FAILED);
 828                         }
 829
 830                         if (manager->event_cb && getuid() == uid)
 831                                 manager->event_cb(pkg_type,
 832                                                   pkg_name, event_type,
 833                                                   PACKAGE_MANAGER_EVENT_STATE_FAILED,
 834                                                   0,
 835                                                   PACKAGE_MANAGER_ERROR_NONE,
 836                                                   manager->user_data);
 837                         if (manager->global_event_cb)
 838                                 manager->global_event_cb(target_uid, pkg_type,
 839                                                   pkg_name, event_type,
 840                                                   PACKAGE_MANAGER_EVENT_STATE_FAILED,
 841                                                   0,
 842                                                   PACKAGE_MANAGER_ERROR_NONE,
 843                                                   manager->global_user_data);
 844                 }
 845         } else if (strcasecmp(key, "end") == 0) {
 846                 if (__find_event
 847                     (&(manager->head), req_id, &event_type,
 848                      &event_state) == 0) {
 849                         if (event_state != PACKAGE_MANAGER_EVENT_STATE_FAILED) {
 850                                 if (manager->event_cb && getuid() == uid)
 851                                         manager->event_cb(pkg_type,
 852                                                           pkg_name, event_type,
 853                                                           PACKAGE_MANAGER_EVENT_STATE_COMPLETED,
 854                                                           100,
 855                                                           PACKAGE_MANAGER_ERROR_NONE,
 856                                                           manager->user_data);
 857                                 if (manager->global_event_cb)
 858                                         manager->global_event_cb(target_uid, pkg_type,
 859                                                           pkg_name, event_type,
 860                                                           PACKAGE_MANAGER_EVENT_STATE_COMPLETED,
 861                                                           100,
 862                                                           PACKAGE_MANAGER_ERROR_NONE,
 863                                                           manager->global_user_data);
 864                         }
 865                 } else {
 866                         if (strcasecmp(key, "ok") != 0) {
 867                                 if (manager->event_cb && getuid() == uid)
 868                                         manager->event_cb(pkg_type,
 869                                                           pkg_name, event_type,
 870                                                           PACKAGE_MANAGER_EVENT_STATE_FAILED,
 871                                                           0,
 872                                                           PACKAGE_MANAGER_ERROR_NONE,
 873                                                           manager->user_data);
 874                                 if (manager->global_event_cb)
 875                                         manager->global_event_cb(target_uid, pkg_type,
 876                                                           pkg_name, event_type,
 877                                                           PACKAGE_MANAGER_EVENT_STATE_FAILED,
 878                                                           0,
 879                                                           PACKAGE_MANAGER_ERROR_NONE,
 880                                                           manager->global_user_data);
 881                         }
 882                 }
 883         }
 884
 885         return PACKAGE_MANAGER_ERROR_NONE;
 886 }
 887
 888 API int package_manager_set_event_status(package_manager_h manager, int status_type)
 889 {
 890         int retval;
 891
 892         if (manager == NULL)
 893                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 894
 895         retval = pkgmgrinfo_client_set_status_type(manager->pc, status_type);
 896
 897         if (retval < 0)
 898                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
 899
 900         return PACKAGE_MANAGER_ERROR_NONE;
 901 }
 902
 903 API int package_manager_set_event_cb(package_manager_h manager,
 904                                  package_manager_event_cb callback,
 905                                  void *user_data)
 906 {
 907
 908         int retval;
 909         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
 910         if (retval != PACKAGE_MANAGER_ERROR_NONE)
 911                 return retval;
 912
 913         if (package_manager_validate_handle(manager)) {
 914                 return
 915                     package_manager_error
 916                     (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
 917                      NULL);
 918         }
 919
 920         manager->event_cb = callback;
 921         manager->user_data = user_data;
 922
 923         pkgmgr_client_listen_status(manager->pc, global_event_handler, manager);
 924
 925         return PACKAGE_MANAGER_ERROR_NONE;
 926 }
 927
 928 API int package_manager_unset_event_cb(package_manager_h manager)
 929 {
 930         if (manager == NULL) {
 931                 return
 932                     package_manager_error
 933                     (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
 934                      NULL);
 935         }
 936
 937         int retval;
 938         manager->event_cb = NULL;
 939         manager->user_data = NULL;
 940
 941         if (manager->global_event_cb == NULL) {
 942                 retval = pkgmgr_client_remove_listen_status(manager->pc);
 943                 if (retval == PKGMGR_R_EINVAL)
 944                         return
 945                                  package_manager_error
 946                                  (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
 947                                   NULL);
 948                 else if (retval == PKGMGR_R_ERROR)
 949                         return
 950                                  package_manager_error
 951                                  (PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__,
 952                                   NULL);
 953         }
 954
 955         return PACKAGE_MANAGER_ERROR_NONE;
 956 }
 957
 958 API int package_manager_set_global_event_cb(package_manager_h manager,
 959                                  package_manager_global_event_cb callback,
 960                                  void *user_data)
 961 {
 962
 963         int retval;
 964         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
 965         if (retval != PACKAGE_MANAGER_ERROR_NONE)
 966                 return retval;
 967
 968         if (package_manager_validate_handle(manager)) {
 969                 return
 970                     package_manager_error
 971                     (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
 972                      NULL);
 973         }
 974
 975         if (getuid() >= REGULAR_USER) {
 976                 _LOGE("Regular user is not allowed for this api");
 977                 return PACKAGE_MANAGER_ERROR_PERMISSION_DENIED;
 978         }
 979
 980         manager->global_event_cb = callback;
 981         manager->global_user_data = user_data;
 982
 983         pkgmgr_client_listen_status(manager->pc, global_event_handler, manager);
 984
 985         return PACKAGE_MANAGER_ERROR_NONE;
 986 }
 987
 988 API int package_manager_unset_global_event_cb(package_manager_h manager)
 989 {
 990         int retval;
 991
 992         if (manager == NULL) {
 993                 return
 994                     package_manager_error
 995                     (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
 996                      NULL);
 997         }
 998
 999         manager->global_event_cb = NULL;
1000         manager->global_user_data = NULL;
1001
1002         if (manager->event_cb == NULL) {
1003                 retval = pkgmgr_client_remove_listen_status(manager->pc);
1004                 if (retval == PKGMGR_R_EINVAL)
1005                         return
1006                                  package_manager_error
1007                                  (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
1008                                   NULL);
1009                 else if (retval == PKGMGR_R_ERROR)
1010                         return
1011                                  package_manager_error
1012                                  (PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__,
1013                                   NULL);
1014         }
1015
1016         return PACKAGE_MANAGER_ERROR_NONE;
1017 }
1018
1019 API int package_manager_get_package_id_by_app_id(const char *app_id, char **package_id)
1020 {
1021         pkgmgrinfo_appinfo_h pkgmgrinfo_appinfo;
1022         int retval;
1023         char *pkg_id = NULL;
1024         char *pkg_id_dup = NULL;
1025
1026         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
1027         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1028                 return retval;
1029
1030         if (app_id == NULL || package_id == NULL)
1031                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1032
1033         uid_t uid = getuid();
1034         if (uid != GLOBAL_USER) {
1035                 if (pkgmgrinfo_appinfo_get_usr_appinfo(app_id, uid, &pkgmgrinfo_appinfo) != PMINFO_R_OK)
1036                         return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1037         } else {
1038                 if (pkgmgrinfo_appinfo_get_appinfo(app_id, &pkgmgrinfo_appinfo) != PMINFO_R_OK)
1039                         return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1040         }
1041         retval = pkgmgrinfo_appinfo_get_pkgname(pkgmgrinfo_appinfo, &pkg_id);
1042         if (retval != PMINFO_R_OK)
1043                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1044
1045         pkg_id_dup = strdup(pkg_id);
1046         if (pkg_id_dup == NULL) {
1047                 pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
1048                 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
1049         }
1050
1051         *package_id = pkg_id_dup;
1052
1053         pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
1054
1055         return PACKAGE_MANAGER_ERROR_NONE;
1056 }
1057
1058 API int package_manager_get_package_info(const char *package_id, package_info_h *package_info)
1059 {
1060         int retval;
1061         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
1062         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1063                 return retval;
1064
1065         retval = package_info_get_package_info(package_id, package_info);
1066
1067         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1068                 return package_manager_error(retval, __FUNCTION__, NULL);
1069         else
1070                 return PACKAGE_MANAGER_ERROR_NONE;
1071 }
1072
1073 API int package_manager_foreach_package_info(package_manager_package_info_cb callback,
1074                                         void *user_data)
1075 {
1076
1077         int retval;
1078         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
1079         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1080                 return retval;
1081
1082         retval = package_info_foreach_package_info(callback, user_data);
1083
1084         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1085                 return package_manager_error(retval, __FUNCTION__, NULL);
1086         else
1087                 return PACKAGE_MANAGER_ERROR_NONE;
1088 }
1089
1090 API int package_manager_compare_package_cert_info(const char *lhs_package_id, const char *rhs_package_id, package_manager_compare_result_type_e *compare_result)
1091 {
1092         pkgmgrinfo_cert_compare_result_type_e result;
1093         uid_t uid = getuid();
1094
1095         if (lhs_package_id == NULL || rhs_package_id == NULL || compare_result == NULL)
1096                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1097         if (uid != GLOBAL_USER) {
1098                 if (pkgmgrinfo_pkginfo_compare_usr_pkg_cert_info(lhs_package_id, rhs_package_id, uid, &result) != PKGMGR_R_OK)
1099                         return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
1100         } else {
1101                 if (pkgmgrinfo_pkginfo_compare_pkg_cert_info(lhs_package_id, rhs_package_id, &result) != PKGMGR_R_OK)
1102                         return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
1103         }
1104         *compare_result = (package_manager_compare_result_type_e)result;
1105
1106         return PACKAGE_MANAGER_ERROR_NONE;
1107 }
1108
1109 API int package_manager_compare_app_cert_info(const char *lhs_app_id, const char *rhs_app_id, package_manager_compare_result_type_e *compare_result)
1110 {
1111         pkgmgrinfo_cert_compare_result_type_e result;
1112         uid_t uid = getuid();
1113
1114         if (lhs_app_id == NULL || rhs_app_id == NULL || compare_result == NULL)
1115                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1116         if (uid != GLOBAL_USER) {
1117                 if (pkgmgrinfo_pkginfo_compare_usr_app_cert_info(lhs_app_id, rhs_app_id, uid, &result) != PKGMGR_R_OK)
1118                         return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
1119         } else {
1120                 if (pkgmgrinfo_pkginfo_compare_app_cert_info(lhs_app_id, rhs_app_id, &result) != PKGMGR_R_OK)
1121                         return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
1122         }
1123
1124         *compare_result = (package_manager_compare_result_type_e)result;
1125
1126         return PACKAGE_MANAGER_ERROR_NONE;
1127 }
1128
1129 API int package_manager_is_preload_package_by_app_id(const char *app_id, bool *preload)
1130 {
1131
1132         int retval;
1133         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
1134         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1135                 return retval;
1136
1137         pkgmgrinfo_appinfo_h pkgmgrinfo_appinfo = NULL;
1138         pkgmgrinfo_pkginfo_h pkgmgrinfo_pkginfo = NULL;
1139
1140         char *pkg_id = NULL;
1141         bool is_preload = 0;
1142         uid_t uid = getuid();
1143         if (uid != GLOBAL_USER) {
1144                 if (pkgmgrinfo_appinfo_get_usr_appinfo(app_id, uid, &pkgmgrinfo_appinfo) != PMINFO_R_OK)
1145                         return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1146         } else {
1147                 if (pkgmgrinfo_appinfo_get_appinfo(app_id, &pkgmgrinfo_appinfo) != PMINFO_R_OK)
1148                         return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1149         }
1150
1151         retval = pkgmgrinfo_appinfo_get_pkgname(pkgmgrinfo_appinfo, &pkg_id);
1152         if (retval != PMINFO_R_OK) {
1153                 pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
1154                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1155         }
1156         if (uid != GLOBAL_USER) {
1157                 if (pkgmgrinfo_pkginfo_get_usr_pkginfo(pkg_id, uid, &pkgmgrinfo_pkginfo) != PMINFO_R_OK) {
1158                         pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
1159                         pkgmgrinfo_pkginfo_destroy_pkginfo(pkgmgrinfo_pkginfo);
1160                         return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1161                 }
1162         } else {
1163                 if (pkgmgrinfo_pkginfo_get_pkginfo(pkg_id, &pkgmgrinfo_pkginfo) != PMINFO_R_OK) {
1164                         pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
1165                         pkgmgrinfo_pkginfo_destroy_pkginfo(pkgmgrinfo_pkginfo);
1166                         return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1167                 }
1168         }
1169         if (pkgmgrinfo_pkginfo_is_preload(pkgmgrinfo_pkginfo, &is_preload) != PMINFO_R_OK) {
1170                 pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
1171                 pkgmgrinfo_pkginfo_destroy_pkginfo(pkgmgrinfo_pkginfo);
1172                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1173         }
1174
1175         if (is_preload)
1176                 *preload = 1;
1177         else
1178                 *preload = 0;
1179
1180         pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
1181         pkgmgrinfo_pkginfo_destroy_pkginfo(pkgmgrinfo_pkginfo);
1182
1183         return PACKAGE_MANAGER_ERROR_NONE;
1184 }
1185
1186 API int package_manager_get_permission_type(const char *app_id, package_manager_permission_type_e *permission_type)
1187 {
1188
1189         int retval;
1190         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
1191         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1192                 return retval;
1193
1194         pkgmgrinfo_appinfo_h pkgmgrinfo_appinfo = NULL;
1195         pkgmgrinfo_permission_type permission = 0;
1196         uid_t uid = getuid();
1197         if (uid != GLOBAL_USER) {
1198                 if (pkgmgrinfo_appinfo_get_usr_appinfo(app_id, uid, &pkgmgrinfo_appinfo) != PMINFO_R_OK)
1199                         return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1200         } else {
1201                 if (pkgmgrinfo_appinfo_get_appinfo(app_id, &pkgmgrinfo_appinfo) != PMINFO_R_OK)
1202                         return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1203         }
1204         retval = pkgmgrinfo_appinfo_get_permission_type(pkgmgrinfo_appinfo, &permission);
1205         if (retval != PMINFO_R_OK)
1206                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1207
1208         if (permission == PMINFO_PERMISSION_NORMAL)
1209                 *permission_type = PACKAGE_MANAGER_PERMISSION_NORMAL;
1210         else if (permission == PMINFO_PERMISSION_SIGNATURE)
1211                 *permission_type = PACKAGE_MANAGER_PERMISSION_SIGNATURE;
1212         else if (permission == PMINFO_PERMISSION_PRIVILEGE)
1213                 *permission_type = PACKAGE_MANAGER_PERMISSION_PRIVILEGE;
1214         else
1215                 *permission_type = PACKAGE_MANAGER_PERMISSION_NORMAL;
1216
1217         pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
1218         return PACKAGE_MANAGER_ERROR_NONE;
1219 }
1220
1221 API int package_manager_clear_cache_dir(const char *package_id)
1222 {
1223
1224         int retval;
1225         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_CACHE);
1226         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1227                 return retval;
1228
1229         int res = pkgmgr_client_usr_clear_cache_dir(package_id, getuid());
1230         if (res == PKGMGR_R_EINVAL) {
1231                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1232         } else if (res == PKGMGR_R_ENOPKG) {
1233                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1234         } else if (res == PKGMGR_R_ENOMEM) {
1235                 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
1236         } else if (res == PKGMGR_R_EIO) {
1237                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
1238         } else if (res == PKGMGR_R_EPRIV) {
1239                 return package_manager_error(PACKAGE_MANAGER_ERROR_PERMISSION_DENIED, __FUNCTION__, NULL);
1240         } else if (res == PKGMGR_R_ESYSTEM || res == PKGMGR_R_ECOMM || res == PKGMGR_R_ERROR) {
1241                 return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
1242         } else if (res != PKGMGR_R_OK) {
1243                 _LOGE("Unexpected error");
1244                 return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
1245         }
1246
1247         return PACKAGE_MANAGER_ERROR_NONE;
1248 }
1249
1250 API int package_manager_clear_all_cache_dir(void)
1251 {
1252
1253         int retval;
1254         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_ADMIN);
1255         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1256                 return retval;
1257
1258         return package_manager_clear_cache_dir(PKG_CLEAR_ALL_CACHE);
1259 }
1260
1261 static void __free_client(gpointer data)
1262 {
1263         pkgmgr_client *pc = (pkgmgr_client *)data;
1264         pkgmgr_client_free(pc);
1265 }
1266
1267 static void __initialize_cb_table(void)
1268 {
1269         __cb_table = g_hash_table_new_full(g_int_hash, g_int_equal, __free_client, NULL);
1270 }
1271
1272 static void __result_cb(pkgmgr_client *pc, const char *pkgid, const pkg_size_info_t *result, void *user_data)
1273 {
1274         package_manager_size_info_receive_cb callback = g_hash_table_lookup(__cb_table, pc);
1275         if (callback == NULL) {
1276                 _LOGE("callback is null.");
1277                 g_hash_table_remove(__cb_table, pc);
1278                 return;
1279         }
1280
1281         package_size_info_t size_info;
1282         size_info.data_size  = result->data_size;
1283         size_info.cache_size = result->cache_size;
1284         size_info.app_size   = result->app_size;
1285         size_info.external_data_size  = result->ext_data_size;
1286         size_info.external_cache_size = result->ext_cache_size;
1287         size_info.external_app_size   = result->ext_app_size;
1288
1289         callback(pkgid, (package_size_info_h)&size_info, user_data);
1290
1291         g_hash_table_remove(__cb_table, pc);
1292 }
1293
1294 static void __total_result_cb(pkgmgr_client *pc, const pkg_size_info_t *result, void *user_data)
1295 {
1296         package_manager_total_size_info_receive_cb callback = g_hash_table_lookup(__cb_table, pc);
1297         if (callback == NULL) {
1298                 _LOGE("callback is null.");
1299                 g_hash_table_remove(__cb_table, pc);
1300                 return;
1301         }
1302
1303         package_size_info_t size_info;
1304         size_info.data_size  = result->data_size;
1305         size_info.cache_size = result->cache_size;
1306         size_info.app_size   = result->app_size;
1307         size_info.external_data_size  = result->ext_data_size;
1308         size_info.external_cache_size = result->ext_cache_size;
1309         size_info.external_app_size   = result->ext_app_size;
1310
1311         callback((package_size_info_h)&size_info, user_data);
1312
1313         g_hash_table_remove(__cb_table, pc);
1314 }
1315
1316 static int _get_pkg_size_info(const char *package_id, void *callback, void *user_data)
1317 {
1318         if (package_id == NULL || callback == NULL)
1319                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1320
1321         if (__cb_table == NULL)
1322                 __initialize_cb_table();
1323
1324         pkgmgr_client *pc = pkgmgr_client_new(PC_REQUEST);
1325         if (pc == NULL)
1326                 return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
1327
1328         int res = 0;
1329         if (strcmp(package_id, PKG_SIZE_INFO_TOTAL) != 0)
1330                 res = pkgmgr_client_usr_get_package_size_info(pc, package_id, __result_cb, user_data, getuid());
1331         else
1332                 res = pkgmgr_client_usr_get_total_package_size_info(pc, __total_result_cb, user_data, getuid());
1333
1334         if (res == PKGMGR_R_EINVAL) {
1335                 pkgmgr_client_free(pc);
1336                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1337         } else if (res == PKGMGR_R_ENOPKG) {
1338                 pkgmgr_client_free(pc);
1339                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1340         } else if (res == PKGMGR_R_ENOMEM) {
1341                 pkgmgr_client_free(pc);
1342                 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
1343         } else if (res == PKGMGR_R_EIO) {
1344                 pkgmgr_client_free(pc);
1345                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
1346         } else if (res == PKGMGR_R_EPRIV) {
1347                 pkgmgr_client_free(pc);
1348                 return package_manager_error(PACKAGE_MANAGER_ERROR_PERMISSION_DENIED, __FUNCTION__, NULL);
1349         } else if (res == PKGMGR_R_ESYSTEM || res == PKGMGR_R_ECOMM || res == PKGMGR_R_ERROR) {
1350                 pkgmgr_client_free(pc);
1351                 return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
1352         } else if (res != PKGMGR_R_OK) {
1353                 _LOGE("Unexpected error");
1354                 pkgmgr_client_free(pc);
1355                 return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
1356         }
1357
1358         g_hash_table_insert(__cb_table, pc, callback);
1359
1360         _LOGD("Successful");
1361         return PACKAGE_MANAGER_ERROR_NONE;
1362 }
1363
1364 API int package_manager_get_package_size_info(const char *package_id, package_manager_size_info_receive_cb callback, void *user_data)
1365 {
1366         return _get_pkg_size_info(package_id, (void *)callback, user_data);
1367 }
1368
1369 API int package_manager_get_total_package_size_info(package_manager_total_size_info_receive_cb callback, void *user_data)
1370 {
1371         return _get_pkg_size_info(PKG_SIZE_INFO_TOTAL, (void *)callback, user_data);
1372 }
1373
1374 API int package_manager_filter_create(package_manager_filter_h *handle)
1375 {
1376         int retval;
1377         pkgmgrinfo_pkginfo_filter_h pkgmgr_filter = NULL;
1378
1379         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
1380         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1381                 return retval;
1382
1383         if (handle == NULL) {
1384                 return
1385                     package_manager_error
1386                     (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
1387                      NULL);
1388         }
1389
1390         retval = pkgmgrinfo_pkginfo_filter_create(&pkgmgr_filter);
1391         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1392                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
1393
1394         *handle = pkgmgr_filter;
1395
1396         return PACKAGE_MANAGER_ERROR_NONE;
1397 }
1398
1399 API int package_manager_filter_destroy(package_manager_filter_h handle)
1400 {
1401         int retval;
1402
1403         if (handle == NULL) {
1404                 return
1405                     package_manager_error
1406                     (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
1407                      NULL);
1408         }
1409
1410         retval = pkgmgrinfo_pkginfo_filter_destroy(handle);
1411         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1412                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
1413
1414         return PACKAGE_MANAGER_ERROR_NONE;
1415 }
1416
1417 API int package_manager_filter_add_bool(package_manager_filter_h handle,
1418                 const char *property, const bool value)
1419 {
1420         int retval;
1421
1422         if ((handle == NULL) || (property == NULL)) {
1423                 return
1424                     package_manager_error
1425                     (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
1426                      NULL);
1427         }
1428
1429         retval = pkgmgrinfo_pkginfo_filter_add_bool(handle, property, value);
1430         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1431                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
1432
1433         return PACKAGE_MANAGER_ERROR_NONE;
1434 }
1435
1436 API int package_manager_filter_count(package_manager_filter_h handle, int *count)
1437 {
1438
1439         int retval;
1440         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
1441         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1442                 return retval;
1443
1444         if ((handle == NULL) || (count == NULL))
1445                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1446
1447         retval = pkgmgrinfo_pkginfo_filter_count(handle, count);
1448         if (retval < 0)
1449                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
1450
1451         return PACKAGE_MANAGER_ERROR_NONE;
1452 }
1453
1454 API int package_manager_filter_foreach_package_info(package_manager_filter_h handle,
1455                 package_manager_package_info_cb callback, void *user_data)
1456 {
1457
1458         int retval;
1459         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
1460         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1461                 return retval;
1462
1463         retval = package_info_filter_foreach_package_info(handle, callback, user_data);
1464
1465         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1466                 return package_manager_error(retval, __FUNCTION__, NULL);
1467         else
1468                 return PACKAGE_MANAGER_ERROR_NONE;
1469 }
1470
1471 API int package_size_info_get_data_size(package_size_info_h handle, long long *data_size)
1472 {
1473         if (handle == NULL)
1474                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1475
1476         package_size_info_t *size_info = (package_size_info_t *)handle;
1477
1478         *data_size = (long long)size_info->data_size;
1479         return PACKAGE_MANAGER_ERROR_NONE;
1480 }
1481
1482 API int package_size_info_get_cache_size(package_size_info_h handle, long long *cache_size)
1483 {
1484         if (handle == NULL)
1485                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1486
1487         package_size_info_t *size_info = (package_size_info_t *)handle;
1488
1489         *cache_size = size_info->cache_size;
1490         return PACKAGE_MANAGER_ERROR_NONE;
1491 }
1492
1493 API int package_size_info_get_app_size(package_size_info_h handle, long long *app_size)
1494 {
1495         if (handle == NULL)
1496                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1497
1498         package_size_info_t *size_info = (package_size_info_t *)handle;
1499         *app_size = size_info->app_size;
1500         return PACKAGE_MANAGER_ERROR_NONE;
1501 }
1502
1503 API int package_size_info_get_external_data_size(package_size_info_h handle, long long *ext_data_size)
1504 {
1505         if (handle == NULL)
1506                 return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
1507
1508         package_size_info_t *size_info = (package_size_info_t *)handle;
1509         *ext_data_size = size_info->external_data_size;
1510         return PACKAGE_MANAGER_ERROR_NONE;
1511 }
1512
1513 API int package_size_info_get_external_cache_size(package_size_info_h handle, long long *ext_cache_size)
1514 {
1515         if (handle == NULL)
1516                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1517
1518         package_size_info_t *size_info = (package_size_info_t *)handle;
1519         *ext_cache_size = size_info->external_cache_size;
1520         return PACKAGE_MANAGER_ERROR_NONE;
1521 }
1522
1523 API int package_size_info_get_external_app_size(package_size_info_h handle, long long *ext_app_size)
1524 {
1525         if (handle == NULL)
1526                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1527
1528         package_size_info_t *size_info = (package_size_info_t *)handle;
1529         *ext_app_size = size_info->external_app_size;
1530         return PACKAGE_MANAGER_ERROR_NONE;
1531 }