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