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