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