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