src/pkgmgrinfo_pkginfo.c

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