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_light_user_switch_mode(pkgmgrinfo_pkginfo_h handle, char **mode)
 929 {
 930         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
 931
 932         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
 933         retvm_if(mode == NULL, PMINFO_R_EINVAL,
 934                         "Argument supplied to hold return value is NULL\n");
 935
 936         if (info->pkg_info == NULL)
 937                 return PMINFO_R_ERROR;
 938
 939         if (info->pkg_info->light_user_switch_mode == NULL)
 940                 return PMINFO_R_ERROR;
 941
 942         *mode = (char *)info->pkg_info->light_user_switch_mode;
 943
 944         return PMINFO_R_OK;
 945 }
 946
 947 API int pkgmgrinfo_pkginfo_get_support_mode(pkgmgrinfo_pkginfo_h handle, int *support_mode)
 948 {
 949         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
 950         retvm_if(support_mode == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
 951
 952         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
 953         if (info->pkg_info->support_mode)
 954                 *support_mode = atoi(info->pkg_info->support_mode);
 955         else
 956                 *support_mode = 0;
 957
 958         return PMINFO_R_OK;
 959 }
 960
 961 API int pkgmgrinfo_pkginfo_is_accessible(pkgmgrinfo_pkginfo_h handle, bool *accessible)
 962 {
 963         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
 964         retvm_if(accessible == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
 965
 966 #if 0 /* smack issue occured, check later */
 967         char *pkgid = NULL;
 968         pkgmgrinfo_pkginfo_get_pkgid(handle, &pkgid);
 969         if (pkgid == NULL) {
 970                  _LOGD("invalid func parameters\n");
 971                  return PMINFO_R_ERROR;
 972         }
 973          _LOGD("pkgmgr_get_pkg_external_validation() called\n");
 974
 975         FILE *fp = NULL;
 976         char app_mmc_path[FILENAME_MAX] = { 0, };
 977         char app_dir_path[FILENAME_MAX] = { 0, };
 978         char app_mmc_internal_path[FILENAME_MAX] = { 0, };
 979         snprintf(app_dir_path, FILENAME_MAX, "%s%s", PKG_INSTALLATION_PATH, pkgid);
 980         snprintf(app_mmc_path, FILENAME_MAX, "%s%s", PKG_SD_PATH, pkgid);
 981         snprintf(app_mmc_internal_path, FILENAME_MAX, "%s%s/.mmc", PKG_INSTALLATION_PATH, pkgid);
 982
 983         /*check whether application is in external memory or not */
 984         fp = fopen(app_mmc_path, "r");
 985         if (fp == NULL) {
 986                 _LOGD(" app path in external memory not accesible\n");
 987         } else {
 988                 fclose(fp);
 989                 fp = NULL;
 990                 *accessible = 1;
 991                 _LOGD("pkgmgr_get_pkg_external_validation() : SD_CARD \n");
 992                 return PMINFO_R_OK;
 993         }
 994
 995         /*check whether application is in internal or not */
 996         if (fp == NULL) {
 997                 _LOGD(" app path in internal memory not accesible\n");
 998                 *accessible = 0;
 999                 return PMINFO_R_ERROR;
1000         } else {
1001                 fclose(fp);
1002                 /*check whether the application is installed in SD card
1003                 but SD card is not present*/
1004                 fp = fopen(app_mmc_internal_path, "r");
1005                 if (fp == NULL) {
1006                         *accessible = 1;
1007                         _LOGD("pkgmgr_get_pkg_external_validation() : INTERNAL_MEM \n");
1008                         return PMINFO_R_OK;
1009                 } else {
1010                         *accessible = 0;
1011                         _LOGD("pkgmgr_get_pkg_external_validation() : ERROR_MMC_STATUS \n");
1012                 }
1013                 fclose(fp);
1014         }
1015
1016         _LOGD("pkgmgr_get_pkg_external_validation() end\n");
1017 #endif
1018
1019         *accessible = 1;
1020         return PMINFO_R_OK;
1021 }
1022
1023 API int pkgmgrinfo_pkginfo_is_removable(pkgmgrinfo_pkginfo_h handle, bool *removable)
1024 {
1025         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1026
1027         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1028         retvm_if(removable == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1029
1030         if (info->pkg_info == NULL || info->pkg_info->removable == NULL)
1031                 return PMINFO_R_ERROR;
1032
1033         *removable = _get_bool_value(info->pkg_info->removable);
1034
1035         return PMINFO_R_OK;
1036 }
1037
1038 API int pkgmgrinfo_pkginfo_is_movable(pkgmgrinfo_pkginfo_h handle, bool *movable)
1039 {
1040         char *val;
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(movable == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1045
1046         if (info->pkg_info == NULL || info->pkg_info->installlocation == NULL)
1047                 return PMINFO_R_ERROR;
1048
1049         val = (char *)info->pkg_info->installlocation;
1050         if (strcmp(val, "internal-only") == 0)
1051                 *movable = 0;
1052         else
1053                 *movable = 1;
1054
1055         return PMINFO_R_OK;
1056 }
1057
1058 API int pkgmgrinfo_pkginfo_is_preload(pkgmgrinfo_pkginfo_h handle, bool *preload)
1059 {
1060         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1061
1062         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1063         retvm_if(preload == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1064
1065         if (info->pkg_info == NULL || info->pkg_info->preload == NULL)
1066                 return PMINFO_R_ERROR;
1067
1068         *preload = _get_bool_value(info->pkg_info->preload);
1069
1070         return PMINFO_R_OK;
1071 }
1072
1073 API int pkgmgrinfo_pkginfo_is_system(pkgmgrinfo_pkginfo_h handle, bool *system)
1074 {
1075         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1076
1077         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1078         retvm_if(system == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1079
1080         if (info->pkg_info == NULL || info->pkg_info->system == NULL)
1081                 return PMINFO_R_ERROR;
1082
1083         *system = _get_bool_value(info->pkg_info->system);
1084
1085         return PMINFO_R_OK;
1086 }
1087
1088 API int pkgmgrinfo_pkginfo_is_readonly(pkgmgrinfo_pkginfo_h handle, bool *readonly)
1089 {
1090         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1091
1092         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1093         retvm_if(readonly == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1094
1095         if (info->pkg_info == NULL || info->pkg_info->readonly == NULL)
1096                 return PMINFO_R_ERROR;
1097
1098         *readonly = _get_bool_value(info->pkg_info->readonly);
1099
1100         return PMINFO_R_OK;
1101 }
1102
1103 API int pkgmgrinfo_pkginfo_is_update(pkgmgrinfo_pkginfo_h handle, bool *update)
1104 {
1105         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1106
1107         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1108         retvm_if(update == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1109
1110         if (info->pkg_info == NULL || info->pkg_info->update == NULL)
1111                 return PMINFO_R_ERROR;
1112
1113         *update = _get_bool_value(info->pkg_info->update);
1114
1115         return PMINFO_R_OK;
1116 }
1117
1118 API int pkgmgrinfo_pkginfo_is_support_disable(pkgmgrinfo_pkginfo_h handle, bool *support_disable)
1119 {
1120         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1121
1122         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1123         retvm_if(support_disable == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1124
1125         if (info->pkg_info == NULL || info->pkg_info->support_disable == NULL)
1126                 return PMINFO_R_ERROR;
1127
1128         *support_disable = _get_bool_value(info->pkg_info->support_disable);
1129
1130         return PMINFO_R_OK;
1131 }
1132
1133 API int pkgmgrinfo_pkginfo_is_global(pkgmgrinfo_pkginfo_h handle, bool *global)
1134 {
1135         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1136
1137         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1138         retvm_if(global == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1139
1140         if (info->pkg_info == NULL || info->pkg_info->for_all_users == NULL)
1141                 return PMINFO_R_ERROR;
1142
1143         *global = _get_bool_value(info->pkg_info->for_all_users);
1144
1145         return PMINFO_R_OK;
1146 }
1147
1148 API int pkgmgrinfo_pkginfo_is_for_all_users(pkgmgrinfo_pkginfo_h handle, bool *for_all_users)
1149 {
1150         return pkgmgrinfo_pkginfo_is_global(handle, for_all_users);
1151 }
1152
1153 API int pkgmgrinfo_pkginfo_destroy_pkginfo(pkgmgrinfo_pkginfo_h handle)
1154 {
1155         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1156
1157         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1158
1159         __cleanup_pkginfo(info);
1160
1161         return PMINFO_R_OK;
1162 }
1163
1164 API int pkgmgrinfo_pkginfo_filter_create(pkgmgrinfo_pkginfo_filter_h *handle)
1165 {
1166         pkgmgrinfo_filter_x *filter;
1167
1168         retvm_if(handle == NULL, PMINFO_R_EINVAL, "Filter handle output parameter is NULL\n");
1169
1170         filter = (pkgmgrinfo_filter_x *)calloc(1, sizeof(pkgmgrinfo_filter_x));
1171         if (filter == NULL) {
1172                 _LOGE("Out of Memory!!!");
1173                 return PMINFO_R_ERROR;
1174         }
1175
1176         *handle = filter;
1177
1178         return PMINFO_R_OK;
1179 }
1180
1181 API int pkgmgrinfo_pkginfo_filter_destroy(pkgmgrinfo_pkginfo_filter_h handle)
1182 {
1183         pkgmgrinfo_filter_x *filter = (pkgmgrinfo_filter_x *)handle;
1184
1185         retvm_if(handle == NULL, PMINFO_R_EINVAL, "Filter handle input parameter is NULL\n");
1186
1187         if (filter->list)
1188                 g_slist_free_full(filter->list,
1189                                 (GDestroyNotify)_pkgmgrinfo_node_destroy);
1190
1191         if (filter->list_metadata)
1192                 g_slist_free_full(filter->list_metadata,
1193                                 __destroy_metadata_node);
1194
1195         free(filter);
1196
1197         return PMINFO_R_OK;
1198 }
1199
1200 API int pkgmgrinfo_pkginfo_filter_add_int(pkgmgrinfo_pkginfo_filter_h handle,
1201                                 const char *property, const int value)
1202 {
1203         char buf[PKG_VALUE_STRING_LEN_MAX] = {'\0'};
1204         char *val;
1205         GSList *link;
1206         int prop;
1207         pkgmgrinfo_filter_x *filter = (pkgmgrinfo_filter_x *)handle;
1208         pkgmgrinfo_node_x *node;
1209
1210         retvm_if(handle == NULL, PMINFO_R_EINVAL, "Filter handle input parameter is NULL\n");
1211         retvm_if(property == NULL, PMINFO_R_EINVAL, "Filter handle input parameter is NULL\n");
1212
1213         prop = _pminfo_pkginfo_convert_to_prop_int(property);
1214         if (prop < E_PMINFO_PKGINFO_PROP_PACKAGE_MIN_INT ||
1215                 prop > E_PMINFO_PKGINFO_PROP_PACKAGE_MAX_INT) {
1216                 _LOGE("Invalid Integer Property\n");
1217                 return PMINFO_R_EINVAL;
1218         }
1219         node = (pkgmgrinfo_node_x *)calloc(1, sizeof(pkgmgrinfo_node_x));
1220         if (node == NULL) {
1221                 _LOGE("Out of Memory!!!\n");
1222                 return PMINFO_R_ERROR;
1223         }
1224         snprintf(buf, PKG_VALUE_STRING_LEN_MAX - 1, "%d", value);
1225         val = strndup(buf, PKG_VALUE_STRING_LEN_MAX - 1);
1226         if (val == NULL) {
1227                 _LOGE("Out of Memory\n");
1228                 free(node);
1229                 return PMINFO_R_ERROR;
1230         }
1231         node->prop = prop;
1232         node->value = val;
1233         /*If API is called multiple times for same property, we should override the previous values.
1234         Last value set will be used for filtering.*/
1235         link = g_slist_find_custom(filter->list, (gconstpointer)node, __compare_func);
1236         if (link) {
1237                 _pkgmgrinfo_node_destroy(link->data);
1238                 filter->list = g_slist_delete_link(filter->list, link);
1239         }
1240         filter->list = g_slist_append(filter->list, (gpointer)node);
1241         return PMINFO_R_OK;
1242
1243 }
1244
1245 API int pkgmgrinfo_pkginfo_filter_add_bool(pkgmgrinfo_pkginfo_filter_h handle,
1246                                 const char *property, const bool value)
1247 {
1248         char *val;
1249         GSList *link;
1250         int prop;
1251         pkgmgrinfo_filter_x *filter = (pkgmgrinfo_filter_x *)handle;
1252         pkgmgrinfo_node_x *node;
1253
1254         retvm_if(handle == NULL, PMINFO_R_EINVAL, "Filter handle input parameter is NULL\n");
1255         retvm_if(property == NULL, PMINFO_R_EINVAL, "Filter handle input parameter is NULL\n");
1256
1257         prop = _pminfo_pkginfo_convert_to_prop_bool(property);
1258         if (prop < E_PMINFO_PKGINFO_PROP_PACKAGE_MIN_BOOL ||
1259                 prop > E_PMINFO_PKGINFO_PROP_PACKAGE_MAX_BOOL) {
1260                 _LOGE("Invalid Boolean Property\n");
1261                 return PMINFO_R_EINVAL;
1262         }
1263         node = (pkgmgrinfo_node_x *)calloc(1, sizeof(pkgmgrinfo_node_x));
1264         if (node == NULL) {
1265                 _LOGE("Out of Memory!!!\n");
1266                 return PMINFO_R_ERROR;
1267         }
1268         if (value)
1269                 val = strndup("true", 4);
1270         else
1271                 val = strndup("false", 5);
1272         if (val == NULL) {
1273                 _LOGE("Out of Memory\n");
1274                 free(node);
1275                 return PMINFO_R_ERROR;
1276         }
1277         node->prop = prop;
1278         node->value = val;
1279         /*If API is called multiple times for same property, we should override the previous values.
1280         Last value set will be used for filtering.*/
1281         link = g_slist_find_custom(filter->list, (gconstpointer)node, __compare_func);
1282         if (link) {
1283                 _pkgmgrinfo_node_destroy(link->data);
1284                 filter->list = g_slist_delete_link(filter->list, link);
1285         }
1286         filter->list = g_slist_append(filter->list, (gpointer)node);
1287         return PMINFO_R_OK;
1288
1289 }
1290
1291 API int pkgmgrinfo_pkginfo_filter_add_string(pkgmgrinfo_pkginfo_filter_h handle,
1292                                 const char *property, const char *value)
1293 {
1294         char *val;
1295         GSList *link;
1296         int prop;
1297         pkgmgrinfo_filter_x *filter = (pkgmgrinfo_filter_x *)handle;
1298         pkgmgrinfo_node_x *node;
1299
1300         retvm_if(handle == NULL, PMINFO_R_EINVAL, "Filter handle input parameter is NULL\n");
1301         retvm_if(property == NULL, PMINFO_R_EINVAL, "Filter handle input parameter is NULL\n");
1302         retvm_if(value == NULL, PMINFO_R_EINVAL, "Filter handle input parameter is NULL\n");
1303
1304         prop = _pminfo_pkginfo_convert_to_prop_str(property);
1305         if (prop < E_PMINFO_PKGINFO_PROP_PACKAGE_MIN_STR ||
1306                 prop > E_PMINFO_PKGINFO_PROP_PACKAGE_MAX_STR) {
1307                 _LOGE("Invalid String Property\n");
1308                 return PMINFO_R_EINVAL;
1309         }
1310         node = (pkgmgrinfo_node_x *)calloc(1, sizeof(pkgmgrinfo_node_x));
1311         if (node == NULL) {
1312                 _LOGE("Out of Memory!!!\n");
1313                 return PMINFO_R_ERROR;
1314         }
1315         if (strcmp(value, PMINFO_PKGINFO_INSTALL_LOCATION_AUTO) == 0)
1316                 val = strndup("auto", PKG_STRING_LEN_MAX - 1);
1317         else if (strcmp(value, PMINFO_PKGINFO_INSTALL_LOCATION_INTERNAL) == 0)
1318                 val = strndup("internal-only", PKG_STRING_LEN_MAX - 1);
1319         else if (strcmp(value, PMINFO_PKGINFO_INSTALL_LOCATION_EXTERNAL) == 0)
1320                 val = strndup("prefer-external", PKG_STRING_LEN_MAX - 1);
1321         else if (strcmp(value, "installed_internal") == 0)
1322                 val = strndup("installed_internal", PKG_STRING_LEN_MAX - 1);
1323         else if (strcmp(value, "installed_external") == 0)
1324                 val = strndup("installed_external", PKG_STRING_LEN_MAX - 1);
1325         else
1326                 val = strndup(value, PKG_STRING_LEN_MAX - 1);
1327         if (val == NULL) {
1328                 _LOGE("Out of Memory\n");
1329                 free(node);
1330                 return PMINFO_R_ERROR;
1331         }
1332         node->prop = prop;
1333         node->value = val;
1334         /*If API is called multiple times for same property, we should override the previous values.
1335         Last value set will be used for filtering.*/
1336         link = g_slist_find_custom(filter->list, (gconstpointer)node, __compare_func);
1337         if (link) {
1338                 _pkgmgrinfo_node_destroy(link->data);
1339                 filter->list = g_slist_delete_link(filter->list, link);
1340         }
1341         filter->list = g_slist_append(filter->list, (gpointer)node);
1342         return PMINFO_R_OK;
1343
1344 }
1345
1346 API int pkgmgrinfo_pkginfo_usr_filter_count(pkgmgrinfo_pkginfo_filter_h handle, int *count, uid_t uid)
1347 {
1348         int ret;
1349         int query_count;
1350         GHashTable *list = NULL;
1351
1352         if (handle == NULL || count == NULL) {
1353                 _LOGE("invalid parameter");
1354                 return PMINFO_R_EINVAL;
1355         }
1356
1357         list = g_hash_table_new_full(g_str_hash, g_str_equal, NULL,
1358                         __free_packages);
1359         if (list == NULL)
1360                 return PMINFO_R_ERROR;
1361
1362         if (__check_disable_filter_exist((pkgmgrinfo_filter_x *)handle) == false) {
1363                 ret = pkgmgrinfo_pkginfo_filter_add_bool(handle,
1364                                 PMINFO_PKGINFO_PROP_PACKAGE_DISABLE, false);
1365                 if (ret != PMINFO_R_OK) {
1366                         g_hash_table_destroy(list);
1367                         return PMINFO_R_ERROR;
1368                 }
1369         }
1370
1371         ret = _pkginfo_get_packages(uid, handle, PMINFO_PKGINFO_GET_BASICINFO, list);
1372         query_count = g_hash_table_size(list);
1373         g_hash_table_destroy(list);
1374         if (ret == PMINFO_R_ERROR)
1375                 return ret;
1376         *count = query_count;
1377         return PMINFO_R_OK;
1378 }
1379
1380 API int pkgmgrinfo_pkginfo_filter_count(pkgmgrinfo_pkginfo_filter_h handle, int *count)
1381 {
1382         return pkgmgrinfo_pkginfo_usr_filter_count(handle, count, _getuid());
1383 }
1384
1385 API int pkgmgrinfo_pkginfo_usr_filter_foreach_pkginfo(
1386                 pkgmgrinfo_pkginfo_filter_h handle,
1387                 pkgmgrinfo_pkg_list_cb pkg_cb, void *user_data, uid_t uid)
1388 {
1389         if (handle == NULL || pkg_cb == NULL) {
1390                 LOGE("invalid parameter");
1391                 return PMINFO_R_EINVAL;
1392         }
1393
1394         return _pkginfo_get_filtered_foreach_pkginfo(uid, handle,
1395                         PMINFO_PKGINFO_GET_ALL, pkg_cb, user_data);
1396 }
1397
1398 API int pkgmgrinfo_pkginfo_filter_foreach_pkginfo(pkgmgrinfo_pkginfo_filter_h handle,
1399                                 pkgmgrinfo_pkg_list_cb pkg_cb, void *user_data)
1400 {
1401         return pkgmgrinfo_pkginfo_usr_filter_foreach_pkginfo(handle, pkg_cb, user_data, _getuid());
1402 }
1403
1404 API int pkgmgrinfo_pkginfo_foreach_privilege(pkgmgrinfo_pkginfo_h handle,
1405                         pkgmgrinfo_pkg_privilege_list_cb privilege_func, void *user_data)
1406 {
1407         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL");
1408         retvm_if(privilege_func == NULL, PMINFO_R_EINVAL, "Callback function is NULL");
1409         int ret;
1410         privilege_x *privilege;
1411         appdefined_privilege_x *appdefined_privilege;
1412         GList *tmp;
1413         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1414
1415         if (info->pkg_info == NULL)
1416                 return PMINFO_R_ERROR;
1417
1418         for (tmp = info->pkg_info->privileges; tmp; tmp = tmp->next) {
1419                 privilege = (privilege_x *)tmp->data;
1420                 if (privilege == NULL)
1421                         continue;
1422                 ret = privilege_func(privilege->value, user_data);
1423                 if (ret < 0)
1424                         return PMINFO_R_OK;
1425         }
1426
1427         for (tmp = info->pkg_info->appdefined_privileges; tmp;
1428                         tmp = tmp->next) {
1429                 appdefined_privilege = (appdefined_privilege_x *)tmp->data;
1430                 if (appdefined_privilege == NULL)
1431                         continue;
1432                 ret = privilege_func(appdefined_privilege->value, user_data);
1433                 if (ret < 0)
1434                         return PMINFO_R_OK;
1435         }
1436         return PMINFO_R_OK;
1437 }
1438
1439 API int pkgmgrinfo_pkginfo_foreach_plugin(pkgmgrinfo_pkginfo_h handle,
1440                         pkgmgrinfo_plugin_list_cb plugin_func, void *user_data)
1441 {
1442         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL");
1443         retvm_if(plugin_func == NULL, PMINFO_R_EINVAL,
1444                         "Callback function is NULL");
1445         int ret;
1446         plugin_x *plugin;
1447         GList *tmp;
1448         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1449
1450         if (info->pkg_info == NULL)
1451                 return PMINFO_R_ERROR;
1452
1453         for (tmp = info->pkg_info->plugin; tmp; tmp = tmp->next) {
1454                 plugin = (plugin_x *)tmp->data;
1455                 if (plugin == NULL)
1456                         continue;
1457                 ret = plugin_func(plugin->pkgid, plugin->appid,
1458                                 plugin->plugin_type, plugin->plugin_name, user_data);
1459                 if (ret < 0)
1460                         return PMINFO_R_OK;
1461         }
1462
1463         return PMINFO_R_OK;
1464 }
1465
1466 API int pkgmgrinfo_pkginfo_foreach_appdefined_privilege(
1467                 pkgmgrinfo_pkginfo_h handle,
1468                 pkgmgrinfo_pkg_appdefined_privilege_list_cb privilege_func,
1469                 void *user_data)
1470 {
1471         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL");
1472         retvm_if(privilege_func == NULL, PMINFO_R_EINVAL,
1473                         "Callback function is NULL");
1474         int ret;
1475         appdefined_privilege_x *privilege;
1476         GList *tmp;
1477         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1478
1479         if (info->pkg_info == NULL)
1480                 return PMINFO_R_ERROR;
1481
1482         for (tmp = info->pkg_info->appdefined_privileges; tmp;
1483                         tmp = tmp->next) {
1484                 privilege = (appdefined_privilege_x *)tmp->data;
1485                 if (privilege == NULL)
1486                         continue;
1487                 ret = privilege_func(privilege->value, privilege->license,
1488                                 user_data);
1489                 if (ret < 0)
1490                         break;
1491         }
1492         return PMINFO_R_OK;
1493 }
1494
1495 API int pkgmgrinfo_pkginfo_foreach_dependency(pkgmgrinfo_pkginfo_h handle,
1496                 pkgmgrinfo_pkg_dependency_list_cb dependency_cb,
1497                 void *user_data)
1498 {
1499         int ret;
1500         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1501         GList *tmp;
1502         dependency_x *dependency;
1503
1504         if (handle == NULL || dependency_cb == NULL) {
1505                 LOGE("invalid parameter");
1506                 return PMINFO_R_EINVAL;
1507         }
1508
1509         if (info->pkg_info == NULL)
1510                 return PMINFO_R_ERROR;
1511
1512         for (tmp = info->pkg_info->dependencies; tmp; tmp = tmp->next) {
1513                 dependency = (dependency_x *)tmp->data;
1514                 if (dependency == NULL)
1515                         continue;
1516                 ret = dependency_cb(info->pkg_info->package,
1517                                 dependency->depends_on, dependency->type,
1518                                 dependency->required_version, user_data);
1519                 if (ret < 0)
1520                         break;
1521         }
1522
1523         return PMINFO_R_OK;
1524 }
1525
1526 static void __free_depends_on(gpointer data)
1527 {
1528         dependency_x *dep = (dependency_x *)data;
1529         pkgmgrinfo_basic_free_dependency(dep);
1530 }
1531
1532 API int pkgmgrinfo_pkginfo_foreach_depends_on(pkgmgrinfo_pkginfo_h handle,
1533                 pkgmgrinfo_pkg_dependency_list_cb dependency_cb,
1534                 void *user_data)
1535 {
1536         int ret;
1537         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1538         GList *pkg_list = NULL;
1539         GList *l;
1540         dependency_x *dep;
1541
1542         if (handle == NULL || dependency_cb == NULL || info->pkg_info == NULL) {
1543                 LOGE("invalid parameter");
1544                 return PMINFO_R_EINVAL;
1545         }
1546
1547         ret = _pkginfo_get_depends_on(info->uid, info->pkg_info->package, &pkg_list);
1548         if (ret != PMINFO_R_OK)
1549                 return PMINFO_R_ERROR;
1550
1551         for (l = pkg_list; l != NULL; l = g_list_next(l)) {
1552                 dep = (dependency_x *)l->data;
1553                 ret = dependency_cb(dep->pkgid, dep->depends_on,
1554                                 dep->type, dep->required_version, user_data);
1555                 if (ret < 0)
1556                         break;
1557         }
1558         g_list_free_full(pkg_list, __free_depends_on);
1559
1560         return PMINFO_R_OK;
1561 }
1562
1563 API int pkgmgrinfo_pkginfo_foreach_res_allowed_package(
1564                 pkgmgrinfo_pkginfo_h handle,
1565                 pkgmgrinfo_res_allowed_package_list_cb res_allowed_package_cb,
1566                 void *user_data)
1567 {
1568         int ret;
1569         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1570         GList *res_pkgs;
1571         res_allowed_package_x *res_allowed_package;
1572
1573         if (handle == NULL || res_allowed_package_cb == NULL) {
1574                 LOGE("invalid parameter");
1575                 return PMINFO_R_EINVAL;
1576         }
1577
1578         if (info->pkg_info == NULL)
1579                 return PMINFO_R_ERROR;
1580
1581         for (res_pkgs = info->pkg_info->res_allowed_packages; res_pkgs;
1582                         res_pkgs = res_pkgs->next) {
1583                 res_allowed_package = (res_allowed_package_x *)res_pkgs->data;
1584                 if (res_allowed_package == NULL)
1585                         continue;
1586
1587                 ret = res_allowed_package_cb(
1588                                 res_allowed_package->allowed_package,
1589                                 res_allowed_package->required_privileges,
1590                                 user_data);
1591                 if (ret < 0)
1592                         return PMINFO_R_OK;
1593         }
1594
1595         return PMINFO_R_OK;
1596 }
1597
1598 API int pkgmgrinfo_pkginfo_foreach_required_privilege(
1599                 required_privilege_h handle,
1600                 pkgmgrinfo_pkg_privilege_list_cb privilege_func,
1601                 void *user_data)
1602 {
1603         int ret;
1604         GList *privs;
1605
1606         if (privilege_func == NULL) {
1607                 LOGE("invalid parameter");
1608                 return PMINFO_R_EINVAL;
1609         }
1610
1611         for (privs = (GList *)handle; privs; privs = privs->next) {
1612                 ret = privilege_func((char *)privs->data, user_data);
1613                 if (ret < 0)
1614                         return PMINFO_R_OK;
1615         }
1616
1617         return PMINFO_R_OK;
1618 }
1619
1620 int __compare_package_version(const char *version, int *major,
1621                 int *minor, int *macro, int *nano)
1622 {
1623         char *version_temp = NULL;
1624         char *major_str = NULL;
1625         char *minor_str = NULL;
1626         char *macro_str = NULL;
1627         char *nano_str = NULL;
1628         char *save_str = NULL;
1629
1630         if (version == NULL || major == NULL || minor == NULL ||
1631                 macro == NULL || nano == NULL) {
1632                 return PMINFO_R_EINVAL;
1633         }
1634
1635         version_temp = strdup(version);
1636         if (version_temp == NULL) {
1637                 LOGE("Out of memory");
1638                 return PMINFO_R_ERROR;
1639         }
1640
1641         major_str = strtok_r(version_temp, ".", &save_str);
1642         if (major_str == NULL) {
1643                 _LOGE("major version is NULL");
1644                 free(version_temp);
1645                 return PMINFO_R_ERROR;
1646         }
1647
1648         minor_str = strtok_r(NULL, ".", &save_str);
1649         if (minor_str == NULL) {
1650                 _LOGE("minor version is NULL");
1651                 free(version_temp);
1652                 return PMINFO_R_ERROR;
1653         }
1654
1655         *major = atoi(major_str);
1656         *minor = atoi(minor_str);
1657         *macro = 0;
1658         *nano = 0;
1659         macro_str = strtok_r(NULL, ".", &save_str);
1660         if (macro_str == NULL) {
1661                 _LOGD("macro version is NULL");
1662         } else {
1663                 *macro = atoi(macro_str);
1664                 nano_str = strtok_r(NULL, ".", &save_str);
1665                 if (nano_str) {
1666                         *nano = atoi(nano_str);
1667                         _LOGD("nano version exists");
1668                 }
1669         }
1670         _LOGD("version = [%s] -> major = [%d], minor = [%d]," \
1671                 " macro = [%d], nano = [%d]", version, *major,
1672                 *minor, *macro, *nano);
1673
1674         free(version_temp);
1675
1676         return PMINFO_R_OK;
1677 }
1678
1679 API int pkgmgrinfo_compare_package_version(const char *current_version,
1680                 const char *target_version,
1681                 pkgmgrinfo_version_compare_type *res)
1682 {
1683         int ret = 0;
1684         int current_version_major = 0;
1685         int current_version_minor = 0;
1686         int current_version_macro = 0;
1687         int current_version_nano = 0;
1688         int target_version_major = 0;
1689         int target_version_minor = 0;
1690         int target_version_macro = 0;
1691         int target_version_nano = 0;
1692
1693         if (current_version == NULL || target_version == NULL ||
1694                 res == NULL) {
1695                 _LOGE("Invalid parameter");
1696                 return PMINFO_R_EINVAL;
1697         }
1698
1699         ret = __compare_package_version(target_version,
1700                 &target_version_major, &target_version_minor,
1701                 &target_version_macro, &target_version_nano);
1702         if (ret < 0) {
1703                 _LOGE("Failed to compare target version(%d)", ret);
1704                 return PMINFO_R_ERROR;
1705         }
1706
1707         ret = __compare_package_version(current_version,
1708                 &current_version_major, &current_version_minor,
1709                 &current_version_macro, &current_version_nano);
1710         if (ret < 0) {
1711                 _LOGE("Failed to compare current version(%d)", ret);
1712                 return PMINFO_R_ERROR;
1713         }
1714
1715         _LOGD("new[%d.%d.%d.%d] old[%d.%d.%d.%d]", target_version_major,
1716                 target_version_minor, target_version_macro,
1717                 target_version_nano, current_version_major,
1718                 current_version_minor, current_version_macro,
1719                 target_version_nano);
1720
1721         if (target_version_major > current_version_major)
1722                 *res = PMINFO_VERSION_NEW;
1723         else if (target_version_major < current_version_major)
1724                 *res = PMINFO_VERSION_OLD;
1725         else if (target_version_minor > current_version_minor)
1726                 *res = PMINFO_VERSION_NEW;
1727         else if (target_version_minor < current_version_minor)
1728                 *res = PMINFO_VERSION_OLD;
1729         else if (target_version_macro > current_version_macro)
1730                 *res = PMINFO_VERSION_NEW;
1731         else if (target_version_macro < current_version_macro)
1732                 *res = PMINFO_VERSION_OLD;
1733         else if (target_version_nano > current_version_nano)
1734                 *res = PMINFO_VERSION_NEW;
1735         else if (target_version_nano < current_version_nano)
1736                 *res = PMINFO_VERSION_OLD;
1737         else
1738                 *res = PMINFO_VERSION_SAME;
1739
1740         return PMINFO_R_OK;
1741 }