src/package_info.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
  18 #include <stdio.h>
  19 #include <stdlib.h>
  20 #include <string.h>
  21 #include <unistd.h>
  22
  23 #include <package-manager.h>
  24 #include <pkgmgr-info.h>
  25 #include <dlog.h>
  26
  27 #include <package_info.h>
  28 #include <package_manager.h>
  29 #include <package_manager_internal.h>
  30 #include <privilege_checker.h>
  31
  32 #ifdef LOG_TAG
  33 #undef LOG_TAG
  34 #endif
  35
  36 #define LOG_TAG "CAPI_APPFW_PACKAGE_MANAGER"
  37
  38 struct package_info_s {
  39         char *package;
  40         pkgmgrinfo_pkginfo_h pkgmgrinfo_pkginfo;
  41 };
  42
  43 struct package_cert_info_s {
  44         char *package;
  45         pkgmgrinfo_certinfo_h pkgmgrinfo_certinfo;
  46 };
  47
  48 typedef struct _foreach_pkg_context_{
  49         package_manager_package_info_cb callback;
  50         void *user_data;
  51 } foreach_pkg_context_s;
  52
  53
  54 typedef struct _foreach_app_context_{
  55         package_info_app_cb callback;
  56         void *user_data;
  57 } foreach_app_context_s;
  58
  59
  60 int package_info_create(const char *package,  package_info_h *package_info)
  61 {
  62         package_info_h package_info_created;
  63         pkgmgrinfo_pkginfo_h pkgmgrinfo_pkginfo;
  64
  65         if (package == NULL || package_info == NULL)
  66         {
  67                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
  68         }
  69
  70         if (pkgmgrinfo_pkginfo_get_pkginfo(package, &pkgmgrinfo_pkginfo) != PKGMGR_R_OK)
  71         {
  72                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
  73         }
  74
  75         package_info_created = calloc(1, sizeof(struct package_info_s));
  76
  77         if (package_info_created == NULL)
  78         {
  79                 pkgmgrinfo_pkginfo_destroy_pkginfo(pkgmgrinfo_pkginfo);
  80                 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
  81         }
  82
  83         package_info_created->package = strdup(package);
  84
  85         if (package_info_created->package == NULL)
  86         {
  87                 pkgmgrinfo_pkginfo_destroy_pkginfo(pkgmgrinfo_pkginfo);
  88                 free(package_info_created);
  89                 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
  90         }
  91
  92         package_info_created->pkgmgrinfo_pkginfo = pkgmgrinfo_pkginfo;
  93
  94         *package_info = package_info_created;
  95
  96         return PACKAGE_MANAGER_ERROR_NONE;
  97 }
  98
  99
 100 int package_info_get_package_info(const char *package, package_info_h *package_info)
 101 {
 102         return package_info_create(package, package_info);
 103 }
 104
 105
 106 static int package_info_foreach_package_info_cb(const pkgmgrinfo_pkginfo_h handle, void *user_data)
 107 {
 108         char *pkg_name = NULL;
 109         foreach_pkg_context_s *foreach_pkg_context = user_data;
 110         package_info_h package_info = NULL;
 111
 112         if (handle == NULL || foreach_pkg_context == NULL)
 113         {
 114                 package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 115                 return PKGMGR_R_EINVAL;
 116         }
 117
 118         pkgmgrinfo_pkginfo_get_pkgname(handle, &pkg_name);
 119
 120         if (package_info_create(pkg_name, &package_info) == PACKAGE_MANAGER_ERROR_NONE)
 121         {
 122                 foreach_pkg_context->callback(package_info, foreach_pkg_context->user_data);
 123                 package_info_destroy(package_info);
 124         }
 125
 126         /* pkgmgr_get_info_list() needs to be enhanced to stop and continue callback */
 127         return PKGMGR_R_OK;
 128 }
 129
 130
 131 int package_info_foreach_package_info(package_manager_package_info_cb callback, void *user_data)
 132 {
 133         foreach_pkg_context_s foreach_pkg_context = {
 134                 .callback = callback,
 135                 .user_data = user_data,
 136         };
 137         int ret = 0;
 138
 139         if (callback == NULL)
 140         {
 141                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 142         }
 143
 144         ret = pkgmgrinfo_pkginfo_get_list(package_info_foreach_package_info_cb, &foreach_pkg_context);
 145         if (ret < 0) {
 146                 return PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE;
 147         }
 148
 149         return PACKAGE_MANAGER_ERROR_NONE;
 150 }
 151
 152 int package_info_filter_foreach_package_info(pkgmgrinfo_pkginfo_filter_h handle, package_manager_package_info_cb callback, void *user_data)
 153 {
 154         foreach_pkg_context_s foreach_pkg_context = {
 155                 .callback = callback,
 156                 .user_data = user_data,
 157         };
 158         int ret = 0;
 159
 160         if ((handle == NULL) || (callback == NULL))
 161         {
 162                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 163         }
 164
 165         ret = pkgmgrinfo_pkginfo_filter_foreach_pkginfo(handle, package_info_foreach_package_info_cb, &foreach_pkg_context);
 166         if (ret < 0) {
 167                 return PACKAGE_MANAGER_ERROR_IO_ERROR;
 168         }
 169
 170         return PACKAGE_MANAGER_ERROR_NONE;
 171 }
 172
 173 static int package_info_foreach_app_cb (const pkgmgrinfo_appinfo_h handle, void *user_data)
 174 {
 175         char *appid = NULL;
 176         char *comp_type = NULL;
 177         pkgmgr_app_component comp = PACKAGE_INFO_UIAPP;
 178         foreach_app_context_s *foreach_app_context = user_data;
 179         int ret = 0;
 180
 181         if (handle == NULL || foreach_app_context == NULL)
 182         {
 183                 package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 184                 return PKGMGR_R_EINVAL;
 185         }
 186
 187         ret = pkgmgrinfo_appinfo_get_appid(handle, &appid);
 188         if (ret < 0) {
 189                 return PKGMGR_R_ERROR;
 190         }
 191
 192         ret = pkgmgrinfo_appinfo_get_component_type(handle, &comp_type);
 193         if (ret < 0) {
 194                 return PKGMGR_R_ERROR;
 195         }
 196
 197         if (comp_type && !strncmp("svcapp", comp_type, strlen(comp_type))) {
 198                 comp = PACKAGE_INFO_SERVICEAPP;
 199         } else if (comp_type && !strncmp("uiapp", comp_type, strlen(comp_type))) {
 200                 comp = PACKAGE_INFO_UIAPP;
 201         } else {
 202                 comp = PACKAGE_INFO_ALLAPP;
 203         }
 204
 205         ret = foreach_app_context->callback(comp, appid, foreach_app_context->user_data);
 206         if (!ret)
 207         {
 208                 package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
 209                 return PKGMGR_R_ERROR;
 210         }
 211
 212         return PKGMGR_R_OK;
 213 }
 214
 215
 216
 217 int package_info_foreach_app_from_package(package_info_h package_info, package_info_app_component_type_e comp_type, package_info_app_cb callback, void *user_data)
 218 {
 219         foreach_app_context_s foreach_app_context = {
 220                 .callback = callback,
 221                 .user_data = user_data,
 222         };
 223         pkgmgrinfo_pkginfo_h pkgmgrinfo_pkginfo;
 224         int ret = 0;
 225
 226         if (package_info == NULL || callback == NULL)
 227         {
 228                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 229         }
 230
 231         if (pkgmgrinfo_pkginfo_get_pkginfo(package_info->package, &pkgmgrinfo_pkginfo) != PKGMGR_R_OK)
 232         {
 233                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
 234         }
 235         if (comp_type == PACKAGE_INFO_ALLAPP)
 236                 ret = pkgmgrinfo_appinfo_get_list(pkgmgrinfo_pkginfo, PMINFO_ALL_APP, package_info_foreach_app_cb, &foreach_app_context);
 237         if (comp_type == PACKAGE_INFO_UIAPP)
 238                 ret = pkgmgrinfo_appinfo_get_list(pkgmgrinfo_pkginfo, PMINFO_UI_APP, package_info_foreach_app_cb, &foreach_app_context);
 239         if (comp_type == PACKAGE_INFO_SERVICEAPP)
 240                 ret = pkgmgrinfo_appinfo_get_list(pkgmgrinfo_pkginfo, PMINFO_SVC_APP, package_info_foreach_app_cb, &foreach_app_context);
 241
 242         pkgmgrinfo_pkginfo_destroy_pkginfo(pkgmgrinfo_pkginfo);
 243
 244         return ret;
 245 }
 246
 247
 248 int package_info_destroy(package_info_h package_info)
 249 {
 250         if (package_info == NULL)
 251         {
 252                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 253         }
 254
 255         free(package_info->package);
 256
 257         pkgmgrinfo_pkginfo_destroy_pkginfo(package_info->pkgmgrinfo_pkginfo);
 258
 259         free(package_info);
 260
 261         package_info = NULL;
 262
 263         return PACKAGE_MANAGER_ERROR_NONE;
 264 }
 265
 266 int package_info_get_package(package_info_h package_info, char **package)
 267 {
 268         char *package_dup;
 269
 270         if (package_info == NULL || package == NULL)
 271         {
 272                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 273         }
 274
 275         package_dup = strdup(package_info->package);
 276
 277         if (package_dup == NULL)
 278         {
 279                 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
 280         }
 281
 282         *package = package_dup;
 283
 284         return PACKAGE_MANAGER_ERROR_NONE;
 285 }
 286
 287 int package_info_get_label(package_info_h package_info, char **label)
 288 {
 289         char *pkg_info_value = NULL;
 290         char *label_dup = NULL;
 291
 292         if (package_info == NULL || label == NULL)
 293         {
 294                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 295         }
 296
 297         if (pkgmgrinfo_pkginfo_get_label(package_info->pkgmgrinfo_pkginfo, &pkg_info_value) != PKGMGR_R_OK)
 298         {
 299                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
 300         }
 301
 302         if(!pkg_info_value)
 303                 goto END;
 304
 305         label_dup = strdup(pkg_info_value);
 306
 307         if (label_dup == NULL)
 308         {
 309                 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
 310         }
 311
 312 END:
 313         *label = label_dup;
 314
 315         return PACKAGE_MANAGER_ERROR_NONE;
 316 }
 317
 318 int package_info_get_icon(package_info_h package_info, char **path)
 319 {
 320         char *pkg_info_value = NULL;
 321         char *icon_dup = NULL;
 322
 323         if (package_info == NULL || path == NULL)
 324         {
 325                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 326         }
 327
 328         if (pkgmgrinfo_pkginfo_get_icon(package_info->pkgmgrinfo_pkginfo, &pkg_info_value) != PKGMGR_R_OK)
 329         {
 330                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
 331         }
 332
 333         if(!pkg_info_value)
 334                 goto END;
 335
 336         icon_dup = strdup(pkg_info_value);
 337
 338         if (icon_dup == NULL)
 339         {
 340                 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
 341         }
 342
 343 END:
 344         *path = icon_dup;
 345
 346         return PACKAGE_MANAGER_ERROR_NONE;
 347 }
 348
 349 int package_info_get_version(package_info_h package_info, char **version)
 350 {
 351         char *pkg_info_value = NULL;
 352         char *ver_dup = NULL;
 353
 354         if (package_info == NULL || version == NULL)
 355         {
 356                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 357         }
 358
 359         if (pkgmgrinfo_pkginfo_get_version(package_info->pkgmgrinfo_pkginfo, &pkg_info_value) != PKGMGR_R_OK)
 360         {
 361                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
 362         }
 363
 364         if(!pkg_info_value)
 365                 goto END;
 366
 367         ver_dup = strdup(pkg_info_value);
 368
 369         if (ver_dup == NULL)
 370         {
 371                 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
 372         }
 373
 374 END:
 375         *version = ver_dup;
 376
 377         return PACKAGE_MANAGER_ERROR_NONE;
 378 }
 379
 380 int package_info_get_type(package_info_h package_info, char **type)
 381 {
 382         char *pkg_info_value = NULL;
 383         char *type_dup = NULL;
 384
 385         if (package_info == NULL || type == NULL)
 386         {
 387                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 388         }
 389
 390         if (pkgmgrinfo_pkginfo_get_type(package_info->pkgmgrinfo_pkginfo, &pkg_info_value) != PKGMGR_R_OK)
 391         {
 392                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
 393         }
 394
 395         if(!pkg_info_value)
 396                 goto END;
 397
 398         type_dup = strdup(pkg_info_value);
 399
 400         if (type_dup == NULL)
 401         {
 402                 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
 403         }
 404
 405 END:
 406         *type = type_dup;
 407
 408         return PACKAGE_MANAGER_ERROR_NONE;
 409 }
 410
 411 int package_info_get_installed_storage(package_info_h package_info, package_info_installed_storage_type_e *storage)
 412 {
 413         int ret = 0;
 414         pkgmgr_installed_storage pkg_info_value;
 415
 416         if (package_info == NULL || storage == NULL)
 417         {
 418                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 419         }
 420
 421         ret = pkgmgrinfo_pkginfo_get_installed_storage(package_info->pkgmgrinfo_pkginfo, (pkgmgrinfo_installed_storage *)&pkg_info_value);
 422         if (ret < 0)
 423                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
 424
 425         if (pkg_info_value == PM_INTERNAL_STORAGE)
 426                 *storage = PACKAGE_INFO_INTERNAL_STORAGE;
 427         else if (pkg_info_value == PM_EXTERNAL_STORAGE)
 428                 *storage = PACKAGE_INFO_EXTERNAL_STORAGE;
 429
 430         return PACKAGE_MANAGER_ERROR_NONE;
 431 }
 432
 433 int package_info_get_root_path(package_info_h package_info, char **path)
 434 {
 435         char *pkg_info_value = NULL;
 436         char *path_dup = NULL;
 437
 438         if (package_info == NULL || path == NULL)
 439         {
 440                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 441         }
 442
 443         if (pkgmgrinfo_pkginfo_get_root_path(package_info->pkgmgrinfo_pkginfo, &pkg_info_value) != PKGMGR_R_OK)
 444         {
 445                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
 446         }
 447
 448         if(!pkg_info_value)
 449                 goto END;
 450
 451         path_dup = strdup(pkg_info_value);
 452
 453         if (path_dup == NULL)
 454         {
 455                 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
 456         }
 457
 458 END:
 459         *path = path_dup;
 460
 461         return PACKAGE_MANAGER_ERROR_NONE;
 462 }
 463
 464 int package_info_get_tep_name (package_info_h package_info, char **name)
 465 {
 466 #ifdef _APPFW_FEATURE_EXPANSION_PKG_INSTALL
 467         pkgmgrinfo_pkginfo_h pkginfo;
 468         char *tepname_tmp = NULL;
 469         int retval = 0;
 470
 471         if (package_info == NULL || package_info->package == NULL || name == NULL)
 472                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 473
 474         retval = package_manager_admin_check_privilege();
 475         if (retval != PACKAGE_MANAGER_ERROR_NONE) {
 476                 return retval;
 477         }
 478
 479         if (pkgmgrinfo_pkginfo_get_pkginfo(package_info->package, &pkginfo) != PMINFO_R_OK)
 480                 return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
 481
 482         if (pkginfo == NULL)
 483                 return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
 484
 485         if (pkgmgrinfo_pkginfo_get_tep_name(pkginfo, &tepname_tmp) != PMINFO_R_OK)
 486                 return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
 487
 488         if (tepname_tmp != NULL)
 489                 *name = strdup(tepname_tmp);
 490
 491         if (*name == NULL)
 492                 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
 493
 494         pkgmgrinfo_pkginfo_destroy_pkginfo(pkginfo);
 495
 496         return PACKAGE_MANAGER_ERROR_NONE;
 497 #else
 498         return PACKAGE_MANAGER_ERROR_SYSTEM_ERROR;
 499 #endif
 500 }
 501
 502 /*
 503 int package_info_get_install_location(package_info_h package_info, package_manager_package_location_e *location)
 504 {
 505         pkgmgr_install_location pkg_info_value = 0;
 506
 507         if (package_info == NULL || system == NULL)
 508         {
 509                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 510         }
 511
 512         if (pkgmgrinfo_pkginfo_get_install_location(package_info->pkgmgrinfo_pkginfo, &pkg_info_value) != PKGMGR_R_OK)
 513         {
 514                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
 515         }
 516
 517         *location = (pkg_info_value==PM_INSTALL_LOCATION_INTERNAL_ONLY ? PACAKGE_MANAGER_LOCATION_INTERNAL : PACAKGE_MANAGER_LOCATION_EXTERNAL);
 518
 519         return PACKAGE_MANAGER_ERROR_NONE;
 520 }
 521 */
 522
 523 int package_info_is_system_package(package_info_h package_info, bool *system)
 524 {
 525         bool pkg_info_value = false;
 526
 527         if (package_info == NULL || system == NULL)
 528         {
 529                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 530         }
 531
 532         if (pkgmgrinfo_pkginfo_is_preload(package_info->pkgmgrinfo_pkginfo, &pkg_info_value) != PKGMGR_R_OK)
 533         {
 534                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
 535         }
 536
 537         *system = pkg_info_value;
 538
 539         return PACKAGE_MANAGER_ERROR_NONE;
 540 }
 541
 542 int package_info_is_removable_package(package_info_h package_info, bool *removable)
 543 {
 544         bool pkg_info_value = false;
 545
 546         if (package_info == NULL || removable == NULL)
 547         {
 548                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 549         }
 550
 551         if (pkgmgrinfo_pkginfo_is_removable(package_info->pkgmgrinfo_pkginfo, &pkg_info_value) != PKGMGR_R_OK)
 552         {
 553                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
 554         }
 555
 556         *removable = pkg_info_value;
 557
 558         return PACKAGE_MANAGER_ERROR_NONE;
 559 }
 560
 561 int package_info_is_preload_package(package_info_h package_info, bool *preload)
 562 {
 563         bool pkg_info_value = false;
 564
 565         if (package_info == NULL || preload == NULL)
 566         {
 567                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 568         }
 569
 570         if (pkgmgrinfo_pkginfo_is_preload(package_info->pkgmgrinfo_pkginfo, &pkg_info_value) != PKGMGR_R_OK)
 571         {
 572                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
 573         }
 574
 575         *preload = pkg_info_value;
 576
 577         return PACKAGE_MANAGER_ERROR_NONE;
 578 }
 579
 580 int package_info_is_equal(package_info_h lhs, package_info_h rhs, bool *equal)
 581 {
 582         if (lhs == NULL || rhs == NULL || equal == NULL)
 583         {
 584                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 585         }
 586
 587         if (!strcmp(lhs->package, rhs->package))
 588         {
 589                 *equal = true;
 590         }
 591         else
 592         {
 593                 *equal = false;
 594         }
 595
 596         return PACKAGE_MANAGER_ERROR_NONE;
 597 }
 598
 599 int package_info_is_accessible(package_info_h package_info, bool *accessible)
 600 {
 601         int ret = 0;
 602         bool pkg_info_value = false;
 603
 604         if (package_info == NULL || accessible == NULL)
 605         {
 606                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 607         }
 608
 609         ret = pkgmgrinfo_pkginfo_is_accessible(package_info->pkgmgrinfo_pkginfo, &pkg_info_value);
 610         if (ret < 0)
 611                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
 612
 613
 614         *accessible = pkg_info_value;
 615
 616         return PACKAGE_MANAGER_ERROR_NONE;
 617 }
 618
 619 int package_info_clone(package_info_h *clone, package_info_h package_info)
 620 {
 621         int retval;
 622
 623         if (clone == NULL || package_info == NULL)
 624         {
 625                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 626         }
 627
 628         retval = package_info_create(package_info->package, clone);
 629
 630         if (retval != PACKAGE_MANAGER_ERROR_NONE)
 631         {
 632                 return package_manager_error(retval, __FUNCTION__, NULL);
 633         }
 634
 635         return PACKAGE_MANAGER_ERROR_NONE;
 636 }
 637
 638 int package_info_foreach_cert_info(package_info_h package_info, package_info_cert_info_cb callback, void* user_data)
 639 {
 640         int retval;
 641         pkgmgrinfo_certinfo_h handle = NULL;
 642         int i = 0;
 643         const char *cert_value = NULL;
 644
 645         if (package_info == NULL || callback == NULL)
 646         {
 647                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 648         }
 649
 650         retval = pkgmgrinfo_pkginfo_create_certinfo(&handle);
 651         if (retval != PMINFO_R_OK)
 652                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
 653
 654         retval = pkgmgrinfo_pkginfo_load_certinfo(package_info->package, handle);
 655         if (retval != PMINFO_R_OK)
 656         {
 657                 pkgmgrinfo_pkginfo_destroy_certinfo(handle);
 658                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
 659         }
 660
 661         for( i=0; i<=PACKAGE_INFO_DISTRIBUTOR2_SIGNER_CERT; i++)
 662         {
 663                 retval = pkgmgrinfo_pkginfo_get_cert_value(handle, i, &cert_value);
 664                 if (retval != PMINFO_R_OK)
 665                 {
 666                         pkgmgrinfo_pkginfo_destroy_certinfo(handle);
 667                         return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
 668                 }
 669
 670                 if ( cert_value && strncmp(cert_value, "(null)", strlen("(null)")) )
 671                 {
 672                         retval = callback(package_info, (package_cert_type_e)i, cert_value, user_data);
 673                         if (!retval)
 674                                 break;
 675                 }
 676
 677                 cert_value = NULL;
 678         }
 679
 680         pkgmgrinfo_pkginfo_destroy_certinfo(handle);
 681
 682         return PACKAGE_MANAGER_ERROR_NONE;
 683 }
 684
 685 int package_info_foreach_privilege_info(package_info_h package_info, package_info_privilege_info_cb callback, void *user_data)
 686 {
 687         int ret = 0;
 688
 689         if (package_info == NULL || callback == NULL)
 690         {
 691                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 692         }
 693
 694         ret = pkgmgrinfo_pkginfo_foreach_privilege(package_info->pkgmgrinfo_pkginfo, (pkgmgrinfo_pkg_privilege_list_cb)callback, user_data);
 695
 696         return ret;
 697 }