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