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