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 __cleanup_pkginfo(pkgmgr_pkginfo_x *data)
  90 {
  91         ret_if(data == NULL);
  92         if (data->locale) {
  93                 free((void *)data->locale);
  94                 data->locale = NULL;
  95         }
  96
  97         pkgmgrinfo_basic_free_package(data->pkg_info);
  98         free((void *)data);
  99         data = NULL;
 100         return;
 101 }
 102
 103 long long _pkgmgr_calculate_dir_size(char *dirname)
 104 {
 105         long long total = 0;
 106         long long ret = 0;
 107         int q = 0; /*quotient*/
 108         int r = 0; /*remainder*/
 109         DIR *dp = NULL;
 110         struct dirent ep, *result;
 111         struct stat fileinfo;
 112         char abs_filename[FILENAME_MAX] = { 0, };
 113         retvm_if(dirname == NULL, PMINFO_R_ERROR, "dirname is NULL");
 114
 115         dp = opendir(dirname);
 116         if (dp == NULL) {
 117                 _LOGE("Couldn't open the directory\n");
 118                 return -1;
 119         }
 120
 121         for (ret = readdir_r(dp, &ep, &result);
 122                         ret == 0 && result != NULL;
 123                         ret = readdir_r(dp, &ep, &result)) {
 124                 if (!strcmp(ep.d_name, ".") ||
 125                         !strcmp(ep.d_name, "..")) {
 126                         continue;
 127                 }
 128                 snprintf(abs_filename, FILENAME_MAX, "%s/%s", dirname,
 129                          ep.d_name);
 130                 if (lstat(abs_filename, &fileinfo) < 0)
 131                         perror(abs_filename);
 132                 else {
 133                         if (S_ISDIR(fileinfo.st_mode)) {
 134                                 total += fileinfo.st_size;
 135                                 if (strcmp(ep.d_name, ".")
 136                                     && strcmp(ep.d_name, "..")) {
 137                                         ret = _pkgmgr_calculate_dir_size
 138                                             (abs_filename);
 139                                         total = total + ret;
 140                                 }
 141                         } else if (S_ISLNK(fileinfo.st_mode)) {
 142                                 continue;
 143                         } else {
 144                                 /*It is a file. Calculate the actual
 145                                 size occupied (in terms of 4096 blocks)*/
 146                         q = (fileinfo.st_size / BLOCK_SIZE);
 147                         r = (fileinfo.st_size % BLOCK_SIZE);
 148                         if (r)
 149                                 q = q + 1;
 150                         total += q * BLOCK_SIZE;
 151                         }
 152                 }
 153         }
 154         (void)closedir(dp);
 155         return total;
 156
 157 }
 158
 159 static int _pkginfo_add_description_info_into_list(const char *locale,
 160                 char *record, GList **description)
 161 {
 162         description_x *info;
 163
 164         info = calloc(1, sizeof(description_x));
 165         if (info == NULL) {
 166                 LOGE("out of memory");
 167                 return PMINFO_R_ERROR;
 168         }
 169         info->lang = strdup(locale);
 170         info->text = record;
 171         *description = g_list_append(*description, info);
 172
 173         return PMINFO_R_OK;
 174 }
 175
 176 static int _pkginfo_get_privilege(sqlite3 *db, const char *pkgid,
 177                 GList **privileges)
 178 {
 179         static const char query_raw[] =
 180                 "SELECT DISTINCT privilege, type FROM package_privilege_info "
 181                 "WHERE package=%Q";
 182         int ret;
 183         char *query;
 184         sqlite3_stmt *stmt;
 185         privilege_x *privilege;
 186
 187         query = sqlite3_mprintf(query_raw, pkgid);
 188         if (query == NULL) {
 189                 LOGE("out of memory");
 190                 return PMINFO_R_ERROR;
 191         }
 192
 193         ret = sqlite3_prepare_v2(db, query, strlen(query),
 194                         &stmt, NULL);
 195         sqlite3_free(query);
 196         if (ret != SQLITE_OK) {
 197                 LOGE("prepare failed: %s", sqlite3_errmsg(db));
 198                 return PMINFO_R_ERROR;
 199         }
 200
 201         while (sqlite3_step(stmt) == SQLITE_ROW) {
 202                 privilege = calloc(1, sizeof(privilege_x));
 203                 _save_column_str(stmt, 0, &privilege->value);
 204                 _save_column_str(stmt, 1, &privilege->type);
 205                 *privileges = g_list_append(*privileges,
 206                                 (gpointer)privilege);
 207         }
 208
 209         sqlite3_finalize(stmt);
 210
 211         return PMINFO_R_OK;
 212 }
 213
 214 static const char join_localized_info[] =
 215         " LEFT OUTER JOIN package_localized_info"
 216         "  ON pi.package=package_localized_info.package"
 217         "  AND package_localized_info.package_locale=?";
 218 static const char join_privilege_info[] =
 219         " LEFT OUTER JOIN package_privilege_info"
 220         "  ON pi.package=package_privilege_info.package";
 221
 222 static int _get_filtered_query(pkgmgrinfo_filter_x *filter,
 223                 const char *locale, char **query, GList **bind_params)
 224 {
 225         int joined = 0;
 226         char buf[MAX_QUERY_LEN] = { '\0' };
 227         char buf2[MAX_QUERY_LEN] = { '\0' };
 228         char *condition = NULL;
 229         size_t len = 0;
 230         GSList *list = NULL;
 231
 232         if (filter == NULL)
 233                 return PMINFO_R_OK;
 234
 235         len += strlen(" WHERE 1=1 ");
 236         strncat(buf, " WHERE 1=1 ", MAX_QUERY_LEN - len - 1);
 237         for (list = filter->list; list; list = list->next) {
 238                 joined |= __get_filter_condition(list->data, &condition,
 239                                 bind_params);
 240                 if (condition == NULL)
 241                         continue;
 242
 243                 len += strlen(" AND ");
 244                 strncat(buf, " AND ", MAX_QUERY_LEN - len - 1);
 245
 246                 len += strlen(condition);
 247                 strncat(buf, condition, sizeof(buf) - len - 1);
 248                 free(condition);
 249                 condition = NULL;
 250         }
 251
 252         if (joined & E_PMINFO_PKGINFO_JOIN_LOCALIZED_INFO) {
 253                 strncat(buf2, join_localized_info, MAX_QUERY_LEN - len - 1);
 254                 len += strlen(join_localized_info);
 255                 *bind_params = g_list_append(*bind_params, strdup(locale));
 256         }
 257         if (joined & E_PMINFO_PKGINFO_JOIN_PRIVILEGE_INFO) {
 258                 strncat(buf2, join_privilege_info, MAX_QUERY_LEN - len - 1);
 259                 len += strlen(join_privilege_info);
 260         }
 261         strncat(buf2, buf, MAX_QUERY_LEN - len - 1);
 262
 263         *query = strdup(buf2);
 264         if (*query == NULL)
 265                 return PMINFO_R_ERROR;
 266
 267         return PMINFO_R_OK;
 268 }
 269
 270 static void __free_packages(gpointer data)
 271 {
 272         pkgmgrinfo_basic_free_package((package_x *)data);
 273 }
 274
 275 static bool __check_disable_filter_exist(pkgmgrinfo_filter_x *filter)
 276 {
 277         GSList *link;
 278
 279         if (filter == NULL)
 280                 return false;
 281
 282         link = g_slist_find_custom(filter->list, NULL, __pkg_disable_chk_func);
 283         if (link)
 284                 return true;
 285
 286         return false;
 287 }
 288
 289 static int __bind_params(sqlite3_stmt *stmt, GList *params)
 290 {
 291         GList *tmp_list = NULL;
 292         int idx = 0;
 293         int ret;
 294
 295         if (stmt == NULL || params == NULL)
 296                 return PMINFO_R_EINVAL;
 297
 298         tmp_list = params;
 299         while (tmp_list) {
 300                 ret = sqlite3_bind_text(stmt, ++idx, (char *)tmp_list->data, -1, SQLITE_STATIC);
 301                 if (ret != SQLITE_OK)
 302                         return PMINFO_R_ERROR;
 303                 tmp_list = tmp_list->next;
 304         }
 305
 306         return PMINFO_R_OK;
 307 }
 308
 309 static int _pkginfo_get_packages(uid_t uid, const char *locale,
 310                 pkgmgrinfo_filter_x *filter, int flag, GHashTable *packages)
 311 {
 312         static const char query_raw[] =
 313                 "SELECT DISTINCT pi.package, pi.package_version, "
 314                 "pi.install_location, pi.package_removable, "
 315                 "pi.package_preload, pi.package_readonly, pi.package_update, "
 316                 "pi.package_appsetting, pi.package_system, pi.package_type, "
 317                 "pi.package_size, pi.installed_time, pi.installed_storage, "
 318                 "pi.storeclient_id, pi.mainapp_id, pi.package_url, "
 319                 "pi.root_path, pi.csc_path, pi.package_nodisplay, "
 320                 "pi.package_api_version, pi.package_support_disable, "
 321                 "pi.package_tep_name, pi.package_zip_mount_file, pi.external_path, "
 322                 "pi.package_support_mode";
 323         static const char query_author[] =
 324                 ", pi.author_name, pi.author_email, pi.author_href";
 325         static const char query_label[] =
 326                 ", COALESCE("
 327                 "(SELECT package_label FROM package_localized_info WHERE pi.package=package AND package_locale=?), "
 328                 "(SELECT package_label FROM package_localized_info WHERE pi.package=package AND package_locale='No Locale'))";
 329         static const char query_icon[] =
 330                 ", COALESCE("
 331                 "(SELECT package_icon FROM package_localized_info WHERE pi.package=package AND package_locale=?), "
 332                 "(SELECT package_icon FROM package_localized_info WHERE pi.package=package AND package_locale='No Locale'))";
 333         static const char query_description[] =
 334                 ", COALESCE("
 335                 "(SELECT package_description FROM package_localized_info WHERE pi.package=package AND package_locale=?), "
 336                 "(SELECT package_description FROM package_localized_info WHERE pi.package=package AND package_locale='No Locale'))";
 337         static const char query_from_clause[] = " FROM package_info as pi";
 338         int ret = PMINFO_R_ERROR;
 339         int idx = 0;
 340         int query_len = 0;
 341         char *dbpath;
 342         char *tmp_record = NULL;
 343         char *constraints = NULL;
 344         char query[MAX_QUERY_LEN] = { '\0' };
 345         package_x *info = NULL;
 346         author_x *author = NULL;
 347         GList *bind_params = NULL;
 348         sqlite3 *db;
 349         sqlite3_stmt *stmt;
 350         pkgmgrinfo_filter_x *tmp_filter = NULL;
 351
 352         dbpath = getUserPkgParserDBPathUID(uid);
 353         if (dbpath == NULL)
 354                 return PMINFO_R_ERROR;
 355
 356         ret = sqlite3_open_v2(dbpath, &db, SQLITE_OPEN_READONLY, NULL);
 357         if (ret != SQLITE_OK) {
 358                 _LOGD("failed to open db: %d", ret);
 359                 free(dbpath);
 360                 return PMINFO_R_ERROR;
 361         }
 362         free(dbpath);
 363
 364         if (filter != NULL) {
 365                 tmp_filter = filter;
 366         } else {
 367                 ret = pkgmgrinfo_pkginfo_filter_create((void *)&tmp_filter);
 368                 if (ret != PMINFO_R_OK) {
 369                         _LOGE("Failed to create filter");
 370                         return PMINFO_R_ERROR;
 371                 }
 372         }
 373
 374         /* add package_disable='false' clause by default */
 375         if (__check_disable_filter_exist(tmp_filter) == false)
 376                 pkgmgrinfo_pkginfo_filter_add_bool(tmp_filter,
 377                                 PMINFO_PKGINFO_PROP_PACKAGE_DISABLE, false);
 378
 379
 380         query_len = strlen(query_raw);
 381         snprintf(query, MAX_QUERY_LEN - 1, "%s", query_raw);
 382         if (flag & PMINFO_PKGINFO_GET_AUTHOR) {
 383                 strncat(query, query_author, MAX_QUERY_LEN - query_len - 1);
 384                 query_len += strlen(query_author);
 385         }
 386         if (flag & PMINFO_PKGINFO_GET_LABEL) {
 387                 strncat(query, query_label, MAX_QUERY_LEN - query_len - 1);
 388                 query_len += strlen(query_label);
 389                 bind_params = g_list_append(bind_params, strdup(locale));
 390         }
 391         if (flag & PMINFO_PKGINFO_GET_ICON) {
 392                 strncat(query, query_icon, MAX_QUERY_LEN - query_len - 1);
 393                 query_len += strlen(query_icon);
 394                 bind_params = g_list_append(bind_params, strdup(locale));
 395         }
 396         if (flag & PMINFO_PKGINFO_GET_DESCRIPTION) {
 397                 strncat(query, query_description, MAX_QUERY_LEN - query_len - 1);
 398                 query_len += strlen(query_description);
 399                 bind_params = g_list_append(bind_params, strdup(locale));
 400         }
 401
 402         strncat(query, query_from_clause, MAX_QUERY_LEN - query_len - 1);
 403         query_len += strlen(query_from_clause);
 404
 405         ret = _get_filtered_query(tmp_filter, locale, &constraints, &bind_params);
 406         if (ret != PMINFO_R_OK) {
 407                 LOGE("Failed to get WHERE clause");
 408                 goto catch;
 409         }
 410
 411         if (constraints)
 412                 strncat(query, constraints, MAX_QUERY_LEN - query_len - 1);
 413
 414         ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
 415         if (ret != SQLITE_OK) {
 416                 LOGE("prepare failed: %s", sqlite3_errmsg(db));
 417                 ret = PMINFO_R_ERROR;
 418                 goto catch;
 419         }
 420
 421         ret = __bind_params(stmt, bind_params);
 422         if (ret != SQLITE_OK) {
 423                 LOGE("Failed to bind parameters");
 424                 goto catch;
 425         }
 426
 427         while (sqlite3_step(stmt) == SQLITE_ROW) {
 428                 info = calloc(1, sizeof(package_x));
 429                 if (info == NULL) {
 430                         LOGE("out of memory");
 431                         sqlite3_finalize(stmt);
 432                         sqlite3_close_v2(db);
 433                         return PMINFO_R_ERROR;
 434                 }
 435                 idx = 0;
 436                 _save_column_str(stmt, idx++, &info->package);
 437                 if (g_hash_table_contains(packages,
 438                                         (gconstpointer)info->package)) {
 439                         free(info->package);
 440                         free(info);
 441                         continue;
 442                 }
 443                 _save_column_str(stmt, idx++, &info->version);
 444                 _save_column_str(stmt, idx++, &info->installlocation);
 445                 _save_column_str(stmt, idx++, &info->removable);
 446                 _save_column_str(stmt, idx++, &info->preload);
 447                 _save_column_str(stmt, idx++, &info->readonly);
 448                 _save_column_str(stmt, idx++, &info->update);
 449                 _save_column_str(stmt, idx++, &info->appsetting);
 450                 _save_column_str(stmt, idx++, &info->system);
 451                 _save_column_str(stmt, idx++, &info->type);
 452                 _save_column_str(stmt, idx++, &info->package_size);
 453                 _save_column_str(stmt, idx++, &info->installed_time);
 454                 _save_column_str(stmt, idx++, &info->installed_storage);
 455                 _save_column_str(stmt, idx++, &info->storeclient_id);
 456                 _save_column_str(stmt, idx++, &info->mainapp_id);
 457                 _save_column_str(stmt, idx++, &info->package_url);
 458                 _save_column_str(stmt, idx++, &info->root_path);
 459                 _save_column_str(stmt, idx++, &info->csc_path);
 460                 _save_column_str(stmt, idx++, &info->nodisplay_setting);
 461                 _save_column_str(stmt, idx++, &info->api_version);
 462                 _save_column_str(stmt, idx++, &info->support_disable);
 463                 _save_column_str(stmt, idx++, &info->tep_name);
 464                 _save_column_str(stmt, idx++, &info->zip_mount_file);
 465                 _save_column_str(stmt, idx++, &info->external_path);
 466                 _save_column_str(stmt, idx++, &info->support_mode);
 467                 info->for_all_users =
 468                         strdup((uid != GLOBAL_USER) ? "false" : "true");
 469
 470                 if (flag & PMINFO_PKGINFO_GET_AUTHOR) {
 471                         /* TODO : author should be retrieved at package_localized_info */
 472                         author = calloc(1, sizeof(author_x));
 473                         if (author == NULL) {
 474                                 pkgmgrinfo_basic_free_package(info);
 475                                 sqlite3_finalize(stmt);
 476                                 sqlite3_close_v2(db);
 477                                 return PMINFO_R_ERROR;
 478                         }
 479                         _save_column_str(stmt, idx++, &author->text);
 480                         _save_column_str(stmt, idx++, &author->email);
 481                         _save_column_str(stmt, idx++, &author->href);
 482                         info->author = g_list_append(info->author, author);
 483                 }
 484
 485                 if (flag & PMINFO_PKGINFO_GET_LABEL) {
 486                         tmp_record = NULL;
 487                         _save_column_str(stmt, idx++, &tmp_record);
 488
 489                         if (_add_label_info_into_list(locale, tmp_record, &info->label)) {
 490                                 pkgmgrinfo_basic_free_package(info);
 491                                 sqlite3_finalize(stmt);
 492                                 sqlite3_close_v2(db);
 493                                 return PMINFO_R_ERROR;
 494                         }
 495                 }
 496
 497                 if (flag & PMINFO_PKGINFO_GET_ICON) {
 498                         tmp_record = NULL;
 499                         _save_column_str(stmt, idx++, &tmp_record);
 500                         if (_add_icon_info_into_list(locale, tmp_record, &info->icon)) {
 501                                 pkgmgrinfo_basic_free_package(info);
 502                                 sqlite3_finalize(stmt);
 503                                 sqlite3_close_v2(db);
 504                                 return PMINFO_R_ERROR;
 505                         }
 506                 }
 507
 508                 if (flag & PMINFO_PKGINFO_GET_DESCRIPTION) {
 509                         tmp_record = NULL;
 510                         _save_column_str(stmt, idx++, &tmp_record);
 511                         if (_pkginfo_add_description_info_into_list(locale, tmp_record,
 512                                         &info->description)) {
 513                                 pkgmgrinfo_basic_free_package(info);
 514                                 sqlite3_finalize(stmt);
 515                                 sqlite3_close_v2(db);
 516                                 return PMINFO_R_ERROR;
 517                         }
 518                 }
 519
 520                 if (flag & PMINFO_PKGINFO_GET_PRIVILEGE) {
 521                         if (_pkginfo_get_privilege(db, info->package,
 522                                                 &info->privileges)) {
 523                                 pkgmgrinfo_basic_free_package(info);
 524                                 sqlite3_finalize(stmt);
 525                                 sqlite3_close_v2(db);
 526                                 return PMINFO_R_ERROR;
 527                         }
 528                 }
 529
 530                 if (__pkginfo_check_installed_storage(info) != PMINFO_R_OK) {
 531                         ret = PMINFO_R_ERROR;
 532                         pkgmgrinfo_basic_free_package(info);
 533                         info = NULL;
 534                         continue;
 535                 }
 536
 537                 g_hash_table_insert(packages, (gpointer)info->package,
 538                                 (gpointer)info);
 539         }
 540
 541         ret = PMINFO_R_OK;
 542
 543 catch:
 544         if (constraints)
 545                 free(constraints);
 546
 547         if (ret != PMINFO_R_OK && info != NULL)
 548                 pkgmgrinfo_basic_free_package(info);
 549
 550         if (filter == NULL)
 551                 pkgmgrinfo_pkginfo_filter_destroy(tmp_filter);
 552
 553         g_list_free_full(bind_params, free);
 554         sqlite3_close_v2(db);
 555         sqlite3_finalize(stmt);
 556
 557         return ret;
 558 }
 559
 560 static int _pkginfo_get_filtered_foreach_pkginfo(uid_t uid,
 561                 pkgmgrinfo_filter_x *filter, int flag,
 562                 pkgmgrinfo_pkg_list_cb pkg_list_cb, void *user_data)
 563 {
 564         int ret;
 565         char *locale;
 566         package_x *pkg;
 567         pkgmgr_pkginfo_x info;
 568         GHashTable *list;
 569         GHashTableIter iter;
 570         gpointer value;
 571
 572         locale = _get_system_locale();
 573         if (locale == NULL)
 574                 return PMINFO_R_ERROR;
 575
 576         list = g_hash_table_new_full(g_str_hash, g_str_equal, NULL,
 577                         __free_packages);
 578         if (list == NULL) {
 579                 free(locale);
 580                 return PMINFO_R_ERROR;
 581         }
 582
 583         ret = _pkginfo_get_packages(uid, locale, filter, flag, list);
 584         if (ret == PMINFO_R_OK && uid != GLOBAL_USER)
 585                 ret = _pkginfo_get_packages(GLOBAL_USER, locale, filter,
 586                                 flag, list);
 587
 588         if (ret != PMINFO_R_OK) {
 589                 g_hash_table_destroy(list);
 590                 free(locale);
 591                 return PMINFO_R_ERROR;
 592         }
 593
 594         g_hash_table_iter_init(&iter, list);
 595         while (g_hash_table_iter_next(&iter, NULL, &value)) {
 596                 pkg = (package_x *)value;
 597                 info.uid = uid;
 598                 info.pkg_info = pkg;
 599                 info.locale = locale;
 600                 if (pkg_list_cb(&info, user_data) < 0)
 601                         break;
 602         }
 603
 604         g_hash_table_destroy(list);
 605         free(locale);
 606
 607         return PMINFO_R_OK;
 608 }
 609
 610 API int pkgmgrinfo_pkginfo_get_usr_pkginfo(const char *pkgid, uid_t uid,
 611                 pkgmgrinfo_pkginfo_h *handle)
 612 {
 613         int ret;
 614         char *locale;
 615         GHashTable *list;
 616         pkgmgrinfo_pkginfo_filter_h filter;
 617         pkgmgr_pkginfo_x *info;
 618
 619         if (pkgid == NULL || handle == NULL) {
 620                 LOGE("invalid parameter");
 621                 return PMINFO_R_EINVAL;
 622         }
 623
 624         locale = _get_system_locale();
 625         if (locale == NULL)
 626                 return PMINFO_R_ERROR;
 627
 628         ret = pkgmgrinfo_pkginfo_filter_create(&filter);
 629         if (ret != PMINFO_R_OK) {
 630                 free(locale);
 631                 return ret;
 632         }
 633
 634         ret = pkgmgrinfo_pkginfo_filter_add_string(filter,
 635                         PMINFO_PKGINFO_PROP_PACKAGE_ID, pkgid);
 636         if (ret != PMINFO_R_OK) {
 637                 pkgmgrinfo_pkginfo_filter_destroy(filter);
 638                 free(locale);
 639                 return PMINFO_R_ERROR;
 640         }
 641
 642         list = g_hash_table_new(g_str_hash, g_str_equal);
 643         if (list == NULL) {
 644                 pkgmgrinfo_pkginfo_filter_destroy(filter);
 645                 free(locale);
 646                 return PMINFO_R_ERROR;
 647         }
 648
 649         ret = _pkginfo_get_packages(uid, locale, filter,
 650                         PMINFO_PKGINFO_GET_ALL, list);
 651         if (!g_hash_table_size(list) && uid != GLOBAL_USER)
 652                 ret = _pkginfo_get_packages(GLOBAL_USER, locale, filter,
 653                                 PMINFO_PKGINFO_GET_ALL, list);
 654
 655         pkgmgrinfo_pkginfo_filter_destroy(filter);
 656         if (ret != PMINFO_R_OK) {
 657                 g_hash_table_destroy(list);
 658                 free(locale);
 659                 return ret;
 660         }
 661
 662         if (!g_hash_table_size(list)) {
 663                 _LOGI("pkginfo for [%s] is not existed for user [%d]",
 664                                 pkgid, uid);
 665                 g_hash_table_destroy(list);
 666                 free(locale);
 667                 return PMINFO_R_ENOENT;
 668         }
 669
 670         info = calloc(1, sizeof(pkgmgr_pkginfo_x));
 671         if (info == NULL) {
 672                 _LOGE("out of memory");
 673                 g_hash_table_destroy(list);
 674                 free(locale);
 675                 return PMINFO_R_ERROR;
 676         }
 677
 678         info->uid = uid;
 679         info->pkg_info = (package_x *)g_hash_table_lookup(list, pkgid);
 680         info->locale = locale;
 681
 682         /* just free list only */
 683         g_hash_table_destroy(list);
 684
 685         *handle = info;
 686
 687         return ret;
 688 }
 689
 690 API int pkgmgrinfo_pkginfo_get_pkginfo(const char *pkgid,
 691                 pkgmgrinfo_pkginfo_h *handle)
 692 {
 693         return pkgmgrinfo_pkginfo_get_usr_pkginfo(pkgid, _getuid(), handle);
 694 }
 695
 696 API int pkgmgrinfo_pkginfo_get_usr_disabled_pkginfo(const char *pkgid,
 697                 uid_t uid, pkgmgrinfo_pkginfo_h *handle)
 698 {
 699         int ret;
 700         char *locale;
 701         GHashTable *list;
 702         pkgmgrinfo_pkginfo_filter_h filter;
 703         pkgmgr_pkginfo_x *info;
 704
 705         if (pkgid == NULL || handle == NULL) {
 706                 LOGE("invalid parameter");
 707                 return PMINFO_R_EINVAL;
 708         }
 709
 710         locale = _get_system_locale();
 711         if (locale == NULL)
 712                 return PMINFO_R_ERROR;
 713
 714         ret = pkgmgrinfo_pkginfo_filter_create(&filter);
 715         if (ret != PMINFO_R_OK) {
 716                 free(locale);
 717                 return ret;
 718         }
 719
 720         ret = pkgmgrinfo_pkginfo_filter_add_string(filter,
 721                         PMINFO_PKGINFO_PROP_PACKAGE_ID, pkgid);
 722         if (ret != PMINFO_R_OK) {
 723                 pkgmgrinfo_pkginfo_filter_destroy(filter);
 724                 free(locale);
 725                 return PMINFO_R_ERROR;
 726         }
 727
 728         ret = pkgmgrinfo_pkginfo_filter_add_bool(filter,
 729                         PMINFO_PKGINFO_PROP_PACKAGE_DISABLE, true);
 730         if (ret != PMINFO_R_OK) {
 731                 pkgmgrinfo_pkginfo_filter_destroy(filter);
 732                 free(locale);
 733                 return PMINFO_R_ERROR;
 734         }
 735
 736         list = g_hash_table_new(g_str_hash, g_str_equal);
 737         if (list == NULL) {
 738                 pkgmgrinfo_pkginfo_filter_destroy(filter);
 739                 free(locale);
 740                 return PMINFO_R_ERROR;
 741         }
 742
 743         ret = _pkginfo_get_packages(uid, locale, filter,
 744                         PMINFO_PKGINFO_GET_ALL, list);
 745         if (!g_hash_table_size(list) && uid != GLOBAL_USER)
 746                 ret = _pkginfo_get_packages(GLOBAL_USER, locale, filter,
 747                                 PMINFO_PKGINFO_GET_ALL, list);
 748
 749         pkgmgrinfo_pkginfo_filter_destroy(filter);
 750         if (ret != PMINFO_R_OK) {
 751                 g_hash_table_destroy(list);
 752                 free(locale);
 753                 return ret;
 754         }
 755
 756         if (!g_hash_table_size(list)) {
 757                 _LOGI("disabled pkginfo for [%s] is not existed for user [%d]",
 758                                 pkgid, uid);
 759                 g_hash_table_destroy(list);
 760                 free(locale);
 761                 return PMINFO_R_ENOENT;
 762         }
 763
 764         info = calloc(1, sizeof(pkgmgr_pkginfo_x));
 765         if (info == NULL) {
 766                 _LOGE("out of memory");
 767                 g_hash_table_destroy(list);
 768                 free(locale);
 769                 return PMINFO_R_ERROR;
 770         }
 771
 772         info->uid = uid;
 773         info->pkg_info = (package_x *)g_hash_table_lookup(list, pkgid);
 774         info->locale = locale;
 775
 776         /* just free list only */
 777         g_hash_table_destroy(list);
 778
 779         *handle = info;
 780
 781         return ret;
 782 }
 783
 784 API int pkgmgrinfo_pkginfo_get_disabled_pkginfo(const char *pkgid,
 785                 pkgmgrinfo_pkginfo_h *handle)
 786 {
 787         return pkgmgrinfo_pkginfo_get_usr_disabled_pkginfo(pkgid, _getuid(),
 788                         handle);
 789 }
 790
 791 API int pkgmgrinfo_pkginfo_get_usr_list_full(pkgmgrinfo_pkg_list_cb pkg_list_cb,
 792                 int flag, void *user_data, uid_t uid)
 793 {
 794         if (pkg_list_cb == NULL) {
 795                 LOGE("invalid parameter");
 796                 return PMINFO_R_EINVAL;
 797         }
 798
 799         return _pkginfo_get_filtered_foreach_pkginfo(uid, NULL, flag,
 800                         pkg_list_cb, user_data);
 801 }
 802
 803 API int pkgmgrinfo_pkginfo_get_list_full(pkgmgrinfo_pkg_list_cb pkg_list_cb,
 804                 int flag, void *user_data)
 805 {
 806         return pkgmgrinfo_pkginfo_get_usr_list_full(pkg_list_cb, flag,
 807                         user_data, _getuid());
 808 }
 809
 810 API int pkgmgrinfo_pkginfo_get_usr_list(pkgmgrinfo_pkg_list_cb pkg_list_cb,
 811                 void *user_data, uid_t uid)
 812 {
 813         if (pkg_list_cb == NULL) {
 814                 LOGE("invalid parameter");
 815                 return PMINFO_R_EINVAL;
 816         }
 817
 818         return _pkginfo_get_filtered_foreach_pkginfo(uid, NULL,
 819                         PMINFO_PKGINFO_GET_ALL, pkg_list_cb, user_data);
 820 }
 821
 822 API int pkgmgrinfo_pkginfo_get_list(pkgmgrinfo_pkg_list_cb pkg_list_cb,
 823                 void *user_data)
 824 {
 825         return pkgmgrinfo_pkginfo_get_usr_list(pkg_list_cb, user_data,
 826                         _getuid());
 827 }
 828
 829 API int pkgmgrinfo_pkginfo_get_usr_disabled_list(
 830                 pkgmgrinfo_pkg_list_cb pkg_list_cb, void *user_data, uid_t uid)
 831 {
 832         int ret;
 833         pkgmgrinfo_pkginfo_filter_h filter;
 834
 835         if (pkg_list_cb == NULL) {
 836                 LOGE("invalid parameter");
 837                 return PMINFO_R_EINVAL;
 838         }
 839
 840         ret = pkgmgrinfo_pkginfo_filter_create(&filter);
 841         if (ret != PMINFO_R_OK)
 842                 return ret;
 843
 844         ret = pkgmgrinfo_pkginfo_filter_add_bool(filter,
 845                         PMINFO_PKGINFO_PROP_PACKAGE_DISABLE, true);
 846         if (ret != PMINFO_R_OK) {
 847                 pkgmgrinfo_pkginfo_filter_destroy(filter);
 848                 return PMINFO_R_ERROR;
 849         }
 850
 851         ret = _pkginfo_get_filtered_foreach_pkginfo(uid, filter,
 852                         PMINFO_PKGINFO_GET_ALL, pkg_list_cb, user_data);
 853
 854         pkgmgrinfo_pkginfo_filter_destroy(filter);
 855
 856         return ret;
 857 }
 858
 859 API int pkgmgrinfo_pkginfo_get_disabled_list(pkgmgrinfo_pkg_list_cb pkg_list_cb,
 860                 void *user_data)
 861 {
 862         return pkgmgrinfo_pkginfo_get_usr_disabled_list(pkg_list_cb, user_data,
 863                         _getuid());
 864 }
 865
 866 API int pkgmgrinfo_pkginfo_get_pkgname(pkgmgrinfo_pkginfo_h handle, char **pkg_name)
 867 {
 868         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
 869
 870         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
 871         retvm_if(pkg_name == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
 872
 873         if (info->pkg_info == NULL || info->pkg_info->package == NULL)
 874                 return PMINFO_R_ERROR;
 875
 876         *pkg_name = (char *)info->pkg_info->package;
 877
 878         return PMINFO_R_OK;
 879 }
 880
 881 API int pkgmgrinfo_pkginfo_get_pkgid(pkgmgrinfo_pkginfo_h handle, char **pkgid)
 882 {
 883         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
 884
 885         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
 886         retvm_if(pkgid == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
 887
 888         if (info->pkg_info == NULL || info->pkg_info->package == NULL)
 889                 return PMINFO_R_ERROR;
 890
 891         *pkgid = (char *)info->pkg_info->package;
 892
 893         return PMINFO_R_OK;
 894 }
 895
 896 API int pkgmgrinfo_pkginfo_get_type(pkgmgrinfo_pkginfo_h handle, char **type)
 897 {
 898         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
 899
 900         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
 901         retvm_if(type == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
 902
 903         if (info->pkg_info == NULL)
 904                 return PMINFO_R_ERROR;
 905
 906         if (info->pkg_info->type == NULL)
 907                 *type = "";
 908         else
 909                 *type = (char *)info->pkg_info->type;
 910
 911         return PMINFO_R_OK;
 912 }
 913
 914 API int pkgmgrinfo_pkginfo_get_version(pkgmgrinfo_pkginfo_h handle, char **version)
 915 {
 916         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
 917
 918         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
 919         retvm_if(version == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
 920
 921         if (info->pkg_info == NULL)
 922                 return PMINFO_R_ERROR;
 923
 924         if (info->pkg_info->version == NULL)
 925                 *version = "";
 926         else
 927                 *version = (char *)info->pkg_info->version;
 928
 929         return PMINFO_R_OK;
 930 }
 931
 932 API int pkgmgrinfo_pkginfo_get_api_version(pkgmgrinfo_pkginfo_h handle, char **api_version)
 933 {
 934         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
 935
 936         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
 937         retvm_if(api_version == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
 938
 939         if (info->pkg_info == NULL)
 940                 return PMINFO_R_ERROR;
 941
 942         if (info->pkg_info->api_version == NULL)
 943                 *api_version = "";
 944         else
 945                 *api_version = (char *)info->pkg_info->api_version;
 946
 947         return PMINFO_R_OK;
 948 }
 949
 950 API int pkgmgrinfo_pkginfo_get_tep_name(pkgmgrinfo_pkginfo_h handle, char **tep_name)
 951 {
 952         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
 953
 954         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
 955         retvm_if(tep_name == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
 956
 957         if (info->pkg_info == NULL || info->pkg_info->tep_name == NULL)
 958                 return PMINFO_R_ERROR;
 959
 960         *tep_name = (char *)info->pkg_info->tep_name;
 961
 962         return PMINFO_R_OK;
 963 }
 964
 965 API int pkgmgrinfo_pkginfo_get_zip_mount_file(pkgmgrinfo_pkginfo_h handle, char **zip_mount_file)
 966 {
 967         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
 968
 969         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
 970         retvm_if(zip_mount_file == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
 971
 972         if (info->pkg_info == NULL)
 973                 return PMINFO_R_ERROR;
 974
 975         if (info->pkg_info->zip_mount_file == NULL)
 976                 *zip_mount_file = "";
 977         else
 978                 *zip_mount_file = (char *)info->pkg_info->zip_mount_file;
 979
 980         return PMINFO_R_OK;
 981 }
 982
 983 API int pkgmgrinfo_pkginfo_get_install_location(pkgmgrinfo_pkginfo_h handle, pkgmgrinfo_install_location *location)
 984 {
 985         char *val;
 986         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
 987
 988         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
 989         retvm_if(location == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
 990
 991         if (info->pkg_info == NULL || info->pkg_info->installlocation == NULL)
 992                 return PMINFO_R_ERROR;
 993
 994         val = (char *)info->pkg_info->installlocation;
 995         if (strcmp(val, "internal-only") == 0)
 996                 *location = PMINFO_INSTALL_LOCATION_INTERNAL_ONLY;
 997         else if (strcmp(val, "prefer-external") == 0)
 998                 *location = PMINFO_INSTALL_LOCATION_PREFER_EXTERNAL;
 999         else
1000                 *location = PMINFO_INSTALL_LOCATION_AUTO;
1001
1002         return PMINFO_R_OK;
1003 }
1004
1005 API int pkgmgrinfo_pkginfo_get_package_size(pkgmgrinfo_pkginfo_h handle, int *size)
1006 {
1007         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1008         char *temp = NULL;
1009
1010         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1011         retvm_if(size == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1012
1013         if (info->pkg_info == NULL)
1014                 return PMINFO_R_ERROR;
1015
1016         if (info->pkg_info->package_size == NULL) {
1017                 temp = strdup("");
1018                 if (temp == NULL) {
1019                         _LOGE("out of memory");
1020                         return PMINFO_R_ERROR;
1021                 } else {
1022                         info->pkg_info->package_size = temp;
1023                 }
1024         }
1025
1026         *size = atoi((char *)info->pkg_info->package_size);
1027
1028         return PMINFO_R_OK;
1029 }
1030
1031 API int pkgmgrinfo_pkginfo_get_icon(pkgmgrinfo_pkginfo_h handle, char **icon)
1032 {
1033         icon_x *ptr;
1034         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1035
1036         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL");
1037         retvm_if(icon == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL");
1038
1039         if (info->pkg_info == NULL || info->pkg_info->icon == NULL)
1040                 return PMINFO_R_ERROR;
1041
1042         ptr = (icon_x *)info->pkg_info->icon->data;
1043         if (ptr == NULL)
1044                 return PMINFO_R_ERROR;
1045
1046         /* TODO : should we return empty string if there was no icon? */
1047         if (ptr->text == NULL)
1048                 *icon = "";
1049         else
1050                 *icon = ptr->text;
1051
1052         return PMINFO_R_OK;
1053 }
1054
1055 API int pkgmgrinfo_pkginfo_get_label(pkgmgrinfo_pkginfo_h handle, char **label)
1056 {
1057         label_x *ptr;
1058         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1059
1060         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL");
1061         retvm_if(label == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL");
1062
1063         if (info->pkg_info == NULL || info->pkg_info->label == NULL)
1064                 return PMINFO_R_ERROR;
1065
1066         ptr = (label_x *)info->pkg_info->label->data;
1067         if (ptr == NULL)
1068                 return PMINFO_R_ERROR;
1069
1070         /* TODO : should we return empty string if there was no label? */
1071         if (ptr->text == NULL)
1072                 *label = "";
1073         else
1074                 *label = ptr->text;
1075
1076         return PMINFO_R_OK;
1077 }
1078
1079 API int pkgmgrinfo_pkginfo_get_description(pkgmgrinfo_pkginfo_h handle, char **description)
1080 {
1081         description_x *ptr;
1082         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1083
1084         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1085         retvm_if(description == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1086
1087         if (info->pkg_info == NULL || info->pkg_info->description == NULL)
1088                 return PMINFO_R_ERROR;
1089
1090         ptr = (description_x *)info->pkg_info->description->data;
1091         if (ptr == NULL)
1092                 return PMINFO_R_ERROR;
1093
1094         if (ptr->text == NULL)
1095                 *description = "";
1096         else
1097                 *description = (char *)ptr->text;
1098
1099         return PMINFO_R_OK;
1100 }
1101
1102 API int pkgmgrinfo_pkginfo_get_author_name(pkgmgrinfo_pkginfo_h handle, char **author_name)
1103 {
1104         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1105         author_x *author;
1106
1107         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1108         retvm_if(author_name == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1109
1110         if (info->pkg_info == NULL || info->pkg_info->author == NULL)
1111                 return PMINFO_R_ERROR;
1112
1113         author = (author_x *)info->pkg_info->author->data;
1114         if (author == NULL)
1115                 return PMINFO_R_ERROR;
1116
1117         if (author->text == NULL)
1118                 *author_name = "";
1119         else
1120                 *author_name = (char *)author->text;
1121
1122         return PMINFO_R_OK;
1123 }
1124
1125 API int pkgmgrinfo_pkginfo_get_author_email(pkgmgrinfo_pkginfo_h handle, char **author_email)
1126 {
1127         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1128         author_x *author;
1129
1130         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1131         retvm_if(author_email == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1132
1133         if (info->pkg_info == NULL || info->pkg_info->author == NULL)
1134                 return PMINFO_R_ERROR;
1135
1136         author = (author_x *)info->pkg_info->author->data;
1137         if (author == NULL)
1138                 return PMINFO_R_ERROR;
1139
1140         if (author->email == NULL)
1141                 *author_email = "";
1142         else
1143                 *author_email = (char *)author->email;
1144
1145         return PMINFO_R_OK;
1146 }
1147
1148 API int pkgmgrinfo_pkginfo_get_author_href(pkgmgrinfo_pkginfo_h handle, char **author_href)
1149 {
1150         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1151         author_x *author;
1152
1153         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1154         retvm_if(author_href == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1155
1156         if (info->pkg_info == NULL || info->pkg_info->author == NULL)
1157                 return PMINFO_R_ERROR;
1158
1159         author = (author_x *)info->pkg_info->author->data;
1160         if (author == NULL)
1161                 return PMINFO_R_ERROR;
1162
1163         if (author->href == NULL)
1164                 *author_href = "";
1165         else
1166                 *author_href = (char *)author->href;
1167
1168         return PMINFO_R_OK;
1169 }
1170
1171 API int pkgmgrinfo_pkginfo_get_installed_storage(pkgmgrinfo_pkginfo_h handle, pkgmgrinfo_installed_storage *storage)
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(storage == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1177
1178         if (info->pkg_info == NULL || info->pkg_info->installed_storage == NULL)
1179                 return PMINFO_R_ERROR;
1180
1181         if (strcmp(info->pkg_info->installed_storage, "installed_internal") == 0)
1182                 *storage = PMINFO_INTERNAL_STORAGE;
1183         else if (strcmp(info->pkg_info->installed_storage, "installed_external") == 0)
1184                 *storage = PMINFO_EXTERNAL_STORAGE;
1185         else
1186                 return PMINFO_R_ERROR;
1187
1188         return PMINFO_R_OK;
1189 }
1190
1191 API int pkgmgrinfo_pkginfo_get_installed_time(pkgmgrinfo_pkginfo_h handle, int *installed_time)
1192 {
1193         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1194
1195         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1196         retvm_if(installed_time == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1197
1198         if (info->pkg_info == NULL || info->pkg_info->installed_time == NULL)
1199                 return PMINFO_R_ERROR;
1200
1201         *installed_time = atoi(info->pkg_info->installed_time);
1202
1203         return PMINFO_R_OK;
1204 }
1205
1206 API int pkgmgrinfo_pkginfo_get_storeclientid(pkgmgrinfo_pkginfo_h handle, char **storeclientid)
1207 {
1208         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1209
1210         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1211         retvm_if(storeclientid == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1212
1213         if (info->pkg_info == NULL)
1214                 return PMINFO_R_ERROR;
1215
1216         if (info->pkg_info->storeclient_id == NULL)
1217                 *storeclientid = "";
1218         else
1219                 *storeclientid = (char *)info->pkg_info->storeclient_id;
1220
1221         return PMINFO_R_OK;
1222 }
1223
1224 API int pkgmgrinfo_pkginfo_get_mainappid(pkgmgrinfo_pkginfo_h handle, char **mainappid)
1225 {
1226         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1227
1228         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1229         retvm_if(mainappid == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1230
1231         if (info->pkg_info == NULL || info->pkg_info->mainapp_id == NULL)
1232                 return PMINFO_R_ERROR;
1233
1234         *mainappid = (char *)info->pkg_info->mainapp_id;
1235
1236         return PMINFO_R_OK;
1237 }
1238
1239 API int pkgmgrinfo_pkginfo_get_url(pkgmgrinfo_pkginfo_h handle, char **url)
1240 {
1241         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1242
1243         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1244         retvm_if(url == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1245
1246         if (info->pkg_info == NULL)
1247                 return PMINFO_R_ERROR;
1248
1249         if (info->pkg_info->package_url == NULL)
1250                 *url = "";
1251         else
1252                 *url = (char *)info->pkg_info->package_url;
1253
1254         return PMINFO_R_OK;
1255 }
1256
1257 API int pkgmgrinfo_pkginfo_get_root_path(pkgmgrinfo_pkginfo_h handle, char **path)
1258 {
1259         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1260
1261         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1262         retvm_if(path == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1263
1264         if (info->pkg_info == NULL || info->pkg_info->root_path == NULL)
1265                 return PMINFO_R_ERROR;
1266
1267         *path = (char *)info->pkg_info->root_path;
1268
1269         return PMINFO_R_OK;
1270 }
1271
1272 API int pkgmgrinfo_pkginfo_get_csc_path(pkgmgrinfo_pkginfo_h handle, char **path)
1273 {
1274         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1275
1276         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1277         retvm_if(path == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1278
1279         if (info->pkg_info == NULL)
1280                 return PMINFO_R_ERROR;
1281
1282         if (info->pkg_info->csc_path == NULL)
1283                 *path = "";
1284         else
1285                 *path = (char *)info->pkg_info->csc_path;
1286
1287         return PMINFO_R_OK;
1288 }
1289
1290 API int pkgmgrinfo_pkginfo_get_support_mode(pkgmgrinfo_pkginfo_h handle, int *support_mode)
1291 {
1292         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1293         retvm_if(support_mode == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1294
1295         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1296         if (info->pkg_info->support_mode)
1297                 *support_mode = atoi(info->pkg_info->support_mode);
1298         else
1299                 *support_mode = 0;
1300
1301         return PMINFO_R_OK;
1302 }
1303
1304 API int pkgmgrinfo_pkginfo_is_accessible(pkgmgrinfo_pkginfo_h handle, bool *accessible)
1305 {
1306         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1307         retvm_if(accessible == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1308
1309 #if 0 /* smack issue occured, check later */
1310         char *pkgid = NULL;
1311         pkgmgrinfo_pkginfo_get_pkgid(handle, &pkgid);
1312         if (pkgid == NULL) {
1313                  _LOGD("invalid func parameters\n");
1314                  return PMINFO_R_ERROR;
1315         }
1316          _LOGD("pkgmgr_get_pkg_external_validation() called\n");
1317
1318         FILE *fp = NULL;
1319         char app_mmc_path[FILENAME_MAX] = { 0, };
1320         char app_dir_path[FILENAME_MAX] = { 0, };
1321         char app_mmc_internal_path[FILENAME_MAX] = { 0, };
1322         snprintf(app_dir_path, FILENAME_MAX, "%s%s", PKG_INSTALLATION_PATH, pkgid);
1323         snprintf(app_mmc_path, FILENAME_MAX, "%s%s", PKG_SD_PATH, pkgid);
1324         snprintf(app_mmc_internal_path, FILENAME_MAX, "%s%s/.mmc", PKG_INSTALLATION_PATH, pkgid);
1325
1326         /*check whether application is in external memory or not */
1327         fp = fopen(app_mmc_path, "r");
1328         if (fp == NULL) {
1329                 _LOGD(" app path in external memory not accesible\n");
1330         } else {
1331                 fclose(fp);
1332                 fp = NULL;
1333                 *accessible = 1;
1334                 _LOGD("pkgmgr_get_pkg_external_validation() : SD_CARD \n");
1335                 return PMINFO_R_OK;
1336         }
1337
1338         /*check whether application is in internal or not */
1339         if (fp == NULL) {
1340                 _LOGD(" app path in internal memory not accesible\n");
1341                 *accessible = 0;
1342                 return PMINFO_R_ERROR;
1343         } else {
1344                 fclose(fp);
1345                 /*check whether the application is installed in SD card
1346                 but SD card is not present*/
1347                 fp = fopen(app_mmc_internal_path, "r");
1348                 if (fp == NULL) {
1349                         *accessible = 1;
1350                         _LOGD("pkgmgr_get_pkg_external_validation() : INTERNAL_MEM \n");
1351                         return PMINFO_R_OK;
1352                 } else {
1353                         *accessible = 0;
1354                         _LOGD("pkgmgr_get_pkg_external_validation() : ERROR_MMC_STATUS \n");
1355                 }
1356                 fclose(fp);
1357         }
1358
1359         _LOGD("pkgmgr_get_pkg_external_validation() end\n");
1360 #endif
1361
1362         *accessible = 1;
1363         return PMINFO_R_OK;
1364 }
1365
1366 API int pkgmgrinfo_pkginfo_is_removable(pkgmgrinfo_pkginfo_h handle, bool *removable)
1367 {
1368         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1369
1370         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1371         retvm_if(removable == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1372
1373         if (info->pkg_info == NULL || info->pkg_info->removable == NULL)
1374                 return PMINFO_R_ERROR;
1375
1376         *removable = _get_bool_value(info->pkg_info->removable);
1377
1378         return PMINFO_R_OK;
1379 }
1380
1381 API int pkgmgrinfo_pkginfo_is_movable(pkgmgrinfo_pkginfo_h handle, bool *movable)
1382 {
1383         char *val;
1384         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1385
1386         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1387         retvm_if(movable == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1388
1389         if (info->pkg_info == NULL || info->pkg_info->installlocation == NULL)
1390                 return PMINFO_R_ERROR;
1391
1392         val = (char *)info->pkg_info->installlocation;
1393         if (strcmp(val, "internal-only") == 0)
1394                 *movable = 0;
1395         else if (strcmp(val, "prefer-external") == 0)
1396                 *movable = 1;
1397         else
1398                 *movable = 1;
1399
1400         return PMINFO_R_OK;
1401 }
1402
1403 API int pkgmgrinfo_pkginfo_is_preload(pkgmgrinfo_pkginfo_h handle, bool *preload)
1404 {
1405         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1406
1407         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1408         retvm_if(preload == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1409
1410         if (info->pkg_info == NULL || info->pkg_info->preload == NULL)
1411                 return PMINFO_R_ERROR;
1412
1413         *preload = _get_bool_value(info->pkg_info->preload);
1414
1415         return PMINFO_R_OK;
1416 }
1417
1418 API int pkgmgrinfo_pkginfo_is_system(pkgmgrinfo_pkginfo_h handle, bool *system)
1419 {
1420         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1421
1422         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1423         retvm_if(system == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1424
1425         if (info->pkg_info == NULL || info->pkg_info->system == NULL)
1426                 return PMINFO_R_ERROR;
1427
1428         *system = _get_bool_value(info->pkg_info->system);
1429
1430         return PMINFO_R_OK;
1431 }
1432
1433 API int pkgmgrinfo_pkginfo_is_readonly(pkgmgrinfo_pkginfo_h handle, bool *readonly)
1434 {
1435         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1436
1437         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1438         retvm_if(readonly == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1439
1440         if (info->pkg_info == NULL || info->pkg_info->readonly == NULL)
1441                 return PMINFO_R_ERROR;
1442
1443         *readonly = _get_bool_value(info->pkg_info->readonly);
1444
1445         return PMINFO_R_OK;
1446 }
1447
1448 API int pkgmgrinfo_pkginfo_is_update(pkgmgrinfo_pkginfo_h handle, bool *update)
1449 {
1450         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1451
1452         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1453         retvm_if(update == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1454
1455         if (info->pkg_info == NULL || info->pkg_info->update == NULL)
1456                 return PMINFO_R_ERROR;
1457
1458         *update = _get_bool_value(info->pkg_info->update);
1459
1460         return PMINFO_R_OK;
1461 }
1462
1463 API int pkgmgrinfo_pkginfo_is_support_disable(pkgmgrinfo_pkginfo_h handle, bool *support_disable)
1464 {
1465         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1466
1467         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1468         retvm_if(support_disable == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1469
1470         if (info->pkg_info == NULL || info->pkg_info->support_disable == NULL)
1471                 return PMINFO_R_ERROR;
1472
1473         *support_disable = _get_bool_value(info->pkg_info->support_disable);
1474
1475         return PMINFO_R_OK;
1476 }
1477
1478 API int pkgmgrinfo_pkginfo_is_global(pkgmgrinfo_pkginfo_h handle, bool *global)
1479 {
1480         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1481
1482         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1483         retvm_if(global == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1484
1485         if (info->pkg_info == NULL || info->pkg_info->for_all_users == NULL)
1486                 return PMINFO_R_ERROR;
1487
1488         *global = _get_bool_value(info->pkg_info->for_all_users);
1489
1490         return PMINFO_R_OK;
1491 }
1492
1493 API int pkgmgrinfo_pkginfo_is_for_all_users(pkgmgrinfo_pkginfo_h handle, bool *for_all_users)
1494 {
1495         return pkgmgrinfo_pkginfo_is_global(handle, for_all_users);
1496 }
1497
1498 API int pkgmgrinfo_pkginfo_destroy_pkginfo(pkgmgrinfo_pkginfo_h handle)
1499 {
1500         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1501
1502         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1503
1504         __cleanup_pkginfo(info);
1505
1506         return PMINFO_R_OK;
1507 }
1508
1509 API int pkgmgrinfo_pkginfo_filter_create(pkgmgrinfo_pkginfo_filter_h *handle)
1510 {
1511         pkgmgrinfo_filter_x *filter;
1512
1513         retvm_if(handle == NULL, PMINFO_R_EINVAL, "Filter handle output parameter is NULL\n");
1514
1515         filter = (pkgmgrinfo_filter_x*)calloc(1, sizeof(pkgmgrinfo_filter_x));
1516         if (filter == NULL) {
1517                 _LOGE("Out of Memory!!!");
1518                 return PMINFO_R_ERROR;
1519         }
1520
1521         *handle = filter;
1522
1523         return PMINFO_R_OK;
1524 }
1525
1526 API int pkgmgrinfo_pkginfo_filter_destroy(pkgmgrinfo_pkginfo_filter_h handle)
1527 {
1528         pkgmgrinfo_filter_x *filter = (pkgmgrinfo_filter_x *)handle;
1529
1530         retvm_if(handle == NULL, PMINFO_R_EINVAL, "Filter handle input parameter is NULL\n");
1531
1532         if (filter->list) {
1533                 g_slist_foreach(filter->list, __destroy_each_node, NULL);
1534                 g_slist_free(filter->list);
1535         }
1536
1537         free(filter);
1538
1539         return PMINFO_R_OK;
1540 }
1541
1542 API int pkgmgrinfo_pkginfo_filter_add_int(pkgmgrinfo_pkginfo_filter_h handle,
1543                                 const char *property, const int value)
1544 {
1545         char buf[PKG_VALUE_STRING_LEN_MAX] = {'\0'};
1546         char *val;
1547         GSList *link;
1548         int prop;
1549         pkgmgrinfo_filter_x *filter = (pkgmgrinfo_filter_x *)handle;
1550         pkgmgrinfo_node_x *node;
1551
1552         retvm_if(handle == NULL, PMINFO_R_EINVAL, "Filter handle input parameter is NULL\n");
1553         retvm_if(property == NULL, PMINFO_R_EINVAL, "Filter handle input parameter is NULL\n");
1554
1555         prop = _pminfo_pkginfo_convert_to_prop_int(property);
1556         if (prop < E_PMINFO_PKGINFO_PROP_PACKAGE_MIN_INT ||
1557                 prop > E_PMINFO_PKGINFO_PROP_PACKAGE_MAX_INT) {
1558                 _LOGE("Invalid Integer Property\n");
1559                 return PMINFO_R_EINVAL;
1560         }
1561         node = (pkgmgrinfo_node_x *)calloc(1, sizeof(pkgmgrinfo_node_x));
1562         if (node == NULL) {
1563                 _LOGE("Out of Memory!!!\n");
1564                 return PMINFO_R_ERROR;
1565         }
1566         snprintf(buf, PKG_VALUE_STRING_LEN_MAX - 1, "%d", value);
1567         val = strndup(buf, PKG_VALUE_STRING_LEN_MAX - 1);
1568         if (val == NULL) {
1569                 _LOGE("Out of Memory\n");
1570                 free(node);
1571                 return PMINFO_R_ERROR;
1572         }
1573         node->prop = prop;
1574         node->value = val;
1575         /*If API is called multiple times for same property, we should override the previous values.
1576         Last value set will be used for filtering.*/
1577         link = g_slist_find_custom(filter->list, (gconstpointer)node, __compare_func);
1578         if (link)
1579                 filter->list = g_slist_delete_link(filter->list, link);
1580         filter->list = g_slist_append(filter->list, (gpointer)node);
1581         return PMINFO_R_OK;
1582
1583 }
1584
1585 API int pkgmgrinfo_pkginfo_filter_add_bool(pkgmgrinfo_pkginfo_filter_h handle,
1586                                 const char *property, const bool value)
1587 {
1588         char *val;
1589         GSList *link;
1590         int prop;
1591         pkgmgrinfo_filter_x *filter = (pkgmgrinfo_filter_x *)handle;
1592         pkgmgrinfo_node_x *node;
1593
1594         retvm_if(handle == NULL, PMINFO_R_EINVAL, "Filter handle input parameter is NULL\n");
1595         retvm_if(property == NULL, PMINFO_R_EINVAL, "Filter handle input parameter is NULL\n");
1596
1597         prop = _pminfo_pkginfo_convert_to_prop_bool(property);
1598         if (prop < E_PMINFO_PKGINFO_PROP_PACKAGE_MIN_BOOL ||
1599                 prop > E_PMINFO_PKGINFO_PROP_PACKAGE_MAX_BOOL) {
1600                 _LOGE("Invalid Boolean Property\n");
1601                 return PMINFO_R_EINVAL;
1602         }
1603         node = (pkgmgrinfo_node_x *)calloc(1, sizeof(pkgmgrinfo_node_x));
1604         if (node == NULL) {
1605                 _LOGE("Out of Memory!!!\n");
1606                 return PMINFO_R_ERROR;
1607         }
1608         if (value)
1609                 val = strndup("true", 4);
1610         else
1611                 val = strndup("false", 5);
1612         if (val == NULL) {
1613                 _LOGE("Out of Memory\n");
1614                 free(node);
1615                 return PMINFO_R_ERROR;
1616         }
1617         node->prop = prop;
1618         node->value = val;
1619         /*If API is called multiple times for same property, we should override the previous values.
1620         Last value set will be used for filtering.*/
1621         link = g_slist_find_custom(filter->list, (gconstpointer)node, __compare_func);
1622         if (link)
1623                 filter->list = g_slist_delete_link(filter->list, link);
1624         filter->list = g_slist_append(filter->list, (gpointer)node);
1625         return PMINFO_R_OK;
1626
1627 }
1628
1629 API int pkgmgrinfo_pkginfo_filter_add_string(pkgmgrinfo_pkginfo_filter_h handle,
1630                                 const char *property, const char *value)
1631 {
1632         char *val;
1633         GSList *link;
1634         int prop;
1635         pkgmgrinfo_filter_x *filter = (pkgmgrinfo_filter_x *)handle;
1636         pkgmgrinfo_node_x *node;
1637
1638         retvm_if(handle == NULL, PMINFO_R_EINVAL, "Filter handle input parameter is NULL\n");
1639         retvm_if(property == NULL, PMINFO_R_EINVAL, "Filter handle input parameter is NULL\n");
1640         retvm_if(value == NULL, PMINFO_R_EINVAL, "Filter handle input parameter is NULL\n");
1641
1642         prop = _pminfo_pkginfo_convert_to_prop_str(property);
1643         if (prop < E_PMINFO_PKGINFO_PROP_PACKAGE_MIN_STR ||
1644                 prop > E_PMINFO_PKGINFO_PROP_PACKAGE_MAX_STR) {
1645                 _LOGE("Invalid String Property\n");
1646                 return PMINFO_R_EINVAL;
1647         }
1648         node = (pkgmgrinfo_node_x *)calloc(1, sizeof(pkgmgrinfo_node_x));
1649         if (node == NULL) {
1650                 _LOGE("Out of Memory!!!\n");
1651                 return PMINFO_R_ERROR;
1652         }
1653         if (strcmp(value, PMINFO_PKGINFO_INSTALL_LOCATION_AUTO) == 0)
1654                 val = strndup("auto", PKG_STRING_LEN_MAX - 1);
1655         else if (strcmp(value, PMINFO_PKGINFO_INSTALL_LOCATION_INTERNAL) == 0)
1656                 val = strndup("internal-only", PKG_STRING_LEN_MAX - 1);
1657         else if (strcmp(value, PMINFO_PKGINFO_INSTALL_LOCATION_EXTERNAL) == 0)
1658                 val = strndup("prefer-external", PKG_STRING_LEN_MAX - 1);
1659         else if (strcmp(value, "installed_internal") == 0)
1660                 val = strndup("installed_internal", PKG_STRING_LEN_MAX - 1);
1661         else if (strcmp(value, "installed_external") == 0)
1662                 val = strndup("installed_external", PKG_STRING_LEN_MAX - 1);
1663         else
1664                 val = strndup(value, PKG_STRING_LEN_MAX - 1);
1665         if (val == NULL) {
1666                 _LOGE("Out of Memory\n");
1667                 free(node);
1668                 return PMINFO_R_ERROR;
1669         }
1670         node->prop = prop;
1671         node->value = val;
1672         /*If API is called multiple times for same property, we should override the previous values.
1673         Last value set will be used for filtering.*/
1674         link = g_slist_find_custom(filter->list, (gconstpointer)node, __compare_func);
1675         if (link)
1676                 filter->list = g_slist_delete_link(filter->list, link);
1677         filter->list = g_slist_append(filter->list, (gpointer)node);
1678         return PMINFO_R_OK;
1679
1680 }
1681
1682 API int pkgmgrinfo_pkginfo_usr_filter_count(pkgmgrinfo_pkginfo_filter_h handle, int *count, uid_t uid)
1683 {
1684         int ret;
1685         char *locale;
1686         GHashTable *list = NULL;
1687
1688         if (handle == NULL || count == NULL) {
1689                 _LOGE("invalid parameter");
1690                 return PMINFO_R_EINVAL;
1691         }
1692
1693         locale = _get_system_locale();
1694         if (locale == NULL)
1695                 return PMINFO_R_ERROR;
1696
1697         list = g_hash_table_new_full(g_str_hash, g_str_equal, NULL,
1698                         __free_packages);
1699         if (list == NULL) {
1700                 free(locale);
1701                 return PMINFO_R_ERROR;
1702         }
1703
1704         ret = _pkginfo_get_packages(uid, locale,
1705                         (pkgmgrinfo_filter_x *)handle, 0, list);
1706         if (ret == PMINFO_R_OK && uid != GLOBAL_USER)
1707                 ret = _pkginfo_get_packages(GLOBAL_USER, locale, handle, 0,
1708                                 list);
1709
1710         if (ret != PMINFO_R_OK) {
1711                 g_hash_table_destroy(list);
1712                 free(locale);
1713                 return PMINFO_R_ERROR;
1714         }
1715
1716         *count = g_hash_table_size(list);
1717
1718         g_hash_table_destroy(list);
1719         free(locale);
1720
1721         return PMINFO_R_OK;
1722 }
1723
1724 API int pkgmgrinfo_pkginfo_filter_count(pkgmgrinfo_pkginfo_filter_h handle, int *count)
1725 {
1726         return pkgmgrinfo_pkginfo_usr_filter_count(handle, count, _getuid());
1727 }
1728
1729 API int pkgmgrinfo_pkginfo_usr_filter_foreach_pkginfo(
1730                 pkgmgrinfo_pkginfo_filter_h handle,
1731                 pkgmgrinfo_pkg_list_cb pkg_cb, void *user_data, uid_t uid)
1732 {
1733         if (handle == NULL || pkg_cb == NULL) {
1734                 LOGE("invalid parameter");
1735                 return PMINFO_R_EINVAL;
1736         }
1737
1738         return _pkginfo_get_filtered_foreach_pkginfo(uid, handle,
1739                         PMINFO_PKGINFO_GET_ALL, pkg_cb, user_data);
1740 }
1741
1742 API int pkgmgrinfo_pkginfo_filter_foreach_pkginfo(pkgmgrinfo_pkginfo_filter_h handle,
1743                                 pkgmgrinfo_pkg_list_cb pkg_cb, void *user_data)
1744 {
1745         return pkgmgrinfo_pkginfo_usr_filter_foreach_pkginfo(handle, pkg_cb, user_data, _getuid());
1746 }
1747
1748 API int pkgmgrinfo_pkginfo_foreach_privilege(pkgmgrinfo_pkginfo_h handle,
1749                         pkgmgrinfo_pkg_privilege_list_cb privilege_func, void *user_data)
1750 {
1751         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL");
1752         retvm_if(privilege_func == NULL, PMINFO_R_EINVAL, "Callback function is NULL");
1753         int ret;
1754         privilege_x *privilege;
1755         GList *tmp;
1756         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1757
1758         if (info->pkg_info == NULL)
1759                 return PMINFO_R_ERROR;
1760
1761         for (tmp = info->pkg_info->privileges; tmp; tmp = tmp->next) {
1762                 privilege = (privilege_x *)tmp->data;
1763                 if (privilege == NULL)
1764                         continue;
1765                 ret = privilege_func(privilege->value, user_data);
1766                 if (ret < 0)
1767                         break;
1768         }
1769         return PMINFO_R_OK;
1770 }