src/package_info.c

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