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