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_installer_error.h>
  25 #include <pkgmgr-info.h>
  26 #include <tzplatform_config.h>
  27
  28 #include "package_manager.h"
  29 #include "package_manager_internal.h"
  30
  31 #define GLOBAL_USER tzplatform_getuid(TZ_SYS_GLOBALAPP_USER)
  32 typedef struct _request_event_info {
  33         int req_id;
  34         package_manager_event_type_e event_type;
  35         package_manager_event_state_e event_state;
  36         struct _request_event_info *next;
  37 } request_event_info;
  38
  39 struct package_manager_event_info {
  40         char *pkg_name;
  41         package_manager_event_type_e event_type;
  42         package_manager_event_state_e event_state;
  43 };
  44
  45 struct package_manager_s {
  46         int handle_id;
  47         pkgmgr_client_type ctype;
  48         pkgmgr_client *pc;
  49         pkgmgr_mode mode;
  50         GHashTable *event_info_table;
  51         package_manager_event_cb event_cb;
  52         void *user_data;
  53 };
  54
  55 struct package_manager_request_s {
  56         int handle_id;
  57         pkgmgr_client_type ctype;
  58         pkgmgr_client *pc;
  59         char *pkg_type;
  60         pkgmgr_mode mode;
  61         request_event_info *head;
  62         package_manager_request_event_cb event_cb;
  63         GHashTable *request_cb_table;
  64         void *user_data;
  65 };
  66
  67 struct package_manager_request_cb_info {
  68         int req_id;
  69         package_manager_request_event_cb callback;
  70         void *user_data;
  71 };
  72
  73 typedef struct package_size_info {
  74         long long data_size;
  75         long long cache_size;
  76         long long app_size;
  77
  78         long long external_data_size;
  79         long long external_cache_size;
  80         long long external_app_size;
  81 } package_size_info_t;
  82
  83 struct package_manager_filter_s {
  84         pkgmgrinfo_pkginfo_filter_h pkgmgrinfo_pkginfo_filter;
  85 };
  86
  87 struct package_updateinfo_request_s {
  88         pkgmgr_client *pc;
  89         pkg_update_info_t *updateinfo_handle;
  90 };
  91
  92 static int package_manager_request_new_id()
  93 {
  94         static int request_handle_id = 0;
  95         return request_handle_id++;
  96 }
  97
  98 static int package_manager_new_id()
  99 {
 100         static int manager_handle_id = 0;
 101         return manager_handle_id++;
 102 }
 103
 104 static void __clean_all_event_info(request_event_info *head)
 105 {
 106         request_event_info *current = head;
 107         request_event_info *prev;
 108
 109         if (current == NULL)
 110                 return;
 111
 112         while (current) {
 113                 prev = current;
 114                 current = current->next;
 115                 free(prev);
 116         }
 117 }
 118
 119 static int __insert_event_info(package_manager_h manager, const char *pkg_name,
 120                         package_manager_event_type_e event_type,
 121                         package_manager_event_state_e event_state)
 122 {
 123         struct package_manager_event_info *info;
 124
 125         info = calloc(1, sizeof(struct package_manager_event_info));
 126         if (info == NULL)
 127                 return -1;
 128         info->pkg_name = strdup(pkg_name);
 129         info->event_type = event_type;
 130         info->event_state = event_state;
 131         g_hash_table_insert(manager->event_info_table, info->pkg_name, info);
 132
 133         return 0;
 134 }
 135
 136 static void __free_event_info(gpointer data)
 137 {
 138         struct package_manager_event_info *info =
 139                         (struct package_manager_event_info *)data;
 140
 141         if (!info)
 142                 return;
 143
 144         if (info->pkg_name)
 145                 free(info->pkg_name);
 146         free(info);
 147
 148         _LOGD("event_info removed");
 149 }
 150
 151 static void __free_request_cb_info(gpointer data)
 152 {
 153         int req_id;
 154         struct package_manager_request_cb_info *cb_info =
 155                         (struct package_manager_request_cb_info *)data;
 156
 157         req_id = cb_info->req_id;
 158         free(cb_info);
 159         cb_info = NULL;
 160
 161         _LOGD("request callback info removed, req_id(%d)", req_id);
 162 }
 163
 164 static void __initialize_request_cb_table(package_manager_request_h request)
 165 {
 166         request->request_cb_table =
 167                 g_hash_table_new_full(g_direct_hash, g_direct_equal, NULL, __free_request_cb_info);
 168 }
 169
 170 static int __insert_request_cb_info(package_manager_request_h request, int req_id,
 171                 package_manager_request_event_cb callback, void *user_data)
 172 {
 173         struct package_manager_request_cb_info *cb_info;
 174
 175         if (request->request_cb_table == NULL)
 176                 return -1;
 177
 178         cb_info = calloc(1, sizeof(struct package_manager_request_cb_info));
 179         if (cb_info == NULL)
 180                 return -1;
 181         cb_info->req_id = req_id;
 182         cb_info->callback = callback;
 183         cb_info->user_data = user_data;
 184         _LOGD("insert req_id(%d)", req_id);
 185         g_hash_table_insert(request->request_cb_table, GINT_TO_POINTER(cb_info->req_id), cb_info);
 186
 187         return 0;
 188 }
 189
 190 API int package_manager_request_create(package_manager_request_h *request)
 191 {
 192         struct package_manager_request_s *package_manager_request;
 193
 194         if (request == NULL) {
 195                 return
 196                     package_manager_error
 197                     (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
 198                      NULL);
 199         }
 200
 201         package_manager_request =
 202             calloc(1, sizeof(struct package_manager_request_s));
 203         if (package_manager_request == NULL) {
 204                 return
 205                     package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY,
 206                                           __FUNCTION__,
 207                                           "failed to create a package_manager handle");
 208         }
 209
 210         package_manager_request->ctype = PC_REQUEST;
 211         package_manager_request->pc = pkgmgr_client_new(PC_REQUEST);
 212         if (package_manager_request->pc == NULL) {
 213                 free(package_manager_request);
 214                 return
 215                     package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY,
 216                                           __FUNCTION__,
 217                                           "failed to create a package_manager client");
 218         }
 219
 220         package_manager_request->handle_id = package_manager_request_new_id();
 221
 222         *request = package_manager_request;
 223
 224         return PACKAGE_MANAGER_ERROR_NONE;
 225 }
 226
 227 static int package_manager_client_validate_handle(package_manager_request_h
 228                                                  request)
 229 {
 230         if (request == NULL || request->pc == NULL)
 231                 return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
 232
 233         return PACKAGE_MANAGER_ERROR_NONE;
 234 }
 235
 236 API int package_manager_request_destroy(package_manager_request_h request)
 237 {
 238         if (package_manager_client_validate_handle(request)) {
 239                 return
 240                     package_manager_error
 241                     (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
 242                      NULL);
 243         }
 244
 245         pkgmgr_client_free(request->pc);
 246         request->pc = NULL;
 247         free(request->pkg_type);
 248         __clean_all_event_info(request->head);
 249         if (request->request_cb_table) {
 250                 g_hash_table_destroy(request->request_cb_table);
 251                 request->request_cb_table = NULL;
 252         }
 253         free(request);
 254
 255         return PACKAGE_MANAGER_ERROR_NONE;
 256 }
 257
 258 static int __reset_user_request_callback(package_manager_request_h request,
 259                         package_manager_request_event_cb callback, void *user_data)
 260 {
 261         if (package_manager_client_validate_handle(request))
 262                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 263
 264         request->event_cb = callback;
 265         request->user_data = user_data;
 266
 267         return PACKAGE_MANAGER_ERROR_NONE;
 268 }
 269
 270 API int package_manager_request_set_event_cb(package_manager_request_h request,
 271                                          package_manager_request_event_cb
 272                                          callback, void *user_data)
 273 {
 274         int ret;
 275
 276         if (package_manager_client_validate_handle(request))
 277                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER,
 278                                 __FUNCTION__, NULL);
 279
 280         ret = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
 281         if (ret != PACKAGE_MANAGER_ERROR_NONE)
 282                 return ret;
 283
 284         return __reset_user_request_callback(request, callback, user_data);
 285 }
 286
 287 API int package_manager_request_unset_event_cb(package_manager_request_h request)
 288 {
 289         if (package_manager_client_validate_handle(request))
 290                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 291
 292         request->event_cb = NULL;
 293         request->user_data = NULL;
 294
 295         return PACKAGE_MANAGER_ERROR_NONE;
 296 }
 297
 298 API int package_manager_request_set_type(package_manager_request_h request,
 299                                      const char *pkg_type)
 300 {
 301         if (package_manager_client_validate_handle(request)) {
 302                 return
 303                     package_manager_error
 304                     (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
 305                      NULL);
 306         }
 307
 308         if (request->pkg_type)
 309                 free(request->pkg_type);
 310         request->pkg_type = strdup(pkg_type);
 311
 312         return PACKAGE_MANAGER_ERROR_NONE;
 313 }
 314
 315 API int package_manager_request_set_mode(package_manager_request_h request,
 316                                      package_manager_request_mode_e mode)
 317 {
 318         if (package_manager_client_validate_handle(request)) {
 319                 return
 320                     package_manager_error
 321                     (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
 322                      NULL);
 323         }
 324
 325         /* request mode is not used anymore */
 326
 327         return PACKAGE_MANAGER_ERROR_NONE;
 328 }
 329
 330 API int package_manager_request_set_tep(package_manager_request_h request,
 331                                      const char *tep_path)
 332 {
 333         int retval = 0;
 334
 335         if (package_manager_client_validate_handle(request) || tep_path == NULL) {
 336                 return
 337                         package_manager_error
 338                         (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
 339                          NULL);
 340         }
 341
 342         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_ADMIN);
 343         if (retval != PACKAGE_MANAGER_ERROR_NONE)
 344                 return retval;
 345
 346         if (pkgmgr_client_set_tep_path(request->pc, tep_path, true))
 347                 return PACKAGE_MANAGER_ERROR_SYSTEM_ERROR;
 348
 349         return PACKAGE_MANAGER_ERROR_NONE;
 350 }
 351
 352 static int package_manager_get_event_type(const char *key,
 353                                           package_manager_event_type_e *
 354                                           event_type)
 355 {
 356         if (key == NULL)
 357                 return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
 358
 359         if (strcasecmp(key, PKGMGR_INSTALLER_INSTALL_EVENT_STR) == 0)
 360                 *event_type = PACKAGE_MANAGER_EVENT_TYPE_INSTALL;
 361         else if (strcasecmp(key, PKGMGR_INSTALLER_UNINSTALL_EVENT_STR) == 0)
 362                 *event_type = PACKAGE_MANAGER_EVENT_TYPE_UNINSTALL;
 363         else if (strcasecmp(key, PKGMGR_INSTALLER_UPGRADE_EVENT_STR) == 0)
 364                 *event_type = PACKAGE_MANAGER_EVENT_TYPE_UPDATE;
 365         else if (strcasecmp(key, PKGMGR_INSTALLER_MOVE_EVENT_STR) == 0)
 366                 *event_type = PACKAGE_MANAGER_EVENT_TYPE_MOVE;
 367         else if (strcasecmp(key, PKGMGR_INSTALLER_CLEAR_EVENT_STR) == 0)
 368                 *event_type = PACKAGE_MANAGER_EVENT_TYPE_CLEAR;
 369         else
 370                 return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
 371
 372         return PACKAGE_MANAGER_ERROR_NONE;
 373 }
 374
 375 static package_manager_error_e __convert_to_error(const char *val)
 376 {
 377         int errcode = atoi(val);
 378
 379         switch (errcode) {
 380         case PKGMGR_INSTALLER_ERRCODE_UNDEFINED_ERROR:
 381         case PKGMGR_INSTALLER_ERRCODE_GLOBALSYMLINK_ERROR:
 382         case PKGMGR_INSTALLER_ERRCODE_GRANT_PERMISSION_ERROR:
 383         case PKGMGR_INSTALLER_ERRCODE_IMAGE_ERROR:
 384         case PKGMGR_INSTALLER_ERRCODE_PARSE_ERROR:
 385         case PKGMGR_INSTALLER_ERRCODE_RECOVERY_ERROR:
 386         case PKGMGR_INSTALLER_ERRCODE_DELTA_ERROR:
 387         case PKGMGR_INSTALLER_ERRCODE_APP_DIR_ERROR:
 388         case PKGMGR_INSTALLER_ERRCODE_CONFIG_ERROR:
 389         case PKGMGR_INSTALLER_ERRCODE_ICON_ERROR:
 390         case PKGMGR_INSTALLER_ERRCODE_MANIFEST_ERROR:
 391         case PKGMGR_INSTALLER_ERRCODE_OUT_OF_SPACE:
 392         case PKGMGR_INSTALLER_ERRCODE_ERROR:
 393                 return PACKAGE_MANAGER_ERROR_SYSTEM_ERROR;
 394         case PKGMGR_INSTALLER_ERRCODE_UNZIP_ERROR:
 395         case PKGMGR_INSTALLER_ERRCODE_SECURITY_ERROR:
 396         case PKGMGR_INSTALLER_ERRCODE_REGISTER_ERROR:
 397         case PKGMGR_INSTALLER_ERRCODE_PRIVILEGE_ERROR:
 398         case PKGMGR_INSTALLER_ERRCODE_SIGNATURE_ERROR:
 399         case PKGMGR_INSTALLER_ERRCODE_SIGNATURE_INVALID:
 400         case PKGMGR_INSTALLER_ERRCODE_CERT_ERROR:
 401         case PKGMGR_INSTALLER_ERRCODE_AUTHOR_CERT_NOT_MATCH:
 402         case PKGMGR_INSTALLER_ERRCODE_AUTHOR_CERT_NOT_FOUND:
 403         case PKGMGR_INSTALLER_ERRCODE_ICON_NOT_FOUND:
 404         case PKGMGR_INSTALLER_ERRCODE_MANIFEST_NOT_FOUND:
 405                 return PACKAGE_MANAGER_ERROR_IO_ERROR;
 406         case PKGMGR_INSTALLER_ERRCODE_PACKAGE_NOT_FOUND:
 407                 return PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE;
 408         case PKGMGR_INSTALLER_ERRCODE_OPERATION_NOT_ALLOWED:
 409                 return PACKAGE_MANAGER_ERROR_PERMISSION_DENIED;
 410         case PKGMGR_INSTALLER_ERRCODE_INVALID_VALUE:
 411                 return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
 412         case PKGMGR_INSTALLER_ERRCODE_OK:
 413                 return PACKAGE_MANAGER_ERROR_NONE;
 414         default:
 415                 return PACKAGE_MANAGER_ERROR_SYSTEM_ERROR;
 416         }
 417 }
 418
 419 static int __add_event_info(request_event_info **head, int req_id,
 420                             package_manager_event_type_e event_type,
 421                             package_manager_event_state_e event_state)
 422 {
 423         request_event_info *evt_info;
 424         request_event_info *current;
 425         request_event_info *prev;
 426
 427         evt_info = (request_event_info *) calloc(1, sizeof(request_event_info));
 428         if (evt_info == NULL) {
 429                 _LOGD("calloc failed");
 430                 return -1;
 431         }
 432         evt_info->req_id = req_id;
 433         evt_info->event_type = event_type;
 434         evt_info->event_state = event_state;
 435         evt_info->next = NULL;
 436
 437         if (*head == NULL)
 438                 *head = evt_info;
 439         else {
 440                 current = prev = *head;
 441                 while (current) {
 442                         prev = current;
 443                         current = current->next;
 444                 }
 445
 446                 prev->next = evt_info;
 447         }
 448
 449         return 0;
 450 }
 451
 452 static int __find_event_info(request_event_info **head, int req_id,
 453                              package_manager_event_type_e *event_type,
 454                              package_manager_event_state_e *event_state)
 455 {
 456         request_event_info *tmp;
 457
 458         tmp = *head;
 459
 460         if (tmp == NULL) {
 461                 _LOGE("tmp is NULL");
 462                 return -1;
 463         }
 464
 465         while (tmp) {
 466                 if (tmp->req_id == req_id) {
 467                         *event_type = tmp->event_type;
 468                         *event_state = tmp->event_state;
 469                         return 0;
 470                 }
 471                 tmp = tmp->next;
 472         }
 473         return -1;
 474 }
 475
 476 static int __update_event_info(request_event_info **head, int req_id,
 477                                package_manager_event_type_e event_type,
 478                                package_manager_event_state_e event_state)
 479 {
 480         package_manager_event_type_e evt_type;
 481         package_manager_event_state_e evt_state;
 482         request_event_info *tmp;
 483
 484         if (__find_event_info(head, req_id, &evt_type, &evt_state) != 0)
 485                 __add_event_info(head, req_id, event_type, event_state);
 486         else {
 487                 tmp = *head;
 488
 489                 if (tmp == NULL) {
 490                         _LOGE("tmp is NULL");
 491                         return -1;
 492                 }
 493
 494                 while (tmp) {
 495                         if (tmp->req_id == req_id) {
 496                                 tmp->event_type = event_type;
 497                                 tmp->event_state = event_state;
 498                                 return 0;
 499                         }
 500                         tmp = tmp->next;
 501                 }
 502         }
 503
 504         return -1;
 505 }
 506
 507 static int request_event_handler(uid_t target_uid, int req_id, const char *pkg_type,
 508                                  const char *pkg_name, const char *key,
 509                                  const char *val, const void *pmsg, void *data)
 510 {
 511         int ret = -1;
 512         package_manager_event_type_e event_type = -1;
 513         package_manager_event_state_e event_state = -1;
 514
 515         package_manager_request_h request = data;
 516
 517         if (strcasecmp(key, "start") == 0) {
 518                 ret = package_manager_get_event_type(val, &event_type);
 519                 if (ret != PACKAGE_MANAGER_ERROR_NONE)
 520                         return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
 521
 522                 __add_event_info(&(request->head), req_id, event_type,
 523                                  PACKAGE_MANAGER_EVENT_STATE_STARTED);
 524
 525                 if (request->event_cb)
 526                         request->event_cb(req_id, pkg_type, pkg_name,
 527                                           event_type,
 528                                           PACKAGE_MANAGER_EVENT_STATE_STARTED,
 529                                           0, PACKAGE_MANAGER_ERROR_NONE, request->user_data);
 530
 531         } else if (strcasecmp(key, "install_percent") == 0
 532                    || strcasecmp(key, "progress_percent") == 0) {
 533                 if (__find_event_info
 534                     (&(request->head), req_id, &event_type,
 535                      &event_state) == 0) {
 536                         __update_event_info(&(request->head), req_id,
 537                                             event_type,
 538                                             PACKAGE_MANAGER_EVENT_STATE_PROCESSING);
 539                         if (request->event_cb)
 540                                 request->event_cb(req_id, pkg_type, pkg_name,
 541                                                   event_type,
 542                                                   PACKAGE_MANAGER_EVENT_STATE_PROCESSING,
 543                                                   atoi(val),
 544                                                   PACKAGE_MANAGER_ERROR_NONE,
 545                                                   request->user_data);
 546                 }
 547
 548         } else if (strcasecmp(key, "error") == 0) {
 549                 if (__find_event_info
 550                     (&(request->head), req_id, &event_type,
 551                      &event_state) == 0) {
 552                         __update_event_info(&(request->head), req_id,
 553                                             event_type,
 554                                             PACKAGE_MANAGER_EVENT_STATE_FAILED);
 555                 }
 556
 557                 if (request->event_cb)
 558                         request->event_cb(req_id, pkg_type,
 559                                           pkg_name, event_type,
 560                                           PACKAGE_MANAGER_EVENT_STATE_FAILED,
 561                                           0,
 562                                           __convert_to_error(val),
 563                                           request->user_data);
 564
 565         } else if (strcasecmp(key, "end") == 0) {
 566                 if (__find_event_info
 567                     (&(request->head), req_id, &event_type,
 568                      &event_state) == 0) {
 569                         if (event_state != PACKAGE_MANAGER_EVENT_STATE_FAILED) {
 570                                 if (request->event_cb)
 571                                         request->event_cb(req_id, pkg_type,
 572                                                           pkg_name, event_type,
 573                                                           PACKAGE_MANAGER_EVENT_STATE_COMPLETED,
 574                                                           100,
 575                                                           PACKAGE_MANAGER_ERROR_NONE,
 576                                                           request->user_data);
 577                         }
 578                 } else {
 579                         if (strcasecmp(key, "ok") != 0)
 580                                 if (request->event_cb)
 581                                         request->event_cb(req_id, pkg_type,
 582                                                           pkg_name, event_type,
 583                                                           PACKAGE_MANAGER_EVENT_STATE_FAILED,
 584                                                           0,
 585                                                           PACKAGE_MANAGER_ERROR_SYSTEM_ERROR,
 586                                                           request->user_data);
 587                 }
 588         }
 589
 590         return PACKAGE_MANAGER_ERROR_NONE;
 591 }
 592
 593 static int internal_request_callback(uid_t target_uid, int req_id, const char *pkg_type,
 594                                 const char *pkg_name, const char *key,
 595                                 const char *val, const void *pmsg, void *data)
 596 {
 597         int ret;
 598         package_manager_event_type_e event_type = -1;
 599         package_manager_event_state_e event_state = -1;
 600         struct package_manager_request_cb_info *cb_info;
 601         package_manager_request_event_cb event_cb;
 602         void *user_data = NULL;
 603
 604         _LOGD("request callback called, req_id[%d]", req_id);
 605
 606         package_manager_request_h request = data;
 607
 608         if (request->request_cb_table)
 609                 cb_info = g_hash_table_lookup(request->request_cb_table,
 610                                 GINT_TO_POINTER(req_id));
 611         else
 612                 cb_info = NULL;
 613
 614         if (!cb_info || (cb_info && !cb_info->callback)) {
 615                 _LOGE("no callback info");
 616                 return 0;
 617         }
 618
 619         if (cb_info->req_id != req_id) {
 620                 _LOGE("not matched request id");
 621                 return 0;
 622         }
 623
 624         event_cb = cb_info->callback;
 625         user_data = cb_info->user_data;
 626
 627         if (strcasecmp(key, "start") == 0) {
 628                 ret = package_manager_get_event_type(val, &event_type);
 629                 if (ret != PACKAGE_MANAGER_ERROR_NONE)
 630                         return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
 631
 632                 __add_event_info(&request->head, req_id, event_type,
 633                                  PACKAGE_MANAGER_EVENT_STATE_STARTED);
 634
 635                 event_cb(req_id, pkg_type, pkg_name,
 636                         event_type,
 637                         PACKAGE_MANAGER_EVENT_STATE_STARTED,
 638                         0, PACKAGE_MANAGER_ERROR_NONE, user_data);
 639         } else if (strcasecmp(key, "install_percent") == 0) {
 640                 if (__find_event_info(&request->head, req_id, &event_type,
 641                                 &event_state) == 0) {
 642                         __update_event_info(&request->head, req_id,
 643                                         event_type,
 644                                         PACKAGE_MANAGER_EVENT_STATE_PROCESSING);
 645                         event_cb(req_id, pkg_type, pkg_name,
 646                                 event_type,
 647                                 PACKAGE_MANAGER_EVENT_STATE_PROCESSING,
 648                                 atoi(val),
 649                                 PACKAGE_MANAGER_ERROR_NONE,
 650                                 user_data);
 651                 }
 652         } else if (strcasecmp(key, "error") == 0) {
 653                 if (__find_event_info(&request->head, req_id, &event_type,
 654                                 &event_state) == 0) {
 655                         __update_event_info(&request->head, req_id,
 656                                         event_type,
 657                                         PACKAGE_MANAGER_EVENT_STATE_FAILED);
 658                         event_cb(req_id, pkg_type,
 659                                 pkg_name, event_type,
 660                                 PACKAGE_MANAGER_EVENT_STATE_FAILED,
 661                                 0,
 662                                 __convert_to_error(val),
 663                                 user_data);
 664                 }
 665         } else if (strcasecmp(key, "end") == 0) {
 666                 if (__find_event_info(&request->head, req_id, &event_type,
 667                                 &event_state) == 0) {
 668                         if (request->request_cb_table) {
 669                                 _LOGD("remove item, req_id(%d)", req_id);
 670                                 g_hash_table_remove(request->request_cb_table,
 671                                         GINT_TO_POINTER(req_id));
 672                         }
 673                         if (event_state != PACKAGE_MANAGER_EVENT_STATE_FAILED) {
 674                                 if (strcasecmp(val, "ok") == 0) {
 675                                         event_cb(req_id, pkg_type,
 676                                                 pkg_name, event_type,
 677                                                 PACKAGE_MANAGER_EVENT_STATE_COMPLETED,
 678                                                 100,
 679                                                 PACKAGE_MANAGER_ERROR_NONE,
 680                                                 user_data);
 681                                 } else {
 682                                         event_cb(req_id, pkg_type,
 683                                                 pkg_name, event_type,
 684                                                 PACKAGE_MANAGER_EVENT_STATE_FAILED,
 685                                                 0,
 686                                                 PACKAGE_MANAGER_ERROR_SYSTEM_ERROR,
 687                                                 user_data);
 688                                 }
 689                         }
 690                 } else {
 691                         _LOGE("unexpected end event");
 692                 }
 693         }
 694
 695         return 0;
 696 }
 697
 698 static int __request_install(package_manager_request_h request,
 699                 const char *path, pkgmgr_handler event_cb, int *id)
 700 {
 701         int retval;
 702         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_ADMIN);
 703         if (retval != PACKAGE_MANAGER_ERROR_NONE)
 704                 return retval;
 705
 706         if (package_manager_client_validate_handle(request))
 707                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 708
 709         if (path == NULL)
 710                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 711
 712         int request_id = 0;
 713         request_id = pkgmgr_client_install(request->pc, request->pkg_type, NULL,
 714                         path, NULL, request->mode, event_cb ? event_cb : request_event_handler, request);
 715
 716         if (request_id == PKGMGR_R_EINVAL)
 717                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 718         else if (request_id == PKGMGR_R_ENOPKG)
 719                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
 720         else if (request_id == PKGMGR_R_ENOMEM)
 721                 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
 722         else if (request_id == PKGMGR_R_EIO)
 723                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
 724         else if (request_id == PKGMGR_R_EPRIV)
 725                 return package_manager_error(PACKAGE_MANAGER_ERROR_PERMISSION_DENIED, __FUNCTION__, NULL);
 726         else if (request_id == PKGMGR_R_ESYSTEM || request_id == PKGMGR_R_ECOMM || request_id == PKGMGR_R_ERROR)
 727                 return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
 728
 729         if (id)
 730                 *id = request_id;
 731
 732         return PACKAGE_MANAGER_ERROR_NONE;
 733 }
 734
 735 static int __request_uninstall(package_manager_request_h request,
 736                 const char *name, pkgmgr_handler event_cb, int *id)
 737 {
 738         int retval;
 739         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_ADMIN);
 740         if (retval != PACKAGE_MANAGER_ERROR_NONE)
 741                 return retval;
 742
 743         if (package_manager_client_validate_handle(request))
 744                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 745
 746         if (name == NULL)
 747                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 748
 749         int request_id = 0;
 750         request_id = pkgmgr_client_uninstall(request->pc, request->pkg_type,
 751                         name, request->mode, event_cb ? event_cb : request_event_handler, request);
 752
 753         if (request_id == PKGMGR_R_EINVAL)
 754                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 755         else if (request_id == PKGMGR_R_ENOPKG)
 756                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
 757         else if (request_id == PKGMGR_R_ENOMEM)
 758                 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
 759         else if (request_id == PKGMGR_R_EIO)
 760                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
 761         else if (request_id == PKGMGR_R_EPRIV)
 762                 return package_manager_error(PACKAGE_MANAGER_ERROR_PERMISSION_DENIED, __FUNCTION__, NULL);
 763         else if (request_id == PKGMGR_R_ESYSTEM || request_id == PKGMGR_R_ECOMM || request_id == PKGMGR_R_ERROR)
 764                 return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
 765
 766         if (id)
 767                 *id = request_id;
 768
 769         return PACKAGE_MANAGER_ERROR_NONE;
 770 }
 771
 772 static int __request_move(package_manager_request_h request,
 773                 const char *name, package_manager_move_type_e move_type,
 774                 pkgmgr_handler event_cb, int *id)
 775 {
 776         int retval;
 777         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_ADMIN);
 778         if (retval != PACKAGE_MANAGER_ERROR_NONE)
 779                 return retval;
 780
 781         if (package_manager_client_validate_handle(request))
 782                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 783
 784         if (name == NULL)
 785                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 786
 787         int request_id = 0;
 788         request_id = pkgmgr_client_request_service(PM_REQUEST_MOVE, move_type,
 789                         request->pc, request->pkg_type, name,
 790                         NULL, event_cb ? event_cb : request_event_handler, request);
 791
 792         if (request_id == PKGMGR_R_EINVAL)
 793                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 794         else if (request_id == PKGMGR_R_ENOPKG)
 795                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
 796         else if (request_id == PKGMGR_R_ENOMEM)
 797                 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
 798         else if (request_id == PKGMGR_R_EIO)
 799                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
 800         else if (request_id == PKGMGR_R_EPRIV)
 801                 return package_manager_error(PACKAGE_MANAGER_ERROR_PERMISSION_DENIED, __FUNCTION__, NULL);
 802         else if (request_id == PKGMGR_R_ESYSTEM || request_id == PKGMGR_R_ECOMM || request_id == PKGMGR_R_ERROR)
 803                 return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
 804
 805         if (id)
 806                 *id = request_id;
 807
 808         return PACKAGE_MANAGER_ERROR_NONE;
 809 }
 810
 811 static int __request_mount_install(package_manager_request_h request,
 812                 const char *path, pkgmgr_handler event_cb, int *id)
 813 {
 814         int retval;
 815         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_ADMIN);
 816         if (retval != PACKAGE_MANAGER_ERROR_NONE)
 817                 return retval;
 818
 819         if (package_manager_client_validate_handle(request))
 820                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 821
 822         if (path == NULL)
 823                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 824
 825         int request_id = 0;
 826         request_id = pkgmgr_client_mount_install(request->pc, request->pkg_type, NULL,
 827                         path, NULL, request->mode, event_cb ? event_cb : request_event_handler, request);
 828
 829         if (request_id == PKGMGR_R_EINVAL)
 830                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 831         else if (request_id == PKGMGR_R_ENOPKG)
 832                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
 833         else if (request_id == PKGMGR_R_ENOMEM)
 834                 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
 835         else if (request_id == PKGMGR_R_EIO)
 836                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
 837         else if (request_id == PKGMGR_R_EPRIV)
 838                 return package_manager_error(PACKAGE_MANAGER_ERROR_PERMISSION_DENIED, __FUNCTION__, NULL);
 839         else if (request_id == PKGMGR_R_ESYSTEM || request_id == PKGMGR_R_ECOMM || request_id == PKGMGR_R_ERROR)
 840                 return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
 841
 842         if (id)
 843                 *id = request_id;
 844
 845         return PACKAGE_MANAGER_ERROR_NONE;
 846 }
 847
 848
 849 API int package_manager_request_install(package_manager_request_h request,
 850                                 const char *path, int *id)
 851 {
 852         return __request_install(request, path, NULL, id);
 853 }
 854
 855 API int package_manager_request_install_with_cb(package_manager_request_h request,
 856                         const char *path, package_manager_request_event_cb callback,
 857                         void *user_data, int *id)
 858 {
 859         int ret;
 860         int req_id = 0;
 861
 862         if (request->request_cb_table == NULL)
 863                 __initialize_request_cb_table(request);
 864
 865         ret = __request_install(request, path, internal_request_callback, &req_id);
 866
 867         if (req_id > 0) {
 868                 ret = __insert_request_cb_info(request, req_id, callback, user_data);
 869                 if (ret < 0)
 870                         return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY,
 871                                         __FUNCTION__, "failed to create request cb info");
 872                 if (id)
 873                         *id = req_id;
 874         }
 875
 876         return ret;
 877 }
 878
 879 API int package_manager_request_uninstall(package_manager_request_h request,
 880                 const char *name, int *id)
 881 {
 882         return __request_uninstall(request, name, NULL, id);
 883 }
 884
 885 API int package_manager_request_uninstall_with_cb(package_manager_request_h request,
 886                         const char *name, package_manager_request_event_cb callback,
 887                         void *user_data, int *id)
 888 {
 889         int ret;
 890         int req_id = 0;
 891
 892         if (request->request_cb_table == NULL)
 893                 __initialize_request_cb_table(request);
 894
 895         ret = __request_uninstall(request, name, internal_request_callback, &req_id);
 896
 897         if (req_id > 0) {
 898                 ret = __insert_request_cb_info(request, req_id, callback, user_data);
 899                 if (ret < 0)
 900                         return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY,
 901                                         __FUNCTION__, "failed to create request cb info");
 902                 if (id)
 903                         *id = req_id;
 904         }
 905
 906         return ret;
 907 }
 908
 909 API int package_manager_request_move(package_manager_request_h request,
 910                 const char *name, package_manager_move_type_e move_type)
 911 {
 912         return __request_move(request, name, move_type, NULL, NULL);
 913 }
 914
 915 API int package_manager_request_move_with_cb(package_manager_request_h request,
 916                 const char *name, package_manager_move_type_e move_type,
 917                 package_manager_request_event_cb callback, void *user_data, int *id)
 918 {
 919         int ret;
 920         int req_id = 0;
 921
 922         if (request->request_cb_table == NULL)
 923                 __initialize_request_cb_table(request);
 924
 925         ret = __request_move(request, name, move_type, internal_request_callback, &req_id);
 926
 927         if (req_id > 0) {
 928                 ret = __insert_request_cb_info(request, req_id, callback, user_data);
 929                 if (ret < 0)
 930                         return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY,
 931                                         __FUNCTION__, "failed to create request cb info");
 932                 if (id)
 933                         *id = req_id;
 934         }
 935
 936         return ret;
 937 }
 938
 939 API int package_manager_request_mount_install(package_manager_request_h request,
 940                                 const char *path, int *id)
 941 {
 942         return __request_mount_install(request, path, NULL, id);
 943 }
 944
 945 API int package_manager_request_mount_install_with_cb(package_manager_request_h request,
 946                         const char *path, package_manager_request_event_cb callback,
 947                         void *user_data, int *id)
 948 {
 949         int ret;
 950         int req_id = 0;
 951
 952         if (request->request_cb_table == NULL)
 953                 __initialize_request_cb_table(request);
 954
 955         ret = __request_mount_install(request, path, internal_request_callback, &req_id);
 956
 957         if (req_id > 0) {
 958                 ret = __insert_request_cb_info(request, req_id, callback, user_data);
 959                 if (ret < 0)
 960                         return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY,
 961                                         __FUNCTION__, "failed to create request cb info");
 962                 if (id)
 963                         *id = req_id;
 964         }
 965
 966         return ret;
 967 }
 968
 969 API int package_manager_create(package_manager_h *manager)
 970 {
 971         int retval;
 972         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
 973         if (retval != PACKAGE_MANAGER_ERROR_NONE)
 974                 return retval;
 975
 976         struct package_manager_s *package_manager = NULL;
 977
 978         if (manager == NULL) {
 979                 return
 980                     package_manager_error
 981                     (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
 982                      NULL);
 983         }
 984
 985         package_manager = calloc(1, sizeof(struct package_manager_s));
 986         if (package_manager == NULL) {
 987                 return
 988                     package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY,
 989                                           __FUNCTION__,
 990                                           "failed to create a package_manager handle");
 991         }
 992
 993         package_manager->ctype = PC_LISTENING;
 994         package_manager->pc = pkgmgr_client_new(PC_LISTENING);
 995         if (package_manager->pc == NULL) {
 996                 free(package_manager);
 997                 return
 998                     package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY,
 999                                           __FUNCTION__,
1000                                           "failed to create a package_manager client");
1001         }
1002
1003         package_manager->handle_id = package_manager_new_id();
1004
1005         *manager = package_manager;
1006
1007         return PACKAGE_MANAGER_ERROR_NONE;
1008 }
1009
1010 static int package_manager_validate_handle(package_manager_h manager)
1011 {
1012         if (manager == NULL || manager->pc == NULL)
1013                 return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
1014
1015         return PACKAGE_MANAGER_ERROR_NONE;
1016 }
1017
1018 API int package_manager_destroy(package_manager_h manager)
1019 {
1020         if (package_manager_validate_handle(manager)) {
1021                 return
1022                     package_manager_error
1023                     (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
1024                      NULL);
1025         }
1026
1027         pkgmgr_client_free(manager->pc);
1028         g_hash_table_destroy(manager->event_info_table);
1029         free(manager);
1030
1031         return PACKAGE_MANAGER_ERROR_NONE;
1032 }
1033
1034 /* App Event Listening Policy:
1035  * +----------------+------------+---------------+------------------+
1036  * |Listener \ Type |Global Event|My User's Event|Other user's Event|
1037  * +----------------+------------+---------------+------------------+
1038  * |User Process App|   Grant    |     Grant     |      Deny        |
1039  * +----------------+------------+---------------+------------------+
1040  * |Platform module |   Grant    |     Grant     |      Grant       |
1041  * +----------------+------------+---------------+------------------+
1042  * UID assignment policy:
1043  * https://wiki.tizen.org/wiki/Security/User_and_group_ID_assignment_policy
1044  */
1045 #define REGULAR_USER 5000
1046 static int __validate_event_signal(uid_t target_uid)
1047 {
1048         uid_t self = getuid();
1049
1050         if (self == target_uid)
1051                 return 0;
1052
1053         if (self < REGULAR_USER)
1054                 return 0;
1055
1056         return -1;
1057 }
1058
1059 static int internal_callback(uid_t target_uid, int req_id, const char *pkg_type,
1060                                 const char *pkg_name, const char *key,
1061                                 const char *val, const void *pmsg, void *data)
1062 {
1063         int ret = -1;
1064         package_manager_event_type_e event_type = -1;
1065         struct package_manager_event_info *info = NULL;
1066         package_manager_h manager = data;
1067         uid_t uid = target_uid;
1068
1069         _LOGD("req_id(%d), pkg_name(%s), type(%s), key(%s), val(%s)",
1070                         req_id, pkg_name, pkg_type, key, val);
1071
1072         if (target_uid == GLOBAL_USER)
1073                 uid = getuid();
1074
1075         if (__validate_event_signal(uid))
1076                 return PACKAGE_MANAGER_ERROR_NONE;
1077
1078         if (manager && manager->event_info_table) {
1079                 info = g_hash_table_lookup(manager->event_info_table, pkg_name);
1080         } else {
1081                 _LOGE("invalid handle");
1082                 return PACKAGE_MANAGER_ERROR_NONE;
1083         }
1084
1085         if (!info) {
1086                 if (strcasecmp(key, "start") != 0) {
1087                         _LOGD("unexpected signal or no info(removed)");
1088                         return PACKAGE_MANAGER_ERROR_NONE;
1089                 }
1090         }
1091
1092         if (strcasecmp(key, "start") == 0) {
1093                 ret = package_manager_get_event_type(val, &event_type);
1094                 if (ret != PACKAGE_MANAGER_ERROR_NONE)
1095                         return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
1096
1097                 if (!info) {
1098                         __insert_event_info(manager, pkg_name, event_type,
1099                                         PACKAGE_MANAGER_EVENT_STATE_STARTED);
1100
1101                         if (manager->event_cb && getuid() == uid)
1102                                 manager->event_cb(pkg_type, pkg_name,
1103                                                 event_type,
1104                                                 PACKAGE_MANAGER_EVENT_STATE_STARTED,
1105                                                 0,
1106                                                 PACKAGE_MANAGER_ERROR_NONE,
1107                                                 manager->user_data);
1108                 } else {
1109                         _LOGE("unexpected start event");
1110                 }
1111         } else if (strcasecmp(key, "install_percent") == 0
1112                    || strcasecmp(key, "progress_percent") == 0) {
1113                 info->event_state = PACKAGE_MANAGER_EVENT_STATE_PROCESSING;
1114                 if (manager->event_cb && getuid() == uid)
1115                         manager->event_cb(pkg_type, pkg_name,
1116                                         info->event_type,
1117                                         info->event_state,
1118                                         atoi(val),
1119                                         PACKAGE_MANAGER_ERROR_NONE,
1120                                         manager->user_data);
1121         } else if (strcasecmp(key, "error") == 0) {
1122                 info->event_state = PACKAGE_MANAGER_EVENT_STATE_FAILED;
1123                 if (manager->event_cb && getuid() == uid)
1124                         manager->event_cb(pkg_type, pkg_name,
1125                                         info->event_type,
1126                                         info->event_state,
1127                                         0,
1128                                         __convert_to_error(val),
1129                                         manager->user_data);
1130         } else if (strcasecmp(key, "end") == 0) {
1131                 if (info->event_state != PACKAGE_MANAGER_EVENT_STATE_FAILED) {
1132                         if (manager->event_cb && getuid() == uid) {
1133                                 if (strcasecmp(val, "ok") == 0) {
1134                                         manager->event_cb(pkg_type, pkg_name,
1135                                                 info->event_type,
1136                                                 PACKAGE_MANAGER_EVENT_STATE_COMPLETED,
1137                                                 100,
1138                                                 PACKAGE_MANAGER_ERROR_NONE,
1139                                                 manager->user_data);
1140                                 } else {
1141                                         manager->event_cb(pkg_type, pkg_name,
1142                                                 info->event_type,
1143                                                 PACKAGE_MANAGER_EVENT_STATE_FAILED,
1144                                                 0,
1145                                                 PACKAGE_MANAGER_ERROR_SYSTEM_ERROR,
1146                                                 manager->user_data);
1147                                 }
1148                         }
1149                 }
1150                 g_hash_table_remove(manager->event_info_table, info->pkg_name);
1151         }
1152
1153         return PACKAGE_MANAGER_ERROR_NONE;
1154 }
1155
1156 static int __convert_status_type(package_manager_status_type_e status_type)
1157 {
1158         int type = 0;
1159
1160         if (status_type == PACKAGE_MANAGER_STATUS_TYPE_ALL)
1161                 return PKGMGR_CLIENT_STATUS_ALL;
1162
1163         if (status_type & PACKAGE_MANAGER_STATUS_TYPE_INSTALL)
1164                 type |= PKGMGR_CLIENT_STATUS_INSTALL;
1165         if (status_type & PACKAGE_MANAGER_STATUS_TYPE_UNINSTALL)
1166                 type |= PKGMGR_CLIENT_STATUS_UNINSTALL;
1167         if (status_type & PACKAGE_MANAGER_STATUS_TYPE_UPGRADE)
1168                 type |= PKGMGR_CLIENT_STATUS_UPGRADE;
1169         if (status_type & PACKAGE_MANAGER_STATUS_TYPE_MOVE)
1170                 type |= PKGMGR_CLIENT_STATUS_MOVE;
1171         if (status_type & PACKAGE_MANAGER_STATUS_TYPE_CLEAR_DATA)
1172                 type |= PKGMGR_CLIENT_STATUS_CLEAR_DATA;
1173         if (status_type & PACKAGE_MANAGER_STATUS_TYPE_INSTALL_PROGRESS)
1174                 type |= PKGMGR_CLIENT_STATUS_INSTALL_PROGRESS;
1175         if (status_type & PACKAGE_MANAGER_STATUS_TYPE_GET_SIZE)
1176                 type |= PKGMGR_CLIENT_STATUS_GET_SIZE;
1177
1178         return type;
1179 }
1180
1181 API int package_manager_set_event_status(package_manager_h manager, int status_type)
1182 {
1183         int retval;
1184         int type;
1185         int type_all = PACKAGE_MANAGER_STATUS_TYPE_INSTALL |
1186                 PACKAGE_MANAGER_STATUS_TYPE_UNINSTALL |
1187                 PACKAGE_MANAGER_STATUS_TYPE_UPGRADE |
1188                 PACKAGE_MANAGER_STATUS_TYPE_MOVE |
1189                 PACKAGE_MANAGER_STATUS_TYPE_CLEAR_DATA |
1190                 PACKAGE_MANAGER_STATUS_TYPE_INSTALL_PROGRESS |
1191                 PACKAGE_MANAGER_STATUS_TYPE_GET_SIZE;
1192
1193         if (manager == NULL)
1194                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1195
1196         if (status_type < 0 || status_type > type_all)
1197                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1198
1199         type = __convert_status_type(status_type);
1200         retval = pkgmgr_client_set_status_type(manager->pc, type);
1201
1202         if (retval < 0)
1203                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
1204
1205         return PACKAGE_MANAGER_ERROR_NONE;
1206 }
1207
1208 API int package_manager_set_event_cb(package_manager_h manager,
1209                                  package_manager_event_cb callback,
1210                                  void *user_data)
1211 {
1212         int retval;
1213         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
1214         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1215                 return retval;
1216
1217         if (package_manager_validate_handle(manager)) {
1218                 return
1219                     package_manager_error
1220                     (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
1221                      NULL);
1222         }
1223
1224         manager->event_cb = callback;
1225         manager->user_data = user_data;
1226
1227         retval = pkgmgr_client_listen_status(manager->pc,
1228                         internal_callback, manager);
1229         if (retval < 0) {
1230                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR,
1231                         __FUNCTION__, NULL);
1232         }
1233
1234         if (!manager->event_info_table) {
1235                 manager->event_info_table =
1236                         g_hash_table_new_full(g_str_hash, g_str_equal,
1237                                 NULL, __free_event_info);
1238         }
1239
1240         return PACKAGE_MANAGER_ERROR_NONE;
1241 }
1242
1243 API int package_manager_unset_event_cb(package_manager_h manager)
1244 {
1245         if (manager == NULL) {
1246                 return
1247                     package_manager_error
1248                     (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
1249                      NULL);
1250         }
1251
1252         int retval;
1253         manager->event_cb = NULL;
1254         manager->user_data = NULL;
1255
1256         g_hash_table_remove_all(manager->event_info_table);
1257
1258         retval = pkgmgr_client_remove_listen_status(manager->pc);
1259         if (retval == PKGMGR_R_EINVAL)
1260                 return
1261                          package_manager_error
1262                          (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
1263                           NULL);
1264         else if (retval == PKGMGR_R_ERROR)
1265                 return
1266                          package_manager_error
1267                          (PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__,
1268                           NULL);
1269
1270         return PACKAGE_MANAGER_ERROR_NONE;
1271 }
1272
1273 API int package_manager_get_package_id_by_app_id(const char *app_id, char **package_id)
1274 {
1275         pkgmgrinfo_appinfo_h pkgmgrinfo_appinfo;
1276         int retval;
1277         char *pkg_id = NULL;
1278         char *pkg_id_dup = NULL;
1279
1280         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
1281         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1282                 return retval;
1283
1284         if (app_id == NULL || package_id == NULL)
1285                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1286
1287         if (pkgmgrinfo_appinfo_get_appinfo(app_id, &pkgmgrinfo_appinfo) != PMINFO_R_OK)
1288                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1289         retval = pkgmgrinfo_appinfo_get_pkgname(pkgmgrinfo_appinfo, &pkg_id);
1290         if (retval != PMINFO_R_OK) {
1291                 pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
1292                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1293         }
1294
1295         pkg_id_dup = strdup(pkg_id);
1296         if (pkg_id_dup == NULL) {
1297                 pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
1298                 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
1299         }
1300
1301         *package_id = pkg_id_dup;
1302
1303         pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
1304
1305         return PACKAGE_MANAGER_ERROR_NONE;
1306 }
1307
1308 API int package_manager_get_package_info(const char *package_id, package_info_h *package_info)
1309 {
1310         int retval;
1311         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
1312         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1313                 return retval;
1314
1315         retval = package_info_get_package_info(package_id, package_info);
1316
1317         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1318                 return package_manager_error(retval, __FUNCTION__, NULL);
1319         else
1320                 return PACKAGE_MANAGER_ERROR_NONE;
1321 }
1322
1323 API int package_manager_foreach_package_info(package_manager_package_info_cb callback,
1324                                         void *user_data)
1325 {
1326         int retval;
1327         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
1328         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1329                 return retval;
1330
1331         retval = package_info_foreach_package_info(callback, user_data);
1332
1333         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1334                 return package_manager_error(retval, __FUNCTION__, NULL);
1335         else
1336                 return PACKAGE_MANAGER_ERROR_NONE;
1337 }
1338
1339 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)
1340 {
1341         pkgmgrinfo_cert_compare_result_type_e result;
1342
1343         if (lhs_package_id == NULL || rhs_package_id == NULL || compare_result == NULL)
1344                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1345         if (pkgmgrinfo_pkginfo_compare_pkg_cert_info(lhs_package_id, rhs_package_id, &result) != PKGMGR_R_OK)
1346                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
1347         *compare_result = (package_manager_compare_result_type_e)result;
1348
1349         return PACKAGE_MANAGER_ERROR_NONE;
1350 }
1351
1352 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)
1353 {
1354         pkgmgrinfo_cert_compare_result_type_e result;
1355
1356         if (lhs_app_id == NULL || rhs_app_id == NULL || compare_result == NULL)
1357                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1358         if (pkgmgrinfo_pkginfo_compare_app_cert_info(lhs_app_id, rhs_app_id, &result) != PKGMGR_R_OK)
1359                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
1360
1361         *compare_result = (package_manager_compare_result_type_e)result;
1362
1363         return PACKAGE_MANAGER_ERROR_NONE;
1364 }
1365
1366 API int package_manager_is_preload_package_by_app_id(const char *app_id, bool *preload)
1367 {
1368         int retval;
1369         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
1370         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1371                 return retval;
1372
1373         pkgmgrinfo_appinfo_h pkgmgrinfo_appinfo = NULL;
1374         pkgmgrinfo_pkginfo_h pkgmgrinfo_pkginfo = NULL;
1375
1376         char *pkg_id = NULL;
1377         bool is_preload = 0;
1378         if (pkgmgrinfo_appinfo_get_appinfo(app_id, &pkgmgrinfo_appinfo) != PMINFO_R_OK)
1379                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1380
1381         retval = pkgmgrinfo_appinfo_get_pkgname(pkgmgrinfo_appinfo, &pkg_id);
1382         if (retval != PMINFO_R_OK) {
1383                 pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
1384                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1385         }
1386         if (pkgmgrinfo_pkginfo_get_pkginfo(pkg_id, &pkgmgrinfo_pkginfo) != PMINFO_R_OK) {
1387                 pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
1388                 pkgmgrinfo_pkginfo_destroy_pkginfo(pkgmgrinfo_pkginfo);
1389                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1390         }
1391         if (pkgmgrinfo_pkginfo_is_preload(pkgmgrinfo_pkginfo, &is_preload) != PMINFO_R_OK) {
1392                 pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
1393                 pkgmgrinfo_pkginfo_destroy_pkginfo(pkgmgrinfo_pkginfo);
1394                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1395         }
1396
1397         if (is_preload)
1398                 *preload = 1;
1399         else
1400                 *preload = 0;
1401
1402         pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
1403         pkgmgrinfo_pkginfo_destroy_pkginfo(pkgmgrinfo_pkginfo);
1404
1405         return PACKAGE_MANAGER_ERROR_NONE;
1406 }
1407
1408 API int package_manager_get_permission_type(const char *app_id, package_manager_permission_type_e *permission_type)
1409 {
1410         int retval;
1411         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
1412         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1413                 return retval;
1414
1415         pkgmgrinfo_appinfo_h pkgmgrinfo_appinfo = NULL;
1416         pkgmgrinfo_permission_type permission = 0;
1417         if (pkgmgrinfo_appinfo_get_appinfo(app_id, &pkgmgrinfo_appinfo) != PMINFO_R_OK)
1418                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1419         retval = pkgmgrinfo_appinfo_get_permission_type(pkgmgrinfo_appinfo, &permission);
1420         if (retval != PMINFO_R_OK) {
1421                 pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
1422                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1423         }
1424
1425         if (permission == PMINFO_PERMISSION_NORMAL)
1426                 *permission_type = PACKAGE_MANAGER_PERMISSION_NORMAL;
1427         else if (permission == PMINFO_PERMISSION_SIGNATURE)
1428                 *permission_type = PACKAGE_MANAGER_PERMISSION_SIGNATURE;
1429         else if (permission == PMINFO_PERMISSION_PRIVILEGE)
1430                 *permission_type = PACKAGE_MANAGER_PERMISSION_PRIVILEGE;
1431         else
1432                 *permission_type = PACKAGE_MANAGER_PERMISSION_NORMAL;
1433
1434         pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
1435         return PACKAGE_MANAGER_ERROR_NONE;
1436 }
1437
1438 API int package_manager_clear_cache_dir(const char *package_id)
1439 {
1440         int retval;
1441         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_CACHE);
1442         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1443                 return retval;
1444
1445         int res = pkgmgr_client_clear_cache_dir(package_id);
1446         if (res == PKGMGR_R_EINVAL) {
1447                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1448         } else if (res == PKGMGR_R_ENOPKG) {
1449                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1450         } else if (res == PKGMGR_R_ENOMEM) {
1451                 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
1452         } else if (res == PKGMGR_R_EIO) {
1453                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
1454         } else if (res == PKGMGR_R_EPRIV) {
1455                 return package_manager_error(PACKAGE_MANAGER_ERROR_PERMISSION_DENIED, __FUNCTION__, NULL);
1456         } else if (res == PKGMGR_R_ESYSTEM || res == PKGMGR_R_ECOMM || res == PKGMGR_R_ERROR) {
1457                 return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
1458         } else if (res != PKGMGR_R_OK) {
1459                 _LOGE("Unexpected error");
1460                 return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
1461         }
1462
1463         return PACKAGE_MANAGER_ERROR_NONE;
1464 }
1465
1466 API int package_manager_clear_data_dir(const char *package_id)
1467 {
1468         int retval;
1469         pkgmgr_client *pc = NULL;
1470         char *pkg_type = NULL;
1471         pkgmgrinfo_pkginfo_h pkginfo = NULL;
1472
1473         if (package_id == NULL)
1474                 return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
1475
1476         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_ADMIN);
1477         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1478                 return retval;
1479
1480         retval = pkgmgrinfo_pkginfo_get_pkginfo(package_id, &pkginfo);
1481         if (retval == PMINFO_R_ENOENT)
1482                 return PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE;
1483         else if (retval != PMINFO_R_OK || pkginfo == NULL)
1484                 return PACKAGE_MANAGER_ERROR_SYSTEM_ERROR;
1485
1486         retval = pkgmgrinfo_pkginfo_get_type(pkginfo, &pkg_type);
1487         if (retval != PMINFO_R_OK || pkg_type == NULL) {
1488                 pkgmgrinfo_pkginfo_destroy_pkginfo(pkginfo);
1489                 return PACKAGE_MANAGER_ERROR_SYSTEM_ERROR;
1490         }
1491
1492         pc = pkgmgr_client_new(PC_REQUEST);
1493         if (pc == NULL) {
1494                 _LOGE("Out of memory");
1495                 pkgmgrinfo_pkginfo_destroy_pkginfo(pkginfo);
1496                 return PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY;
1497         }
1498
1499         retval = pkgmgr_client_clear_user_data(pc, pkg_type, package_id, PM_QUIET);
1500         pkgmgr_client_free(pc);
1501         pkgmgrinfo_pkginfo_destroy_pkginfo(pkginfo);
1502
1503         if (retval == PKGMGR_R_EINVAL) {
1504                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1505         } else if (retval == PKGMGR_R_ENOPKG) {
1506                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1507         } else if (retval == PKGMGR_R_ENOMEM) {
1508                 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
1509         } else if (retval == PKGMGR_R_EIO) {
1510                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
1511         } else if (retval == PKGMGR_R_EPRIV) {
1512                 return package_manager_error(PACKAGE_MANAGER_ERROR_PERMISSION_DENIED, __FUNCTION__, NULL);
1513         } else if (retval == PKGMGR_R_ESYSTEM || retval == PKGMGR_R_ECOMM || retval == PKGMGR_R_ERROR) {
1514                 return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
1515         } else if (retval != PKGMGR_R_OK) {
1516                 _LOGE("Unexpected error");
1517                 return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
1518         }
1519
1520         return PACKAGE_MANAGER_ERROR_NONE;
1521 }
1522
1523 API int package_manager_clear_all_cache_dir(void)
1524 {
1525         int retval;
1526         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_ADMIN);
1527         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1528                 return retval;
1529
1530         return package_manager_clear_cache_dir(PKG_CLEAR_ALL_CACHE);
1531 }
1532
1533 struct getsize_cbdata {
1534         pkgmgr_client *pc;
1535         void *cb;
1536         void *user_data;
1537 };
1538
1539 static void __free_getsize_cbdata(struct getsize_cbdata *cbdata)
1540 {
1541         pkgmgr_client_free(cbdata->pc);
1542         free(cbdata);
1543 }
1544
1545 static void __result_cb(pkgmgr_client *pc, const char *pkgid, const pkg_size_info_t *result, void *user_data)
1546 {
1547         struct getsize_cbdata *cbdata = (struct getsize_cbdata *)user_data;
1548         package_manager_size_info_receive_cb callback = cbdata->cb;
1549         if (callback == NULL) {
1550                 _LOGE("callback is null.");
1551                 __free_getsize_cbdata(cbdata);
1552                 return;
1553         }
1554
1555         package_size_info_t size_info;
1556         size_info.data_size  = result->data_size;
1557         size_info.cache_size = result->cache_size;
1558         size_info.app_size   = result->app_size;
1559         size_info.external_data_size  = result->ext_data_size;
1560         size_info.external_cache_size = result->ext_cache_size;
1561         size_info.external_app_size   = result->ext_app_size;
1562
1563         callback(pkgid, (package_size_info_h)&size_info, user_data);
1564
1565         __free_getsize_cbdata(cbdata);
1566 }
1567
1568 static void __total_result_cb(pkgmgr_client *pc, const pkg_size_info_t *result, void *user_data)
1569 {
1570         struct getsize_cbdata *cbdata = (struct getsize_cbdata *)user_data;
1571         package_manager_total_size_info_receive_cb callback = cbdata->cb;
1572         if (callback == NULL) {
1573                 _LOGE("callback is null.");
1574                 __free_getsize_cbdata(cbdata);
1575                 return;
1576         }
1577
1578         package_size_info_t size_info;
1579         size_info.data_size  = result->data_size;
1580         size_info.cache_size = result->cache_size;
1581         size_info.app_size   = result->app_size;
1582         size_info.external_data_size  = result->ext_data_size;
1583         size_info.external_cache_size = result->ext_cache_size;
1584         size_info.external_app_size   = result->ext_app_size;
1585
1586         callback((package_size_info_h)&size_info, user_data);
1587
1588         __free_getsize_cbdata(cbdata);
1589 }
1590
1591 static int _get_pkg_size_info(const char *package_id, void *callback, void *user_data)
1592 {
1593         struct getsize_cbdata *cbdata;
1594
1595         if (package_id == NULL || callback == NULL)
1596                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1597
1598         cbdata = malloc(sizeof(struct getsize_cbdata));
1599         if (cbdata == NULL)
1600                 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
1601
1602         pkgmgr_client *pc = pkgmgr_client_new(PC_REQUEST);
1603         if (pc == NULL) {
1604                 free(cbdata);
1605                 return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
1606         }
1607
1608         cbdata->pc = pc;
1609         cbdata->cb = callback;
1610         cbdata->user_data = user_data;
1611
1612         int res = 0;
1613         if (strcmp(package_id, PKG_SIZE_INFO_TOTAL) != 0)
1614                 res = pkgmgr_client_get_package_size_info(pc, package_id, __result_cb, cbdata);
1615         else
1616                 res = pkgmgr_client_get_total_package_size_info(pc, __total_result_cb, cbdata);
1617
1618         if (res == PKGMGR_R_EINVAL) {
1619                 pkgmgr_client_free(pc);
1620                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1621         } else if (res == PKGMGR_R_ENOPKG) {
1622                 pkgmgr_client_free(pc);
1623                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1624         } else if (res == PKGMGR_R_ENOMEM) {
1625                 pkgmgr_client_free(pc);
1626                 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
1627         } else if (res == PKGMGR_R_EIO) {
1628                 pkgmgr_client_free(pc);
1629                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
1630         } else if (res == PKGMGR_R_EPRIV) {
1631                 pkgmgr_client_free(pc);
1632                 return package_manager_error(PACKAGE_MANAGER_ERROR_PERMISSION_DENIED, __FUNCTION__, NULL);
1633         } else if (res == PKGMGR_R_ESYSTEM || res == PKGMGR_R_ECOMM || res == PKGMGR_R_ERROR) {
1634                 pkgmgr_client_free(pc);
1635                 return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
1636         } else if (res != PKGMGR_R_OK) {
1637                 _LOGE("Unexpected error");
1638                 __free_getsize_cbdata(cbdata);
1639                 return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
1640         }
1641
1642         return PACKAGE_MANAGER_ERROR_NONE;
1643 }
1644
1645 API int package_manager_get_package_size_info(const char *package_id, package_manager_size_info_receive_cb callback, void *user_data)
1646 {
1647         return _get_pkg_size_info(package_id, (void *)callback, user_data);
1648 }
1649
1650 API int package_manager_get_total_package_size_info(package_manager_total_size_info_receive_cb callback, void *user_data)
1651 {
1652         return _get_pkg_size_info(PKG_SIZE_INFO_TOTAL, (void *)callback, user_data);
1653 }
1654
1655 API int package_manager_filter_create(package_manager_filter_h *handle)
1656 {
1657         int retval;
1658         pkgmgrinfo_pkginfo_filter_h pkgmgr_filter = NULL;
1659
1660         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
1661         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1662                 return retval;
1663
1664         if (handle == NULL) {
1665                 return
1666                     package_manager_error
1667                     (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
1668                      NULL);
1669         }
1670
1671         retval = pkgmgrinfo_pkginfo_filter_create(&pkgmgr_filter);
1672         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1673                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
1674
1675         *handle = pkgmgr_filter;
1676
1677         return PACKAGE_MANAGER_ERROR_NONE;
1678 }
1679
1680 API int package_manager_filter_destroy(package_manager_filter_h handle)
1681 {
1682         int retval;
1683
1684         if (handle == NULL) {
1685                 return
1686                     package_manager_error
1687                     (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
1688                      NULL);
1689         }
1690
1691         retval = pkgmgrinfo_pkginfo_filter_destroy(handle);
1692         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1693                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
1694
1695         return PACKAGE_MANAGER_ERROR_NONE;
1696 }
1697
1698 API int package_manager_filter_add_bool(package_manager_filter_h handle,
1699                 const char *property, const bool value)
1700 {
1701         int retval;
1702
1703         if ((handle == NULL) || (property == NULL)) {
1704                 return
1705                     package_manager_error
1706                     (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
1707                      NULL);
1708         }
1709
1710         retval = pkgmgrinfo_pkginfo_filter_add_bool(handle, property, value);
1711         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1712                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
1713
1714         return PACKAGE_MANAGER_ERROR_NONE;
1715 }
1716
1717 API int package_manager_filter_count(package_manager_filter_h handle, int *count)
1718 {
1719         int retval;
1720         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
1721         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1722                 return retval;
1723
1724         if ((handle == NULL) || (count == NULL))
1725                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1726
1727         retval = pkgmgrinfo_pkginfo_filter_count(handle, count);
1728         if (retval < 0)
1729                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
1730
1731         return PACKAGE_MANAGER_ERROR_NONE;
1732 }
1733
1734 API int package_manager_filter_foreach_package_info(package_manager_filter_h handle,
1735                 package_manager_package_info_cb callback, void *user_data)
1736 {
1737         int retval;
1738         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
1739         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1740                 return retval;
1741
1742         retval = package_info_filter_foreach_package_info(handle, callback, user_data);
1743
1744         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1745                 return package_manager_error(retval, __FUNCTION__, NULL);
1746         else
1747                 return PACKAGE_MANAGER_ERROR_NONE;
1748 }
1749
1750 API int package_size_info_get_data_size(package_size_info_h handle, long long *data_size)
1751 {
1752         if (handle == NULL)
1753                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1754
1755         package_size_info_t *size_info = (package_size_info_t *)handle;
1756
1757         *data_size = (long long)size_info->data_size;
1758         return PACKAGE_MANAGER_ERROR_NONE;
1759 }
1760
1761 API int package_size_info_get_cache_size(package_size_info_h handle, long long *cache_size)
1762 {
1763         if (handle == NULL)
1764                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1765
1766         package_size_info_t *size_info = (package_size_info_t *)handle;
1767
1768         *cache_size = size_info->cache_size;
1769         return PACKAGE_MANAGER_ERROR_NONE;
1770 }
1771
1772 API int package_size_info_get_app_size(package_size_info_h handle, long long *app_size)
1773 {
1774         if (handle == NULL)
1775                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1776
1777         package_size_info_t *size_info = (package_size_info_t *)handle;
1778         *app_size = size_info->app_size;
1779         return PACKAGE_MANAGER_ERROR_NONE;
1780 }
1781
1782 API int package_size_info_get_external_data_size(package_size_info_h handle, long long *ext_data_size)
1783 {
1784         if (handle == NULL)
1785                 return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
1786
1787         package_size_info_t *size_info = (package_size_info_t *)handle;
1788         *ext_data_size = size_info->external_data_size;
1789         return PACKAGE_MANAGER_ERROR_NONE;
1790 }
1791
1792 API int package_size_info_get_external_cache_size(package_size_info_h handle, long long *ext_cache_size)
1793 {
1794         if (handle == NULL)
1795                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1796
1797         package_size_info_t *size_info = (package_size_info_t *)handle;
1798         *ext_cache_size = size_info->external_cache_size;
1799         return PACKAGE_MANAGER_ERROR_NONE;
1800 }
1801
1802 API int package_size_info_get_external_app_size(package_size_info_h handle, long long *ext_app_size)
1803 {
1804         if (handle == NULL)
1805                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1806
1807         package_size_info_t *size_info = (package_size_info_t *)handle;
1808         *ext_app_size = size_info->external_app_size;
1809         return PACKAGE_MANAGER_ERROR_NONE;
1810 }
1811
1812 API int package_manager_updateinfo_set_pkgid(package_updateinfo_request_h pkg_updateinfo_req, const char *pkgid)
1813 {
1814         struct package_updateinfo_request_s *request;
1815
1816         if (pkg_updateinfo_req == NULL || pkg_updateinfo_req->updateinfo_handle == NULL || pkgid == NULL)
1817                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1818
1819         request = (struct package_updateinfo_request_s *)pkg_updateinfo_req;
1820         if (request->updateinfo_handle->pkgid)
1821                 free(request->updateinfo_handle->pkgid);
1822         request->updateinfo_handle->pkgid = strdup(pkgid);
1823         if (request->updateinfo_handle->pkgid == NULL)
1824                 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
1825
1826         return PACKAGE_MANAGER_ERROR_NONE;
1827 }
1828
1829 API int package_manager_updateinfo_set_version(package_updateinfo_request_h pkg_updateinfo_req, const char *version)
1830 {
1831         struct package_updateinfo_request_s *request;
1832
1833         if (pkg_updateinfo_req == NULL || pkg_updateinfo_req->updateinfo_handle == NULL || version == NULL)
1834                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1835
1836         request = (struct package_updateinfo_request_s *)pkg_updateinfo_req;
1837         if (request->updateinfo_handle->version)
1838                 free(request->updateinfo_handle->version);
1839         request->updateinfo_handle->version = strdup(version);
1840         if (request->updateinfo_handle->version == NULL)
1841                 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
1842
1843         return PACKAGE_MANAGER_ERROR_NONE;
1844 }
1845
1846 static int package_manager_updateinfo_convert_property(package_updateinfo_type_e property, pkgmgr_updateinfo_type *converted_property)
1847 {
1848         if (converted_property == NULL)
1849                 return -1;
1850
1851         if (property == PACKAGE_UPDATEINFO_TYPE_FORCE)
1852                 *converted_property = PM_UPDATEINFO_TYPE_FORCE;
1853         else if (property == PACKAGE_UPDATEINFO_TYPE_OPTIONAL)
1854                 *converted_property = PM_UPDATEINFO_TYPE_OPTIONAL;
1855         else if (property == PACKAGE_UPDATEINFO_TYPE_NONE)
1856                 *converted_property = PM_UPDATEINFO_TYPE_NONE;
1857         else
1858                 return -1;
1859
1860         return 0;
1861 }
1862
1863 API int package_manager_updateinfo_set_type(package_updateinfo_request_h pkg_updateinfo_req, package_updateinfo_type_e type)
1864 {
1865         int retval;
1866         pkgmgr_updateinfo_type converted_type;
1867         struct package_updateinfo_request_s *request;
1868
1869         if (pkg_updateinfo_req == NULL || pkg_updateinfo_req->updateinfo_handle == NULL)
1870                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1871
1872         request = (struct package_updateinfo_request_s *)pkg_updateinfo_req;
1873         retval = package_manager_updateinfo_convert_property(type, &converted_type);
1874         if (retval != 0)
1875                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1876
1877         request->updateinfo_handle->type = converted_type;
1878         return PACKAGE_MANAGER_ERROR_NONE;
1879 }
1880
1881 API int package_manager_updateinfo_request_destroy(package_updateinfo_request_h pkg_updateinfo_req)
1882 {
1883         struct package_updateinfo_request_s *request;
1884
1885         if (pkg_updateinfo_req == NULL)
1886                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1887
1888         request = (struct package_updateinfo_request_s *)pkg_updateinfo_req;
1889         if (request->pc)
1890                 pkgmgr_client_free(request->pc);
1891
1892         if (request->updateinfo_handle) {
1893                 if (request->updateinfo_handle->pkgid)
1894                         free(request->updateinfo_handle->pkgid);
1895                 if (request->updateinfo_handle->version)
1896                         free(request->updateinfo_handle->version);
1897                 free(request->updateinfo_handle);
1898         }
1899         free(request);
1900
1901         return PACKAGE_MANAGER_ERROR_NONE;
1902 }
1903
1904 API  int package_manager_updateinfo_request_create(package_updateinfo_request_h *pkg_updateinfo_req)
1905 {
1906         struct package_updateinfo_request_s *request;
1907         pkg_update_info_t *update_info;
1908
1909         if (pkg_updateinfo_req == NULL)
1910                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1911
1912         request = calloc(1, sizeof(struct package_updateinfo_request_s));
1913         if (request == NULL)
1914                 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
1915
1916         request->pc = pkgmgr_client_new(PC_REQUEST);
1917         if (request->pc == NULL) {
1918                 free(request);
1919                 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
1920         }
1921
1922         update_info = calloc(1, sizeof(pkg_update_info_t));
1923         if (update_info == NULL) {
1924                 pkgmgr_client_free(request->pc);
1925                 free(request);
1926                 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
1927         }
1928         request->updateinfo_handle = update_info;
1929
1930         *pkg_updateinfo_req = request;
1931         return PACKAGE_MANAGER_ERROR_NONE;
1932 }
1933
1934 API int package_manager_updateinfo_request_register(package_updateinfo_request_h pkg_updateinfo_req)
1935 {
1936         struct package_updateinfo_request_s *update_info;
1937         int retval;
1938
1939         if (pkg_updateinfo_req == NULL)
1940                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1941         update_info = (struct package_updateinfo_request_s *)pkg_updateinfo_req;
1942
1943         retval = pkgmgr_client_register_pkg_update_info(update_info->pc, update_info->updateinfo_handle);
1944         if (retval == PKGMGR_R_EINVAL)
1945                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1946
1947         return PACKAGE_MANAGER_ERROR_NONE;
1948 }
1949
1950 API int package_manager_updateinfo_request_unregister(package_updateinfo_request_h pkg_updateinfo_req, const char *pkgid)
1951 {
1952         int retval;
1953         struct package_updateinfo_request_s *update_info;
1954
1955         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_ADMIN);
1956         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1957                 return retval;
1958
1959         if (pkg_updateinfo_req == NULL || pkgid == NULL)
1960                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1961
1962         update_info = (struct package_updateinfo_request_s *)pkg_updateinfo_req;
1963         retval = pkgmgr_client_unregister_pkg_update_info(update_info->pc, pkgid);
1964         if (retval != PMINFO_R_OK)
1965                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
1966
1967         return PACKAGE_MANAGER_ERROR_NONE;
1968 }
1969
1970 API int package_manager_updateinfo_request_unregister_all(package_updateinfo_request_h pkg_updateinfo_req)
1971 {
1972         int retval;
1973         struct package_updateinfo_request_s *update_info;
1974
1975         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_ADMIN);
1976         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1977                 return retval;
1978
1979         if (pkg_updateinfo_req == NULL)
1980                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1981
1982         update_info = (struct package_updateinfo_request_s *)pkg_updateinfo_req;
1983         retval = pkgmgr_client_unregister_all_pkg_update_info(update_info->pc);
1984
1985         if (retval != PMINFO_R_OK)
1986                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
1987
1988         return PACKAGE_MANAGER_ERROR_NONE;
1989 }