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