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