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