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                 /* just return error without error log, because most of packages doesn't use tep */
 401                 return PACKAGE_MANAGER_ERROR_SYSTEM_ERROR;
 402
 403         if (tepname_tmp != NULL)
 404                 *name = strdup(tepname_tmp);
 405
 406         if (*name == NULL)
 407                 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
 408
 409         return PACKAGE_MANAGER_ERROR_NONE;
 410 }
 411
 412 API int package_info_get_res_type(package_info_h package_info, char **res_type)
 413 {
 414         char *pkg_info_value = NULL;
 415         char *res_type_dup = NULL;
 416
 417         if (package_info == NULL || res_type == NULL)
 418                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 419
 420         if (pkgmgrinfo_pkginfo_get_res_type(package_info->pkgmgr_pkginfo, &pkg_info_value) != PKGMGR_R_OK)
 421                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
 422
 423         res_type_dup = strdup(pkg_info_value);
 424
 425         if (res_type_dup == NULL)
 426                 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
 427
 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         *res_version = res_version_dup;
 450
 451         return PACKAGE_MANAGER_ERROR_NONE;
 452 }
 453
 454 API int package_info_is_system_package(package_info_h package_info, bool *system)
 455 {
 456         bool pkg_info_value = false;
 457
 458         if (package_info == NULL || system == NULL)
 459                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 460
 461         if (pkgmgrinfo_pkginfo_is_system(package_info->pkgmgr_pkginfo, &pkg_info_value) != PKGMGR_R_OK)
 462                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
 463
 464         *system = pkg_info_value;
 465
 466         return PACKAGE_MANAGER_ERROR_NONE;
 467 }
 468
 469 API int package_info_is_removable_package(package_info_h package_info, bool *removable)
 470 {
 471         bool pkg_info_value = false;
 472
 473         if (package_info == NULL || removable == NULL)
 474                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 475
 476         if (pkgmgrinfo_pkginfo_is_removable(package_info->pkgmgr_pkginfo, &pkg_info_value) != PKGMGR_R_OK)
 477                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
 478
 479         *removable = pkg_info_value;
 480
 481         return PACKAGE_MANAGER_ERROR_NONE;
 482 }
 483
 484 API int package_info_is_preload_package(package_info_h package_info, bool *preload)
 485 {
 486         bool pkg_info_value = false;
 487
 488         if (package_info == NULL || preload == NULL)
 489                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 490
 491         if (pkgmgrinfo_pkginfo_is_preload(package_info->pkgmgr_pkginfo, &pkg_info_value) != PKGMGR_R_OK)
 492                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
 493
 494         *preload = pkg_info_value;
 495
 496         return PACKAGE_MANAGER_ERROR_NONE;
 497 }
 498
 499 API int package_info_is_equal(package_info_h lhs, package_info_h rhs, bool *equal)
 500 {
 501         if (lhs == NULL || rhs == NULL || equal == NULL)
 502                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 503
 504         if (!strcmp(lhs->package, rhs->package))
 505                 *equal = true;
 506         else
 507                 *equal = false;
 508
 509         return PACKAGE_MANAGER_ERROR_NONE;
 510 }
 511
 512 API int package_info_is_accessible(package_info_h package_info, bool *accessible)
 513 {
 514         int ret = 0;
 515         bool pkg_info_value = false;
 516
 517         if (package_info == NULL || accessible == NULL)
 518                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 519
 520         ret = pkgmgrinfo_pkginfo_is_accessible(package_info->pkgmgr_pkginfo, &pkg_info_value);
 521         if (ret < 0)
 522                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
 523
 524
 525         *accessible = pkg_info_value;
 526
 527         return PACKAGE_MANAGER_ERROR_NONE;
 528 }
 529
 530 API int package_info_get_installed_time(package_info_h package_info, int *installed_time)
 531 {
 532         int ret;
 533         int time_value;
 534
 535         if (package_info == NULL || installed_time == NULL)
 536                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 537
 538         ret = pkgmgrinfo_pkginfo_get_installed_time(package_info->pkgmgr_pkginfo, &time_value);
 539         if (ret < 0)
 540                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
 541
 542         *installed_time = time_value;
 543
 544         return PACKAGE_MANAGER_ERROR_NONE;
 545 }
 546
 547 API int package_info_clone(package_info_h *clone, package_info_h package_info)
 548 {
 549         int retval;
 550
 551         if (clone == NULL || package_info == NULL)
 552                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 553
 554         retval = package_info_create(package_info->package, clone);
 555
 556         if (retval != PACKAGE_MANAGER_ERROR_NONE)
 557                 return package_manager_error(retval, __FUNCTION__, NULL);
 558
 559         return PACKAGE_MANAGER_ERROR_NONE;
 560 }
 561
 562 API int package_info_foreach_cert_info(package_info_h package_info, package_info_cert_info_cb callback, void *user_data)
 563 {
 564         int retval;
 565         pkgmgrinfo_certinfo_h handle = NULL;
 566         int i = 0;
 567         const char *cert_value = NULL;
 568
 569         if (package_info == NULL || callback == NULL)
 570                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 571
 572         retval = pkgmgrinfo_pkginfo_create_certinfo(&handle);
 573         if (retval != PMINFO_R_OK)
 574                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
 575
 576         retval = pkgmgrinfo_pkginfo_load_certinfo(package_info->package, handle, getuid());
 577         if (retval != PMINFO_R_OK) {
 578                 pkgmgrinfo_pkginfo_destroy_certinfo(handle);
 579                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
 580         }
 581
 582         for (i = 0; i <= PACKAGE_INFO_DISTRIBUTOR2_SIGNER_CERT; i++) {
 583                 retval = pkgmgrinfo_pkginfo_get_cert_value(handle, i, &cert_value);
 584                 if (retval != PMINFO_R_OK) {
 585                         pkgmgrinfo_pkginfo_destroy_certinfo(handle);
 586                         return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
 587                 }
 588
 589                 if (cert_value && strncmp(cert_value, "(null)", strlen("(null)"))) {
 590                         retval = callback(package_info, (package_cert_type_e)i, cert_value, user_data);
 591                         if (!retval)
 592                                 break;
 593                 }
 594
 595                 cert_value = NULL;
 596         }
 597
 598         pkgmgrinfo_pkginfo_destroy_certinfo(handle);
 599
 600         return PACKAGE_MANAGER_ERROR_NONE;
 601 }
 602
 603 static int package_info_foreach_privilege_cb(const char *privilege_name, void *user_data)
 604 {
 605         foreach_privilege_s *foreach_privilege = (foreach_privilege_s *)user_data;
 606
 607         if (!foreach_privilege->callback(privilege_name, foreach_privilege->user_data))
 608                 return -1;
 609         else
 610                 return 0;
 611 }
 612
 613 API int package_info_foreach_privilege_info(package_info_h package_info, package_info_privilege_info_cb callback, void *user_data)
 614 {
 615         int ret = 0;
 616         foreach_privilege_s foreach_privilege = {
 617                 .callback = callback,
 618                 .user_data = user_data,
 619         };
 620
 621         if (package_info == NULL || callback == NULL)
 622                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 623
 624         ret = pkgmgrinfo_pkginfo_foreach_privilege(package_info->pkgmgr_pkginfo, package_info_foreach_privilege_cb, &foreach_privilege);
 625
 626         return ret;
 627 }
 628
 629 static int package_info_foreach_dependency_cb(const char *from, const char *to, const char *type, const char *required_version, void *user_data)
 630 {
 631         foreach_dependency_s *foreach_dependency = (foreach_dependency_s *)user_data;
 632
 633         if (!foreach_dependency->callback(from, to, type, required_version, user_data))
 634                 return -1;
 635         else
 636                 return 0;
 637 }
 638
 639 API int package_info_foreach_dependency_info(package_info_h package_info, package_info_dependency_info_cb callback, void *user_data)
 640 {
 641         int ret = 0;
 642         foreach_dependency_s foreach_dependency = {
 643                 .callback = callback,
 644                 .user_data = user_data,
 645         };
 646
 647         if (package_info == NULL || callback == NULL)
 648                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 649
 650         ret = pkgmgrinfo_pkginfo_foreach_dependency(package_info->pkgmgr_pkginfo, package_info_foreach_dependency_cb, &foreach_dependency);
 651         if (ret == PMINFO_R_EINVAL)
 652                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 653         else if (ret == PMINFO_R_ERROR)
 654                 return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
 655
 656         return PACKAGE_MANAGER_ERROR_NONE;
 657 }
 658
 659 API int package_info_foreach_dependency_info_depends_on(package_info_h package_info, package_info_dependency_info_cb callback, void *user_data)
 660 {
 661         int ret = 0;
 662         foreach_dependency_s foreach_dependency = {
 663                 .callback = callback,
 664                 .user_data = user_data,
 665         };
 666
 667         if (package_info == NULL || callback == NULL)
 668                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 669
 670         ret = pkgmgrinfo_pkginfo_foreach_depends_on(package_info->pkgmgr_pkginfo, package_info_foreach_dependency_cb, &foreach_dependency);
 671         if (ret == PMINFO_R_EINVAL)
 672                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 673         else if (ret == PMINFO_R_ERROR)
 674                 return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
 675
 676         return PACKAGE_MANAGER_ERROR_NONE;
 677 }
 678
 679 static int package_info_foreach_res_allowed_package_cb(const char *allowed_package, required_privilege_h privilege_handle, void *user_data)
 680 {
 681         foreach_res_allowed_package_s *foreach_res_allowed_package = (foreach_res_allowed_package_s *)user_data;
 682         allowed_package_required_privilege_s allowed_package_required_privilege = {
 683                 .priv = privilege_handle,
 684         };
 685
 686         if (!foreach_res_allowed_package->callback(allowed_package, &allowed_package_required_privilege, foreach_res_allowed_package->user_data))
 687                 return -1;
 688         else
 689                 return 0;
 690 }
 691
 692 API int package_info_foreach_res_allowed_package(package_info_h package_info, package_info_res_allowed_package_cb callback, void *user_data)
 693 {
 694         int ret = 0;
 695         foreach_res_allowed_package_s foreach_res_allowed_package = {
 696                 .callback = callback,
 697                 .user_data = user_data,
 698         };
 699
 700         if (package_info == NULL || callback == NULL)
 701                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 702
 703         ret = pkgmgrinfo_pkginfo_foreach_res_allowed_package(package_info->pkgmgr_pkginfo, package_info_foreach_res_allowed_package_cb, &foreach_res_allowed_package);
 704         if (ret == PMINFO_R_EINVAL)
 705                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 706         else if (ret == PMINFO_R_ERROR)
 707                 return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
 708
 709         return PACKAGE_MANAGER_ERROR_NONE;
 710 }
 711
 712 API int package_info_foreach_required_privilege(allowed_package_required_privilege_h priv_info, package_info_privilege_info_cb callback, void *user_data)
 713 {
 714         int ret = 0;
 715         foreach_privilege_s foreach_privilege = {
 716                 .callback = callback,
 717                 .user_data = user_data,
 718         };
 719
 720         if (priv_info == NULL || callback == NULL)
 721                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 722
 723         ret = pkgmgrinfo_pkginfo_foreach_required_privilege(priv_info->priv, package_info_foreach_privilege_cb, &foreach_privilege);
 724         if (ret == PMINFO_R_EINVAL)
 725                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 726
 727         return PACKAGE_MANAGER_ERROR_NONE;
 728 }
 729
 730 API int package_info_updateinfo_create(const char *pkgid, package_updateinfo_h *info)
 731 {
 732         int ret;
 733         package_updateinfo_s *update_info;
 734
 735         if (pkgid == NULL || info == NULL)
 736                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 737
 738         update_info = calloc(1, sizeof(package_updateinfo_s));
 739         if (update_info == NULL)
 740                 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
 741
 742         ret = pkgmgrinfo_updateinfo_get_updateinfo(pkgid, &update_info->update_info);
 743         if (ret == PMINFO_R_ENOENT) {
 744                 free(update_info);
 745                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
 746         } else if (ret == PMINFO_R_EINVAL) {
 747                 free(update_info);
 748                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 749         } else if (ret == PMINFO_R_ERROR) {
 750                 free(update_info);
 751                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
 752         }
 753
 754         *info = update_info;
 755         return PACKAGE_MANAGER_ERROR_NONE;
 756 }
 757
 758 API int package_info_updateinfo_get_pkgid(package_updateinfo_h info, char **package)
 759 {
 760         int ret;
 761         char *pkg_updateinfo_value = NULL;
 762         char *pkgid_dup;
 763         package_updateinfo_s *update_info;
 764
 765         if (package == NULL || info == NULL)
 766                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 767
 768         update_info = (package_updateinfo_s *)info;
 769         ret = pkgmgrinfo_updateinfo_get_pkgid(update_info->update_info, &pkg_updateinfo_value);
 770         if (ret != PMINFO_R_OK || pkg_updateinfo_value == NULL)
 771                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
 772
 773         pkgid_dup = strdup(pkg_updateinfo_value);
 774         if (pkgid_dup == NULL)
 775                 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
 776
 777         *package = pkgid_dup;
 778         return PACKAGE_MANAGER_ERROR_NONE;
 779 }
 780
 781 API int package_info_updateinfo_get_version(package_updateinfo_h info, char **version)
 782 {
 783         int ret;
 784         char *pkg_updateinfo_value = NULL;
 785         char *ver_dup;
 786         package_updateinfo_s *update_info;
 787
 788         if (info == NULL || version == NULL)
 789                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 790
 791         update_info = (package_updateinfo_s *)info;
 792         ret = pkgmgrinfo_updateinfo_get_version(update_info->update_info, &pkg_updateinfo_value);
 793         if (ret != PMINFO_R_OK || pkg_updateinfo_value == NULL)
 794                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
 795
 796         ver_dup = strdup(pkg_updateinfo_value);
 797         if (ver_dup == NULL)
 798                 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
 799
 800         *version = ver_dup;
 801         return PACKAGE_MANAGER_ERROR_NONE;
 802 }
 803
 804 API int package_info_updateinfo_get_type(package_updateinfo_h info, package_updateinfo_type_e *type)
 805 {
 806         int ret;
 807         pkgmgrinfo_updateinfo_update_type pkg_updateinfo_value;
 808         package_updateinfo_type_e converted_type;
 809         package_updateinfo_s *update_info;
 810
 811         if (info == NULL || type == NULL)
 812                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 813
 814         update_info = (package_updateinfo_s *)info;
 815         ret = pkgmgrinfo_updateinfo_get_update_type(update_info->update_info, &pkg_updateinfo_value);
 816         if (ret != PMINFO_R_OK)
 817                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
 818
 819         ret = package_info_updateinfo_convert_type(pkg_updateinfo_value, &converted_type);
 820         if (ret != 0)
 821                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
 822
 823         *type = converted_type;
 824         return PACKAGE_MANAGER_ERROR_NONE;
 825 }
 826
 827 API int package_info_updateinfo_destroy(package_updateinfo_h info)
 828 {
 829         package_updateinfo_s *update_info;
 830
 831         if (info == NULL)
 832                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 833
 834         update_info = (package_updateinfo_s *)info;
 835         pkgmgrinfo_updateinfo_destroy(update_info->update_info);
 836         free(update_info);
 837
 838         return PACKAGE_MANAGER_ERROR_NONE;
 839 }
 840
 841 API int package_info_updateinfo_foreach_info(package_info_updateinfo_cb callback, void *user_data)
 842 {
 843         int ret;
 844
 845         if (callback == NULL)
 846                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 847
 848         foreach_updateinfo_context_s foreach_updateinfo = {
 849                 .callback = callback,
 850                 .user_data = user_data,
 851         };
 852
 853         ret = pkgmgrinfo_updateinfo_foreach_updateinfo(package_info_foreach_updateinfo_cb, &foreach_updateinfo);
 854         if (ret != PMINFO_R_OK)
 855                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
 856
 857         return PACKAGE_MANAGER_ERROR_NONE;
 858 }
 859
 860 int package_info_create_with_pkginfo(pkgmgrinfo_pkginfo_h pkg_handle, package_info_h *package_info)
 861 {
 862         package_info_h pkg_info = NULL;
 863         char *pkg_name = NULL;
 864         int ret;
 865
 866         ret = pkgmgrinfo_pkginfo_get_pkgid(pkg_handle, &pkg_name);
 867         if (ret != PMINFO_R_OK)
 868                 return PACKAGE_MANAGER_ERROR_SYSTEM_ERROR;
 869
 870         pkg_info = calloc(1, sizeof(struct package_info_s));
 871         if (pkg_info == NULL)
 872                 return PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY;
 873
 874         pkg_info->package = strdup(pkg_name);
 875         if (pkg_info->package == NULL) {
 876                 free(pkg_info);
 877                 return PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY;
 878         }
 879
 880         pkg_info->pkgmgr_pkginfo = pkg_handle;
 881         *package_info = pkg_info;
 882
 883         return PACKAGE_MANAGER_ERROR_NONE;
 884 }
 885
 886 int package_info_destroy_handle(package_info_h handle)
 887 {
 888         if (handle == NULL)
 889                 return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
 890
 891         free(handle->package);
 892         free(handle);
 893
 894         return PACKAGE_MANAGER_ERROR_NONE;
 895 }