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