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         if (package_manager_client_validate_handle(request))
 278                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER,
 279                                 __FUNCTION__, NULL);
 280
 281         ret = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
 282         if (ret != PACKAGE_MANAGER_ERROR_NONE)
 283                 return ret;
 284
 285         return __reset_user_request_callback(request, callback, user_data);
 286 }
 287
 288 API int package_manager_request_unset_event_cb(package_manager_request_h request)
 289 {
 290         if (package_manager_client_validate_handle(request))
 291                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 292
 293         request->event_cb = NULL;
 294         request->user_data = NULL;
 295
 296         return PACKAGE_MANAGER_ERROR_NONE;
 297 }
 298
 299 API int package_manager_request_set_type(package_manager_request_h request,
 300                                      const char *pkg_type)
 301 {
 302         if (package_manager_client_validate_handle(request)) {
 303                 return
 304                     package_manager_error
 305                     (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
 306                      NULL);
 307         }
 308
 309         if (request->pkg_type)
 310                 free(request->pkg_type);
 311         request->pkg_type = strdup(pkg_type);
 312
 313         return PACKAGE_MANAGER_ERROR_NONE;
 314 }
 315
 316 API int package_manager_request_set_mode(package_manager_request_h request,
 317                                      package_manager_request_mode_e mode)
 318 {
 319         if (package_manager_client_validate_handle(request)) {
 320                 return
 321                     package_manager_error
 322                     (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
 323                      NULL);
 324         }
 325
 326         /* request mode is not used anymore */
 327
 328         return PACKAGE_MANAGER_ERROR_NONE;
 329 }
 330
 331 API int package_manager_request_set_tep(package_manager_request_h request,
 332                                      const char *tep_path)
 333 {
 334         int retval = 0;
 335
 336         if (package_manager_client_validate_handle(request) || tep_path == NULL) {
 337                 return
 338                         package_manager_error
 339                         (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
 340                          NULL);
 341         }
 342
 343         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_ADMIN);
 344         if (retval != PACKAGE_MANAGER_ERROR_NONE)
 345                 return retval;
 346
 347         if (pkgmgr_client_set_tep_path(request->pc, tep_path, true))
 348                 return PACKAGE_MANAGER_ERROR_SYSTEM_ERROR;
 349
 350         return PACKAGE_MANAGER_ERROR_NONE;
 351 }
 352
 353 static int package_manager_get_event_type(const char *key,
 354                                           package_manager_event_type_e *
 355                                           event_type)
 356 {
 357         if (key == NULL)
 358                 return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
 359
 360         if (strcasecmp(key, PKGMGR_INSTALLER_INSTALL_EVENT_STR) == 0)
 361                 *event_type = PACKAGE_MANAGER_EVENT_TYPE_INSTALL;
 362         else if (strcasecmp(key, PKGMGR_INSTALLER_UNINSTALL_EVENT_STR) == 0)
 363                 *event_type = PACKAGE_MANAGER_EVENT_TYPE_UNINSTALL;
 364         else if (strcasecmp(key, PKGMGR_INSTALLER_UPGRADE_EVENT_STR) == 0)
 365                 *event_type = PACKAGE_MANAGER_EVENT_TYPE_UPDATE;
 366         else if (strcasecmp(key, PKGMGR_INSTALLER_MOVE_EVENT_STR) == 0)
 367                 *event_type = PACKAGE_MANAGER_EVENT_TYPE_MOVE;
 368         else if (strcasecmp(key, PKGMGR_INSTALLER_CLEAR_EVENT_STR) == 0)
 369                 *event_type = PACKAGE_MANAGER_EVENT_TYPE_CLEAR;
 370         else
 371                 return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
 372
 373         return PACKAGE_MANAGER_ERROR_NONE;
 374 }
 375
 376 static int __add_event_info(request_event_info **head, int req_id,
 377                             package_manager_event_type_e event_type,
 378                             package_manager_event_state_e event_state)
 379 {
 380         request_event_info *evt_info;
 381         request_event_info *current;
 382         request_event_info *prev;
 383
 384         evt_info = (request_event_info *) calloc(1, sizeof(request_event_info));
 385         if (evt_info == NULL) {
 386                 _LOGD("calloc failed");
 387                 return -1;
 388         }
 389         evt_info->req_id = req_id;
 390         evt_info->event_type = event_type;
 391         evt_info->event_state = event_state;
 392         evt_info->next = NULL;
 393
 394         if (*head == NULL)
 395                 *head = evt_info;
 396         else {
 397                 current = prev = *head;
 398                 while (current) {
 399                         prev = current;
 400                         current = current->next;
 401                 }
 402
 403                 prev->next = evt_info;
 404         }
 405
 406         return 0;
 407 }
 408
 409 static int __find_event_info(request_event_info **head, int req_id,
 410                              package_manager_event_type_e *event_type,
 411                              package_manager_event_state_e *event_state)
 412 {
 413         request_event_info *tmp;
 414
 415         tmp = *head;
 416
 417         if (tmp == NULL) {
 418                 _LOGE("tmp is NULL");
 419                 return -1;
 420         }
 421
 422         while (tmp) {
 423                 if (tmp->req_id == req_id) {
 424                         *event_type = tmp->event_type;
 425                         *event_state = tmp->event_state;
 426                         return 0;
 427                 }
 428                 tmp = tmp->next;
 429         }
 430         return -1;
 431 }
 432
 433 static int __update_event_info(request_event_info **head, int req_id,
 434                                package_manager_event_type_e event_type,
 435                                package_manager_event_state_e event_state)
 436 {
 437         package_manager_event_type_e evt_type;
 438         package_manager_event_state_e evt_state;
 439         request_event_info *tmp;
 440
 441         if (__find_event_info(head, req_id, &evt_type, &evt_state) != 0)
 442                 __add_event_info(head, req_id, event_type, event_state);
 443         else {
 444                 tmp = *head;
 445
 446                 if (tmp == NULL) {
 447                         _LOGE("tmp is NULL");
 448                         return -1;
 449                 }
 450
 451                 while (tmp) {
 452                         if (tmp->req_id == req_id) {
 453                                 tmp->event_type = event_type;
 454                                 tmp->event_state = event_state;
 455                                 return 0;
 456                         }
 457                         tmp = tmp->next;
 458                 }
 459         }
 460
 461         return -1;
 462 }
 463
 464 static int request_event_handler(uid_t target_uid, int req_id, const char *pkg_type,
 465                                  const char *pkg_name, const char *key,
 466                                  const char *val, const void *pmsg, void *data)
 467 {
 468         int ret = -1;
 469         package_manager_event_type_e event_type = -1;
 470         package_manager_event_state_e event_state = -1;
 471
 472         package_manager_request_h request = data;
 473
 474         if (strcasecmp(key, "start") == 0) {
 475                 ret = package_manager_get_event_type(val, &event_type);
 476                 if (ret != PACKAGE_MANAGER_ERROR_NONE)
 477                         return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
 478
 479                 __add_event_info(&(request->head), req_id, event_type,
 480                                  PACKAGE_MANAGER_EVENT_STATE_STARTED);
 481
 482                 if (request->event_cb)
 483                         request->event_cb(req_id, pkg_type, pkg_name,
 484                                           event_type,
 485                                           PACKAGE_MANAGER_EVENT_STATE_STARTED,
 486                                           0, PACKAGE_MANAGER_ERROR_NONE, request->user_data);
 487
 488         } else if (strcasecmp(key, "install_percent") == 0
 489                    || strcasecmp(key, "progress_percent") == 0) {
 490                 if (__find_event_info
 491                     (&(request->head), req_id, &event_type,
 492                      &event_state) == 0) {
 493                         __update_event_info(&(request->head), req_id,
 494                                             event_type,
 495                                             PACKAGE_MANAGER_EVENT_STATE_PROCESSING);
 496                         if (request->event_cb)
 497                                 request->event_cb(req_id, pkg_type, pkg_name,
 498                                                   event_type,
 499                                                   PACKAGE_MANAGER_EVENT_STATE_PROCESSING,
 500                                                   atoi(val),
 501                                                   PACKAGE_MANAGER_ERROR_NONE,
 502                                                   request->user_data);
 503                 }
 504
 505         } else if (strcasecmp(key, "error") == 0) {
 506                 if (__find_event_info
 507                     (&(request->head), req_id, &event_type,
 508                      &event_state) == 0) {
 509                         __update_event_info(&(request->head), req_id,
 510                                             event_type,
 511                                             PACKAGE_MANAGER_EVENT_STATE_FAILED);
 512                 }
 513
 514                 if (request->event_cb)
 515                         request->event_cb(req_id, pkg_type,
 516                                           pkg_name, event_type,
 517                                           PACKAGE_MANAGER_EVENT_STATE_FAILED,
 518                                           0,
 519                                           PACKAGE_MANAGER_ERROR_NONE,
 520                                           request->user_data);
 521
 522         } else if (strcasecmp(key, "end") == 0) {
 523                 if (__find_event_info
 524                     (&(request->head), req_id, &event_type,
 525                      &event_state) == 0) {
 526                         if (event_state != PACKAGE_MANAGER_EVENT_STATE_FAILED) {
 527                                 if (request->event_cb)
 528                                         request->event_cb(req_id, pkg_type,
 529                                                           pkg_name, event_type,
 530                                                           PACKAGE_MANAGER_EVENT_STATE_COMPLETED,
 531                                                           100,
 532                                                           PACKAGE_MANAGER_ERROR_NONE,
 533                                                           request->user_data);
 534                         }
 535                 } else {
 536                         if (strcasecmp(key, "ok") != 0)
 537                                 if (request->event_cb)
 538                                         request->event_cb(req_id, pkg_type,
 539                                                           pkg_name, event_type,
 540                                                           PACKAGE_MANAGER_EVENT_STATE_FAILED,
 541                                                           0,
 542                                                           PACKAGE_MANAGER_ERROR_NONE,
 543                                                           request->user_data);
 544                 }
 545         }
 546
 547         return PACKAGE_MANAGER_ERROR_NONE;
 548 }
 549
 550 static int internal_request_callback(uid_t target_uid, int req_id, const char *pkg_type,
 551                                 const char *pkg_name, const char *key,
 552                                 const char *val, const void *pmsg, void *data)
 553 {
 554         int ret;
 555         package_manager_event_type_e event_type = -1;
 556         package_manager_event_state_e event_state = -1;
 557         struct package_manager_request_cb_info *cb_info;
 558         package_manager_request_event_cb event_cb;
 559         void *user_data = NULL;
 560
 561         _LOGD("request callback called, req_id[%d]", req_id);
 562
 563         package_manager_request_h request = data;
 564
 565         if (request->request_cb_table)
 566                 cb_info = g_hash_table_lookup(request->request_cb_table,
 567                                 GINT_TO_POINTER(req_id));
 568         else
 569                 cb_info = NULL;
 570
 571         if (!cb_info || (cb_info && !cb_info->callback)) {
 572                 _LOGE("no callback info");
 573                 return 0;
 574         }
 575
 576         if (cb_info->req_id != req_id) {
 577                 _LOGE("not matched request id");
 578                 return 0;
 579         }
 580
 581         event_cb = cb_info->callback;
 582         user_data = cb_info->user_data;
 583
 584         if (strcasecmp(key, "start") == 0) {
 585                 ret = package_manager_get_event_type(val, &event_type);
 586                 if (ret != PACKAGE_MANAGER_ERROR_NONE)
 587                         return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
 588
 589                 __add_event_info(&request->head, req_id, event_type,
 590                                  PACKAGE_MANAGER_EVENT_STATE_STARTED);
 591
 592                 event_cb(req_id, pkg_type, pkg_name,
 593                         event_type,
 594                         PACKAGE_MANAGER_EVENT_STATE_STARTED,
 595                         0, PACKAGE_MANAGER_ERROR_NONE, user_data);
 596         } else if (strcasecmp(key, "install_percent") == 0) {
 597                 if (__find_event_info(&request->head, req_id, &event_type,
 598                                 &event_state) == 0) {
 599                         __update_event_info(&request->head, req_id,
 600                                         event_type,
 601                                         PACKAGE_MANAGER_EVENT_STATE_PROCESSING);
 602                         event_cb(req_id, pkg_type, pkg_name,
 603                                 event_type,
 604                                 PACKAGE_MANAGER_EVENT_STATE_PROCESSING,
 605                                 atoi(val),
 606                                 PACKAGE_MANAGER_ERROR_NONE,
 607                                 user_data);
 608                 }
 609         } else if (strcasecmp(key, "error") == 0) {
 610                 if (__find_event_info(&request->head, req_id, &event_type,
 611                                 &event_state) == 0) {
 612                         __update_event_info(&request->head, req_id,
 613                                         event_type,
 614                                         PACKAGE_MANAGER_EVENT_STATE_FAILED);
 615                         event_cb(req_id, pkg_type,
 616                                 pkg_name, event_type,
 617                                 PACKAGE_MANAGER_EVENT_STATE_FAILED,
 618                                 0,
 619                                 PACKAGE_MANAGER_ERROR_NONE,
 620                                 user_data);
 621                 }
 622         } else if (strcasecmp(key, "end") == 0) {
 623                 if (__find_event_info(&request->head, req_id, &event_type,
 624                                 &event_state) == 0) {
 625                         if (request->request_cb_table) {
 626                                 _LOGD("remove item, req_id(%d)", req_id);
 627                                 g_hash_table_remove(request->request_cb_table,
 628                                         GINT_TO_POINTER(req_id));
 629                         }
 630                         if (event_state != PACKAGE_MANAGER_EVENT_STATE_FAILED) {
 631                                 if (strcasecmp(val, "ok") == 0) {
 632                                         event_cb(req_id, pkg_type,
 633                                                 pkg_name, event_type,
 634                                                 PACKAGE_MANAGER_EVENT_STATE_COMPLETED,
 635                                                 100,
 636                                                 PACKAGE_MANAGER_ERROR_NONE,
 637                                                 user_data);
 638                                 } else {
 639                                         event_cb(req_id, pkg_type,
 640                                                 pkg_name, event_type,
 641                                                 PACKAGE_MANAGER_EVENT_STATE_FAILED,
 642                                                 0,
 643                                                 PACKAGE_MANAGER_ERROR_NONE,
 644                                                 user_data);
 645                                 }
 646                         }
 647                 } else {
 648                         _LOGE("unexpected end event");
 649                 }
 650         }
 651
 652         return 0;
 653 }
 654
 655 static int __request_install(package_manager_request_h request,
 656                 const char *path, pkgmgr_handler event_cb, int *id)
 657 {
 658         int retval;
 659         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_ADMIN);
 660         if (retval != PACKAGE_MANAGER_ERROR_NONE)
 661                 return retval;
 662
 663         if (package_manager_client_validate_handle(request))
 664                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 665
 666         if (path == NULL)
 667                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 668
 669         int request_id = 0;
 670         request_id = pkgmgr_client_install(request->pc, request->pkg_type, NULL,
 671                         path, NULL, request->mode, event_cb ? event_cb : request_event_handler, request);
 672
 673         if (request_id == PKGMGR_R_EINVAL)
 674                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 675         else if (request_id == PKGMGR_R_ENOPKG)
 676                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
 677         else if (request_id == PKGMGR_R_ENOMEM)
 678                 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
 679         else if (request_id == PKGMGR_R_EIO)
 680                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
 681         else if (request_id == PKGMGR_R_EPRIV)
 682                 return package_manager_error(PACKAGE_MANAGER_ERROR_PERMISSION_DENIED, __FUNCTION__, NULL);
 683         else if (request_id == PKGMGR_R_ESYSTEM || request_id == PKGMGR_R_ECOMM || request_id == PKGMGR_R_ERROR)
 684                 return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
 685
 686         if (id)
 687                 *id = request_id;
 688
 689         return PACKAGE_MANAGER_ERROR_NONE;
 690 }
 691
 692 static int __request_uninstall(package_manager_request_h request,
 693                 const char *name, pkgmgr_handler event_cb, int *id)
 694 {
 695         int retval;
 696         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_ADMIN);
 697         if (retval != PACKAGE_MANAGER_ERROR_NONE)
 698                 return retval;
 699
 700         if (package_manager_client_validate_handle(request))
 701                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 702
 703         if (name == NULL)
 704                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 705
 706         int request_id = 0;
 707         request_id = pkgmgr_client_uninstall(request->pc, request->pkg_type,
 708                         name, request->mode, event_cb ? event_cb : request_event_handler, request);
 709
 710         if (request_id == PKGMGR_R_EINVAL)
 711                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 712         else if (request_id == PKGMGR_R_ENOPKG)
 713                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
 714         else if (request_id == PKGMGR_R_ENOMEM)
 715                 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
 716         else if (request_id == PKGMGR_R_EIO)
 717                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
 718         else if (request_id == PKGMGR_R_EPRIV)
 719                 return package_manager_error(PACKAGE_MANAGER_ERROR_PERMISSION_DENIED, __FUNCTION__, NULL);
 720         else if (request_id == PKGMGR_R_ESYSTEM || request_id == PKGMGR_R_ECOMM || request_id == PKGMGR_R_ERROR)
 721                 return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
 722
 723         if (id)
 724                 *id = request_id;
 725
 726         return PACKAGE_MANAGER_ERROR_NONE;
 727 }
 728
 729 static int __request_move(package_manager_request_h request,
 730                 const char *name, package_manager_move_type_e move_type,
 731                 pkgmgr_handler event_cb, int *id)
 732 {
 733         int retval;
 734         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_ADMIN);
 735         if (retval != PACKAGE_MANAGER_ERROR_NONE)
 736                 return retval;
 737
 738         if (package_manager_client_validate_handle(request))
 739                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 740
 741         if (name == NULL)
 742                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 743
 744         int request_id = 0;
 745         request_id = pkgmgr_client_request_service(PM_REQUEST_MOVE, move_type,
 746                         request->pc, request->pkg_type, name,
 747                         NULL, event_cb ? event_cb : request_event_handler, request);
 748
 749         if (request_id == PKGMGR_R_EINVAL)
 750                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 751         else if (request_id == PKGMGR_R_ENOPKG)
 752                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
 753         else if (request_id == PKGMGR_R_ENOMEM)
 754                 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
 755         else if (request_id == PKGMGR_R_EIO)
 756                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
 757         else if (request_id == PKGMGR_R_EPRIV)
 758                 return package_manager_error(PACKAGE_MANAGER_ERROR_PERMISSION_DENIED, __FUNCTION__, NULL);
 759         else if (request_id == PKGMGR_R_ESYSTEM || request_id == PKGMGR_R_ECOMM || request_id == PKGMGR_R_ERROR)
 760                 return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
 761
 762         if (id)
 763                 *id = request_id;
 764
 765         return PACKAGE_MANAGER_ERROR_NONE;
 766 }
 767
 768 static int __request_mount_install(package_manager_request_h request,
 769                 const char *path, pkgmgr_handler event_cb, int *id)
 770 {
 771         int retval;
 772         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_ADMIN);
 773         if (retval != PACKAGE_MANAGER_ERROR_NONE)
 774                 return retval;
 775
 776         if (package_manager_client_validate_handle(request))
 777                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 778
 779         if (path == NULL)
 780                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 781
 782         int request_id = 0;
 783         request_id = pkgmgr_client_mount_install(request->pc, request->pkg_type, NULL,
 784                         path, NULL, request->mode, event_cb ? event_cb : request_event_handler, request);
 785
 786         if (request_id == PKGMGR_R_EINVAL)
 787                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 788         else if (request_id == PKGMGR_R_ENOPKG)
 789                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
 790         else if (request_id == PKGMGR_R_ENOMEM)
 791                 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
 792         else if (request_id == PKGMGR_R_EIO)
 793                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
 794         else if (request_id == PKGMGR_R_EPRIV)
 795                 return package_manager_error(PACKAGE_MANAGER_ERROR_PERMISSION_DENIED, __FUNCTION__, NULL);
 796         else if (request_id == PKGMGR_R_ESYSTEM || request_id == PKGMGR_R_ECOMM || request_id == PKGMGR_R_ERROR)
 797                 return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
 798
 799         if (id)
 800                 *id = request_id;
 801
 802         return PACKAGE_MANAGER_ERROR_NONE;
 803 }
 804
 805
 806 API int package_manager_request_install(package_manager_request_h request,
 807                                 const char *path, int *id)
 808 {
 809         return __request_install(request, path, NULL, id);
 810 }
 811
 812 API int package_manager_request_install_with_cb(package_manager_request_h request,
 813                         const char *path, package_manager_request_event_cb callback,
 814                         void *user_data, int *id)
 815 {
 816         int ret;
 817         int req_id = 0;
 818
 819         if (request->request_cb_table == NULL)
 820                 __initialize_request_cb_table(request);
 821
 822         ret = __request_install(request, path, internal_request_callback, &req_id);
 823
 824         if (req_id > 0) {
 825                 ret = __insert_request_cb_info(request, req_id, callback, user_data);
 826                 if (ret < 0)
 827                         return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY,
 828                                         __FUNCTION__, "failed to create request cb info");
 829                 if (id)
 830                         *id = req_id;
 831         }
 832
 833         return ret;
 834 }
 835
 836 API int package_manager_request_uninstall(package_manager_request_h request,
 837                 const char *name, int *id)
 838 {
 839         return __request_uninstall(request, name, NULL, id);
 840 }
 841
 842 API int package_manager_request_uninstall_with_cb(package_manager_request_h request,
 843                         const char *name, package_manager_request_event_cb callback,
 844                         void *user_data, int *id)
 845 {
 846         int ret;
 847         int req_id = 0;
 848
 849         if (request->request_cb_table == NULL)
 850                 __initialize_request_cb_table(request);
 851
 852         ret = __request_uninstall(request, name, internal_request_callback, &req_id);
 853
 854         if (req_id > 0) {
 855                 ret = __insert_request_cb_info(request, req_id, callback, user_data);
 856                 if (ret < 0)
 857                         return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY,
 858                                         __FUNCTION__, "failed to create request cb info");
 859                 if (id)
 860                         *id = req_id;
 861         }
 862
 863         return ret;
 864 }
 865
 866 API int package_manager_request_move(package_manager_request_h request,
 867                 const char *name, package_manager_move_type_e move_type)
 868 {
 869         return __request_move(request, name, move_type, NULL, NULL);
 870 }
 871
 872 API int package_manager_request_move_with_cb(package_manager_request_h request,
 873                 const char *name, package_manager_move_type_e move_type,
 874                 package_manager_request_event_cb callback, void *user_data, int *id)
 875 {
 876         int ret;
 877         int req_id = 0;
 878
 879         if (request->request_cb_table == NULL)
 880                 __initialize_request_cb_table(request);
 881
 882         ret = __request_move(request, name, move_type, internal_request_callback, &req_id);
 883
 884         if (req_id > 0) {
 885                 ret = __insert_request_cb_info(request, req_id, callback, user_data);
 886                 if (ret < 0)
 887                         return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY,
 888                                         __FUNCTION__, "failed to create request cb info");
 889                 if (id)
 890                         *id = req_id;
 891         }
 892
 893         return ret;
 894 }
 895
 896 API int package_manager_request_mount_install(package_manager_request_h request,
 897                                 const char *path, int *id)
 898 {
 899         return __request_mount_install(request, path, NULL, id);
 900 }
 901
 902 API int package_manager_request_mount_install_with_cb(package_manager_request_h request,
 903                         const char *path, package_manager_request_event_cb callback,
 904                         void *user_data, int *id)
 905 {
 906         int ret;
 907         int req_id = 0;
 908
 909         if (request->request_cb_table == NULL)
 910                 __initialize_request_cb_table(request);
 911
 912         ret = __request_mount_install(request, path, internal_request_callback, &req_id);
 913
 914         if (req_id > 0) {
 915                 ret = __insert_request_cb_info(request, req_id, callback, user_data);
 916                 if (ret < 0)
 917                         return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY,
 918                                         __FUNCTION__, "failed to create request cb info");
 919                 if (id)
 920                         *id = req_id;
 921         }
 922
 923         return ret;
 924 }
 925
 926 API int package_manager_create(package_manager_h *manager)
 927 {
 928         int retval;
 929         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
 930         if (retval != PACKAGE_MANAGER_ERROR_NONE)
 931                 return retval;
 932
 933         struct package_manager_s *package_manager = NULL;
 934
 935         if (manager == NULL) {
 936                 return
 937                     package_manager_error
 938                     (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
 939                      NULL);
 940         }
 941
 942         package_manager = calloc(1, sizeof(struct package_manager_s));
 943         if (package_manager == NULL) {
 944                 return
 945                     package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY,
 946                                           __FUNCTION__,
 947                                           "failed to create a package_manager handle");
 948         }
 949
 950         package_manager->ctype = PC_LISTENING;
 951         package_manager->pc = pkgmgr_client_new(PC_LISTENING);
 952         if (package_manager->pc == NULL) {
 953                 free(package_manager);
 954                 return
 955                     package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY,
 956                                           __FUNCTION__,
 957                                           "failed to create a package_manager client");
 958         }
 959
 960         package_manager->handle_id = package_manager_new_id();
 961
 962         *manager = package_manager;
 963
 964         return PACKAGE_MANAGER_ERROR_NONE;
 965 }
 966
 967 static int package_manager_validate_handle(package_manager_h manager)
 968 {
 969         if (manager == NULL || manager->pc == NULL)
 970                 return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
 971
 972         return PACKAGE_MANAGER_ERROR_NONE;
 973 }
 974
 975 API int package_manager_destroy(package_manager_h manager)
 976 {
 977         if (package_manager_validate_handle(manager)) {
 978                 return
 979                     package_manager_error
 980                     (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
 981                      NULL);
 982         }
 983
 984         pkgmgr_client_free(manager->pc);
 985         g_hash_table_destroy(manager->event_info_table);
 986         free(manager);
 987
 988         return PACKAGE_MANAGER_ERROR_NONE;
 989 }
 990
 991 /* App Event Listening Policy:
 992  * +----------------+------------+---------------+------------------+
 993  * |Listener \ Type |Global Event|My User's Event|Other user's Event|
 994  * +----------------+------------+---------------+------------------+
 995  * |User Process App|   Grant    |     Grant     |      Deny        |
 996  * +----------------+------------+---------------+------------------+
 997  * |Platform module |   Grant    |     Grant     |      Grant       |
 998  * +----------------+------------+---------------+------------------+
 999  * UID assignment policy:
1000  * https://wiki.tizen.org/wiki/Security/User_and_group_ID_assignment_policy
1001  */
1002 #define REGULAR_USER 5000
1003 static int __validate_event_signal(uid_t target_uid)
1004 {
1005         uid_t self = getuid();
1006
1007         if (self == target_uid)
1008                 return 0;
1009
1010         if (self < REGULAR_USER)
1011                 return 0;
1012
1013         return -1;
1014 }
1015
1016 static int internal_callback(uid_t target_uid, int req_id, const char *pkg_type,
1017                                 const char *pkg_name, const char *key,
1018                                 const char *val, const void *pmsg, void *data)
1019 {
1020         int ret = -1;
1021         package_manager_event_type_e event_type = -1;
1022         struct package_manager_event_info *info = NULL;
1023         package_manager_h manager = data;
1024         uid_t uid = target_uid;
1025
1026         _LOGD("req_id(%d), pkg_name(%s), type(%s), key(%s), val(%s)",
1027                         req_id, pkg_name, pkg_type, key, val);
1028
1029         if (target_uid == GLOBAL_USER)
1030                 uid = getuid();
1031
1032         if (__validate_event_signal(uid))
1033                 return PACKAGE_MANAGER_ERROR_NONE;
1034
1035         if (manager && manager->event_info_table) {
1036                 info = g_hash_table_lookup(manager->event_info_table, pkg_name);
1037         } else {
1038                 _LOGE("invalid handle");
1039                 return PACKAGE_MANAGER_ERROR_NONE;
1040         }
1041
1042         if (!info) {
1043                 if (strcasecmp(key, "start") != 0) {
1044                         _LOGD("unexpected signal or no info(removed)");
1045                         return PACKAGE_MANAGER_ERROR_NONE;
1046                 }
1047         }
1048
1049         if (strcasecmp(key, "start") == 0) {
1050                 ret = package_manager_get_event_type(val, &event_type);
1051                 if (ret != PACKAGE_MANAGER_ERROR_NONE)
1052                         return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
1053
1054                 if (!info) {
1055                         __insert_event_info(manager, pkg_name, event_type,
1056                                         PACKAGE_MANAGER_EVENT_STATE_STARTED);
1057
1058                         if (manager->event_cb && getuid() == uid)
1059                                 manager->event_cb(pkg_type, pkg_name,
1060                                                 event_type,
1061                                                 PACKAGE_MANAGER_EVENT_STATE_STARTED,
1062                                                 0,
1063                                                 PACKAGE_MANAGER_ERROR_NONE,
1064                                                 manager->user_data);
1065                 } else {
1066                         _LOGE("unexpected start event");
1067                 }
1068         } else if (strcasecmp(key, "install_percent") == 0
1069                    || strcasecmp(key, "progress_percent") == 0) {
1070                 info->event_state = PACKAGE_MANAGER_EVENT_STATE_PROCESSING;
1071                 if (manager->event_cb && getuid() == uid)
1072                         manager->event_cb(pkg_type, pkg_name,
1073                                         info->event_type,
1074                                         info->event_state,
1075                                         atoi(val),
1076                                         PACKAGE_MANAGER_ERROR_NONE,
1077                                         manager->user_data);
1078         } else if (strcasecmp(key, "error") == 0) {
1079                 info->event_state = PACKAGE_MANAGER_EVENT_STATE_FAILED;
1080                 if (manager->event_cb && getuid() == uid)
1081                         manager->event_cb(pkg_type, pkg_name,
1082                                         info->event_type,
1083                                         info->event_state,
1084                                         0,
1085                                         PACKAGE_MANAGER_ERROR_NONE,
1086                                         manager->user_data);
1087         } else if (strcasecmp(key, "end") == 0) {
1088                 if (info->event_state != PACKAGE_MANAGER_EVENT_STATE_FAILED) {
1089                         if (manager->event_cb && getuid() == uid) {
1090                                 if (strcasecmp(val, "ok") == 0) {
1091                                         manager->event_cb(pkg_type, pkg_name,
1092                                                 info->event_type,
1093                                                 PACKAGE_MANAGER_EVENT_STATE_COMPLETED,
1094                                                 100,
1095                                                 PACKAGE_MANAGER_ERROR_NONE,
1096                                                 manager->user_data);
1097                                 } else {
1098                                         manager->event_cb(pkg_type, pkg_name,
1099                                                 info->event_type,
1100                                                 PACKAGE_MANAGER_EVENT_STATE_FAILED,
1101                                                 0,
1102                                                 PACKAGE_MANAGER_ERROR_NONE,
1103                                                 manager->user_data);
1104                                 }
1105                         }
1106                 }
1107                 g_hash_table_remove(manager->event_info_table, info->pkg_name);
1108         }
1109
1110         return PACKAGE_MANAGER_ERROR_NONE;
1111 }
1112
1113 static int __convert_status_type(package_manager_status_type_e status_type)
1114 {
1115         int type = 0;
1116
1117         if (status_type == PACKAGE_MANAGER_STATUS_TYPE_ALL)
1118                 return PKGMGR_CLIENT_STATUS_ALL;
1119
1120         if (status_type & PACKAGE_MANAGER_STATUS_TYPE_INSTALL)
1121                 type |= PKGMGR_CLIENT_STATUS_INSTALL;
1122         if (status_type & PACKAGE_MANAGER_STATUS_TYPE_UNINSTALL)
1123                 type |= PKGMGR_CLIENT_STATUS_UNINSTALL;
1124         if (status_type & PACKAGE_MANAGER_STATUS_TYPE_UPGRADE)
1125                 type |= PKGMGR_CLIENT_STATUS_UPGRADE;
1126         if (status_type & PACKAGE_MANAGER_STATUS_TYPE_MOVE)
1127                 type |= PKGMGR_CLIENT_STATUS_MOVE;
1128         if (status_type & PACKAGE_MANAGER_STATUS_TYPE_CLEAR_DATA)
1129                 type |= PKGMGR_CLIENT_STATUS_CLEAR_DATA;
1130         if (status_type & PACKAGE_MANAGER_STATUS_TYPE_INSTALL_PROGRESS)
1131                 type |= PKGMGR_CLIENT_STATUS_INSTALL_PROGRESS;
1132         if (status_type & PACKAGE_MANAGER_STATUS_TYPE_GET_SIZE)
1133                 type |= PKGMGR_CLIENT_STATUS_GET_SIZE;
1134
1135         return type;
1136 }
1137
1138 API int package_manager_set_event_status(package_manager_h manager, int status_type)
1139 {
1140         int retval;
1141         int type;
1142         int type_all = PACKAGE_MANAGER_STATUS_TYPE_INSTALL |
1143                 PACKAGE_MANAGER_STATUS_TYPE_UNINSTALL |
1144                 PACKAGE_MANAGER_STATUS_TYPE_UPGRADE |
1145                 PACKAGE_MANAGER_STATUS_TYPE_MOVE |
1146                 PACKAGE_MANAGER_STATUS_TYPE_CLEAR_DATA |
1147                 PACKAGE_MANAGER_STATUS_TYPE_INSTALL_PROGRESS |
1148                 PACKAGE_MANAGER_STATUS_TYPE_GET_SIZE;
1149
1150         if (manager == NULL)
1151                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1152
1153         if (status_type < 0 || status_type > type_all)
1154                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1155
1156         type = __convert_status_type(status_type);
1157         retval = pkgmgr_client_set_status_type(manager->pc, type);
1158
1159         if (retval < 0)
1160                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
1161
1162         return PACKAGE_MANAGER_ERROR_NONE;
1163 }
1164
1165 API int package_manager_set_event_cb(package_manager_h manager,
1166                                  package_manager_event_cb callback,
1167                                  void *user_data)
1168 {
1169         int retval;
1170         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
1171         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1172                 return retval;
1173
1174         if (package_manager_validate_handle(manager)) {
1175                 return
1176                     package_manager_error
1177                     (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
1178                      NULL);
1179         }
1180
1181         manager->event_cb = callback;
1182         manager->user_data = user_data;
1183
1184         retval = pkgmgr_client_listen_status(manager->pc,
1185                         internal_callback, manager);
1186         if (retval < 0) {
1187                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR,
1188                         __FUNCTION__, NULL);
1189         }
1190
1191         if (!manager->event_info_table) {
1192                 manager->event_info_table =
1193                         g_hash_table_new_full(g_str_hash, g_str_equal,
1194                                 NULL, __free_event_info);
1195         }
1196
1197         return PACKAGE_MANAGER_ERROR_NONE;
1198 }
1199
1200 API int package_manager_unset_event_cb(package_manager_h manager)
1201 {
1202         if (manager == NULL) {
1203                 return
1204                     package_manager_error
1205                     (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
1206                      NULL);
1207         }
1208
1209         int retval;
1210         manager->event_cb = NULL;
1211         manager->user_data = NULL;
1212
1213         g_hash_table_remove_all(manager->event_info_table);
1214
1215         retval = pkgmgr_client_remove_listen_status(manager->pc);
1216         if (retval == PKGMGR_R_EINVAL)
1217                 return
1218                          package_manager_error
1219                          (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
1220                           NULL);
1221         else if (retval == PKGMGR_R_ERROR)
1222                 return
1223                          package_manager_error
1224                          (PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__,
1225                           NULL);
1226
1227         return PACKAGE_MANAGER_ERROR_NONE;
1228 }
1229
1230 API int package_manager_get_package_id_by_app_id(const char *app_id, char **package_id)
1231 {
1232         pkgmgrinfo_appinfo_h pkgmgrinfo_appinfo;
1233         int retval;
1234         char *pkg_id = NULL;
1235         char *pkg_id_dup = NULL;
1236
1237         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
1238         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1239                 return retval;
1240
1241         if (app_id == NULL || package_id == NULL)
1242                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1243
1244         if (pkgmgrinfo_appinfo_get_appinfo(app_id, &pkgmgrinfo_appinfo) != PMINFO_R_OK)
1245                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1246         retval = pkgmgrinfo_appinfo_get_pkgname(pkgmgrinfo_appinfo, &pkg_id);
1247         if (retval != PMINFO_R_OK) {
1248                 pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
1249                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1250         }
1251
1252         pkg_id_dup = strdup(pkg_id);
1253         if (pkg_id_dup == NULL) {
1254                 pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
1255                 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
1256         }
1257
1258         *package_id = pkg_id_dup;
1259
1260         pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
1261
1262         return PACKAGE_MANAGER_ERROR_NONE;
1263 }
1264
1265 API int package_manager_get_package_info(const char *package_id, package_info_h *package_info)
1266 {
1267         int retval;
1268         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
1269         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1270                 return retval;
1271
1272         retval = package_info_get_package_info(package_id, package_info);
1273
1274         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1275                 return package_manager_error(retval, __FUNCTION__, NULL);
1276         else
1277                 return PACKAGE_MANAGER_ERROR_NONE;
1278 }
1279
1280 API int package_manager_foreach_package_info(package_manager_package_info_cb callback,
1281                                         void *user_data)
1282 {
1283         int retval;
1284         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
1285         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1286                 return retval;
1287
1288         retval = package_info_foreach_package_info(callback, user_data);
1289
1290         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1291                 return package_manager_error(retval, __FUNCTION__, NULL);
1292         else
1293                 return PACKAGE_MANAGER_ERROR_NONE;
1294 }
1295
1296 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)
1297 {
1298         pkgmgrinfo_cert_compare_result_type_e result;
1299
1300         if (lhs_package_id == NULL || rhs_package_id == NULL || compare_result == NULL)
1301                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1302         if (pkgmgrinfo_pkginfo_compare_pkg_cert_info(lhs_package_id, rhs_package_id, &result) != PKGMGR_R_OK)
1303                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
1304         *compare_result = (package_manager_compare_result_type_e)result;
1305
1306         return PACKAGE_MANAGER_ERROR_NONE;
1307 }
1308
1309 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)
1310 {
1311         pkgmgrinfo_cert_compare_result_type_e result;
1312
1313         if (lhs_app_id == NULL || rhs_app_id == NULL || compare_result == NULL)
1314                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1315         if (pkgmgrinfo_pkginfo_compare_app_cert_info(lhs_app_id, rhs_app_id, &result) != PKGMGR_R_OK)
1316                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
1317
1318         *compare_result = (package_manager_compare_result_type_e)result;
1319
1320         return PACKAGE_MANAGER_ERROR_NONE;
1321 }
1322
1323 API int package_manager_is_preload_package_by_app_id(const char *app_id, bool *preload)
1324 {
1325         int retval;
1326         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
1327         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1328                 return retval;
1329
1330         pkgmgrinfo_appinfo_h pkgmgrinfo_appinfo = NULL;
1331         pkgmgrinfo_pkginfo_h pkgmgrinfo_pkginfo = NULL;
1332
1333         char *pkg_id = NULL;
1334         bool is_preload = 0;
1335         if (pkgmgrinfo_appinfo_get_appinfo(app_id, &pkgmgrinfo_appinfo) != PMINFO_R_OK)
1336                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1337
1338         retval = pkgmgrinfo_appinfo_get_pkgname(pkgmgrinfo_appinfo, &pkg_id);
1339         if (retval != PMINFO_R_OK) {
1340                 pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
1341                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1342         }
1343         if (pkgmgrinfo_pkginfo_get_pkginfo(pkg_id, &pkgmgrinfo_pkginfo) != PMINFO_R_OK) {
1344                 pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
1345                 pkgmgrinfo_pkginfo_destroy_pkginfo(pkgmgrinfo_pkginfo);
1346                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1347         }
1348         if (pkgmgrinfo_pkginfo_is_preload(pkgmgrinfo_pkginfo, &is_preload) != PMINFO_R_OK) {
1349                 pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
1350                 pkgmgrinfo_pkginfo_destroy_pkginfo(pkgmgrinfo_pkginfo);
1351                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1352         }
1353
1354         if (is_preload)
1355                 *preload = 1;
1356         else
1357                 *preload = 0;
1358
1359         pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
1360         pkgmgrinfo_pkginfo_destroy_pkginfo(pkgmgrinfo_pkginfo);
1361
1362         return PACKAGE_MANAGER_ERROR_NONE;
1363 }
1364
1365 API int package_manager_get_permission_type(const char *app_id, package_manager_permission_type_e *permission_type)
1366 {
1367         int retval;
1368         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
1369         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1370                 return retval;
1371
1372         pkgmgrinfo_appinfo_h pkgmgrinfo_appinfo = NULL;
1373         pkgmgrinfo_permission_type permission = 0;
1374         if (pkgmgrinfo_appinfo_get_appinfo(app_id, &pkgmgrinfo_appinfo) != PMINFO_R_OK)
1375                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1376         retval = pkgmgrinfo_appinfo_get_permission_type(pkgmgrinfo_appinfo, &permission);
1377         if (retval != PMINFO_R_OK) {
1378                 pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
1379                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1380         }
1381
1382         if (permission == PMINFO_PERMISSION_NORMAL)
1383                 *permission_type = PACKAGE_MANAGER_PERMISSION_NORMAL;
1384         else if (permission == PMINFO_PERMISSION_SIGNATURE)
1385                 *permission_type = PACKAGE_MANAGER_PERMISSION_SIGNATURE;
1386         else if (permission == PMINFO_PERMISSION_PRIVILEGE)
1387                 *permission_type = PACKAGE_MANAGER_PERMISSION_PRIVILEGE;
1388         else
1389                 *permission_type = PACKAGE_MANAGER_PERMISSION_NORMAL;
1390
1391         pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
1392         return PACKAGE_MANAGER_ERROR_NONE;
1393 }
1394
1395 API int package_manager_clear_cache_dir(const char *package_id)
1396 {
1397         int retval;
1398         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_CACHE);
1399         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1400                 return retval;
1401
1402         int res = pkgmgr_client_clear_cache_dir(package_id);
1403         if (res == PKGMGR_R_EINVAL) {
1404                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1405         } else if (res == PKGMGR_R_ENOPKG) {
1406                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1407         } else if (res == PKGMGR_R_ENOMEM) {
1408                 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
1409         } else if (res == PKGMGR_R_EIO) {
1410                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
1411         } else if (res == PKGMGR_R_EPRIV) {
1412                 return package_manager_error(PACKAGE_MANAGER_ERROR_PERMISSION_DENIED, __FUNCTION__, NULL);
1413         } else if (res == PKGMGR_R_ESYSTEM || res == PKGMGR_R_ECOMM || res == PKGMGR_R_ERROR) {
1414                 return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
1415         } else if (res != PKGMGR_R_OK) {
1416                 _LOGE("Unexpected error");
1417                 return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
1418         }
1419
1420         return PACKAGE_MANAGER_ERROR_NONE;
1421 }
1422
1423 API int package_manager_clear_data_dir(const char *package_id)
1424 {
1425         int retval;
1426         pkgmgr_client *pc = NULL;
1427         char *pkg_type = NULL;
1428         pkgmgrinfo_pkginfo_h pkginfo = NULL;
1429
1430         if (package_id == NULL)
1431                 return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
1432
1433         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_ADMIN);
1434         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1435                 return retval;
1436
1437         retval = pkgmgrinfo_pkginfo_get_pkginfo(package_id, &pkginfo);
1438         if (retval == PMINFO_R_ENOENT)
1439                 return PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE;
1440         else if (retval != PMINFO_R_OK || pkginfo == NULL)
1441                 return PACKAGE_MANAGER_ERROR_SYSTEM_ERROR;
1442
1443         retval = pkgmgrinfo_pkginfo_get_type(pkginfo, &pkg_type);
1444         if (retval != PMINFO_R_OK || pkg_type == NULL) {
1445                 pkgmgrinfo_pkginfo_destroy_pkginfo(pkginfo);
1446                 return PACKAGE_MANAGER_ERROR_SYSTEM_ERROR;
1447         }
1448
1449         pc = pkgmgr_client_new(PC_REQUEST);
1450         if (pc == NULL) {
1451                 _LOGE("Out of memory");
1452                 pkgmgrinfo_pkginfo_destroy_pkginfo(pkginfo);
1453                 return PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY;
1454         }
1455
1456         retval = pkgmgr_client_clear_user_data(pc, pkg_type, package_id, PM_QUIET);
1457         pkgmgr_client_free(pc);
1458         pkgmgrinfo_pkginfo_destroy_pkginfo(pkginfo);
1459
1460         if (retval == PKGMGR_R_EINVAL) {
1461                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1462         } else if (retval == PKGMGR_R_ENOPKG) {
1463                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1464         } else if (retval == PKGMGR_R_ENOMEM) {
1465                 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
1466         } else if (retval == PKGMGR_R_EIO) {
1467                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
1468         } else if (retval == PKGMGR_R_EPRIV) {
1469                 return package_manager_error(PACKAGE_MANAGER_ERROR_PERMISSION_DENIED, __FUNCTION__, NULL);
1470         } else if (retval == PKGMGR_R_ESYSTEM || retval == PKGMGR_R_ECOMM || retval == PKGMGR_R_ERROR) {
1471                 return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
1472         } else if (retval != PKGMGR_R_OK) {
1473                 _LOGE("Unexpected error");
1474                 return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
1475         }
1476
1477         return PACKAGE_MANAGER_ERROR_NONE;
1478 }
1479
1480 API int package_manager_clear_all_cache_dir(void)
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         int retval;
1667         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
1668         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1669                 return retval;
1670
1671         if ((handle == NULL) || (count == NULL))
1672                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1673
1674         retval = pkgmgrinfo_pkginfo_filter_count(handle, count);
1675         if (retval < 0)
1676                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
1677
1678         return PACKAGE_MANAGER_ERROR_NONE;
1679 }
1680
1681 API int package_manager_filter_foreach_package_info(package_manager_filter_h handle,
1682                 package_manager_package_info_cb callback, void *user_data)
1683 {
1684         int retval;
1685         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
1686         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1687                 return retval;
1688
1689         retval = package_info_filter_foreach_package_info(handle, callback, user_data);
1690
1691         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1692                 return package_manager_error(retval, __FUNCTION__, NULL);
1693         else
1694                 return PACKAGE_MANAGER_ERROR_NONE;
1695 }
1696
1697 API int package_size_info_get_data_size(package_size_info_h handle, long long *data_size)
1698 {
1699         if (handle == NULL)
1700                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1701
1702         package_size_info_t *size_info = (package_size_info_t *)handle;
1703
1704         *data_size = (long long)size_info->data_size;
1705         return PACKAGE_MANAGER_ERROR_NONE;
1706 }
1707
1708 API int package_size_info_get_cache_size(package_size_info_h handle, long long *cache_size)
1709 {
1710         if (handle == NULL)
1711                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1712
1713         package_size_info_t *size_info = (package_size_info_t *)handle;
1714
1715         *cache_size = size_info->cache_size;
1716         return PACKAGE_MANAGER_ERROR_NONE;
1717 }
1718
1719 API int package_size_info_get_app_size(package_size_info_h handle, long long *app_size)
1720 {
1721         if (handle == NULL)
1722                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1723
1724         package_size_info_t *size_info = (package_size_info_t *)handle;
1725         *app_size = size_info->app_size;
1726         return PACKAGE_MANAGER_ERROR_NONE;
1727 }
1728
1729 API int package_size_info_get_external_data_size(package_size_info_h handle, long long *ext_data_size)
1730 {
1731         if (handle == NULL)
1732                 return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
1733
1734         package_size_info_t *size_info = (package_size_info_t *)handle;
1735         *ext_data_size = size_info->external_data_size;
1736         return PACKAGE_MANAGER_ERROR_NONE;
1737 }
1738
1739 API int package_size_info_get_external_cache_size(package_size_info_h handle, long long *ext_cache_size)
1740 {
1741         if (handle == NULL)
1742                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1743
1744         package_size_info_t *size_info = (package_size_info_t *)handle;
1745         *ext_cache_size = size_info->external_cache_size;
1746         return PACKAGE_MANAGER_ERROR_NONE;
1747 }
1748
1749 API int package_size_info_get_external_app_size(package_size_info_h handle, long long *ext_app_size)
1750 {
1751         if (handle == NULL)
1752                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1753
1754         package_size_info_t *size_info = (package_size_info_t *)handle;
1755         *ext_app_size = size_info->external_app_size;
1756         return PACKAGE_MANAGER_ERROR_NONE;
1757 }
1758
1759 API int package_manager_updateinfo_set_pkgid(package_updateinfo_request_h pkg_updateinfo_req, const char *pkgid)
1760 {
1761         struct package_updateinfo_request_s *request;
1762
1763         if (pkg_updateinfo_req == NULL || pkg_updateinfo_req->updateinfo_handle == NULL || pkgid == NULL)
1764                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1765
1766         request = (struct package_updateinfo_request_s *)pkg_updateinfo_req;
1767         if (request->updateinfo_handle->pkgid)
1768                 free(request->updateinfo_handle->pkgid);
1769         request->updateinfo_handle->pkgid = strdup(pkgid);
1770         if (request->updateinfo_handle->pkgid == NULL)
1771                 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
1772
1773         return PACKAGE_MANAGER_ERROR_NONE;
1774 }
1775
1776 API int package_manager_updateinfo_set_version(package_updateinfo_request_h pkg_updateinfo_req, const char *version)
1777 {
1778         struct package_updateinfo_request_s *request;
1779
1780         if (pkg_updateinfo_req == NULL || pkg_updateinfo_req->updateinfo_handle == NULL || version == NULL)
1781                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1782
1783         request = (struct package_updateinfo_request_s *)pkg_updateinfo_req;
1784         if (request->updateinfo_handle->version)
1785                 free(request->updateinfo_handle->version);
1786         request->updateinfo_handle->version = strdup(version);
1787         if (request->updateinfo_handle->version == NULL)
1788                 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
1789
1790         return PACKAGE_MANAGER_ERROR_NONE;
1791 }
1792
1793 static int package_manager_updateinfo_convert_property(package_updateinfo_type_e property, pkgmgr_updateinfo_type *converted_property)
1794 {
1795         if (converted_property == NULL)
1796                 return -1;
1797
1798         if (property == PACKAGE_UPDATEINFO_TYPE_FORCE)
1799                 *converted_property = PM_UPDATEINFO_TYPE_FORCE;
1800         else if (property == PACKAGE_UPDATEINFO_TYPE_OPTIONAL)
1801                 *converted_property = PM_UPDATEINFO_TYPE_OPTIONAL;
1802         else if (property == PACKAGE_UPDATEINFO_TYPE_NONE)
1803                 *converted_property = PM_UPDATEINFO_TYPE_NONE;
1804         else
1805                 return -1;
1806
1807         return 0;
1808 }
1809
1810 API int package_manager_updateinfo_set_type(package_updateinfo_request_h pkg_updateinfo_req, package_updateinfo_type_e type)
1811 {
1812         int retval;
1813         pkgmgr_updateinfo_type converted_type;
1814         struct package_updateinfo_request_s *request;
1815
1816         if (pkg_updateinfo_req == NULL || pkg_updateinfo_req->updateinfo_handle == NULL)
1817                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1818
1819         request = (struct package_updateinfo_request_s *)pkg_updateinfo_req;
1820         retval = package_manager_updateinfo_convert_property(type, &converted_type);
1821         if (retval != 0)
1822                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1823
1824         request->updateinfo_handle->type = converted_type;
1825         return PACKAGE_MANAGER_ERROR_NONE;
1826 }
1827
1828 API int package_manager_updateinfo_request_destroy(package_updateinfo_request_h pkg_updateinfo_req)
1829 {
1830         struct package_updateinfo_request_s *request;
1831
1832         if (pkg_updateinfo_req == NULL)
1833                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1834
1835         request = (struct package_updateinfo_request_s *)pkg_updateinfo_req;
1836         if (request->pc)
1837                 pkgmgr_client_free(request->pc);
1838
1839         if (request->updateinfo_handle) {
1840                 if (request->updateinfo_handle->pkgid)
1841                         free(request->updateinfo_handle->pkgid);
1842                 if (request->updateinfo_handle->version)
1843                         free(request->updateinfo_handle->version);
1844                 free(request->updateinfo_handle);
1845         }
1846         free(request);
1847
1848         return PACKAGE_MANAGER_ERROR_NONE;
1849 }
1850
1851 API  int package_manager_updateinfo_request_create(package_updateinfo_request_h *pkg_updateinfo_req)
1852 {
1853         struct package_updateinfo_request_s *request;
1854         pkg_update_info_t *update_info;
1855
1856         if (pkg_updateinfo_req == NULL)
1857                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1858
1859         request = calloc(1, sizeof(struct package_updateinfo_request_s));
1860         if (request == NULL)
1861                 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
1862
1863         request->pc = pkgmgr_client_new(PC_REQUEST);
1864         if (request->pc == NULL) {
1865                 free(request);
1866                 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
1867         }
1868
1869         update_info = calloc(1, sizeof(pkg_update_info_t));
1870         if (update_info == NULL) {
1871                 pkgmgr_client_free(request->pc);
1872                 free(request);
1873                 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
1874         }
1875         request->updateinfo_handle = update_info;
1876
1877         *pkg_updateinfo_req = request;
1878         return PACKAGE_MANAGER_ERROR_NONE;
1879 }
1880
1881 API int package_manager_updateinfo_request_register(package_updateinfo_request_h pkg_updateinfo_req)
1882 {
1883         struct package_updateinfo_request_s *update_info;
1884         int retval;
1885
1886         if (pkg_updateinfo_req == NULL)
1887                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1888         update_info = (struct package_updateinfo_request_s *)pkg_updateinfo_req;
1889
1890         retval = pkgmgr_client_register_pkg_update_info(update_info->pc, update_info->updateinfo_handle);
1891         if (retval == PKGMGR_R_EINVAL)
1892                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1893
1894         return PACKAGE_MANAGER_ERROR_NONE;
1895 }
1896
1897 API int package_manager_updateinfo_request_unregister(package_updateinfo_request_h pkg_updateinfo_req, const char *pkgid)
1898 {
1899         int retval;
1900         struct package_updateinfo_request_s *update_info;
1901
1902         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_ADMIN);
1903         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1904                 return retval;
1905
1906         if (pkg_updateinfo_req == NULL || pkgid == NULL)
1907                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1908
1909         update_info = (struct package_updateinfo_request_s *)pkg_updateinfo_req;
1910         retval = pkgmgr_client_unregister_pkg_update_info(update_info->pc, pkgid);
1911         if (retval != PMINFO_R_OK)
1912                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
1913
1914         return PACKAGE_MANAGER_ERROR_NONE;
1915 }
1916
1917 API int package_manager_updateinfo_request_unregister_all(package_updateinfo_request_h pkg_updateinfo_req)
1918 {
1919         int retval;
1920         struct package_updateinfo_request_s *update_info;
1921
1922         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_ADMIN);
1923         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1924                 return retval;
1925
1926         if (pkg_updateinfo_req == NULL)
1927                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1928
1929         update_info = (struct package_updateinfo_request_s *)pkg_updateinfo_req;
1930         retval = pkgmgr_client_unregister_all_pkg_update_info(update_info->pc);
1931
1932         if (retval != PMINFO_R_OK)
1933                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
1934
1935         return PACKAGE_MANAGER_ERROR_NONE;
1936 }