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         package_manager_res_event_cb res_event_cb;
  53         void *user_data;
  54         GMutex mutex;
  55 };
  56
  57 struct package_manager_request_s {
  58         int handle_id;
  59         pkgmgr_client_type ctype;
  60         pkgmgr_client *pc;
  61         char *pkg_type;
  62         pkgmgr_mode mode;
  63         request_event_info *head;
  64         package_manager_request_event_cb event_cb;
  65         GHashTable *request_cb_table;
  66         int n_paths;
  67         void *user_data;
  68 };
  69
  70 struct package_manager_request_cb_info {
  71         int req_id;
  72         package_manager_request_event_cb callback;
  73         package_manager_request_res_event_cb res_callback;
  74         void *user_data;
  75 };
  76
  77 typedef struct package_size_info {
  78         long long data_size;
  79         long long cache_size;
  80         long long app_size;
  81
  82         long long external_data_size;
  83         long long external_cache_size;
  84         long long external_app_size;
  85 } package_size_info_t;
  86
  87 struct package_manager_filter_s {
  88         pkgmgrinfo_pkginfo_filter_h pkgmgrinfo_pkginfo_filter;
  89 };
  90
  91 struct package_updateinfo_request_s {
  92         pkgmgr_client *pc;
  93         pkg_update_info_t *updateinfo_handle;
  94 };
  95
  96 struct package_manager_res_event_info_s {
  97         pkgmgr_res_event_info *res_event_info_handle;
  98 };
  99
 100 static int package_manager_request_new_id()
 101 {
 102         static int request_handle_id = 0;
 103         return request_handle_id++;
 104 }
 105
 106 static int package_manager_new_id()
 107 {
 108         static int manager_handle_id = 0;
 109         return manager_handle_id++;
 110 }
 111
 112 static void __clean_all_event_info(request_event_info *head)
 113 {
 114         request_event_info *current = head;
 115         request_event_info *prev;
 116
 117         if (current == NULL)
 118                 return;
 119
 120         while (current) {
 121                 prev = current;
 122                 current = current->next;
 123                 free(prev);
 124         }
 125 }
 126
 127 static int __insert_event_info(package_manager_h manager, const char *pkg_name,
 128                         package_manager_event_type_e event_type,
 129                         package_manager_event_state_e event_state)
 130 {
 131         struct package_manager_event_info *info;
 132
 133         info = calloc(1, sizeof(struct package_manager_event_info));
 134         if (info == NULL)
 135                 return -1;
 136         info->pkg_name = strdup(pkg_name);
 137         info->event_type = event_type;
 138         info->event_state = event_state;
 139         g_hash_table_insert(manager->event_info_table, info->pkg_name, info);
 140
 141         return 0;
 142 }
 143
 144 static void __free_event_info(gpointer data)
 145 {
 146         struct package_manager_event_info *info =
 147                         (struct package_manager_event_info *)data;
 148
 149         if (!info)
 150                 return;
 151
 152         if (info->pkg_name)
 153                 free(info->pkg_name);
 154         free(info);
 155
 156         _LOGD("event_info removed");
 157 }
 158
 159 static void __free_request_cb_info(gpointer data)
 160 {
 161         int req_id;
 162         struct package_manager_request_cb_info *cb_info =
 163                         (struct package_manager_request_cb_info *)data;
 164
 165         req_id = cb_info->req_id;
 166         free(cb_info);
 167         cb_info = NULL;
 168
 169         _LOGD("request callback info removed, req_id(%d)", req_id);
 170 }
 171
 172 static void __initialize_request_cb_table(package_manager_request_h request)
 173 {
 174         request->request_cb_table =
 175                 g_hash_table_new_full(g_direct_hash, g_direct_equal, NULL, __free_request_cb_info);
 176 }
 177
 178 static int __insert_request_cb_info(package_manager_request_h request, int req_id,
 179                 package_manager_request_event_cb callback, void *user_data)
 180 {
 181         struct package_manager_request_cb_info *cb_info;
 182
 183         if (request->request_cb_table == NULL)
 184                 return -1;
 185
 186         cb_info = calloc(1, sizeof(struct package_manager_request_cb_info));
 187         if (cb_info == NULL)
 188                 return -1;
 189         cb_info->req_id = req_id;
 190         cb_info->callback = callback;
 191         cb_info->user_data = user_data;
 192         _LOGD("insert req_id(%d)", req_id);
 193         g_hash_table_insert(request->request_cb_table, GINT_TO_POINTER(cb_info->req_id), cb_info);
 194
 195         return 0;
 196 }
 197
 198 static int __insert_res_request_cb_info(package_manager_request_h request,
 199                 int req_id, package_manager_request_res_event_cb callback,
 200                 void *user_data)
 201 {
 202         struct package_manager_request_cb_info *cb_info;
 203
 204         if (request->request_cb_table == NULL)
 205                 return -1;
 206
 207         cb_info = calloc(1, sizeof(struct package_manager_request_cb_info));
 208         if (cb_info == NULL)
 209                 return -1;
 210         cb_info->req_id = req_id;
 211         cb_info->res_callback = callback;
 212         cb_info->user_data = user_data;
 213         _LOGD("insert req_id(%d)", req_id);
 214         g_hash_table_insert(request->request_cb_table, GINT_TO_POINTER(cb_info->req_id), cb_info);
 215
 216         return 0;
 217 }
 218
 219 API int package_manager_request_create(package_manager_request_h *request)
 220 {
 221         struct package_manager_request_s *package_manager_request;
 222
 223         if (request == NULL) {
 224                 return
 225                     package_manager_error
 226                     (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
 227                      NULL);
 228         }
 229
 230         package_manager_request =
 231             calloc(1, sizeof(struct package_manager_request_s));
 232         if (package_manager_request == NULL) {
 233                 return
 234                     package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY,
 235                                           __FUNCTION__,
 236                                           "failed to create a package_manager handle");
 237         }
 238
 239         package_manager_request->ctype = PC_REQUEST;
 240         package_manager_request->pc = pkgmgr_client_new(PC_REQUEST);
 241         if (package_manager_request->pc == NULL) {
 242                 free(package_manager_request);
 243                 return
 244                     package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY,
 245                                           __FUNCTION__,
 246                                           "failed to create a package_manager client");
 247         }
 248
 249         package_manager_request->handle_id = package_manager_request_new_id();
 250
 251         *request = package_manager_request;
 252
 253         return PACKAGE_MANAGER_ERROR_NONE;
 254 }
 255
 256 static int package_manager_client_validate_handle(package_manager_request_h
 257                                                  request)
 258 {
 259         if (request == NULL || request->pc == NULL)
 260                 return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
 261
 262         return PACKAGE_MANAGER_ERROR_NONE;
 263 }
 264
 265 API int package_manager_request_destroy(package_manager_request_h request)
 266 {
 267         if (package_manager_client_validate_handle(request)) {
 268                 return
 269                     package_manager_error
 270                     (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
 271                      NULL);
 272         }
 273
 274         pkgmgr_client_free(request->pc);
 275         request->pc = NULL;
 276         free(request->pkg_type);
 277         __clean_all_event_info(request->head);
 278         if (request->request_cb_table) {
 279                 g_hash_table_destroy(request->request_cb_table);
 280                 request->request_cb_table = NULL;
 281         }
 282         free(request);
 283
 284         return PACKAGE_MANAGER_ERROR_NONE;
 285 }
 286
 287 static int __reset_user_request_callback(package_manager_request_h request,
 288                         package_manager_request_event_cb callback, void *user_data)
 289 {
 290         if (package_manager_client_validate_handle(request))
 291                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 292
 293         request->event_cb = callback;
 294         request->user_data = user_data;
 295
 296         return PACKAGE_MANAGER_ERROR_NONE;
 297 }
 298
 299 API int package_manager_request_set_event_cb(package_manager_request_h request,
 300                                          package_manager_request_event_cb
 301                                          callback, void *user_data)
 302 {
 303         int ret;
 304
 305         if (package_manager_client_validate_handle(request))
 306                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER,
 307                                 __FUNCTION__, NULL);
 308
 309         ret = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
 310         if (ret != PACKAGE_MANAGER_ERROR_NONE)
 311                 return ret;
 312
 313         return __reset_user_request_callback(request, callback, user_data);
 314 }
 315
 316 API int package_manager_request_unset_event_cb(package_manager_request_h request)
 317 {
 318         if (package_manager_client_validate_handle(request))
 319                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 320
 321         request->event_cb = NULL;
 322         request->user_data = NULL;
 323
 324         return PACKAGE_MANAGER_ERROR_NONE;
 325 }
 326
 327 API int package_manager_request_set_type(package_manager_request_h request,
 328                                      const char *pkg_type)
 329 {
 330         if (package_manager_client_validate_handle(request)) {
 331                 return
 332                     package_manager_error
 333                     (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
 334                      NULL);
 335         }
 336
 337         if (request->pkg_type)
 338                 free(request->pkg_type);
 339         request->pkg_type = strdup(pkg_type);
 340
 341         return PACKAGE_MANAGER_ERROR_NONE;
 342 }
 343
 344 API int package_manager_request_set_mode(package_manager_request_h request,
 345                                      package_manager_request_mode_e mode)
 346 {
 347         if (package_manager_client_validate_handle(request)) {
 348                 return
 349                     package_manager_error
 350                     (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
 351                      NULL);
 352         }
 353
 354         /* request mode is not used anymore */
 355
 356         return PACKAGE_MANAGER_ERROR_NONE;
 357 }
 358
 359 API int package_manager_request_set_tep(package_manager_request_h request,
 360                                      const char *tep_path)
 361 {
 362         int retval = 0;
 363
 364         if (package_manager_client_validate_handle(request) || tep_path == NULL) {
 365                 return
 366                         package_manager_error
 367                         (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
 368                          NULL);
 369         }
 370
 371         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_ADMIN);
 372         if (retval != PACKAGE_MANAGER_ERROR_NONE)
 373                 return retval;
 374
 375         if (pkgmgr_client_set_tep_path(request->pc, tep_path, true))
 376                 return PACKAGE_MANAGER_ERROR_SYSTEM_ERROR;
 377
 378         return PACKAGE_MANAGER_ERROR_NONE;
 379 }
 380
 381 static int package_manager_get_event_type(const char *key,
 382                                           package_manager_event_type_e *
 383                                           event_type)
 384 {
 385         if (key == NULL)
 386                 return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
 387
 388         if (strcasecmp(key, PKGMGR_INSTALLER_INSTALL_EVENT_STR) == 0)
 389                 *event_type = PACKAGE_MANAGER_EVENT_TYPE_INSTALL;
 390         else if (strcasecmp(key, PKGMGR_INSTALLER_UNINSTALL_EVENT_STR) == 0)
 391                 *event_type = PACKAGE_MANAGER_EVENT_TYPE_UNINSTALL;
 392         else if (strcasecmp(key, PKGMGR_INSTALLER_UPGRADE_EVENT_STR) == 0)
 393                 *event_type = PACKAGE_MANAGER_EVENT_TYPE_UPDATE;
 394         else if (strcasecmp(key, PKGMGR_INSTALLER_MOVE_EVENT_STR) == 0)
 395                 *event_type = PACKAGE_MANAGER_EVENT_TYPE_MOVE;
 396         else if (strcasecmp(key, PKGMGR_INSTALLER_CLEAR_EVENT_STR) == 0)
 397                 *event_type = PACKAGE_MANAGER_EVENT_TYPE_CLEAR;
 398         else if (strcasecmp(key, PKGMGR_INSTALLER_RES_COPY_EVENT_STR) == 0)
 399                 *event_type = PACKAGE_MANAGER_EVENT_TYPE_RES_COPY;
 400         else if (strcasecmp(key, PKGMGR_INSTALLER_RES_CREATE_DIR_EVENT_STR) == 0)
 401                 *event_type = PACKAGE_MANAGER_EVENT_TYPE_RES_CREATE_DIR;
 402         else if (strcasecmp(key, PKGMGR_INSTALLER_RES_REMOVE_EVENT_STR) == 0)
 403                 *event_type = PACKAGE_MANAGER_EVENT_TYPE_RES_REMOVE;
 404         else if (strcasecmp(key, PKGMGR_INSTALLER_RES_UNINSTALL_EVENT_STR) == 0)
 405                 *event_type = PACKAGE_MANAGER_EVENT_TYPE_RES_UNINSTALL;
 406         else
 407                 return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
 408
 409         return PACKAGE_MANAGER_ERROR_NONE;
 410 }
 411
 412 static package_manager_error_e __convert_to_error(int errcode)
 413 {
 414         switch (errcode) {
 415         case PKGMGR_INSTALLER_ERRCODE_UNDEFINED_ERROR:
 416         case PKGMGR_INSTALLER_ERRCODE_GLOBALSYMLINK_ERROR:
 417         case PKGMGR_INSTALLER_ERRCODE_GRANT_PERMISSION_ERROR:
 418         case PKGMGR_INSTALLER_ERRCODE_IMAGE_ERROR:
 419         case PKGMGR_INSTALLER_ERRCODE_PARSE_ERROR:
 420         case PKGMGR_INSTALLER_ERRCODE_RECOVERY_ERROR:
 421         case PKGMGR_INSTALLER_ERRCODE_DELTA_ERROR:
 422         case PKGMGR_INSTALLER_ERRCODE_APP_DIR_ERROR:
 423         case PKGMGR_INSTALLER_ERRCODE_CONFIG_ERROR:
 424         case PKGMGR_INSTALLER_ERRCODE_ICON_ERROR:
 425         case PKGMGR_INSTALLER_ERRCODE_MANIFEST_ERROR:
 426         case PKGMGR_INSTALLER_ERRCODE_OUT_OF_SPACE:
 427         case PKGMGR_INSTALLER_ERRCODE_ERROR:
 428                 return PACKAGE_MANAGER_ERROR_SYSTEM_ERROR;
 429         case PKGMGR_INSTALLER_ERRCODE_UNZIP_ERROR:
 430         case PKGMGR_INSTALLER_ERRCODE_SECURITY_ERROR:
 431         case PKGMGR_INSTALLER_ERRCODE_REGISTER_ERROR:
 432         case PKGMGR_INSTALLER_ERRCODE_PRIVILEGE_ERROR:
 433         case PKGMGR_INSTALLER_ERRCODE_SIGNATURE_ERROR:
 434         case PKGMGR_INSTALLER_ERRCODE_SIGNATURE_INVALID:
 435         case PKGMGR_INSTALLER_ERRCODE_CERT_ERROR:
 436         case PKGMGR_INSTALLER_ERRCODE_AUTHOR_CERT_NOT_MATCH:
 437         case PKGMGR_INSTALLER_ERRCODE_AUTHOR_CERT_NOT_FOUND:
 438         case PKGMGR_INSTALLER_ERRCODE_ICON_NOT_FOUND:
 439         case PKGMGR_INSTALLER_ERRCODE_MANIFEST_NOT_FOUND:
 440                 return PACKAGE_MANAGER_ERROR_IO_ERROR;
 441         case PKGMGR_INSTALLER_ERRCODE_PACKAGE_NOT_FOUND:
 442                 return PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE;
 443         case PKGMGR_INSTALLER_ERRCODE_OPERATION_NOT_ALLOWED:
 444                 return PACKAGE_MANAGER_ERROR_PERMISSION_DENIED;
 445         case PKGMGR_INSTALLER_ERRCODE_INVALID_VALUE:
 446                 return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
 447         case PKGMGR_INSTALLER_ERRCODE_OK:
 448                 return PACKAGE_MANAGER_ERROR_NONE;
 449         default:
 450                 return PACKAGE_MANAGER_ERROR_SYSTEM_ERROR;
 451         }
 452 }
 453
 454 static package_manager_error_e __convert_str_to_error(const char *val)
 455 {
 456         int errcode = atoi(val);
 457
 458         return __convert_to_error(errcode);
 459 }
 460
 461 static int __add_event_info(request_event_info **head, int req_id,
 462                             package_manager_event_type_e event_type,
 463                             package_manager_event_state_e event_state)
 464 {
 465         request_event_info *evt_info;
 466         request_event_info *current;
 467         request_event_info *prev;
 468
 469         evt_info = (request_event_info *) calloc(1, sizeof(request_event_info));
 470         if (evt_info == NULL) {
 471                 _LOGD("calloc failed");
 472                 return -1;
 473         }
 474         evt_info->req_id = req_id;
 475         evt_info->event_type = event_type;
 476         evt_info->event_state = event_state;
 477         evt_info->next = NULL;
 478
 479         if (*head == NULL)
 480                 *head = evt_info;
 481         else {
 482                 current = prev = *head;
 483                 while (current) {
 484                         prev = current;
 485                         current = current->next;
 486                 }
 487
 488                 prev->next = evt_info;
 489         }
 490
 491         return 0;
 492 }
 493
 494 static int __find_event_info(request_event_info **head, int req_id,
 495                              package_manager_event_type_e *event_type,
 496                              package_manager_event_state_e *event_state)
 497 {
 498         request_event_info *tmp;
 499
 500         tmp = *head;
 501
 502         if (tmp == NULL) {
 503                 _LOGE("tmp is NULL");
 504                 return -1;
 505         }
 506
 507         while (tmp) {
 508                 if (tmp->req_id == req_id) {
 509                         *event_type = tmp->event_type;
 510                         *event_state = tmp->event_state;
 511                         return 0;
 512                 }
 513                 tmp = tmp->next;
 514         }
 515         return -1;
 516 }
 517
 518 static int __update_event_info(request_event_info **head, int req_id,
 519                                package_manager_event_type_e event_type,
 520                                package_manager_event_state_e event_state)
 521 {
 522         package_manager_event_type_e evt_type;
 523         package_manager_event_state_e evt_state;
 524         request_event_info *tmp;
 525
 526         if (__find_event_info(head, req_id, &evt_type, &evt_state) != 0)
 527                 __add_event_info(head, req_id, event_type, event_state);
 528         else {
 529                 tmp = *head;
 530
 531                 if (tmp == NULL) {
 532                         _LOGE("tmp is NULL");
 533                         return -1;
 534                 }
 535
 536                 while (tmp) {
 537                         if (tmp->req_id == req_id) {
 538                                 tmp->event_type = event_type;
 539                                 tmp->event_state = event_state;
 540                                 return 0;
 541                         }
 542                         tmp = tmp->next;
 543                 }
 544         }
 545
 546         return -1;
 547 }
 548
 549 static int request_event_handler(uid_t target_uid, int req_id, const char *pkg_type,
 550                                  const char *pkg_name, const char *key,
 551                                  const char *val, const void *pmsg, void *data)
 552 {
 553         int ret = -1;
 554         package_manager_event_type_e event_type = -1;
 555         package_manager_event_state_e event_state = -1;
 556
 557         package_manager_request_h request = data;
 558
 559         if (strcasecmp(key, "start") == 0) {
 560                 ret = package_manager_get_event_type(val, &event_type);
 561                 if (ret != PACKAGE_MANAGER_ERROR_NONE)
 562                         return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
 563
 564                 __add_event_info(&(request->head), req_id, event_type,
 565                                  PACKAGE_MANAGER_EVENT_STATE_STARTED);
 566
 567                 if (request->event_cb)
 568                         request->event_cb(req_id, pkg_type, pkg_name,
 569                                           event_type,
 570                                           PACKAGE_MANAGER_EVENT_STATE_STARTED,
 571                                           0, PACKAGE_MANAGER_ERROR_NONE, request->user_data);
 572
 573         } else if (strcasecmp(key, "install_percent") == 0
 574                    || strcasecmp(key, "progress_percent") == 0) {
 575                 if (__find_event_info
 576                     (&(request->head), req_id, &event_type,
 577                      &event_state) == 0) {
 578                         __update_event_info(&(request->head), req_id,
 579                                             event_type,
 580                                             PACKAGE_MANAGER_EVENT_STATE_PROCESSING);
 581                         if (request->event_cb)
 582                                 request->event_cb(req_id, pkg_type, pkg_name,
 583                                                   event_type,
 584                                                   PACKAGE_MANAGER_EVENT_STATE_PROCESSING,
 585                                                   atoi(val),
 586                                                   PACKAGE_MANAGER_ERROR_NONE,
 587                                                   request->user_data);
 588                 }
 589
 590         } else if (strcasecmp(key, "error") == 0) {
 591                 if (__find_event_info
 592                     (&(request->head), req_id, &event_type,
 593                      &event_state) == 0) {
 594                         __update_event_info(&(request->head), req_id,
 595                                             event_type,
 596                                             PACKAGE_MANAGER_EVENT_STATE_FAILED);
 597                 }
 598
 599                 if (request->event_cb)
 600                         request->event_cb(req_id, pkg_type,
 601                                           pkg_name, event_type,
 602                                           PACKAGE_MANAGER_EVENT_STATE_FAILED,
 603                                           0,
 604                                           __convert_str_to_error(val),
 605                                           request->user_data);
 606
 607         } else if (strcasecmp(key, "end") == 0) {
 608                 if (__find_event_info
 609                     (&(request->head), req_id, &event_type,
 610                      &event_state) == 0) {
 611                         if (event_state != PACKAGE_MANAGER_EVENT_STATE_FAILED) {
 612                                 if (request->event_cb)
 613                                         request->event_cb(req_id, pkg_type,
 614                                                           pkg_name, event_type,
 615                                                           PACKAGE_MANAGER_EVENT_STATE_COMPLETED,
 616                                                           100,
 617                                                           PACKAGE_MANAGER_ERROR_NONE,
 618                                                           request->user_data);
 619                         }
 620                 } else {
 621                         if (strcasecmp(key, "ok") != 0)
 622                                 if (request->event_cb)
 623                                         request->event_cb(req_id, pkg_type,
 624                                                           pkg_name, event_type,
 625                                                           PACKAGE_MANAGER_EVENT_STATE_FAILED,
 626                                                           0,
 627                                                           PACKAGE_MANAGER_ERROR_SYSTEM_ERROR,
 628                                                           request->user_data);
 629                 }
 630         }
 631
 632         return PACKAGE_MANAGER_ERROR_NONE;
 633 }
 634
 635 static int internal_request_callback(uid_t target_uid, int req_id, const char *pkg_type,
 636                                 const char *pkg_name, const char *key,
 637                                 const char *val, const void *pmsg, void *data)
 638 {
 639         int ret;
 640         package_manager_event_type_e event_type = -1;
 641         package_manager_event_state_e event_state = -1;
 642         struct package_manager_request_cb_info *cb_info;
 643         package_manager_request_event_cb event_cb;
 644         void *user_data = NULL;
 645
 646         _LOGD("request callback called, req_id[%d]", req_id);
 647
 648         package_manager_request_h request = data;
 649
 650         if (request->request_cb_table)
 651                 cb_info = g_hash_table_lookup(request->request_cb_table,
 652                                 GINT_TO_POINTER(req_id));
 653         else
 654                 cb_info = NULL;
 655
 656         if (!cb_info || (cb_info && !cb_info->callback)) {
 657                 _LOGE("no callback info");
 658                 return 0;
 659         }
 660
 661         if (cb_info->req_id != req_id) {
 662                 _LOGE("not matched request id");
 663                 return 0;
 664         }
 665
 666         event_cb = cb_info->callback;
 667         user_data = cb_info->user_data;
 668
 669         if (strcasecmp(key, "start") == 0) {
 670                 ret = package_manager_get_event_type(val, &event_type);
 671                 if (ret != PACKAGE_MANAGER_ERROR_NONE)
 672                         return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
 673
 674                 __add_event_info(&request->head, req_id, event_type,
 675                                  PACKAGE_MANAGER_EVENT_STATE_STARTED);
 676
 677                 event_cb(req_id, pkg_type, pkg_name,
 678                         event_type,
 679                         PACKAGE_MANAGER_EVENT_STATE_STARTED,
 680                         0, PACKAGE_MANAGER_ERROR_NONE, user_data);
 681         } else if (strcasecmp(key, "install_percent") == 0) {
 682                 if (__find_event_info(&request->head, req_id, &event_type,
 683                                 &event_state) == 0) {
 684                         __update_event_info(&request->head, req_id,
 685                                         event_type,
 686                                         PACKAGE_MANAGER_EVENT_STATE_PROCESSING);
 687                         event_cb(req_id, pkg_type, pkg_name,
 688                                 event_type,
 689                                 PACKAGE_MANAGER_EVENT_STATE_PROCESSING,
 690                                 atoi(val),
 691                                 PACKAGE_MANAGER_ERROR_NONE,
 692                                 user_data);
 693                 }
 694         } else if (strcasecmp(key, "error") == 0) {
 695                 if (__find_event_info(&request->head, req_id, &event_type,
 696                                 &event_state) == 0) {
 697                         __update_event_info(&request->head, req_id,
 698                                         event_type,
 699                                         PACKAGE_MANAGER_EVENT_STATE_FAILED);
 700                         event_cb(req_id, pkg_type,
 701                                 pkg_name, event_type,
 702                                 PACKAGE_MANAGER_EVENT_STATE_FAILED,
 703                                 0,
 704                                 __convert_str_to_error(val),
 705                                 user_data);
 706                 }
 707         } else if (strcasecmp(key, "end") == 0) {
 708                 if (__find_event_info(&request->head, req_id, &event_type,
 709                                 &event_state) == 0) {
 710                         if (request->request_cb_table) {
 711                                 request->n_paths--;
 712                                 if (request->n_paths < 1) {
 713                                         _LOGD("remove item, req_id(%d)", req_id);
 714                                         g_hash_table_remove(
 715                                                 request->request_cb_table,
 716                                                 GINT_TO_POINTER(req_id));
 717                                 }
 718                         }
 719                         if (event_state != PACKAGE_MANAGER_EVENT_STATE_FAILED) {
 720                                 if (strcasecmp(val, "ok") == 0) {
 721                                         event_cb(req_id, pkg_type,
 722                                                 pkg_name, event_type,
 723                                                 PACKAGE_MANAGER_EVENT_STATE_COMPLETED,
 724                                                 100,
 725                                                 PACKAGE_MANAGER_ERROR_NONE,
 726                                                 user_data);
 727                                 } else {
 728                                         event_cb(req_id, pkg_type,
 729                                                 pkg_name, event_type,
 730                                                 PACKAGE_MANAGER_EVENT_STATE_FAILED,
 731                                                 0,
 732                                                 PACKAGE_MANAGER_ERROR_SYSTEM_ERROR,
 733                                                 user_data);
 734                                 }
 735                         }
 736                 } else {
 737                         _LOGE("unexpected end event");
 738                 }
 739         }
 740
 741         return 0;
 742 }
 743
 744 static void internal_res_request_callback(uid_t target_uid, int req_id,
 745                 const char *pkgid, const char *request_type, const char *status,
 746                 pkgmgr_res_event_info *handle, void *data)
 747 {
 748         int ret;
 749         package_manager_event_type_e event_type = -1;
 750         package_manager_event_state_e event_state = -1;
 751         struct package_manager_request_cb_info *cb_info;
 752         package_manager_request_res_event_cb event_cb;
 753         struct package_manager_res_event_info_s event_info;
 754         void *user_data = NULL;
 755
 756         _LOGD("request callback called, req_id[%d]", req_id);
 757
 758         package_manager_request_h request = data;
 759         event_info.res_event_info_handle = handle;
 760
 761         if (request->request_cb_table)
 762                 cb_info = g_hash_table_lookup(request->request_cb_table,
 763                                 GINT_TO_POINTER(req_id));
 764         else
 765                 cb_info = NULL;
 766
 767         if (!cb_info || (cb_info && !cb_info->res_callback)) {
 768                 _LOGE("no callback info");
 769                 return;
 770         }
 771
 772         if (cb_info->req_id != req_id) {
 773                 _LOGE("not matched request id");
 774                 return;
 775         }
 776
 777         event_cb = cb_info->res_callback;
 778         user_data = cb_info->user_data;
 779
 780         ret = package_manager_get_event_type(request_type, &event_type);
 781         if (ret != PACKAGE_MANAGER_ERROR_NONE)
 782                 return;
 783         if (strcasecmp(status, "start") == 0) {
 784                 event_state = PACKAGE_MANAGER_EVENT_STATE_STARTED;
 785         } else if (strcasecmp(status, "fail") == 0) {
 786                 event_state = PACKAGE_MANAGER_EVENT_STATE_FAILED;
 787                 _LOGD("remove item, req_id(%d)", req_id);
 788                 g_hash_table_remove(request->request_cb_table,
 789                                 GINT_TO_POINTER(req_id));
 790         } else if (strcasecmp(status, "ok") == 0) {
 791                 event_state = PACKAGE_MANAGER_EVENT_STATE_COMPLETED;
 792                 _LOGD("remove item, req_id(%d)", req_id);
 793                 g_hash_table_remove(request->request_cb_table,
 794                                 GINT_TO_POINTER(req_id));
 795         } else {
 796                 _LOGE("unexpected event");
 797                 return;
 798         }
 799
 800         event_cb(req_id, pkgid, event_type, event_state,
 801                         &event_info, user_data);
 802
 803         return;
 804 }
 805
 806 static int __request_install(package_manager_request_h request,
 807                 const char *path, pkgmgr_handler event_cb, int *id)
 808 {
 809         int retval;
 810         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_ADMIN);
 811         if (retval != PACKAGE_MANAGER_ERROR_NONE)
 812                 return retval;
 813
 814         if (package_manager_client_validate_handle(request))
 815                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 816
 817         if (path == NULL)
 818                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 819
 820         int request_id = 0;
 821         request_id = pkgmgr_client_install(request->pc, request->pkg_type, NULL,
 822                         path, NULL, request->mode, event_cb ? event_cb : request_event_handler, request);
 823
 824         if (request_id == PKGMGR_R_EINVAL)
 825                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 826         else if (request_id == PKGMGR_R_ENOPKG)
 827                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
 828         else if (request_id == PKGMGR_R_ENOMEM)
 829                 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
 830         else if (request_id == PKGMGR_R_EIO)
 831                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
 832         else if (request_id == PKGMGR_R_EPRIV)
 833                 return package_manager_error(PACKAGE_MANAGER_ERROR_PERMISSION_DENIED, __FUNCTION__, NULL);
 834         else if (request_id == PKGMGR_R_ESYSTEM || request_id == PKGMGR_R_ECOMM || request_id == PKGMGR_R_ERROR)
 835                 return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
 836
 837         if (id)
 838                 *id = request_id;
 839
 840         return PACKAGE_MANAGER_ERROR_NONE;
 841 }
 842
 843 static int __request_install_packages(package_manager_request_h request,
 844                 const char **paths, int n_paths, pkgmgr_handler event_cb,
 845                 int *id)
 846 {
 847         int retval;
 848         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_ADMIN);
 849         if (retval != PACKAGE_MANAGER_ERROR_NONE)
 850                 return retval;
 851
 852         if (package_manager_client_validate_handle(request))
 853                 return package_manager_error(
 854                                 PACKAGE_MANAGER_ERROR_INVALID_PARAMETER,
 855                                 __FUNCTION__, NULL);
 856
 857         if (paths == NULL || n_paths < 1)
 858                 return package_manager_error(
 859                                 PACKAGE_MANAGER_ERROR_INVALID_PARAMETER,
 860                                 __FUNCTION__, NULL);
 861         request->n_paths = n_paths;
 862         int request_id = 0;
 863         request_id = pkgmgr_client_install_packages(request->pc, paths,
 864                         n_paths, event_cb ? event_cb : request_event_handler,
 865                         request);
 866
 867         if (request_id == PKGMGR_R_EINVAL)
 868                 return package_manager_error(
 869                                 PACKAGE_MANAGER_ERROR_INVALID_PARAMETER,
 870                                 __FUNCTION__, NULL);
 871         else if (request_id == PKGMGR_R_ENOPKG)
 872                 return package_manager_error(
 873                                 PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE,
 874                                 __FUNCTION__, NULL);
 875         else if (request_id == PKGMGR_R_ENOMEM)
 876                 return package_manager_error(
 877                                 PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY,
 878                                 __FUNCTION__, NULL);
 879         else if (request_id == PKGMGR_R_EIO)
 880                 return package_manager_error(
 881                                 PACKAGE_MANAGER_ERROR_IO_ERROR,
 882                                 __FUNCTION__, NULL);
 883         else if (request_id == PKGMGR_R_EPRIV)
 884                 return package_manager_error(
 885                                 PACKAGE_MANAGER_ERROR_PERMISSION_DENIED,
 886                                 __FUNCTION__, NULL);
 887         else if (request_id == PKGMGR_R_ESYSTEM ||
 888                         request_id == PKGMGR_R_ECOMM ||
 889                         request_id == PKGMGR_R_ERROR)
 890                 return package_manager_error(
 891                                 PACKAGE_MANAGER_ERROR_SYSTEM_ERROR,
 892                                 __FUNCTION__, NULL);
 893
 894         if (id)
 895                 *id = request_id;
 896
 897         return PACKAGE_MANAGER_ERROR_NONE;
 898 }
 899
 900 static int __request_uninstall(package_manager_request_h request,
 901                 const char *name, pkgmgr_handler event_cb, int *id)
 902 {
 903         int retval;
 904         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_ADMIN);
 905         if (retval != PACKAGE_MANAGER_ERROR_NONE)
 906                 return retval;
 907
 908         if (package_manager_client_validate_handle(request))
 909                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 910
 911         if (name == NULL)
 912                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 913
 914         int request_id = 0;
 915         request_id = pkgmgr_client_uninstall(request->pc, request->pkg_type,
 916                         name, request->mode, event_cb ? event_cb : request_event_handler, request);
 917
 918         if (request_id == PKGMGR_R_EINVAL)
 919                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 920         else if (request_id == PKGMGR_R_ENOPKG)
 921                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
 922         else if (request_id == PKGMGR_R_ENOMEM)
 923                 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
 924         else if (request_id == PKGMGR_R_EIO)
 925                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
 926         else if (request_id == PKGMGR_R_EPRIV)
 927                 return package_manager_error(PACKAGE_MANAGER_ERROR_PERMISSION_DENIED, __FUNCTION__, NULL);
 928         else if (request_id == PKGMGR_R_ESYSTEM || request_id == PKGMGR_R_ECOMM || request_id == PKGMGR_R_ERROR)
 929                 return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
 930
 931         if (id)
 932                 *id = request_id;
 933
 934         return PACKAGE_MANAGER_ERROR_NONE;
 935 }
 936
 937 static int __request_move(package_manager_request_h request,
 938                 const char *name, package_manager_move_type_e move_type,
 939                 pkgmgr_handler event_cb, int *id)
 940 {
 941         int retval;
 942         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_ADMIN);
 943         if (retval != PACKAGE_MANAGER_ERROR_NONE)
 944                 return retval;
 945
 946         if (package_manager_client_validate_handle(request))
 947                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 948
 949         if (name == NULL)
 950                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 951
 952         int request_id = 0;
 953         request_id = pkgmgr_client_request_service(PM_REQUEST_MOVE, move_type,
 954                         request->pc, request->pkg_type, name,
 955                         NULL, event_cb ? event_cb : request_event_handler, request);
 956
 957         if (request_id == PKGMGR_R_EINVAL)
 958                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 959         else if (request_id == PKGMGR_R_ENOPKG)
 960                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
 961         else if (request_id == PKGMGR_R_ENOMEM)
 962                 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
 963         else if (request_id == PKGMGR_R_EIO)
 964                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
 965         else if (request_id == PKGMGR_R_EPRIV)
 966                 return package_manager_error(PACKAGE_MANAGER_ERROR_PERMISSION_DENIED, __FUNCTION__, NULL);
 967         else if (request_id == PKGMGR_R_ESYSTEM || request_id == PKGMGR_R_ECOMM || request_id == PKGMGR_R_ERROR)
 968                 return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
 969
 970         if (id)
 971                 *id = request_id;
 972
 973         return PACKAGE_MANAGER_ERROR_NONE;
 974 }
 975
 976 static int __request_mount_install(package_manager_request_h request,
 977                 const char *path, pkgmgr_handler event_cb, int *id)
 978 {
 979         int retval;
 980         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_ADMIN);
 981         if (retval != PACKAGE_MANAGER_ERROR_NONE)
 982                 return retval;
 983
 984         if (package_manager_client_validate_handle(request))
 985                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 986
 987         if (path == NULL)
 988                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 989
 990         int request_id = 0;
 991         request_id = pkgmgr_client_mount_install(request->pc, request->pkg_type, NULL,
 992                         path, NULL, request->mode, event_cb ? event_cb : request_event_handler, request);
 993
 994         if (request_id == PKGMGR_R_EINVAL)
 995                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 996         else if (request_id == PKGMGR_R_ENOPKG)
 997                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
 998         else if (request_id == PKGMGR_R_ENOMEM)
 999                 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
1000         else if (request_id == PKGMGR_R_EIO)
1001                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
1002         else if (request_id == PKGMGR_R_EPRIV)
1003                 return package_manager_error(PACKAGE_MANAGER_ERROR_PERMISSION_DENIED, __FUNCTION__, NULL);
1004         else if (request_id == PKGMGR_R_ESYSTEM || request_id == PKGMGR_R_ECOMM || request_id == PKGMGR_R_ERROR)
1005                 return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
1006
1007         if (id)
1008                 *id = request_id;
1009
1010         return PACKAGE_MANAGER_ERROR_NONE;
1011 }
1012
1013 static int __request_mount_install_packages(package_manager_request_h request,
1014                 const char **paths, int n_paths, pkgmgr_handler event_cb,
1015                 int *id)
1016 {
1017         int retval;
1018         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_ADMIN);
1019         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1020                 return retval;
1021
1022         if (package_manager_client_validate_handle(request))
1023                 return package_manager_error(
1024                                 PACKAGE_MANAGER_ERROR_INVALID_PARAMETER,
1025                                 __FUNCTION__, NULL);
1026
1027         if (paths == NULL || n_paths < 1)
1028                 return package_manager_error(
1029                                 PACKAGE_MANAGER_ERROR_INVALID_PARAMETER,
1030                                 __FUNCTION__, NULL);
1031         request->n_paths = n_paths;
1032         int request_id = 0;
1033         request_id = pkgmgr_client_mount_install_packages(request->pc, paths,
1034                         n_paths, event_cb ? event_cb : request_event_handler,
1035                         request);
1036
1037         if (request_id == PKGMGR_R_EINVAL)
1038                 return package_manager_error(
1039                                 PACKAGE_MANAGER_ERROR_INVALID_PARAMETER,
1040                                 __FUNCTION__, NULL);
1041         else if (request_id == PKGMGR_R_ENOPKG)
1042                 return package_manager_error(
1043                                 PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE,
1044                                 __FUNCTION__, NULL);
1045         else if (request_id == PKGMGR_R_ENOMEM)
1046                 return package_manager_error(
1047                                 PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY,
1048                                 __FUNCTION__, NULL);
1049         else if (request_id == PKGMGR_R_EIO)
1050                 return package_manager_error(
1051                                 PACKAGE_MANAGER_ERROR_IO_ERROR,
1052                                 __FUNCTION__, NULL);
1053         else if (request_id == PKGMGR_R_EPRIV)
1054                 return package_manager_error(
1055                                 PACKAGE_MANAGER_ERROR_PERMISSION_DENIED,
1056                                 __FUNCTION__, NULL);
1057         else if (request_id == PKGMGR_R_ESYSTEM ||
1058                         request_id == PKGMGR_R_ECOMM ||
1059                         request_id == PKGMGR_R_ERROR)
1060                 return package_manager_error(
1061                                 PACKAGE_MANAGER_ERROR_SYSTEM_ERROR,
1062                                 __FUNCTION__, NULL);
1063
1064         if (id)
1065                 *id = request_id;
1066
1067         return PACKAGE_MANAGER_ERROR_NONE;
1068 }
1069
1070 static int __request_res_copy(package_manager_request_h request,
1071                 pkgmgr_res_handler event_cb, int *id)
1072 {
1073         int retval;
1074         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_ADMIN);
1075         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1076                 return retval;
1077
1078         if (package_manager_client_validate_handle(request))
1079                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1080
1081         int request_id = 0;
1082         request_id = pkgmgr_client_res_copy(request->pc, event_cb, request);
1083
1084         if (request_id == PKGMGR_R_EINVAL)
1085                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1086         else if (request_id == PKGMGR_R_ENOMEM)
1087                 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
1088         else if (request_id == PKGMGR_R_EIO)
1089                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
1090         else if (request_id == PKGMGR_R_EPRIV)
1091                 return package_manager_error(PACKAGE_MANAGER_ERROR_PERMISSION_DENIED, __FUNCTION__, NULL);
1092         else if (request_id == PKGMGR_R_ESYSTEM || request_id == PKGMGR_R_ECOMM || request_id == PKGMGR_R_ERROR)
1093                 return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
1094
1095         if (id)
1096                 *id = request_id;
1097
1098         return PACKAGE_MANAGER_ERROR_NONE;
1099 }
1100
1101 static int __request_res_create_dir(package_manager_request_h request,
1102                 pkgmgr_res_handler event_cb, int *id)
1103 {
1104         int retval;
1105         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_ADMIN);
1106         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1107                 return retval;
1108
1109         if (package_manager_client_validate_handle(request))
1110                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1111
1112         int request_id = 0;
1113         request_id = pkgmgr_client_res_create_dir(request->pc, event_cb, request);
1114
1115         if (request_id == PKGMGR_R_EINVAL)
1116                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1117         else if (request_id == PKGMGR_R_ENOMEM)
1118                 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
1119         else if (request_id == PKGMGR_R_EIO)
1120                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
1121         else if (request_id == PKGMGR_R_EPRIV)
1122                 return package_manager_error(PACKAGE_MANAGER_ERROR_PERMISSION_DENIED, __FUNCTION__, NULL);
1123         else if (request_id == PKGMGR_R_ESYSTEM || request_id == PKGMGR_R_ECOMM || request_id == PKGMGR_R_ERROR)
1124                 return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
1125
1126         if (id)
1127                 *id = request_id;
1128
1129         return PACKAGE_MANAGER_ERROR_NONE;
1130 }
1131
1132 static int __request_res_remove(package_manager_request_h request,
1133                 pkgmgr_res_handler event_cb, int *id)
1134 {
1135         int retval;
1136         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_ADMIN);
1137         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1138                 return retval;
1139
1140         if (package_manager_client_validate_handle(request))
1141                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1142
1143         int request_id = 0;
1144         request_id = pkgmgr_client_res_remove(request->pc, event_cb, request);
1145
1146         if (request_id == PKGMGR_R_EINVAL)
1147                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1148         else if (request_id == PKGMGR_R_ENOMEM)
1149                 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
1150         else if (request_id == PKGMGR_R_EIO)
1151                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
1152         else if (request_id == PKGMGR_R_EPRIV)
1153                 return package_manager_error(PACKAGE_MANAGER_ERROR_PERMISSION_DENIED, __FUNCTION__, NULL);
1154         else if (request_id == PKGMGR_R_ESYSTEM || request_id == PKGMGR_R_ECOMM || request_id == PKGMGR_R_ERROR)
1155                 return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
1156
1157         if (id)
1158                 *id = request_id;
1159
1160         return PACKAGE_MANAGER_ERROR_NONE;
1161 }
1162
1163 API int package_manager_request_install(package_manager_request_h request,
1164                                 const char *path, int *id)
1165 {
1166         return __request_install(request, path, NULL, id);
1167 }
1168
1169 API int package_manager_request_install_with_cb(package_manager_request_h request,
1170                         const char *path, package_manager_request_event_cb callback,
1171                         void *user_data, int *id)
1172 {
1173         int ret;
1174         int req_id = 0;
1175
1176         if (request->request_cb_table == NULL)
1177                 __initialize_request_cb_table(request);
1178
1179         ret = __request_install(request, path, internal_request_callback, &req_id);
1180
1181         if (req_id > 0) {
1182                 ret = __insert_request_cb_info(request, req_id, callback, user_data);
1183                 if (ret < 0)
1184                         return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY,
1185                                         __FUNCTION__, "failed to create request cb info");
1186                 if (id)
1187                         *id = req_id;
1188         }
1189
1190         return ret;
1191 }
1192
1193 API int package_manager_request_install_packages(
1194                 package_manager_request_h request, const char **paths,
1195                 int paths_count, int *id)
1196 {
1197         return __request_install_packages(request, paths, paths_count, NULL, id);
1198 }
1199
1200 API int package_manager_request_install_packages_with_cb(
1201                 package_manager_request_h request, const char **paths,
1202                 int paths_count, package_manager_request_event_cb callback,
1203                 void *user_data, int *id)
1204 {
1205         int ret;
1206         int req_id = 0;
1207
1208         if (request->request_cb_table == NULL)
1209                 __initialize_request_cb_table(request);
1210
1211         ret = __request_install_packages(request, paths, paths_count,
1212                         internal_request_callback, &req_id);
1213
1214         if (req_id > 0) {
1215                 ret = __insert_request_cb_info(request, req_id, callback,
1216                                 user_data);
1217                 if (ret < 0)
1218                         return package_manager_error(
1219                                         PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY,
1220                                         __FUNCTION__,
1221                                         "failed to create request cb info");
1222                 if (id)
1223                         *id = req_id;
1224         }
1225
1226         return ret;
1227 }
1228
1229 API int package_manager_request_uninstall(package_manager_request_h request,
1230                 const char *name, int *id)
1231 {
1232         return __request_uninstall(request, name, NULL, id);
1233 }
1234
1235 API int package_manager_request_uninstall_with_cb(package_manager_request_h request,
1236                         const char *name, package_manager_request_event_cb callback,
1237                         void *user_data, int *id)
1238 {
1239         int ret;
1240         int req_id = 0;
1241
1242         if (request->request_cb_table == NULL)
1243                 __initialize_request_cb_table(request);
1244
1245         ret = __request_uninstall(request, name, internal_request_callback, &req_id);
1246
1247         if (req_id > 0) {
1248                 ret = __insert_request_cb_info(request, req_id, callback, user_data);
1249                 if (ret < 0)
1250                         return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY,
1251                                         __FUNCTION__, "failed to create request cb info");
1252                 if (id)
1253                         *id = req_id;
1254         }
1255
1256         return ret;
1257 }
1258
1259 API int package_manager_request_move(package_manager_request_h request,
1260                 const char *name, package_manager_move_type_e move_type)
1261 {
1262         return __request_move(request, name, move_type, NULL, NULL);
1263 }
1264
1265 API int package_manager_request_move_with_cb(package_manager_request_h request,
1266                 const char *name, package_manager_move_type_e move_type,
1267                 package_manager_request_event_cb callback, void *user_data, int *id)
1268 {
1269         int ret;
1270         int req_id = 0;
1271
1272         if (request->request_cb_table == NULL)
1273                 __initialize_request_cb_table(request);
1274
1275         ret = __request_move(request, name, move_type, internal_request_callback, &req_id);
1276
1277         if (req_id > 0) {
1278                 ret = __insert_request_cb_info(request, req_id, callback, user_data);
1279                 if (ret < 0)
1280                         return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY,
1281                                         __FUNCTION__, "failed to create request cb info");
1282                 if (id)
1283                         *id = req_id;
1284         }
1285
1286         return ret;
1287 }
1288
1289 API int package_manager_request_mount_install(package_manager_request_h request,
1290                                 const char *path, int *id)
1291 {
1292         return __request_mount_install(request, path, NULL, id);
1293 }
1294
1295 API int package_manager_request_mount_install_with_cb(package_manager_request_h request,
1296                         const char *path, package_manager_request_event_cb callback,
1297                         void *user_data, int *id)
1298 {
1299         int ret;
1300         int req_id = 0;
1301
1302         if (request->request_cb_table == NULL)
1303                 __initialize_request_cb_table(request);
1304
1305         ret = __request_mount_install(request, path, internal_request_callback, &req_id);
1306
1307         if (req_id > 0) {
1308                 ret = __insert_request_cb_info(request, req_id, callback, user_data);
1309                 if (ret < 0)
1310                         return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY,
1311                                         __FUNCTION__, "failed to create request cb info");
1312                 if (id)
1313                         *id = req_id;
1314         }
1315
1316         return ret;
1317 }
1318
1319 API int package_manager_request_mount_install_packages(
1320                 package_manager_request_h request, const char **paths,
1321                 int paths_count, int *id)
1322 {
1323         return __request_mount_install_packages(request, paths, paths_count, NULL,
1324                         id);
1325 }
1326
1327 API int package_manager_request_mount_install_packages_with_cb(
1328                 package_manager_request_h request, const char **paths,
1329                 int paths_count, package_manager_request_event_cb callback,
1330                 void *user_data, int *id)
1331 {
1332         int ret;
1333         int req_id = 0;
1334
1335         if (request->request_cb_table == NULL)
1336                 __initialize_request_cb_table(request);
1337
1338         ret = __request_mount_install_packages(request, paths, paths_count,
1339                         internal_request_callback, &req_id);
1340
1341         if (req_id > 0) {
1342                 ret = __insert_request_cb_info(request, req_id, callback,
1343                                 user_data);
1344                 if (ret < 0)
1345                         return package_manager_error(
1346                                         PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY,
1347                                         __FUNCTION__,
1348                                         "failed to create request cb info");
1349                 if (id)
1350                         *id = req_id;
1351         }
1352
1353         return ret;
1354 }
1355
1356 API int package_manager_create(package_manager_h *manager)
1357 {
1358         int retval;
1359         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
1360         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1361                 return retval;
1362
1363         struct package_manager_s *package_manager = NULL;
1364
1365         if (manager == NULL) {
1366                 return
1367                     package_manager_error
1368                     (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
1369                      NULL);
1370         }
1371
1372         package_manager = calloc(1, sizeof(struct package_manager_s));
1373         if (package_manager == NULL) {
1374                 return
1375                     package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY,
1376                                           __FUNCTION__,
1377                                           "failed to create a package_manager handle");
1378         }
1379
1380         package_manager->ctype = PC_LISTENING;
1381         package_manager->pc = pkgmgr_client_new(PC_LISTENING);
1382         if (package_manager->pc == NULL) {
1383                 free(package_manager);
1384                 return
1385                     package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY,
1386                                           __FUNCTION__,
1387                                           "failed to create a package_manager client");
1388         }
1389
1390         package_manager->handle_id = package_manager_new_id();
1391         g_mutex_init(&package_manager->mutex);
1392
1393         *manager = package_manager;
1394
1395         return PACKAGE_MANAGER_ERROR_NONE;
1396 }
1397
1398 static int package_manager_validate_handle(package_manager_h manager)
1399 {
1400         if (manager == NULL || manager->pc == NULL)
1401                 return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
1402
1403         return PACKAGE_MANAGER_ERROR_NONE;
1404 }
1405
1406 API int package_manager_destroy(package_manager_h manager)
1407 {
1408         if (package_manager_validate_handle(manager)) {
1409                 return
1410                     package_manager_error
1411                     (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
1412                      NULL);
1413         }
1414
1415         g_mutex_clear(&manager->mutex);
1416         pkgmgr_client_free(manager->pc);
1417         g_hash_table_destroy(manager->event_info_table);
1418         free(manager);
1419
1420         return PACKAGE_MANAGER_ERROR_NONE;
1421 }
1422
1423 /* App Event Listening Policy:
1424  * +----------------+------------+---------------+------------------+
1425  * |Listener \ Type |Global Event|My User's Event|Other user's Event|
1426  * +----------------+------------+---------------+------------------+
1427  * |User Process App|   Grant    |     Grant     |      Deny        |
1428  * +----------------+------------+---------------+------------------+
1429  * |Platform module |   Grant    |     Grant     |      Grant       |
1430  * +----------------+------------+---------------+------------------+
1431  * UID assignment policy:
1432  * https://wiki.tizen.org/wiki/Security/User_and_group_ID_assignment_policy
1433  */
1434 #define REGULAR_USER 5000
1435 static int __validate_event_signal(uid_t target_uid)
1436 {
1437         uid_t self = getuid();
1438
1439         if (self == target_uid)
1440                 return 0;
1441
1442         if (self < REGULAR_USER)
1443                 return 0;
1444
1445         return -1;
1446 }
1447
1448 static int internal_callback(uid_t target_uid, int req_id, const char *pkg_type,
1449                                 const char *pkg_name, const char *key,
1450                                 const char *val, const void *pmsg, void *data)
1451 {
1452         struct package_manager_event_info *info = NULL;
1453         int ret = -1;
1454         package_manager_h manager = data;
1455         uid_t uid = target_uid;
1456         bool invoke_callback = false;
1457         package_manager_event_type_e event_type = -1;
1458         package_manager_event_state_e event_state;
1459         int progress = 0;
1460         package_manager_error_e error = PACKAGE_MANAGER_ERROR_NONE;
1461
1462         _LOGD("req_id(%d), pkg_name(%s), type(%s), key(%s), val(%s)",
1463                         req_id, pkg_name, pkg_type, key, val);
1464
1465         if (target_uid == GLOBAL_USER)
1466                 uid = getuid();
1467
1468         if (__validate_event_signal(uid))
1469                 return PACKAGE_MANAGER_ERROR_NONE;
1470
1471         if (manager && manager->event_info_table) {
1472                 g_mutex_lock(&manager->mutex);
1473                 info = g_hash_table_lookup(manager->event_info_table, pkg_name);
1474         } else {
1475                 _LOGE("invalid handle");
1476                 return PACKAGE_MANAGER_ERROR_NONE;
1477         }
1478
1479         if (!info) {
1480                 if (strcasecmp(key, "start") != 0) {
1481                         _LOGD("unexpected signal or no info(removed)");
1482                         g_mutex_unlock(&manager->mutex);
1483                         return PACKAGE_MANAGER_ERROR_NONE;
1484                 }
1485         }
1486
1487         if (strcasecmp(key, "start") == 0) {
1488                 ret = package_manager_get_event_type(val, &event_type);
1489                 if (ret != PACKAGE_MANAGER_ERROR_NONE) {
1490                         g_mutex_unlock(&manager->mutex);
1491                         return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
1492                 }
1493
1494                 if (!info) {
1495                         __insert_event_info(manager, pkg_name, event_type,
1496                                         PACKAGE_MANAGER_EVENT_STATE_STARTED);
1497
1498                         event_state = PACKAGE_MANAGER_EVENT_STATE_STARTED;
1499                         progress = 0;
1500                         error = PACKAGE_MANAGER_ERROR_NONE;
1501                         invoke_callback = true;
1502                 } else {
1503                         _LOGE("unexpected start event");
1504                 }
1505         } else if (strcasecmp(key, "install_percent") == 0
1506                    || strcasecmp(key, "progress_percent") == 0) {
1507                 info->event_state = PACKAGE_MANAGER_EVENT_STATE_PROCESSING;
1508                 event_type = info->event_type;
1509                 event_state = info->event_state;
1510                 progress = atoi(val);
1511                 error = PACKAGE_MANAGER_ERROR_NONE;
1512                 invoke_callback = true;
1513         } else if (strcasecmp(key, "error") == 0) {
1514                 info->event_state = PACKAGE_MANAGER_EVENT_STATE_FAILED;
1515                 event_type = info->event_type;
1516                 event_state = info->event_state;
1517                 progress = 0;
1518                 error = __convert_str_to_error(val);
1519                 invoke_callback = true;
1520         } else if (strcasecmp(key, "end") == 0) {
1521                 if (info->event_state != PACKAGE_MANAGER_EVENT_STATE_FAILED) {
1522                         if (strcasecmp(val, "ok") == 0) {
1523                                 event_type = info->event_type;
1524                                 event_state =
1525                                         PACKAGE_MANAGER_EVENT_STATE_COMPLETED;
1526                                 progress = 100;
1527                                 error = PACKAGE_MANAGER_ERROR_NONE;
1528                                 invoke_callback = true;
1529                         } else {
1530                                 event_type = info->event_type;
1531                                 event_state =
1532                                         PACKAGE_MANAGER_EVENT_STATE_FAILED;
1533                                 progress = 0;
1534                                 error = PACKAGE_MANAGER_ERROR_SYSTEM_ERROR;
1535                                 invoke_callback = true;
1536                         }
1537                 }
1538                 g_hash_table_remove(manager->event_info_table, info->pkg_name);
1539         }
1540         g_mutex_unlock(&manager->mutex);
1541
1542         if (invoke_callback && manager->event_cb && getuid() == uid) {
1543                 manager->event_cb(pkg_type, pkg_name, event_type, event_state,
1544                                 progress, error, manager->user_data);
1545         }
1546
1547         return PACKAGE_MANAGER_ERROR_NONE;
1548 }
1549
1550 static void internal_res_callback(uid_t target_uid, int req_id,
1551                 const char *pkgid, const char *request_type, const char *status,
1552                 pkgmgr_res_event_info *handle, void *data)
1553 {
1554         int ret = -1;
1555         package_manager_h manager = data;
1556         uid_t uid = target_uid;
1557         package_manager_event_type_e event_type = -1;
1558         package_manager_event_state_e event_state;
1559         struct package_manager_res_event_info_s event_info;
1560
1561         event_info.res_event_info_handle = handle;
1562
1563         _LOGD("req_id(%d), pkg_name(%s), request_type(%s), status(%s)",
1564                         req_id, pkgid, request_type, status);
1565
1566         if (target_uid == GLOBAL_USER)
1567                 uid = getuid();
1568
1569         if (__validate_event_signal(uid))
1570                 return;
1571
1572         if (manager) {
1573                 g_mutex_lock(&manager->mutex);
1574         } else {
1575                 _LOGE("invalid handle");
1576                 return;
1577         }
1578         ret = package_manager_get_event_type(request_type, &event_type);
1579         if (ret != PACKAGE_MANAGER_ERROR_NONE) {
1580                 g_mutex_unlock(&manager->mutex);
1581                 return;
1582         }
1583
1584         if (strcasecmp(status, "start") == 0) {
1585                 event_state = PACKAGE_MANAGER_EVENT_STATE_STARTED;
1586         } else if (strcasecmp(status, "fail") == 0) {
1587                 event_state = PACKAGE_MANAGER_EVENT_STATE_FAILED;
1588         } else if (strcasecmp(status, "ok") == 0) {
1589                 event_state = PACKAGE_MANAGER_EVENT_STATE_COMPLETED;
1590         } else {
1591                 _LOGE("unexpected event");
1592                 g_mutex_unlock(&manager->mutex);
1593                 return;
1594         }
1595         g_mutex_unlock(&manager->mutex);
1596
1597         if (manager->res_event_cb && getuid() == uid) {
1598                 _LOGE("call callback");
1599                 manager->res_event_cb(pkgid, event_type, event_state,
1600                                 &event_info, manager->user_data);
1601         } else {
1602                 if (!manager->res_event_cb)
1603                         _LOGE("res_event_cb is null");
1604                 if (getuid() != uid)
1605                         _LOGE("getuid : %d, uid : %d", getuid(), uid);
1606         }
1607
1608         return;
1609 }
1610
1611 static int __convert_status_type(package_manager_status_type_e status_type)
1612 {
1613         int type = 0;
1614
1615         if (status_type == PACKAGE_MANAGER_STATUS_TYPE_ALL)
1616                 return PKGMGR_CLIENT_STATUS_ALL;
1617
1618         if (status_type & PACKAGE_MANAGER_STATUS_TYPE_INSTALL)
1619                 type |= PKGMGR_CLIENT_STATUS_INSTALL;
1620         if (status_type & PACKAGE_MANAGER_STATUS_TYPE_UNINSTALL)
1621                 type |= PKGMGR_CLIENT_STATUS_UNINSTALL;
1622         if (status_type & PACKAGE_MANAGER_STATUS_TYPE_UPGRADE)
1623                 type |= PKGMGR_CLIENT_STATUS_UPGRADE;
1624         if (status_type & PACKAGE_MANAGER_STATUS_TYPE_MOVE)
1625                 type |= PKGMGR_CLIENT_STATUS_MOVE;
1626         if (status_type & PACKAGE_MANAGER_STATUS_TYPE_CLEAR_DATA)
1627                 type |= PKGMGR_CLIENT_STATUS_CLEAR_DATA;
1628         if (status_type & PACKAGE_MANAGER_STATUS_TYPE_INSTALL_PROGRESS)
1629                 type |= PKGMGR_CLIENT_STATUS_INSTALL_PROGRESS;
1630         if (status_type & PACKAGE_MANAGER_STATUS_TYPE_GET_SIZE)
1631                 type |= PKGMGR_CLIENT_STATUS_GET_SIZE;
1632         if (status_type & PACKAGE_MANAGER_STATUS_TYPE_RES_COPY)
1633                 type |= PKGMGR_CLIENT_STATUS_RES_COPY;
1634         if (status_type & PACKAGE_MANAGER_STATUS_TYPE_RES_CREATE_DIR)
1635                 type |= PKGMGR_CLIENT_STATUS_RES_CREATE_DIR;
1636         if (status_type & PACKAGE_MANAGER_STATUS_TYPE_RES_REMOVE)
1637                 type |= PKGMGR_CLIENT_STATUS_RES_REMOVE;
1638         if (status_type & PACKAGE_MANAGER_STATUS_TYPE_RES_UNINSTALL)
1639                 type |= PKGMGR_CLIENT_STATUS_RES_UNINSTALL;
1640
1641         return type;
1642 }
1643
1644 API int package_manager_set_event_status(package_manager_h manager, int status_type)
1645 {
1646         int retval;
1647         int type;
1648         int type_all = PACKAGE_MANAGER_STATUS_TYPE_INSTALL |
1649                 PACKAGE_MANAGER_STATUS_TYPE_UNINSTALL |
1650                 PACKAGE_MANAGER_STATUS_TYPE_UPGRADE |
1651                 PACKAGE_MANAGER_STATUS_TYPE_MOVE |
1652                 PACKAGE_MANAGER_STATUS_TYPE_CLEAR_DATA |
1653                 PACKAGE_MANAGER_STATUS_TYPE_INSTALL_PROGRESS |
1654                 PACKAGE_MANAGER_STATUS_TYPE_GET_SIZE |
1655                 PACKAGE_MANAGER_STATUS_TYPE_RES_COPY |
1656                 PACKAGE_MANAGER_STATUS_TYPE_RES_CREATE_DIR |
1657                 PACKAGE_MANAGER_STATUS_TYPE_RES_REMOVE |
1658                 PACKAGE_MANAGER_STATUS_TYPE_RES_UNINSTALL;
1659
1660         if (manager == NULL)
1661                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1662
1663         if (status_type < 0 || status_type > type_all)
1664                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1665
1666         type = __convert_status_type(status_type);
1667         retval = pkgmgr_client_set_status_type(manager->pc, type);
1668
1669         if (retval < 0)
1670                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
1671
1672         return PACKAGE_MANAGER_ERROR_NONE;
1673 }
1674
1675 API int package_manager_set_event_cb(package_manager_h manager,
1676                                  package_manager_event_cb callback,
1677                                  void *user_data)
1678 {
1679         int retval;
1680         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
1681         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1682                 return retval;
1683
1684         if (package_manager_validate_handle(manager)) {
1685                 return
1686                     package_manager_error
1687                     (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
1688                      NULL);
1689         }
1690
1691         manager->event_cb = callback;
1692         manager->user_data = user_data;
1693
1694         retval = pkgmgr_client_remove_listen_status(manager->pc);
1695         if (retval < 0) {
1696                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR,
1697                         __FUNCTION__, NULL);
1698         }
1699
1700         retval = pkgmgr_client_listen_status(manager->pc,
1701                         internal_callback, manager);
1702         if (retval < 0) {
1703                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR,
1704                         __FUNCTION__, NULL);
1705         }
1706
1707         if (!manager->event_info_table) {
1708                 manager->event_info_table =
1709                         g_hash_table_new_full(g_str_hash, g_str_equal,
1710                                 NULL, __free_event_info);
1711         }
1712
1713         return PACKAGE_MANAGER_ERROR_NONE;
1714 }
1715
1716 API int package_manager_set_res_event_cb(package_manager_h manager,
1717                 package_manager_res_event_cb callback, void *user_data)
1718 {
1719         int retval;
1720         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_ADMIN);
1721         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1722                 return retval;
1723
1724         if (package_manager_validate_handle(manager)) {
1725                 return
1726                     package_manager_error
1727                     (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
1728                      NULL);
1729         }
1730
1731         manager->res_event_cb = callback;
1732         manager->user_data = user_data;
1733
1734         retval = pkgmgr_client_remove_listen_status(manager->pc);
1735         if (retval < 0) {
1736                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR,
1737                         __FUNCTION__, NULL);
1738         }
1739
1740         retval = pkgmgr_client_listen_res_status(manager->pc,
1741                         internal_res_callback, manager);
1742         if (retval < 0) {
1743                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR,
1744                         __FUNCTION__, NULL);
1745         }
1746
1747         return PACKAGE_MANAGER_ERROR_NONE;
1748 }
1749
1750 API int package_manager_unset_event_cb(package_manager_h manager)
1751 {
1752         if (manager == NULL) {
1753                 return
1754                     package_manager_error
1755                     (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
1756                      NULL);
1757         }
1758
1759         int retval;
1760         manager->event_cb = NULL;
1761         manager->res_event_cb = NULL;
1762         manager->user_data = NULL;
1763
1764         g_mutex_lock(&manager->mutex);
1765         g_hash_table_remove_all(manager->event_info_table);
1766         g_mutex_unlock(&manager->mutex);
1767
1768         retval = pkgmgr_client_remove_listen_status(manager->pc);
1769         if (retval == PKGMGR_R_EINVAL)
1770                 return
1771                          package_manager_error
1772                          (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
1773                           NULL);
1774         else if (retval == PKGMGR_R_ERROR)
1775                 return
1776                          package_manager_error
1777                          (PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__,
1778                           NULL);
1779
1780         return PACKAGE_MANAGER_ERROR_NONE;
1781 }
1782
1783 API int package_manager_get_package_id_by_app_id(const char *app_id, char **package_id)
1784 {
1785         pkgmgrinfo_appinfo_h pkgmgrinfo_appinfo;
1786         int retval;
1787         char *pkg_id = NULL;
1788         char *pkg_id_dup = NULL;
1789
1790         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
1791         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1792                 return retval;
1793
1794         if (app_id == NULL || package_id == NULL)
1795                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1796
1797         if (pkgmgrinfo_appinfo_get_appinfo(app_id, &pkgmgrinfo_appinfo) != PMINFO_R_OK)
1798                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1799         retval = pkgmgrinfo_appinfo_get_pkgname(pkgmgrinfo_appinfo, &pkg_id);
1800         if (retval != PMINFO_R_OK) {
1801                 pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
1802                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1803         }
1804
1805         pkg_id_dup = strdup(pkg_id);
1806         if (pkg_id_dup == NULL) {
1807                 pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
1808                 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
1809         }
1810
1811         *package_id = pkg_id_dup;
1812
1813         pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
1814
1815         return PACKAGE_MANAGER_ERROR_NONE;
1816 }
1817
1818 API int package_manager_get_package_info(const char *package_id, package_info_h *package_info)
1819 {
1820         int retval;
1821         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
1822         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1823                 return retval;
1824
1825         retval = package_info_get_package_info(package_id, package_info);
1826
1827         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1828                 return package_manager_error(retval, __FUNCTION__, NULL);
1829         else
1830                 return PACKAGE_MANAGER_ERROR_NONE;
1831 }
1832
1833 API int package_manager_foreach_package_info(package_manager_package_info_cb callback,
1834                                         void *user_data)
1835 {
1836         int retval;
1837         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
1838         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1839                 return retval;
1840
1841         retval = package_info_foreach_package_info(callback, user_data);
1842
1843         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1844                 return package_manager_error(retval, __FUNCTION__, NULL);
1845         else
1846                 return PACKAGE_MANAGER_ERROR_NONE;
1847 }
1848
1849 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)
1850 {
1851         pkgmgrinfo_cert_compare_result_type_e result;
1852
1853         if (lhs_package_id == NULL || rhs_package_id == NULL || compare_result == NULL)
1854                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1855         if (pkgmgrinfo_pkginfo_compare_pkg_cert_info(lhs_package_id, rhs_package_id, &result) != PKGMGR_R_OK)
1856                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
1857         *compare_result = (package_manager_compare_result_type_e)result;
1858
1859         return PACKAGE_MANAGER_ERROR_NONE;
1860 }
1861
1862 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)
1863 {
1864         pkgmgrinfo_cert_compare_result_type_e result;
1865
1866         if (lhs_app_id == NULL || rhs_app_id == NULL || compare_result == NULL)
1867                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1868         if (pkgmgrinfo_pkginfo_compare_app_cert_info(lhs_app_id, rhs_app_id, &result) != PKGMGR_R_OK)
1869                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
1870
1871         *compare_result = (package_manager_compare_result_type_e)result;
1872
1873         return PACKAGE_MANAGER_ERROR_NONE;
1874 }
1875
1876 API int package_manager_is_preload_package_by_app_id(const char *app_id, bool *preload)
1877 {
1878         int retval;
1879         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
1880         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1881                 return retval;
1882
1883         pkgmgrinfo_appinfo_h pkgmgrinfo_appinfo = NULL;
1884         pkgmgrinfo_pkginfo_h pkgmgrinfo_pkginfo = NULL;
1885
1886         char *pkg_id = NULL;
1887         bool is_preload = 0;
1888         if (pkgmgrinfo_appinfo_get_appinfo(app_id, &pkgmgrinfo_appinfo) != PMINFO_R_OK)
1889                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1890
1891         retval = pkgmgrinfo_appinfo_get_pkgname(pkgmgrinfo_appinfo, &pkg_id);
1892         if (retval != PMINFO_R_OK) {
1893                 pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
1894                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1895         }
1896         if (pkgmgrinfo_pkginfo_get_pkginfo(pkg_id, &pkgmgrinfo_pkginfo) != PMINFO_R_OK) {
1897                 pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
1898                 pkgmgrinfo_pkginfo_destroy_pkginfo(pkgmgrinfo_pkginfo);
1899                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1900         }
1901         if (pkgmgrinfo_pkginfo_is_preload(pkgmgrinfo_pkginfo, &is_preload) != PMINFO_R_OK) {
1902                 pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
1903                 pkgmgrinfo_pkginfo_destroy_pkginfo(pkgmgrinfo_pkginfo);
1904                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1905         }
1906
1907         if (is_preload)
1908                 *preload = 1;
1909         else
1910                 *preload = 0;
1911
1912         pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
1913         pkgmgrinfo_pkginfo_destroy_pkginfo(pkgmgrinfo_pkginfo);
1914
1915         return PACKAGE_MANAGER_ERROR_NONE;
1916 }
1917
1918 API int package_manager_get_permission_type(const char *app_id, package_manager_permission_type_e *permission_type)
1919 {
1920         int retval;
1921         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
1922         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1923                 return retval;
1924
1925         pkgmgrinfo_appinfo_h pkgmgrinfo_appinfo = NULL;
1926         pkgmgrinfo_permission_type permission = 0;
1927         if (pkgmgrinfo_appinfo_get_appinfo(app_id, &pkgmgrinfo_appinfo) != PMINFO_R_OK)
1928                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1929         retval = pkgmgrinfo_appinfo_get_permission_type(pkgmgrinfo_appinfo, &permission);
1930         if (retval != PMINFO_R_OK) {
1931                 pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
1932                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1933         }
1934
1935         if (permission == PMINFO_PERMISSION_NORMAL)
1936                 *permission_type = PACKAGE_MANAGER_PERMISSION_NORMAL;
1937         else if (permission == PMINFO_PERMISSION_SIGNATURE)
1938                 *permission_type = PACKAGE_MANAGER_PERMISSION_SIGNATURE;
1939         else if (permission == PMINFO_PERMISSION_PRIVILEGE)
1940                 *permission_type = PACKAGE_MANAGER_PERMISSION_PRIVILEGE;
1941         else
1942                 *permission_type = PACKAGE_MANAGER_PERMISSION_NORMAL;
1943
1944         pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
1945         return PACKAGE_MANAGER_ERROR_NONE;
1946 }
1947
1948 API int package_manager_clear_cache_dir(const char *package_id)
1949 {
1950         int retval;
1951         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_CACHE);
1952         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1953                 return retval;
1954
1955         int res = pkgmgr_client_clear_cache_dir(package_id);
1956         if (res == PKGMGR_R_EINVAL) {
1957                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1958         } else if (res == PKGMGR_R_ENOPKG) {
1959                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1960         } else if (res == PKGMGR_R_ENOMEM) {
1961                 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
1962         } else if (res == PKGMGR_R_EIO) {
1963                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
1964         } else if (res == PKGMGR_R_EPRIV) {
1965                 return package_manager_error(PACKAGE_MANAGER_ERROR_PERMISSION_DENIED, __FUNCTION__, NULL);
1966         } else if (res == PKGMGR_R_ESYSTEM || res == PKGMGR_R_ECOMM || res == PKGMGR_R_ERROR) {
1967                 return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
1968         } else if (res != PKGMGR_R_OK) {
1969                 _LOGE("Unexpected error");
1970                 return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
1971         }
1972
1973         return PACKAGE_MANAGER_ERROR_NONE;
1974 }
1975
1976 API int package_manager_clear_data_dir(const char *package_id)
1977 {
1978         int retval;
1979         pkgmgr_client *pc = NULL;
1980         char *pkg_type = NULL;
1981         pkgmgrinfo_pkginfo_h pkginfo = NULL;
1982
1983         if (package_id == NULL)
1984                 return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
1985
1986         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_ADMIN);
1987         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1988                 return retval;
1989
1990         retval = pkgmgrinfo_pkginfo_get_pkginfo(package_id, &pkginfo);
1991         if (retval == PMINFO_R_ENOENT)
1992                 return PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE;
1993         else if (retval != PMINFO_R_OK || pkginfo == NULL)
1994                 return PACKAGE_MANAGER_ERROR_SYSTEM_ERROR;
1995
1996         retval = pkgmgrinfo_pkginfo_get_type(pkginfo, &pkg_type);
1997         if (retval != PMINFO_R_OK || pkg_type == NULL) {
1998                 pkgmgrinfo_pkginfo_destroy_pkginfo(pkginfo);
1999                 return PACKAGE_MANAGER_ERROR_SYSTEM_ERROR;
2000         }
2001
2002         pc = pkgmgr_client_new(PC_REQUEST);
2003         if (pc == NULL) {
2004                 _LOGE("Out of memory");
2005                 pkgmgrinfo_pkginfo_destroy_pkginfo(pkginfo);
2006                 return PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY;
2007         }
2008
2009         retval = pkgmgr_client_clear_user_data(pc, pkg_type, package_id, PM_QUIET);
2010         pkgmgr_client_free(pc);
2011         pkgmgrinfo_pkginfo_destroy_pkginfo(pkginfo);
2012
2013         if (retval == PKGMGR_R_EINVAL) {
2014                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
2015         } else if (retval == PKGMGR_R_ENOPKG) {
2016                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
2017         } else if (retval == PKGMGR_R_ENOMEM) {
2018                 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
2019         } else if (retval == PKGMGR_R_EIO) {
2020                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
2021         } else if (retval == PKGMGR_R_EPRIV) {
2022                 return package_manager_error(PACKAGE_MANAGER_ERROR_PERMISSION_DENIED, __FUNCTION__, NULL);
2023         } else if (retval == PKGMGR_R_ESYSTEM || retval == PKGMGR_R_ECOMM || retval == PKGMGR_R_ERROR) {
2024                 return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
2025         } else if (retval != PKGMGR_R_OK) {
2026                 _LOGE("Unexpected error");
2027                 return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
2028         }
2029
2030         return PACKAGE_MANAGER_ERROR_NONE;
2031 }
2032
2033 API int package_manager_clear_all_cache_dir(void)
2034 {
2035         int retval;
2036         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_ADMIN);
2037         if (retval != PACKAGE_MANAGER_ERROR_NONE)
2038                 return retval;
2039
2040         return package_manager_clear_cache_dir(PKG_CLEAR_ALL_CACHE);
2041 }
2042
2043 struct getsize_cbdata {
2044         pkgmgr_client *pc;
2045         void *cb;
2046         void *user_data;
2047 };
2048
2049 static void __free_getsize_cbdata(struct getsize_cbdata *cbdata)
2050 {
2051         pkgmgr_client_free(cbdata->pc);
2052         free(cbdata);
2053 }
2054
2055 static void __result_cb(pkgmgr_client *pc, const char *pkgid, const pkg_size_info_t *result, void *user_data)
2056 {
2057         struct getsize_cbdata *cbdata = (struct getsize_cbdata *)user_data;
2058         package_manager_size_info_receive_cb callback = cbdata->cb;
2059         if (callback == NULL) {
2060                 _LOGE("callback is null.");
2061                 __free_getsize_cbdata(cbdata);
2062                 return;
2063         }
2064
2065         package_size_info_t size_info;
2066         size_info.data_size  = result->data_size;
2067         size_info.cache_size = result->cache_size;
2068         size_info.app_size   = result->app_size;
2069         size_info.external_data_size  = result->ext_data_size;
2070         size_info.external_cache_size = result->ext_cache_size;
2071         size_info.external_app_size   = result->ext_app_size;
2072
2073         callback(pkgid, (package_size_info_h)&size_info, cbdata->user_data);
2074
2075         __free_getsize_cbdata(cbdata);
2076 }
2077
2078 static void __total_result_cb(pkgmgr_client *pc, const pkg_size_info_t *result, void *user_data)
2079 {
2080         struct getsize_cbdata *cbdata = (struct getsize_cbdata *)user_data;
2081         package_manager_total_size_info_receive_cb callback = cbdata->cb;
2082         if (callback == NULL) {
2083                 _LOGE("callback is null.");
2084                 __free_getsize_cbdata(cbdata);
2085                 return;
2086         }
2087
2088         package_size_info_t size_info;
2089         size_info.data_size  = result->data_size;
2090         size_info.cache_size = result->cache_size;
2091         size_info.app_size   = result->app_size;
2092         size_info.external_data_size  = result->ext_data_size;
2093         size_info.external_cache_size = result->ext_cache_size;
2094         size_info.external_app_size   = result->ext_app_size;
2095
2096         callback((package_size_info_h)&size_info, cbdata->user_data);
2097
2098         __free_getsize_cbdata(cbdata);
2099 }
2100
2101 static int _get_pkg_size_info(const char *package_id, void *callback, void *user_data)
2102 {
2103         struct getsize_cbdata *cbdata;
2104
2105         if (package_id == NULL || callback == NULL)
2106                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
2107
2108         cbdata = malloc(sizeof(struct getsize_cbdata));
2109         if (cbdata == NULL)
2110                 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
2111
2112         pkgmgr_client *pc = pkgmgr_client_new(PC_REQUEST);
2113         if (pc == NULL) {
2114                 free(cbdata);
2115                 return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
2116         }
2117
2118         cbdata->pc = pc;
2119         cbdata->cb = callback;
2120         cbdata->user_data = user_data;
2121
2122         int res = 0;
2123         if (strcmp(package_id, PKG_SIZE_INFO_TOTAL) != 0)
2124                 res = pkgmgr_client_get_package_size_info(pc, package_id, __result_cb, cbdata);
2125         else
2126                 res = pkgmgr_client_get_total_package_size_info(pc, __total_result_cb, cbdata);
2127
2128         if (res != PKGMGR_R_OK) {
2129                 __free_getsize_cbdata(cbdata);
2130                 if (res == PKGMGR_R_EINVAL) {
2131                         return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
2132                 } else if (res == PKGMGR_R_ENOPKG) {
2133                         return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
2134                 } else if (res == PKGMGR_R_ENOMEM) {
2135                         return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
2136                 } else if (res == PKGMGR_R_EIO) {
2137                         return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
2138                 } else if (res == PKGMGR_R_EPRIV) {
2139                         return package_manager_error(PACKAGE_MANAGER_ERROR_PERMISSION_DENIED, __FUNCTION__, NULL);
2140                 } else if (res == PKGMGR_R_ESYSTEM || res == PKGMGR_R_ECOMM || res == PKGMGR_R_ERROR) {
2141                         return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
2142                 } else {
2143                         _LOGE("Unexpected error");
2144                         return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
2145                 }
2146         }
2147
2148         return PACKAGE_MANAGER_ERROR_NONE;
2149 }
2150
2151 API int package_manager_get_package_size_info(const char *package_id, package_manager_size_info_receive_cb callback, void *user_data)
2152 {
2153         return _get_pkg_size_info(package_id, (void *)callback, user_data);
2154 }
2155
2156 API int package_manager_get_total_package_size_info(package_manager_total_size_info_receive_cb callback, void *user_data)
2157 {
2158         return _get_pkg_size_info(PKG_SIZE_INFO_TOTAL, (void *)callback, user_data);
2159 }
2160
2161 API int package_manager_filter_create(package_manager_filter_h *handle)
2162 {
2163         int retval;
2164         pkgmgrinfo_pkginfo_filter_h pkgmgr_filter = NULL;
2165
2166         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
2167         if (retval != PACKAGE_MANAGER_ERROR_NONE)
2168                 return retval;
2169
2170         if (handle == NULL) {
2171                 return
2172                     package_manager_error
2173                     (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
2174                      NULL);
2175         }
2176
2177         retval = pkgmgrinfo_pkginfo_filter_create(&pkgmgr_filter);
2178         if (retval != PACKAGE_MANAGER_ERROR_NONE)
2179                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
2180
2181         *handle = pkgmgr_filter;
2182
2183         return PACKAGE_MANAGER_ERROR_NONE;
2184 }
2185
2186 API int package_manager_filter_destroy(package_manager_filter_h handle)
2187 {
2188         int retval;
2189
2190         if (handle == NULL) {
2191                 return
2192                     package_manager_error
2193                     (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
2194                      NULL);
2195         }
2196
2197         retval = pkgmgrinfo_pkginfo_filter_destroy(handle);
2198         if (retval != PACKAGE_MANAGER_ERROR_NONE)
2199                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
2200
2201         return PACKAGE_MANAGER_ERROR_NONE;
2202 }
2203
2204 API int package_manager_filter_add_bool(package_manager_filter_h handle,
2205                 const char *property, const bool value)
2206 {
2207         int retval;
2208
2209         if ((handle == NULL) || (property == NULL)) {
2210                 return
2211                     package_manager_error
2212                     (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
2213                      NULL);
2214         }
2215
2216         retval = pkgmgrinfo_pkginfo_filter_add_bool(handle, property, value);
2217         if (retval != PACKAGE_MANAGER_ERROR_NONE)
2218                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
2219
2220         return PACKAGE_MANAGER_ERROR_NONE;
2221 }
2222
2223
2224 API int package_manager_filter_add_string(package_manager_filter_h handle, const char *property, const char *value)
2225 {
2226         int retval;
2227
2228         if ((handle == NULL) || (property == NULL) || (value == NULL)) {
2229                 return
2230                     package_manager_error
2231                     (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
2232                      NULL);
2233         }
2234
2235         retval = pkgmgrinfo_pkginfo_filter_add_string(handle, property, value);
2236         if (retval != PACKAGE_MANAGER_ERROR_NONE)
2237                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
2238
2239         return PACKAGE_MANAGER_ERROR_NONE;
2240 }
2241
2242 API int package_manager_filter_count(package_manager_filter_h handle, int *count)
2243 {
2244         int retval;
2245         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
2246         if (retval != PACKAGE_MANAGER_ERROR_NONE)
2247                 return retval;
2248
2249         if ((handle == NULL) || (count == NULL))
2250                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
2251
2252         retval = pkgmgrinfo_pkginfo_filter_count(handle, count);
2253         if (retval < 0)
2254                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
2255
2256         return PACKAGE_MANAGER_ERROR_NONE;
2257 }
2258
2259 API int package_manager_filter_foreach_package_info(package_manager_filter_h handle,
2260                 package_manager_package_info_cb callback, void *user_data)
2261 {
2262         int retval;
2263         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
2264         if (retval != PACKAGE_MANAGER_ERROR_NONE)
2265                 return retval;
2266
2267         retval = package_info_filter_foreach_package_info(handle, callback, user_data);
2268
2269         if (retval != PACKAGE_MANAGER_ERROR_NONE)
2270                 return package_manager_error(retval, __FUNCTION__, NULL);
2271         else
2272                 return PACKAGE_MANAGER_ERROR_NONE;
2273 }
2274
2275 API int package_size_info_get_data_size(package_size_info_h handle, long long *data_size)
2276 {
2277         if (handle == NULL)
2278                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
2279
2280         package_size_info_t *size_info = (package_size_info_t *)handle;
2281
2282         *data_size = (long long)size_info->data_size;
2283         return PACKAGE_MANAGER_ERROR_NONE;
2284 }
2285
2286 API int package_size_info_get_cache_size(package_size_info_h handle, long long *cache_size)
2287 {
2288         if (handle == NULL)
2289                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
2290
2291         package_size_info_t *size_info = (package_size_info_t *)handle;
2292
2293         *cache_size = size_info->cache_size;
2294         return PACKAGE_MANAGER_ERROR_NONE;
2295 }
2296
2297 API int package_size_info_get_app_size(package_size_info_h handle, long long *app_size)
2298 {
2299         if (handle == NULL)
2300                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
2301
2302         package_size_info_t *size_info = (package_size_info_t *)handle;
2303         *app_size = size_info->app_size;
2304         return PACKAGE_MANAGER_ERROR_NONE;
2305 }
2306
2307 API int package_size_info_get_external_data_size(package_size_info_h handle, long long *ext_data_size)
2308 {
2309         if (handle == NULL)
2310                 return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
2311
2312         package_size_info_t *size_info = (package_size_info_t *)handle;
2313         *ext_data_size = size_info->external_data_size;
2314         return PACKAGE_MANAGER_ERROR_NONE;
2315 }
2316
2317 API int package_size_info_get_external_cache_size(package_size_info_h handle, long long *ext_cache_size)
2318 {
2319         if (handle == NULL)
2320                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
2321
2322         package_size_info_t *size_info = (package_size_info_t *)handle;
2323         *ext_cache_size = size_info->external_cache_size;
2324         return PACKAGE_MANAGER_ERROR_NONE;
2325 }
2326
2327 API int package_size_info_get_external_app_size(package_size_info_h handle, long long *ext_app_size)
2328 {
2329         if (handle == NULL)
2330                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
2331
2332         package_size_info_t *size_info = (package_size_info_t *)handle;
2333         *ext_app_size = size_info->external_app_size;
2334         return PACKAGE_MANAGER_ERROR_NONE;
2335 }
2336
2337 API int package_manager_updateinfo_set_pkgid(package_updateinfo_request_h pkg_updateinfo_req, const char *pkgid)
2338 {
2339         struct package_updateinfo_request_s *request;
2340
2341         if (pkg_updateinfo_req == NULL || pkg_updateinfo_req->updateinfo_handle == NULL || pkgid == NULL)
2342                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
2343
2344         request = (struct package_updateinfo_request_s *)pkg_updateinfo_req;
2345         if (request->updateinfo_handle->pkgid)
2346                 free(request->updateinfo_handle->pkgid);
2347         request->updateinfo_handle->pkgid = strdup(pkgid);
2348         if (request->updateinfo_handle->pkgid == NULL)
2349                 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
2350
2351         return PACKAGE_MANAGER_ERROR_NONE;
2352 }
2353
2354 API int package_manager_updateinfo_set_version(package_updateinfo_request_h pkg_updateinfo_req, const char *version)
2355 {
2356         struct package_updateinfo_request_s *request;
2357
2358         if (pkg_updateinfo_req == NULL || pkg_updateinfo_req->updateinfo_handle == NULL || version == NULL)
2359                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
2360
2361         request = (struct package_updateinfo_request_s *)pkg_updateinfo_req;
2362         if (request->updateinfo_handle->version)
2363                 free(request->updateinfo_handle->version);
2364         request->updateinfo_handle->version = strdup(version);
2365         if (request->updateinfo_handle->version == NULL)
2366                 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
2367
2368         return PACKAGE_MANAGER_ERROR_NONE;
2369 }
2370
2371 static int package_manager_updateinfo_convert_property(package_updateinfo_type_e property, pkgmgr_updateinfo_type *converted_property)
2372 {
2373         if (converted_property == NULL)
2374                 return -1;
2375
2376         if (property == PACKAGE_UPDATEINFO_TYPE_FORCE)
2377                 *converted_property = PM_UPDATEINFO_TYPE_FORCE;
2378         else if (property == PACKAGE_UPDATEINFO_TYPE_OPTIONAL)
2379                 *converted_property = PM_UPDATEINFO_TYPE_OPTIONAL;
2380         else if (property == PACKAGE_UPDATEINFO_TYPE_NONE)
2381                 *converted_property = PM_UPDATEINFO_TYPE_NONE;
2382         else
2383                 return -1;
2384
2385         return 0;
2386 }
2387
2388 API int package_manager_updateinfo_set_type(package_updateinfo_request_h pkg_updateinfo_req, package_updateinfo_type_e type)
2389 {
2390         int retval;
2391         pkgmgr_updateinfo_type converted_type;
2392         struct package_updateinfo_request_s *request;
2393
2394         if (pkg_updateinfo_req == NULL || pkg_updateinfo_req->updateinfo_handle == NULL)
2395                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
2396
2397         request = (struct package_updateinfo_request_s *)pkg_updateinfo_req;
2398         retval = package_manager_updateinfo_convert_property(type, &converted_type);
2399         if (retval != 0)
2400                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
2401
2402         request->updateinfo_handle->type = converted_type;
2403         return PACKAGE_MANAGER_ERROR_NONE;
2404 }
2405
2406 API int package_manager_updateinfo_request_destroy(package_updateinfo_request_h pkg_updateinfo_req)
2407 {
2408         struct package_updateinfo_request_s *request;
2409
2410         if (pkg_updateinfo_req == NULL)
2411                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
2412
2413         request = (struct package_updateinfo_request_s *)pkg_updateinfo_req;
2414         if (request->pc)
2415                 pkgmgr_client_free(request->pc);
2416
2417         if (request->updateinfo_handle) {
2418                 if (request->updateinfo_handle->pkgid)
2419                         free(request->updateinfo_handle->pkgid);
2420                 if (request->updateinfo_handle->version)
2421                         free(request->updateinfo_handle->version);
2422                 free(request->updateinfo_handle);
2423         }
2424         free(request);
2425
2426         return PACKAGE_MANAGER_ERROR_NONE;
2427 }
2428
2429 API  int package_manager_updateinfo_request_create(package_updateinfo_request_h *pkg_updateinfo_req)
2430 {
2431         struct package_updateinfo_request_s *request;
2432         pkg_update_info_t *update_info;
2433
2434         if (pkg_updateinfo_req == NULL)
2435                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
2436
2437         request = calloc(1, sizeof(struct package_updateinfo_request_s));
2438         if (request == NULL)
2439                 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
2440
2441         request->pc = pkgmgr_client_new(PC_REQUEST);
2442         if (request->pc == NULL) {
2443                 free(request);
2444                 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
2445         }
2446
2447         update_info = calloc(1, sizeof(pkg_update_info_t));
2448         if (update_info == NULL) {
2449                 pkgmgr_client_free(request->pc);
2450                 free(request);
2451                 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
2452         }
2453         request->updateinfo_handle = update_info;
2454
2455         *pkg_updateinfo_req = request;
2456         return PACKAGE_MANAGER_ERROR_NONE;
2457 }
2458
2459 API int package_manager_updateinfo_request_register(package_updateinfo_request_h pkg_updateinfo_req)
2460 {
2461         struct package_updateinfo_request_s *update_info;
2462         int retval;
2463
2464         if (pkg_updateinfo_req == NULL)
2465                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
2466         update_info = (struct package_updateinfo_request_s *)pkg_updateinfo_req;
2467
2468         retval = pkgmgr_client_register_pkg_update_info(update_info->pc, update_info->updateinfo_handle);
2469         if (retval == PKGMGR_R_EINVAL)
2470                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
2471
2472         return PACKAGE_MANAGER_ERROR_NONE;
2473 }
2474
2475 API int package_manager_updateinfo_request_unregister(package_updateinfo_request_h pkg_updateinfo_req, const char *pkgid)
2476 {
2477         int retval;
2478         struct package_updateinfo_request_s *update_info;
2479
2480         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_ADMIN);
2481         if (retval != PACKAGE_MANAGER_ERROR_NONE)
2482                 return retval;
2483
2484         if (pkg_updateinfo_req == NULL || pkgid == NULL)
2485                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
2486
2487         update_info = (struct package_updateinfo_request_s *)pkg_updateinfo_req;
2488         retval = pkgmgr_client_unregister_pkg_update_info(update_info->pc, pkgid);
2489         if (retval != PMINFO_R_OK)
2490                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
2491
2492         return PACKAGE_MANAGER_ERROR_NONE;
2493 }
2494
2495 API int package_manager_updateinfo_request_unregister_all(package_updateinfo_request_h pkg_updateinfo_req)
2496 {
2497         int retval;
2498         struct package_updateinfo_request_s *update_info;
2499
2500         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_ADMIN);
2501         if (retval != PACKAGE_MANAGER_ERROR_NONE)
2502                 return retval;
2503
2504         if (pkg_updateinfo_req == NULL)
2505                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
2506
2507         update_info = (struct package_updateinfo_request_s *)pkg_updateinfo_req;
2508         retval = pkgmgr_client_unregister_all_pkg_update_info(update_info->pc);
2509
2510         if (retval != PMINFO_R_OK)
2511                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
2512
2513         return PACKAGE_MANAGER_ERROR_NONE;
2514 }
2515
2516 API int package_manager_request_add_res_copy_path(
2517                 package_manager_request_h request,
2518                 const char *src_path, const char *dest_path)
2519 {
2520         int retval = 0;
2521
2522         if (package_manager_client_validate_handle(request)
2523                         || src_path == NULL || dest_path == NULL) {
2524                 return
2525                         package_manager_error
2526                         (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
2527                          NULL);
2528         }
2529
2530         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_ADMIN);
2531         if (retval != PACKAGE_MANAGER_ERROR_NONE)
2532                 return retval;
2533
2534         if (pkgmgr_client_add_res_copy_path(request->pc, src_path, dest_path))
2535                 return PACKAGE_MANAGER_ERROR_SYSTEM_ERROR;
2536
2537         return PACKAGE_MANAGER_ERROR_NONE;
2538 }
2539
2540 API int package_manager_request_res_copy_with_cb(package_manager_request_h request,
2541                 package_manager_request_res_event_cb callback,
2542                 void *user_data, int *id)
2543 {
2544         int ret;
2545         int req_id = 0;
2546
2547         if (package_manager_client_validate_handle(request)
2548                         || callback == NULL || id == NULL) {
2549                 return package_manager_error(
2550                                 PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
2551         }
2552
2553         ret = check_privilege(PRIVILEGE_PACKAGE_MANAGER_ADMIN);
2554         if (ret != PACKAGE_MANAGER_ERROR_NONE)
2555                 return ret;
2556
2557         if (request->request_cb_table == NULL)
2558                 __initialize_request_cb_table(request);
2559
2560         ret = __request_res_copy(request, internal_res_request_callback, &req_id);
2561
2562         if (req_id > 0) {
2563                 ret = __insert_res_request_cb_info(request, req_id,
2564                                 callback, user_data);
2565                 if (ret < 0)
2566                         return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY,
2567                                         __FUNCTION__, "failed to create request cb info");
2568                 if (id)
2569                         *id = req_id;
2570         }
2571
2572         return ret;
2573 }
2574
2575 API int package_manager_request_add_res_create_dir_path(
2576                 package_manager_request_h request, const char *dir_path)
2577 {
2578         int retval = 0;
2579
2580         if (package_manager_client_validate_handle(request)
2581                         || dir_path == NULL) {
2582                 return
2583                         package_manager_error
2584                         (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
2585                          NULL);
2586         }
2587
2588         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_ADMIN);
2589         if (retval != PACKAGE_MANAGER_ERROR_NONE)
2590                 return retval;
2591
2592         if (pkgmgr_client_add_res_create_dir_path(request->pc, dir_path))
2593                 return PACKAGE_MANAGER_ERROR_SYSTEM_ERROR;
2594
2595         return PACKAGE_MANAGER_ERROR_NONE;
2596 }
2597
2598 API int package_manager_request_res_create_dir_with_cb(
2599                 package_manager_request_h request,
2600                 package_manager_request_res_event_cb callback,
2601                 void *user_data, int *id)
2602 {
2603         int ret;
2604         int req_id = 0;
2605
2606         if (package_manager_client_validate_handle(request)
2607                         || callback == NULL || id == NULL) {
2608                 return package_manager_error(
2609                                 PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
2610         }
2611
2612         if (request->request_cb_table == NULL)
2613                 __initialize_request_cb_table(request);
2614
2615         ret = check_privilege(PRIVILEGE_PACKAGE_MANAGER_ADMIN);
2616         if (ret != PACKAGE_MANAGER_ERROR_NONE)
2617                 return ret;
2618
2619         ret = __request_res_create_dir(request, internal_res_request_callback, &req_id);
2620
2621         if (req_id > 0) {
2622                 ret = __insert_res_request_cb_info(request, req_id,
2623                                 callback, user_data);
2624                 if (ret < 0)
2625                         return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY,
2626                                         __FUNCTION__, "failed to create request cb info");
2627                 if (id)
2628                         *id = req_id;
2629         }
2630
2631         return ret;
2632 }
2633
2634 API int package_manager_request_add_res_remove_path(
2635                 package_manager_request_h request, const char *res_path)
2636 {
2637         int retval = 0;
2638
2639         if (package_manager_client_validate_handle(request)
2640                         || res_path == NULL) {
2641                 return
2642                         package_manager_error
2643                         (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
2644                          NULL);
2645         }
2646
2647         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_ADMIN);
2648         if (retval != PACKAGE_MANAGER_ERROR_NONE)
2649                 return retval;
2650
2651         if (pkgmgr_client_add_res_remove_path(request->pc, res_path))
2652                 return PACKAGE_MANAGER_ERROR_SYSTEM_ERROR;
2653
2654         return PACKAGE_MANAGER_ERROR_NONE;
2655 }
2656
2657 API int package_manager_request_res_remove_with_cb(
2658                 package_manager_request_h request,
2659                 package_manager_request_res_event_cb callback,
2660                 void *user_data, int *id)
2661 {
2662         int ret;
2663         int req_id = 0;
2664
2665         if (package_manager_client_validate_handle(request)
2666                         || callback == NULL || id == NULL) {
2667                 return package_manager_error(
2668                                 PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
2669         }
2670
2671         ret = check_privilege(PRIVILEGE_PACKAGE_MANAGER_ADMIN);
2672         if (ret != PACKAGE_MANAGER_ERROR_NONE)
2673                 return ret;
2674
2675         if (request->request_cb_table == NULL)
2676                 __initialize_request_cb_table(request);
2677
2678         ret = __request_res_remove(request, internal_res_request_callback, &req_id);
2679
2680         if (req_id > 0) {
2681                 ret = __insert_res_request_cb_info(request, req_id,
2682                                 callback, user_data);
2683                 if (ret < 0)
2684                         return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY,
2685                                         __FUNCTION__, "failed to create request cb info");
2686                 if (id)
2687                         *id = req_id;
2688         }
2689
2690         return ret;
2691 }
2692
2693 API int package_manager_res_event_info_get_error_code(
2694                 package_manager_res_event_info_h handle,
2695                 package_manager_error_e *error)
2696 {
2697         int ret;
2698         int error_code = 0;
2699
2700         ret = check_privilege(PRIVILEGE_PACKAGE_MANAGER_ADMIN);
2701         if (ret != PACKAGE_MANAGER_ERROR_NONE)
2702                 return ret;
2703
2704         if (handle == NULL || error == NULL)
2705                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
2706
2707         struct package_manager_res_event_info_s *event_info =
2708                         (struct package_manager_res_event_info_s *)handle;
2709
2710         if (event_info->res_event_info_handle == NULL)
2711                 return package_manager_error(
2712                                 PACKAGE_MANAGER_ERROR_INVALID_PARAMETER,
2713                                 __FUNCTION__, NULL);
2714
2715         if (pkgmgr_res_event_info_get_error_code(
2716                         event_info->res_event_info_handle, &error_code))
2717                         return package_manager_error(
2718                                         PACKAGE_MANAGER_ERROR_INVALID_PARAMETER,
2719                                         __FUNCTION__, NULL);
2720
2721         *error = __convert_to_error(error_code);
2722
2723         return PACKAGE_MANAGER_ERROR_NONE;
2724 }
2725
2726 typedef struct _foreach_res_event_path_context_ {
2727         package_manager_res_event_path_cb callback;
2728         void *user_data;
2729 } foreach_res_event_path_context_s;
2730
2731 static int package_res_event_info_foreach_path_cb(const char *path,
2732                 pkgmgr_res_event_path_state state, void *user_data)
2733 {
2734         foreach_res_event_path_context_s *foreach_context = user_data;
2735         package_manager_res_event_path_state_e path_state =
2736                         PACKAGE_MANAGER_RES_EVENT_PATH_STATE_NONE;
2737         bool r = false;
2738
2739         if (foreach_context == NULL) {
2740                 package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER,
2741                                 __FUNCTION__, NULL);
2742                 return -1;
2743         }
2744
2745         if (state == PM_RES_EVENT_PATH_STATE_NONE) {
2746                 path_state = PACKAGE_MANAGER_RES_EVENT_PATH_STATE_NONE;
2747         } else if (state == PM_RES_EVENT_PATH_STATE_OK) {
2748                 path_state = PACKAGE_MANAGER_RES_EVENT_PATH_STATE_OK;
2749         } else if (state == PM_RES_EVENT_PATH_STATE_FAILED) {
2750                 path_state = PACKAGE_MANAGER_RES_EVENT_PATH_STATE_FAILED;
2751         } else {
2752                 package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER,
2753                                 __FUNCTION__, NULL);
2754                 return -1;
2755         }
2756
2757         r = foreach_context->callback(path, path_state,
2758                         foreach_context->user_data);
2759         if (r == false)
2760                 return -1;
2761
2762         return 0;
2763 }
2764
2765 API int package_manager_res_event_info_foreach_path(
2766                 package_manager_res_event_info_h handle,
2767                 package_manager_res_event_path_cb callback, void *user_data)
2768 {
2769         int ret;
2770         foreach_res_event_path_context_s foreach_res_event_path_context = {
2771                 .callback = callback,
2772                 .user_data = user_data,
2773         };
2774
2775         ret = check_privilege(PRIVILEGE_PACKAGE_MANAGER_ADMIN);
2776         if (ret != PACKAGE_MANAGER_ERROR_NONE)
2777                 return ret;
2778
2779         if (handle == NULL || callback == NULL)
2780                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
2781
2782         struct package_manager_res_event_info_s *event_info =
2783                         (struct package_manager_res_event_info_s *)handle;
2784
2785         if (event_info->res_event_info_handle == NULL)
2786                 return package_manager_error(
2787                                 PACKAGE_MANAGER_ERROR_INVALID_PARAMETER,
2788                                 __FUNCTION__, NULL);
2789
2790         ret = pkgmgr_res_event_info_foreach_path(
2791                         event_info->res_event_info_handle,
2792                         package_res_event_info_foreach_path_cb,
2793                         &foreach_res_event_path_context);
2794         if (ret != PKGMGR_R_OK) {
2795                 return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR,
2796                                 __FUNCTION__, NULL);
2797         }
2798
2799         return PACKAGE_MANAGER_ERROR_NONE;
2800 }