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->event_state = event_state;
 648         evt_info->next = NULL;
 649
 650         *head = evt_info;
 651
 652         return 0;
 653 }
 654
 655 static int __find_event(event_info **head, int req_id,
 656                              package_manager_event_type_e *event_type,
 657                              package_manager_event_state_e *event_state)
 658 {
 659         event_info *tmp;
 660
 661         tmp = *head;
 662
 663         if (tmp == NULL) {
 664                 _LOGE("tmp is NULL");
 665                 return -1;
 666         }
 667
 668         *event_type = tmp->event_type;
 669         *event_state = tmp->event_state;
 670         return 0;
 671 }
 672
 673 static int __update_event(event_info **head, int req_id,
 674                                package_manager_event_type_e event_type,
 675                                package_manager_event_state_e event_state)
 676 {
 677         package_manager_event_type_e evt_type;
 678         package_manager_event_state_e evt_state;
 679         event_info *tmp;
 680
 681         if (__find_event_info(head, req_id, &evt_type, &evt_state) != 0)
 682                 __add_event_info(head, req_id, event_type, event_state);
 683         else {
 684                 tmp = *head;
 685
 686                 if (tmp == NULL) {
 687                         _LOGE("tmp is NULL");
 688                         return -1;
 689                 }
 690
 691                 tmp->event_type = event_type;
 692                 tmp->event_state = event_state;
 693                 return 0;
 694         }
 695
 696         return -1;
 697 }
 698
 699 /* App Event Listening Policy:
 700  * +----------------+------------+---------------+------------------+
 701  * |Listener \ Type |Global Event|My User's Event|Other user's Event|
 702  * +----------------+------------+---------------+------------------+
 703  * |User Process App|   Grant    |     Grant     |      Deny        |
 704  * +----------------+------------+---------------+------------------+
 705  * |Platform module |   Grant    |     Grant     |      Grant       |
 706  * +----------------+------------+---------------+------------------+
 707  * UID assignment policy:
 708  * https://wiki.tizen.org/wiki/Security/User_and_group_ID_assignment_policy
 709  */
 710 #define REGULAR_USER 5000
 711 static int __validate_event_signal(uid_t target_uid)
 712 {
 713         uid_t self = getuid();
 714
 715         if (self == target_uid)
 716                 return 0;
 717
 718         if (self < REGULAR_USER)
 719                 return 0;
 720
 721         return -1;
 722 }
 723
 724 static int global_event_handler(uid_t target_uid, int req_id, const char *pkg_type,
 725                                 const char *pkg_name, const char *key,
 726                                 const char *val, const void *pmsg, void *data)
 727 {
 728         int ret = -1;
 729         package_manager_event_type_e event_type = -1;
 730         package_manager_event_state_e event_state = -1;
 731         uid_t uid = target_uid;
 732
 733         _LOGD("global_event_handler is called");
 734
 735         package_manager_h manager = data;
 736
 737         if (target_uid == GLOBAL_USER)
 738                 uid = getuid();
 739
 740         if (__validate_event_signal(uid))
 741                 return PACKAGE_MANAGER_ERROR_NONE;
 742
 743         if (strcasecmp(key, "start") == 0) {
 744                 ret = package_manager_get_event_type(val, &event_type);
 745                 if (ret != PACKAGE_MANAGER_ERROR_NONE)
 746                         return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
 747
 748                 __add_event(&(manager->head), req_id, event_type,
 749                                  PACKAGE_MANAGER_EVENT_STATE_STARTED);
 750
 751                 if (manager->event_cb && getuid() == uid)
 752                         manager->event_cb(pkg_type, pkg_name,
 753                                           event_type,
 754                                           PACKAGE_MANAGER_EVENT_STATE_STARTED,
 755                                           0, PACKAGE_MANAGER_ERROR_NONE, manager->user_data);
 756         } else if (strcasecmp(key, "install_percent") == 0
 757                    || strcasecmp(key, "progress_percent") == 0) {
 758                 if (__find_event
 759                     (&(manager->head), req_id, &event_type,
 760                      &event_state) == 0) {
 761                         __update_event(&(manager->head), req_id,
 762                                             event_type,
 763                                             PACKAGE_MANAGER_EVENT_STATE_PROCESSING);
 764                         if (manager->event_cb && getuid() == uid)
 765                                 manager->event_cb(pkg_type, pkg_name,
 766                                                   event_type,
 767                                                   PACKAGE_MANAGER_EVENT_STATE_PROCESSING,
 768                                                   atoi(val),
 769                                                   PACKAGE_MANAGER_ERROR_NONE,
 770                                                   manager->user_data);
 771                 }
 772
 773         } else if (strcasecmp(key, "error") == 0) {
 774                 if (strcasecmp(key, "0") != 0) {
 775                         if (__find_event
 776                             (&(manager->head), req_id, &event_type,
 777                              &event_state) == 0) {
 778                                 __update_event(&(manager->head), req_id,
 779                                                     event_type,
 780                                                     PACKAGE_MANAGER_EVENT_STATE_FAILED);
 781                         }
 782
 783                         if (manager->event_cb && getuid() == uid)
 784                                 manager->event_cb(pkg_type,
 785                                                   pkg_name, event_type,
 786                                                   PACKAGE_MANAGER_EVENT_STATE_FAILED,
 787                                                   0,
 788                                                   PACKAGE_MANAGER_ERROR_NONE,
 789                                                   manager->user_data);
 790                 }
 791         } else if (strcasecmp(key, "end") == 0) {
 792                 if (__find_event
 793                     (&(manager->head), req_id, &event_type,
 794                      &event_state) == 0) {
 795                         if (event_state != PACKAGE_MANAGER_EVENT_STATE_FAILED) {
 796                                 if (manager->event_cb && getuid() == uid)
 797                                         manager->event_cb(pkg_type,
 798                                                           pkg_name, event_type,
 799                                                           PACKAGE_MANAGER_EVENT_STATE_COMPLETED,
 800                                                           100,
 801                                                           PACKAGE_MANAGER_ERROR_NONE,
 802                                                           manager->user_data);
 803                         }
 804                 } else {
 805                         if (strcasecmp(key, "ok") != 0) {
 806                                 if (manager->event_cb && getuid() == uid)
 807                                         manager->event_cb(pkg_type,
 808                                                           pkg_name, event_type,
 809                                                           PACKAGE_MANAGER_EVENT_STATE_FAILED,
 810                                                           0,
 811                                                           PACKAGE_MANAGER_ERROR_NONE,
 812                                                           manager->user_data);
 813                         }
 814                 }
 815         }
 816
 817         return PACKAGE_MANAGER_ERROR_NONE;
 818 }
 819
 820 API int package_manager_set_event_status(package_manager_h manager, int status_type)
 821 {
 822         int retval;
 823
 824         if (manager == NULL)
 825                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 826
 827         retval = pkgmgrinfo_client_set_status_type(manager->pc, status_type);
 828
 829         if (retval < 0)
 830                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
 831
 832         return PACKAGE_MANAGER_ERROR_NONE;
 833 }
 834
 835 API int package_manager_set_event_cb(package_manager_h manager,
 836                                  package_manager_event_cb callback,
 837                                  void *user_data)
 838 {
 839
 840         int retval;
 841         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
 842         if (retval != PACKAGE_MANAGER_ERROR_NONE)
 843                 return retval;
 844
 845         if (package_manager_validate_handle(manager)) {
 846                 return
 847                     package_manager_error
 848                     (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
 849                      NULL);
 850         }
 851
 852         manager->event_cb = callback;
 853         manager->user_data = user_data;
 854
 855         pkgmgr_client_listen_status(manager->pc, global_event_handler, manager);
 856
 857         return PACKAGE_MANAGER_ERROR_NONE;
 858 }
 859
 860 API int package_manager_unset_event_cb(package_manager_h manager)
 861 {
 862         if (manager == NULL) {
 863                 return
 864                     package_manager_error
 865                     (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
 866                      NULL);
 867         }
 868
 869         int retval;
 870         manager->event_cb = NULL;
 871         manager->user_data = NULL;
 872
 873         retval = pkgmgr_client_remove_listen_status(manager->pc);
 874         if (retval == PKGMGR_R_EINVAL)
 875                 return
 876                          package_manager_error
 877                          (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
 878                           NULL);
 879         else if (retval == PKGMGR_R_ERROR)
 880                 return
 881                          package_manager_error
 882                          (PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__,
 883                           NULL);
 884
 885         return PACKAGE_MANAGER_ERROR_NONE;
 886 }
 887
 888 API int package_manager_get_package_id_by_app_id(const char *app_id, char **package_id)
 889 {
 890         pkgmgrinfo_appinfo_h pkgmgrinfo_appinfo;
 891         int retval;
 892         char *pkg_id = NULL;
 893         char *pkg_id_dup = NULL;
 894
 895         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
 896         if (retval != PACKAGE_MANAGER_ERROR_NONE)
 897                 return retval;
 898
 899         if (app_id == NULL || package_id == NULL)
 900                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 901
 902         if (pkgmgrinfo_appinfo_get_appinfo(app_id, &pkgmgrinfo_appinfo) != PMINFO_R_OK)
 903                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
 904         retval = pkgmgrinfo_appinfo_get_pkgname(pkgmgrinfo_appinfo, &pkg_id);
 905         if (retval != PMINFO_R_OK)
 906                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
 907
 908         pkg_id_dup = strdup(pkg_id);
 909         if (pkg_id_dup == NULL) {
 910                 pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
 911                 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
 912         }
 913
 914         *package_id = pkg_id_dup;
 915
 916         pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
 917
 918         return PACKAGE_MANAGER_ERROR_NONE;
 919 }
 920
 921 API int package_manager_get_package_info(const char *package_id, package_info_h *package_info)
 922 {
 923         int retval;
 924         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
 925         if (retval != PACKAGE_MANAGER_ERROR_NONE)
 926                 return retval;
 927
 928         retval = package_info_get_package_info(package_id, package_info);
 929
 930         if (retval != PACKAGE_MANAGER_ERROR_NONE)
 931                 return package_manager_error(retval, __FUNCTION__, NULL);
 932         else
 933                 return PACKAGE_MANAGER_ERROR_NONE;
 934 }
 935
 936 API int package_manager_foreach_package_info(package_manager_package_info_cb callback,
 937                                         void *user_data)
 938 {
 939
 940         int retval;
 941         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
 942         if (retval != PACKAGE_MANAGER_ERROR_NONE)
 943                 return retval;
 944
 945         retval = package_info_foreach_package_info(callback, user_data);
 946
 947         if (retval != PACKAGE_MANAGER_ERROR_NONE)
 948                 return package_manager_error(retval, __FUNCTION__, NULL);
 949         else
 950                 return PACKAGE_MANAGER_ERROR_NONE;
 951 }
 952
 953 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)
 954 {
 955         pkgmgrinfo_cert_compare_result_type_e result;
 956
 957         if (lhs_package_id == NULL || rhs_package_id == NULL || compare_result == NULL)
 958                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 959         if (pkgmgrinfo_pkginfo_compare_pkg_cert_info(lhs_package_id, rhs_package_id, &result) != PKGMGR_R_OK)
 960                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
 961         *compare_result = (package_manager_compare_result_type_e)result;
 962
 963         return PACKAGE_MANAGER_ERROR_NONE;
 964 }
 965
 966 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)
 967 {
 968         pkgmgrinfo_cert_compare_result_type_e result;
 969
 970         if (lhs_app_id == NULL || rhs_app_id == NULL || compare_result == NULL)
 971                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 972         if (pkgmgrinfo_pkginfo_compare_app_cert_info(lhs_app_id, rhs_app_id, &result) != PKGMGR_R_OK)
 973                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
 974
 975         *compare_result = (package_manager_compare_result_type_e)result;
 976
 977         return PACKAGE_MANAGER_ERROR_NONE;
 978 }
 979
 980 API int package_manager_is_preload_package_by_app_id(const char *app_id, bool *preload)
 981 {
 982
 983         int retval;
 984         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
 985         if (retval != PACKAGE_MANAGER_ERROR_NONE)
 986                 return retval;
 987
 988         pkgmgrinfo_appinfo_h pkgmgrinfo_appinfo = NULL;
 989         pkgmgrinfo_pkginfo_h pkgmgrinfo_pkginfo = NULL;
 990
 991         char *pkg_id = NULL;
 992         bool is_preload = 0;
 993         if (pkgmgrinfo_appinfo_get_appinfo(app_id, &pkgmgrinfo_appinfo) != PMINFO_R_OK)
 994                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
 995
 996         retval = pkgmgrinfo_appinfo_get_pkgname(pkgmgrinfo_appinfo, &pkg_id);
 997         if (retval != PMINFO_R_OK) {
 998                 pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
 999                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1000         }
1001         if (pkgmgrinfo_pkginfo_get_pkginfo(pkg_id, &pkgmgrinfo_pkginfo) != PMINFO_R_OK) {
1002                 pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
1003                 pkgmgrinfo_pkginfo_destroy_pkginfo(pkgmgrinfo_pkginfo);
1004                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1005         }
1006         if (pkgmgrinfo_pkginfo_is_preload(pkgmgrinfo_pkginfo, &is_preload) != PMINFO_R_OK) {
1007                 pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
1008                 pkgmgrinfo_pkginfo_destroy_pkginfo(pkgmgrinfo_pkginfo);
1009                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1010         }
1011
1012         if (is_preload)
1013                 *preload = 1;
1014         else
1015                 *preload = 0;
1016
1017         pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
1018         pkgmgrinfo_pkginfo_destroy_pkginfo(pkgmgrinfo_pkginfo);
1019
1020         return PACKAGE_MANAGER_ERROR_NONE;
1021 }
1022
1023 API int package_manager_get_permission_type(const char *app_id, package_manager_permission_type_e *permission_type)
1024 {
1025
1026         int retval;
1027         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
1028         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1029                 return retval;
1030
1031         pkgmgrinfo_appinfo_h pkgmgrinfo_appinfo = NULL;
1032         pkgmgrinfo_permission_type permission = 0;
1033         if (pkgmgrinfo_appinfo_get_appinfo(app_id, &pkgmgrinfo_appinfo) != PMINFO_R_OK)
1034                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1035         retval = pkgmgrinfo_appinfo_get_permission_type(pkgmgrinfo_appinfo, &permission);
1036         if (retval != PMINFO_R_OK)
1037                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1038
1039         if (permission == PMINFO_PERMISSION_NORMAL)
1040                 *permission_type = PACKAGE_MANAGER_PERMISSION_NORMAL;
1041         else if (permission == PMINFO_PERMISSION_SIGNATURE)
1042                 *permission_type = PACKAGE_MANAGER_PERMISSION_SIGNATURE;
1043         else if (permission == PMINFO_PERMISSION_PRIVILEGE)
1044                 *permission_type = PACKAGE_MANAGER_PERMISSION_PRIVILEGE;
1045         else
1046                 *permission_type = PACKAGE_MANAGER_PERMISSION_NORMAL;
1047
1048         pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
1049         return PACKAGE_MANAGER_ERROR_NONE;
1050 }
1051
1052 API int package_manager_clear_cache_dir(const char *package_id)
1053 {
1054
1055         int retval;
1056         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_CACHE);
1057         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1058                 return retval;
1059
1060         int res = pkgmgr_client_clear_cache_dir(package_id);
1061         if (res == PKGMGR_R_EINVAL) {
1062                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1063         } else if (res == PKGMGR_R_ENOPKG) {
1064                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1065         } else if (res == PKGMGR_R_ENOMEM) {
1066                 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
1067         } else if (res == PKGMGR_R_EIO) {
1068                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
1069         } else if (res == PKGMGR_R_EPRIV) {
1070                 return package_manager_error(PACKAGE_MANAGER_ERROR_PERMISSION_DENIED, __FUNCTION__, NULL);
1071         } else if (res == PKGMGR_R_ESYSTEM || res == PKGMGR_R_ECOMM || res == PKGMGR_R_ERROR) {
1072                 return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
1073         } else if (res != PKGMGR_R_OK) {
1074                 _LOGE("Unexpected error");
1075                 return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
1076         }
1077
1078         return PACKAGE_MANAGER_ERROR_NONE;
1079 }
1080
1081 API int package_manager_clear_all_cache_dir(void)
1082 {
1083
1084         int retval;
1085         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_ADMIN);
1086         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1087                 return retval;
1088
1089         return package_manager_clear_cache_dir(PKG_CLEAR_ALL_CACHE);
1090 }
1091
1092 static void __free_client(gpointer data)
1093 {
1094         pkgmgr_client *pc = (pkgmgr_client *)data;
1095         pkgmgr_client_free(pc);
1096 }
1097
1098 static void __initialize_cb_table(void)
1099 {
1100         __cb_table = g_hash_table_new_full(g_direct_hash, g_direct_equal, __free_client, NULL);
1101 }
1102
1103 static void __result_cb(pkgmgr_client *pc, const char *pkgid, const pkg_size_info_t *result, void *user_data)
1104 {
1105         package_manager_size_info_receive_cb callback = g_hash_table_lookup(__cb_table, pc);
1106         if (callback == NULL) {
1107                 _LOGE("callback is null.");
1108                 g_hash_table_remove(__cb_table, pc);
1109                 return;
1110         }
1111
1112         package_size_info_t size_info;
1113         size_info.data_size  = result->data_size;
1114         size_info.cache_size = result->cache_size;
1115         size_info.app_size   = result->app_size;
1116         size_info.external_data_size  = result->ext_data_size;
1117         size_info.external_cache_size = result->ext_cache_size;
1118         size_info.external_app_size   = result->ext_app_size;
1119
1120         callback(pkgid, (package_size_info_h)&size_info, user_data);
1121
1122         g_hash_table_remove(__cb_table, pc);
1123 }
1124
1125 static void __total_result_cb(pkgmgr_client *pc, const pkg_size_info_t *result, void *user_data)
1126 {
1127         package_manager_total_size_info_receive_cb callback = g_hash_table_lookup(__cb_table, pc);
1128         if (callback == NULL) {
1129                 _LOGE("callback is null.");
1130                 g_hash_table_remove(__cb_table, pc);
1131                 return;
1132         }
1133
1134         package_size_info_t size_info;
1135         size_info.data_size  = result->data_size;
1136         size_info.cache_size = result->cache_size;
1137         size_info.app_size   = result->app_size;
1138         size_info.external_data_size  = result->ext_data_size;
1139         size_info.external_cache_size = result->ext_cache_size;
1140         size_info.external_app_size   = result->ext_app_size;
1141
1142         callback((package_size_info_h)&size_info, user_data);
1143
1144         g_hash_table_remove(__cb_table, pc);
1145 }
1146
1147 static int _get_pkg_size_info(const char *package_id, void *callback, void *user_data)
1148 {
1149         if (package_id == NULL || callback == NULL)
1150                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1151
1152         if (__cb_table == NULL)
1153                 __initialize_cb_table();
1154
1155         pkgmgr_client *pc = pkgmgr_client_new(PC_REQUEST);
1156         if (pc == NULL)
1157                 return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
1158
1159         int res = 0;
1160         if (strcmp(package_id, PKG_SIZE_INFO_TOTAL) != 0)
1161                 res = pkgmgr_client_get_package_size_info(pc, package_id, __result_cb, user_data);
1162         else
1163                 res = pkgmgr_client_get_total_package_size_info(pc, __total_result_cb, user_data);
1164
1165         if (res == PKGMGR_R_EINVAL) {
1166                 pkgmgr_client_free(pc);
1167                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1168         } else if (res == PKGMGR_R_ENOPKG) {
1169                 pkgmgr_client_free(pc);
1170                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1171         } else if (res == PKGMGR_R_ENOMEM) {
1172                 pkgmgr_client_free(pc);
1173                 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
1174         } else if (res == PKGMGR_R_EIO) {
1175                 pkgmgr_client_free(pc);
1176                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
1177         } else if (res == PKGMGR_R_EPRIV) {
1178                 pkgmgr_client_free(pc);
1179                 return package_manager_error(PACKAGE_MANAGER_ERROR_PERMISSION_DENIED, __FUNCTION__, NULL);
1180         } else if (res == PKGMGR_R_ESYSTEM || res == PKGMGR_R_ECOMM || res == PKGMGR_R_ERROR) {
1181                 pkgmgr_client_free(pc);
1182                 return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
1183         } else if (res != PKGMGR_R_OK) {
1184                 _LOGE("Unexpected error");
1185                 pkgmgr_client_free(pc);
1186                 return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
1187         }
1188
1189         g_hash_table_insert(__cb_table, pc, callback);
1190
1191         _LOGD("Successful");
1192         return PACKAGE_MANAGER_ERROR_NONE;
1193 }
1194
1195 API int package_manager_get_package_size_info(const char *package_id, package_manager_size_info_receive_cb callback, void *user_data)
1196 {
1197         return _get_pkg_size_info(package_id, (void *)callback, user_data);
1198 }
1199
1200 API int package_manager_get_total_package_size_info(package_manager_total_size_info_receive_cb callback, void *user_data)
1201 {
1202         return _get_pkg_size_info(PKG_SIZE_INFO_TOTAL, (void *)callback, user_data);
1203 }
1204
1205 API int package_manager_filter_create(package_manager_filter_h *handle)
1206 {
1207         int retval;
1208         pkgmgrinfo_pkginfo_filter_h pkgmgr_filter = NULL;
1209
1210         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
1211         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1212                 return retval;
1213
1214         if (handle == NULL) {
1215                 return
1216                     package_manager_error
1217                     (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
1218                      NULL);
1219         }
1220
1221         retval = pkgmgrinfo_pkginfo_filter_create(&pkgmgr_filter);
1222         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1223                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
1224
1225         *handle = pkgmgr_filter;
1226
1227         return PACKAGE_MANAGER_ERROR_NONE;
1228 }
1229
1230 API int package_manager_filter_destroy(package_manager_filter_h handle)
1231 {
1232         int retval;
1233
1234         if (handle == NULL) {
1235                 return
1236                     package_manager_error
1237                     (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
1238                      NULL);
1239         }
1240
1241         retval = pkgmgrinfo_pkginfo_filter_destroy(handle);
1242         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1243                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
1244
1245         return PACKAGE_MANAGER_ERROR_NONE;
1246 }
1247
1248 API int package_manager_filter_add_bool(package_manager_filter_h handle,
1249                 const char *property, const bool value)
1250 {
1251         int retval;
1252
1253         if ((handle == NULL) || (property == NULL)) {
1254                 return
1255                     package_manager_error
1256                     (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
1257                      NULL);
1258         }
1259
1260         retval = pkgmgrinfo_pkginfo_filter_add_bool(handle, property, value);
1261         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1262                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
1263
1264         return PACKAGE_MANAGER_ERROR_NONE;
1265 }
1266
1267 API int package_manager_filter_count(package_manager_filter_h handle, int *count)
1268 {
1269
1270         int retval;
1271         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
1272         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1273                 return retval;
1274
1275         if ((handle == NULL) || (count == NULL))
1276                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1277
1278         retval = pkgmgrinfo_pkginfo_filter_count(handle, count);
1279         if (retval < 0)
1280                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
1281
1282         return PACKAGE_MANAGER_ERROR_NONE;
1283 }
1284
1285 API int package_manager_filter_foreach_package_info(package_manager_filter_h handle,
1286                 package_manager_package_info_cb callback, void *user_data)
1287 {
1288
1289         int retval;
1290         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
1291         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1292                 return retval;
1293
1294         retval = package_info_filter_foreach_package_info(handle, callback, user_data);
1295
1296         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1297                 return package_manager_error(retval, __FUNCTION__, NULL);
1298         else
1299                 return PACKAGE_MANAGER_ERROR_NONE;
1300 }
1301
1302 API int package_size_info_get_data_size(package_size_info_h handle, long long *data_size)
1303 {
1304         if (handle == NULL)
1305                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1306
1307         package_size_info_t *size_info = (package_size_info_t *)handle;
1308
1309         *data_size = (long long)size_info->data_size;
1310         return PACKAGE_MANAGER_ERROR_NONE;
1311 }
1312
1313 API int package_size_info_get_cache_size(package_size_info_h handle, long long *cache_size)
1314 {
1315         if (handle == NULL)
1316                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1317
1318         package_size_info_t *size_info = (package_size_info_t *)handle;
1319
1320         *cache_size = size_info->cache_size;
1321         return PACKAGE_MANAGER_ERROR_NONE;
1322 }
1323
1324 API int package_size_info_get_app_size(package_size_info_h handle, long long *app_size)
1325 {
1326         if (handle == NULL)
1327                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1328
1329         package_size_info_t *size_info = (package_size_info_t *)handle;
1330         *app_size = size_info->app_size;
1331         return PACKAGE_MANAGER_ERROR_NONE;
1332 }
1333
1334 API int package_size_info_get_external_data_size(package_size_info_h handle, long long *ext_data_size)
1335 {
1336         if (handle == NULL)
1337                 return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
1338
1339         package_size_info_t *size_info = (package_size_info_t *)handle;
1340         *ext_data_size = size_info->external_data_size;
1341         return PACKAGE_MANAGER_ERROR_NONE;
1342 }
1343
1344 API int package_size_info_get_external_cache_size(package_size_info_h handle, long long *ext_cache_size)
1345 {
1346         if (handle == NULL)
1347                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1348
1349         package_size_info_t *size_info = (package_size_info_t *)handle;
1350         *ext_cache_size = size_info->external_cache_size;
1351         return PACKAGE_MANAGER_ERROR_NONE;
1352 }
1353
1354 API int package_size_info_get_external_app_size(package_size_info_h handle, long long *ext_app_size)
1355 {
1356         if (handle == NULL)
1357                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1358
1359         package_size_info_t *size_info = (package_size_info_t *)handle;
1360         *ext_app_size = size_info->external_app_size;
1361         return PACKAGE_MANAGER_ERROR_NONE;
1362 }