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         }
 463
 464         *id = request_id;
 465
 466         return PACKAGE_MANAGER_ERROR_NONE;
 467 }
 468
 469 API int package_manager_request_uninstall(package_manager_request_h request,
 470                                       const char *name, int *id)
 471 {
 472         if (package_manager_client_validate_handle(request)) {
 473                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 474         }
 475         if (name == NULL) {
 476                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 477         }
 478
 479         int request_id = 0;
 480         request->pkg_name = name;
 481         uid_t uid = getuid();
 482         if (uid != GLOBAL_USER)
 483                 request_id = pkgmgr_client_usr_uninstall(request->pc, request->pkg_type,
 484                                                                 request->pkg_name, request->mode,
 485                                                                 request_event_handler, request, uid);
 486         else
 487                 request_id = pkgmgr_client_uninstall(request->pc, request->pkg_type,
 488                                                                 request->pkg_name, request->mode,
 489                                                                 request_event_handler, request);
 490
 491         if (request_id == PKGMGR_R_EINVAL) {
 492                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 493         } else if (request_id == PKGMGR_R_ENOPKG) {
 494                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
 495         } else if (request_id == PKGMGR_R_ENOMEM) {
 496                 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
 497         } else if (request_id == PKGMGR_R_EIO) {
 498                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
 499         } else if (request_id == PKGMGR_R_EPRIV) {
 500                 return package_manager_error(PACKAGE_MANAGER_ERROR_PERMISSION_DENIED, __FUNCTION__, NULL);
 501         } else if (request_id == PKGMGR_R_ESYSTEM || request_id == PKGMGR_R_ECOMM || request_id == PKGMGR_R_ERROR) {
 502                 return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
 503         }
 504
 505         *id = request_id;
 506
 507         return PACKAGE_MANAGER_ERROR_NONE;
 508 }
 509
 510 API int package_manager_request_move(package_manager_request_h request,
 511                                     const char *name, package_manager_move_type_e move_type)
 512 {
 513         if (package_manager_client_validate_handle(request)) {
 514                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 515         }
 516         if (name == NULL) {
 517                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 518         }
 519
 520         int ret = 0;
 521         request->pkg_name = name;
 522         uid_t uid = getuid();
 523         if (uid != GLOBAL_USER)
 524                 ret = pkgmgr_client_usr_move(request->pc, request->pkg_type, request->pkg_name,
 525                                                         move_type, request->mode, uid);
 526         else
 527                 ret = pkgmgr_client_move(request->pc, request->pkg_type, request->pkg_name,
 528                                                         move_type, request->mode);
 529         if (ret == PKGMGR_R_EINVAL) {
 530                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 531         } else if (ret == PKGMGR_R_ENOPKG) {
 532                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
 533         } else if (ret == PKGMGR_R_ENOMEM) {
 534                 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
 535         } else if (ret == PKGMGR_R_EIO) {
 536                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
 537         } else if (ret == PKGMGR_R_EPRIV) {
 538                 return package_manager_error(PACKAGE_MANAGER_ERROR_PERMISSION_DENIED, __FUNCTION__, NULL);
 539         } else if (ret == PKGMGR_R_ESYSTEM || ret == PKGMGR_R_ECOMM || ret == PKGMGR_R_ERROR) {
 540                 return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
 541         }
 542
 543
 544         return PACKAGE_MANAGER_ERROR_NONE;
 545 }
 546
 547 API int package_manager_create(package_manager_h * manager)
 548 {
 549         struct package_manager_s *package_manager = NULL;
 550
 551         if (manager == NULL) {
 552                 return
 553                     package_manager_error
 554                     (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
 555                      NULL);
 556         }
 557
 558         package_manager = calloc(1, sizeof(struct package_manager_s));
 559         if (package_manager == NULL) {
 560                 return
 561                     package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY,
 562                                           __FUNCTION__,
 563                                           "failed to create a package_manager handle");
 564         }
 565
 566         package_manager->ctype = PC_LISTENING;
 567         package_manager->pc = pkgmgr_client_new(PC_LISTENING);
 568         if (package_manager->pc == NULL) {
 569                 free(package_manager);
 570                 return
 571                     package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY,
 572                                           __FUNCTION__,
 573                                           "failed to create a package_manager client");
 574         }
 575
 576         package_manager->handle_id = package_manager_new_id();
 577
 578         *manager = package_manager;
 579
 580         return PACKAGE_MANAGER_ERROR_NONE;
 581 }
 582
 583 static int package_manager_validate_handle(package_manager_h manager)
 584 {
 585         if (manager == NULL || manager->pc == NULL) {
 586                 return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
 587         }
 588
 589         return PACKAGE_MANAGER_ERROR_NONE;
 590 }
 591
 592 API int package_manager_destroy(package_manager_h manager)
 593 {
 594         if (package_manager_validate_handle(manager)) {
 595                 return
 596                     package_manager_error
 597                     (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
 598                      NULL);
 599         }
 600
 601         pkgmgr_client_free(manager->pc);
 602         manager->pc = NULL;
 603         free(manager);
 604
 605         return PACKAGE_MANAGER_ERROR_NONE;
 606 }
 607
 608 static int __add_event(event_info ** head, int req_id,
 609                             package_manager_event_type_e event_type,
 610                             package_manager_event_state_e event_state)
 611 {
 612         event_info *evt_info;
 613
 614         evt_info = (event_info *) calloc(1, sizeof(event_info));
 615         if (evt_info == NULL) {
 616                 _LOGD("calloc failed");
 617                 return -1;
 618         }
 619         evt_info->req_id = req_id;
 620         evt_info->event_type = event_type;
 621         evt_info->next = NULL;
 622
 623         *head = evt_info;
 624
 625         return 0;
 626 }
 627
 628 static int __find_event(event_info ** head, int req_id,
 629                              package_manager_event_type_e * event_type,
 630                              package_manager_event_state_e * event_state)
 631 {
 632         event_info *tmp;
 633
 634         tmp = *head;
 635
 636         if (tmp == NULL) {
 637                 _LOGE("tmp is NULL");
 638                 return -1;
 639         }
 640
 641         *event_type = tmp->event_type;
 642         return 0;
 643 }
 644
 645 static int __update_event(event_info ** head, int req_id,
 646                                package_manager_event_type_e event_type,
 647                                package_manager_event_state_e event_state)
 648 {
 649         package_manager_event_type_e evt_type;
 650         package_manager_event_state_e evt_state;
 651         event_info *tmp;
 652
 653         if (__find_event_info(head, req_id, &evt_type, &evt_state) != 0)
 654                 __add_event_info(head, req_id, event_type, event_state);
 655         else {
 656                 tmp = *head;
 657
 658                 if (tmp == NULL) {
 659                         _LOGE("tmp is NULL");
 660                         return -1;
 661                 }
 662
 663                 tmp->event_type = event_type;
 664                 return 0;
 665         }
 666
 667         return -1;
 668 }
 669
 670 /* App Event Listening Policy:
 671  * +----------------+------------+---------------+------------------+
 672  * |Listener \ Type |Global Event|My User's Event|Other user's Event|
 673  * +----------------+------------+---------------+------------------+
 674  * |User Process App|   Grant    |     Grant     |      Deny        |
 675  * +----------------+------------+---------------+------------------+
 676  * |Platform module |   Grant    |     Grant     |      Grant       |
 677  * +----------------+------------+---------------+------------------+
 678  * UID assignment policy:
 679  * https://wiki.tizen.org/wiki/Security/User_and_group_ID_assignment_policy
 680  */
 681 #define REGULAR_USER 5000
 682 static int __validate_event_signal(uid_t target_uid)
 683 {
 684         uid_t self = getuid();
 685
 686         if (self == target_uid)
 687                 return 0;
 688
 689         if (self < REGULAR_USER)
 690                 return 0;
 691
 692         return -1;
 693 }
 694
 695 static int global_event_handler(uid_t target_uid, int req_id, const char *pkg_type,
 696                                 const char *pkg_name, const char *key,
 697                                 const char *val, const void *pmsg, void *data)
 698 {
 699         int ret = -1;
 700         package_manager_event_type_e event_type = -1;
 701         package_manager_event_state_e event_state = -1;
 702
 703         _LOGD("global_event_handler is called");
 704
 705         package_manager_h manager = data;
 706
 707         if (__validate_event_signal(target_uid))
 708                 return PACKAGE_MANAGER_ERROR_NONE;
 709
 710         if (strcasecmp(key, "start") == 0) {
 711                 ret = package_manager_get_event_type(val, &event_type);
 712                 if (ret != PACKAGE_MANAGER_ERROR_NONE)
 713                         return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
 714
 715                 __add_event(&(manager->head), req_id, event_type,
 716                                  PACKAGE_MANAGER_EVENT_STATE_STARTED);
 717
 718                 if (manager->event_cb && getuid() == target_uid)
 719                         manager->event_cb(pkg_type, pkg_name,
 720                                           event_type,
 721                                           PACKAGE_MANAGER_EVENT_STATE_STARTED,
 722                                           0, PACKAGE_MANAGER_ERROR_NONE, manager->user_data);
 723                 if (manager->global_event_cb)
 724                         manager->global_event_cb(target_uid, pkg_type, pkg_name,
 725                                           event_type,
 726                                           PACKAGE_MANAGER_EVENT_STATE_STARTED,
 727                                           0, PACKAGE_MANAGER_ERROR_NONE, manager->user_data);
 728
 729         } else if (strcasecmp(key, "install_percent") == 0
 730                    || strcasecmp(key, "progress_percent") == 0) {
 731                 if (__find_event
 732                     (&(manager->head), req_id, &event_type,
 733                      &event_state) == 0) {
 734                         __update_event(&(manager->head), req_id,
 735                                             event_type,
 736                                             PACKAGE_MANAGER_EVENT_STATE_PROCESSING);
 737                         if (manager->event_cb && getuid() == target_uid)
 738                                 manager->event_cb(pkg_type, pkg_name,
 739                                                   event_type,
 740                                                   PACKAGE_MANAGER_EVENT_STATE_PROCESSING,
 741                                                   atoi(val),
 742                                                   PACKAGE_MANAGER_ERROR_NONE,
 743                                                   manager->user_data);
 744                         if (manager->global_event_cb)
 745                                 manager->global_event_cb(target_uid, pkg_type, pkg_name,
 746                                                   event_type,
 747                                                   PACKAGE_MANAGER_EVENT_STATE_PROCESSING,
 748                                                   atoi(val),
 749                                                   PACKAGE_MANAGER_ERROR_NONE,
 750                                                   manager->user_data);
 751                 }
 752
 753         } else if (strcasecmp(key, "error") == 0) {
 754                 if (strcasecmp(key, "0") != 0) {
 755                         if (__find_event
 756                             (&(manager->head), req_id, &event_type,
 757                              &event_state) == 0) {
 758                                 __update_event(&(manager->head), req_id,
 759                                                     event_type,
 760                                                     PACKAGE_MANAGER_EVENT_STATE_FAILED);
 761                         }
 762
 763                         if (manager->event_cb && getuid() == target_uid)
 764                                 manager->event_cb(pkg_type,
 765                                                   pkg_name, event_type,
 766                                                   PACKAGE_MANAGER_EVENT_STATE_FAILED,
 767                                                   0,
 768                                                   PACKAGE_MANAGER_ERROR_NONE,
 769                                                   manager->user_data);
 770                         if (manager->global_event_cb)
 771                                 manager->global_event_cb(target_uid, pkg_type,
 772                                                   pkg_name, event_type,
 773                                                   PACKAGE_MANAGER_EVENT_STATE_FAILED,
 774                                                   0,
 775                                                   PACKAGE_MANAGER_ERROR_NONE,
 776                                                   manager->user_data);
 777                 }
 778         } else if (strcasecmp(key, "end") == 0) {
 779                 if (__find_event
 780                     (&(manager->head), req_id, &event_type,
 781                      &event_state) == 0) {
 782                         if (event_state != PACKAGE_MANAGER_EVENT_STATE_FAILED) {
 783                                 if (manager->event_cb && getuid() == target_uid)
 784                                         manager->event_cb(pkg_type,
 785                                                           pkg_name, event_type,
 786                                                           PACKAGE_MANAGER_EVENT_STATE_COMPLETED,
 787                                                           100,
 788                                                           PACKAGE_MANAGER_ERROR_NONE,
 789                                                           manager->user_data);
 790                                 if (manager->global_event_cb)
 791                                         manager->global_event_cb(target_uid, pkg_type,
 792                                                           pkg_name, event_type,
 793                                                           PACKAGE_MANAGER_EVENT_STATE_COMPLETED,
 794                                                           100,
 795                                                           PACKAGE_MANAGER_ERROR_NONE,
 796                                                           manager->user_data);
 797                         }
 798                 } else {
 799                         if (strcasecmp(key, "ok") != 0) {
 800                                 if (manager->event_cb && getuid() == target_uid)
 801                                         manager->event_cb(pkg_type,
 802                                                           pkg_name, event_type,
 803                                                           PACKAGE_MANAGER_EVENT_STATE_FAILED,
 804                                                           0,
 805                                                           PACKAGE_MANAGER_ERROR_NONE,
 806                                                           manager->user_data);
 807                                 if (manager->global_event_cb)
 808                                         manager->global_event_cb(target_uid, pkg_type,
 809                                                           pkg_name, event_type,
 810                                                           PACKAGE_MANAGER_EVENT_STATE_FAILED,
 811                                                           0,
 812                                                           PACKAGE_MANAGER_ERROR_NONE,
 813                                                           manager->user_data);
 814                         }
 815                 }
 816         }
 817
 818         return PACKAGE_MANAGER_ERROR_NONE;
 819 }
 820
 821 API int package_manager_set_event_status(package_manager_h manager, int status_type)
 822 {
 823         int retval;
 824
 825         if (manager == NULL){
 826                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 827         }
 828
 829         retval = pkgmgrinfo_client_set_status_type(manager->pc, status_type);
 830
 831         if (retval < 0){
 832                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
 833         }
 834
 835         return PACKAGE_MANAGER_ERROR_NONE;
 836 }
 837
 838 API int package_manager_set_event_cb(package_manager_h manager,
 839                                  package_manager_event_cb callback,
 840                                  void *user_data)
 841 {
 842         if (package_manager_validate_handle(manager)) {
 843                 return
 844                     package_manager_error
 845                     (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
 846                      NULL);
 847         }
 848
 849         manager->event_cb = callback;
 850         manager->user_data = user_data;
 851
 852     pkgmgr_client_listen_status(manager->pc, global_event_handler, manager);
 853
 854         return PACKAGE_MANAGER_ERROR_NONE;
 855 }
 856
 857 API int package_manager_unset_event_cb(package_manager_h manager)
 858 {
 859         if (manager == NULL) {
 860                 return
 861                     package_manager_error
 862                     (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
 863                      NULL);
 864         }
 865
 866         // TODO: Please implement this function.
 867         return PACKAGE_MANAGER_ERROR_NONE;
 868 }
 869
 870 API int package_manager_set_global_event_cb(package_manager_h manager,
 871                                  package_manager_global_event_cb callback,
 872                                  void *user_data)
 873 {
 874         if (package_manager_validate_handle(manager)) {
 875                 return
 876                     package_manager_error
 877                     (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
 878                      NULL);
 879         }
 880
 881         if (getuid() >= REGULAR_USER) {
 882                 _LOGE("Regular user is not allowed for this api");
 883                 return PACKAGE_MANAGER_ERROR_PERMISSION_DENIED;
 884         }
 885
 886         manager->global_event_cb = callback;
 887         manager->user_data = user_data;
 888
 889     pkgmgr_client_listen_status(manager->pc, global_event_handler, manager);
 890
 891         return PACKAGE_MANAGER_ERROR_NONE;
 892 }
 893
 894 API int package_manager_unset_global_event_cb(package_manager_h manager)
 895 {
 896         if (manager == NULL) {
 897                 return
 898                     package_manager_error
 899                     (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
 900                      NULL);
 901         }
 902
 903         // TODO: Please implement this function.
 904         return PACKAGE_MANAGER_ERROR_NONE;
 905 }
 906
 907 API int package_manager_get_package_id_by_app_id(const char *app_id, char **package_id)
 908 {
 909         pkgmgrinfo_appinfo_h pkgmgrinfo_appinfo;
 910         int retval;
 911         char *pkg_id = NULL;
 912         char *pkg_id_dup = NULL;
 913
 914         if (app_id == NULL || package_id == NULL)
 915                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 916
 917         uid_t uid = getuid();
 918         if (uid != GLOBAL_USER)
 919         {
 920                 if (pkgmgrinfo_appinfo_get_usr_appinfo(app_id, uid, &pkgmgrinfo_appinfo) != PMINFO_R_OK)
 921                         return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
 922         } else
 923         {
 924                 if (pkgmgrinfo_appinfo_get_appinfo(app_id, &pkgmgrinfo_appinfo) != PMINFO_R_OK)
 925                         return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
 926         }
 927         retval = pkgmgrinfo_appinfo_get_pkgname(pkgmgrinfo_appinfo, &pkg_id);
 928         if (retval != PMINFO_R_OK)
 929         {
 930                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
 931         }
 932
 933         pkg_id_dup = strdup(pkg_id);
 934         if (pkg_id_dup == NULL)
 935         {
 936                 pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
 937                 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
 938         }
 939
 940         *package_id = pkg_id_dup;
 941
 942         pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
 943
 944         return PACKAGE_MANAGER_ERROR_NONE;
 945 }
 946
 947 API int package_manager_get_package_info(const char *package_id, package_info_h *package_info)
 948 {
 949         int retval;
 950
 951         retval = package_info_get_package_info(package_id, package_info);
 952
 953         if (retval != PACKAGE_MANAGER_ERROR_NONE)
 954                 return package_manager_error(retval, __FUNCTION__, NULL);
 955         else
 956                 return PACKAGE_MANAGER_ERROR_NONE;
 957 }
 958
 959 API int package_manager_foreach_package_info(package_manager_package_info_cb callback,
 960                                         void *user_data)
 961 {
 962         int retval;
 963
 964         retval = package_info_foreach_package_info(callback, user_data);
 965
 966         if (retval != PACKAGE_MANAGER_ERROR_NONE)
 967                 return package_manager_error(retval, __FUNCTION__, NULL);
 968         else
 969         {
 970                 return PACKAGE_MANAGER_ERROR_NONE;
 971         }
 972 }
 973
 974 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)
 975 {
 976         pkgmgrinfo_cert_compare_result_type_e result;
 977   uid_t uid = getuid();
 978
 979         if (lhs_package_id == NULL || rhs_package_id == NULL || compare_result == NULL)
 980                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 981         if (uid != GLOBAL_USER)
 982         {
 983                 if (pkgmgrinfo_pkginfo_compare_usr_pkg_cert_info(lhs_package_id, rhs_package_id, uid, &result) != PKGMGR_R_OK)
 984                         return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
 985         } else
 986         {
 987                 if (pkgmgrinfo_pkginfo_compare_pkg_cert_info(lhs_package_id, rhs_package_id, &result) != PKGMGR_R_OK)
 988                         return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
 989         }
 990         *compare_result = (package_manager_compare_result_type_e)result;
 991
 992         return PACKAGE_MANAGER_ERROR_NONE;
 993 }
 994
 995 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)
 996 {
 997         pkgmgrinfo_cert_compare_result_type_e result;
 998         uid_t uid = getuid();
 999
1000         if (lhs_app_id == NULL || rhs_app_id == NULL || compare_result == NULL)
1001                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1002         if (uid != GLOBAL_USER)
1003         {
1004                 if (pkgmgrinfo_pkginfo_compare_usr_app_cert_info(lhs_app_id, rhs_app_id, uid, &result) != PKGMGR_R_OK)
1005                         return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
1006         } else
1007         {
1008                 if (pkgmgrinfo_pkginfo_compare_app_cert_info(lhs_app_id, rhs_app_id, &result) != PKGMGR_R_OK)
1009                         return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
1010         }
1011
1012         *compare_result = (package_manager_compare_result_type_e)result;
1013
1014         return PACKAGE_MANAGER_ERROR_NONE;
1015 }
1016
1017 API int package_manager_is_preload_package_by_app_id(const char *app_id, bool *preload)
1018 {
1019         pkgmgrinfo_appinfo_h pkgmgrinfo_appinfo = NULL;
1020         pkgmgrinfo_pkginfo_h pkgmgrinfo_pkginfo = NULL;
1021
1022         int retval =0;
1023         char *pkg_id = NULL;
1024         bool is_preload = 0;
1025         uid_t uid = getuid();
1026         if (uid != GLOBAL_USER)
1027         {
1028                 if (pkgmgrinfo_appinfo_get_usr_appinfo(app_id, uid, &pkgmgrinfo_appinfo) != PMINFO_R_OK)
1029                         return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1030         } else
1031   {
1032                 if (pkgmgrinfo_appinfo_get_appinfo(app_id, &pkgmgrinfo_appinfo) != PMINFO_R_OK)
1033                         return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1034   }
1035         retval = pkgmgrinfo_appinfo_get_pkgname(pkgmgrinfo_appinfo, &pkg_id);
1036         if (retval != PMINFO_R_OK)
1037         {
1038                 pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
1039                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1040         }
1041         if (uid != GLOBAL_USER)
1042         {
1043                 if (pkgmgrinfo_pkginfo_get_usr_pkginfo(pkg_id, uid, &pkgmgrinfo_pkginfo) != PMINFO_R_OK)
1044                 {
1045                         pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
1046                         pkgmgrinfo_pkginfo_destroy_pkginfo(pkgmgrinfo_pkginfo);
1047                         return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1048                 }
1049         } else
1050         {
1051                 if (pkgmgrinfo_pkginfo_get_pkginfo(pkg_id, &pkgmgrinfo_pkginfo) != PMINFO_R_OK)
1052                 {
1053                         pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
1054                         pkgmgrinfo_pkginfo_destroy_pkginfo(pkgmgrinfo_pkginfo);
1055                         return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1056                 }
1057         }
1058         if (pkgmgrinfo_pkginfo_is_preload(pkgmgrinfo_pkginfo, &is_preload) != PMINFO_R_OK)
1059         {
1060                 pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
1061                 pkgmgrinfo_pkginfo_destroy_pkginfo(pkgmgrinfo_pkginfo);
1062                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1063         }
1064
1065         if (is_preload)
1066                 *preload = 1;
1067         else
1068                 *preload = 0;
1069
1070         pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
1071         pkgmgrinfo_pkginfo_destroy_pkginfo(pkgmgrinfo_pkginfo);
1072
1073         return PACKAGE_MANAGER_ERROR_NONE;
1074 }
1075
1076 API int package_manager_get_permission_type(const char *app_id, package_manager_permission_type_e *permission_type)
1077 {
1078         int retval = 0;
1079         pkgmgrinfo_appinfo_h pkgmgrinfo_appinfo =NULL;
1080         pkgmgrinfo_permission_type permission = 0;
1081         uid_t uid = getuid();
1082         if (uid != GLOBAL_USER)
1083         {
1084                 if (pkgmgrinfo_appinfo_get_usr_appinfo(app_id, uid, &pkgmgrinfo_appinfo) != PMINFO_R_OK)
1085                         return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1086         } else {
1087                 if (pkgmgrinfo_appinfo_get_appinfo(app_id, &pkgmgrinfo_appinfo) != PMINFO_R_OK)
1088                         return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1089         }
1090         retval = pkgmgrinfo_appinfo_get_permission_type(pkgmgrinfo_appinfo, &permission);
1091         if (retval != PMINFO_R_OK)
1092                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1093
1094         if (permission == PMINFO_PERMISSION_NORMAL)
1095                 *permission_type = PACKAGE_MANAGER_PERMISSION_NORMAL;
1096         else if (permission == PMINFO_PERMISSION_SIGNATURE)
1097                 *permission_type = PACKAGE_MANAGER_PERMISSION_SIGNATURE;
1098         else if (permission == PMINFO_PERMISSION_PRIVILEGE)
1099                 *permission_type = PACKAGE_MANAGER_PERMISSION_PRIVILEGE;
1100         else
1101                 *permission_type = PACKAGE_MANAGER_PERMISSION_NORMAL;
1102
1103         pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
1104         return PACKAGE_MANAGER_ERROR_NONE;
1105 }
1106
1107 API int package_manager_clear_cache_dir(const char *package_id)
1108 {
1109         int res = pkgmgr_client_usr_clear_cache_dir(package_id, getuid());
1110         if (res == PKGMGR_R_EINVAL)
1111         {
1112                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1113         }
1114         else if (res == PKGMGR_R_ENOPKG)
1115         {
1116                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1117         }
1118         else if (res == PKGMGR_R_ENOMEM)
1119         {
1120                 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
1121         }
1122         else if (res == PKGMGR_R_EIO)
1123         {
1124                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
1125         }
1126         else if (res == PKGMGR_R_EPRIV)
1127         {
1128                 return package_manager_error(PACKAGE_MANAGER_ERROR_PERMISSION_DENIED, __FUNCTION__, NULL);
1129         }
1130         else if (res == PKGMGR_R_ESYSTEM || res == PKGMGR_R_ECOMM || res == PKGMGR_R_ERROR)
1131         {
1132                 return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
1133         }
1134         else if (res != PKGMGR_R_OK)
1135         {
1136                 _LOGE("Unexpected error");
1137                 return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
1138         }
1139
1140         return PACKAGE_MANAGER_ERROR_NONE;
1141 }
1142
1143 API int package_manager_clear_all_cache_dir(void)
1144 {
1145         return package_manager_clear_cache_dir(PKG_CLEAR_ALL_CACHE);
1146 }
1147
1148 static void __initialize_cb_table(void)
1149 {
1150         __cb_table = g_hash_table_new_full(g_int_hash, g_int_equal, pkgmgr_client_free, NULL);
1151 }
1152
1153 static void __result_cb(pkgmgr_client *pc, const char *pkgid, const pkg_size_info_t *result, void *user_data)
1154 {
1155         package_manager_size_info_receive_cb callback = g_hash_table_lookup(__cb_table, pc);
1156         if (callback == NULL)
1157         {
1158                 _LOGE("callback is null.");
1159                 g_hash_table_remove(__cb_table, pc);
1160                 return;
1161         }
1162
1163         package_size_info_t size_info;
1164         size_info.data_size  = result->data_size;
1165         size_info.cache_size = result->cache_size;
1166         size_info.app_size   = result->app_size;
1167         size_info.external_data_size  = result->ext_data_size;
1168         size_info.external_cache_size = result->ext_cache_size;
1169         size_info.external_app_size   = result->ext_app_size;
1170
1171         callback(pkgid, &size_info, user_data);
1172
1173         g_hash_table_remove(__cb_table, pc);
1174 }
1175
1176 static void __total_result_cb(pkgmgr_client *pc, const pkg_size_info_t *result, void *user_data)
1177 {
1178         package_manager_total_size_info_receive_cb callback = g_hash_table_lookup(__cb_table, pc);
1179         if (callback == NULL)
1180         {
1181                 _LOGE("callback is null.");
1182                 g_hash_table_remove(__cb_table, pc);
1183                 return;
1184         }
1185
1186         package_size_info_t size_info;
1187         size_info.data_size  = result->data_size;
1188         size_info.cache_size = result->cache_size;
1189         size_info.app_size   = result->app_size;
1190         size_info.external_data_size  = result->ext_data_size;
1191         size_info.external_cache_size = result->ext_cache_size;
1192         size_info.external_app_size   = result->ext_app_size;
1193
1194         callback(&size_info, user_data);
1195
1196         g_hash_table_remove(__cb_table, pc);
1197 }
1198
1199 API int package_manager_get_package_size_info(const char *package_id, package_manager_size_info_receive_cb callback, void *user_data)
1200 {
1201         if (package_id == NULL || callback == NULL)
1202         {
1203                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1204         }
1205
1206         if (__cb_table == NULL)
1207         {
1208                 __initialize_cb_table();
1209         }
1210
1211         pkgmgr_client *pc = pkgmgr_client_new(PC_REQUEST);
1212         if (pc == NULL)
1213         {
1214                 return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
1215         }
1216
1217         int res = 0;
1218         if (strcmp(package_id, PKG_SIZE_INFO_TOTAL) != 0)
1219         {
1220                 res = pkgmgr_client_usr_get_package_size_info(pc, package_id, __result_cb, user_data, getuid());
1221         }
1222         else
1223         {
1224                 res = pkgmgr_client_usr_get_total_package_size_info(pc, __total_result_cb, user_data, getuid());
1225         }
1226
1227         if (res == PKGMGR_R_EINVAL)
1228         {
1229                 pkgmgr_client_free(pc);
1230                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1231         }
1232         else if (res == PKGMGR_R_ENOPKG)
1233         {
1234                 pkgmgr_client_free(pc);
1235                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1236         }
1237         else if (res == PKGMGR_R_ENOMEM)
1238         {
1239                 pkgmgr_client_free(pc);
1240                 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
1241         }
1242         else if (res == PKGMGR_R_EIO)
1243         {
1244                 pkgmgr_client_free(pc);
1245                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
1246         }
1247         else if (res == PKGMGR_R_EPRIV)
1248         {
1249                 pkgmgr_client_free(pc);
1250                 return package_manager_error(PACKAGE_MANAGER_ERROR_PERMISSION_DENIED, __FUNCTION__, NULL);
1251         }
1252         else if (res == PKGMGR_R_ESYSTEM || res == PKGMGR_R_ECOMM || res == PKGMGR_R_ERROR)
1253         {
1254                 pkgmgr_client_free(pc);
1255                 return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
1256         }
1257         else if (res != PKGMGR_R_OK)
1258         {
1259                 _LOGE("Unexpected error");
1260                 pkgmgr_client_free(pc);
1261                 return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
1262         }
1263
1264         g_hash_table_insert(__cb_table, pc, callback);
1265
1266         _LOGD("Successful");
1267         return PACKAGE_MANAGER_ERROR_NONE;
1268 }
1269
1270 API int package_manager_get_total_package_size_info(package_manager_total_size_info_receive_cb callback, void *user_data)
1271 {
1272         return package_manager_get_package_size_info(PKG_SIZE_INFO_TOTAL, callback, user_data);
1273 }
1274
1275 API int package_manager_filter_create(package_manager_filter_h *handle)
1276 {
1277         int retval;
1278         pkgmgrinfo_pkginfo_filter_h pkgmgr_filter = NULL;
1279
1280         if (handle == NULL)
1281         {
1282                 return
1283                     package_manager_error
1284                     (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
1285                      NULL);
1286         }
1287
1288         retval = pkgmgrinfo_pkginfo_filter_create(&pkgmgr_filter);
1289         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1290         {
1291                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
1292         }
1293
1294         *handle = pkgmgr_filter;
1295
1296         return PACKAGE_MANAGER_ERROR_NONE;
1297 }
1298
1299 API int package_manager_filter_destroy(package_manager_filter_h handle)
1300 {
1301         int retval;
1302
1303         if (handle == NULL)
1304         {
1305                 return
1306                     package_manager_error
1307                     (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
1308                      NULL);
1309         }
1310
1311         retval = pkgmgrinfo_pkginfo_filter_destroy(handle);
1312         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1313         {
1314                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
1315         }
1316
1317         return PACKAGE_MANAGER_ERROR_NONE;
1318 }
1319
1320 API int package_manager_filter_add_bool(package_manager_filter_h handle,
1321                 const char *property, const bool value)
1322 {
1323         int retval;
1324
1325         if ((handle == NULL) || (property == NULL))
1326         {
1327                 return
1328                     package_manager_error
1329                     (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
1330                      NULL);
1331         }
1332
1333         retval = pkgmgrinfo_pkginfo_filter_add_bool(handle, property, value);
1334         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1335         {
1336                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
1337         }
1338
1339         return PACKAGE_MANAGER_ERROR_NONE;
1340 }
1341
1342 API int package_manager_filter_count(package_manager_filter_h handle, int *count)
1343 {
1344         int retval = 0;
1345
1346         if ((handle == NULL) || (count == NULL))
1347         {
1348                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1349         }
1350
1351         retval = pkgmgrinfo_pkginfo_filter_count(handle, count);
1352         if (retval < 0)
1353         {
1354                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
1355         }
1356
1357         return PACKAGE_MANAGER_ERROR_NONE;
1358 }
1359
1360 API int package_manager_filter_foreach_package_info(package_manager_filter_h handle,
1361                 package_manager_package_info_cb callback, void *user_data)
1362 {
1363         int retval;
1364
1365         retval = package_info_filter_foreach_package_info(handle, callback, user_data);
1366
1367         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1368         {
1369                 return package_manager_error(retval, __FUNCTION__, NULL);
1370         }
1371         else
1372         {
1373                 return PACKAGE_MANAGER_ERROR_NONE;
1374         }
1375 }
1376
1377 API int package_manager_drm_generate_license_request(const char *resp_data, char **req_data, char **license_url)
1378 {
1379         if (resp_data == NULL || req_data == NULL || license_url == NULL) {
1380                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1381         }
1382
1383         /* TODO */
1384         return PACKAGE_MANAGER_ERROR_NONE;
1385 }
1386
1387 API int package_manager_drm_register_license(const char *resp_data)
1388 {
1389         if (resp_data == NULL) {
1390                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1391         }
1392
1393         /* TODO */
1394         return PACKAGE_MANAGER_ERROR_NONE;
1395 }
1396
1397 API int package_manager_drm_decrypt_package(const char *drm_file_path, const char *decrypted_file_path)
1398 {
1399         if (drm_file_path == NULL || decrypted_file_path == NULL) {
1400                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1401         }
1402
1403         /* TODO */
1404         return PACKAGE_MANAGER_ERROR_NONE;
1405 }
1406
1407 API int package_size_info_get_data_size(package_size_info_h handle, long long *data_size)
1408 {
1409         if (handle == NULL)
1410                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1411
1412         package_size_info_t *size_info = (package_size_info_t *)handle;
1413
1414         *data_size = (long long)size_info->data_size;
1415         return PACKAGE_MANAGER_ERROR_NONE;
1416 }
1417
1418 API int package_size_info_get_cache_size(package_size_info_h handle, long long *cache_size)
1419 {
1420         if (handle == NULL)
1421                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1422
1423         package_size_info_t *size_info = (package_size_info_t *)handle;
1424
1425         *cache_size = size_info->cache_size;
1426         return PACKAGE_MANAGER_ERROR_NONE;
1427 }
1428
1429 API int package_size_info_get_app_size(package_size_info_h handle, long long *app_size)
1430 {
1431         if (handle == NULL)
1432                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1433
1434         package_size_info_t *size_info = (package_size_info_t *)handle;
1435         *app_size = size_info->app_size;
1436         return PACKAGE_MANAGER_ERROR_NONE;
1437 }
1438
1439 API int package_size_info_get_external_data_size(package_size_info_h handle, long long *ext_data_size)
1440 {
1441         if (handle == NULL)
1442                 return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
1443
1444         package_size_info_t *size_info = (package_size_info_t *)handle;
1445         *ext_data_size = size_info->external_data_size;
1446         return PACKAGE_MANAGER_ERROR_NONE;
1447 }
1448
1449 API int package_size_info_get_external_cache_size(package_size_info_h handle, long long *ext_cache_size)
1450 {
1451         if (handle == NULL)
1452                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1453
1454         package_size_info_t *size_info = (package_size_info_t *)handle;
1455         *ext_cache_size = size_info->external_cache_size;
1456         return PACKAGE_MANAGER_ERROR_NONE;
1457 }
1458
1459 API int package_size_info_get_external_app_size(package_size_info_h handle, long long *ext_app_size)
1460 {
1461         if (handle == NULL)
1462                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1463
1464         package_size_info_t *size_info = (package_size_info_t *)handle;
1465         *ext_app_size = size_info->external_app_size;
1466         return PACKAGE_MANAGER_ERROR_NONE;
1467 }