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