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