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