src/pkgmgrinfo_pkginfo.c

   1 /*
   2  * pkgmgr-info
   3  *
   4  * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Contact: Jayoun Lee <airjany@samsung.com>, Sewook Park <sewook7.park@samsung.com>,
   7  * Jaeho Lee <jaeho81.lee@samsung.com>, Shobhit Srivastava <shobhit.s@samsung.com>
   8  *
   9  * Licensed under the Apache License, Version 2.0 (the "License");
  10  * you may not use this file except in compliance with the License.
  11  * You may obtain a copy of the License at
  12  *
  13  * http://www.apache.org/licenses/LICENSE-2.0
  14  *
  15  * Unless required by applicable law or agreed to in writing, software
  16  * distributed under the License is distributed on an "AS IS" BASIS,
  17  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  18  * See the License for the specific language governing permissions and
  19  * limitations under the License.
  20  *
  21  */
  22
  23 #define _GNU_SOURCE
  24 #include <stdio.h>
  25 #include <stdlib.h>
  26 #include <string.h>
  27 #include <stdbool.h>
  28 #include <unistd.h>
  29 #include <ctype.h>
  30 #include <sys/smack.h>
  31 #include <linux/limits.h>
  32 #include <libgen.h>
  33 #include <sys/stat.h>
  34
  35 #include <sqlite3.h>
  36 #include <glib.h>
  37
  38 #include "pkgmgrinfo_basic.h"
  39 #include "pkgmgrinfo_private.h"
  40 #include "pkgmgrinfo_debug.h"
  41 #include "pkgmgr-info.h"
  42
  43 static bool _get_bool_value(const char *str)
  44 {
  45         if (str && !strcmp(str, "true"))
  46                 return true;
  47         else
  48                 return false;
  49 }
  50
  51 static gint __compare_func(gconstpointer data1, gconstpointer data2)
  52 {
  53         pkgmgrinfo_node_x *node1 = (pkgmgrinfo_node_x *)data1;
  54         pkgmgrinfo_node_x *node2 = (pkgmgrinfo_node_x *)data2;
  55         if (node1->prop == node2->prop)
  56                 return 0;
  57         else if (node1->prop > node2->prop)
  58                 return 1;
  59         else
  60                 return -1;
  61 }
  62
  63 static gint __pkg_disable_chk_func(gconstpointer data1, gconstpointer data2)
  64 {
  65         pkgmgrinfo_node_x *node = (pkgmgrinfo_node_x *)data1;
  66
  67         if (node->prop == E_PMINFO_PKGINFO_PROP_PACKAGE_DISABLE)
  68                 return 0;
  69         else
  70                 return 1;
  71 }
  72
  73 static void __destroy_each_node(gpointer data, gpointer user_data)
  74 {
  75         ret_if(data == NULL);
  76         pkgmgrinfo_node_x *node = (pkgmgrinfo_node_x *)data;
  77         if (node->value) {
  78                 free(node->value);
  79                 node->value = NULL;
  80         }
  81         if (node->key) {
  82                 free(node->key);
  83                 node->key = NULL;
  84         }
  85         free(node);
  86         node = NULL;
  87 }
  88
  89 static void __destroy_metadata_node(gpointer data)
  90 {
  91         pkgmgrinfo_metadata_node_x *node = (pkgmgrinfo_metadata_node_x *)data;
  92         if (node->key)
  93                 free(node->key);
  94         if (node->value)
  95                 free(node->value);
  96         free(node);
  97 }
  98
  99 static void __cleanup_pkginfo(pkgmgr_pkginfo_x *data)
 100 {
 101         ret_if(data == NULL);
 102         if (data->locale) {
 103                 free((void *)data->locale);
 104                 data->locale = NULL;
 105         }
 106
 107         pkgmgrinfo_basic_free_package(data->pkg_info);
 108         free((void *)data);
 109         data = NULL;
 110         return;
 111 }
 112
 113 long long _pkgmgr_calculate_dir_size(char *dirname)
 114 {
 115         long long total = 0;
 116         long long ret = 0;
 117         int q = 0; /*quotient*/
 118         int r = 0; /*remainder*/
 119         DIR *dp = NULL;
 120         struct dirent *ep;
 121         struct stat fileinfo;
 122         char abs_filename[FILENAME_MAX] = { 0, };
 123         retvm_if(dirname == NULL, PMINFO_R_ERROR, "dirname is NULL");
 124
 125         dp = opendir(dirname);
 126         if (dp == NULL) {
 127                 _LOGE("Couldn't open the directory\n");
 128                 return -1;
 129         }
 130
 131         for (ep = readdir(dp); ep != NULL; ep = readdir(dp)) {
 132                 if (!strcmp(ep->d_name, ".") ||
 133                         !strcmp(ep->d_name, "..")) {
 134                         continue;
 135                 }
 136                 snprintf(abs_filename, FILENAME_MAX, "%s/%s", dirname,
 137                          ep->d_name);
 138                 if (lstat(abs_filename, &fileinfo) < 0)
 139                         perror(abs_filename);
 140                 else {
 141                         if (S_ISDIR(fileinfo.st_mode)) {
 142                                 total += fileinfo.st_size;
 143                                 if (strcmp(ep->d_name, ".")
 144                                     && strcmp(ep->d_name, "..")) {
 145                                         ret = _pkgmgr_calculate_dir_size
 146                                             (abs_filename);
 147                                         total = total + ret;
 148                                 }
 149                         } else if (S_ISLNK(fileinfo.st_mode)) {
 150                                 continue;
 151                         } else {
 152                                 /*It is a file. Calculate the actual
 153                                 size occupied (in terms of 4096 blocks)*/
 154                         q = (fileinfo.st_size / BLOCK_SIZE);
 155                         r = (fileinfo.st_size % BLOCK_SIZE);
 156                         if (r)
 157                                 q = q + 1;
 158                         total += q * BLOCK_SIZE;
 159                         }
 160                 }
 161         }
 162         (void)closedir(dp);
 163         return total;
 164
 165 }
 166
 167 static int _pkginfo_add_description_info_into_list(const char *locale,
 168                 char *record, GList **description)
 169 {
 170         description_x *info;
 171
 172         info = calloc(1, sizeof(description_x));
 173         if (info == NULL) {
 174                 LOGE("out of memory");
 175                 return PMINFO_R_ERROR;
 176         }
 177         info->lang = strdup(locale);
 178         info->text = record;
 179         *description = g_list_append(*description, info);
 180
 181         return PMINFO_R_OK;
 182 }
 183
 184 static int _pkginfo_get_privilege(sqlite3 *db, const char *pkgid,
 185                 GList **privileges)
 186 {
 187         static const char query_raw[] =
 188                 "SELECT DISTINCT privilege, type FROM package_privilege_info "
 189                 "WHERE package=%Q";
 190         int ret;
 191         char *query;
 192         sqlite3_stmt *stmt;
 193         privilege_x *privilege;
 194
 195         query = sqlite3_mprintf(query_raw, pkgid);
 196         if (query == NULL) {
 197                 LOGE("out of memory");
 198                 return PMINFO_R_ERROR;
 199         }
 200
 201         ret = sqlite3_prepare_v2(db, query, strlen(query),
 202                         &stmt, NULL);
 203         sqlite3_free(query);
 204         if (ret != SQLITE_OK) {
 205                 LOGE("prepare failed: %s", sqlite3_errmsg(db));
 206                 return PMINFO_R_ERROR;
 207         }
 208
 209         while (sqlite3_step(stmt) == SQLITE_ROW) {
 210                 privilege = calloc(1, sizeof(privilege_x));
 211                 _save_column_str(stmt, 0, &privilege->value);
 212                 _save_column_str(stmt, 1, &privilege->type);
 213                 *privileges = g_list_append(*privileges,
 214                                 (gpointer)privilege);
 215         }
 216
 217         sqlite3_finalize(stmt);
 218
 219         return PMINFO_R_OK;
 220 }
 221
 222 static int _pkginfo_get_appdefined_privilege(sqlite3 *db, const char *pkgid,
 223                 GList **privileges)
 224 {
 225         static const char query_raw[] =
 226                 "SELECT DISTINCT privilege, license, type FROM "
 227                 "package_appdefined_privilege_info WHERE package=%Q";
 228         int ret;
 229         char *query;
 230         sqlite3_stmt *stmt;
 231         appdefined_privilege_x *privilege;
 232
 233         query = sqlite3_mprintf(query_raw, pkgid);
 234         if (query == NULL) {
 235                 LOGE("out of memory");
 236                 return PMINFO_R_ERROR;
 237         }
 238
 239         ret = sqlite3_prepare_v2(db, query, strlen(query),
 240                         &stmt, NULL);
 241         sqlite3_free(query);
 242         if (ret != SQLITE_OK) {
 243                 LOGE("prepare failed: %s", sqlite3_errmsg(db));
 244                 return PMINFO_R_ERROR;
 245         }
 246
 247         while (sqlite3_step(stmt) == SQLITE_ROW) {
 248                 privilege = calloc(1, sizeof(appdefined_privilege_x));
 249                 if (!privilege) {
 250                         LOGE("failed to alloc memory");
 251                         sqlite3_finalize(stmt);
 252                         return PMINFO_R_ERROR;
 253                 }
 254                 _save_column_str(stmt, 0, &privilege->value);
 255                 _save_column_str(stmt, 1, &privilege->license);
 256                 _save_column_str(stmt, 2, &privilege->type);
 257                 *privileges = g_list_append(*privileges,
 258                                 (gpointer)privilege);
 259         }
 260
 261         sqlite3_finalize(stmt);
 262
 263         return PMINFO_R_OK;
 264 }
 265
 266 static const char join_localized_info[] =
 267         " LEFT OUTER JOIN package_localized_info"
 268         "  ON pi.package=package_localized_info.package"
 269         "  AND package_localized_info.package_locale=?";
 270 static const char join_privilege_info[] =
 271         " LEFT OUTER JOIN package_privilege_info"
 272         "  ON pi.package=package_privilege_info.package";
 273
 274 static int _get_filtered_query(pkgmgrinfo_filter_x *filter,
 275                 const char *locale, uid_t uid, char **query, GList **bind_params)
 276 {
 277         int joined = 0;
 278         char buf[MAX_QUERY_LEN] = { '\0' };
 279         char buf2[MAX_QUERY_LEN] = { '\0' };
 280         char *condition = NULL;
 281         GSList *list = NULL;
 282
 283         if (filter == NULL)
 284                 return PMINFO_R_OK;
 285
 286         snprintf(buf, sizeof(buf), "%s", " WHERE 1=1 ");
 287         for (list = filter->list; list; list = list->next) {
 288                 joined |= __get_filter_condition(list->data, uid, &condition,
 289                                 bind_params);
 290                 if (condition == NULL)
 291                         continue;
 292
 293                 strncat(buf, " AND ", sizeof(buf) - strlen(buf) - 1);
 294
 295                 strncat(buf, condition, sizeof(buf) - strlen(buf) - 1);
 296                 free(condition);
 297                 condition = NULL;
 298         }
 299
 300         if (joined & E_PMINFO_PKGINFO_JOIN_LOCALIZED_INFO) {
 301                 strncat(buf2, join_localized_info, sizeof(buf2) - strlen(buf2) - 1);
 302                 *bind_params = g_list_append(*bind_params, strdup(locale));
 303         }
 304         if (joined & E_PMINFO_PKGINFO_JOIN_PRIVILEGE_INFO)
 305                 strncat(buf2, join_privilege_info, sizeof(buf2) - strlen(buf2) - 1);
 306         strncat(buf2, buf, sizeof(buf2) - strlen(buf2) - 1);
 307
 308         *query = strdup(buf2);
 309         if (*query == NULL)
 310                 return PMINFO_R_ERROR;
 311
 312         return PMINFO_R_OK;
 313 }
 314
 315 static void __free_packages(gpointer data)
 316 {
 317         pkgmgrinfo_basic_free_package((package_x *)data);
 318 }
 319
 320 static bool __check_disable_filter_exist(pkgmgrinfo_filter_x *filter)
 321 {
 322         GSList *link;
 323
 324         if (filter == NULL)
 325                 return false;
 326
 327         link = g_slist_find_custom(filter->list, NULL, __pkg_disable_chk_func);
 328         if (link)
 329                 return true;
 330
 331         return false;
 332 }
 333
 334 static int __bind_params(sqlite3_stmt *stmt, GList *params)
 335 {
 336         GList *tmp_list = NULL;
 337         int idx = 0;
 338         int ret;
 339
 340         if (stmt == NULL || params == NULL)
 341                 return PMINFO_R_EINVAL;
 342
 343         tmp_list = params;
 344         while (tmp_list) {
 345                 ret = sqlite3_bind_text(stmt, ++idx, (char *)tmp_list->data, -1, SQLITE_STATIC);
 346                 if (ret != SQLITE_OK)
 347                         return PMINFO_R_ERROR;
 348                 tmp_list = tmp_list->next;
 349         }
 350
 351         return PMINFO_R_OK;
 352 }
 353
 354 static bool __check_package_storage_status(pkgmgrinfo_filter_x *tmp_filter)
 355 {
 356         GSList *tmp_list = NULL;
 357         pkgmgrinfo_node_x *tmp_node = NULL;
 358         int property = -1;
 359
 360         property = _pminfo_pkginfo_convert_to_prop_bool(PMINFO_PKGINFO_PROP_PACKAGE_CHECK_STORAGE);
 361         for (tmp_list = tmp_filter->list; tmp_list != NULL;
 362                         tmp_list = g_slist_next(tmp_list)) {
 363                 tmp_node = (pkgmgrinfo_node_x *)tmp_list->data;
 364                 if (property == tmp_node->prop) {
 365                         if (strcmp(tmp_node->value, "true") == 0)
 366                                 return true;
 367                         else
 368                                 return false;
 369                 }
 370         }
 371         return true;
 372 }
 373
 374 static int _pkginfo_get_packages(uid_t uid, const char *locale,
 375                 pkgmgrinfo_filter_x *filter, int flag, GHashTable *packages)
 376 {
 377         static const char query_raw[] =
 378                 "SELECT DISTINCT pi.package, pi.installed_storage, pi.external_path";
 379         static const char query_basic[] =
 380                 ", pi.package_version, pi.install_location, "
 381                 "pi.package_removable, pi.package_preload, pi.package_readonly, "
 382                 "pi.package_update, pi.package_appsetting, pi.package_system, "
 383                 "pi.package_type, pi.package_size, pi.installed_time, "
 384                 "pi.storeclient_id, pi.mainapp_id, pi.package_url, pi.root_path, "
 385                 "pi.csc_path, pi.package_nodisplay, pi.package_api_version, "
 386                 "pi.package_support_disable, pi.package_tep_name, "
 387                 "pi.package_zip_mount_file, pi.package_support_mode";
 388         static const char query_author[] =
 389                 ", pi.author_name, pi.author_email, pi.author_href";
 390         static const char query_label[] =
 391                 ", COALESCE("
 392                 "(SELECT package_label FROM package_localized_info WHERE pi.package=package AND package_locale=?), "
 393                 "(SELECT package_label FROM package_localized_info WHERE pi.package=package AND package_locale='No Locale'))";
 394         static const char query_icon[] =
 395                 ", COALESCE("
 396                 "(SELECT package_icon FROM package_localized_info WHERE pi.package=package AND package_locale=?), "
 397                 "(SELECT package_icon FROM package_localized_info WHERE pi.package=package AND package_locale='No Locale'))";
 398         static const char query_description[] =
 399                 ", COALESCE("
 400                 "(SELECT package_description FROM package_localized_info WHERE pi.package=package AND package_locale=?), "
 401                 "(SELECT package_description FROM package_localized_info WHERE pi.package=package AND package_locale='No Locale'))";
 402         static const char query_from_clause[] = " FROM package_info as pi";
 403         int ret = PMINFO_R_ERROR;
 404         int idx = 0;
 405         char *dbpath;
 406         char *tmp_record = NULL;
 407         char *constraints = NULL;
 408         char query[MAX_QUERY_LEN] = { '\0' };
 409         package_x *info = NULL;
 410         author_x *author = NULL;
 411         GList *bind_params = NULL;
 412         sqlite3 *db;
 413         sqlite3_stmt *stmt = NULL;
 414         pkgmgrinfo_filter_x *tmp_filter = NULL;
 415         bool is_check_storage = true;
 416         const uid_t global_user_uid = GLOBAL_USER;
 417
 418         dbpath = getUserPkgParserDBPathUID(uid);
 419         if (dbpath == NULL)
 420                 return PMINFO_R_ERROR;
 421
 422         ret = __open_db(dbpath, &db, SQLITE_OPEN_READONLY);
 423         if (ret != SQLITE_OK) {
 424                 _LOGD("failed to open db(%s): %d", dbpath, ret);
 425                 free(dbpath);
 426                 return PMINFO_R_ERROR;
 427         }
 428         free(dbpath);
 429
 430         if (filter != NULL) {
 431                 tmp_filter = filter;
 432         } else {
 433                 ret = pkgmgrinfo_pkginfo_filter_create((void *)&tmp_filter);
 434                 if (ret != PMINFO_R_OK) {
 435                         _LOGE("Failed to create filter");
 436                         return PMINFO_R_ERROR;
 437                 }
 438         }
 439
 440         is_check_storage = __check_package_storage_status(tmp_filter);
 441
 442         snprintf(query, MAX_QUERY_LEN - 1, "%s", query_raw);
 443         if (flag & PMINFO_APPINFO_GET_BASICINFO)
 444                 strncat(query, query_basic, sizeof(query) - strlen(query) - 1);
 445         if (flag & PMINFO_PKGINFO_GET_AUTHOR)
 446                 strncat(query, query_author, sizeof(query) - strlen(query) - 1);
 447         if (flag & PMINFO_PKGINFO_GET_LABEL) {
 448                 strncat(query, query_label, sizeof(query) - strlen(query) - 1);
 449                 bind_params = g_list_append(bind_params, strdup(locale));
 450         }
 451         if (flag & PMINFO_PKGINFO_GET_ICON) {
 452                 strncat(query, query_icon, sizeof(query) - strlen(query) - 1);
 453                 bind_params = g_list_append(bind_params, strdup(locale));
 454         }
 455         if (flag & PMINFO_PKGINFO_GET_DESCRIPTION) {
 456                 strncat(query, query_description, sizeof(query) - strlen(query) - 1);
 457                 bind_params = g_list_append(bind_params, strdup(locale));
 458         }
 459
 460         strncat(query, query_from_clause, sizeof(query) - strlen(query) - 1);
 461
 462         ret = _get_filtered_query(tmp_filter, locale, uid, &constraints, &bind_params);
 463         if (ret != PMINFO_R_OK) {
 464                 LOGE("Failed to get WHERE clause");
 465                 goto catch;
 466         }
 467
 468         if (constraints)
 469                 strncat(query, constraints, sizeof(query) - strlen(query) - 1);
 470
 471         ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
 472         if (ret != SQLITE_OK) {
 473                 LOGE("prepare failed: %s", sqlite3_errmsg(db));
 474                 ret = PMINFO_R_ERROR;
 475                 goto catch;
 476         }
 477
 478         ret = __bind_params(stmt, bind_params);
 479         if (ret != SQLITE_OK) {
 480                 LOGE("Failed to bind parameters");
 481                 goto catch;
 482         }
 483
 484         while (sqlite3_step(stmt) == SQLITE_ROW) {
 485                 info = calloc(1, sizeof(package_x));
 486                 if (info == NULL) {
 487                         LOGE("out of memory");
 488                         ret = PMINFO_R_ERROR;
 489                         goto catch;
 490                 }
 491                 idx = 0;
 492                 _save_column_str(stmt, idx++, &info->package);
 493                 _save_column_str(stmt, idx++, &info->installed_storage);
 494                 _save_column_str(stmt, idx++, &info->external_path);
 495
 496                 if (flag & PMINFO_APPINFO_GET_BASICINFO) {
 497                         _save_column_str(stmt, idx++, &info->version);
 498                         _save_column_str(stmt, idx++, &info->installlocation);
 499                         _save_column_str(stmt, idx++, &info->removable);
 500                         _save_column_str(stmt, idx++, &info->preload);
 501                         _save_column_str(stmt, idx++, &info->readonly);
 502                         _save_column_str(stmt, idx++, &info->update);
 503                         _save_column_str(stmt, idx++, &info->appsetting);
 504                         _save_column_str(stmt, idx++, &info->system);
 505                         _save_column_str(stmt, idx++, &info->type);
 506                         _save_column_str(stmt, idx++, &info->package_size);
 507                         _save_column_str(stmt, idx++, &info->installed_time);
 508                         _save_column_str(stmt, idx++, &info->storeclient_id);
 509                         _save_column_str(stmt, idx++, &info->mainapp_id);
 510                         _save_column_str(stmt, idx++, &info->package_url);
 511                         _save_column_str(stmt, idx++, &info->root_path);
 512                         _save_column_str(stmt, idx++, &info->csc_path);
 513                         _save_column_str(stmt, idx++, &info->nodisplay_setting);
 514                         _save_column_str(stmt, idx++, &info->api_version);
 515                         _save_column_str(stmt, idx++, &info->support_disable);
 516                         _save_column_str(stmt, idx++, &info->tep_name);
 517                         _save_column_str(stmt, idx++, &info->zip_mount_file);
 518                         _save_column_str(stmt, idx++, &info->support_mode);
 519                 }
 520
 521                 info->for_all_users =
 522                         strdup((uid != global_user_uid) ? "false" : "true");
 523
 524                 if (flag & PMINFO_PKGINFO_GET_AUTHOR) {
 525                         /* TODO : author should be retrieved at package_localized_info */
 526                         author = calloc(1, sizeof(author_x));
 527                         if (author == NULL) {
 528                                 ret = PMINFO_R_ERROR;
 529                                 goto catch;
 530                         }
 531                         _save_column_str(stmt, idx++, &author->text);
 532                         _save_column_str(stmt, idx++, &author->email);
 533                         _save_column_str(stmt, idx++, &author->href);
 534                         info->author = g_list_append(info->author, author);
 535                 }
 536
 537                 if (flag & PMINFO_PKGINFO_GET_LABEL) {
 538                         tmp_record = NULL;
 539                         _save_column_str(stmt, idx++, &tmp_record);
 540
 541                         if (_add_label_info_into_list(locale, tmp_record, &info->label)) {
 542                                 ret = PMINFO_R_ERROR;
 543                                 goto catch;
 544                         }
 545                 }
 546
 547                 if (flag & PMINFO_PKGINFO_GET_ICON) {
 548                         tmp_record = NULL;
 549                         _save_column_str(stmt, idx++, &tmp_record);
 550                         if (_add_icon_info_into_list(locale, tmp_record, &info->icon)) {
 551                                 ret = PMINFO_R_ERROR;
 552                                 goto catch;
 553                         }
 554                 }
 555
 556                 if (flag & PMINFO_PKGINFO_GET_DESCRIPTION) {
 557                         tmp_record = NULL;
 558                         _save_column_str(stmt, idx++, &tmp_record);
 559                         if (_pkginfo_add_description_info_into_list(locale, tmp_record,
 560                                         &info->description)) {
 561                                 ret = PMINFO_R_ERROR;
 562                                 goto catch;
 563                         }
 564                 }
 565
 566                 if (flag & PMINFO_PKGINFO_GET_PRIVILEGE) {
 567                         if (_pkginfo_get_privilege(db, info->package,
 568                                                 &info->privileges)) {
 569                                 ret = PMINFO_R_ERROR;
 570                                 goto catch;
 571                         }
 572                 }
 573
 574                 if (flag & PMINFO_PKGINFO_GET_APPDEFINED_PRIVILEGE) {
 575                         if (_pkginfo_get_appdefined_privilege(db, info->package,
 576                                                 &info->appdefined_privileges)) {
 577                                 ret = PMINFO_R_ERROR;
 578                                 goto catch;
 579                         }
 580                 }
 581
 582                 if (is_check_storage &&
 583                                 __pkginfo_check_installed_storage(info) != PMINFO_R_OK) {
 584                         ret = PMINFO_R_ERROR;
 585                         pkgmgrinfo_basic_free_package(info);
 586                         info = NULL;
 587                         continue;
 588                 }
 589
 590                 g_hash_table_insert(packages, (gpointer)info->package,
 591                                 (gpointer)info);
 592         }
 593
 594         ret = PMINFO_R_OK;
 595
 596 catch:
 597         if (constraints)
 598                 free(constraints);
 599
 600         if (ret != PMINFO_R_OK && info != NULL)
 601                 pkgmgrinfo_basic_free_package(info);
 602
 603         if (filter == NULL)
 604                 pkgmgrinfo_pkginfo_filter_destroy(tmp_filter);
 605
 606         g_list_free_full(bind_params, free);
 607         sqlite3_close_v2(db);
 608         if (stmt)
 609                 sqlite3_finalize(stmt);
 610
 611         return ret;
 612 }
 613
 614 static int _pkginfo_get_filtered_foreach_pkginfo(uid_t uid,
 615                 pkgmgrinfo_filter_x *filter, int flag,
 616                 pkgmgrinfo_pkg_list_cb pkg_list_cb, void *user_data)
 617 {
 618         int ret;
 619         char *locale;
 620         package_x *pkg;
 621         pkgmgr_pkginfo_x info;
 622         pkgmgrinfo_filter_x *tmp_filter = NULL;
 623         GHashTable *list;
 624         GHashTableIter iter;
 625         gpointer value;
 626
 627         locale = _get_system_locale();
 628         if (locale == NULL)
 629                 return PMINFO_R_ERROR;
 630
 631         list = g_hash_table_new_full(g_str_hash, g_str_equal, NULL,
 632                         __free_packages);
 633         if (list == NULL) {
 634                 free(locale);
 635                 return PMINFO_R_ERROR;
 636         }
 637
 638         if (filter != NULL) {
 639                 tmp_filter = (pkgmgrinfo_filter_x *)filter;
 640         } else {
 641                 ret = pkgmgrinfo_pkginfo_filter_create((void *)&tmp_filter);
 642                 if (ret != PMINFO_R_OK) {
 643                         _LOGE("Failed to create filter");
 644                         g_hash_table_destroy(list);
 645                         free(locale);
 646                         return PMINFO_R_ERROR;
 647                 }
 648         }
 649
 650         if (__check_disable_filter_exist(tmp_filter) == false) {
 651                 ret = pkgmgrinfo_pkginfo_filter_add_bool(tmp_filter,
 652                                 PMINFO_PKGINFO_PROP_PACKAGE_DISABLE, false);
 653                 if (ret != PMINFO_R_OK) {
 654                         _LOGE("Failed to add filter");
 655                         g_hash_table_destroy(list);
 656                         free(locale);
 657                         if (filter == NULL)
 658                                 pkgmgrinfo_pkginfo_filter_destroy(tmp_filter);
 659                         return PMINFO_R_ERROR;
 660                 }
 661         }
 662
 663         ret = _pkginfo_get_packages(uid, locale, tmp_filter,
 664                         flag | PMINFO_PKGINFO_GET_BASICINFO, list);
 665         if (ret == PMINFO_R_OK && uid != GLOBAL_USER)
 666                 ret = _pkginfo_get_packages(GLOBAL_USER, locale, tmp_filter,
 667                                 flag | PMINFO_PKGINFO_GET_BASICINFO, list);
 668
 669         if (ret != PMINFO_R_OK) {
 670                 g_hash_table_destroy(list);
 671                 free(locale);
 672                 if (filter == NULL)
 673                         pkgmgrinfo_pkginfo_filter_destroy(tmp_filter);
 674                 return PMINFO_R_ERROR;
 675         }
 676
 677         g_hash_table_iter_init(&iter, list);
 678         while (g_hash_table_iter_next(&iter, NULL, &value)) {
 679                 pkg = (package_x *)value;
 680                 info.uid = uid;
 681                 info.pkg_info = pkg;
 682                 info.locale = locale;
 683                 if (pkg_list_cb(&info, user_data) < 0)
 684                         break;
 685         }
 686
 687         g_hash_table_destroy(list);
 688         free(locale);
 689
 690         if (filter == NULL)
 691                 pkgmgrinfo_pkginfo_filter_destroy(tmp_filter);
 692
 693         return PMINFO_R_OK;
 694 }
 695
 696 static int _pkgmgrinfo_get_pkginfo(const char *pkgid, uid_t uid,
 697         pkgmgrinfo_pkginfo_filter_h filter, pkgmgrinfo_pkginfo_h *handle)
 698 {
 699         int ret;
 700         char *locale;
 701         GHashTable *list;
 702         pkgmgr_pkginfo_x *info;
 703
 704         if (pkgid == NULL || filter == NULL || handle == NULL) {
 705                         LOGE("invalid parameter");
 706                         return PMINFO_R_EINVAL;
 707         }
 708
 709         locale = _get_system_locale();
 710         if (locale == NULL)
 711                 return PMINFO_R_ERROR;
 712
 713         list = g_hash_table_new_full(g_str_hash, g_str_equal, NULL,
 714                         __free_packages);
 715         if (list == NULL) {
 716                 free(locale);
 717                 return PMINFO_R_ERROR;
 718         }
 719
 720         ret = _pkginfo_get_packages(uid, locale, filter,
 721                         PMINFO_PKGINFO_GET_ALL, list);
 722         if (!g_hash_table_size(list) && uid != GLOBAL_USER)
 723                 ret = _pkginfo_get_packages(GLOBAL_USER, locale, filter,
 724                                 PMINFO_PKGINFO_GET_ALL, list);
 725
 726         if (ret != PMINFO_R_OK) {
 727                 g_hash_table_destroy(list);
 728                 free(locale);
 729                 return ret;
 730         }
 731
 732         if (!g_hash_table_size(list)) {
 733                 _LOGD("pkginfo for [%s] is not existed for user [%d]",
 734                                 pkgid, uid);
 735                 g_hash_table_destroy(list);
 736                 free(locale);
 737                 return PMINFO_R_ENOENT;
 738         }
 739
 740         info = calloc(1, sizeof(pkgmgr_pkginfo_x));
 741         if (info == NULL) {
 742                 _LOGE("out of memory");
 743                 g_hash_table_destroy(list);
 744                 free(locale);
 745                 return PMINFO_R_ERROR;
 746         }
 747
 748         info->uid = uid;
 749         info->pkg_info = (package_x *)g_hash_table_lookup(list, pkgid);
 750         info->locale = locale;
 751
 752         /* just free list only */
 753         g_hash_table_steal(list, (gconstpointer)pkgid);
 754         g_hash_table_destroy(list);
 755
 756         *handle = info;
 757
 758         return ret;
 759 }
 760
 761 API int pkgmgrinfo_pkginfo_get_usr_pkginfo(const char *pkgid, uid_t uid,
 762                 pkgmgrinfo_pkginfo_h *handle)
 763 {
 764         int ret;
 765         pkgmgrinfo_pkginfo_filter_h filter;
 766
 767         if (pkgid == NULL || handle == NULL) {
 768                 LOGE("invalid parameter");
 769                 return PMINFO_R_EINVAL;
 770         }
 771
 772         ret = pkgmgrinfo_pkginfo_filter_create(&filter);
 773         if (ret != PMINFO_R_OK)
 774                 return ret;
 775
 776         ret = pkgmgrinfo_pkginfo_filter_add_string(filter,
 777                         PMINFO_PKGINFO_PROP_PACKAGE_ID, pkgid);
 778         if (ret != PMINFO_R_OK) {
 779                 pkgmgrinfo_pkginfo_filter_destroy(filter);
 780                 return PMINFO_R_ERROR;
 781         }
 782
 783         ret = pkgmgrinfo_pkginfo_filter_add_bool(filter,
 784                         PMINFO_PKGINFO_PROP_PACKAGE_DISABLE, false);
 785         if (ret != PMINFO_R_OK) {
 786                 pkgmgrinfo_pkginfo_filter_destroy(filter);
 787                 return PMINFO_R_ERROR;
 788         }
 789
 790         ret = _pkgmgrinfo_get_pkginfo(pkgid, uid, filter, handle);
 791         pkgmgrinfo_pkginfo_filter_destroy(filter);
 792
 793         return ret;
 794 }
 795
 796 API int pkgmgrinfo_pkginfo_get_pkginfo(const char *pkgid,
 797                 pkgmgrinfo_pkginfo_h *handle)
 798 {
 799         return pkgmgrinfo_pkginfo_get_usr_pkginfo(pkgid, _getuid(), handle);
 800 }
 801
 802 API int pkgmgrinfo_pkginfo_get_usr_disabled_pkginfo(const char *pkgid,
 803                 uid_t uid, pkgmgrinfo_pkginfo_h *handle)
 804 {
 805         int ret;
 806         char *locale;
 807         GHashTable *list;
 808         pkgmgrinfo_pkginfo_filter_h filter;
 809         pkgmgr_pkginfo_x *info;
 810
 811         if (pkgid == NULL || handle == NULL) {
 812                 LOGE("invalid parameter");
 813                 return PMINFO_R_EINVAL;
 814         }
 815
 816         locale = _get_system_locale();
 817         if (locale == NULL)
 818                 return PMINFO_R_ERROR;
 819
 820         ret = pkgmgrinfo_pkginfo_filter_create(&filter);
 821         if (ret != PMINFO_R_OK) {
 822                 free(locale);
 823                 return ret;
 824         }
 825
 826         ret = pkgmgrinfo_pkginfo_filter_add_string(filter,
 827                         PMINFO_PKGINFO_PROP_PACKAGE_ID, pkgid);
 828         if (ret != PMINFO_R_OK) {
 829                 pkgmgrinfo_pkginfo_filter_destroy(filter);
 830                 free(locale);
 831                 return PMINFO_R_ERROR;
 832         }
 833
 834         ret = pkgmgrinfo_pkginfo_filter_add_bool(filter,
 835                         PMINFO_PKGINFO_PROP_PACKAGE_DISABLE, true);
 836         if (ret != PMINFO_R_OK) {
 837                 pkgmgrinfo_pkginfo_filter_destroy(filter);
 838                 free(locale);
 839                 return PMINFO_R_ERROR;
 840         }
 841
 842         list = g_hash_table_new_full(g_str_hash, g_str_equal, NULL,
 843                         __free_packages);
 844         if (list == NULL) {
 845                 pkgmgrinfo_pkginfo_filter_destroy(filter);
 846                 free(locale);
 847                 return PMINFO_R_ERROR;
 848         }
 849
 850         ret = _pkginfo_get_packages(uid, locale, filter,
 851                         PMINFO_PKGINFO_GET_ALL, list);
 852         if (!g_hash_table_size(list) && uid != GLOBAL_USER)
 853                 ret = _pkginfo_get_packages(GLOBAL_USER, locale, filter,
 854                                 PMINFO_PKGINFO_GET_ALL, list);
 855
 856         pkgmgrinfo_pkginfo_filter_destroy(filter);
 857         if (ret != PMINFO_R_OK) {
 858                 g_hash_table_destroy(list);
 859                 free(locale);
 860                 return ret;
 861         }
 862
 863         if (!g_hash_table_size(list)) {
 864                 _LOGD("disabled pkginfo for [%s] is not existed for user [%d]",
 865                                 pkgid, uid);
 866                 g_hash_table_destroy(list);
 867                 free(locale);
 868                 return PMINFO_R_ENOENT;
 869         }
 870
 871         info = calloc(1, sizeof(pkgmgr_pkginfo_x));
 872         if (info == NULL) {
 873                 _LOGE("out of memory");
 874                 g_hash_table_destroy(list);
 875                 free(locale);
 876                 return PMINFO_R_ERROR;
 877         }
 878
 879         info->uid = uid;
 880         info->pkg_info = (package_x *)g_hash_table_lookup(list, pkgid);
 881         info->locale = locale;
 882
 883         /* just free list only */
 884         g_hash_table_steal(list, (gconstpointer)pkgid);
 885         g_hash_table_destroy(list);
 886
 887         *handle = info;
 888
 889         return ret;
 890 }
 891
 892 API int pkgmgrinfo_pkginfo_get_usr_all_pkginfo(const char *pkgid, uid_t uid,
 893                 pkgmgrinfo_pkginfo_h *handle)
 894 {
 895
 896         int ret;
 897         pkgmgrinfo_pkginfo_filter_h filter;
 898
 899         if (pkgid == NULL || handle == NULL) {
 900                 LOGE("invalid parameter");
 901                 return PMINFO_R_EINVAL;
 902         }
 903
 904         ret = pkgmgrinfo_pkginfo_filter_create(&filter);
 905         if (ret != PMINFO_R_OK)
 906                 return ret;
 907
 908         ret = pkgmgrinfo_pkginfo_filter_add_string(filter,
 909                         PMINFO_PKGINFO_PROP_PACKAGE_ID, pkgid);
 910         if (ret != PMINFO_R_OK) {
 911                 pkgmgrinfo_pkginfo_filter_destroy(filter);
 912                 return PMINFO_R_ERROR;
 913         }
 914
 915         ret = pkgmgrinfo_pkginfo_filter_add_bool(filter,
 916                         PMINFO_PKGINFO_PROP_PACKAGE_CHECK_STORAGE, false);
 917         if (ret != PMINFO_R_OK) {
 918                 pkgmgrinfo_pkginfo_filter_destroy(filter);
 919                 return PMINFO_R_ERROR;
 920         }
 921
 922         ret = _pkgmgrinfo_get_pkginfo(pkgid, uid, filter, handle);
 923         pkgmgrinfo_pkginfo_filter_destroy(filter);
 924
 925         return ret;
 926 }
 927
 928 API int pkgmgrinfo_pkginfo_get_disabled_pkginfo(const char *pkgid,
 929                 pkgmgrinfo_pkginfo_h *handle)
 930 {
 931         return pkgmgrinfo_pkginfo_get_usr_disabled_pkginfo(pkgid, _getuid(),
 932                         handle);
 933 }
 934
 935 API int pkgmgrinfo_pkginfo_get_all_pkginfo(const char *pkgid,
 936                 pkgmgrinfo_pkginfo_h *handle)
 937 {
 938         return pkgmgrinfo_pkginfo_get_usr_all_pkginfo(pkgid, _getuid(), handle);
 939 }
 940
 941 API int pkgmgrinfo_pkginfo_get_usr_list_full(pkgmgrinfo_pkg_list_cb pkg_list_cb,
 942                 int flag, void *user_data, uid_t uid)
 943 {
 944         int ret;
 945         pkgmgrinfo_pkginfo_filter_h filter;
 946
 947         if (pkg_list_cb == NULL) {
 948                 LOGE("invalid parameter");
 949                 return PMINFO_R_EINVAL;
 950         }
 951
 952         /* create an empty filter */
 953         ret = pkgmgrinfo_pkginfo_filter_create(&filter);
 954         if (ret != PMINFO_R_OK)
 955                 return ret;
 956
 957         ret = _pkginfo_get_filtered_foreach_pkginfo(uid, filter, flag,
 958                         pkg_list_cb, user_data);
 959
 960         pkgmgrinfo_pkginfo_filter_destroy(filter);
 961
 962         return ret;
 963 }
 964
 965 API int pkgmgrinfo_pkginfo_get_list_full(pkgmgrinfo_pkg_list_cb pkg_list_cb,
 966                 int flag, void *user_data)
 967 {
 968         return pkgmgrinfo_pkginfo_get_usr_list_full(pkg_list_cb, flag,
 969                         user_data, _getuid());
 970 }
 971
 972 API int pkgmgrinfo_pkginfo_get_usr_list(pkgmgrinfo_pkg_list_cb pkg_list_cb,
 973                 void *user_data, uid_t uid)
 974 {
 975         int ret;
 976         pkgmgrinfo_pkginfo_filter_h filter;
 977
 978         if (pkg_list_cb == NULL) {
 979                 LOGE("invalid parameter");
 980                 return PMINFO_R_EINVAL;
 981         }
 982
 983         /* create an empty filter */
 984         ret = pkgmgrinfo_pkginfo_filter_create(&filter);
 985         if (ret != PMINFO_R_OK)
 986                 return ret;
 987
 988         ret = _pkginfo_get_filtered_foreach_pkginfo(uid, filter,
 989                         PMINFO_PKGINFO_GET_ALL, pkg_list_cb, user_data);
 990
 991         pkgmgrinfo_pkginfo_filter_destroy(filter);
 992
 993         return ret;
 994 }
 995
 996 API int pkgmgrinfo_pkginfo_get_list(pkgmgrinfo_pkg_list_cb pkg_list_cb,
 997                 void *user_data)
 998 {
 999         return pkgmgrinfo_pkginfo_get_usr_list(pkg_list_cb, user_data,
1000                         _getuid());
1001 }
1002
1003 API int pkgmgrinfo_pkginfo_get_usr_disabled_list(
1004                 pkgmgrinfo_pkg_list_cb pkg_list_cb, void *user_data, uid_t uid)
1005 {
1006         int ret;
1007         pkgmgrinfo_pkginfo_filter_h filter;
1008
1009         if (pkg_list_cb == NULL) {
1010                 LOGE("invalid parameter");
1011                 return PMINFO_R_EINVAL;
1012         }
1013
1014         ret = pkgmgrinfo_pkginfo_filter_create(&filter);
1015         if (ret != PMINFO_R_OK)
1016                 return ret;
1017
1018         ret = pkgmgrinfo_pkginfo_filter_add_bool(filter,
1019                         PMINFO_PKGINFO_PROP_PACKAGE_DISABLE, true);
1020         if (ret != PMINFO_R_OK) {
1021                 pkgmgrinfo_pkginfo_filter_destroy(filter);
1022                 return PMINFO_R_ERROR;
1023         }
1024
1025         ret = _pkginfo_get_filtered_foreach_pkginfo(uid, filter,
1026                         PMINFO_PKGINFO_GET_ALL, pkg_list_cb, user_data);
1027
1028         pkgmgrinfo_pkginfo_filter_destroy(filter);
1029
1030         return ret;
1031 }
1032
1033 API int pkgmgrinfo_pkginfo_get_disabled_list(pkgmgrinfo_pkg_list_cb pkg_list_cb,
1034                 void *user_data)
1035 {
1036         return pkgmgrinfo_pkginfo_get_usr_disabled_list(pkg_list_cb, user_data,
1037                         _getuid());
1038 }
1039
1040 API int pkgmgrinfo_pkginfo_get_pkgname(pkgmgrinfo_pkginfo_h handle, char **pkg_name)
1041 {
1042         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1043
1044         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1045         retvm_if(pkg_name == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1046
1047         if (info->pkg_info == NULL || info->pkg_info->package == NULL)
1048                 return PMINFO_R_ERROR;
1049
1050         *pkg_name = (char *)info->pkg_info->package;
1051
1052         return PMINFO_R_OK;
1053 }
1054
1055 API int pkgmgrinfo_pkginfo_get_pkgid(pkgmgrinfo_pkginfo_h handle, char **pkgid)
1056 {
1057         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1058
1059         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1060         retvm_if(pkgid == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1061
1062         if (info->pkg_info == NULL || info->pkg_info->package == NULL)
1063                 return PMINFO_R_ERROR;
1064
1065         *pkgid = (char *)info->pkg_info->package;
1066
1067         return PMINFO_R_OK;
1068 }
1069
1070 API int pkgmgrinfo_pkginfo_get_type(pkgmgrinfo_pkginfo_h handle, char **type)
1071 {
1072         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1073
1074         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1075         retvm_if(type == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1076
1077         if (info->pkg_info == NULL)
1078                 return PMINFO_R_ERROR;
1079
1080         if (info->pkg_info->type == NULL)
1081                 *type = "";
1082         else
1083                 *type = (char *)info->pkg_info->type;
1084
1085         return PMINFO_R_OK;
1086 }
1087
1088 API int pkgmgrinfo_pkginfo_get_version(pkgmgrinfo_pkginfo_h handle, char **version)
1089 {
1090         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1091
1092         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1093         retvm_if(version == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1094
1095         if (info->pkg_info == NULL)
1096                 return PMINFO_R_ERROR;
1097
1098         if (info->pkg_info->version == NULL)
1099                 *version = "";
1100         else
1101                 *version = (char *)info->pkg_info->version;
1102
1103         return PMINFO_R_OK;
1104 }
1105
1106 API int pkgmgrinfo_pkginfo_get_api_version(pkgmgrinfo_pkginfo_h handle, char **api_version)
1107 {
1108         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1109
1110         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1111         retvm_if(api_version == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1112
1113         if (info->pkg_info == NULL)
1114                 return PMINFO_R_ERROR;
1115
1116         if (info->pkg_info->api_version == NULL)
1117                 *api_version = "";
1118         else
1119                 *api_version = (char *)info->pkg_info->api_version;
1120
1121         return PMINFO_R_OK;
1122 }
1123
1124 API int pkgmgrinfo_pkginfo_get_tep_name(pkgmgrinfo_pkginfo_h handle, char **tep_name)
1125 {
1126         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1127
1128         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1129         retvm_if(tep_name == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1130
1131         if (info->pkg_info == NULL || info->pkg_info->tep_name == NULL)
1132                 return PMINFO_R_ERROR;
1133
1134         *tep_name = (char *)info->pkg_info->tep_name;
1135
1136         return PMINFO_R_OK;
1137 }
1138
1139 API int pkgmgrinfo_pkginfo_get_zip_mount_file(pkgmgrinfo_pkginfo_h handle, char **zip_mount_file)
1140 {
1141         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1142
1143         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1144         retvm_if(zip_mount_file == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1145
1146         if (info->pkg_info == NULL)
1147                 return PMINFO_R_ERROR;
1148
1149         if (info->pkg_info->zip_mount_file == NULL)
1150                 *zip_mount_file = "";
1151         else
1152                 *zip_mount_file = (char *)info->pkg_info->zip_mount_file;
1153
1154         return PMINFO_R_OK;
1155 }
1156
1157 API int pkgmgrinfo_pkginfo_get_external_image_path(pkgmgrinfo_pkginfo_h handle, char **ext_image_path)
1158 {
1159         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1160
1161         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1162         retvm_if(ext_image_path == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1163
1164         if (info->pkg_info == NULL)
1165                 return PMINFO_R_ERROR;
1166
1167         if (info->pkg_info->external_path == NULL)
1168                 return PMINFO_R_ENOENT;
1169
1170         *ext_image_path = (char *)info->pkg_info->external_path;
1171
1172         return PMINFO_R_OK;
1173 }
1174
1175 API int pkgmgrinfo_pkginfo_get_install_location(pkgmgrinfo_pkginfo_h handle, pkgmgrinfo_install_location *location)
1176 {
1177         char *val;
1178         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1179
1180         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1181         retvm_if(location == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1182
1183         if (info->pkg_info == NULL || info->pkg_info->installlocation == NULL)
1184                 return PMINFO_R_ERROR;
1185
1186         val = (char *)info->pkg_info->installlocation;
1187         if (strcmp(val, "internal-only") == 0)
1188                 *location = PMINFO_INSTALL_LOCATION_INTERNAL_ONLY;
1189         else if (strcmp(val, "prefer-external") == 0)
1190                 *location = PMINFO_INSTALL_LOCATION_PREFER_EXTERNAL;
1191         else
1192                 *location = PMINFO_INSTALL_LOCATION_AUTO;
1193
1194         return PMINFO_R_OK;
1195 }
1196
1197 API int pkgmgrinfo_pkginfo_get_package_size(pkgmgrinfo_pkginfo_h handle, int *size)
1198 {
1199         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1200         char *temp = NULL;
1201
1202         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1203         retvm_if(size == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1204
1205         if (info->pkg_info == NULL)
1206                 return PMINFO_R_ERROR;
1207
1208         if (info->pkg_info->package_size == NULL) {
1209                 temp = strdup("");
1210                 if (temp == NULL) {
1211                         _LOGE("out of memory");
1212                         return PMINFO_R_ERROR;
1213                 } else {
1214                         info->pkg_info->package_size = temp;
1215                 }
1216         }
1217
1218         *size = atoi((char *)info->pkg_info->package_size);
1219
1220         return PMINFO_R_OK;
1221 }
1222
1223 API int pkgmgrinfo_pkginfo_get_icon(pkgmgrinfo_pkginfo_h handle, char **icon)
1224 {
1225         icon_x *ptr;
1226         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1227
1228         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL");
1229         retvm_if(icon == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL");
1230
1231         if (info->pkg_info == NULL || info->pkg_info->icon == NULL)
1232                 return PMINFO_R_ERROR;
1233
1234         ptr = (icon_x *)info->pkg_info->icon->data;
1235         if (ptr == NULL)
1236                 return PMINFO_R_ERROR;
1237
1238         /* TODO : should we return empty string if there was no icon? */
1239         if (ptr->text == NULL)
1240                 *icon = "";
1241         else
1242                 *icon = ptr->text;
1243
1244         return PMINFO_R_OK;
1245 }
1246
1247 API int pkgmgrinfo_pkginfo_get_label(pkgmgrinfo_pkginfo_h handle, char **label)
1248 {
1249         label_x *ptr;
1250         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1251
1252         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL");
1253         retvm_if(label == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL");
1254
1255         if (info->pkg_info == NULL || info->pkg_info->label == NULL)
1256                 return PMINFO_R_ERROR;
1257
1258         ptr = (label_x *)info->pkg_info->label->data;
1259         if (ptr == NULL)
1260                 return PMINFO_R_ERROR;
1261
1262         /* TODO : should we return empty string if there was no label? */
1263         if (ptr->text == NULL)
1264                 *label = "";
1265         else
1266                 *label = ptr->text;
1267
1268         return PMINFO_R_OK;
1269 }
1270
1271 API int pkgmgrinfo_pkginfo_get_description(pkgmgrinfo_pkginfo_h handle, char **description)
1272 {
1273         description_x *ptr;
1274         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1275
1276         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1277         retvm_if(description == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1278
1279         if (info->pkg_info == NULL || info->pkg_info->description == NULL)
1280                 return PMINFO_R_ERROR;
1281
1282         ptr = (description_x *)info->pkg_info->description->data;
1283         if (ptr == NULL)
1284                 return PMINFO_R_ERROR;
1285
1286         if (ptr->text == NULL)
1287                 *description = "";
1288         else
1289                 *description = (char *)ptr->text;
1290
1291         return PMINFO_R_OK;
1292 }
1293
1294 API int pkgmgrinfo_pkginfo_get_author_name(pkgmgrinfo_pkginfo_h handle, char **author_name)
1295 {
1296         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1297         author_x *author;
1298
1299         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1300         retvm_if(author_name == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1301
1302         if (info->pkg_info == NULL || info->pkg_info->author == NULL)
1303                 return PMINFO_R_ERROR;
1304
1305         author = (author_x *)info->pkg_info->author->data;
1306         if (author == NULL)
1307                 return PMINFO_R_ERROR;
1308
1309         if (author->text == NULL)
1310                 *author_name = "";
1311         else
1312                 *author_name = (char *)author->text;
1313
1314         return PMINFO_R_OK;
1315 }
1316
1317 API int pkgmgrinfo_pkginfo_get_author_email(pkgmgrinfo_pkginfo_h handle, char **author_email)
1318 {
1319         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1320         author_x *author;
1321
1322         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1323         retvm_if(author_email == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1324
1325         if (info->pkg_info == NULL || info->pkg_info->author == NULL)
1326                 return PMINFO_R_ERROR;
1327
1328         author = (author_x *)info->pkg_info->author->data;
1329         if (author == NULL)
1330                 return PMINFO_R_ERROR;
1331
1332         if (author->email == NULL)
1333                 *author_email = "";
1334         else
1335                 *author_email = (char *)author->email;
1336
1337         return PMINFO_R_OK;
1338 }
1339
1340 API int pkgmgrinfo_pkginfo_get_author_href(pkgmgrinfo_pkginfo_h handle, char **author_href)
1341 {
1342         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1343         author_x *author;
1344
1345         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1346         retvm_if(author_href == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1347
1348         if (info->pkg_info == NULL || info->pkg_info->author == NULL)
1349                 return PMINFO_R_ERROR;
1350
1351         author = (author_x *)info->pkg_info->author->data;
1352         if (author == NULL)
1353                 return PMINFO_R_ERROR;
1354
1355         if (author->href == NULL)
1356                 *author_href = "";
1357         else
1358                 *author_href = (char *)author->href;
1359
1360         return PMINFO_R_OK;
1361 }
1362
1363 API int pkgmgrinfo_pkginfo_get_installed_storage(pkgmgrinfo_pkginfo_h handle, pkgmgrinfo_installed_storage *storage)
1364 {
1365         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1366
1367         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1368         retvm_if(storage == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1369
1370         if (info->pkg_info == NULL || info->pkg_info->installed_storage == NULL)
1371                 return PMINFO_R_ERROR;
1372
1373         if (strcmp(info->pkg_info->installed_storage, "installed_internal") == 0)
1374                 *storage = PMINFO_INTERNAL_STORAGE;
1375         else if (strcmp(info->pkg_info->installed_storage, "installed_external") == 0)
1376                 *storage = PMINFO_EXTERNAL_STORAGE;
1377         else if (strcmp(info->pkg_info->installed_storage, "installed_extended") == 0)
1378                 *storage = PMINFO_EXTENDED_STORAGE;
1379         else
1380                 return PMINFO_R_ERROR;
1381
1382         return PMINFO_R_OK;
1383 }
1384
1385 API int pkgmgrinfo_pkginfo_get_installed_time(pkgmgrinfo_pkginfo_h handle, int *installed_time)
1386 {
1387         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1388
1389         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1390         retvm_if(installed_time == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1391
1392         if (info->pkg_info == NULL || info->pkg_info->installed_time == NULL)
1393                 return PMINFO_R_ERROR;
1394
1395         *installed_time = atoi(info->pkg_info->installed_time);
1396
1397         return PMINFO_R_OK;
1398 }
1399
1400 API int pkgmgrinfo_pkginfo_get_storeclientid(pkgmgrinfo_pkginfo_h handle, char **storeclientid)
1401 {
1402         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1403
1404         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1405         retvm_if(storeclientid == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1406
1407         if (info->pkg_info == NULL)
1408                 return PMINFO_R_ERROR;
1409
1410         if (info->pkg_info->storeclient_id == NULL)
1411                 *storeclientid = "";
1412         else
1413                 *storeclientid = (char *)info->pkg_info->storeclient_id;
1414
1415         return PMINFO_R_OK;
1416 }
1417
1418 API int pkgmgrinfo_pkginfo_get_mainappid(pkgmgrinfo_pkginfo_h handle, char **mainappid)
1419 {
1420         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1421
1422         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1423         retvm_if(mainappid == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1424
1425         if (info->pkg_info == NULL || info->pkg_info->mainapp_id == NULL)
1426                 return PMINFO_R_ERROR;
1427
1428         *mainappid = (char *)info->pkg_info->mainapp_id;
1429
1430         return PMINFO_R_OK;
1431 }
1432
1433 API int pkgmgrinfo_pkginfo_get_url(pkgmgrinfo_pkginfo_h handle, char **url)
1434 {
1435         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1436
1437         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1438         retvm_if(url == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1439
1440         if (info->pkg_info == NULL)
1441                 return PMINFO_R_ERROR;
1442
1443         if (info->pkg_info->package_url == NULL)
1444                 *url = "";
1445         else
1446                 *url = (char *)info->pkg_info->package_url;
1447
1448         return PMINFO_R_OK;
1449 }
1450
1451 API int pkgmgrinfo_pkginfo_get_root_path(pkgmgrinfo_pkginfo_h handle, char **path)
1452 {
1453         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1454
1455         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1456         retvm_if(path == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1457
1458         if (info->pkg_info == NULL || info->pkg_info->root_path == NULL)
1459                 return PMINFO_R_ERROR;
1460
1461         *path = (char *)info->pkg_info->root_path;
1462
1463         return PMINFO_R_OK;
1464 }
1465
1466 API int pkgmgrinfo_pkginfo_get_csc_path(pkgmgrinfo_pkginfo_h handle, char **path)
1467 {
1468         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1469
1470         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1471         retvm_if(path == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1472
1473         if (info->pkg_info == NULL)
1474                 return PMINFO_R_ERROR;
1475
1476         if (info->pkg_info->csc_path == NULL)
1477                 *path = "";
1478         else
1479                 *path = (char *)info->pkg_info->csc_path;
1480
1481         return PMINFO_R_OK;
1482 }
1483
1484 API int pkgmgrinfo_pkginfo_get_support_mode(pkgmgrinfo_pkginfo_h handle, int *support_mode)
1485 {
1486         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1487         retvm_if(support_mode == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1488
1489         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1490         if (info->pkg_info->support_mode)
1491                 *support_mode = atoi(info->pkg_info->support_mode);
1492         else
1493                 *support_mode = 0;
1494
1495         return PMINFO_R_OK;
1496 }
1497
1498 API int pkgmgrinfo_pkginfo_is_accessible(pkgmgrinfo_pkginfo_h handle, bool *accessible)
1499 {
1500         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1501         retvm_if(accessible == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1502
1503 #if 0 /* smack issue occured, check later */
1504         char *pkgid = NULL;
1505         pkgmgrinfo_pkginfo_get_pkgid(handle, &pkgid);
1506         if (pkgid == NULL) {
1507                  _LOGD("invalid func parameters\n");
1508                  return PMINFO_R_ERROR;
1509         }
1510          _LOGD("pkgmgr_get_pkg_external_validation() called\n");
1511
1512         FILE *fp = NULL;
1513         char app_mmc_path[FILENAME_MAX] = { 0, };
1514         char app_dir_path[FILENAME_MAX] = { 0, };
1515         char app_mmc_internal_path[FILENAME_MAX] = { 0, };
1516         snprintf(app_dir_path, FILENAME_MAX, "%s%s", PKG_INSTALLATION_PATH, pkgid);
1517         snprintf(app_mmc_path, FILENAME_MAX, "%s%s", PKG_SD_PATH, pkgid);
1518         snprintf(app_mmc_internal_path, FILENAME_MAX, "%s%s/.mmc", PKG_INSTALLATION_PATH, pkgid);
1519
1520         /*check whether application is in external memory or not */
1521         fp = fopen(app_mmc_path, "r");
1522         if (fp == NULL) {
1523                 _LOGD(" app path in external memory not accesible\n");
1524         } else {
1525                 fclose(fp);
1526                 fp = NULL;
1527                 *accessible = 1;
1528                 _LOGD("pkgmgr_get_pkg_external_validation() : SD_CARD \n");
1529                 return PMINFO_R_OK;
1530         }
1531
1532         /*check whether application is in internal or not */
1533         if (fp == NULL) {
1534                 _LOGD(" app path in internal memory not accesible\n");
1535                 *accessible = 0;
1536                 return PMINFO_R_ERROR;
1537         } else {
1538                 fclose(fp);
1539                 /*check whether the application is installed in SD card
1540                 but SD card is not present*/
1541                 fp = fopen(app_mmc_internal_path, "r");
1542                 if (fp == NULL) {
1543                         *accessible = 1;
1544                         _LOGD("pkgmgr_get_pkg_external_validation() : INTERNAL_MEM \n");
1545                         return PMINFO_R_OK;
1546                 } else {
1547                         *accessible = 0;
1548                         _LOGD("pkgmgr_get_pkg_external_validation() : ERROR_MMC_STATUS \n");
1549                 }
1550                 fclose(fp);
1551         }
1552
1553         _LOGD("pkgmgr_get_pkg_external_validation() end\n");
1554 #endif
1555
1556         *accessible = 1;
1557         return PMINFO_R_OK;
1558 }
1559
1560 API int pkgmgrinfo_pkginfo_is_removable(pkgmgrinfo_pkginfo_h handle, bool *removable)
1561 {
1562         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1563
1564         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1565         retvm_if(removable == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1566
1567         if (info->pkg_info == NULL || info->pkg_info->removable == NULL)
1568                 return PMINFO_R_ERROR;
1569
1570         *removable = _get_bool_value(info->pkg_info->removable);
1571
1572         return PMINFO_R_OK;
1573 }
1574
1575 API int pkgmgrinfo_pkginfo_is_movable(pkgmgrinfo_pkginfo_h handle, bool *movable)
1576 {
1577         char *val;
1578         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1579
1580         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1581         retvm_if(movable == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1582
1583         if (info->pkg_info == NULL || info->pkg_info->installlocation == NULL)
1584                 return PMINFO_R_ERROR;
1585
1586         val = (char *)info->pkg_info->installlocation;
1587         if (strcmp(val, "internal-only") == 0)
1588                 *movable = 0;
1589         else
1590                 *movable = 1;
1591
1592         return PMINFO_R_OK;
1593 }
1594
1595 API int pkgmgrinfo_pkginfo_is_preload(pkgmgrinfo_pkginfo_h handle, bool *preload)
1596 {
1597         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1598
1599         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1600         retvm_if(preload == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1601
1602         if (info->pkg_info == NULL || info->pkg_info->preload == NULL)
1603                 return PMINFO_R_ERROR;
1604
1605         *preload = _get_bool_value(info->pkg_info->preload);
1606
1607         return PMINFO_R_OK;
1608 }
1609
1610 API int pkgmgrinfo_pkginfo_is_system(pkgmgrinfo_pkginfo_h handle, bool *system)
1611 {
1612         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1613
1614         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1615         retvm_if(system == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1616
1617         if (info->pkg_info == NULL || info->pkg_info->system == NULL)
1618                 return PMINFO_R_ERROR;
1619
1620         *system = _get_bool_value(info->pkg_info->system);
1621
1622         return PMINFO_R_OK;
1623 }
1624
1625 API int pkgmgrinfo_pkginfo_is_readonly(pkgmgrinfo_pkginfo_h handle, bool *readonly)
1626 {
1627         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1628
1629         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1630         retvm_if(readonly == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1631
1632         if (info->pkg_info == NULL || info->pkg_info->readonly == NULL)
1633                 return PMINFO_R_ERROR;
1634
1635         *readonly = _get_bool_value(info->pkg_info->readonly);
1636
1637         return PMINFO_R_OK;
1638 }
1639
1640 API int pkgmgrinfo_pkginfo_is_update(pkgmgrinfo_pkginfo_h handle, bool *update)
1641 {
1642         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1643
1644         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1645         retvm_if(update == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1646
1647         if (info->pkg_info == NULL || info->pkg_info->update == NULL)
1648                 return PMINFO_R_ERROR;
1649
1650         *update = _get_bool_value(info->pkg_info->update);
1651
1652         return PMINFO_R_OK;
1653 }
1654
1655 API int pkgmgrinfo_pkginfo_is_support_disable(pkgmgrinfo_pkginfo_h handle, bool *support_disable)
1656 {
1657         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1658
1659         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1660         retvm_if(support_disable == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1661
1662         if (info->pkg_info == NULL || info->pkg_info->support_disable == NULL)
1663                 return PMINFO_R_ERROR;
1664
1665         *support_disable = _get_bool_value(info->pkg_info->support_disable);
1666
1667         return PMINFO_R_OK;
1668 }
1669
1670 API int pkgmgrinfo_pkginfo_is_global(pkgmgrinfo_pkginfo_h handle, bool *global)
1671 {
1672         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1673
1674         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1675         retvm_if(global == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1676
1677         if (info->pkg_info == NULL || info->pkg_info->for_all_users == NULL)
1678                 return PMINFO_R_ERROR;
1679
1680         *global = _get_bool_value(info->pkg_info->for_all_users);
1681
1682         return PMINFO_R_OK;
1683 }
1684
1685 API int pkgmgrinfo_pkginfo_is_for_all_users(pkgmgrinfo_pkginfo_h handle, bool *for_all_users)
1686 {
1687         return pkgmgrinfo_pkginfo_is_global(handle, for_all_users);
1688 }
1689
1690 API int pkgmgrinfo_pkginfo_destroy_pkginfo(pkgmgrinfo_pkginfo_h handle)
1691 {
1692         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1693
1694         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1695
1696         __cleanup_pkginfo(info);
1697
1698         return PMINFO_R_OK;
1699 }
1700
1701 API int pkgmgrinfo_pkginfo_filter_create(pkgmgrinfo_pkginfo_filter_h *handle)
1702 {
1703         pkgmgrinfo_filter_x *filter;
1704
1705         retvm_if(handle == NULL, PMINFO_R_EINVAL, "Filter handle output parameter is NULL\n");
1706
1707         filter = (pkgmgrinfo_filter_x *)calloc(1, sizeof(pkgmgrinfo_filter_x));
1708         if (filter == NULL) {
1709                 _LOGE("Out of Memory!!!");
1710                 return PMINFO_R_ERROR;
1711         }
1712
1713         *handle = filter;
1714
1715         return PMINFO_R_OK;
1716 }
1717
1718 API int pkgmgrinfo_pkginfo_filter_destroy(pkgmgrinfo_pkginfo_filter_h handle)
1719 {
1720         pkgmgrinfo_filter_x *filter = (pkgmgrinfo_filter_x *)handle;
1721
1722         retvm_if(handle == NULL, PMINFO_R_EINVAL, "Filter handle input parameter is NULL\n");
1723
1724         if (filter->list) {
1725                 g_slist_foreach(filter->list, __destroy_each_node, NULL);
1726                 g_slist_free(filter->list);
1727         }
1728
1729         g_slist_free_full(filter->list_metadata, __destroy_metadata_node);
1730
1731         free(filter);
1732
1733         return PMINFO_R_OK;
1734 }
1735
1736 API int pkgmgrinfo_pkginfo_filter_add_int(pkgmgrinfo_pkginfo_filter_h handle,
1737                                 const char *property, const int value)
1738 {
1739         char buf[PKG_VALUE_STRING_LEN_MAX] = {'\0'};
1740         char *val;
1741         GSList *link;
1742         int prop;
1743         pkgmgrinfo_filter_x *filter = (pkgmgrinfo_filter_x *)handle;
1744         pkgmgrinfo_node_x *node;
1745
1746         retvm_if(handle == NULL, PMINFO_R_EINVAL, "Filter handle input parameter is NULL\n");
1747         retvm_if(property == NULL, PMINFO_R_EINVAL, "Filter handle input parameter is NULL\n");
1748
1749         prop = _pminfo_pkginfo_convert_to_prop_int(property);
1750         if (prop < E_PMINFO_PKGINFO_PROP_PACKAGE_MIN_INT ||
1751                 prop > E_PMINFO_PKGINFO_PROP_PACKAGE_MAX_INT) {
1752                 _LOGE("Invalid Integer Property\n");
1753                 return PMINFO_R_EINVAL;
1754         }
1755         node = (pkgmgrinfo_node_x *)calloc(1, sizeof(pkgmgrinfo_node_x));
1756         if (node == NULL) {
1757                 _LOGE("Out of Memory!!!\n");
1758                 return PMINFO_R_ERROR;
1759         }
1760         snprintf(buf, PKG_VALUE_STRING_LEN_MAX - 1, "%d", value);
1761         val = strndup(buf, PKG_VALUE_STRING_LEN_MAX - 1);
1762         if (val == NULL) {
1763                 _LOGE("Out of Memory\n");
1764                 free(node);
1765                 return PMINFO_R_ERROR;
1766         }
1767         node->prop = prop;
1768         node->value = val;
1769         /*If API is called multiple times for same property, we should override the previous values.
1770         Last value set will be used for filtering.*/
1771         link = g_slist_find_custom(filter->list, (gconstpointer)node, __compare_func);
1772         if (link)
1773                 filter->list = g_slist_delete_link(filter->list, link);
1774         filter->list = g_slist_append(filter->list, (gpointer)node);
1775         return PMINFO_R_OK;
1776
1777 }
1778
1779 API int pkgmgrinfo_pkginfo_filter_add_bool(pkgmgrinfo_pkginfo_filter_h handle,
1780                                 const char *property, const bool value)
1781 {
1782         char *val;
1783         GSList *link;
1784         int prop;
1785         pkgmgrinfo_filter_x *filter = (pkgmgrinfo_filter_x *)handle;
1786         pkgmgrinfo_node_x *node;
1787
1788         retvm_if(handle == NULL, PMINFO_R_EINVAL, "Filter handle input parameter is NULL\n");
1789         retvm_if(property == NULL, PMINFO_R_EINVAL, "Filter handle input parameter is NULL\n");
1790
1791         prop = _pminfo_pkginfo_convert_to_prop_bool(property);
1792         if (prop < E_PMINFO_PKGINFO_PROP_PACKAGE_MIN_BOOL ||
1793                 prop > E_PMINFO_PKGINFO_PROP_PACKAGE_MAX_BOOL) {
1794                 _LOGE("Invalid Boolean Property\n");
1795                 return PMINFO_R_EINVAL;
1796         }
1797         node = (pkgmgrinfo_node_x *)calloc(1, sizeof(pkgmgrinfo_node_x));
1798         if (node == NULL) {
1799                 _LOGE("Out of Memory!!!\n");
1800                 return PMINFO_R_ERROR;
1801         }
1802         if (value)
1803                 val = strndup("true", 4);
1804         else
1805                 val = strndup("false", 5);
1806         if (val == NULL) {
1807                 _LOGE("Out of Memory\n");
1808                 free(node);
1809                 return PMINFO_R_ERROR;
1810         }
1811         node->prop = prop;
1812         node->value = val;
1813         /*If API is called multiple times for same property, we should override the previous values.
1814         Last value set will be used for filtering.*/
1815         link = g_slist_find_custom(filter->list, (gconstpointer)node, __compare_func);
1816         if (link)
1817                 filter->list = g_slist_delete_link(filter->list, link);
1818         filter->list = g_slist_append(filter->list, (gpointer)node);
1819         return PMINFO_R_OK;
1820
1821 }
1822
1823 API int pkgmgrinfo_pkginfo_filter_add_string(pkgmgrinfo_pkginfo_filter_h handle,
1824                                 const char *property, const char *value)
1825 {
1826         char *val;
1827         GSList *link;
1828         int prop;
1829         pkgmgrinfo_filter_x *filter = (pkgmgrinfo_filter_x *)handle;
1830         pkgmgrinfo_node_x *node;
1831
1832         retvm_if(handle == NULL, PMINFO_R_EINVAL, "Filter handle input parameter is NULL\n");
1833         retvm_if(property == NULL, PMINFO_R_EINVAL, "Filter handle input parameter is NULL\n");
1834         retvm_if(value == NULL, PMINFO_R_EINVAL, "Filter handle input parameter is NULL\n");
1835
1836         prop = _pminfo_pkginfo_convert_to_prop_str(property);
1837         if (prop < E_PMINFO_PKGINFO_PROP_PACKAGE_MIN_STR ||
1838                 prop > E_PMINFO_PKGINFO_PROP_PACKAGE_MAX_STR) {
1839                 _LOGE("Invalid String Property\n");
1840                 return PMINFO_R_EINVAL;
1841         }
1842         node = (pkgmgrinfo_node_x *)calloc(1, sizeof(pkgmgrinfo_node_x));
1843         if (node == NULL) {
1844                 _LOGE("Out of Memory!!!\n");
1845                 return PMINFO_R_ERROR;
1846         }
1847         if (strcmp(value, PMINFO_PKGINFO_INSTALL_LOCATION_AUTO) == 0)
1848                 val = strndup("auto", PKG_STRING_LEN_MAX - 1);
1849         else if (strcmp(value, PMINFO_PKGINFO_INSTALL_LOCATION_INTERNAL) == 0)
1850                 val = strndup("internal-only", PKG_STRING_LEN_MAX - 1);
1851         else if (strcmp(value, PMINFO_PKGINFO_INSTALL_LOCATION_EXTERNAL) == 0)
1852                 val = strndup("prefer-external", PKG_STRING_LEN_MAX - 1);
1853         else if (strcmp(value, "installed_internal") == 0)
1854                 val = strndup("installed_internal", PKG_STRING_LEN_MAX - 1);
1855         else if (strcmp(value, "installed_external") == 0)
1856                 val = strndup("installed_external", PKG_STRING_LEN_MAX - 1);
1857         else
1858                 val = strndup(value, PKG_STRING_LEN_MAX - 1);
1859         if (val == NULL) {
1860                 _LOGE("Out of Memory\n");
1861                 free(node);
1862                 return PMINFO_R_ERROR;
1863         }
1864         node->prop = prop;
1865         node->value = val;
1866         /*If API is called multiple times for same property, we should override the previous values.
1867         Last value set will be used for filtering.*/
1868         link = g_slist_find_custom(filter->list, (gconstpointer)node, __compare_func);
1869         if (link)
1870                 filter->list = g_slist_delete_link(filter->list, link);
1871         filter->list = g_slist_append(filter->list, (gpointer)node);
1872         return PMINFO_R_OK;
1873
1874 }
1875
1876 API int pkgmgrinfo_pkginfo_usr_filter_count(pkgmgrinfo_pkginfo_filter_h handle, int *count, uid_t uid)
1877 {
1878         int ret;
1879         char *locale;
1880         GHashTable *list = NULL;
1881
1882         if (handle == NULL || count == NULL) {
1883                 _LOGE("invalid parameter");
1884                 return PMINFO_R_EINVAL;
1885         }
1886
1887         locale = _get_system_locale();
1888         if (locale == NULL)
1889                 return PMINFO_R_ERROR;
1890
1891         list = g_hash_table_new_full(g_str_hash, g_str_equal, NULL,
1892                         __free_packages);
1893         if (list == NULL) {
1894                 free(locale);
1895                 return PMINFO_R_ERROR;
1896         }
1897
1898         if (__check_disable_filter_exist((pkgmgrinfo_filter_x *)handle) == false) {
1899                 ret = pkgmgrinfo_pkginfo_filter_add_bool(handle,
1900                                 PMINFO_PKGINFO_PROP_PACKAGE_DISABLE, false);
1901                 if (ret != PMINFO_R_OK) {
1902                         free(locale);
1903                         g_hash_table_destroy(list);
1904                         return PMINFO_R_ERROR;
1905                 }
1906         }
1907
1908         ret = _pkginfo_get_packages(uid, locale,
1909                         (pkgmgrinfo_filter_x *)handle, 0, list);
1910         if (ret == PMINFO_R_OK && uid != GLOBAL_USER)
1911                 ret = _pkginfo_get_packages(GLOBAL_USER, locale, handle, 0,
1912                                 list);
1913
1914         if (ret != PMINFO_R_OK) {
1915                 g_hash_table_destroy(list);
1916                 free(locale);
1917                 return PMINFO_R_ERROR;
1918         }
1919
1920         *count = g_hash_table_size(list);
1921
1922         g_hash_table_destroy(list);
1923         free(locale);
1924
1925         return PMINFO_R_OK;
1926 }
1927
1928 API int pkgmgrinfo_pkginfo_filter_count(pkgmgrinfo_pkginfo_filter_h handle, int *count)
1929 {
1930         return pkgmgrinfo_pkginfo_usr_filter_count(handle, count, _getuid());
1931 }
1932
1933 API int pkgmgrinfo_pkginfo_usr_filter_foreach_pkginfo(
1934                 pkgmgrinfo_pkginfo_filter_h handle,
1935                 pkgmgrinfo_pkg_list_cb pkg_cb, void *user_data, uid_t uid)
1936 {
1937         if (handle == NULL || pkg_cb == NULL) {
1938                 LOGE("invalid parameter");
1939                 return PMINFO_R_EINVAL;
1940         }
1941
1942         return _pkginfo_get_filtered_foreach_pkginfo(uid, handle,
1943                         PMINFO_PKGINFO_GET_ALL, pkg_cb, user_data);
1944 }
1945
1946 API int pkgmgrinfo_pkginfo_filter_foreach_pkginfo(pkgmgrinfo_pkginfo_filter_h handle,
1947                                 pkgmgrinfo_pkg_list_cb pkg_cb, void *user_data)
1948 {
1949         return pkgmgrinfo_pkginfo_usr_filter_foreach_pkginfo(handle, pkg_cb, user_data, _getuid());
1950 }
1951
1952 API int pkgmgrinfo_pkginfo_foreach_privilege(pkgmgrinfo_pkginfo_h handle,
1953                         pkgmgrinfo_pkg_privilege_list_cb privilege_func, void *user_data)
1954 {
1955         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL");
1956         retvm_if(privilege_func == NULL, PMINFO_R_EINVAL, "Callback function is NULL");
1957         int ret;
1958         privilege_x *privilege;
1959         appdefined_privilege_x *appdefined_privilege;
1960         GList *tmp;
1961         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1962
1963         if (info->pkg_info == NULL)
1964                 return PMINFO_R_ERROR;
1965
1966         for (tmp = info->pkg_info->privileges; tmp; tmp = tmp->next) {
1967                 privilege = (privilege_x *)tmp->data;
1968                 if (privilege == NULL)
1969                         continue;
1970                 ret = privilege_func(privilege->value, user_data);
1971                 if (ret < 0)
1972                         return PMINFO_R_OK;
1973         }
1974
1975         for (tmp = info->pkg_info->appdefined_privileges; tmp;
1976                         tmp = tmp->next) {
1977                 appdefined_privilege = (appdefined_privilege_x *)tmp->data;
1978                 if (appdefined_privilege == NULL)
1979                         continue;
1980                 ret = privilege_func(appdefined_privilege->value, user_data);
1981                 if (ret < 0)
1982                         return PMINFO_R_OK;
1983         }
1984         return PMINFO_R_OK;
1985 }
1986
1987 API int pkgmgrinfo_pkginfo_foreach_appdefined_privilege(
1988                 pkgmgrinfo_pkginfo_h handle,
1989                 pkgmgrinfo_pkg_appdefined_privilege_list_cb privilege_func,
1990                 void *user_data)
1991 {
1992         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL");
1993         retvm_if(privilege_func == NULL, PMINFO_R_EINVAL,
1994                         "Callback function is NULL");
1995         int ret;
1996         appdefined_privilege_x *privilege;
1997         GList *tmp;
1998         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1999
2000         if (info->pkg_info == NULL)
2001                 return PMINFO_R_ERROR;
2002
2003         for (tmp = info->pkg_info->appdefined_privileges; tmp;
2004                         tmp = tmp->next) {
2005                 privilege = (appdefined_privilege_x *)tmp->data;
2006                 if (privilege == NULL)
2007                         continue;
2008                 ret = privilege_func(privilege->value, privilege->license,
2009                                 user_data);
2010                 if (ret < 0)
2011                         break;
2012         }
2013         return PMINFO_R_OK;
2014 }
2015
2016 int __compare_package_version(const char *version, int *major,
2017                 int *minor, int *macro, int *nano)
2018 {
2019         char *version_temp = NULL;
2020         char *major_str = NULL;
2021         char *minor_str = NULL;
2022         char *macro_str = NULL;
2023         char *nano_str = NULL;
2024         char *save_str = NULL;
2025
2026         if (version == NULL || major == NULL || minor == NULL ||
2027                 macro == NULL || nano == NULL) {
2028                 return PMINFO_R_EINVAL;
2029         }
2030
2031         version_temp = strdup(version);
2032         if (version_temp == NULL) {
2033                 LOGE("Out of memory");
2034                 return PMINFO_R_ERROR;
2035         }
2036
2037         major_str = strtok_r(version_temp, ".", &save_str);
2038         if (major_str == NULL) {
2039                 _LOGE("major version is NULL");
2040                 free(version_temp);
2041                 return PMINFO_R_ERROR;
2042         }
2043
2044         minor_str = strtok_r(NULL, ".", &save_str);
2045         if (minor_str == NULL) {
2046                 _LOGE("minor version is NULL");
2047                 free(version_temp);
2048                 return PMINFO_R_ERROR;
2049         }
2050
2051         *major = atoi(major_str);
2052         *minor = atoi(minor_str);
2053         *macro = 0;
2054         *nano = 0;
2055         macro_str = strtok_r(NULL, ".", &save_str);
2056         if (macro_str == NULL) {
2057                 _LOGD("macro version is NULL");
2058         } else {
2059                 *macro = atoi(macro_str);
2060                 nano_str = strtok_r(NULL, ".", &save_str);
2061                 if (nano_str) {
2062                         *nano = atoi(nano_str);
2063                         _LOGD("nano version exists");
2064                 }
2065         }
2066         _LOGD("version = [%s] -> major = [%d], minor = [%d]," \
2067                 " macro = [%d], nano = [%d]", version, *major,
2068                 *minor, *macro, *nano);
2069
2070         free(version_temp);
2071
2072         return PMINFO_R_OK;
2073 }
2074
2075 API int pkgmgrinfo_compare_package_version(const char *current_version,
2076                 const char *target_version,
2077                 pkgmgrinfo_version_compare_type *res)
2078 {
2079         int ret = 0;
2080         int current_version_major = 0;
2081         int current_version_minor = 0;
2082         int current_version_macro = 0;
2083         int current_version_nano = 0;
2084         int target_version_major = 0;
2085         int target_version_minor = 0;
2086         int target_version_macro = 0;
2087         int target_version_nano = 0;
2088
2089         if (current_version == NULL || target_version == NULL ||
2090                 res == NULL) {
2091                 _LOGE("Invalid parameter");
2092                 return PMINFO_R_EINVAL;
2093         }
2094
2095         ret = __compare_package_version(target_version,
2096                 &target_version_major, &target_version_minor,
2097                 &target_version_macro, &target_version_nano);
2098         if (ret < 0) {
2099                 _LOGE("Failed to compare target version(%d)", ret);
2100                 return PMINFO_R_ERROR;
2101         }
2102
2103         ret = __compare_package_version(current_version,
2104                 &current_version_major, &current_version_minor,
2105                 &current_version_macro, &current_version_nano);
2106         if (ret < 0) {
2107                 _LOGE("Failed to compare current version(%d)", ret);
2108                 return PMINFO_R_ERROR;
2109         }
2110
2111         _LOGD("new[%d.%d.%d.%d] old[%d.%d.%d.%d]", target_version_major,
2112                 target_version_minor, target_version_macro,
2113                 target_version_nano, current_version_major,
2114                 current_version_minor, current_version_macro,
2115                 target_version_nano);
2116
2117         if (target_version_major > current_version_major)
2118                 *res = PMINFO_VERSION_NEW;
2119         else if (target_version_major < current_version_major)
2120                 *res = PMINFO_VERSION_OLD;
2121         else if (target_version_minor > current_version_minor)
2122                 *res = PMINFO_VERSION_NEW;
2123         else if (target_version_minor < current_version_minor)
2124                 *res = PMINFO_VERSION_OLD;
2125         else if (target_version_macro > current_version_macro)
2126                 *res = PMINFO_VERSION_NEW;
2127         else if (target_version_macro < current_version_macro)
2128                 *res = PMINFO_VERSION_OLD;
2129         else if (target_version_nano > current_version_nano)
2130                 *res = PMINFO_VERSION_NEW;
2131         else if (target_version_nano < current_version_nano)
2132                 *res = PMINFO_VERSION_OLD;
2133         else
2134                 *res = PMINFO_VERSION_SAME;
2135
2136         return PMINFO_R_OK;
2137 }