src/package_manager.c

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