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