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