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