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