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