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
 334         return PACKAGE_MANAGER_ERROR_NONE;
 335 }
 336
 337 API int package_info_get_root_path(package_info_h package_info, char **path)
 338 {
 339         char *pkg_info_value = NULL;
 340         char *path_dup = NULL;
 341
 342         if (package_info == NULL || path == NULL)
 343                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 344
 345         if (pkgmgrinfo_pkginfo_get_root_path(package_info->pkgmgr_pkginfo, &pkg_info_value) != PKGMGR_R_OK)
 346                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
 347
 348         if (!pkg_info_value)
 349                 goto END;
 350
 351         path_dup = strdup(pkg_info_value);
 352
 353         if (path_dup == NULL)
 354                 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
 355
 356 END:
 357         *path = path_dup;
 358
 359         return PACKAGE_MANAGER_ERROR_NONE;
 360 }
 361
 362 API int package_info_get_tep_name(package_info_h package_info, char **name)
 363 {
 364         char *tepname_tmp = NULL;
 365         int retval = 0;
 366
 367         if (package_info == NULL || package_info->package == NULL || name == NULL)
 368                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 369
 370         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_ADMIN);
 371         if (retval != PACKAGE_MANAGER_ERROR_NONE)
 372                 return retval;
 373
 374         if (pkgmgrinfo_pkginfo_get_tep_name(package_info->pkgmgr_pkginfo, &tepname_tmp) != PMINFO_R_OK)
 375                 return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
 376
 377         if (tepname_tmp != NULL)
 378                 *name = strdup(tepname_tmp);
 379
 380         if (*name == NULL)
 381                 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
 382
 383         return PACKAGE_MANAGER_ERROR_NONE;
 384 }
 385
 386 API int package_info_is_system_package(package_info_h package_info, bool *system)
 387 {
 388         bool pkg_info_value = false;
 389
 390         if (package_info == NULL || system == NULL)
 391                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 392
 393         if (pkgmgrinfo_pkginfo_is_system(package_info->pkgmgr_pkginfo, &pkg_info_value) != PKGMGR_R_OK)
 394                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
 395
 396         *system = pkg_info_value;
 397
 398         return PACKAGE_MANAGER_ERROR_NONE;
 399 }
 400
 401 API int package_info_is_removable_package(package_info_h package_info, bool *removable)
 402 {
 403         bool pkg_info_value = false;
 404
 405         if (package_info == NULL || removable == NULL)
 406                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 407
 408         if (pkgmgrinfo_pkginfo_is_removable(package_info->pkgmgr_pkginfo, &pkg_info_value) != PKGMGR_R_OK)
 409                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
 410
 411         *removable = pkg_info_value;
 412
 413         return PACKAGE_MANAGER_ERROR_NONE;
 414 }
 415
 416 API int package_info_is_preload_package(package_info_h package_info, bool *preload)
 417 {
 418         bool pkg_info_value = false;
 419
 420         if (package_info == NULL || preload == NULL)
 421                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 422
 423         if (pkgmgrinfo_pkginfo_is_preload(package_info->pkgmgr_pkginfo, &pkg_info_value) != PKGMGR_R_OK)
 424                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
 425
 426         *preload = pkg_info_value;
 427
 428         return PACKAGE_MANAGER_ERROR_NONE;
 429 }
 430
 431 API int package_info_is_equal(package_info_h lhs, package_info_h rhs, bool *equal)
 432 {
 433         if (lhs == NULL || rhs == NULL || equal == NULL)
 434                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 435
 436         if (!strcmp(lhs->package, rhs->package))
 437                 *equal = true;
 438         else
 439                 *equal = false;
 440
 441         return PACKAGE_MANAGER_ERROR_NONE;
 442 }
 443
 444 API int package_info_is_accessible(package_info_h package_info, bool *accessible)
 445 {
 446         int ret = 0;
 447         bool pkg_info_value = false;
 448
 449         if (package_info == NULL || accessible == NULL)
 450                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 451
 452         ret = pkgmgrinfo_pkginfo_is_accessible(package_info->pkgmgr_pkginfo, &pkg_info_value);
 453         if (ret < 0)
 454                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
 455
 456
 457         *accessible = pkg_info_value;
 458
 459         return PACKAGE_MANAGER_ERROR_NONE;
 460 }
 461
 462 API int package_info_get_installed_time(package_info_h package_info, int *installed_time)
 463 {
 464         int ret;
 465         int time_value;
 466
 467         if (package_info == NULL || installed_time == NULL)
 468                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 469
 470         ret = pkgmgrinfo_pkginfo_get_installed_time(package_info->pkgmgr_pkginfo, &time_value);
 471         if (ret < 0)
 472                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
 473
 474         *installed_time = time_value;
 475
 476         return PACKAGE_MANAGER_ERROR_NONE;
 477 }
 478
 479 API int package_info_clone(package_info_h *clone, package_info_h package_info)
 480 {
 481         int retval;
 482
 483         if (clone == NULL || package_info == NULL)
 484                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 485
 486         retval = package_info_create(package_info->package, clone);
 487
 488         if (retval != PACKAGE_MANAGER_ERROR_NONE)
 489                 return package_manager_error(retval, __FUNCTION__, NULL);
 490
 491         return PACKAGE_MANAGER_ERROR_NONE;
 492 }
 493
 494 API int package_info_foreach_cert_info(package_info_h package_info, package_info_cert_info_cb callback, void *user_data)
 495 {
 496         int retval;
 497         pkgmgrinfo_certinfo_h handle = NULL;
 498         int i = 0;
 499         const char *cert_value = NULL;
 500
 501         if (package_info == NULL || callback == NULL)
 502                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 503
 504         retval = pkgmgrinfo_pkginfo_create_certinfo(&handle);
 505         if (retval != PMINFO_R_OK)
 506                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
 507
 508         retval = pkgmgrinfo_pkginfo_load_certinfo(package_info->package, handle, getuid());
 509         if (retval != PMINFO_R_OK) {
 510                 pkgmgrinfo_pkginfo_destroy_certinfo(handle);
 511                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
 512         }
 513
 514         for (i = 0; i <= PACKAGE_INFO_DISTRIBUTOR2_SIGNER_CERT; i++) {
 515                 retval = pkgmgrinfo_pkginfo_get_cert_value(handle, i, &cert_value);
 516                 if (retval != PMINFO_R_OK) {
 517                         pkgmgrinfo_pkginfo_destroy_certinfo(handle);
 518                         return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
 519                 }
 520
 521                 if (cert_value && strncmp(cert_value, "(null)", strlen("(null)"))) {
 522                         retval = callback(package_info, (package_cert_type_e)i, cert_value, user_data);
 523                         if (!retval)
 524                                 break;
 525                 }
 526
 527                 cert_value = NULL;
 528         }
 529
 530         pkgmgrinfo_pkginfo_destroy_certinfo(handle);
 531
 532         return PACKAGE_MANAGER_ERROR_NONE;
 533 }
 534
 535 API int package_info_foreach_privilege_info(package_info_h package_info, package_info_privilege_info_cb callback, void *user_data)
 536 {
 537         int ret = 0;
 538
 539         if (package_info == NULL || callback == NULL)
 540                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 541
 542         ret = pkgmgrinfo_pkginfo_foreach_privilege(package_info->pkgmgr_pkginfo, (pkgmgrinfo_pkg_privilege_list_cb)callback, user_data);
 543
 544         return ret;
 545 }
 546
 547 API int package_info_updateinfo_create(const char *pkgid, package_updateinfo_h *info)
 548 {
 549         int ret;
 550         package_updateinfo_s *update_info;
 551
 552         if (pkgid == NULL || info == NULL)
 553                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 554
 555         update_info = calloc(1, sizeof(package_updateinfo_s));
 556         if (update_info == NULL)
 557                 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
 558
 559         ret = pkgmgrinfo_updateinfo_get_updateinfo(pkgid, &update_info->update_info);
 560         if (ret == PMINFO_R_ENOENT) {
 561                 free(update_info);
 562                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
 563         } else if (ret == PMINFO_R_EINVAL) {
 564                 free(update_info);
 565                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 566         } else if (ret == PMINFO_R_ERROR) {
 567                 free(update_info);
 568                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
 569         }
 570
 571         *info = update_info;
 572         return PACKAGE_MANAGER_ERROR_NONE;
 573 }
 574
 575 API int package_info_updateinfo_get_pkgid(package_updateinfo_h info, char **package)
 576 {
 577         int ret;
 578         char *pkg_updateinfo_value = NULL;
 579         char *pkgid_dup;
 580         package_updateinfo_s *update_info;
 581
 582         if (package == NULL || info == NULL)
 583                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 584
 585         update_info = (package_updateinfo_s *)info;
 586         ret = pkgmgrinfo_updateinfo_get_pkgid(update_info->update_info, &pkg_updateinfo_value);
 587         if (ret != PMINFO_R_OK || pkg_updateinfo_value == NULL)
 588                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
 589
 590         pkgid_dup = strdup(pkg_updateinfo_value);
 591         if (pkgid_dup == NULL)
 592                 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
 593
 594         *package = pkgid_dup;
 595         return PACKAGE_MANAGER_ERROR_NONE;
 596 }
 597
 598 API int package_info_updateinfo_get_version(package_updateinfo_h info, char **version)
 599 {
 600         int ret;
 601         char *pkg_updateinfo_value = NULL;
 602         char *ver_dup;
 603         package_updateinfo_s *update_info;
 604
 605         if (info == NULL || version == 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_version(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         ver_dup = strdup(pkg_updateinfo_value);
 614         if (ver_dup == NULL)
 615                 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
 616
 617         *version = ver_dup;
 618         return PACKAGE_MANAGER_ERROR_NONE;
 619 }
 620
 621 API int package_info_updateinfo_get_type(package_updateinfo_h info, package_updateinfo_type_e *type)
 622 {
 623         int ret;
 624         pkgmgrinfo_updateinfo_update_type pkg_updateinfo_value;
 625         package_updateinfo_type_e converted_type;
 626         package_updateinfo_s *update_info;
 627
 628         if (info == NULL || type == 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_update_type(update_info->update_info, &pkg_updateinfo_value);
 633         if (ret != PMINFO_R_OK)
 634                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
 635
 636         ret = package_info_updateinfo_convert_type(pkg_updateinfo_value, &converted_type);
 637         if (ret != 0)
 638                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
 639
 640         *type = converted_type;
 641         return PACKAGE_MANAGER_ERROR_NONE;
 642 }
 643
 644 API int package_info_updateinfo_destroy(package_updateinfo_h info)
 645 {
 646         package_updateinfo_s *update_info;
 647
 648         if (info == NULL)
 649                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 650
 651         update_info = (package_updateinfo_s *)info;
 652         pkgmgrinfo_updateinfo_destroy(update_info->update_info);
 653         free(update_info);
 654
 655         return PACKAGE_MANAGER_ERROR_NONE;
 656 }
 657
 658 API int package_info_updateinfo_foreach_info(package_info_updateinfo_cb callback, void *user_data)
 659 {
 660         int ret;
 661
 662         if (callback == NULL)
 663                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 664
 665         foreach_updateinfo_context_s foreach_updateinfo = {
 666                 .callback = callback,
 667                 .user_data = user_data,
 668         };
 669
 670         ret = pkgmgrinfo_updateinfo_foreach_updateinfo(package_info_foreach_updateinfo_cb, &foreach_updateinfo);
 671         if (ret != PMINFO_R_OK)
 672                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
 673
 674         return PACKAGE_MANAGER_ERROR_NONE;
 675 }
 676
 677 int package_info_create_with_pkginfo(pkgmgrinfo_pkginfo_h pkg_handle, package_info_h *package_info)
 678 {
 679         package_info_h pkg_info = NULL;
 680         char *pkg_name = NULL;
 681         int ret;
 682
 683         ret = pkgmgrinfo_pkginfo_get_pkgid(pkg_handle, &pkg_name);
 684         if (ret != PMINFO_R_OK)
 685                 return PACKAGE_MANAGER_ERROR_SYSTEM_ERROR;
 686
 687         pkg_info = calloc(1, sizeof(struct package_info_s));
 688         if (pkg_info == NULL)
 689                 return PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY;
 690
 691         pkg_info->package = strdup(pkg_name);
 692         if (pkg_info->package == NULL) {
 693                 free(pkg_info);
 694                 return PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY;
 695         }
 696
 697         pkg_info->pkgmgr_pkginfo = pkg_handle;
 698         *package_info = pkg_info;
 699
 700         return PACKAGE_MANAGER_ERROR_NONE;
 701 }
 702
 703 int package_info_destroy_handle(package_info_h handle)
 704 {
 705         if (handle == NULL)
 706                 return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
 707
 708         free(handle->package);
 709         free(handle);
 710
 711         return PACKAGE_MANAGER_ERROR_NONE;
 712 }