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