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