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