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