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                 pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
1244                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1245         }
1246
1247         pkg_id_dup = strdup(pkg_id);
1248         if (pkg_id_dup == NULL) {
1249                 pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
1250                 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
1251         }
1252
1253         *package_id = pkg_id_dup;
1254
1255         pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
1256
1257         return PACKAGE_MANAGER_ERROR_NONE;
1258 }
1259
1260 API int package_manager_get_package_info(const char *package_id, package_info_h *package_info)
1261 {
1262         int retval;
1263         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
1264         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1265                 return retval;
1266
1267         retval = package_info_get_package_info(package_id, package_info);
1268
1269         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1270                 return package_manager_error(retval, __FUNCTION__, NULL);
1271         else
1272                 return PACKAGE_MANAGER_ERROR_NONE;
1273 }
1274
1275 API int package_manager_foreach_package_info(package_manager_package_info_cb callback,
1276                                         void *user_data)
1277 {
1278
1279         int retval;
1280         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
1281         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1282                 return retval;
1283
1284         retval = package_info_foreach_package_info(callback, user_data);
1285
1286         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1287                 return package_manager_error(retval, __FUNCTION__, NULL);
1288         else
1289                 return PACKAGE_MANAGER_ERROR_NONE;
1290 }
1291
1292 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)
1293 {
1294         pkgmgrinfo_cert_compare_result_type_e result;
1295
1296         if (lhs_package_id == NULL || rhs_package_id == NULL || compare_result == NULL)
1297                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1298         if (pkgmgrinfo_pkginfo_compare_pkg_cert_info(lhs_package_id, rhs_package_id, &result) != PKGMGR_R_OK)
1299                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
1300         *compare_result = (package_manager_compare_result_type_e)result;
1301
1302         return PACKAGE_MANAGER_ERROR_NONE;
1303 }
1304
1305 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)
1306 {
1307         pkgmgrinfo_cert_compare_result_type_e result;
1308
1309         if (lhs_app_id == NULL || rhs_app_id == NULL || compare_result == NULL)
1310                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1311         if (pkgmgrinfo_pkginfo_compare_app_cert_info(lhs_app_id, rhs_app_id, &result) != PKGMGR_R_OK)
1312                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
1313
1314         *compare_result = (package_manager_compare_result_type_e)result;
1315
1316         return PACKAGE_MANAGER_ERROR_NONE;
1317 }
1318
1319 API int package_manager_is_preload_package_by_app_id(const char *app_id, bool *preload)
1320 {
1321
1322         int retval;
1323         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
1324         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1325                 return retval;
1326
1327         pkgmgrinfo_appinfo_h pkgmgrinfo_appinfo = NULL;
1328         pkgmgrinfo_pkginfo_h pkgmgrinfo_pkginfo = NULL;
1329
1330         char *pkg_id = NULL;
1331         bool is_preload = 0;
1332         if (pkgmgrinfo_appinfo_get_appinfo(app_id, &pkgmgrinfo_appinfo) != PMINFO_R_OK)
1333                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1334
1335         retval = pkgmgrinfo_appinfo_get_pkgname(pkgmgrinfo_appinfo, &pkg_id);
1336         if (retval != PMINFO_R_OK) {
1337                 pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
1338                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1339         }
1340         if (pkgmgrinfo_pkginfo_get_pkginfo(pkg_id, &pkgmgrinfo_pkginfo) != PMINFO_R_OK) {
1341                 pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
1342                 pkgmgrinfo_pkginfo_destroy_pkginfo(pkgmgrinfo_pkginfo);
1343                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1344         }
1345         if (pkgmgrinfo_pkginfo_is_preload(pkgmgrinfo_pkginfo, &is_preload) != PMINFO_R_OK) {
1346                 pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
1347                 pkgmgrinfo_pkginfo_destroy_pkginfo(pkgmgrinfo_pkginfo);
1348                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1349         }
1350
1351         if (is_preload)
1352                 *preload = 1;
1353         else
1354                 *preload = 0;
1355
1356         pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
1357         pkgmgrinfo_pkginfo_destroy_pkginfo(pkgmgrinfo_pkginfo);
1358
1359         return PACKAGE_MANAGER_ERROR_NONE;
1360 }
1361
1362 API int package_manager_get_permission_type(const char *app_id, package_manager_permission_type_e *permission_type)
1363 {
1364
1365         int retval;
1366         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
1367         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1368                 return retval;
1369
1370         pkgmgrinfo_appinfo_h pkgmgrinfo_appinfo = NULL;
1371         pkgmgrinfo_permission_type permission = 0;
1372         if (pkgmgrinfo_appinfo_get_appinfo(app_id, &pkgmgrinfo_appinfo) != PMINFO_R_OK)
1373                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1374         retval = pkgmgrinfo_appinfo_get_permission_type(pkgmgrinfo_appinfo, &permission);
1375         if (retval != PMINFO_R_OK) {
1376                 pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
1377                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1378         }
1379
1380         if (permission == PMINFO_PERMISSION_NORMAL)
1381                 *permission_type = PACKAGE_MANAGER_PERMISSION_NORMAL;
1382         else if (permission == PMINFO_PERMISSION_SIGNATURE)
1383                 *permission_type = PACKAGE_MANAGER_PERMISSION_SIGNATURE;
1384         else if (permission == PMINFO_PERMISSION_PRIVILEGE)
1385                 *permission_type = PACKAGE_MANAGER_PERMISSION_PRIVILEGE;
1386         else
1387                 *permission_type = PACKAGE_MANAGER_PERMISSION_NORMAL;
1388
1389         pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
1390         return PACKAGE_MANAGER_ERROR_NONE;
1391 }
1392
1393 API int package_manager_clear_cache_dir(const char *package_id)
1394 {
1395
1396         int retval;
1397         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_CACHE);
1398         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1399                 return retval;
1400
1401         int res = pkgmgr_client_clear_cache_dir(package_id);
1402         if (res == PKGMGR_R_EINVAL) {
1403                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1404         } else if (res == PKGMGR_R_ENOPKG) {
1405                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1406         } else if (res == PKGMGR_R_ENOMEM) {
1407                 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
1408         } else if (res == PKGMGR_R_EIO) {
1409                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
1410         } else if (res == PKGMGR_R_EPRIV) {
1411                 return package_manager_error(PACKAGE_MANAGER_ERROR_PERMISSION_DENIED, __FUNCTION__, NULL);
1412         } else if (res == PKGMGR_R_ESYSTEM || res == PKGMGR_R_ECOMM || res == PKGMGR_R_ERROR) {
1413                 return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
1414         } else if (res != PKGMGR_R_OK) {
1415                 _LOGE("Unexpected error");
1416                 return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
1417         }
1418
1419         return PACKAGE_MANAGER_ERROR_NONE;
1420 }
1421
1422 API int package_manager_clear_data_dir(const char *package_id)
1423 {
1424         int retval;
1425         pkgmgr_client *pc = NULL;
1426         char *pkg_type = NULL;
1427         pkgmgrinfo_pkginfo_h pkginfo = NULL;
1428
1429         if (package_id == NULL)
1430                 return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
1431
1432         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_ADMIN);
1433         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1434                 return retval;
1435
1436         retval = pkgmgrinfo_pkginfo_get_pkginfo(package_id, &pkginfo);
1437         if (retval == PMINFO_R_ENOENT)
1438                 return PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE;
1439         else if (retval != PMINFO_R_OK || pkginfo == NULL)
1440                 return PACKAGE_MANAGER_ERROR_SYSTEM_ERROR;
1441
1442         retval = pkgmgrinfo_pkginfo_get_type(pkginfo, &pkg_type);
1443         if (retval != PMINFO_R_OK || pkg_type == NULL) {
1444                 pkgmgrinfo_pkginfo_destroy_pkginfo(pkginfo);
1445                 return PACKAGE_MANAGER_ERROR_SYSTEM_ERROR;
1446         }
1447
1448         pc = pkgmgr_client_new(PC_REQUEST);
1449         if (pc == NULL) {
1450                 _LOGE("Out of memory");
1451                 pkgmgrinfo_pkginfo_destroy_pkginfo(pkginfo);
1452                 return PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY;
1453         }
1454
1455         retval = pkgmgr_client_clear_user_data(pc, pkg_type, package_id, PM_QUIET);
1456         pkgmgr_client_free(pc);
1457         pkgmgrinfo_pkginfo_destroy_pkginfo(pkginfo);
1458
1459         if (retval == PKGMGR_R_EINVAL) {
1460                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1461         } else if (retval == PKGMGR_R_ENOPKG) {
1462                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1463         } else if (retval == PKGMGR_R_ENOMEM) {
1464                 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
1465         } else if (retval == PKGMGR_R_EIO) {
1466                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
1467         } else if (retval == PKGMGR_R_EPRIV) {
1468                 return package_manager_error(PACKAGE_MANAGER_ERROR_PERMISSION_DENIED, __FUNCTION__, NULL);
1469         } else if (retval == PKGMGR_R_ESYSTEM || retval == PKGMGR_R_ECOMM || retval == PKGMGR_R_ERROR) {
1470                 return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
1471         } else if (retval != PKGMGR_R_OK) {
1472                 _LOGE("Unexpected error");
1473                 return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
1474         }
1475
1476         return PACKAGE_MANAGER_ERROR_NONE;
1477 }
1478
1479 API int package_manager_clear_all_cache_dir(void)
1480 {
1481
1482         int retval;
1483         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_ADMIN);
1484         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1485                 return retval;
1486
1487         return package_manager_clear_cache_dir(PKG_CLEAR_ALL_CACHE);
1488 }
1489
1490 static void __free_client(gpointer data)
1491 {
1492         pkgmgr_client *pc = (pkgmgr_client *)data;
1493         pkgmgr_client_free(pc);
1494 }
1495
1496 static void __initialize_cb_table(void)
1497 {
1498         __cb_table = g_hash_table_new_full(g_direct_hash, g_direct_equal, __free_client, NULL);
1499 }
1500
1501 static void __result_cb(pkgmgr_client *pc, const char *pkgid, const pkg_size_info_t *result, void *user_data)
1502 {
1503         package_manager_size_info_receive_cb callback = g_hash_table_lookup(__cb_table, pc);
1504         if (callback == NULL) {
1505                 _LOGE("callback is null.");
1506                 g_hash_table_remove(__cb_table, pc);
1507                 return;
1508         }
1509
1510         package_size_info_t size_info;
1511         size_info.data_size  = result->data_size;
1512         size_info.cache_size = result->cache_size;
1513         size_info.app_size   = result->app_size;
1514         size_info.external_data_size  = result->ext_data_size;
1515         size_info.external_cache_size = result->ext_cache_size;
1516         size_info.external_app_size   = result->ext_app_size;
1517
1518         callback(pkgid, (package_size_info_h)&size_info, user_data);
1519
1520         g_hash_table_remove(__cb_table, pc);
1521 }
1522
1523 static void __total_result_cb(pkgmgr_client *pc, const pkg_size_info_t *result, void *user_data)
1524 {
1525         package_manager_total_size_info_receive_cb callback = g_hash_table_lookup(__cb_table, pc);
1526         if (callback == NULL) {
1527                 _LOGE("callback is null.");
1528                 g_hash_table_remove(__cb_table, pc);
1529                 return;
1530         }
1531
1532         package_size_info_t size_info;
1533         size_info.data_size  = result->data_size;
1534         size_info.cache_size = result->cache_size;
1535         size_info.app_size   = result->app_size;
1536         size_info.external_data_size  = result->ext_data_size;
1537         size_info.external_cache_size = result->ext_cache_size;
1538         size_info.external_app_size   = result->ext_app_size;
1539
1540         callback((package_size_info_h)&size_info, user_data);
1541
1542         g_hash_table_remove(__cb_table, pc);
1543 }
1544
1545 static int _get_pkg_size_info(const char *package_id, void *callback, void *user_data)
1546 {
1547         if (package_id == NULL || callback == NULL)
1548                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1549
1550         if (__cb_table == NULL)
1551                 __initialize_cb_table();
1552
1553         pkgmgr_client *pc = pkgmgr_client_new(PC_REQUEST);
1554         if (pc == NULL)
1555                 return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
1556
1557         int res = 0;
1558         if (strcmp(package_id, PKG_SIZE_INFO_TOTAL) != 0)
1559                 res = pkgmgr_client_get_package_size_info(pc, package_id, __result_cb, user_data);
1560         else
1561                 res = pkgmgr_client_get_total_package_size_info(pc, __total_result_cb, user_data);
1562
1563         if (res == PKGMGR_R_EINVAL) {
1564                 pkgmgr_client_free(pc);
1565                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1566         } else if (res == PKGMGR_R_ENOPKG) {
1567                 pkgmgr_client_free(pc);
1568                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1569         } else if (res == PKGMGR_R_ENOMEM) {
1570                 pkgmgr_client_free(pc);
1571                 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
1572         } else if (res == PKGMGR_R_EIO) {
1573                 pkgmgr_client_free(pc);
1574                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
1575         } else if (res == PKGMGR_R_EPRIV) {
1576                 pkgmgr_client_free(pc);
1577                 return package_manager_error(PACKAGE_MANAGER_ERROR_PERMISSION_DENIED, __FUNCTION__, NULL);
1578         } else if (res == PKGMGR_R_ESYSTEM || res == PKGMGR_R_ECOMM || res == PKGMGR_R_ERROR) {
1579                 pkgmgr_client_free(pc);
1580                 return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
1581         } else if (res != PKGMGR_R_OK) {
1582                 _LOGE("Unexpected error");
1583                 pkgmgr_client_free(pc);
1584                 return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
1585         }
1586
1587         g_hash_table_insert(__cb_table, pc, callback);
1588
1589         return PACKAGE_MANAGER_ERROR_NONE;
1590 }
1591
1592 API int package_manager_get_package_size_info(const char *package_id, package_manager_size_info_receive_cb callback, void *user_data)
1593 {
1594         return _get_pkg_size_info(package_id, (void *)callback, user_data);
1595 }
1596
1597 API int package_manager_get_total_package_size_info(package_manager_total_size_info_receive_cb callback, void *user_data)
1598 {
1599         return _get_pkg_size_info(PKG_SIZE_INFO_TOTAL, (void *)callback, user_data);
1600 }
1601
1602 API int package_manager_filter_create(package_manager_filter_h *handle)
1603 {
1604         int retval;
1605         pkgmgrinfo_pkginfo_filter_h pkgmgr_filter = NULL;
1606
1607         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
1608         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1609                 return retval;
1610
1611         if (handle == NULL) {
1612                 return
1613                     package_manager_error
1614                     (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
1615                      NULL);
1616         }
1617
1618         retval = pkgmgrinfo_pkginfo_filter_create(&pkgmgr_filter);
1619         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1620                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
1621
1622         *handle = pkgmgr_filter;
1623
1624         return PACKAGE_MANAGER_ERROR_NONE;
1625 }
1626
1627 API int package_manager_filter_destroy(package_manager_filter_h handle)
1628 {
1629         int retval;
1630
1631         if (handle == NULL) {
1632                 return
1633                     package_manager_error
1634                     (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
1635                      NULL);
1636         }
1637
1638         retval = pkgmgrinfo_pkginfo_filter_destroy(handle);
1639         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1640                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
1641
1642         return PACKAGE_MANAGER_ERROR_NONE;
1643 }
1644
1645 API int package_manager_filter_add_bool(package_manager_filter_h handle,
1646                 const char *property, const bool value)
1647 {
1648         int retval;
1649
1650         if ((handle == NULL) || (property == NULL)) {
1651                 return
1652                     package_manager_error
1653                     (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
1654                      NULL);
1655         }
1656
1657         retval = pkgmgrinfo_pkginfo_filter_add_bool(handle, property, value);
1658         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1659                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
1660
1661         return PACKAGE_MANAGER_ERROR_NONE;
1662 }
1663
1664 API int package_manager_filter_count(package_manager_filter_h handle, int *count)
1665 {
1666
1667         int retval;
1668         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
1669         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1670                 return retval;
1671
1672         if ((handle == NULL) || (count == NULL))
1673                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1674
1675         retval = pkgmgrinfo_pkginfo_filter_count(handle, count);
1676         if (retval < 0)
1677                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
1678
1679         return PACKAGE_MANAGER_ERROR_NONE;
1680 }
1681
1682 API int package_manager_filter_foreach_package_info(package_manager_filter_h handle,
1683                 package_manager_package_info_cb callback, void *user_data)
1684 {
1685
1686         int retval;
1687         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
1688         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1689                 return retval;
1690
1691         retval = package_info_filter_foreach_package_info(handle, callback, user_data);
1692
1693         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1694                 return package_manager_error(retval, __FUNCTION__, NULL);
1695         else
1696                 return PACKAGE_MANAGER_ERROR_NONE;
1697 }
1698
1699 API int package_size_info_get_data_size(package_size_info_h handle, long long *data_size)
1700 {
1701         if (handle == NULL)
1702                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1703
1704         package_size_info_t *size_info = (package_size_info_t *)handle;
1705
1706         *data_size = (long long)size_info->data_size;
1707         return PACKAGE_MANAGER_ERROR_NONE;
1708 }
1709
1710 API int package_size_info_get_cache_size(package_size_info_h handle, long long *cache_size)
1711 {
1712         if (handle == NULL)
1713                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1714
1715         package_size_info_t *size_info = (package_size_info_t *)handle;
1716
1717         *cache_size = size_info->cache_size;
1718         return PACKAGE_MANAGER_ERROR_NONE;
1719 }
1720
1721 API int package_size_info_get_app_size(package_size_info_h handle, long long *app_size)
1722 {
1723         if (handle == NULL)
1724                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1725
1726         package_size_info_t *size_info = (package_size_info_t *)handle;
1727         *app_size = size_info->app_size;
1728         return PACKAGE_MANAGER_ERROR_NONE;
1729 }
1730
1731 API int package_size_info_get_external_data_size(package_size_info_h handle, long long *ext_data_size)
1732 {
1733         if (handle == NULL)
1734                 return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
1735
1736         package_size_info_t *size_info = (package_size_info_t *)handle;
1737         *ext_data_size = size_info->external_data_size;
1738         return PACKAGE_MANAGER_ERROR_NONE;
1739 }
1740
1741 API int package_size_info_get_external_cache_size(package_size_info_h handle, long long *ext_cache_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_cache_size = size_info->external_cache_size;
1748         return PACKAGE_MANAGER_ERROR_NONE;
1749 }
1750
1751 API int package_size_info_get_external_app_size(package_size_info_h handle, long long *ext_app_size)
1752 {
1753         if (handle == NULL)
1754                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1755
1756         package_size_info_t *size_info = (package_size_info_t *)handle;
1757         *ext_app_size = size_info->external_app_size;
1758         return PACKAGE_MANAGER_ERROR_NONE;
1759 }
1760
1761 API int package_manager_updateinfo_set_pkgid(package_updateinfo_request_h pkg_updateinfo_req, const char *pkgid)
1762 {
1763         struct package_updateinfo_request_s *request;
1764
1765         if (pkg_updateinfo_req == NULL || pkg_updateinfo_req->updateinfo_handle == NULL || pkgid == NULL)
1766                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1767
1768         request = (struct package_updateinfo_request_s *)pkg_updateinfo_req;
1769         if (request->updateinfo_handle->pkgid)
1770                 free(request->updateinfo_handle->pkgid);
1771         request->updateinfo_handle->pkgid = strdup(pkgid);
1772         if (request->updateinfo_handle->pkgid == NULL)
1773                 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
1774
1775         return PACKAGE_MANAGER_ERROR_NONE;
1776 }
1777
1778 API int package_manager_updateinfo_set_version(package_updateinfo_request_h pkg_updateinfo_req, const char *version)
1779 {
1780         struct package_updateinfo_request_s *request;
1781
1782         if (pkg_updateinfo_req == NULL || pkg_updateinfo_req->updateinfo_handle == NULL || version == NULL)
1783                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1784
1785         request = (struct package_updateinfo_request_s *)pkg_updateinfo_req;
1786         if (request->updateinfo_handle->version)
1787                 free(request->updateinfo_handle->version);
1788         request->updateinfo_handle->version = strdup(version);
1789         if (request->updateinfo_handle->version == NULL)
1790                 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
1791
1792         return PACKAGE_MANAGER_ERROR_NONE;
1793 }
1794
1795 static int package_manager_updateinfo_convert_property(package_updateinfo_type_e property, pkgmgr_updateinfo_type *converted_property)
1796 {
1797         if (converted_property == NULL)
1798                 return -1;
1799
1800         if (property == PACKAGE_UPDATEINFO_TYPE_FORCE)
1801                 *converted_property = PM_UPDATEINFO_TYPE_FORCE;
1802         else if (property == PACKAGE_UPDATEINFO_TYPE_OPTIONAL)
1803                 *converted_property = PM_UPDATEINFO_TYPE_OPTIONAL;
1804         else if (property == PACKAGE_UPDATEINFO_TYPE_NONE)
1805                 *converted_property = PM_UPDATEINFO_TYPE_NONE;
1806         else
1807                 return -1;
1808
1809         return 0;
1810 }
1811
1812 API int package_manager_updateinfo_set_type(package_updateinfo_request_h pkg_updateinfo_req, package_updateinfo_type_e type)
1813 {
1814         int retval;
1815         pkgmgr_updateinfo_type converted_type;
1816         struct package_updateinfo_request_s *request;
1817
1818         if (pkg_updateinfo_req == NULL || pkg_updateinfo_req->updateinfo_handle == NULL)
1819                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1820
1821         request = (struct package_updateinfo_request_s *)pkg_updateinfo_req;
1822         retval = package_manager_updateinfo_convert_property(type, &converted_type);
1823         if (retval != 0)
1824                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1825
1826         request->updateinfo_handle->type = converted_type;
1827         return PACKAGE_MANAGER_ERROR_NONE;
1828 }
1829
1830 API int package_manager_updateinfo_request_destroy(package_updateinfo_request_h pkg_updateinfo_req)
1831 {
1832         struct package_updateinfo_request_s *request;
1833
1834         if (pkg_updateinfo_req == NULL)
1835                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1836
1837         request = (struct package_updateinfo_request_s *)pkg_updateinfo_req;
1838         if (request->pc)
1839                 pkgmgr_client_free(request->pc);
1840
1841         if (request->updateinfo_handle) {
1842                 if (request->updateinfo_handle->pkgid)
1843                         free(request->updateinfo_handle->pkgid);
1844                 if (request->updateinfo_handle->version)
1845                         free(request->updateinfo_handle->version);
1846                 free(request->updateinfo_handle);
1847         }
1848         free(request);
1849
1850         return PACKAGE_MANAGER_ERROR_NONE;
1851 }
1852
1853 API  int package_manager_updateinfo_request_create(package_updateinfo_request_h *pkg_updateinfo_req)
1854 {
1855         struct package_updateinfo_request_s *request;
1856         pkg_update_info_t *update_info;
1857
1858         if (pkg_updateinfo_req == NULL)
1859                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1860
1861         request = calloc(1, sizeof(struct package_updateinfo_request_s));
1862         if (request == NULL)
1863                 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
1864
1865         request->pc = pkgmgr_client_new(PC_REQUEST);
1866         if (request->pc == NULL) {
1867                 free(request);
1868                 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
1869         }
1870
1871         update_info = calloc(1, sizeof(pkg_update_info_t));
1872         if (update_info == NULL) {
1873                 pkgmgr_client_free(request->pc);
1874                 free(request);
1875                 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
1876         }
1877         request->updateinfo_handle = update_info;
1878
1879         *pkg_updateinfo_req = request;
1880         return PACKAGE_MANAGER_ERROR_NONE;
1881 }
1882
1883 API int package_manager_updateinfo_request_register(package_updateinfo_request_h pkg_updateinfo_req)
1884 {
1885         struct package_updateinfo_request_s *update_info;
1886         int retval;
1887
1888         if (pkg_updateinfo_req == NULL)
1889                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1890         update_info = (struct package_updateinfo_request_s *)pkg_updateinfo_req;
1891
1892         retval = pkgmgr_client_register_pkg_update_info(update_info->pc, update_info->updateinfo_handle);
1893         if (retval == PKGMGR_R_EINVAL)
1894                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1895
1896         return PACKAGE_MANAGER_ERROR_NONE;
1897 }
1898
1899 API int package_manager_updateinfo_request_unregister(package_updateinfo_request_h pkg_updateinfo_req, const char *pkgid)
1900 {
1901         int retval;
1902         struct package_updateinfo_request_s *update_info;
1903
1904         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_ADMIN);
1905         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1906                 return retval;
1907
1908         if (pkg_updateinfo_req == NULL || pkgid == NULL)
1909                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1910
1911         update_info = (struct package_updateinfo_request_s *)pkg_updateinfo_req;
1912         retval = pkgmgr_client_unregister_pkg_update_info(update_info->pc, pkgid);
1913         if (retval != PMINFO_R_OK)
1914                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
1915
1916         return PACKAGE_MANAGER_ERROR_NONE;
1917 }
1918
1919 API int package_manager_updateinfo_request_unregister_all(package_updateinfo_request_h pkg_updateinfo_req)
1920 {
1921         int retval;
1922         struct package_updateinfo_request_s *update_info;
1923
1924         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_ADMIN);
1925         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1926                 return retval;
1927
1928         if (pkg_updateinfo_req == NULL)
1929                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1930
1931         update_info = (struct package_updateinfo_request_s *)pkg_updateinfo_req;
1932         retval = pkgmgr_client_unregister_all_pkg_update_info(update_info->pc);
1933
1934         if (retval != PMINFO_R_OK)
1935                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
1936
1937         return PACKAGE_MANAGER_ERROR_NONE;
1938 }