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 <dlog.h>
  20 #include <unistd.h>
  21
  22 #include <package-manager.h>
  23 #include <package_manager.h>
  24 #include <package_manager_private.h>
  25 #include <pkgmgr-info.h>
  26 #include <tzplatform_config.h>
  27
  28
  29 #ifdef LOG_TAG
  30 #undef LOG_TAG
  31 #endif
  32
  33 #define LOG_TAG "CAPI_APPFW_PACKAGE_MANAGER"
  34
  35 #define _LOGE(fmt, arg...) LOGE(fmt,##arg)
  36 #define _LOGD(fmt, arg...) LOGD(fmt, ##arg)
  37
  38 #define GLOBAL_USER tzplatform_getuid(TZ_SYS_GLOBALAPP_USER)
  39 typedef struct _event_info {
  40         int req_id;
  41         package_manager_event_type_e event_type;
  42         package_manager_event_state_e event_state;
  43         struct _event_info *next;
  44 } event_info;
  45
  46 struct package_manager_s {
  47         int handle_id;
  48         client_type ctype;
  49         pkgmgr_client *pc;
  50         pkgmgr_mode mode;
  51         event_info *head;
  52         package_manager_event_cb event_cb;
  53         void *user_data;
  54 };
  55
  56 struct package_manager_request_s {
  57         int handle_id;
  58         client_type ctype;
  59         pkgmgr_client *pc;
  60         const char *pkg_type;
  61         const char *pkg_path;
  62         const char *pkg_name;
  63         pkgmgr_mode mode;
  64         event_info *head;
  65         package_manager_request_event_cb event_cb;
  66         void *user_data;
  67 };
  68
  69 static int package_manager_request_new_id()
  70 {
  71         static int request_handle_id = 0;
  72         return request_handle_id++;
  73 }
  74
  75 static int package_manager_new_id()
  76 {
  77         static int manager_handle_id = 0;
  78         return manager_handle_id++;
  79 }
  80
  81 static const char *package_manager_error_to_string(package_manager_error_e
  82                                                    error)
  83 {
  84         switch (error) {
  85         case PACKAGE_MANAGER_ERROR_NONE:
  86                 return "NONE";
  87
  88         case PACKAGE_MANAGER_ERROR_INVALID_PARAMETER:
  89                 return "INVALID_PARAMETER";
  90
  91         case PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY:
  92                 return "OUT_OF_MEMORY";
  93
  94         case PACKAGE_MANAGER_ERROR_IO_ERROR:
  95                 return "IO_ERROR";
  96         default:
  97                 return "UNKNOWN";
  98         }
  99 }
 100
 101 int package_manager_error(package_manager_error_e error,
 102                                  const char *function, const char *description)
 103 {
 104         if (description) {
 105                 _LOGE("[%s] %s(0x%08x) : %s", function,
 106                      package_manager_error_to_string(error), error,
 107                      description);
 108         } else {
 109                 _LOGE("[%s] %s(0x%08x)", function,
 110                      package_manager_error_to_string(error), error);
 111         }
 112
 113         return error;
 114 }
 115
 116 int package_manager_request_create(package_manager_request_h * request)
 117 {
 118         struct package_manager_request_s *package_manager_request;
 119
 120         if (request == NULL) {
 121                 return
 122                     package_manager_error
 123                     (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
 124                      NULL);
 125         }
 126
 127         package_manager_request =
 128             calloc(1, sizeof(struct package_manager_request_s));
 129         if (package_manager_request == NULL) {
 130                 return
 131                     package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY,
 132                                           __FUNCTION__,
 133                                           "failed to create a package_manager handle");
 134         }
 135
 136         package_manager_request->ctype = PC_REQUEST;
 137         package_manager_request->pc = pkgmgr_client_new(PC_REQUEST);
 138         if (package_manager_request->pc == NULL) {
 139                 free(package_manager_request);
 140                 return
 141                     package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY,
 142                                           __FUNCTION__,
 143                                           "failed to create a package_manager client");
 144         }
 145
 146         package_manager_request->handle_id = package_manager_request_new_id();
 147
 148         *request = package_manager_request;
 149
 150         return PACKAGE_MANAGER_ERROR_NONE;
 151 }
 152
 153 static int package_manager_client_valiate_handle(package_manager_request_h
 154                                                  request)
 155 {
 156         if (request == NULL || request->pc == NULL) {
 157                 return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
 158         }
 159
 160         return PACKAGE_MANAGER_ERROR_NONE;
 161 }
 162
 163 int package_manager_client_destroy(package_manager_request_h request)
 164 {
 165         if (package_manager_client_valiate_handle(request)) {
 166                 return
 167                     package_manager_error
 168                     (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
 169                      NULL);
 170         }
 171
 172         pkgmgr_client_free(request->pc);
 173         request->pc = NULL;
 174         free(request);
 175
 176         return PACKAGE_MANAGER_ERROR_NONE;
 177 }
 178
 179 int package_manager_request_destroy(package_manager_request_h request)
 180 {
 181         if (package_manager_client_valiate_handle(request)) {
 182                 return
 183                     package_manager_error
 184                     (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
 185                      NULL);
 186         }
 187
 188         pkgmgr_client_free(request->pc);
 189         request->pc = NULL;
 190         free(request);
 191
 192         return PACKAGE_MANAGER_ERROR_NONE;
 193 }
 194
 195 int package_manager_request_set_event_cb(package_manager_request_h request,
 196                                          package_manager_request_event_cb
 197                                          callback, void *user_data)
 198 {
 199         if (package_manager_client_valiate_handle(request)) {
 200                 return
 201                     package_manager_error
 202                     (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
 203                      NULL);
 204         }
 205
 206         request->event_cb = callback;
 207         request->user_data = user_data;
 208
 209         return PACKAGE_MANAGER_ERROR_NONE;
 210 }
 211
 212 int package_manager_request_unset_event_cb(package_manager_request_h request)
 213 {
 214         // TODO: Please implement this function.
 215         return PACKAGE_MANAGER_ERROR_NONE;
 216 }
 217
 218
 219 int package_manager_request_set_type(package_manager_request_h request,
 220                                      const char *pkg_type)
 221 {
 222         if (package_manager_client_valiate_handle(request)) {
 223                 return
 224                     package_manager_error
 225                     (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
 226                      NULL);
 227         }
 228
 229         request->pkg_type = pkg_type;
 230
 231         return PACKAGE_MANAGER_ERROR_NONE;
 232 }
 233
 234 int package_manager_request_set_mode(package_manager_request_h request,
 235                                      package_manager_request_mode_e mode)
 236 {
 237         if (package_manager_client_valiate_handle(request)) {
 238                 return
 239                     package_manager_error
 240                     (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
 241                      NULL);
 242         }
 243
 244         if (mode == PACKAGE_MANAGER_REQUEST_MODE_QUIET)
 245                 request->mode = PM_QUIET;
 246         else
 247                 request->mode = PM_DEFAULT;
 248
 249         return PACKAGE_MANAGER_ERROR_NONE;
 250 }
 251
 252 static int package_manager_get_event_type(const char *key,
 253                                           package_manager_event_type_e *
 254                                           event_type)
 255 {
 256         if (key == NULL)
 257                 return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
 258
 259         if (strcasecmp(key, "install") == 0)
 260                 *event_type = PACKAGE_MANAGER_EVENT_TYPE_INSTALL;
 261         else if (strcasecmp(key, "uninstall") == 0)
 262                 *event_type = PACKAGE_MANAGER_EVENT_TYPE_UNINSTALL;
 263         else if (strcasecmp(key, "update") == 0)
 264                 *event_type = PACKAGE_MANAGER_EVENT_TYPE_UPDATE;
 265         else
 266                 return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
 267
 268         return PACKAGE_MANAGER_ERROR_NONE;
 269 }
 270
 271 static int __add_event_info(event_info ** head, int req_id,
 272                             package_manager_event_type_e event_type,
 273                             package_manager_event_state_e event_state)
 274 {
 275         event_info *evt_info;
 276         event_info *current;
 277         event_info *prev;
 278
 279         evt_info = (event_info *) calloc(1, sizeof(event_info));
 280         if (evt_info == NULL) {
 281                 _LOGD("calloc failed");
 282                 return -1;
 283         }
 284         evt_info->req_id = req_id;
 285         evt_info->event_type = event_type;
 286         evt_info->next = NULL;
 287
 288         if (*head == NULL)
 289                 *head = evt_info;
 290         else {
 291                 current = prev = *head;
 292                 while (current) {
 293                         prev = current;
 294                         current = current->next;
 295                 }
 296
 297                 prev->next = evt_info;
 298         }
 299
 300         return 0;
 301 }
 302
 303 static int __find_event_info(event_info ** head, int req_id,
 304                              package_manager_event_type_e * event_type,
 305                              package_manager_event_state_e * event_state)
 306 {
 307         event_info *tmp;
 308
 309         tmp = *head;
 310
 311         if (tmp == NULL) {
 312                 _LOGE("tmp is NULL");
 313                 return -1;
 314         }
 315
 316         _LOGD("tmp->req_id %d, event_type %d", tmp->req_id, event_type);
 317
 318         while (tmp) {
 319                 if (tmp->req_id == req_id) {
 320                         *event_type = tmp->event_type;
 321                         return 0;
 322                 }
 323                 tmp = tmp->next;
 324         }
 325         return -1;
 326 }
 327
 328 static int __update_event_info(event_info ** head, int req_id,
 329                                package_manager_event_type_e event_type,
 330                                package_manager_event_state_e event_state)
 331 {
 332         package_manager_event_type_e evt_type;
 333         package_manager_event_state_e evt_state;
 334         event_info *tmp;
 335
 336         if (__find_event_info(head, req_id, &evt_type, &evt_state) != 0)
 337                 __add_event_info(head, req_id, event_type, event_state);
 338         else {
 339                 tmp = *head;
 340
 341                 if (tmp == NULL) {
 342                         _LOGE("tmp is NULL");
 343                         return -1;
 344                 }
 345
 346                 while (tmp) {
 347                         if (tmp->req_id == req_id) {
 348                                 tmp->event_type = event_type;
 349                                 return 0;
 350                         }
 351                         tmp = tmp->next;
 352                 }
 353         }
 354
 355         return -1;
 356 }
 357
 358 /*
 359 static int __remove_event_info(event_info **head request, int req_id)
 360 {
 361         event_info *current;
 362         event_info *tmp;
 363
 364         if (* == NULL)
 365                 return -1;
 366
 367         current = *head;
 368         while (current) {
 369                 if (current->next) {
 370                         if (current->next->req_id == req_id) {
 371                                 tmp = current->next;
 372                                 current->next = current->next->next;
 373                                 free(tmp);
 374                                 return 0;
 375                         }
 376                 }
 377                 tmp = tmp->next;
 378         }
 379
 380         return -1;
 381 }
 382 */
 383
 384 static int request_event_handler(int req_id, const char *pkg_type,
 385                                  const char *pkg_name, const char *key,
 386                                  const char *val, const void *pmsg, void *data)
 387 {
 388         int ret = -1;
 389         package_manager_event_type_e event_type = -1;
 390         package_manager_event_state_e event_state = -1;
 391
 392         _LOGD("request_event_handler is called");
 393
 394         package_manager_request_h request = data;
 395
 396         if (strcasecmp(key, "start") == 0) {
 397                 ret = package_manager_get_event_type(val, &event_type);
 398                 if (ret != PACKAGE_MANAGER_ERROR_NONE)
 399                         return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
 400
 401                 __add_event_info(&(request->head), req_id, event_type,
 402                                  PACKAGE_MANAGER_EVENT_STATE_STARTED);
 403
 404                 if (request->event_cb)
 405                         request->event_cb(req_id, pkg_type, pkg_name,
 406                                           event_type,
 407                                           PACKAGE_MANAGER_EVENT_STATE_STARTED,
 408                                           0, PACKAGE_MANAGER_ERROR_NONE, request->user_data);
 409
 410         } else if (strcasecmp(key, "install_percent") == 0
 411                    || strcasecmp(key, "progress_percent") == 0) {
 412                 if (__find_event_info
 413                     (&(request->head), req_id, &event_type,
 414                      &event_state) == 0) {
 415                         __update_event_info(&(request->head), req_id,
 416                                             event_type,
 417                                             PACKAGE_MANAGER_EVENT_STATE_PROCESSING);
 418                         if (request->event_cb)
 419                                 request->event_cb(req_id, pkg_type, pkg_name,
 420                                                   event_type,
 421                                                   PACKAGE_MANAGER_EVENT_STATE_PROCESSING,
 422                                                   atoi(val),
 423                                                   PACKAGE_MANAGER_ERROR_NONE,
 424                                                   request->user_data);
 425                 }
 426
 427         } else if (strcasecmp(key, "error") == 0) {
 428                 if (strcasecmp(key, "0") != 0) {
 429                         if (__find_event_info
 430                             (&(request->head), req_id, &event_type,
 431                              &event_state) == 0) {
 432                                 __update_event_info(&(request->head), req_id,
 433                                                     event_type,
 434                                                     PACKAGE_MANAGER_EVENT_STATE_FAILED);
 435                         }
 436
 437                         if (request->event_cb)
 438                                 request->event_cb(req_id, pkg_type,
 439                                                   pkg_name, event_type,
 440                                                   PACKAGE_MANAGER_EVENT_STATE_FAILED,
 441                                                   0,
 442                                                   PACKAGE_MANAGER_ERROR_NONE,
 443                                                   request->user_data);
 444
 445                 }
 446         } else if (strcasecmp(key, "end") == 0) {
 447                 if (__find_event_info
 448                     (&(request->head), req_id, &event_type,
 449                      &event_state) == 0) {
 450                         if (event_state != PACKAGE_MANAGER_EVENT_STATE_FAILED) {
 451                                 if (request->event_cb)
 452                                         request->event_cb(req_id, pkg_type,
 453                                                           pkg_name, event_type,
 454                                                           PACKAGE_MANAGER_EVENT_STATE_COMPLETED,
 455                                                           100,
 456                                                           PACKAGE_MANAGER_ERROR_NONE,
 457                                                           request->user_data);
 458                         }
 459                 } else {
 460                         if (strcasecmp(key, "ok") != 0)
 461                                 if (request->event_cb)
 462                                         request->event_cb(req_id, pkg_type,
 463                                                           pkg_name, event_type,
 464                                                           PACKAGE_MANAGER_EVENT_STATE_FAILED,
 465                                                           0,
 466                                                           PACKAGE_MANAGER_ERROR_NONE,
 467                                                           request->user_data);
 468                 }
 469         }
 470
 471         return PACKAGE_MANAGER_ERROR_NONE;
 472 }
 473
 474 int package_manager_request_install(package_manager_request_h request,
 475                                     const char *path, int *id)
 476 {
 477         int request_id = 0;
 478         request->pkg_path = path;
 479         uid_t uid = getuid();
 480         if (uid != GLOBAL_USER)
 481                 request_id = pkgmgr_client_usr_install(request->pc, request->pkg_type, NULL,
 482                                                         request->pkg_path, NULL,
 483                                                         request->mode, request_event_handler,
 484                                                         request,
 485                                                         uid);
 486         else
 487                 request_id = pkgmgr_client_install(request->pc, request->pkg_type, NULL,
 488                                                         request->pkg_path, NULL,
 489                                                         request->mode, request_event_handler,
 490                                                         request);
 491         if (request_id < 0)
 492                 return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
 493
 494         *id = request_id;
 495
 496         return PACKAGE_MANAGER_ERROR_NONE;
 497 }
 498
 499 int package_manager_request_uninstall(package_manager_request_h request,
 500                                       const char *name, int *id)
 501 {
 502         int request_id = 0;
 503         request->pkg_name = name;
 504         uid_t uid = getuid();
 505         if (uid != GLOBAL_USER)
 506                 request_id = pkgmgr_client_usr_uninstall(request->pc, request->pkg_type,
 507                                                                 request->pkg_name, request->mode,
 508                                                                 request_event_handler, request, uid);
 509         else
 510                 request_id = pkgmgr_client_uninstall(request->pc, request->pkg_type,
 511                                                                 request->pkg_name, request->mode,
 512                                                                 request_event_handler, request);
 513         if (request_id < 0)
 514                 return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
 515
 516         *id = request_id;
 517
 518         return PACKAGE_MANAGER_ERROR_NONE;
 519 }
 520
 521 int package_manager_request_move(package_manager_request_h request,
 522                                     const char *name, package_manager_move_type_e move_type)
 523 {
 524         int ret = 0;
 525         request->pkg_name = name;
 526         uid_t uid = getuid();
 527         if (uid != GLOBAL_USER)
 528                 ret = pkgmgr_client_usr_move(request->pc, request->pkg_type, request->pkg_name,
 529                                                         move_type, request->mode, uid);
 530         else
 531                 ret = pkgmgr_client_move(request->pc, request->pkg_type, request->pkg_name,
 532                                                         move_type, request->mode);
 533         if (ret < 0)
 534                 return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
 535         else
 536                 return PACKAGE_MANAGER_ERROR_NONE;
 537 }
 538 int package_manager_create(package_manager_h * manager)
 539 {
 540         struct package_manager_s *package_manager = NULL;
 541
 542         if (manager == NULL) {
 543                 return
 544                     package_manager_error
 545                     (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
 546                      NULL);
 547         }
 548
 549         package_manager = calloc(1, sizeof(struct package_manager_s));
 550         if (package_manager == NULL) {
 551                 return
 552                     package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY,
 553                                           __FUNCTION__,
 554                                           "failed to create a package_manager handle");
 555         }
 556
 557         package_manager->ctype = PC_LISTENING;
 558         package_manager->pc = pkgmgr_client_new(PC_LISTENING);
 559         if (package_manager->pc == NULL) {
 560                 free(package_manager);
 561                 return
 562                     package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY,
 563                                           __FUNCTION__,
 564                                           "failed to create a package_manager client");
 565         }
 566
 567         package_manager->handle_id = package_manager_new_id();
 568
 569         *manager = package_manager;
 570
 571         return PACKAGE_MANAGER_ERROR_NONE;
 572 }
 573
 574 static int package_manager_valiate_handle(package_manager_h manager)
 575 {
 576         if (manager == NULL || manager->pc == NULL) {
 577                 return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
 578         }
 579
 580         return PACKAGE_MANAGER_ERROR_NONE;
 581 }
 582
 583 int package_manager_destroy(package_manager_h manager)
 584 {
 585         if (package_manager_valiate_handle(manager)) {
 586                 return
 587                     package_manager_error
 588                     (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
 589                      NULL);
 590         }
 591
 592         pkgmgr_client_free(manager->pc);
 593         manager->pc = NULL;
 594         free(manager);
 595
 596         return PACKAGE_MANAGER_ERROR_NONE;
 597 }
 598
 599 static int __add_event(event_info ** head, int req_id,
 600                             package_manager_event_type_e event_type,
 601                             package_manager_event_state_e event_state)
 602 {
 603         event_info *evt_info;
 604
 605         evt_info = (event_info *) calloc(1, sizeof(event_info));
 606         if (evt_info == NULL) {
 607                 _LOGD("calloc failed");
 608                 return -1;
 609         }
 610         evt_info->req_id = req_id;
 611         evt_info->event_type = event_type;
 612         evt_info->next = NULL;
 613
 614         *head = evt_info;
 615
 616         return 0;
 617 }
 618
 619 static int __find_event(event_info ** head, int req_id,
 620                              package_manager_event_type_e * event_type,
 621                              package_manager_event_state_e * event_state)
 622 {
 623         event_info *tmp;
 624
 625         tmp = *head;
 626
 627         if (tmp == NULL) {
 628                 _LOGE("tmp is NULL");
 629                 return -1;
 630         }
 631
 632         *event_type = tmp->event_type;
 633         return 0;
 634 }
 635
 636 static int __update_event(event_info ** head, int req_id,
 637                                package_manager_event_type_e event_type,
 638                                package_manager_event_state_e event_state)
 639 {
 640         package_manager_event_type_e evt_type;
 641         package_manager_event_state_e evt_state;
 642         event_info *tmp;
 643
 644         if (__find_event_info(head, req_id, &evt_type, &evt_state) != 0)
 645                 __add_event_info(head, req_id, event_type, event_state);
 646         else {
 647                 tmp = *head;
 648
 649                 if (tmp == NULL) {
 650                         _LOGE("tmp is NULL");
 651                         return -1;
 652                 }
 653
 654                 tmp->event_type = event_type;
 655                 return 0;
 656         }
 657
 658         return -1;
 659 }
 660
 661 static int global_event_handler(int req_id, const char *pkg_type,
 662                                 const char *pkg_name, const char *key,
 663                                 const char *val, const void *pmsg, void *data)
 664 {
 665         int ret = -1;
 666         package_manager_event_type_e event_type = -1;
 667         package_manager_event_state_e event_state = -1;
 668
 669         _LOGD("global_event_handler is called");
 670
 671         package_manager_h manager = data;
 672
 673         if (strcasecmp(key, "start") == 0) {
 674                 ret = package_manager_get_event_type(val, &event_type);
 675                 if (ret != PACKAGE_MANAGER_ERROR_NONE)
 676                         return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
 677
 678                 __add_event(&(manager->head), req_id, event_type,
 679                                  PACKAGE_MANAGER_EVENT_STATE_STARTED);
 680
 681                 if (manager->event_cb)
 682                         manager->event_cb(pkg_type, pkg_name,
 683                                           event_type,
 684                                           PACKAGE_MANAGER_EVENT_STATE_STARTED,
 685                                           0, PACKAGE_MANAGER_ERROR_NONE, manager->user_data);
 686
 687         } else if (strcasecmp(key, "install_percent") == 0
 688                    || strcasecmp(key, "progress_percent") == 0) {
 689                 if (__find_event
 690                     (&(manager->head), req_id, &event_type,
 691                      &event_state) == 0) {
 692                         __update_event(&(manager->head), req_id,
 693                                             event_type,
 694                                             PACKAGE_MANAGER_EVENT_STATE_PROCESSING);
 695                         if (manager->event_cb)
 696                                 manager->event_cb(pkg_type, pkg_name,
 697                                                   event_type,
 698                                                   PACKAGE_MANAGER_EVENT_STATE_PROCESSING,
 699                                                   atoi(val),
 700                                                   PACKAGE_MANAGER_ERROR_NONE,
 701                                                   manager->user_data);
 702                 }
 703
 704         } else if (strcasecmp(key, "error") == 0) {
 705                 if (strcasecmp(key, "0") != 0) {
 706                         if (__find_event
 707                             (&(manager->head), req_id, &event_type,
 708                              &event_state) == 0) {
 709                                 __update_event(&(manager->head), req_id,
 710                                                     event_type,
 711                                                     PACKAGE_MANAGER_EVENT_STATE_FAILED);
 712                         }
 713
 714                         if (manager->event_cb)
 715                                 manager->event_cb(pkg_type,
 716                                                   pkg_name, event_type,
 717                                                   PACKAGE_MANAGER_EVENT_STATE_FAILED,
 718                                                   0,
 719                                                   PACKAGE_MANAGER_ERROR_NONE,
 720                                                   manager->user_data);
 721
 722                 }
 723         } else if (strcasecmp(key, "end") == 0) {
 724                 if (__find_event
 725                     (&(manager->head), req_id, &event_type,
 726                      &event_state) == 0) {
 727                         if (event_state != PACKAGE_MANAGER_EVENT_STATE_FAILED) {
 728                                 if (manager->event_cb)
 729                                         manager->event_cb(pkg_type,
 730                                                           pkg_name, event_type,
 731                                                           PACKAGE_MANAGER_EVENT_STATE_COMPLETED,
 732                                                           100,
 733                                                           PACKAGE_MANAGER_ERROR_NONE,
 734                                                           manager->user_data);
 735                         }
 736                 } else {
 737                         if (strcasecmp(key, "ok") != 0)
 738                                 if (manager->event_cb)
 739                                         manager->event_cb(pkg_type,
 740                                                           pkg_name, event_type,
 741                                                           PACKAGE_MANAGER_EVENT_STATE_FAILED,
 742                                                           0,
 743                                                           PACKAGE_MANAGER_ERROR_NONE,
 744                                                           manager->user_data);
 745                 }
 746         }
 747
 748         return PACKAGE_MANAGER_ERROR_NONE;
 749 }
 750
 751 int package_manager_set_event_cb(package_manager_h manager,
 752                                  package_manager_event_cb callback,
 753                                  void *user_data)
 754 {
 755         if (package_manager_valiate_handle(manager)) {
 756                 return
 757                     package_manager_error
 758                     (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
 759                      NULL);
 760         }
 761
 762         manager->event_cb = callback;
 763         manager->user_data = user_data;
 764
 765     pkgmgr_client_listen_status(manager->pc, global_event_handler, manager);
 766
 767         return PACKAGE_MANAGER_ERROR_NONE;
 768 }
 769
 770 int package_manager_unset_event_cb(package_manager_h manager)
 771 {
 772         // TODO: Please implement this function.
 773         return PACKAGE_MANAGER_ERROR_NONE;
 774 }
 775
 776 int package_manager_get_package_id_by_app_id(const char *app_id, char **package_id)
 777 {
 778         pkgmgrinfo_appinfo_h pkgmgrinfo_appinfo;
 779         int retval;
 780         char *pkg_id = NULL;
 781         char *pkg_id_dup = NULL;
 782
 783         uid_t uid = getuid();
 784         if (uid != GLOBAL_USER)
 785         {
 786                 if (pkgmgrinfo_appinfo_get_usr_appinfo(app_id, uid, &pkgmgrinfo_appinfo) != PMINFO_R_OK)
 787                         return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
 788         } else
 789         {
 790                 if (pkgmgrinfo_appinfo_get_appinfo(app_id, &pkgmgrinfo_appinfo) != PMINFO_R_OK)
 791                         return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
 792         }
 793         retval = pkgmgrinfo_appinfo_get_pkgname(pkgmgrinfo_appinfo, &pkg_id);
 794         if (retval != PMINFO_R_OK)
 795         {
 796                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
 797         }
 798
 799         pkg_id_dup = strdup(pkg_id);
 800         if (pkg_id_dup == NULL)
 801         {
 802                 pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
 803                 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
 804         }
 805
 806         *package_id = pkg_id_dup;
 807
 808         pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
 809
 810         return PACKAGE_MANAGER_ERROR_NONE;
 811 }
 812
 813 int package_manager_get_package_info(const char *package_id, package_info_h *package_info)
 814 {
 815         int retval;
 816
 817         retval = package_info_get_package_info(package_id, package_info);
 818
 819         if (retval != PACKAGE_MANAGER_ERROR_NONE)
 820                 return package_manager_error(retval, __FUNCTION__, NULL);
 821         else
 822                 return PACKAGE_MANAGER_ERROR_NONE;
 823 }
 824
 825 int package_manager_foreach_package_info(package_manager_package_info_cb callback,
 826                                         void *user_data)
 827 {
 828         int retval;
 829
 830         retval = package_info_foreach_package_info(callback, user_data);
 831
 832         if (retval != PACKAGE_MANAGER_ERROR_NONE)
 833                 return package_manager_error(retval, __FUNCTION__, NULL);
 834         else
 835         {
 836                 return PACKAGE_MANAGER_ERROR_NONE;
 837         }
 838 }
 839 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)
 840 {
 841         pkgmgrinfo_cert_compare_result_type_e result;
 842   uid_t uid = getuid();
 843
 844         if (lhs_package_id == NULL || rhs_package_id == NULL || compare_result == NULL)
 845                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 846         if (uid != GLOBAL_USER)
 847         {
 848                 if (pkgmgrinfo_pkginfo_compare_usr_pkg_cert_info(lhs_package_id, rhs_package_id, uid, &result) != PKGMGR_R_OK)
 849                         return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
 850         } else
 851         {
 852                 if (pkgmgrinfo_pkginfo_compare_pkg_cert_info(lhs_package_id, rhs_package_id, &result) != PKGMGR_R_OK)
 853                         return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
 854         }
 855         *compare_result = (package_manager_compare_result_type_e)result;
 856
 857         return PACKAGE_MANAGER_ERROR_NONE;
 858 }
 859
 860 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)
 861 {
 862         pkgmgrinfo_cert_compare_result_type_e result;
 863         uid_t uid = getuid();
 864
 865         if (lhs_app_id == NULL || rhs_app_id == NULL || compare_result == NULL)
 866                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 867         if (uid != GLOBAL_USER)
 868         {
 869                 if (pkgmgrinfo_pkginfo_compare_usr_app_cert_info(lhs_app_id, rhs_app_id, uid, &result) != PKGMGR_R_OK)
 870                         return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
 871         } else
 872         {
 873                 if (pkgmgrinfo_pkginfo_compare_app_cert_info(lhs_app_id, rhs_app_id, &result) != PKGMGR_R_OK)
 874                         return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
 875         }
 876
 877         *compare_result = (package_manager_compare_result_type_e)result;
 878
 879         return PACKAGE_MANAGER_ERROR_NONE;
 880 }
 881
 882 int package_manager_is_preload_package_by_app_id(const char *app_id, bool *preload)
 883 {
 884         pkgmgrinfo_appinfo_h pkgmgrinfo_appinfo = NULL;
 885         pkgmgrinfo_pkginfo_h pkgmgrinfo_pkginfo = NULL;
 886
 887         int retval =0;
 888         char *pkg_id = NULL;
 889         bool is_preload = 0;
 890         uid_t uid = getuid();
 891         if (uid != GLOBAL_USER)
 892         {
 893                 if (pkgmgrinfo_appinfo_get_usr_appinfo(app_id, uid, &pkgmgrinfo_appinfo) != PMINFO_R_OK)
 894                         return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
 895         } else
 896   {
 897                 if (pkgmgrinfo_appinfo_get_appinfo(app_id, &pkgmgrinfo_appinfo) != PMINFO_R_OK)
 898                         return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
 899   }
 900         retval = pkgmgrinfo_appinfo_get_pkgname(pkgmgrinfo_appinfo, &pkg_id);
 901         if (retval != PMINFO_R_OK)
 902         {
 903                 pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
 904                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
 905         }
 906         if (uid != GLOBAL_USER)
 907         {
 908                 if (pkgmgrinfo_pkginfo_get_usr_pkginfo(pkg_id, uid, &pkgmgrinfo_pkginfo) != PMINFO_R_OK)
 909                 {
 910                         pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
 911                         pkgmgrinfo_pkginfo_destroy_pkginfo(pkgmgrinfo_pkginfo);
 912                         return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
 913                 }
 914         } else
 915         {
 916                 if (pkgmgrinfo_pkginfo_get_pkginfo(pkg_id, &pkgmgrinfo_pkginfo) != PMINFO_R_OK)
 917                 {
 918                         pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
 919                         pkgmgrinfo_pkginfo_destroy_pkginfo(pkgmgrinfo_pkginfo);
 920                         return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
 921                 }
 922         }
 923         if (pkgmgrinfo_pkginfo_is_preload(pkgmgrinfo_pkginfo, &is_preload) != PMINFO_R_OK)
 924         {
 925                 pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
 926                 pkgmgrinfo_pkginfo_destroy_pkginfo(pkgmgrinfo_pkginfo);
 927                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
 928         }
 929
 930         if (is_preload)
 931                 *preload = 1;
 932         else
 933                 *preload = 0;
 934
 935         pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
 936         pkgmgrinfo_pkginfo_destroy_pkginfo(pkgmgrinfo_pkginfo);
 937
 938         return PACKAGE_MANAGER_ERROR_NONE;
 939 }
 940
 941 int package_manager_get_permission_type(const char *app_id, package_manager_permission_type_e *permission_type)
 942 {
 943         int retval = 0;
 944         pkgmgrinfo_appinfo_h pkgmgrinfo_appinfo =NULL;
 945         pkgmgrinfo_permission_type permission = 0;
 946         uid_t uid = getuid();
 947         if (uid != GLOBAL_USER)
 948         {
 949                 if (pkgmgrinfo_appinfo_get_usr_appinfo(app_id, uid, &pkgmgrinfo_appinfo) != PMINFO_R_OK)
 950                         return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
 951         } else {
 952                 if (pkgmgrinfo_appinfo_get_appinfo(app_id, &pkgmgrinfo_appinfo) != PMINFO_R_OK)
 953                         return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
 954         }
 955         retval = pkgmgrinfo_appinfo_get_permission_type(pkgmgrinfo_appinfo, &permission);
 956         if (retval != PMINFO_R_OK)
 957                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
 958
 959         if (permission == PMINFO_PERMISSION_NORMAL)
 960                 *permission_type = PACKAGE_MANAGER_PERMISSION_NORMAL;
 961         else if (permission == PMINFO_PERMISSION_SIGNATURE)
 962                 *permission_type = PACKAGE_MANAGER_PERMISSION_SIGNATURE;
 963         else if (permission == PMINFO_PERMISSION_PRIVILEGE)
 964                 *permission_type = PACKAGE_MANAGER_PERMISSION_PRIVILEGE;
 965         else
 966                 *permission_type = PACKAGE_MANAGER_PERMISSION_NORMAL;
 967
 968         pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
 969         return PACKAGE_MANAGER_ERROR_NONE;
 970 }