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