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