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