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