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 <tzplatform_config.h>
  26
  27 #include "package_info.h"
  28 #include "package_manager.h"
  29 #include "package_manager_internal.h"
  30
  31 struct package_info_s {
  32         char *package;
  33         pkgmgrinfo_pkginfo_h pkgmgr_pkginfo;
  34 };
  35
  36 struct package_cert_info_s {
  37         char *package;
  38         pkgmgrinfo_certinfo_h pkgmgrinfo_certinfo;
  39 };
  40
  41 typedef struct package_updateinfo_s {
  42         pkgmgrinfo_updateinfo_h update_info;
  43 } package_updateinfo_s;
  44
  45 typedef struct _foreach_app_context_ {
  46         package_info_app_cb callback;
  47         void *user_data;
  48 } foreach_app_context_s;
  49
  50 typedef struct _foreach_updateinfo_ {
  51         package_info_updateinfo_cb callback;
  52         void *user_data;
  53 } foreach_updateinfo_context_s;
  54
  55 typedef struct _foreach_privilege_ {
  56         package_info_privilege_info_cb callback;
  57         void *user_data;
  58 } foreach_privilege_s;
  59
  60 typedef struct _foreach_dependency_ {
  61         package_info_dependency_info_cb callback;
  62         void *user_data;
  63 } foreach_dependency_s;
  64
  65 static int package_info_foreach_updateinfo_cb(const pkgmgrinfo_updateinfo_h handle, void *user_data)
  66 {
  67         foreach_updateinfo_context_s *foreach_updateinfo = user_data;
  68         bool iteration_next;
  69
  70         if (handle == NULL || foreach_updateinfo == NULL)
  71                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
  72         iteration_next = foreach_updateinfo->callback(handle, foreach_updateinfo->user_data);
  73         if (iteration_next == true)
  74                 return PMINFO_R_OK;
  75         else
  76                 return PMINFO_R_ERROR;
  77 }
  78
  79 static int package_info_updateinfo_convert_type(pkgmgrinfo_updateinfo_update_type type, package_updateinfo_type_e *converted_type)
  80 {
  81         if (type == PMINFO_UPDATEINFO_NONE)
  82                 *converted_type = PACKAGE_UPDATEINFO_TYPE_NONE;
  83         else if (type == PMINFO_UPDATEINFO_FORCE)
  84                 *converted_type = PACKAGE_UPDATEINFO_TYPE_FORCE;
  85         else if (type == PMINFO_UPDATEINFO_OPTIONAL)
  86                 *converted_type = PACKAGE_UPDATEINFO_TYPE_OPTIONAL;
  87         else
  88                 return -1;
  89
  90         return 0;
  91 }
  92
  93 API int package_info_create(const char *package, package_info_h *package_info)
  94 {
  95         package_info_h package_info_created;
  96         pkgmgrinfo_pkginfo_h pkgmgr_pkginfo;
  97
  98         if (package == NULL || package_info == NULL)
  99                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 100
 101         if (pkgmgrinfo_pkginfo_get_pkginfo(package, &pkgmgr_pkginfo) != PKGMGR_R_OK)
 102                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
 103
 104         package_info_created = calloc(1, sizeof(struct package_info_s));
 105
 106         if (package_info_created == NULL) {
 107                 pkgmgrinfo_pkginfo_destroy_pkginfo(pkgmgr_pkginfo);
 108                 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
 109         }
 110
 111         package_info_created->package = strdup(package);
 112
 113         if (package_info_created->package == NULL) {
 114                 pkgmgrinfo_pkginfo_destroy_pkginfo(pkgmgr_pkginfo);
 115                 free(package_info_created);
 116                 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
 117         }
 118
 119         package_info_created->pkgmgr_pkginfo = pkgmgr_pkginfo;
 120
 121         *package_info = package_info_created;
 122
 123         return PACKAGE_MANAGER_ERROR_NONE;
 124 }
 125
 126 static int package_info_foreach_app_cb(const pkgmgrinfo_appinfo_h handle, void *user_data)
 127 {
 128         char *appid = NULL;
 129         pkgmgrinfo_app_component comp;
 130         foreach_app_context_s *foreach_app_context = user_data;
 131         int ret = 0;
 132         bool r;
 133
 134         if (handle == NULL || foreach_app_context == NULL) {
 135                 package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 136                 return PKGMGR_R_EINVAL;
 137         }
 138
 139         ret = pkgmgrinfo_appinfo_get_appid(handle, &appid);
 140         if (ret < 0)
 141                 return PKGMGR_R_ERROR;
 142
 143         ret = pkgmgrinfo_appinfo_get_component(handle, &comp);
 144         if (ret < 0)
 145                 return PKGMGR_R_ERROR;
 146
 147         r = foreach_app_context->callback(comp, appid, foreach_app_context->user_data);
 148
 149         return (r == true) ? PKGMGR_R_OK : PKGMGR_R_ERROR;
 150 }
 151
 152 API 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)
 153 {
 154         foreach_app_context_s foreach_app_context = {
 155                 .callback = callback,
 156                 .user_data = user_data,
 157         };
 158
 159         if (package_info == NULL || callback == NULL)
 160                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 161
 162         if (comp_type == PACKAGE_INFO_APP_COMPONENT_TYPE_ALL)
 163                 pkgmgrinfo_appinfo_get_list(package_info->pkgmgr_pkginfo, PMINFO_ALL_APP, package_info_foreach_app_cb, &foreach_app_context);
 164         if (comp_type == PACKAGE_INFO_APP_COMPONENT_TYPE_UI)
 165                 pkgmgrinfo_appinfo_get_list(package_info->pkgmgr_pkginfo, PMINFO_UI_APP, package_info_foreach_app_cb, &foreach_app_context);
 166         if (comp_type == PACKAGE_INFO_APP_COMPONENT_TYPE_SERVICE)
 167                 pkgmgrinfo_appinfo_get_list(package_info->pkgmgr_pkginfo, PMINFO_SVC_APP, package_info_foreach_app_cb, &foreach_app_context);
 168         if (comp_type == PACKAGE_INFO_APP_COMPONENT_TYPE_WIDGET)
 169                 pkgmgrinfo_appinfo_get_list(package_info->pkgmgr_pkginfo, PMINFO_WIDGET_APP, package_info_foreach_app_cb, &foreach_app_context);
 170         if (comp_type == PACKAGE_INFO_APP_COMPONENT_TYPE_WATCH)
 171                 pkgmgrinfo_appinfo_get_list(package_info->pkgmgr_pkginfo, PMINFO_WATCH_APP, package_info_foreach_app_cb, &foreach_app_context);
 172         if (comp_type == PACKAGE_INFO_APP_COMPONENT_TYPE_COMPONENT_BASED)
 173                 pkgmgrinfo_appinfo_get_list(package_info->pkgmgr_pkginfo, PMINFO_COMPONENT_BASED_APP, package_info_foreach_app_cb, &foreach_app_context);
 174
 175         return PACKAGE_MANAGER_ERROR_NONE;
 176 }
 177
 178 API int package_info_destroy(package_info_h package_info)
 179 {
 180         if (package_info == NULL)
 181                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 182
 183         free(package_info->package);
 184
 185         pkgmgrinfo_pkginfo_destroy_pkginfo(package_info->pkgmgr_pkginfo);
 186
 187         free(package_info);
 188
 189         return PACKAGE_MANAGER_ERROR_NONE;
 190 }
 191
 192 API int package_info_get_package(package_info_h package_info, char **package)
 193 {
 194         char *package_dup;
 195
 196         if (package_info == NULL || package == NULL)
 197                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 198
 199         package_dup = strdup(package_info->package);
 200
 201         if (package_dup == NULL)
 202                 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
 203
 204         *package = package_dup;
 205
 206         return PACKAGE_MANAGER_ERROR_NONE;
 207 }
 208
 209 API int package_info_get_main_app_id(package_info_h package_info, char **main_app_id)
 210 {
 211         char *mainappid_dup;
 212         char *pkg_info_value;
 213
 214         if (package_info == NULL || main_app_id == NULL)
 215                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 216
 217         if (pkgmgrinfo_pkginfo_get_mainappid(package_info->pkgmgr_pkginfo, &pkg_info_value) != PKGMGR_R_OK)
 218                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
 219
 220         mainappid_dup = strdup(pkg_info_value);
 221         if (mainappid_dup == NULL)
 222                 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
 223
 224         *main_app_id = mainappid_dup;
 225
 226         return PACKAGE_MANAGER_ERROR_NONE;
 227 }
 228
 229 API int package_info_get_label(package_info_h package_info, char **label)
 230 {
 231         char *pkg_info_value = NULL;
 232         char *label_dup = NULL;
 233
 234         if (package_info == NULL || label == NULL)
 235                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 236
 237         if (pkgmgrinfo_pkginfo_get_label(package_info->pkgmgr_pkginfo, &pkg_info_value) != PKGMGR_R_OK)
 238                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
 239
 240         if (!pkg_info_value)
 241                 goto END;
 242
 243         label_dup = strdup(pkg_info_value);
 244
 245         if (label_dup == NULL)
 246                 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
 247
 248 END:
 249         *label = label_dup;
 250
 251         return PACKAGE_MANAGER_ERROR_NONE;
 252 }
 253
 254 API int package_info_get_icon(package_info_h package_info, char **path)
 255 {
 256         char *pkg_info_value = NULL;
 257         char *icon_dup = NULL;
 258
 259         if (package_info == NULL || path == NULL)
 260                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 261
 262         if (pkgmgrinfo_pkginfo_get_icon(package_info->pkgmgr_pkginfo, &pkg_info_value) != PKGMGR_R_OK)
 263                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
 264
 265         if (!pkg_info_value)
 266                 goto END;
 267
 268         icon_dup = strdup(pkg_info_value);
 269
 270         if (icon_dup == NULL)
 271                 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
 272
 273 END:
 274         *path = icon_dup;
 275
 276         return PACKAGE_MANAGER_ERROR_NONE;
 277 }
 278
 279 API int package_info_get_version(package_info_h package_info, char **version)
 280 {
 281         char *pkg_info_value = NULL;
 282         char *ver_dup = NULL;
 283
 284         if (package_info == NULL || version == NULL)
 285                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 286
 287         if (pkgmgrinfo_pkginfo_get_version(package_info->pkgmgr_pkginfo, &pkg_info_value) != PKGMGR_R_OK)
 288                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
 289
 290         if (!pkg_info_value)
 291                 goto END;
 292
 293         ver_dup = strdup(pkg_info_value);
 294
 295         if (ver_dup == NULL)
 296                 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
 297
 298 END:
 299         *version = ver_dup;
 300
 301         return PACKAGE_MANAGER_ERROR_NONE;
 302 }
 303
 304 API int package_info_get_type(package_info_h package_info, char **type)
 305 {
 306         char *pkg_info_value = NULL;
 307         char *type_dup = NULL;
 308
 309         if (package_info == NULL || type == NULL)
 310                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 311
 312         if (pkgmgrinfo_pkginfo_get_type(package_info->pkgmgr_pkginfo, &pkg_info_value) != PKGMGR_R_OK)
 313                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
 314
 315         if (!pkg_info_value)
 316                 goto END;
 317
 318         type_dup = strdup(pkg_info_value);
 319
 320         if (type_dup == NULL)
 321                 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
 322
 323 END:
 324         *type = type_dup;
 325
 326         return PACKAGE_MANAGER_ERROR_NONE;
 327 }
 328
 329 API int package_info_get_installed_storage(package_info_h package_info, package_info_installed_storage_type_e *storage)
 330 {
 331         int ret = 0;
 332         pkgmgrinfo_installed_storage pkg_info_value;
 333
 334         if (package_info == NULL || storage == NULL)
 335                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 336
 337         ret = pkgmgrinfo_pkginfo_get_installed_storage(package_info->pkgmgr_pkginfo, &pkg_info_value);
 338         if (ret < 0)
 339                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
 340
 341         if (pkg_info_value == PMINFO_INTERNAL_STORAGE)
 342                 *storage = PACKAGE_INFO_INTERNAL_STORAGE;
 343         else if (pkg_info_value == PMINFO_EXTERNAL_STORAGE)
 344                 *storage = PACKAGE_INFO_EXTERNAL_STORAGE;
 345         else if (pkg_info_value == PMINFO_EXTENDED_STORAGE)
 346                 *storage = PACKAGE_INFO_EXTENDED_STORAGE;
 347         else
 348                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
 349
 350         return PACKAGE_MANAGER_ERROR_NONE;
 351 }
 352
 353 API int package_info_get_root_path(package_info_h package_info, char **path)
 354 {
 355         char *pkg_info_value = NULL;
 356         char *path_dup = NULL;
 357
 358         if (package_info == NULL || path == NULL)
 359                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 360
 361         if (pkgmgrinfo_pkginfo_get_root_path(package_info->pkgmgr_pkginfo, &pkg_info_value) != PKGMGR_R_OK)
 362                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
 363
 364         if (!pkg_info_value)
 365                 goto END;
 366
 367         path_dup = strdup(pkg_info_value);
 368
 369         if (path_dup == NULL)
 370                 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
 371
 372 END:
 373         *path = path_dup;
 374
 375         return PACKAGE_MANAGER_ERROR_NONE;
 376 }
 377
 378 API int package_info_get_tep_name(package_info_h package_info, char **name)
 379 {
 380         char *tepname_tmp = NULL;
 381         int retval = 0;
 382
 383         if (package_info == NULL || package_info->package == NULL || name == NULL)
 384                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 385
 386         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_ADMIN);
 387         if (retval != PACKAGE_MANAGER_ERROR_NONE)
 388                 return retval;
 389
 390         if (pkgmgrinfo_pkginfo_get_tep_name(package_info->pkgmgr_pkginfo, &tepname_tmp) != PMINFO_R_OK)
 391                 return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
 392
 393         if (tepname_tmp != NULL)
 394                 *name = strdup(tepname_tmp);
 395
 396         if (*name == NULL)
 397                 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
 398
 399         return PACKAGE_MANAGER_ERROR_NONE;
 400 }
 401
 402 API int package_info_is_system_package(package_info_h package_info, bool *system)
 403 {
 404         bool pkg_info_value = false;
 405
 406         if (package_info == NULL || system == NULL)
 407                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 408
 409         if (pkgmgrinfo_pkginfo_is_system(package_info->pkgmgr_pkginfo, &pkg_info_value) != PKGMGR_R_OK)
 410                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
 411
 412         *system = pkg_info_value;
 413
 414         return PACKAGE_MANAGER_ERROR_NONE;
 415 }
 416
 417 API int package_info_is_removable_package(package_info_h package_info, bool *removable)
 418 {
 419         bool pkg_info_value = false;
 420
 421         if (package_info == NULL || removable == NULL)
 422                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 423
 424         if (pkgmgrinfo_pkginfo_is_removable(package_info->pkgmgr_pkginfo, &pkg_info_value) != PKGMGR_R_OK)
 425                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
 426
 427         *removable = pkg_info_value;
 428
 429         return PACKAGE_MANAGER_ERROR_NONE;
 430 }
 431
 432 API int package_info_is_preload_package(package_info_h package_info, bool *preload)
 433 {
 434         bool pkg_info_value = false;
 435
 436         if (package_info == NULL || preload == NULL)
 437                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 438
 439         if (pkgmgrinfo_pkginfo_is_preload(package_info->pkgmgr_pkginfo, &pkg_info_value) != PKGMGR_R_OK)
 440                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
 441
 442         *preload = pkg_info_value;
 443
 444         return PACKAGE_MANAGER_ERROR_NONE;
 445 }
 446
 447 API int package_info_is_equal(package_info_h lhs, package_info_h rhs, bool *equal)
 448 {
 449         if (lhs == NULL || rhs == NULL || equal == NULL)
 450                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 451
 452         if (!strcmp(lhs->package, rhs->package))
 453                 *equal = true;
 454         else
 455                 *equal = false;
 456
 457         return PACKAGE_MANAGER_ERROR_NONE;
 458 }
 459
 460 API int package_info_is_accessible(package_info_h package_info, bool *accessible)
 461 {
 462         int ret = 0;
 463         bool pkg_info_value = false;
 464
 465         if (package_info == NULL || accessible == NULL)
 466                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 467
 468         ret = pkgmgrinfo_pkginfo_is_accessible(package_info->pkgmgr_pkginfo, &pkg_info_value);
 469         if (ret < 0)
 470                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
 471
 472
 473         *accessible = pkg_info_value;
 474
 475         return PACKAGE_MANAGER_ERROR_NONE;
 476 }
 477
 478 API int package_info_get_installed_time(package_info_h package_info, int *installed_time)
 479 {
 480         int ret;
 481         int time_value;
 482
 483         if (package_info == NULL || installed_time == NULL)
 484                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 485
 486         ret = pkgmgrinfo_pkginfo_get_installed_time(package_info->pkgmgr_pkginfo, &time_value);
 487         if (ret < 0)
 488                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
 489
 490         *installed_time = time_value;
 491
 492         return PACKAGE_MANAGER_ERROR_NONE;
 493 }
 494
 495 API int package_info_clone(package_info_h *clone, package_info_h package_info)
 496 {
 497         int retval;
 498
 499         if (clone == NULL || package_info == NULL)
 500                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 501
 502         retval = package_info_create(package_info->package, clone);
 503
 504         if (retval != PACKAGE_MANAGER_ERROR_NONE)
 505                 return package_manager_error(retval, __FUNCTION__, NULL);
 506
 507         return PACKAGE_MANAGER_ERROR_NONE;
 508 }
 509
 510 API int package_info_foreach_cert_info(package_info_h package_info, package_info_cert_info_cb callback, void *user_data)
 511 {
 512         int retval;
 513         pkgmgrinfo_certinfo_h handle = NULL;
 514         int i = 0;
 515         const char *cert_value = NULL;
 516
 517         if (package_info == NULL || callback == NULL)
 518                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 519
 520         retval = pkgmgrinfo_pkginfo_create_certinfo(&handle);
 521         if (retval != PMINFO_R_OK)
 522                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
 523
 524         retval = pkgmgrinfo_pkginfo_load_certinfo(package_info->package, handle, getuid());
 525         if (retval != PMINFO_R_OK) {
 526                 pkgmgrinfo_pkginfo_destroy_certinfo(handle);
 527                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
 528         }
 529
 530         for (i = 0; i <= PACKAGE_INFO_DISTRIBUTOR2_SIGNER_CERT; i++) {
 531                 retval = pkgmgrinfo_pkginfo_get_cert_value(handle, i, &cert_value);
 532                 if (retval != PMINFO_R_OK) {
 533                         pkgmgrinfo_pkginfo_destroy_certinfo(handle);
 534                         return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
 535                 }
 536
 537                 if (cert_value && strncmp(cert_value, "(null)", strlen("(null)"))) {
 538                         retval = callback(package_info, (package_cert_type_e)i, cert_value, user_data);
 539                         if (!retval)
 540                                 break;
 541                 }
 542
 543                 cert_value = NULL;
 544         }
 545
 546         pkgmgrinfo_pkginfo_destroy_certinfo(handle);
 547
 548         return PACKAGE_MANAGER_ERROR_NONE;
 549 }
 550
 551 static int package_info_foreach_privilege_cb(const char *privilege_name, void *user_data)
 552 {
 553         foreach_privilege_s *foreach_privilege = (foreach_privilege_s *)user_data;
 554
 555         if (!foreach_privilege->callback(privilege_name, foreach_privilege->user_data))
 556                 return -1;
 557         else
 558                 return 0;
 559 }
 560
 561 API int package_info_foreach_privilege_info(package_info_h package_info, package_info_privilege_info_cb callback, void *user_data)
 562 {
 563         int ret = 0;
 564         foreach_privilege_s foreach_privilege = {
 565                 .callback = callback,
 566                 .user_data = user_data,
 567         };
 568
 569         if (package_info == NULL || callback == NULL)
 570                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 571
 572         ret = pkgmgrinfo_pkginfo_foreach_privilege(package_info->pkgmgr_pkginfo, package_info_foreach_privilege_cb, &foreach_privilege);
 573
 574         return ret;
 575 }
 576
 577 static int package_info_foreach_dependency_cb(const char *from, const char *to, const char *type, const char *required_version, void *user_data)
 578 {
 579         foreach_dependency_s *foreach_dependency = (foreach_dependency_s *)user_data;
 580
 581         if (!foreach_dependency->callback(from, to, type, required_version, user_data))
 582                 return -1;
 583         else
 584                 return 0;
 585 }
 586
 587 API int package_info_foreach_dependency_info(package_info_h package_info, package_info_dependency_info_cb callback, void *user_data)
 588 {
 589         int ret = 0;
 590         foreach_dependency_s foreach_dependency = {
 591                 .callback = callback,
 592                 .user_data = user_data,
 593         };
 594
 595         if (package_info == NULL || callback == NULL)
 596                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 597
 598         ret = pkgmgrinfo_pkginfo_foreach_dependency(package_info->pkgmgr_pkginfo, package_info_foreach_dependency_cb, &foreach_dependency);
 599         if (ret == PMINFO_R_EINVAL)
 600                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 601         else if (ret == PMINFO_R_ERROR)
 602                 return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
 603
 604         return PACKAGE_MANAGER_ERROR_NONE;
 605 }
 606
 607 API int package_info_foreach_dependency_info_depends_on(package_info_h package_info, package_info_dependency_info_cb callback, void *user_data)
 608 {
 609         int ret = 0;
 610         foreach_dependency_s foreach_dependency = {
 611                 .callback = callback,
 612                 .user_data = user_data,
 613         };
 614
 615         if (package_info == NULL || callback == NULL)
 616                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 617
 618         ret = pkgmgrinfo_pkginfo_foreach_depends_on(package_info->pkgmgr_pkginfo, package_info_foreach_dependency_cb, &foreach_dependency);
 619         if (ret == PMINFO_R_EINVAL)
 620                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 621         else if (ret == PMINFO_R_ERROR)
 622                 return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
 623
 624         return PACKAGE_MANAGER_ERROR_NONE;
 625 }
 626
 627 API int package_info_updateinfo_create(const char *pkgid, package_updateinfo_h *info)
 628 {
 629         int ret;
 630         package_updateinfo_s *update_info;
 631
 632         if (pkgid == NULL || info == NULL)
 633                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 634
 635         update_info = calloc(1, sizeof(package_updateinfo_s));
 636         if (update_info == NULL)
 637                 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
 638
 639         ret = pkgmgrinfo_updateinfo_get_updateinfo(pkgid, &update_info->update_info);
 640         if (ret == PMINFO_R_ENOENT) {
 641                 free(update_info);
 642                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
 643         } else if (ret == PMINFO_R_EINVAL) {
 644                 free(update_info);
 645                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 646         } else if (ret == PMINFO_R_ERROR) {
 647                 free(update_info);
 648                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
 649         }
 650
 651         *info = update_info;
 652         return PACKAGE_MANAGER_ERROR_NONE;
 653 }
 654
 655 API int package_info_updateinfo_get_pkgid(package_updateinfo_h info, char **package)
 656 {
 657         int ret;
 658         char *pkg_updateinfo_value = NULL;
 659         char *pkgid_dup;
 660         package_updateinfo_s *update_info;
 661
 662         if (package == NULL || info == NULL)
 663                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 664
 665         update_info = (package_updateinfo_s *)info;
 666         ret = pkgmgrinfo_updateinfo_get_pkgid(update_info->update_info, &pkg_updateinfo_value);
 667         if (ret != PMINFO_R_OK || pkg_updateinfo_value == NULL)
 668                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
 669
 670         pkgid_dup = strdup(pkg_updateinfo_value);
 671         if (pkgid_dup == NULL)
 672                 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
 673
 674         *package = pkgid_dup;
 675         return PACKAGE_MANAGER_ERROR_NONE;
 676 }
 677
 678 API int package_info_updateinfo_get_version(package_updateinfo_h info, char **version)
 679 {
 680         int ret;
 681         char *pkg_updateinfo_value = NULL;
 682         char *ver_dup;
 683         package_updateinfo_s *update_info;
 684
 685         if (info == NULL || version == NULL)
 686                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 687
 688         update_info = (package_updateinfo_s *)info;
 689         ret = pkgmgrinfo_updateinfo_get_version(update_info->update_info, &pkg_updateinfo_value);
 690         if (ret != PMINFO_R_OK || pkg_updateinfo_value == NULL)
 691                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
 692
 693         ver_dup = strdup(pkg_updateinfo_value);
 694         if (ver_dup == NULL)
 695                 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
 696
 697         *version = ver_dup;
 698         return PACKAGE_MANAGER_ERROR_NONE;
 699 }
 700
 701 API int package_info_updateinfo_get_type(package_updateinfo_h info, package_updateinfo_type_e *type)
 702 {
 703         int ret;
 704         pkgmgrinfo_updateinfo_update_type pkg_updateinfo_value;
 705         package_updateinfo_type_e converted_type;
 706         package_updateinfo_s *update_info;
 707
 708         if (info == NULL || type == NULL)
 709                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 710
 711         update_info = (package_updateinfo_s *)info;
 712         ret = pkgmgrinfo_updateinfo_get_update_type(update_info->update_info, &pkg_updateinfo_value);
 713         if (ret != PMINFO_R_OK)
 714                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
 715
 716         ret = package_info_updateinfo_convert_type(pkg_updateinfo_value, &converted_type);
 717         if (ret != 0)
 718                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
 719
 720         *type = converted_type;
 721         return PACKAGE_MANAGER_ERROR_NONE;
 722 }
 723
 724 API int package_info_updateinfo_destroy(package_updateinfo_h info)
 725 {
 726         package_updateinfo_s *update_info;
 727
 728         if (info == NULL)
 729                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 730
 731         update_info = (package_updateinfo_s *)info;
 732         pkgmgrinfo_updateinfo_destroy(update_info->update_info);
 733         free(update_info);
 734
 735         return PACKAGE_MANAGER_ERROR_NONE;
 736 }
 737
 738 API int package_info_updateinfo_foreach_info(package_info_updateinfo_cb callback, void *user_data)
 739 {
 740         int ret;
 741
 742         if (callback == NULL)
 743                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 744
 745         foreach_updateinfo_context_s foreach_updateinfo = {
 746                 .callback = callback,
 747                 .user_data = user_data,
 748         };
 749
 750         ret = pkgmgrinfo_updateinfo_foreach_updateinfo(package_info_foreach_updateinfo_cb, &foreach_updateinfo);
 751         if (ret != PMINFO_R_OK)
 752                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
 753
 754         return PACKAGE_MANAGER_ERROR_NONE;
 755 }
 756
 757 int package_info_create_with_pkginfo(pkgmgrinfo_pkginfo_h pkg_handle, package_info_h *package_info)
 758 {
 759         package_info_h pkg_info = NULL;
 760         char *pkg_name = NULL;
 761         int ret;
 762
 763         ret = pkgmgrinfo_pkginfo_get_pkgid(pkg_handle, &pkg_name);
 764         if (ret != PMINFO_R_OK)
 765                 return PACKAGE_MANAGER_ERROR_SYSTEM_ERROR;
 766
 767         pkg_info = calloc(1, sizeof(struct package_info_s));
 768         if (pkg_info == NULL)
 769                 return PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY;
 770
 771         pkg_info->package = strdup(pkg_name);
 772         if (pkg_info->package == NULL) {
 773                 free(pkg_info);
 774                 return PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY;
 775         }
 776
 777         pkg_info->pkgmgr_pkginfo = pkg_handle;
 778         *package_info = pkg_info;
 779
 780         return PACKAGE_MANAGER_ERROR_NONE;
 781 }
 782
 783 int package_info_destroy_handle(package_info_h handle)
 784 {
 785         if (handle == NULL)
 786                 return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
 787
 788         free(handle->package);
 789         free(handle);
 790
 791         return PACKAGE_MANAGER_ERROR_NONE;
 792 }