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         package_manager_global_event_cb global_event_cb;
  48         void *user_data;
  49 };
  50
  51 struct package_manager_request_s {
  52         int handle_id;
  53         client_type ctype;
  54         pkgmgr_client *pc;
  55         const char *pkg_type;
  56         const char *pkg_path;
  57         const char *pkg_name;
  58         const char *tep_path;
  59         pkgmgr_mode mode;
  60         event_info *head;
  61         package_manager_request_event_cb event_cb;
  62         bool tep_move;
  63         void *user_data;
  64 };
  65
  66 typedef struct package_size_info {
  67         long long data_size;
  68         long long cache_size;
  69         long long app_size;
  70
  71         long long external_data_size;
  72         long long external_cache_size;
  73         long long external_app_size;
  74 } package_size_info_t;
  75
  76 struct package_manager_filter_s {
  77         pkgmgrinfo_pkginfo_filter_h pkgmgrinfo_pkginfo_filter;
  78 };
  79
  80 static int package_manager_request_new_id()
  81 {
  82         static int request_handle_id = 0;
  83         return request_handle_id++;
  84 }
  85
  86 static int package_manager_new_id()
  87 {
  88         static int manager_handle_id = 0;
  89         return manager_handle_id++;
  90 }
  91
  92 API int package_manager_request_create(package_manager_request_h *request)
  93 {
  94         struct package_manager_request_s *package_manager_request;
  95
  96         if (request == NULL) {
  97                 return
  98                     package_manager_error
  99                     (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
 100                      NULL);
 101         }
 102
 103         package_manager_request =
 104             calloc(1, sizeof(struct package_manager_request_s));
 105         if (package_manager_request == NULL) {
 106                 return
 107                     package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY,
 108                                           __FUNCTION__,
 109                                           "failed to create a package_manager handle");
 110         }
 111
 112         package_manager_request->ctype = PC_REQUEST;
 113         package_manager_request->pc = pkgmgr_client_new(PC_REQUEST);
 114         if (package_manager_request->pc == NULL) {
 115                 free(package_manager_request);
 116                 return
 117                     package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY,
 118                                           __FUNCTION__,
 119                                           "failed to create a package_manager client");
 120         }
 121
 122         package_manager_request->handle_id = package_manager_request_new_id();
 123
 124         *request = package_manager_request;
 125
 126         return PACKAGE_MANAGER_ERROR_NONE;
 127 }
 128
 129 static int package_manager_client_validate_handle(package_manager_request_h
 130                                                  request)
 131 {
 132         if (request == NULL || request->pc == NULL)
 133                 return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
 134
 135         return PACKAGE_MANAGER_ERROR_NONE;
 136 }
 137
 138 API int package_manager_request_destroy(package_manager_request_h request)
 139 {
 140         if (package_manager_client_validate_handle(request)) {
 141                 return
 142                     package_manager_error
 143                     (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
 144                      NULL);
 145         }
 146
 147         pkgmgr_client_free(request->pc);
 148         request->pc = NULL;
 149         free(request);
 150
 151         return PACKAGE_MANAGER_ERROR_NONE;
 152 }
 153
 154 API int package_manager_request_set_event_cb(package_manager_request_h request,
 155                                          package_manager_request_event_cb
 156                                          callback, void *user_data)
 157 {
 158
 159         int retval;
 160         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
 161         if (retval != PACKAGE_MANAGER_ERROR_NONE)
 162                 return retval;
 163
 164         if (package_manager_client_validate_handle(request)) {
 165                 return
 166                     package_manager_error
 167                     (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
 168                      NULL);
 169         }
 170
 171         request->event_cb = callback;
 172         request->user_data = user_data;
 173
 174         return PACKAGE_MANAGER_ERROR_NONE;
 175 }
 176
 177 API int package_manager_request_unset_event_cb(package_manager_request_h request)
 178 {
 179         /* TODO: Please implement this function. */
 180         if (package_manager_client_validate_handle(request))
 181                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 182
 183         return PACKAGE_MANAGER_ERROR_NONE;
 184 }
 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 = 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 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((void *)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         request->pkg_path = path;
 487         uid_t uid = getuid();
 488         if (uid != GLOBAL_USER)
 489                 request_id = pkgmgr_client_usr_install(request->pc, request->pkg_type, NULL,
 490                                                         request->pkg_path, NULL,
 491                                                         request->mode, request_event_handler,
 492                                                         request,
 493                                                         uid);
 494         else
 495                 request_id = pkgmgr_client_install(request->pc, request->pkg_type, NULL,
 496                                                         request->pkg_path, NULL,
 497                                                         request->mode, request_event_handler,
 498                                                         request);
 499
 500         if (request_id == PKGMGR_R_EINVAL)
 501                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 502         else if (request_id == PKGMGR_R_ENOPKG)
 503                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
 504         else if (request_id == PKGMGR_R_ENOMEM)
 505                 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
 506         else if (request_id == PKGMGR_R_EIO)
 507                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
 508         else if (request_id == PKGMGR_R_EPRIV)
 509                 return package_manager_error(PACKAGE_MANAGER_ERROR_PERMISSION_DENIED, __FUNCTION__, NULL);
 510         else if (request_id == PKGMGR_R_ESYSTEM || request_id == PKGMGR_R_ECOMM || request_id == PKGMGR_R_ERROR)
 511                 return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
 512
 513         *id = request_id;
 514
 515         return PACKAGE_MANAGER_ERROR_NONE;
 516 }
 517
 518 API int package_manager_request_uninstall(package_manager_request_h request,
 519                                       const char *name, int *id)
 520 {
 521
 522         int retval;
 523         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_ADMIN);
 524         if (retval != PACKAGE_MANAGER_ERROR_NONE)
 525                 return retval;
 526
 527         if (package_manager_client_validate_handle(request))
 528                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 529
 530         if (name == NULL)
 531                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 532
 533         int request_id = 0;
 534         request->pkg_name = name;
 535         uid_t uid = getuid();
 536         if (uid != GLOBAL_USER)
 537                 request_id = pkgmgr_client_usr_uninstall(request->pc, request->pkg_type,
 538                                                                 request->pkg_name, request->mode,
 539                                                                 request_event_handler, request, uid);
 540         else
 541                 request_id = pkgmgr_client_uninstall(request->pc, request->pkg_type,
 542                                                                 request->pkg_name, request->mode,
 543                                                                 request_event_handler, request);
 544
 545         if (request_id == PKGMGR_R_EINVAL)
 546                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 547         else if (request_id == PKGMGR_R_ENOPKG)
 548                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
 549         else if (request_id == PKGMGR_R_ENOMEM)
 550                 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
 551         else if (request_id == PKGMGR_R_EIO)
 552                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
 553         else if (request_id == PKGMGR_R_EPRIV)
 554                 return package_manager_error(PACKAGE_MANAGER_ERROR_PERMISSION_DENIED, __FUNCTION__, NULL);
 555         else if (request_id == PKGMGR_R_ESYSTEM || request_id == PKGMGR_R_ECOMM || request_id == PKGMGR_R_ERROR)
 556                 return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
 557
 558         *id = request_id;
 559
 560         return PACKAGE_MANAGER_ERROR_NONE;
 561 }
 562
 563 API int package_manager_request_move(package_manager_request_h request,
 564                                     const char *name, package_manager_move_type_e move_type)
 565 {
 566
 567         int retval;
 568         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_ADMIN);
 569         if (retval != PACKAGE_MANAGER_ERROR_NONE)
 570                 return retval;
 571
 572         if (package_manager_client_validate_handle(request))
 573                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 574
 575         if (name == NULL)
 576                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 577
 578         int ret = 0;
 579         request->pkg_name = name;
 580         uid_t uid = getuid();
 581         if (uid != GLOBAL_USER)
 582                 ret = pkgmgr_client_usr_move(request->pc, request->pkg_type, request->pkg_name,
 583                                                         move_type, request->mode, uid);
 584         else
 585                 ret = pkgmgr_client_move(request->pc, request->pkg_type, request->pkg_name,
 586                                                         move_type, request->mode);
 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                 if (manager->global_event_cb)
 789                         manager->global_event_cb(target_uid, pkg_type, pkg_name,
 790                                           event_type,
 791                                           PACKAGE_MANAGER_EVENT_STATE_STARTED,
 792                                           0, PACKAGE_MANAGER_ERROR_NONE, manager->user_data);
 793
 794         } else if (strcasecmp(key, "install_percent") == 0
 795                    || strcasecmp(key, "progress_percent") == 0) {
 796                 if (__find_event
 797                     (&(manager->head), req_id, &event_type,
 798                      &event_state) == 0) {
 799                         __update_event(&(manager->head), req_id,
 800                                             event_type,
 801                                             PACKAGE_MANAGER_EVENT_STATE_PROCESSING);
 802                         if (manager->event_cb && getuid() == uid)
 803                                 manager->event_cb(pkg_type, pkg_name,
 804                                                   event_type,
 805                                                   PACKAGE_MANAGER_EVENT_STATE_PROCESSING,
 806                                                   atoi(val),
 807                                                   PACKAGE_MANAGER_ERROR_NONE,
 808                                                   manager->user_data);
 809                         if (manager->global_event_cb)
 810                                 manager->global_event_cb(target_uid, pkg_type, pkg_name,
 811                                                   event_type,
 812                                                   PACKAGE_MANAGER_EVENT_STATE_PROCESSING,
 813                                                   atoi(val),
 814                                                   PACKAGE_MANAGER_ERROR_NONE,
 815                                                   manager->user_data);
 816                 }
 817
 818         } else if (strcasecmp(key, "error") == 0) {
 819                 if (strcasecmp(key, "0") != 0) {
 820                         if (__find_event
 821                             (&(manager->head), req_id, &event_type,
 822                              &event_state) == 0) {
 823                                 __update_event(&(manager->head), req_id,
 824                                                     event_type,
 825                                                     PACKAGE_MANAGER_EVENT_STATE_FAILED);
 826                         }
 827
 828                         if (manager->event_cb && getuid() == uid)
 829                                 manager->event_cb(pkg_type,
 830                                                   pkg_name, event_type,
 831                                                   PACKAGE_MANAGER_EVENT_STATE_FAILED,
 832                                                   0,
 833                                                   PACKAGE_MANAGER_ERROR_NONE,
 834                                                   manager->user_data);
 835                         if (manager->global_event_cb)
 836                                 manager->global_event_cb(target_uid, pkg_type,
 837                                                   pkg_name, event_type,
 838                                                   PACKAGE_MANAGER_EVENT_STATE_FAILED,
 839                                                   0,
 840                                                   PACKAGE_MANAGER_ERROR_NONE,
 841                                                   manager->user_data);
 842                 }
 843         } else if (strcasecmp(key, "end") == 0) {
 844                 if (__find_event
 845                     (&(manager->head), req_id, &event_type,
 846                      &event_state) == 0) {
 847                         if (event_state != PACKAGE_MANAGER_EVENT_STATE_FAILED) {
 848                                 if (manager->event_cb && getuid() == uid)
 849                                         manager->event_cb(pkg_type,
 850                                                           pkg_name, event_type,
 851                                                           PACKAGE_MANAGER_EVENT_STATE_COMPLETED,
 852                                                           100,
 853                                                           PACKAGE_MANAGER_ERROR_NONE,
 854                                                           manager->user_data);
 855                                 if (manager->global_event_cb)
 856                                         manager->global_event_cb(target_uid, pkg_type,
 857                                                           pkg_name, event_type,
 858                                                           PACKAGE_MANAGER_EVENT_STATE_COMPLETED,
 859                                                           100,
 860                                                           PACKAGE_MANAGER_ERROR_NONE,
 861                                                           manager->user_data);
 862                         }
 863                 } else {
 864                         if (strcasecmp(key, "ok") != 0) {
 865                                 if (manager->event_cb && getuid() == uid)
 866                                         manager->event_cb(pkg_type,
 867                                                           pkg_name, event_type,
 868                                                           PACKAGE_MANAGER_EVENT_STATE_FAILED,
 869                                                           0,
 870                                                           PACKAGE_MANAGER_ERROR_NONE,
 871                                                           manager->user_data);
 872                                 if (manager->global_event_cb)
 873                                         manager->global_event_cb(target_uid, pkg_type,
 874                                                           pkg_name, event_type,
 875                                                           PACKAGE_MANAGER_EVENT_STATE_FAILED,
 876                                                           0,
 877                                                           PACKAGE_MANAGER_ERROR_NONE,
 878                                                           manager->user_data);
 879                         }
 880                 }
 881         }
 882
 883         return PACKAGE_MANAGER_ERROR_NONE;
 884 }
 885
 886 API int package_manager_set_event_status(package_manager_h manager, int status_type)
 887 {
 888         int retval;
 889
 890         if (manager == NULL)
 891                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 892
 893         retval = pkgmgrinfo_client_set_status_type(manager->pc, status_type);
 894
 895         if (retval < 0)
 896                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
 897
 898         return PACKAGE_MANAGER_ERROR_NONE;
 899 }
 900
 901 API int package_manager_set_event_cb(package_manager_h manager,
 902                                  package_manager_event_cb callback,
 903                                  void *user_data)
 904 {
 905
 906         int retval;
 907         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
 908         if (retval != PACKAGE_MANAGER_ERROR_NONE)
 909                 return retval;
 910
 911         if (package_manager_validate_handle(manager)) {
 912                 return
 913                     package_manager_error
 914                     (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
 915                      NULL);
 916         }
 917
 918         manager->event_cb = callback;
 919         manager->user_data = user_data;
 920
 921         pkgmgr_client_listen_status(manager->pc, global_event_handler, manager);
 922
 923         return PACKAGE_MANAGER_ERROR_NONE;
 924 }
 925
 926 API int package_manager_unset_event_cb(package_manager_h manager)
 927 {
 928         if (manager == NULL) {
 929                 return
 930                     package_manager_error
 931                     (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
 932                      NULL);
 933         }
 934
 935         /* TODO: Please implement this function. */
 936         return PACKAGE_MANAGER_ERROR_NONE;
 937 }
 938
 939 API int package_manager_set_global_event_cb(package_manager_h manager,
 940                                  package_manager_global_event_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         if (package_manager_validate_handle(manager)) {
 950                 return
 951                     package_manager_error
 952                     (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
 953                      NULL);
 954         }
 955
 956         if (getuid() >= REGULAR_USER) {
 957                 _LOGE("Regular user is not allowed for this api");
 958                 return PACKAGE_MANAGER_ERROR_PERMISSION_DENIED;
 959         }
 960
 961         manager->global_event_cb = callback;
 962         manager->user_data = user_data;
 963
 964         pkgmgr_client_listen_status(manager->pc, global_event_handler, manager);
 965
 966         return PACKAGE_MANAGER_ERROR_NONE;
 967 }
 968
 969 API int package_manager_unset_global_event_cb(package_manager_h manager)
 970 {
 971         if (manager == NULL) {
 972                 return
 973                     package_manager_error
 974                     (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
 975                      NULL);
 976         }
 977
 978         /* TODO: Please implement this function. */
 979         return PACKAGE_MANAGER_ERROR_NONE;
 980 }
 981
 982 API int package_manager_get_package_id_by_app_id(const char *app_id, char **package_id)
 983 {
 984         pkgmgrinfo_appinfo_h pkgmgrinfo_appinfo;
 985         int retval;
 986         char *pkg_id = NULL;
 987         char *pkg_id_dup = NULL;
 988
 989         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
 990         if (retval != PACKAGE_MANAGER_ERROR_NONE)
 991                 return retval;
 992
 993         if (app_id == NULL || package_id == NULL)
 994                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 995
 996         uid_t uid = getuid();
 997         if (uid != GLOBAL_USER) {
 998                 if (pkgmgrinfo_appinfo_get_usr_appinfo(app_id, uid, &pkgmgrinfo_appinfo) != PMINFO_R_OK)
 999                         return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1000         } else {
1001                 if (pkgmgrinfo_appinfo_get_appinfo(app_id, &pkgmgrinfo_appinfo) != PMINFO_R_OK)
1002                         return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1003         }
1004         retval = pkgmgrinfo_appinfo_get_pkgname(pkgmgrinfo_appinfo, &pkg_id);
1005         if (retval != PMINFO_R_OK)
1006                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1007
1008         pkg_id_dup = strdup(pkg_id);
1009         if (pkg_id_dup == NULL) {
1010                 pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
1011                 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
1012         }
1013
1014         *package_id = pkg_id_dup;
1015
1016         pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
1017
1018         return PACKAGE_MANAGER_ERROR_NONE;
1019 }
1020
1021 API int package_manager_get_package_info(const char *package_id, package_info_h *package_info)
1022 {
1023         int retval;
1024         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
1025         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1026                 return retval;
1027
1028         retval = package_info_get_package_info(package_id, package_info);
1029
1030         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1031                 return package_manager_error(retval, __FUNCTION__, NULL);
1032         else
1033                 return PACKAGE_MANAGER_ERROR_NONE;
1034 }
1035
1036 API int package_manager_foreach_package_info(package_manager_package_info_cb callback,
1037                                         void *user_data)
1038 {
1039
1040         int retval;
1041         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
1042         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1043                 return retval;
1044
1045         retval = package_info_foreach_package_info(callback, user_data);
1046
1047         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1048                 return package_manager_error(retval, __FUNCTION__, NULL);
1049         else
1050                 return PACKAGE_MANAGER_ERROR_NONE;
1051 }
1052
1053 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)
1054 {
1055         pkgmgrinfo_cert_compare_result_type_e result;
1056         uid_t uid = getuid();
1057
1058         if (lhs_package_id == NULL || rhs_package_id == NULL || compare_result == NULL)
1059                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1060         if (uid != GLOBAL_USER) {
1061                 if (pkgmgrinfo_pkginfo_compare_usr_pkg_cert_info(lhs_package_id, rhs_package_id, uid, &result) != PKGMGR_R_OK)
1062                         return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
1063         } else {
1064                 if (pkgmgrinfo_pkginfo_compare_pkg_cert_info(lhs_package_id, rhs_package_id, &result) != PKGMGR_R_OK)
1065                         return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
1066         }
1067         *compare_result = (package_manager_compare_result_type_e)result;
1068
1069         return PACKAGE_MANAGER_ERROR_NONE;
1070 }
1071
1072 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)
1073 {
1074         pkgmgrinfo_cert_compare_result_type_e result;
1075         uid_t uid = getuid();
1076
1077         if (lhs_app_id == NULL || rhs_app_id == NULL || compare_result == NULL)
1078                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1079         if (uid != GLOBAL_USER) {
1080                 if (pkgmgrinfo_pkginfo_compare_usr_app_cert_info(lhs_app_id, rhs_app_id, uid, &result) != PKGMGR_R_OK)
1081                         return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
1082         } else {
1083                 if (pkgmgrinfo_pkginfo_compare_app_cert_info(lhs_app_id, rhs_app_id, &result) != PKGMGR_R_OK)
1084                         return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
1085         }
1086
1087         *compare_result = (package_manager_compare_result_type_e)result;
1088
1089         return PACKAGE_MANAGER_ERROR_NONE;
1090 }
1091
1092 API int package_manager_is_preload_package_by_app_id(const char *app_id, bool *preload)
1093 {
1094
1095         int retval;
1096         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
1097         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1098                 return retval;
1099
1100         pkgmgrinfo_appinfo_h pkgmgrinfo_appinfo = NULL;
1101         pkgmgrinfo_pkginfo_h pkgmgrinfo_pkginfo = NULL;
1102
1103         char *pkg_id = NULL;
1104         bool is_preload = 0;
1105         uid_t uid = getuid();
1106         if (uid != GLOBAL_USER) {
1107                 if (pkgmgrinfo_appinfo_get_usr_appinfo(app_id, uid, &pkgmgrinfo_appinfo) != PMINFO_R_OK)
1108                         return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1109         } else {
1110                 if (pkgmgrinfo_appinfo_get_appinfo(app_id, &pkgmgrinfo_appinfo) != PMINFO_R_OK)
1111                         return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1112         }
1113
1114         retval = pkgmgrinfo_appinfo_get_pkgname(pkgmgrinfo_appinfo, &pkg_id);
1115         if (retval != PMINFO_R_OK) {
1116                 pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
1117                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1118         }
1119         if (uid != GLOBAL_USER) {
1120                 if (pkgmgrinfo_pkginfo_get_usr_pkginfo(pkg_id, uid, &pkgmgrinfo_pkginfo) != PMINFO_R_OK) {
1121                         pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
1122                         pkgmgrinfo_pkginfo_destroy_pkginfo(pkgmgrinfo_pkginfo);
1123                         return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1124                 }
1125         } else {
1126                 if (pkgmgrinfo_pkginfo_get_pkginfo(pkg_id, &pkgmgrinfo_pkginfo) != PMINFO_R_OK) {
1127                         pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
1128                         pkgmgrinfo_pkginfo_destroy_pkginfo(pkgmgrinfo_pkginfo);
1129                         return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1130                 }
1131         }
1132         if (pkgmgrinfo_pkginfo_is_preload(pkgmgrinfo_pkginfo, &is_preload) != PMINFO_R_OK) {
1133                 pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
1134                 pkgmgrinfo_pkginfo_destroy_pkginfo(pkgmgrinfo_pkginfo);
1135                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1136         }
1137
1138         if (is_preload)
1139                 *preload = 1;
1140         else
1141                 *preload = 0;
1142
1143         pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
1144         pkgmgrinfo_pkginfo_destroy_pkginfo(pkgmgrinfo_pkginfo);
1145
1146         return PACKAGE_MANAGER_ERROR_NONE;
1147 }
1148
1149 API int package_manager_get_permission_type(const char *app_id, package_manager_permission_type_e *permission_type)
1150 {
1151
1152         int retval;
1153         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
1154         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1155                 return retval;
1156
1157         pkgmgrinfo_appinfo_h pkgmgrinfo_appinfo = NULL;
1158         pkgmgrinfo_permission_type permission = 0;
1159         uid_t uid = getuid();
1160         if (uid != GLOBAL_USER) {
1161                 if (pkgmgrinfo_appinfo_get_usr_appinfo(app_id, uid, &pkgmgrinfo_appinfo) != PMINFO_R_OK)
1162                         return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1163         } else {
1164                 if (pkgmgrinfo_appinfo_get_appinfo(app_id, &pkgmgrinfo_appinfo) != PMINFO_R_OK)
1165                         return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1166         }
1167         retval = pkgmgrinfo_appinfo_get_permission_type(pkgmgrinfo_appinfo, &permission);
1168         if (retval != PMINFO_R_OK)
1169                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1170
1171         if (permission == PMINFO_PERMISSION_NORMAL)
1172                 *permission_type = PACKAGE_MANAGER_PERMISSION_NORMAL;
1173         else if (permission == PMINFO_PERMISSION_SIGNATURE)
1174                 *permission_type = PACKAGE_MANAGER_PERMISSION_SIGNATURE;
1175         else if (permission == PMINFO_PERMISSION_PRIVILEGE)
1176                 *permission_type = PACKAGE_MANAGER_PERMISSION_PRIVILEGE;
1177         else
1178                 *permission_type = PACKAGE_MANAGER_PERMISSION_NORMAL;
1179
1180         pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
1181         return PACKAGE_MANAGER_ERROR_NONE;
1182 }
1183
1184 API int package_manager_clear_cache_dir(const char *package_id)
1185 {
1186
1187         int retval;
1188         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_CACHE);
1189         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1190                 return retval;
1191
1192         int res = pkgmgr_client_usr_clear_cache_dir(package_id, getuid());
1193         if (res == PKGMGR_R_EINVAL) {
1194                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1195         } else if (res == PKGMGR_R_ENOPKG) {
1196                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1197         } else if (res == PKGMGR_R_ENOMEM) {
1198                 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
1199         } else if (res == PKGMGR_R_EIO) {
1200                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
1201         } else if (res == PKGMGR_R_EPRIV) {
1202                 return package_manager_error(PACKAGE_MANAGER_ERROR_PERMISSION_DENIED, __FUNCTION__, NULL);
1203         } else if (res == PKGMGR_R_ESYSTEM || res == PKGMGR_R_ECOMM || res == PKGMGR_R_ERROR) {
1204                 return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
1205         } else if (res != PKGMGR_R_OK) {
1206                 _LOGE("Unexpected error");
1207                 return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
1208         }
1209
1210         return PACKAGE_MANAGER_ERROR_NONE;
1211 }
1212
1213 API int package_manager_clear_all_cache_dir(void)
1214 {
1215
1216         int retval;
1217         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_ADMIN);
1218         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1219                 return retval;
1220
1221         return package_manager_clear_cache_dir(PKG_CLEAR_ALL_CACHE);
1222 }
1223
1224 static void __free_client(gpointer data)
1225 {
1226         pkgmgr_client *pc = (pkgmgr_client *)data;
1227         pkgmgr_client_free(pc);
1228 }
1229
1230 static void __initialize_cb_table(void)
1231 {
1232         __cb_table = g_hash_table_new_full(g_int_hash, g_int_equal, __free_client, NULL);
1233 }
1234
1235 static void __result_cb(pkgmgr_client *pc, const char *pkgid, const pkg_size_info_t *result, void *user_data)
1236 {
1237         package_manager_size_info_receive_cb callback = g_hash_table_lookup(__cb_table, pc);
1238         if (callback == NULL) {
1239                 _LOGE("callback is null.");
1240                 g_hash_table_remove(__cb_table, pc);
1241                 return;
1242         }
1243
1244         package_size_info_t size_info;
1245         size_info.data_size  = result->data_size;
1246         size_info.cache_size = result->cache_size;
1247         size_info.app_size   = result->app_size;
1248         size_info.external_data_size  = result->ext_data_size;
1249         size_info.external_cache_size = result->ext_cache_size;
1250         size_info.external_app_size   = result->ext_app_size;
1251
1252         callback(pkgid, (package_size_info_h)&size_info, user_data);
1253
1254         g_hash_table_remove(__cb_table, pc);
1255 }
1256
1257 static void __total_result_cb(pkgmgr_client *pc, const pkg_size_info_t *result, void *user_data)
1258 {
1259         package_manager_total_size_info_receive_cb callback = g_hash_table_lookup(__cb_table, pc);
1260         if (callback == NULL) {
1261                 _LOGE("callback is null.");
1262                 g_hash_table_remove(__cb_table, pc);
1263                 return;
1264         }
1265
1266         package_size_info_t size_info;
1267         size_info.data_size  = result->data_size;
1268         size_info.cache_size = result->cache_size;
1269         size_info.app_size   = result->app_size;
1270         size_info.external_data_size  = result->ext_data_size;
1271         size_info.external_cache_size = result->ext_cache_size;
1272         size_info.external_app_size   = result->ext_app_size;
1273
1274         callback((package_size_info_h)&size_info, user_data);
1275
1276         g_hash_table_remove(__cb_table, pc);
1277 }
1278
1279 static int _get_pkg_size_info(const char *package_id, void *callback, void *user_data)
1280 {
1281         if (package_id == NULL || callback == NULL)
1282                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1283
1284         if (__cb_table == NULL)
1285                 __initialize_cb_table();
1286
1287         pkgmgr_client *pc = pkgmgr_client_new(PC_REQUEST);
1288         if (pc == NULL)
1289                 return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
1290
1291         int res = 0;
1292         if (strcmp(package_id, PKG_SIZE_INFO_TOTAL) != 0)
1293                 res = pkgmgr_client_usr_get_package_size_info(pc, package_id, __result_cb, user_data, getuid());
1294         else
1295                 res = pkgmgr_client_usr_get_total_package_size_info(pc, __total_result_cb, user_data, getuid());
1296
1297         if (res == PKGMGR_R_EINVAL) {
1298                 pkgmgr_client_free(pc);
1299                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1300         } else if (res == PKGMGR_R_ENOPKG) {
1301                 pkgmgr_client_free(pc);
1302                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1303         } else if (res == PKGMGR_R_ENOMEM) {
1304                 pkgmgr_client_free(pc);
1305                 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
1306         } else if (res == PKGMGR_R_EIO) {
1307                 pkgmgr_client_free(pc);
1308                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
1309         } else if (res == PKGMGR_R_EPRIV) {
1310                 pkgmgr_client_free(pc);
1311                 return package_manager_error(PACKAGE_MANAGER_ERROR_PERMISSION_DENIED, __FUNCTION__, NULL);
1312         } else if (res == PKGMGR_R_ESYSTEM || res == PKGMGR_R_ECOMM || res == PKGMGR_R_ERROR) {
1313                 pkgmgr_client_free(pc);
1314                 return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
1315         } else if (res != PKGMGR_R_OK) {
1316                 _LOGE("Unexpected error");
1317                 pkgmgr_client_free(pc);
1318                 return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
1319         }
1320
1321         g_hash_table_insert(__cb_table, pc, callback);
1322
1323         _LOGD("Successful");
1324         return PACKAGE_MANAGER_ERROR_NONE;
1325 }
1326
1327 API int package_manager_get_package_size_info(const char *package_id, package_manager_size_info_receive_cb callback, void *user_data)
1328 {
1329         return _get_pkg_size_info(package_id, (void *)callback, user_data);
1330 }
1331
1332 API int package_manager_get_total_package_size_info(package_manager_total_size_info_receive_cb callback, void *user_data)
1333 {
1334         return _get_pkg_size_info(PKG_SIZE_INFO_TOTAL, (void *)callback, user_data);
1335 }
1336
1337 API int package_manager_filter_create(package_manager_filter_h *handle)
1338 {
1339         int retval;
1340         pkgmgrinfo_pkginfo_filter_h pkgmgr_filter = NULL;
1341
1342         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
1343         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1344                 return retval;
1345
1346         if (handle == NULL) {
1347                 return
1348                     package_manager_error
1349                     (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
1350                      NULL);
1351         }
1352
1353         retval = pkgmgrinfo_pkginfo_filter_create(&pkgmgr_filter);
1354         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1355                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
1356
1357         *handle = pkgmgr_filter;
1358
1359         return PACKAGE_MANAGER_ERROR_NONE;
1360 }
1361
1362 API int package_manager_filter_destroy(package_manager_filter_h handle)
1363 {
1364         int retval;
1365
1366         if (handle == NULL) {
1367                 return
1368                     package_manager_error
1369                     (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
1370                      NULL);
1371         }
1372
1373         retval = pkgmgrinfo_pkginfo_filter_destroy(handle);
1374         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1375                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
1376
1377         return PACKAGE_MANAGER_ERROR_NONE;
1378 }
1379
1380 API int package_manager_filter_add_bool(package_manager_filter_h handle,
1381                 const char *property, const bool value)
1382 {
1383         int retval;
1384
1385         if ((handle == NULL) || (property == NULL)) {
1386                 return
1387                     package_manager_error
1388                     (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
1389                      NULL);
1390         }
1391
1392         retval = pkgmgrinfo_pkginfo_filter_add_bool(handle, property, value);
1393         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1394                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
1395
1396         return PACKAGE_MANAGER_ERROR_NONE;
1397 }
1398
1399 API int package_manager_filter_count(package_manager_filter_h handle, int *count)
1400 {
1401
1402         int retval;
1403         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
1404         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1405                 return retval;
1406
1407         if ((handle == NULL) || (count == NULL))
1408                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1409
1410         retval = pkgmgrinfo_pkginfo_filter_count(handle, count);
1411         if (retval < 0)
1412                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
1413
1414         return PACKAGE_MANAGER_ERROR_NONE;
1415 }
1416
1417 API int package_manager_filter_foreach_package_info(package_manager_filter_h handle,
1418                 package_manager_package_info_cb callback, void *user_data)
1419 {
1420
1421         int retval;
1422         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
1423         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1424                 return retval;
1425
1426         retval = package_info_filter_foreach_package_info(handle, callback, user_data);
1427
1428         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1429                 return package_manager_error(retval, __FUNCTION__, NULL);
1430         else
1431                 return PACKAGE_MANAGER_ERROR_NONE;
1432 }
1433
1434 API int package_size_info_get_data_size(package_size_info_h handle, long long *data_size)
1435 {
1436         if (handle == NULL)
1437                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1438
1439         package_size_info_t *size_info = (package_size_info_t *)handle;
1440
1441         *data_size = (long long)size_info->data_size;
1442         return PACKAGE_MANAGER_ERROR_NONE;
1443 }
1444
1445 API int package_size_info_get_cache_size(package_size_info_h handle, long long *cache_size)
1446 {
1447         if (handle == NULL)
1448                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1449
1450         package_size_info_t *size_info = (package_size_info_t *)handle;
1451
1452         *cache_size = size_info->cache_size;
1453         return PACKAGE_MANAGER_ERROR_NONE;
1454 }
1455
1456 API int package_size_info_get_app_size(package_size_info_h handle, long long *app_size)
1457 {
1458         if (handle == NULL)
1459                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1460
1461         package_size_info_t *size_info = (package_size_info_t *)handle;
1462         *app_size = size_info->app_size;
1463         return PACKAGE_MANAGER_ERROR_NONE;
1464 }
1465
1466 API int package_size_info_get_external_data_size(package_size_info_h handle, long long *ext_data_size)
1467 {
1468         if (handle == NULL)
1469                 return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
1470
1471         package_size_info_t *size_info = (package_size_info_t *)handle;
1472         *ext_data_size = size_info->external_data_size;
1473         return PACKAGE_MANAGER_ERROR_NONE;
1474 }
1475
1476 API int package_size_info_get_external_cache_size(package_size_info_h handle, long long *ext_cache_size)
1477 {
1478         if (handle == NULL)
1479                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1480
1481         package_size_info_t *size_info = (package_size_info_t *)handle;
1482         *ext_cache_size = size_info->external_cache_size;
1483         return PACKAGE_MANAGER_ERROR_NONE;
1484 }
1485
1486 API int package_size_info_get_external_app_size(package_size_info_h handle, long long *ext_app_size)
1487 {
1488         if (handle == NULL)
1489                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1490
1491         package_size_info_t *size_info = (package_size_info_t *)handle;
1492         *ext_app_size = size_info->external_app_size;
1493         return PACKAGE_MANAGER_ERROR_NONE;
1494 }