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