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