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 "
 643                 "FROM package_info WHERE package=%Q";
 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
 703         if (_pkginfo_get_author(db, info->package, &info->author)) {
 704                 pkgmgrinfo_basic_free_package(info);
 705                 sqlite3_finalize(stmt);
 706                 return PMINFO_R_ERROR;
 707         }
 708
 709         if (_pkginfo_get_label(db, info->package, locale, &info->label)) {
 710                 pkgmgrinfo_basic_free_package(info);
 711                 sqlite3_finalize(stmt);
 712                 return PMINFO_R_ERROR;
 713         }
 714
 715         if (_pkginfo_get_icon(db, info->package, locale, &info->icon)) {
 716                 pkgmgrinfo_basic_free_package(info);
 717                 sqlite3_finalize(stmt);
 718                 return PMINFO_R_ERROR;
 719         }
 720
 721         if (_pkginfo_get_description(db, info->package, locale,
 722                                 &info->description)) {
 723                 pkgmgrinfo_basic_free_package(info);
 724                 sqlite3_finalize(stmt);
 725                 return PMINFO_R_ERROR;
 726         }
 727
 728         if (_pkginfo_get_privilege(db, info->package, &info->privileges)) {
 729                 pkgmgrinfo_basic_free_package(info);
 730                 sqlite3_finalize(stmt);
 731                 return PMINFO_R_ERROR;
 732         }
 733
 734         *package = info;
 735         sqlite3_finalize(stmt);
 736
 737         return PMINFO_R_OK;
 738 }
 739
 740 static int _pkginfo_get_pkginfo(const char *pkgid, uid_t uid,
 741                 pkgmgr_pkginfo_x **pkginfo)
 742 {
 743         int ret;
 744         sqlite3 *db;
 745         const char *dbpath;
 746         char *locale;
 747         pkgmgr_pkginfo_x *info;
 748
 749         dbpath = getUserPkgParserDBPathUID(uid);
 750         if (dbpath == NULL)
 751                 return PMINFO_R_ERROR;
 752
 753         locale = _get_system_locale();
 754         if (locale == NULL)
 755                 return PMINFO_R_ERROR;
 756
 757         ret = sqlite3_open_v2(dbpath, &db, SQLITE_OPEN_READONLY, NULL);
 758         if (ret != SQLITE_OK) {
 759                 _LOGE("failed to open db: %d", ret);
 760                 free(locale);
 761                 return PMINFO_R_ERROR;
 762         }
 763
 764         info = calloc(1, sizeof(pkgmgr_pkginfo_x));
 765         if (info == NULL) {
 766                 _LOGE("out of memory");
 767                 free(locale);
 768                 sqlite3_close_v2(db);
 769                 return PMINFO_R_ERROR;
 770         }
 771
 772         ret = _pkginfo_get_package(db, pkgid, locale, &info->pkg_info);
 773         if (ret != PMINFO_R_OK) {
 774                 free(info);
 775                 free(locale);
 776                 sqlite3_close_v2(db);
 777                 return ret;
 778         }
 779
 780         info->locale = locale;
 781         info->uid = uid;
 782         info->pkg_info->for_all_users = strdup(
 783                         uid != GLOBAL_USER ? "false" : "true");
 784
 785         *pkginfo = info;
 786
 787         sqlite3_close_v2(db);
 788
 789         return ret;
 790 }
 791
 792 API int pkgmgrinfo_pkginfo_get_usr_pkginfo(const char *pkgid, uid_t uid,
 793                 pkgmgrinfo_pkginfo_h *handle)
 794 {
 795         int ret;
 796
 797         if (pkgid == NULL || handle == NULL) {
 798                 LOGE("invalid parameter");
 799                 return PMINFO_R_EINVAL;
 800         }
 801
 802         ret = _pkginfo_get_pkginfo(pkgid, uid, (pkgmgr_pkginfo_x **)handle);
 803         if (ret == PMINFO_R_ENOENT && uid != GLOBAL_USER)
 804                 ret = _pkginfo_get_pkginfo(pkgid, GLOBAL_USER,
 805                                 (pkgmgr_pkginfo_x **)handle);
 806
 807         if (ret != PMINFO_R_OK)
 808                 _LOGE("failed to get pkginfo of %s for user %d", pkgid, uid);
 809
 810         return ret;
 811 }
 812
 813 API int pkgmgrinfo_pkginfo_get_pkginfo(const char *pkgid, pkgmgrinfo_pkginfo_h *handle)
 814 {
 815         return pkgmgrinfo_pkginfo_get_usr_pkginfo(pkgid, GLOBAL_USER, handle);
 816 }
 817
 818 API int pkgmgrinfo_pkginfo_get_pkgname(pkgmgrinfo_pkginfo_h handle, char **pkg_name)
 819 {
 820         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
 821
 822         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
 823         retvm_if(pkg_name == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
 824
 825         if (info->pkg_info == NULL || info->pkg_info->package == NULL)
 826                 return PMINFO_R_ERROR;
 827
 828         *pkg_name = (char *)info->pkg_info->package;
 829
 830         return PMINFO_R_OK;
 831 }
 832
 833 API int pkgmgrinfo_pkginfo_get_pkgid(pkgmgrinfo_pkginfo_h handle, char **pkgid)
 834 {
 835         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
 836
 837         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
 838         retvm_if(pkgid == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
 839
 840         if (info->pkg_info == NULL || info->pkg_info->package == NULL)
 841                 return PMINFO_R_ERROR;
 842
 843         *pkgid = (char *)info->pkg_info->package;
 844
 845         return PMINFO_R_OK;
 846 }
 847
 848 API int pkgmgrinfo_pkginfo_get_type(pkgmgrinfo_pkginfo_h handle, char **type)
 849 {
 850         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
 851
 852         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
 853         retvm_if(type == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
 854
 855         if (info->pkg_info == NULL || info->pkg_info->type == NULL)
 856                 return PMINFO_R_ERROR;
 857
 858         *type = (char *)info->pkg_info->type;
 859
 860         return PMINFO_R_OK;
 861 }
 862
 863 API int pkgmgrinfo_pkginfo_get_version(pkgmgrinfo_pkginfo_h handle, char **version)
 864 {
 865         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
 866
 867         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
 868         retvm_if(version == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
 869
 870         if (info->pkg_info == NULL || info->pkg_info->version == NULL)
 871                 return PMINFO_R_ERROR;
 872
 873         *version = (char *)info->pkg_info->version;
 874
 875         return PMINFO_R_OK;
 876 }
 877
 878 API int pkgmgrinfo_pkginfo_get_install_location(pkgmgrinfo_pkginfo_h handle, pkgmgrinfo_install_location *location)
 879 {
 880         char *val;
 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(location == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
 885
 886         if (info->pkg_info == NULL || info->pkg_info->installlocation == NULL)
 887                 return PMINFO_R_ERROR;
 888
 889         val = (char *)info->pkg_info->installlocation;
 890         if (strcmp(val, "internal-only") == 0)
 891                 *location = PMINFO_INSTALL_LOCATION_INTERNAL_ONLY;
 892         else if (strcmp(val, "prefer-external") == 0)
 893                 *location = PMINFO_INSTALL_LOCATION_PREFER_EXTERNAL;
 894         else
 895                 *location = PMINFO_INSTALL_LOCATION_AUTO;
 896
 897         return PMINFO_R_OK;
 898 }
 899
 900 API int pkgmgrinfo_pkginfo_get_package_size(pkgmgrinfo_pkginfo_h handle, int *size)
 901 {
 902         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
 903
 904         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
 905         retvm_if(size == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
 906
 907         if (info->pkg_info == NULL || info->pkg_info->package_size == NULL)
 908                 return PMINFO_R_ERROR;
 909
 910         *size = atoi((char *)info->pkg_info->package_size);
 911
 912         return PMINFO_R_OK;
 913 }
 914
 915 API int pkgmgrinfo_pkginfo_get_total_size(pkgmgrinfo_pkginfo_h handle, int *size)
 916 {
 917         char *pkgid;
 918         char device_path[PKG_STRING_LEN_MAX] = { '\0', };
 919         long long rw_size = 0;
 920         long long ro_size = 0;
 921         long long tmp_size = 0;
 922         long long total_size = 0;
 923         struct stat fileinfo;
 924         int ret;
 925
 926         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
 927         retvm_if(size == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
 928
 929         ret = pkgmgrinfo_pkginfo_get_pkgid(handle, &pkgid);
 930         if (ret < 0)
 931                 return PMINFO_R_ERROR;
 932
 933         /* RW area */
 934         snprintf(device_path, PKG_STRING_LEN_MAX, "%s%s/bin", PKG_RW_PATH, pkgid);
 935         if (lstat(device_path, &fileinfo) == 0) {
 936                 if (!S_ISLNK(fileinfo.st_mode)) {
 937                         tmp_size = _pkgmgr_calculate_dir_size(device_path);
 938                         if (tmp_size > 0)
 939                                 rw_size += tmp_size;
 940                 }
 941         }
 942
 943         snprintf(device_path, PKG_STRING_LEN_MAX, "%s%s/info", PKG_RW_PATH, pkgid);
 944         if (lstat(device_path, &fileinfo) == 0) {
 945                 if (!S_ISLNK(fileinfo.st_mode)) {
 946                         tmp_size = _pkgmgr_calculate_dir_size(device_path);
 947                         if (tmp_size > 0)
 948                         rw_size += tmp_size;
 949                 }
 950         }
 951
 952         snprintf(device_path, PKG_STRING_LEN_MAX, "%s%s/res", PKG_RW_PATH, pkgid);
 953         if (lstat(device_path, &fileinfo) == 0) {
 954                 if (!S_ISLNK(fileinfo.st_mode)) {
 955                         tmp_size = _pkgmgr_calculate_dir_size(device_path);
 956                         if (tmp_size > 0)
 957                         rw_size += tmp_size;
 958                 }
 959         }
 960
 961         snprintf(device_path, PKG_STRING_LEN_MAX, "%s%s/data", PKG_RW_PATH, pkgid);
 962         if (lstat(device_path, &fileinfo) == 0) {
 963                 if (!S_ISLNK(fileinfo.st_mode)) {
 964                         tmp_size = _pkgmgr_calculate_dir_size(device_path);
 965                         if (tmp_size > 0)
 966                                 rw_size += tmp_size;
 967                 }
 968         }
 969
 970         snprintf(device_path, PKG_STRING_LEN_MAX, "%s%s/shared", 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/setting", 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         /* RO area */
 989         snprintf(device_path, PKG_STRING_LEN_MAX, "%s%s/bin", PKG_RO_PATH, pkgid);
 990         if (lstat(device_path, &fileinfo) == 0) {
 991                 if (!S_ISLNK(fileinfo.st_mode)) {
 992                         tmp_size = _pkgmgr_calculate_dir_size(device_path);
 993                         if (tmp_size > 0)
 994                                 ro_size += tmp_size;
 995                 }
 996         }
 997
 998         snprintf(device_path, PKG_STRING_LEN_MAX, "%s%s/info", PKG_RO_PATH, pkgid);
 999         if (lstat(device_path, &fileinfo) == 0) {
1000                 if (!S_ISLNK(fileinfo.st_mode)) {
1001                         tmp_size = _pkgmgr_calculate_dir_size(device_path);
1002                         if (tmp_size > 0)
1003                                 ro_size += tmp_size;
1004                 }
1005         }
1006
1007         snprintf(device_path, PKG_STRING_LEN_MAX, "%s%s/res", PKG_RO_PATH, pkgid);
1008         if (lstat(device_path, &fileinfo) == 0) {
1009                 if (!S_ISLNK(fileinfo.st_mode)) {
1010                         tmp_size = _pkgmgr_calculate_dir_size(device_path);
1011                         if (tmp_size > 0)
1012                                 ro_size += tmp_size;
1013                 }
1014         }
1015
1016         snprintf(device_path, PKG_STRING_LEN_MAX, "%s%s/data", PKG_RO_PATH, pkgid);
1017         if (lstat(device_path, &fileinfo) == 0) {
1018                 if (!S_ISLNK(fileinfo.st_mode)) {
1019                         tmp_size = _pkgmgr_calculate_dir_size(device_path);
1020                         if (tmp_size > 0)
1021                                 ro_size += tmp_size;
1022                 }
1023         }
1024
1025         snprintf(device_path, PKG_STRING_LEN_MAX, "%s%s/shared", 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/setting", 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         /* Total size */
1044         total_size = rw_size + ro_size;
1045         *size = (int)total_size;
1046
1047         return PMINFO_R_OK;
1048 }
1049
1050 API int pkgmgrinfo_pkginfo_get_data_size(pkgmgrinfo_pkginfo_h handle, int *size)
1051 {
1052         char *pkgid;
1053         char device_path[PKG_STRING_LEN_MAX] = { '\0', };
1054         long long total_size = 0;
1055
1056         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1057         retvm_if(size == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1058
1059         if (pkgmgrinfo_pkginfo_get_pkgid(handle, &pkgid) < 0)
1060                 return PMINFO_R_ERROR;
1061
1062         snprintf(device_path, PKG_STRING_LEN_MAX, "%s%s/data", PKG_RW_PATH, pkgid);
1063         if (access(device_path, R_OK) == 0)
1064                 total_size = _pkgmgr_calculate_dir_size(device_path);
1065         if (total_size < 0)
1066                 return PMINFO_R_ERROR;
1067
1068         *size = (int)total_size;
1069
1070         return PMINFO_R_OK;
1071 }
1072
1073 API int pkgmgrinfo_pkginfo_get_icon(pkgmgrinfo_pkginfo_h handle, char **icon)
1074 {
1075         const char *locale;
1076         icon_x *ptr;
1077         GList *tmp;
1078         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1079
1080         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL");
1081         retvm_if(icon == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL");
1082
1083         locale = info->locale;
1084         retvm_if(locale == NULL, PMINFO_R_ERROR, "manifest locale is NULL");
1085
1086         if (info->pkg_info == NULL)
1087                 return PMINFO_R_ERROR;
1088
1089         for (tmp = info->pkg_info->icon; tmp; tmp = tmp->next) {
1090                 ptr = (icon_x *)tmp->data;
1091                 if (ptr == NULL || ptr->text == NULL || ptr->lang == NULL ||
1092                                 strcmp(ptr->lang, locale))
1093                         continue;
1094                 *icon = (char *)ptr->text;
1095                 return PMINFO_R_OK;
1096         }
1097
1098         locale = DEFAULT_LOCALE;
1099         for (tmp = info->pkg_info->icon; tmp; tmp = tmp->next) {
1100                 ptr = (icon_x *)tmp->data;
1101                 if (ptr == NULL || ptr->text == NULL || ptr->lang == NULL ||
1102                                 strcmp(ptr->lang, locale))
1103                         continue;
1104                 *icon = (char *)ptr->text;
1105                 return PMINFO_R_OK;
1106         }
1107
1108         return PMINFO_R_ERROR;
1109 }
1110
1111 API int pkgmgrinfo_pkginfo_get_label(pkgmgrinfo_pkginfo_h handle, char **label)
1112 {
1113         const char *locale;
1114         label_x *ptr;
1115         GList *tmp;
1116         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1117
1118         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL");
1119         retvm_if(label == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL");
1120
1121         locale = info->locale;
1122         retvm_if(locale == NULL, PMINFO_R_ERROR, "manifest locale is NULL");
1123
1124         for (tmp = info->pkg_info->label; tmp != NULL; tmp = tmp->next) {
1125                 ptr = (label_x *)tmp->data;
1126                 if (ptr == NULL || ptr->text == NULL || ptr->lang == NULL ||
1127                                 strcmp(ptr->lang, locale))
1128                         continue;
1129                 *label = (char *)ptr->text;
1130                 return PMINFO_R_OK;
1131         }
1132
1133         locale = DEFAULT_LOCALE;
1134         for (tmp = info->pkg_info->label; tmp != NULL; tmp = tmp->next) {
1135                 ptr = (label_x *)tmp->data;
1136                 if (ptr == NULL || ptr->text == NULL || ptr->lang == NULL ||
1137                                 strcmp(ptr->lang, locale))
1138                         continue;
1139                 *label = (char *)ptr->text;
1140                 return PMINFO_R_OK;
1141         }
1142
1143         return PMINFO_R_ERROR;
1144 }
1145
1146 API int pkgmgrinfo_pkginfo_get_description(pkgmgrinfo_pkginfo_h handle, char **description)
1147 {
1148         const char *locale;
1149         description_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\n");
1154         retvm_if(description == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1155
1156         locale = info->locale;
1157         retvm_if(locale == NULL, PMINFO_R_ERROR, "manifest locale is NULL");
1158
1159         for (tmp = info->pkg_info->description; tmp; tmp = tmp->next) {
1160                 ptr = (description_x *)tmp->data;
1161                 if (ptr == NULL || ptr->text == NULL || ptr->lang == NULL ||
1162                                 strcmp(ptr->lang, locale))
1163                         continue;
1164                 *description = (char *)ptr->text;
1165                 return PMINFO_R_OK;
1166         }
1167
1168         locale = DEFAULT_LOCALE;
1169         for (tmp = info->pkg_info->description; tmp; tmp = tmp->next) {
1170                 ptr = (description_x *)tmp->data;
1171                 if (ptr == NULL || ptr->text == NULL || ptr->lang == NULL ||
1172                                 strcmp(ptr->lang, locale))
1173                         continue;
1174                 *description = (char *)ptr->text;
1175                 return PMINFO_R_OK;
1176         }
1177
1178         return PMINFO_R_ERROR;
1179 }
1180
1181 API int pkgmgrinfo_pkginfo_get_author_name(pkgmgrinfo_pkginfo_h handle, char **author_name)
1182 {
1183         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1184         author_x *author;
1185
1186         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1187         retvm_if(author_name == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1188
1189         if (info->pkg_info == NULL || info->pkg_info->author == NULL)
1190                 return PMINFO_R_ERROR;
1191
1192         author = (author_x *)info->pkg_info->author->data;
1193         if (author == NULL || author->text == NULL)
1194                 return PMINFO_R_ERROR;
1195
1196         *author_name = (char *)author->text;
1197
1198         return PMINFO_R_OK;
1199 }
1200
1201 API int pkgmgrinfo_pkginfo_get_author_email(pkgmgrinfo_pkginfo_h handle, char **author_email)
1202 {
1203         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1204         author_x *author;
1205
1206         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1207         retvm_if(author_email == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1208
1209         if (info->pkg_info == NULL || info->pkg_info->author == NULL)
1210                 return PMINFO_R_ERROR;
1211
1212         author = (author_x *)info->pkg_info->author->data;
1213         if (author == NULL || author->email == NULL)
1214                 return PMINFO_R_ERROR;
1215
1216         *author_email = (char *)author->email;
1217
1218         return PMINFO_R_OK;
1219 }
1220
1221 API int pkgmgrinfo_pkginfo_get_author_href(pkgmgrinfo_pkginfo_h handle, char **author_href)
1222 {
1223         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1224         author_x *author;
1225
1226         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1227         retvm_if(author_href == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1228
1229         if (info->pkg_info == NULL || info->pkg_info->author == NULL)
1230                 return PMINFO_R_ERROR;
1231
1232         author = (author_x *)info->pkg_info->author->data;
1233         if (author == NULL || author->href == NULL)
1234                 return PMINFO_R_ERROR;
1235
1236         *author_href = (char *)author->href;
1237
1238         return PMINFO_R_OK;
1239 }
1240
1241 API int pkgmgrinfo_pkginfo_get_installed_storage(pkgmgrinfo_pkginfo_h handle, pkgmgrinfo_installed_storage *storage)
1242 {
1243         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1244
1245         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1246         retvm_if(storage == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1247
1248         if (info->pkg_info == NULL || info->pkg_info->installed_storage == NULL)
1249                 return PMINFO_R_ERROR;
1250
1251         if (strcmp(info->pkg_info->installed_storage,"installed_internal") == 0)
1252                 *storage = PMINFO_INTERNAL_STORAGE;
1253         else if (strcmp(info->pkg_info->installed_storage,"installed_external") == 0)
1254                 *storage = PMINFO_EXTERNAL_STORAGE;
1255         else
1256                 return PMINFO_R_ERROR;
1257
1258         return PMINFO_R_OK;
1259 }
1260
1261 API int pkgmgrinfo_pkginfo_get_installed_time(pkgmgrinfo_pkginfo_h handle, int *installed_time)
1262 {
1263         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1264
1265         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1266         retvm_if(installed_time == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1267
1268         if (info->pkg_info == NULL || info->pkg_info->installed_time == NULL)
1269                 return PMINFO_R_ERROR;
1270
1271         *installed_time = atoi(info->pkg_info->installed_time);
1272
1273         return PMINFO_R_OK;
1274 }
1275
1276 API int pkgmgrinfo_pkginfo_get_storeclientid(pkgmgrinfo_pkginfo_h handle, char **storeclientid)
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(storeclientid == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1282
1283         if (info->pkg_info == NULL || info->pkg_info->storeclient_id == NULL)
1284                 return PMINFO_R_ERROR;
1285
1286         *storeclientid = (char *)info->pkg_info->storeclient_id;
1287
1288         return PMINFO_R_OK;
1289 }
1290
1291 API int pkgmgrinfo_pkginfo_get_mainappid(pkgmgrinfo_pkginfo_h handle, char **mainappid)
1292 {
1293         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1294
1295         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1296         retvm_if(mainappid == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1297
1298         if (info->pkg_info == NULL || info->pkg_info->mainapp_id == NULL)
1299                 return PMINFO_R_ERROR;
1300
1301         *mainappid = (char *)info->pkg_info->mainapp_id;
1302
1303         return PMINFO_R_OK;
1304 }
1305
1306 API int pkgmgrinfo_pkginfo_get_url(pkgmgrinfo_pkginfo_h handle, char **url)
1307 {
1308         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1309
1310         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1311         retvm_if(url == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1312
1313         if (info->pkg_info == NULL || info->pkg_info->package_url == NULL)
1314                 return PMINFO_R_ERROR;
1315
1316         *url = (char *)info->pkg_info->package_url;
1317
1318         return PMINFO_R_OK;
1319 }
1320
1321 API int pkgmgrinfo_pkginfo_get_size_from_xml(const char *manifest, int *size)
1322 {
1323         const char *val = NULL;
1324         const xmlChar *node;
1325         xmlTextReaderPtr reader;
1326         retvm_if(manifest == NULL, PMINFO_R_EINVAL, "Input argument is NULL\n");
1327         retvm_if(size == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1328
1329         xmlInitParser();
1330         reader = xmlReaderForFile(manifest, NULL, 0);
1331
1332         if (reader){
1333                 if (__child_element(reader, -1)) {
1334                         node = xmlTextReaderConstName(reader);
1335                         if (!node) {
1336                                 _LOGE("xmlTextReaderConstName value is NULL\n");
1337                                 xmlFreeTextReader(reader);
1338                                 xmlCleanupParser();
1339                                 return PMINFO_R_ERROR;
1340                         }
1341
1342                         if (!strcmp(ASC_CHAR(node), "manifest")) {
1343                                 if (xmlTextReaderGetAttribute(reader, XML_CHAR("size")))
1344                                         val = ASC_CHAR(xmlTextReaderGetAttribute(reader, XML_CHAR("size")));
1345
1346                                 if (val) {
1347                                         *size = atoi(val);
1348                                 } else {
1349                                         *size = 0;
1350                                         _LOGE("package size is not specified\n");
1351                                         xmlFreeTextReader(reader);
1352                                         xmlCleanupParser();
1353                                         return PMINFO_R_ERROR;
1354                                 }
1355                         } else {
1356                                 _LOGE("Unable to create xml reader\n");
1357                                 xmlFreeTextReader(reader);
1358                                 xmlCleanupParser();
1359                                 return PMINFO_R_ERROR;
1360                         }
1361                 }
1362         } else {
1363                 _LOGE("xmlReaderForFile value is NULL\n");
1364                 xmlCleanupParser();
1365                 return PMINFO_R_ERROR;
1366         }
1367
1368         xmlFreeTextReader(reader);
1369         xmlCleanupParser();
1370
1371         return PMINFO_R_OK;
1372 }
1373
1374 API int pkgmgrinfo_pkginfo_get_location_from_xml(const char *manifest, pkgmgrinfo_install_location *location)
1375 {
1376         const char *val = NULL;
1377         const xmlChar *node;
1378         xmlTextReaderPtr reader;
1379         retvm_if(manifest == NULL, PMINFO_R_EINVAL, "Input argument is NULL\n");
1380         retvm_if(location == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1381
1382         xmlInitParser();
1383         reader = xmlReaderForFile(manifest, NULL, 0);
1384
1385         if (reader) {
1386                 if ( __child_element(reader, -1)) {
1387                         node = xmlTextReaderConstName(reader);
1388                         if (!node) {
1389                                 _LOGE("xmlTextReaderConstName value is NULL\n");
1390                                 xmlFreeTextReader(reader);
1391                                 xmlCleanupParser();
1392                                 return PMINFO_R_ERROR;
1393                         }
1394
1395                         if (!strcmp(ASC_CHAR(node), "manifest")) {
1396                                 if (xmlTextReaderGetAttribute(reader, XML_CHAR("install-location")))
1397                                         val = ASC_CHAR(xmlTextReaderGetAttribute(reader, XML_CHAR("install-location")));
1398
1399                                 if (val) {
1400                                         if (strcmp(val, "internal-only") == 0)
1401                                                 *location = PMINFO_INSTALL_LOCATION_INTERNAL_ONLY;
1402                                         else if (strcmp(val, "prefer-external") == 0)
1403                                                 *location = PMINFO_INSTALL_LOCATION_PREFER_EXTERNAL;
1404                                         else
1405                                                 *location = PMINFO_INSTALL_LOCATION_AUTO;
1406                                 }
1407                         } else {
1408                                 _LOGE("Unable to create xml reader\n");
1409                                 xmlFreeTextReader(reader);
1410                                 xmlCleanupParser();
1411                                 return PMINFO_R_ERROR;
1412                         }
1413                 }
1414         } else {
1415                 _LOGE("xmlReaderForFile value is NULL\n");
1416                 xmlCleanupParser();
1417                 return PMINFO_R_ERROR;
1418         }
1419
1420         xmlFreeTextReader(reader);
1421         xmlCleanupParser();
1422
1423         return PMINFO_R_OK;
1424 }
1425
1426
1427 API int pkgmgrinfo_pkginfo_get_root_path(pkgmgrinfo_pkginfo_h handle, char **path)
1428 {
1429         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1430
1431         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1432         retvm_if(path == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1433
1434         if (info->pkg_info == NULL || info->pkg_info->root_path == NULL)
1435                 return PMINFO_R_ERROR;
1436
1437         *path = (char *)info->pkg_info->root_path;
1438
1439         return PMINFO_R_OK;
1440 }
1441
1442 API int pkgmgrinfo_pkginfo_get_csc_path(pkgmgrinfo_pkginfo_h handle, char **path)
1443 {
1444         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1445
1446         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1447         retvm_if(path == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1448
1449         if (info->pkg_info == NULL || info->pkg_info->csc_path == NULL)
1450                 return PMINFO_R_ERROR;
1451
1452         *path = (char *)info->pkg_info->csc_path;
1453
1454         return PMINFO_R_OK;
1455 }
1456
1457
1458 API int pkgmgrinfo_pkginfo_is_accessible(pkgmgrinfo_pkginfo_h handle, bool *accessible)
1459 {
1460         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1461         retvm_if(accessible == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1462
1463 #if 0 //smack issue occured, check later
1464         char *pkgid = NULL;
1465         pkgmgrinfo_pkginfo_get_pkgid(handle, &pkgid);
1466         if (pkgid == NULL){
1467                  _LOGD("invalid func parameters\n");
1468                  return PMINFO_R_ERROR;
1469         }
1470          _LOGD("pkgmgr_get_pkg_external_validation() called\n");
1471
1472         FILE *fp = NULL;
1473         char app_mmc_path[FILENAME_MAX] = { 0, };
1474         char app_dir_path[FILENAME_MAX] = { 0, };
1475         char app_mmc_internal_path[FILENAME_MAX] = { 0, };
1476         snprintf(app_dir_path, FILENAME_MAX,"%s%s", PKG_INSTALLATION_PATH, pkgid);
1477         snprintf(app_mmc_path, FILENAME_MAX,"%s%s", PKG_SD_PATH, pkgid);
1478         snprintf(app_mmc_internal_path, FILENAME_MAX,"%s%s/.mmc", PKG_INSTALLATION_PATH, pkgid);
1479
1480         /*check whether application is in external memory or not */
1481         fp = fopen(app_mmc_path, "r");
1482         if (fp == NULL){
1483                 _LOGD(" app path in external memory not accesible\n");
1484         } else {
1485                 fclose(fp);
1486                 fp = NULL;
1487                 *accessible = 1;
1488                 _LOGD("pkgmgr_get_pkg_external_validation() : SD_CARD \n");
1489                 return PMINFO_R_OK;
1490         }
1491
1492         /*check whether application is in internal or not */
1493         fp = fopen(app_dir_path, "r");
1494         if (fp == NULL) {
1495                 _LOGD(" app path in internal memory not accesible\n");
1496                 *accessible = 0;
1497                 return PMINFO_R_ERROR;
1498         } else {
1499                 fclose(fp);
1500                 /*check whether the application is installed in SD card
1501                 but SD card is not present*/
1502                 fp = fopen(app_mmc_internal_path, "r");
1503                 if (fp == NULL){
1504                         *accessible = 1;
1505                         _LOGD("pkgmgr_get_pkg_external_validation() : INTERNAL_MEM \n");
1506                         return PMINFO_R_OK;
1507                 }
1508                 else{
1509                         *accessible = 0;
1510                         _LOGD("pkgmgr_get_pkg_external_validation() : ERROR_MMC_STATUS \n");
1511                 }
1512                 fclose(fp);
1513         }
1514
1515         _LOGD("pkgmgr_get_pkg_external_validation() end\n");
1516 #endif
1517
1518         *accessible = 1;
1519         return PMINFO_R_OK;
1520 }
1521
1522 API int pkgmgrinfo_pkginfo_is_removable(pkgmgrinfo_pkginfo_h handle, bool *removable)
1523 {
1524         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1525
1526         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1527         retvm_if(removable == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1528
1529         if (info->pkg_info == NULL || info->pkg_info->removable == NULL)
1530                 return PMINFO_R_ERROR;
1531
1532         *removable = _get_bool_value(info->pkg_info->removable);
1533
1534         return PMINFO_R_OK;
1535 }
1536
1537 API int pkgmgrinfo_pkginfo_is_movable(pkgmgrinfo_pkginfo_h handle, bool *movable)
1538 {
1539         char *val;
1540         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1541
1542         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1543         retvm_if(movable == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1544
1545         if (info->pkg_info == NULL || info->pkg_info->installlocation == NULL)
1546                 return PMINFO_R_ERROR;
1547
1548         val = (char *)info->pkg_info->installlocation;
1549         if (strcmp(val, "internal-only") == 0)
1550                 *movable = 0;
1551         else if (strcmp(val, "prefer-external") == 0)
1552                 *movable = 1;
1553         else
1554                 *movable = 1;
1555
1556         return PMINFO_R_OK;
1557 }
1558
1559 API int pkgmgrinfo_pkginfo_is_preload(pkgmgrinfo_pkginfo_h handle, bool *preload)
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(preload == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1565
1566         if (info->pkg_info == NULL || info->pkg_info->preload == NULL)
1567                 return PMINFO_R_ERROR;
1568
1569         *preload = _get_bool_value(info->pkg_info->preload);
1570
1571         return PMINFO_R_OK;
1572 }
1573
1574 API int pkgmgrinfo_pkginfo_is_system(pkgmgrinfo_pkginfo_h handle, bool *system)
1575 {
1576         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1577
1578         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1579         retvm_if(system == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1580
1581         if (info->pkg_info == NULL || info->pkg_info->system == NULL)
1582                 return PMINFO_R_ERROR;
1583
1584         *system = _get_bool_value(info->pkg_info->system);
1585
1586         return PMINFO_R_OK;
1587 }
1588
1589 API int pkgmgrinfo_pkginfo_is_readonly(pkgmgrinfo_pkginfo_h handle, bool *readonly)
1590 {
1591         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1592
1593         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1594         retvm_if(readonly == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1595
1596         if (info->pkg_info == NULL || info->pkg_info->readonly == NULL)
1597                 return PMINFO_R_ERROR;
1598
1599         *readonly = _get_bool_value(info->pkg_info->readonly);
1600
1601         return PMINFO_R_OK;
1602 }
1603
1604 API int pkgmgrinfo_pkginfo_is_update(pkgmgrinfo_pkginfo_h handle, bool *update)
1605 {
1606         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1607
1608         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1609         retvm_if(update == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1610
1611         if (info->pkg_info == NULL || info->pkg_info->update == NULL)
1612                 return PMINFO_R_ERROR;
1613
1614         *update = _get_bool_value(info->pkg_info->update);
1615
1616         return PMINFO_R_OK;
1617 }
1618
1619 API int pkgmgrinfo_pkginfo_is_support_disable(pkgmgrinfo_pkginfo_h handle, bool *support_disable)
1620 {
1621         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1622
1623         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1624         retvm_if(support_disable == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1625
1626         if (info->pkg_info == NULL || info->pkg_info->support_disable == NULL)
1627                 return PMINFO_R_ERROR;
1628
1629         *support_disable = _get_bool_value(info->pkg_info->support_disable);
1630
1631         return PMINFO_R_OK;
1632 }
1633
1634 API int pkgmgrinfo_pkginfo_is_global(pkgmgrinfo_pkginfo_h handle, bool *global)
1635 {
1636         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1637
1638         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
1639         retvm_if(global == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
1640
1641         if (info->pkg_info == NULL || info->pkg_info->for_all_users == NULL)
1642                 return PMINFO_R_ERROR;
1643
1644         *global = _get_bool_value(info->pkg_info->for_all_users);
1645
1646         return PMINFO_R_OK;
1647 }
1648
1649 API int pkgmgrinfo_pkginfo_is_for_all_users(pkgmgrinfo_pkginfo_h handle, bool *for_all_users)
1650 {
1651         return pkgmgrinfo_pkginfo_is_global(handle, for_all_users);
1652 }
1653
1654 API int pkgmgrinfo_pkginfo_destroy_pkginfo(pkgmgrinfo_pkginfo_h handle)
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
1660         __cleanup_pkginfo(info);
1661
1662         return PMINFO_R_OK;
1663 }
1664
1665 API int pkgmgrinfo_pkginfo_filter_create(pkgmgrinfo_pkginfo_filter_h *handle)
1666 {
1667         pkgmgrinfo_filter_x *filter;
1668
1669         retvm_if(handle == NULL, PMINFO_R_EINVAL, "Filter handle output parameter is NULL\n");
1670
1671         filter = (pkgmgrinfo_filter_x*)calloc(1, sizeof(pkgmgrinfo_filter_x));
1672         if (filter == NULL) {
1673                 _LOGE("Out of Memory!!!");
1674                 return PMINFO_R_ERROR;
1675         }
1676
1677         *handle = filter;
1678
1679         return PMINFO_R_OK;
1680 }
1681
1682 API int pkgmgrinfo_pkginfo_filter_destroy(pkgmgrinfo_pkginfo_filter_h handle)
1683 {
1684         pkgmgrinfo_filter_x *filter = (pkgmgrinfo_filter_x *)handle;
1685
1686         retvm_if(handle == NULL, PMINFO_R_EINVAL, "Filter handle input parameter is NULL\n");
1687
1688         if (filter->list) {
1689                 g_slist_foreach(filter->list, __destroy_each_node, NULL);
1690                 g_slist_free(filter->list);
1691         }
1692
1693         free(filter);
1694
1695         return PMINFO_R_OK;
1696 }
1697
1698 API int pkgmgrinfo_pkginfo_filter_add_int(pkgmgrinfo_pkginfo_filter_h handle,
1699                                 const char *property, const int value)
1700 {
1701         char buf[PKG_VALUE_STRING_LEN_MAX] = {'\0'};
1702         char *val;
1703         GSList *link;
1704         int prop;
1705         pkgmgrinfo_filter_x *filter = (pkgmgrinfo_filter_x *)handle;
1706         pkgmgrinfo_node_x *node;
1707
1708         retvm_if(handle == NULL, PMINFO_R_EINVAL, "Filter handle input parameter is NULL\n");
1709         retvm_if(property == NULL, PMINFO_R_EINVAL, "Filter handle input parameter is NULL\n");
1710
1711         prop = _pminfo_pkginfo_convert_to_prop_int(property);
1712         if (prop < E_PMINFO_PKGINFO_PROP_PACKAGE_MIN_INT ||
1713                 prop > E_PMINFO_PKGINFO_PROP_PACKAGE_MAX_INT) {
1714                 _LOGE("Invalid Integer Property\n");
1715                 return PMINFO_R_EINVAL;
1716         }
1717         node = (pkgmgrinfo_node_x *)calloc(1, sizeof(pkgmgrinfo_node_x));
1718         if (node == NULL) {
1719                 _LOGE("Out of Memory!!!\n");
1720                 return PMINFO_R_ERROR;
1721         }
1722         snprintf(buf, PKG_VALUE_STRING_LEN_MAX - 1, "%d", value);
1723         val = strndup(buf, PKG_VALUE_STRING_LEN_MAX - 1);
1724         if (val == NULL) {
1725                 _LOGE("Out of Memory\n");
1726                 free(node);
1727                 return PMINFO_R_ERROR;
1728         }
1729         node->prop = prop;
1730         node->value = val;
1731         /*If API is called multiple times for same property, we should override the previous values.
1732         Last value set will be used for filtering.*/
1733         link = g_slist_find_custom(filter->list, (gconstpointer)node, __compare_func);
1734         if (link)
1735                 filter->list = g_slist_delete_link(filter->list, link);
1736         filter->list = g_slist_append(filter->list, (gpointer)node);
1737         return PMINFO_R_OK;
1738
1739 }
1740
1741 API int pkgmgrinfo_pkginfo_filter_add_bool(pkgmgrinfo_pkginfo_filter_h handle,
1742                                 const char *property, const bool value)
1743 {
1744         char *val;
1745         GSList *link;
1746         int prop;
1747         pkgmgrinfo_filter_x *filter = (pkgmgrinfo_filter_x *)handle;
1748         pkgmgrinfo_node_x *node;
1749
1750         retvm_if(handle == NULL, PMINFO_R_EINVAL, "Filter handle input parameter is NULL\n");
1751         retvm_if(property == NULL, PMINFO_R_EINVAL, "Filter handle input parameter is NULL\n");
1752
1753         prop = _pminfo_pkginfo_convert_to_prop_bool(property);
1754         if (prop < E_PMINFO_PKGINFO_PROP_PACKAGE_MIN_BOOL ||
1755                 prop > E_PMINFO_PKGINFO_PROP_PACKAGE_MAX_BOOL) {
1756                 _LOGE("Invalid Boolean Property\n");
1757                 return PMINFO_R_EINVAL;
1758         }
1759         node = (pkgmgrinfo_node_x *)calloc(1, sizeof(pkgmgrinfo_node_x));
1760         if (node == NULL) {
1761                 _LOGE("Out of Memory!!!\n");
1762                 return PMINFO_R_ERROR;
1763         }
1764         if (value)
1765                 val = strndup("('true','True')", 15);
1766         else
1767                 val = strndup("('false','False')", 17);
1768         if (val == NULL) {
1769                 _LOGE("Out of Memory\n");
1770                 free(node);
1771                 return PMINFO_R_ERROR;
1772         }
1773         node->prop = prop;
1774         node->value = val;
1775         /*If API is called multiple times for same property, we should override the previous values.
1776         Last value set will be used for filtering.*/
1777         link = g_slist_find_custom(filter->list, (gconstpointer)node, __compare_func);
1778         if (link)
1779                 filter->list = g_slist_delete_link(filter->list, link);
1780         filter->list = g_slist_append(filter->list, (gpointer)node);
1781         return PMINFO_R_OK;
1782
1783 }
1784
1785 API int pkgmgrinfo_pkginfo_filter_add_string(pkgmgrinfo_pkginfo_filter_h handle,
1786                                 const char *property, const char *value)
1787 {
1788         char *val;
1789         GSList *link;
1790         int prop;
1791         pkgmgrinfo_filter_x *filter = (pkgmgrinfo_filter_x *)handle;
1792         pkgmgrinfo_node_x *node;
1793
1794         retvm_if(handle == NULL, PMINFO_R_EINVAL, "Filter handle input parameter is NULL\n");
1795         retvm_if(property == NULL, PMINFO_R_EINVAL, "Filter handle input parameter is NULL\n");
1796         retvm_if(value == NULL, PMINFO_R_EINVAL, "Filter handle input parameter is NULL\n");
1797
1798         prop = _pminfo_pkginfo_convert_to_prop_str(property);
1799         if (prop < E_PMINFO_PKGINFO_PROP_PACKAGE_MIN_STR ||
1800                 prop > E_PMINFO_PKGINFO_PROP_PACKAGE_MAX_STR) {
1801                 _LOGE("Invalid String Property\n");
1802                 return PMINFO_R_EINVAL;
1803         }
1804         node = (pkgmgrinfo_node_x *)calloc(1, sizeof(pkgmgrinfo_node_x));
1805         if (node == NULL) {
1806                 _LOGE("Out of Memory!!!\n");
1807                 return PMINFO_R_ERROR;
1808         }
1809         if (strcmp(value, PMINFO_PKGINFO_INSTALL_LOCATION_AUTO) == 0)
1810                 val = strndup("auto", PKG_STRING_LEN_MAX - 1);
1811         else if (strcmp(value, PMINFO_PKGINFO_INSTALL_LOCATION_INTERNAL) == 0)
1812                 val = strndup("internal-only", PKG_STRING_LEN_MAX - 1);
1813         else if (strcmp(value, PMINFO_PKGINFO_INSTALL_LOCATION_EXTERNAL) == 0)
1814                 val = strndup("prefer-external", PKG_STRING_LEN_MAX - 1);
1815         else if (strcmp(value, "installed_internal") == 0)
1816                 val = strndup("installed_internal", PKG_STRING_LEN_MAX - 1);
1817         else if (strcmp(value, "installed_external") == 0)
1818                 val = strndup("installed_external", PKG_STRING_LEN_MAX - 1);
1819         else
1820                 val = strndup(value, PKG_STRING_LEN_MAX - 1);
1821         if (val == NULL) {
1822                 _LOGE("Out of Memory\n");
1823                 free(node);
1824                 return PMINFO_R_ERROR;
1825         }
1826         node->prop = prop;
1827         node->value = val;
1828         /*If API is called multiple times for same property, we should override the previous values.
1829         Last value set will be used for filtering.*/
1830         link = g_slist_find_custom(filter->list, (gconstpointer)node, __compare_func);
1831         if (link)
1832                 filter->list = g_slist_delete_link(filter->list, link);
1833         filter->list = g_slist_append(filter->list, (gpointer)node);
1834         return PMINFO_R_OK;
1835
1836 }
1837
1838 API int pkgmgrinfo_pkginfo_usr_filter_count(pkgmgrinfo_pkginfo_filter_h handle, int *count, uid_t uid)
1839 {
1840         int ret;
1841         GList *list = NULL;
1842
1843         if (handle == NULL || count == NULL) {
1844                 _LOGE("invalid parameter");
1845                 return PMINFO_R_EINVAL;
1846         }
1847
1848         ret = _pkginfo_get_filtered_list((pkgmgrinfo_filter_x *)handle, uid, &list);
1849         if (ret != PMINFO_R_OK)
1850                 return PMINFO_R_ERROR;
1851
1852         *count = g_list_length(list);
1853
1854         g_list_free_full(list, free);
1855
1856         return PMINFO_R_OK;
1857 }
1858
1859 API int pkgmgrinfo_pkginfo_filter_count(pkgmgrinfo_pkginfo_filter_h handle, int *count)
1860 {
1861         return pkgmgrinfo_pkginfo_usr_filter_count(handle, count, GLOBAL_USER);
1862 }
1863
1864 API int pkgmgrinfo_pkginfo_usr_filter_foreach_pkginfo(
1865                 pkgmgrinfo_pkginfo_filter_h handle,
1866                 pkgmgrinfo_pkg_list_cb pkg_cb, void *user_data, uid_t uid)
1867 {
1868         if (handle == NULL || pkg_cb == NULL) {
1869                 LOGE("invalid parameter");
1870                 return PMINFO_R_EINVAL;
1871         }
1872
1873         return _pkginfo_get_filtered_foreach_pkginfo(handle, pkg_cb, user_data,
1874                         uid);
1875 }
1876
1877 API int pkgmgrinfo_pkginfo_filter_foreach_pkginfo(pkgmgrinfo_pkginfo_filter_h handle,
1878                                 pkgmgrinfo_pkg_list_cb pkg_cb, void *user_data)
1879 {
1880         return pkgmgrinfo_pkginfo_usr_filter_foreach_pkginfo(handle, pkg_cb, user_data, GLOBAL_USER);
1881 }
1882
1883 API int pkgmgrinfo_pkginfo_foreach_privilege(pkgmgrinfo_pkginfo_h handle,
1884                         pkgmgrinfo_pkg_privilege_list_cb privilege_func, void *user_data)
1885 {
1886         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL");
1887         retvm_if(privilege_func == NULL, PMINFO_R_EINVAL, "Callback function is NULL");
1888         int ret;
1889         const char *privilege;
1890         GList *tmp;
1891         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
1892
1893         if (info->pkg_info == NULL)
1894                 return PMINFO_R_ERROR;
1895
1896         for (tmp = info->pkg_info->privileges; tmp; tmp = tmp->next) {
1897                 privilege = (const char *)tmp->data;
1898                 if (privilege == NULL)
1899                         continue;
1900                 ret = privilege_func(privilege, user_data);
1901                 if (ret < 0)
1902                         break;
1903         }
1904         return PMINFO_R_OK;
1905 }
1906
1907 API int pkgmgrinfo_create_pkgusrdbinfo(const char *pkgid, uid_t uid, pkgmgrinfo_pkgdbinfo_h *handle)
1908 {
1909         retvm_if(!pkgid, PMINFO_R_EINVAL, "pkgid is NULL");
1910         retvm_if(!handle, PMINFO_R_EINVAL, "Argument supplied is NULL");
1911
1912         char *manifest = NULL;
1913         manifest_x *mfx = NULL;
1914         *handle = NULL;
1915         manifest = pkgmgr_parser_get_usr_manifest_file(pkgid, uid);
1916         retvm_if(manifest == NULL, PMINFO_R_EINVAL, "pkg[%s] dont have manifest file", pkgid);
1917
1918         mfx = pkgmgr_parser_usr_process_manifest_xml(manifest, uid);
1919         if (manifest) {
1920                 free(manifest);
1921                 manifest = NULL;
1922         }
1923         retvm_if(mfx == NULL, PMINFO_R_EINVAL, "pkg[%s] parsing fail", pkgid);
1924
1925         *handle = (void *)mfx;
1926
1927         return PMINFO_R_OK;
1928 }
1929
1930 API int pkgmgrinfo_create_pkgdbinfo(const char *pkgid, pkgmgrinfo_pkgdbinfo_h *handle)
1931 {
1932         retvm_if(!pkgid, PMINFO_R_EINVAL, "pkgid is NULL");
1933         retvm_if(!handle, PMINFO_R_EINVAL, "Argument supplied is NULL");
1934
1935         char *manifest = NULL;
1936         manifest_x *mfx = NULL;
1937         *handle = NULL;
1938         manifest = pkgmgr_parser_get_manifest_file(pkgid);
1939         retvm_if(manifest == NULL, PMINFO_R_EINVAL, "pkg[%s] dont have manifest file", pkgid);
1940
1941         mfx = pkgmgr_parser_process_manifest_xml(manifest);
1942         if (manifest) {
1943                 free(manifest);
1944                 manifest = NULL;
1945         }
1946         retvm_if(mfx == NULL, PMINFO_R_EINVAL, "pkg[%s] parsing fail", pkgid);
1947
1948         *handle = (void *)mfx;
1949
1950         return PMINFO_R_OK;
1951 }
1952
1953 API int pkgmgrinfo_set_type_to_pkgdbinfo(pkgmgrinfo_pkgdbinfo_h handle, const char *type)
1954 {
1955         int len;
1956         manifest_x *mfx = (manifest_x *)handle;
1957
1958         retvm_if(!type, PMINFO_R_EINVAL, "Argument supplied is NULL");
1959         retvm_if(!handle, PMINFO_R_EINVAL, "Argument supplied is NULL");
1960
1961         len = strlen(type);
1962         retvm_if(len > PKG_TYPE_STRING_LEN_MAX, PMINFO_R_EINVAL, "pkg type length exceeds the max limit");
1963
1964         if (mfx->type)
1965                 free((void *)mfx->type);
1966
1967         mfx->type = strndup(type, PKG_TYPE_STRING_LEN_MAX);
1968
1969         return PMINFO_R_OK;
1970 }
1971
1972 API int pkgmgrinfo_set_version_to_pkgdbinfo(pkgmgrinfo_pkgdbinfo_h handle, const char *version)
1973 {
1974         int len;
1975         manifest_x *mfx = (manifest_x *)handle;
1976
1977         retvm_if(!version, PMINFO_R_EINVAL, "Argument supplied is NULL");
1978         retvm_if(!handle, PMINFO_R_EINVAL, "Argument supplied is NULL");
1979
1980         len = strlen(version);
1981         retvm_if(len > PKG_TYPE_STRING_LEN_MAX, PMINFO_R_EINVAL, "pkg type length exceeds the max limit");
1982
1983         if (mfx->version)
1984                 free((void *)mfx->version);
1985
1986         mfx->version = strndup(version, PKG_VERSION_STRING_LEN_MAX);
1987         return PMINFO_R_OK;
1988 }
1989
1990 API int pkgmgrinfo_set_install_location_to_pkgdbinfo(pkgmgrinfo_pkgdbinfo_h handle, INSTALL_LOCATION location)
1991 {
1992         manifest_x *mfx = (manifest_x *)handle;
1993
1994         retvm_if(!handle, PMINFO_R_EINVAL, "Argument supplied is NULL");
1995         retvm_if((location < 0) || (location > 1), PMINFO_R_EINVAL, "Argument supplied is NULL");
1996
1997         if (mfx->installlocation)
1998                 free((void *)mfx->installlocation);
1999
2000         if (location == INSTALL_INTERNAL)
2001                 mfx->installlocation = strdup("internal-only");
2002         else if (location == INSTALL_EXTERNAL)
2003                 mfx->installlocation = strdup("prefer-external");
2004
2005         return PMINFO_R_OK;
2006 }
2007
2008 API int pkgmgrinfo_set_size_to_pkgdbinfo(pkgmgrinfo_pkgdbinfo_h handle, const char *size)
2009 {
2010         manifest_x *mfx = (manifest_x *)handle;
2011
2012         retvm_if(!handle, PMINFO_R_EINVAL, "Argument supplied is NULL");
2013         retvm_if(size == NULL, PMINFO_R_EINVAL, "Argument supplied is NULL");
2014
2015         if (mfx->package_size)
2016                 free((void *)mfx->package_size);
2017
2018         mfx->package_size = strdup(size);
2019
2020         return PMINFO_R_OK;
2021 }
2022
2023 API int pkgmgrinfo_set_label_to_pkgdbinfo(pkgmgrinfo_pkgdbinfo_h handle, const char *label_txt, const char *locale)
2024 {
2025         int len;
2026         manifest_x *mfx = (manifest_x *)handle;
2027         label_x *label;
2028
2029         retvm_if(!handle, PMINFO_R_EINVAL, "Argument supplied is NULL");
2030         retvm_if(!label_txt, PMINFO_R_EINVAL, "Argument supplied is NULL");
2031
2032         len = strlen(label_txt);
2033         retvm_if(len > PKG_TYPE_STRING_LEN_MAX, PMINFO_R_EINVAL, "pkg type length exceeds the max limit");
2034
2035         label = calloc(1, sizeof(label_x));
2036         retvm_if(label == NULL, PMINFO_R_EINVAL, "Malloc Failed");
2037
2038         if (locale)
2039                 label->lang = strdup(locale);
2040         else
2041                 label->lang = strdup(DEFAULT_LOCALE);
2042         label->text = strdup(label_txt);
2043         mfx->label = g_list_append(mfx->label, label);
2044
2045         return PMINFO_R_OK;
2046 }
2047
2048 API int pkgmgrinfo_set_icon_to_pkgdbinfo(pkgmgrinfo_pkgdbinfo_h handle, const char *icon_txt, const char *locale)
2049 {
2050         int len;
2051         manifest_x *mfx = (manifest_x *)handle;
2052         icon_x *icon;
2053
2054         retvm_if(!handle, PMINFO_R_EINVAL, "Argument supplied is NULL");
2055         retvm_if(!icon_txt, PMINFO_R_EINVAL, "Argument supplied is NULL");
2056
2057         len = strlen(icon_txt);
2058         retvm_if(len > PKG_TYPE_STRING_LEN_MAX, PMINFO_R_EINVAL, "pkg type length exceeds the max limit");
2059
2060         icon = calloc(1, sizeof(icon_x));
2061         retvm_if(icon == NULL, PMINFO_R_EINVAL, "Malloc Failed");
2062
2063         if (locale)
2064                 icon->lang = strdup(locale);
2065         else
2066                 icon->lang = strdup(DEFAULT_LOCALE);
2067         icon->text = strdup(icon_txt);
2068         mfx->icon = g_list_append(mfx->icon, icon);
2069
2070         return PMINFO_R_OK;
2071 }
2072
2073 API int pkgmgrinfo_set_description_to_pkgdbinfo(pkgmgrinfo_pkgdbinfo_h handle, const char *desc_txt, const char *locale)
2074 {
2075         int len = strlen(desc_txt);
2076         manifest_x *mfx = (manifest_x *)handle;
2077         description_x *description;
2078
2079         retvm_if(!handle, PMINFO_R_EINVAL, "Argument supplied is NULL");
2080         retvm_if(!desc_txt, PMINFO_R_EINVAL, "Argument supplied is NULL");
2081
2082         len = strlen(desc_txt);
2083         retvm_if(len > PKG_TYPE_STRING_LEN_MAX, PMINFO_R_EINVAL, "pkg type length exceeds the max limit");
2084
2085         description = calloc(1, sizeof(description_x));
2086         retvm_if(description == NULL, PMINFO_R_EINVAL, "Malloc Failed");
2087
2088         if (locale)
2089                 description->lang = strdup(locale);
2090         else
2091                 description->lang = strdup(DEFAULT_LOCALE);
2092         description->text = strdup(desc_txt);
2093         mfx->description = g_list_append(mfx->description, description);
2094
2095         return PMINFO_R_OK;
2096 }
2097
2098 API int pkgmgrinfo_set_author_to_pkgdbinfo(pkgmgrinfo_pkgdbinfo_h handle, const char *author_name,
2099                 const char *author_email, const char *author_href, const char *locale)
2100 {
2101         manifest_x *mfx = (manifest_x *)handle;
2102         author_x *author;
2103
2104         retvm_if(!handle, PMINFO_R_EINVAL, "Argument supplied is NULL");
2105
2106         author = calloc(1, sizeof(author_x));
2107         retvm_if(author == NULL, PMINFO_R_EINVAL, "Argument supplied is NULL");
2108
2109         if (author_name)
2110                 author->text = strdup(author_name);
2111         if (author_email)
2112                 author->email = strdup(author_email);
2113         if (author_href)
2114                 author->href = strdup(author_href);
2115         if (locale)
2116                 author->lang = strdup(locale);
2117         else
2118                 author->lang = strdup(DEFAULT_LOCALE);
2119         mfx->author = g_list_append(mfx->author, author);
2120         return PMINFO_R_OK;
2121 }
2122
2123 API int pkgmgrinfo_set_removable_to_pkgdbinfo(pkgmgrinfo_pkgdbinfo_h handle, int removable)
2124 {
2125         manifest_x *mfx = (manifest_x *)handle;
2126
2127         retvm_if(!handle, PMINFO_R_EINVAL, "Argument supplied is NULL");
2128         retvm_if((removable < 0) || (removable > 1), PMINFO_R_EINVAL, "Argument supplied is NULL");
2129
2130         if (mfx->removable)
2131                 free((void *)mfx->removable);
2132
2133         if (removable == 0)
2134                 mfx->removable = strdup("false");
2135         else if (removable == 1)
2136                 mfx->removable = strdup("true");
2137
2138         return PMINFO_R_OK;
2139 }
2140
2141 API int pkgmgrinfo_set_preload_to_pkgdbinfo(pkgmgrinfo_pkgdbinfo_h handle, int preload)
2142 {
2143         manifest_x *mfx = (manifest_x *)handle;
2144
2145         retvm_if(!handle, PMINFO_R_EINVAL, "Argument supplied is NULL");
2146         retvm_if((preload < 0) || (preload > 1), PMINFO_R_EINVAL, "Argument supplied is NULL");
2147
2148         if (mfx->preload)
2149                 free((void *)mfx->preload);
2150
2151         if (preload == 0)
2152                 mfx->preload = strdup("false");
2153         else if (preload == 1)
2154                 mfx->preload = strdup("true");
2155
2156         return PMINFO_R_OK;
2157 }
2158
2159 API int pkgmgrinfo_set_installed_storage_to_pkgdbinfo(pkgmgrinfo_pkgdbinfo_h handle, INSTALL_LOCATION location)
2160 {
2161         manifest_x *mfx = (manifest_x *)handle;
2162
2163         retvm_if(!handle, PMINFO_R_EINVAL, "Argument supplied is NULL");
2164         retvm_if((location < 0) || (location > 1), PMINFO_R_EINVAL, "Argument supplied is NULL");
2165
2166         if (mfx->installed_storage)
2167                 free((void *)mfx->installed_storage);
2168
2169         if (location == INSTALL_INTERNAL)
2170                 mfx->installed_storage = strdup("installed_internal");
2171         else if (location == INSTALL_EXTERNAL)
2172                 mfx->installed_storage = strdup("installed_external");
2173
2174         return PMINFO_R_OK;
2175 }
2176
2177 API int pkgmgrinfo_save_pkgdbinfo(pkgmgrinfo_pkgdbinfo_h handle)
2178 {
2179         int ret;
2180         manifest_x *mfx = (manifest_x *)handle;
2181         mfx = (manifest_x *)handle;
2182
2183         retvm_if(!handle, PMINFO_R_EINVAL, "Argument supplied is NULL");
2184
2185         ret = pkgmgr_parser_update_manifest_info_in_db(mfx);
2186         if (ret == 0) {
2187                 _LOGE("Successfully stored info in DB\n");
2188                 return PMINFO_R_OK;
2189         } else {
2190                 _LOGE("Failed to store info in DB\n");
2191                 return PMINFO_R_ERROR;
2192         }
2193 }
2194
2195 API int pkgmgrinfo_save_pkgusrdbinfo(pkgmgrinfo_pkgdbinfo_h handle, uid_t uid)
2196 {
2197         int ret;
2198         manifest_x *mfx = (manifest_x *)handle;
2199
2200         retvm_if(!handle, PMINFO_R_EINVAL, "Argument supplied is NULL");
2201
2202         ret = pkgmgr_parser_update_manifest_info_in_usr_db(mfx, uid);
2203         if (ret == 0) {
2204                 _LOGE("Successfully stored info in DB\n");
2205                 return PMINFO_R_OK;
2206         } else {
2207                 _LOGE("Failed to store info in DB\n");
2208                 return PMINFO_R_ERROR;
2209         }
2210 }
2211
2212 API int pkgmgrinfo_destroy_pkgdbinfo(pkgmgrinfo_pkgdbinfo_h handle)
2213 {
2214         manifest_x *mfx = (manifest_x *)handle;
2215
2216         retvm_if(!handle, PMINFO_R_EINVAL, "Argument supplied is NULL");
2217
2218         pkgmgrinfo_basic_free_package(mfx);
2219
2220         return PMINFO_R_OK;
2221 }