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