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