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