src/package_manager.c

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