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