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