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