src/pkgmgrinfo_pkginfo.c

   1 /*
   2  * pkgmgr-info
   3  *
   4  * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Contact: Jayoun Lee <airjany@samsung.com>, Sewook Park <sewook7.park@samsung.com>,
   7  * Jaeho Lee <jaeho81.lee@samsung.com>, Shobhit Srivastava <shobhit.s@samsung.com>
   8  *
   9  * Licensed under the Apache License, Version 2.0 (the "License");
  10  * you may not use this file except in compliance with the License.
  11  * You may obtain a copy of the License at
  12  *
  13  * http://www.apache.org/licenses/LICENSE-2.0
  14  *
  15  * Unless required by applicable law or agreed to in writing, software
  16  * distributed under the License is distributed on an "AS IS" BASIS,
  17  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  18  * See the License for the specific language governing permissions and
  19  * limitations under the License.
  20  *
  21  */
  22
  23 #define _GNU_SOURCE
  24 #include <stdio.h>
  25 #include <stdlib.h>
  26 #include <string.h>
  27 #include <stdbool.h>
  28 #include <unistd.h>
  29 #include <ctype.h>
  30 #include <sys/smack.h>
  31 #include <linux/limits.h>
  32 #include <libgen.h>
  33 #include <sys/stat.h>
  34
  35 #include <glib.h>
  36
  37 #include "pkgmgrinfo_basic.h"
  38 #include "pkgmgrinfo_private.h"
  39 #include "pkgmgrinfo_debug.h"
  40 #include "pkgmgr-info.h"
  41 #include "manager/pkginfo_manager.h"
  42
  43 static bool _get_bool_value(const char *str)
  44 {
  45         if (str && !strcmp(str, "true"))
  46                 return true;
  47         else
  48                 return false;
  49 }
  50
  51 static gint __compare_func(gconstpointer data1, gconstpointer data2)
  52 {
  53         pkgmgrinfo_node_x *node1 = (pkgmgrinfo_node_x *)data1;
  54         pkgmgrinfo_node_x *node2 = (pkgmgrinfo_node_x *)data2;
  55         if (node1->prop == node2->prop)
  56                 return 0;
  57         else if (node1->prop > node2->prop)
  58                 return 1;
  59         else
  60                 return -1;
  61 }
  62
  63 static gint __pkg_disable_chk_func(gconstpointer data1, gconstpointer data2)
  64 {
  65         pkgmgrinfo_node_x *node = (pkgmgrinfo_node_x *)data1;
  66
  67         if (node->prop == E_PMINFO_PKGINFO_PROP_PACKAGE_DISABLE)
  68                 return 0;
  69         else
  70                 return 1;
  71 }
  72
  73 static void __destroy_metadata_node(gpointer data)
  74 {
  75         pkgmgrinfo_metadata_node_x *node = (pkgmgrinfo_metadata_node_x *)data;
  76         if (node->key)
  77                 free(node->key);
  78         if (node->value)
  79                 free(node->value);
  80         free(node);
  81 }
  82
  83 static void __cleanup_pkginfo(pkgmgr_pkginfo_x *data)
  84 {
  85         ret_if(data == NULL);
  86         if (data->locale) {
  87                 free((void *)data->locale);
  88                 data->locale = NULL;
  89         }
  90
  91         pkgmgrinfo_basic_free_package(data->pkg_info);
  92         free((void *)data);
  93         data = NULL;
  94         return;
  95 }
  96
  97 static void __free_packages(gpointer data)
  98 {
  99         pkgmgrinfo_basic_free_package((package_x *)data);
 100 }
 101
 102 static bool __check_disable_filter_exist(pkgmgrinfo_filter_x *filter)
 103 {
 104         GSList *link;
 105
 106         if (filter == NULL)
 107                 return false;
 108
 109         link = g_slist_find_custom(filter->list, NULL, __pkg_disable_chk_func);
 110         if (link)
 111                 return true;
 112
 113         return false;
 114 }
 115
 116 static int _pkginfo_get_filtered_foreach_pkginfo(uid_t uid,
 117                 pkgmgrinfo_filter_x *filter, int flag,
 118                 pkgmgrinfo_pkg_list_cb pkg_list_cb, void *user_data)
 119 {
 120         int ret;
 121         package_x *pkg;
 122         pkgmgr_pkginfo_x info;
 123         GHashTable *list;
 124         GHashTableIter iter;
 125         gpointer value;
 126
 127         list = g_hash_table_new_full(g_str_hash, g_str_equal, NULL,
 128                         __free_packages);
 129         if (list == NULL)
 130                 return PMINFO_R_ERROR;
 131
 132         if (__check_disable_filter_exist(filter) == false) {
 133                 ret = pkgmgrinfo_pkginfo_filter_add_bool(filter,
 134                                 PMINFO_PKGINFO_PROP_PACKAGE_DISABLE, false);
 135                 if (ret != PMINFO_R_OK) {
 136                         _LOGE("Failed to add filter");
 137                         g_hash_table_destroy(list);
 138                         return PMINFO_R_ERROR;
 139                 }
 140         }
 141
 142         ret = _pkginfo_get_packages(uid, filter, flag, list);
 143         if (ret == PMINFO_R_ERROR) {
 144                 g_hash_table_destroy(list);
 145                 return ret;
 146         }
 147
 148         g_hash_table_iter_init(&iter, list);
 149         while (g_hash_table_iter_next(&iter, NULL, &value)) {
 150                 pkg = (package_x *)value;
 151                 info.uid = uid;
 152                 info.pkg_info = pkg;
 153                 info.locale = pkg->locale;
 154                 if (pkg_list_cb(&info, user_data) < 0)
 155                         break;
 156         }
 157
 158         g_hash_table_destroy(list);
 159
 160         return PMINFO_R_OK;
 161 }
 162
 163 static int _pkgmgrinfo_get_pkginfo(const char *pkgid, uid_t uid,
 164         pkgmgrinfo_pkginfo_filter_h filter, pkgmgrinfo_pkginfo_h *handle)
 165 {
 166         int ret;
 167         GHashTable *list;
 168         pkgmgr_pkginfo_x *info;
 169
 170         if (pkgid == NULL || filter == NULL || handle == NULL) {
 171                         LOGE("invalid parameter");
 172                         return PMINFO_R_EINVAL;
 173         }
 174
 175         list = g_hash_table_new_full(g_str_hash, g_str_equal, NULL,
 176                         __free_packages);
 177         if (list == NULL)
 178                 return PMINFO_R_ERROR;
 179
 180         ret = _pkginfo_get_packages(uid, filter, PMINFO_PKGINFO_GET_ALL, list);
 181         if (ret != PMINFO_R_OK) {
 182                 g_hash_table_destroy(list);
 183                 return ret;
 184         }
 185
 186         if (!g_hash_table_size(list) || !g_hash_table_lookup(list, pkgid)) {
 187                 _LOGD("pkginfo for [%s] is not existed for user [%d]",
 188                                 pkgid, uid);
 189                 g_hash_table_destroy(list);
 190                 return PMINFO_R_ENOENT;
 191         }
 192
 193         info = calloc(1, sizeof(pkgmgr_pkginfo_x));
 194         if (info == NULL) {
 195                 _LOGE("out of memory");
 196                 g_hash_table_destroy(list);
 197                 return PMINFO_R_ERROR;
 198         }
 199
 200         info->uid = uid;
 201         info->pkg_info = (package_x *)g_hash_table_lookup(list, pkgid);
 202         info->locale = strdup(info->pkg_info->locale);
 203         if (info->locale == NULL) {
 204                 _LOGE("Out of memory");
 205                 g_hash_table_destroy(list);
 206                 free(info);
 207                 return PMINFO_R_ERROR;
 208         }
 209
 210         /* just free list only */
 211         g_hash_table_steal(list, (gconstpointer)pkgid);
 212         g_hash_table_destroy(list);
 213
 214         *handle = info;
 215
 216         return ret;
 217 }
 218
 219 API int pkgmgrinfo_pkginfo_get_usr_pkginfo(const char *pkgid, uid_t uid,
 220                 pkgmgrinfo_pkginfo_h *handle)
 221 {
 222         int ret;
 223         pkgmgrinfo_pkginfo_filter_h filter;
 224
 225         if (pkgid == NULL || handle == NULL) {
 226                 LOGE("invalid parameter");
 227                 return PMINFO_R_EINVAL;
 228         }
 229
 230         ret = pkgmgrinfo_pkginfo_filter_create(&filter);
 231         if (ret != PMINFO_R_OK)
 232                 return ret;
 233
 234         ret = pkgmgrinfo_pkginfo_filter_add_string(filter,
 235                         PMINFO_PKGINFO_PROP_PACKAGE_ID, pkgid);
 236         if (ret != PMINFO_R_OK) {
 237                 pkgmgrinfo_pkginfo_filter_destroy(filter);
 238                 return PMINFO_R_ERROR;
 239         }
 240
 241         ret = pkgmgrinfo_pkginfo_filter_add_bool(filter,
 242                         PMINFO_PKGINFO_PROP_PACKAGE_DISABLE, false);
 243         if (ret != PMINFO_R_OK) {
 244                 pkgmgrinfo_pkginfo_filter_destroy(filter);
 245                 return PMINFO_R_ERROR;
 246         }
 247         ret = _pkgmgrinfo_get_pkginfo(pkgid, uid, filter, handle);
 248         pkgmgrinfo_pkginfo_filter_destroy(filter);
 249
 250         return ret;
 251 }
 252
 253 API int pkgmgrinfo_pkginfo_get_pkginfo(const char *pkgid,
 254                 pkgmgrinfo_pkginfo_h *handle)
 255 {
 256         return pkgmgrinfo_pkginfo_get_usr_pkginfo(pkgid, _getuid(), handle);
 257 }
 258
 259 API int pkgmgrinfo_pkginfo_get_usr_disabled_pkginfo(const char *pkgid,
 260                 uid_t uid, pkgmgrinfo_pkginfo_h *handle)
 261 {
 262         int ret;
 263         pkgmgrinfo_pkginfo_filter_h filter;
 264
 265         if (pkgid == NULL || handle == NULL) {
 266                 LOGE("invalid parameter");
 267                 return PMINFO_R_EINVAL;
 268         }
 269
 270         ret = pkgmgrinfo_pkginfo_filter_create(&filter);
 271         if (ret != PMINFO_R_OK) {
 272                 return ret;
 273         }
 274
 275         ret = pkgmgrinfo_pkginfo_filter_add_string(filter,
 276                         PMINFO_PKGINFO_PROP_PACKAGE_ID, pkgid);
 277         if (ret != PMINFO_R_OK) {
 278                 pkgmgrinfo_pkginfo_filter_destroy(filter);
 279                 return PMINFO_R_ERROR;
 280         }
 281
 282         ret = pkgmgrinfo_pkginfo_filter_add_bool(filter,
 283                         PMINFO_PKGINFO_PROP_PACKAGE_DISABLE, true);
 284         if (ret != PMINFO_R_OK) {
 285                 pkgmgrinfo_pkginfo_filter_destroy(filter);
 286                 return PMINFO_R_ERROR;
 287         }
 288
 289         ret = _pkgmgrinfo_get_pkginfo(pkgid, uid, filter, handle);
 290         if (ret == PMINFO_R_ENOENT)
 291                 LOGE("disabled pkginfo for [%s] is not existed for user [%d]",
 292                                 pkgid, uid);
 293         pkgmgrinfo_pkginfo_filter_destroy(filter);
 294         return ret;
 295 }
 296
 297 API int pkgmgrinfo_pkginfo_get_usr_all_pkginfo(const char *pkgid, uid_t uid,
 298                 pkgmgrinfo_pkginfo_h *handle)
 299 {
 300         int ret;
 301         pkgmgrinfo_pkginfo_filter_h filter;
 302
 303         if (pkgid == NULL || handle == NULL) {
 304                 LOGE("invalid parameter");
 305                 return PMINFO_R_EINVAL;
 306         }
 307
 308         ret = pkgmgrinfo_pkginfo_filter_create(&filter);
 309         if (ret != PMINFO_R_OK)
 310                 return ret;
 311
 312         ret = pkgmgrinfo_pkginfo_filter_add_string(filter,
 313                         PMINFO_PKGINFO_PROP_PACKAGE_ID, pkgid);
 314         if (ret != PMINFO_R_OK) {
 315                 pkgmgrinfo_pkginfo_filter_destroy(filter);
 316                 return PMINFO_R_ERROR;
 317         }
 318
 319         ret = pkgmgrinfo_pkginfo_filter_add_bool(filter,
 320                         PMINFO_PKGINFO_PROP_PACKAGE_CHECK_STORAGE, false);
 321         if (ret != PMINFO_R_OK) {
 322                 pkgmgrinfo_pkginfo_filter_destroy(filter);
 323                 return PMINFO_R_ERROR;
 324         }
 325
 326         ret = _pkgmgrinfo_get_pkginfo(pkgid, uid, filter, handle);
 327         pkgmgrinfo_pkginfo_filter_destroy(filter);
 328
 329         return ret;
 330 }
 331
 332 API int pkgmgrinfo_pkginfo_get_disabled_pkginfo(const char *pkgid,
 333                 pkgmgrinfo_pkginfo_h *handle)
 334 {
 335         return pkgmgrinfo_pkginfo_get_usr_disabled_pkginfo(pkgid, _getuid(),
 336                         handle);
 337 }
 338
 339 API int pkgmgrinfo_pkginfo_get_all_pkginfo(const char *pkgid,
 340                 pkgmgrinfo_pkginfo_h *handle)
 341 {
 342         return pkgmgrinfo_pkginfo_get_usr_all_pkginfo(pkgid, _getuid(), handle);
 343 }
 344
 345 API int pkgmgrinfo_pkginfo_get_usr_list_full(pkgmgrinfo_pkg_list_cb pkg_list_cb,
 346                 int flag, void *user_data, uid_t uid)
 347 {
 348         int ret;
 349         pkgmgrinfo_pkginfo_filter_h filter;
 350
 351         if (pkg_list_cb == NULL) {
 352                 LOGE("invalid parameter");
 353                 return PMINFO_R_EINVAL;
 354         }
 355
 356         /* create an empty filter */
 357         ret = pkgmgrinfo_pkginfo_filter_create(&filter);
 358         if (ret != PMINFO_R_OK)
 359                 return ret;
 360
 361         ret = _pkginfo_get_filtered_foreach_pkginfo(uid, filter, flag,
 362                         pkg_list_cb, user_data);
 363
 364         pkgmgrinfo_pkginfo_filter_destroy(filter);
 365
 366         return ret;
 367 }
 368
 369 API int pkgmgrinfo_pkginfo_get_list_full(pkgmgrinfo_pkg_list_cb pkg_list_cb,
 370                 int flag, void *user_data)
 371 {
 372         return pkgmgrinfo_pkginfo_get_usr_list_full(pkg_list_cb, flag,
 373                         user_data, _getuid());
 374 }
 375
 376 API int pkgmgrinfo_pkginfo_get_usr_list(pkgmgrinfo_pkg_list_cb pkg_list_cb,
 377                 void *user_data, uid_t uid)
 378 {
 379         int ret;
 380         pkgmgrinfo_pkginfo_filter_h filter;
 381
 382         if (pkg_list_cb == NULL) {
 383                 LOGE("invalid parameter");
 384                 return PMINFO_R_EINVAL;
 385         }
 386
 387         /* create an empty filter */
 388         ret = pkgmgrinfo_pkginfo_filter_create(&filter);
 389         if (ret != PMINFO_R_OK)
 390                 return ret;
 391
 392         ret = _pkginfo_get_filtered_foreach_pkginfo(uid, filter,
 393                         PMINFO_PKGINFO_GET_ALL, pkg_list_cb, user_data);
 394
 395         pkgmgrinfo_pkginfo_filter_destroy(filter);
 396
 397         return ret;
 398 }
 399
 400 API int pkgmgrinfo_pkginfo_get_list(pkgmgrinfo_pkg_list_cb pkg_list_cb,
 401                 void *user_data)
 402 {
 403         return pkgmgrinfo_pkginfo_get_usr_list(pkg_list_cb, user_data,
 404                         _getuid());
 405 }
 406
 407 API int pkgmgrinfo_pkginfo_get_usr_disabled_list(
 408                 pkgmgrinfo_pkg_list_cb pkg_list_cb, void *user_data, uid_t uid)
 409 {
 410         int ret;
 411         pkgmgrinfo_pkginfo_filter_h filter;
 412
 413         if (pkg_list_cb == NULL) {
 414                 LOGE("invalid parameter");
 415                 return PMINFO_R_EINVAL;
 416         }
 417
 418         ret = pkgmgrinfo_pkginfo_filter_create(&filter);
 419         if (ret != PMINFO_R_OK)
 420                 return ret;
 421
 422         ret = pkgmgrinfo_pkginfo_filter_add_bool(filter,
 423                         PMINFO_PKGINFO_PROP_PACKAGE_DISABLE, true);
 424         if (ret != PMINFO_R_OK) {
 425                 pkgmgrinfo_pkginfo_filter_destroy(filter);
 426                 return PMINFO_R_ERROR;
 427         }
 428
 429         ret = _pkginfo_get_filtered_foreach_pkginfo(uid, filter,
 430                         PMINFO_PKGINFO_GET_ALL, pkg_list_cb, user_data);
 431
 432         pkgmgrinfo_pkginfo_filter_destroy(filter);
 433
 434         return ret;
 435 }
 436
 437 API int pkgmgrinfo_pkginfo_get_disabled_list(pkgmgrinfo_pkg_list_cb pkg_list_cb,
 438                 void *user_data)
 439 {
 440         return pkgmgrinfo_pkginfo_get_usr_disabled_list(pkg_list_cb, user_data,
 441                         _getuid());
 442 }
 443
 444 API int pkgmgrinfo_pkginfo_get_pkgname(pkgmgrinfo_pkginfo_h handle, char **pkg_name)
 445 {
 446         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
 447
 448         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
 449         retvm_if(pkg_name == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
 450
 451         if (info->pkg_info == NULL || info->pkg_info->package == NULL)
 452                 return PMINFO_R_ERROR;
 453
 454         *pkg_name = (char *)info->pkg_info->package;
 455
 456         return PMINFO_R_OK;
 457 }
 458
 459 API int pkgmgrinfo_pkginfo_get_pkgid(pkgmgrinfo_pkginfo_h handle, char **pkgid)
 460 {
 461         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
 462
 463         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
 464         retvm_if(pkgid == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
 465
 466         if (info->pkg_info == NULL || info->pkg_info->package == NULL)
 467                 return PMINFO_R_ERROR;
 468
 469         *pkgid = (char *)info->pkg_info->package;
 470
 471         return PMINFO_R_OK;
 472 }
 473
 474 API int pkgmgrinfo_pkginfo_get_type(pkgmgrinfo_pkginfo_h handle, char **type)
 475 {
 476         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
 477
 478         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
 479         retvm_if(type == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
 480
 481         if (info->pkg_info == NULL)
 482                 return PMINFO_R_ERROR;
 483
 484         if (info->pkg_info->type == NULL)
 485                 *type = "";
 486         else
 487                 *type = (char *)info->pkg_info->type;
 488
 489         return PMINFO_R_OK;
 490 }
 491
 492 API int pkgmgrinfo_pkginfo_get_version(pkgmgrinfo_pkginfo_h handle, char **version)
 493 {
 494         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
 495
 496         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
 497         retvm_if(version == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
 498
 499         if (info->pkg_info == NULL)
 500                 return PMINFO_R_ERROR;
 501
 502         if (info->pkg_info->version == NULL)
 503                 *version = "";
 504         else
 505                 *version = (char *)info->pkg_info->version;
 506
 507         return PMINFO_R_OK;
 508 }
 509
 510 API int pkgmgrinfo_pkginfo_get_api_version(pkgmgrinfo_pkginfo_h handle, char **api_version)
 511 {
 512         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
 513
 514         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
 515         retvm_if(api_version == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
 516
 517         if (info->pkg_info == NULL)
 518                 return PMINFO_R_ERROR;
 519
 520         if (info->pkg_info->api_version == NULL)
 521                 *api_version = "";
 522         else
 523                 *api_version = (char *)info->pkg_info->api_version;
 524
 525         return PMINFO_R_OK;
 526 }
 527
 528 API int pkgmgrinfo_pkginfo_get_tep_name(pkgmgrinfo_pkginfo_h handle, char **tep_name)
 529 {
 530         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
 531
 532         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
 533         retvm_if(tep_name == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
 534
 535         if (info->pkg_info == NULL || info->pkg_info->tep_name == NULL)
 536                 return PMINFO_R_ERROR;
 537
 538         *tep_name = (char *)info->pkg_info->tep_name;
 539
 540         return PMINFO_R_OK;
 541 }
 542
 543 API int pkgmgrinfo_pkginfo_get_zip_mount_file(pkgmgrinfo_pkginfo_h handle, char **zip_mount_file)
 544 {
 545         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
 546
 547         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
 548         retvm_if(zip_mount_file == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
 549
 550         if (info->pkg_info == NULL)
 551                 return PMINFO_R_ERROR;
 552
 553         if (info->pkg_info->zip_mount_file == NULL)
 554                 *zip_mount_file = "";
 555         else
 556                 *zip_mount_file = (char *)info->pkg_info->zip_mount_file;
 557
 558         return PMINFO_R_OK;
 559 }
 560
 561 API int pkgmgrinfo_pkginfo_get_external_image_path(pkgmgrinfo_pkginfo_h handle, char **ext_image_path)
 562 {
 563         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
 564
 565         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
 566         retvm_if(ext_image_path == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
 567
 568         if (info->pkg_info == NULL)
 569                 return PMINFO_R_ERROR;
 570
 571         if (info->pkg_info->external_path == NULL)
 572                 return PMINFO_R_ENOENT;
 573
 574         *ext_image_path = (char *)info->pkg_info->external_path;
 575
 576         return PMINFO_R_OK;
 577 }
 578
 579 API int pkgmgrinfo_pkginfo_get_install_location(pkgmgrinfo_pkginfo_h handle, pkgmgrinfo_install_location *location)
 580 {
 581         char *val;
 582         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
 583
 584         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
 585         retvm_if(location == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
 586
 587         if (info->pkg_info == NULL || info->pkg_info->installlocation == NULL)
 588                 return PMINFO_R_ERROR;
 589
 590         val = (char *)info->pkg_info->installlocation;
 591         if (strcmp(val, "internal-only") == 0)
 592                 *location = PMINFO_INSTALL_LOCATION_INTERNAL_ONLY;
 593         else if (strcmp(val, "prefer-external") == 0)
 594                 *location = PMINFO_INSTALL_LOCATION_PREFER_EXTERNAL;
 595         else
 596                 *location = PMINFO_INSTALL_LOCATION_AUTO;
 597
 598         return PMINFO_R_OK;
 599 }
 600
 601 API int pkgmgrinfo_pkginfo_get_package_size(pkgmgrinfo_pkginfo_h handle, int *size)
 602 {
 603         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
 604         char *temp = NULL;
 605
 606         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
 607         retvm_if(size == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
 608
 609         if (info->pkg_info == NULL)
 610                 return PMINFO_R_ERROR;
 611
 612         if (info->pkg_info->package_size == NULL) {
 613                 temp = strdup("");
 614                 if (temp == NULL) {
 615                         _LOGE("out of memory");
 616                         return PMINFO_R_ERROR;
 617                 } else {
 618                         info->pkg_info->package_size = temp;
 619                 }
 620         }
 621
 622         *size = atoi((char *)info->pkg_info->package_size);
 623
 624         return PMINFO_R_OK;
 625 }
 626
 627 API int pkgmgrinfo_pkginfo_get_icon(pkgmgrinfo_pkginfo_h handle, char **icon)
 628 {
 629         icon_x *ptr;
 630         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
 631
 632         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL");
 633         retvm_if(icon == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL");
 634
 635         if (info->pkg_info == NULL || info->pkg_info->icon == NULL)
 636                 return PMINFO_R_ERROR;
 637
 638         ptr = (icon_x *)info->pkg_info->icon->data;
 639         if (ptr == NULL)
 640                 return PMINFO_R_ERROR;
 641
 642         /* TODO : should we return empty string if there was no icon? */
 643         if (ptr->text == NULL)
 644                 *icon = "";
 645         else
 646                 *icon = ptr->text;
 647
 648         return PMINFO_R_OK;
 649 }
 650
 651 API int pkgmgrinfo_pkginfo_get_label(pkgmgrinfo_pkginfo_h handle, char **label)
 652 {
 653         label_x *ptr;
 654         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
 655
 656         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL");
 657         retvm_if(label == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL");
 658
 659         if (info->pkg_info == NULL || info->pkg_info->label == NULL)
 660                 return PMINFO_R_ERROR;
 661
 662         ptr = (label_x *)info->pkg_info->label->data;
 663         if (ptr == NULL)
 664                 return PMINFO_R_ERROR;
 665
 666         /* TODO : should we return empty string if there was no label? */
 667         if (ptr->text == NULL)
 668                 *label = "";
 669         else
 670                 *label = ptr->text;
 671
 672         return PMINFO_R_OK;
 673 }
 674
 675 API int pkgmgrinfo_pkginfo_get_description(pkgmgrinfo_pkginfo_h handle, char **description)
 676 {
 677         description_x *ptr;
 678         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
 679
 680         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
 681         retvm_if(description == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
 682
 683         if (info->pkg_info == NULL || info->pkg_info->description == NULL)
 684                 return PMINFO_R_ERROR;
 685
 686         ptr = (description_x *)info->pkg_info->description->data;
 687         if (ptr == NULL)
 688                 return PMINFO_R_ERROR;
 689
 690         if (ptr->text == NULL)
 691                 *description = "";
 692         else
 693                 *description = (char *)ptr->text;
 694
 695         return PMINFO_R_OK;
 696 }
 697
 698 API int pkgmgrinfo_pkginfo_get_author_name(pkgmgrinfo_pkginfo_h handle, char **author_name)
 699 {
 700         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
 701         author_x *author;
 702
 703         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
 704         retvm_if(author_name == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
 705
 706         if (info->pkg_info == NULL || info->pkg_info->author == NULL)
 707                 return PMINFO_R_ERROR;
 708
 709         author = (author_x *)info->pkg_info->author->data;
 710         if (author == NULL)
 711                 return PMINFO_R_ERROR;
 712
 713         if (author->text == NULL)
 714                 *author_name = "";
 715         else
 716                 *author_name = (char *)author->text;
 717
 718         return PMINFO_R_OK;
 719 }
 720
 721 API int pkgmgrinfo_pkginfo_get_author_email(pkgmgrinfo_pkginfo_h handle, char **author_email)
 722 {
 723         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
 724         author_x *author;
 725
 726         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
 727         retvm_if(author_email == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
 728
 729         if (info->pkg_info == NULL || info->pkg_info->author == NULL)
 730                 return PMINFO_R_ERROR;
 731
 732         author = (author_x *)info->pkg_info->author->data;
 733         if (author == NULL)
 734                 return PMINFO_R_ERROR;
 735
 736         if (author->email == NULL)
 737                 *author_email = "";
 738         else
 739                 *author_email = (char *)author->email;
 740
 741         return PMINFO_R_OK;
 742 }
 743
 744 API int pkgmgrinfo_pkginfo_get_author_href(pkgmgrinfo_pkginfo_h handle, char **author_href)
 745 {
 746         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
 747         author_x *author;
 748
 749         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
 750         retvm_if(author_href == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
 751
 752         if (info->pkg_info == NULL || info->pkg_info->author == NULL)
 753                 return PMINFO_R_ERROR;
 754
 755         author = (author_x *)info->pkg_info->author->data;
 756         if (author == NULL)
 757                 return PMINFO_R_ERROR;
 758
 759         if (author->href == NULL)
 760                 *author_href = "";
 761         else
 762                 *author_href = (char *)author->href;
 763
 764         return PMINFO_R_OK;
 765 }
 766
 767 API int pkgmgrinfo_pkginfo_get_installed_storage(pkgmgrinfo_pkginfo_h handle, pkgmgrinfo_installed_storage *storage)
 768 {
 769         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
 770
 771         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
 772         retvm_if(storage == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
 773
 774         if (info->pkg_info == NULL || info->pkg_info->installed_storage == NULL)
 775                 return PMINFO_R_ERROR;
 776
 777         if (strcmp(info->pkg_info->installed_storage, "installed_internal") == 0)
 778                 *storage = PMINFO_INTERNAL_STORAGE;
 779         else if (strcmp(info->pkg_info->installed_storage, "installed_external") == 0)
 780                 *storage = PMINFO_EXTERNAL_STORAGE;
 781         else if (strcmp(info->pkg_info->installed_storage, "installed_extended") == 0)
 782                 *storage = PMINFO_EXTENDED_STORAGE;
 783         else
 784                 return PMINFO_R_ERROR;
 785
 786         return PMINFO_R_OK;
 787 }
 788
 789 API int pkgmgrinfo_pkginfo_get_installed_time(pkgmgrinfo_pkginfo_h handle, int *installed_time)
 790 {
 791         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
 792
 793         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
 794         retvm_if(installed_time == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
 795
 796         if (info->pkg_info == NULL || info->pkg_info->installed_time == NULL)
 797                 return PMINFO_R_ERROR;
 798
 799         *installed_time = atoi(info->pkg_info->installed_time);
 800
 801         return PMINFO_R_OK;
 802 }
 803
 804 API int pkgmgrinfo_pkginfo_get_storeclientid(pkgmgrinfo_pkginfo_h handle, char **storeclientid)
 805 {
 806         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
 807
 808         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
 809         retvm_if(storeclientid == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
 810
 811         if (info->pkg_info == NULL)
 812                 return PMINFO_R_ERROR;
 813
 814         if (info->pkg_info->storeclient_id == NULL)
 815                 *storeclientid = "";
 816         else
 817                 *storeclientid = (char *)info->pkg_info->storeclient_id;
 818
 819         return PMINFO_R_OK;
 820 }
 821
 822 API int pkgmgrinfo_pkginfo_get_mainappid(pkgmgrinfo_pkginfo_h handle, char **mainappid)
 823 {
 824         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
 825
 826         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
 827         retvm_if(mainappid == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
 828
 829         if (info->pkg_info == NULL || info->pkg_info->mainapp_id == NULL)
 830                 return PMINFO_R_ERROR;
 831
 832         *mainappid = (char *)info->pkg_info->mainapp_id;
 833
 834         return PMINFO_R_OK;
 835 }
 836
 837 API int pkgmgrinfo_pkginfo_get_url(pkgmgrinfo_pkginfo_h handle, char **url)
 838 {
 839         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
 840
 841         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
 842         retvm_if(url == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
 843
 844         if (info->pkg_info == NULL)
 845                 return PMINFO_R_ERROR;
 846
 847         if (info->pkg_info->package_url == NULL)
 848                 *url = "";
 849         else
 850                 *url = (char *)info->pkg_info->package_url;
 851
 852         return PMINFO_R_OK;
 853 }
 854
 855 API int pkgmgrinfo_pkginfo_get_root_path(pkgmgrinfo_pkginfo_h handle, char **path)
 856 {
 857         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
 858
 859         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
 860         retvm_if(path == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
 861
 862         if (info->pkg_info == NULL || info->pkg_info->root_path == NULL)
 863                 return PMINFO_R_ERROR;
 864
 865         *path = (char *)info->pkg_info->root_path;
 866
 867         return PMINFO_R_OK;
 868 }
 869
 870 API int pkgmgrinfo_pkginfo_get_csc_path(pkgmgrinfo_pkginfo_h handle, char **path)
 871 {
 872         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
 873
 874         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
 875         retvm_if(path == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
 876
 877         if (info->pkg_info == NULL)
 878                 return PMINFO_R_ERROR;
 879
 880         if (info->pkg_info->csc_path == NULL)
 881                 *path = "";
 882         else
 883                 *path = (char *)info->pkg_info->csc_path;
 884
 885         return PMINFO_R_OK;
 886 }
 887
 888 API int pkgmgrinfo_pkginfo_get_res_type(pkgmgrinfo_pkginfo_h handle,
 889                 char **res_type)
 890 {
 891         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
 892
 893         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
 894         retvm_if(res_type == NULL, PMINFO_R_EINVAL,
 895                         "Argument supplied to hold return value is NULL\n");
 896
 897         if (info->pkg_info == NULL)
 898                 return PMINFO_R_ERROR;
 899
 900         if (info->pkg_info->res_type == NULL)
 901                 return PMINFO_R_ENOENT;
 902
 903         *res_type = (char *)info->pkg_info->res_type;
 904
 905         return PMINFO_R_OK;
 906 }
 907
 908 API int pkgmgrinfo_pkginfo_get_res_version(pkgmgrinfo_pkginfo_h handle,
 909                 char **res_version)
 910 {
 911         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
 912
 913         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
 914         retvm_if(res_version == NULL, PMINFO_R_EINVAL,
 915                         "Argument supplied to hold return value is NULL\n");
 916
 917         if (info->pkg_info == NULL)
 918                 return PMINFO_R_ERROR;
 919
 920         if (info->pkg_info->res_version == NULL)
 921                 return PMINFO_R_ENOENT;
 922
 923         *res_version = (char *)info->pkg_info->res_version;
 924
 925         return PMINFO_R_OK;
 926 }
 927
 928 API int pkgmgrinfo_pkginfo_get_support_mode(pkgmgrinfo_pkginfo_h handle, int *support_mode)
 929 {
 930         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
 931         retvm_if(support_mode == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
 932
 933         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
 934         if (info->pkg_info->support_mode)
 935                 *support_mode = atoi(info->pkg_info->support_mode);
 936         else
 937                 *support_mode = 0;
 938
 939         return PMINFO_R_OK;
 940 }
 941
 942 API int pkgmgrinfo_pkginfo_is_accessible(pkgmgrinfo_pkginfo_h handle, bool *accessible)
 943 {
 944         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
 945         retvm_if(accessible == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
 946
 947 #if 0 /* smack issue occured, check later */
 948         char *pkgid = NULL;
 949         pkgmgrinfo_pkginfo_get_pkgid(handle, &pkgid);
 950         if (pkgid == NULL) {
 951                  _LOGD("invalid func parameters\n");
 952                  return PMINFO_R_ERROR;
 953         }
 954          _LOGD("pkgmgr_get_pkg_external_validation() called\n");
 955
 956         FILE *fp = NULL;
 957         char app_mmc_path[FILENAME_MAX] = { 0, };
 958         char app_dir_path[FILENAME_MAX] = { 0, };
 959         char app_mmc_internal_path[FILENAME_MAX] = { 0, };
 960         snprintf(app_dir_path, FILENAME_MAX, "%s%s", PKG_INSTALLATION_PATH, pkgid);
 961         snprintf(app_mmc_path, FILENAME_MAX, "%s%s", PKG_SD_PATH, pkgid);
 962         snprintf(app_mmc_internal_path, FILENAME_MAX, "%s%s/.mmc", PKG_INSTALLATION_PATH, pkgid);
 963
 964         /*check whether application is in external memory or not */
 965         fp = fopen(app_mmc_path, "r");
 966         if (fp == NULL) {
 967                 _LOGD(" app path in external memory not accesible\n");
 968         } else {
 969                 fclose(fp);
 970                 fp = NULL;
 971                 *accessible = 1;
 972                 _LOGD("pkgmgr_get_pkg_external_validation() : SD_CARD \n");
 973                 return PMINFO_R_OK;
 974         }
 975
 976         /*check whether application is in internal or not */
 977         if (fp == NULL) {
 978                 _LOGD(" app path in internal memory not accesible\n");
 979                 *accessible = 0;
 980                 return PMINFO_R_ERROR;
 981         } else {
 982                 fclose(fp);
 983                 /*check whether the application is installed in SD card
 984                 but SD card is not present*/
 985                 fp = fopen(app_mmc_internal_path, "r");
 986                 if (fp == NULL) {
 987                         *accessible = 1;
 988                         _LOGD("pkgmgr_get_pkg_external_validation() : INTERNAL_MEM \n");
 989                         return PMINFO_R_OK;
 990                 } else {
 991                         *accessible = 0;
 992                         _LOGD("pkgmgr_get_pkg_external_validation() : ERROR_MMC_STATUS \n");
 993                 }
 994                 fclose(fp);
 995         }
 996
 997         _LOGD("pkgmgr_get_pkg_external_validation() end\n");
 998 #endif
 999
1000         *accessible = 1;
1001         return PMINFO_R_OK;
1002 }
1003
1004 API int pkgmgrinfo_pkginfo_is_removable(pkgmgrinfo_pkginfo_h handle, bool *removable)
1005 {
1006         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1007
1008         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1009         retvm_if(removable == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1010
1011         if (info->pkg_info == NULL || info->pkg_info->removable == NULL)
1012                 return PMINFO_R_ERROR;
1013
1014         *removable = _get_bool_value(info->pkg_info->removable);
1015
1016         return PMINFO_R_OK;
1017 }
1018
1019 API int pkgmgrinfo_pkginfo_is_movable(pkgmgrinfo_pkginfo_h handle, bool *movable)
1020 {
1021         char *val;
1022         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1023
1024         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1025         retvm_if(movable == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1026
1027         if (info->pkg_info == NULL || info->pkg_info->installlocation == NULL)
1028                 return PMINFO_R_ERROR;
1029
1030         val = (char *)info->pkg_info->installlocation;
1031         if (strcmp(val, "internal-only") == 0)
1032                 *movable = 0;
1033         else
1034                 *movable = 1;
1035
1036         return PMINFO_R_OK;
1037 }
1038
1039 API int pkgmgrinfo_pkginfo_is_preload(pkgmgrinfo_pkginfo_h handle, bool *preload)
1040 {
1041         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1042
1043         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1044         retvm_if(preload == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1045
1046         if (info->pkg_info == NULL || info->pkg_info->preload == NULL)
1047                 return PMINFO_R_ERROR;
1048
1049         *preload = _get_bool_value(info->pkg_info->preload);
1050
1051         return PMINFO_R_OK;
1052 }
1053
1054 API int pkgmgrinfo_pkginfo_is_system(pkgmgrinfo_pkginfo_h handle, bool *system)
1055 {
1056         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1057
1058         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1059         retvm_if(system == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1060
1061         if (info->pkg_info == NULL || info->pkg_info->system == NULL)
1062                 return PMINFO_R_ERROR;
1063
1064         *system = _get_bool_value(info->pkg_info->system);
1065
1066         return PMINFO_R_OK;
1067 }
1068
1069 API int pkgmgrinfo_pkginfo_is_readonly(pkgmgrinfo_pkginfo_h handle, bool *readonly)
1070 {
1071         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1072
1073         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1074         retvm_if(readonly == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1075
1076         if (info->pkg_info == NULL || info->pkg_info->readonly == NULL)
1077                 return PMINFO_R_ERROR;
1078
1079         *readonly = _get_bool_value(info->pkg_info->readonly);
1080
1081         return PMINFO_R_OK;
1082 }
1083
1084 API int pkgmgrinfo_pkginfo_is_update(pkgmgrinfo_pkginfo_h handle, bool *update)
1085 {
1086         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1087
1088         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1089         retvm_if(update == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1090
1091         if (info->pkg_info == NULL || info->pkg_info->update == NULL)
1092                 return PMINFO_R_ERROR;
1093
1094         *update = _get_bool_value(info->pkg_info->update);
1095
1096         return PMINFO_R_OK;
1097 }
1098
1099 API int pkgmgrinfo_pkginfo_is_support_disable(pkgmgrinfo_pkginfo_h handle, bool *support_disable)
1100 {
1101         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1102
1103         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1104         retvm_if(support_disable == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1105
1106         if (info->pkg_info == NULL || info->pkg_info->support_disable == NULL)
1107                 return PMINFO_R_ERROR;
1108
1109         *support_disable = _get_bool_value(info->pkg_info->support_disable);
1110
1111         return PMINFO_R_OK;
1112 }
1113
1114 API int pkgmgrinfo_pkginfo_is_global(pkgmgrinfo_pkginfo_h handle, bool *global)
1115 {
1116         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1117
1118         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1119         retvm_if(global == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1120
1121         if (info->pkg_info == NULL || info->pkg_info->for_all_users == NULL)
1122                 return PMINFO_R_ERROR;
1123
1124         *global = _get_bool_value(info->pkg_info->for_all_users);
1125
1126         return PMINFO_R_OK;
1127 }
1128
1129 API int pkgmgrinfo_pkginfo_is_for_all_users(pkgmgrinfo_pkginfo_h handle, bool *for_all_users)
1130 {
1131         return pkgmgrinfo_pkginfo_is_global(handle, for_all_users);
1132 }
1133
1134 API int pkgmgrinfo_pkginfo_destroy_pkginfo(pkgmgrinfo_pkginfo_h handle)
1135 {
1136         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1137
1138         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1139
1140         __cleanup_pkginfo(info);
1141
1142         return PMINFO_R_OK;
1143 }
1144
1145 API int pkgmgrinfo_pkginfo_filter_create(pkgmgrinfo_pkginfo_filter_h *handle)
1146 {
1147         pkgmgrinfo_filter_x *filter;
1148
1149         retvm_if(handle == NULL, PMINFO_R_EINVAL, "Filter handle output parameter is NULL\n");
1150
1151         filter = (pkgmgrinfo_filter_x *)calloc(1, sizeof(pkgmgrinfo_filter_x));
1152         if (filter == NULL) {
1153                 _LOGE("Out of Memory!!!");
1154                 return PMINFO_R_ERROR;
1155         }
1156
1157         *handle = filter;
1158
1159         return PMINFO_R_OK;
1160 }
1161
1162 API int pkgmgrinfo_pkginfo_filter_destroy(pkgmgrinfo_pkginfo_filter_h handle)
1163 {
1164         pkgmgrinfo_filter_x *filter = (pkgmgrinfo_filter_x *)handle;
1165
1166         retvm_if(handle == NULL, PMINFO_R_EINVAL, "Filter handle input parameter is NULL\n");
1167
1168         if (filter->list)
1169                 g_slist_free_full(filter->list,
1170                                 (GDestroyNotify)_pkgmgrinfo_node_destroy);
1171
1172         if (filter->list_metadata)
1173                 g_slist_free_full(filter->list_metadata,
1174                                 __destroy_metadata_node);
1175
1176         free(filter);
1177
1178         return PMINFO_R_OK;
1179 }
1180
1181 API int pkgmgrinfo_pkginfo_filter_add_int(pkgmgrinfo_pkginfo_filter_h handle,
1182                                 const char *property, const int value)
1183 {
1184         char buf[PKG_VALUE_STRING_LEN_MAX] = {'\0'};
1185         char *val;
1186         GSList *link;
1187         int prop;
1188         pkgmgrinfo_filter_x *filter = (pkgmgrinfo_filter_x *)handle;
1189         pkgmgrinfo_node_x *node;
1190
1191         retvm_if(handle == NULL, PMINFO_R_EINVAL, "Filter handle input parameter is NULL\n");
1192         retvm_if(property == NULL, PMINFO_R_EINVAL, "Filter handle input parameter is NULL\n");
1193
1194         prop = _pminfo_pkginfo_convert_to_prop_int(property);
1195         if (prop < E_PMINFO_PKGINFO_PROP_PACKAGE_MIN_INT ||
1196                 prop > E_PMINFO_PKGINFO_PROP_PACKAGE_MAX_INT) {
1197                 _LOGE("Invalid Integer Property\n");
1198                 return PMINFO_R_EINVAL;
1199         }
1200         node = (pkgmgrinfo_node_x *)calloc(1, sizeof(pkgmgrinfo_node_x));
1201         if (node == NULL) {
1202                 _LOGE("Out of Memory!!!\n");
1203                 return PMINFO_R_ERROR;
1204         }
1205         snprintf(buf, PKG_VALUE_STRING_LEN_MAX - 1, "%d", value);
1206         val = strndup(buf, PKG_VALUE_STRING_LEN_MAX - 1);
1207         if (val == NULL) {
1208                 _LOGE("Out of Memory\n");
1209                 free(node);
1210                 return PMINFO_R_ERROR;
1211         }
1212         node->prop = prop;
1213         node->value = val;
1214         /*If API is called multiple times for same property, we should override the previous values.
1215         Last value set will be used for filtering.*/
1216         link = g_slist_find_custom(filter->list, (gconstpointer)node, __compare_func);
1217         if (link) {
1218                 _pkgmgrinfo_node_destroy(link->data);
1219                 filter->list = g_slist_delete_link(filter->list, link);
1220         }
1221         filter->list = g_slist_append(filter->list, (gpointer)node);
1222         return PMINFO_R_OK;
1223
1224 }
1225
1226 API int pkgmgrinfo_pkginfo_filter_add_bool(pkgmgrinfo_pkginfo_filter_h handle,
1227                                 const char *property, const bool value)
1228 {
1229         char *val;
1230         GSList *link;
1231         int prop;
1232         pkgmgrinfo_filter_x *filter = (pkgmgrinfo_filter_x *)handle;
1233         pkgmgrinfo_node_x *node;
1234
1235         retvm_if(handle == NULL, PMINFO_R_EINVAL, "Filter handle input parameter is NULL\n");
1236         retvm_if(property == NULL, PMINFO_R_EINVAL, "Filter handle input parameter is NULL\n");
1237
1238         prop = _pminfo_pkginfo_convert_to_prop_bool(property);
1239         if (prop < E_PMINFO_PKGINFO_PROP_PACKAGE_MIN_BOOL ||
1240                 prop > E_PMINFO_PKGINFO_PROP_PACKAGE_MAX_BOOL) {
1241                 _LOGE("Invalid Boolean Property\n");
1242                 return PMINFO_R_EINVAL;
1243         }
1244         node = (pkgmgrinfo_node_x *)calloc(1, sizeof(pkgmgrinfo_node_x));
1245         if (node == NULL) {
1246                 _LOGE("Out of Memory!!!\n");
1247                 return PMINFO_R_ERROR;
1248         }
1249         if (value)
1250                 val = strndup("true", 4);
1251         else
1252                 val = strndup("false", 5);
1253         if (val == NULL) {
1254                 _LOGE("Out of Memory\n");
1255                 free(node);
1256                 return PMINFO_R_ERROR;
1257         }
1258         node->prop = prop;
1259         node->value = val;
1260         /*If API is called multiple times for same property, we should override the previous values.
1261         Last value set will be used for filtering.*/
1262         link = g_slist_find_custom(filter->list, (gconstpointer)node, __compare_func);
1263         if (link) {
1264                 _pkgmgrinfo_node_destroy(link->data);
1265                 filter->list = g_slist_delete_link(filter->list, link);
1266         }
1267         filter->list = g_slist_append(filter->list, (gpointer)node);
1268         return PMINFO_R_OK;
1269
1270 }
1271
1272 API int pkgmgrinfo_pkginfo_filter_add_string(pkgmgrinfo_pkginfo_filter_h handle,
1273                                 const char *property, const char *value)
1274 {
1275         char *val;
1276         GSList *link;
1277         int prop;
1278         pkgmgrinfo_filter_x *filter = (pkgmgrinfo_filter_x *)handle;
1279         pkgmgrinfo_node_x *node;
1280
1281         retvm_if(handle == NULL, PMINFO_R_EINVAL, "Filter handle input parameter is NULL\n");
1282         retvm_if(property == NULL, PMINFO_R_EINVAL, "Filter handle input parameter is NULL\n");
1283         retvm_if(value == NULL, PMINFO_R_EINVAL, "Filter handle input parameter is NULL\n");
1284
1285         prop = _pminfo_pkginfo_convert_to_prop_str(property);
1286         if (prop < E_PMINFO_PKGINFO_PROP_PACKAGE_MIN_STR ||
1287                 prop > E_PMINFO_PKGINFO_PROP_PACKAGE_MAX_STR) {
1288                 _LOGE("Invalid String Property\n");
1289                 return PMINFO_R_EINVAL;
1290         }
1291         node = (pkgmgrinfo_node_x *)calloc(1, sizeof(pkgmgrinfo_node_x));
1292         if (node == NULL) {
1293                 _LOGE("Out of Memory!!!\n");
1294                 return PMINFO_R_ERROR;
1295         }
1296         if (strcmp(value, PMINFO_PKGINFO_INSTALL_LOCATION_AUTO) == 0)
1297                 val = strndup("auto", PKG_STRING_LEN_MAX - 1);
1298         else if (strcmp(value, PMINFO_PKGINFO_INSTALL_LOCATION_INTERNAL) == 0)
1299                 val = strndup("internal-only", PKG_STRING_LEN_MAX - 1);
1300         else if (strcmp(value, PMINFO_PKGINFO_INSTALL_LOCATION_EXTERNAL) == 0)
1301                 val = strndup("prefer-external", PKG_STRING_LEN_MAX - 1);
1302         else if (strcmp(value, "installed_internal") == 0)
1303                 val = strndup("installed_internal", PKG_STRING_LEN_MAX - 1);
1304         else if (strcmp(value, "installed_external") == 0)
1305                 val = strndup("installed_external", PKG_STRING_LEN_MAX - 1);
1306         else
1307                 val = strndup(value, PKG_STRING_LEN_MAX - 1);
1308         if (val == NULL) {
1309                 _LOGE("Out of Memory\n");
1310                 free(node);
1311                 return PMINFO_R_ERROR;
1312         }
1313         node->prop = prop;
1314         node->value = val;
1315         /*If API is called multiple times for same property, we should override the previous values.
1316         Last value set will be used for filtering.*/
1317         link = g_slist_find_custom(filter->list, (gconstpointer)node, __compare_func);
1318         if (link) {
1319                 _pkgmgrinfo_node_destroy(link->data);
1320                 filter->list = g_slist_delete_link(filter->list, link);
1321         }
1322         filter->list = g_slist_append(filter->list, (gpointer)node);
1323         return PMINFO_R_OK;
1324
1325 }
1326
1327 API int pkgmgrinfo_pkginfo_usr_filter_count(pkgmgrinfo_pkginfo_filter_h handle, int *count, uid_t uid)
1328 {
1329         int ret;
1330         int query_count;
1331         GHashTable *list = NULL;
1332
1333         if (handle == NULL || count == NULL) {
1334                 _LOGE("invalid parameter");
1335                 return PMINFO_R_EINVAL;
1336         }
1337
1338         list = g_hash_table_new_full(g_str_hash, g_str_equal, NULL,
1339                         __free_packages);
1340         if (list == NULL)
1341                 return PMINFO_R_ERROR;
1342
1343         if (__check_disable_filter_exist((pkgmgrinfo_filter_x *)handle) == false) {
1344                 ret = pkgmgrinfo_pkginfo_filter_add_bool(handle,
1345                                 PMINFO_PKGINFO_PROP_PACKAGE_DISABLE, false);
1346                 if (ret != PMINFO_R_OK) {
1347                         g_hash_table_destroy(list);
1348                         return PMINFO_R_ERROR;
1349                 }
1350         }
1351
1352         ret = _pkginfo_get_packages(uid, handle, PMINFO_PKGINFO_GET_BASICINFO, list);
1353         query_count = g_hash_table_size(list);
1354         g_hash_table_destroy(list);
1355         if (ret == PMINFO_R_ERROR)
1356                 return ret;
1357         *count = query_count;
1358         return PMINFO_R_OK;
1359 }
1360
1361 API int pkgmgrinfo_pkginfo_filter_count(pkgmgrinfo_pkginfo_filter_h handle, int *count)
1362 {
1363         return pkgmgrinfo_pkginfo_usr_filter_count(handle, count, _getuid());
1364 }
1365
1366 API int pkgmgrinfo_pkginfo_usr_filter_foreach_pkginfo(
1367                 pkgmgrinfo_pkginfo_filter_h handle,
1368                 pkgmgrinfo_pkg_list_cb pkg_cb, void *user_data, uid_t uid)
1369 {
1370         if (handle == NULL || pkg_cb == NULL) {
1371                 LOGE("invalid parameter");
1372                 return PMINFO_R_EINVAL;
1373         }
1374
1375         return _pkginfo_get_filtered_foreach_pkginfo(uid, handle,
1376                         PMINFO_PKGINFO_GET_ALL, pkg_cb, user_data);
1377 }
1378
1379 API int pkgmgrinfo_pkginfo_filter_foreach_pkginfo(pkgmgrinfo_pkginfo_filter_h handle,
1380                                 pkgmgrinfo_pkg_list_cb pkg_cb, void *user_data)
1381 {
1382         return pkgmgrinfo_pkginfo_usr_filter_foreach_pkginfo(handle, pkg_cb, user_data, _getuid());
1383 }
1384
1385 API int pkgmgrinfo_pkginfo_foreach_privilege(pkgmgrinfo_pkginfo_h handle,
1386                         pkgmgrinfo_pkg_privilege_list_cb privilege_func, void *user_data)
1387 {
1388         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL");
1389         retvm_if(privilege_func == NULL, PMINFO_R_EINVAL, "Callback function is NULL");
1390         int ret;
1391         privilege_x *privilege;
1392         appdefined_privilege_x *appdefined_privilege;
1393         GList *tmp;
1394         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1395
1396         if (info->pkg_info == NULL)
1397                 return PMINFO_R_ERROR;
1398
1399         for (tmp = info->pkg_info->privileges; tmp; tmp = tmp->next) {
1400                 privilege = (privilege_x *)tmp->data;
1401                 if (privilege == NULL)
1402                         continue;
1403                 ret = privilege_func(privilege->value, user_data);
1404                 if (ret < 0)
1405                         return PMINFO_R_OK;
1406         }
1407
1408         for (tmp = info->pkg_info->appdefined_privileges; tmp;
1409                         tmp = tmp->next) {
1410                 appdefined_privilege = (appdefined_privilege_x *)tmp->data;
1411                 if (appdefined_privilege == NULL)
1412                         continue;
1413                 ret = privilege_func(appdefined_privilege->value, user_data);
1414                 if (ret < 0)
1415                         return PMINFO_R_OK;
1416         }
1417         return PMINFO_R_OK;
1418 }
1419
1420 API int pkgmgrinfo_pkginfo_foreach_plugin(pkgmgrinfo_pkginfo_h handle,
1421                         pkgmgrinfo_plugin_list_cb plugin_func, void *user_data)
1422 {
1423         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL");
1424         retvm_if(plugin_func == NULL, PMINFO_R_EINVAL,
1425                         "Callback function is NULL");
1426         int ret;
1427         plugin_x *plugin;
1428         GList *tmp;
1429         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1430
1431         if (info->pkg_info == NULL)
1432                 return PMINFO_R_ERROR;
1433
1434         for (tmp = info->pkg_info->plugin; tmp; tmp = tmp->next) {
1435                 plugin = (plugin_x *)tmp->data;
1436                 if (plugin == NULL)
1437                         continue;
1438                 ret = plugin_func(plugin->pkgid, plugin->appid,
1439                                 plugin->plugin_type, plugin->plugin_name, user_data);
1440                 if (ret < 0)
1441                         return PMINFO_R_OK;
1442         }
1443
1444         return PMINFO_R_OK;
1445 }
1446
1447 API int pkgmgrinfo_pkginfo_foreach_appdefined_privilege(
1448                 pkgmgrinfo_pkginfo_h handle,
1449                 pkgmgrinfo_pkg_appdefined_privilege_list_cb privilege_func,
1450                 void *user_data)
1451 {
1452         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL");
1453         retvm_if(privilege_func == NULL, PMINFO_R_EINVAL,
1454                         "Callback function is NULL");
1455         int ret;
1456         appdefined_privilege_x *privilege;
1457         GList *tmp;
1458         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1459
1460         if (info->pkg_info == NULL)
1461                 return PMINFO_R_ERROR;
1462
1463         for (tmp = info->pkg_info->appdefined_privileges; tmp;
1464                         tmp = tmp->next) {
1465                 privilege = (appdefined_privilege_x *)tmp->data;
1466                 if (privilege == NULL)
1467                         continue;
1468                 ret = privilege_func(privilege->value, privilege->license,
1469                                 user_data);
1470                 if (ret < 0)
1471                         break;
1472         }
1473         return PMINFO_R_OK;
1474 }
1475
1476 API int pkgmgrinfo_pkginfo_foreach_dependency(pkgmgrinfo_pkginfo_h handle,
1477                 pkgmgrinfo_pkg_dependency_list_cb dependency_cb,
1478                 void *user_data)
1479 {
1480         int ret;
1481         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1482         GList *tmp;
1483         dependency_x *dependency;
1484
1485         if (handle == NULL || dependency_cb == NULL) {
1486                 LOGE("invalid parameter");
1487                 return PMINFO_R_EINVAL;
1488         }
1489
1490         if (info->pkg_info == NULL)
1491                 return PMINFO_R_ERROR;
1492
1493         for (tmp = info->pkg_info->dependencies; tmp; tmp = tmp->next) {
1494                 dependency = (dependency_x *)tmp->data;
1495                 if (dependency == NULL)
1496                         continue;
1497                 ret = dependency_cb(info->pkg_info->package,
1498                                 dependency->depends_on, dependency->type,
1499                                 dependency->required_version, user_data);
1500                 if (ret < 0)
1501                         break;
1502         }
1503
1504         return PMINFO_R_OK;
1505 }
1506
1507 static void __free_depends_on(gpointer data)
1508 {
1509         dependency_x *dep = (dependency_x *)data;
1510         pkgmgrinfo_basic_free_dependency(dep);
1511 }
1512
1513 API int pkgmgrinfo_pkginfo_foreach_depends_on(pkgmgrinfo_pkginfo_h handle,
1514                 pkgmgrinfo_pkg_dependency_list_cb dependency_cb,
1515                 void *user_data)
1516 {
1517         int ret;
1518         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1519         GList *pkg_list = NULL;
1520         GList *l;
1521         dependency_x *dep;
1522
1523         if (handle == NULL || dependency_cb == NULL || info->pkg_info == NULL) {
1524                 LOGE("invalid parameter");
1525                 return PMINFO_R_EINVAL;
1526         }
1527
1528         ret = _pkginfo_get_depends_on(info->uid, info->pkg_info->package, &pkg_list);
1529         if (ret != PMINFO_R_OK)
1530                 return PMINFO_R_ERROR;
1531
1532         for (l = pkg_list; l != NULL; l = g_list_next(l)) {
1533                 dep = (dependency_x *)l->data;
1534                 ret = dependency_cb(dep->pkgid, dep->depends_on,
1535                                 dep->type, dep->required_version, user_data);
1536                 if (ret < 0)
1537                         break;
1538         }
1539         g_list_free_full(pkg_list, __free_depends_on);
1540
1541         return PMINFO_R_OK;
1542 }
1543
1544 API int pkgmgrinfo_pkginfo_foreach_res_allowed_package(
1545                 pkgmgrinfo_pkginfo_h handle,
1546                 pkgmgrinfo_res_allowed_package_list_cb res_allowed_package_cb,
1547                 void *user_data)
1548 {
1549         int ret;
1550         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1551         GList *res_pkgs;
1552         res_allowed_package_x *res_allowed_package;
1553
1554         if (handle == NULL || res_allowed_package_cb == NULL) {
1555                 LOGE("invalid parameter");
1556                 return PMINFO_R_EINVAL;
1557         }
1558
1559         if (info->pkg_info == NULL)
1560                 return PMINFO_R_ERROR;
1561
1562         for (res_pkgs = info->pkg_info->res_allowed_packages; res_pkgs;
1563                         res_pkgs = res_pkgs->next) {
1564                 res_allowed_package = (res_allowed_package_x *)res_pkgs->data;
1565                 if (res_allowed_package == NULL)
1566                         continue;
1567
1568                 ret = res_allowed_package_cb(
1569                                 res_allowed_package->allowed_package,
1570                                 res_allowed_package->required_privileges,
1571                                 user_data);
1572                 if (ret < 0)
1573                         return PMINFO_R_OK;
1574         }
1575
1576         return PMINFO_R_OK;
1577 }
1578
1579 API int pkgmgrinfo_pkginfo_foreach_required_privilege(
1580                 required_privilege_h handle,
1581                 pkgmgrinfo_pkg_privilege_list_cb privilege_func,
1582                 void *user_data)
1583 {
1584         int ret;
1585         GList *privs;
1586
1587         if (privilege_func == NULL) {
1588                 LOGE("invalid parameter");
1589                 return PMINFO_R_EINVAL;
1590         }
1591
1592         for (privs = (GList *)handle; privs; privs = privs->next) {
1593                 ret = privilege_func((char *)privs->data, user_data);
1594                 if (ret < 0)
1595                         return PMINFO_R_OK;
1596         }
1597
1598         return PMINFO_R_OK;
1599 }
1600
1601 int __compare_package_version(const char *version, int *major,
1602                 int *minor, int *macro, int *nano)
1603 {
1604         char *version_temp = NULL;
1605         char *major_str = NULL;
1606         char *minor_str = NULL;
1607         char *macro_str = NULL;
1608         char *nano_str = NULL;
1609         char *save_str = NULL;
1610
1611         if (version == NULL || major == NULL || minor == NULL ||
1612                 macro == NULL || nano == NULL) {
1613                 return PMINFO_R_EINVAL;
1614         }
1615
1616         version_temp = strdup(version);
1617         if (version_temp == NULL) {
1618                 LOGE("Out of memory");
1619                 return PMINFO_R_ERROR;
1620         }
1621
1622         major_str = strtok_r(version_temp, ".", &save_str);
1623         if (major_str == NULL) {
1624                 _LOGE("major version is NULL");
1625                 free(version_temp);
1626                 return PMINFO_R_ERROR;
1627         }
1628
1629         minor_str = strtok_r(NULL, ".", &save_str);
1630         if (minor_str == NULL) {
1631                 _LOGE("minor version is NULL");
1632                 free(version_temp);
1633                 return PMINFO_R_ERROR;
1634         }
1635
1636         *major = atoi(major_str);
1637         *minor = atoi(minor_str);
1638         *macro = 0;
1639         *nano = 0;
1640         macro_str = strtok_r(NULL, ".", &save_str);
1641         if (macro_str == NULL) {
1642                 _LOGD("macro version is NULL");
1643         } else {
1644                 *macro = atoi(macro_str);
1645                 nano_str = strtok_r(NULL, ".", &save_str);
1646                 if (nano_str) {
1647                         *nano = atoi(nano_str);
1648                         _LOGD("nano version exists");
1649                 }
1650         }
1651         _LOGD("version = [%s] -> major = [%d], minor = [%d]," \
1652                 " macro = [%d], nano = [%d]", version, *major,
1653                 *minor, *macro, *nano);
1654
1655         free(version_temp);
1656
1657         return PMINFO_R_OK;
1658 }
1659
1660 API int pkgmgrinfo_compare_package_version(const char *current_version,
1661                 const char *target_version,
1662                 pkgmgrinfo_version_compare_type *res)
1663 {
1664         int ret = 0;
1665         int current_version_major = 0;
1666         int current_version_minor = 0;
1667         int current_version_macro = 0;
1668         int current_version_nano = 0;
1669         int target_version_major = 0;
1670         int target_version_minor = 0;
1671         int target_version_macro = 0;
1672         int target_version_nano = 0;
1673
1674         if (current_version == NULL || target_version == NULL ||
1675                 res == NULL) {
1676                 _LOGE("Invalid parameter");
1677                 return PMINFO_R_EINVAL;
1678         }
1679
1680         ret = __compare_package_version(target_version,
1681                 &target_version_major, &target_version_minor,
1682                 &target_version_macro, &target_version_nano);
1683         if (ret < 0) {
1684                 _LOGE("Failed to compare target version(%d)", ret);
1685                 return PMINFO_R_ERROR;
1686         }
1687
1688         ret = __compare_package_version(current_version,
1689                 &current_version_major, &current_version_minor,
1690                 &current_version_macro, &current_version_nano);
1691         if (ret < 0) {
1692                 _LOGE("Failed to compare current version(%d)", ret);
1693                 return PMINFO_R_ERROR;
1694         }
1695
1696         _LOGD("new[%d.%d.%d.%d] old[%d.%d.%d.%d]", target_version_major,
1697                 target_version_minor, target_version_macro,
1698                 target_version_nano, current_version_major,
1699                 current_version_minor, current_version_macro,
1700                 target_version_nano);
1701
1702         if (target_version_major > current_version_major)
1703                 *res = PMINFO_VERSION_NEW;
1704         else if (target_version_major < current_version_major)
1705                 *res = PMINFO_VERSION_OLD;
1706         else if (target_version_minor > current_version_minor)
1707                 *res = PMINFO_VERSION_NEW;
1708         else if (target_version_minor < current_version_minor)
1709                 *res = PMINFO_VERSION_OLD;
1710         else if (target_version_macro > current_version_macro)
1711                 *res = PMINFO_VERSION_NEW;
1712         else if (target_version_macro < current_version_macro)
1713                 *res = PMINFO_VERSION_OLD;
1714         else if (target_version_nano > current_version_nano)
1715                 *res = PMINFO_VERSION_NEW;
1716         else if (target_version_nano < current_version_nano)
1717                 *res = PMINFO_VERSION_OLD;
1718         else
1719                 *res = PMINFO_VERSION_SAME;
1720
1721         return PMINFO_R_OK;
1722 }