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