src/package_manager.c

   1 /*
   2  * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the License);
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an AS IS BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include <stdlib.h>
  18 #include <string.h>
  19 #include <glib.h>
  20 #include <unistd.h>
  21
  22 #include <package-manager.h>
  23 #include <pkgmgr_installer.h>
  24 #include <pkgmgr-info.h>
  25 #include <tzplatform_config.h>
  26
  27 #include "package_manager.h"
  28 #include "package_manager_internal.h"
  29
  30 static GHashTable *__cb_table = NULL;
  31
  32 #define GLOBAL_USER tzplatform_getuid(TZ_SYS_GLOBALAPP_USER)
  33 typedef struct _event_info {
  34         int req_id;
  35         package_manager_event_type_e event_type;
  36         package_manager_event_state_e event_state;
  37         struct _event_info *next;
  38 } event_info;
  39
  40 struct package_manager_s {
  41         int handle_id;
  42         pkgmgr_client_type ctype;
  43         pkgmgr_client *pc;
  44         pkgmgr_mode mode;
  45         event_info *head;
  46         package_manager_event_cb event_cb;
  47         void *user_data;
  48 };
  49
  50 struct package_manager_request_s {
  51         int handle_id;
  52         pkgmgr_client_type ctype;
  53         pkgmgr_client *pc;
  54         char *pkg_type;
  55         pkgmgr_mode mode;
  56         event_info *head;
  57         package_manager_request_event_cb event_cb;
  58         void *user_data;
  59 };
  60
  61 typedef struct package_size_info {
  62         long long data_size;
  63         long long cache_size;
  64         long long app_size;
  65
  66         long long external_data_size;
  67         long long external_cache_size;
  68         long long external_app_size;
  69 } package_size_info_t;
  70
  71 struct package_manager_filter_s {
  72         pkgmgrinfo_pkginfo_filter_h pkgmgrinfo_pkginfo_filter;
  73 };
  74
  75 static int package_manager_request_new_id()
  76 {
  77         static int request_handle_id = 0;
  78         return request_handle_id++;
  79 }
  80
  81 static int package_manager_new_id()
  82 {
  83         static int manager_handle_id = 0;
  84         return manager_handle_id++;
  85 }
  86
  87 API int package_manager_request_create(package_manager_request_h *request)
  88 {
  89         struct package_manager_request_s *package_manager_request;
  90
  91         if (request == NULL) {
  92                 return
  93                     package_manager_error
  94                     (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
  95                      NULL);
  96         }
  97
  98         package_manager_request =
  99             calloc(1, sizeof(struct package_manager_request_s));
 100         if (package_manager_request == NULL) {
 101                 return
 102                     package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY,
 103                                           __FUNCTION__,
 104                                           "failed to create a package_manager handle");
 105         }
 106
 107         package_manager_request->ctype = PC_REQUEST;
 108         package_manager_request->pc = pkgmgr_client_new(PC_REQUEST);
 109         if (package_manager_request->pc == NULL) {
 110                 free(package_manager_request);
 111                 return
 112                     package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY,
 113                                           __FUNCTION__,
 114                                           "failed to create a package_manager client");
 115         }
 116
 117         package_manager_request->handle_id = package_manager_request_new_id();
 118
 119         *request = package_manager_request;
 120
 121         return PACKAGE_MANAGER_ERROR_NONE;
 122 }
 123
 124 static int package_manager_client_validate_handle(package_manager_request_h
 125                                                  request)
 126 {
 127         if (request == NULL || request->pc == NULL)
 128                 return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
 129
 130         return PACKAGE_MANAGER_ERROR_NONE;
 131 }
 132
 133 API int package_manager_request_destroy(package_manager_request_h request)
 134 {
 135         if (package_manager_client_validate_handle(request)) {
 136                 return
 137                     package_manager_error
 138                     (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
 139                      NULL);
 140         }
 141
 142         pkgmgr_client_free(request->pc);
 143         request->pc = NULL;
 144         free(request->pkg_type);
 145         free(request);
 146
 147         return PACKAGE_MANAGER_ERROR_NONE;
 148 }
 149
 150 API int package_manager_request_set_event_cb(package_manager_request_h request,
 151                                          package_manager_request_event_cb
 152                                          callback, void *user_data)
 153 {
 154
 155         int retval;
 156         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
 157         if (retval != PACKAGE_MANAGER_ERROR_NONE)
 158                 return retval;
 159
 160         if (package_manager_client_validate_handle(request)) {
 161                 return
 162                     package_manager_error
 163                     (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
 164                      NULL);
 165         }
 166
 167         request->event_cb = callback;
 168         request->user_data = user_data;
 169
 170         return PACKAGE_MANAGER_ERROR_NONE;
 171 }
 172
 173 API int package_manager_request_unset_event_cb(package_manager_request_h request)
 174 {
 175         if (package_manager_client_validate_handle(request))
 176                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 177
 178         request->event_cb = NULL;
 179         request->user_data = NULL;
 180
 181         return PACKAGE_MANAGER_ERROR_NONE;
 182 }
 183
 184 API int package_manager_request_set_type(package_manager_request_h request,
 185                                      const char *pkg_type)
 186 {
 187         if (package_manager_client_validate_handle(request)) {
 188                 return
 189                     package_manager_error
 190                     (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
 191                      NULL);
 192         }
 193
 194         request->pkg_type = strdup(pkg_type);
 195
 196         return PACKAGE_MANAGER_ERROR_NONE;
 197 }
 198
 199 API int package_manager_request_set_mode(package_manager_request_h request,
 200                                      package_manager_request_mode_e mode)
 201 {
 202         if (package_manager_client_validate_handle(request)) {
 203                 return
 204                     package_manager_error
 205                     (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
 206                      NULL);
 207         }
 208
 209         /* request mode is not used anymore */
 210
 211         return PACKAGE_MANAGER_ERROR_NONE;
 212 }
 213
 214 API int package_manager_request_set_tep(package_manager_request_h request,
 215                                      const char *tep_path)
 216 {
 217         int retval = 0;
 218
 219         if (package_manager_client_validate_handle(request) || tep_path == NULL) {
 220                 return
 221                         package_manager_error
 222                         (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
 223                          NULL);
 224         }
 225
 226         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_ADMIN);
 227         if (retval != PACKAGE_MANAGER_ERROR_NONE)
 228                 return retval;
 229
 230         if (pkgmgr_client_set_tep_path(request->pc, tep_path, true))
 231                 return PACKAGE_MANAGER_ERROR_SYSTEM_ERROR;
 232
 233         return PACKAGE_MANAGER_ERROR_NONE;
 234 }
 235
 236 static int package_manager_get_event_type(const char *key,
 237                                           package_manager_event_type_e *
 238                                           event_type)
 239 {
 240         if (key == NULL)
 241                 return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
 242
 243         if (strcasecmp(key, PKGMGR_INSTALLER_INSTALL_EVENT_STR) == 0)
 244                 *event_type = PACKAGE_MANAGER_EVENT_TYPE_INSTALL;
 245         else if (strcasecmp(key, PKGMGR_INSTALLER_UNINSTALL_EVENT_STR) == 0)
 246                 *event_type = PACKAGE_MANAGER_EVENT_TYPE_UNINSTALL;
 247         else if (strcasecmp(key, PKGMGR_INSTALLER_UPGRADE_EVENT_STR) == 0)
 248                 *event_type = PACKAGE_MANAGER_EVENT_TYPE_UPDATE;
 249         else if (strcasecmp(key, PKGMGR_INSTALLER_MOVE_EVENT_STR) == 0)
 250                 *event_type = PACKAGE_MANAGER_EVENT_TYPE_MOVE;
 251         else if (strcasecmp(key, PKGMGR_INSTALLER_CLEAR_EVENT_STR) == 0)
 252                 *event_type = PACKAGE_MANAGER_EVENT_TYPE_CLEAR;
 253         else
 254                 return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
 255
 256         return PACKAGE_MANAGER_ERROR_NONE;
 257 }
 258
 259 static int __add_event_info(event_info **head, int req_id,
 260                             package_manager_event_type_e event_type,
 261                             package_manager_event_state_e event_state)
 262 {
 263         event_info *evt_info;
 264         event_info *current;
 265         event_info *prev;
 266
 267         evt_info = (event_info *) calloc(1, sizeof(event_info));
 268         if (evt_info == NULL) {
 269                 _LOGD("calloc failed");
 270                 return -1;
 271         }
 272         evt_info->req_id = req_id;
 273         evt_info->event_type = event_type;
 274         evt_info->next = NULL;
 275
 276         if (*head == NULL)
 277                 *head = evt_info;
 278         else {
 279                 current = prev = *head;
 280                 while (current) {
 281                         prev = current;
 282                         current = current->next;
 283                 }
 284
 285                 prev->next = evt_info;
 286         }
 287
 288         return 0;
 289 }
 290
 291 static int __find_event_info(event_info **head, int req_id,
 292                              package_manager_event_type_e *event_type,
 293                              package_manager_event_state_e *event_state)
 294 {
 295         event_info *tmp;
 296
 297         tmp = *head;
 298
 299         if (tmp == NULL) {
 300                 _LOGE("tmp is NULL");
 301                 return -1;
 302         }
 303
 304         _LOGD("tmp->req_id %d, event_type %d", tmp->req_id, event_type);
 305
 306         while (tmp) {
 307                 if (tmp->req_id == req_id) {
 308                         *event_type = tmp->event_type;
 309                         return 0;
 310                 }
 311                 tmp = tmp->next;
 312         }
 313         return -1;
 314 }
 315
 316 static int __update_event_info(event_info **head, int req_id,
 317                                package_manager_event_type_e event_type,
 318                                package_manager_event_state_e event_state)
 319 {
 320         package_manager_event_type_e evt_type;
 321         package_manager_event_state_e evt_state;
 322         event_info *tmp;
 323
 324         if (__find_event_info(head, req_id, &evt_type, &evt_state) != 0)
 325                 __add_event_info(head, req_id, event_type, event_state);
 326         else {
 327                 tmp = *head;
 328
 329                 if (tmp == NULL) {
 330                         _LOGE("tmp is NULL");
 331                         return -1;
 332                 }
 333
 334                 while (tmp) {
 335                         if (tmp->req_id == req_id) {
 336                                 tmp->event_type = event_type;
 337                                 return 0;
 338                         }
 339                         tmp = tmp->next;
 340                 }
 341         }
 342
 343         return -1;
 344 }
 345
 346 /*
 347 static int __remove_event_info(event_info **head request, int req_id)
 348 {
 349         event_info *current;
 350         event_info *tmp;
 351
 352         if (* == NULL)
 353                 return -1;
 354
 355         current = *head;
 356         while (current) {
 357                 if (current->next) {
 358                         if (current->next->req_id == req_id) {
 359                                 tmp = current->next;
 360                                 current->next = current->next->next;
 361                                 free(tmp);
 362                                 return 0;
 363                         }
 364                 }
 365                 tmp = tmp->next;
 366         }
 367
 368         return -1;
 369 }
 370 */
 371
 372 static int request_event_handler(uid_t target_uid, int req_id, const char *pkg_type,
 373                                  const char *pkg_name, const char *key,
 374                                  const char *val, const void *pmsg, void *data)
 375 {
 376         int ret = -1;
 377         package_manager_event_type_e event_type = -1;
 378         package_manager_event_state_e event_state = -1;
 379
 380         _LOGD("request_event_handler is called");
 381
 382         package_manager_request_h request = data;
 383
 384         if (strcasecmp(key, "start") == 0) {
 385                 ret = package_manager_get_event_type(val, &event_type);
 386                 if (ret != PACKAGE_MANAGER_ERROR_NONE)
 387                         return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
 388
 389                 __add_event_info(&(request->head), req_id, event_type,
 390                                  PACKAGE_MANAGER_EVENT_STATE_STARTED);
 391
 392                 if (request->event_cb)
 393                         request->event_cb(req_id, pkg_type, pkg_name,
 394                                           event_type,
 395                                           PACKAGE_MANAGER_EVENT_STATE_STARTED,
 396                                           0, PACKAGE_MANAGER_ERROR_NONE, request->user_data);
 397
 398         } else if (strcasecmp(key, "install_percent") == 0
 399                    || strcasecmp(key, "progress_percent") == 0) {
 400                 if (__find_event_info
 401                     (&(request->head), req_id, &event_type,
 402                      &event_state) == 0) {
 403                         __update_event_info(&(request->head), req_id,
 404                                             event_type,
 405                                             PACKAGE_MANAGER_EVENT_STATE_PROCESSING);
 406                         if (request->event_cb)
 407                                 request->event_cb(req_id, pkg_type, pkg_name,
 408                                                   event_type,
 409                                                   PACKAGE_MANAGER_EVENT_STATE_PROCESSING,
 410                                                   atoi(val),
 411                                                   PACKAGE_MANAGER_ERROR_NONE,
 412                                                   request->user_data);
 413                 }
 414
 415         } else if (strcasecmp(key, "error") == 0) {
 416                 if (strcasecmp(key, "0") != 0) {
 417                         if (__find_event_info
 418                             (&(request->head), req_id, &event_type,
 419                              &event_state) == 0) {
 420                                 __update_event_info(&(request->head), req_id,
 421                                                     event_type,
 422                                                     PACKAGE_MANAGER_EVENT_STATE_FAILED);
 423                         }
 424
 425                         if (request->event_cb)
 426                                 request->event_cb(req_id, pkg_type,
 427                                                   pkg_name, event_type,
 428                                                   PACKAGE_MANAGER_EVENT_STATE_FAILED,
 429                                                   0,
 430                                                   PACKAGE_MANAGER_ERROR_NONE,
 431                                                   request->user_data);
 432
 433                 }
 434         } else if (strcasecmp(key, "end") == 0) {
 435                 if (__find_event_info
 436                     (&(request->head), req_id, &event_type,
 437                      &event_state) == 0) {
 438                         if (event_state != PACKAGE_MANAGER_EVENT_STATE_FAILED) {
 439                                 if (request->event_cb)
 440                                         request->event_cb(req_id, pkg_type,
 441                                                           pkg_name, event_type,
 442                                                           PACKAGE_MANAGER_EVENT_STATE_COMPLETED,
 443                                                           100,
 444                                                           PACKAGE_MANAGER_ERROR_NONE,
 445                                                           request->user_data);
 446                         }
 447                 } else {
 448                         if (strcasecmp(key, "ok") != 0)
 449                                 if (request->event_cb)
 450                                         request->event_cb(req_id, pkg_type,
 451                                                           pkg_name, event_type,
 452                                                           PACKAGE_MANAGER_EVENT_STATE_FAILED,
 453                                                           0,
 454                                                           PACKAGE_MANAGER_ERROR_NONE,
 455                                                           request->user_data);
 456                 }
 457         }
 458
 459         return PACKAGE_MANAGER_ERROR_NONE;
 460 }
 461
 462 API int package_manager_request_install(package_manager_request_h request,
 463                                     const char *path, int *id)
 464 {
 465
 466         int retval;
 467         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_ADMIN);
 468         if (retval != PACKAGE_MANAGER_ERROR_NONE)
 469                 return retval;
 470
 471         if (package_manager_client_validate_handle(request))
 472                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 473
 474         if (path == NULL)
 475                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 476
 477         int request_id = 0;
 478         request_id = pkgmgr_client_install(request->pc, request->pkg_type, NULL,
 479                         path, NULL, request->mode, request_event_handler, request);
 480
 481         if (request_id == PKGMGR_R_EINVAL)
 482                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 483         else if (request_id == PKGMGR_R_ENOPKG)
 484                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
 485         else if (request_id == PKGMGR_R_ENOMEM)
 486                 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
 487         else if (request_id == PKGMGR_R_EIO)
 488                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
 489         else if (request_id == PKGMGR_R_EPRIV)
 490                 return package_manager_error(PACKAGE_MANAGER_ERROR_PERMISSION_DENIED, __FUNCTION__, NULL);
 491         else if (request_id == PKGMGR_R_ESYSTEM || request_id == PKGMGR_R_ECOMM || request_id == PKGMGR_R_ERROR)
 492                 return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
 493
 494         *id = request_id;
 495
 496         return PACKAGE_MANAGER_ERROR_NONE;
 497 }
 498
 499 API int package_manager_request_uninstall(package_manager_request_h request,
 500                                       const char *name, int *id)
 501 {
 502
 503         int retval;
 504         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_ADMIN);
 505         if (retval != PACKAGE_MANAGER_ERROR_NONE)
 506                 return retval;
 507
 508         if (package_manager_client_validate_handle(request))
 509                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 510
 511         if (name == NULL)
 512                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 513
 514         int request_id = 0;
 515         request_id = pkgmgr_client_uninstall(request->pc, request->pkg_type,
 516                         name, request->mode, request_event_handler, request);
 517
 518         if (request_id == PKGMGR_R_EINVAL)
 519                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 520         else if (request_id == PKGMGR_R_ENOPKG)
 521                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
 522         else if (request_id == PKGMGR_R_ENOMEM)
 523                 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
 524         else if (request_id == PKGMGR_R_EIO)
 525                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
 526         else if (request_id == PKGMGR_R_EPRIV)
 527                 return package_manager_error(PACKAGE_MANAGER_ERROR_PERMISSION_DENIED, __FUNCTION__, NULL);
 528         else if (request_id == PKGMGR_R_ESYSTEM || request_id == PKGMGR_R_ECOMM || request_id == PKGMGR_R_ERROR)
 529                 return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
 530
 531         *id = request_id;
 532
 533         return PACKAGE_MANAGER_ERROR_NONE;
 534 }
 535
 536 API int package_manager_request_move(package_manager_request_h request,
 537                                     const char *name, package_manager_move_type_e move_type)
 538 {
 539
 540         int retval;
 541         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_ADMIN);
 542         if (retval != PACKAGE_MANAGER_ERROR_NONE)
 543                 return retval;
 544
 545         if (package_manager_client_validate_handle(request))
 546                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 547
 548         if (name == NULL)
 549                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 550
 551         int ret = 0;
 552         ret = pkgmgr_client_request_service(PM_REQUEST_MOVE, move_type,
 553                         request->pc, request->pkg_type, name,
 554                         NULL, request_event_handler, request);
 555
 556         if (ret == PKGMGR_R_EINVAL)
 557                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 558         else if (ret == PKGMGR_R_ENOPKG)
 559                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
 560         else if (ret == PKGMGR_R_ENOMEM)
 561                 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
 562         else if (ret == PKGMGR_R_EIO)
 563                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
 564         else if (ret == PKGMGR_R_EPRIV)
 565                 return package_manager_error(PACKAGE_MANAGER_ERROR_PERMISSION_DENIED, __FUNCTION__, NULL);
 566         else if (ret == PKGMGR_R_ESYSTEM || ret == PKGMGR_R_ECOMM || ret == PKGMGR_R_ERROR)
 567                 return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
 568
 569         return PACKAGE_MANAGER_ERROR_NONE;
 570 }
 571
 572 API int package_manager_create(package_manager_h *manager)
 573 {
 574
 575         int retval;
 576         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
 577         if (retval != PACKAGE_MANAGER_ERROR_NONE)
 578                 return retval;
 579
 580         struct package_manager_s *package_manager = NULL;
 581
 582         if (manager == NULL) {
 583                 return
 584                     package_manager_error
 585                     (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
 586                      NULL);
 587         }
 588
 589         package_manager = calloc(1, sizeof(struct package_manager_s));
 590         if (package_manager == NULL) {
 591                 return
 592                     package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY,
 593                                           __FUNCTION__,
 594                                           "failed to create a package_manager handle");
 595         }
 596
 597         package_manager->ctype = PC_LISTENING;
 598         package_manager->pc = pkgmgr_client_new(PC_LISTENING);
 599         if (package_manager->pc == NULL) {
 600                 free(package_manager);
 601                 return
 602                     package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY,
 603                                           __FUNCTION__,
 604                                           "failed to create a package_manager client");
 605         }
 606
 607         package_manager->handle_id = package_manager_new_id();
 608
 609         *manager = package_manager;
 610
 611         return PACKAGE_MANAGER_ERROR_NONE;
 612 }
 613
 614 static int package_manager_validate_handle(package_manager_h manager)
 615 {
 616         if (manager == NULL || manager->pc == NULL)
 617                 return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
 618
 619         return PACKAGE_MANAGER_ERROR_NONE;
 620 }
 621
 622 API int package_manager_destroy(package_manager_h manager)
 623 {
 624         if (package_manager_validate_handle(manager)) {
 625                 return
 626                     package_manager_error
 627                     (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
 628                      NULL);
 629         }
 630
 631         pkgmgr_client_free(manager->pc);
 632         manager->pc = NULL;
 633         free(manager);
 634
 635         return PACKAGE_MANAGER_ERROR_NONE;
 636 }
 637
 638 static int __add_event(event_info **head, int req_id,
 639                             package_manager_event_type_e event_type,
 640                             package_manager_event_state_e event_state)
 641 {
 642         event_info *evt_info;
 643
 644         evt_info = (event_info *) calloc(1, sizeof(event_info));
 645         if (evt_info == NULL) {
 646                 _LOGD("calloc failed");
 647                 return -1;
 648         }
 649         evt_info->req_id = req_id;
 650         evt_info->event_type = event_type;
 651         evt_info->event_state = event_state;
 652         evt_info->next = NULL;
 653
 654         *head = evt_info;
 655
 656         return 0;
 657 }
 658
 659 static int __find_event(event_info **head, int req_id,
 660                              package_manager_event_type_e *event_type,
 661                              package_manager_event_state_e *event_state)
 662 {
 663         event_info *tmp;
 664
 665         tmp = *head;
 666
 667         if (tmp == NULL) {
 668                 _LOGE("tmp is NULL");
 669                 return -1;
 670         }
 671
 672         *event_type = tmp->event_type;
 673         *event_state = tmp->event_state;
 674         return 0;
 675 }
 676
 677 static int __update_event(event_info **head, int req_id,
 678                                package_manager_event_type_e event_type,
 679                                package_manager_event_state_e event_state)
 680 {
 681         package_manager_event_type_e evt_type;
 682         package_manager_event_state_e evt_state;
 683         event_info *tmp;
 684
 685         if (__find_event_info(head, req_id, &evt_type, &evt_state) != 0)
 686                 __add_event_info(head, req_id, event_type, event_state);
 687         else {
 688                 tmp = *head;
 689
 690                 if (tmp == NULL) {
 691                         _LOGE("tmp is NULL");
 692                         return -1;
 693                 }
 694
 695                 tmp->event_type = event_type;
 696                 tmp->event_state = event_state;
 697                 return 0;
 698         }
 699
 700         return -1;
 701 }
 702
 703 /* App Event Listening Policy:
 704  * +----------------+------------+---------------+------------------+
 705  * |Listener \ Type |Global Event|My User's Event|Other user's Event|
 706  * +----------------+------------+---------------+------------------+
 707  * |User Process App|   Grant    |     Grant     |      Deny        |
 708  * +----------------+------------+---------------+------------------+
 709  * |Platform module |   Grant    |     Grant     |      Grant       |
 710  * +----------------+------------+---------------+------------------+
 711  * UID assignment policy:
 712  * https://wiki.tizen.org/wiki/Security/User_and_group_ID_assignment_policy
 713  */
 714 #define REGULAR_USER 5000
 715 static int __validate_event_signal(uid_t target_uid)
 716 {
 717         uid_t self = getuid();
 718
 719         if (self == target_uid)
 720                 return 0;
 721
 722         if (self < REGULAR_USER)
 723                 return 0;
 724
 725         return -1;
 726 }
 727
 728 static int global_event_handler(uid_t target_uid, int req_id, const char *pkg_type,
 729                                 const char *pkg_name, const char *key,
 730                                 const char *val, const void *pmsg, void *data)
 731 {
 732         int ret = -1;
 733         package_manager_event_type_e event_type = -1;
 734         package_manager_event_state_e event_state = -1;
 735         uid_t uid = target_uid;
 736
 737         _LOGD("global_event_handler is called");
 738
 739         package_manager_h manager = data;
 740
 741         if (target_uid == GLOBAL_USER)
 742                 uid = getuid();
 743
 744         if (__validate_event_signal(uid))
 745                 return PACKAGE_MANAGER_ERROR_NONE;
 746
 747         if (strcasecmp(key, "start") == 0) {
 748                 ret = package_manager_get_event_type(val, &event_type);
 749                 if (ret != PACKAGE_MANAGER_ERROR_NONE)
 750                         return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
 751
 752                 __add_event(&(manager->head), req_id, event_type,
 753                                  PACKAGE_MANAGER_EVENT_STATE_STARTED);
 754
 755                 if (manager->event_cb && getuid() == uid)
 756                         manager->event_cb(pkg_type, pkg_name,
 757                                           event_type,
 758                                           PACKAGE_MANAGER_EVENT_STATE_STARTED,
 759                                           0, PACKAGE_MANAGER_ERROR_NONE, manager->user_data);
 760         } else if (strcasecmp(key, "install_percent") == 0
 761                    || strcasecmp(key, "progress_percent") == 0) {
 762                 if (__find_event
 763                     (&(manager->head), req_id, &event_type,
 764                      &event_state) == 0) {
 765                         __update_event(&(manager->head), req_id,
 766                                             event_type,
 767                                             PACKAGE_MANAGER_EVENT_STATE_PROCESSING);
 768                         if (manager->event_cb && getuid() == uid)
 769                                 manager->event_cb(pkg_type, pkg_name,
 770                                                   event_type,
 771                                                   PACKAGE_MANAGER_EVENT_STATE_PROCESSING,
 772                                                   atoi(val),
 773                                                   PACKAGE_MANAGER_ERROR_NONE,
 774                                                   manager->user_data);
 775                 }
 776
 777         } else if (strcasecmp(key, "error") == 0) {
 778                 if (strcasecmp(key, "0") != 0) {
 779                         if (__find_event
 780                             (&(manager->head), req_id, &event_type,
 781                              &event_state) == 0) {
 782                                 __update_event(&(manager->head), req_id,
 783                                                     event_type,
 784                                                     PACKAGE_MANAGER_EVENT_STATE_FAILED);
 785                         }
 786
 787                         if (manager->event_cb && getuid() == uid)
 788                                 manager->event_cb(pkg_type,
 789                                                   pkg_name, event_type,
 790                                                   PACKAGE_MANAGER_EVENT_STATE_FAILED,
 791                                                   0,
 792                                                   PACKAGE_MANAGER_ERROR_NONE,
 793                                                   manager->user_data);
 794                 }
 795         } else if (strcasecmp(key, "end") == 0) {
 796                 if (__find_event
 797                     (&(manager->head), req_id, &event_type,
 798                      &event_state) == 0) {
 799                         if (event_state != PACKAGE_MANAGER_EVENT_STATE_FAILED) {
 800                                 if (manager->event_cb && getuid() == uid)
 801                                         manager->event_cb(pkg_type,
 802                                                           pkg_name, event_type,
 803                                                           PACKAGE_MANAGER_EVENT_STATE_COMPLETED,
 804                                                           100,
 805                                                           PACKAGE_MANAGER_ERROR_NONE,
 806                                                           manager->user_data);
 807                         }
 808                 } else {
 809                         if (strcasecmp(key, "ok") != 0) {
 810                                 if (manager->event_cb && getuid() == uid)
 811                                         manager->event_cb(pkg_type,
 812                                                           pkg_name, event_type,
 813                                                           PACKAGE_MANAGER_EVENT_STATE_FAILED,
 814                                                           0,
 815                                                           PACKAGE_MANAGER_ERROR_NONE,
 816                                                           manager->user_data);
 817                         }
 818                 }
 819         }
 820
 821         return PACKAGE_MANAGER_ERROR_NONE;
 822 }
 823
 824 static int __convert_status_type(package_manager_status_type_e type)
 825 {
 826         switch (type) {
 827         case PACKAGE_MANAGER_STATUS_TYPE_ALL:
 828                 return PKGMGR_CLIENT_STATUS_ALL;
 829         case PACKAGE_MANAGER_STATUS_TYPE_INSTALL:
 830                 return PKGMGR_CLIENT_STATUS_INSTALL;
 831         case PACKAGE_MANAGER_STATUS_TYPE_UNINSTALL:
 832                 return PKGMGR_CLIENT_STATUS_UNINSTALL;
 833         case PACKAGE_MANAGER_STATUS_TYPE_UPGRADE:
 834                 return PKGMGR_CLIENT_STATUS_UPGRADE;
 835         case PACKAGE_MANAGER_STATUS_TYPE_MOVE:
 836                 return PKGMGR_CLIENT_STATUS_MOVE;
 837         case PACKAGE_MANAGER_STATUS_TYPE_CLEAR_DATA:
 838                 return PKGMGR_CLIENT_STATUS_CLEAR_DATA;
 839         case PACKAGE_MANAGER_STATUS_TYPE_INSTALL_PROGRESS:
 840                 return PKGMGR_CLIENT_STATUS_INSTALL_PROGRESS;
 841         case PACKAGE_MANAGER_STATUS_TYPE_GET_SIZE:
 842                 return PKGMGR_CLIENT_STATUS_GET_SIZE;
 843         default:
 844                 return -1;
 845         }
 846 }
 847
 848 API int package_manager_set_event_status(package_manager_h manager, int status_type)
 849 {
 850         int retval;
 851         int type;
 852
 853         if (manager == NULL)
 854                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 855
 856         type = __convert_status_type(status_type);
 857         if (type == -1)
 858                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 859
 860         retval = pkgmgr_client_set_status_type(manager->pc, type);
 861
 862         if (retval < 0)
 863                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
 864
 865         return PACKAGE_MANAGER_ERROR_NONE;
 866 }
 867
 868 API int package_manager_set_event_cb(package_manager_h manager,
 869                                  package_manager_event_cb callback,
 870                                  void *user_data)
 871 {
 872
 873         int retval;
 874         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
 875         if (retval != PACKAGE_MANAGER_ERROR_NONE)
 876                 return retval;
 877
 878         if (package_manager_validate_handle(manager)) {
 879                 return
 880                     package_manager_error
 881                     (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
 882                      NULL);
 883         }
 884
 885         manager->event_cb = callback;
 886         manager->user_data = user_data;
 887
 888         pkgmgr_client_listen_status(manager->pc, global_event_handler, manager);
 889
 890         return PACKAGE_MANAGER_ERROR_NONE;
 891 }
 892
 893 API int package_manager_unset_event_cb(package_manager_h manager)
 894 {
 895         if (manager == NULL) {
 896                 return
 897                     package_manager_error
 898                     (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
 899                      NULL);
 900         }
 901
 902         int retval;
 903         manager->event_cb = NULL;
 904         manager->user_data = NULL;
 905
 906         retval = pkgmgr_client_remove_listen_status(manager->pc);
 907         if (retval == PKGMGR_R_EINVAL)
 908                 return
 909                          package_manager_error
 910                          (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
 911                           NULL);
 912         else if (retval == PKGMGR_R_ERROR)
 913                 return
 914                          package_manager_error
 915                          (PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__,
 916                           NULL);
 917
 918         return PACKAGE_MANAGER_ERROR_NONE;
 919 }
 920
 921 API int package_manager_get_package_id_by_app_id(const char *app_id, char **package_id)
 922 {
 923         pkgmgrinfo_appinfo_h pkgmgrinfo_appinfo;
 924         int retval;
 925         char *pkg_id = NULL;
 926         char *pkg_id_dup = NULL;
 927
 928         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
 929         if (retval != PACKAGE_MANAGER_ERROR_NONE)
 930                 return retval;
 931
 932         if (app_id == NULL || package_id == NULL)
 933                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 934
 935         if (pkgmgrinfo_appinfo_get_appinfo(app_id, &pkgmgrinfo_appinfo) != PMINFO_R_OK)
 936                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
 937         retval = pkgmgrinfo_appinfo_get_pkgname(pkgmgrinfo_appinfo, &pkg_id);
 938         if (retval != PMINFO_R_OK)
 939                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
 940
 941         pkg_id_dup = strdup(pkg_id);
 942         if (pkg_id_dup == NULL) {
 943                 pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
 944                 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
 945         }
 946
 947         *package_id = pkg_id_dup;
 948
 949         pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
 950
 951         return PACKAGE_MANAGER_ERROR_NONE;
 952 }
 953
 954 API int package_manager_get_package_info(const char *package_id, package_info_h *package_info)
 955 {
 956         int retval;
 957         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
 958         if (retval != PACKAGE_MANAGER_ERROR_NONE)
 959                 return retval;
 960
 961         retval = package_info_get_package_info(package_id, package_info);
 962
 963         if (retval != PACKAGE_MANAGER_ERROR_NONE)
 964                 return package_manager_error(retval, __FUNCTION__, NULL);
 965         else
 966                 return PACKAGE_MANAGER_ERROR_NONE;
 967 }
 968
 969 API int package_manager_foreach_package_info(package_manager_package_info_cb callback,
 970                                         void *user_data)
 971 {
 972
 973         int retval;
 974         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
 975         if (retval != PACKAGE_MANAGER_ERROR_NONE)
 976                 return retval;
 977
 978         retval = package_info_foreach_package_info(callback, user_data);
 979
 980         if (retval != PACKAGE_MANAGER_ERROR_NONE)
 981                 return package_manager_error(retval, __FUNCTION__, NULL);
 982         else
 983                 return PACKAGE_MANAGER_ERROR_NONE;
 984 }
 985
 986 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)
 987 {
 988         pkgmgrinfo_cert_compare_result_type_e result;
 989
 990         if (lhs_package_id == NULL || rhs_package_id == NULL || compare_result == NULL)
 991                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 992         if (pkgmgrinfo_pkginfo_compare_pkg_cert_info(lhs_package_id, rhs_package_id, &result) != PKGMGR_R_OK)
 993                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
 994         *compare_result = (package_manager_compare_result_type_e)result;
 995
 996         return PACKAGE_MANAGER_ERROR_NONE;
 997 }
 998
 999 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)
1000 {
1001         pkgmgrinfo_cert_compare_result_type_e result;
1002
1003         if (lhs_app_id == NULL || rhs_app_id == NULL || compare_result == NULL)
1004                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1005         if (pkgmgrinfo_pkginfo_compare_app_cert_info(lhs_app_id, rhs_app_id, &result) != PKGMGR_R_OK)
1006                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
1007
1008         *compare_result = (package_manager_compare_result_type_e)result;
1009
1010         return PACKAGE_MANAGER_ERROR_NONE;
1011 }
1012
1013 API int package_manager_is_preload_package_by_app_id(const char *app_id, bool *preload)
1014 {
1015
1016         int retval;
1017         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
1018         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1019                 return retval;
1020
1021         pkgmgrinfo_appinfo_h pkgmgrinfo_appinfo = NULL;
1022         pkgmgrinfo_pkginfo_h pkgmgrinfo_pkginfo = NULL;
1023
1024         char *pkg_id = NULL;
1025         bool is_preload = 0;
1026         if (pkgmgrinfo_appinfo_get_appinfo(app_id, &pkgmgrinfo_appinfo) != PMINFO_R_OK)
1027                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1028
1029         retval = pkgmgrinfo_appinfo_get_pkgname(pkgmgrinfo_appinfo, &pkg_id);
1030         if (retval != PMINFO_R_OK) {
1031                 pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
1032                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1033         }
1034         if (pkgmgrinfo_pkginfo_get_pkginfo(pkg_id, &pkgmgrinfo_pkginfo) != PMINFO_R_OK) {
1035                 pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
1036                 pkgmgrinfo_pkginfo_destroy_pkginfo(pkgmgrinfo_pkginfo);
1037                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1038         }
1039         if (pkgmgrinfo_pkginfo_is_preload(pkgmgrinfo_pkginfo, &is_preload) != PMINFO_R_OK) {
1040                 pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
1041                 pkgmgrinfo_pkginfo_destroy_pkginfo(pkgmgrinfo_pkginfo);
1042                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1043         }
1044
1045         if (is_preload)
1046                 *preload = 1;
1047         else
1048                 *preload = 0;
1049
1050         pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
1051         pkgmgrinfo_pkginfo_destroy_pkginfo(pkgmgrinfo_pkginfo);
1052
1053         return PACKAGE_MANAGER_ERROR_NONE;
1054 }
1055
1056 API int package_manager_get_permission_type(const char *app_id, package_manager_permission_type_e *permission_type)
1057 {
1058
1059         int retval;
1060         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
1061         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1062                 return retval;
1063
1064         pkgmgrinfo_appinfo_h pkgmgrinfo_appinfo = NULL;
1065         pkgmgrinfo_permission_type permission = 0;
1066         if (pkgmgrinfo_appinfo_get_appinfo(app_id, &pkgmgrinfo_appinfo) != PMINFO_R_OK)
1067                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1068         retval = pkgmgrinfo_appinfo_get_permission_type(pkgmgrinfo_appinfo, &permission);
1069         if (retval != PMINFO_R_OK)
1070                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1071
1072         if (permission == PMINFO_PERMISSION_NORMAL)
1073                 *permission_type = PACKAGE_MANAGER_PERMISSION_NORMAL;
1074         else if (permission == PMINFO_PERMISSION_SIGNATURE)
1075                 *permission_type = PACKAGE_MANAGER_PERMISSION_SIGNATURE;
1076         else if (permission == PMINFO_PERMISSION_PRIVILEGE)
1077                 *permission_type = PACKAGE_MANAGER_PERMISSION_PRIVILEGE;
1078         else
1079                 *permission_type = PACKAGE_MANAGER_PERMISSION_NORMAL;
1080
1081         pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
1082         return PACKAGE_MANAGER_ERROR_NONE;
1083 }
1084
1085 API int package_manager_clear_cache_dir(const char *package_id)
1086 {
1087
1088         int retval;
1089         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_CACHE);
1090         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1091                 return retval;
1092
1093         int res = pkgmgr_client_clear_cache_dir(package_id);
1094         if (res == PKGMGR_R_EINVAL) {
1095                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1096         } else if (res == PKGMGR_R_ENOPKG) {
1097                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1098         } else if (res == PKGMGR_R_ENOMEM) {
1099                 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
1100         } else if (res == PKGMGR_R_EIO) {
1101                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
1102         } else if (res == PKGMGR_R_EPRIV) {
1103                 return package_manager_error(PACKAGE_MANAGER_ERROR_PERMISSION_DENIED, __FUNCTION__, NULL);
1104         } else if (res == PKGMGR_R_ESYSTEM || res == PKGMGR_R_ECOMM || res == PKGMGR_R_ERROR) {
1105                 return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
1106         } else if (res != PKGMGR_R_OK) {
1107                 _LOGE("Unexpected error");
1108                 return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
1109         }
1110
1111         return PACKAGE_MANAGER_ERROR_NONE;
1112 }
1113
1114 API int package_manager_clear_data(const char *package_id)
1115 {
1116         int retval;
1117         pkgmgr_client *pc = NULL;
1118         char *pkg_type = NULL;
1119         pkgmgrinfo_pkginfo_h pkginfo = NULL;
1120
1121         if (package_id == NULL)
1122                 return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
1123
1124         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_ADMIN);
1125         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1126                 return retval;
1127
1128         retval = pkgmgrinfo_pkginfo_get_pkginfo(package_id, &pkginfo);
1129         if (retval == PMINFO_R_ENOENT)
1130                 return PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE;
1131         else if (retval != PMINFO_R_OK || pkginfo == NULL)
1132                 return PACKAGE_MANAGER_ERROR_SYSTEM_ERROR;
1133
1134         retval = pkgmgrinfo_pkginfo_get_type(pkginfo, &pkg_type);
1135         if (retval != PMINFO_R_OK || pkg_type == NULL) {
1136                 pkgmgrinfo_pkginfo_destroy_pkginfo(pkginfo);
1137                 return PACKAGE_MANAGER_ERROR_SYSTEM_ERROR;
1138         }
1139
1140         pc = pkgmgr_client_new(PC_REQUEST);
1141         if (pc == NULL) {
1142                 _LOGE("Out of memory");
1143                 pkgmgrinfo_pkginfo_destroy_pkginfo(pkginfo);
1144                 return PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY;
1145         }
1146
1147         retval = pkgmgr_client_clear_user_data(pc, pkg_type, package_id, PM_QUIET);
1148         pkgmgr_client_free(pc);
1149         pkgmgrinfo_pkginfo_destroy_pkginfo(pkginfo);
1150
1151         if (retval != PKGMGR_R_OK)
1152                 return PACKAGE_MANAGER_ERROR_IO_ERROR;
1153
1154         return PACKAGE_MANAGER_ERROR_NONE;
1155 }
1156
1157 API int package_manager_clear_all_cache_dir(void)
1158 {
1159
1160         int retval;
1161         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_ADMIN);
1162         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1163                 return retval;
1164
1165         return package_manager_clear_cache_dir(PKG_CLEAR_ALL_CACHE);
1166 }
1167
1168 static void __free_client(gpointer data)
1169 {
1170         pkgmgr_client *pc = (pkgmgr_client *)data;
1171         pkgmgr_client_free(pc);
1172 }
1173
1174 static void __initialize_cb_table(void)
1175 {
1176         __cb_table = g_hash_table_new_full(g_direct_hash, g_direct_equal, __free_client, NULL);
1177 }
1178
1179 static void __result_cb(pkgmgr_client *pc, const char *pkgid, const pkg_size_info_t *result, void *user_data)
1180 {
1181         package_manager_size_info_receive_cb callback = g_hash_table_lookup(__cb_table, pc);
1182         if (callback == NULL) {
1183                 _LOGE("callback is null.");
1184                 g_hash_table_remove(__cb_table, pc);
1185                 return;
1186         }
1187
1188         package_size_info_t size_info;
1189         size_info.data_size  = result->data_size;
1190         size_info.cache_size = result->cache_size;
1191         size_info.app_size   = result->app_size;
1192         size_info.external_data_size  = result->ext_data_size;
1193         size_info.external_cache_size = result->ext_cache_size;
1194         size_info.external_app_size   = result->ext_app_size;
1195
1196         callback(pkgid, (package_size_info_h)&size_info, user_data);
1197
1198         g_hash_table_remove(__cb_table, pc);
1199 }
1200
1201 static void __total_result_cb(pkgmgr_client *pc, const pkg_size_info_t *result, void *user_data)
1202 {
1203         package_manager_total_size_info_receive_cb callback = g_hash_table_lookup(__cb_table, pc);
1204         if (callback == NULL) {
1205                 _LOGE("callback is null.");
1206                 g_hash_table_remove(__cb_table, pc);
1207                 return;
1208         }
1209
1210         package_size_info_t size_info;
1211         size_info.data_size  = result->data_size;
1212         size_info.cache_size = result->cache_size;
1213         size_info.app_size   = result->app_size;
1214         size_info.external_data_size  = result->ext_data_size;
1215         size_info.external_cache_size = result->ext_cache_size;
1216         size_info.external_app_size   = result->ext_app_size;
1217
1218         callback((package_size_info_h)&size_info, user_data);
1219
1220         g_hash_table_remove(__cb_table, pc);
1221 }
1222
1223 static int _get_pkg_size_info(const char *package_id, void *callback, void *user_data)
1224 {
1225         if (package_id == NULL || callback == NULL)
1226                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1227
1228         if (__cb_table == NULL)
1229                 __initialize_cb_table();
1230
1231         pkgmgr_client *pc = pkgmgr_client_new(PC_REQUEST);
1232         if (pc == NULL)
1233                 return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
1234
1235         int res = 0;
1236         if (strcmp(package_id, PKG_SIZE_INFO_TOTAL) != 0)
1237                 res = pkgmgr_client_get_package_size_info(pc, package_id, __result_cb, user_data);
1238         else
1239                 res = pkgmgr_client_get_total_package_size_info(pc, __total_result_cb, user_data);
1240
1241         if (res == PKGMGR_R_EINVAL) {
1242                 pkgmgr_client_free(pc);
1243                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1244         } else if (res == PKGMGR_R_ENOPKG) {
1245                 pkgmgr_client_free(pc);
1246                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1247         } else if (res == PKGMGR_R_ENOMEM) {
1248                 pkgmgr_client_free(pc);
1249                 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
1250         } else if (res == PKGMGR_R_EIO) {
1251                 pkgmgr_client_free(pc);
1252                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
1253         } else if (res == PKGMGR_R_EPRIV) {
1254                 pkgmgr_client_free(pc);
1255                 return package_manager_error(PACKAGE_MANAGER_ERROR_PERMISSION_DENIED, __FUNCTION__, NULL);
1256         } else if (res == PKGMGR_R_ESYSTEM || res == PKGMGR_R_ECOMM || res == PKGMGR_R_ERROR) {
1257                 pkgmgr_client_free(pc);
1258                 return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
1259         } else if (res != PKGMGR_R_OK) {
1260                 _LOGE("Unexpected error");
1261                 pkgmgr_client_free(pc);
1262                 return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
1263         }
1264
1265         g_hash_table_insert(__cb_table, pc, callback);
1266
1267         _LOGD("Successful");
1268         return PACKAGE_MANAGER_ERROR_NONE;
1269 }
1270
1271 API int package_manager_get_package_size_info(const char *package_id, package_manager_size_info_receive_cb callback, void *user_data)
1272 {
1273         return _get_pkg_size_info(package_id, (void *)callback, user_data);
1274 }
1275
1276 API int package_manager_get_total_package_size_info(package_manager_total_size_info_receive_cb callback, void *user_data)
1277 {
1278         return _get_pkg_size_info(PKG_SIZE_INFO_TOTAL, (void *)callback, user_data);
1279 }
1280
1281 API int package_manager_filter_create(package_manager_filter_h *handle)
1282 {
1283         int retval;
1284         pkgmgrinfo_pkginfo_filter_h pkgmgr_filter = NULL;
1285
1286         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
1287         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1288                 return retval;
1289
1290         if (handle == NULL) {
1291                 return
1292                     package_manager_error
1293                     (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
1294                      NULL);
1295         }
1296
1297         retval = pkgmgrinfo_pkginfo_filter_create(&pkgmgr_filter);
1298         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1299                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
1300
1301         *handle = pkgmgr_filter;
1302
1303         return PACKAGE_MANAGER_ERROR_NONE;
1304 }
1305
1306 API int package_manager_filter_destroy(package_manager_filter_h handle)
1307 {
1308         int retval;
1309
1310         if (handle == NULL) {
1311                 return
1312                     package_manager_error
1313                     (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
1314                      NULL);
1315         }
1316
1317         retval = pkgmgrinfo_pkginfo_filter_destroy(handle);
1318         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1319                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
1320
1321         return PACKAGE_MANAGER_ERROR_NONE;
1322 }
1323
1324 API int package_manager_filter_add_bool(package_manager_filter_h handle,
1325                 const char *property, const bool value)
1326 {
1327         int retval;
1328
1329         if ((handle == NULL) || (property == NULL)) {
1330                 return
1331                     package_manager_error
1332                     (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
1333                      NULL);
1334         }
1335
1336         retval = pkgmgrinfo_pkginfo_filter_add_bool(handle, property, value);
1337         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1338                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
1339
1340         return PACKAGE_MANAGER_ERROR_NONE;
1341 }
1342
1343 API int package_manager_filter_count(package_manager_filter_h handle, int *count)
1344 {
1345
1346         int retval;
1347         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
1348         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1349                 return retval;
1350
1351         if ((handle == NULL) || (count == NULL))
1352                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1353
1354         retval = pkgmgrinfo_pkginfo_filter_count(handle, count);
1355         if (retval < 0)
1356                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
1357
1358         return PACKAGE_MANAGER_ERROR_NONE;
1359 }
1360
1361 API int package_manager_filter_foreach_package_info(package_manager_filter_h handle,
1362                 package_manager_package_info_cb callback, void *user_data)
1363 {
1364
1365         int retval;
1366         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
1367         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1368                 return retval;
1369
1370         retval = package_info_filter_foreach_package_info(handle, callback, user_data);
1371
1372         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1373                 return package_manager_error(retval, __FUNCTION__, NULL);
1374         else
1375                 return PACKAGE_MANAGER_ERROR_NONE;
1376 }
1377
1378 API int package_size_info_get_data_size(package_size_info_h handle, long long *data_size)
1379 {
1380         if (handle == NULL)
1381                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1382
1383         package_size_info_t *size_info = (package_size_info_t *)handle;
1384
1385         *data_size = (long long)size_info->data_size;
1386         return PACKAGE_MANAGER_ERROR_NONE;
1387 }
1388
1389 API int package_size_info_get_cache_size(package_size_info_h handle, long long *cache_size)
1390 {
1391         if (handle == NULL)
1392                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1393
1394         package_size_info_t *size_info = (package_size_info_t *)handle;
1395
1396         *cache_size = size_info->cache_size;
1397         return PACKAGE_MANAGER_ERROR_NONE;
1398 }
1399
1400 API int package_size_info_get_app_size(package_size_info_h handle, long long *app_size)
1401 {
1402         if (handle == NULL)
1403                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1404
1405         package_size_info_t *size_info = (package_size_info_t *)handle;
1406         *app_size = size_info->app_size;
1407         return PACKAGE_MANAGER_ERROR_NONE;
1408 }
1409
1410 API int package_size_info_get_external_data_size(package_size_info_h handle, long long *ext_data_size)
1411 {
1412         if (handle == NULL)
1413                 return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
1414
1415         package_size_info_t *size_info = (package_size_info_t *)handle;
1416         *ext_data_size = size_info->external_data_size;
1417         return PACKAGE_MANAGER_ERROR_NONE;
1418 }
1419
1420 API int package_size_info_get_external_cache_size(package_size_info_h handle, long long *ext_cache_size)
1421 {
1422         if (handle == NULL)
1423                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1424
1425         package_size_info_t *size_info = (package_size_info_t *)handle;
1426         *ext_cache_size = size_info->external_cache_size;
1427         return PACKAGE_MANAGER_ERROR_NONE;
1428 }
1429
1430 API int package_size_info_get_external_app_size(package_size_info_h handle, long long *ext_app_size)
1431 {
1432         if (handle == NULL)
1433                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1434
1435         package_size_info_t *size_info = (package_size_info_t *)handle;
1436         *ext_app_size = size_info->external_app_size;
1437         return PACKAGE_MANAGER_ERROR_NONE;
1438 }