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 API int package_manager_set_event_status(package_manager_h manager, int status_type)
 825 {
 826         int retval;
 827
 828         if (manager == NULL)
 829                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 830
 831         retval = pkgmgr_client_set_status_type(manager->pc, status_type);
 832
 833         if (retval < 0)
 834                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
 835
 836         return PACKAGE_MANAGER_ERROR_NONE;
 837 }
 838
 839 API int package_manager_set_event_cb(package_manager_h manager,
 840                                  package_manager_event_cb callback,
 841                                  void *user_data)
 842 {
 843
 844         int retval;
 845         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
 846         if (retval != PACKAGE_MANAGER_ERROR_NONE)
 847                 return retval;
 848
 849         if (package_manager_validate_handle(manager)) {
 850                 return
 851                     package_manager_error
 852                     (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
 853                      NULL);
 854         }
 855
 856         manager->event_cb = callback;
 857         manager->user_data = user_data;
 858
 859         pkgmgr_client_listen_status(manager->pc, global_event_handler, manager);
 860
 861         return PACKAGE_MANAGER_ERROR_NONE;
 862 }
 863
 864 API int package_manager_unset_event_cb(package_manager_h manager)
 865 {
 866         if (manager == NULL) {
 867                 return
 868                     package_manager_error
 869                     (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
 870                      NULL);
 871         }
 872
 873         int retval;
 874         manager->event_cb = NULL;
 875         manager->user_data = NULL;
 876
 877         retval = pkgmgr_client_remove_listen_status(manager->pc);
 878         if (retval == PKGMGR_R_EINVAL)
 879                 return
 880                          package_manager_error
 881                          (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
 882                           NULL);
 883         else if (retval == PKGMGR_R_ERROR)
 884                 return
 885                          package_manager_error
 886                          (PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__,
 887                           NULL);
 888
 889         return PACKAGE_MANAGER_ERROR_NONE;
 890 }
 891
 892 API int package_manager_get_package_id_by_app_id(const char *app_id, char **package_id)
 893 {
 894         pkgmgrinfo_appinfo_h pkgmgrinfo_appinfo;
 895         int retval;
 896         char *pkg_id = NULL;
 897         char *pkg_id_dup = NULL;
 898
 899         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
 900         if (retval != PACKAGE_MANAGER_ERROR_NONE)
 901                 return retval;
 902
 903         if (app_id == NULL || package_id == NULL)
 904                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 905
 906         if (pkgmgrinfo_appinfo_get_appinfo(app_id, &pkgmgrinfo_appinfo) != PMINFO_R_OK)
 907                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
 908         retval = pkgmgrinfo_appinfo_get_pkgname(pkgmgrinfo_appinfo, &pkg_id);
 909         if (retval != PMINFO_R_OK)
 910                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
 911
 912         pkg_id_dup = strdup(pkg_id);
 913         if (pkg_id_dup == NULL) {
 914                 pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
 915                 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
 916         }
 917
 918         *package_id = pkg_id_dup;
 919
 920         pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
 921
 922         return PACKAGE_MANAGER_ERROR_NONE;
 923 }
 924
 925 API int package_manager_get_package_info(const char *package_id, package_info_h *package_info)
 926 {
 927         int retval;
 928         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
 929         if (retval != PACKAGE_MANAGER_ERROR_NONE)
 930                 return retval;
 931
 932         retval = package_info_get_package_info(package_id, package_info);
 933
 934         if (retval != PACKAGE_MANAGER_ERROR_NONE)
 935                 return package_manager_error(retval, __FUNCTION__, NULL);
 936         else
 937                 return PACKAGE_MANAGER_ERROR_NONE;
 938 }
 939
 940 API int package_manager_foreach_package_info(package_manager_package_info_cb callback,
 941                                         void *user_data)
 942 {
 943
 944         int retval;
 945         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
 946         if (retval != PACKAGE_MANAGER_ERROR_NONE)
 947                 return retval;
 948
 949         retval = package_info_foreach_package_info(callback, user_data);
 950
 951         if (retval != PACKAGE_MANAGER_ERROR_NONE)
 952                 return package_manager_error(retval, __FUNCTION__, NULL);
 953         else
 954                 return PACKAGE_MANAGER_ERROR_NONE;
 955 }
 956
 957 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)
 958 {
 959         pkgmgrinfo_cert_compare_result_type_e result;
 960
 961         if (lhs_package_id == NULL || rhs_package_id == NULL || compare_result == NULL)
 962                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 963         if (pkgmgrinfo_pkginfo_compare_pkg_cert_info(lhs_package_id, rhs_package_id, &result) != PKGMGR_R_OK)
 964                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
 965         *compare_result = (package_manager_compare_result_type_e)result;
 966
 967         return PACKAGE_MANAGER_ERROR_NONE;
 968 }
 969
 970 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)
 971 {
 972         pkgmgrinfo_cert_compare_result_type_e result;
 973
 974         if (lhs_app_id == NULL || rhs_app_id == NULL || compare_result == NULL)
 975                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 976         if (pkgmgrinfo_pkginfo_compare_app_cert_info(lhs_app_id, rhs_app_id, &result) != PKGMGR_R_OK)
 977                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
 978
 979         *compare_result = (package_manager_compare_result_type_e)result;
 980
 981         return PACKAGE_MANAGER_ERROR_NONE;
 982 }
 983
 984 API int package_manager_is_preload_package_by_app_id(const char *app_id, bool *preload)
 985 {
 986
 987         int retval;
 988         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
 989         if (retval != PACKAGE_MANAGER_ERROR_NONE)
 990                 return retval;
 991
 992         pkgmgrinfo_appinfo_h pkgmgrinfo_appinfo = NULL;
 993         pkgmgrinfo_pkginfo_h pkgmgrinfo_pkginfo = NULL;
 994
 995         char *pkg_id = NULL;
 996         bool is_preload = 0;
 997         if (pkgmgrinfo_appinfo_get_appinfo(app_id, &pkgmgrinfo_appinfo) != PMINFO_R_OK)
 998                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
 999
1000         retval = pkgmgrinfo_appinfo_get_pkgname(pkgmgrinfo_appinfo, &pkg_id);
1001         if (retval != PMINFO_R_OK) {
1002                 pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
1003                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1004         }
1005         if (pkgmgrinfo_pkginfo_get_pkginfo(pkg_id, &pkgmgrinfo_pkginfo) != PMINFO_R_OK) {
1006                 pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
1007                 pkgmgrinfo_pkginfo_destroy_pkginfo(pkgmgrinfo_pkginfo);
1008                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1009         }
1010         if (pkgmgrinfo_pkginfo_is_preload(pkgmgrinfo_pkginfo, &is_preload) != PMINFO_R_OK) {
1011                 pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
1012                 pkgmgrinfo_pkginfo_destroy_pkginfo(pkgmgrinfo_pkginfo);
1013                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1014         }
1015
1016         if (is_preload)
1017                 *preload = 1;
1018         else
1019                 *preload = 0;
1020
1021         pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
1022         pkgmgrinfo_pkginfo_destroy_pkginfo(pkgmgrinfo_pkginfo);
1023
1024         return PACKAGE_MANAGER_ERROR_NONE;
1025 }
1026
1027 API int package_manager_get_permission_type(const char *app_id, package_manager_permission_type_e *permission_type)
1028 {
1029
1030         int retval;
1031         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
1032         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1033                 return retval;
1034
1035         pkgmgrinfo_appinfo_h pkgmgrinfo_appinfo = NULL;
1036         pkgmgrinfo_permission_type permission = 0;
1037         if (pkgmgrinfo_appinfo_get_appinfo(app_id, &pkgmgrinfo_appinfo) != PMINFO_R_OK)
1038                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1039         retval = pkgmgrinfo_appinfo_get_permission_type(pkgmgrinfo_appinfo, &permission);
1040         if (retval != PMINFO_R_OK)
1041                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1042
1043         if (permission == PMINFO_PERMISSION_NORMAL)
1044                 *permission_type = PACKAGE_MANAGER_PERMISSION_NORMAL;
1045         else if (permission == PMINFO_PERMISSION_SIGNATURE)
1046                 *permission_type = PACKAGE_MANAGER_PERMISSION_SIGNATURE;
1047         else if (permission == PMINFO_PERMISSION_PRIVILEGE)
1048                 *permission_type = PACKAGE_MANAGER_PERMISSION_PRIVILEGE;
1049         else
1050                 *permission_type = PACKAGE_MANAGER_PERMISSION_NORMAL;
1051
1052         pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
1053         return PACKAGE_MANAGER_ERROR_NONE;
1054 }
1055
1056 API int package_manager_clear_cache_dir(const char *package_id)
1057 {
1058
1059         int retval;
1060         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_CACHE);
1061         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1062                 return retval;
1063
1064         int res = pkgmgr_client_clear_cache_dir(package_id);
1065         if (res == PKGMGR_R_EINVAL) {
1066                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1067         } else if (res == PKGMGR_R_ENOPKG) {
1068                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1069         } else if (res == PKGMGR_R_ENOMEM) {
1070                 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
1071         } else if (res == PKGMGR_R_EIO) {
1072                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
1073         } else if (res == PKGMGR_R_EPRIV) {
1074                 return package_manager_error(PACKAGE_MANAGER_ERROR_PERMISSION_DENIED, __FUNCTION__, NULL);
1075         } else if (res == PKGMGR_R_ESYSTEM || res == PKGMGR_R_ECOMM || res == PKGMGR_R_ERROR) {
1076                 return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
1077         } else if (res != PKGMGR_R_OK) {
1078                 _LOGE("Unexpected error");
1079                 return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
1080         }
1081
1082         return PACKAGE_MANAGER_ERROR_NONE;
1083 }
1084
1085 API int package_manager_clear_data(const char *package_id)
1086 {
1087         int retval;
1088         pkgmgr_client *pc = NULL;
1089         char *pkg_type = NULL;
1090         pkgmgrinfo_pkginfo_h pkginfo = NULL;
1091
1092         if (package_id == NULL)
1093                 return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
1094
1095         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_ADMIN);
1096         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1097                 return retval;
1098
1099         retval = pkgmgrinfo_pkginfo_get_pkginfo(package_id, &pkginfo);
1100         if (retval == PMINFO_R_ENOENT)
1101                 return PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE;
1102         else if (retval != PMINFO_R_OK || pkginfo == NULL)
1103                 return PACKAGE_MANAGER_ERROR_SYSTEM_ERROR;
1104
1105         retval = pkgmgrinfo_pkginfo_get_type(pkginfo, &pkg_type);
1106         if (retval != PMINFO_R_OK || pkg_type == NULL) {
1107                 pkgmgrinfo_pkginfo_destroy_pkginfo(pkginfo);
1108                 return PACKAGE_MANAGER_ERROR_SYSTEM_ERROR;
1109         }
1110
1111         pc = pkgmgr_client_new(PC_REQUEST);
1112         if (pc == NULL) {
1113                 _LOGE("Out of memory");
1114                 pkgmgrinfo_pkginfo_destroy_pkginfo(pkginfo);
1115                 return PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY;
1116         }
1117
1118         retval = pkgmgr_client_clear_user_data(pc, pkg_type, package_id, PM_QUIET);
1119         pkgmgr_client_free(pc);
1120         pkgmgrinfo_pkginfo_destroy_pkginfo(pkginfo);
1121
1122         if (retval != PKGMGR_R_OK)
1123                 return PACKAGE_MANAGER_ERROR_IO_ERROR;
1124
1125         return PACKAGE_MANAGER_ERROR_NONE;
1126 }
1127
1128 API int package_manager_clear_all_cache_dir(void)
1129 {
1130
1131         int retval;
1132         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_ADMIN);
1133         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1134                 return retval;
1135
1136         return package_manager_clear_cache_dir(PKG_CLEAR_ALL_CACHE);
1137 }
1138
1139 static void __free_client(gpointer data)
1140 {
1141         pkgmgr_client *pc = (pkgmgr_client *)data;
1142         pkgmgr_client_free(pc);
1143 }
1144
1145 static void __initialize_cb_table(void)
1146 {
1147         __cb_table = g_hash_table_new_full(g_direct_hash, g_direct_equal, __free_client, NULL);
1148 }
1149
1150 static void __result_cb(pkgmgr_client *pc, const char *pkgid, const pkg_size_info_t *result, void *user_data)
1151 {
1152         package_manager_size_info_receive_cb callback = g_hash_table_lookup(__cb_table, pc);
1153         if (callback == NULL) {
1154                 _LOGE("callback is null.");
1155                 g_hash_table_remove(__cb_table, pc);
1156                 return;
1157         }
1158
1159         package_size_info_t size_info;
1160         size_info.data_size  = result->data_size;
1161         size_info.cache_size = result->cache_size;
1162         size_info.app_size   = result->app_size;
1163         size_info.external_data_size  = result->ext_data_size;
1164         size_info.external_cache_size = result->ext_cache_size;
1165         size_info.external_app_size   = result->ext_app_size;
1166
1167         callback(pkgid, (package_size_info_h)&size_info, user_data);
1168
1169         g_hash_table_remove(__cb_table, pc);
1170 }
1171
1172 static void __total_result_cb(pkgmgr_client *pc, const pkg_size_info_t *result, void *user_data)
1173 {
1174         package_manager_total_size_info_receive_cb callback = g_hash_table_lookup(__cb_table, pc);
1175         if (callback == NULL) {
1176                 _LOGE("callback is null.");
1177                 g_hash_table_remove(__cb_table, pc);
1178                 return;
1179         }
1180
1181         package_size_info_t size_info;
1182         size_info.data_size  = result->data_size;
1183         size_info.cache_size = result->cache_size;
1184         size_info.app_size   = result->app_size;
1185         size_info.external_data_size  = result->ext_data_size;
1186         size_info.external_cache_size = result->ext_cache_size;
1187         size_info.external_app_size   = result->ext_app_size;
1188
1189         callback((package_size_info_h)&size_info, user_data);
1190
1191         g_hash_table_remove(__cb_table, pc);
1192 }
1193
1194 static int _get_pkg_size_info(const char *package_id, void *callback, void *user_data)
1195 {
1196         if (package_id == NULL || callback == NULL)
1197                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1198
1199         if (__cb_table == NULL)
1200                 __initialize_cb_table();
1201
1202         pkgmgr_client *pc = pkgmgr_client_new(PC_REQUEST);
1203         if (pc == NULL)
1204                 return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
1205
1206         int res = 0;
1207         if (strcmp(package_id, PKG_SIZE_INFO_TOTAL) != 0)
1208                 res = pkgmgr_client_get_package_size_info(pc, package_id, __result_cb, user_data);
1209         else
1210                 res = pkgmgr_client_get_total_package_size_info(pc, __total_result_cb, user_data);
1211
1212         if (res == PKGMGR_R_EINVAL) {
1213                 pkgmgr_client_free(pc);
1214                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1215         } else if (res == PKGMGR_R_ENOPKG) {
1216                 pkgmgr_client_free(pc);
1217                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1218         } else if (res == PKGMGR_R_ENOMEM) {
1219                 pkgmgr_client_free(pc);
1220                 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
1221         } else if (res == PKGMGR_R_EIO) {
1222                 pkgmgr_client_free(pc);
1223                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
1224         } else if (res == PKGMGR_R_EPRIV) {
1225                 pkgmgr_client_free(pc);
1226                 return package_manager_error(PACKAGE_MANAGER_ERROR_PERMISSION_DENIED, __FUNCTION__, NULL);
1227         } else if (res == PKGMGR_R_ESYSTEM || res == PKGMGR_R_ECOMM || res == PKGMGR_R_ERROR) {
1228                 pkgmgr_client_free(pc);
1229                 return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
1230         } else if (res != PKGMGR_R_OK) {
1231                 _LOGE("Unexpected error");
1232                 pkgmgr_client_free(pc);
1233                 return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
1234         }
1235
1236         g_hash_table_insert(__cb_table, pc, callback);
1237
1238         _LOGD("Successful");
1239         return PACKAGE_MANAGER_ERROR_NONE;
1240 }
1241
1242 API int package_manager_get_package_size_info(const char *package_id, package_manager_size_info_receive_cb callback, void *user_data)
1243 {
1244         return _get_pkg_size_info(package_id, (void *)callback, user_data);
1245 }
1246
1247 API int package_manager_get_total_package_size_info(package_manager_total_size_info_receive_cb callback, void *user_data)
1248 {
1249         return _get_pkg_size_info(PKG_SIZE_INFO_TOTAL, (void *)callback, user_data);
1250 }
1251
1252 API int package_manager_filter_create(package_manager_filter_h *handle)
1253 {
1254         int retval;
1255         pkgmgrinfo_pkginfo_filter_h pkgmgr_filter = NULL;
1256
1257         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
1258         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1259                 return retval;
1260
1261         if (handle == NULL) {
1262                 return
1263                     package_manager_error
1264                     (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
1265                      NULL);
1266         }
1267
1268         retval = pkgmgrinfo_pkginfo_filter_create(&pkgmgr_filter);
1269         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1270                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
1271
1272         *handle = pkgmgr_filter;
1273
1274         return PACKAGE_MANAGER_ERROR_NONE;
1275 }
1276
1277 API int package_manager_filter_destroy(package_manager_filter_h handle)
1278 {
1279         int retval;
1280
1281         if (handle == NULL) {
1282                 return
1283                     package_manager_error
1284                     (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
1285                      NULL);
1286         }
1287
1288         retval = pkgmgrinfo_pkginfo_filter_destroy(handle);
1289         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1290                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
1291
1292         return PACKAGE_MANAGER_ERROR_NONE;
1293 }
1294
1295 API int package_manager_filter_add_bool(package_manager_filter_h handle,
1296                 const char *property, const bool value)
1297 {
1298         int retval;
1299
1300         if ((handle == NULL) || (property == NULL)) {
1301                 return
1302                     package_manager_error
1303                     (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
1304                      NULL);
1305         }
1306
1307         retval = pkgmgrinfo_pkginfo_filter_add_bool(handle, property, value);
1308         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1309                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
1310
1311         return PACKAGE_MANAGER_ERROR_NONE;
1312 }
1313
1314 API int package_manager_filter_count(package_manager_filter_h handle, int *count)
1315 {
1316
1317         int retval;
1318         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
1319         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1320                 return retval;
1321
1322         if ((handle == NULL) || (count == NULL))
1323                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1324
1325         retval = pkgmgrinfo_pkginfo_filter_count(handle, count);
1326         if (retval < 0)
1327                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
1328
1329         return PACKAGE_MANAGER_ERROR_NONE;
1330 }
1331
1332 API int package_manager_filter_foreach_package_info(package_manager_filter_h handle,
1333                 package_manager_package_info_cb callback, void *user_data)
1334 {
1335
1336         int retval;
1337         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
1338         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1339                 return retval;
1340
1341         retval = package_info_filter_foreach_package_info(handle, callback, user_data);
1342
1343         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1344                 return package_manager_error(retval, __FUNCTION__, NULL);
1345         else
1346                 return PACKAGE_MANAGER_ERROR_NONE;
1347 }
1348
1349 API int package_size_info_get_data_size(package_size_info_h handle, long long *data_size)
1350 {
1351         if (handle == NULL)
1352                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1353
1354         package_size_info_t *size_info = (package_size_info_t *)handle;
1355
1356         *data_size = (long long)size_info->data_size;
1357         return PACKAGE_MANAGER_ERROR_NONE;
1358 }
1359
1360 API int package_size_info_get_cache_size(package_size_info_h handle, long long *cache_size)
1361 {
1362         if (handle == NULL)
1363                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1364
1365         package_size_info_t *size_info = (package_size_info_t *)handle;
1366
1367         *cache_size = size_info->cache_size;
1368         return PACKAGE_MANAGER_ERROR_NONE;
1369 }
1370
1371 API int package_size_info_get_app_size(package_size_info_h handle, long long *app_size)
1372 {
1373         if (handle == NULL)
1374                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1375
1376         package_size_info_t *size_info = (package_size_info_t *)handle;
1377         *app_size = size_info->app_size;
1378         return PACKAGE_MANAGER_ERROR_NONE;
1379 }
1380
1381 API int package_size_info_get_external_data_size(package_size_info_h handle, long long *ext_data_size)
1382 {
1383         if (handle == NULL)
1384                 return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
1385
1386         package_size_info_t *size_info = (package_size_info_t *)handle;
1387         *ext_data_size = size_info->external_data_size;
1388         return PACKAGE_MANAGER_ERROR_NONE;
1389 }
1390
1391 API int package_size_info_get_external_cache_size(package_size_info_h handle, long long *ext_cache_size)
1392 {
1393         if (handle == NULL)
1394                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1395
1396         package_size_info_t *size_info = (package_size_info_t *)handle;
1397         *ext_cache_size = size_info->external_cache_size;
1398         return PACKAGE_MANAGER_ERROR_NONE;
1399 }
1400
1401 API int package_size_info_get_external_app_size(package_size_info_h handle, long long *ext_app_size)
1402 {
1403         if (handle == NULL)
1404                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1405
1406         package_size_info_t *size_info = (package_size_info_t *)handle;
1407         *ext_app_size = size_info->external_app_size;
1408         return PACKAGE_MANAGER_ERROR_NONE;
1409 }