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
  21 #include <package-manager.h>
  22 #include <package_manager.h>
  23 #include <package_manager_private.h>
  24 #include <pkgmgr-info.h>
  25
  26
  27 #ifdef LOG_TAG
  28 #undef LOG_TAG
  29 #endif
  30
  31 #define LOG_TAG "CAPI_APPFW_PACKAGE_MANAGER"
  32
  33 #define _LOGE(fmt, arg...) LOGE(fmt,##arg)
  34 #define _LOGD(fmt, arg...) LOGD(fmt, ##arg)
  35
  36 typedef struct _event_info {
  37         int req_id;
  38         package_manager_event_type_e event_type;
  39         package_manager_event_state_e event_state;
  40         struct _event_info *next;
  41 } event_info;
  42
  43 struct package_manager_s {
  44         int handle_id;
  45         client_type ctype;
  46         pkgmgr_client *pc;
  47         pkgmgr_mode mode;
  48         event_info *head;
  49         package_manager_event_cb event_cb;
  50         void *user_data;
  51 };
  52
  53 struct package_manager_request_s {
  54         int handle_id;
  55         client_type ctype;
  56         pkgmgr_client *pc;
  57         const char *pkg_type;
  58         const char *pkg_path;
  59         const char *pkg_name;
  60         pkgmgr_mode mode;
  61         event_info *head;
  62         package_manager_request_event_cb event_cb;
  63         void *user_data;
  64 };
  65
  66 static int package_manager_request_new_id()
  67 {
  68         static int request_handle_id = 0;
  69         return request_handle_id++;
  70 }
  71
  72 static int package_manager_new_id()
  73 {
  74         static int manager_handle_id = 0;
  75         return manager_handle_id++;
  76 }
  77
  78 static const char *package_manager_error_to_string(package_manager_error_e
  79                                                    error)
  80 {
  81         switch (error) {
  82         case PACKAGE_MANAGER_ERROR_NONE:
  83                 return "NONE";
  84
  85         case PACKAGE_MANAGER_ERROR_INVALID_PARAMETER:
  86                 return "INVALID_PARAMETER";
  87
  88         case PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY:
  89                 return "OUT_OF_MEMORY";
  90
  91         case PACKAGE_MANAGER_ERROR_IO_ERROR:
  92                 return "IO_ERROR";
  93         default:
  94                 return "UNKNOWN";
  95         }
  96 }
  97
  98 int package_manager_error(package_manager_error_e error,
  99                                  const char *function, const char *description)
 100 {
 101         if (description) {
 102                 _LOGE("[%s] %s(0x%08x) : %s", function,
 103                      package_manager_error_to_string(error), error,
 104                      description);
 105         } else {
 106                 _LOGE("[%s] %s(0x%08x)", function,
 107                      package_manager_error_to_string(error), error);
 108         }
 109
 110         return error;
 111 }
 112
 113 int package_manager_request_create(package_manager_request_h * request)
 114 {
 115         struct package_manager_request_s *package_manager_request;
 116
 117         if (request == NULL) {
 118                 return
 119                     package_manager_error
 120                     (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
 121                      NULL);
 122         }
 123
 124         package_manager_request =
 125             calloc(1, sizeof(struct package_manager_request_s));
 126         if (package_manager_request == NULL) {
 127                 return
 128                     package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY,
 129                                           __FUNCTION__,
 130                                           "failed to create a package_manager handle");
 131         }
 132
 133         package_manager_request->ctype = PC_REQUEST;
 134         package_manager_request->pc = pkgmgr_client_new(PC_REQUEST);
 135         if (package_manager_request->pc == NULL) {
 136                 free(package_manager_request);
 137                 return
 138                     package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY,
 139                                           __FUNCTION__,
 140                                           "failed to create a package_manager client");
 141         }
 142
 143         package_manager_request->handle_id = package_manager_request_new_id();
 144
 145         *request = package_manager_request;
 146
 147         return PACKAGE_MANAGER_ERROR_NONE;
 148 }
 149
 150 static int package_manager_client_valiate_handle(package_manager_request_h
 151                                                  request)
 152 {
 153         if (request == NULL || request->pc == NULL) {
 154                 return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
 155         }
 156
 157         return PACKAGE_MANAGER_ERROR_NONE;
 158 }
 159
 160 int package_manager_client_destroy(package_manager_request_h request)
 161 {
 162         if (package_manager_client_valiate_handle(request)) {
 163                 return
 164                     package_manager_error
 165                     (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
 166                      NULL);
 167         }
 168
 169         pkgmgr_client_free(request->pc);
 170         request->pc = NULL;
 171         free(request);
 172
 173         return PACKAGE_MANAGER_ERROR_NONE;
 174 }
 175
 176 int package_manager_request_set_event_cb(package_manager_request_h request,
 177                                          package_manager_request_event_cb
 178                                          callback, void *user_data)
 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         request->event_cb = callback;
 188         request->user_data = user_data;
 189
 190         return PACKAGE_MANAGER_ERROR_NONE;
 191 }
 192
 193 int package_manager_request_unset_event_cb(package_manager_request_h request)
 194 {
 195         // TODO: Please implement this function.
 196         return PACKAGE_MANAGER_ERROR_NONE;
 197 }
 198
 199
 200 int package_manager_request_set_type(package_manager_request_h request,
 201                                      const char *pkg_type)
 202 {
 203         if (package_manager_client_valiate_handle(request)) {
 204                 return
 205                     package_manager_error
 206                     (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
 207                      NULL);
 208         }
 209
 210         request->pkg_type = pkg_type;
 211
 212         return PACKAGE_MANAGER_ERROR_NONE;
 213 }
 214
 215 int package_manager_request_set_mode(package_manager_request_h request,
 216                                      package_manager_request_mode_e mode)
 217 {
 218         if (package_manager_client_valiate_handle(request)) {
 219                 return
 220                     package_manager_error
 221                     (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
 222                      NULL);
 223         }
 224
 225         if (mode == PACAKGE_MANAGER_REQUEST_MODE_QUIET)
 226                 request->mode = PM_QUIET;
 227         else
 228                 request->mode = PM_DEFAULT;
 229
 230         return PACKAGE_MANAGER_ERROR_NONE;
 231 }
 232
 233 static int package_manager_get_event_type(const char *key,
 234                                           package_manager_event_type_e *
 235                                           event_type)
 236 {
 237         if (key == NULL)
 238                 return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
 239
 240         if (strcasecmp(key, "install") == 0)
 241                 *event_type = PACAKGE_MANAGER_EVENT_TYPE_INSTALL;
 242         else if (strcasecmp(key, "uninstall") == 0)
 243                 *event_type = PACAKGE_MANAGER_EVENT_TYPE_UNINSTALL;
 244         else if (strcasecmp(key, "undate") == 0)
 245                 *event_type = PACAKGE_MANAGER_EVENT_TYPE_UPDATE;
 246         else
 247                 return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
 248
 249         return PACKAGE_MANAGER_ERROR_NONE;
 250 }
 251
 252 static int __add_event_info(event_info ** head, int req_id,
 253                             package_manager_event_type_e event_type,
 254                             package_manager_event_state_e event_state)
 255 {
 256         event_info *evt_info;
 257         event_info *current;
 258         event_info *prev;
 259
 260         evt_info = (event_info *) calloc(1, sizeof(event_info));
 261         if (evt_info == NULL) {
 262                 _LOGD("calloc failed");
 263                 return -1;
 264         }
 265         evt_info->req_id = req_id;
 266         evt_info->event_type = event_type;
 267         evt_info->next = NULL;
 268
 269         if (*head == NULL)
 270                 *head = evt_info;
 271         else {
 272                 current = prev = *head;
 273                 while (current) {
 274                         prev = current;
 275                         current = current->next;
 276                 }
 277
 278                 prev->next = evt_info;
 279         }
 280
 281         return 0;
 282 }
 283
 284 static int __find_event_info(event_info ** head, int req_id,
 285                              package_manager_event_type_e * event_type,
 286                              package_manager_event_state_e * event_state)
 287 {
 288         event_info *tmp;
 289
 290         tmp = *head;
 291
 292         if (tmp == NULL) {
 293                 _LOGE("tmp is NULL");
 294                 return -1;
 295         }
 296
 297         _LOGD("tmp->req_id %d, event_type %d", tmp->req_id, event_type);
 298
 299         while (tmp) {
 300                 if (tmp->req_id == req_id) {
 301                         *event_type = tmp->event_type;
 302                         return 0;
 303                 }
 304                 tmp = tmp->next;
 305         }
 306         return -1;
 307 }
 308
 309 static int __update_event_info(event_info ** head, int req_id,
 310                                package_manager_event_type_e event_type,
 311                                package_manager_event_state_e event_state)
 312 {
 313         package_manager_event_type_e evt_type;
 314         package_manager_event_state_e evt_state;
 315         event_info *tmp;
 316
 317         if (__find_event_info(head, req_id, &evt_type, &evt_state) != 0)
 318                 __add_event_info(head, req_id, event_type, event_state);
 319         else {
 320                 tmp = *head;
 321
 322                 if (tmp == NULL) {
 323                         _LOGE("tmp is NULL");
 324                         return -1;
 325                 }
 326
 327                 while (tmp) {
 328                         if (tmp->req_id == req_id) {
 329                                 tmp->event_type = event_type;
 330                                 return 0;
 331                         }
 332                         tmp = tmp->next;
 333                 }
 334         }
 335
 336         return -1;
 337 }
 338
 339 /*
 340 static int __remove_event_info(event_info **head request, int req_id)
 341 {
 342         event_info *current;
 343         event_info *tmp;
 344
 345         if (* == NULL)
 346                 return -1;
 347
 348         current = *head;
 349         while (current) {
 350                 if (current->next) {
 351                         if (current->next->req_id == req_id) {
 352                                 tmp = current->next;
 353                                 current->next = current->next->next;
 354                                 free(tmp);
 355                                 return 0;
 356                         }
 357                 }
 358                 tmp = tmp->next;
 359         }
 360
 361         return -1;
 362 }
 363 */
 364
 365 static int request_event_handler(int req_id, const char *pkg_type,
 366                                  const char *pkg_name, const char *key,
 367                                  const char *val, const void *pmsg, void *data)
 368 {
 369         int ret = -1;
 370         package_manager_event_type_e event_type = -1;
 371         package_manager_event_state_e event_state = -1;
 372
 373         _LOGD("request_event_handler is called");
 374
 375         package_manager_request_h request = data;
 376
 377         if (strcasecmp(key, "start") == 0) {
 378                 ret = package_manager_get_event_type(val, &event_type);
 379                 if (ret != PACKAGE_MANAGER_ERROR_NONE)
 380                         return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
 381
 382                 __add_event_info(&(request->head), req_id, event_type,
 383                                  PACAKGE_MANAGER_EVENT_STATE_STARTED);
 384
 385                 if (request->event_cb)
 386                         request->event_cb(req_id, pkg_type, pkg_name,
 387                                           event_type,
 388                                           PACAKGE_MANAGER_EVENT_STATE_STARTED,
 389                                           0, PACKAGE_MANAGER_ERROR_NONE, request->user_data);
 390
 391         } else if (strcasecmp(key, "install_percent") == 0
 392                    || strcasecmp(key, "progress_percent") == 0) {
 393                 if (__find_event_info
 394                     (&(request->head), req_id, &event_type,
 395                      &event_state) == 0) {
 396                         __update_event_info(&(request->head), req_id,
 397                                             event_type,
 398                                             PACAKGE_MANAGER_EVENT_STATE_PROCESSING);
 399                         if (request->event_cb)
 400                                 request->event_cb(req_id, pkg_type, pkg_name,
 401                                                   event_type,
 402                                                   PACAKGE_MANAGER_EVENT_STATE_PROCESSING,
 403                                                   atoi(val),
 404                                                   PACKAGE_MANAGER_ERROR_NONE,
 405                                                   request->user_data);
 406                 }
 407
 408         } else if (strcasecmp(key, "error") == 0) {
 409                 if (strcasecmp(key, "0") != 0) {
 410                         if (__find_event_info
 411                             (&(request->head), req_id, &event_type,
 412                              &event_state) == 0) {
 413                                 __update_event_info(&(request->head), req_id,
 414                                                     event_type,
 415                                                     PACAKGE_MANAGER_EVENT_STATE_FAILED);
 416                         }
 417
 418                         if (request->event_cb)
 419                                 request->event_cb(req_id, pkg_type,
 420                                                   pkg_name, event_type,
 421                                                   PACAKGE_MANAGER_EVENT_STATE_FAILED,
 422                                                   0,
 423                                                   PACKAGE_MANAGER_ERROR_NONE,
 424                                                   request->user_data);
 425
 426                 }
 427         } else if (strcasecmp(key, "end") == 0) {
 428                 if (__find_event_info
 429                     (&(request->head), req_id, &event_type,
 430                      &event_state) == 0) {
 431                         if (event_state != PACAKGE_MANAGER_EVENT_STATE_FAILED) {
 432                                 if (request->event_cb)
 433                                         request->event_cb(req_id, pkg_type,
 434                                                           pkg_name, event_type,
 435                                                           PACAKGE_MANAGER_EVENT_STATE_COMPLETED,
 436                                                           100,
 437                                                           PACKAGE_MANAGER_ERROR_NONE,
 438                                                           request->user_data);
 439                         }
 440                 } else {
 441                         if (strcasecmp(key, "ok") != 0)
 442                                 if (request->event_cb)
 443                                         request->event_cb(req_id, pkg_type,
 444                                                           pkg_name, event_type,
 445                                                           PACAKGE_MANAGER_EVENT_STATE_FAILED,
 446                                                           0,
 447                                                           PACKAGE_MANAGER_ERROR_NONE,
 448                                                           request->user_data);
 449                 }
 450         }
 451
 452         return PACKAGE_MANAGER_ERROR_NONE;
 453 }
 454
 455 int package_manager_request_install(package_manager_request_h request,
 456                                     const char *path, int *id)
 457 {
 458         int request_id = 0;
 459         request->pkg_path = path;
 460         request_id = pkgmgr_client_install(request->pc, request->pkg_type, NULL,
 461                                            request->pkg_path, NULL,
 462                                            request->mode, request_event_handler,
 463                                            request);
 464
 465         if (request_id < 0)
 466                 return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
 467
 468         *id = request_id;
 469
 470         return PACKAGE_MANAGER_ERROR_NONE;
 471 }
 472
 473 int package_manager_request_uninstall(package_manager_request_h request,
 474                                       const char *name, int *id)
 475 {
 476         int request_id = 0;
 477         request->pkg_name = name;
 478         request_id = pkgmgr_client_uninstall(request->pc, request->pkg_type,
 479                                              request->pkg_name, PM_DEFAULT,
 480                                              request_event_handler, request);
 481
 482         if (request_id < 0)
 483                 return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
 484
 485         *id = request_id;
 486
 487         return PACKAGE_MANAGER_ERROR_NONE;
 488 }
 489
 490 int package_manager_request_move(package_manager_request_h request,
 491                                     const char *name, package_manager_move_type_e move_type)
 492 {
 493         int ret = 0;
 494         request->pkg_name = name;
 495         ret = pkgmgr_client_move(request->pc, request->pkg_type, request->pkg_name,
 496                                            move_type, request->mode);
 497
 498         if (ret < 0)
 499         {
 500                 return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
 501         }
 502         else
 503         {
 504                 return PACKAGE_MANAGER_ERROR_NONE;
 505         }
 506 }
 507 int package_manager_create(package_manager_h * manager)
 508 {
 509         struct package_manager_s *package_manager = NULL;
 510
 511         if (manager == NULL) {
 512                 return
 513                     package_manager_error
 514                     (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
 515                      NULL);
 516         }
 517
 518         package_manager = calloc(1, sizeof(struct package_manager_s));
 519         if (package_manager == NULL) {
 520                 return
 521                     package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY,
 522                                           __FUNCTION__,
 523                                           "failed to create a package_manager handle");
 524         }
 525
 526         package_manager->ctype = PC_LISTENING;
 527         package_manager->pc = pkgmgr_client_new(PC_LISTENING);
 528         if (package_manager->pc == NULL) {
 529                 free(package_manager);
 530                 return
 531                     package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY,
 532                                           __FUNCTION__,
 533                                           "failed to create a package_manager client");
 534         }
 535
 536         package_manager->handle_id = package_manager_new_id();
 537
 538         *manager = package_manager;
 539
 540         return PACKAGE_MANAGER_ERROR_NONE;
 541 }
 542
 543 static int package_manager_valiate_handle(package_manager_h manager)
 544 {
 545         if (manager == NULL || manager->pc == NULL) {
 546                 return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
 547         }
 548
 549         return PACKAGE_MANAGER_ERROR_NONE;
 550 }
 551
 552 int package_manager_destroy(package_manager_h manager)
 553 {
 554         if (package_manager_valiate_handle(manager)) {
 555                 return
 556                     package_manager_error
 557                     (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
 558                      NULL);
 559         }
 560
 561         pkgmgr_client_free(manager->pc);
 562         manager->pc = NULL;
 563         free(manager);
 564
 565         return PACKAGE_MANAGER_ERROR_NONE;
 566 }
 567
 568 static int global_event_handler(int req_id, const char *pkg_type,
 569                                 const char *pkg_name, const char *key,
 570                                 const char *val, const void *pmsg, void *data)
 571 {
 572         int ret = -1;
 573         package_manager_event_type_e event_type = -1;
 574         package_manager_event_state_e event_state = -1;
 575
 576         _LOGD("global_event_handler is called");
 577
 578         package_manager_h manager = data;
 579
 580         if (strcasecmp(key, "start") == 0) {
 581                 ret = package_manager_get_event_type(val, &event_type);
 582                 if (ret != PACKAGE_MANAGER_ERROR_NONE)
 583                         return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
 584
 585                 __add_event_info(&(manager->head), req_id, event_type,
 586                                  PACAKGE_MANAGER_EVENT_STATE_STARTED);
 587
 588                 if (manager->event_cb)
 589                         manager->event_cb(pkg_type, pkg_name,
 590                                           event_type,
 591                                           PACAKGE_MANAGER_EVENT_STATE_STARTED,
 592                                           0, PACKAGE_MANAGER_ERROR_NONE, manager->user_data);
 593
 594         } else if (strcasecmp(key, "install_percent") == 0
 595                    || strcasecmp(key, "progress_percent") == 0) {
 596                 if (__find_event_info
 597                     (&(manager->head), req_id, &event_type,
 598                      &event_state) == 0) {
 599                         __update_event_info(&(manager->head), req_id,
 600                                             event_type,
 601                                             PACAKGE_MANAGER_EVENT_STATE_PROCESSING);
 602                         if (manager->event_cb)
 603                                 manager->event_cb(pkg_type, pkg_name,
 604                                                   event_type,
 605                                                   PACAKGE_MANAGER_EVENT_STATE_PROCESSING,
 606                                                   atoi(val),
 607                                                   PACKAGE_MANAGER_ERROR_NONE,
 608                                                   manager->user_data);
 609                 }
 610
 611         } else if (strcasecmp(key, "error") == 0) {
 612                 if (strcasecmp(key, "0") != 0) {
 613                         if (__find_event_info
 614                             (&(manager->head), req_id, &event_type,
 615                              &event_state) == 0) {
 616                                 __update_event_info(&(manager->head), req_id,
 617                                                     event_type,
 618                                                     PACAKGE_MANAGER_EVENT_STATE_FAILED);
 619                         }
 620
 621                         if (manager->event_cb)
 622                                 manager->event_cb(pkg_type,
 623                                                   pkg_name, event_type,
 624                                                   PACAKGE_MANAGER_EVENT_STATE_FAILED,
 625                                                   0,
 626                                                   PACKAGE_MANAGER_ERROR_NONE,
 627                                                   manager->user_data);
 628
 629                 }
 630         } else if (strcasecmp(key, "end") == 0) {
 631                 if (__find_event_info
 632                     (&(manager->head), req_id, &event_type,
 633                      &event_state) == 0) {
 634                         if (event_state != PACAKGE_MANAGER_EVENT_STATE_FAILED) {
 635                                 if (manager->event_cb)
 636                                         manager->event_cb(pkg_type,
 637                                                           pkg_name, event_type,
 638                                                           PACAKGE_MANAGER_EVENT_STATE_COMPLETED,
 639                                                           100,
 640                                                           PACKAGE_MANAGER_ERROR_NONE,
 641                                                           manager->user_data);
 642                         }
 643                 } else {
 644                         if (strcasecmp(key, "ok") != 0)
 645                                 if (manager->event_cb)
 646                                         manager->event_cb(pkg_type,
 647                                                           pkg_name, event_type,
 648                                                           PACAKGE_MANAGER_EVENT_STATE_FAILED,
 649                                                           0,
 650                                                           PACKAGE_MANAGER_ERROR_NONE,
 651                                                           manager->user_data);
 652                 }
 653         }
 654
 655         return PACKAGE_MANAGER_ERROR_NONE;
 656 }
 657
 658 int package_manager_set_event_cb(package_manager_h manager,
 659                                  package_manager_event_cb callback,
 660                                  void *user_data)
 661 {
 662         int ret = 0;
 663         if (package_manager_valiate_handle(manager)) {
 664                 return
 665                     package_manager_error
 666                     (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
 667                      NULL);
 668         }
 669
 670         manager->event_cb = callback;
 671         manager->user_data = user_data;
 672
 673         ret =
 674             pkgmgr_client_listen_status(manager->pc, global_event_handler,
 675                                         manager);
 676
 677         return PACKAGE_MANAGER_ERROR_NONE;
 678 }
 679
 680 int package_manager_unset_event_cb(package_manager_h manager)
 681 {
 682         // TODO: Please implement this function.
 683         return PACKAGE_MANAGER_ERROR_NONE;
 684 }
 685
 686 int package_manager_get_package_id_by_app_id(const char *app_id, char **package_id)
 687 {
 688         pkgmgrinfo_appinfo_h pkgmgrinfo_appinfo;
 689         int retval;
 690         char *pkg_id = NULL;
 691         char *pkg_id_dup = NULL;
 692
 693         if (pkgmgrinfo_appinfo_get_appinfo(app_id, &pkgmgrinfo_appinfo) != PMINFO_R_OK)
 694         {
 695                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
 696         }
 697
 698         retval = pkgmgrinfo_appinfo_get_pkgname(pkgmgrinfo_appinfo, &pkg_id);
 699         if (retval != PMINFO_R_OK)
 700         {
 701                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
 702         }
 703
 704         pkg_id_dup = strdup(pkg_id);
 705         if (pkg_id_dup == NULL)
 706         {
 707                 pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
 708                 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
 709         }
 710
 711         *package_id = pkg_id_dup;
 712
 713         pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
 714
 715         return PACKAGE_MANAGER_ERROR_NONE;
 716 }
 717
 718 int package_manager_get_package_info(const char *package_id, package_info_h *package_info)
 719 {
 720         int retval;
 721
 722         retval = package_info_get_package_info(package_id, package_info);
 723
 724         if (retval != PACKAGE_MANAGER_ERROR_NONE)
 725         {
 726                 return package_manager_error(retval, __FUNCTION__, NULL);
 727         }
 728         else
 729         {
 730                 return PACKAGE_MANAGER_ERROR_NONE;
 731         }
 732 }
 733
 734 int package_manager_foreach_package_info(package_manager_package_info_cb callback,
 735                                         void *user_data)
 736 {
 737         int retval;
 738
 739         retval = package_info_foreach_package_info(callback, user_data);
 740
 741         if (retval != PACKAGE_MANAGER_ERROR_NONE)
 742         {
 743                 return package_manager_error(retval, __FUNCTION__, NULL);
 744         }
 745         else
 746         {
 747                 return PACKAGE_MANAGER_ERROR_NONE;
 748         }
 749 }
 750 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)
 751 {
 752         pkgmgrinfo_cert_compare_result_type_e result;
 753
 754         if (lhs_package_id == NULL || rhs_package_id == NULL || compare_result == NULL)
 755         {
 756                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 757         }
 758
 759         if (pkgmgrinfo_pkginfo_compare_pkg_cert_info(lhs_package_id, rhs_package_id, &result) != PKGMGR_R_OK)
 760         {
 761                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
 762         }
 763
 764         *compare_result = (package_manager_compare_result_type_e)result;
 765
 766         return PACKAGE_MANAGER_ERROR_NONE;
 767 }
 768
 769 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)
 770 {
 771         pkgmgrinfo_cert_compare_result_type_e result;
 772
 773         if (lhs_app_id == NULL || rhs_app_id == NULL || compare_result == NULL)
 774         {
 775                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 776         }
 777
 778         if (pkgmgrinfo_pkginfo_compare_app_cert_info(lhs_app_id, rhs_app_id, &result) != PKGMGR_R_OK)
 779         {
 780                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
 781         }
 782
 783         *compare_result = (package_manager_compare_result_type_e)result;
 784
 785         return PACKAGE_MANAGER_ERROR_NONE;
 786 }
 787