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