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