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