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 = NULL;
 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                 while ((ep = readdir(dp)) != NULL) {
 152                         if (!strcmp(ep->d_name, ".") ||
 153                                 !strcmp(ep->d_name, "..")) {
 154                                 continue;
 155                         }
 156                         snprintf(abs_filename, FILENAME_MAX, "%s/%s", dirname,
 157                                  ep->d_name);
 158                         if (lstat(abs_filename, &fileinfo) < 0)
 159                                 perror(abs_filename);
 160                         else {
 161                                 if (S_ISDIR(fileinfo.st_mode)) {
 162                                         total += fileinfo.st_size;
 163                                         if (strcmp(ep->d_name, ".")
 164                                             && strcmp(ep->d_name, "..")) {
 165                                                 ret = _pkgmgr_calculate_dir_size
 166                                                     (abs_filename);
 167                                                 total = total + ret;
 168                                         }
 169                                 } else if (S_ISLNK(fileinfo.st_mode)) {
 170                                         continue;
 171                                 } else {
 172                                         /*It is a file. Calculate the actual
 173                                         size occupied (in terms of 4096 blocks)*/
 174                                 q = (fileinfo.st_size / BLOCK_SIZE);
 175                                 r = (fileinfo.st_size % BLOCK_SIZE);
 176                                 if (r) {
 177                                         q = q + 1;
 178                                 }
 179                                 total += q * BLOCK_SIZE;
 180                                 }
 181                         }
 182                 }
 183                 (void)closedir(dp);
 184         } else {
 185                 _LOGE("Couldn't open the directory\n");
 186                 return -1;
 187         }
 188         return total;
 189
 190 }
 191
 192 static gint __list_strcmp(gconstpointer a, gconstpointer b)
 193 {
 194         return strcmp((char *)a, (char *)b);
 195 }
 196
 197 static int _pkginfo_get_list(sqlite3 *db, const char *locale,
 198                 pkgmgrinfo_filter_x *filter, GList **list)
 199 {
 200         static const char query_raw[] =
 201                 "SELECT DISTINCT package_info.package FROM package_info"
 202                 " LEFT OUTER JOIN package_localized_info"
 203                 "  ON package_info.package=package_localized_info.package"
 204                 "  AND package_localized_info.package_locale=%Q "
 205                 " LEFT OUTER JOIN package_privilege_info"
 206                 "  ON package_info.package=package_privilege_info.package";
 207         int ret;
 208         char *query;
 209         char *query_localized;
 210         sqlite3_stmt *stmt;
 211         char *pkgid = NULL;
 212
 213         query = _get_filtered_query(query_raw, filter);
 214         if (query == NULL)
 215                 return -1;
 216         query_localized = sqlite3_mprintf(query, locale);
 217         free(query);
 218         if (query_localized == NULL)
 219                 return -1;
 220
 221         ret = sqlite3_prepare_v2(db, query_localized,
 222                         strlen(query_localized), &stmt, NULL);
 223         sqlite3_free(query_localized);
 224         if (ret != SQLITE_OK) {
 225                 LOGE("prepare failed: %s", sqlite3_errmsg(db));
 226                 return -1;
 227         }
 228
 229         while (sqlite3_step(stmt) == SQLITE_ROW) {
 230                 _save_column_str(stmt, 0, (const char **)&pkgid);
 231                 if (pkgid != NULL)
 232                         *list = g_list_insert_sorted(*list, pkgid,
 233                                         __list_strcmp);
 234         }
 235
 236         sqlite3_finalize(stmt);
 237
 238         return 0;
 239 }
 240
 241 static int _pkginfo_get_filtered_list(pkgmgrinfo_filter_x *filter, uid_t uid,
 242                 GList **list)
 243 {
 244         int ret;
 245         sqlite3 *db;
 246         const char *dbpath;
 247         char *locale;
 248         GList *tmp;
 249         GList *tmp2;
 250
 251         locale = _get_system_locale();
 252         if (locale == NULL)
 253                 return PMINFO_R_ERROR;
 254
 255         dbpath = getUserPkgParserDBPathUID(uid);
 256         if (dbpath == NULL) {
 257                 free(locale);
 258                 return PMINFO_R_ERROR;
 259         }
 260
 261         ret = sqlite3_open_v2(dbpath, &db, SQLITE_OPEN_READONLY, NULL);
 262         if (ret != SQLITE_OK) {
 263                 _LOGE("failed to open db: %d", ret);
 264                 free(locale);
 265                 return PMINFO_R_ERROR;
 266         }
 267
 268         if (_pkginfo_get_list(db, locale, filter, list)) {
 269                 free(locale);
 270                 sqlite3_close_v2(db);
 271                 return PMINFO_R_ERROR;
 272         }
 273         sqlite3_close_v2(db);
 274
 275         if (uid == GLOBAL_USER) {
 276                 free(locale);
 277                 return PMINFO_R_OK;
 278         }
 279
 280         /* search again from global */
 281         dbpath = getUserPkgParserDBPathUID(GLOBAL_USER);
 282         if (dbpath == NULL) {
 283                 free(locale);
 284                 return PMINFO_R_ERROR;
 285         }
 286
 287         ret = sqlite3_open_v2(dbpath, &db, SQLITE_OPEN_READONLY, NULL);
 288         if (ret != SQLITE_OK) {
 289                 _LOGE("failed to open db: %d", ret);
 290                 free(locale);
 291                 return PMINFO_R_ERROR;
 292         }
 293
 294         if (_pkginfo_get_list(db, locale, filter, list)) {
 295                 free(locale);
 296                 sqlite3_close_v2(db);
 297                 return PMINFO_R_ERROR;
 298         }
 299         sqlite3_close_v2(db);
 300
 301         /* remove duplicate element:
 302          * since the list is sorted, we can remove duplicates in linear time
 303          */
 304         for (tmp = *list, tmp2 = g_list_next(tmp); tmp;
 305                         tmp = tmp2, tmp2 = g_list_next(tmp)) {
 306                 if (tmp->prev == NULL || tmp->data == NULL)
 307                         continue;
 308                 if (strcmp((const char *)tmp->prev->data,
 309                                         (const char *)tmp->data) == 0)
 310                         *list = g_list_delete_link(*list, tmp);
 311         }
 312
 313         free(locale);
 314
 315         return PMINFO_R_OK;
 316 }
 317
 318
 319 static int _pkginfo_get_filtered_foreach_pkginfo(pkgmgrinfo_filter_x *filter,
 320                 pkgmgrinfo_pkg_list_cb pkg_list_cb, void *user_data, uid_t uid)
 321 {
 322         int ret;
 323         pkgmgr_pkginfo_x *info;
 324         GList *list = NULL;
 325         GList *tmp;
 326         char *pkgid;
 327         int stop = 0;
 328
 329         ret = _pkginfo_get_filtered_list(filter, uid, &list);
 330         if (ret != PMINFO_R_OK)
 331                 return PMINFO_R_ERROR;
 332
 333         for (tmp = list; tmp; tmp = tmp->next) {
 334                 pkgid = (char *)tmp->data;
 335                 if (stop == 0) {
 336                         ret = _pkginfo_get_pkginfo(pkgid, uid, &info);
 337                         if (ret == PMINFO_R_ENOENT && uid != GLOBAL_USER)
 338                                 ret = _pkginfo_get_pkginfo(pkgid, GLOBAL_USER,
 339                                                 &info);
 340                         if (ret != PMINFO_R_OK) {
 341                                 free(pkgid);
 342                                 continue;
 343                         }
 344                         if (pkg_list_cb(info, user_data) < 0)
 345                                 stop = 1;
 346                         pkgmgrinfo_pkginfo_destroy_pkginfo(info);
 347                 }
 348                 free(pkgid);
 349         }
 350
 351         g_list_free(list);
 352
 353         return PMINFO_R_OK;
 354 }
 355
 356 API int pkgmgrinfo_pkginfo_get_usr_list(pkgmgrinfo_pkg_list_cb pkg_list_cb,
 357                 void *user_data, uid_t uid)
 358 {
 359         if (pkg_list_cb == NULL) {
 360                 LOGE("invalid parameter");
 361                 return PMINFO_R_EINVAL;
 362         }
 363
 364         return _pkginfo_get_filtered_foreach_pkginfo(NULL, pkg_list_cb,
 365                         user_data, uid);
 366 }
 367
 368 API int pkgmgrinfo_pkginfo_get_list(pkgmgrinfo_pkg_list_cb pkg_list_cb, void *user_data)
 369 {
 370         return pkgmgrinfo_pkginfo_get_usr_list(pkg_list_cb, user_data, GLOBAL_USER);
 371 }
 372
 373 static int _pkginfo_get_author(sqlite3 *db, const char *pkgid,
 374                 GList **author)
 375 {
 376         static const char query_raw[] =
 377                 "SELECT author_name, author_email, author_href "
 378                 "FROM package_info WHERE package=%Q";
 379         int ret;
 380         char *query;
 381         sqlite3_stmt *stmt;
 382         int idx = 0;
 383         author_x *info;
 384
 385         query = sqlite3_mprintf(query_raw, pkgid);
 386         if (query == NULL) {
 387                 LOGE("out of memory");
 388                 return PMINFO_R_ERROR;
 389         }
 390
 391         ret = sqlite3_prepare_v2(db, query, strlen(query),
 392                         &stmt, NULL);
 393         sqlite3_free(query);
 394         if (ret != SQLITE_OK) {
 395                 LOGE("prepare failed: %s", sqlite3_errmsg(db));
 396                 return PMINFO_R_ERROR;
 397         }
 398
 399         if (sqlite3_step(stmt) == SQLITE_ERROR) {
 400                 LOGE("step error: %s", sqlite3_errmsg(db));
 401                 sqlite3_finalize(stmt);
 402                 return PMINFO_R_ERROR;
 403         }
 404
 405         /* one author per one package */
 406         info = calloc(1, sizeof(author_x));
 407         if (info == NULL) {
 408                 LOGE("out of memory");
 409                 sqlite3_finalize(stmt);
 410                 return PMINFO_R_ERROR;
 411         }
 412
 413         _save_column_str(stmt, idx++, &info->text);
 414         _save_column_str(stmt, idx++, &info->email);
 415         _save_column_str(stmt, idx++, &info->href);
 416
 417         /* TODO: revised */
 418         *author = g_list_append(*author, info);
 419
 420         sqlite3_finalize(stmt);
 421
 422         return PMINFO_R_OK;
 423 }
 424
 425 static int _pkginfo_get_label(sqlite3 *db, const char *pkgid,
 426                 const char *locale, GList **label)
 427 {
 428         static const char query_raw[] =
 429                 "SELECT package_label, package_locale "
 430                 "FROM package_localized_info "
 431                 "WHERE package=%Q AND package_locale IN (%Q, %Q)";
 432         int ret;
 433         char *query;
 434         sqlite3_stmt *stmt;
 435         int idx;
 436         label_x *info;
 437
 438         query = sqlite3_mprintf(query_raw, pkgid, locale, DEFAULT_LOCALE);
 439         if (query == NULL) {
 440                 LOGE("out of memory");
 441                 return PMINFO_R_ERROR;
 442         }
 443
 444         ret = sqlite3_prepare_v2(db, query, strlen(query),
 445                         &stmt, NULL);
 446         sqlite3_free(query);
 447         if (ret != SQLITE_OK) {
 448                 LOGE("prepare failed: %s", sqlite3_errmsg(db));
 449                 return PMINFO_R_ERROR;
 450         }
 451
 452         while (sqlite3_step(stmt) == SQLITE_ROW) {
 453                 info = calloc(1, sizeof(label_x));
 454                 if (info == NULL) {
 455                         LOGE("out of memory");
 456                         sqlite3_finalize(stmt);
 457                         return PMINFO_R_ERROR;
 458                 }
 459                 idx = 0;
 460                 _save_column_str(stmt, idx++, &info->text);
 461                 _save_column_str(stmt, idx++, &info->lang);
 462                 *label = g_list_append(*label, info);
 463         }
 464
 465         sqlite3_finalize(stmt);
 466
 467         return PMINFO_R_OK;
 468 }
 469
 470 static int _pkginfo_get_icon(sqlite3 *db, const char *pkgid, const char *locale,
 471                 GList **icon)
 472 {
 473         static const char query_raw[] =
 474                 "SELECT package_icon, package_locale "
 475                 "FROM package_localized_info "
 476                 "WHERE package=%Q AND package_locale IN (%Q, %Q)";
 477         int ret;
 478         char *query;
 479         sqlite3_stmt *stmt;
 480         int idx;
 481         icon_x *info;
 482
 483         query = sqlite3_mprintf(query_raw, pkgid, locale, DEFAULT_LOCALE);
 484         if (query == NULL) {
 485                 LOGE("out of memory");
 486                 return PMINFO_R_ERROR;
 487         }
 488
 489         ret = sqlite3_prepare_v2(db, query, strlen(query),
 490                         &stmt, NULL);
 491         sqlite3_free(query);
 492         if (ret != SQLITE_OK) {
 493                 LOGE("prepare failed: %s", sqlite3_errmsg(db));
 494                 return PMINFO_R_ERROR;
 495         }
 496
 497         while (sqlite3_step(stmt) == SQLITE_ROW) {
 498                 info = calloc(1, sizeof(icon_x));
 499                 if (info == NULL) {
 500                         LOGE("out of memory");
 501                         sqlite3_finalize(stmt);
 502                         return PMINFO_R_ERROR;
 503                 }
 504                 idx = 0;
 505                 _save_column_str(stmt, idx++, &info->text);
 506                 _save_column_str(stmt, idx++, &info->lang);
 507                 *icon = g_list_append(*icon, info);
 508         }
 509
 510         sqlite3_finalize(stmt);
 511
 512         return PMINFO_R_OK;
 513 }
 514
 515 static int _pkginfo_get_description(sqlite3 *db, const char *pkgid,
 516                 const char *locale, GList **description)
 517 {
 518         static const char query_raw[] =
 519                 "SELECT package_description, package_locale "
 520                 "FROM package_localized_info "
 521                 "WHERE package=%Q AND package_locale IN (%Q, %Q)";
 522         int ret;
 523         char *query;
 524         sqlite3_stmt *stmt;
 525         int idx;
 526         description_x *info;
 527
 528         query = sqlite3_mprintf(query_raw, pkgid, locale, DEFAULT_LOCALE);
 529         if (query == NULL) {
 530                 LOGE("out of memory");
 531                 return PMINFO_R_ERROR;
 532         }
 533
 534         ret = sqlite3_prepare_v2(db, query, strlen(query),
 535                         &stmt, NULL);
 536         sqlite3_free(query);
 537         if (ret != SQLITE_OK) {
 538                 LOGE("prepare failed: %s", sqlite3_errmsg(db));
 539                 return PMINFO_R_ERROR;
 540         }
 541
 542         while (sqlite3_step(stmt) == SQLITE_ROW) {
 543                 info = calloc(1, sizeof(description_x));
 544                 if (info == NULL) {
 545                         LOGE("out of memory");
 546                         sqlite3_finalize(stmt);
 547                         return PMINFO_R_ERROR;
 548                 }
 549                 idx = 0;
 550                 _save_column_str(stmt, idx++, &info->text);
 551                 _save_column_str(stmt, idx++, &info->lang);
 552                 *description = g_list_append(*description, info);
 553         }
 554
 555         sqlite3_finalize(stmt);
 556
 557         return PMINFO_R_OK;
 558 }
 559
 560 static int _pkginfo_get_privilege(sqlite3 *db, const char *pkgid,
 561                 GList **privileges)
 562 {
 563         static const char query_raw[] =
 564                 "SELECT privilege FROM package_privilege_info WHERE package=%Q";
 565         int ret;
 566         char *query;
 567         sqlite3_stmt *stmt;
 568         const char *privilege;
 569
 570         query = sqlite3_mprintf(query_raw, pkgid);
 571         if (query == NULL) {
 572                 LOGE("out of memory");
 573                 return PMINFO_R_ERROR;
 574         }
 575
 576         ret = sqlite3_prepare_v2(db, query, strlen(query),
 577                         &stmt, NULL);
 578         sqlite3_free(query);
 579         if (ret != SQLITE_OK) {
 580                 LOGE("prepare failed: %s", sqlite3_errmsg(db));
 581                 return PMINFO_R_ERROR;
 582         }
 583
 584         while (sqlite3_step(stmt) == SQLITE_ROW) {
 585                 privilege = NULL;
 586                 _save_column_str(stmt, 0, &privilege);
 587                 if (privilege)
 588                         *privileges = g_list_append(*privileges,
 589                                         (gpointer)privilege);
 590         }
 591
 592         sqlite3_finalize(stmt);
 593
 594         return PMINFO_R_OK;
 595 }
 596
 597 static char *_get_filtered_query(const char *query_raw,
 598                 pkgmgrinfo_filter_x *filter)
 599 {
 600         char buf[MAX_QUERY_LEN] = { 0, };
 601         char *condition;
 602         size_t len;
 603         GSList *list;
 604         GSList *head = NULL;
 605
 606         if (filter)
 607                 head = filter->list;
 608
 609         strncat(buf, query_raw, MAX_QUERY_LEN - 1);
 610         len = strlen(buf);
 611         for (list = head; list; list = list->next) {
 612                 /* TODO: revise condition getter function */
 613                 __get_filter_condition(list->data, &condition);
 614                 if (condition == NULL)
 615                         continue;
 616                 if (buf[strlen(query_raw)] == '\0') {
 617                         len += strlen(" WHERE ");
 618                         strncat(buf, " WHERE ", MAX_QUERY_LEN - len - 1);
 619                 } else {
 620                         len += strlen(" AND ");
 621                         strncat(buf, " AND ", MAX_QUERY_LEN -len - 1);
 622                 }
 623                 len += strlen(condition);
 624                 strncat(buf, condition, sizeof(buf) - len - 1);
 625                 free(condition);
 626                 condition = NULL;
 627         }
 628
 629         return strdup(buf);
 630 }
 631
 632 static int _pkginfo_get_package(sqlite3 *db, const char *pkgid,
 633                 const char *locale, package_x **package)
 634 {
 635         static const char query_raw[] =
 636                 "SELECT package, package_version, "
 637                 "install_location, package_removable, package_preload, "
 638                 "package_readonly, package_update, package_appsetting, "
 639                 "package_system, package_type, package_size, installed_time, "
 640                 "installed_storage, storeclient_id, mainapp_id, package_url, "
 641                 "root_path, csc_path, package_nodisplay, package_api_version, "
 642                 "package_support_disable, package_tep_name "
 643                 "FROM package_info WHERE package=%Q AND package_disable='false'";
 644         int ret;
 645         char *query;
 646         sqlite3_stmt *stmt;
 647         int idx;
 648         package_x *info;
 649
 650         query = sqlite3_mprintf(query_raw, pkgid);
 651         if (query == NULL) {
 652                 LOGE("out of memory");
 653                 return PMINFO_R_ERROR;
 654         }
 655
 656         ret = sqlite3_prepare_v2(db, query, strlen(query),
 657                         &stmt, NULL);
 658         sqlite3_free(query);
 659         if (ret != SQLITE_OK) {
 660                 LOGE("prepare failed: %s", sqlite3_errmsg(db));
 661                 return PMINFO_R_ERROR;
 662         }
 663
 664         ret = sqlite3_step(stmt);
 665         if (ret == SQLITE_DONE) {
 666                 sqlite3_finalize(stmt);
 667                 return PMINFO_R_ENOENT;
 668         } else if (ret != SQLITE_ROW) {
 669                 LOGE("step failed: %s", sqlite3_errmsg(db));
 670                 sqlite3_finalize(stmt);
 671                 return PMINFO_R_ERROR;
 672         }
 673
 674         info = calloc(1, sizeof(package_x));
 675         if (info == NULL) {
 676                 LOGE("out of memory");
 677                 sqlite3_finalize(stmt);
 678                 return PMINFO_R_ERROR;
 679         }
 680         idx = 0;
 681         _save_column_str(stmt, idx++, &info->package);
 682         _save_column_str(stmt, idx++, &info->version);
 683         _save_column_str(stmt, idx++, &info->installlocation);
 684         _save_column_str(stmt, idx++, &info->removable);
 685         _save_column_str(stmt, idx++, &info->preload);
 686         _save_column_str(stmt, idx++, &info->readonly);
 687         _save_column_str(stmt, idx++, &info->update);
 688         _save_column_str(stmt, idx++, &info->appsetting);
 689         _save_column_str(stmt, idx++, &info->system);
 690         _save_column_str(stmt, idx++, &info->type);
 691         _save_column_str(stmt, idx++, &info->package_size);
 692         _save_column_str(stmt, idx++, &info->installed_time);
 693         _save_column_str(stmt, idx++, &info->installed_storage);
 694         _save_column_str(stmt, idx++, &info->storeclient_id);
 695         _save_column_str(stmt, idx++, &info->mainapp_id);
 696         _save_column_str(stmt, idx++, &info->package_url);
 697         _save_column_str(stmt, idx++, &info->root_path);
 698         _save_column_str(stmt, idx++, &info->csc_path);
 699         _save_column_str(stmt, idx++, &info->nodisplay_setting);
 700         _save_column_str(stmt, idx++, &info->api_version);
 701         _save_column_str(stmt, idx++, &info->support_disable);
 702         _save_column_str(stmt, idx++, &info->tep_name);
 703
 704         if (_pkginfo_get_author(db, info->package, &info->author)) {
 705                 pkgmgrinfo_basic_free_package(info);
 706                 sqlite3_finalize(stmt);
 707                 return PMINFO_R_ERROR;
 708         }
 709
 710         if (_pkginfo_get_label(db, info->package, locale, &info->label)) {
 711                 pkgmgrinfo_basic_free_package(info);
 712                 sqlite3_finalize(stmt);
 713                 return PMINFO_R_ERROR;
 714         }
 715
 716         if (_pkginfo_get_icon(db, info->package, locale, &info->icon)) {
 717                 pkgmgrinfo_basic_free_package(info);
 718                 sqlite3_finalize(stmt);
 719                 return PMINFO_R_ERROR;
 720         }
 721
 722         if (_pkginfo_get_description(db, info->package, locale,
 723                                 &info->description)) {
 724                 pkgmgrinfo_basic_free_package(info);
 725                 sqlite3_finalize(stmt);
 726                 return PMINFO_R_ERROR;
 727         }
 728
 729         if (_pkginfo_get_privilege(db, info->package, &info->privileges)) {
 730                 pkgmgrinfo_basic_free_package(info);
 731                 sqlite3_finalize(stmt);
 732                 return PMINFO_R_ERROR;
 733         }
 734
 735         *package = info;
 736         sqlite3_finalize(stmt);
 737
 738         return PMINFO_R_OK;
 739 }
 740
 741 static int _pkginfo_get_pkginfo(const char *pkgid, uid_t uid,
 742                 pkgmgr_pkginfo_x **pkginfo)
 743 {
 744         int ret;
 745         sqlite3 *db;
 746         const char *dbpath;
 747         char *locale;
 748         pkgmgr_pkginfo_x *info;
 749
 750         dbpath = getUserPkgParserDBPathUID(uid);
 751         if (dbpath == NULL)
 752                 return PMINFO_R_ERROR;
 753
 754         locale = _get_system_locale();
 755         if (locale == NULL)
 756                 return PMINFO_R_ERROR;
 757
 758         ret = sqlite3_open_v2(dbpath, &db, SQLITE_OPEN_READONLY, NULL);
 759         if (ret != SQLITE_OK) {
 760                 _LOGE("failed to open db: %d", ret);
 761                 free(locale);
 762                 return PMINFO_R_ERROR;
 763         }
 764
 765         info = calloc(1, sizeof(pkgmgr_pkginfo_x));
 766         if (info == NULL) {
 767                 _LOGE("out of memory");
 768                 free(locale);
 769                 sqlite3_close_v2(db);
 770                 return PMINFO_R_ERROR;
 771         }
 772
 773         ret = _pkginfo_get_package(db, pkgid, locale, &info->pkg_info);
 774         if (ret != PMINFO_R_OK) {
 775                 free(info);
 776                 free(locale);
 777                 sqlite3_close_v2(db);
 778                 return ret;
 779         }
 780
 781         info->locale = locale;
 782         info->uid = uid;
 783         info->pkg_info->for_all_users = strdup(
 784                         uid != GLOBAL_USER ? "false" : "true");
 785
 786         *pkginfo = info;
 787
 788         sqlite3_close_v2(db);
 789
 790         return ret;
 791 }
 792
 793 API int pkgmgrinfo_pkginfo_get_usr_pkginfo(const char *pkgid, uid_t uid,
 794                 pkgmgrinfo_pkginfo_h *handle)
 795 {
 796         int ret;
 797
 798         if (pkgid == NULL || handle == NULL) {
 799                 LOGE("invalid parameter");
 800                 return PMINFO_R_EINVAL;
 801         }
 802
 803         ret = _pkginfo_get_pkginfo(pkgid, uid, (pkgmgr_pkginfo_x **)handle);
 804         if (ret == PMINFO_R_ENOENT && uid != GLOBAL_USER)
 805                 ret = _pkginfo_get_pkginfo(pkgid, GLOBAL_USER,
 806                                 (pkgmgr_pkginfo_x **)handle);
 807
 808         if (ret != PMINFO_R_OK)
 809                 _LOGE("failed to get pkginfo of %s for user %d", pkgid, uid);
 810
 811         return ret;
 812 }
 813
 814 API int pkgmgrinfo_pkginfo_get_pkginfo(const char *pkgid, pkgmgrinfo_pkginfo_h *handle)
 815 {
 816         return pkgmgrinfo_pkginfo_get_usr_pkginfo(pkgid, GLOBAL_USER, handle);
 817 }
 818
 819 API int pkgmgrinfo_pkginfo_get_pkgname(pkgmgrinfo_pkginfo_h handle, char **pkg_name)
 820 {
 821         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
 822
 823         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
 824         retvm_if(pkg_name == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
 825
 826         if (info->pkg_info == NULL || info->pkg_info->package == NULL)
 827                 return PMINFO_R_ERROR;
 828
 829         *pkg_name = (char *)info->pkg_info->package;
 830
 831         return PMINFO_R_OK;
 832 }
 833
 834 API int pkgmgrinfo_pkginfo_get_pkgid(pkgmgrinfo_pkginfo_h handle, char **pkgid)
 835 {
 836         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
 837
 838         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
 839         retvm_if(pkgid == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
 840
 841         if (info->pkg_info == NULL || info->pkg_info->package == NULL)
 842                 return PMINFO_R_ERROR;
 843
 844         *pkgid = (char *)info->pkg_info->package;
 845
 846         return PMINFO_R_OK;
 847 }
 848
 849 API int pkgmgrinfo_pkginfo_get_type(pkgmgrinfo_pkginfo_h handle, char **type)
 850 {
 851         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
 852
 853         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
 854         retvm_if(type == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
 855
 856         if (info->pkg_info == NULL || info->pkg_info->type == NULL)
 857                 return PMINFO_R_ERROR;
 858
 859         *type = (char *)info->pkg_info->type;
 860
 861         return PMINFO_R_OK;
 862 }
 863
 864 API int pkgmgrinfo_pkginfo_get_version(pkgmgrinfo_pkginfo_h handle, char **version)
 865 {
 866         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
 867
 868         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
 869         retvm_if(version == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
 870
 871         if (info->pkg_info == NULL || info->pkg_info->version == NULL)
 872                 return PMINFO_R_ERROR;
 873
 874         *version = (char *)info->pkg_info->version;
 875
 876         return PMINFO_R_OK;
 877 }
 878
 879 API int pkgmgrinfo_pkginfo_get_api_version(pkgmgrinfo_pkginfo_h handle, char **api_version)
 880 {
 881         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
 882
 883         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
 884         retvm_if(api_version == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
 885
 886         if (info->pkg_info == NULL || info->pkg_info->api_version == NULL)
 887                 return PMINFO_R_ERROR;
 888
 889         *api_version = (char *)info->pkg_info->api_version;
 890
 891         return PMINFO_R_OK;
 892 }
 893
 894 API int pkgmgrinfo_pkginfo_get_tep_name(pkgmgrinfo_pkginfo_h handle, char **tep_name)
 895 {
 896         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
 897
 898         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
 899         retvm_if(tep_name == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
 900
 901         if (info->pkg_info == NULL || info->pkg_info->tep_name == NULL)
 902                 return PMINFO_R_ERROR;
 903
 904         if (strlen(info->pkg_info->tep_name) == 0)
 905                 return PMINFO_R_ERROR;
 906
 907         *tep_name = (char *)info->pkg_info->tep_name;
 908
 909         return PMINFO_R_OK;
 910 }
 911
 912 API int pkgmgrinfo_pkginfo_get_install_location(pkgmgrinfo_pkginfo_h handle, pkgmgrinfo_install_location *location)
 913 {
 914         char *val;
 915         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
 916
 917         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
 918         retvm_if(location == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
 919
 920         if (info->pkg_info == NULL || info->pkg_info->installlocation == NULL)
 921                 return PMINFO_R_ERROR;
 922
 923         val = (char *)info->pkg_info->installlocation;
 924         if (strcmp(val, "internal-only") == 0)
 925                 *location = PMINFO_INSTALL_LOCATION_INTERNAL_ONLY;
 926         else if (strcmp(val, "prefer-external") == 0)
 927                 *location = PMINFO_INSTALL_LOCATION_PREFER_EXTERNAL;
 928         else
 929                 *location = PMINFO_INSTALL_LOCATION_AUTO;
 930
 931         return PMINFO_R_OK;
 932 }
 933
 934 API int pkgmgrinfo_pkginfo_get_package_size(pkgmgrinfo_pkginfo_h handle, int *size)
 935 {
 936         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
 937
 938         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
 939         retvm_if(size == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
 940
 941         if (info->pkg_info == NULL || info->pkg_info->package_size == NULL)
 942                 return PMINFO_R_ERROR;
 943
 944         *size = atoi((char *)info->pkg_info->package_size);
 945
 946         return PMINFO_R_OK;
 947 }
 948
 949 API int pkgmgrinfo_pkginfo_get_total_size(pkgmgrinfo_pkginfo_h handle, int *size)
 950 {
 951         char *pkgid;
 952         char device_path[PKG_STRING_LEN_MAX] = { '\0', };
 953         long long rw_size = 0;
 954         long long ro_size = 0;
 955         long long tmp_size = 0;
 956         long long total_size = 0;
 957         struct stat fileinfo;
 958         int ret;
 959
 960         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
 961         retvm_if(size == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
 962
 963         ret = pkgmgrinfo_pkginfo_get_pkgid(handle, &pkgid);
 964         if (ret < 0)
 965                 return PMINFO_R_ERROR;
 966
 967         /* RW area */
 968         snprintf(device_path, PKG_STRING_LEN_MAX, "%s%s/bin", PKG_RW_PATH, pkgid);
 969         if (lstat(device_path, &fileinfo) == 0) {
 970                 if (!S_ISLNK(fileinfo.st_mode)) {
 971                         tmp_size = _pkgmgr_calculate_dir_size(device_path);
 972                         if (tmp_size > 0)
 973                                 rw_size += tmp_size;
 974                 }
 975         }
 976
 977         snprintf(device_path, PKG_STRING_LEN_MAX, "%s%s/info", PKG_RW_PATH, pkgid);
 978         if (lstat(device_path, &fileinfo) == 0) {
 979                 if (!S_ISLNK(fileinfo.st_mode)) {
 980                         tmp_size = _pkgmgr_calculate_dir_size(device_path);
 981                         if (tmp_size > 0)
 982                         rw_size += tmp_size;
 983                 }
 984         }
 985
 986         snprintf(device_path, PKG_STRING_LEN_MAX, "%s%s/res", 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/data", 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/shared", 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/setting", 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         /* RO area */
1023         snprintf(device_path, PKG_STRING_LEN_MAX, "%s%s/bin", PKG_RO_PATH, pkgid);
1024         if (lstat(device_path, &fileinfo) == 0) {
1025                 if (!S_ISLNK(fileinfo.st_mode)) {
1026                         tmp_size = _pkgmgr_calculate_dir_size(device_path);
1027                         if (tmp_size > 0)
1028                                 ro_size += tmp_size;
1029                 }
1030         }
1031
1032         snprintf(device_path, PKG_STRING_LEN_MAX, "%s%s/info", PKG_RO_PATH, pkgid);
1033         if (lstat(device_path, &fileinfo) == 0) {
1034                 if (!S_ISLNK(fileinfo.st_mode)) {
1035                         tmp_size = _pkgmgr_calculate_dir_size(device_path);
1036                         if (tmp_size > 0)
1037                                 ro_size += tmp_size;
1038                 }
1039         }
1040
1041         snprintf(device_path, PKG_STRING_LEN_MAX, "%s%s/res", 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/data", 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/shared", 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/setting", 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         /* Total size */
1078         total_size = rw_size + ro_size;
1079         *size = (int)total_size;
1080
1081         return PMINFO_R_OK;
1082 }
1083
1084 API int pkgmgrinfo_pkginfo_get_data_size(pkgmgrinfo_pkginfo_h handle, int *size)
1085 {
1086         char *pkgid;
1087         char device_path[PKG_STRING_LEN_MAX] = { '\0', };
1088         long long total_size = 0;
1089
1090         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1091         retvm_if(size == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1092
1093         if (pkgmgrinfo_pkginfo_get_pkgid(handle, &pkgid) < 0)
1094                 return PMINFO_R_ERROR;
1095
1096         snprintf(device_path, PKG_STRING_LEN_MAX, "%s%s/data", PKG_RW_PATH, pkgid);
1097         if (access(device_path, R_OK) == 0)
1098                 total_size = _pkgmgr_calculate_dir_size(device_path);
1099         if (total_size < 0)
1100                 return PMINFO_R_ERROR;
1101
1102         *size = (int)total_size;
1103
1104         return PMINFO_R_OK;
1105 }
1106
1107 API int pkgmgrinfo_pkginfo_get_icon(pkgmgrinfo_pkginfo_h handle, char **icon)
1108 {
1109         const char *locale;
1110         icon_x *ptr;
1111         GList *tmp;
1112         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1113
1114         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL");
1115         retvm_if(icon == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL");
1116
1117         locale = info->locale;
1118         retvm_if(locale == NULL, PMINFO_R_ERROR, "manifest locale is NULL");
1119
1120         if (info->pkg_info == NULL)
1121                 return PMINFO_R_ERROR;
1122
1123         for (tmp = info->pkg_info->icon; tmp; tmp = tmp->next) {
1124                 ptr = (icon_x *)tmp->data;
1125                 if (ptr == NULL || ptr->text == NULL || ptr->lang == NULL ||
1126                                 !strcasecmp(ptr->text, "(null)") ||
1127                                 strcmp(ptr->lang, locale))
1128                         continue;
1129                 *icon = (char *)ptr->text;
1130                 return PMINFO_R_OK;
1131         }
1132
1133         locale = DEFAULT_LOCALE;
1134         for (tmp = info->pkg_info->icon; tmp; tmp = tmp->next) {
1135                 ptr = (icon_x *)tmp->data;
1136                 if (ptr == NULL || ptr->text == NULL || ptr->lang == NULL ||
1137                                 strcmp(ptr->lang, locale))
1138                         continue;
1139                 *icon = (char *)ptr->text;
1140                 return PMINFO_R_OK;
1141         }
1142
1143         return PMINFO_R_ERROR;
1144 }
1145
1146 API int pkgmgrinfo_pkginfo_get_label(pkgmgrinfo_pkginfo_h handle, char **label)
1147 {
1148         const char *locale;
1149         label_x *ptr;
1150         GList *tmp;
1151         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1152
1153         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL");
1154         retvm_if(label == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL");
1155
1156         locale = info->locale;
1157         retvm_if(locale == NULL, PMINFO_R_ERROR, "manifest locale is NULL");
1158
1159         for (tmp = info->pkg_info->label; tmp != NULL; tmp = tmp->next) {
1160                 ptr = (label_x *)tmp->data;
1161                 if (ptr == NULL || ptr->text == NULL || ptr->lang == NULL ||
1162                                 strcmp(ptr->lang, locale))
1163                         continue;
1164                 *label = (char *)ptr->text;
1165                 return PMINFO_R_OK;
1166         }
1167
1168         locale = DEFAULT_LOCALE;
1169         for (tmp = info->pkg_info->label; tmp != NULL; tmp = tmp->next) {
1170                 ptr = (label_x *)tmp->data;
1171                 if (ptr == NULL || ptr->text == NULL || ptr->lang == NULL ||
1172                                 strcmp(ptr->lang, locale))
1173                         continue;
1174                 *label = (char *)ptr->text;
1175                 return PMINFO_R_OK;
1176         }
1177
1178         return PMINFO_R_ERROR;
1179 }
1180
1181 API int pkgmgrinfo_pkginfo_get_description(pkgmgrinfo_pkginfo_h handle, char **description)
1182 {
1183         const char *locale;
1184         description_x *ptr;
1185         GList *tmp;
1186         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1187
1188         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1189         retvm_if(description == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1190
1191         locale = info->locale;
1192         retvm_if(locale == NULL, PMINFO_R_ERROR, "manifest locale is NULL");
1193
1194         for (tmp = info->pkg_info->description; tmp; tmp = tmp->next) {
1195                 ptr = (description_x *)tmp->data;
1196                 if (ptr == NULL || ptr->text == NULL || ptr->lang == NULL ||
1197                                 strcmp(ptr->lang, locale))
1198                         continue;
1199                 *description = (char *)ptr->text;
1200                 return PMINFO_R_OK;
1201         }
1202
1203         locale = DEFAULT_LOCALE;
1204         for (tmp = info->pkg_info->description; tmp; tmp = tmp->next) {
1205                 ptr = (description_x *)tmp->data;
1206                 if (ptr == NULL || ptr->text == NULL || ptr->lang == NULL ||
1207                                 strcmp(ptr->lang, locale))
1208                         continue;
1209                 *description = (char *)ptr->text;
1210                 return PMINFO_R_OK;
1211         }
1212
1213         return PMINFO_R_ERROR;
1214 }
1215
1216 API int pkgmgrinfo_pkginfo_get_author_name(pkgmgrinfo_pkginfo_h handle, char **author_name)
1217 {
1218         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1219         author_x *author;
1220
1221         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1222         retvm_if(author_name == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1223
1224         if (info->pkg_info == NULL || info->pkg_info->author == NULL)
1225                 return PMINFO_R_ERROR;
1226
1227         author = (author_x *)info->pkg_info->author->data;
1228         if (author == NULL || author->text == NULL)
1229                 return PMINFO_R_ERROR;
1230
1231         *author_name = (char *)author->text;
1232
1233         return PMINFO_R_OK;
1234 }
1235
1236 API int pkgmgrinfo_pkginfo_get_author_email(pkgmgrinfo_pkginfo_h handle, char **author_email)
1237 {
1238         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1239         author_x *author;
1240
1241         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1242         retvm_if(author_email == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1243
1244         if (info->pkg_info == NULL || info->pkg_info->author == NULL)
1245                 return PMINFO_R_ERROR;
1246
1247         author = (author_x *)info->pkg_info->author->data;
1248         if (author == NULL || author->email == NULL)
1249                 return PMINFO_R_ERROR;
1250
1251         *author_email = (char *)author->email;
1252
1253         return PMINFO_R_OK;
1254 }
1255
1256 API int pkgmgrinfo_pkginfo_get_author_href(pkgmgrinfo_pkginfo_h handle, char **author_href)
1257 {
1258         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1259         author_x *author;
1260
1261         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1262         retvm_if(author_href == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1263
1264         if (info->pkg_info == NULL || info->pkg_info->author == NULL)
1265                 return PMINFO_R_ERROR;
1266
1267         author = (author_x *)info->pkg_info->author->data;
1268         if (author == NULL || author->href == NULL)
1269                 return PMINFO_R_ERROR;
1270
1271         *author_href = (char *)author->href;
1272
1273         return PMINFO_R_OK;
1274 }
1275
1276 API int pkgmgrinfo_pkginfo_get_installed_storage(pkgmgrinfo_pkginfo_h handle, pkgmgrinfo_installed_storage *storage)
1277 {
1278         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1279
1280         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1281         retvm_if(storage == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1282
1283         if (info->pkg_info == NULL || info->pkg_info->installed_storage == NULL)
1284                 return PMINFO_R_ERROR;
1285
1286         if (strcmp(info->pkg_info->installed_storage,"installed_internal") == 0)
1287                 *storage = PMINFO_INTERNAL_STORAGE;
1288         else if (strcmp(info->pkg_info->installed_storage,"installed_external") == 0)
1289                 *storage = PMINFO_EXTERNAL_STORAGE;
1290         else
1291                 return PMINFO_R_ERROR;
1292
1293         return PMINFO_R_OK;
1294 }
1295
1296 API int pkgmgrinfo_pkginfo_get_installed_time(pkgmgrinfo_pkginfo_h handle, int *installed_time)
1297 {
1298         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1299
1300         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1301         retvm_if(installed_time == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1302
1303         if (info->pkg_info == NULL || info->pkg_info->installed_time == NULL)
1304                 return PMINFO_R_ERROR;
1305
1306         *installed_time = atoi(info->pkg_info->installed_time);
1307
1308         return PMINFO_R_OK;
1309 }
1310
1311 API int pkgmgrinfo_pkginfo_get_storeclientid(pkgmgrinfo_pkginfo_h handle, char **storeclientid)
1312 {
1313         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1314
1315         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1316         retvm_if(storeclientid == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1317
1318         if (info->pkg_info == NULL || info->pkg_info->storeclient_id == NULL)
1319                 return PMINFO_R_ERROR;
1320
1321         *storeclientid = (char *)info->pkg_info->storeclient_id;
1322
1323         return PMINFO_R_OK;
1324 }
1325
1326 API int pkgmgrinfo_pkginfo_get_mainappid(pkgmgrinfo_pkginfo_h handle, char **mainappid)
1327 {
1328         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1329
1330         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1331         retvm_if(mainappid == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1332
1333         if (info->pkg_info == NULL || info->pkg_info->mainapp_id == NULL)
1334                 return PMINFO_R_ERROR;
1335
1336         *mainappid = (char *)info->pkg_info->mainapp_id;
1337
1338         return PMINFO_R_OK;
1339 }
1340
1341 API int pkgmgrinfo_pkginfo_get_url(pkgmgrinfo_pkginfo_h handle, char **url)
1342 {
1343         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1344
1345         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1346         retvm_if(url == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1347
1348         if (info->pkg_info == NULL || info->pkg_info->package_url == NULL)
1349                 return PMINFO_R_ERROR;
1350
1351         *url = (char *)info->pkg_info->package_url;
1352
1353         return PMINFO_R_OK;
1354 }
1355
1356 API int pkgmgrinfo_pkginfo_get_size_from_xml(const char *manifest, int *size)
1357 {
1358         const char *val = NULL;
1359         const xmlChar *node;
1360         xmlTextReaderPtr reader;
1361         retvm_if(manifest == NULL, PMINFO_R_EINVAL, "Input argument is NULL\n");
1362         retvm_if(size == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1363
1364         xmlInitParser();
1365         reader = xmlReaderForFile(manifest, NULL, 0);
1366
1367         if (reader){
1368                 if (__child_element(reader, -1)) {
1369                         node = xmlTextReaderConstName(reader);
1370                         if (!node) {
1371                                 _LOGE("xmlTextReaderConstName value is NULL\n");
1372                                 xmlFreeTextReader(reader);
1373                                 xmlCleanupParser();
1374                                 return PMINFO_R_ERROR;
1375                         }
1376
1377                         if (!strcmp(ASC_CHAR(node), "manifest")) {
1378                                 if (xmlTextReaderGetAttribute(reader, XML_CHAR("size")))
1379                                         val = ASC_CHAR(xmlTextReaderGetAttribute(reader, XML_CHAR("size")));
1380
1381                                 if (val) {
1382                                         *size = atoi(val);
1383                                 } else {
1384                                         *size = 0;
1385                                         _LOGE("package size is not specified\n");
1386                                         xmlFreeTextReader(reader);
1387                                         xmlCleanupParser();
1388                                         return PMINFO_R_ERROR;
1389                                 }
1390                         } else {
1391                                 _LOGE("Unable to create xml reader\n");
1392                                 xmlFreeTextReader(reader);
1393                                 xmlCleanupParser();
1394                                 return PMINFO_R_ERROR;
1395                         }
1396                 }
1397         } else {
1398                 _LOGE("xmlReaderForFile value is NULL\n");
1399                 xmlCleanupParser();
1400                 return PMINFO_R_ERROR;
1401         }
1402
1403         xmlFreeTextReader(reader);
1404         xmlCleanupParser();
1405
1406         return PMINFO_R_OK;
1407 }
1408
1409 API int pkgmgrinfo_pkginfo_get_location_from_xml(const char *manifest, pkgmgrinfo_install_location *location)
1410 {
1411         const char *val = NULL;
1412         const xmlChar *node;
1413         xmlTextReaderPtr reader;
1414         retvm_if(manifest == NULL, PMINFO_R_EINVAL, "Input argument is NULL\n");
1415         retvm_if(location == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1416
1417         xmlInitParser();
1418         reader = xmlReaderForFile(manifest, NULL, 0);
1419
1420         if (reader) {
1421                 if ( __child_element(reader, -1)) {
1422                         node = xmlTextReaderConstName(reader);
1423                         if (!node) {
1424                                 _LOGE("xmlTextReaderConstName value is NULL\n");
1425                                 xmlFreeTextReader(reader);
1426                                 xmlCleanupParser();
1427                                 return PMINFO_R_ERROR;
1428                         }
1429
1430                         if (!strcmp(ASC_CHAR(node), "manifest")) {
1431                                 if (xmlTextReaderGetAttribute(reader, XML_CHAR("install-location")))
1432                                         val = ASC_CHAR(xmlTextReaderGetAttribute(reader, XML_CHAR("install-location")));
1433
1434                                 if (val) {
1435                                         if (strcmp(val, "internal-only") == 0)
1436                                                 *location = PMINFO_INSTALL_LOCATION_INTERNAL_ONLY;
1437                                         else if (strcmp(val, "prefer-external") == 0)
1438                                                 *location = PMINFO_INSTALL_LOCATION_PREFER_EXTERNAL;
1439                                         else
1440                                                 *location = PMINFO_INSTALL_LOCATION_AUTO;
1441                                 }
1442                         } else {
1443                                 _LOGE("Unable to create xml reader\n");
1444                                 xmlFreeTextReader(reader);
1445                                 xmlCleanupParser();
1446                                 return PMINFO_R_ERROR;
1447                         }
1448                 }
1449         } else {
1450                 _LOGE("xmlReaderForFile value is NULL\n");
1451                 xmlCleanupParser();
1452                 return PMINFO_R_ERROR;
1453         }
1454
1455         xmlFreeTextReader(reader);
1456         xmlCleanupParser();
1457
1458         return PMINFO_R_OK;
1459 }
1460
1461
1462 API int pkgmgrinfo_pkginfo_get_root_path(pkgmgrinfo_pkginfo_h handle, char **path)
1463 {
1464         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1465
1466         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1467         retvm_if(path == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1468
1469         if (info->pkg_info == NULL || info->pkg_info->root_path == NULL)
1470                 return PMINFO_R_ERROR;
1471
1472         *path = (char *)info->pkg_info->root_path;
1473
1474         return PMINFO_R_OK;
1475 }
1476
1477 API int pkgmgrinfo_pkginfo_get_csc_path(pkgmgrinfo_pkginfo_h handle, char **path)
1478 {
1479         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1480
1481         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1482         retvm_if(path == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1483
1484         if (info->pkg_info == NULL || info->pkg_info->csc_path == NULL)
1485                 return PMINFO_R_ERROR;
1486
1487         *path = (char *)info->pkg_info->csc_path;
1488
1489         return PMINFO_R_OK;
1490 }
1491
1492
1493 API int pkgmgrinfo_pkginfo_is_accessible(pkgmgrinfo_pkginfo_h handle, bool *accessible)
1494 {
1495         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1496         retvm_if(accessible == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1497
1498 #if 0 //smack issue occured, check later
1499         char *pkgid = NULL;
1500         pkgmgrinfo_pkginfo_get_pkgid(handle, &pkgid);
1501         if (pkgid == NULL){
1502                  _LOGD("invalid func parameters\n");
1503                  return PMINFO_R_ERROR;
1504         }
1505          _LOGD("pkgmgr_get_pkg_external_validation() called\n");
1506
1507         FILE *fp = NULL;
1508         char app_mmc_path[FILENAME_MAX] = { 0, };
1509         char app_dir_path[FILENAME_MAX] = { 0, };
1510         char app_mmc_internal_path[FILENAME_MAX] = { 0, };
1511         snprintf(app_dir_path, FILENAME_MAX,"%s%s", PKG_INSTALLATION_PATH, pkgid);
1512         snprintf(app_mmc_path, FILENAME_MAX,"%s%s", PKG_SD_PATH, pkgid);
1513         snprintf(app_mmc_internal_path, FILENAME_MAX,"%s%s/.mmc", PKG_INSTALLATION_PATH, pkgid);
1514
1515         /*check whether application is in external memory or not */
1516         fp = fopen(app_mmc_path, "r");
1517         if (fp == NULL){
1518                 _LOGD(" app path in external memory not accesible\n");
1519         } else {
1520                 fclose(fp);
1521                 fp = NULL;
1522                 *accessible = 1;
1523                 _LOGD("pkgmgr_get_pkg_external_validation() : SD_CARD \n");
1524                 return PMINFO_R_OK;
1525         }
1526
1527         /*check whether application is in internal or not */
1528         fp = fopen(app_dir_path, "r");
1529         if (fp == NULL) {
1530                 _LOGD(" app path in internal memory not accesible\n");
1531                 *accessible = 0;
1532                 return PMINFO_R_ERROR;
1533         } else {
1534                 fclose(fp);
1535                 /*check whether the application is installed in SD card
1536                 but SD card is not present*/
1537                 fp = fopen(app_mmc_internal_path, "r");
1538                 if (fp == NULL){
1539                         *accessible = 1;
1540                         _LOGD("pkgmgr_get_pkg_external_validation() : INTERNAL_MEM \n");
1541                         return PMINFO_R_OK;
1542                 }
1543                 else{
1544                         *accessible = 0;
1545                         _LOGD("pkgmgr_get_pkg_external_validation() : ERROR_MMC_STATUS \n");
1546                 }
1547                 fclose(fp);
1548         }
1549
1550         _LOGD("pkgmgr_get_pkg_external_validation() end\n");
1551 #endif
1552
1553         *accessible = 1;
1554         return PMINFO_R_OK;
1555 }
1556
1557 API int pkgmgrinfo_pkginfo_is_removable(pkgmgrinfo_pkginfo_h handle, bool *removable)
1558 {
1559         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1560
1561         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1562         retvm_if(removable == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1563
1564         if (info->pkg_info == NULL || info->pkg_info->removable == NULL)
1565                 return PMINFO_R_ERROR;
1566
1567         *removable = _get_bool_value(info->pkg_info->removable);
1568
1569         return PMINFO_R_OK;
1570 }
1571
1572 API int pkgmgrinfo_pkginfo_is_movable(pkgmgrinfo_pkginfo_h handle, bool *movable)
1573 {
1574         char *val;
1575         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1576
1577         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1578         retvm_if(movable == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1579
1580         if (info->pkg_info == NULL || info->pkg_info->installlocation == NULL)
1581                 return PMINFO_R_ERROR;
1582
1583         val = (char *)info->pkg_info->installlocation;
1584         if (strcmp(val, "internal-only") == 0)
1585                 *movable = 0;
1586         else if (strcmp(val, "prefer-external") == 0)
1587                 *movable = 1;
1588         else
1589                 *movable = 1;
1590
1591         return PMINFO_R_OK;
1592 }
1593
1594 API int pkgmgrinfo_pkginfo_is_preload(pkgmgrinfo_pkginfo_h handle, bool *preload)
1595 {
1596         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1597
1598         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1599         retvm_if(preload == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1600
1601         if (info->pkg_info == NULL || info->pkg_info->preload == NULL)
1602                 return PMINFO_R_ERROR;
1603
1604         *preload = _get_bool_value(info->pkg_info->preload);
1605
1606         return PMINFO_R_OK;
1607 }
1608
1609 API int pkgmgrinfo_pkginfo_is_system(pkgmgrinfo_pkginfo_h handle, bool *system)
1610 {
1611         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1612
1613         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1614         retvm_if(system == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1615
1616         if (info->pkg_info == NULL || info->pkg_info->system == NULL)
1617                 return PMINFO_R_ERROR;
1618
1619         *system = _get_bool_value(info->pkg_info->system);
1620
1621         return PMINFO_R_OK;
1622 }
1623
1624 API int pkgmgrinfo_pkginfo_is_readonly(pkgmgrinfo_pkginfo_h handle, bool *readonly)
1625 {
1626         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1627
1628         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1629         retvm_if(readonly == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1630
1631         if (info->pkg_info == NULL || info->pkg_info->readonly == NULL)
1632                 return PMINFO_R_ERROR;
1633
1634         *readonly = _get_bool_value(info->pkg_info->readonly);
1635
1636         return PMINFO_R_OK;
1637 }
1638
1639 API int pkgmgrinfo_pkginfo_is_update(pkgmgrinfo_pkginfo_h handle, bool *update)
1640 {
1641         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1642
1643         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1644         retvm_if(update == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1645
1646         if (info->pkg_info == NULL || info->pkg_info->update == NULL)
1647                 return PMINFO_R_ERROR;
1648
1649         *update = _get_bool_value(info->pkg_info->update);
1650
1651         return PMINFO_R_OK;
1652 }
1653
1654 API int pkgmgrinfo_pkginfo_is_support_disable(pkgmgrinfo_pkginfo_h handle, bool *support_disable)
1655 {
1656         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1657
1658         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1659         retvm_if(support_disable == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1660
1661         if (info->pkg_info == NULL || info->pkg_info->support_disable == NULL)
1662                 return PMINFO_R_ERROR;
1663
1664         *support_disable = _get_bool_value(info->pkg_info->support_disable);
1665
1666         return PMINFO_R_OK;
1667 }
1668
1669 API int pkgmgrinfo_pkginfo_is_global(pkgmgrinfo_pkginfo_h handle, bool *global)
1670 {
1671         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1672
1673         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1674         retvm_if(global == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1675
1676         if (info->pkg_info == NULL || info->pkg_info->for_all_users == NULL)
1677                 return PMINFO_R_ERROR;
1678
1679         *global = _get_bool_value(info->pkg_info->for_all_users);
1680
1681         return PMINFO_R_OK;
1682 }
1683
1684 API int pkgmgrinfo_pkginfo_is_for_all_users(pkgmgrinfo_pkginfo_h handle, bool *for_all_users)
1685 {
1686         return pkgmgrinfo_pkginfo_is_global(handle, for_all_users);
1687 }
1688
1689 API int pkgmgrinfo_pkginfo_destroy_pkginfo(pkgmgrinfo_pkginfo_h handle)
1690 {
1691         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1692
1693         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1694
1695         __cleanup_pkginfo(info);
1696
1697         return PMINFO_R_OK;
1698 }
1699
1700 API int pkgmgrinfo_pkginfo_filter_create(pkgmgrinfo_pkginfo_filter_h *handle)
1701 {
1702         pkgmgrinfo_filter_x *filter;
1703
1704         retvm_if(handle == NULL, PMINFO_R_EINVAL, "Filter handle output parameter is NULL\n");
1705
1706         filter = (pkgmgrinfo_filter_x*)calloc(1, sizeof(pkgmgrinfo_filter_x));
1707         if (filter == NULL) {
1708                 _LOGE("Out of Memory!!!");
1709                 return PMINFO_R_ERROR;
1710         }
1711
1712         *handle = filter;
1713
1714         return PMINFO_R_OK;
1715 }
1716
1717 API int pkgmgrinfo_pkginfo_filter_destroy(pkgmgrinfo_pkginfo_filter_h handle)
1718 {
1719         pkgmgrinfo_filter_x *filter = (pkgmgrinfo_filter_x *)handle;
1720
1721         retvm_if(handle == NULL, PMINFO_R_EINVAL, "Filter handle input parameter is NULL\n");
1722
1723         if (filter->list) {
1724                 g_slist_foreach(filter->list, __destroy_each_node, NULL);
1725                 g_slist_free(filter->list);
1726         }
1727
1728         free(filter);
1729
1730         return PMINFO_R_OK;
1731 }
1732
1733 API int pkgmgrinfo_pkginfo_filter_add_int(pkgmgrinfo_pkginfo_filter_h handle,
1734                                 const char *property, const int value)
1735 {
1736         char buf[PKG_VALUE_STRING_LEN_MAX] = {'\0'};
1737         char *val;
1738         GSList *link;
1739         int prop;
1740         pkgmgrinfo_filter_x *filter = (pkgmgrinfo_filter_x *)handle;
1741         pkgmgrinfo_node_x *node;
1742
1743         retvm_if(handle == NULL, PMINFO_R_EINVAL, "Filter handle input parameter is NULL\n");
1744         retvm_if(property == NULL, PMINFO_R_EINVAL, "Filter handle input parameter is NULL\n");
1745
1746         prop = _pminfo_pkginfo_convert_to_prop_int(property);
1747         if (prop < E_PMINFO_PKGINFO_PROP_PACKAGE_MIN_INT ||
1748                 prop > E_PMINFO_PKGINFO_PROP_PACKAGE_MAX_INT) {
1749                 _LOGE("Invalid Integer Property\n");
1750                 return PMINFO_R_EINVAL;
1751         }
1752         node = (pkgmgrinfo_node_x *)calloc(1, sizeof(pkgmgrinfo_node_x));
1753         if (node == NULL) {
1754                 _LOGE("Out of Memory!!!\n");
1755                 return PMINFO_R_ERROR;
1756         }
1757         snprintf(buf, PKG_VALUE_STRING_LEN_MAX - 1, "%d", value);
1758         val = strndup(buf, PKG_VALUE_STRING_LEN_MAX - 1);
1759         if (val == NULL) {
1760                 _LOGE("Out of Memory\n");
1761                 free(node);
1762                 return PMINFO_R_ERROR;
1763         }
1764         node->prop = prop;
1765         node->value = val;
1766         /*If API is called multiple times for same property, we should override the previous values.
1767         Last value set will be used for filtering.*/
1768         link = g_slist_find_custom(filter->list, (gconstpointer)node, __compare_func);
1769         if (link)
1770                 filter->list = g_slist_delete_link(filter->list, link);
1771         filter->list = g_slist_append(filter->list, (gpointer)node);
1772         return PMINFO_R_OK;
1773
1774 }
1775
1776 API int pkgmgrinfo_pkginfo_filter_add_bool(pkgmgrinfo_pkginfo_filter_h handle,
1777                                 const char *property, const bool value)
1778 {
1779         char *val;
1780         GSList *link;
1781         int prop;
1782         pkgmgrinfo_filter_x *filter = (pkgmgrinfo_filter_x *)handle;
1783         pkgmgrinfo_node_x *node;
1784
1785         retvm_if(handle == NULL, PMINFO_R_EINVAL, "Filter handle input parameter is NULL\n");
1786         retvm_if(property == NULL, PMINFO_R_EINVAL, "Filter handle input parameter is NULL\n");
1787
1788         prop = _pminfo_pkginfo_convert_to_prop_bool(property);
1789         if (prop < E_PMINFO_PKGINFO_PROP_PACKAGE_MIN_BOOL ||
1790                 prop > E_PMINFO_PKGINFO_PROP_PACKAGE_MAX_BOOL) {
1791                 _LOGE("Invalid Boolean Property\n");
1792                 return PMINFO_R_EINVAL;
1793         }
1794         node = (pkgmgrinfo_node_x *)calloc(1, sizeof(pkgmgrinfo_node_x));
1795         if (node == NULL) {
1796                 _LOGE("Out of Memory!!!\n");
1797                 return PMINFO_R_ERROR;
1798         }
1799         if (value)
1800                 val = strndup("('true','True')", 15);
1801         else
1802                 val = strndup("('false','False')", 17);
1803         if (val == NULL) {
1804                 _LOGE("Out of Memory\n");
1805                 free(node);
1806                 return PMINFO_R_ERROR;
1807         }
1808         node->prop = prop;
1809         node->value = val;
1810         /*If API is called multiple times for same property, we should override the previous values.
1811         Last value set will be used for filtering.*/
1812         link = g_slist_find_custom(filter->list, (gconstpointer)node, __compare_func);
1813         if (link)
1814                 filter->list = g_slist_delete_link(filter->list, link);
1815         filter->list = g_slist_append(filter->list, (gpointer)node);
1816         return PMINFO_R_OK;
1817
1818 }
1819
1820 API int pkgmgrinfo_pkginfo_filter_add_string(pkgmgrinfo_pkginfo_filter_h handle,
1821                                 const char *property, const char *value)
1822 {
1823         char *val;
1824         GSList *link;
1825         int prop;
1826         pkgmgrinfo_filter_x *filter = (pkgmgrinfo_filter_x *)handle;
1827         pkgmgrinfo_node_x *node;
1828
1829         retvm_if(handle == NULL, PMINFO_R_EINVAL, "Filter handle input parameter is NULL\n");
1830         retvm_if(property == NULL, PMINFO_R_EINVAL, "Filter handle input parameter is NULL\n");
1831         retvm_if(value == NULL, PMINFO_R_EINVAL, "Filter handle input parameter is NULL\n");
1832
1833         prop = _pminfo_pkginfo_convert_to_prop_str(property);
1834         if (prop < E_PMINFO_PKGINFO_PROP_PACKAGE_MIN_STR ||
1835                 prop > E_PMINFO_PKGINFO_PROP_PACKAGE_MAX_STR) {
1836                 _LOGE("Invalid String Property\n");
1837                 return PMINFO_R_EINVAL;
1838         }
1839         node = (pkgmgrinfo_node_x *)calloc(1, sizeof(pkgmgrinfo_node_x));
1840         if (node == NULL) {
1841                 _LOGE("Out of Memory!!!\n");
1842                 return PMINFO_R_ERROR;
1843         }
1844         if (strcmp(value, PMINFO_PKGINFO_INSTALL_LOCATION_AUTO) == 0)
1845                 val = strndup("auto", PKG_STRING_LEN_MAX - 1);
1846         else if (strcmp(value, PMINFO_PKGINFO_INSTALL_LOCATION_INTERNAL) == 0)
1847                 val = strndup("internal-only", PKG_STRING_LEN_MAX - 1);
1848         else if (strcmp(value, PMINFO_PKGINFO_INSTALL_LOCATION_EXTERNAL) == 0)
1849                 val = strndup("prefer-external", PKG_STRING_LEN_MAX - 1);
1850         else if (strcmp(value, "installed_internal") == 0)
1851                 val = strndup("installed_internal", PKG_STRING_LEN_MAX - 1);
1852         else if (strcmp(value, "installed_external") == 0)
1853                 val = strndup("installed_external", PKG_STRING_LEN_MAX - 1);
1854         else
1855                 val = strndup(value, PKG_STRING_LEN_MAX - 1);
1856         if (val == NULL) {
1857                 _LOGE("Out of Memory\n");
1858                 free(node);
1859                 return PMINFO_R_ERROR;
1860         }
1861         node->prop = prop;
1862         node->value = val;
1863         /*If API is called multiple times for same property, we should override the previous values.
1864         Last value set will be used for filtering.*/
1865         link = g_slist_find_custom(filter->list, (gconstpointer)node, __compare_func);
1866         if (link)
1867                 filter->list = g_slist_delete_link(filter->list, link);
1868         filter->list = g_slist_append(filter->list, (gpointer)node);
1869         return PMINFO_R_OK;
1870
1871 }
1872
1873 API int pkgmgrinfo_pkginfo_usr_filter_count(pkgmgrinfo_pkginfo_filter_h handle, int *count, uid_t uid)
1874 {
1875         int ret;
1876         GList *list = NULL;
1877
1878         if (handle == NULL || count == NULL) {
1879                 _LOGE("invalid parameter");
1880                 return PMINFO_R_EINVAL;
1881         }
1882
1883         ret = _pkginfo_get_filtered_list((pkgmgrinfo_filter_x *)handle, uid, &list);
1884         if (ret != PMINFO_R_OK)
1885                 return PMINFO_R_ERROR;
1886
1887         *count = g_list_length(list);
1888
1889         g_list_free_full(list, free);
1890
1891         return PMINFO_R_OK;
1892 }
1893
1894 API int pkgmgrinfo_pkginfo_filter_count(pkgmgrinfo_pkginfo_filter_h handle, int *count)
1895 {
1896         return pkgmgrinfo_pkginfo_usr_filter_count(handle, count, GLOBAL_USER);
1897 }
1898
1899 API int pkgmgrinfo_pkginfo_usr_filter_foreach_pkginfo(
1900                 pkgmgrinfo_pkginfo_filter_h handle,
1901                 pkgmgrinfo_pkg_list_cb pkg_cb, void *user_data, uid_t uid)
1902 {
1903         if (handle == NULL || pkg_cb == NULL) {
1904                 LOGE("invalid parameter");
1905                 return PMINFO_R_EINVAL;
1906         }
1907
1908         return _pkginfo_get_filtered_foreach_pkginfo(handle, pkg_cb, user_data,
1909                         uid);
1910 }
1911
1912 API int pkgmgrinfo_pkginfo_filter_foreach_pkginfo(pkgmgrinfo_pkginfo_filter_h handle,
1913                                 pkgmgrinfo_pkg_list_cb pkg_cb, void *user_data)
1914 {
1915         return pkgmgrinfo_pkginfo_usr_filter_foreach_pkginfo(handle, pkg_cb, user_data, GLOBAL_USER);
1916 }
1917
1918 API int pkgmgrinfo_pkginfo_foreach_privilege(pkgmgrinfo_pkginfo_h handle,
1919                         pkgmgrinfo_pkg_privilege_list_cb privilege_func, void *user_data)
1920 {
1921         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL");
1922         retvm_if(privilege_func == NULL, PMINFO_R_EINVAL, "Callback function is NULL");
1923         int ret;
1924         const char *privilege;
1925         GList *tmp;
1926         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1927
1928         if (info->pkg_info == NULL)
1929                 return PMINFO_R_ERROR;
1930
1931         for (tmp = info->pkg_info->privileges; tmp; tmp = tmp->next) {
1932                 privilege = (const char *)tmp->data;
1933                 if (privilege == NULL)
1934                         continue;
1935                 ret = privilege_func(privilege, user_data);
1936                 if (ret < 0)
1937                         break;
1938         }
1939         return PMINFO_R_OK;
1940 }
1941
1942 API int pkgmgrinfo_create_pkgusrdbinfo(const char *pkgid, uid_t uid, pkgmgrinfo_pkgdbinfo_h *handle)
1943 {
1944         retvm_if(!pkgid, PMINFO_R_EINVAL, "pkgid is NULL");
1945         retvm_if(!handle, PMINFO_R_EINVAL, "Argument supplied is NULL");
1946
1947         char *manifest = NULL;
1948         manifest_x *mfx = NULL;
1949         *handle = NULL;
1950         manifest = pkgmgr_parser_get_usr_manifest_file(pkgid, uid);
1951         retvm_if(manifest == NULL, PMINFO_R_EINVAL, "pkg[%s] dont have manifest file", pkgid);
1952
1953         mfx = pkgmgr_parser_usr_process_manifest_xml(manifest, uid);
1954         if (manifest) {
1955                 free(manifest);
1956                 manifest = NULL;
1957         }
1958         retvm_if(mfx == NULL, PMINFO_R_EINVAL, "pkg[%s] parsing fail", pkgid);
1959
1960         *handle = (void *)mfx;
1961
1962         return PMINFO_R_OK;
1963 }
1964
1965 API int pkgmgrinfo_create_pkgdbinfo(const char *pkgid, pkgmgrinfo_pkgdbinfo_h *handle)
1966 {
1967         retvm_if(!pkgid, PMINFO_R_EINVAL, "pkgid is NULL");
1968         retvm_if(!handle, PMINFO_R_EINVAL, "Argument supplied is NULL");
1969
1970         char *manifest = NULL;
1971         manifest_x *mfx = NULL;
1972         *handle = NULL;
1973         manifest = pkgmgr_parser_get_manifest_file(pkgid);
1974         retvm_if(manifest == NULL, PMINFO_R_EINVAL, "pkg[%s] dont have manifest file", pkgid);
1975
1976         mfx = pkgmgr_parser_process_manifest_xml(manifest);
1977         if (manifest) {
1978                 free(manifest);
1979                 manifest = NULL;
1980         }
1981         retvm_if(mfx == NULL, PMINFO_R_EINVAL, "pkg[%s] parsing fail", pkgid);
1982
1983         *handle = (void *)mfx;
1984
1985         return PMINFO_R_OK;
1986 }
1987
1988 API int pkgmgrinfo_set_type_to_pkgdbinfo(pkgmgrinfo_pkgdbinfo_h handle, const char *type)
1989 {
1990         int len;
1991         manifest_x *mfx = (manifest_x *)handle;
1992
1993         retvm_if(!type, PMINFO_R_EINVAL, "Argument supplied is NULL");
1994         retvm_if(!handle, PMINFO_R_EINVAL, "Argument supplied is NULL");
1995
1996         len = strlen(type);
1997         retvm_if(len > PKG_TYPE_STRING_LEN_MAX, PMINFO_R_EINVAL, "pkg type length exceeds the max limit");
1998
1999         if (mfx->type)
2000                 free((void *)mfx->type);
2001
2002         mfx->type = strndup(type, PKG_TYPE_STRING_LEN_MAX);
2003
2004         return PMINFO_R_OK;
2005 }
2006
2007 API int pkgmgrinfo_set_version_to_pkgdbinfo(pkgmgrinfo_pkgdbinfo_h handle, const char *version)
2008 {
2009         int len;
2010         manifest_x *mfx = (manifest_x *)handle;
2011
2012         retvm_if(!version, PMINFO_R_EINVAL, "Argument supplied is NULL");
2013         retvm_if(!handle, PMINFO_R_EINVAL, "Argument supplied is NULL");
2014
2015         len = strlen(version);
2016         retvm_if(len > PKG_TYPE_STRING_LEN_MAX, PMINFO_R_EINVAL, "pkg type length exceeds the max limit");
2017
2018         if (mfx->version)
2019                 free((void *)mfx->version);
2020
2021         mfx->version = strndup(version, PKG_VERSION_STRING_LEN_MAX);
2022         return PMINFO_R_OK;
2023 }
2024
2025 API int pkgmgrinfo_set_install_location_to_pkgdbinfo(pkgmgrinfo_pkgdbinfo_h handle, INSTALL_LOCATION location)
2026 {
2027         manifest_x *mfx = (manifest_x *)handle;
2028
2029         retvm_if(!handle, PMINFO_R_EINVAL, "Argument supplied is NULL");
2030         retvm_if((location < 0) || (location > 1), PMINFO_R_EINVAL, "Argument supplied is NULL");
2031
2032         if (mfx->installlocation)
2033                 free((void *)mfx->installlocation);
2034
2035         if (location == INSTALL_INTERNAL)
2036                 mfx->installlocation = strdup("internal-only");
2037         else if (location == INSTALL_EXTERNAL)
2038                 mfx->installlocation = strdup("prefer-external");
2039
2040         return PMINFO_R_OK;
2041 }
2042
2043 API int pkgmgrinfo_set_size_to_pkgdbinfo(pkgmgrinfo_pkgdbinfo_h handle, const char *size)
2044 {
2045         manifest_x *mfx = (manifest_x *)handle;
2046
2047         retvm_if(!handle, PMINFO_R_EINVAL, "Argument supplied is NULL");
2048         retvm_if(size == NULL, PMINFO_R_EINVAL, "Argument supplied is NULL");
2049
2050         if (mfx->package_size)
2051                 free((void *)mfx->package_size);
2052
2053         mfx->package_size = strdup(size);
2054
2055         return PMINFO_R_OK;
2056 }
2057
2058 API int pkgmgrinfo_set_label_to_pkgdbinfo(pkgmgrinfo_pkgdbinfo_h handle, const char *label_txt, const char *locale)
2059 {
2060         int len;
2061         manifest_x *mfx = (manifest_x *)handle;
2062         label_x *label;
2063
2064         retvm_if(!handle, PMINFO_R_EINVAL, "Argument supplied is NULL");
2065         retvm_if(!label_txt, PMINFO_R_EINVAL, "Argument supplied is NULL");
2066
2067         len = strlen(label_txt);
2068         retvm_if(len > PKG_TYPE_STRING_LEN_MAX, PMINFO_R_EINVAL, "pkg type length exceeds the max limit");
2069
2070         label = calloc(1, sizeof(label_x));
2071         retvm_if(label == NULL, PMINFO_R_EINVAL, "Malloc Failed");
2072
2073         if (locale)
2074                 label->lang = strdup(locale);
2075         else
2076                 label->lang = strdup(DEFAULT_LOCALE);
2077         label->text = strdup(label_txt);
2078         mfx->label = g_list_append(mfx->label, label);
2079
2080         return PMINFO_R_OK;
2081 }
2082
2083 API int pkgmgrinfo_set_icon_to_pkgdbinfo(pkgmgrinfo_pkgdbinfo_h handle, const char *icon_txt, const char *locale)
2084 {
2085         int len;
2086         manifest_x *mfx = (manifest_x *)handle;
2087         icon_x *icon;
2088
2089         retvm_if(!handle, PMINFO_R_EINVAL, "Argument supplied is NULL");
2090         retvm_if(!icon_txt, PMINFO_R_EINVAL, "Argument supplied is NULL");
2091
2092         len = strlen(icon_txt);
2093         retvm_if(len > PKG_TYPE_STRING_LEN_MAX, PMINFO_R_EINVAL, "pkg type length exceeds the max limit");
2094
2095         icon = calloc(1, sizeof(icon_x));
2096         retvm_if(icon == NULL, PMINFO_R_EINVAL, "Malloc Failed");
2097
2098         if (locale)
2099                 icon->lang = strdup(locale);
2100         else
2101                 icon->lang = strdup(DEFAULT_LOCALE);
2102         icon->text = strdup(icon_txt);
2103         mfx->icon = g_list_append(mfx->icon, icon);
2104
2105         return PMINFO_R_OK;
2106 }
2107
2108 API int pkgmgrinfo_set_description_to_pkgdbinfo(pkgmgrinfo_pkgdbinfo_h handle, const char *desc_txt, const char *locale)
2109 {
2110         int len = strlen(desc_txt);
2111         manifest_x *mfx = (manifest_x *)handle;
2112         description_x *description;
2113
2114         retvm_if(!handle, PMINFO_R_EINVAL, "Argument supplied is NULL");
2115         retvm_if(!desc_txt, PMINFO_R_EINVAL, "Argument supplied is NULL");
2116
2117         len = strlen(desc_txt);
2118         retvm_if(len > PKG_TYPE_STRING_LEN_MAX, PMINFO_R_EINVAL, "pkg type length exceeds the max limit");
2119
2120         description = calloc(1, sizeof(description_x));
2121         retvm_if(description == NULL, PMINFO_R_EINVAL, "Malloc Failed");
2122
2123         if (locale)
2124                 description->lang = strdup(locale);
2125         else
2126                 description->lang = strdup(DEFAULT_LOCALE);
2127         description->text = strdup(desc_txt);
2128         mfx->description = g_list_append(mfx->description, description);
2129
2130         return PMINFO_R_OK;
2131 }
2132
2133 API int pkgmgrinfo_set_author_to_pkgdbinfo(pkgmgrinfo_pkgdbinfo_h handle, const char *author_name,
2134                 const char *author_email, const char *author_href, const char *locale)
2135 {
2136         manifest_x *mfx = (manifest_x *)handle;
2137         author_x *author;
2138
2139         retvm_if(!handle, PMINFO_R_EINVAL, "Argument supplied is NULL");
2140
2141         author = calloc(1, sizeof(author_x));
2142         retvm_if(author == NULL, PMINFO_R_EINVAL, "Argument supplied is NULL");
2143
2144         if (author_name)
2145                 author->text = strdup(author_name);
2146         if (author_email)
2147                 author->email = strdup(author_email);
2148         if (author_href)
2149                 author->href = strdup(author_href);
2150         if (locale)
2151                 author->lang = strdup(locale);
2152         else
2153                 author->lang = strdup(DEFAULT_LOCALE);
2154         mfx->author = g_list_append(mfx->author, author);
2155         return PMINFO_R_OK;
2156 }
2157
2158 API int pkgmgrinfo_set_removable_to_pkgdbinfo(pkgmgrinfo_pkgdbinfo_h handle, int removable)
2159 {
2160         manifest_x *mfx = (manifest_x *)handle;
2161
2162         retvm_if(!handle, PMINFO_R_EINVAL, "Argument supplied is NULL");
2163         retvm_if((removable < 0) || (removable > 1), PMINFO_R_EINVAL, "Argument supplied is NULL");
2164
2165         if (mfx->removable)
2166                 free((void *)mfx->removable);
2167
2168         if (removable == 0)
2169                 mfx->removable = strdup("false");
2170         else if (removable == 1)
2171                 mfx->removable = strdup("true");
2172
2173         return PMINFO_R_OK;
2174 }
2175
2176 API int pkgmgrinfo_set_preload_to_pkgdbinfo(pkgmgrinfo_pkgdbinfo_h handle, int preload)
2177 {
2178         manifest_x *mfx = (manifest_x *)handle;
2179
2180         retvm_if(!handle, PMINFO_R_EINVAL, "Argument supplied is NULL");
2181         retvm_if((preload < 0) || (preload > 1), PMINFO_R_EINVAL, "Argument supplied is NULL");
2182
2183         if (mfx->preload)
2184                 free((void *)mfx->preload);
2185
2186         if (preload == 0)
2187                 mfx->preload = strdup("false");
2188         else if (preload == 1)
2189                 mfx->preload = strdup("true");
2190
2191         return PMINFO_R_OK;
2192 }
2193
2194 API int pkgmgrinfo_set_installed_storage_to_pkgdbinfo(pkgmgrinfo_pkgdbinfo_h handle, INSTALL_LOCATION location)
2195 {
2196         manifest_x *mfx = (manifest_x *)handle;
2197
2198         retvm_if(!handle, PMINFO_R_EINVAL, "Argument supplied is NULL");
2199         retvm_if((location < 0) || (location > 1), PMINFO_R_EINVAL, "Argument supplied is NULL");
2200
2201         if (mfx->installed_storage)
2202                 free((void *)mfx->installed_storage);
2203
2204         if (location == INSTALL_INTERNAL)
2205                 mfx->installed_storage = strdup("installed_internal");
2206         else if (location == INSTALL_EXTERNAL)
2207                 mfx->installed_storage = strdup("installed_external");
2208
2209         return PMINFO_R_OK;
2210 }
2211
2212 API int pkgmgrinfo_save_pkgdbinfo(pkgmgrinfo_pkgdbinfo_h handle)
2213 {
2214         int ret;
2215         manifest_x *mfx = (manifest_x *)handle;
2216         mfx = (manifest_x *)handle;
2217
2218         retvm_if(!handle, PMINFO_R_EINVAL, "Argument supplied is NULL");
2219
2220         ret = pkgmgr_parser_update_manifest_info_in_db(mfx);
2221         if (ret == 0) {
2222                 _LOGE("Successfully stored info in DB\n");
2223                 return PMINFO_R_OK;
2224         } else {
2225                 _LOGE("Failed to store info in DB\n");
2226                 return PMINFO_R_ERROR;
2227         }
2228 }
2229
2230 API int pkgmgrinfo_save_pkgusrdbinfo(pkgmgrinfo_pkgdbinfo_h handle, uid_t uid)
2231 {
2232         int ret;
2233         manifest_x *mfx = (manifest_x *)handle;
2234
2235         retvm_if(!handle, PMINFO_R_EINVAL, "Argument supplied is NULL");
2236
2237         ret = pkgmgr_parser_update_manifest_info_in_usr_db(mfx, uid);
2238         if (ret == 0) {
2239                 _LOGE("Successfully stored info in DB\n");
2240                 return PMINFO_R_OK;
2241         } else {
2242                 _LOGE("Failed to store info in DB\n");
2243                 return PMINFO_R_ERROR;
2244         }
2245 }
2246
2247 API int pkgmgrinfo_destroy_pkgdbinfo(pkgmgrinfo_pkgdbinfo_h handle)
2248 {
2249         manifest_x *mfx = (manifest_x *)handle;
2250
2251         retvm_if(!handle, PMINFO_R_EINVAL, "Argument supplied is NULL");
2252
2253         pkgmgrinfo_basic_free_package(mfx);
2254
2255         return PMINFO_R_OK;
2256 }