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 <sqlite3.h>
  36 #include <glib.h>
  37
  38 #include "pkgmgrinfo_basic.h"
  39 #include "pkgmgrinfo_private.h"
  40 #include "pkgmgrinfo_debug.h"
  41 #include "pkgmgr-info.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_each_node(gpointer data, gpointer user_data)
  74 {
  75         ret_if(data == NULL);
  76         pkgmgrinfo_node_x *node = (pkgmgrinfo_node_x *)data;
  77         if (node->value) {
  78                 free(node->value);
  79                 node->value = NULL;
  80         }
  81         if (node->key) {
  82                 free(node->key);
  83                 node->key = NULL;
  84         }
  85         free(node);
  86         node = NULL;
  87 }
  88
  89 static void __destroy_metadata_node(gpointer data)
  90 {
  91         pkgmgrinfo_metadata_node_x *node = (pkgmgrinfo_metadata_node_x *)data;
  92         if (node->key)
  93                 free(node->key);
  94         if (node->value)
  95                 free(node->value);
  96         free(node);
  97 }
  98
  99 static void __cleanup_pkginfo(pkgmgr_pkginfo_x *data)
 100 {
 101         ret_if(data == NULL);
 102         if (data->locale) {
 103                 free((void *)data->locale);
 104                 data->locale = NULL;
 105         }
 106
 107         pkgmgrinfo_basic_free_package(data->pkg_info);
 108         free((void *)data);
 109         data = NULL;
 110         return;
 111 }
 112
 113 long long _pkgmgr_calculate_dir_size(char *dirname)
 114 {
 115         long long total = 0;
 116         long long ret = 0;
 117         int q = 0; /*quotient*/
 118         int r = 0; /*remainder*/
 119         DIR *dp = NULL;
 120         struct dirent *ep;
 121         struct stat fileinfo;
 122         char abs_filename[FILENAME_MAX] = { 0, };
 123         retvm_if(dirname == NULL, PMINFO_R_ERROR, "dirname is NULL");
 124
 125         dp = opendir(dirname);
 126         if (dp == NULL) {
 127                 _LOGE("Couldn't open the directory\n");
 128                 return -1;
 129         }
 130
 131         for (ep = readdir(dp); ep != NULL; ep = readdir(dp)) {
 132                 if (!strcmp(ep->d_name, ".") ||
 133                         !strcmp(ep->d_name, "..")) {
 134                         continue;
 135                 }
 136                 snprintf(abs_filename, FILENAME_MAX, "%s/%s", dirname,
 137                          ep->d_name);
 138                 if (lstat(abs_filename, &fileinfo) < 0)
 139                         perror(abs_filename);
 140                 else {
 141                         if (S_ISDIR(fileinfo.st_mode)) {
 142                                 total += fileinfo.st_size;
 143                                 if (strcmp(ep->d_name, ".")
 144                                     && strcmp(ep->d_name, "..")) {
 145                                         ret = _pkgmgr_calculate_dir_size
 146                                             (abs_filename);
 147                                         total = total + ret;
 148                                 }
 149                         } else if (S_ISLNK(fileinfo.st_mode)) {
 150                                 continue;
 151                         } else {
 152                                 /*It is a file. Calculate the actual
 153                                 size occupied (in terms of 4096 blocks)*/
 154                         q = (fileinfo.st_size / BLOCK_SIZE);
 155                         r = (fileinfo.st_size % BLOCK_SIZE);
 156                         if (r)
 157                                 q = q + 1;
 158                         total += q * BLOCK_SIZE;
 159                         }
 160                 }
 161         }
 162         (void)closedir(dp);
 163         return total;
 164
 165 }
 166
 167 static int _pkginfo_add_description_info_into_list(const char *locale,
 168                 char *record, GList **description)
 169 {
 170         description_x *info;
 171
 172         info = calloc(1, sizeof(description_x));
 173         if (info == NULL) {
 174                 LOGE("out of memory");
 175                 return PMINFO_R_ERROR;
 176         }
 177         info->lang = strdup(locale);
 178         info->text = record;
 179         *description = g_list_append(*description, info);
 180
 181         return PMINFO_R_OK;
 182 }
 183
 184 static int _pkginfo_get_plugin_execution_info(sqlite3 *db, const char *pkgid,
 185                 GList **plugins)
 186 {
 187         static const char query_raw[] =
 188                 "SELECT appid, plugin_type, plugin_name FROM package_plugin_info "
 189                 "WHERE pkgid=%Q";
 190         int ret;
 191         char *query;
 192         sqlite3_stmt *stmt;
 193         plugin_x *plugin;
 194
 195         query = sqlite3_mprintf(query_raw, pkgid);
 196         if (query == NULL) {
 197                 LOGE("out of memory");
 198                 return PMINFO_R_ERROR;
 199         }
 200
 201         ret = sqlite3_prepare_v2(db, query, strlen(query),
 202                         &stmt, NULL);
 203         sqlite3_free(query);
 204         if (ret != SQLITE_OK) {
 205                 LOGE("prepare failed: %s", sqlite3_errmsg(db));
 206                 return PMINFO_R_ERROR;
 207         }
 208
 209         while (sqlite3_step(stmt) == SQLITE_ROW) {
 210                 plugin = calloc(1, sizeof(plugin_x));
 211                 if (!plugin) {
 212                         LOGE("out of memory");
 213                         sqlite3_finalize(stmt);
 214                         return PMINFO_R_ERROR;
 215                 }
 216                 plugin->pkgid = strdup(pkgid);
 217                 _save_column_str(stmt, 0, &plugin->appid);
 218                 _save_column_str(stmt, 1, &plugin->plugin_type);
 219                 _save_column_str(stmt, 2, &plugin->plugin_name);
 220                 *plugins = g_list_append(*plugins,
 221                                 (gpointer)plugin);
 222         }
 223
 224         sqlite3_finalize(stmt);
 225
 226         return PMINFO_R_OK;
 227 }
 228
 229 static int _pkginfo_get_privilege(sqlite3 *db, const char *pkgid,
 230                 GList **privileges)
 231 {
 232         static const char query_raw[] =
 233                 "SELECT DISTINCT privilege, type FROM package_privilege_info "
 234                 "WHERE package=%Q";
 235         int ret;
 236         char *query;
 237         sqlite3_stmt *stmt;
 238         privilege_x *privilege;
 239
 240         query = sqlite3_mprintf(query_raw, pkgid);
 241         if (query == NULL) {
 242                 LOGE("out of memory");
 243                 return PMINFO_R_ERROR;
 244         }
 245
 246         ret = sqlite3_prepare_v2(db, query, strlen(query),
 247                         &stmt, NULL);
 248         sqlite3_free(query);
 249         if (ret != SQLITE_OK) {
 250                 LOGE("prepare failed: %s", sqlite3_errmsg(db));
 251                 return PMINFO_R_ERROR;
 252         }
 253
 254         while (sqlite3_step(stmt) == SQLITE_ROW) {
 255                 privilege = calloc(1, sizeof(privilege_x));
 256                 if (!privilege) {
 257                         LOGE("failed to alloc memory");
 258                         sqlite3_finalize(stmt);
 259                         return PMINFO_R_ERROR;
 260                 }
 261                 _save_column_str(stmt, 0, &privilege->value);
 262                 _save_column_str(stmt, 1, &privilege->type);
 263                 *privileges = g_list_append(*privileges,
 264                                 (gpointer)privilege);
 265         }
 266
 267         sqlite3_finalize(stmt);
 268
 269         return PMINFO_R_OK;
 270 }
 271
 272 static int _pkginfo_get_appdefined_privilege(sqlite3 *db, const char *pkgid,
 273                 GList **privileges)
 274 {
 275         static const char query_raw[] =
 276                 "SELECT DISTINCT privilege, license, type FROM "
 277                 "package_appdefined_privilege_info WHERE package=%Q";
 278         int ret;
 279         char *query;
 280         sqlite3_stmt *stmt;
 281         appdefined_privilege_x *privilege;
 282
 283         query = sqlite3_mprintf(query_raw, pkgid);
 284         if (query == NULL) {
 285                 LOGE("out of memory");
 286                 return PMINFO_R_ERROR;
 287         }
 288
 289         ret = sqlite3_prepare_v2(db, query, strlen(query),
 290                         &stmt, NULL);
 291         sqlite3_free(query);
 292         if (ret != SQLITE_OK) {
 293                 LOGE("prepare failed: %s", sqlite3_errmsg(db));
 294                 return PMINFO_R_ERROR;
 295         }
 296
 297         while (sqlite3_step(stmt) == SQLITE_ROW) {
 298                 privilege = calloc(1, sizeof(appdefined_privilege_x));
 299                 if (!privilege) {
 300                         LOGE("failed to alloc memory");
 301                         sqlite3_finalize(stmt);
 302                         return PMINFO_R_ERROR;
 303                 }
 304                 _save_column_str(stmt, 0, &privilege->value);
 305                 _save_column_str(stmt, 1, &privilege->license);
 306                 _save_column_str(stmt, 2, &privilege->type);
 307                 *privileges = g_list_append(*privileges,
 308                                 (gpointer)privilege);
 309         }
 310
 311         sqlite3_finalize(stmt);
 312
 313         return PMINFO_R_OK;
 314 }
 315
 316 static int _pkginfo_get_dependency(sqlite3 *db, const char *pkgid,
 317                 GList **dependencies)
 318 {
 319         static const char query_raw[] =
 320                 "SELECT DISTINCT depends_on, type, required_version "
 321                 "FROM package_dependency_info WHERE package=%Q";
 322         int ret;
 323         char *query;
 324         sqlite3_stmt *stmt;
 325         dependency_x *dependency;
 326
 327         query = sqlite3_mprintf(query_raw, pkgid);
 328         if (query == NULL) {
 329                 LOGE("out of memory");
 330                 return PMINFO_R_ERROR;
 331         }
 332
 333         ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
 334         sqlite3_free(query);
 335         if (ret != SQLITE_OK) {
 336                 LOGE("prepare failed: %s", sqlite3_errmsg(db));
 337                 return PMINFO_R_ERROR;
 338         }
 339
 340         while (sqlite3_step(stmt) == SQLITE_ROW) {
 341                 dependency = calloc(1, sizeof(dependency_x));
 342                 if (!dependency) {
 343                         LOGE("failed to alloc memory");
 344                         sqlite3_finalize(stmt);
 345                         return PMINFO_R_ERROR;
 346                 }
 347                 _save_column_str(stmt, 0, &dependency->depends_on);
 348                 _save_column_str(stmt, 1, &dependency->type);
 349                 _save_column_str(stmt, 2, &dependency->required_version);
 350                 *dependencies = g_list_append(*dependencies,
 351                                 (gpointer)dependency);
 352         }
 353
 354         sqlite3_finalize(stmt);
 355
 356         return PMINFO_R_OK;
 357 }
 358
 359 static const char join_localized_info[] =
 360         " LEFT OUTER JOIN package_localized_info"
 361         "  ON pi.package=package_localized_info.package"
 362         "  AND package_localized_info.package_locale=?";
 363 static const char join_privilege_info[] =
 364         " LEFT OUTER JOIN package_privilege_info"
 365         "  ON pi.package=package_privilege_info.package";
 366
 367 static int _get_filtered_query(pkgmgrinfo_filter_x *filter,
 368                 const char *locale, uid_t uid, char **query, GList **bind_params)
 369 {
 370         int joined = 0;
 371         char buf[MAX_QUERY_LEN] = { '\0' };
 372         char buf2[MAX_QUERY_LEN] = { '\0' };
 373         char *condition = NULL;
 374         GSList *list = NULL;
 375
 376         if (filter == NULL)
 377                 return PMINFO_R_OK;
 378
 379         snprintf(buf, sizeof(buf), "%s", " WHERE 1=1 ");
 380         for (list = filter->list; list; list = list->next) {
 381                 joined |= __get_filter_condition(list->data, uid, &condition,
 382                                 bind_params);
 383                 if (condition == NULL)
 384                         continue;
 385
 386                 strncat(buf, " AND ", sizeof(buf) - strlen(buf) - 1);
 387
 388                 strncat(buf, condition, sizeof(buf) - strlen(buf) - 1);
 389                 free(condition);
 390                 condition = NULL;
 391         }
 392
 393         if (joined & E_PMINFO_PKGINFO_JOIN_LOCALIZED_INFO) {
 394                 strncat(buf2, join_localized_info, sizeof(buf2) - strlen(buf2) - 1);
 395                 *bind_params = g_list_append(*bind_params, strdup(locale));
 396         }
 397         if (joined & E_PMINFO_PKGINFO_JOIN_PRIVILEGE_INFO)
 398                 strncat(buf2, join_privilege_info, sizeof(buf2) - strlen(buf2) - 1);
 399         strncat(buf2, buf, sizeof(buf2) - strlen(buf2) - 1);
 400
 401         *query = strdup(buf2);
 402         if (*query == NULL)
 403                 return PMINFO_R_ERROR;
 404
 405         return PMINFO_R_OK;
 406 }
 407
 408 static void __free_packages(gpointer data)
 409 {
 410         pkgmgrinfo_basic_free_package((package_x *)data);
 411 }
 412
 413 static bool __check_disable_filter_exist(pkgmgrinfo_filter_x *filter)
 414 {
 415         GSList *link;
 416
 417         if (filter == NULL)
 418                 return false;
 419
 420         link = g_slist_find_custom(filter->list, NULL, __pkg_disable_chk_func);
 421         if (link)
 422                 return true;
 423
 424         return false;
 425 }
 426
 427 static int __bind_params(sqlite3_stmt *stmt, GList *params)
 428 {
 429         GList *tmp_list = NULL;
 430         int idx = 0;
 431         int ret;
 432
 433         if (stmt == NULL || params == NULL)
 434                 return PMINFO_R_EINVAL;
 435
 436         tmp_list = params;
 437         while (tmp_list) {
 438                 ret = sqlite3_bind_text(stmt, ++idx, (char *)tmp_list->data, -1, SQLITE_STATIC);
 439                 if (ret != SQLITE_OK)
 440                         return PMINFO_R_ERROR;
 441                 tmp_list = tmp_list->next;
 442         }
 443
 444         return PMINFO_R_OK;
 445 }
 446
 447 static bool __check_package_storage_status(pkgmgrinfo_filter_x *tmp_filter)
 448 {
 449         GSList *tmp_list = NULL;
 450         pkgmgrinfo_node_x *tmp_node = NULL;
 451         int property = -1;
 452
 453         property = _pminfo_pkginfo_convert_to_prop_bool(PMINFO_PKGINFO_PROP_PACKAGE_CHECK_STORAGE);
 454         for (tmp_list = tmp_filter->list; tmp_list != NULL;
 455                         tmp_list = g_slist_next(tmp_list)) {
 456                 tmp_node = (pkgmgrinfo_node_x *)tmp_list->data;
 457                 if (property == tmp_node->prop) {
 458                         if (strcmp(tmp_node->value, "true") == 0)
 459                                 return true;
 460                         else
 461                                 return false;
 462                 }
 463         }
 464         return true;
 465 }
 466
 467 static int _pkginfo_get_packages(uid_t uid, const char *locale,
 468                 pkgmgrinfo_filter_x *filter, int flag, GHashTable *packages)
 469 {
 470         static const char query_raw[] =
 471                 "SELECT DISTINCT pi.package, pi.installed_storage, pi.external_path";
 472         static const char query_basic[] =
 473                 ", pi.package_version, pi.install_location, "
 474                 "pi.package_removable, pi.package_preload, pi.package_readonly, "
 475                 "pi.package_update, pi.package_appsetting, pi.package_system, "
 476                 "pi.package_type, pi.package_size, pi.installed_time, "
 477                 "pi.storeclient_id, pi.mainapp_id, pi.package_url, pi.root_path, "
 478                 "pi.csc_path, pi.package_nodisplay, pi.package_api_version, "
 479                 "pi.package_support_disable, pi.package_tep_name, "
 480                 "pi.package_zip_mount_file, pi.package_support_mode";
 481         static const char query_author[] =
 482                 ", pi.author_name, pi.author_email, pi.author_href";
 483         static const char query_label[] =
 484                 ", COALESCE("
 485                 "(SELECT package_label FROM package_localized_info WHERE pi.package=package AND package_locale=?), "
 486                 "(SELECT package_label FROM package_localized_info WHERE pi.package=package AND package_locale='No Locale'))";
 487         static const char query_icon[] =
 488                 ", COALESCE("
 489                 "(SELECT package_icon FROM package_localized_info WHERE pi.package=package AND package_locale=?), "
 490                 "(SELECT package_icon FROM package_localized_info WHERE pi.package=package AND package_locale='No Locale'))";
 491         static const char query_description[] =
 492                 ", COALESCE("
 493                 "(SELECT package_description FROM package_localized_info WHERE pi.package=package AND package_locale=?), "
 494                 "(SELECT package_description FROM package_localized_info WHERE pi.package=package AND package_locale='No Locale'))";
 495         static const char query_from_clause[] = " FROM package_info as pi";
 496         int ret = PMINFO_R_ERROR;
 497         int idx = 0;
 498         char *dbpath;
 499         char *tmp_record = NULL;
 500         char *constraints = NULL;
 501         char query[MAX_QUERY_LEN] = { '\0' };
 502         package_x *info = NULL;
 503         author_x *author = NULL;
 504         GList *bind_params = NULL;
 505         sqlite3 *db;
 506         sqlite3_stmt *stmt = NULL;
 507         pkgmgrinfo_filter_x *tmp_filter = NULL;
 508         bool is_check_storage = true;
 509         const uid_t global_user_uid = GLOBAL_USER;
 510
 511         dbpath = getUserPkgParserDBPathUID(uid);
 512         if (dbpath == NULL)
 513                 return PMINFO_R_ERROR;
 514
 515         ret = __open_db(dbpath, &db, SQLITE_OPEN_READONLY);
 516         if (ret != SQLITE_OK) {
 517                 _LOGD("failed to open db(%s): %d", dbpath, ret);
 518                 free(dbpath);
 519                 return PMINFO_R_ERROR;
 520         }
 521         free(dbpath);
 522
 523         if (filter != NULL) {
 524                 tmp_filter = filter;
 525         } else {
 526                 ret = pkgmgrinfo_pkginfo_filter_create((void *)&tmp_filter);
 527                 if (ret != PMINFO_R_OK) {
 528                         _LOGE("Failed to create filter");
 529                         return PMINFO_R_ERROR;
 530                 }
 531         }
 532
 533         is_check_storage = __check_package_storage_status(tmp_filter);
 534
 535         snprintf(query, MAX_QUERY_LEN - 1, "%s", query_raw);
 536         if (flag & PMINFO_APPINFO_GET_BASICINFO)
 537                 strncat(query, query_basic, sizeof(query) - strlen(query) - 1);
 538         if (flag & PMINFO_PKGINFO_GET_AUTHOR)
 539                 strncat(query, query_author, sizeof(query) - strlen(query) - 1);
 540         if (flag & PMINFO_PKGINFO_GET_LABEL) {
 541                 strncat(query, query_label, sizeof(query) - strlen(query) - 1);
 542                 bind_params = g_list_append(bind_params, strdup(locale));
 543         }
 544         if (flag & PMINFO_PKGINFO_GET_ICON) {
 545                 strncat(query, query_icon, sizeof(query) - strlen(query) - 1);
 546                 bind_params = g_list_append(bind_params, strdup(locale));
 547         }
 548         if (flag & PMINFO_PKGINFO_GET_DESCRIPTION) {
 549                 strncat(query, query_description, sizeof(query) - strlen(query) - 1);
 550                 bind_params = g_list_append(bind_params, strdup(locale));
 551         }
 552
 553         strncat(query, query_from_clause, sizeof(query) - strlen(query) - 1);
 554
 555         ret = _get_filtered_query(tmp_filter, locale, uid, &constraints, &bind_params);
 556         if (ret != PMINFO_R_OK) {
 557                 LOGE("Failed to get WHERE clause");
 558                 goto catch;
 559         }
 560
 561         if (constraints)
 562                 strncat(query, constraints, sizeof(query) - strlen(query) - 1);
 563
 564         ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
 565         if (ret != SQLITE_OK) {
 566                 LOGE("prepare failed: %s", sqlite3_errmsg(db));
 567                 ret = PMINFO_R_ERROR;
 568                 goto catch;
 569         }
 570
 571         ret = __bind_params(stmt, bind_params);
 572         if (ret != SQLITE_OK) {
 573                 LOGE("Failed to bind parameters");
 574                 goto catch;
 575         }
 576
 577         while (sqlite3_step(stmt) == SQLITE_ROW) {
 578                 info = calloc(1, sizeof(package_x));
 579                 if (info == NULL) {
 580                         LOGE("out of memory");
 581                         ret = PMINFO_R_ERROR;
 582                         goto catch;
 583                 }
 584                 idx = 0;
 585                 _save_column_str(stmt, idx++, &info->package);
 586                 _save_column_str(stmt, idx++, &info->installed_storage);
 587                 _save_column_str(stmt, idx++, &info->external_path);
 588
 589                 if (flag & PMINFO_APPINFO_GET_BASICINFO) {
 590                         _save_column_str(stmt, idx++, &info->version);
 591                         _save_column_str(stmt, idx++, &info->installlocation);
 592                         _save_column_str(stmt, idx++, &info->removable);
 593                         _save_column_str(stmt, idx++, &info->preload);
 594                         _save_column_str(stmt, idx++, &info->readonly);
 595                         _save_column_str(stmt, idx++, &info->update);
 596                         _save_column_str(stmt, idx++, &info->appsetting);
 597                         _save_column_str(stmt, idx++, &info->system);
 598                         _save_column_str(stmt, idx++, &info->type);
 599                         _save_column_str(stmt, idx++, &info->package_size);
 600                         _save_column_str(stmt, idx++, &info->installed_time);
 601                         _save_column_str(stmt, idx++, &info->storeclient_id);
 602                         _save_column_str(stmt, idx++, &info->mainapp_id);
 603                         _save_column_str(stmt, idx++, &info->package_url);
 604                         _save_column_str(stmt, idx++, &info->root_path);
 605                         _save_column_str(stmt, idx++, &info->csc_path);
 606                         _save_column_str(stmt, idx++, &info->nodisplay_setting);
 607                         _save_column_str(stmt, idx++, &info->api_version);
 608                         _save_column_str(stmt, idx++, &info->support_disable);
 609                         _save_column_str(stmt, idx++, &info->tep_name);
 610                         _save_column_str(stmt, idx++, &info->zip_mount_file);
 611                         _save_column_str(stmt, idx++, &info->support_mode);
 612                 }
 613
 614                 info->for_all_users =
 615                         strdup((uid != global_user_uid) ? "false" : "true");
 616
 617                 if (_pkginfo_get_plugin_execution_info(db, info->package, &info->plugin)) {
 618                         ret = PMINFO_R_ERROR;
 619                         goto catch;
 620                 }
 621
 622                 if (flag & PMINFO_PKGINFO_GET_AUTHOR) {
 623                         /* TODO : author should be retrieved at package_localized_info */
 624                         author = calloc(1, sizeof(author_x));
 625                         if (author == NULL) {
 626                                 ret = PMINFO_R_ERROR;
 627                                 goto catch;
 628                         }
 629                         _save_column_str(stmt, idx++, &author->text);
 630                         _save_column_str(stmt, idx++, &author->email);
 631                         _save_column_str(stmt, idx++, &author->href);
 632                         info->author = g_list_append(info->author, author);
 633                 }
 634
 635                 if (flag & PMINFO_PKGINFO_GET_LABEL) {
 636                         tmp_record = NULL;
 637                         _save_column_str(stmt, idx++, &tmp_record);
 638
 639                         if (_add_label_info_into_list(locale, tmp_record, &info->label)) {
 640                                 ret = PMINFO_R_ERROR;
 641                                 goto catch;
 642                         }
 643                 }
 644
 645                 if (flag & PMINFO_PKGINFO_GET_ICON) {
 646                         tmp_record = NULL;
 647                         _save_column_str(stmt, idx++, &tmp_record);
 648                         if (_add_icon_info_into_list(locale, tmp_record, &info->icon)) {
 649                                 ret = PMINFO_R_ERROR;
 650                                 goto catch;
 651                         }
 652                 }
 653
 654                 if (flag & PMINFO_PKGINFO_GET_DESCRIPTION) {
 655                         tmp_record = NULL;
 656                         _save_column_str(stmt, idx++, &tmp_record);
 657                         if (_pkginfo_add_description_info_into_list(locale, tmp_record,
 658                                         &info->description)) {
 659                                 ret = PMINFO_R_ERROR;
 660                                 goto catch;
 661                         }
 662                 }
 663
 664                 if (flag & PMINFO_PKGINFO_GET_PRIVILEGE) {
 665                         if (_pkginfo_get_privilege(db, info->package,
 666                                                 &info->privileges)) {
 667                                 ret = PMINFO_R_ERROR;
 668                                 goto catch;
 669                         }
 670                 }
 671
 672                 if (flag & PMINFO_PKGINFO_GET_APPDEFINED_PRIVILEGE) {
 673                         if (_pkginfo_get_appdefined_privilege(db, info->package,
 674                                                 &info->appdefined_privileges)) {
 675                                 ret = PMINFO_R_ERROR;
 676                                 goto catch;
 677                         }
 678                 }
 679
 680                 if (flag & PMINFO_PKGINFO_GET_DEPENDENCY) {
 681                         if (_pkginfo_get_dependency(db, info->package,
 682                                                 &info->dependencies)) {
 683                                 ret = PMINFO_R_ERROR;
 684                                 goto catch;
 685                         }
 686                 }
 687
 688                 if (is_check_storage &&
 689                                 __pkginfo_check_installed_storage(info) != PMINFO_R_OK) {
 690                         ret = PMINFO_R_ERROR;
 691                         pkgmgrinfo_basic_free_package(info);
 692                         info = NULL;
 693                         continue;
 694                 }
 695
 696                 g_hash_table_insert(packages, (gpointer)info->package,
 697                                 (gpointer)info);
 698         }
 699
 700         ret = PMINFO_R_OK;
 701
 702 catch:
 703         sqlite3_finalize(stmt);
 704         sqlite3_close_v2(db);
 705
 706         if (constraints)
 707                 free(constraints);
 708
 709         if (ret != PMINFO_R_OK && info != NULL)
 710                 pkgmgrinfo_basic_free_package(info);
 711
 712         if (filter == NULL)
 713                 pkgmgrinfo_pkginfo_filter_destroy(tmp_filter);
 714
 715         g_list_free_full(bind_params, free);
 716
 717         return ret;
 718 }
 719
 720 static int _pkginfo_get_filtered_foreach_pkginfo(uid_t uid,
 721                 pkgmgrinfo_filter_x *filter, int flag,
 722                 pkgmgrinfo_pkg_list_cb pkg_list_cb, void *user_data)
 723 {
 724         int ret;
 725         char *locale;
 726         package_x *pkg;
 727         pkgmgr_pkginfo_x info;
 728         pkgmgrinfo_filter_x *tmp_filter = NULL;
 729         GHashTable *list;
 730         GHashTableIter iter;
 731         gpointer value;
 732
 733         locale = _get_system_locale();
 734         if (locale == NULL)
 735                 return PMINFO_R_ERROR;
 736
 737         list = g_hash_table_new_full(g_str_hash, g_str_equal, NULL,
 738                         __free_packages);
 739         if (list == NULL) {
 740                 free(locale);
 741                 return PMINFO_R_ERROR;
 742         }
 743
 744         if (filter != NULL) {
 745                 tmp_filter = (pkgmgrinfo_filter_x *)filter;
 746         } else {
 747                 ret = pkgmgrinfo_pkginfo_filter_create((void *)&tmp_filter);
 748                 if (ret != PMINFO_R_OK) {
 749                         _LOGE("Failed to create filter");
 750                         g_hash_table_destroy(list);
 751                         free(locale);
 752                         return PMINFO_R_ERROR;
 753                 }
 754         }
 755
 756         if (__check_disable_filter_exist(tmp_filter) == false) {
 757                 ret = pkgmgrinfo_pkginfo_filter_add_bool(tmp_filter,
 758                                 PMINFO_PKGINFO_PROP_PACKAGE_DISABLE, false);
 759                 if (ret != PMINFO_R_OK) {
 760                         _LOGE("Failed to add filter");
 761                         g_hash_table_destroy(list);
 762                         free(locale);
 763                         if (filter == NULL)
 764                                 pkgmgrinfo_pkginfo_filter_destroy(tmp_filter);
 765                         return PMINFO_R_ERROR;
 766                 }
 767         }
 768
 769         ret = _pkginfo_get_packages(uid, locale, tmp_filter,
 770                         flag | PMINFO_PKGINFO_GET_BASICINFO, list);
 771         if (ret == PMINFO_R_OK && uid != GLOBAL_USER)
 772                 ret = _pkginfo_get_packages(GLOBAL_USER, locale, tmp_filter,
 773                                 flag | PMINFO_PKGINFO_GET_BASICINFO, list);
 774
 775         if (ret != PMINFO_R_OK) {
 776                 g_hash_table_destroy(list);
 777                 free(locale);
 778                 if (filter == NULL)
 779                         pkgmgrinfo_pkginfo_filter_destroy(tmp_filter);
 780                 return PMINFO_R_ERROR;
 781         }
 782
 783         g_hash_table_iter_init(&iter, list);
 784         while (g_hash_table_iter_next(&iter, NULL, &value)) {
 785                 pkg = (package_x *)value;
 786                 info.uid = uid;
 787                 info.pkg_info = pkg;
 788                 info.locale = locale;
 789                 if (pkg_list_cb(&info, user_data) < 0)
 790                         break;
 791         }
 792
 793         g_hash_table_destroy(list);
 794         free(locale);
 795
 796         if (filter == NULL)
 797                 pkgmgrinfo_pkginfo_filter_destroy(tmp_filter);
 798
 799         return PMINFO_R_OK;
 800 }
 801
 802 static int _pkgmgrinfo_get_pkginfo(const char *pkgid, uid_t uid,
 803         pkgmgrinfo_pkginfo_filter_h filter, pkgmgrinfo_pkginfo_h *handle)
 804 {
 805         int ret;
 806         char *locale;
 807         GHashTable *list;
 808         pkgmgr_pkginfo_x *info;
 809
 810         if (pkgid == NULL || filter == NULL || handle == NULL) {
 811                         LOGE("invalid parameter");
 812                         return PMINFO_R_EINVAL;
 813         }
 814
 815         locale = _get_system_locale();
 816         if (locale == NULL)
 817                 return PMINFO_R_ERROR;
 818
 819         list = g_hash_table_new_full(g_str_hash, g_str_equal, NULL,
 820                         __free_packages);
 821         if (list == NULL) {
 822                 free(locale);
 823                 return PMINFO_R_ERROR;
 824         }
 825
 826         ret = _pkginfo_get_packages(uid, locale, filter,
 827                         PMINFO_PKGINFO_GET_ALL, list);
 828         if (!g_hash_table_size(list) && uid != GLOBAL_USER)
 829                 ret = _pkginfo_get_packages(GLOBAL_USER, locale, filter,
 830                                 PMINFO_PKGINFO_GET_ALL, list);
 831
 832         if (ret != PMINFO_R_OK) {
 833                 g_hash_table_destroy(list);
 834                 free(locale);
 835                 return ret;
 836         }
 837
 838         if (!g_hash_table_size(list)) {
 839                 _LOGD("pkginfo for [%s] is not existed for user [%d]",
 840                                 pkgid, uid);
 841                 g_hash_table_destroy(list);
 842                 free(locale);
 843                 return PMINFO_R_ENOENT;
 844         }
 845
 846         info = calloc(1, sizeof(pkgmgr_pkginfo_x));
 847         if (info == NULL) {
 848                 _LOGE("out of memory");
 849                 g_hash_table_destroy(list);
 850                 free(locale);
 851                 return PMINFO_R_ERROR;
 852         }
 853
 854         info->uid = uid;
 855         info->pkg_info = (package_x *)g_hash_table_lookup(list, pkgid);
 856         info->locale = locale;
 857
 858         /* just free list only */
 859         g_hash_table_steal(list, (gconstpointer)pkgid);
 860         g_hash_table_destroy(list);
 861
 862         *handle = info;
 863
 864         return ret;
 865 }
 866
 867 API int pkgmgrinfo_pkginfo_get_usr_pkginfo(const char *pkgid, uid_t uid,
 868                 pkgmgrinfo_pkginfo_h *handle)
 869 {
 870         int ret;
 871         pkgmgrinfo_pkginfo_filter_h filter;
 872
 873         if (pkgid == NULL || handle == NULL) {
 874                 LOGE("invalid parameter");
 875                 return PMINFO_R_EINVAL;
 876         }
 877
 878         ret = pkgmgrinfo_pkginfo_filter_create(&filter);
 879         if (ret != PMINFO_R_OK)
 880                 return ret;
 881
 882         ret = pkgmgrinfo_pkginfo_filter_add_string(filter,
 883                         PMINFO_PKGINFO_PROP_PACKAGE_ID, pkgid);
 884         if (ret != PMINFO_R_OK) {
 885                 pkgmgrinfo_pkginfo_filter_destroy(filter);
 886                 return PMINFO_R_ERROR;
 887         }
 888
 889         ret = pkgmgrinfo_pkginfo_filter_add_bool(filter,
 890                         PMINFO_PKGINFO_PROP_PACKAGE_DISABLE, false);
 891         if (ret != PMINFO_R_OK) {
 892                 pkgmgrinfo_pkginfo_filter_destroy(filter);
 893                 return PMINFO_R_ERROR;
 894         }
 895
 896         ret = _pkgmgrinfo_get_pkginfo(pkgid, uid, filter, handle);
 897         pkgmgrinfo_pkginfo_filter_destroy(filter);
 898
 899         return ret;
 900 }
 901
 902 API int pkgmgrinfo_pkginfo_get_pkginfo(const char *pkgid,
 903                 pkgmgrinfo_pkginfo_h *handle)
 904 {
 905         return pkgmgrinfo_pkginfo_get_usr_pkginfo(pkgid, _getuid(), handle);
 906 }
 907
 908 API int pkgmgrinfo_pkginfo_get_usr_disabled_pkginfo(const char *pkgid,
 909                 uid_t uid, pkgmgrinfo_pkginfo_h *handle)
 910 {
 911         int ret;
 912         char *locale;
 913         GHashTable *list;
 914         pkgmgrinfo_pkginfo_filter_h filter;
 915         pkgmgr_pkginfo_x *info;
 916
 917         if (pkgid == NULL || handle == NULL) {
 918                 LOGE("invalid parameter");
 919                 return PMINFO_R_EINVAL;
 920         }
 921
 922         locale = _get_system_locale();
 923         if (locale == NULL)
 924                 return PMINFO_R_ERROR;
 925
 926         ret = pkgmgrinfo_pkginfo_filter_create(&filter);
 927         if (ret != PMINFO_R_OK) {
 928                 free(locale);
 929                 return ret;
 930         }
 931
 932         ret = pkgmgrinfo_pkginfo_filter_add_string(filter,
 933                         PMINFO_PKGINFO_PROP_PACKAGE_ID, pkgid);
 934         if (ret != PMINFO_R_OK) {
 935                 pkgmgrinfo_pkginfo_filter_destroy(filter);
 936                 free(locale);
 937                 return PMINFO_R_ERROR;
 938         }
 939
 940         ret = pkgmgrinfo_pkginfo_filter_add_bool(filter,
 941                         PMINFO_PKGINFO_PROP_PACKAGE_DISABLE, true);
 942         if (ret != PMINFO_R_OK) {
 943                 pkgmgrinfo_pkginfo_filter_destroy(filter);
 944                 free(locale);
 945                 return PMINFO_R_ERROR;
 946         }
 947
 948         list = g_hash_table_new_full(g_str_hash, g_str_equal, NULL,
 949                         __free_packages);
 950         if (list == NULL) {
 951                 pkgmgrinfo_pkginfo_filter_destroy(filter);
 952                 free(locale);
 953                 return PMINFO_R_ERROR;
 954         }
 955
 956         ret = _pkginfo_get_packages(uid, locale, filter,
 957                         PMINFO_PKGINFO_GET_ALL, list);
 958         if (!g_hash_table_size(list) && uid != GLOBAL_USER)
 959                 ret = _pkginfo_get_packages(GLOBAL_USER, locale, filter,
 960                                 PMINFO_PKGINFO_GET_ALL, list);
 961
 962         pkgmgrinfo_pkginfo_filter_destroy(filter);
 963         if (ret != PMINFO_R_OK) {
 964                 g_hash_table_destroy(list);
 965                 free(locale);
 966                 return ret;
 967         }
 968
 969         if (!g_hash_table_size(list)) {
 970                 _LOGD("disabled pkginfo for [%s] is not existed for user [%d]",
 971                                 pkgid, uid);
 972                 g_hash_table_destroy(list);
 973                 free(locale);
 974                 return PMINFO_R_ENOENT;
 975         }
 976
 977         info = calloc(1, sizeof(pkgmgr_pkginfo_x));
 978         if (info == NULL) {
 979                 _LOGE("out of memory");
 980                 g_hash_table_destroy(list);
 981                 free(locale);
 982                 return PMINFO_R_ERROR;
 983         }
 984
 985         info->uid = uid;
 986         info->pkg_info = (package_x *)g_hash_table_lookup(list, pkgid);
 987         info->locale = locale;
 988
 989         /* just free list only */
 990         g_hash_table_steal(list, (gconstpointer)pkgid);
 991         g_hash_table_destroy(list);
 992
 993         *handle = info;
 994
 995         return ret;
 996 }
 997
 998 API int pkgmgrinfo_pkginfo_get_usr_all_pkginfo(const char *pkgid, uid_t uid,
 999                 pkgmgrinfo_pkginfo_h *handle)
1000 {
1001
1002         int ret;
1003         pkgmgrinfo_pkginfo_filter_h filter;
1004
1005         if (pkgid == NULL || handle == NULL) {
1006                 LOGE("invalid parameter");
1007                 return PMINFO_R_EINVAL;
1008         }
1009
1010         ret = pkgmgrinfo_pkginfo_filter_create(&filter);
1011         if (ret != PMINFO_R_OK)
1012                 return ret;
1013
1014         ret = pkgmgrinfo_pkginfo_filter_add_string(filter,
1015                         PMINFO_PKGINFO_PROP_PACKAGE_ID, pkgid);
1016         if (ret != PMINFO_R_OK) {
1017                 pkgmgrinfo_pkginfo_filter_destroy(filter);
1018                 return PMINFO_R_ERROR;
1019         }
1020
1021         ret = pkgmgrinfo_pkginfo_filter_add_bool(filter,
1022                         PMINFO_PKGINFO_PROP_PACKAGE_CHECK_STORAGE, false);
1023         if (ret != PMINFO_R_OK) {
1024                 pkgmgrinfo_pkginfo_filter_destroy(filter);
1025                 return PMINFO_R_ERROR;
1026         }
1027
1028         ret = _pkgmgrinfo_get_pkginfo(pkgid, uid, filter, handle);
1029         pkgmgrinfo_pkginfo_filter_destroy(filter);
1030
1031         return ret;
1032 }
1033
1034 API int pkgmgrinfo_pkginfo_get_disabled_pkginfo(const char *pkgid,
1035                 pkgmgrinfo_pkginfo_h *handle)
1036 {
1037         return pkgmgrinfo_pkginfo_get_usr_disabled_pkginfo(pkgid, _getuid(),
1038                         handle);
1039 }
1040
1041 API int pkgmgrinfo_pkginfo_get_all_pkginfo(const char *pkgid,
1042                 pkgmgrinfo_pkginfo_h *handle)
1043 {
1044         return pkgmgrinfo_pkginfo_get_usr_all_pkginfo(pkgid, _getuid(), handle);
1045 }
1046
1047 API int pkgmgrinfo_pkginfo_get_usr_list_full(pkgmgrinfo_pkg_list_cb pkg_list_cb,
1048                 int flag, void *user_data, uid_t uid)
1049 {
1050         int ret;
1051         pkgmgrinfo_pkginfo_filter_h filter;
1052
1053         if (pkg_list_cb == NULL) {
1054                 LOGE("invalid parameter");
1055                 return PMINFO_R_EINVAL;
1056         }
1057
1058         /* create an empty filter */
1059         ret = pkgmgrinfo_pkginfo_filter_create(&filter);
1060         if (ret != PMINFO_R_OK)
1061                 return ret;
1062
1063         ret = _pkginfo_get_filtered_foreach_pkginfo(uid, filter, flag,
1064                         pkg_list_cb, user_data);
1065
1066         pkgmgrinfo_pkginfo_filter_destroy(filter);
1067
1068         return ret;
1069 }
1070
1071 API int pkgmgrinfo_pkginfo_get_list_full(pkgmgrinfo_pkg_list_cb pkg_list_cb,
1072                 int flag, void *user_data)
1073 {
1074         return pkgmgrinfo_pkginfo_get_usr_list_full(pkg_list_cb, flag,
1075                         user_data, _getuid());
1076 }
1077
1078 API int pkgmgrinfo_pkginfo_get_usr_list(pkgmgrinfo_pkg_list_cb pkg_list_cb,
1079                 void *user_data, uid_t uid)
1080 {
1081         int ret;
1082         pkgmgrinfo_pkginfo_filter_h filter;
1083
1084         if (pkg_list_cb == NULL) {
1085                 LOGE("invalid parameter");
1086                 return PMINFO_R_EINVAL;
1087         }
1088
1089         /* create an empty filter */
1090         ret = pkgmgrinfo_pkginfo_filter_create(&filter);
1091         if (ret != PMINFO_R_OK)
1092                 return ret;
1093
1094         ret = _pkginfo_get_filtered_foreach_pkginfo(uid, filter,
1095                         PMINFO_PKGINFO_GET_ALL, pkg_list_cb, user_data);
1096
1097         pkgmgrinfo_pkginfo_filter_destroy(filter);
1098
1099         return ret;
1100 }
1101
1102 API int pkgmgrinfo_pkginfo_get_list(pkgmgrinfo_pkg_list_cb pkg_list_cb,
1103                 void *user_data)
1104 {
1105         return pkgmgrinfo_pkginfo_get_usr_list(pkg_list_cb, user_data,
1106                         _getuid());
1107 }
1108
1109 API int pkgmgrinfo_pkginfo_get_usr_disabled_list(
1110                 pkgmgrinfo_pkg_list_cb pkg_list_cb, void *user_data, uid_t uid)
1111 {
1112         int ret;
1113         pkgmgrinfo_pkginfo_filter_h filter;
1114
1115         if (pkg_list_cb == NULL) {
1116                 LOGE("invalid parameter");
1117                 return PMINFO_R_EINVAL;
1118         }
1119
1120         ret = pkgmgrinfo_pkginfo_filter_create(&filter);
1121         if (ret != PMINFO_R_OK)
1122                 return ret;
1123
1124         ret = pkgmgrinfo_pkginfo_filter_add_bool(filter,
1125                         PMINFO_PKGINFO_PROP_PACKAGE_DISABLE, true);
1126         if (ret != PMINFO_R_OK) {
1127                 pkgmgrinfo_pkginfo_filter_destroy(filter);
1128                 return PMINFO_R_ERROR;
1129         }
1130
1131         ret = _pkginfo_get_filtered_foreach_pkginfo(uid, filter,
1132                         PMINFO_PKGINFO_GET_ALL, pkg_list_cb, user_data);
1133
1134         pkgmgrinfo_pkginfo_filter_destroy(filter);
1135
1136         return ret;
1137 }
1138
1139 API int pkgmgrinfo_pkginfo_get_disabled_list(pkgmgrinfo_pkg_list_cb pkg_list_cb,
1140                 void *user_data)
1141 {
1142         return pkgmgrinfo_pkginfo_get_usr_disabled_list(pkg_list_cb, user_data,
1143                         _getuid());
1144 }
1145
1146 API int pkgmgrinfo_pkginfo_get_pkgname(pkgmgrinfo_pkginfo_h handle, char **pkg_name)
1147 {
1148         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1149
1150         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1151         retvm_if(pkg_name == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1152
1153         if (info->pkg_info == NULL || info->pkg_info->package == NULL)
1154                 return PMINFO_R_ERROR;
1155
1156         *pkg_name = (char *)info->pkg_info->package;
1157
1158         return PMINFO_R_OK;
1159 }
1160
1161 API int pkgmgrinfo_pkginfo_get_pkgid(pkgmgrinfo_pkginfo_h handle, char **pkgid)
1162 {
1163         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1164
1165         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1166         retvm_if(pkgid == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1167
1168         if (info->pkg_info == NULL || info->pkg_info->package == NULL)
1169                 return PMINFO_R_ERROR;
1170
1171         *pkgid = (char *)info->pkg_info->package;
1172
1173         return PMINFO_R_OK;
1174 }
1175
1176 API int pkgmgrinfo_pkginfo_get_type(pkgmgrinfo_pkginfo_h handle, char **type)
1177 {
1178         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1179
1180         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1181         retvm_if(type == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1182
1183         if (info->pkg_info == NULL)
1184                 return PMINFO_R_ERROR;
1185
1186         if (info->pkg_info->type == NULL)
1187                 *type = "";
1188         else
1189                 *type = (char *)info->pkg_info->type;
1190
1191         return PMINFO_R_OK;
1192 }
1193
1194 API int pkgmgrinfo_pkginfo_get_version(pkgmgrinfo_pkginfo_h handle, char **version)
1195 {
1196         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1197
1198         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1199         retvm_if(version == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1200
1201         if (info->pkg_info == NULL)
1202                 return PMINFO_R_ERROR;
1203
1204         if (info->pkg_info->version == NULL)
1205                 *version = "";
1206         else
1207                 *version = (char *)info->pkg_info->version;
1208
1209         return PMINFO_R_OK;
1210 }
1211
1212 API int pkgmgrinfo_pkginfo_get_api_version(pkgmgrinfo_pkginfo_h handle, char **api_version)
1213 {
1214         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1215
1216         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1217         retvm_if(api_version == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1218
1219         if (info->pkg_info == NULL)
1220                 return PMINFO_R_ERROR;
1221
1222         if (info->pkg_info->api_version == NULL)
1223                 *api_version = "";
1224         else
1225                 *api_version = (char *)info->pkg_info->api_version;
1226
1227         return PMINFO_R_OK;
1228 }
1229
1230 API int pkgmgrinfo_pkginfo_get_tep_name(pkgmgrinfo_pkginfo_h handle, char **tep_name)
1231 {
1232         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1233
1234         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1235         retvm_if(tep_name == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1236
1237         if (info->pkg_info == NULL || info->pkg_info->tep_name == NULL)
1238                 return PMINFO_R_ERROR;
1239
1240         *tep_name = (char *)info->pkg_info->tep_name;
1241
1242         return PMINFO_R_OK;
1243 }
1244
1245 API int pkgmgrinfo_pkginfo_get_zip_mount_file(pkgmgrinfo_pkginfo_h handle, char **zip_mount_file)
1246 {
1247         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1248
1249         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1250         retvm_if(zip_mount_file == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1251
1252         if (info->pkg_info == NULL)
1253                 return PMINFO_R_ERROR;
1254
1255         if (info->pkg_info->zip_mount_file == NULL)
1256                 *zip_mount_file = "";
1257         else
1258                 *zip_mount_file = (char *)info->pkg_info->zip_mount_file;
1259
1260         return PMINFO_R_OK;
1261 }
1262
1263 API int pkgmgrinfo_pkginfo_get_external_image_path(pkgmgrinfo_pkginfo_h handle, char **ext_image_path)
1264 {
1265         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1266
1267         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1268         retvm_if(ext_image_path == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1269
1270         if (info->pkg_info == NULL)
1271                 return PMINFO_R_ERROR;
1272
1273         if (info->pkg_info->external_path == NULL)
1274                 return PMINFO_R_ENOENT;
1275
1276         *ext_image_path = (char *)info->pkg_info->external_path;
1277
1278         return PMINFO_R_OK;
1279 }
1280
1281 API int pkgmgrinfo_pkginfo_get_install_location(pkgmgrinfo_pkginfo_h handle, pkgmgrinfo_install_location *location)
1282 {
1283         char *val;
1284         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1285
1286         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1287         retvm_if(location == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1288
1289         if (info->pkg_info == NULL || info->pkg_info->installlocation == NULL)
1290                 return PMINFO_R_ERROR;
1291
1292         val = (char *)info->pkg_info->installlocation;
1293         if (strcmp(val, "internal-only") == 0)
1294                 *location = PMINFO_INSTALL_LOCATION_INTERNAL_ONLY;
1295         else if (strcmp(val, "prefer-external") == 0)
1296                 *location = PMINFO_INSTALL_LOCATION_PREFER_EXTERNAL;
1297         else
1298                 *location = PMINFO_INSTALL_LOCATION_AUTO;
1299
1300         return PMINFO_R_OK;
1301 }
1302
1303 API int pkgmgrinfo_pkginfo_get_package_size(pkgmgrinfo_pkginfo_h handle, int *size)
1304 {
1305         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1306         char *temp = NULL;
1307
1308         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1309         retvm_if(size == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1310
1311         if (info->pkg_info == NULL)
1312                 return PMINFO_R_ERROR;
1313
1314         if (info->pkg_info->package_size == NULL) {
1315                 temp = strdup("");
1316                 if (temp == NULL) {
1317                         _LOGE("out of memory");
1318                         return PMINFO_R_ERROR;
1319                 } else {
1320                         info->pkg_info->package_size = temp;
1321                 }
1322         }
1323
1324         *size = atoi((char *)info->pkg_info->package_size);
1325
1326         return PMINFO_R_OK;
1327 }
1328
1329 API int pkgmgrinfo_pkginfo_get_icon(pkgmgrinfo_pkginfo_h handle, char **icon)
1330 {
1331         icon_x *ptr;
1332         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1333
1334         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL");
1335         retvm_if(icon == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL");
1336
1337         if (info->pkg_info == NULL || info->pkg_info->icon == NULL)
1338                 return PMINFO_R_ERROR;
1339
1340         ptr = (icon_x *)info->pkg_info->icon->data;
1341         if (ptr == NULL)
1342                 return PMINFO_R_ERROR;
1343
1344         /* TODO : should we return empty string if there was no icon? */
1345         if (ptr->text == NULL)
1346                 *icon = "";
1347         else
1348                 *icon = ptr->text;
1349
1350         return PMINFO_R_OK;
1351 }
1352
1353 API int pkgmgrinfo_pkginfo_get_label(pkgmgrinfo_pkginfo_h handle, char **label)
1354 {
1355         label_x *ptr;
1356         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1357
1358         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL");
1359         retvm_if(label == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL");
1360
1361         if (info->pkg_info == NULL || info->pkg_info->label == NULL)
1362                 return PMINFO_R_ERROR;
1363
1364         ptr = (label_x *)info->pkg_info->label->data;
1365         if (ptr == NULL)
1366                 return PMINFO_R_ERROR;
1367
1368         /* TODO : should we return empty string if there was no label? */
1369         if (ptr->text == NULL)
1370                 *label = "";
1371         else
1372                 *label = ptr->text;
1373
1374         return PMINFO_R_OK;
1375 }
1376
1377 API int pkgmgrinfo_pkginfo_get_description(pkgmgrinfo_pkginfo_h handle, char **description)
1378 {
1379         description_x *ptr;
1380         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1381
1382         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1383         retvm_if(description == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1384
1385         if (info->pkg_info == NULL || info->pkg_info->description == NULL)
1386                 return PMINFO_R_ERROR;
1387
1388         ptr = (description_x *)info->pkg_info->description->data;
1389         if (ptr == NULL)
1390                 return PMINFO_R_ERROR;
1391
1392         if (ptr->text == NULL)
1393                 *description = "";
1394         else
1395                 *description = (char *)ptr->text;
1396
1397         return PMINFO_R_OK;
1398 }
1399
1400 API int pkgmgrinfo_pkginfo_get_author_name(pkgmgrinfo_pkginfo_h handle, char **author_name)
1401 {
1402         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1403         author_x *author;
1404
1405         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1406         retvm_if(author_name == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1407
1408         if (info->pkg_info == NULL || info->pkg_info->author == NULL)
1409                 return PMINFO_R_ERROR;
1410
1411         author = (author_x *)info->pkg_info->author->data;
1412         if (author == NULL)
1413                 return PMINFO_R_ERROR;
1414
1415         if (author->text == NULL)
1416                 *author_name = "";
1417         else
1418                 *author_name = (char *)author->text;
1419
1420         return PMINFO_R_OK;
1421 }
1422
1423 API int pkgmgrinfo_pkginfo_get_author_email(pkgmgrinfo_pkginfo_h handle, char **author_email)
1424 {
1425         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1426         author_x *author;
1427
1428         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1429         retvm_if(author_email == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1430
1431         if (info->pkg_info == NULL || info->pkg_info->author == NULL)
1432                 return PMINFO_R_ERROR;
1433
1434         author = (author_x *)info->pkg_info->author->data;
1435         if (author == NULL)
1436                 return PMINFO_R_ERROR;
1437
1438         if (author->email == NULL)
1439                 *author_email = "";
1440         else
1441                 *author_email = (char *)author->email;
1442
1443         return PMINFO_R_OK;
1444 }
1445
1446 API int pkgmgrinfo_pkginfo_get_author_href(pkgmgrinfo_pkginfo_h handle, char **author_href)
1447 {
1448         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1449         author_x *author;
1450
1451         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1452         retvm_if(author_href == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1453
1454         if (info->pkg_info == NULL || info->pkg_info->author == NULL)
1455                 return PMINFO_R_ERROR;
1456
1457         author = (author_x *)info->pkg_info->author->data;
1458         if (author == NULL)
1459                 return PMINFO_R_ERROR;
1460
1461         if (author->href == NULL)
1462                 *author_href = "";
1463         else
1464                 *author_href = (char *)author->href;
1465
1466         return PMINFO_R_OK;
1467 }
1468
1469 API int pkgmgrinfo_pkginfo_get_installed_storage(pkgmgrinfo_pkginfo_h handle, pkgmgrinfo_installed_storage *storage)
1470 {
1471         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1472
1473         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1474         retvm_if(storage == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1475
1476         if (info->pkg_info == NULL || info->pkg_info->installed_storage == NULL)
1477                 return PMINFO_R_ERROR;
1478
1479         if (strcmp(info->pkg_info->installed_storage, "installed_internal") == 0)
1480                 *storage = PMINFO_INTERNAL_STORAGE;
1481         else if (strcmp(info->pkg_info->installed_storage, "installed_external") == 0)
1482                 *storage = PMINFO_EXTERNAL_STORAGE;
1483         else if (strcmp(info->pkg_info->installed_storage, "installed_extended") == 0)
1484                 *storage = PMINFO_EXTENDED_STORAGE;
1485         else
1486                 return PMINFO_R_ERROR;
1487
1488         return PMINFO_R_OK;
1489 }
1490
1491 API int pkgmgrinfo_pkginfo_get_installed_time(pkgmgrinfo_pkginfo_h handle, int *installed_time)
1492 {
1493         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1494
1495         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1496         retvm_if(installed_time == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1497
1498         if (info->pkg_info == NULL || info->pkg_info->installed_time == NULL)
1499                 return PMINFO_R_ERROR;
1500
1501         *installed_time = atoi(info->pkg_info->installed_time);
1502
1503         return PMINFO_R_OK;
1504 }
1505
1506 API int pkgmgrinfo_pkginfo_get_storeclientid(pkgmgrinfo_pkginfo_h handle, char **storeclientid)
1507 {
1508         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1509
1510         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1511         retvm_if(storeclientid == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1512
1513         if (info->pkg_info == NULL)
1514                 return PMINFO_R_ERROR;
1515
1516         if (info->pkg_info->storeclient_id == NULL)
1517                 *storeclientid = "";
1518         else
1519                 *storeclientid = (char *)info->pkg_info->storeclient_id;
1520
1521         return PMINFO_R_OK;
1522 }
1523
1524 API int pkgmgrinfo_pkginfo_get_mainappid(pkgmgrinfo_pkginfo_h handle, char **mainappid)
1525 {
1526         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1527
1528         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1529         retvm_if(mainappid == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1530
1531         if (info->pkg_info == NULL || info->pkg_info->mainapp_id == NULL)
1532                 return PMINFO_R_ERROR;
1533
1534         *mainappid = (char *)info->pkg_info->mainapp_id;
1535
1536         return PMINFO_R_OK;
1537 }
1538
1539 API int pkgmgrinfo_pkginfo_get_url(pkgmgrinfo_pkginfo_h handle, char **url)
1540 {
1541         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1542
1543         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1544         retvm_if(url == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1545
1546         if (info->pkg_info == NULL)
1547                 return PMINFO_R_ERROR;
1548
1549         if (info->pkg_info->package_url == NULL)
1550                 *url = "";
1551         else
1552                 *url = (char *)info->pkg_info->package_url;
1553
1554         return PMINFO_R_OK;
1555 }
1556
1557 API int pkgmgrinfo_pkginfo_get_root_path(pkgmgrinfo_pkginfo_h handle, char **path)
1558 {
1559         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1560
1561         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1562         retvm_if(path == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1563
1564         if (info->pkg_info == NULL || info->pkg_info->root_path == NULL)
1565                 return PMINFO_R_ERROR;
1566
1567         *path = (char *)info->pkg_info->root_path;
1568
1569         return PMINFO_R_OK;
1570 }
1571
1572 API int pkgmgrinfo_pkginfo_get_csc_path(pkgmgrinfo_pkginfo_h handle, char **path)
1573 {
1574         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1575
1576         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1577         retvm_if(path == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1578
1579         if (info->pkg_info == NULL)
1580                 return PMINFO_R_ERROR;
1581
1582         if (info->pkg_info->csc_path == NULL)
1583                 *path = "";
1584         else
1585                 *path = (char *)info->pkg_info->csc_path;
1586
1587         return PMINFO_R_OK;
1588 }
1589
1590 API int pkgmgrinfo_pkginfo_get_support_mode(pkgmgrinfo_pkginfo_h handle, int *support_mode)
1591 {
1592         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1593         retvm_if(support_mode == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1594
1595         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1596         if (info->pkg_info->support_mode)
1597                 *support_mode = atoi(info->pkg_info->support_mode);
1598         else
1599                 *support_mode = 0;
1600
1601         return PMINFO_R_OK;
1602 }
1603
1604 API int pkgmgrinfo_pkginfo_is_accessible(pkgmgrinfo_pkginfo_h handle, bool *accessible)
1605 {
1606         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1607         retvm_if(accessible == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1608
1609 #if 0 /* smack issue occured, check later */
1610         char *pkgid = NULL;
1611         pkgmgrinfo_pkginfo_get_pkgid(handle, &pkgid);
1612         if (pkgid == NULL) {
1613                  _LOGD("invalid func parameters\n");
1614                  return PMINFO_R_ERROR;
1615         }
1616          _LOGD("pkgmgr_get_pkg_external_validation() called\n");
1617
1618         FILE *fp = NULL;
1619         char app_mmc_path[FILENAME_MAX] = { 0, };
1620         char app_dir_path[FILENAME_MAX] = { 0, };
1621         char app_mmc_internal_path[FILENAME_MAX] = { 0, };
1622         snprintf(app_dir_path, FILENAME_MAX, "%s%s", PKG_INSTALLATION_PATH, pkgid);
1623         snprintf(app_mmc_path, FILENAME_MAX, "%s%s", PKG_SD_PATH, pkgid);
1624         snprintf(app_mmc_internal_path, FILENAME_MAX, "%s%s/.mmc", PKG_INSTALLATION_PATH, pkgid);
1625
1626         /*check whether application is in external memory or not */
1627         fp = fopen(app_mmc_path, "r");
1628         if (fp == NULL) {
1629                 _LOGD(" app path in external memory not accesible\n");
1630         } else {
1631                 fclose(fp);
1632                 fp = NULL;
1633                 *accessible = 1;
1634                 _LOGD("pkgmgr_get_pkg_external_validation() : SD_CARD \n");
1635                 return PMINFO_R_OK;
1636         }
1637
1638         /*check whether application is in internal or not */
1639         if (fp == NULL) {
1640                 _LOGD(" app path in internal memory not accesible\n");
1641                 *accessible = 0;
1642                 return PMINFO_R_ERROR;
1643         } else {
1644                 fclose(fp);
1645                 /*check whether the application is installed in SD card
1646                 but SD card is not present*/
1647                 fp = fopen(app_mmc_internal_path, "r");
1648                 if (fp == NULL) {
1649                         *accessible = 1;
1650                         _LOGD("pkgmgr_get_pkg_external_validation() : INTERNAL_MEM \n");
1651                         return PMINFO_R_OK;
1652                 } else {
1653                         *accessible = 0;
1654                         _LOGD("pkgmgr_get_pkg_external_validation() : ERROR_MMC_STATUS \n");
1655                 }
1656                 fclose(fp);
1657         }
1658
1659         _LOGD("pkgmgr_get_pkg_external_validation() end\n");
1660 #endif
1661
1662         *accessible = 1;
1663         return PMINFO_R_OK;
1664 }
1665
1666 API int pkgmgrinfo_pkginfo_is_removable(pkgmgrinfo_pkginfo_h handle, bool *removable)
1667 {
1668         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1669
1670         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1671         retvm_if(removable == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1672
1673         if (info->pkg_info == NULL || info->pkg_info->removable == NULL)
1674                 return PMINFO_R_ERROR;
1675
1676         *removable = _get_bool_value(info->pkg_info->removable);
1677
1678         return PMINFO_R_OK;
1679 }
1680
1681 API int pkgmgrinfo_pkginfo_is_movable(pkgmgrinfo_pkginfo_h handle, bool *movable)
1682 {
1683         char *val;
1684         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1685
1686         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1687         retvm_if(movable == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1688
1689         if (info->pkg_info == NULL || info->pkg_info->installlocation == NULL)
1690                 return PMINFO_R_ERROR;
1691
1692         val = (char *)info->pkg_info->installlocation;
1693         if (strcmp(val, "internal-only") == 0)
1694                 *movable = 0;
1695         else
1696                 *movable = 1;
1697
1698         return PMINFO_R_OK;
1699 }
1700
1701 API int pkgmgrinfo_pkginfo_is_preload(pkgmgrinfo_pkginfo_h handle, bool *preload)
1702 {
1703         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1704
1705         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1706         retvm_if(preload == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1707
1708         if (info->pkg_info == NULL || info->pkg_info->preload == NULL)
1709                 return PMINFO_R_ERROR;
1710
1711         *preload = _get_bool_value(info->pkg_info->preload);
1712
1713         return PMINFO_R_OK;
1714 }
1715
1716 API int pkgmgrinfo_pkginfo_is_system(pkgmgrinfo_pkginfo_h handle, bool *system)
1717 {
1718         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1719
1720         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1721         retvm_if(system == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1722
1723         if (info->pkg_info == NULL || info->pkg_info->system == NULL)
1724                 return PMINFO_R_ERROR;
1725
1726         *system = _get_bool_value(info->pkg_info->system);
1727
1728         return PMINFO_R_OK;
1729 }
1730
1731 API int pkgmgrinfo_pkginfo_is_readonly(pkgmgrinfo_pkginfo_h handle, bool *readonly)
1732 {
1733         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1734
1735         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1736         retvm_if(readonly == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1737
1738         if (info->pkg_info == NULL || info->pkg_info->readonly == NULL)
1739                 return PMINFO_R_ERROR;
1740
1741         *readonly = _get_bool_value(info->pkg_info->readonly);
1742
1743         return PMINFO_R_OK;
1744 }
1745
1746 API int pkgmgrinfo_pkginfo_is_update(pkgmgrinfo_pkginfo_h handle, bool *update)
1747 {
1748         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1749
1750         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1751         retvm_if(update == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1752
1753         if (info->pkg_info == NULL || info->pkg_info->update == NULL)
1754                 return PMINFO_R_ERROR;
1755
1756         *update = _get_bool_value(info->pkg_info->update);
1757
1758         return PMINFO_R_OK;
1759 }
1760
1761 API int pkgmgrinfo_pkginfo_is_support_disable(pkgmgrinfo_pkginfo_h handle, bool *support_disable)
1762 {
1763         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1764
1765         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1766         retvm_if(support_disable == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1767
1768         if (info->pkg_info == NULL || info->pkg_info->support_disable == NULL)
1769                 return PMINFO_R_ERROR;
1770
1771         *support_disable = _get_bool_value(info->pkg_info->support_disable);
1772
1773         return PMINFO_R_OK;
1774 }
1775
1776 API int pkgmgrinfo_pkginfo_is_global(pkgmgrinfo_pkginfo_h handle, bool *global)
1777 {
1778         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1779
1780         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1781         retvm_if(global == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1782
1783         if (info->pkg_info == NULL || info->pkg_info->for_all_users == NULL)
1784                 return PMINFO_R_ERROR;
1785
1786         *global = _get_bool_value(info->pkg_info->for_all_users);
1787
1788         return PMINFO_R_OK;
1789 }
1790
1791 API int pkgmgrinfo_pkginfo_is_for_all_users(pkgmgrinfo_pkginfo_h handle, bool *for_all_users)
1792 {
1793         return pkgmgrinfo_pkginfo_is_global(handle, for_all_users);
1794 }
1795
1796 API int pkgmgrinfo_pkginfo_destroy_pkginfo(pkgmgrinfo_pkginfo_h handle)
1797 {
1798         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1799
1800         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1801
1802         __cleanup_pkginfo(info);
1803
1804         return PMINFO_R_OK;
1805 }
1806
1807 API int pkgmgrinfo_pkginfo_filter_create(pkgmgrinfo_pkginfo_filter_h *handle)
1808 {
1809         pkgmgrinfo_filter_x *filter;
1810
1811         retvm_if(handle == NULL, PMINFO_R_EINVAL, "Filter handle output parameter is NULL\n");
1812
1813         filter = (pkgmgrinfo_filter_x *)calloc(1, sizeof(pkgmgrinfo_filter_x));
1814         if (filter == NULL) {
1815                 _LOGE("Out of Memory!!!");
1816                 return PMINFO_R_ERROR;
1817         }
1818
1819         *handle = filter;
1820
1821         return PMINFO_R_OK;
1822 }
1823
1824 API int pkgmgrinfo_pkginfo_filter_destroy(pkgmgrinfo_pkginfo_filter_h handle)
1825 {
1826         pkgmgrinfo_filter_x *filter = (pkgmgrinfo_filter_x *)handle;
1827
1828         retvm_if(handle == NULL, PMINFO_R_EINVAL, "Filter handle input parameter is NULL\n");
1829
1830         if (filter->list) {
1831                 g_slist_foreach(filter->list, __destroy_each_node, NULL);
1832                 g_slist_free(filter->list);
1833         }
1834
1835         g_slist_free_full(filter->list_metadata, __destroy_metadata_node);
1836
1837         free(filter);
1838
1839         return PMINFO_R_OK;
1840 }
1841
1842 API int pkgmgrinfo_pkginfo_filter_add_int(pkgmgrinfo_pkginfo_filter_h handle,
1843                                 const char *property, const int value)
1844 {
1845         char buf[PKG_VALUE_STRING_LEN_MAX] = {'\0'};
1846         char *val;
1847         GSList *link;
1848         int prop;
1849         pkgmgrinfo_filter_x *filter = (pkgmgrinfo_filter_x *)handle;
1850         pkgmgrinfo_node_x *node;
1851
1852         retvm_if(handle == NULL, PMINFO_R_EINVAL, "Filter handle input parameter is NULL\n");
1853         retvm_if(property == NULL, PMINFO_R_EINVAL, "Filter handle input parameter is NULL\n");
1854
1855         prop = _pminfo_pkginfo_convert_to_prop_int(property);
1856         if (prop < E_PMINFO_PKGINFO_PROP_PACKAGE_MIN_INT ||
1857                 prop > E_PMINFO_PKGINFO_PROP_PACKAGE_MAX_INT) {
1858                 _LOGE("Invalid Integer Property\n");
1859                 return PMINFO_R_EINVAL;
1860         }
1861         node = (pkgmgrinfo_node_x *)calloc(1, sizeof(pkgmgrinfo_node_x));
1862         if (node == NULL) {
1863                 _LOGE("Out of Memory!!!\n");
1864                 return PMINFO_R_ERROR;
1865         }
1866         snprintf(buf, PKG_VALUE_STRING_LEN_MAX - 1, "%d", value);
1867         val = strndup(buf, PKG_VALUE_STRING_LEN_MAX - 1);
1868         if (val == NULL) {
1869                 _LOGE("Out of Memory\n");
1870                 free(node);
1871                 return PMINFO_R_ERROR;
1872         }
1873         node->prop = prop;
1874         node->value = val;
1875         /*If API is called multiple times for same property, we should override the previous values.
1876         Last value set will be used for filtering.*/
1877         link = g_slist_find_custom(filter->list, (gconstpointer)node, __compare_func);
1878         if (link)
1879                 filter->list = g_slist_delete_link(filter->list, link);
1880         filter->list = g_slist_append(filter->list, (gpointer)node);
1881         return PMINFO_R_OK;
1882
1883 }
1884
1885 API int pkgmgrinfo_pkginfo_filter_add_bool(pkgmgrinfo_pkginfo_filter_h handle,
1886                                 const char *property, const bool value)
1887 {
1888         char *val;
1889         GSList *link;
1890         int prop;
1891         pkgmgrinfo_filter_x *filter = (pkgmgrinfo_filter_x *)handle;
1892         pkgmgrinfo_node_x *node;
1893
1894         retvm_if(handle == NULL, PMINFO_R_EINVAL, "Filter handle input parameter is NULL\n");
1895         retvm_if(property == NULL, PMINFO_R_EINVAL, "Filter handle input parameter is NULL\n");
1896
1897         prop = _pminfo_pkginfo_convert_to_prop_bool(property);
1898         if (prop < E_PMINFO_PKGINFO_PROP_PACKAGE_MIN_BOOL ||
1899                 prop > E_PMINFO_PKGINFO_PROP_PACKAGE_MAX_BOOL) {
1900                 _LOGE("Invalid Boolean Property\n");
1901                 return PMINFO_R_EINVAL;
1902         }
1903         node = (pkgmgrinfo_node_x *)calloc(1, sizeof(pkgmgrinfo_node_x));
1904         if (node == NULL) {
1905                 _LOGE("Out of Memory!!!\n");
1906                 return PMINFO_R_ERROR;
1907         }
1908         if (value)
1909                 val = strndup("true", 4);
1910         else
1911                 val = strndup("false", 5);
1912         if (val == NULL) {
1913                 _LOGE("Out of Memory\n");
1914                 free(node);
1915                 return PMINFO_R_ERROR;
1916         }
1917         node->prop = prop;
1918         node->value = val;
1919         /*If API is called multiple times for same property, we should override the previous values.
1920         Last value set will be used for filtering.*/
1921         link = g_slist_find_custom(filter->list, (gconstpointer)node, __compare_func);
1922         if (link)
1923                 filter->list = g_slist_delete_link(filter->list, link);
1924         filter->list = g_slist_append(filter->list, (gpointer)node);
1925         return PMINFO_R_OK;
1926
1927 }
1928
1929 API int pkgmgrinfo_pkginfo_filter_add_string(pkgmgrinfo_pkginfo_filter_h handle,
1930                                 const char *property, const char *value)
1931 {
1932         char *val;
1933         GSList *link;
1934         int prop;
1935         pkgmgrinfo_filter_x *filter = (pkgmgrinfo_filter_x *)handle;
1936         pkgmgrinfo_node_x *node;
1937
1938         retvm_if(handle == NULL, PMINFO_R_EINVAL, "Filter handle input parameter is NULL\n");
1939         retvm_if(property == NULL, PMINFO_R_EINVAL, "Filter handle input parameter is NULL\n");
1940         retvm_if(value == NULL, PMINFO_R_EINVAL, "Filter handle input parameter is NULL\n");
1941
1942         prop = _pminfo_pkginfo_convert_to_prop_str(property);
1943         if (prop < E_PMINFO_PKGINFO_PROP_PACKAGE_MIN_STR ||
1944                 prop > E_PMINFO_PKGINFO_PROP_PACKAGE_MAX_STR) {
1945                 _LOGE("Invalid String Property\n");
1946                 return PMINFO_R_EINVAL;
1947         }
1948         node = (pkgmgrinfo_node_x *)calloc(1, sizeof(pkgmgrinfo_node_x));
1949         if (node == NULL) {
1950                 _LOGE("Out of Memory!!!\n");
1951                 return PMINFO_R_ERROR;
1952         }
1953         if (strcmp(value, PMINFO_PKGINFO_INSTALL_LOCATION_AUTO) == 0)
1954                 val = strndup("auto", PKG_STRING_LEN_MAX - 1);
1955         else if (strcmp(value, PMINFO_PKGINFO_INSTALL_LOCATION_INTERNAL) == 0)
1956                 val = strndup("internal-only", PKG_STRING_LEN_MAX - 1);
1957         else if (strcmp(value, PMINFO_PKGINFO_INSTALL_LOCATION_EXTERNAL) == 0)
1958                 val = strndup("prefer-external", PKG_STRING_LEN_MAX - 1);
1959         else if (strcmp(value, "installed_internal") == 0)
1960                 val = strndup("installed_internal", PKG_STRING_LEN_MAX - 1);
1961         else if (strcmp(value, "installed_external") == 0)
1962                 val = strndup("installed_external", PKG_STRING_LEN_MAX - 1);
1963         else
1964                 val = strndup(value, PKG_STRING_LEN_MAX - 1);
1965         if (val == NULL) {
1966                 _LOGE("Out of Memory\n");
1967                 free(node);
1968                 return PMINFO_R_ERROR;
1969         }
1970         node->prop = prop;
1971         node->value = val;
1972         /*If API is called multiple times for same property, we should override the previous values.
1973         Last value set will be used for filtering.*/
1974         link = g_slist_find_custom(filter->list, (gconstpointer)node, __compare_func);
1975         if (link)
1976                 filter->list = g_slist_delete_link(filter->list, link);
1977         filter->list = g_slist_append(filter->list, (gpointer)node);
1978         return PMINFO_R_OK;
1979
1980 }
1981
1982 API int pkgmgrinfo_pkginfo_usr_filter_count(pkgmgrinfo_pkginfo_filter_h handle, int *count, uid_t uid)
1983 {
1984         int ret;
1985         char *locale;
1986         GHashTable *list = NULL;
1987
1988         if (handle == NULL || count == NULL) {
1989                 _LOGE("invalid parameter");
1990                 return PMINFO_R_EINVAL;
1991         }
1992
1993         locale = _get_system_locale();
1994         if (locale == NULL)
1995                 return PMINFO_R_ERROR;
1996
1997         list = g_hash_table_new_full(g_str_hash, g_str_equal, NULL,
1998                         __free_packages);
1999         if (list == NULL) {
2000                 free(locale);
2001                 return PMINFO_R_ERROR;
2002         }
2003
2004         if (__check_disable_filter_exist((pkgmgrinfo_filter_x *)handle) == false) {
2005                 ret = pkgmgrinfo_pkginfo_filter_add_bool(handle,
2006                                 PMINFO_PKGINFO_PROP_PACKAGE_DISABLE, false);
2007                 if (ret != PMINFO_R_OK) {
2008                         free(locale);
2009                         g_hash_table_destroy(list);
2010                         return PMINFO_R_ERROR;
2011                 }
2012         }
2013
2014         ret = _pkginfo_get_packages(uid, locale,
2015                         (pkgmgrinfo_filter_x *)handle, 0, list);
2016         if (ret == PMINFO_R_OK && uid != GLOBAL_USER)
2017                 ret = _pkginfo_get_packages(GLOBAL_USER, locale, handle, 0,
2018                                 list);
2019
2020         if (ret != PMINFO_R_OK) {
2021                 g_hash_table_destroy(list);
2022                 free(locale);
2023                 return PMINFO_R_ERROR;
2024         }
2025
2026         *count = g_hash_table_size(list);
2027
2028         g_hash_table_destroy(list);
2029         free(locale);
2030
2031         return PMINFO_R_OK;
2032 }
2033
2034 API int pkgmgrinfo_pkginfo_filter_count(pkgmgrinfo_pkginfo_filter_h handle, int *count)
2035 {
2036         return pkgmgrinfo_pkginfo_usr_filter_count(handle, count, _getuid());
2037 }
2038
2039 API int pkgmgrinfo_pkginfo_usr_filter_foreach_pkginfo(
2040                 pkgmgrinfo_pkginfo_filter_h handle,
2041                 pkgmgrinfo_pkg_list_cb pkg_cb, void *user_data, uid_t uid)
2042 {
2043         if (handle == NULL || pkg_cb == NULL) {
2044                 LOGE("invalid parameter");
2045                 return PMINFO_R_EINVAL;
2046         }
2047
2048         return _pkginfo_get_filtered_foreach_pkginfo(uid, handle,
2049                         PMINFO_PKGINFO_GET_ALL, pkg_cb, user_data);
2050 }
2051
2052 API int pkgmgrinfo_pkginfo_filter_foreach_pkginfo(pkgmgrinfo_pkginfo_filter_h handle,
2053                                 pkgmgrinfo_pkg_list_cb pkg_cb, void *user_data)
2054 {
2055         return pkgmgrinfo_pkginfo_usr_filter_foreach_pkginfo(handle, pkg_cb, user_data, _getuid());
2056 }
2057
2058 API int pkgmgrinfo_pkginfo_foreach_privilege(pkgmgrinfo_pkginfo_h handle,
2059                         pkgmgrinfo_pkg_privilege_list_cb privilege_func, void *user_data)
2060 {
2061         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL");
2062         retvm_if(privilege_func == NULL, PMINFO_R_EINVAL, "Callback function is NULL");
2063         int ret;
2064         privilege_x *privilege;
2065         appdefined_privilege_x *appdefined_privilege;
2066         GList *tmp;
2067         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
2068
2069         if (info->pkg_info == NULL)
2070                 return PMINFO_R_ERROR;
2071
2072         for (tmp = info->pkg_info->privileges; tmp; tmp = tmp->next) {
2073                 privilege = (privilege_x *)tmp->data;
2074                 if (privilege == NULL)
2075                         continue;
2076                 ret = privilege_func(privilege->value, user_data);
2077                 if (ret < 0)
2078                         return PMINFO_R_OK;
2079         }
2080
2081         for (tmp = info->pkg_info->appdefined_privileges; tmp;
2082                         tmp = tmp->next) {
2083                 appdefined_privilege = (appdefined_privilege_x *)tmp->data;
2084                 if (appdefined_privilege == NULL)
2085                         continue;
2086                 ret = privilege_func(appdefined_privilege->value, user_data);
2087                 if (ret < 0)
2088                         return PMINFO_R_OK;
2089         }
2090         return PMINFO_R_OK;
2091 }
2092
2093 API int pkgmgrinfo_pkginfo_foreach_plugin(pkgmgrinfo_pkginfo_h handle,
2094                         pkgmgrinfo_plugin_list_cb plugin_func, void *user_data)
2095 {
2096         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL");
2097         retvm_if(plugin_func == NULL, PMINFO_R_EINVAL,
2098                         "Callback function is NULL");
2099         int ret;
2100         plugin_x *plugin;
2101         GList *tmp;
2102         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
2103
2104         if (info->pkg_info == NULL)
2105                 return PMINFO_R_ERROR;
2106
2107         for (tmp = info->pkg_info->plugin; tmp; tmp = tmp->next) {
2108                 plugin = (plugin_x *)tmp->data;
2109                 if (plugin == NULL)
2110                         continue;
2111                 ret = plugin_func(plugin->pkgid, plugin->appid,
2112                                 plugin->plugin_type, plugin->plugin_name, user_data);
2113                 if (ret < 0)
2114                         return PMINFO_R_OK;
2115         }
2116
2117         return PMINFO_R_OK;
2118 }
2119
2120 API int pkgmgrinfo_pkginfo_foreach_appdefined_privilege(
2121                 pkgmgrinfo_pkginfo_h handle,
2122                 pkgmgrinfo_pkg_appdefined_privilege_list_cb privilege_func,
2123                 void *user_data)
2124 {
2125         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL");
2126         retvm_if(privilege_func == NULL, PMINFO_R_EINVAL,
2127                         "Callback function is NULL");
2128         int ret;
2129         appdefined_privilege_x *privilege;
2130         GList *tmp;
2131         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
2132
2133         if (info->pkg_info == NULL)
2134                 return PMINFO_R_ERROR;
2135
2136         for (tmp = info->pkg_info->appdefined_privileges; tmp;
2137                         tmp = tmp->next) {
2138                 privilege = (appdefined_privilege_x *)tmp->data;
2139                 if (privilege == NULL)
2140                         continue;
2141                 ret = privilege_func(privilege->value, privilege->license,
2142                                 user_data);
2143                 if (ret < 0)
2144                         break;
2145         }
2146         return PMINFO_R_OK;
2147 }
2148
2149 API int pkgmgrinfo_pkginfo_foreach_dependency(pkgmgrinfo_pkginfo_h handle,
2150                 pkgmgrinfo_pkg_dependency_list_cb dependency_cb,
2151                 void *user_data)
2152 {
2153         int ret;
2154         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
2155         GList *tmp;
2156         dependency_x *dependency;
2157
2158         if (handle == NULL || dependency_cb == NULL) {
2159                 LOGE("invalid parameter");
2160                 return PMINFO_R_EINVAL;
2161         }
2162
2163         if (info->pkg_info == NULL)
2164                 return PMINFO_R_ERROR;
2165
2166         for (tmp = info->pkg_info->dependencies; tmp; tmp = tmp->next) {
2167                 dependency = (dependency_x *)tmp->data;
2168                 if (dependency == NULL)
2169                         continue;
2170                 ret = dependency_cb(info->pkg_info->package,
2171                                 dependency->depends_on, dependency->type,
2172                                 dependency->required_version, user_data);
2173                 if (ret < 0)
2174                         break;
2175         }
2176
2177         return PMINFO_R_OK;
2178 }
2179
2180 struct depends_on {
2181         char *from;
2182         char *to;
2183         char *type;
2184         char *version;
2185 };
2186
2187 static int _get_depends_on(sqlite3 *db, const char *pkgid, GQueue **queue,
2188                 GHashTable **table, GList **pkg_list)
2189 {
2190         static const char query[] =
2191                 "SELECT package, depends_on, type, required_version "
2192                 "FROM package_dependency_info WHERE depends_on=?";
2193         int ret;
2194         sqlite3_stmt *stmt;
2195         struct depends_on *req;
2196
2197         /* already checked */
2198         if (!g_hash_table_insert(*table, strdup(pkgid), GINT_TO_POINTER(1)))
2199                 return PMINFO_R_OK;
2200
2201         ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
2202         if (ret != SQLITE_OK) {
2203                 LOGE("prepare failed: %s", sqlite3_errmsg(db));
2204                 return PMINFO_R_ERROR;
2205         }
2206
2207         ret = sqlite3_bind_text(stmt, 1, pkgid, -1, SQLITE_STATIC);
2208         if (ret != SQLITE_OK) {
2209                 LOGE("bind failed: %s", sqlite3_errmsg(db));
2210                 sqlite3_finalize(stmt);
2211                 return PMINFO_R_ERROR;
2212         }
2213
2214         while (sqlite3_step(stmt) == SQLITE_ROW) {
2215                 req = calloc(1, sizeof(struct depends_on));
2216                 if (req == NULL) {
2217                         LOGE("out of memory");
2218                         sqlite3_finalize(stmt);
2219                         return PMINFO_R_ERROR;
2220                 }
2221                 _save_column_str(stmt, 0, &req->from);
2222                 _save_column_str(stmt, 1, &req->to);
2223                 _save_column_str(stmt, 2, &req->type);
2224                 _save_column_str(stmt, 3, &req->version);
2225
2226                 *pkg_list = g_list_append(*pkg_list, req);
2227                 g_queue_push_tail(*queue, strdup(req->from));
2228         }
2229
2230         sqlite3_finalize(stmt);
2231
2232         return PMINFO_R_OK;
2233 }
2234
2235 static int _pkginfo_foreach_depends_on(uid_t uid, const char *pkgid,
2236                 GList **pkg_list)
2237 {
2238         int ret;
2239         char *dbpath;
2240         sqlite3 *db;
2241         GQueue *queue;
2242         GHashTable *table;
2243         char *item;
2244
2245         dbpath = getUserPkgParserDBPathUID(uid);
2246         if (dbpath == NULL)
2247                 return PMINFO_R_ERROR;
2248
2249         ret = __open_db(dbpath, &db, SQLITE_OPEN_READONLY);
2250         if (ret != SQLITE_OK) {
2251                 LOGD("failed to open db(%s): %d", dbpath, ret);
2252                 free(dbpath);
2253                 return PMINFO_R_ERROR;
2254         }
2255         free(dbpath);
2256
2257         queue = g_queue_new();
2258         if (queue == NULL) {
2259                 LOGE("out of memory");
2260                 sqlite3_close_v2(db);
2261                 return PMINFO_R_ERROR;
2262         }
2263
2264         table = g_hash_table_new_full(g_str_hash, g_str_equal, free, NULL);
2265
2266         g_queue_push_tail(queue, strdup(pkgid));
2267         while (!g_queue_is_empty(queue)) {
2268                 item = g_queue_pop_head(queue);
2269                 ret = _get_depends_on(db, item, &queue, &table, pkg_list);
2270                 free(item);
2271                 if (ret != PMINFO_R_OK) {
2272                         LOGE("failed to get pkgs depends on %s", pkgid);
2273                         g_hash_table_destroy(table);
2274                         g_queue_free_full(queue, free);
2275                         sqlite3_close_v2(db);
2276                         return PMINFO_R_ERROR;
2277                 }
2278         }
2279
2280         g_hash_table_destroy(table);
2281         g_queue_free_full(queue, free);
2282         sqlite3_close_v2(db);
2283
2284         return PMINFO_R_OK;
2285 }
2286
2287 static void __free_depends_on(gpointer data)
2288 {
2289         struct depends_on *dep = (struct depends_on *)data;
2290
2291         free(dep->from);
2292         free(dep->to);
2293         free(dep->type);
2294         free(dep->version);
2295         free(dep);
2296 }
2297
2298 API int pkgmgrinfo_pkginfo_foreach_depends_on(pkgmgrinfo_pkginfo_h handle,
2299                 pkgmgrinfo_pkg_dependency_list_cb dependency_cb,
2300                 void *user_data)
2301 {
2302         int ret;
2303         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
2304         GList *pkg_list = NULL;
2305         GList *l;
2306         struct depends_on *dep;
2307
2308         if (handle == NULL || dependency_cb == NULL || info->pkg_info == NULL) {
2309                 LOGE("invalid parameter");
2310                 return PMINFO_R_EINVAL;
2311         }
2312
2313         ret = _pkginfo_foreach_depends_on(info->uid, info->pkg_info->package,
2314                         &pkg_list);
2315         if (ret == PMINFO_R_OK && info->uid != GLOBAL_USER)
2316                 ret = _pkginfo_foreach_depends_on(GLOBAL_USER,
2317                                 info->pkg_info->package, &pkg_list);
2318
2319         if (ret != PMINFO_R_OK) {
2320                 g_list_free_full(pkg_list, __free_depends_on);
2321                 return ret;
2322         }
2323
2324         for (l = pkg_list; l != NULL; l = l->next) {
2325                 dep = (struct depends_on *)l->data;
2326                 ret = dependency_cb(dep->from, dep->to, dep->type, dep->version,
2327                                 user_data);
2328                 if (ret < 0)
2329                         break;
2330         }
2331
2332         g_list_free_full(pkg_list, __free_depends_on);
2333
2334         return PMINFO_R_OK;
2335 }
2336
2337 int __compare_package_version(const char *version, int *major,
2338                 int *minor, int *macro, int *nano)
2339 {
2340         char *version_temp = NULL;
2341         char *major_str = NULL;
2342         char *minor_str = NULL;
2343         char *macro_str = NULL;
2344         char *nano_str = NULL;
2345         char *save_str = NULL;
2346
2347         if (version == NULL || major == NULL || minor == NULL ||
2348                 macro == NULL || nano == NULL) {
2349                 return PMINFO_R_EINVAL;
2350         }
2351
2352         version_temp = strdup(version);
2353         if (version_temp == NULL) {
2354                 LOGE("Out of memory");
2355                 return PMINFO_R_ERROR;
2356         }
2357
2358         major_str = strtok_r(version_temp, ".", &save_str);
2359         if (major_str == NULL) {
2360                 _LOGE("major version is NULL");
2361                 free(version_temp);
2362                 return PMINFO_R_ERROR;
2363         }
2364
2365         minor_str = strtok_r(NULL, ".", &save_str);
2366         if (minor_str == NULL) {
2367                 _LOGE("minor version is NULL");
2368                 free(version_temp);
2369                 return PMINFO_R_ERROR;
2370         }
2371
2372         *major = atoi(major_str);
2373         *minor = atoi(minor_str);
2374         *macro = 0;
2375         *nano = 0;
2376         macro_str = strtok_r(NULL, ".", &save_str);
2377         if (macro_str == NULL) {
2378                 _LOGD("macro version is NULL");
2379         } else {
2380                 *macro = atoi(macro_str);
2381                 nano_str = strtok_r(NULL, ".", &save_str);
2382                 if (nano_str) {
2383                         *nano = atoi(nano_str);
2384                         _LOGD("nano version exists");
2385                 }
2386         }
2387         _LOGD("version = [%s] -> major = [%d], minor = [%d]," \
2388                 " macro = [%d], nano = [%d]", version, *major,
2389                 *minor, *macro, *nano);
2390
2391         free(version_temp);
2392
2393         return PMINFO_R_OK;
2394 }
2395
2396 API int pkgmgrinfo_compare_package_version(const char *current_version,
2397                 const char *target_version,
2398                 pkgmgrinfo_version_compare_type *res)
2399 {
2400         int ret = 0;
2401         int current_version_major = 0;
2402         int current_version_minor = 0;
2403         int current_version_macro = 0;
2404         int current_version_nano = 0;
2405         int target_version_major = 0;
2406         int target_version_minor = 0;
2407         int target_version_macro = 0;
2408         int target_version_nano = 0;
2409
2410         if (current_version == NULL || target_version == NULL ||
2411                 res == NULL) {
2412                 _LOGE("Invalid parameter");
2413                 return PMINFO_R_EINVAL;
2414         }
2415
2416         ret = __compare_package_version(target_version,
2417                 &target_version_major, &target_version_minor,
2418                 &target_version_macro, &target_version_nano);
2419         if (ret < 0) {
2420                 _LOGE("Failed to compare target version(%d)", ret);
2421                 return PMINFO_R_ERROR;
2422         }
2423
2424         ret = __compare_package_version(current_version,
2425                 &current_version_major, &current_version_minor,
2426                 &current_version_macro, &current_version_nano);
2427         if (ret < 0) {
2428                 _LOGE("Failed to compare current version(%d)", ret);
2429                 return PMINFO_R_ERROR;
2430         }
2431
2432         _LOGD("new[%d.%d.%d.%d] old[%d.%d.%d.%d]", target_version_major,
2433                 target_version_minor, target_version_macro,
2434                 target_version_nano, current_version_major,
2435                 current_version_minor, current_version_macro,
2436                 target_version_nano);
2437
2438         if (target_version_major > current_version_major)
2439                 *res = PMINFO_VERSION_NEW;
2440         else if (target_version_major < current_version_major)
2441                 *res = PMINFO_VERSION_OLD;
2442         else if (target_version_minor > current_version_minor)
2443                 *res = PMINFO_VERSION_NEW;
2444         else if (target_version_minor < current_version_minor)
2445                 *res = PMINFO_VERSION_OLD;
2446         else if (target_version_macro > current_version_macro)
2447                 *res = PMINFO_VERSION_NEW;
2448         else if (target_version_macro < current_version_macro)
2449                 *res = PMINFO_VERSION_OLD;
2450         else if (target_version_nano > current_version_nano)
2451                 *res = PMINFO_VERSION_NEW;
2452         else if (target_version_nano < current_version_nano)
2453                 *res = PMINFO_VERSION_OLD;
2454         else
2455                 *res = PMINFO_VERSION_SAME;
2456
2457         return PMINFO_R_OK;
2458 }