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         while (tmp) {
 305                 if (tmp->req_id == req_id) {
 306                         *event_type = tmp->event_type;
 307                         return 0;
 308                 }
 309                 tmp = tmp->next;
 310         }
 311         return -1;
 312 }
 313
 314 static int __update_event_info(event_info **head, int req_id,
 315                                package_manager_event_type_e event_type,
 316                                package_manager_event_state_e event_state)
 317 {
 318         package_manager_event_type_e evt_type;
 319         package_manager_event_state_e evt_state;
 320         event_info *tmp;
 321
 322         if (__find_event_info(head, req_id, &evt_type, &evt_state) != 0)
 323                 __add_event_info(head, req_id, event_type, event_state);
 324         else {
 325                 tmp = *head;
 326
 327                 if (tmp == NULL) {
 328                         _LOGE("tmp is NULL");
 329                         return -1;
 330                 }
 331
 332                 while (tmp) {
 333                         if (tmp->req_id == req_id) {
 334                                 tmp->event_type = event_type;
 335                                 return 0;
 336                         }
 337                         tmp = tmp->next;
 338                 }
 339         }
 340
 341         return -1;
 342 }
 343
 344 /*
 345 static int __remove_event_info(event_info **head request, int req_id)
 346 {
 347         event_info *current;
 348         event_info *tmp;
 349
 350         if (* == NULL)
 351                 return -1;
 352
 353         current = *head;
 354         while (current) {
 355                 if (current->next) {
 356                         if (current->next->req_id == req_id) {
 357                                 tmp = current->next;
 358                                 current->next = current->next->next;
 359                                 free(tmp);
 360                                 return 0;
 361                         }
 362                 }
 363                 tmp = tmp->next;
 364         }
 365
 366         return -1;
 367 }
 368 */
 369
 370 static int request_event_handler(uid_t target_uid, int req_id, const char *pkg_type,
 371                                  const char *pkg_name, const char *key,
 372                                  const char *val, const void *pmsg, void *data)
 373 {
 374         int ret = -1;
 375         package_manager_event_type_e event_type = -1;
 376         package_manager_event_state_e event_state = -1;
 377
 378         package_manager_request_h request = data;
 379
 380         if (strcasecmp(key, "start") == 0) {
 381                 ret = package_manager_get_event_type(val, &event_type);
 382                 if (ret != PACKAGE_MANAGER_ERROR_NONE)
 383                         return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
 384
 385                 __add_event_info(&(request->head), req_id, event_type,
 386                                  PACKAGE_MANAGER_EVENT_STATE_STARTED);
 387
 388                 if (request->event_cb)
 389                         request->event_cb(req_id, pkg_type, pkg_name,
 390                                           event_type,
 391                                           PACKAGE_MANAGER_EVENT_STATE_STARTED,
 392                                           0, PACKAGE_MANAGER_ERROR_NONE, request->user_data);
 393
 394         } else if (strcasecmp(key, "install_percent") == 0
 395                    || strcasecmp(key, "progress_percent") == 0) {
 396                 if (__find_event_info
 397                     (&(request->head), req_id, &event_type,
 398                      &event_state) == 0) {
 399                         __update_event_info(&(request->head), req_id,
 400                                             event_type,
 401                                             PACKAGE_MANAGER_EVENT_STATE_PROCESSING);
 402                         if (request->event_cb)
 403                                 request->event_cb(req_id, pkg_type, pkg_name,
 404                                                   event_type,
 405                                                   PACKAGE_MANAGER_EVENT_STATE_PROCESSING,
 406                                                   atoi(val),
 407                                                   PACKAGE_MANAGER_ERROR_NONE,
 408                                                   request->user_data);
 409                 }
 410
 411         } else if (strcasecmp(key, "error") == 0) {
 412                 if (strcasecmp(key, "0") != 0) {
 413                         if (__find_event_info
 414                             (&(request->head), req_id, &event_type,
 415                              &event_state) == 0) {
 416                                 __update_event_info(&(request->head), req_id,
 417                                                     event_type,
 418                                                     PACKAGE_MANAGER_EVENT_STATE_FAILED);
 419                         }
 420
 421                         if (request->event_cb)
 422                                 request->event_cb(req_id, pkg_type,
 423                                                   pkg_name, event_type,
 424                                                   PACKAGE_MANAGER_EVENT_STATE_FAILED,
 425                                                   0,
 426                                                   PACKAGE_MANAGER_ERROR_NONE,
 427                                                   request->user_data);
 428
 429                 }
 430         } else if (strcasecmp(key, "end") == 0) {
 431                 if (__find_event_info
 432                     (&(request->head), req_id, &event_type,
 433                      &event_state) == 0) {
 434                         if (event_state != PACKAGE_MANAGER_EVENT_STATE_FAILED) {
 435                                 if (request->event_cb)
 436                                         request->event_cb(req_id, pkg_type,
 437                                                           pkg_name, event_type,
 438                                                           PACKAGE_MANAGER_EVENT_STATE_COMPLETED,
 439                                                           100,
 440                                                           PACKAGE_MANAGER_ERROR_NONE,
 441                                                           request->user_data);
 442                         }
 443                 } else {
 444                         if (strcasecmp(key, "ok") != 0)
 445                                 if (request->event_cb)
 446                                         request->event_cb(req_id, pkg_type,
 447                                                           pkg_name, event_type,
 448                                                           PACKAGE_MANAGER_EVENT_STATE_FAILED,
 449                                                           0,
 450                                                           PACKAGE_MANAGER_ERROR_NONE,
 451                                                           request->user_data);
 452                 }
 453         }
 454
 455         return PACKAGE_MANAGER_ERROR_NONE;
 456 }
 457
 458 API int package_manager_request_install(package_manager_request_h request,
 459                                     const char *path, int *id)
 460 {
 461
 462         int retval;
 463         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_ADMIN);
 464         if (retval != PACKAGE_MANAGER_ERROR_NONE)
 465                 return retval;
 466
 467         if (package_manager_client_validate_handle(request))
 468                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 469
 470         if (path == NULL)
 471                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 472
 473         int request_id = 0;
 474         request_id = pkgmgr_client_install(request->pc, request->pkg_type, NULL,
 475                         path, NULL, request->mode, request_event_handler, request);
 476
 477         if (request_id == PKGMGR_R_EINVAL)
 478                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 479         else if (request_id == PKGMGR_R_ENOPKG)
 480                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
 481         else if (request_id == PKGMGR_R_ENOMEM)
 482                 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
 483         else if (request_id == PKGMGR_R_EIO)
 484                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
 485         else if (request_id == PKGMGR_R_EPRIV)
 486                 return package_manager_error(PACKAGE_MANAGER_ERROR_PERMISSION_DENIED, __FUNCTION__, NULL);
 487         else if (request_id == PKGMGR_R_ESYSTEM || request_id == PKGMGR_R_ECOMM || request_id == PKGMGR_R_ERROR)
 488                 return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
 489
 490         *id = request_id;
 491
 492         return PACKAGE_MANAGER_ERROR_NONE;
 493 }
 494
 495 API int package_manager_request_uninstall(package_manager_request_h request,
 496                                       const char *name, int *id)
 497 {
 498
 499         int retval;
 500         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_ADMIN);
 501         if (retval != PACKAGE_MANAGER_ERROR_NONE)
 502                 return retval;
 503
 504         if (package_manager_client_validate_handle(request))
 505                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 506
 507         if (name == NULL)
 508                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 509
 510         int request_id = 0;
 511         request_id = pkgmgr_client_uninstall(request->pc, request->pkg_type,
 512                         name, request->mode, request_event_handler, request);
 513
 514         if (request_id == PKGMGR_R_EINVAL)
 515                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 516         else if (request_id == PKGMGR_R_ENOPKG)
 517                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
 518         else if (request_id == PKGMGR_R_ENOMEM)
 519                 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
 520         else if (request_id == PKGMGR_R_EIO)
 521                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
 522         else if (request_id == PKGMGR_R_EPRIV)
 523                 return package_manager_error(PACKAGE_MANAGER_ERROR_PERMISSION_DENIED, __FUNCTION__, NULL);
 524         else if (request_id == PKGMGR_R_ESYSTEM || request_id == PKGMGR_R_ECOMM || request_id == PKGMGR_R_ERROR)
 525                 return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
 526
 527         *id = request_id;
 528
 529         return PACKAGE_MANAGER_ERROR_NONE;
 530 }
 531
 532 API int package_manager_request_move(package_manager_request_h request,
 533                                     const char *name, package_manager_move_type_e move_type)
 534 {
 535
 536         int retval;
 537         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_ADMIN);
 538         if (retval != PACKAGE_MANAGER_ERROR_NONE)
 539                 return retval;
 540
 541         if (package_manager_client_validate_handle(request))
 542                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 543
 544         if (name == NULL)
 545                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 546
 547         int ret = 0;
 548         ret = pkgmgr_client_request_service(PM_REQUEST_MOVE, move_type,
 549                         request->pc, request->pkg_type, name,
 550                         NULL, request_event_handler, request);
 551
 552         if (ret == PKGMGR_R_EINVAL)
 553                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 554         else if (ret == PKGMGR_R_ENOPKG)
 555                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
 556         else if (ret == PKGMGR_R_ENOMEM)
 557                 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
 558         else if (ret == PKGMGR_R_EIO)
 559                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
 560         else if (ret == PKGMGR_R_EPRIV)
 561                 return package_manager_error(PACKAGE_MANAGER_ERROR_PERMISSION_DENIED, __FUNCTION__, NULL);
 562         else if (ret == PKGMGR_R_ESYSTEM || ret == PKGMGR_R_ECOMM || ret == PKGMGR_R_ERROR)
 563                 return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
 564
 565         return PACKAGE_MANAGER_ERROR_NONE;
 566 }
 567
 568 API int package_manager_create(package_manager_h *manager)
 569 {
 570
 571         int retval;
 572         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
 573         if (retval != PACKAGE_MANAGER_ERROR_NONE)
 574                 return retval;
 575
 576         struct package_manager_s *package_manager = NULL;
 577
 578         if (manager == NULL) {
 579                 return
 580                     package_manager_error
 581                     (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
 582                      NULL);
 583         }
 584
 585         package_manager = calloc(1, sizeof(struct package_manager_s));
 586         if (package_manager == NULL) {
 587                 return
 588                     package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY,
 589                                           __FUNCTION__,
 590                                           "failed to create a package_manager handle");
 591         }
 592
 593         package_manager->ctype = PC_LISTENING;
 594         package_manager->pc = pkgmgr_client_new(PC_LISTENING);
 595         if (package_manager->pc == NULL) {
 596                 free(package_manager);
 597                 return
 598                     package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY,
 599                                           __FUNCTION__,
 600                                           "failed to create a package_manager client");
 601         }
 602
 603         package_manager->handle_id = package_manager_new_id();
 604
 605         *manager = package_manager;
 606
 607         return PACKAGE_MANAGER_ERROR_NONE;
 608 }
 609
 610 static int package_manager_validate_handle(package_manager_h manager)
 611 {
 612         if (manager == NULL || manager->pc == NULL)
 613                 return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
 614
 615         return PACKAGE_MANAGER_ERROR_NONE;
 616 }
 617
 618 API int package_manager_destroy(package_manager_h manager)
 619 {
 620         if (package_manager_validate_handle(manager)) {
 621                 return
 622                     package_manager_error
 623                     (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
 624                      NULL);
 625         }
 626
 627         pkgmgr_client_free(manager->pc);
 628         manager->pc = NULL;
 629         free(manager);
 630
 631         return PACKAGE_MANAGER_ERROR_NONE;
 632 }
 633
 634 static int __add_event(event_info **head, int req_id,
 635                             package_manager_event_type_e event_type,
 636                             package_manager_event_state_e event_state)
 637 {
 638         event_info *evt_info;
 639
 640         evt_info = (event_info *) calloc(1, sizeof(event_info));
 641         if (evt_info == NULL) {
 642                 _LOGD("calloc failed");
 643                 return -1;
 644         }
 645         evt_info->req_id = req_id;
 646         evt_info->event_type = event_type;
 647         evt_info->event_state = event_state;
 648         evt_info->next = NULL;
 649
 650         *head = evt_info;
 651
 652         return 0;
 653 }
 654
 655 static int __find_event(event_info **head, int req_id,
 656                              package_manager_event_type_e *event_type,
 657                              package_manager_event_state_e *event_state)
 658 {
 659         event_info *tmp;
 660
 661         tmp = *head;
 662
 663         if (tmp == NULL) {
 664                 _LOGE("tmp is NULL");
 665                 return -1;
 666         }
 667
 668         *event_type = tmp->event_type;
 669         *event_state = tmp->event_state;
 670         return 0;
 671 }
 672
 673 static int __update_event(event_info **head, int req_id,
 674                                package_manager_event_type_e event_type,
 675                                package_manager_event_state_e event_state)
 676 {
 677         package_manager_event_type_e evt_type;
 678         package_manager_event_state_e evt_state;
 679         event_info *tmp;
 680
 681         if (__find_event_info(head, req_id, &evt_type, &evt_state) != 0)
 682                 __add_event_info(head, req_id, event_type, event_state);
 683         else {
 684                 tmp = *head;
 685
 686                 if (tmp == NULL) {
 687                         _LOGE("tmp is NULL");
 688                         return -1;
 689                 }
 690
 691                 tmp->event_type = event_type;
 692                 tmp->event_state = event_state;
 693                 return 0;
 694         }
 695
 696         return -1;
 697 }
 698
 699 /* App Event Listening Policy:
 700  * +----------------+------------+---------------+------------------+
 701  * |Listener \ Type |Global Event|My User's Event|Other user's Event|
 702  * +----------------+------------+---------------+------------------+
 703  * |User Process App|   Grant    |     Grant     |      Deny        |
 704  * +----------------+------------+---------------+------------------+
 705  * |Platform module |   Grant    |     Grant     |      Grant       |
 706  * +----------------+------------+---------------+------------------+
 707  * UID assignment policy:
 708  * https://wiki.tizen.org/wiki/Security/User_and_group_ID_assignment_policy
 709  */
 710 #define REGULAR_USER 5000
 711 static int __validate_event_signal(uid_t target_uid)
 712 {
 713         uid_t self = getuid();
 714
 715         if (self == target_uid)
 716                 return 0;
 717
 718         if (self < REGULAR_USER)
 719                 return 0;
 720
 721         return -1;
 722 }
 723
 724 static int global_event_handler(uid_t target_uid, int req_id, const char *pkg_type,
 725                                 const char *pkg_name, const char *key,
 726                                 const char *val, const void *pmsg, void *data)
 727 {
 728         int ret = -1;
 729         package_manager_event_type_e event_type = -1;
 730         package_manager_event_state_e event_state = -1;
 731         uid_t uid = target_uid;
 732
 733         package_manager_h manager = data;
 734
 735         if (target_uid == GLOBAL_USER)
 736                 uid = getuid();
 737
 738         if (__validate_event_signal(uid))
 739                 return PACKAGE_MANAGER_ERROR_NONE;
 740
 741         if (strcasecmp(key, "start") == 0) {
 742                 ret = package_manager_get_event_type(val, &event_type);
 743                 if (ret != PACKAGE_MANAGER_ERROR_NONE)
 744                         return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
 745
 746                 __add_event(&(manager->head), req_id, event_type,
 747                                  PACKAGE_MANAGER_EVENT_STATE_STARTED);
 748
 749                 if (manager->event_cb && getuid() == uid)
 750                         manager->event_cb(pkg_type, pkg_name,
 751                                           event_type,
 752                                           PACKAGE_MANAGER_EVENT_STATE_STARTED,
 753                                           0, PACKAGE_MANAGER_ERROR_NONE, manager->user_data);
 754         } else if (strcasecmp(key, "install_percent") == 0
 755                    || strcasecmp(key, "progress_percent") == 0) {
 756                 if (__find_event
 757                     (&(manager->head), req_id, &event_type,
 758                      &event_state) == 0) {
 759                         __update_event(&(manager->head), req_id,
 760                                             event_type,
 761                                             PACKAGE_MANAGER_EVENT_STATE_PROCESSING);
 762                         if (manager->event_cb && getuid() == uid)
 763                                 manager->event_cb(pkg_type, pkg_name,
 764                                                   event_type,
 765                                                   PACKAGE_MANAGER_EVENT_STATE_PROCESSING,
 766                                                   atoi(val),
 767                                                   PACKAGE_MANAGER_ERROR_NONE,
 768                                                   manager->user_data);
 769                 }
 770
 771         } else if (strcasecmp(key, "error") == 0) {
 772                 if (strcasecmp(key, "0") != 0) {
 773                         if (__find_event
 774                             (&(manager->head), req_id, &event_type,
 775                              &event_state) == 0) {
 776                                 __update_event(&(manager->head), req_id,
 777                                                     event_type,
 778                                                     PACKAGE_MANAGER_EVENT_STATE_FAILED);
 779                         }
 780
 781                         if (manager->event_cb && getuid() == uid)
 782                                 manager->event_cb(pkg_type,
 783                                                   pkg_name, event_type,
 784                                                   PACKAGE_MANAGER_EVENT_STATE_FAILED,
 785                                                   0,
 786                                                   PACKAGE_MANAGER_ERROR_NONE,
 787                                                   manager->user_data);
 788                 }
 789         } else if (strcasecmp(key, "end") == 0) {
 790                 if (__find_event
 791                     (&(manager->head), req_id, &event_type,
 792                      &event_state) == 0) {
 793                         if (event_state != PACKAGE_MANAGER_EVENT_STATE_FAILED) {
 794                                 if (manager->event_cb && getuid() == uid)
 795                                         manager->event_cb(pkg_type,
 796                                                           pkg_name, event_type,
 797                                                           PACKAGE_MANAGER_EVENT_STATE_COMPLETED,
 798                                                           100,
 799                                                           PACKAGE_MANAGER_ERROR_NONE,
 800                                                           manager->user_data);
 801                         }
 802                 } else {
 803                         if (strcasecmp(key, "ok") != 0) {
 804                                 if (manager->event_cb && getuid() == uid)
 805                                         manager->event_cb(pkg_type,
 806                                                           pkg_name, event_type,
 807                                                           PACKAGE_MANAGER_EVENT_STATE_FAILED,
 808                                                           0,
 809                                                           PACKAGE_MANAGER_ERROR_NONE,
 810                                                           manager->user_data);
 811                         }
 812                 }
 813         }
 814
 815         return PACKAGE_MANAGER_ERROR_NONE;
 816 }
 817
 818 static int __convert_status_type(package_manager_status_type_e status_type)
 819 {
 820         int type = 0;
 821
 822         if (status_type == PACKAGE_MANAGER_STATUS_TYPE_ALL)
 823                 return PKGMGR_CLIENT_STATUS_ALL;
 824
 825         if (status_type & PACKAGE_MANAGER_STATUS_TYPE_INSTALL)
 826                 type |= PKGMGR_CLIENT_STATUS_INSTALL;
 827         if (status_type & PACKAGE_MANAGER_STATUS_TYPE_UNINSTALL)
 828                 type |= PKGMGR_CLIENT_STATUS_UNINSTALL;
 829         if (status_type & PACKAGE_MANAGER_STATUS_TYPE_UPGRADE)
 830                 type |= PKGMGR_CLIENT_STATUS_UPGRADE;
 831         if (status_type & PACKAGE_MANAGER_STATUS_TYPE_MOVE)
 832                 type |= PKGMGR_CLIENT_STATUS_MOVE;
 833         if (status_type & PACKAGE_MANAGER_STATUS_TYPE_CLEAR_DATA)
 834                 type |= PKGMGR_CLIENT_STATUS_CLEAR_DATA;
 835         if (status_type & PACKAGE_MANAGER_STATUS_TYPE_INSTALL_PROGRESS)
 836                 type |= PKGMGR_CLIENT_STATUS_INSTALL_PROGRESS;
 837         if (status_type & PACKAGE_MANAGER_STATUS_TYPE_GET_SIZE)
 838                 type |= PKGMGR_CLIENT_STATUS_GET_SIZE;
 839
 840         return type;
 841 }
 842
 843 API int package_manager_set_event_status(package_manager_h manager, int status_type)
 844 {
 845         int retval;
 846         int type;
 847         int type_all = PACKAGE_MANAGER_STATUS_TYPE_INSTALL |
 848                 PACKAGE_MANAGER_STATUS_TYPE_UNINSTALL |
 849                 PACKAGE_MANAGER_STATUS_TYPE_UPGRADE |
 850                 PACKAGE_MANAGER_STATUS_TYPE_MOVE |
 851                 PACKAGE_MANAGER_STATUS_TYPE_CLEAR_DATA |
 852                 PACKAGE_MANAGER_STATUS_TYPE_INSTALL_PROGRESS |
 853                 PACKAGE_MANAGER_STATUS_TYPE_GET_SIZE;
 854
 855         if (manager == NULL)
 856                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 857
 858         if (status_type < 0 || status_type > type_all)
 859                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 860
 861         type = __convert_status_type(status_type);
 862         retval = pkgmgr_client_set_status_type(manager->pc, type);
 863
 864         if (retval < 0)
 865                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
 866
 867         return PACKAGE_MANAGER_ERROR_NONE;
 868 }
 869
 870 API int package_manager_set_event_cb(package_manager_h manager,
 871                                  package_manager_event_cb callback,
 872                                  void *user_data)
 873 {
 874
 875         int retval;
 876         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
 877         if (retval != PACKAGE_MANAGER_ERROR_NONE)
 878                 return retval;
 879
 880         if (package_manager_validate_handle(manager)) {
 881                 return
 882                     package_manager_error
 883                     (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
 884                      NULL);
 885         }
 886
 887         manager->event_cb = callback;
 888         manager->user_data = user_data;
 889
 890         pkgmgr_client_listen_status(manager->pc, global_event_handler, manager);
 891
 892         return PACKAGE_MANAGER_ERROR_NONE;
 893 }
 894
 895 API int package_manager_unset_event_cb(package_manager_h manager)
 896 {
 897         if (manager == NULL) {
 898                 return
 899                     package_manager_error
 900                     (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
 901                      NULL);
 902         }
 903
 904         int retval;
 905         manager->event_cb = NULL;
 906         manager->user_data = NULL;
 907
 908         retval = pkgmgr_client_remove_listen_status(manager->pc);
 909         if (retval == PKGMGR_R_EINVAL)
 910                 return
 911                          package_manager_error
 912                          (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
 913                           NULL);
 914         else if (retval == PKGMGR_R_ERROR)
 915                 return
 916                          package_manager_error
 917                          (PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__,
 918                           NULL);
 919
 920         return PACKAGE_MANAGER_ERROR_NONE;
 921 }
 922
 923 API int package_manager_get_package_id_by_app_id(const char *app_id, char **package_id)
 924 {
 925         pkgmgrinfo_appinfo_h pkgmgrinfo_appinfo;
 926         int retval;
 927         char *pkg_id = NULL;
 928         char *pkg_id_dup = NULL;
 929
 930         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
 931         if (retval != PACKAGE_MANAGER_ERROR_NONE)
 932                 return retval;
 933
 934         if (app_id == NULL || package_id == NULL)
 935                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 936
 937         if (pkgmgrinfo_appinfo_get_appinfo(app_id, &pkgmgrinfo_appinfo) != PMINFO_R_OK)
 938                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
 939         retval = pkgmgrinfo_appinfo_get_pkgname(pkgmgrinfo_appinfo, &pkg_id);
 940         if (retval != PMINFO_R_OK)
 941                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
 942
 943         pkg_id_dup = strdup(pkg_id);
 944         if (pkg_id_dup == NULL) {
 945                 pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
 946                 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
 947         }
 948
 949         *package_id = pkg_id_dup;
 950
 951         pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
 952
 953         return PACKAGE_MANAGER_ERROR_NONE;
 954 }
 955
 956 API int package_manager_get_package_info(const char *package_id, package_info_h *package_info)
 957 {
 958         int retval;
 959         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
 960         if (retval != PACKAGE_MANAGER_ERROR_NONE)
 961                 return retval;
 962
 963         retval = package_info_get_package_info(package_id, package_info);
 964
 965         if (retval != PACKAGE_MANAGER_ERROR_NONE)
 966                 return package_manager_error(retval, __FUNCTION__, NULL);
 967         else
 968                 return PACKAGE_MANAGER_ERROR_NONE;
 969 }
 970
 971 API int package_manager_foreach_package_info(package_manager_package_info_cb callback,
 972                                         void *user_data)
 973 {
 974
 975         int retval;
 976         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
 977         if (retval != PACKAGE_MANAGER_ERROR_NONE)
 978                 return retval;
 979
 980         retval = package_info_foreach_package_info(callback, user_data);
 981
 982         if (retval != PACKAGE_MANAGER_ERROR_NONE)
 983                 return package_manager_error(retval, __FUNCTION__, NULL);
 984         else
 985                 return PACKAGE_MANAGER_ERROR_NONE;
 986 }
 987
 988 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)
 989 {
 990         pkgmgrinfo_cert_compare_result_type_e result;
 991
 992         if (lhs_package_id == NULL || rhs_package_id == NULL || compare_result == NULL)
 993                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 994         if (pkgmgrinfo_pkginfo_compare_pkg_cert_info(lhs_package_id, rhs_package_id, &result) != PKGMGR_R_OK)
 995                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
 996         *compare_result = (package_manager_compare_result_type_e)result;
 997
 998         return PACKAGE_MANAGER_ERROR_NONE;
 999 }
1000
1001 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)
1002 {
1003         pkgmgrinfo_cert_compare_result_type_e result;
1004
1005         if (lhs_app_id == NULL || rhs_app_id == NULL || compare_result == NULL)
1006                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1007         if (pkgmgrinfo_pkginfo_compare_app_cert_info(lhs_app_id, rhs_app_id, &result) != PKGMGR_R_OK)
1008                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
1009
1010         *compare_result = (package_manager_compare_result_type_e)result;
1011
1012         return PACKAGE_MANAGER_ERROR_NONE;
1013 }
1014
1015 API int package_manager_is_preload_package_by_app_id(const char *app_id, bool *preload)
1016 {
1017
1018         int retval;
1019         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
1020         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1021                 return retval;
1022
1023         pkgmgrinfo_appinfo_h pkgmgrinfo_appinfo = NULL;
1024         pkgmgrinfo_pkginfo_h pkgmgrinfo_pkginfo = NULL;
1025
1026         char *pkg_id = NULL;
1027         bool is_preload = 0;
1028         if (pkgmgrinfo_appinfo_get_appinfo(app_id, &pkgmgrinfo_appinfo) != PMINFO_R_OK)
1029                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1030
1031         retval = pkgmgrinfo_appinfo_get_pkgname(pkgmgrinfo_appinfo, &pkg_id);
1032         if (retval != PMINFO_R_OK) {
1033                 pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
1034                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1035         }
1036         if (pkgmgrinfo_pkginfo_get_pkginfo(pkg_id, &pkgmgrinfo_pkginfo) != PMINFO_R_OK) {
1037                 pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
1038                 pkgmgrinfo_pkginfo_destroy_pkginfo(pkgmgrinfo_pkginfo);
1039                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1040         }
1041         if (pkgmgrinfo_pkginfo_is_preload(pkgmgrinfo_pkginfo, &is_preload) != PMINFO_R_OK) {
1042                 pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
1043                 pkgmgrinfo_pkginfo_destroy_pkginfo(pkgmgrinfo_pkginfo);
1044                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1045         }
1046
1047         if (is_preload)
1048                 *preload = 1;
1049         else
1050                 *preload = 0;
1051
1052         pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
1053         pkgmgrinfo_pkginfo_destroy_pkginfo(pkgmgrinfo_pkginfo);
1054
1055         return PACKAGE_MANAGER_ERROR_NONE;
1056 }
1057
1058 API int package_manager_get_permission_type(const char *app_id, package_manager_permission_type_e *permission_type)
1059 {
1060
1061         int retval;
1062         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
1063         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1064                 return retval;
1065
1066         pkgmgrinfo_appinfo_h pkgmgrinfo_appinfo = NULL;
1067         pkgmgrinfo_permission_type permission = 0;
1068         if (pkgmgrinfo_appinfo_get_appinfo(app_id, &pkgmgrinfo_appinfo) != PMINFO_R_OK)
1069                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1070         retval = pkgmgrinfo_appinfo_get_permission_type(pkgmgrinfo_appinfo, &permission);
1071         if (retval != PMINFO_R_OK)
1072                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1073
1074         if (permission == PMINFO_PERMISSION_NORMAL)
1075                 *permission_type = PACKAGE_MANAGER_PERMISSION_NORMAL;
1076         else if (permission == PMINFO_PERMISSION_SIGNATURE)
1077                 *permission_type = PACKAGE_MANAGER_PERMISSION_SIGNATURE;
1078         else if (permission == PMINFO_PERMISSION_PRIVILEGE)
1079                 *permission_type = PACKAGE_MANAGER_PERMISSION_PRIVILEGE;
1080         else
1081                 *permission_type = PACKAGE_MANAGER_PERMISSION_NORMAL;
1082
1083         pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
1084         return PACKAGE_MANAGER_ERROR_NONE;
1085 }
1086
1087 API int package_manager_clear_cache_dir(const char *package_id)
1088 {
1089
1090         int retval;
1091         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_CACHE);
1092         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1093                 return retval;
1094
1095         int res = pkgmgr_client_clear_cache_dir(package_id);
1096         if (res == PKGMGR_R_EINVAL) {
1097                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1098         } else if (res == PKGMGR_R_ENOPKG) {
1099                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1100         } else if (res == PKGMGR_R_ENOMEM) {
1101                 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
1102         } else if (res == PKGMGR_R_EIO) {
1103                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
1104         } else if (res == PKGMGR_R_EPRIV) {
1105                 return package_manager_error(PACKAGE_MANAGER_ERROR_PERMISSION_DENIED, __FUNCTION__, NULL);
1106         } else if (res == PKGMGR_R_ESYSTEM || res == PKGMGR_R_ECOMM || res == PKGMGR_R_ERROR) {
1107                 return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
1108         } else if (res != PKGMGR_R_OK) {
1109                 _LOGE("Unexpected error");
1110                 return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
1111         }
1112
1113         return PACKAGE_MANAGER_ERROR_NONE;
1114 }
1115
1116 API int package_manager_clear_data_dir(const char *package_id)
1117 {
1118         int retval;
1119         pkgmgr_client *pc = NULL;
1120         char *pkg_type = NULL;
1121         pkgmgrinfo_pkginfo_h pkginfo = NULL;
1122
1123         if (package_id == NULL)
1124                 return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
1125
1126         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_ADMIN);
1127         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1128                 return retval;
1129
1130         retval = pkgmgrinfo_pkginfo_get_pkginfo(package_id, &pkginfo);
1131         if (retval == PMINFO_R_ENOENT)
1132                 return PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE;
1133         else if (retval != PMINFO_R_OK || pkginfo == NULL)
1134                 return PACKAGE_MANAGER_ERROR_SYSTEM_ERROR;
1135
1136         retval = pkgmgrinfo_pkginfo_get_type(pkginfo, &pkg_type);
1137         if (retval != PMINFO_R_OK || pkg_type == NULL) {
1138                 pkgmgrinfo_pkginfo_destroy_pkginfo(pkginfo);
1139                 return PACKAGE_MANAGER_ERROR_SYSTEM_ERROR;
1140         }
1141
1142         pc = pkgmgr_client_new(PC_REQUEST);
1143         if (pc == NULL) {
1144                 _LOGE("Out of memory");
1145                 pkgmgrinfo_pkginfo_destroy_pkginfo(pkginfo);
1146                 return PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY;
1147         }
1148
1149         retval = pkgmgr_client_clear_user_data(pc, pkg_type, package_id, PM_QUIET);
1150         pkgmgr_client_free(pc);
1151         pkgmgrinfo_pkginfo_destroy_pkginfo(pkginfo);
1152
1153         if (retval == PKGMGR_R_EINVAL) {
1154                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1155         } else if (retval == PKGMGR_R_ENOPKG) {
1156                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1157         } else if (retval == PKGMGR_R_ENOMEM) {
1158                 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
1159         } else if (retval == PKGMGR_R_EIO) {
1160                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
1161         } else if (retval == PKGMGR_R_EPRIV) {
1162                 return package_manager_error(PACKAGE_MANAGER_ERROR_PERMISSION_DENIED, __FUNCTION__, NULL);
1163         } else if (retval == PKGMGR_R_ESYSTEM || retval == PKGMGR_R_ECOMM || retval == PKGMGR_R_ERROR) {
1164                 return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
1165         } else if (retval != PKGMGR_R_OK) {
1166                 _LOGE("Unexpected error");
1167                 return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
1168         }
1169
1170         return PACKAGE_MANAGER_ERROR_NONE;
1171 }
1172
1173 API int package_manager_clear_all_cache_dir(void)
1174 {
1175
1176         int retval;
1177         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_ADMIN);
1178         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1179                 return retval;
1180
1181         return package_manager_clear_cache_dir(PKG_CLEAR_ALL_CACHE);
1182 }
1183
1184 static void __free_client(gpointer data)
1185 {
1186         pkgmgr_client *pc = (pkgmgr_client *)data;
1187         pkgmgr_client_free(pc);
1188 }
1189
1190 static void __initialize_cb_table(void)
1191 {
1192         __cb_table = g_hash_table_new_full(g_direct_hash, g_direct_equal, __free_client, NULL);
1193 }
1194
1195 static void __result_cb(pkgmgr_client *pc, const char *pkgid, const pkg_size_info_t *result, void *user_data)
1196 {
1197         package_manager_size_info_receive_cb callback = g_hash_table_lookup(__cb_table, pc);
1198         if (callback == NULL) {
1199                 _LOGE("callback is null.");
1200                 g_hash_table_remove(__cb_table, pc);
1201                 return;
1202         }
1203
1204         package_size_info_t size_info;
1205         size_info.data_size  = result->data_size;
1206         size_info.cache_size = result->cache_size;
1207         size_info.app_size   = result->app_size;
1208         size_info.external_data_size  = result->ext_data_size;
1209         size_info.external_cache_size = result->ext_cache_size;
1210         size_info.external_app_size   = result->ext_app_size;
1211
1212         callback(pkgid, (package_size_info_h)&size_info, user_data);
1213
1214         g_hash_table_remove(__cb_table, pc);
1215 }
1216
1217 static void __total_result_cb(pkgmgr_client *pc, const pkg_size_info_t *result, void *user_data)
1218 {
1219         package_manager_total_size_info_receive_cb callback = g_hash_table_lookup(__cb_table, pc);
1220         if (callback == NULL) {
1221                 _LOGE("callback is null.");
1222                 g_hash_table_remove(__cb_table, pc);
1223                 return;
1224         }
1225
1226         package_size_info_t size_info;
1227         size_info.data_size  = result->data_size;
1228         size_info.cache_size = result->cache_size;
1229         size_info.app_size   = result->app_size;
1230         size_info.external_data_size  = result->ext_data_size;
1231         size_info.external_cache_size = result->ext_cache_size;
1232         size_info.external_app_size   = result->ext_app_size;
1233
1234         callback((package_size_info_h)&size_info, user_data);
1235
1236         g_hash_table_remove(__cb_table, pc);
1237 }
1238
1239 static int _get_pkg_size_info(const char *package_id, void *callback, void *user_data)
1240 {
1241         if (package_id == NULL || callback == NULL)
1242                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1243
1244         if (__cb_table == NULL)
1245                 __initialize_cb_table();
1246
1247         pkgmgr_client *pc = pkgmgr_client_new(PC_REQUEST);
1248         if (pc == NULL)
1249                 return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
1250
1251         int res = 0;
1252         if (strcmp(package_id, PKG_SIZE_INFO_TOTAL) != 0)
1253                 res = pkgmgr_client_get_package_size_info(pc, package_id, __result_cb, user_data);
1254         else
1255                 res = pkgmgr_client_get_total_package_size_info(pc, __total_result_cb, user_data);
1256
1257         if (res == PKGMGR_R_EINVAL) {
1258                 pkgmgr_client_free(pc);
1259                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1260         } else if (res == PKGMGR_R_ENOPKG) {
1261                 pkgmgr_client_free(pc);
1262                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1263         } else if (res == PKGMGR_R_ENOMEM) {
1264                 pkgmgr_client_free(pc);
1265                 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
1266         } else if (res == PKGMGR_R_EIO) {
1267                 pkgmgr_client_free(pc);
1268                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
1269         } else if (res == PKGMGR_R_EPRIV) {
1270                 pkgmgr_client_free(pc);
1271                 return package_manager_error(PACKAGE_MANAGER_ERROR_PERMISSION_DENIED, __FUNCTION__, NULL);
1272         } else if (res == PKGMGR_R_ESYSTEM || res == PKGMGR_R_ECOMM || res == PKGMGR_R_ERROR) {
1273                 pkgmgr_client_free(pc);
1274                 return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
1275         } else if (res != PKGMGR_R_OK) {
1276                 _LOGE("Unexpected error");
1277                 pkgmgr_client_free(pc);
1278                 return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
1279         }
1280
1281         g_hash_table_insert(__cb_table, pc, callback);
1282
1283         return PACKAGE_MANAGER_ERROR_NONE;
1284 }
1285
1286 API int package_manager_get_package_size_info(const char *package_id, package_manager_size_info_receive_cb callback, void *user_data)
1287 {
1288         return _get_pkg_size_info(package_id, (void *)callback, user_data);
1289 }
1290
1291 API int package_manager_get_total_package_size_info(package_manager_total_size_info_receive_cb callback, void *user_data)
1292 {
1293         return _get_pkg_size_info(PKG_SIZE_INFO_TOTAL, (void *)callback, user_data);
1294 }
1295
1296 API int package_manager_filter_create(package_manager_filter_h *handle)
1297 {
1298         int retval;
1299         pkgmgrinfo_pkginfo_filter_h pkgmgr_filter = NULL;
1300
1301         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
1302         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1303                 return retval;
1304
1305         if (handle == NULL) {
1306                 return
1307                     package_manager_error
1308                     (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
1309                      NULL);
1310         }
1311
1312         retval = pkgmgrinfo_pkginfo_filter_create(&pkgmgr_filter);
1313         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1314                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
1315
1316         *handle = pkgmgr_filter;
1317
1318         return PACKAGE_MANAGER_ERROR_NONE;
1319 }
1320
1321 API int package_manager_filter_destroy(package_manager_filter_h handle)
1322 {
1323         int retval;
1324
1325         if (handle == NULL) {
1326                 return
1327                     package_manager_error
1328                     (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
1329                      NULL);
1330         }
1331
1332         retval = pkgmgrinfo_pkginfo_filter_destroy(handle);
1333         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1334                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
1335
1336         return PACKAGE_MANAGER_ERROR_NONE;
1337 }
1338
1339 API int package_manager_filter_add_bool(package_manager_filter_h handle,
1340                 const char *property, const bool value)
1341 {
1342         int retval;
1343
1344         if ((handle == NULL) || (property == NULL)) {
1345                 return
1346                     package_manager_error
1347                     (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
1348                      NULL);
1349         }
1350
1351         retval = pkgmgrinfo_pkginfo_filter_add_bool(handle, property, value);
1352         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1353                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
1354
1355         return PACKAGE_MANAGER_ERROR_NONE;
1356 }
1357
1358 API int package_manager_filter_count(package_manager_filter_h handle, int *count)
1359 {
1360
1361         int retval;
1362         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
1363         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1364                 return retval;
1365
1366         if ((handle == NULL) || (count == NULL))
1367                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1368
1369         retval = pkgmgrinfo_pkginfo_filter_count(handle, count);
1370         if (retval < 0)
1371                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
1372
1373         return PACKAGE_MANAGER_ERROR_NONE;
1374 }
1375
1376 API int package_manager_filter_foreach_package_info(package_manager_filter_h handle,
1377                 package_manager_package_info_cb callback, void *user_data)
1378 {
1379
1380         int retval;
1381         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
1382         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1383                 return retval;
1384
1385         retval = package_info_filter_foreach_package_info(handle, callback, user_data);
1386
1387         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1388                 return package_manager_error(retval, __FUNCTION__, NULL);
1389         else
1390                 return PACKAGE_MANAGER_ERROR_NONE;
1391 }
1392
1393 API int package_size_info_get_data_size(package_size_info_h handle, long long *data_size)
1394 {
1395         if (handle == NULL)
1396                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1397
1398         package_size_info_t *size_info = (package_size_info_t *)handle;
1399
1400         *data_size = (long long)size_info->data_size;
1401         return PACKAGE_MANAGER_ERROR_NONE;
1402 }
1403
1404 API int package_size_info_get_cache_size(package_size_info_h handle, long long *cache_size)
1405 {
1406         if (handle == NULL)
1407                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1408
1409         package_size_info_t *size_info = (package_size_info_t *)handle;
1410
1411         *cache_size = size_info->cache_size;
1412         return PACKAGE_MANAGER_ERROR_NONE;
1413 }
1414
1415 API int package_size_info_get_app_size(package_size_info_h handle, long long *app_size)
1416 {
1417         if (handle == NULL)
1418                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1419
1420         package_size_info_t *size_info = (package_size_info_t *)handle;
1421         *app_size = size_info->app_size;
1422         return PACKAGE_MANAGER_ERROR_NONE;
1423 }
1424
1425 API int package_size_info_get_external_data_size(package_size_info_h handle, long long *ext_data_size)
1426 {
1427         if (handle == NULL)
1428                 return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
1429
1430         package_size_info_t *size_info = (package_size_info_t *)handle;
1431         *ext_data_size = size_info->external_data_size;
1432         return PACKAGE_MANAGER_ERROR_NONE;
1433 }
1434
1435 API int package_size_info_get_external_cache_size(package_size_info_h handle, long long *ext_cache_size)
1436 {
1437         if (handle == NULL)
1438                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1439
1440         package_size_info_t *size_info = (package_size_info_t *)handle;
1441         *ext_cache_size = size_info->external_cache_size;
1442         return PACKAGE_MANAGER_ERROR_NONE;
1443 }
1444
1445 API int package_size_info_get_external_app_size(package_size_info_h handle, long long *ext_app_size)
1446 {
1447         if (handle == NULL)
1448                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1449
1450         package_size_info_t *size_info = (package_size_info_t *)handle;
1451         *ext_app_size = size_info->external_app_size;
1452         return PACKAGE_MANAGER_ERROR_NONE;
1453 }