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