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