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