src/pkgmgr-info.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 #include <stdio.h>
  24 #include <stdlib.h>
  25 #include <string.h>
  26 #include <unistd.h>
  27 #include <db-util.h>
  28 #include <sqlite3.h>
  29 #include <vconf.h>
  30 #include <glib.h>
  31 #include <ctype.h>
  32 #include <assert.h>
  33
  34 #include <libxml/parser.h>
  35 #include <libxml/xmlreader.h>
  36 #include <libxml/xmlschemas.h>
  37
  38 #include "pkgmgr_parser.h"
  39 #include "pkgmgr-info-internal.h"
  40 #include "pkgmgr-info-debug.h"
  41 #include "pkgmgr-info.h"
  42 #include "pkgmgr_parser_db.h"
  43 #include <dirent.h>
  44 #include <sys/stat.h>
  45
  46 #define ASC_CHAR(s) (const char *)s
  47 #define XML_CHAR(s) (const xmlChar *)s
  48
  49 #define MANIFEST_DB     "/opt/dbspace/.pkgmgr_parser.db"
  50 #define MAX_QUERY_LEN   4096
  51 #define MAX_CERT_TYPE   9
  52 #define CERT_DB         "/opt/dbspace/.pkgmgr_cert.db"
  53 #define DATACONTROL_DB  "/opt/usr/dbspace/.app-package.db"
  54 #define PKG_TYPE_STRING_LEN_MAX         128
  55 #define PKG_VERSION_STRING_LEN_MAX      128
  56 #define PKG_VALUE_STRING_LEN_MAX                512
  57 #define PKG_LOCALE_STRING_LEN_MAX               8
  58 #define PKG_RW_PATH "/opt/usr/apps/"
  59 #define PKG_RO_PATH "/usr/apps/"
  60 #define BLOCK_SIZE      4096 /*in bytes*/
  61
  62 #define MMC_PATH "/opt/storage/sdcard"
  63 #define PKG_SD_PATH MMC_PATH"/app2sd/"
  64 #define PKG_INSTALLATION_PATH "/opt/usr/apps/"
  65
  66 #define FILTER_QUERY_COUNT_PACKAGE      "select count(DISTINCT package_info.package) " \
  67                                 "from package_info LEFT OUTER JOIN package_localized_info " \
  68                                 "ON package_info.package=package_localized_info.package " \
  69                                 "and package_localized_info.package_locale='%s' where "
  70
  71 #define FILTER_QUERY_LIST_PACKAGE       "select DISTINCT package_info.package " \
  72                                 "from package_info LEFT OUTER JOIN package_localized_info " \
  73                                 "ON package_info.package=package_localized_info.package " \
  74                                 "and package_localized_info.package_locale='%s' where "
  75
  76 #define FILTER_QUERY_COUNT_APP  "select count(DISTINCT package_app_info.app_id) " \
  77                                 "from package_app_info LEFT OUTER JOIN package_app_localized_info " \
  78                                 "ON package_app_info.app_id=package_app_localized_info.app_id " \
  79                                 "and package_app_localized_info.app_locale='%s' " \
  80                                 "LEFT OUTER JOIN package_app_app_svc " \
  81                                 "ON package_app_info.app_id=package_app_app_svc.app_id " \
  82                                 "LEFT OUTER JOIN package_app_app_category " \
  83                                 "ON package_app_info.app_id=package_app_app_category.app_id where "
  84
  85 #define FILTER_QUERY_LIST_APP   "select DISTINCT package_app_info.app_id, package_app_info.app_component " \
  86                                 "from package_app_info LEFT OUTER JOIN package_app_localized_info " \
  87                                 "ON package_app_info.app_id=package_app_localized_info.app_id " \
  88                                 "and package_app_localized_info.app_locale='%s' " \
  89                                 "LEFT OUTER JOIN package_app_app_svc " \
  90                                 "ON package_app_info.app_id=package_app_app_svc.app_id " \
  91                                 "LEFT OUTER JOIN package_app_app_category " \
  92                                 "ON package_app_info.app_id=package_app_app_category.app_id where "
  93
  94 #define METADATA_FILTER_QUERY_SELECT_CLAUSE     "select DISTINCT package_app_info.app_id, package_app_info.app_component " \
  95                                 "from package_app_info LEFT OUTER JOIN package_app_app_metadata " \
  96                                 "ON package_app_info.app_id=package_app_app_metadata.app_id where "
  97
  98 #define METADATA_FILTER_QUERY_UNION_CLAUSE      " UNION "METADATA_FILTER_QUERY_SELECT_CLAUSE
  99
 100 #define LANGUAGE_LENGTH 2
 101
 102 typedef struct _pkgmgr_instcertinfo_x {
 103         char *pkgid;
 104         char *cert_info[MAX_CERT_TYPE]; /*certificate data*/
 105         int is_new[MAX_CERT_TYPE];              /*whether already exist in table or not*/
 106         int ref_count[MAX_CERT_TYPE];           /*reference count of certificate data*/
 107         int cert_id[MAX_CERT_TYPE];             /*certificate ID in index table*/
 108 } pkgmgr_instcertinfo_x;
 109
 110 typedef struct _pkgmgr_certindexinfo_x {
 111         int cert_id;
 112         int cert_ref_count;
 113 } pkgmgr_certindexinfo_x;
 114
 115 typedef struct _pkgmgr_pkginfo_x {
 116         manifest_x *manifest_info;
 117         char *locale;
 118
 119         struct _pkgmgr_pkginfo_x *prev;
 120         struct _pkgmgr_pkginfo_x *next;
 121 } pkgmgr_pkginfo_x;
 122
 123 typedef struct _pkgmgr_cert_x {
 124         char *pkgid;
 125         int cert_id;
 126 } pkgmgr_cert_x;
 127
 128 typedef struct _pkgmgr_datacontrol_x {
 129         char *appid;
 130         char *access;
 131 } pkgmgr_datacontrol_x;
 132
 133 typedef struct _pkgmgr_iconpath_x {
 134         char *appid;
 135         char *iconpath;
 136 } pkgmgr_iconpath_x;
 137
 138 typedef struct _pkgmgr_image_x {
 139         char *imagepath;
 140 } pkgmgr_image_x;
 141
 142 typedef struct _pkgmgr_locale_x {
 143         char *locale;
 144 } pkgmgr_locale_x;
 145
 146 typedef struct _pkgmgr_appinfo_x {
 147         const char *package;
 148         char *locale;
 149         pkgmgrinfo_app_component app_component;
 150         union {
 151                 uiapplication_x *uiapp_info;
 152                 serviceapplication_x *svcapp_info;
 153         };
 154 } pkgmgr_appinfo_x;
 155
 156 typedef struct _pkgmgr_certinfo_x {
 157         char *pkgid;
 158         char *cert_value;
 159         char *cert_info[MAX_CERT_TYPE]; /*certificate info*/
 160         int cert_id[MAX_CERT_TYPE];             /*certificate ID in index table*/
 161 } pkgmgr_certinfo_x;
 162
 163 /*For filter APIs*/
 164 typedef struct _pkgmgrinfo_filter_x {
 165         GSList *list;
 166 } pkgmgrinfo_filter_x;
 167
 168 typedef struct _pkgmgrinfo_node_x {
 169         int prop;
 170         char *key;
 171         char *value;
 172 } pkgmgrinfo_node_x;
 173
 174 typedef struct _pkgmgrinfo_appcontrol_x {
 175         int operation_count;
 176         int uri_count;
 177         int mime_count;
 178         char **operation;
 179         char **uri;
 180         char **mime;
 181 } pkgmgrinfo_appcontrol_x;
 182
 183 typedef int (*sqlite_query_callback)(void *data, int ncols, char **coltxt, char **colname);
 184
 185 char *pkgtype = "rpm";
 186 __thread sqlite3 *manifest_db = NULL;
 187 __thread sqlite3 *datacontrol_db = NULL;
 188 __thread sqlite3 *cert_db = NULL;
 189
 190 static int __open_manifest_db();
 191 static int __exec_pkginfo_query(char *query, void *data);
 192 static int __exec_certinfo_query(char *query, void *data);
 193 static int __exec_certindexinfo_query(char *query, void *data);
 194 static int __pkginfo_cb(void *data, int ncols, char **coltxt, char **colname);
 195 static int __appinfo_cb(void *data, int ncols, char **coltxt, char **colname);
 196 static int __certinfo_cb(void *data, int ncols, char **coltxt, char **colname);
 197 static int __certindexinfo_cb(void *data, int ncols, char **coltxt, char **colname);
 198 static int __validate_cb(void *data, int ncols, char **coltxt, char **colname);
 199 static int __maxid_cb(void *data, int ncols, char **coltxt, char **colname);
 200 static int __count_cb(void *data, int ncols, char **coltxt, char **colname);
 201 static int __uiapp_list_cb(void *data, int ncols, char **coltxt, char **colname);
 202 static int __svcapp_list_cb(void *data, int ncols, char **coltxt, char **colname);
 203 static int __pkg_list_cb(void *data, int ncols, char **coltxt, char **colname);
 204 static int __app_list_cb(void *data, int ncols, char **coltxt, char **colname);
 205 static void __cleanup_pkginfo(pkgmgr_pkginfo_x *data);
 206 static void __cleanup_appinfo(pkgmgr_appinfo_x *data);
 207 static char* __convert_system_locale_to_manifest_locale(char *syslocale);
 208 static void __destroy_each_node(gpointer data, gpointer user_data);
 209 static void __get_filter_condition(gpointer data, char **condition);
 210 static void __get_metadata_filter_condition(gpointer data, char **condition);
 211 static gint __compare_func(gconstpointer data1, gconstpointer data2);
 212 static int __delete_certinfo(const char *pkgid);
 213
 214 static gint __compare_func(gconstpointer data1, gconstpointer data2)
 215 {
 216         pkgmgrinfo_node_x *node1 = (pkgmgrinfo_node_x*)data1;
 217         pkgmgrinfo_node_x *node2 = (pkgmgrinfo_node_x*)data2;
 218         if (node1->prop == node2->prop)
 219                 return 0;
 220         else if (node1->prop > node2->prop)
 221                 return 1;
 222         else
 223                 return -1;
 224 }
 225
 226 static int __count_cb(void *data, int ncols, char **coltxt, char **colname)
 227 {
 228         int *p = (int*)data;
 229         *p = atoi(coltxt[0]);
 230         _LOGE("count value is %d\n", *p);
 231         return 0;
 232 }
 233
 234 static void __destroy_each_node(gpointer data, gpointer user_data)
 235 {
 236         ret_if(data == NULL);
 237         pkgmgrinfo_node_x *node = (pkgmgrinfo_node_x*)data;
 238         if (node->value) {
 239                 free(node->value);
 240                 node->value = NULL;
 241         }
 242         if (node->key) {
 243                 free(node->key);
 244                 node->key = NULL;
 245         }
 246         free(node);
 247         node = NULL;
 248 }
 249
 250 static void __get_metadata_filter_condition(gpointer data, char **condition)
 251 {
 252         pkgmgrinfo_node_x *node = (pkgmgrinfo_node_x*)data;
 253         char key[MAX_QUERY_LEN] = {'\0'};
 254         char value[MAX_QUERY_LEN] = {'\0'};
 255         if (node->key) {
 256                 snprintf(key, MAX_QUERY_LEN, "(package_app_app_metadata.md_key='%s'", node->key);
 257         }
 258         if (node->value) {
 259                 snprintf(value, MAX_QUERY_LEN, " AND package_app_app_metadata.md_value='%s')", node->value);
 260                 strcat(key, value);
 261         } else {
 262                 strcat(key, ")");
 263         }
 264         *condition = strdup(key);
 265         return;
 266 }
 267
 268 static void __get_filter_condition(gpointer data, char **condition)
 269 {
 270         pkgmgrinfo_node_x *node = (pkgmgrinfo_node_x*)data;
 271         char buf[MAX_QUERY_LEN + 1] = {'\0'};
 272         char temp[PKG_STRING_LEN_MAX] = {'\0'};
 273         switch (node->prop) {
 274         case E_PMINFO_PKGINFO_PROP_PACKAGE_ID:
 275                 snprintf(buf, MAX_QUERY_LEN, "package_info.package='%s'", node->value);
 276                 break;
 277         case E_PMINFO_PKGINFO_PROP_PACKAGE_TYPE:
 278                 snprintf(buf, MAX_QUERY_LEN, "package_info.package_type='%s'", node->value);
 279                 break;
 280         case E_PMINFO_PKGINFO_PROP_PACKAGE_VERSION:
 281                 snprintf(buf, MAX_QUERY_LEN, "package_info.package_version='%s'", node->value);
 282                 break;
 283         case E_PMINFO_PKGINFO_PROP_PACKAGE_INSTALL_LOCATION:
 284                 snprintf(buf, MAX_QUERY_LEN, "package_info.install_location='%s'", node->value);
 285                 break;
 286         case E_PMINFO_PKGINFO_PROP_PACKAGE_INSTALLED_STORAGE:
 287                 snprintf(buf, MAX_QUERY_LEN, "package_info.installed_storage='%s'", node->value);
 288                 break;
 289         case E_PMINFO_PKGINFO_PROP_PACKAGE_AUTHOR_NAME:
 290                 snprintf(buf, MAX_QUERY_LEN, "package_info.author_name='%s'", node->value);
 291                 break;
 292         case E_PMINFO_PKGINFO_PROP_PACKAGE_AUTHOR_HREF:
 293                 snprintf(buf, MAX_QUERY_LEN, "package_info.author_href='%s'", node->value);
 294                 break;
 295         case E_PMINFO_PKGINFO_PROP_PACKAGE_AUTHOR_EMAIL:
 296                 snprintf(buf, MAX_QUERY_LEN, "package_info.author_email='%s'", node->value);
 297                 break;
 298         case E_PMINFO_PKGINFO_PROP_PACKAGE_SIZE:
 299                 snprintf(buf, MAX_QUERY_LEN, "package_info.package_size='%s'", node->value);
 300                 break;
 301         case E_PMINFO_PKGINFO_PROP_PACKAGE_REMOVABLE:
 302                 snprintf(buf, MAX_QUERY_LEN, "package_info.package_removable IN %s", node->value);
 303                 break;
 304         case E_PMINFO_PKGINFO_PROP_PACKAGE_PRELOAD:
 305                 snprintf(buf, MAX_QUERY_LEN, "package_info.package_preload IN %s", node->value);
 306                 break;
 307         case E_PMINFO_PKGINFO_PROP_PACKAGE_READONLY:
 308                 snprintf(buf, MAX_QUERY_LEN, "package_info.package_readonly IN %s", node->value);
 309                 break;
 310         case E_PMINFO_PKGINFO_PROP_PACKAGE_UPDATE:
 311                 snprintf(buf, MAX_QUERY_LEN, "package_info.package_update IN %s", node->value);
 312                 break;
 313         case E_PMINFO_PKGINFO_PROP_PACKAGE_APPSETTING:
 314                 snprintf(buf, MAX_QUERY_LEN, "package_info.package_appsetting IN %s", node->value);
 315                 break;
 316         case E_PMINFO_PKGINFO_PROP_PACKAGE_NODISPLAY_SETTING:
 317                 snprintf(buf, MAX_QUERY_LEN, "package_info.package_nodisplay IN %s", node->value);
 318                 break;
 319
 320         case E_PMINFO_APPINFO_PROP_APP_ID:
 321                 snprintf(buf, MAX_QUERY_LEN, "package_app_info.app_id='%s'", node->value);
 322                 break;
 323         case E_PMINFO_APPINFO_PROP_APP_COMPONENT:
 324                 snprintf(buf, MAX_QUERY_LEN, "package_app_info.app_component='%s'", node->value);
 325                 break;
 326         case E_PMINFO_APPINFO_PROP_APP_EXEC:
 327                 snprintf(buf, MAX_QUERY_LEN, "package_app_info.app_exec='%s'", node->value);
 328                 break;
 329         case E_PMINFO_APPINFO_PROP_APP_ICON:
 330                 snprintf(buf, MAX_QUERY_LEN, "package_app_localized_info.app_icon='%s'", node->value);
 331                 break;
 332         case E_PMINFO_APPINFO_PROP_APP_TYPE:
 333                 snprintf(buf, MAX_QUERY_LEN, "package_app_info.app_type='%s'", node->value);
 334                 break;
 335         case E_PMINFO_APPINFO_PROP_APP_OPERATION:
 336                 snprintf(temp, PKG_STRING_LEN_MAX, "(%s)", node->value);
 337                 snprintf(buf, MAX_QUERY_LEN, "package_app_app_svc.operation IN %s", temp);
 338                 break;
 339         case E_PMINFO_APPINFO_PROP_APP_URI:
 340                 snprintf(temp, PKG_STRING_LEN_MAX, "(%s)", node->value);
 341                 snprintf(buf, MAX_QUERY_LEN, "package_app_app_svc.uri_scheme IN %s", temp);
 342                 break;
 343         case E_PMINFO_APPINFO_PROP_APP_MIME:
 344                 snprintf(temp, PKG_STRING_LEN_MAX, "(%s)", node->value);
 345                 snprintf(buf, MAX_QUERY_LEN, "package_app_app_svc.mime_type IN %s", temp);
 346                 break;
 347         case E_PMINFO_APPINFO_PROP_APP_CATEGORY:
 348                 snprintf(temp, PKG_STRING_LEN_MAX, "(%s)", node->value);
 349                 snprintf(buf, MAX_QUERY_LEN, "package_app_app_category.category IN %s", temp);
 350                 break;
 351         case E_PMINFO_APPINFO_PROP_APP_NODISPLAY:
 352                 snprintf(buf, MAX_QUERY_LEN, "package_app_info.app_nodisplay IN %s", node->value);
 353                 break;
 354         case E_PMINFO_APPINFO_PROP_APP_MULTIPLE:
 355                 snprintf(buf, MAX_QUERY_LEN, "package_app_info.app_multiple IN %s", node->value);
 356                 break;
 357         case E_PMINFO_APPINFO_PROP_APP_ONBOOT:
 358                 snprintf(buf, MAX_QUERY_LEN, "package_app_info.app_onboot IN %s", node->value);
 359                 break;
 360         case E_PMINFO_APPINFO_PROP_APP_AUTORESTART:
 361                 snprintf(buf, MAX_QUERY_LEN, "package_app_info.app_autorestart IN %s", node->value);
 362                 break;
 363         case E_PMINFO_APPINFO_PROP_APP_TASKMANAGE:
 364                 snprintf(buf, MAX_QUERY_LEN, "package_app_info.app_taskmanage IN %s", node->value);
 365                 break;
 366         case E_PMINFO_APPINFO_PROP_APP_HWACCELERATION:
 367                 snprintf(buf, MAX_QUERY_LEN, "package_app_info.app_hwacceleration='%s'", node->value);
 368                 break;
 369         case E_PMINFO_APPINFO_PROP_APP_LAUNCHCONDITION:
 370                 snprintf(buf, MAX_QUERY_LEN, "package_app_info.app_launchcondition='%s'", node->value);
 371                 break;
 372         default:
 373                 _LOGE("Invalid Property Type\n");
 374                 *condition = NULL;
 375                 return;
 376         }
 377         *condition = strdup(buf);
 378         return;
 379 }
 380
 381 static char* __convert_system_locale_to_manifest_locale(char *syslocale)
 382 {
 383         if (syslocale == NULL)
 384                 return strdup(DEFAULT_LOCALE);
 385         char *locale = NULL;
 386         locale = (char *)calloc(1, 6);
 387         retvm_if(!locale, NULL, "Malloc Failed\n");
 388
 389         strncpy(locale, syslocale, 2);
 390         strncat(locale, "-", 1);
 391         locale[3] = syslocale[3] + 32;
 392         locale[4] = syslocale[4] + 32;
 393         return locale;
 394 }
 395
 396 static void __cleanup_pkginfo(pkgmgr_pkginfo_x *data)
 397 {
 398         ret_if(data == NULL);
 399         if (data->locale){
 400                 free((void *)data->locale);
 401                 data->locale = NULL;
 402         }
 403
 404         pkgmgr_parser_free_manifest_xml(data->manifest_info);
 405         free((void *)data);
 406         data = NULL;
 407         return;
 408 }
 409
 410 static void __cleanup_appinfo(pkgmgr_appinfo_x *data)
 411 {
 412         ret_if(data == NULL);
 413         if (data->package){
 414                 free((void *)data->package);
 415                 data->package = NULL;
 416         }
 417         if (data->locale){
 418                 free((void *)data->locale);
 419                 data->locale = NULL;
 420         }
 421
 422         manifest_x *mfx = calloc(1, sizeof(manifest_x));
 423         if (data->app_component == PMINFO_UI_APP)
 424                 mfx->uiapplication = data->uiapp_info;
 425         else if (data->app_component == PMINFO_SVC_APP)
 426                 mfx->serviceapplication = data->svcapp_info;
 427         pkgmgr_parser_free_manifest_xml(mfx);
 428         free((void *)data);
 429         data = NULL;
 430         return;
 431 }
 432
 433 static int __open_manifest_db()
 434 {
 435         int ret = -1;
 436         if (access(MANIFEST_DB, F_OK) == 0) {
 437                 ret =
 438                     db_util_open_with_options(MANIFEST_DB, &manifest_db,
 439                                  SQLITE_OPEN_READONLY, NULL);
 440                 retvm_if(ret != SQLITE_OK, -1, "connect db [%s] failed!\n", MANIFEST_DB);
 441                 return 0;
 442         }
 443         _LOGE("Manifest DB does not exists !!\n");
 444         return -1;
 445 }
 446
 447 static int __open_datacontrol_db()
 448 {
 449         int ret = -1;
 450         if (access(DATACONTROL_DB, F_OK) == 0) {
 451                 ret =
 452                     db_util_open_with_options(DATACONTROL_DB, &datacontrol_db,
 453                                  SQLITE_OPEN_READONLY, NULL);
 454                 retvm_if(ret != SQLITE_OK, -1, "connect db [%s] failed!\n", DATACONTROL_DB);
 455                 return 0;
 456         }
 457         _LOGE("Datacontrol DB does not exists !!\n");
 458         return -1;
 459 }
 460
 461 static int __pkg_list_cb(void *data, int ncols, char **coltxt, char **colname)
 462 {
 463         pkgmgr_pkginfo_x *udata = (pkgmgr_pkginfo_x *)data;
 464         int i = 0;
 465         pkgmgr_pkginfo_x *info = NULL;
 466         info = calloc(1, sizeof(pkgmgr_pkginfo_x));
 467         info->manifest_info = (manifest_x *)calloc(1, sizeof(manifest_x));
 468
 469         LISTADD(udata, info);
 470         for(i = 0; i < ncols; i++)
 471         {
 472                 if (strcmp(colname[i], "package") == 0) {
 473                         if (coltxt[i])
 474                                 info->manifest_info->package = strdup(coltxt[i]);
 475                         else
 476                                 info->manifest_info->package = NULL;
 477                 } else
 478                         continue;
 479         }
 480
 481         return 0;
 482 }
 483
 484 static int __app_list_cb(void *data, int ncols, char **coltxt, char **colname)
 485 {
 486         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)data;
 487         int i = 0;
 488         int j = 0;
 489         uiapplication_x *uiapp = NULL;
 490         serviceapplication_x *svcapp = NULL;
 491         for(i = 0; i < ncols; i++)
 492         {
 493                 if ((strcmp(colname[i], "app_component") == 0) ||
 494                         (strcmp(colname[i], "package_app_info.app_component") == 0)) {
 495                         if (coltxt[i]) {
 496                                 if (strcmp(coltxt[i], "uiapp") == 0) {
 497                                         uiapp = calloc(1, sizeof(uiapplication_x));
 498                                         if (uiapp == NULL) {
 499                                                 _LOGE("Out of Memory!!!\n");
 500                                                 return -1;
 501                                         }
 502                                         LISTADD(info->manifest_info->uiapplication, uiapp);
 503                                         for(j = 0; j < ncols; j++)
 504                                         {
 505                                                 if ((strcmp(colname[j], "app_id") == 0) ||
 506                                                         (strcmp(colname[j], "package_app_info.app_id") == 0)) {
 507                                                         if (coltxt[j])
 508                                                                 info->manifest_info->uiapplication->appid = strdup(coltxt[j]);
 509                                                 } else if (strcmp(colname[j], "package") == 0) {
 510                                                         if (coltxt[j])
 511                                                                 info->manifest_info->uiapplication->package = strdup(coltxt[j]);
 512                                                 } else
 513                                                         continue;
 514                                         }
 515                                 } else {
 516                                         svcapp = calloc(1, sizeof(serviceapplication_x));
 517                                         if (svcapp == NULL) {
 518                                                 _LOGE("Out of Memory!!!\n");
 519                                                 return -1;
 520                                         }
 521                                         LISTADD(info->manifest_info->serviceapplication, svcapp);
 522                                         for(j = 0; j < ncols; j++)
 523                                         {
 524                                                 if ((strcmp(colname[j], "app_id") == 0) ||
 525                                                         (strcmp(colname[j], "package_app_info.app_id") == 0)) {
 526                                                         if (coltxt[j])
 527                                                                 info->manifest_info->serviceapplication->appid = strdup(coltxt[j]);
 528                                                 } else if (strcmp(colname[j], "package") == 0) {
 529                                                         if (coltxt[j])
 530                                                                 info->manifest_info->serviceapplication->package = strdup(coltxt[j]);
 531                                                 } else
 532                                                         continue;
 533                                         }
 534                                 }
 535                         }
 536                 } else
 537                         continue;
 538         }
 539
 540         return 0;
 541 }
 542
 543
 544 static int __uiapp_list_cb(void *data, int ncols, char **coltxt, char **colname)
 545 {
 546         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)data;
 547         int i = 0;
 548         uiapplication_x *uiapp = NULL;
 549         icon_x *icon = NULL;
 550         label_x *label = NULL;
 551
 552         uiapp = calloc(1, sizeof(uiapplication_x));
 553         LISTADD(info->manifest_info->uiapplication, uiapp);
 554         icon = calloc(1, sizeof(icon_x));
 555         LISTADD(info->manifest_info->uiapplication->icon, icon);
 556         label = calloc(1, sizeof(label_x));
 557         LISTADD(info->manifest_info->uiapplication->label, label);
 558
 559         for(i = 0; i < ncols; i++)
 560         {
 561                 if (strcmp(colname[i], "app_id") == 0) {
 562                         if (coltxt[i])
 563                                 info->manifest_info->uiapplication->appid = strdup(coltxt[i]);
 564                         else
 565                                 info->manifest_info->uiapplication->appid = NULL;
 566                 } else if (strcmp(colname[i], "app_exec") == 0) {
 567                         if (coltxt[i])
 568                                 info->manifest_info->uiapplication->exec = strdup(coltxt[i]);
 569                         else
 570                                 info->manifest_info->uiapplication->exec = NULL;
 571                 } else if (strcmp(colname[i], "app_type") == 0 ){
 572                         if (coltxt[i])
 573                                 info->manifest_info->uiapplication->type = strdup(coltxt[i]);
 574                         else
 575                                 info->manifest_info->uiapplication->type = NULL;
 576                 } else if (strcmp(colname[i], "app_nodisplay") == 0 ){
 577                         if (coltxt[i])
 578                                 info->manifest_info->uiapplication->nodisplay = strdup(coltxt[i]);
 579                         else
 580                                 info->manifest_info->uiapplication->nodisplay = NULL;
 581                 } else if (strcmp(colname[i], "app_multiple") == 0 ){
 582                         if (coltxt[i])
 583                                 info->manifest_info->uiapplication->multiple = strdup(coltxt[i]);
 584                         else
 585                                 info->manifest_info->uiapplication->multiple = NULL;
 586                 } else if (strcmp(colname[i], "app_taskmanage") == 0 ){
 587                         if (coltxt[i])
 588                                 info->manifest_info->uiapplication->taskmanage = strdup(coltxt[i]);
 589                         else
 590                                 info->manifest_info->uiapplication->taskmanage = NULL;
 591                 } else if (strcmp(colname[i], "app_hwacceleration") == 0 ){
 592                         if (coltxt[i])
 593                                 info->manifest_info->uiapplication->hwacceleration = strdup(coltxt[i]);
 594                         else
 595                                 info->manifest_info->uiapplication->hwacceleration = NULL;
 596                 } else if (strcmp(colname[i], "app_indicatordisplay") == 0 ){
 597                         if (coltxt[i])
 598                                 info->manifest_info->uiapplication->indicatordisplay = strdup(coltxt[i]);
 599                         else
 600                                 info->manifest_info->uiapplication->indicatordisplay = NULL;
 601                 } else if (strcmp(colname[i], "app_portraitimg") == 0 ){
 602                         if (coltxt[i])
 603                                 info->manifest_info->uiapplication->portraitimg = strdup(coltxt[i]);
 604                         else
 605                                 info->manifest_info->uiapplication->portraitimg = NULL;
 606                 } else if (strcmp(colname[i], "app_landscapeimg") == 0 ){
 607                         if (coltxt[i])
 608                                 info->manifest_info->uiapplication->landscapeimg = strdup(coltxt[i]);
 609                         else
 610                                 info->manifest_info->uiapplication->landscapeimg = NULL;
 611                 } else if (strcmp(colname[i], "app_guestmodevisibility") == 0 ){
 612                         if (coltxt[i])
 613                                 info->manifest_info->uiapplication->guestmode_visibility = strdup(coltxt[i]);
 614                         else
 615                                 info->manifest_info->uiapplication->guestmode_visibility = NULL;
 616                 } else if (strcmp(colname[i], "package") == 0 ){
 617                         if (coltxt[i])
 618                                 info->manifest_info->uiapplication->package = strdup(coltxt[i]);
 619                         else
 620                                 info->manifest_info->uiapplication->package = NULL;
 621                 } else if (strcmp(colname[i], "app_icon") == 0) {
 622                         if (coltxt[i])
 623                                 info->manifest_info->uiapplication->icon->text = strdup(coltxt[i]);
 624                         else
 625                                 info->manifest_info->uiapplication->icon->text = NULL;
 626                 } else if (strcmp(colname[i], "app_label") == 0 ) {
 627                         if (coltxt[i])
 628                                 info->manifest_info->uiapplication->label->text = strdup(coltxt[i]);
 629                         else
 630                                 info->manifest_info->uiapplication->label->text = NULL;
 631                 } else if (strcmp(colname[i], "app_recentimage") == 0 ) {
 632                         if (coltxt[i])
 633                                 info->manifest_info->uiapplication->recentimage = strdup(coltxt[i]);
 634                         else
 635                                 info->manifest_info->uiapplication->recentimage = NULL;
 636                 } else if (strcmp(colname[i], "app_mainapp") == 0 ) {
 637                         if (coltxt[i])
 638                                 info->manifest_info->uiapplication->mainapp = strdup(coltxt[i]);
 639                         else
 640                                 info->manifest_info->uiapplication->mainapp = NULL;
 641                 } else if (strcmp(colname[i], "app_locale") == 0 ) {
 642                         if (coltxt[i]) {
 643                                 info->manifest_info->uiapplication->icon->lang = strdup(coltxt[i]);
 644                                 info->manifest_info->uiapplication->label->lang = strdup(coltxt[i]);
 645                         }
 646                         else {
 647                                 info->manifest_info->uiapplication->icon->lang = NULL;
 648                                 info->manifest_info->uiapplication->label->lang = NULL;
 649                         }
 650                 } else if (strcmp(colname[i], "app_permissiontype") == 0 ) {
 651                         if (coltxt[i])
 652                                 info->manifest_info->uiapplication->permission_type = strdup(coltxt[i]);
 653                         else
 654                                 info->manifest_info->uiapplication->permission_type = NULL;
 655                 } else
 656                         continue;
 657         }
 658         return 0;
 659 }
 660
 661 static int __svcapp_list_cb(void *data, int ncols, char **coltxt, char **colname)
 662 {
 663         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)data;
 664         int i = 0;
 665         serviceapplication_x *svcapp = NULL;
 666         icon_x *icon = NULL;
 667         label_x *label = NULL;
 668
 669         svcapp = calloc(1, sizeof(serviceapplication_x));
 670         LISTADD(info->manifest_info->serviceapplication, svcapp);
 671         icon = calloc(1, sizeof(icon_x));
 672         LISTADD(info->manifest_info->serviceapplication->icon, icon);
 673         label = calloc(1, sizeof(label_x));
 674         LISTADD(info->manifest_info->serviceapplication->label, label);
 675         for(i = 0; i < ncols; i++)
 676         {
 677                 if (strcmp(colname[i], "app_id") == 0) {
 678                         if (coltxt[i])
 679                                 info->manifest_info->serviceapplication->appid = strdup(coltxt[i]);
 680                         else
 681                                 info->manifest_info->serviceapplication->appid = NULL;
 682                 } else if (strcmp(colname[i], "app_exec") == 0) {
 683                         if (coltxt[i])
 684                                 info->manifest_info->serviceapplication->exec = strdup(coltxt[i]);
 685                         else
 686                                 info->manifest_info->serviceapplication->exec = NULL;
 687                 } else if (strcmp(colname[i], "app_type") == 0 ){
 688                         if (coltxt[i])
 689                                 info->manifest_info->serviceapplication->type = strdup(coltxt[i]);
 690                         else
 691                                 info->manifest_info->serviceapplication->type = NULL;
 692                 } else if (strcmp(colname[i], "app_onboot") == 0 ){
 693                         if (coltxt[i])
 694                                 info->manifest_info->serviceapplication->onboot = strdup(coltxt[i]);
 695                         else
 696                                 info->manifest_info->serviceapplication->onboot = NULL;
 697                 } else if (strcmp(colname[i], "app_autorestart") == 0 ){
 698                         if (coltxt[i])
 699                                 info->manifest_info->serviceapplication->autorestart = strdup(coltxt[i]);
 700                         else
 701                                 info->manifest_info->serviceapplication->autorestart = NULL;
 702                 } else if (strcmp(colname[i], "package") == 0 ){
 703                         if (coltxt[i])
 704                                 info->manifest_info->serviceapplication->package = strdup(coltxt[i]);
 705                         else
 706                                 info->manifest_info->serviceapplication->package = NULL;
 707                 } else if (strcmp(colname[i], "app_icon") == 0) {
 708                         if (coltxt[i])
 709                                 info->manifest_info->serviceapplication->icon->text = strdup(coltxt[i]);
 710                         else
 711                                 info->manifest_info->serviceapplication->icon->text = NULL;
 712                 } else if (strcmp(colname[i], "app_label") == 0 ) {
 713                         if (coltxt[i])
 714                                 info->manifest_info->serviceapplication->label->text = strdup(coltxt[i]);
 715                         else
 716                                 info->manifest_info->serviceapplication->label->text = NULL;
 717                 } else if (strcmp(colname[i], "app_locale") == 0 ) {
 718                         if (coltxt[i]) {
 719                                 info->manifest_info->serviceapplication->icon->lang = strdup(coltxt[i]);
 720                                 info->manifest_info->serviceapplication->label->lang = strdup(coltxt[i]);
 721                         }
 722                         else {
 723                                 info->manifest_info->serviceapplication->icon->lang = NULL;
 724                                 info->manifest_info->serviceapplication->label->lang = NULL;
 725                         }
 726                 } else if (strcmp(colname[i], "app_permissiontype") == 0 ) {
 727                         if (coltxt[i])
 728                                 info->manifest_info->serviceapplication->permission_type = strdup(coltxt[i]);
 729                         else
 730                                 info->manifest_info->serviceapplication->permission_type = NULL;
 731                 } else
 732                         continue;
 733         }
 734         return 0;
 735 }
 736
 737 static int __allapp_list_cb(void *data, int ncols, char **coltxt, char **colname)
 738 {
 739         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)data;
 740         int i = 0;
 741         int j = 0;
 742         uiapplication_x *uiapp = NULL;
 743         serviceapplication_x *svcapp = NULL;
 744         for(j = 0; j < ncols; j++)
 745         {
 746                 if (strcmp(colname[j], "app_component") == 0) {
 747                         if (coltxt[j]) {
 748                                 if (strcmp(coltxt[j], "uiapp") == 0) {
 749                                         uiapp = calloc(1, sizeof(uiapplication_x));
 750                                         if (uiapp == NULL) {
 751                                                 _LOGE("Out of Memory!!!\n");
 752                                                 return -1;
 753                                         }
 754                                         LISTADD(info->manifest_info->uiapplication, uiapp);
 755                                         for(i = 0; i < ncols; i++)
 756                                         {
 757                                                 if (strcmp(colname[i], "app_id") == 0) {
 758                                                         if (coltxt[i])
 759                                                                 info->manifest_info->uiapplication->appid = strdup(coltxt[i]);
 760                                                         else
 761                                                                 info->manifest_info->uiapplication->appid = NULL;
 762                                                 } else if (strcmp(colname[i], "app_exec") == 0) {
 763                                                         if (coltxt[i])
 764                                                                 info->manifest_info->uiapplication->exec = strdup(coltxt[i]);
 765                                                         else
 766                                                                 info->manifest_info->uiapplication->exec = NULL;
 767                                                 } else if (strcmp(colname[i], "app_type") == 0 ){
 768                                                         if (coltxt[i])
 769                                                                 info->manifest_info->uiapplication->type = strdup(coltxt[i]);
 770                                                         else
 771                                                                 info->manifest_info->uiapplication->type = NULL;
 772                                                 } else if (strcmp(colname[i], "app_nodisplay") == 0 ){
 773                                                         if (coltxt[i])
 774                                                                 info->manifest_info->uiapplication->nodisplay = strdup(coltxt[i]);
 775                                                         else
 776                                                                 info->manifest_info->uiapplication->nodisplay = NULL;
 777                                                 } else if (strcmp(colname[i], "app_multiple") == 0 ){
 778                                                         if (coltxt[i])
 779                                                                 info->manifest_info->uiapplication->multiple = strdup(coltxt[i]);
 780                                                         else
 781                                                                 info->manifest_info->uiapplication->multiple = NULL;
 782                                                 } else if (strcmp(colname[i], "app_taskmanage") == 0 ){
 783                                                         if (coltxt[i])
 784                                                                 info->manifest_info->uiapplication->taskmanage = strdup(coltxt[i]);
 785                                                         else
 786                                                                 info->manifest_info->uiapplication->taskmanage = NULL;
 787                                                 } else if (strcmp(colname[i], "app_hwacceleration") == 0 ){
 788                                                         if (coltxt[i])
 789                                                                 info->manifest_info->uiapplication->hwacceleration = strdup(coltxt[i]);
 790                                                         else
 791                                                                 info->manifest_info->uiapplication->hwacceleration = NULL;
 792                                                 } else if (strcmp(colname[i], "app_indicatordisplay") == 0 ){
 793                                                         if (coltxt[i])
 794                                                                 info->manifest_info->uiapplication->indicatordisplay = strdup(coltxt[i]);
 795                                                         else
 796                                                                 info->manifest_info->uiapplication->indicatordisplay = NULL;
 797                                                 } else if (strcmp(colname[i], "app_portraitimg") == 0 ){
 798                                                         if (coltxt[i])
 799                                                                 info->manifest_info->uiapplication->portraitimg = strdup(coltxt[i]);
 800                                                         else
 801                                                                 info->manifest_info->uiapplication->portraitimg = NULL;
 802                                                 } else if (strcmp(colname[i], "app_landscapeimg") == 0 ){
 803                                                         if (coltxt[i])
 804                                                                 info->manifest_info->uiapplication->landscapeimg = strdup(coltxt[i]);
 805                                                         else
 806                                                                 info->manifest_info->uiapplication->landscapeimg = NULL;
 807                                                 } else if (strcmp(colname[i], "app_guestmodevisibility") == 0 ){
 808                                                         if (coltxt[i])
 809                                                                 info->manifest_info->uiapplication->guestmode_visibility = strdup(coltxt[i]);
 810                                                         else
 811                                                                 info->manifest_info->uiapplication->guestmode_visibility = NULL;
 812                                                 } else if (strcmp(colname[i], "package") == 0 ){
 813                                                         if (coltxt[i])
 814                                                                 info->manifest_info->uiapplication->package = strdup(coltxt[i]);
 815                                                         else
 816                                                                 info->manifest_info->uiapplication->package = NULL;
 817                                                 } else if (strcmp(colname[i], "app_icon") == 0) {
 818                                                         if (coltxt[i])
 819                                                                 info->manifest_info->uiapplication->icon->text = strdup(coltxt[i]);
 820                                                         else
 821                                                                 info->manifest_info->uiapplication->icon->text = NULL;
 822                                                 } else if (strcmp(colname[i], "app_label") == 0 ) {
 823                                                         if (coltxt[i])
 824                                                                 info->manifest_info->uiapplication->label->text = strdup(coltxt[i]);
 825                                                         else
 826                                                                 info->manifest_info->uiapplication->label->text = NULL;
 827                                                 } else if (strcmp(colname[i], "app_recentimage") == 0 ) {
 828                                                         if (coltxt[i])
 829                                                                 info->manifest_info->uiapplication->recentimage = strdup(coltxt[i]);
 830                                                         else
 831                                                                 info->manifest_info->uiapplication->recentimage = NULL;
 832                                                 } else if (strcmp(colname[i], "app_mainapp") == 0 ) {
 833                                                         if (coltxt[i])
 834                                                                 info->manifest_info->uiapplication->mainapp= strdup(coltxt[i]);
 835                                                         else
 836                                                                 info->manifest_info->uiapplication->mainapp = NULL;
 837                                                 } else if (strcmp(colname[i], "app_locale") == 0 ) {
 838                                                         if (coltxt[i]) {
 839                                                                 info->manifest_info->uiapplication->icon->lang = strdup(coltxt[i]);
 840                                                                 info->manifest_info->uiapplication->label->lang = strdup(coltxt[i]);
 841                                                         }
 842                                                         else {
 843                                                                 info->manifest_info->uiapplication->icon->lang = NULL;
 844                                                                 info->manifest_info->uiapplication->label->lang = NULL;
 845                                                         }
 846                                                 } else if (strcmp(colname[i], "app_permissiontype") == 0 ) {
 847                                                         if (coltxt[i])
 848                                                                 info->manifest_info->uiapplication->permission_type = strdup(coltxt[i]);
 849                                                         else
 850                                                                 info->manifest_info->uiapplication->permission_type = NULL;
 851                                                 } else
 852                                                         continue;
 853                                         }
 854                                 } else {
 855                                         svcapp = calloc(1, sizeof(serviceapplication_x));
 856                                         if (svcapp == NULL) {
 857                                                 _LOGE("Out of Memory!!!\n");
 858                                                 return -1;
 859                                         }
 860                                         LISTADD(info->manifest_info->serviceapplication, svcapp);
 861                                         for(i = 0; i < ncols; i++)
 862                                         {
 863                                                 if (strcmp(colname[i], "app_id") == 0) {
 864                                                         if (coltxt[i])
 865                                                                 info->manifest_info->serviceapplication->appid = strdup(coltxt[i]);
 866                                                         else
 867                                                                 info->manifest_info->serviceapplication->appid = NULL;
 868                                                 } else if (strcmp(colname[i], "app_exec") == 0) {
 869                                                         if (coltxt[i])
 870                                                                 info->manifest_info->serviceapplication->exec = strdup(coltxt[i]);
 871                                                         else
 872                                                                 info->manifest_info->serviceapplication->exec = NULL;
 873                                                 } else if (strcmp(colname[i], "app_type") == 0 ){
 874                                                         if (coltxt[i])
 875                                                                 info->manifest_info->serviceapplication->type = strdup(coltxt[i]);
 876                                                         else
 877                                                                 info->manifest_info->serviceapplication->type = NULL;
 878                                                 } else if (strcmp(colname[i], "app_onboot") == 0 ){
 879                                                         if (coltxt[i])
 880                                                                 info->manifest_info->serviceapplication->onboot = strdup(coltxt[i]);
 881                                                         else
 882                                                                 info->manifest_info->serviceapplication->onboot = NULL;
 883                                                 } else if (strcmp(colname[i], "app_autorestart") == 0 ){
 884                                                         if (coltxt[i])
 885                                                                 info->manifest_info->serviceapplication->autorestart = strdup(coltxt[i]);
 886                                                         else
 887                                                                 info->manifest_info->serviceapplication->autorestart = NULL;
 888                                                 } else if (strcmp(colname[i], "package") == 0 ){
 889                                                         if (coltxt[i])
 890                                                                 info->manifest_info->serviceapplication->package = strdup(coltxt[i]);
 891                                                         else
 892                                                                 info->manifest_info->serviceapplication->package = NULL;
 893                                                 } else if (strcmp(colname[i], "app_icon") == 0) {
 894                                                         if (coltxt[i])
 895                                                                 info->manifest_info->serviceapplication->icon->text = strdup(coltxt[i]);
 896                                                         else
 897                                                                 info->manifest_info->serviceapplication->icon->text = NULL;
 898                                                 } else if (strcmp(colname[i], "app_label") == 0 ) {
 899                                                         if (coltxt[i])
 900                                                                 info->manifest_info->serviceapplication->label->text = strdup(coltxt[i]);
 901                                                         else
 902                                                                 info->manifest_info->serviceapplication->label->text = NULL;
 903                                                 } else if (strcmp(colname[i], "app_locale") == 0 ) {
 904                                                         if (coltxt[i]) {
 905                                                                 info->manifest_info->serviceapplication->icon->lang = strdup(coltxt[i]);
 906                                                                 info->manifest_info->serviceapplication->label->lang = strdup(coltxt[i]);
 907                                                         }
 908                                                         else {
 909                                                                 info->manifest_info->serviceapplication->icon->lang = NULL;
 910                                                                 info->manifest_info->serviceapplication->label->lang = NULL;
 911                                                         }
 912                                                 } else if (strcmp(colname[i], "app_permissiontype") == 0 ) {
 913                                                         if (coltxt[i])
 914                                                                 info->manifest_info->serviceapplication->permission_type = strdup(coltxt[i]);
 915                                                         else
 916                                                                 info->manifest_info->serviceapplication->permission_type = NULL;
 917                                                 } else
 918                                                         continue;
 919                                         }
 920                                 }
 921                         }
 922                 } else
 923                         continue;
 924         }
 925
 926         return 0;
 927 }
 928
 929
 930
 931 static int __validate_cb(void *data, int ncols, char **coltxt, char **colname)
 932 {
 933         int *p = (int*)data;
 934         *p = atoi(coltxt[0]);
 935         return 0;
 936 }
 937
 938 static int __maxid_cb(void *data, int ncols, char **coltxt, char **colname)
 939 {
 940         int *p = (int*)data;
 941         if (coltxt[0])
 942                 *p = atoi(coltxt[0]);
 943         return 0;
 944 }
 945
 946 static int __pkginfo_cb(void *data, int ncols, char **coltxt, char **colname)
 947 {
 948         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)data;
 949         int i = 0;
 950         author_x *author = NULL;
 951         icon_x *icon = NULL;
 952         label_x *label = NULL;
 953         description_x *description = NULL;
 954         privilege_x *privilege = NULL;
 955
 956         author = calloc(1, sizeof(author_x));
 957         LISTADD(info->manifest_info->author, author);
 958         icon = calloc(1, sizeof(icon_x));
 959         LISTADD(info->manifest_info->icon, icon);
 960         label = calloc(1, sizeof(label_x));
 961         LISTADD(info->manifest_info->label, label);
 962         description = calloc(1, sizeof(description_x));
 963         LISTADD(info->manifest_info->description, description);
 964         privilege = calloc(1, sizeof(privilege_x));
 965         LISTADD(info->manifest_info->privileges->privilege, privilege);
 966         for(i = 0; i < ncols; i++)
 967         {
 968                 if (strcmp(colname[i], "package_version") == 0) {
 969                         if (coltxt[i])
 970                                 info->manifest_info->version = strdup(coltxt[i]);
 971                         else
 972                                 info->manifest_info->version = NULL;
 973                 } else if (strcmp(colname[i], "package_type") == 0) {
 974                         if (coltxt[i])
 975                                 info->manifest_info->type = strdup(coltxt[i]);
 976                         else
 977                                 info->manifest_info->type = NULL;
 978                 } else if (strcmp(colname[i], "install_location") == 0) {
 979                         if (coltxt[i])
 980                                 info->manifest_info->installlocation = strdup(coltxt[i]);
 981                         else
 982                                 info->manifest_info->installlocation = NULL;
 983                 } else if (strcmp(colname[i], "package_size") == 0) {
 984                         if (coltxt[i])
 985                                 info->manifest_info->package_size = strdup(coltxt[i]);
 986                         else
 987                                 info->manifest_info->package_size = NULL;
 988                 } else if (strcmp(colname[i], "author_email") == 0 ){
 989                         if (coltxt[i])
 990                                 info->manifest_info->author->email = strdup(coltxt[i]);
 991                         else
 992                                 info->manifest_info->author->email = NULL;
 993                 } else if (strcmp(colname[i], "author_href") == 0 ){
 994                         if (coltxt[i])
 995                                 info->manifest_info->author->href = strdup(coltxt[i]);
 996                         else
 997                                 info->manifest_info->author->href = NULL;
 998                 } else if (strcmp(colname[i], "package_label") == 0 ){
 999                         if (coltxt[i])
1000                                 info->manifest_info->label->text = strdup(coltxt[i]);
1001                         else
1002                                 info->manifest_info->label->text = NULL;
1003                 } else if (strcmp(colname[i], "package_icon") == 0 ){
1004                         if (coltxt[i])
1005                                 info->manifest_info->icon->text = strdup(coltxt[i]);
1006                         else
1007                                 info->manifest_info->icon->text = NULL;
1008                 } else if (strcmp(colname[i], "package_description") == 0 ){
1009                         if (coltxt[i])
1010                                 info->manifest_info->description->text = strdup(coltxt[i]);
1011                         else
1012                                 info->manifest_info->description->text = NULL;
1013                 } else if (strcmp(colname[i], "package_author") == 0 ){
1014                         if (coltxt[i])
1015                                 info->manifest_info->author->text = strdup(coltxt[i]);
1016                         else
1017                                 info->manifest_info->author->text = NULL;
1018                 } else if (strcmp(colname[i], "package_removable") == 0 ){
1019                         if (coltxt[i])
1020                                 info->manifest_info->removable = strdup(coltxt[i]);
1021                         else
1022                                 info->manifest_info->removable = NULL;
1023                 } else if (strcmp(colname[i], "package_preload") == 0 ){
1024                         if (coltxt[i])
1025                                 info->manifest_info->preload = strdup(coltxt[i]);
1026                         else
1027                                 info->manifest_info->preload = NULL;
1028                 } else if (strcmp(colname[i], "package_readonly") == 0 ){
1029                         if (coltxt[i])
1030                                 info->manifest_info->readonly = strdup(coltxt[i]);
1031                         else
1032                                 info->manifest_info->readonly = NULL;
1033                 } else if (strcmp(colname[i], "package_update") == 0 ){
1034                         if (coltxt[i])
1035                                 info->manifest_info->update= strdup(coltxt[i]);
1036                         else
1037                                 info->manifest_info->update = NULL;
1038                 } else if (strcmp(colname[i], "package_appsetting") == 0 ){
1039                         if (coltxt[i])
1040                                 info->manifest_info->appsetting = strdup(coltxt[i]);
1041                         else
1042                                 info->manifest_info->appsetting = NULL;
1043                 } else if (strcmp(colname[i], "installed_time") == 0 ){
1044                         if (coltxt[i])
1045                                 info->manifest_info->installed_time = strdup(coltxt[i]);
1046                         else
1047                                 info->manifest_info->installed_time = NULL;
1048                 } else if (strcmp(colname[i], "mainapp_id") == 0 ){
1049                         if (coltxt[i])
1050                                 info->manifest_info->mainapp_id = strdup(coltxt[i]);
1051                         else
1052                                 info->manifest_info->mainapp_id = NULL;
1053                 } else if (strcmp(colname[i], "root_path") == 0 ){
1054                         if (coltxt[i])
1055                                 info->manifest_info->root_path = strdup(coltxt[i]);
1056                         else
1057                                 info->manifest_info->root_path = NULL;
1058                 } else if (strcmp(colname[i], "privilege") == 0 ){
1059                         if (coltxt[i])
1060                                 info->manifest_info->privileges->privilege->text = strdup(coltxt[i]);
1061                         else
1062                                 info->manifest_info->privileges->privilege->text = NULL;
1063                 } else if (strcmp(colname[i], "package_locale") == 0 ){
1064                         if (coltxt[i]) {
1065                                 info->manifest_info->author->lang = strdup(coltxt[i]);
1066                                 info->manifest_info->icon->lang = strdup(coltxt[i]);
1067                                 info->manifest_info->label->lang = strdup(coltxt[i]);
1068                                 info->manifest_info->description->lang = strdup(coltxt[i]);
1069                         }
1070                         else {
1071                                 info->manifest_info->author->lang = NULL;
1072                                 info->manifest_info->icon->lang = NULL;
1073                                 info->manifest_info->label->lang = NULL;
1074                                 info->manifest_info->description->lang = NULL;
1075                         }
1076                 } else if (strcmp(colname[i], "package_url") == 0 ){
1077                         if (coltxt[i])
1078                                 info->manifest_info->package_url = strdup(coltxt[i]);
1079                         else
1080                                 info->manifest_info->package_url = NULL;
1081                 } else
1082                         continue;
1083         }
1084         return 0;
1085 }
1086
1087
1088 static pkgmgrinfo_app_component __appcomponent_convert(const char *comp)
1089 {
1090         if ( strcasecmp(comp, "uiapp") == 0)
1091                 return PMINFO_UI_APP;
1092         else if ( strcasecmp(comp, "svcapp") == 0)
1093                 return PMINFO_SVC_APP;
1094         else
1095                 return -1;
1096 }
1097
1098 static int __certindexinfo_cb(void *data, int ncols, char **coltxt, char **colname)
1099 {
1100         pkgmgr_certindexinfo_x *info = (pkgmgr_certindexinfo_x *)data;
1101         int i = 0;
1102         for(i = 0; i < ncols; i++) {
1103                 if (strcmp(colname[i], "cert_id") == 0) {
1104                         if (coltxt[i])
1105                                 info->cert_id = atoi(coltxt[i]);
1106                         else
1107                                 info->cert_id = 0;
1108                 } else if (strcmp(colname[i], "cert_ref_count") == 0) {
1109                         if (coltxt[i])
1110                                 info->cert_ref_count = atoi(coltxt[i]);
1111                         else
1112                                 info->cert_ref_count = 0;
1113                 } else
1114                         continue;
1115         }
1116         return 0;
1117 }
1118 static int __certinfo_cb(void *data, int ncols, char **coltxt, char **colname)
1119 {
1120         pkgmgr_certinfo_x *info = (pkgmgr_certinfo_x *)data;
1121         int i = 0;
1122         for(i = 0; i < ncols; i++)
1123         {
1124                 if (strcmp(colname[i], "package") == 0) {
1125                         if (coltxt[i])
1126                                 info->pkgid = strdup(coltxt[i]);
1127                         else
1128                                 info->pkgid = NULL;
1129                 } else if (strcmp(colname[i], "author_signer_cert") == 0) {
1130                         if (coltxt[i])
1131                                 (info->cert_id)[PMINFO_AUTHOR_SIGNER_CERT] = atoi(coltxt[i]);
1132                         else
1133                                 (info->cert_id)[PMINFO_AUTHOR_SIGNER_CERT] = 0;
1134                 } else if (strcmp(colname[i], "author_im_cert") == 0) {
1135                         if (coltxt[i])
1136                                 (info->cert_id)[PMINFO_AUTHOR_INTERMEDIATE_CERT] = atoi(coltxt[i]);
1137                         else
1138                                 (info->cert_id)[PMINFO_AUTHOR_INTERMEDIATE_CERT] = 0;
1139                 } else if (strcmp(colname[i], "author_root_cert") == 0) {
1140                         if (coltxt[i])
1141                                 (info->cert_id)[PMINFO_AUTHOR_ROOT_CERT] = atoi(coltxt[i]);
1142                         else
1143                                 (info->cert_id)[PMINFO_AUTHOR_ROOT_CERT] = 0;
1144                 } else if (strcmp(colname[i], "dist_signer_cert") == 0 ){
1145                         if (coltxt[i])
1146                                 (info->cert_id)[PMINFO_DISTRIBUTOR_SIGNER_CERT] = atoi(coltxt[i]);
1147                         else
1148                                 (info->cert_id)[PMINFO_DISTRIBUTOR_SIGNER_CERT] = 0;
1149                 } else if (strcmp(colname[i], "dist_im_cert") == 0 ){
1150                         if (coltxt[i])
1151                                 (info->cert_id)[PMINFO_DISTRIBUTOR_INTERMEDIATE_CERT] = atoi(coltxt[i]);
1152                         else
1153                                 (info->cert_id)[PMINFO_DISTRIBUTOR_INTERMEDIATE_CERT] = 0;
1154                 } else if (strcmp(colname[i], "dist_root_cert") == 0 ){
1155                         if (coltxt[i])
1156                                 (info->cert_id)[PMINFO_DISTRIBUTOR_ROOT_CERT] = atoi(coltxt[i]);
1157                         else
1158                                 (info->cert_id)[PMINFO_DISTRIBUTOR_ROOT_CERT] = 0;
1159                 } else if (strcmp(colname[i], "dist2_signer_cert") == 0 ){
1160                         if (coltxt[i])
1161                                 (info->cert_id)[PMINFO_DISTRIBUTOR2_SIGNER_CERT] = atoi(coltxt[i]);
1162                         else
1163                                 (info->cert_id)[PMINFO_DISTRIBUTOR2_SIGNER_CERT] = 0;
1164                 } else if (strcmp(colname[i], "dist2_im_cert") == 0 ){
1165                         if (coltxt[i])
1166                                 (info->cert_id)[PMINFO_DISTRIBUTOR2_INTERMEDIATE_CERT] = atoi(coltxt[i]);
1167                         else
1168                                 (info->cert_id)[PMINFO_DISTRIBUTOR2_INTERMEDIATE_CERT] = 0;
1169                 } else if (strcmp(colname[i], "dist2_root_cert") == 0 ){
1170                         if (coltxt[i])
1171                                 (info->cert_id)[PMINFO_DISTRIBUTOR2_ROOT_CERT] = atoi(coltxt[i]);
1172                         else
1173                                 (info->cert_id)[PMINFO_DISTRIBUTOR2_ROOT_CERT] = 0;
1174                 } else if (strcmp(colname[i], "cert_info") == 0 ){
1175                         if (coltxt[i])
1176                                 info->cert_value = strdup(coltxt[i]);
1177                         else
1178                                 info->cert_value = NULL;
1179                 } else
1180                         continue;
1181         }
1182         return 0;
1183 }
1184
1185 static int __mini_appinfo_cb(void *data, int ncols, char **coltxt, char **colname)
1186 {
1187         pkgmgr_appinfo_x *info = (pkgmgr_appinfo_x *)data;
1188         int i = 0;
1189         uiapplication_x *uiapp = NULL;
1190         uiapp = calloc(1, sizeof(uiapplication_x));
1191         if (uiapp == NULL) {
1192                 _LOGE("Out of Memory!!!\n");
1193                 return -1;
1194         }
1195
1196         LISTADD(info->uiapp_info, uiapp);
1197
1198         for(i = 0; i < ncols; i++)
1199         {
1200                 if (strcmp(colname[i], "app_id") == 0) {
1201                         /*appid being foreign key, is column in every table
1202                         Hence appid gets strduped every time leading to memory leak.
1203                         If appid is already set, just continue.*/
1204                         if (info->uiapp_info->appid)
1205                                 continue;
1206                         if (coltxt[i])
1207                                 info->uiapp_info->appid = strdup(coltxt[i]);
1208                         else
1209                                 info->uiapp_info->appid = NULL;
1210                 } else if (strcmp(colname[i], "app_exec") == 0) {
1211                         if (coltxt[i])
1212                                 info->uiapp_info->exec = strdup(coltxt[i]);
1213                         else
1214                                 info->uiapp_info->exec = NULL;
1215                 } else if (strcmp(colname[i], "app_nodisplay") == 0) {
1216                         if (coltxt[i])
1217                                 info->uiapp_info->nodisplay = strdup(coltxt[i]);
1218                         else
1219                                 info->uiapp_info->nodisplay = NULL;
1220                 } else if (strcmp(colname[i], "app_type") == 0 ) {
1221                         if (coltxt[i])
1222                                 info->uiapp_info->type = strdup(coltxt[i]);
1223                         else
1224                                 info->uiapp_info->type = NULL;
1225                 } else if (strcmp(colname[i], "app_multiple") == 0 ) {
1226                         if (coltxt[i])
1227                                 info->uiapp_info->multiple = strdup(coltxt[i]);
1228                         else
1229                                 info->uiapp_info->multiple = NULL;
1230                 } else if (strcmp(colname[i], "app_taskmanage") == 0 ) {
1231                         if (coltxt[i])
1232                                 info->uiapp_info->taskmanage = strdup(coltxt[i]);
1233                         else
1234                                 info->uiapp_info->taskmanage = NULL;
1235                 } else if (strcmp(colname[i], "app_hwacceleration") == 0 ) {
1236                         if (coltxt[i])
1237                                 info->uiapp_info->hwacceleration = strdup(coltxt[i]);
1238                         else
1239                                 info->uiapp_info->hwacceleration = NULL;
1240                 } else if (strcmp(colname[i], "app_enabled") == 0 ) {
1241                         if (coltxt[i])
1242                                 info->uiapp_info->enabled= strdup(coltxt[i]);
1243                         else
1244                                 info->uiapp_info->enabled = NULL;
1245                 } else if (strcmp(colname[i], "app_indicatordisplay") == 0){
1246                         if (coltxt[i])
1247                                 info->uiapp_info->indicatordisplay = strdup(coltxt[i]);
1248                         else
1249                                 info->uiapp_info->indicatordisplay = NULL;
1250                 } else if (strcmp(colname[i], "app_portraitimg") == 0){
1251                         if (coltxt[i])
1252                                 info->uiapp_info->portraitimg = strdup(coltxt[i]);
1253                         else
1254                                 info->uiapp_info->portraitimg = NULL;
1255                 } else if (strcmp(colname[i], "app_landscapeimg") == 0){
1256                         if (coltxt[i])
1257                                 info->uiapp_info->landscapeimg = strdup(coltxt[i]);
1258                         else
1259                                 info->uiapp_info->landscapeimg = NULL;
1260                 } else if (strcmp(colname[i], "app_guestmodevisibility") == 0){
1261                         if (coltxt[i])
1262                                 info->uiapp_info->guestmode_visibility = strdup(coltxt[i]);
1263                         else
1264                                 info->uiapp_info->guestmode_visibility = NULL;
1265                 } else if (strcmp(colname[i], "app_recentimage") == 0 ) {
1266                         if (coltxt[i])
1267                                 info->uiapp_info->recentimage = strdup(coltxt[i]);
1268                         else
1269                                 info->uiapp_info->recentimage = NULL;
1270                 } else if (strcmp(colname[i], "app_mainapp") == 0 ) {
1271                         if (coltxt[i])
1272                                 info->uiapp_info->mainapp = strdup(coltxt[i]);
1273                         else
1274                                 info->uiapp_info->mainapp = NULL;
1275                 } else if (strcmp(colname[i], "package") == 0 ) {
1276                         if (coltxt[i])
1277                                 info->uiapp_info->package = strdup(coltxt[i]);
1278                         else
1279                                 info->uiapp_info->package = NULL;
1280                 } else if (strcmp(colname[i], "app_component") == 0) {
1281                         if (coltxt[i])
1282                                 info->uiapp_info->app_component = strdup(coltxt[i]);
1283                         else
1284                                 info->uiapp_info->app_component = NULL;
1285                 } else if (strcmp(colname[i], "app_permissiontype") == 0 ) {
1286                         if (coltxt[i])
1287                                 info->uiapp_info->permission_type = strdup(coltxt[i]);
1288                         else
1289                                 info->uiapp_info->permission_type = NULL;
1290                 } else
1291                         continue;
1292         }
1293
1294         return 0;
1295 }
1296
1297 static int __appinfo_cb(void *data, int ncols, char **coltxt, char **colname)
1298 {
1299         pkgmgr_appinfo_x *info = (pkgmgr_appinfo_x *)data;
1300         int i = 0;
1301         icon_x *icon = NULL;
1302         label_x *label = NULL;
1303         category_x *category = NULL;
1304         metadata_x *metadata = NULL;
1305         permission_x *permission = NULL;
1306         image_x *image = NULL;
1307
1308         switch (info->app_component) {
1309         case PMINFO_UI_APP:
1310                 icon = calloc(1, sizeof(icon_x));
1311                 LISTADD(info->uiapp_info->icon, icon);
1312                 label = calloc(1, sizeof(label_x));
1313                 LISTADD(info->uiapp_info->label, label);
1314                 category = calloc(1, sizeof(category_x));
1315                 LISTADD(info->uiapp_info->category, category);
1316                 metadata = calloc(1, sizeof(metadata_x));
1317                 LISTADD(info->uiapp_info->metadata, metadata);
1318                 permission = calloc(1, sizeof(permission_x));
1319                 LISTADD(info->uiapp_info->permission, permission);
1320                 image = calloc(1, sizeof(image_x));
1321                 LISTADD(info->uiapp_info->image, image);
1322
1323                 for(i = 0; i < ncols; i++)
1324                 {
1325                         if (strcmp(colname[i], "app_id") == 0) {
1326                                 /*appid being foreign key, is column in every table
1327                                 Hence appid gets strduped every time leading to memory leak.
1328                                 If appid is already set, just continue.*/
1329                                 if (info->uiapp_info->appid)
1330                                         continue;
1331                                 if (coltxt[i])
1332                                         info->uiapp_info->appid = strdup(coltxt[i]);
1333                                 else
1334                                         info->uiapp_info->appid = NULL;
1335                         } else if (strcmp(colname[i], "app_exec") == 0) {
1336                                 if (coltxt[i])
1337                                         info->uiapp_info->exec = strdup(coltxt[i]);
1338                                 else
1339                                         info->uiapp_info->exec = NULL;
1340                         } else if (strcmp(colname[i], "app_nodisplay") == 0) {
1341                                 if (coltxt[i])
1342                                         info->uiapp_info->nodisplay = strdup(coltxt[i]);
1343                                 else
1344                                         info->uiapp_info->nodisplay = NULL;
1345                         } else if (strcmp(colname[i], "app_type") == 0 ) {
1346                                 if (coltxt[i])
1347                                         info->uiapp_info->type = strdup(coltxt[i]);
1348                                 else
1349                                         info->uiapp_info->type = NULL;
1350                         } else if (strcmp(colname[i], "app_icon_section") == 0 ) {
1351                                 if (coltxt[i])
1352                                         info->uiapp_info->icon->section= strdup(coltxt[i]);
1353                                 else
1354                                         info->uiapp_info->icon->section = NULL;
1355                         } else if (strcmp(colname[i], "app_icon") == 0) {
1356                                 if (coltxt[i])
1357                                         info->uiapp_info->icon->text = strdup(coltxt[i]);
1358                                 else
1359                                         info->uiapp_info->icon->text = NULL;
1360                         } else if (strcmp(colname[i], "app_label") == 0 ) {
1361                                 if (coltxt[i])
1362                                         info->uiapp_info->label->text = strdup(coltxt[i]);
1363                                 else
1364                                         info->uiapp_info->label->text = NULL;
1365                         } else if (strcmp(colname[i], "app_multiple") == 0 ) {
1366                                 if (coltxt[i])
1367                                         info->uiapp_info->multiple = strdup(coltxt[i]);
1368                                 else
1369                                         info->uiapp_info->multiple = NULL;
1370                         } else if (strcmp(colname[i], "app_taskmanage") == 0 ) {
1371                                 if (coltxt[i])
1372                                         info->uiapp_info->taskmanage = strdup(coltxt[i]);
1373                                 else
1374                                         info->uiapp_info->taskmanage = NULL;
1375                         } else if (strcmp(colname[i], "app_hwacceleration") == 0 ) {
1376                                 if (coltxt[i])
1377                                         info->uiapp_info->hwacceleration = strdup(coltxt[i]);
1378                                 else
1379                                         info->uiapp_info->hwacceleration = NULL;
1380                         } else if (strcmp(colname[i], "app_enabled") == 0 ) {
1381                                 if (coltxt[i])
1382                                         info->uiapp_info->enabled= strdup(coltxt[i]);
1383                                 else
1384                                         info->uiapp_info->enabled = NULL;
1385                         } else if (strcmp(colname[i], "app_indicatordisplay") == 0){
1386                                 if (coltxt[i])
1387                                         info->uiapp_info->indicatordisplay = strdup(coltxt[i]);
1388                                 else
1389                                         info->uiapp_info->indicatordisplay = NULL;
1390                         } else if (strcmp(colname[i], "app_portraitimg") == 0){
1391                                 if (coltxt[i])
1392                                         info->uiapp_info->portraitimg = strdup(coltxt[i]);
1393                                 else
1394                                         info->uiapp_info->portraitimg = NULL;
1395                         } else if (strcmp(colname[i], "app_landscapeimg") == 0){
1396                                 if (coltxt[i])
1397                                         info->uiapp_info->landscapeimg = strdup(coltxt[i]);
1398                                 else
1399                                         info->uiapp_info->landscapeimg = NULL;
1400                         } else if (strcmp(colname[i], "app_guestmodevisibility") == 0){
1401                                 if (coltxt[i])
1402                                         info->uiapp_info->guestmode_visibility = strdup(coltxt[i]);
1403                                 else
1404                                         info->uiapp_info->guestmode_visibility = NULL;
1405                         } else if (strcmp(colname[i], "category") == 0 ) {
1406                                 if (coltxt[i])
1407                                         info->uiapp_info->category->name = strdup(coltxt[i]);
1408                                 else
1409                                         info->uiapp_info->category->name = NULL;
1410                         } else if (strcmp(colname[i], "md_key") == 0 ) {
1411                                 if (coltxt[i])
1412                                         info->uiapp_info->metadata->key = strdup(coltxt[i]);
1413                                 else
1414                                         info->uiapp_info->metadata->key = NULL;
1415                         } else if (strcmp(colname[i], "md_value") == 0 ) {
1416                                 if (coltxt[i])
1417                                         info->uiapp_info->metadata->value = strdup(coltxt[i]);
1418                                 else
1419                                         info->uiapp_info->metadata->value = NULL;
1420                         } else if (strcmp(colname[i], "pm_type") == 0 ) {
1421                                 if (coltxt[i])
1422                                         info->uiapp_info->permission->type= strdup(coltxt[i]);
1423                                 else
1424                                         info->uiapp_info->permission->type = NULL;
1425                         } else if (strcmp(colname[i], "pm_value") == 0 ) {
1426                                 if (coltxt[i])
1427                                         info->uiapp_info->permission->value = strdup(coltxt[i]);
1428                                 else
1429                                         info->uiapp_info->permission->value = NULL;
1430                         } else if (strcmp(colname[i], "app_recentimage") == 0 ) {
1431                                 if (coltxt[i])
1432                                         info->uiapp_info->recentimage = strdup(coltxt[i]);
1433                                 else
1434                                         info->uiapp_info->recentimage = NULL;
1435                         } else if (strcmp(colname[i], "app_mainapp") == 0 ) {
1436                                 if (coltxt[i])
1437                                         info->uiapp_info->mainapp = strdup(coltxt[i]);
1438                                 else
1439                                         info->uiapp_info->mainapp = NULL;
1440                         } else if (strcmp(colname[i], "app_locale") == 0 ) {
1441                                 if (coltxt[i]) {
1442                                         info->uiapp_info->icon->lang = strdup(coltxt[i]);
1443                                         info->uiapp_info->label->lang = strdup(coltxt[i]);
1444                                 }
1445                                 else {
1446                                         info->uiapp_info->icon->lang = NULL;
1447                                         info->uiapp_info->label->lang = NULL;
1448                                 }
1449                         } else if (strcmp(colname[i], "app_image") == 0) {
1450                                         if (coltxt[i])
1451                                                 info->uiapp_info->image->text= strdup(coltxt[i]);
1452                                         else
1453                                                 info->uiapp_info->image->text = NULL;
1454                         } else if (strcmp(colname[i], "app_image_section") == 0) {
1455                                         if (coltxt[i])
1456                                                 info->uiapp_info->image->section= strdup(coltxt[i]);
1457                                         else
1458                                                 info->uiapp_info->image->section = NULL;
1459                         } else if (strcmp(colname[i], "app_permissiontype") == 0 ) {
1460                                 if (coltxt[i])
1461                                         info->uiapp_info->permission_type = strdup(coltxt[i]);
1462                                 else
1463                                         info->uiapp_info->permission_type = NULL;
1464                         } else
1465                                 continue;
1466                 }
1467                 break;
1468         case PMINFO_SVC_APP:
1469                 icon = calloc(1, sizeof(icon_x));
1470                 LISTADD(info->svcapp_info->icon, icon);
1471                 label = calloc(1, sizeof(label_x));
1472                 LISTADD(info->svcapp_info->label, label);
1473                 category = calloc(1, sizeof(category_x));
1474                 LISTADD(info->svcapp_info->category, category);
1475                 metadata = calloc(1, sizeof(metadata_x));
1476                 LISTADD(info->svcapp_info->metadata, metadata);
1477                 permission = calloc(1, sizeof(permission_x));
1478                 LISTADD(info->svcapp_info->permission, permission);
1479                 for(i = 0; i < ncols; i++)
1480                 {
1481                         if (strcmp(colname[i], "app_id") == 0) {
1482                                 /*appid being foreign key, is column in every table
1483                                 Hence appid gets strduped every time leading to memory leak.
1484                                 If appid is already set, just continue.*/
1485                                 if (info->svcapp_info->appid)
1486                                         continue;
1487                                 if (coltxt[i])
1488                                         info->svcapp_info->appid = strdup(coltxt[i]);
1489                                 else
1490                                         info->svcapp_info->appid = NULL;
1491                         } else if (strcmp(colname[i], "app_exec") == 0) {
1492                                 if (coltxt[i])
1493                                         info->svcapp_info->exec = strdup(coltxt[i]);
1494                                 else
1495                                         info->svcapp_info->exec = NULL;
1496                         } else if (strcmp(colname[i], "app_icon") == 0) {
1497                                 if (coltxt[i])
1498                                         info->svcapp_info->icon->text = strdup(coltxt[i]);
1499                                 else
1500                                         info->svcapp_info->icon->text = NULL;
1501                         } else if (strcmp(colname[i], "app_label") == 0 ) {
1502                                 if (coltxt[i])
1503                                         info->svcapp_info->label->text = strdup(coltxt[i]);
1504                                 else
1505                                         info->svcapp_info->label->text = NULL;
1506                         } else if (strcmp(colname[i], "app_type") == 0 ) {
1507                                 if (coltxt[i])
1508                                         info->svcapp_info->type = strdup(coltxt[i]);
1509                                 else
1510                                         info->svcapp_info->type = NULL;
1511                         } else if (strcmp(colname[i], "app_onboot") == 0 ) {
1512                                 if (coltxt[i])
1513                                         info->svcapp_info->onboot = strdup(coltxt[i]);
1514                                 else
1515                                         info->svcapp_info->onboot = NULL;
1516                         } else if (strcmp(colname[i], "app_autorestart") == 0 ) {
1517                                 if (coltxt[i])
1518                                         info->svcapp_info->autorestart = strdup(coltxt[i]);
1519                                 else
1520                                         info->svcapp_info->autorestart = NULL;
1521                         } else if (strcmp(colname[i], "app_enabled") == 0 ) {
1522                                 if (coltxt[i])
1523                                         info->svcapp_info->enabled= strdup(coltxt[i]);
1524                                 else
1525                                         info->svcapp_info->enabled = NULL;
1526                         } else if (strcmp(colname[i], "category") == 0 ) {
1527                                 if (coltxt[i])
1528                                         info->svcapp_info->category->name = strdup(coltxt[i]);
1529                                 else
1530                                         info->svcapp_info->category->name = NULL;
1531                         } else if (strcmp(colname[i], "md_key") == 0 ) {
1532                                 if (coltxt[i])
1533                                         info->svcapp_info->metadata->key = strdup(coltxt[i]);
1534                                 else
1535                                         info->svcapp_info->metadata->key = NULL;
1536                         } else if (strcmp(colname[i], "md_value") == 0 ) {
1537                                 if (coltxt[i])
1538                                         info->svcapp_info->metadata->value = strdup(coltxt[i]);
1539                                 else
1540                                         info->svcapp_info->metadata->value = NULL;
1541                         } else if (strcmp(colname[i], "pm_type") == 0 ) {
1542                                 if (coltxt[i])
1543                                         info->svcapp_info->permission->type= strdup(coltxt[i]);
1544                                 else
1545                                         info->svcapp_info->permission->type = NULL;
1546                         } else if (strcmp(colname[i], "pm_value") == 0 ) {
1547                                 if (coltxt[i])
1548                                         info->svcapp_info->permission->value = strdup(coltxt[i]);
1549                                 else
1550                                         info->svcapp_info->permission->value = NULL;
1551                         } else if (strcmp(colname[i], "app_locale") == 0 ) {
1552                                 if (coltxt[i]) {
1553                                         info->svcapp_info->icon->lang = strdup(coltxt[i]);
1554                                         info->svcapp_info->label->lang = strdup(coltxt[i]);
1555                                 }
1556                                 else {
1557                                         info->svcapp_info->icon->lang = NULL;
1558                                         info->svcapp_info->label->lang = NULL;
1559                                 }
1560                         } else if (strcmp(colname[i], "app_permissiontype") == 0 ) {
1561                                 if (coltxt[i])
1562                                         info->svcapp_info->permission_type = strdup(coltxt[i]);
1563                                 else
1564                                         info->svcapp_info->permission_type = NULL;
1565                         } else
1566                                 continue;
1567                 }
1568                 break;
1569         default:
1570                 break;
1571         }
1572
1573         return 0;
1574 }
1575
1576
1577 static int __appcomponent_cb(void *data, int ncols, char **coltxt, char **colname)
1578 {
1579         pkgmgr_appinfo_x *info = (pkgmgr_appinfo_x *)data;
1580         int i = 0;
1581         for(i = 0; i < ncols; i++)
1582         {
1583                 if (strcmp(colname[i], "app_component") == 0) {
1584                         info->app_component = __appcomponent_convert(coltxt[i]);
1585                 } else if (strcmp(colname[i], "package") == 0) {
1586                         info->package = strdup(coltxt[i]);
1587                 }
1588         }
1589
1590         return 0;
1591 }
1592
1593 static int __datacontrol_cb(void *data, int ncols, char **coltxt, char **colname)
1594 {
1595         pkgmgr_datacontrol_x *info = (pkgmgr_datacontrol_x *)data;
1596         int i = 0;
1597         for(i = 0; i < ncols; i++)
1598         {
1599                 if (strcmp(colname[i], "PACKAGE_NAME") == 0) {
1600                         if (coltxt[i])
1601                                 info->appid = strdup(coltxt[i]);
1602                         else
1603                                 info->appid = NULL;
1604                 } else if (strcmp(colname[i], "ACCESS") == 0 ){
1605                         if (coltxt[i])
1606                                 info->access = strdup(coltxt[i]);
1607                         else
1608                                 info->access = NULL;
1609                 } else
1610                         continue;
1611         }
1612         return 0;
1613 }
1614
1615 static int __cert_cb(void *data, int ncols, char **coltxt, char **colname)
1616 {
1617         pkgmgr_cert_x *info = (pkgmgr_cert_x *)data;
1618         int i = 0;
1619
1620         for(i = 0; i < ncols; i++)
1621         {
1622                 if (strcmp(colname[i], "author_signer_cert") == 0) {
1623                         if (coltxt[i])
1624                                 info->cert_id = atoi(coltxt[i]);
1625                         else
1626                                 info->cert_id = 0;
1627                 } else if (strcmp(colname[i], "package") == 0) {
1628                         if (coltxt[i])
1629                                 info->pkgid= strdup(coltxt[i]);
1630                         else
1631                                 info->pkgid = NULL;
1632                 } else
1633                         continue;
1634         }
1635         return 0;
1636 }
1637
1638 /* get the first locale value*/
1639 static int __fallback_locale_cb(void *data, int ncols, char **coltxt, char **colname)
1640 {
1641         pkgmgr_locale_x *info = (pkgmgr_locale_x *)data;
1642
1643         if (ncols >= 1)
1644                 info->locale = strdup(coltxt[0]);
1645         else
1646                 info->locale = NULL;
1647
1648         return 0;
1649 }
1650
1651 static int __exec_pkginfo_query(char *query, void *data)
1652 {
1653         char *error_message = NULL;
1654         if (SQLITE_OK !=
1655             sqlite3_exec(manifest_db, query, __pkginfo_cb, data, &error_message)) {
1656                 _LOGE("Don't execute query = %s error message = %s\n", query,
1657                        error_message);
1658                 sqlite3_free(error_message);
1659                 return -1;
1660         }
1661         sqlite3_free(error_message);
1662         return 0;
1663 }
1664
1665 static int __exec_certinfo_query(char *query, void *data)
1666 {
1667         char *error_message = NULL;
1668         if (SQLITE_OK !=
1669             sqlite3_exec(cert_db, query, __certinfo_cb, data, &error_message)) {
1670                 _LOGE("Don't execute query = %s error message = %s\n", query,
1671                        error_message);
1672                 sqlite3_free(error_message);
1673                 return -1;
1674         }
1675         sqlite3_free(error_message);
1676         return 0;
1677 }
1678
1679 static int __exec_certindexinfo_query(char *query, void *data)
1680 {
1681         char *error_message = NULL;
1682         if (SQLITE_OK !=
1683             sqlite3_exec(cert_db, query, __certindexinfo_cb, data, &error_message)) {
1684                 _LOGE("Don't execute query = %s error message = %s\n", query,
1685                        error_message);
1686                 sqlite3_free(error_message);
1687                 return -1;
1688         }
1689         sqlite3_free(error_message);
1690         return 0;
1691 }
1692
1693 static int __exec_db_query(sqlite3 *db, char *query, sqlite_query_callback callback, void *data)
1694 {
1695         char *error_message = NULL;
1696         if (SQLITE_OK !=
1697             sqlite3_exec(db, query, callback, data, &error_message)) {
1698                 _LOGE("Don't execute query = %s error message = %s\n", query,
1699                        error_message);
1700                 sqlite3_free(error_message);
1701                 return -1;
1702         }
1703         sqlite3_free(error_message);
1704         return 0;
1705 }
1706
1707
1708 static int __child_element(xmlTextReaderPtr reader, int depth)
1709 {
1710         int ret = xmlTextReaderRead(reader);
1711         int cur = xmlTextReaderDepth(reader);
1712         while (ret == 1) {
1713
1714                 switch (xmlTextReaderNodeType(reader)) {
1715                 case XML_READER_TYPE_ELEMENT:
1716                         if (cur == depth + 1)
1717                                 return 1;
1718                         break;
1719                 case XML_READER_TYPE_TEXT:
1720                         /*text is handled by each function separately*/
1721                         if (cur == depth + 1)
1722                                 return 0;
1723                         break;
1724                 case XML_READER_TYPE_END_ELEMENT:
1725                         if (cur == depth)
1726                                 return 0;
1727                         break;
1728                 default:
1729                         if (cur <= depth)
1730                                 return 0;
1731                         break;
1732                 }
1733                 ret = xmlTextReaderRead(reader);
1734                 cur = xmlTextReaderDepth(reader);
1735         }
1736         return ret;
1737 }
1738
1739 static int __check_validation_of_qurey_cb(void *data, int ncols, char **coltxt, char **colname)
1740 {
1741         int *p = (int*)data;
1742         *p = atoi(coltxt[0]);
1743         return 0;
1744 }
1745
1746 static int __check_app_locale_from_app_localized_info_by_exact(sqlite3 *db, const char *appid, const char *locale)
1747 {
1748         int result_query = -1;
1749         int ret = 0;
1750         char query[MAX_QUERY_LEN];
1751
1752         snprintf(query, MAX_QUERY_LEN, "select exists(select app_locale from package_app_localized_info where app_id='%s' and app_locale='%s')", appid, locale);
1753         ret = __exec_db_query(db, query, __check_validation_of_qurey_cb, (void *)&result_query);
1754         retvm_if(ret == -1, PMINFO_R_ERROR, "Exec DB query failed");
1755         return result_query;
1756 }
1757
1758 static int __check_app_locale_from_app_localized_info_by_fallback(sqlite3 *db, const char *appid, const char *locale)
1759 {
1760         int result_query = -1;
1761         int ret = 0;
1762         char wildcard[2] = {'%','\0'};
1763         char query[MAX_QUERY_LEN];
1764         char lang[3] = {'\0'};
1765         strncpy(lang, locale, LANGUAGE_LENGTH);
1766
1767         snprintf(query, MAX_QUERY_LEN, "select exists(select app_locale from package_app_localized_info where app_id='%s' and app_locale like '%s%s')", appid, lang, wildcard);
1768         ret = __exec_db_query(db, query, __check_validation_of_qurey_cb, (void *)&result_query);
1769         retvm_if(ret == -1, PMINFO_R_ERROR, "Exec DB query failed");
1770         return result_query;
1771 }
1772
1773 static char* __get_app_locale_from_app_localized_info_by_fallback(sqlite3 *db, const char *appid, const char *locale)
1774 {
1775         int ret = 0;
1776         char wildcard[2] = {'%','\0'};
1777         char lang[3] = {'\0'};
1778         char query[MAX_QUERY_LEN];
1779         char *locale_new = NULL;
1780         pkgmgr_locale_x *info = NULL;
1781
1782         info = (pkgmgr_locale_x *)malloc(sizeof(pkgmgr_locale_x));
1783         if (info == NULL) {
1784                 _LOGE("Out of Memory!!!\n");
1785                 return NULL;
1786         }
1787         memset(info, '\0', sizeof(*info));
1788
1789         strncpy(lang, locale, 2);
1790         snprintf(query, MAX_QUERY_LEN, "select app_locale from package_app_localized_info where app_id='%s' and app_locale like '%s%s'", appid, lang, wildcard);
1791         ret = __exec_db_query(db, query, __fallback_locale_cb, (void *)info);
1792         tryvm_if(ret == -1, PMINFO_R_ERROR, "Exec DB query failed");
1793         locale_new = info->locale;
1794         free(info);
1795         return locale_new;
1796 catch:
1797         if (info) {
1798                 free(info);
1799                 info = NULL;
1800         }
1801         return NULL;
1802 }
1803
1804 static char* __convert_syslocale_to_manifest_locale(char *syslocale)
1805 {
1806         char *locale = malloc(6);
1807         if (!locale) {
1808                 _LOGE("Malloc Failed\n");
1809                 return NULL;
1810         }
1811
1812         sprintf(locale, "%c%c-%c%c", syslocale[0], syslocale[1], tolower(syslocale[3]), tolower(syslocale[4]));
1813         return locale;
1814 }
1815
1816 static char* __get_app_locale_by_fallback(sqlite3 *db, const char *appid, const char *syslocale)
1817 {
1818         assert(appid);
1819         assert(syslocale);
1820
1821         char *locale = NULL;
1822         char *locale_new = NULL;
1823         int check_result = 0;
1824
1825         locale = __convert_syslocale_to_manifest_locale((char *)syslocale);
1826
1827         /*check exact matching */
1828         check_result = __check_app_locale_from_app_localized_info_by_exact(db, appid, locale);
1829
1830         /* Exact found */
1831         if (check_result == 1) {
1832                 _LOGD("%s find exact locale(%s)\n", appid, locale);
1833                 return locale;
1834         }
1835
1836         /* fallback matching */
1837         check_result = __check_app_locale_from_app_localized_info_by_fallback(db, appid, locale);
1838         if(check_result == 1) {
1839                    locale_new = __get_app_locale_from_app_localized_info_by_fallback(db, appid, locale);
1840                    _LOGD("%s found (%s) language-locale in DB by fallback!\n", appid, locale_new);
1841                    free(locale);
1842                    if (locale_new == NULL)
1843                            locale_new =  strdup(DEFAULT_LOCALE);
1844                    return locale_new;
1845         }
1846
1847         /* default locale */
1848         free(locale);
1849         _LOGD("%s DEFAULT_LOCALE)\n", appid);
1850         return  strdup(DEFAULT_LOCALE);
1851 }
1852
1853 long long _pkgmgr_calculate_dir_size(char *dirname)
1854 {
1855         long long total = 0;
1856         long long ret = 0;
1857         int q = 0; /*quotient*/
1858         int r = 0; /*remainder*/
1859         DIR *dp = NULL;
1860         struct dirent *ep = NULL;
1861         struct stat fileinfo;
1862         char abs_filename[FILENAME_MAX] = { 0, };
1863         retvm_if(dirname == NULL, PMINFO_R_ERROR, "dirname is NULL");
1864
1865         dp = opendir(dirname);
1866         if (dp != NULL) {
1867                 while ((ep = readdir(dp)) != NULL) {
1868                         if (!strcmp(ep->d_name, ".") ||
1869                                 !strcmp(ep->d_name, "..")) {
1870                                 continue;
1871                         }
1872                         snprintf(abs_filename, FILENAME_MAX, "%s/%s", dirname,
1873                                  ep->d_name);
1874                         if (lstat(abs_filename, &fileinfo) < 0)
1875                                 perror(abs_filename);
1876                         else {
1877                                 if (S_ISDIR(fileinfo.st_mode)) {
1878                                         total += fileinfo.st_size;
1879                                         if (strcmp(ep->d_name, ".")
1880                                             && strcmp(ep->d_name, "..")) {
1881                                                 ret = _pkgmgr_calculate_dir_size
1882                                                     (abs_filename);
1883                                                 total = total + ret;
1884                                         }
1885                                 } else if (S_ISLNK(fileinfo.st_mode)) {
1886                                         continue;
1887                                 } else {
1888                                         /*It is a file. Calculate the actual
1889                                         size occupied (in terms of 4096 blocks)*/
1890                                 q = (fileinfo.st_size / BLOCK_SIZE);
1891                                 r = (fileinfo.st_size % BLOCK_SIZE);
1892                                 if (r) {
1893                                         q = q + 1;
1894                                 }
1895                                 total += q * BLOCK_SIZE;
1896                                 }
1897                         }
1898                 }
1899                 (void)closedir(dp);
1900         } else {
1901                 _LOGE("Couldn't open the directory\n");
1902                 return -1;
1903         }
1904         return total;
1905
1906 }
1907
1908 static int __delete_certinfo(const char *pkgid)
1909 {
1910         int ret = -1;
1911         int i = 0;
1912         int j = 0;
1913         int c = 0;
1914         int unique_id[MAX_CERT_TYPE] = {0, 0, 0, 0, 0, 0, 0, 0, 0};
1915         char *error_message = NULL;
1916         char query[MAX_QUERY_LEN] = {'\0'};
1917         pkgmgr_certinfo_x *certinfo = NULL;
1918         pkgmgr_certindexinfo_x *indexinfo = NULL;
1919         certinfo = calloc(1, sizeof(pkgmgr_certinfo_x));
1920         retvm_if(certinfo == NULL, PMINFO_R_ERROR, "Malloc Failed\n");
1921         indexinfo = calloc(1, sizeof(pkgmgr_certindexinfo_x));
1922         if (indexinfo == NULL) {
1923                 _LOGE("Out of Memory!!!");
1924                 ret = PMINFO_R_ERROR;
1925                 goto err;
1926         }
1927         /*populate certinfo from DB*/
1928         snprintf(query, MAX_QUERY_LEN, "select * from package_cert_info where package='%s' ", pkgid);
1929         ret = __exec_certinfo_query(query, (void *)certinfo);
1930         if (ret == -1) {
1931                 _LOGE("Package Cert Info DB Information retrieval failed\n");
1932                 ret = PMINFO_R_ERROR;
1933                 goto err;
1934         }
1935         /*Update cert index table*/
1936         for (i = 0; i < MAX_CERT_TYPE; i++) {
1937                 if ((certinfo->cert_id)[i]) {
1938                         for (j = 0; j < MAX_CERT_TYPE; j++) {
1939                                 if ((certinfo->cert_id)[i] == unique_id[j]) {
1940                                         /*Ref count has already been updated. Just continue*/
1941                                         break;
1942                                 }
1943                         }
1944                         if (j == MAX_CERT_TYPE)
1945                                 unique_id[c++] = (certinfo->cert_id)[i];
1946                         else
1947                                 continue;
1948                         memset(query, '\0', MAX_QUERY_LEN);
1949                         snprintf(query, MAX_QUERY_LEN, "select * from package_cert_index_info where cert_id=%d ", (certinfo->cert_id)[i]);
1950                         ret = __exec_certindexinfo_query(query, (void *)indexinfo);
1951                         if (ret == -1) {
1952                                 _LOGE("Cert Info DB Information retrieval failed\n");
1953                                 ret = PMINFO_R_ERROR;
1954                                 goto err;
1955                         }
1956                         memset(query, '\0', MAX_QUERY_LEN);
1957                         if (indexinfo->cert_ref_count > 1) {
1958                                 /*decrease ref count*/
1959                                 snprintf(query, MAX_QUERY_LEN, "update package_cert_index_info set cert_ref_count=%d where cert_id=%d ",
1960                                 indexinfo->cert_ref_count - 1, (certinfo->cert_id)[i]);
1961                         } else {
1962                                 /*delete this certificate as ref count is 1 and it will become 0*/
1963                                 snprintf(query, MAX_QUERY_LEN, "delete from  package_cert_index_info where cert_id=%d ", (certinfo->cert_id)[i]);
1964                         }
1965                         if (SQLITE_OK !=
1966                             sqlite3_exec(cert_db, query, NULL, NULL, &error_message)) {
1967                                 _LOGE("Don't execute query = %s error message = %s\n", query,
1968                                        error_message);
1969                                 sqlite3_free(error_message);
1970                                 ret = PMINFO_R_ERROR;
1971                                 goto err;
1972                         }
1973                 }
1974         }
1975         /*Now delete the entry from db*/
1976         snprintf(query, MAX_QUERY_LEN, "delete from package_cert_info where package='%s'", pkgid);
1977         if (SQLITE_OK !=
1978             sqlite3_exec(cert_db, query, NULL, NULL, &error_message)) {
1979                 _LOGE("Don't execute query = %s error message = %s\n", query,
1980                        error_message);
1981                 sqlite3_free(error_message);
1982                 ret = PMINFO_R_ERROR;
1983                 goto err;
1984         }
1985         ret = PMINFO_R_OK;
1986 err:
1987         if (indexinfo) {
1988                 free(indexinfo);
1989                 indexinfo = NULL;
1990         }
1991         if (certinfo->pkgid) {
1992                 free(certinfo->pkgid);
1993                 certinfo->pkgid = NULL;
1994         }
1995         for (i = 0; i < MAX_CERT_TYPE; i++) {
1996                 if ((certinfo->cert_info)[i]) {
1997                         free((certinfo->cert_info)[i]);
1998                         (certinfo->cert_info)[i] = NULL;
1999                 }
2000         }
2001         free(certinfo);
2002         certinfo = NULL;
2003         return ret;
2004 }
2005
2006 API int pkgmgrinfo_pkginfo_get_list(pkgmgrinfo_pkg_list_cb pkg_list_cb, void *user_data)
2007 {
2008         retvm_if(pkg_list_cb == NULL, PMINFO_R_EINVAL, "callback function is NULL\n");
2009         char *error_message = NULL;
2010         int ret = PMINFO_R_OK;
2011         char query[MAX_QUERY_LEN] = {'\0'};
2012         char *syslocale = NULL;
2013         char *locale = NULL;
2014         pkgmgr_pkginfo_x *pkginfo = NULL;
2015         label_x *tmp1 = NULL;
2016         icon_x *tmp2 = NULL;
2017         description_x *tmp3 = NULL;
2018         author_x *tmp4 = NULL;
2019         privilege_x *tmp5 = NULL;
2020
2021         syslocale = vconf_get_str(VCONFKEY_LANGSET);
2022         if (syslocale == NULL) {
2023                 _LOGE("current locale is NULL\n");
2024                 ret = PMINFO_R_ERROR;
2025                 goto err;
2026         }
2027         locale = __convert_system_locale_to_manifest_locale(syslocale);
2028         if (locale == NULL) {
2029                 _LOGE("manifest locale is NULL\n");
2030                 ret = PMINFO_R_EINVAL;
2031                 goto err;
2032         }
2033
2034         ret = __open_manifest_db();
2035         if (ret == -1) {
2036                 _LOGE("Fail to open manifest DB\n");
2037                 ret = PMINFO_R_ERROR;
2038                 goto err;
2039         }
2040         pkgmgr_pkginfo_x *tmphead = (pkgmgr_pkginfo_x *)calloc(1, sizeof(pkgmgr_pkginfo_x));
2041         pkgmgr_pkginfo_x *node = NULL;
2042         pkgmgr_pkginfo_x *temp_node = NULL;
2043
2044         snprintf(query, MAX_QUERY_LEN, "select * from package_info");
2045         if (SQLITE_OK !=
2046             sqlite3_exec(manifest_db, query, __pkg_list_cb, (void *)tmphead, &error_message)) {
2047                 _LOGE("Don't execute query = %s error message = %s\n", query,
2048                        error_message);
2049                 sqlite3_free(error_message);
2050                 sqlite3_close(manifest_db);
2051                 ret = PMINFO_R_ERROR;
2052                 goto err;
2053         }
2054
2055         LISTHEAD(tmphead, node);
2056
2057         for(node = node->next; node ; node = node->next) {
2058                 pkginfo = node;
2059                 pkginfo->locale = strdup(locale);
2060                 pkginfo->manifest_info->privileges = (privileges_x *)calloc(1, sizeof(privileges_x));
2061                 if (pkginfo->manifest_info->privileges == NULL) {
2062                         _LOGE("Failed to allocate memory for privileges info\n");
2063                         ret = PMINFO_R_ERROR;
2064                         goto err;
2065                 }
2066                 /*populate manifest_info from DB*/
2067                 snprintf(query, MAX_QUERY_LEN, "select * from package_info where package='%s' ", pkginfo->manifest_info->package);
2068                 ret = __exec_pkginfo_query(query, (void *)pkginfo);
2069                 if (ret == -1) {
2070                         _LOGE("Package Info DB Information retrieval failed\n");
2071                         ret = PMINFO_R_ERROR;
2072                         goto err;
2073                 }
2074                 memset(query, '\0', MAX_QUERY_LEN);
2075                 /*populate privilege_info from DB*/
2076                 snprintf(query, MAX_QUERY_LEN, "select * from package_privilege_info where package='%s' ", pkginfo->manifest_info->package);
2077                 ret = __exec_pkginfo_query(query, (void *)pkginfo);
2078                 if (ret == -1) {
2079                         _LOGE("Package Privilege Info DB Information retrieval failed\n");
2080                         ret = PMINFO_R_ERROR;
2081                         goto err;
2082                 }
2083                 memset(query, '\0', MAX_QUERY_LEN);
2084                 snprintf(query, MAX_QUERY_LEN, "select * from package_localized_info where" \
2085                         " package='%s' and package_locale='%s'", pkginfo->manifest_info->package, locale);
2086                 ret = __exec_pkginfo_query(query, (void *)pkginfo);
2087                 if (ret == -1) {
2088                         _LOGE("Package Info DB Information retrieval failed\n");
2089                         ret = PMINFO_R_ERROR;
2090                         goto err;
2091                 }
2092                 /*Also store the values corresponding to default locales*/
2093                 memset(query, '\0', MAX_QUERY_LEN);
2094                 snprintf(query, MAX_QUERY_LEN, "select * from package_localized_info where" \
2095                         " package='%s' and package_locale='%s'", pkginfo->manifest_info->package, DEFAULT_LOCALE);
2096                 ret = __exec_pkginfo_query(query, (void *)pkginfo);
2097                 if (ret == -1) {
2098                         _LOGE("Package Info DB Information retrieval failed\n");
2099                         ret = PMINFO_R_ERROR;
2100                         goto err;
2101                 }
2102                 if (pkginfo->manifest_info->label) {
2103                         LISTHEAD(pkginfo->manifest_info->label, tmp1);
2104                         pkginfo->manifest_info->label = tmp1;
2105                 }
2106                 if (pkginfo->manifest_info->icon) {
2107                         LISTHEAD(pkginfo->manifest_info->icon, tmp2);
2108                         pkginfo->manifest_info->icon = tmp2;
2109                 }
2110                 if (pkginfo->manifest_info->description) {
2111                         LISTHEAD(pkginfo->manifest_info->description, tmp3);
2112                         pkginfo->manifest_info->description = tmp3;
2113                 }
2114                 if (pkginfo->manifest_info->author) {
2115                         LISTHEAD(pkginfo->manifest_info->author, tmp4);
2116                         pkginfo->manifest_info->author = tmp4;
2117                 }
2118                 if (pkginfo->manifest_info->privileges->privilege) {
2119                         LISTHEAD(pkginfo->manifest_info->privileges->privilege, tmp5);
2120                         pkginfo->manifest_info->privileges->privilege = tmp5;
2121                 }
2122         }
2123
2124         LISTHEAD(tmphead, node);
2125
2126         for(node = node->next; node ; node = node->next) {
2127                 pkginfo = node;
2128                 ret = pkg_list_cb( (void *)pkginfo, user_data);
2129                 if(ret < 0)
2130                         break;
2131         }
2132
2133         ret = PMINFO_R_OK;
2134
2135 err:
2136         sqlite3_close(manifest_db);
2137         if (syslocale) {
2138                 free(syslocale);
2139                 syslocale = NULL;
2140         }
2141         if (locale) {
2142                 free(locale);
2143                 locale = NULL;
2144         }
2145         LISTHEAD(tmphead, node);
2146         temp_node = node->next;
2147         node = temp_node;
2148         while (node) {
2149                 temp_node = node->next;
2150                 __cleanup_pkginfo(node);
2151                 node = temp_node;
2152         }
2153         __cleanup_pkginfo(tmphead);
2154         return ret;
2155 }
2156
2157
2158 API int pkgmgrinfo_pkginfo_get_pkginfo(const char *pkgid, pkgmgrinfo_pkginfo_h *handle)
2159 {
2160         retvm_if(pkgid == NULL, PMINFO_R_EINVAL, "pkgid is NULL\n");
2161         retvm_if(handle == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
2162         pkgmgr_pkginfo_x *pkginfo = NULL;
2163         int ret = PMINFO_R_OK;
2164         char query[MAX_QUERY_LEN] = {'\0'};
2165         char *syslocale = NULL;
2166         char *locale = NULL;
2167         int exist = 0;
2168         label_x *tmp1 = NULL;
2169         icon_x *tmp2 = NULL;
2170         description_x *tmp3 = NULL;
2171         author_x *tmp4 = NULL;
2172         privilege_x *tmp5 = NULL;
2173         sqlite3 *pkginfo_db = NULL;
2174
2175         /*validate pkgid*/
2176         ret = db_util_open_with_options(MANIFEST_DB, &pkginfo_db, SQLITE_OPEN_READONLY, NULL);
2177         retvm_if(ret != SQLITE_OK, PMINFO_R_ERROR, "connect db [%s] failed!", MANIFEST_DB);
2178
2179         /*check pkgid exist on db*/
2180         snprintf(query, MAX_QUERY_LEN, "select exists(select * from package_info where package='%s')", pkgid);
2181         ret = __exec_db_query(pkginfo_db, query, __validate_cb, (void *)&exist);
2182         tryvm_if(ret == -1, ret = PMINFO_R_ERROR, "sqlite3_exec[%s] fail", pkgid);
2183         tryvm_if(exist == 0, ret = PMINFO_R_ERROR, "pkgid[%s] not found in DB", pkgid);
2184
2185         /*get system locale*/
2186         syslocale = vconf_get_str(VCONFKEY_LANGSET);
2187         tryvm_if(syslocale == NULL, ret = PMINFO_R_ERROR, "current locale is NULL");
2188
2189         /*get locale on db*/
2190         locale = __convert_system_locale_to_manifest_locale(syslocale);
2191         tryvm_if(locale == NULL, ret = PMINFO_R_ERROR, "manifest locale is NULL");
2192
2193         pkginfo = (pkgmgr_pkginfo_x *)calloc(1, sizeof(pkgmgr_pkginfo_x));
2194         tryvm_if(pkginfo == NULL, ret = PMINFO_R_ERROR, "Failed to allocate memory for pkginfo");
2195
2196         pkginfo->locale = strdup(locale);
2197
2198         pkginfo->manifest_info = (manifest_x *)calloc(1, sizeof(manifest_x));
2199         tryvm_if(pkginfo->manifest_info == NULL, ret = PMINFO_R_ERROR, "Failed to allocate memory for manifest info");
2200
2201         pkginfo->manifest_info->package = strdup(pkgid);
2202         pkginfo->manifest_info->privileges = (privileges_x *)calloc(1, sizeof(privileges_x));
2203         tryvm_if(pkginfo->manifest_info->privileges == NULL, ret = PMINFO_R_ERROR, "Failed to allocate memory for privileges info");
2204
2205         /*populate manifest_info from DB*/
2206         snprintf(query, MAX_QUERY_LEN, "select * from package_info where package='%s' ", pkgid);
2207         ret = __exec_db_query(pkginfo_db, query, __pkginfo_cb, (void *)pkginfo);
2208         tryvm_if(ret == -1, ret = PMINFO_R_ERROR, "Package Info DB Information retrieval failed");
2209
2210         memset(query, '\0', MAX_QUERY_LEN);
2211         /*populate privilege_info from DB*/
2212         snprintf(query, MAX_QUERY_LEN, "select * from package_privilege_info where package='%s' ", pkgid);
2213         ret = __exec_db_query(pkginfo_db, query, __pkginfo_cb, (void *)pkginfo);
2214         tryvm_if(ret == -1, ret = PMINFO_R_ERROR, "Package Privilege Info DB Information retrieval failed");
2215
2216         memset(query, '\0', MAX_QUERY_LEN);
2217         snprintf(query, MAX_QUERY_LEN, "select * from package_localized_info where" \
2218                 " package='%s' and package_locale='%s'", pkgid, locale);
2219         ret = __exec_db_query(pkginfo_db, query, __pkginfo_cb, (void *)pkginfo);
2220         tryvm_if(ret == -1, ret = PMINFO_R_ERROR, "Package Info DB Information retrieval failed");
2221
2222         /*Also store the values corresponding to default locales*/
2223         memset(query, '\0', MAX_QUERY_LEN);
2224         snprintf(query, MAX_QUERY_LEN, "select * from package_localized_info where" \
2225                 " package='%s' and package_locale='%s'", pkgid, DEFAULT_LOCALE);
2226         ret = __exec_db_query(pkginfo_db, query, __pkginfo_cb, (void *)pkginfo);
2227         tryvm_if(ret == -1, ret = PMINFO_R_ERROR, "Package Info DB Information retrieval failed");
2228
2229         if (pkginfo->manifest_info->label) {
2230                 LISTHEAD(pkginfo->manifest_info->label, tmp1);
2231                 pkginfo->manifest_info->label = tmp1;
2232         }
2233         if (pkginfo->manifest_info->icon) {
2234                 LISTHEAD(pkginfo->manifest_info->icon, tmp2);
2235                 pkginfo->manifest_info->icon = tmp2;
2236         }
2237         if (pkginfo->manifest_info->description) {
2238                 LISTHEAD(pkginfo->manifest_info->description, tmp3);
2239                 pkginfo->manifest_info->description = tmp3;
2240         }
2241         if (pkginfo->manifest_info->author) {
2242                 LISTHEAD(pkginfo->manifest_info->author, tmp4);
2243                 pkginfo->manifest_info->author = tmp4;
2244         }
2245         if (pkginfo->manifest_info->privileges->privilege) {
2246                 LISTHEAD(pkginfo->manifest_info->privileges->privilege, tmp5);
2247                 pkginfo->manifest_info->privileges->privilege = tmp5;
2248         }
2249
2250 catch:
2251         if (ret == PMINFO_R_OK)
2252                 *handle = (void*)pkginfo;
2253         else {
2254                 *handle = NULL;
2255                 __cleanup_pkginfo(pkginfo);
2256         }
2257         sqlite3_close(pkginfo_db);
2258
2259         if (syslocale) {
2260                 free(syslocale);
2261                 syslocale = NULL;
2262         }
2263         if (locale) {
2264                 free(locale);
2265                 locale = NULL;
2266         }
2267         return ret;
2268 }
2269
2270
2271 API int pkgmgrinfo_pkginfo_get_pkgname(pkgmgrinfo_pkginfo_h handle, char **pkg_name)
2272 {
2273         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
2274         retvm_if(pkg_name == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
2275         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
2276         if (info->manifest_info->package)
2277                 *pkg_name = (char *)info->manifest_info->package;
2278         else
2279                 return PMINFO_R_ERROR;
2280
2281         return PMINFO_R_OK;
2282 }
2283
2284 API int pkgmgrinfo_pkginfo_get_pkgid(pkgmgrinfo_pkginfo_h handle, char **pkgid)
2285 {
2286         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
2287         retvm_if(pkgid == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
2288         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
2289         if (info->manifest_info->package)
2290                 *pkgid = (char *)info->manifest_info->package;
2291         else
2292                 return PMINFO_R_ERROR;
2293
2294         return PMINFO_R_OK;
2295 }
2296
2297 API int pkgmgrinfo_pkginfo_get_type(pkgmgrinfo_pkginfo_h handle, char **type)
2298 {
2299         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
2300         retvm_if(type == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
2301         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
2302         if (info->manifest_info->type)
2303                 *type = (char *)info->manifest_info->type;
2304         else
2305                 *type = pkgtype;
2306         return PMINFO_R_OK;
2307 }
2308
2309 API int pkgmgrinfo_pkginfo_get_version(pkgmgrinfo_pkginfo_h handle, char **version)
2310 {
2311         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
2312         retvm_if(version == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
2313         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
2314         *version = (char *)info->manifest_info->version;
2315         return PMINFO_R_OK;
2316 }
2317
2318 API int pkgmgrinfo_pkginfo_get_install_location(pkgmgrinfo_pkginfo_h handle, pkgmgrinfo_install_location *location)
2319 {
2320         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
2321         retvm_if(location == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
2322         char *val = NULL;
2323         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
2324         val = (char *)info->manifest_info->installlocation;
2325         if (val) {
2326                 if (strcmp(val, "internal-only") == 0)
2327                         *location = PMINFO_INSTALL_LOCATION_INTERNAL_ONLY;
2328                 else if (strcmp(val, "prefer-external") == 0)
2329                         *location = PMINFO_INSTALL_LOCATION_PREFER_EXTERNAL;
2330                 else
2331                         *location = PMINFO_INSTALL_LOCATION_AUTO;
2332         }
2333         return PMINFO_R_OK;
2334 }
2335
2336 API int pkgmgrinfo_pkginfo_get_package_size(pkgmgrinfo_pkginfo_h handle, int *size)
2337 {
2338         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
2339         retvm_if(size == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
2340         char *val = NULL;
2341         char *location = NULL;
2342         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
2343         location = (char *)info->manifest_info->installlocation;
2344         val = (char *)info->manifest_info->package_size;
2345         if (val) {
2346                 *size = atoi(val);
2347         } else {
2348                 *size = 0;
2349                 _LOGE("package size is not specified\n");
2350                 return PMINFO_R_ERROR;
2351         }
2352         return PMINFO_R_OK;
2353 }
2354
2355 API int pkgmgrinfo_pkginfo_get_total_size(pkgmgrinfo_pkginfo_h handle, int *size)
2356 {
2357         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
2358         retvm_if(size == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
2359
2360         char *pkgid = NULL;
2361         char device_path[PKG_STRING_LEN_MAX] = { '\0', };
2362         long long rw_size = 0;
2363         long long ro_size= 0;
2364         long long tmp_size= 0;
2365         long long total_size= 0;
2366         struct stat fileinfo;
2367         int ret = -1;
2368
2369         ret = pkgmgrinfo_pkginfo_get_pkgid(handle,&pkgid);
2370         if(ret < 0)
2371                 return PMINFO_R_ERROR;
2372
2373         /* RW area */
2374         snprintf(device_path, PKG_STRING_LEN_MAX, "%s%s/bin", PKG_RW_PATH, pkgid);
2375         if (lstat(device_path, &fileinfo) == 0) {
2376                 if (!S_ISLNK(fileinfo.st_mode)) {
2377                         tmp_size = _pkgmgr_calculate_dir_size(device_path);
2378                         if (tmp_size > 0)
2379                                 rw_size += tmp_size;
2380                 }
2381         }
2382
2383         snprintf(device_path, PKG_STRING_LEN_MAX, "%s%s/info", PKG_RW_PATH, pkgid);
2384         if (lstat(device_path, &fileinfo) == 0) {
2385                 if (!S_ISLNK(fileinfo.st_mode)) {
2386                         tmp_size = _pkgmgr_calculate_dir_size(device_path);
2387                         if (tmp_size > 0)
2388                         rw_size += tmp_size;
2389                 }
2390         }
2391
2392         snprintf(device_path, PKG_STRING_LEN_MAX, "%s%s/res", PKG_RW_PATH, pkgid);
2393         if (lstat(device_path, &fileinfo) == 0) {
2394                 if (!S_ISLNK(fileinfo.st_mode)) {
2395                         tmp_size = _pkgmgr_calculate_dir_size(device_path);
2396                         if (tmp_size > 0)
2397                         rw_size += tmp_size;
2398                 }
2399         }
2400
2401         snprintf(device_path, PKG_STRING_LEN_MAX, "%s%s/data", PKG_RW_PATH, pkgid);
2402         if (lstat(device_path, &fileinfo) == 0) {
2403                 if (!S_ISLNK(fileinfo.st_mode)) {
2404                         tmp_size = _pkgmgr_calculate_dir_size(device_path);
2405                         if (tmp_size > 0)
2406                                 rw_size += tmp_size;
2407                 }
2408         }
2409
2410         snprintf(device_path, PKG_STRING_LEN_MAX, "%s%s/shared", PKG_RW_PATH, pkgid);
2411         if (lstat(device_path, &fileinfo) == 0) {
2412                 if (!S_ISLNK(fileinfo.st_mode)) {
2413                         tmp_size = _pkgmgr_calculate_dir_size(device_path);
2414                         if (tmp_size > 0)
2415                                 rw_size += tmp_size;
2416         }
2417         }
2418
2419         snprintf(device_path, PKG_STRING_LEN_MAX, "%s%s/setting", PKG_RW_PATH, pkgid);
2420         if (lstat(device_path, &fileinfo) == 0) {
2421                 if (!S_ISLNK(fileinfo.st_mode)) {
2422                         tmp_size = _pkgmgr_calculate_dir_size(device_path);
2423                         if (tmp_size > 0)
2424                                 rw_size += tmp_size;
2425                 }
2426         }
2427
2428         /* RO area */
2429         snprintf(device_path, PKG_STRING_LEN_MAX, "%s%s/bin", PKG_RO_PATH, pkgid);
2430         if (lstat(device_path, &fileinfo) == 0) {
2431                 if (!S_ISLNK(fileinfo.st_mode)) {
2432                         tmp_size = _pkgmgr_calculate_dir_size(device_path);
2433                         if (tmp_size > 0)
2434                                 ro_size += tmp_size;
2435                 }
2436         }
2437
2438         snprintf(device_path, PKG_STRING_LEN_MAX, "%s%s/info", PKG_RO_PATH, pkgid);
2439         if (lstat(device_path, &fileinfo) == 0) {
2440                 if (!S_ISLNK(fileinfo.st_mode)) {
2441                         tmp_size = _pkgmgr_calculate_dir_size(device_path);
2442                         if (tmp_size > 0)
2443                                 ro_size += tmp_size;
2444                 }
2445         }
2446
2447         snprintf(device_path, PKG_STRING_LEN_MAX, "%s%s/res", PKG_RO_PATH, pkgid);
2448         if (lstat(device_path, &fileinfo) == 0) {
2449                 if (!S_ISLNK(fileinfo.st_mode)) {
2450                         tmp_size = _pkgmgr_calculate_dir_size(device_path);
2451                         if (tmp_size > 0)
2452                                 ro_size += tmp_size;
2453                 }
2454         }
2455
2456         snprintf(device_path, PKG_STRING_LEN_MAX, "%s%s/data", PKG_RO_PATH, pkgid);
2457         if (lstat(device_path, &fileinfo) == 0) {
2458                 if (!S_ISLNK(fileinfo.st_mode)) {
2459                         tmp_size = _pkgmgr_calculate_dir_size(device_path);
2460                         if (tmp_size > 0)
2461                                 ro_size += tmp_size;
2462                 }
2463         }
2464
2465         snprintf(device_path, PKG_STRING_LEN_MAX, "%s%s/shared", PKG_RO_PATH, pkgid);
2466         if (lstat(device_path, &fileinfo) == 0) {
2467                 if (!S_ISLNK(fileinfo.st_mode)) {
2468                         tmp_size = _pkgmgr_calculate_dir_size(device_path);
2469                         if (tmp_size > 0)
2470                                 ro_size += tmp_size;
2471         }
2472         }
2473
2474         snprintf(device_path, PKG_STRING_LEN_MAX, "%s%s/setting", PKG_RO_PATH, pkgid);
2475         if (lstat(device_path, &fileinfo) == 0) {
2476                 if (!S_ISLNK(fileinfo.st_mode)) {
2477                         tmp_size = _pkgmgr_calculate_dir_size(device_path);
2478                         if (tmp_size > 0)
2479                                 ro_size += tmp_size;
2480                 }
2481         }
2482
2483         /* Total size */
2484         total_size = rw_size + ro_size;
2485         *size = (int)total_size;
2486
2487         return PMINFO_R_OK;
2488 }
2489
2490 API int pkgmgrinfo_pkginfo_get_data_size(pkgmgrinfo_pkginfo_h handle, int *size)
2491 {
2492         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
2493         retvm_if(size == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
2494
2495         char *pkgid = NULL;
2496         char device_path[PKG_STRING_LEN_MAX] = { '\0', };
2497         long long total_size= 0;
2498         int ret = -1;
2499
2500         ret = pkgmgrinfo_pkginfo_get_pkgid(handle,&pkgid);
2501         if(ret < 0)
2502                 return PMINFO_R_ERROR;
2503
2504         snprintf(device_path, PKG_STRING_LEN_MAX, "%s%s/data", PKG_RW_PATH, pkgid);
2505         if (access(device_path, R_OK) == 0)
2506                 total_size = _pkgmgr_calculate_dir_size(device_path);
2507         if (total_size < 0)
2508                 return PMINFO_R_ERROR;
2509
2510         *size = (int)total_size;
2511
2512         return PMINFO_R_OK;
2513 }
2514
2515 API int pkgmgrinfo_pkginfo_get_icon(pkgmgrinfo_pkginfo_h handle, char **icon)
2516 {
2517         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL");
2518         retvm_if(icon == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL");
2519         int ret = PMINFO_R_OK;
2520         char *locale = NULL;
2521         icon_x *ptr = NULL;
2522         *icon = NULL;
2523
2524         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
2525
2526         locale = info->locale;
2527         retvm_if(locale == NULL, PMINFO_R_ERROR, "manifest locale is NULL");
2528
2529         for(ptr = info->manifest_info->icon; ptr != NULL; ptr = ptr->next)
2530         {
2531                 if (ptr->lang) {
2532                         if (strcmp(ptr->lang, locale) == 0) {
2533                                 *icon = (char *)ptr->text;
2534                                 if (strcasecmp(*icon, "(null)") == 0) {
2535                                         locale = DEFAULT_LOCALE;
2536                                         continue;
2537                                 } else
2538                                         break;
2539                         } else if (strcmp(ptr->lang, DEFAULT_LOCALE) == 0) {
2540                                 *icon = (char *)ptr->text;
2541                                 break;
2542                         }
2543                 }
2544         }
2545
2546         return ret;
2547 }
2548
2549 API int pkgmgrinfo_pkginfo_get_label(pkgmgrinfo_pkginfo_h handle, char **label)
2550 {
2551         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL");
2552         retvm_if(label == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL");
2553         int ret = PMINFO_R_OK;
2554         char *locale = NULL;
2555         label_x *ptr = NULL;
2556         *label = NULL;
2557
2558         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
2559         locale = info->locale;
2560         retvm_if(locale == NULL, PMINFO_R_ERROR, "manifest locale is NULL");
2561
2562         for(ptr = info->manifest_info->label; ptr != NULL; ptr = ptr->next)
2563         {
2564                 if (ptr->lang) {
2565                         if (strcmp(ptr->lang, locale) == 0) {
2566                                 *label = (char *)ptr->text;
2567                                 if (strcasecmp(*label, "(null)") == 0) {
2568                                         locale = DEFAULT_LOCALE;
2569                                         continue;
2570                                 } else
2571                                         break;
2572                         } else if (strcmp(ptr->lang, DEFAULT_LOCALE) == 0) {
2573                                 *label = (char *)ptr->text;
2574                                 break;
2575                         }
2576                 }
2577         }
2578
2579         return ret;
2580 }
2581
2582 API int pkgmgrinfo_pkginfo_get_description(pkgmgrinfo_pkginfo_h handle, char **description)
2583 {
2584         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
2585         retvm_if(description == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
2586         char *locale = NULL;
2587         description_x *ptr = NULL;
2588         *description = NULL;
2589
2590         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
2591         locale = info->locale;
2592         retvm_if(locale == NULL, PMINFO_R_ERROR, "manifest locale is NULL");
2593
2594         for(ptr = info->manifest_info->description; ptr != NULL; ptr = ptr->next)
2595         {
2596                 if (ptr->lang) {
2597                         if (strcmp(ptr->lang, locale) == 0) {
2598                                 *description = (char *)ptr->text;
2599                                 if (strcasecmp(*description, "(null)") == 0) {
2600                                         locale = DEFAULT_LOCALE;
2601                                         continue;
2602                                 } else
2603                                         break;
2604                         } else if (strcmp(ptr->lang, DEFAULT_LOCALE) == 0) {
2605                                 *description = (char *)ptr->text;
2606                                 break;
2607                         }
2608                 }
2609         }
2610         return PMINFO_R_OK;
2611 }
2612
2613 API int pkgmgrinfo_pkginfo_get_author_name(pkgmgrinfo_pkginfo_h handle, char **author_name)
2614 {
2615         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
2616         retvm_if(author_name == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
2617         char *locale = NULL;
2618         author_x *ptr = NULL;
2619         *author_name = NULL;
2620
2621         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
2622         locale = info->locale;
2623         retvm_if(locale == NULL, PMINFO_R_ERROR, "manifest locale is NULL");
2624
2625         for(ptr = info->manifest_info->author; ptr != NULL; ptr = ptr->next)
2626         {
2627                 if (ptr->lang) {
2628                         if (strcmp(ptr->lang, locale) == 0) {
2629                                 *author_name = (char *)ptr->text;
2630                                 if (strcasecmp(*author_name, "(null)") == 0) {
2631                                         locale = DEFAULT_LOCALE;
2632                                         continue;
2633                                 } else
2634                                         break;
2635                         } else if (strcmp(ptr->lang, DEFAULT_LOCALE) == 0) {
2636                                 *author_name = (char *)ptr->text;
2637                                 break;
2638                         }
2639                 }
2640         }
2641         return PMINFO_R_OK;
2642 }
2643
2644 API int pkgmgrinfo_pkginfo_get_author_email(pkgmgrinfo_pkginfo_h handle, char **author_email)
2645 {
2646         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
2647         retvm_if(author_email == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
2648         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
2649         *author_email = (char *)info->manifest_info->author->email;
2650         return PMINFO_R_OK;
2651 }
2652
2653 API int pkgmgrinfo_pkginfo_get_author_href(pkgmgrinfo_pkginfo_h handle, char **author_href)
2654 {
2655         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
2656         retvm_if(author_href == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
2657         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
2658         *author_href = (char *)info->manifest_info->author->href;
2659         return PMINFO_R_OK;
2660 }
2661
2662 API int pkgmgrinfo_pkginfo_get_installed_storage(pkgmgrinfo_pkginfo_h handle, pkgmgrinfo_installed_storage *storage)
2663 {
2664         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
2665         retvm_if(storage == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
2666
2667         char *pkgid = NULL;
2668         pkgmgrinfo_pkginfo_get_pkgid(handle, &pkgid);
2669         if (pkgid == NULL){
2670                  _LOGE("invalid func parameters\n");
2671                  return PMINFO_R_ERROR;
2672         }
2673
2674         FILE *fp = NULL;
2675         char app_mmc_path[FILENAME_MAX] = { 0, };
2676         char app_dir_path[FILENAME_MAX] = { 0, };
2677         char app_mmc_internal_path[FILENAME_MAX] = { 0, };
2678         snprintf(app_dir_path, FILENAME_MAX,
2679         "%s%s", PKG_INSTALLATION_PATH, pkgid);
2680         snprintf(app_mmc_path, FILENAME_MAX,
2681         "%s%s", PKG_SD_PATH, pkgid);
2682         snprintf(app_mmc_internal_path, FILENAME_MAX,
2683         "%s%s/.mmc", PKG_INSTALLATION_PATH, pkgid);
2684
2685         /*check whether application is in external memory or not */
2686         fp = fopen(app_mmc_path, "r");
2687         if (fp == NULL) {
2688                 _LOGE(" app path in external memory not accesible\n");
2689         } else {
2690                 fclose(fp);
2691                 fp = NULL;
2692                 *storage = PMINFO_EXTERNAL_STORAGE;
2693                 return PMINFO_R_OK;
2694         }
2695
2696         /*check whether application is in internal or not */
2697         fp = fopen(app_dir_path, "r");
2698         if (fp == NULL) {
2699                 _LOGE(" app path in internal memory not accesible\n");
2700                 *storage = -1;
2701                 return PMINFO_R_ERROR;
2702         } else {
2703                 fclose(fp);
2704                 /*check whether the application is installed in SD card
2705                         but SD card is not present*/
2706                 fp = fopen(app_mmc_internal_path, "r");
2707                 if (fp == NULL) {
2708                         *storage = PMINFO_INTERNAL_STORAGE;
2709                         return PMINFO_R_OK;
2710                 } else {
2711                         fclose(fp);
2712                         *storage = PMINFO_EXTERNAL_STORAGE;
2713                         return PMINFO_R_OK;
2714                 }
2715         }
2716 }
2717
2718 API int pkgmgrinfo_pkginfo_get_installed_time(pkgmgrinfo_pkginfo_h handle, int *installed_time)
2719 {
2720         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
2721         retvm_if(installed_time == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
2722         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
2723         if (info->manifest_info->installed_time)
2724                 *installed_time = atoi(info->manifest_info->installed_time);
2725         else
2726                 return PMINFO_R_ERROR;
2727
2728         return PMINFO_R_OK;
2729 }
2730
2731 API int pkgmgrinfo_pkginfo_get_storeclientid(pkgmgrinfo_pkginfo_h handle, char **storeclientid)
2732 {
2733         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
2734         retvm_if(storeclientid == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
2735         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
2736         *storeclientid = (char *)info->manifest_info->storeclient_id;
2737         return PMINFO_R_OK;
2738 }
2739
2740 API int pkgmgrinfo_pkginfo_get_mainappid(pkgmgrinfo_pkginfo_h handle, char **mainappid)
2741 {
2742         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
2743         retvm_if(mainappid == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
2744         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
2745         *mainappid = (char *)info->manifest_info->mainapp_id;
2746         return PMINFO_R_OK;
2747 }
2748
2749 API int pkgmgrinfo_pkginfo_get_url(pkgmgrinfo_pkginfo_h handle, char **url)
2750 {
2751         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
2752         retvm_if(url == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
2753         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
2754         *url = (char *)info->manifest_info->package_url;
2755         return PMINFO_R_OK;
2756 }
2757
2758 API int pkgmgrinfo_pkginfo_get_size_from_xml(const char *manifest, int *size)
2759 {
2760         const char *val = NULL;
2761         const xmlChar *node;
2762         xmlTextReaderPtr reader;
2763         retvm_if(manifest == NULL, PMINFO_R_EINVAL, "Input argument is NULL\n");
2764         retvm_if(size == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
2765
2766         xmlInitParser();
2767         reader = xmlReaderForFile(manifest, NULL, 0);
2768
2769         if (reader){
2770                 if (__child_element(reader, -1)) {
2771                         node = xmlTextReaderConstName(reader);
2772                         if (!node) {
2773                                 _LOGE("xmlTextReaderConstName value is NULL\n");
2774                                 xmlFreeTextReader(reader);
2775                                 xmlCleanupParser();
2776                                 return PMINFO_R_ERROR;
2777                         }
2778
2779                         if (!strcmp(ASC_CHAR(node), "manifest")) {
2780                                 if (xmlTextReaderGetAttribute(reader, XML_CHAR("size")))
2781                                         val = ASC_CHAR(xmlTextReaderGetAttribute(reader, XML_CHAR("size")));
2782
2783                                 if (val) {
2784                                         *size = atoi(val);
2785                                 } else {
2786                                         *size = 0;
2787                                         _LOGE("package size is not specified\n");
2788                                         xmlFreeTextReader(reader);
2789                                         xmlCleanupParser();
2790                                         return PMINFO_R_ERROR;
2791                                 }
2792                         } else {
2793                                 _LOGE("Unable to create xml reader\n");
2794                                 xmlFreeTextReader(reader);
2795                                 xmlCleanupParser();
2796                                 return PMINFO_R_ERROR;
2797                         }
2798                 }
2799         } else {
2800                 _LOGE("xmlReaderForFile value is NULL\n");
2801                 xmlCleanupParser();
2802                 return PMINFO_R_ERROR;
2803         }
2804
2805         xmlFreeTextReader(reader);
2806         xmlCleanupParser();
2807
2808         return PMINFO_R_OK;
2809 }
2810
2811 API int pkgmgrinfo_pkginfo_get_location_from_xml(const char *manifest, pkgmgrinfo_install_location *location)
2812 {
2813         const char *val = NULL;
2814         const xmlChar *node;
2815         xmlTextReaderPtr reader;
2816         retvm_if(manifest == NULL, PMINFO_R_EINVAL, "Input argument is NULL\n");
2817         retvm_if(location == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
2818
2819         xmlInitParser();
2820         reader = xmlReaderForFile(manifest, NULL, 0);
2821
2822         if (reader){
2823                 if ( __child_element(reader, -1)) {
2824                         node = xmlTextReaderConstName(reader);
2825                         if (!node) {
2826                                 _LOGE("xmlTextReaderConstName value is NULL\n");
2827                                 xmlFreeTextReader(reader);
2828                                 xmlCleanupParser();
2829                                 return PMINFO_R_ERROR;
2830                         }
2831
2832                         if (!strcmp(ASC_CHAR(node), "manifest")) {
2833                                 if (xmlTextReaderGetAttribute(reader, XML_CHAR("install-location")))
2834                                         val = ASC_CHAR(xmlTextReaderGetAttribute(reader, XML_CHAR("install-location")));
2835
2836                                 if (val) {
2837                                         if (strcmp(val, "internal-only") == 0)
2838                                                 *location = PMINFO_INSTALL_LOCATION_INTERNAL_ONLY;
2839                                         else if (strcmp(val, "prefer-external") == 0)
2840                                                 *location = PMINFO_INSTALL_LOCATION_PREFER_EXTERNAL;
2841                                         else
2842                                                 *location = PMINFO_INSTALL_LOCATION_AUTO;
2843                                 }
2844                         } else {
2845                                 _LOGE("Unable to create xml reader\n");
2846                                 xmlFreeTextReader(reader);
2847                                 xmlCleanupParser();
2848                                 return PMINFO_R_ERROR;
2849                         }
2850                 }
2851         } else {
2852                 _LOGE("xmlReaderForFile value is NULL\n");
2853                 xmlCleanupParser();
2854                 return PMINFO_R_ERROR;
2855         }
2856
2857         xmlFreeTextReader(reader);
2858         xmlCleanupParser();
2859
2860         return PMINFO_R_OK;
2861 }
2862
2863
2864 API int pkgmgrinfo_pkginfo_get_root_path(pkgmgrinfo_pkginfo_h handle, char **path)
2865 {
2866         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
2867         retvm_if(path == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
2868
2869         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
2870         if (info->manifest_info->root_path)
2871                 *path = (char *)info->manifest_info->root_path;
2872         else
2873                 return PMINFO_R_ERROR;
2874
2875         return PMINFO_R_OK;
2876 }
2877
2878
2879 API int pkgmgrinfo_pkginfo_compare_pkg_cert_info(const char *lhs_package_id, const char *rhs_package_id, pkgmgrinfo_cert_compare_result_type_e *compare_result)
2880 {
2881         retvm_if(lhs_package_id == NULL, PMINFO_R_EINVAL, "lhs package ID is NULL");
2882         retvm_if(rhs_package_id == NULL, PMINFO_R_EINVAL, "rhs package ID is NULL");
2883         retvm_if(compare_result == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL");
2884
2885         int ret = PMINFO_R_OK;
2886         char query[MAX_QUERY_LEN] = {'\0'};
2887         char *error_message = NULL;
2888         pkgmgr_cert_x *info= NULL;
2889         int lcert = 0;
2890         int rcert = 0;
2891         int exist = -1;
2892         *compare_result = PMINFO_CERT_COMPARE_ERROR;
2893         info = (pkgmgr_cert_x *)calloc(1, sizeof(pkgmgr_cert_x));
2894         retvm_if(info == NULL, PMINFO_R_ERROR, "Out of Memory!!!");
2895
2896         ret = db_util_open_with_options(CERT_DB, &cert_db,
2897                                         SQLITE_OPEN_READONLY, NULL);
2898         if (ret != SQLITE_OK) {
2899                 _LOGE("connect db [%s] failed!\n", CERT_DB);
2900                 ret = PMINFO_R_ERROR;
2901                 goto err;
2902         }
2903
2904         snprintf(query, MAX_QUERY_LEN, "select exists(select * from package_cert_info where package='%s')", lhs_package_id);
2905         if (SQLITE_OK !=
2906             sqlite3_exec(cert_db, query, __validate_cb, (void *)&exist, &error_message)) {
2907                 _LOGE("Don't execute query = %s error message = %s\n", query,
2908                        error_message);
2909                 ret = PMINFO_R_ERROR;
2910                 goto err;
2911         }
2912
2913         if (exist == 0) {
2914                 lcert = 0;
2915         } else {
2916                 snprintf(query, MAX_QUERY_LEN, "select author_signer_cert from package_cert_info where package='%s'", lhs_package_id);
2917                 if (SQLITE_OK !=
2918                         sqlite3_exec(cert_db, query, __cert_cb, (void *)info, &error_message)) {
2919                         _LOGE("Don't execute query = %s error message = %s\n", query,
2920                                    error_message);
2921                         ret = PMINFO_R_ERROR;
2922                         goto err;
2923                 }
2924                 lcert = info->cert_id;
2925         }
2926
2927         snprintf(query, MAX_QUERY_LEN, "select exists(select * from package_cert_info where package='%s')", rhs_package_id);
2928         if (SQLITE_OK !=
2929                 sqlite3_exec(cert_db, query, __validate_cb, (void *)&exist, &error_message)) {
2930                 _LOGE("Don't execute query = %s error message = %s\n", query,
2931                            error_message);
2932                 ret = PMINFO_R_ERROR;
2933                 goto err;
2934         }
2935
2936         if (exist == 0) {
2937                 rcert = 0;
2938         } else {
2939                 snprintf(query, MAX_QUERY_LEN, "select author_signer_cert from package_cert_info where package='%s'", rhs_package_id);
2940                 if (SQLITE_OK !=
2941                         sqlite3_exec(cert_db, query, __cert_cb, (void *)info, &error_message)) {
2942                         _LOGE("Don't execute query = %s error message = %s\n", query,
2943                                    error_message);
2944                         ret = PMINFO_R_ERROR;
2945                         goto err;
2946                 }
2947                 rcert = info->cert_id;
2948         }
2949
2950         if ((lcert == 0) || (rcert == 0))
2951         {
2952                 if ((lcert == 0) && (rcert == 0))
2953                         *compare_result = PMINFO_CERT_COMPARE_BOTH_NO_CERT;
2954                 else if (lcert == 0)
2955                         *compare_result = PMINFO_CERT_COMPARE_LHS_NO_CERT;
2956                 else if (rcert == 0)
2957                         *compare_result = PMINFO_CERT_COMPARE_RHS_NO_CERT;
2958         } else {
2959                 if (lcert == rcert)
2960                         *compare_result = PMINFO_CERT_COMPARE_MATCH;
2961                 else
2962                         *compare_result = PMINFO_CERT_COMPARE_MISMATCH;
2963         }
2964
2965 err:
2966         sqlite3_free(error_message);
2967         sqlite3_close(cert_db);
2968         if (info) {
2969                 if (info->pkgid) {
2970                         free(info->pkgid);
2971                         info->pkgid = NULL;
2972                 }
2973                 free(info);
2974                 info = NULL;
2975         }
2976         return ret;
2977 }
2978
2979
2980 API int pkgmgrinfo_pkginfo_compare_app_cert_info(const char *lhs_app_id, const char *rhs_app_id, pkgmgrinfo_cert_compare_result_type_e *compare_result)
2981 {
2982         retvm_if(lhs_app_id == NULL, PMINFO_R_EINVAL, "lhs app ID is NULL");
2983         retvm_if(rhs_app_id == NULL, PMINFO_R_EINVAL, "rhs app ID is NULL");
2984         retvm_if(compare_result == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL");
2985
2986         int ret = PMINFO_R_OK;
2987         char query[MAX_QUERY_LEN] = {'\0'};
2988         char *error_message = NULL;
2989         pkgmgr_cert_x *info= NULL;
2990         int exist = -1;
2991         char *lpkgid = NULL;
2992         char *rpkgid = NULL;
2993
2994         info = (pkgmgr_cert_x *)calloc(1, sizeof(pkgmgr_cert_x));
2995         retvm_if(info == NULL, PMINFO_R_ERROR, "Out of Memory!!!");
2996
2997         ret = db_util_open_with_options(MANIFEST_DB, &manifest_db,
2998                                         SQLITE_OPEN_READONLY, NULL);
2999         if (ret != SQLITE_OK) {
3000                 _LOGE("connect db [%s] failed!\n", MANIFEST_DB);
3001                 ret = PMINFO_R_ERROR;
3002                 goto err;
3003         }
3004
3005         snprintf(query, MAX_QUERY_LEN, "select exists(select * from package_app_info where app_id='%s')", lhs_app_id);
3006         if (SQLITE_OK !=
3007             sqlite3_exec(manifest_db, query, __validate_cb, (void *)&exist, &error_message)) {
3008                 _LOGE("Don't execute query = %s error message = %s\n", query,
3009                        error_message);
3010                 ret = PMINFO_R_ERROR;
3011                 goto err;
3012         }
3013
3014         if (exist == 0) {
3015                 lpkgid = NULL;
3016         } else {
3017                 snprintf(query, MAX_QUERY_LEN, "select package from package_app_info where app_id='%s' ", lhs_app_id);
3018                 if (SQLITE_OK !=
3019                         sqlite3_exec(manifest_db, query, __cert_cb, (void *)info, &error_message)) {
3020                         _LOGE("Don't execute query = %s error message = %s\n", query,
3021                                    error_message);
3022                         ret = PMINFO_R_ERROR;
3023                         goto err;
3024                 }
3025                 lpkgid = strdup(info->pkgid);
3026                 if (lpkgid == NULL) {
3027                         _LOGE("Out of Memory\n");
3028                         ret = PMINFO_R_ERROR;
3029                         goto err;
3030                 }
3031                 free(info->pkgid);
3032                 info->pkgid = NULL;
3033         }
3034
3035         snprintf(query, MAX_QUERY_LEN, "select exists(select * from package_app_info where app_id='%s')", rhs_app_id);
3036         if (SQLITE_OK !=
3037             sqlite3_exec(manifest_db, query, __validate_cb, (void *)&exist, &error_message)) {
3038                 _LOGE("Don't execute query = %s error message = %s\n", query,
3039                        error_message);
3040                 ret = PMINFO_R_ERROR;
3041                 goto err;
3042         }
3043
3044         if (exist == 0) {
3045                 rpkgid = NULL;
3046         } else {
3047                 snprintf(query, MAX_QUERY_LEN, "select package from package_app_info where app_id='%s' ", rhs_app_id);
3048                 if (SQLITE_OK !=
3049                         sqlite3_exec(manifest_db, query, __cert_cb, (void *)info, &error_message)) {
3050                         _LOGE("Don't execute query = %s error message = %s\n", query,
3051                                    error_message);
3052                         ret = PMINFO_R_ERROR;
3053                         goto err;
3054                 }
3055                 rpkgid = strdup(info->pkgid);
3056                 if (rpkgid == NULL) {
3057                         _LOGE("Out of Memory\n");
3058                         ret = PMINFO_R_ERROR;
3059                         goto err;
3060                 }
3061                 free(info->pkgid);
3062                 info->pkgid = NULL;
3063         }
3064         ret = pkgmgrinfo_pkginfo_compare_pkg_cert_info(lpkgid, rpkgid, compare_result);
3065  err:
3066         sqlite3_free(error_message);
3067         sqlite3_close(manifest_db);
3068         if (info) {
3069                 if (info->pkgid) {
3070                         free(info->pkgid);
3071                         info->pkgid = NULL;
3072                 }
3073                 free(info);
3074                 info = NULL;
3075         }
3076         if (lpkgid) {
3077                 free(lpkgid);
3078                 lpkgid = NULL;
3079         }
3080         if (rpkgid) {
3081                 free(rpkgid);
3082                 rpkgid = NULL;
3083         }
3084         return ret;
3085 }
3086
3087 API int pkgmgrinfo_pkginfo_is_accessible(pkgmgrinfo_pkginfo_h handle, bool *accessible)
3088 {
3089         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
3090         retvm_if(accessible == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
3091         char *pkgid = NULL;
3092         pkgmgrinfo_pkginfo_get_pkgid(handle, &pkgid);
3093         if (pkgid == NULL){
3094                  _LOGD("invalid func parameters\n");
3095                  return PMINFO_R_ERROR;
3096         }
3097          _LOGD("pkgmgr_get_pkg_external_validation() called\n");
3098
3099         FILE *fp = NULL;
3100         char app_mmc_path[FILENAME_MAX] = { 0, };
3101         char app_dir_path[FILENAME_MAX] = { 0, };
3102         char app_mmc_internal_path[FILENAME_MAX] = { 0, };
3103         snprintf(app_dir_path, FILENAME_MAX,"%s%s", PKG_INSTALLATION_PATH, pkgid);
3104         snprintf(app_mmc_path, FILENAME_MAX,"%s%s", PKG_SD_PATH, pkgid);
3105         snprintf(app_mmc_internal_path, FILENAME_MAX,"%s%s/.mmc", PKG_INSTALLATION_PATH, pkgid);
3106
3107         /*check whether application is in external memory or not */
3108         fp = fopen(app_mmc_path, "r");
3109         if (fp == NULL){
3110                 _LOGD(" app path in external memory not accesible\n");
3111         } else {
3112                 fclose(fp);
3113                 fp = NULL;
3114                 *accessible = 1;
3115                 _LOGD("pkgmgr_get_pkg_external_validation() : SD_CARD \n");
3116                 return PMINFO_R_OK;
3117         }
3118
3119         /*check whether application is in internal or not */
3120         fp = fopen(app_dir_path, "r");
3121         if (fp == NULL) {
3122                 _LOGD(" app path in internal memory not accesible\n");
3123                 *accessible = 0;
3124                 return PMINFO_R_ERROR;
3125         } else {
3126                 fclose(fp);
3127                 /*check whether the application is installed in SD card
3128                 but SD card is not present*/
3129                 fp = fopen(app_mmc_internal_path, "r");
3130                 if (fp == NULL){
3131                         *accessible = 1;
3132                         _LOGD("pkgmgr_get_pkg_external_validation() : INTERNAL_MEM \n");
3133                         return PMINFO_R_OK;
3134                 }
3135                 else{
3136                         *accessible = 0;
3137                         _LOGD("pkgmgr_get_pkg_external_validation() : ERROR_MMC_STATUS \n");
3138                 }
3139                 fclose(fp);
3140         }
3141
3142         _LOGD("pkgmgr_get_pkg_external_validation() end\n");
3143         return PMINFO_R_OK;
3144 }
3145
3146 API int pkgmgrinfo_pkginfo_is_removable(pkgmgrinfo_pkginfo_h handle, bool *removable)
3147 {
3148         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
3149         retvm_if(removable == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
3150         char *val = NULL;
3151         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
3152         val = (char *)info->manifest_info->removable;
3153         if (val) {
3154                 if (strcasecmp(val, "true") == 0)
3155                         *removable = 1;
3156                 else if (strcasecmp(val, "false") == 0)
3157                         *removable = 0;
3158                 else
3159                         *removable = 1;
3160         }
3161         return PMINFO_R_OK;
3162 }
3163
3164 API int pkgmgrinfo_pkginfo_is_movable(pkgmgrinfo_pkginfo_h handle, bool *movable)
3165 {
3166         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
3167         retvm_if(movable == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
3168
3169         char *val = NULL;
3170         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
3171
3172         val = (char *)info->manifest_info->installlocation;
3173         if (val) {
3174                 if (strcmp(val, "internal-only") == 0)
3175                         *movable = 0;
3176                 else if (strcmp(val, "prefer-external") == 0)
3177                         *movable = 1;
3178                 else
3179                         *movable = 1;
3180         }
3181
3182         return PMINFO_R_OK;
3183 }
3184
3185 API int pkgmgrinfo_pkginfo_is_preload(pkgmgrinfo_pkginfo_h handle, bool *preload)
3186 {
3187         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
3188         retvm_if(preload == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
3189         char *val = NULL;
3190         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
3191         val = (char *)info->manifest_info->preload;
3192         if (val) {
3193                 if (strcasecmp(val, "true") == 0)
3194                         *preload = 1;
3195                 else if (strcasecmp(val, "false") == 0)
3196                         *preload = 0;
3197                 else
3198                         *preload = 0;
3199         }
3200         return PMINFO_R_OK;
3201 }
3202
3203 API int pkgmgrinfo_pkginfo_is_readonly(pkgmgrinfo_pkginfo_h handle, bool *readonly)
3204 {
3205         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
3206         retvm_if(readonly == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
3207         char *val = NULL;
3208         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
3209         val = (char *)info->manifest_info->readonly;
3210         if (val) {
3211                 if (strcasecmp(val, "true") == 0)
3212                         *readonly = 1;
3213                 else if (strcasecmp(val, "false") == 0)
3214                         *readonly = 0;
3215                 else
3216                         *readonly = 0;
3217         }
3218         return PMINFO_R_OK;
3219 }
3220
3221 API int pkgmgrinfo_pkginfo_is_update(pkgmgrinfo_pkginfo_h handle, bool *update)
3222 {
3223         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
3224         retvm_if(update == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
3225
3226         char *val = NULL;
3227         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
3228         val = (char *)info->manifest_info->update;
3229         if (val) {
3230                 if (strcasecmp(val, "true") == 0)
3231                         *update = 1;
3232                 else if (strcasecmp(val, "false") == 0)
3233                         *update = 0;
3234                 else
3235                         *update = 1;
3236         }
3237         return PMINFO_R_OK;
3238 }
3239
3240 API int pkgmgrinfo_pkginfo_destroy_pkginfo(pkgmgrinfo_pkginfo_h handle)
3241 {
3242         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n");
3243         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
3244         __cleanup_pkginfo(info);
3245         return PMINFO_R_OK;
3246 }
3247
3248 API int pkgmgrinfo_pkginfo_filter_create(pkgmgrinfo_pkginfo_filter_h *handle)
3249 {
3250         retvm_if(handle == NULL, PMINFO_R_EINVAL, "Filter handle output parameter is NULL\n");
3251         *handle = NULL;
3252         pkgmgrinfo_filter_x *filter = (pkgmgrinfo_filter_x*)calloc(1, sizeof(pkgmgrinfo_filter_x));
3253         if (filter == NULL) {
3254                 _LOGE("Out of Memory!!!");
3255                 return PMINFO_R_ERROR;
3256         }
3257         *handle = filter;
3258         return PMINFO_R_OK;
3259 }
3260
3261 API int pkgmgrinfo_pkginfo_filter_destroy(pkgmgrinfo_pkginfo_filter_h handle)
3262 {
3263         retvm_if(handle == NULL, PMINFO_R_EINVAL, "Filter handle input parameter is NULL\n");
3264         pkgmgrinfo_filter_x *filter = (pkgmgrinfo_filter_x*)handle;
3265         if (filter->list){
3266                 g_slist_foreach(filter->list, __destroy_each_node, NULL);
3267                 g_slist_free(filter->list);
3268         }
3269         free(filter);
3270         filter = NULL;
3271         return PMINFO_R_OK;
3272 }
3273
3274 API int pkgmgrinfo_pkginfo_filter_add_int(pkgmgrinfo_pkginfo_filter_h handle,
3275                                 const char *property, const int value)
3276 {
3277         retvm_if(handle == NULL, PMINFO_R_EINVAL, "Filter handle input parameter is NULL\n");
3278         retvm_if(property == NULL, PMINFO_R_EINVAL, "Filter handle input parameter is NULL\n");
3279         char buf[PKG_VALUE_STRING_LEN_MAX] = {'\0'};
3280         char *val = NULL;
3281         GSList *link = NULL;
3282         int prop = -1;
3283         prop = _pminfo_pkginfo_convert_to_prop_int(property);
3284         if (prop < E_PMINFO_PKGINFO_PROP_PACKAGE_MIN_INT ||
3285                 prop > E_PMINFO_PKGINFO_PROP_PACKAGE_MAX_INT) {
3286                 _LOGE("Invalid Integer Property\n");
3287                 return PMINFO_R_EINVAL;
3288         }
3289         pkgmgrinfo_filter_x *filter = (pkgmgrinfo_filter_x*)handle;
3290         pkgmgrinfo_node_x *node = (pkgmgrinfo_node_x*)calloc(1, sizeof(pkgmgrinfo_node_x));
3291         if (node == NULL) {
3292                 _LOGE("Out of Memory!!!\n");
3293                 return PMINFO_R_ERROR;
3294         }
3295         snprintf(buf, PKG_VALUE_STRING_LEN_MAX - 1, "%d", value);
3296         val = strndup(buf, PKG_VALUE_STRING_LEN_MAX - 1);
3297         if (val == NULL) {
3298                 _LOGE("Out of Memory\n");
3299                 free(node);
3300                 node = NULL;
3301                 return PMINFO_R_ERROR;
3302         }
3303         node->prop = prop;
3304         node->value = val;
3305         /*If API is called multiple times for same property, we should override the previous values.
3306         Last value set will be used for filtering.*/
3307         link = g_slist_find_custom(filter->list, (gconstpointer)node, __compare_func);
3308         if (link)
3309                 filter->list = g_slist_delete_link(filter->list, link);
3310         filter->list = g_slist_append(filter->list, (gpointer)node);
3311         return PMINFO_R_OK;
3312
3313 }
3314
3315 API int pkgmgrinfo_pkginfo_filter_add_bool(pkgmgrinfo_pkginfo_filter_h handle,
3316                                 const char *property, const bool value)
3317 {
3318         retvm_if(handle == NULL, PMINFO_R_EINVAL, "Filter handle input parameter is NULL\n");
3319         retvm_if(property == NULL, PMINFO_R_EINVAL, "Filter handle input parameter is NULL\n");
3320         char *val = NULL;
3321         GSList *link = NULL;
3322         int prop = -1;
3323         prop = _pminfo_pkginfo_convert_to_prop_bool(property);
3324         if (prop < E_PMINFO_PKGINFO_PROP_PACKAGE_MIN_BOOL ||
3325                 prop > E_PMINFO_PKGINFO_PROP_PACKAGE_MAX_BOOL) {
3326                 _LOGE("Invalid Boolean Property\n");
3327                 return PMINFO_R_EINVAL;
3328         }
3329         pkgmgrinfo_filter_x *filter = (pkgmgrinfo_filter_x*)handle;
3330         pkgmgrinfo_node_x *node = (pkgmgrinfo_node_x*)calloc(1, sizeof(pkgmgrinfo_node_x));
3331         if (node == NULL) {
3332                 _LOGE("Out of Memory!!!\n");
3333                 return PMINFO_R_ERROR;
3334         }
3335         if (value)
3336                 val = strndup("('true','True')", 15);
3337         else
3338                 val = strndup("('false','False')", 17);
3339         if (val == NULL) {
3340                 _LOGE("Out of Memory\n");
3341                 free(node);
3342                 node = NULL;
3343                 return PMINFO_R_ERROR;
3344         }
3345         node->prop = prop;
3346         node->value = val;
3347         /*If API is called multiple times for same property, we should override the previous values.
3348         Last value set will be used for filtering.*/
3349         link = g_slist_find_custom(filter->list, (gconstpointer)node, __compare_func);
3350         if (link)
3351                 filter->list = g_slist_delete_link(filter->list, link);
3352         filter->list = g_slist_append(filter->list, (gpointer)node);
3353         return PMINFO_R_OK;
3354
3355 }
3356
3357 API int pkgmgrinfo_pkginfo_filter_add_string(pkgmgrinfo_pkginfo_filter_h handle,
3358                                 const char *property, const char *value)
3359 {
3360         retvm_if(handle == NULL, PMINFO_R_EINVAL, "Filter handle input parameter is NULL\n");
3361         retvm_if(property == NULL, PMINFO_R_EINVAL, "Filter handle input parameter is NULL\n");
3362         retvm_if(value == NULL, PMINFO_R_EINVAL, "Filter handle input parameter is NULL\n");
3363         char *val = NULL;
3364         GSList *link = NULL;
3365         int prop = -1;
3366         prop = _pminfo_pkginfo_convert_to_prop_str(property);
3367         if (prop < E_PMINFO_PKGINFO_PROP_PACKAGE_MIN_STR ||
3368                 prop > E_PMINFO_PKGINFO_PROP_PACKAGE_MAX_STR) {
3369                 _LOGE("Invalid String Property\n");
3370                 return PMINFO_R_EINVAL;
3371         }
3372         pkgmgrinfo_filter_x *filter = (pkgmgrinfo_filter_x*)handle;
3373         pkgmgrinfo_node_x *node = (pkgmgrinfo_node_x*)calloc(1, sizeof(pkgmgrinfo_node_x));
3374         if (node == NULL) {
3375                 _LOGE("Out of Memory!!!\n");
3376                 return PMINFO_R_ERROR;
3377         }
3378         if (strcmp(value, PMINFO_PKGINFO_INSTALL_LOCATION_AUTO) == 0)
3379                 val = strndup("auto", PKG_STRING_LEN_MAX - 1);
3380         else if (strcmp(value, PMINFO_PKGINFO_INSTALL_LOCATION_INTERNAL) == 0)
3381                 val = strndup("internal-only", PKG_STRING_LEN_MAX - 1);
3382         else if (strcmp(value, PMINFO_PKGINFO_INSTALL_LOCATION_EXTERNAL) == 0)
3383                 val = strndup("prefer-external", PKG_STRING_LEN_MAX - 1);
3384         else if (strcmp(value, "installed_internal") == 0)
3385                 val = strndup("installed_internal", PKG_STRING_LEN_MAX - 1);
3386         else if (strcmp(value, "installed_external") == 0)
3387                 val = strndup("installed_external", PKG_STRING_LEN_MAX - 1);
3388         else
3389                 val = strndup(value, PKG_STRING_LEN_MAX - 1);
3390         if (val == NULL) {
3391                 _LOGE("Out of Memory\n");
3392                 free(node);
3393                 node = NULL;
3394                 return PMINFO_R_ERROR;
3395         }
3396         node->prop = prop;
3397         node->value = val;
3398         /*If API is called multiple times for same property, we should override the previous values.
3399         Last value set will be used for filtering.*/
3400         link = g_slist_find_custom(filter->list, (gconstpointer)node, __compare_func);
3401         if (link)
3402                 filter->list = g_slist_delete_link(filter->list, link);
3403         filter->list = g_slist_append(filter->list, (gpointer)node);
3404         return PMINFO_R_OK;
3405
3406 }
3407
3408 API int pkgmgrinfo_pkginfo_filter_count(pkgmgrinfo_pkginfo_filter_h handle, int *count)
3409 {
3410         retvm_if(handle == NULL, PMINFO_R_EINVAL, "Filter handle input parameter is NULL\n");
3411         retvm_if(count == NULL, PMINFO_R_EINVAL, "Filter handle input parameter is NULL\n");
3412         char *syslocale = NULL;
3413         char *locale = NULL;
3414         char *condition = NULL;
3415         char *error_message = NULL;
3416         char query[MAX_QUERY_LEN] = {'\0'};
3417         char where[MAX_QUERY_LEN] = {'\0'};
3418         GSList *list;
3419         int ret = 0;
3420
3421         pkgmgrinfo_filter_x *filter = (pkgmgrinfo_filter_x*)handle;
3422         /*Get current locale*/
3423         syslocale = vconf_get_str(VCONFKEY_LANGSET);
3424         if (syslocale == NULL) {
3425                 _LOGE("current locale is NULL\n");
3426                 return PMINFO_R_ERROR;
3427         }
3428         locale = __convert_system_locale_to_manifest_locale(syslocale);
3429         if (locale == NULL) {
3430                 _LOGE("manifest locale is NULL\n");
3431                 free(syslocale);
3432                 return PMINFO_R_ERROR;
3433         }
3434
3435         ret = __open_manifest_db();
3436         if (ret == -1) {
3437                 _LOGE("Fail to open manifest DB\n");
3438                 ret = PMINFO_R_ERROR;
3439                 goto err;
3440         }
3441
3442         /*Start constructing query*/
3443         snprintf(query, MAX_QUERY_LEN - 1, FILTER_QUERY_COUNT_PACKAGE, locale);
3444
3445         /*Get where clause*/
3446         for (list = filter->list; list; list = g_slist_next(list)) {
3447                 __get_filter_condition(list->data, &condition);
3448                 if (condition) {
3449                         strncat(where, condition, sizeof(where) - strlen(where) -1);
3450                         where[sizeof(where) - 1] = '\0';
3451                         free(condition);
3452                         condition = NULL;
3453                 }
3454                 if (g_slist_next(list)) {
3455                         strncat(where, " and ", sizeof(where) - strlen(where) - 1);
3456                         where[sizeof(where) - 1] = '\0';
3457                 }
3458         }
3459         _LOGE("where = %s\n", where);
3460         if (strlen(where) > 0) {
3461                 strncat(query, where, sizeof(query) - strlen(query) - 1);
3462                 query[sizeof(query) - 1] = '\0';
3463         }
3464         _LOGE("query = %s\n", query);
3465
3466         /*Execute Query*/
3467         if (SQLITE_OK !=
3468             sqlite3_exec(manifest_db, query, __count_cb, (void *)count, &error_message)) {
3469                 _LOGE("Don't execute query = %s error message = %s\n", query,
3470                        error_message);
3471                 sqlite3_free(error_message);
3472                 sqlite3_close(manifest_db);
3473                 ret = PMINFO_R_ERROR;
3474                 *count = 0;
3475                 goto err;
3476         }
3477         ret = PMINFO_R_OK;
3478 err:
3479         if (locale) {
3480                 free(locale);
3481                 locale = NULL;
3482         }
3483         if (syslocale) {
3484                 free(syslocale);
3485                 syslocale = NULL;
3486         }
3487         sqlite3_close(manifest_db);
3488         return ret;
3489 }
3490
3491 API int pkgmgrinfo_pkginfo_filter_foreach_pkginfo(pkgmgrinfo_pkginfo_filter_h handle,
3492                                 pkgmgrinfo_pkg_list_cb pkg_cb, void *user_data)
3493 {
3494         retvm_if(handle == NULL, PMINFO_R_EINVAL, "Filter handle input parameter is NULL\n");
3495         retvm_if(pkg_cb == NULL, PMINFO_R_EINVAL, "Filter handle input parameter is NULL\n");
3496         char *syslocale = NULL;
3497         char *locale = NULL;
3498         char *condition = NULL;
3499         char *error_message = NULL;
3500         char query[MAX_QUERY_LEN] = {'\0'};
3501         char where[MAX_QUERY_LEN] = {'\0'};
3502         GSList *list;
3503         int ret = 0;
3504         label_x *tmp1 = NULL;
3505         icon_x *tmp2 = NULL;
3506         description_x *tmp3 = NULL;
3507         author_x *tmp4 = NULL;
3508         privilege_x *tmp5 = NULL;
3509         pkgmgr_pkginfo_x *node = NULL;
3510         pkgmgr_pkginfo_x *tmphead = NULL;
3511         pkgmgr_pkginfo_x *pkginfo = NULL;
3512
3513         pkgmgrinfo_filter_x *filter = (pkgmgrinfo_filter_x*)handle;
3514         /*Get current locale*/
3515         syslocale = vconf_get_str(VCONFKEY_LANGSET);
3516         if (syslocale == NULL) {
3517                 _LOGE("current locale is NULL\n");
3518                 return PMINFO_R_ERROR;
3519         }
3520         locale = __convert_system_locale_to_manifest_locale(syslocale);
3521         if (locale == NULL) {
3522                 _LOGE("manifest locale is NULL\n");
3523                 free(syslocale);
3524                 return PMINFO_R_ERROR;
3525         }
3526
3527         ret = __open_manifest_db();
3528         if (ret == -1) {
3529                 _LOGE("Fail to open manifest DB\n");
3530                 ret = PMINFO_R_ERROR;
3531                 goto err;
3532         }
3533         /*Start constructing query*/
3534         snprintf(query, MAX_QUERY_LEN - 1, FILTER_QUERY_LIST_PACKAGE, locale);
3535
3536         /*Get where clause*/
3537         for (list = filter->list; list; list = g_slist_next(list)) {
3538                 __get_filter_condition(list->data, &condition);
3539                 if (condition) {
3540                         strncat(where, condition, sizeof(where) - strlen(where) -1);
3541                         where[sizeof(where) - 1] = '\0';
3542                         free(condition);
3543                         condition = NULL;
3544                 }
3545                 if (g_slist_next(list)) {
3546                         strncat(where, " and ", sizeof(where) - strlen(where) - 1);
3547                         where[sizeof(where) - 1] = '\0';
3548                 }
3549         }
3550         _LOGE("where = %s\n", where);
3551         if (strlen(where) > 0) {
3552                 strncat(query, where, sizeof(query) - strlen(query) - 1);
3553                 query[sizeof(query) - 1] = '\0';
3554         }
3555         _LOGE("query = %s\n", query);
3556         tmphead = calloc(1, sizeof(pkgmgr_pkginfo_x));
3557         if (tmphead == NULL) {
3558                 _LOGE("Out of Memory!!!\n");
3559                 ret = PMINFO_R_ERROR;
3560                 goto err;
3561         }
3562
3563         if (SQLITE_OK !=
3564             sqlite3_exec(manifest_db, query, __pkg_list_cb, (void *)tmphead, &error_message)) {
3565                 _LOGE("Don't execute query = %s error message = %s\n", query,
3566                        error_message);
3567                 sqlite3_free(error_message);
3568                 sqlite3_close(manifest_db);
3569                 ret = PMINFO_R_ERROR;
3570                 goto err;
3571         }
3572
3573         LISTHEAD(tmphead, node);
3574         for(node = node->next ; node ; node = node->next) {
3575                 pkginfo = node;
3576                 pkginfo->locale = strdup(locale);
3577                 pkginfo->manifest_info->privileges = (privileges_x *)calloc(1, sizeof(privileges_x));
3578                 if (pkginfo->manifest_info->privileges == NULL) {
3579                         _LOGE("Failed to allocate memory for privileges info\n");
3580                         ret = PMINFO_R_ERROR;
3581                         goto err;
3582                 }
3583
3584                 /*populate manifest_info from DB*/
3585                 snprintf(query, MAX_QUERY_LEN, "select * from package_info where package='%s' ", pkginfo->manifest_info->package);
3586                 ret = __exec_pkginfo_query(query, (void *)pkginfo);
3587                 if (ret == -1) {
3588                         _LOGE("Package Info DB Information retrieval failed\n");
3589                         ret = PMINFO_R_ERROR;
3590                         goto err;
3591                 }
3592                 memset(query, '\0', MAX_QUERY_LEN);
3593                 snprintf(query, MAX_QUERY_LEN, "select * from package_localized_info where" \
3594                         " package='%s' and package_locale='%s'", pkginfo->manifest_info->package, locale);
3595                 ret = __exec_pkginfo_query(query, (void *)pkginfo);
3596                 if (ret == -1) {
3597                         _LOGE("Package Info DB Information retrieval failed\n");
3598                         ret = PMINFO_R_ERROR;
3599                         goto err;
3600                 }
3601                 /*Also store the values corresponding to default locales*/
3602                 memset(query, '\0', MAX_QUERY_LEN);
3603                 snprintf(query, MAX_QUERY_LEN, "select * from package_localized_info where" \
3604                         " package='%s' and package_locale='%s'", pkginfo->manifest_info->package, DEFAULT_LOCALE);
3605                 ret = __exec_pkginfo_query(query, (void *)pkginfo);
3606                 if (ret == -1) {
3607                         _LOGE("Package Info DB Information retrieval failed\n");
3608                         ret = PMINFO_R_ERROR;
3609                         goto err;
3610                 }
3611                 if (pkginfo->manifest_info->label) {
3612                         LISTHEAD(pkginfo->manifest_info->label, tmp1);
3613                         pkginfo->manifest_info->label = tmp1;
3614                 }
3615                 if (pkginfo->manifest_info->icon) {
3616                         LISTHEAD(pkginfo->manifest_info->icon, tmp2);
3617                         pkginfo->manifest_info->icon = tmp2;
3618                 }
3619                 if (pkginfo->manifest_info->description) {
3620                         LISTHEAD(pkginfo->manifest_info->description, tmp3);
3621                         pkginfo->manifest_info->description = tmp3;
3622                 }
3623                 if (pkginfo->manifest_info->author) {
3624                         LISTHEAD(pkginfo->manifest_info->author, tmp4);
3625                         pkginfo->manifest_info->author = tmp4;
3626                 }
3627                 if (pkginfo->manifest_info->privileges->privilege) {
3628                         LISTHEAD(pkginfo->manifest_info->privileges->privilege, tmp5);
3629                         pkginfo->manifest_info->privileges->privilege = tmp5;
3630                 }
3631         }
3632
3633         LISTHEAD(tmphead, node);
3634
3635         for(node = node->next ; node ; node = node->next) {
3636                 pkginfo = node;
3637                 ret = pkg_cb( (void *)pkginfo, user_data);
3638                 if(ret < 0)
3639                         break;
3640         }
3641         ret = PMINFO_R_OK;
3642
3643 err:
3644         if (locale) {
3645                 free(locale);
3646                 locale = NULL;
3647         }
3648         if (syslocale) {
3649                 free(syslocale);
3650                 syslocale = NULL;
3651         }
3652         sqlite3_close(manifest_db);
3653         __cleanup_pkginfo(tmphead);
3654         return ret;
3655 }
3656
3657 API int pkgmgrinfo_pkginfo_foreach_privilege(pkgmgrinfo_pkginfo_h handle,
3658                         pkgmgrinfo_pkg_privilege_list_cb privilege_func, void *user_data)
3659 {
3660         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL");
3661         retvm_if(privilege_func == NULL, PMINFO_R_EINVAL, "Callback function is NULL");
3662         int ret = -1;
3663         privilege_x *ptr = NULL;
3664         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
3665         ptr = info->manifest_info->privileges->privilege;
3666         for (; ptr; ptr = ptr->next) {
3667                 ret = privilege_func(ptr->text, user_data);
3668                 if (ret < 0)
3669                         break;
3670         }
3671         return PMINFO_R_OK;
3672 }
3673
3674 API int pkgmgrinfo_appinfo_get_list(pkgmgrinfo_pkginfo_h handle, pkgmgrinfo_app_component component,
3675                                                 pkgmgrinfo_app_list_cb app_func, void *user_data)
3676 {
3677         retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL");
3678         retvm_if(app_func == NULL, PMINFO_R_EINVAL, "callback pointer is NULL");
3679         retvm_if((component != PMINFO_UI_APP) && (component != PMINFO_SVC_APP) && (component != PMINFO_ALL_APP), PMINFO_R_EINVAL, "Invalid App Component Type");
3680
3681         char *syslocale = NULL;
3682         char *locale = NULL;
3683         int ret = -1;
3684         char query[MAX_QUERY_LEN] = {'\0'};
3685         pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle;
3686         pkgmgr_pkginfo_x *allinfo = NULL;
3687         pkgmgr_appinfo_x *appinfo = NULL;
3688         icon_x *ptr1 = NULL;
3689         label_x *ptr2 = NULL;
3690         category_x *ptr3 = NULL;
3691         metadata_x *ptr4 = NULL;
3692         permission_x *ptr5 = NULL;
3693         image_x *ptr6 = NULL;
3694         sqlite3 *appinfo_db = NULL;
3695
3696         /*get system locale*/
3697         syslocale = vconf_get_str(VCONFKEY_LANGSET);
3698         tryvm_if(syslocale == NULL, ret = PMINFO_R_EINVAL, "current locale is NULL");
3699
3700         /*get locale on db*/
3701         locale = __convert_system_locale_to_manifest_locale(syslocale);
3702         tryvm_if(locale == NULL, ret = PMINFO_R_EINVAL, "manifest locale is NULL");
3703
3704         /*calloc allinfo*/
3705         allinfo = (pkgmgr_pkginfo_x *)calloc(1, sizeof(pkgmgr_pkginfo_x));
3706         tryvm_if(allinfo == NULL, ret = PMINFO_R_ERROR, "Failed to allocate memory for appinfo");
3707
3708         /*calloc manifest_info*/
3709         allinfo->manifest_info = (manifest_x *)calloc(1, sizeof(manifest_x));
3710         tryvm_if(allinfo->manifest_info == NULL, ret = PMINFO_R_ERROR, "Out of Memory!!!");
3711
3712         /*calloc appinfo*/
3713         appinfo = (pkgmgr_appinfo_x *)calloc(1, sizeof(pkgmgr_appinfo_x));
3714         tryvm_if(appinfo == NULL, ret = PMINFO_R_ERROR, "Failed to allocate memory for appinfo");
3715
3716         /*set component type*/
3717         if (component == PMINFO_UI_APP)
3718                 appinfo->app_component = PMINFO_UI_APP;
3719         if (component == PMINFO_SVC_APP)
3720                 appinfo->app_component = PMINFO_SVC_APP;
3721         if (component == PMINFO_ALL_APP)
3722                 appinfo->app_component = PMINFO_ALL_APP;
3723
3724         /*open db */
3725         ret = db_util_open_with_options(MANIFEST_DB, &appinfo_db, SQLITE_OPEN_READONLY, NULL);
3726         retvm_if(ret != SQLITE_OK, ret = PMINFO_R_ERROR, "connect db [%s] failed!", MANIFEST_DB);
3727
3728         appinfo->package = strdup(info->manifest_info->package);
3729         snprintf(query, MAX_QUERY_LEN, "select DISTINCT * " \
3730                         "from package_app_info where " \
3731                         "package='%s' and app_component='%s'",
3732                         info->manifest_info->package,
3733                         (appinfo->app_component==PMINFO_UI_APP ? "uiapp" : "svcapp"));
3734
3735         switch(component) {
3736         case PMINFO_UI_APP:
3737                 /*Populate ui app info */
3738                 ret = __exec_db_query(appinfo_db, query, __uiapp_list_cb, (void *)info);
3739                 tryvm_if(ret == -1, ret = PMINFO_R_ERROR, "App Info list retrieval failed");
3740
3741                 uiapplication_x *tmp = NULL;
3742                 if (info->manifest_info->uiapplication) {
3743                         LISTHEAD(info->manifest_info->uiapplication, tmp);
3744                         info->manifest_info->uiapplication = tmp;
3745                 }
3746                 /*Populate localized info for default locales and call callback*/
3747                 /*If the callback func return < 0 we break and no more call back is called*/
3748                 while(tmp != NULL)
3749                 {
3750                         appinfo->locale = strdup(locale);
3751                         appinfo->uiapp_info = tmp;
3752                         if (strcmp(appinfo->uiapp_info->type,"c++app") == 0){
3753                                 if (locale) {
3754                                         free(locale);
3755                                 }
3756                                 locale = __get_app_locale_by_fallback(appinfo_db, appinfo->uiapp_info->appid, syslocale);
3757                         }
3758
3759                         memset(query, '\0', MAX_QUERY_LEN);
3760                         snprintf(query, MAX_QUERY_LEN, "select * from package_app_localized_info where app_id='%s' and app_locale='%s'", appinfo->uiapp_info->appid, locale);
3761                         ret = __exec_db_query(appinfo_db, query, __appinfo_cb, (void *)appinfo);
3762                         tryvm_if(ret == -1, ret = PMINFO_R_ERROR, "App Localized Info DB Information retrieval failed");
3763
3764                         memset(query, '\0', MAX_QUERY_LEN);
3765                         snprintf(query, MAX_QUERY_LEN, "select * from package_app_localized_info where app_id='%s' and app_locale='%s'", appinfo->uiapp_info->appid, DEFAULT_LOCALE);
3766                         ret = __exec_db_query(appinfo_db, query, __appinfo_cb, (void *)appinfo);
3767                         tryvm_if(ret == -1, ret = PMINFO_R_ERROR, "App Localized Info DB Information retrieval failed");
3768
3769                         /*store setting notification icon section*/
3770                         memset(query, '\0', MAX_QUERY_LEN);
3771                         snprintf(query, MAX_QUERY_LEN, "select * from package_app_icon_section_info where app_id='%s'", appinfo->uiapp_info->appid);
3772                         ret = __exec_db_query(appinfo_db, query, __appinfo_cb, (void *)appinfo);
3773                         tryvm_if(ret == -1, ret = PMINFO_R_ERROR, "App icon section Info DB Information retrieval failed");
3774
3775                         /*store app preview image info*/
3776                         memset(query, '\0', MAX_QUERY_LEN);
3777                         snprintf(query, MAX_QUERY_LEN, "select app_image_section, app_image from package_app_image_info where app_id='%s'", appinfo->uiapp_info->appid);
3778                         ret = __exec_db_query(appinfo_db, query, __appinfo_cb, (void *)appinfo);
3779                         tryvm_if(ret == -1, ret = PMINFO_R_ERROR, "App image Info DB Information retrieval failed");
3780
3781                         if (appinfo->uiapp_info->label) {
3782                                 LISTHEAD(appinfo->uiapp_info->label, ptr2);
3783                                 appinfo->uiapp_info->label = ptr2;
3784                         }
3785                         if (appinfo->uiapp_info->icon) {
3786                                 LISTHEAD(appinfo->uiapp_info->icon, ptr1);
3787                                 appinfo->uiapp_info->icon = ptr1;
3788                         }
3789                         if (appinfo->uiapp_info->category) {
3790                                 LISTHEAD(appinfo->uiapp_info->category, ptr3);
3791                                 appinfo->uiapp_info->category = ptr3;
3792                         }
3793                         if (appinfo->uiapp_info->metadata) {
3794                                 LISTHEAD(appinfo->uiapp_info->metadata, ptr4);
3795                                 appinfo->uiapp_info->metadata = ptr4;
3796                         }
3797                         if (appinfo->uiapp_info->permission) {
3798                                 LISTHEAD(appinfo->uiapp_info->permission, ptr5);
3799                                 appinfo->uiapp_info->permission = ptr5;
3800                         }
3801                         if (appinfo->uiapp_info->image) {
3802                                 LISTHEAD(appinfo->uiapp_info->image, ptr6);
3803                                 appinfo->uiapp_info->image = ptr6;
3804                         }
3805                         ret = app_func((void *)appinfo, user_data);
3806                         if (ret < 0)
3807                                 break;
3808                         tmp = tmp->next;
3809                 }
3810                 break;
3811         case PMINFO_SVC_APP:
3812                 /*Populate svc app info */
3813                 ret = __exec_db_query(appinfo_db, query, __svcapp_list_cb, (void *)info);
3814                 tryvm_if(ret == -1, ret = PMINFO_R_ERROR, "App Info list retrieval failed");
3815
3816                 serviceapplication_x *tmp1 = NULL;
3817                 if (info->manifest_info->serviceapplication) {
3818                         LISTHEAD(info->manifest_info->serviceapplication, tmp1);
3819                         info->manifest_info->serviceapplication = tmp1;
3820                 }
3821                 /*Populate localized info for default locales and call callback*/
3822                 /*If the callback func return < 0 we break and no more call back is called*/
3823                 while(tmp1 != NULL)
3824                 {
3825                         appinfo->locale = strdup(locale);
3826                         appinfo->svcapp_info = tmp1;
3827                         memset(query, '\0', MAX_QUERY_LEN);
3828                         snprintf(query, MAX_QUERY_LEN, "select * from package_app_localized_info where app_id='%s' and app_locale='%s'", appinfo->svcapp_info->appid, locale);
3829                         ret = __exec_db_query(appinfo_db, query, __appinfo_cb, (void *)appinfo);
3830                         tryvm_if(ret == -1, ret = PMINFO_R_ERROR, "App Localized Info DB Information retrieval failed");
3831
3832                         memset(query, '\0', MAX_QUERY_LEN);
3833                         snprintf(query, MAX_QUERY_LEN, "select * from package_app_localized_info where app_id='%s' and app_locale='%s'", appinfo->svcapp_info->appid, DEFAULT_LOCALE);
3834                         ret = __exec_db_query(appinfo_db, query, __appinfo_cb, (void *)appinfo);
3835                         tryvm_if(ret == -1, ret = PMINFO_R_ERROR, "App Localized Info DB Information retrieval failed");
3836
3837                         if (appinfo->svcapp_info->label) {
3838                                 LISTHEAD(appinfo->svcapp_info->label, ptr2);
3839                                 appinfo->svcapp_info->label = ptr2;
3840                         }
3841                         if (appinfo->svcapp_info->icon) {
3842                                 LISTHEAD(appinfo->svcapp_info->icon, ptr1);
3843                                 appinfo->svcapp_info->icon = ptr1;
3844                         }
3845                         if (appinfo->svcapp_info->category) {
3846                                 LISTHEAD(appinfo->svcapp_info->category, ptr3);
3847                                 appinfo->svcapp_info->category = ptr3;
3848                         }
3849                         if (appinfo->svcapp_info->metadata) {
3850                                 LISTHEAD(appinfo->svcapp_info->metadata, ptr4);
3851                                 appinfo->svcapp_info->metadata = ptr4;
3852                         }
3853                         if (appinfo->svcapp_info->permission) {
3854                                 LISTHEAD(appinfo->svcapp_info->permission, ptr5);
3855                                 appinfo->svcapp_info->permission = ptr5;
3856                         }
3857                         ret = app_func((void *)appinfo, user_data);
3858                         if (ret < 0)
3859                                 break;
3860                         tmp1 = tmp1->next;
3861                 }
3862                 break;
3863         case PMINFO_ALL_APP:
3864                 memset(query, '\0', MAX_QUERY_LEN);
3865                 snprintf(query, MAX_QUERY_LEN, "select * from package_app_info where package='%s'", info->manifest_info->package);
3866
3867                 /*Populate all app info */
3868                 ret = __exec_db_query(appinfo_db, query, __allapp_list_cb, (void *)allinfo);
3869                 tryvm_if(ret == -1, ret = PMINFO_R_ERROR, "App Info list retrieval failed");
3870
3871                 /*UI Apps*/
3872                 appinfo->app_component = PMINFO_UI_APP;
3873                 uiapplication_x *tmp2 = NULL;
3874                 if (allinfo->manifest_info->uiapplication) {
3875                         LISTHEAD(allinfo->manifest_info->uiapplication, tmp2);
3876                         allinfo->manifest_info->uiapplication = tmp2;
3877                 }
3878                 /*Populate localized info for default locales and call callback*/
3879                 /*If the callback func return < 0 we break and no more call back is called*/
3880                 while(tmp2 != NULL)
3881                 {
3882                         appinfo->locale = strdup(locale);
3883                         appinfo->uiapp_info = tmp2;
3884                         memset(query, '\0', MAX_QUERY_LEN);
3885                         snprintf(query, MAX_QUERY_LEN, "select * from package_app_localized_info where app_id='%s' and app_locale='%s'", appinfo->uiapp_info->appid, locale);
3886                         ret = __exec_db_query(appinfo_db, query, __appinfo_cb, (void *)appinfo);
3887                         tryvm_if(ret == -1, ret = PMINFO_R_ERROR, "App Localized Info DB Information retrieval failed");
3888
3889                         memset(query, '\0', MAX_QUERY_LEN);
3890                         snprintf(query, MAX_QUERY_LEN, "select * from package_app_localized_info where app_id='%s' and app_locale='%s'", appinfo->uiapp_info->appid, DEFAULT_LOCALE);
3891                         ret = __exec_db_query(appinfo_db, query, __appinfo_cb, (void *)appinfo);
3892                         tryvm_if(ret == -1, ret = PMINFO_R_ERROR, "App Localized Info DB Information retrieval failed");
3893
3894                         /*store setting notification icon section*/
3895                         memset(query, '\0', MAX_QUERY_LEN);
3896                         snprintf(query, MAX_QUERY_LEN, "select * from package_app_icon_section_info where app_id='%s'", appinfo->uiapp_info->appid);
3897                         ret = __exec_db_query(appinfo_db, query, __appinfo_cb, (void *)appinfo);
3898                         tryvm_if(ret == -1, ret = PMINFO_R_ERROR, "App icon section Info DB Information retrieval failed");
3899
3900                         /*store app preview image info*/
3901                         memset(query, '\0', MAX_QUERY_LEN);
3902                         snprintf(query, MAX_QUERY_LEN, "select app_image_section, app_image from package_app_image_info where app_id='%s'", appinfo->uiapp_info->appid);
3903                         ret = __exec_db_query(appinfo_db, query, __appinfo_cb, (void *)appinfo);
3904                         tryvm_if(ret == -1, ret = PMINFO_R_ERROR, "App image Info DB Information retrieval failed");
3905
3906                         if (appinfo->uiapp_info->label) {
3907                                 LISTHEAD(appinfo->uiapp_info->label, ptr2);
3908                                 appinfo->uiapp_info->label = ptr2;
3909                         }
3910                         if (appinfo->uiapp_info->icon) {
3911                                 LISTHEAD(appinfo->uiapp_info->icon, ptr1);
3912                                 appinfo->uiapp_info->icon = ptr1;
3913                         }
3914                         if (appinfo->uiapp_info->category) {
3915                                 LISTHEAD(appinfo->uiapp_info->category, ptr3);
3916                                 appinfo->uiapp_info->category = ptr3;
3917                         }
3918                         if (appinfo->uiapp_info->metadata) {
3919                                 LISTHEAD(appinfo->uiapp_info->metadata, ptr4);
3920                                 appinfo->uiapp_info->metadata = ptr4;
3921                         }
3922                         if (appinfo->uiapp_info->permission) {
3923                                 LISTHEAD(appinfo->uiapp_info->permission, ptr5);
3924                                 appinfo->uiapp_info->permission = ptr5;
3925                         }
3926                         if (appinfo->uiapp_info->image) {
3927                                 LISTHEAD(appinfo->uiapp_info->image, ptr6);
3928                                 appinfo->uiapp_info->image = ptr6;
3929                         }
3930                         ret = app_func((void *)appinfo, user_data);
3931                         if (ret < 0)
3932                                 break;
3933                         tmp2 = tmp2->next;
3934                 }
3935
3936                 /*SVC Apps*/
3937                 appinfo->app_component = PMINFO_SVC_APP;
3938                 serviceapplication_x *tmp3 = NULL;
3939                 if (allinfo->manifest_info->serviceapplication) {
3940                         LISTHEAD(allinfo->manifest_info->serviceapplication, tmp3);
3941                         allinfo->manifest_info->serviceapplication = tmp3;
3942                 }
3943                 /*Populate localized info for default locales and call callback*/
3944                 /*If the callback func return < 0 we break and no more call back is called*/
3945                 while(tmp3 != NULL)
3946                 {
3947                         appinfo->locale = strdup(locale);
3948                         appinfo->svcapp_info = tmp3;
3949                         memset(query, '\0', MAX_QUERY_LEN);
3950                         snprintf(query, MAX_QUERY_LEN, "select * from package_app_localized_info where app_id='%s' and app_locale='%s'", appinfo->svcapp_info->appid, locale);
3951                         ret = __exec_db_query(appinfo_db, query, __appinfo_cb, (void *)appinfo);
3952                         tryvm_if(ret == -1, ret = PMINFO_R_ERROR, "App Localized Info DB Information retrieval failed");
3953
3954                         memset(query, '\0', MAX_QUERY_LEN);
3955                         snprintf(query, MAX_QUERY_LEN, "select * from package_app_localized_info where app_id='%s' and app_locale='%s'", appinfo->svcapp_info->appid, DEFAULT_LOCALE);
3956                         ret = __exec_db_query(appinfo_db, query, __appinfo_cb, (void *)appinfo);
3957                         tryvm_if(ret == -1, ret = PMINFO_R_ERROR, "App Localized Info DB Information retrieval failed");
3958
3959                         if (appinfo->svcapp_info->label) {
3960                                 LISTHEAD(appinfo->svcapp_info->label, ptr2);
3961                                 appinfo->svcapp_info->label = ptr2;
3962                         }
3963                         if (appinfo->svcapp_info->icon) {
3964                                 LISTHEAD(appinfo->svcapp_info->icon, ptr1);
3965                                 appinfo->svcapp_info->icon = ptr1;
3966                         }
3967                         if (appinfo->svcapp_info->category) {
3968                                 LISTHEAD(appinfo->svcapp_info->category, ptr3);
3969                                 appinfo->svcapp_info->category = ptr3;
3970                         }
3971                         if (appinfo->svcapp_info->metadata) {
3972                                 LISTHEAD(appinfo->svcapp_info->metadata, ptr4);
3973                                 appinfo->svcapp_info->metadata = ptr4;
3974                         }
3975                         if (appinfo->svcapp_info->permission) {
3976                                 LISTHEAD(appinfo->svcapp_info->permission, ptr5);
3977                                 appinfo->svcapp_info->permission = ptr5;
3978                         }
3979                         ret = app_func((void *)appinfo, user_data);
3980                         if (ret < 0)
3981                                 break;
3982                         tmp3 = tmp3->next;
3983                 }
3984                 appinfo->app_component = PMINFO_ALL_APP;
3985                 break;
3986
3987         }
3988
3989         ret = PMINFO_R_OK;
3990 catch:
3991         if (locale) {
3992                 free(locale);
3993                 locale = NULL;
3994         }
3995         if (syslocale) {
3996                 free(syslocale);
3997                 syslocale = NULL;
3998         }
3999         if (appinfo) {
4000                 if (appinfo->package) {
4001                         free((void *)appinfo->package);
4002                         appinfo->package = NULL;
4003                 }
4004                 free(appinfo);
4005                 appinfo = NULL;
4006         }
4007         __cleanup_pkginfo(allinfo);
4008
4009         sqlite3_close(appinfo_db);
4010         return ret;
4011 }
4012
4013 API int pkgmgrinfo_appinfo_get_install_list(pkgmgrinfo_app_list_cb app_func, void *user_data)
4014 {
4015         retvm_if(app_func == NULL, PMINFO_R_EINVAL, "callback function is NULL");
4016
4017         int ret = PMINFO_R_OK;
4018         char query[MAX_QUERY_LEN] = {'\0'};
4019         pkgmgr_appinfo_x *info = NULL;
4020         pkgmgr_appinfo_x *appinfo = NULL;
4021         uiapplication_x *ptr1 = NULL;
4022         sqlite3 *appinfo_db = NULL;
4023
4024         /*open db*/
4025         ret = db_util_open_with_options(MANIFEST_DB, &appinfo_db, SQLITE_OPEN_READONLY, NULL);
4026         retvm_if(ret != SQLITE_OK, ret = PMINFO_R_ERROR, "connect db [%s] failed!", MANIFEST_DB);
4027
4028         /*calloc appinfo*/
4029         info = (pkgmgr_appinfo_x *)calloc(1, sizeof(pkgmgr_appinfo_x));
4030         tryvm_if(info == NULL, ret = PMINFO_R_ERROR, "Out of Memory!!!");
4031
4032         /*calloc uiapplication_x*/
4033         info->uiapp_info= (uiapplication_x *)calloc(1, sizeof(uiapplication_x));
4034         tryvm_if(info->uiapp_info == NULL, ret = PMINFO_R_ERROR, "Out of Memory!!!");
4035
4036         /*calloc appinfo*/
4037         appinfo = (pkgmgr_appinfo_x *)calloc(1, sizeof(pkgmgr_appinfo_x));
4038         tryvm_if(appinfo == NULL, ret = PMINFO_R_ERROR, "Out of Memory!!!");
4039
4040         /*query package_app_info*/
4041         snprintf(query, MAX_QUERY_LEN, "select * from package_app_info");
4042         ret = __exec_db_query(appinfo_db, query, __mini_appinfo_cb, (void *)info);
4043         tryvm_if(ret == -1, ret = PMINFO_R_ERROR, "App Info DB Information retrieval failed");
4044
4045         LISTHEAD(info->uiapp_info, ptr1);
4046
4047         /*call back*/
4048         for(ptr1 = ptr1->next ; ptr1 ; ptr1 = ptr1->next)
4049         {
4050                 appinfo->uiapp_info= ptr1;
4051                 appinfo->package = strdup(ptr1->package);
4052                 if (strcmp(ptr1->app_component, "uiapp") == 0)
4053                         appinfo->app_component = PMINFO_UI_APP;
4054                 else
4055                         appinfo->app_component = PMINFO_SVC_APP;
4056
4057                 ret = app_func((void *)appinfo, user_data);
4058                 if (ret < 0)
4059                         break;
4060                 free((void *)appinfo->package);
4061                 appinfo->package = NULL;
4062         }
4063
4064 catch:
4065         sqlite3_close(appinfo_db);
4066
4067         if (appinfo) {
4068                 free(appinfo);
4069                 appinfo = NULL;
4070         }
4071         __cleanup_appinfo(info);
4072         return ret;
4073 }
4074
4075 API int pkgmgrinfo_appinfo_get_installed_list(pkgmgrinfo_app_list_cb app_func, void *user_data)
4076 {
4077         retvm_if(app_func == NULL, PMINFO_R_EINVAL, "callback function is NULL");
4078
4079         int ret = PMINFO_R_OK;
4080         char query[MAX_QUERY_LEN] = {'\0'};
4081         char *syslocale = NULL;
4082         char *locale = NULL;
4083         pkgmgr_appinfo_x *appinfo = NULL;
4084         uiapplication_x *ptr1 = NULL;
4085         serviceapplication_x *ptr2 = NULL;
4086         label_x *tmp1 = NULL;
4087         icon_x *tmp2 = NULL;
4088         category_x *tmp3 = NULL;
4089         metadata_x *tmp4 = NULL;
4090         permission_x *tmp5 = NULL;
4091         image_x *tmp6 = NULL;
4092         sqlite3 *appinfo_db = NULL;
4093
4094         /*get system locale*/
4095         syslocale = vconf_get_str(VCONFKEY_LANGSET);
4096         tryvm_if(syslocale == NULL, ret = PMINFO_R_ERROR, "current locale is NULL");
4097
4098         /*get locale on db*/
4099         locale = __convert_system_locale_to_manifest_locale(syslocale);
4100         tryvm_if(locale == NULL, ret = PMINFO_R_ERROR, "manifest locale is NULL");
4101
4102         /*open db*/
4103         ret = db_util_open_with_options(MANIFEST_DB, &appinfo_db, SQLITE_OPEN_READONLY, NULL);
4104         retvm_if(ret != SQLITE_OK, ret = PMINFO_R_ERROR, "connect db [%s] failed!", MANIFEST_DB);
4105
4106         /*calloc pkginfo*/
4107         pkgmgr_pkginfo_x *info = NULL;
4108         info = (pkgmgr_pkginfo_x *)calloc(1, sizeof(pkgmgr_pkginfo_x));
4109         tryvm_if(info == NULL, ret = PMINFO_R_ERROR, "Out of Memory!!!");
4110
4111         /*calloc manifest_info*/
4112         info->manifest_info = (manifest_x *)calloc(1, sizeof(manifest_x));
4113         tryvm_if(info->manifest_info == NULL, ret = PMINFO_R_ERROR, "Out of Memory!!!");
4114
4115         /*calloc appinfo*/
4116         appinfo = (pkgmgr_appinfo_x *)calloc(1, sizeof(pkgmgr_appinfo_x));
4117         tryvm_if(appinfo == NULL, ret = PMINFO_R_ERROR, "Out of Memory!!!");
4118
4119         snprintf(query, MAX_QUERY_LEN, "select * from package_app_info");
4120         ret = __exec_db_query(appinfo_db, query, __app_list_cb, (void *)info);
4121         tryvm_if(ret == -1, ret = PMINFO_R_ERROR, "App Info DB Information retrieval failed");
4122
4123         if (info->manifest_info->uiapplication) {
4124                 LISTHEAD(info->manifest_info->uiapplication, ptr1);
4125                 info->manifest_info->uiapplication = ptr1;
4126         }
4127         if (info->manifest_info->serviceapplication) {
4128                 LISTHEAD(info->manifest_info->serviceapplication, ptr2);
4129                 info->manifest_info->serviceapplication = ptr2;
4130         }
4131
4132         /*UI Apps*/
4133         for(ptr1 = info->manifest_info->uiapplication; ptr1; ptr1 = ptr1->next)
4134         {
4135                 appinfo->locale = strdup(locale);
4136                 appinfo->app_component = PMINFO_UI_APP;
4137                 appinfo->package = strdup(ptr1->package);
4138                 appinfo->uiapp_info = ptr1;
4139                 snprintf(query, MAX_QUERY_LEN, "select DISTINCT * " \
4140                                 "from package_app_info where " \
4141                                 "app_id='%s'", ptr1->appid);
4142                 ret = __exec_db_query(appinfo_db, query, __appinfo_cb, (void *)appinfo);
4143                 tryvm_if(ret == -1, ret = PMINFO_R_ERROR, "App Info DB Information retrieval failed");
4144
4145                 if (strcmp(appinfo->uiapp_info->type,"c++app") == 0){
4146                         if (locale) {
4147                                 free(locale);
4148                         }
4149                         locale = __get_app_locale_by_fallback(appinfo_db, ptr1->appid, syslocale);
4150                 }
4151
4152                 memset(query, '\0', MAX_QUERY_LEN);
4153                 snprintf(query, MAX_QUERY_LEN, "select DISTINCT * " \
4154                                 "from package_app_localized_info where " \
4155                                 "app_id='%s' and app_locale='%s'",
4156                                 ptr1->appid, locale);
4157                 ret = __exec_db_query(appinfo_db, query, __appinfo_cb, (void *)appinfo);
4158                 tryvm_if(ret == -1, ret = PMINFO_R_ERROR, "App Localized Info DB Information retrieval failed");
4159
4160                 memset(query, '\0', MAX_QUERY_LEN);
4161                 snprintf(query, MAX_QUERY_LEN, "select DISTINCT * " \
4162                                 "from package_app_localized_info where " \
4163                                 "app_id='%s' and app_locale='%s'",
4164                                 ptr1->appid, DEFAULT_LOCALE);
4165
4166                 ret = __exec_db_query(appinfo_db, query, __appinfo_cb, (void *)appinfo);
4167                 tryvm_if(ret == -1, ret = PMINFO_R_ERROR, "App Localized Info DB Information retrieval failed");
4168
4169                 /*store setting notification icon section*/
4170                 memset(query, '\0', MAX_QUERY_LEN);
4171                 snprintf(query, MAX_QUERY_LEN, "select * from package_app_icon_section_info where app_id='%s'", ptr1->appid);
4172                 ret = __exec_db_query(appinfo_db, query, __appinfo_cb, (void *)appinfo);
4173                 tryvm_if(ret == -1, ret = PMINFO_R_ERROR, "App icon section Info DB Information retrieval failed");
4174
4175                 /*store app preview image info*/
4176                 memset(query, '\0', MAX_QUERY_LEN);
4177                 snprintf(query, MAX_QUERY_LEN, "select app_image_section, app_image from package_app_image_info where app_id='%s'", ptr1->appid);
4178                 ret = __exec_db_query(appinfo_db, query, __appinfo_cb, (void *)appinfo);
4179                 tryvm_if(ret == -1, ret = PMINFO_R_ERROR, "App image Info DB Information retrieval failed");
4180
4181                 if (appinfo->uiapp_info->label) {
4182                         LISTHEAD(appinfo->uiapp_info->label, tmp1);
4183                         appinfo->uiapp_info->label = tmp1;
4184                 }
4185                 if (appinfo->uiapp_info->icon) {
4186                         LISTHEAD(appinfo->uiapp_info->icon, tmp2);
4187                         appinfo->uiapp_info->icon= tmp2;
4188                 }
4189                 if (appinfo->uiapp_info->category) {
4190                         LISTHEAD(appinfo->uiapp_info->category, tmp3);
4191                         appinfo->uiapp_info->category = tmp3;
4192                 }
4193                 if (appinfo->uiapp_info->metadata) {
4194                         LISTHEAD(appinfo->uiapp_info->metadata, tmp4);
4195                         appinfo->uiapp_info->metadata = tmp4;
4196                 }
4197                 if (appinfo->uiapp_info->permission) {
4198                         LISTHEAD(appinfo->uiapp_info->permission, tmp5);
4199                         appinfo->uiapp_info->permission = tmp5;
4200                 }
4201                 if (appinfo->uiapp_info->image) {
4202                         LISTHEAD(appinfo->uiapp_info->image, tmp6);
4203                         appinfo->uiapp_info->image = tmp6;
4204                 }
4205                 ret = app_func((void *)appinfo, user_data);
4206                 if (ret < 0)
4207                         break;
4208                 free((void *)appinfo->package);
4209                 appinfo->package = NULL;
4210         }
4211         /*Service Apps*/
4212         for(ptr2 = info->manifest_info->serviceapplication; ptr2; ptr2 = ptr2->next)
4213         {
4214                 appinfo->locale = strdup(locale);
4215                 appinfo->app_component = PMINFO_SVC_APP;
4216                 appinfo->package = strdup(ptr2->package);
4217                 appinfo->svcapp_info = ptr2;
4218                 memset(query, '\0', MAX_QUERY_LEN);
4219                 snprintf(query, MAX_QUERY_LEN, "select DISTINCT * " \
4220                                 "from package_app_info where " \
4221                                 "app_id='%s'", ptr2->appid);
4222                 ret = __exec_db_query(appinfo_db, query, __appinfo_cb, (void *)appinfo);
4223                 tryvm_if(ret == -1, ret = PMINFO_R_ERROR, "App Info DB Information retrieval failed");
4224
4225                 memset(query, '\0', MAX_QUERY_LEN);
4226                 snprintf(query, MAX_QUERY_LEN, "select DISTINCT * " \
4227                                 "from package_app_localized_info where " \
4228                                 "app_id='%s' and app_locale='%s'",
4229                                 ptr2->appid, locale);
4230                 ret = __exec_db_query(appinfo_db, query, __appinfo_cb, (void *)appinfo);
4231                 tryvm_if(ret == -1, ret = PMINFO_R_ERROR, "App Info DB Information retrieval failed");
4232
4233                 memset(query, '\0', MAX_QUERY_LEN);
4234                 snprintf(query, MAX_QUERY_LEN, "select DISTINCT * " \
4235                                 "from package_app_localized_info where " \
4236                                 "app_id='%s' and app_locale='%s'",
4237                                 ptr2->appid, DEFAULT_LOCALE);
4238                 ret = __exec_db_query(appinfo_db, query, __appinfo_cb, (void *)appinfo);
4239                 tryvm_if(ret == -1, ret = PMINFO_R_ERROR, "App Info DB Information retrieval failed");
4240
4241                 if (appinfo->svcapp_info->label) {
4242                         LISTHEAD(appinfo->svcapp_info->label, tmp1);
4243                         appinfo->svcapp_info->label = tmp1;
4244                 }
4245                 if (appinfo->svcapp_info->icon) {
4246                         LISTHEAD(appinfo->svcapp_info->icon, tmp2);
4247                         appinfo->svcapp_info->icon= tmp2;
4248                 }
4249                 if (appinfo->svcapp_info->category) {
4250                         LISTHEAD(appinfo->svcapp_info->category, tmp3);
4251                         appinfo->svcapp_info->category = tmp3;
4252                 }
4253                 if (appinfo->svcapp_info->metadata) {
4254                         LISTHEAD(appinfo->svcapp_info->metadata, tmp4);
4255                         appinfo->svcapp_info->metadata = tmp4;
4256                 }
4257                 if (appinfo->svcapp_info->permission) {
4258                         LISTHEAD(appinfo->svcapp_info->permission, tmp5);
4259                         appinfo->svcapp_info->permission = tmp5;
4260                 }
4261                 ret = app_func((void *)appinfo, user_data);
4262                 if (ret < 0)
4263                         break;
4264                 free((void *)appinfo->package);
4265                 appinfo->package = NULL;
4266         }
4267         ret = PMINFO_R_OK;
4268
4269 catch:
4270         if (locale) {
4271                 free(locale);
4272                 locale = NULL;
4273         }
4274         if (syslocale) {
4275                 free(syslocale);
4276                 syslocale = NULL;
4277         }
4278         sqlite3_close(appinfo_db);
4279         if (appinfo) {
4280                 free(appinfo);
4281                 appinfo = NULL;
4282         }
4283         __cleanup_pkginfo(info);
4284         return ret;
4285 }
4286
4287 API int pkgmgrinfo_appinfo_get_appinfo(const char *appid, pkgmgrinfo_appinfo_h *handle)
4288 {
4289         retvm_if(appid == NULL, PMINFO_R_EINVAL, "appid is NULL");
4290         retvm_if(handle == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL");
4291
4292         pkgmgr_appinfo_x *appinfo = NULL;
4293         char *syslocale = NULL;
4294         char *locale = NULL;
4295         int ret = -1;
4296         int exist = 0;
4297         label_x *tmp1 = NULL;
4298         icon_x *tmp2 = NULL;
4299         category_x *tmp3 = NULL;
4300         metadata_x *tmp4 = NULL;
4301         permission_x *tmp5 = NULL;
4302         image_x *tmp6 = NULL;
4303         char query[MAX_QUERY_LEN] = {'\0'};
4304         sqlite3 *appinfo_db = NULL;
4305
4306         /*open db*/
4307         ret = db_util_open_with_options(MANIFEST_DB, &appinfo_db, SQLITE_OPEN_READONLY, NULL);
4308         retvm_if(ret != SQLITE_OK, ret = PMINFO_R_ERROR, "connect db [%s] failed!", MANIFEST_DB);
4309
4310         /*check appid exist on db*/
4311         snprintf(query, MAX_QUERY_LEN, "select exists(select * from package_app_info where app_id='%s')", appid);
4312         ret = __exec_db_query(appinfo_db, query, __validate_cb, (void *)&exist);
4313         tryvm_if(ret == -1, ret = PMINFO_R_ERROR, "sqlite3_exec fail");
4314         tryvm_if(exist == 0, ret = PMINFO_R_ERROR, "Appid[%s] not found in DB", appid);
4315
4316         /*get system locale*/
4317         syslocale = vconf_get_str(VCONFKEY_LANGSET);
4318         tryvm_if(syslocale == NULL, ret = PMINFO_R_ERROR, "current locale is NULL");
4319
4320         /*get locale on db*/
4321         locale = __convert_system_locale_to_manifest_locale(syslocale);
4322         tryvm_if(locale == NULL, ret = PMINFO_R_ERROR, "manifest locale is NULL");
4323
4324         /*calloc appinfo*/
4325         appinfo = (pkgmgr_appinfo_x *)calloc(1, sizeof(pkgmgr_appinfo_x));
4326         tryvm_if(appinfo == NULL, ret = PMINFO_R_ERROR, "Failed to allocate memory for appinfo");
4327
4328         /*check app_component from DB*/
4329         memset(query, '\0', MAX_QUERY_LEN);
4330         snprintf(query, MAX_QUERY_LEN, "select app_component, package from package_app_info where app_id='%s' ", appid);
4331         ret = __exec_db_query(appinfo_db, query, __appcomponent_cb, (void *)appinfo);
4332         tryvm_if(ret == -1, ret = PMINFO_R_ERROR, "App Info DB Information retrieval failed");
4333
4334         /*calloc app_component*/
4335         if (appinfo->app_component == PMINFO_UI_APP) {
4336                 appinfo->uiapp_info = (uiapplication_x *)calloc(1, sizeof(uiapplication_x));
4337                 tryvm_if(appinfo->uiapp_info == NULL, ret = PMINFO_R_ERROR, "Failed to allocate memory for uiapp info");
4338         } else {
4339                 appinfo->svcapp_info = (serviceapplication_x *)calloc(1, sizeof(serviceapplication_x));
4340                 tryvm_if(appinfo->svcapp_info == NULL, ret = PMINFO_R_ERROR, "Failed to allocate memory for svcapp info");
4341         }
4342         appinfo->locale = strdup(locale);
4343
4344         /*populate app_info from DB*/
4345         memset(query, '\0', MAX_QUERY_LEN);
4346         snprintf(query, MAX_QUERY_LEN, "select * from package_app_info where app_id='%s' ", appid);
4347         ret = __exec_db_query(appinfo_db, query, __appinfo_cb, (void *)appinfo);
4348         tryvm_if(ret == -1, ret = PMINFO_R_ERROR, "App Info DB Information retrieval failed");
4349
4350         memset(query, '\0', MAX_QUERY_LEN);
4351         snprintf(query, MAX_QUERY_LEN, "select * from package_app_localized_info where app_id='%s' and app_locale='%s'", appid, locale);
4352         ret = __exec_db_query(appinfo_db, query, __appinfo_cb, (void *)appinfo);
4353         tryvm_if(ret == -1, ret = PMINFO_R_ERROR, "App Info DB Information retrieval failed");
4354
4355         /*Also store the values corresponding to default locales*/
4356         memset(query, '\0', MAX_QUERY_LEN);
4357         snprintf(query, MAX_QUERY_LEN, "select * from package_app_localized_info where app_id='%s' and app_locale='%s'", appid, DEFAULT_LOCALE);
4358         ret = __exec_db_query(appinfo_db, query, __appinfo_cb, (void *)appinfo);
4359         tryvm_if(ret == -1, ret = PMINFO_R_ERROR, "App Localized Info DB Information retrieval failed");
4360
4361         /*Populate app category*/
4362         memset(query, '\0', MAX_QUERY_LEN);
4363         snprintf(query, MAX_QUERY_LEN, "select * from package_app_app_category where app_id='%s'", appid);
4364         ret = __exec_db_query(appinfo_db, query, __appinfo_cb, (void *)appinfo);
4365         tryvm_if(ret == -1, ret = PMINFO_R_ERROR, "App Category Info DB Information retrieval failed");
4366
4367         /*Populate app metadata*/
4368         memset(query, '\0', MAX_QUERY_LEN);
4369         snprintf(query, MAX_QUERY_LEN, "select * from package_app_app_metadata where app_id='%s'", appid);
4370         ret = __exec_db_query(appinfo_db, query, __appinfo_cb, (void *)appinfo);
4371         tryvm_if(ret == -1, ret = PMINFO_R_ERROR, "App Metadata Info DB Information retrieval failed");
4372
4373         /*Populate app permission*/
4374         memset(query, '\0', MAX_QUERY_LEN);
4375         snprintf(query, MAX_QUERY_LEN, "select * from package_app_app_permission where app_id='%s'", appid);
4376         ret = __exec_db_query(appinfo_db, query, __appinfo_cb, (void *)appinfo);
4377         tryvm_if(ret == -1, ret = PMINFO_R_ERROR, "App permission Info DB Information retrieval failed");
4378
4379         /*store setting notification icon section*/
4380         memset(query, '\0', MAX_QUERY_LEN);
4381         snprintf(query, MAX_QUERY_LEN, "select * from package_app_icon_section_info where app_id='%s'", appid);
4382         ret = __exec_db_query(appinfo_db, query, __appinfo_cb, (void *)appinfo);
4383         tryvm_if(ret == -1, ret = PMINFO_R_ERROR, "App icon section Info DB Information retrieval failed");
4384
4385         /*store app preview image info*/
4386         memset(query, '\0', MAX_QUERY_LEN);
4387         snprintf(query, MAX_QUERY_LEN, "select app_image_section, app_image from package_app_image_info where app_id='%s'", appid);
4388         ret = __exec_db_query(appinfo_db, query, __appinfo_cb, (void *)appinfo);
4389         tryvm_if(ret == -1, ret = PMINFO_R_ERROR, "App image Info DB Information retrieval failed");
4390
4391         switch (appinfo->app_component) {
4392         case PMINFO_UI_APP:
4393                 if (appinfo->uiapp_info->label) {
4394                         LISTHEAD(appinfo->uiapp_info->label, tmp1);
4395                         appinfo->uiapp_info->label = tmp1;
4396                 }
4397                 if (appinfo->uiapp_info->icon) {
4398                         LISTHEAD(appinfo->uiapp_info->icon, tmp2);
4399                         appinfo->uiapp_info->icon = tmp2;
4400                 }
4401                 if (appinfo->uiapp_info->category) {
4402                         LISTHEAD(appinfo->uiapp_info->category, tmp3);
4403                         appinfo->uiapp_info->category = tmp3;
4404                 }
4405                 if (appinfo->uiapp_info->metadata) {
4406                         LISTHEAD(appinfo->uiapp_info->metadata, tmp4);
4407                         appinfo->uiapp_info->metadata = tmp4;
4408                 }
4409                 if (appinfo->uiapp_info->permission) {
4410                         LISTHEAD(appinfo->uiapp_info->permission, tmp5);
4411                         appinfo->uiapp_info->permission = tmp5;
4412                 }
4413                 if (appinfo->uiapp_info->image) {
4414                         LISTHEAD(appinfo->uiapp_info->image, tmp6);
4415                         appinfo->uiapp_info->image = tmp6;
4416                 }
4417                 break;
4418         case PMINFO_SVC_APP:
4419                 if (appinfo->svcapp_info->label) {
4420                         LISTHEAD(appinfo->svcapp_info->label, tmp1);
4421                         appinfo->svcapp_info->label = tmp1;
4422                 }
4423                 if (appinfo->svcapp_info->icon) {
4424                         LISTHEAD(appinfo->svcapp_info->icon, tmp2);
4425                         appinfo->svcapp_info->icon = tmp2;
4426                 }
4427                 if (appinfo->svcapp_info->category) {
4428                         LISTHEAD(appinfo->svcapp_info->category, tmp3);
4429                         appinfo->svcapp_info->category = tmp3;
4430                 }
4431                 if (appinfo->svcapp_info->metadata) {
4432                         LISTHEAD(appinfo->svcapp_info->metadata, tmp4);
4433                         appinfo->svcapp_info->metadata = tmp4;
4434                 }
4435                 if (appinfo->svcapp_info->permission) {
4436                         LISTHEAD(appinfo->svcapp_info->permission, tmp5);
4437                         appinfo->svcapp_info->permission = tmp5;
4438                 }
4439                 break;
4440         default:
4441                 break;
4442         }
4443
4444         ret = PMINFO_R_OK;
4445
4446 catch:
4447         if (ret == PMINFO_R_OK)
4448                 *handle = (void*)appinfo;
4449         else {
4450                 *handle = NULL;
4451                 __cleanup_appinfo(appinfo);
4452         }
4453
4454         sqlite3_close(appinfo_db);
4455         if (syslocale) {
4456                 free(syslocale);
4457                 syslocale = NULL;
4458         }
4459         if (locale) {
4460                 free(locale);
4461                 locale = NULL;
4462         }
4463         return ret;
4464 }
4465
4466
4467 API int pkgmgrinfo_appinfo_get_appid(pkgmgrinfo_appinfo_h  handle, char **appid)
4468 {
4469         retvm_if(handle == NULL, PMINFO_R_EINVAL, "appinfo handle is NULL");
4470         retvm_if(appid == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL");
4471         pkgmgr_appinfo_x *info = (pkgmgr_appinfo_x *)handle;
4472
4473         if (info->app_component == PMINFO_UI_APP)
4474                 *appid = (char *)info->uiapp_info->appid;
4475         else if (info->app_component == PMINFO_SVC_APP)
4476                 *appid = (char *)info->svcapp_info->appid;
4477
4478         return PMINFO_R_OK;
4479 }
4480
4481 API int pkgmgrinfo_appinfo_get_pkgname(pkgmgrinfo_appinfo_h  handle, char **pkg_name)
4482 {
4483         retvm_if(handle == NULL, PMINFO_R_EINVAL, "appinfo handle is NULL");
4484         retvm_if(pkg_name == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL");
4485         pkgmgr_appinfo_x *info = (pkgmgr_appinfo_x *)handle;
4486
4487         *pkg_name = (char *)info->package;
4488
4489         return PMINFO_R_OK;
4490 }
4491
4492 API int pkgmgrinfo_appinfo_get_pkgid(pkgmgrinfo_appinfo_h  handle, char **pkgid)
4493 {
4494         retvm_if(handle == NULL, PMINFO_R_EINVAL, "appinfo handle is NULL");
4495         retvm_if(pkgid == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL");
4496         pkgmgr_appinfo_x *info = (pkgmgr_appinfo_x *)handle;
4497
4498         *pkgid = (char *)info->package;
4499
4500         return PMINFO_R_OK;
4501 }
4502
4503 API int pkgmgrinfo_appinfo_get_exec(pkgmgrinfo_appinfo_h  handle, char **exec)
4504 {
4505         retvm_if(handle == NULL, PMINFO_R_EINVAL, "appinfo handle is NULL");
4506         retvm_if(exec == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL");
4507         pkgmgr_appinfo_x *info = (pkgmgr_appinfo_x *)handle;
4508
4509         if (info->app_component == PMINFO_UI_APP)
4510                 *exec = (char *)info->uiapp_info->exec;
4511         if (info->app_component == PMINFO_SVC_APP)
4512                 *exec = (char *)info->svcapp_info->exec;
4513
4514         return PMINFO_R_OK;
4515 }
4516
4517
4518 API int pkgmgrinfo_appinfo_get_icon(pkgmgrinfo_appinfo_h  handle, char **icon)
4519 {
4520         retvm_if(handle == NULL, PMINFO_R_EINVAL, "appinfo handle is NULL");
4521         retvm_if(icon == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL");
4522         char *locale = NULL;
4523         icon_x *ptr = NULL;
4524         icon_x *start = NULL;
4525         *icon = NULL;
4526
4527         pkgmgr_appinfo_x *info = (pkgmgr_appinfo_x *)handle;
4528                 locale = info->locale;
4529                 retvm_if(locale == NULL, PMINFO_R_ERROR, "manifest locale is NULL");
4530
4531         if (info->app_component == PMINFO_UI_APP)
4532                 start = info->uiapp_info->icon;
4533         if (info->app_component == PMINFO_SVC_APP)
4534                 start = info->svcapp_info->icon;
4535         for(ptr = start; ptr != NULL; ptr = ptr->next)
4536         {
4537                 if (ptr->lang) {
4538                         if (strcmp(ptr->lang, locale) == 0) {
4539                                 *icon = (char *)ptr->text;
4540                                 if (strcasecmp(*icon, "(null)") == 0) {
4541                                         locale = DEFAULT_LOCALE;
4542                                         continue;
4543                                 } else
4544                                         break;
4545                         } else if (strcmp(ptr->lang, DEFAULT_LOCALE) == 0) {
4546                                 *icon = (char *)ptr->text;
4547                                 break;
4548                         }
4549                 }
4550         }
4551         return PMINFO_R_OK;
4552 }
4553
4554
4555 API int pkgmgrinfo_appinfo_get_label(pkgmgrinfo_appinfo_h  handle, char **label)
4556 {
4557         retvm_if(handle == NULL, PMINFO_R_EINVAL, "appinfo handle is NULL");
4558         retvm_if(label == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL");
4559         char *locale = NULL;
4560         label_x *ptr = NULL;
4561         label_x *start = NULL;
4562         *label = NULL;
4563
4564         pkgmgr_appinfo_x *info = (pkgmgr_appinfo_x *)handle;
4565         locale = info->locale;
4566         retvm_if(locale == NULL, PMINFO_R_ERROR, "manifest locale is NULL");
4567
4568         if (info->app_component == PMINFO_UI_APP)
4569                 start = info->uiapp_info->label;
4570         if (info->app_component == PMINFO_SVC_APP)
4571                 start = info->svcapp_info->label;
4572         for(ptr = start; ptr != NULL; ptr = ptr->next)
4573         {
4574                 if (ptr->lang) {
4575                         if (strcmp(ptr->lang, locale) == 0) {
4576                                 *label = (char *)ptr->text;
4577                                 if (strcasecmp(*label, "(null)") == 0) {
4578                                         locale = DEFAULT_LOCALE;
4579                                         continue;
4580                                 } else
4581                                         break;
4582                         } else if (strncasecmp(ptr->lang, locale, 2) == 0) {
4583                                 *label = (char *)ptr->text;
4584                                 if (strcasecmp(*label, "(null)") == 0) {
4585                                                 locale = DEFAULT_LOCALE;
4586                                                 continue;
4587                                 } else
4588                                                 break;
4589                         } else if (strcmp(ptr->lang, DEFAULT_LOCALE) == 0) {
4590                                 *label = (char *)ptr->text;
4591                                 break;
4592                         }
4593                 }
4594         }
4595         return PMINFO_R_OK;
4596 }
4597
4598
4599 API int pkgmgrinfo_appinfo_get_component(pkgmgrinfo_appinfo_h  handle, pkgmgrinfo_app_component *component)
4600 {
4601         retvm_if(handle == NULL, PMINFO_R_EINVAL, "appinfo handle is NULL");
4602         retvm_if(component == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL");
4603         pkgmgr_appinfo_x *info = (pkgmgr_appinfo_x *)handle;
4604
4605         if (info->app_component == PMINFO_UI_APP)
4606                 *component = PMINFO_UI_APP;
4607         else if (info->app_component == PMINFO_SVC_APP)
4608                 *component = PMINFO_SVC_APP;
4609         else
4610                 return PMINFO_R_ERROR;
4611
4612         return PMINFO_R_OK;
4613 }
4614
4615 API int pkgmgrinfo_appinfo_get_apptype(pkgmgrinfo_appinfo_h  handle, char **app_type)
4616 {
4617         retvm_if(handle == NULL, PMINFO_R_EINVAL, "appinfo handle is NULL");
4618         retvm_if(app_type == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL");
4619         pkgmgr_appinfo_x *info = (pkgmgr_appinfo_x *)handle;
4620
4621         if (info->app_component == PMINFO_UI_APP)
4622                 *app_type = (char *)info->uiapp_info->type;
4623         if (info->app_component == PMINFO_SVC_APP)
4624                 *app_type = (char *)info->svcapp_info->type;
4625
4626         return PMINFO_R_OK;
4627 }
4628
4629 API int pkgmgrinfo_appinfo_get_operation(pkgmgrinfo_appcontrol_h  handle,
4630                                         int *operation_count, char ***operation)
4631 {
4632         retvm_if(handle == NULL, PMINFO_R_EINVAL, "appinfo handle is NULL");
4633         retvm_if(operation == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL");
4634         retvm_if(operation_count == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL");
4635         pkgmgrinfo_appcontrol_x *data = (pkgmgrinfo_appcontrol_x *)handle;
4636         *operation_count = data->operation_count;
4637         *operation = data->operation;
4638         return PMINFO_R_OK;
4639 }
4640
4641 API int pkgmgrinfo_appinfo_get_uri(pkgmgrinfo_appcontrol_h  handle,
4642                                         int *uri_count, char ***uri)
4643 {
4644         retvm_if(handle == NULL, PMINFO_R_EINVAL, "appinfo handle is NULL");
4645         retvm_if(uri == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL");
4646         retvm_if(uri_count == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL");
4647         pkgmgrinfo_appcontrol_x *data = (pkgmgrinfo_appcontrol_x *)handle;
4648         *uri_count = data->uri_count;
4649         *uri = data->uri;
4650         return PMINFO_R_OK;
4651 }
4652
4653 API int pkgmgrinfo_appinfo_get_mime(pkgmgrinfo_appcontrol_h  handle,
4654                                         int *mime_count, char ***mime)
4655 {
4656         retvm_if(handle == NULL, PMINFO_R_EINVAL, "appinfo handle is NULL");
4657         retvm_if(mime == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL");
4658         retvm_if(mime_count == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL");
4659         pkgmgrinfo_appcontrol_x *data = (pkgmgrinfo_appcontrol_x *)handle;
4660         *mime_count = data->mime_count;
4661         *mime = data->mime;
4662         return PMINFO_R_OK;
4663 }
4664
4665 API int pkgmgrinfo_appinfo_get_setting_icon(pkgmgrinfo_appinfo_h  handle, char **icon)
4666 {
4667         retvm_if(handle == NULL, PMINFO_R_EINVAL, "appinfo handle is NULL\n");
4668         retvm_if(icon == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
4669
4670         char *val = NULL;
4671         icon_x *ptr = NULL;
4672         icon_x *start = NULL;
4673         pkgmgr_appinfo_x *info = (pkgmgr_appinfo_x *)handle;
4674
4675         start = info->uiapp_info->icon;
4676
4677         for(ptr = start; ptr != NULL; ptr = ptr->next)
4678         {
4679                 if (ptr->section) {
4680                         val = (char *)ptr->section;
4681                         if (strcmp(val, "setting") == 0){
4682                                 *icon = (char *)ptr->text;
4683                                 break;
4684                         }
4685                 }
4686         }
4687         return PMINFO_R_OK;
4688 }
4689
4690
4691 API int pkgmgrinfo_appinfo_get_notification_icon(pkgmgrinfo_appinfo_h  handle, char **icon)
4692 {
4693         retvm_if(handle == NULL, PMINFO_R_EINVAL, "appinfo handle is NULL\n");
4694         retvm_if(icon == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
4695
4696         char *val = NULL;
4697         icon_x *ptr = NULL;
4698         icon_x *start = NULL;
4699         pkgmgr_appinfo_x *info = (pkgmgr_appinfo_x *)handle;
4700
4701         start = info->uiapp_info->icon;
4702
4703         for(ptr = start; ptr != NULL; ptr = ptr->next)
4704         {
4705                 if (ptr->section) {
4706                         val = (char *)ptr->section;
4707
4708                         if (strcmp(val, "notification") == 0){
4709                                 *icon = (char *)ptr->text;
4710                                 break;
4711                         }
4712                 }
4713         }
4714
4715         return PMINFO_R_OK;
4716 }
4717
4718 API int pkgmgrinfo_appinfo_get_recent_image_type(pkgmgrinfo_appinfo_h  handle, pkgmgrinfo_app_recentimage *type)
4719 {
4720         retvm_if(handle == NULL, PMINFO_R_EINVAL, "appinfo handle is NULL");
4721         retvm_if(type == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL");
4722         char *val = NULL;
4723         pkgmgr_appinfo_x *info = (pkgmgr_appinfo_x *)handle;
4724         val = (char *)info->uiapp_info->recentimage;
4725         if (val) {
4726                 if (strcasecmp(val, "capture") == 0)
4727                         *type = PMINFO_RECENTIMAGE_USE_CAPTURE;
4728                 else if (strcasecmp(val, "icon") == 0)
4729                         *type = PMINFO_RECENTIMAGE_USE_ICON;
4730                 else
4731                         *type = PMINFO_RECENTIMAGE_USE_NOTHING;
4732         }
4733
4734         return PMINFO_R_OK;
4735 }
4736
4737 API int pkgmgrinfo_appinfo_get_preview_image(pkgmgrinfo_appinfo_h  handle, char **preview_img)
4738 {
4739         retvm_if(handle == NULL, PMINFO_R_EINVAL, "appinfo handle is NULL\n");
4740         retvm_if(preview_img == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
4741
4742         char *val = NULL;
4743         image_x *ptr = NULL;
4744         image_x *start = NULL;
4745         pkgmgr_appinfo_x *info = (pkgmgr_appinfo_x *)handle;
4746
4747         start = info->uiapp_info->image;
4748
4749         for(ptr = start; ptr != NULL; ptr = ptr->next)
4750         {
4751                 if (ptr->section) {
4752                         val = (char *)ptr->section;
4753
4754                         if (strcmp(val, "preview") == 0)
4755                                 *preview_img = (char *)ptr->text;
4756
4757                         break;
4758                 }
4759         }
4760         return PMINFO_R_OK;
4761 }
4762
4763 API int pkgmgrinfo_appinfo_get_permission_type(pkgmgrinfo_appinfo_h  handle, pkgmgrinfo_permission_type *permission)
4764 {
4765         retvm_if(handle == NULL, PMINFO_R_EINVAL, "appinfo handle is NULL\n");
4766         retvm_if(permission == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
4767
4768         char *val = NULL;
4769         pkgmgr_appinfo_x *info = (pkgmgr_appinfo_x *)handle;
4770
4771         val = info->uiapp_info->permission_type;
4772
4773         if (strcmp(val, "signature") == 0)
4774                 *permission = PMINFO_PERMISSION_SIGNATURE;
4775         else if (strcmp(val, "privilege") == 0)
4776                 *permission = PMINFO_PERMISSION_PRIVILEGE;
4777         else
4778                 *permission = PMINFO_PERMISSION_NORMAL;
4779
4780         return PMINFO_R_OK;
4781 }
4782
4783 API int pkgmgrinfo_appinfo_foreach_permission(pkgmgrinfo_appinfo_h handle,
4784                         pkgmgrinfo_app_permission_list_cb permission_func, void *user_data)
4785 {
4786         retvm_if(handle == NULL, PMINFO_R_EINVAL, "appinfo handle is NULL");
4787         retvm_if(permission_func == NULL, PMINFO_R_EINVAL, "Callback function is NULL");
4788         int ret = -1;
4789         permission_x *ptr = NULL;
4790         pkgmgr_appinfo_x *info = (pkgmgr_appinfo_x *)handle;
4791         if (info->app_component == PMINFO_UI_APP)
4792                 ptr = info->uiapp_info->permission;
4793         else if (info->app_component == PMINFO_SVC_APP)
4794                 ptr = info->svcapp_info->permission;
4795         else
4796                 return PMINFO_R_EINVAL;
4797         for (; ptr; ptr = ptr->next) {
4798                 ret = permission_func(ptr->value, user_data);
4799                 if (ret < 0)
4800                         break;
4801         }
4802         return PMINFO_R_OK;
4803 }
4804
4805 API int pkgmgrinfo_appinfo_foreach_category(pkgmgrinfo_appinfo_h handle,
4806                         pkgmgrinfo_app_category_list_cb category_func, void *user_data)
4807 {
4808         retvm_if(handle == NULL, PMINFO_R_EINVAL, "appinfo handle is NULL");
4809         retvm_if(category_func == NULL, PMINFO_R_EINVAL, "Callback function is NULL");
4810         int ret = -1;
4811         category_x *ptr = NULL;
4812         pkgmgr_appinfo_x *info = (pkgmgr_appinfo_x *)handle;
4813         if (info->app_component == PMINFO_UI_APP)
4814                 ptr = info->uiapp_info->category;
4815         else if (info->app_component == PMINFO_SVC_APP)
4816                 ptr = info->svcapp_info->category;
4817         else
4818                 return PMINFO_R_EINVAL;
4819         for (; ptr; ptr = ptr->next) {
4820                 ret = category_func(ptr->name, user_data);
4821                 if (ret < 0)
4822                         break;
4823         }
4824         return PMINFO_R_OK;
4825 }
4826
4827 API int pkgmgrinfo_appinfo_foreach_metadata(pkgmgrinfo_appinfo_h handle,
4828                         pkgmgrinfo_app_metadata_list_cb metadata_func, void *user_data)
4829 {
4830         retvm_if(handle == NULL, PMINFO_R_EINVAL, "appinfo handle is NULL");
4831         retvm_if(metadata_func == NULL, PMINFO_R_EINVAL, "Callback function is NULL");
4832         int ret = -1;
4833         metadata_x *ptr = NULL;
4834         pkgmgr_appinfo_x *info = (pkgmgr_appinfo_x *)handle;
4835         if (info->app_component == PMINFO_UI_APP)
4836                 ptr = info->uiapp_info->metadata;
4837         else if (info->app_component == PMINFO_SVC_APP)
4838                 ptr = info->svcapp_info->metadata;
4839         else
4840                 return PMINFO_R_EINVAL;
4841         for (; ptr; ptr = ptr->next) {
4842                 ret = metadata_func(ptr->key, ptr->value, user_data);
4843                 if (ret < 0)
4844                         break;
4845         }
4846         return PMINFO_R_OK;
4847 }
4848
4849 API int pkgmgrinfo_appinfo_foreach_appcontrol(pkgmgrinfo_appinfo_h handle,
4850                         pkgmgrinfo_app_control_list_cb appcontrol_func, void *user_data)
4851 {
4852         retvm_if(handle == NULL, PMINFO_R_EINVAL, "appinfo handle is NULL");
4853         retvm_if(appcontrol_func == NULL, PMINFO_R_EINVAL, "Callback function is NULL");
4854         int i = 0;
4855         int ret = -1;
4856         int oc = 0;
4857         int mc = 0;
4858         int uc = 0;
4859         char *pkgid = NULL;
4860         char *manifest = NULL;
4861         char **operation = NULL;
4862         char **uri = NULL;
4863         char **mime = NULL;
4864         appcontrol_x *appcontrol = NULL;
4865         manifest_x *mfx = NULL;
4866         operation_x *op = NULL;
4867         uri_x *ui = NULL;
4868         mime_x *mi = NULL;
4869         pkgmgrinfo_app_component component;
4870         pkgmgrinfo_appcontrol_x *ptr = NULL;
4871         ret = pkgmgrinfo_appinfo_get_pkgid(handle, &pkgid);
4872         if (ret < 0) {
4873                 _LOGE("Failed to get package name\n");
4874                 return PMINFO_R_ERROR;
4875         }
4876         ret = pkgmgrinfo_appinfo_get_component(handle, &component);
4877         if (ret < 0) {
4878                 _LOGE("Failed to get app component name\n");
4879                 return PMINFO_R_ERROR;
4880         }
4881         manifest = pkgmgr_parser_get_manifest_file(pkgid);
4882         if (manifest == NULL) {
4883                 _LOGE("Failed to fetch package manifest file\n");
4884                 return PMINFO_R_ERROR;
4885         }
4886         mfx = pkgmgr_parser_process_manifest_xml(manifest);
4887         if (mfx == NULL) {
4888                 _LOGE("Failed to parse package manifest file\n");
4889                 free(manifest);
4890                 manifest = NULL;
4891                 return PMINFO_R_ERROR;
4892         }
4893         free(manifest);
4894         ptr  = calloc(1, sizeof(pkgmgrinfo_appcontrol_x));
4895         if (ptr == NULL) {
4896                 _LOGE("Out of Memory!!!\n");
4897                 pkgmgr_parser_free_manifest_xml(mfx);
4898                 return PMINFO_R_ERROR;
4899         }
4900         /*Get Operation, Uri, Mime*/
4901         switch (component) {
4902         case PMINFO_UI_APP:
4903                 if (mfx->uiapplication) {
4904                         if (mfx->uiapplication->appcontrol) {
4905                                 appcontrol = mfx->uiapplication->appcontrol;
4906                         }
4907                 }
4908                 break;
4909         case PMINFO_SVC_APP:
4910                 if (mfx->serviceapplication) {
4911                         if (mfx->serviceapplication->appcontrol) {
4912                                 appcontrol = mfx->serviceapplication->appcontrol;
4913                         }
4914                 }
4915                 break;
4916         default:
4917                 break;
4918         }
4919         for (; appcontrol; appcontrol = appcontrol->next) {
4920                 op = appcontrol->operation;
4921                 for (; op; op = op->next)
4922                         oc = oc + 1;
4923                 op = appcontrol->operation;
4924
4925                 ui = appcontrol->uri;
4926                 for (; ui; ui = ui->next)
4927                         uc = uc + 1;
4928                 ui = appcontrol->uri;
4929
4930                 mi = appcontrol->mime;
4931                 for (; mi; mi = mi->next)
4932                         mc = mc + 1;
4933                 mi = appcontrol->mime;
4934
4935                 operation = (char **)calloc(oc, sizeof(char *));
4936                 for (i = 0; i < oc; i++) {
4937                         operation[i] = strndup(op->name, PKG_STRING_LEN_MAX - 1);
4938                         op = op->next;
4939                 }
4940
4941                 uri = (char **)calloc(uc, sizeof(char *));
4942                 for (i = 0; i < uc; i++) {
4943                         uri[i] = strndup(ui->name, PKG_STRING_LEN_MAX - 1);
4944                         ui = ui->next;
4945                 }
4946
4947                 mime = (char **)calloc(mc, sizeof(char *));
4948                 for (i = 0; i < mc; i++) {
4949                         mime[i] = strndup(mi->name, PKG_STRING_LEN_MAX - 1);
4950                         mi = mi->next;
4951                 }
4952                 /*populate appcontrol handle*/
4953                 ptr->operation_count = oc;
4954                 ptr->uri_count = uc;
4955                 ptr->mime_count = mc;
4956                 ptr->operation = operation;
4957                 ptr->uri = uri;
4958                 ptr->mime = mime;
4959                 ret = appcontrol_func((void *)ptr, user_data);
4960                 for (i = 0; i < oc; i++) {
4961                         if (operation[i]) {
4962                                 free(operation[i]);
4963                                 operation[i] = NULL;
4964                         }
4965                 }
4966                 if (operation) {
4967                         free(operation);
4968                         operation = NULL;
4969                 }
4970                 for (i = 0; i < uc; i++) {
4971                         if (uri[i]) {
4972                                 free(uri[i]);
4973                                 uri[i] = NULL;
4974                         }
4975                 }
4976                 if (uri) {
4977                         free(uri);
4978                         uri = NULL;
4979                 }
4980                 for (i = 0; i < mc; i++) {
4981                         if (mime[i]) {
4982                                 free(mime[i]);
4983                                 mime[i] = NULL;
4984                         }
4985                 }
4986                 if (mime) {
4987                         free(mime);
4988                         mime = NULL;
4989                 }
4990                 if (ret < 0)
4991                         break;
4992                 uc = 0;
4993                 mc = 0;
4994                 oc = 0;
4995         }
4996         pkgmgr_parser_free_manifest_xml(mfx);
4997         if (ptr) {
4998                 free(ptr);
4999                 ptr = NULL;
5000         }
5001         return PMINFO_R_OK;
5002 }
5003
5004 API int pkgmgrinfo_appinfo_is_nodisplay(pkgmgrinfo_appinfo_h  handle, bool *nodisplay)
5005 {
5006         retvm_if(handle == NULL, PMINFO_R_EINVAL, "appinfo handle is NULL");
5007         retvm_if(nodisplay == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL");
5008         char *val = NULL;
5009         pkgmgr_appinfo_x *info = (pkgmgr_appinfo_x *)handle;
5010         val = (char *)info->uiapp_info->nodisplay;
5011         if (val) {
5012                 if (strcasecmp(val, "true") == 0)
5013                         *nodisplay = 1;
5014                 else if (strcasecmp(val, "false") == 0)
5015                         *nodisplay = 0;
5016                 else
5017                         *nodisplay = 0;
5018         }
5019         return PMINFO_R_OK;
5020 }
5021
5022 API int pkgmgrinfo_appinfo_is_multiple(pkgmgrinfo_appinfo_h  handle, bool *multiple)
5023 {
5024         retvm_if(handle == NULL, PMINFO_R_EINVAL, "appinfo handle is NULL");
5025         retvm_if(multiple == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL");
5026         char *val = NULL;
5027         pkgmgr_appinfo_x *info = (pkgmgr_appinfo_x *)handle;
5028         val = (char *)info->uiapp_info->multiple;
5029         if (val) {
5030                 if (strcasecmp(val, "true") == 0)
5031                         *multiple = 1;
5032                 else if (strcasecmp(val, "false") == 0)
5033                         *multiple = 0;
5034                 else
5035                         *multiple = 0;
5036         }
5037         return PMINFO_R_OK;
5038 }
5039
5040 API int pkgmgrinfo_appinfo_is_indicator_display_allowed(pkgmgrinfo_appinfo_h handle, bool *indicator_disp)
5041 {
5042         retvm_if(handle == NULL, PMINFO_R_EINVAL, "appinfo handle is NULL");
5043         retvm_if(indicator_disp == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL");
5044         char *val = NULL;
5045         pkgmgr_appinfo_x *info = (pkgmgr_appinfo_x *)handle;
5046         val = (char *)info->uiapp_info->indicatordisplay;
5047         if (val) {
5048                 if (strcasecmp(val, "true") == 0){
5049                         *indicator_disp = 1;
5050                 }else if (strcasecmp(val, "false") == 0){
5051                         *indicator_disp = 0;
5052                 }else{
5053                         *indicator_disp = 0;
5054                 }
5055         }
5056         return PMINFO_R_OK;
5057 }
5058
5059
5060 API int pkgmgrinfo_appinfo_get_effectimage(pkgmgrinfo_appinfo_h  handle, char **portrait_img, char **landscape_img)
5061 {
5062         retvm_if(handle == NULL, PMINFO_R_EINVAL, "appinfo handle is NULL");
5063         retvm_if(portrait_img == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL");
5064         retvm_if(landscape_img == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL");
5065         pkgmgr_appinfo_x *info = (pkgmgr_appinfo_x *)handle;
5066
5067         if (info->app_component == PMINFO_UI_APP){
5068                 *portrait_img = (char *)info->uiapp_info->portraitimg;
5069                 *landscape_img = (char *)info->uiapp_info->landscapeimg;
5070         }
5071
5072         return PMINFO_R_OK;
5073 }
5074
5075 API int pkgmgrinfo_appinfo_is_taskmanage(pkgmgrinfo_appinfo_h  handle, bool *taskmanage)
5076 {
5077         retvm_if(handle == NULL, PMINFO_R_EINVAL, "appinfo handle is NULL");
5078         retvm_if(taskmanage == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL");
5079         char *val = NULL;
5080         pkgmgr_appinfo_x *info = (pkgmgr_appinfo_x *)handle;
5081         val = (char *)info->uiapp_info->taskmanage;
5082         if (val) {
5083                 if (strcasecmp(val, "true") == 0)
5084                         *taskmanage = 1;
5085                 else if (strcasecmp(val, "false") == 0)
5086                         *taskmanage = 0;
5087                 else
5088                         *taskmanage = 0;
5089         }
5090         return PMINFO_R_OK;
5091 }
5092
5093 API int pkgmgrinfo_appinfo_is_enabled(pkgmgrinfo_appinfo_h  handle, bool *enabled)
5094 {
5095         retvm_if(handle == NULL, PMINFO_R_EINVAL, "appinfo handle is NULL");
5096         retvm_if(enabled == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL");
5097         char *val = NULL;
5098         pkgmgr_appinfo_x *info = (pkgmgr_appinfo_x *)handle;
5099         if (info->app_component == PMINFO_UI_APP)
5100                 val = (char *)info->uiapp_info->enabled;
5101         else if (info->app_component == PMINFO_SVC_APP)
5102                 val = (char *)info->uiapp_info->enabled;
5103         else {
5104                 _LOGE("invalid component type\n");
5105                 return PMINFO_R_EINVAL;
5106         }
5107
5108         if (val) {
5109                 if (strcasecmp(val, "true") == 0)
5110                         *enabled = 1;
5111                 else if (strcasecmp(val, "false") == 0)
5112                         *enabled = 0;
5113                 else
5114                         *enabled = 1;
5115         }
5116         return PMINFO_R_OK;
5117
5118 }
5119
5120 API int pkgmgrinfo_appinfo_get_hwacceleration(pkgmgrinfo_appinfo_h  handle, pkgmgrinfo_app_hwacceleration *hwacceleration)
5121 {
5122         retvm_if(handle == NULL, PMINFO_R_EINVAL, "appinfo handle is NULL");
5123         retvm_if(hwacceleration == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL");
5124         char *val = NULL;
5125         pkgmgr_appinfo_x *info = (pkgmgr_appinfo_x *)handle;
5126         val = (char *)info->uiapp_info->hwacceleration;
5127         if (val) {
5128                 if (strcasecmp(val, "not-use-GL") == 0)
5129                         *hwacceleration = PMINFO_HWACCELERATION_NOT_USE_GL;
5130                 else if (strcasecmp(val, "use-GL") == 0)
5131                         *hwacceleration = PMINFO_HWACCELERATION_USE_GL;
5132                 else
5133                         *hwacceleration = PMINFO_HWACCELERATION_USE_SYSTEM_SETTING;
5134         }
5135         return PMINFO_R_OK;
5136 }
5137
5138 API int pkgmgrinfo_appinfo_is_onboot(pkgmgrinfo_appinfo_h  handle, bool *onboot)
5139 {
5140         retvm_if(handle == NULL, PMINFO_R_EINVAL, "appinfo handle is NULL");
5141         retvm_if(onboot == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL");
5142         char *val = NULL;
5143         pkgmgr_appinfo_x *info = (pkgmgr_appinfo_x *)handle;
5144         val = (char *)info->svcapp_info->onboot;
5145         if (val) {
5146                 if (strcasecmp(val, "true") == 0)
5147                         *onboot = 1;
5148                 else if (strcasecmp(val, "false") == 0)
5149                         *onboot = 0;
5150                 else
5151                         *onboot = 0;
5152         }
5153         return PMINFO_R_OK;
5154 }
5155
5156 API int pkgmgrinfo_appinfo_is_autorestart(pkgmgrinfo_appinfo_h  handle, bool *autorestart)
5157 {
5158         retvm_if(handle == NULL, PMINFO_R_EINVAL, "appinfo handle is NULL");
5159         retvm_if(autorestart == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL");
5160         char *val = NULL;
5161         pkgmgr_appinfo_x *info = (pkgmgr_appinfo_x *)handle;
5162         val = (char *)info->svcapp_info->autorestart;
5163         if (val) {
5164                 if (strcasecmp(val, "true") == 0)
5165                         *autorestart = 1;
5166                 else if (strcasecmp(val, "false") == 0)
5167                         *autorestart = 0;
5168                 else
5169                         *autorestart = 0;
5170         }
5171         return PMINFO_R_OK;
5172 }
5173
5174 API int pkgmgrinfo_appinfo_is_mainapp(pkgmgrinfo_appinfo_h  handle, bool *mainapp)
5175 {
5176         retvm_if(handle == NULL, PMINFO_R_EINVAL, "appinfo handle is NULL");
5177         retvm_if(mainapp == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL");
5178         char *val = NULL;
5179         pkgmgr_appinfo_x *info = (pkgmgr_appinfo_x *)handle;
5180         val = (char *)info->uiapp_info->mainapp;
5181         if (val) {
5182                 if (strcasecmp(val, "true") == 0)
5183                         *mainapp = 1;
5184                 else if (strcasecmp(val, "false") == 0)
5185                         *mainapp = 0;
5186                 else
5187                         *mainapp = 0;
5188         }
5189         return PMINFO_R_OK;
5190 }
5191
5192 API int pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo_h  handle)
5193 {
5194         retvm_if(handle == NULL, PMINFO_R_EINVAL, "appinfo handle is NULL");
5195         pkgmgr_appinfo_x *info = (pkgmgr_appinfo_x *)handle;
5196         __cleanup_appinfo(info);
5197         return PMINFO_R_OK;
5198 }
5199
5200 API int pkgmgrinfo_appinfo_filter_create(pkgmgrinfo_appinfo_filter_h *handle)
5201 {
5202         return (pkgmgrinfo_pkginfo_filter_create(handle));
5203 }
5204
5205 API int pkgmgrinfo_appinfo_filter_destroy(pkgmgrinfo_appinfo_filter_h handle)
5206 {
5207         return (pkgmgrinfo_pkginfo_filter_destroy(handle));
5208 }
5209
5210 API int pkgmgrinfo_appinfo_filter_add_int(pkgmgrinfo_appinfo_filter_h handle,
5211                                 const char *property, const int value)
5212 {
5213         retvm_if(handle == NULL, PMINFO_R_EINVAL, "Filter handle input parameter is NULL\n");
5214         retvm_if(property == NULL, PMINFO_R_EINVAL, "Filter handle input parameter is NULL\n");
5215         char buf[PKG_VALUE_STRING_LEN_MAX] = {'\0'};
5216         char *val = NULL;
5217         GSList *link = NULL;
5218         int prop = -1;
5219         prop = _pminfo_appinfo_convert_to_prop_int(property);
5220         if (prop < E_PMINFO_APPINFO_PROP_APP_MIN_INT ||
5221                 prop > E_PMINFO_APPINFO_PROP_APP_MAX_INT) {
5222                 _LOGE("Invalid Integer Property\n");
5223                 return PMINFO_R_EINVAL;
5224         }
5225         pkgmgrinfo_filter_x *filter = (pkgmgrinfo_filter_x*)handle;
5226         pkgmgrinfo_node_x *node = (pkgmgrinfo_node_x*)calloc(1, sizeof(pkgmgrinfo_node_x));
5227         if (node == NULL) {
5228                 _LOGE("Out of Memory!!!\n");
5229                 return PMINFO_R_ERROR;
5230         }
5231         snprintf(buf, PKG_VALUE_STRING_LEN_MAX - 1, "%d", value);
5232         val = strndup(buf, PKG_VALUE_STRING_LEN_MAX - 1);
5233         if (val == NULL) {
5234                 _LOGE("Out of Memory\n");
5235                 free(node);
5236                 node = NULL;
5237                 return PMINFO_R_ERROR;
5238         }
5239         node->prop = prop;
5240         node->value = val;
5241         /*If API is called multiple times for same property, we should override the previous values.
5242         Last value set will be used for filtering.*/
5243         link = g_slist_find_custom(filter->list, (gconstpointer)node, __compare_func);
5244         if (link)
5245                 filter->list = g_slist_delete_link(filter->list, link);
5246         filter->list = g_slist_append(filter->list, (gpointer)node);
5247         return PMINFO_R_OK;
5248
5249 }
5250
5251 API int pkgmgrinfo_appinfo_filter_add_bool(pkgmgrinfo_appinfo_filter_h handle,
5252                                 const char *property, const bool value)
5253 {
5254         retvm_if(handle == NULL, PMINFO_R_EINVAL, "Filter handle input parameter is NULL\n");
5255         retvm_if(property == NULL, PMINFO_R_EINVAL, "Filter handle input parameter is NULL\n");
5256         char *val = NULL;
5257         GSList *link = NULL;
5258         int prop = -1;
5259         prop = _pminfo_appinfo_convert_to_prop_bool(property);
5260         if (prop < E_PMINFO_APPINFO_PROP_APP_MIN_BOOL ||
5261                 prop > E_PMINFO_APPINFO_PROP_APP_MAX_BOOL) {
5262                 _LOGE("Invalid Boolean Property\n");
5263                 return PMINFO_R_EINVAL;
5264         }
5265         pkgmgrinfo_filter_x *filter = (pkgmgrinfo_filter_x*)handle;
5266         pkgmgrinfo_node_x *node = (pkgmgrinfo_node_x*)calloc(1, sizeof(pkgmgrinfo_node_x));
5267         if (node == NULL) {
5268                 _LOGE("Out of Memory!!!\n");
5269                 return PMINFO_R_ERROR;
5270         }
5271         if (value)
5272                 val = strndup("('true','True')", 15);
5273         else
5274                 val = strndup("('false','False')", 17);
5275         if (val == NULL) {
5276                 _LOGE("Out of Memory\n");
5277                 free(node);
5278                 node = NULL;
5279                 return PMINFO_R_ERROR;
5280         }
5281         node->prop = prop;
5282         node->value = val;
5283         /*If API is called multiple times for same property, we should override the previous values.
5284         Last value set will be used for filtering.*/
5285         link = g_slist_find_custom(filter->list, (gconstpointer)node, __compare_func);
5286         if (link)
5287                 filter->list = g_slist_delete_link(filter->list, link);
5288         filter->list = g_slist_append(filter->list, (gpointer)node);
5289         return PMINFO_R_OK;
5290
5291 }
5292
5293 API int pkgmgrinfo_appinfo_filter_add_string(pkgmgrinfo_appinfo_filter_h handle,
5294                                 const char *property, const char *value)
5295 {
5296         retvm_if(handle == NULL, PMINFO_R_EINVAL, "Filter handle input parameter is NULL\n");
5297         retvm_if(property == NULL, PMINFO_R_EINVAL, "Filter handle input parameter is NULL\n");
5298         retvm_if(value == NULL, PMINFO_R_EINVAL, "Filter handle input parameter is NULL\n");
5299         char *val = NULL;
5300         pkgmgrinfo_node_x *ptr = NULL;
5301         char prev[PKG_STRING_LEN_MAX] = {'\0'};
5302         char temp[PKG_STRING_LEN_MAX] = {'\0'};
5303         GSList *link = NULL;
5304         int prop = -1;
5305         prop = _pminfo_appinfo_convert_to_prop_str(property);
5306         if (prop < E_PMINFO_APPINFO_PROP_APP_MIN_STR ||
5307                 prop > E_PMINFO_APPINFO_PROP_APP_MAX_STR) {
5308                 _LOGE("Invalid String Property\n");
5309                 return PMINFO_R_EINVAL;
5310         }
5311         pkgmgrinfo_filter_x *filter = (pkgmgrinfo_filter_x*)handle;
5312         pkgmgrinfo_node_x *node = (pkgmgrinfo_node_x*)calloc(1, sizeof(pkgmgrinfo_node_x));
5313         if (node == NULL) {
5314                 _LOGE("Out of Memory!!!\n");
5315                 return PMINFO_R_ERROR;
5316         }
5317         node->prop = prop;
5318         switch (prop) {
5319         case E_PMINFO_APPINFO_PROP_APP_COMPONENT:
5320                 if (strcmp(value, PMINFO_APPINFO_UI_APP) == 0)
5321                         val = strndup("uiapp", PKG_STRING_LEN_MAX - 1);
5322                 else
5323                         val = strndup("svcapp", PKG_STRING_LEN_MAX - 1);
5324                 node->value = val;
5325                 link = g_slist_find_custom(filter->list, (gconstpointer)node, __compare_func);
5326                 if (link)
5327                         filter->list = g_slist_delete_link(filter->list, link);
5328                 filter->list = g_slist_append(filter->list, (gpointer)node);
5329                 break;
5330         case E_PMINFO_APPINFO_PROP_APP_CATEGORY:
5331         case E_PMINFO_APPINFO_PROP_APP_OPERATION:
5332         case E_PMINFO_APPINFO_PROP_APP_URI:
5333         case E_PMINFO_APPINFO_PROP_APP_MIME:
5334                 val = (char *)calloc(1, PKG_STRING_LEN_MAX);
5335                 if (val == NULL) {
5336                         _LOGE("Out of Memory\n");
5337                         free(node);
5338                         node = NULL;
5339                         return PMINFO_R_ERROR;
5340                 }
5341                 link = g_slist_find_custom(filter->list, (gconstpointer)node, __compare_func);
5342                 if (link) {
5343                         ptr = (pkgmgrinfo_node_x *)link->data;
5344                         strncpy(prev, ptr->value, PKG_STRING_LEN_MAX - 1);
5345                         _LOGE("Previous value is %s\n", prev);
5346                         filter->list = g_slist_delete_link(filter->list, link);
5347                         snprintf(temp, PKG_STRING_LEN_MAX - 1, "%s , '%s'", prev, value);
5348                         strncpy(val, temp, PKG_STRING_LEN_MAX - 1);
5349                         _LOGE("New value is %s\n", val);
5350                         node->value = val;
5351                         filter->list = g_slist_append(filter->list, (gpointer)node);
5352                         memset(temp, '\0', PKG_STRING_LEN_MAX);
5353                 } else {
5354                         snprintf(temp, PKG_STRING_LEN_MAX - 1, "'%s'", value);
5355                         strncpy(val, temp, PKG_STRING_LEN_MAX - 1);
5356                         _LOGE("First value is %s\n", val);
5357                         node->value = val;
5358                         filter->list = g_slist_append(filter->list, (gpointer)node);
5359                         memset(temp, '\0', PKG_STRING_LEN_MAX);
5360                 }
5361                 break;
5362         default:
5363                 node->value = strndup(value, PKG_STRING_LEN_MAX - 1);
5364                 link = g_slist_find_custom(filter->list, (gconstpointer)node, __compare_func);
5365                 if (link)
5366                         filter->list = g_slist_delete_link(filter->list, link);
5367                 filter->list = g_slist_append(filter->list, (gpointer)node);
5368                 break;
5369         }
5370         return PMINFO_R_OK;
5371 }
5372
5373 API int pkgmgrinfo_appinfo_filter_count(pkgmgrinfo_appinfo_filter_h handle, int *count)
5374 {
5375         retvm_if(handle == NULL, PMINFO_R_EINVAL, "Filter handle input parameter is NULL\n");
5376         retvm_if(count == NULL, PMINFO_R_EINVAL, "Filter handle input parameter is NULL\n");
5377         char *syslocale = NULL;
5378         char *locale = NULL;
5379         char *condition = NULL;
5380         char *error_message = NULL;
5381         char query[MAX_QUERY_LEN] = {'\0'};
5382         char where[MAX_QUERY_LEN] = {'\0'};
5383         GSList *list;
5384         int ret = 0;
5385
5386         pkgmgrinfo_filter_x *filter = (pkgmgrinfo_filter_x*)handle;
5387         /*Get current locale*/
5388         syslocale = vconf_get_str(VCONFKEY_LANGSET);
5389         if (syslocale == NULL) {
5390                 _LOGE("current locale is NULL\n");
5391                 return PMINFO_R_ERROR;
5392         }
5393         locale = __convert_system_locale_to_manifest_locale(syslocale);
5394         if (locale == NULL) {
5395                 _LOGE("manifest locale is NULL\n");
5396                 free(syslocale);
5397                 return PMINFO_R_ERROR;
5398         }
5399
5400         ret = __open_manifest_db();
5401         if (ret == -1) {
5402                 _LOGE("Fail to open manifest DB\n");
5403                 ret = PMINFO_R_ERROR;
5404                 goto err;
5405         }
5406
5407         /*Start constructing query*/
5408         snprintf(query, MAX_QUERY_LEN - 1, FILTER_QUERY_COUNT_APP, locale);
5409
5410         /*Get where clause*/
5411         for (list = filter->list; list; list = g_slist_next(list)) {
5412                 __get_filter_condition(list->data, &condition);
5413                 if (condition) {
5414                         strncat(where, condition, sizeof(where) - strlen(where) -1);
5415                         where[sizeof(where) - 1] = '\0';
5416                         free(condition);
5417                         condition = NULL;
5418                 }
5419                 if (g_slist_next(list)) {
5420                         strncat(where, " and ", sizeof(where) - strlen(where) - 1);
5421                         where[sizeof(where) - 1] = '\0';
5422                 }
5423         }
5424         _LOGE("where = %s\n", where);
5425         if (strlen(where) > 0) {
5426                 strncat(query, where, sizeof(query) - strlen(query) - 1);
5427                 query[sizeof(query) - 1] = '\0';
5428         }
5429         _LOGE("query = %s\n", query);
5430
5431         /*Execute Query*/
5432         if (SQLITE_OK !=
5433             sqlite3_exec(manifest_db, query, __count_cb, (void *)count, &error_message)) {
5434                 _LOGE("Don't execute query = %s error message = %s\n", query,
5435                        error_message);
5436                 sqlite3_free(error_message);
5437                 sqlite3_close(manifest_db);
5438                 ret = PMINFO_R_ERROR;
5439                 *count = 0;
5440                 goto err;
5441         }
5442         ret = PMINFO_R_OK;
5443 err:
5444         if (locale) {
5445                 free(locale);
5446                 locale = NULL;
5447         }
5448         if (syslocale) {
5449                 free(syslocale);
5450                 syslocale = NULL;
5451         }
5452         sqlite3_close(manifest_db);
5453         return ret;
5454 }
5455
5456 API int pkgmgrinfo_appinfo_filter_foreach_appinfo(pkgmgrinfo_appinfo_filter_h handle,
5457                                 pkgmgrinfo_app_list_cb app_cb, void * user_data)
5458 {
5459         retvm_if(handle == NULL, PMINFO_R_EINVAL, "Filter handle input parameter is NULL\n");
5460         retvm_if(app_cb == NULL, PMINFO_R_EINVAL, "Filter handle input parameter is NULL\n");
5461         char *syslocale = NULL;
5462         char *locale = NULL;
5463         char *condition = NULL;
5464         char *error_message = NULL;
5465         char query[MAX_QUERY_LEN] = {'\0'};
5466         char where[MAX_QUERY_LEN] = {'\0'};
5467         GSList *list;
5468         int ret = 0;
5469         uiapplication_x *ptr1 = NULL;
5470         serviceapplication_x *ptr2 = NULL;
5471         pkgmgrinfo_filter_x *filter = (pkgmgrinfo_filter_x*)handle;
5472         /*Get current locale*/
5473         syslocale = vconf_get_str(VCONFKEY_LANGSET);
5474         if (syslocale == NULL) {
5475                 _LOGE("current locale is NULL\n");
5476                 return PMINFO_R_ERROR;
5477         }
5478         locale = __convert_system_locale_to_manifest_locale(syslocale);
5479         if (locale == NULL) {
5480                 _LOGE("manifest locale is NULL\n");
5481                 free(syslocale);
5482                 return PMINFO_R_ERROR;
5483         }
5484
5485         ret = __open_manifest_db();
5486         if (ret == -1) {
5487                 _LOGE("Fail to open manifest DB\n");
5488                 ret = PMINFO_R_ERROR;
5489                 goto err;
5490         }
5491         /*Start constructing query*/
5492         snprintf(query, MAX_QUERY_LEN - 1, FILTER_QUERY_LIST_APP, locale);
5493         /*Get where clause*/
5494         for (list = filter->list; list; list = g_slist_next(list)) {
5495                 __get_filter_condition(list->data, &condition);
5496                 if (condition) {
5497                         strncat(where, condition, sizeof(where) - strlen(where) -1);
5498                         where[sizeof(where) - 1] = '\0';
5499                         free(condition);
5500                         condition = NULL;
5501                 }
5502                 if (g_slist_next(list)) {
5503                         strncat(where, " and ", sizeof(where) - strlen(where) - 1);
5504                         where[sizeof(where) - 1] = '\0';
5505                 }
5506         }
5507         _LOGE("where = %s\n", where);
5508         if (strlen(where) > 0) {
5509                 strncat(query, where, sizeof(query) - strlen(query) - 1);
5510                 query[sizeof(query) - 1] = '\0';
5511         }
5512         _LOGE("query = %s\n", query);
5513         /*To get filtered list*/
5514         pkgmgr_pkginfo_x *info = NULL;
5515         info = (pkgmgr_pkginfo_x *)calloc(1, sizeof(pkgmgr_pkginfo_x));
5516         if (info == NULL) {
5517                 _LOGE("Out of Memory!!!\n");
5518                 ret = PMINFO_R_ERROR;
5519                 goto err;
5520         }
5521         info->manifest_info = (manifest_x *)calloc(1, sizeof(manifest_x));
5522         if (info->manifest_info == NULL) {
5523                 _LOGE("Out of Memory!!!\n");
5524                 ret = PMINFO_R_ERROR;
5525                 goto err;
5526         }
5527         /*To get detail app info for each member of filtered list*/
5528         pkgmgr_pkginfo_x *filtinfo = NULL;
5529         filtinfo = (pkgmgr_pkginfo_x *)calloc(1, sizeof(pkgmgr_pkginfo_x));
5530         if (filtinfo == NULL) {
5531                 _LOGE("Out of Memory!!!\n");
5532                 ret = PMINFO_R_ERROR;
5533                 goto err;
5534         }
5535         filtinfo->manifest_info = (manifest_x *)calloc(1, sizeof(manifest_x));
5536         if (filtinfo->manifest_info == NULL) {
5537                 _LOGE("Out of Memory!!!\n");
5538                 ret = PMINFO_R_ERROR;
5539                 goto err;
5540         }
5541         pkgmgr_appinfo_x *appinfo = (pkgmgr_appinfo_x *)calloc(1, sizeof(pkgmgr_appinfo_x));
5542         if (appinfo == NULL) {
5543                 _LOGE("Out of Memory!!!\n");
5544                 ret = PMINFO_R_ERROR;
5545                 goto err;
5546         }
5547         if (SQLITE_OK !=
5548             sqlite3_exec(manifest_db, query, __app_list_cb, (void *)info, &error_message)) {
5549                 _LOGE("Don't execute query = %s error message = %s\n", query,
5550                        error_message);
5551                 sqlite3_free(error_message);
5552                 sqlite3_close(manifest_db);
5553                 ret = PMINFO_R_ERROR;
5554                 goto err;
5555         }
5556         memset(query, '\0', MAX_QUERY_LEN);
5557         if (info->manifest_info->uiapplication) {
5558                 LISTHEAD(info->manifest_info->uiapplication, ptr1);
5559                 info->manifest_info->uiapplication = ptr1;
5560         }
5561         if (info->manifest_info->serviceapplication) {
5562                 LISTHEAD(info->manifest_info->serviceapplication, ptr2);
5563                 info->manifest_info->serviceapplication = ptr2;
5564         }
5565         /*Filtered UI Apps*/
5566         for(ptr1 = info->manifest_info->uiapplication; ptr1; ptr1 = ptr1->next)
5567         {
5568                 snprintf(query, MAX_QUERY_LEN, "select * from package_app_info where app_id='%s' and app_component='%s'",
5569                                                         ptr1->appid, "uiapp");
5570                 if (SQLITE_OK !=
5571                 sqlite3_exec(manifest_db, query, __uiapp_list_cb, (void *)filtinfo, &error_message)) {
5572                         _LOGE("Don't execute query = %s error message = %s\n", query,
5573                                error_message);
5574                         sqlite3_free(error_message);
5575                         sqlite3_close(manifest_db);
5576                         ret = PMINFO_R_ERROR;
5577                         goto err;
5578                 }
5579         }
5580         for(ptr2 = info->manifest_info->serviceapplication; ptr2; ptr2 = ptr2->next)
5581         {
5582                 snprintf(query, MAX_QUERY_LEN, "select * from package_app_info where app_id='%s' and app_component='%s'",
5583                                                         ptr2->appid, "svcapp");
5584                 if (SQLITE_OK !=
5585                 sqlite3_exec(manifest_db, query, __svcapp_list_cb, (void *)filtinfo, &error_message)) {
5586                         _LOGE("Don't execute query = %s error message = %s\n", query,
5587                                error_message);
5588                         sqlite3_free(error_message);
5589                         sqlite3_close(manifest_db);
5590                         ret = PMINFO_R_ERROR;
5591                         goto err;
5592                 }
5593         }
5594         if (filtinfo->manifest_info->uiapplication) {
5595                 LISTHEAD(filtinfo->manifest_info->uiapplication, ptr1);
5596                 filtinfo->manifest_info->uiapplication = ptr1;
5597         }
5598         /*If the callback func return < 0 we break and no more call back is called*/
5599         while(ptr1 != NULL)
5600         {
5601                 appinfo->locale = strdup(locale);
5602                 appinfo->uiapp_info = ptr1;
5603                 appinfo->app_component = PMINFO_UI_APP;
5604                 ret = app_cb((void *)appinfo, user_data);
5605                 if (ret < 0)
5606                         break;
5607                 ptr1 = ptr1->next;
5608         }
5609         /*Filtered Service Apps*/
5610         if (filtinfo->manifest_info->serviceapplication) {
5611                 LISTHEAD(filtinfo->manifest_info->serviceapplication, ptr2);
5612                 filtinfo->manifest_info->serviceapplication = ptr2;
5613         }
5614         /*If the callback func return < 0 we break and no more call back is called*/
5615         while(ptr2 != NULL)
5616         {
5617                 appinfo->locale = strdup(locale);
5618                 appinfo->svcapp_info = ptr2;
5619                 appinfo->app_component = PMINFO_SVC_APP;
5620                 ret = app_cb((void *)appinfo, user_data);
5621                 if (ret < 0)
5622                         break;
5623                 ptr2 = ptr2->next;
5624         }
5625         ret = PMINFO_R_OK;
5626 err:
5627         if (locale) {
5628                 free(locale);
5629                 locale = NULL;
5630         }
5631         if (syslocale) {
5632                 free(syslocale);
5633                 syslocale = NULL;
5634         }
5635         sqlite3_close(manifest_db);
5636         if (appinfo) {
5637                 free(appinfo);
5638                 appinfo = NULL;
5639         }
5640         __cleanup_pkginfo(info);
5641         __cleanup_pkginfo(filtinfo);
5642         return ret;
5643 }
5644
5645 API int pkgmgrinfo_appinfo_metadata_filter_create(pkgmgrinfo_appinfo_metadata_filter_h *handle)
5646 {
5647         return (pkgmgrinfo_pkginfo_filter_create(handle));
5648 }
5649
5650 API int pkgmgrinfo_appinfo_metadata_filter_destroy(pkgmgrinfo_appinfo_metadata_filter_h handle)
5651 {
5652         return (pkgmgrinfo_pkginfo_filter_destroy(handle));
5653 }
5654
5655 API int pkgmgrinfo_appinfo_metadata_filter_add(pkgmgrinfo_appinfo_metadata_filter_h handle,
5656                 const char *key, const char *value)
5657 {
5658         retvm_if(handle == NULL, PMINFO_R_EINVAL, "filter handle is NULL\n");
5659         retvm_if(key == NULL, PMINFO_R_EINVAL, "metadata key supplied is NULL\n");
5660         /*value can be NULL. In that case all apps with specified key should be displayed*/
5661         int ret = 0;
5662         char *k = NULL;
5663         char *v = NULL;
5664         pkgmgrinfo_filter_x *filter = (pkgmgrinfo_filter_x*)handle;
5665         pkgmgrinfo_node_x *node = (pkgmgrinfo_node_x*)calloc(1, sizeof(pkgmgrinfo_node_x));
5666         retvm_if(node == NULL, PMINFO_R_ERROR, "Out of Memory!!!\n");
5667         k = strdup(key);
5668         tryvm_if(k == NULL, ret = PMINFO_R_ERROR, "Out of Memory!!!\n");
5669         node->key = k;
5670         if (value) {
5671                 v = strdup(value);
5672                 tryvm_if(v == NULL, ret = PMINFO_R_ERROR, "Out of Memory!!!\n");
5673         }
5674         node->value = v;
5675         /*If API is called multiple times, we should OR all conditions.*/
5676         filter->list = g_slist_append(filter->list, (gpointer)node);
5677         /*All memory will be freed in destroy API*/
5678         return PMINFO_R_OK;
5679 catch:
5680         if (node) {
5681                 if (node->key) {
5682                         free(node->key);
5683                         node->key = NULL;
5684                 }
5685                 if (node->value) {
5686                         free(node->value);
5687                         node->value = NULL;
5688                 }
5689                 free(node);
5690                 node = NULL;
5691         }
5692         return ret;
5693 }
5694
5695 API int pkgmgrinfo_appinfo_metadata_filter_foreach(pkgmgrinfo_appinfo_metadata_filter_h handle,
5696                 pkgmgrinfo_app_list_cb app_cb, void *user_data)
5697 {
5698         retvm_if(handle == NULL, PMINFO_R_EINVAL, "filter handle is NULL\n");
5699         retvm_if(app_cb == NULL, PMINFO_R_EINVAL, "Callback function supplied is NULL\n");
5700         char *syslocale = NULL;
5701         char *locale = NULL;
5702         char *condition = NULL;
5703         char *error_message = NULL;
5704         char query[MAX_QUERY_LEN] = {'\0'};
5705         char where[MAX_QUERY_LEN] = {'\0'};
5706         GSList *list;
5707         int ret = 0;
5708         pkgmgr_pkginfo_x *info = NULL;
5709         pkgmgr_pkginfo_x *filtinfo = NULL;
5710         pkgmgr_appinfo_x *appinfo = NULL;
5711         uiapplication_x *ptr1 = NULL;
5712         serviceapplication_x *ptr2 = NULL;
5713         pkgmgrinfo_filter_x *filter = (pkgmgrinfo_filter_x*)handle;
5714
5715         /*Get current locale*/
5716         syslocale = vconf_get_str(VCONFKEY_LANGSET);
5717         retvm_if(syslocale == NULL, PMINFO_R_ERROR, "current locale is NULL\n");
5718         locale = __convert_system_locale_to_manifest_locale(syslocale);
5719         tryvm_if(locale == NULL, ret = PMINFO_R_ERROR, "manifest locale is NULL\n");
5720
5721         ret = __open_manifest_db();
5722         tryvm_if(ret == -1, ret = PMINFO_R_ERROR, "Fail to open manifest DB\n");
5723
5724         /*Start constructing query*/
5725         memset(where, '\0', MAX_QUERY_LEN);
5726         memset(query, '\0', MAX_QUERY_LEN);
5727         snprintf(query, MAX_QUERY_LEN - 1, METADATA_FILTER_QUERY_SELECT_CLAUSE);
5728         /*Get where clause*/
5729         for (list = filter->list; list; list = g_slist_next(list)) {
5730                 __get_metadata_filter_condition(list->data, &condition);
5731                 if (condition) {
5732                         strncat(where, condition, sizeof(where) - strlen(where) -1);
5733                         free(condition);
5734                         condition = NULL;
5735                 }
5736                 if (g_slist_next(list)) {
5737                         strncat(where, METADATA_FILTER_QUERY_UNION_CLAUSE, sizeof(where) - strlen(where) - 1);
5738                 }
5739         }
5740         _LOGE("where = %s (%d)\n", where, strlen(where));
5741         if (strlen(where) > 0) {
5742                 strncat(query, where, sizeof(query) - strlen(query) - 1);
5743         }
5744         _LOGE("query = %s (%d)\n", query, strlen(query));
5745         /*To get filtered list*/
5746         info = (pkgmgr_pkginfo_x *)calloc(1, sizeof(pkgmgr_pkginfo_x));
5747         tryvm_if(info == NULL, ret = PMINFO_R_ERROR, "Out of Memory!!!\n");
5748
5749         info->manifest_info = (manifest_x *)calloc(1, sizeof(manifest_x));
5750         tryvm_if(info->manifest_info == NULL, ret = PMINFO_R_ERROR, "Out of Memory!!!\n");
5751
5752         /*To get detail app info for each member of filtered list*/
5753         filtinfo = (pkgmgr_pkginfo_x *)calloc(1, sizeof(pkgmgr_pkginfo_x));
5754         tryvm_if(filtinfo == NULL, ret = PMINFO_R_ERROR, "Out of Memory!!!\n");
5755
5756         filtinfo->manifest_info = (manifest_x *)calloc(1, sizeof(manifest_x));
5757         tryvm_if(filtinfo->manifest_info == NULL, ret = PMINFO_R_ERROR, "Out of Memory!!!\n");
5758
5759         appinfo = (pkgmgr_appinfo_x *)calloc(1, sizeof(pkgmgr_appinfo_x));
5760         tryvm_if(appinfo == NULL, ret = PMINFO_R_ERROR, "Out of Memory!!!\n");
5761
5762         ret = sqlite3_exec(manifest_db, query, __app_list_cb, (void *)info, &error_message);
5763         tryvm_if(ret != SQLITE_OK, ret = PMINFO_R_ERROR, "Don't execute query = %s error message = %s\n", query, error_message);
5764         memset(query, '\0', MAX_QUERY_LEN);
5765
5766         if (info->manifest_info->uiapplication) {
5767                 LISTHEAD(info->manifest_info->uiapplication, ptr1);
5768                 info->manifest_info->uiapplication = ptr1;
5769         }
5770         if (info->manifest_info->serviceapplication) {
5771                 LISTHEAD(info->manifest_info->serviceapplication, ptr2);
5772                 info->manifest_info->serviceapplication = ptr2;
5773         }
5774
5775         /*UI Apps*/
5776         for(ptr1 = info->manifest_info->uiapplication; ptr1; ptr1 = ptr1->next)
5777         {
5778                 snprintf(query, MAX_QUERY_LEN, "select * from package_app_info where app_id='%s' and app_component='%s'",
5779                                                         ptr1->appid, "uiapp");
5780                 ret = sqlite3_exec(manifest_db, query, __uiapp_list_cb, (void *)filtinfo, &error_message);
5781                 tryvm_if(ret != SQLITE_OK, ret = PMINFO_R_ERROR, "Don't execute query = %s error message = %s\n", query, error_message);
5782                 memset(query, '\0', MAX_QUERY_LEN);
5783         }
5784         /*Service Apps*/
5785         for(ptr2 = info->manifest_info->serviceapplication; ptr2; ptr2 = ptr2->next)
5786         {
5787                 snprintf(query, MAX_QUERY_LEN, "select * from package_app_info where app_id='%s' and app_component='%s'",
5788                                                         ptr2->appid, "svcapp");
5789                 ret = sqlite3_exec(manifest_db, query, __svcapp_list_cb, (void *)filtinfo, &error_message);
5790                 tryvm_if(ret != SQLITE_OK, ret = PMINFO_R_ERROR, "Don't execute query = %s error message = %s\n", query, error_message);
5791                 memset(query, '\0', MAX_QUERY_LEN);
5792         }
5793         /*Filtered UI Apps*/
5794         if (filtinfo->manifest_info->uiapplication) {
5795                 LISTHEAD(filtinfo->manifest_info->uiapplication, ptr1);
5796                 filtinfo->manifest_info->uiapplication = ptr1;
5797         }
5798         /*If the callback func return < 0 we break and no more call back is called*/
5799         while(ptr1 != NULL)
5800         {
5801                 appinfo->locale = strdup(locale);
5802                 appinfo->uiapp_info = ptr1;
5803                 appinfo->app_component = PMINFO_UI_APP;
5804                 ret = app_cb((void *)appinfo, user_data);
5805                 if (ret < 0)
5806                         break;
5807                 ptr1 = ptr1->next;
5808         }
5809         /*Filtered Service Apps*/
5810         if (filtinfo->manifest_info->serviceapplication) {
5811                 LISTHEAD(filtinfo->manifest_info->serviceapplication, ptr2);
5812                 filtinfo->manifest_info->serviceapplication = ptr2;
5813         }
5814         /*If the callback func return < 0 we break and no more call back is called*/
5815         while(ptr2 != NULL)
5816         {
5817                 appinfo->locale = strdup(locale);
5818                 appinfo->svcapp_info = ptr2;
5819                 appinfo->app_component = PMINFO_SVC_APP;
5820                 ret = app_cb((void *)appinfo, user_data);
5821                 if (ret < 0)
5822                         break;
5823                 ptr2 = ptr2->next;
5824         }
5825         ret = PMINFO_R_OK;
5826 catch:
5827         if (locale) {
5828                 free(locale);
5829                 locale = NULL;
5830         }
5831         if (syslocale) {
5832                 free(syslocale);
5833                 syslocale = NULL;
5834         }
5835         sqlite3_free(error_message);
5836         sqlite3_close(manifest_db);
5837         if (appinfo) {
5838                 free(appinfo);
5839                 appinfo = NULL;
5840         }
5841         __cleanup_pkginfo(info);
5842         __cleanup_pkginfo(filtinfo);
5843         return ret;
5844 }
5845
5846 API int pkgmgrinfo_pkginfo_create_certinfo(pkgmgrinfo_certinfo_h *handle)
5847 {
5848         retvm_if(handle == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
5849         pkgmgr_certinfo_x *certinfo = NULL;
5850         certinfo = calloc(1, sizeof(pkgmgr_certinfo_x));
5851         retvm_if(certinfo == NULL, PMINFO_R_ERROR, "Malloc Failed\n");
5852         *handle = (void *)certinfo;
5853         return PMINFO_R_OK;
5854 }
5855
5856 API int pkgmgrinfo_pkginfo_load_certinfo(const char *pkgid, pkgmgrinfo_certinfo_h handle)
5857 {
5858         retvm_if(pkgid == NULL, PMINFO_R_EINVAL, "package ID is NULL\n");
5859         retvm_if(handle == NULL, PMINFO_R_EINVAL, "Certinfo handle is NULL\n");
5860         pkgmgr_certinfo_x *certinfo = NULL;
5861         char *error_message = NULL;
5862         int ret = PMINFO_R_OK;
5863         char query[MAX_QUERY_LEN] = {'\0'};
5864         int exist = 0;
5865         int i = 0;
5866
5867         /*Open db.*/
5868         ret = db_util_open_with_options(CERT_DB, &cert_db,
5869                                         SQLITE_OPEN_READONLY, NULL);
5870         if (ret != SQLITE_OK) {
5871                 _LOGE("connect db [%s] failed!\n", CERT_DB);
5872                 return PMINFO_R_ERROR;
5873         }
5874         /*validate pkgid*/
5875         snprintf(query, MAX_QUERY_LEN, "select exists(select * from package_cert_info where package='%s')", pkgid);
5876         if (SQLITE_OK !=
5877             sqlite3_exec(cert_db, query, __validate_cb, (void *)&exist, &error_message)) {
5878                 _LOGE("Don't execute query = %s error message = %s\n", query,
5879                        error_message);
5880                 sqlite3_free(error_message);
5881                 ret = PMINFO_R_ERROR;
5882                 goto err;
5883         }
5884         if (exist == 0) {
5885                 _LOGE("Package not found in DB\n");
5886                 ret = PMINFO_R_ERROR;
5887                 goto err;
5888         }
5889         certinfo = (pkgmgr_certinfo_x *)handle;
5890         /*populate certinfo from DB*/
5891         snprintf(query, MAX_QUERY_LEN, "select * from package_cert_info where package='%s' ", pkgid);
5892         ret = __exec_certinfo_query(query, (void *)certinfo);
5893         if (ret == -1) {
5894                 _LOGE("Package Cert Info DB Information retrieval failed\n");
5895                 ret = PMINFO_R_ERROR;
5896                 goto err;
5897         }
5898         for (i = 0; i < MAX_CERT_TYPE; i++) {
5899                 memset(query, '\0', MAX_QUERY_LEN);
5900                 snprintf(query, MAX_QUERY_LEN, "select cert_info from package_cert_index_info where cert_id=%d ", (certinfo->cert_id)[i]);
5901                 ret = __exec_certinfo_query(query, (void *)certinfo);
5902                 if (ret == -1) {
5903                         _LOGE("Cert Info DB Information retrieval failed\n");
5904                         ret = PMINFO_R_ERROR;
5905                         goto err;
5906                 }
5907                 if (certinfo->cert_value) {
5908                         (certinfo->cert_info)[i] = strdup(certinfo->cert_value);
5909                         free(certinfo->cert_value);
5910                         certinfo->cert_value = NULL;
5911                 }
5912         }
5913 err:
5914         sqlite3_close(cert_db);
5915         return ret;
5916 }
5917
5918 API int pkgmgrinfo_pkginfo_get_cert_value(pkgmgrinfo_certinfo_h handle, pkgmgrinfo_cert_type cert_type, const char **cert_value)
5919 {
5920         retvm_if(handle == NULL, PMINFO_R_EINVAL, "Argument supplied is NULL\n");
5921         retvm_if(cert_value == NULL, PMINFO_R_EINVAL, "Argument supplied is NULL\n");
5922         retvm_if(cert_type < PMINFO_AUTHOR_ROOT_CERT, PMINFO_R_EINVAL, "Invalid certificate type\n");
5923         retvm_if(cert_type > PMINFO_DISTRIBUTOR2_SIGNER_CERT, PMINFO_R_EINVAL, "Invalid certificate type\n");
5924         pkgmgr_certinfo_x *certinfo = NULL;
5925         certinfo = (pkgmgr_certinfo_x *)handle;
5926         if ((certinfo->cert_info)[cert_type])
5927                 *cert_value = (certinfo->cert_info)[cert_type];
5928         else
5929                 *cert_value = NULL;
5930         return PMINFO_R_OK;
5931 }
5932
5933 API int pkgmgrinfo_pkginfo_destroy_certinfo(pkgmgrinfo_certinfo_h handle)
5934 {
5935         retvm_if(handle == NULL, PMINFO_R_EINVAL, "Argument supplied is NULL\n");
5936         int i = 0;
5937         pkgmgr_certinfo_x *certinfo = NULL;
5938         certinfo = (pkgmgr_certinfo_x *)handle;
5939         if (certinfo->pkgid) {
5940                 free(certinfo->pkgid);
5941                 certinfo->pkgid = NULL;
5942         }
5943         for (i = 0; i < MAX_CERT_TYPE; i++) {
5944                 if ((certinfo->cert_info)[i]) {
5945                         free((certinfo->cert_info)[i]);
5946                         (certinfo->cert_info)[i] = NULL;
5947                 }
5948         }
5949         free(certinfo);
5950         certinfo = NULL;
5951         return PMINFO_R_OK;
5952 }
5953
5954 API int pkgmgrinfo_create_certinfo_set_handle(pkgmgrinfo_instcertinfo_h *handle)
5955 {
5956         retvm_if(handle == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
5957         pkgmgr_instcertinfo_x *certinfo = NULL;
5958         certinfo = calloc(1, sizeof(pkgmgr_instcertinfo_x));
5959         retvm_if(certinfo == NULL, PMINFO_R_ERROR, "Malloc Failed\n");
5960         *handle = (void *)certinfo;
5961         return PMINFO_R_OK;
5962 }
5963
5964 API int pkgmgrinfo_set_cert_value(pkgmgrinfo_instcertinfo_h handle, pkgmgrinfo_instcert_type cert_type, char *cert_value)
5965 {
5966         retvm_if(handle == NULL, PMINFO_R_EINVAL, "Argument supplied is NULL\n");
5967         retvm_if(cert_value == NULL, PMINFO_R_EINVAL, "Argument supplied is NULL\n");
5968         retvm_if(cert_type < PMINFO_SET_AUTHOR_ROOT_CERT, PMINFO_R_EINVAL, "Invalid certificate type\n");
5969         retvm_if(cert_type > PMINFO_SET_DISTRIBUTOR2_SIGNER_CERT, PMINFO_R_EINVAL, "Invalid certificate type\n");
5970         pkgmgr_instcertinfo_x *certinfo = NULL;
5971         certinfo = (pkgmgr_instcertinfo_x *)handle;
5972         (certinfo->cert_info)[cert_type] = strdup(cert_value);
5973         return PMINFO_R_OK;
5974 }
5975
5976 API int pkgmgrinfo_save_certinfo(const char *pkgid, pkgmgrinfo_instcertinfo_h handle)
5977 {
5978         retvm_if(pkgid == NULL, PMINFO_R_EINVAL, "package ID is NULL\n");
5979         retvm_if(handle == NULL, PMINFO_R_EINVAL, "Certinfo handle is NULL\n");
5980         char *error_message = NULL;
5981         char query[MAX_QUERY_LEN] = {'\0'};
5982         char *vquery = NULL;
5983         int len = 0;
5984         int i = 0;
5985         int j = 0;
5986         int c = 0;
5987         int unique_id[MAX_CERT_TYPE] = {0, 0, 0, 0, 0, 0, 0, 0, 0};
5988         int newid = 0;
5989         int is_new = 0;
5990         int exist = -1;
5991         int ret = -1;
5992         int maxid = 0;
5993         int flag = 0;
5994         pkgmgr_instcertinfo_x *info = (pkgmgr_instcertinfo_x *)handle;
5995         pkgmgr_certindexinfo_x *indexinfo = NULL;
5996         indexinfo = calloc(1, sizeof(pkgmgr_certindexinfo_x));
5997         if (indexinfo == NULL) {
5998                 _LOGE("Out of Memory!!!");
5999                 return PMINFO_R_ERROR;
6000         }
6001         info->pkgid = strdup(pkgid);
6002
6003         /*Open db.*/
6004         ret = db_util_open_with_options(CERT_DB, &cert_db,
6005                                         SQLITE_OPEN_READWRITE, NULL);
6006         if (ret != SQLITE_OK) {
6007                 _LOGE("connect db [%s] failed!\n", CERT_DB);
6008                 ret = PMINFO_R_ERROR;
6009                 goto err;
6010         }
6011         /*Begin Transaction*/
6012         ret = sqlite3_exec(cert_db, "BEGIN EXCLUSIVE", NULL, NULL, NULL);
6013         if (ret != SQLITE_OK) {
6014                 _LOGE("Failed to begin transaction\n");
6015                 ret = PMINFO_R_ERROR;
6016                 goto err;
6017         }
6018         _LOGE("Transaction Begin\n");
6019         /*Check if request is to insert/update*/
6020         snprintf(query, MAX_QUERY_LEN, "select exists(select * from package_cert_info where package='%s')", pkgid);
6021         if (SQLITE_OK !=
6022             sqlite3_exec(cert_db, query, __validate_cb, (void *)&exist, &error_message)) {
6023                 _LOGE("Don't execute query = %s error message = %s\n", query,
6024                        error_message);
6025                 sqlite3_free(error_message);
6026                 ret = PMINFO_R_ERROR;
6027                 goto err;
6028         }
6029         if (exist) {
6030                 /*Update request.
6031                 We cant just issue update query directly. We need to manage index table also.
6032                 Hence it is better to delete and insert again in case of update*/
6033                 ret = __delete_certinfo(pkgid);
6034                 if (ret < 0)
6035                         _LOGE("Certificate Deletion Failed\n");
6036         }
6037         for (i = 0; i < MAX_CERT_TYPE; i++) {
6038                 if ((info->cert_info)[i]) {
6039                         for (j = 0; j < i; j++) {
6040                                 if ( (info->cert_info)[j]) {
6041                                         if (strcmp((info->cert_info)[i], (info->cert_info)[j]) == 0) {
6042                                                 (info->cert_id)[i] = (info->cert_id)[j];
6043                                                 (info->is_new)[i] = 0;
6044                                                 (info->ref_count)[i] = (info->ref_count)[j];
6045                                                 break;
6046                                         }
6047                                 }
6048                         }
6049                         if (j < i)
6050                                 continue;
6051                         memset(query, '\0', MAX_QUERY_LEN);
6052                         snprintf(query, MAX_QUERY_LEN, "select * from package_cert_index_info " \
6053                                 "where cert_info='%s'",(info->cert_info)[i]);
6054                         ret = __exec_certindexinfo_query(query, (void *)indexinfo);
6055                         if (ret == -1) {
6056                                 _LOGE("Cert Info DB Information retrieval failed\n");
6057                                 ret = PMINFO_R_ERROR;
6058                                 goto err;
6059                         }
6060                         if (indexinfo->cert_id == 0) {
6061                                 /*New certificate. Get newid*/
6062                                 memset(query, '\0', MAX_QUERY_LEN);
6063                                 snprintf(query, MAX_QUERY_LEN, "select MAX(cert_id) from package_cert_index_info ");
6064                                 if (SQLITE_OK !=
6065                                     sqlite3_exec(cert_db, query, __maxid_cb, (void *)&newid, &error_message)) {
6066                                         _LOGE("Don't execute query = %s error message = %s\n", query,
6067                                                error_message);
6068                                         sqlite3_free(error_message);
6069                                         ret = PMINFO_R_ERROR;
6070                                         goto err;
6071                                 }
6072                                 newid = newid + 1;
6073                                 if (flag == 0) {
6074                                         maxid = newid;
6075                                         flag = 1;
6076                                 }
6077                                 indexinfo->cert_id = maxid;
6078                                 indexinfo->cert_ref_count = 1;
6079                                 is_new = 1;
6080                                 maxid = maxid + 1;
6081                         }
6082                         (info->cert_id)[i] = indexinfo->cert_id;
6083                         (info->is_new)[i] = is_new;
6084                         (info->ref_count)[i] = indexinfo->cert_ref_count;
6085                         _LOGE("Id:Count = %d %d\n", indexinfo->cert_id, indexinfo->cert_ref_count);
6086                         indexinfo->cert_id = 0;
6087                         indexinfo->cert_ref_count = 0;
6088                         is_new = 0;
6089                 }
6090         }
6091         len = MAX_QUERY_LEN;
6092         for (i = 0; i < MAX_CERT_TYPE; i++) {
6093                 if ((info->cert_info)[i])
6094                         len+= strlen((info->cert_info)[i]);
6095         }
6096         vquery = (char *)calloc(1, len);
6097         /*insert*/
6098         snprintf(vquery, len,
6099                  "insert into package_cert_info(package, author_root_cert, author_im_cert, author_signer_cert, dist_root_cert, " \
6100                 "dist_im_cert, dist_signer_cert, dist2_root_cert, dist2_im_cert, dist2_signer_cert) " \
6101                 "values('%s', %d, %d, %d, %d, %d, %d, %d, %d, %d)",\
6102                  info->pkgid,(info->cert_id)[PMINFO_SET_AUTHOR_ROOT_CERT],(info->cert_id)[PMINFO_SET_AUTHOR_INTERMEDIATE_CERT],
6103                 (info->cert_id)[PMINFO_SET_AUTHOR_SIGNER_CERT], (info->cert_id)[PMINFO_SET_DISTRIBUTOR_ROOT_CERT],
6104                 (info->cert_id)[PMINFO_SET_DISTRIBUTOR_INTERMEDIATE_CERT], (info->cert_id)[PMINFO_SET_DISTRIBUTOR_SIGNER_CERT],
6105                 (info->cert_id)[PMINFO_SET_DISTRIBUTOR2_ROOT_CERT],(info->cert_id)[PMINFO_SET_DISTRIBUTOR2_INTERMEDIATE_CERT],
6106                 (info->cert_id)[PMINFO_SET_DISTRIBUTOR2_SIGNER_CERT]);
6107         if (SQLITE_OK !=
6108             sqlite3_exec(cert_db, vquery, NULL, NULL, &error_message)) {
6109                 _LOGE("Don't execute query = %s error message = %s\n", vquery,
6110                        error_message);
6111                 sqlite3_free(error_message);
6112                 ret = PMINFO_R_ERROR;
6113                 goto err;
6114         }
6115         /*Update index table info*/
6116         /*If cert_id exists and is repeated for current package, ref count should only be increased once*/
6117         for (i = 0; i < MAX_CERT_TYPE; i++) {
6118                 if ((info->cert_info)[i]) {
6119                         memset(vquery, '\0', len);
6120                         if ((info->is_new)[i]) {
6121                                 snprintf(vquery, len, "insert into package_cert_index_info(cert_info, cert_id, cert_ref_count) " \
6122                                 "values('%s', '%d', '%d') ", (info->cert_info)[i], (info->cert_id)[i], 1);
6123                                 unique_id[c++] = (info->cert_id)[i];
6124                         } else {
6125                                 /*Update*/
6126                                 for (j = 0; j < MAX_CERT_TYPE; j++) {
6127                                         if ((info->cert_id)[i] == unique_id[j]) {
6128                                                 /*Ref count has already been increased. Just continue*/
6129                                                 break;
6130                                         }
6131                                 }
6132                                 if (j == MAX_CERT_TYPE)
6133                                         unique_id[c++] = (info->cert_id)[i];
6134                                 else
6135                                         continue;
6136                                 snprintf(vquery, len, "update package_cert_index_info set cert_ref_count=%d " \
6137                                 "where cert_id=%d",  (info->ref_count)[i] + 1, (info->cert_id)[i]);
6138                         }
6139                         if (SQLITE_OK !=
6140                             sqlite3_exec(cert_db, vquery, NULL, NULL, &error_message)) {
6141                                 _LOGE("Don't execute query = %s error message = %s\n", vquery,
6142                                        error_message);
6143                                 sqlite3_free(error_message);
6144                                 ret = PMINFO_R_ERROR;
6145                                 goto err;
6146                         }
6147                 }
6148         }
6149         /*Commit transaction*/
6150         ret = sqlite3_exec(cert_db, "COMMIT", NULL, NULL, NULL);
6151         if (ret != SQLITE_OK) {
6152                 _LOGE("Failed to commit transaction, Rollback now\n");
6153                 sqlite3_exec(cert_db, "ROLLBACK", NULL, NULL, NULL);
6154                 ret = PMINFO_R_ERROR;
6155                 goto err;
6156         }
6157         _LOGE("Transaction Commit and End\n");
6158         ret =  PMINFO_R_OK;
6159 err:
6160         sqlite3_close(cert_db);
6161         if (vquery) {
6162                 free(vquery);
6163                 vquery = NULL;
6164         }
6165         if (indexinfo) {
6166                 free(indexinfo);
6167                 indexinfo = NULL;
6168         }
6169         return ret;
6170 }
6171
6172 API int pkgmgrinfo_destroy_certinfo_set_handle(pkgmgrinfo_instcertinfo_h handle)
6173 {
6174         retvm_if(handle == NULL, PMINFO_R_EINVAL, "Argument supplied is NULL\n");
6175         int i = 0;
6176         pkgmgr_instcertinfo_x *certinfo = NULL;
6177         certinfo = (pkgmgr_instcertinfo_x *)handle;
6178         if (certinfo->pkgid) {
6179                 free(certinfo->pkgid);
6180                 certinfo->pkgid = NULL;
6181         }
6182         for (i = 0; i < MAX_CERT_TYPE; i++) {
6183                 if ((certinfo->cert_info)[i]) {
6184                         free((certinfo->cert_info)[i]);
6185                         (certinfo->cert_info)[i] = NULL;
6186                 }
6187         }
6188         free(certinfo);
6189         certinfo = NULL;
6190         return PMINFO_R_OK;
6191 }
6192
6193 API int pkgmgrinfo_delete_certinfo(const char *pkgid)
6194 {
6195         retvm_if(pkgid == NULL, PMINFO_R_EINVAL, "Argument supplied is NULL\n");
6196         int ret = -1;
6197         /*Open db.*/
6198         ret = db_util_open_with_options(CERT_DB, &cert_db,
6199                                         SQLITE_OPEN_READWRITE, NULL);
6200         if (ret != SQLITE_OK) {
6201                 _LOGE("connect db [%s] failed!\n", CERT_DB);
6202                 ret = PMINFO_R_ERROR;
6203                 goto err;
6204         }
6205         /*Begin Transaction*/
6206         ret = sqlite3_exec(cert_db, "BEGIN EXCLUSIVE", NULL, NULL, NULL);
6207         if (ret != SQLITE_OK) {
6208                 _LOGE("Failed to begin transaction\n");
6209                 ret = PMINFO_R_ERROR;
6210                 goto err;
6211         }
6212         _LOGE("Transaction Begin\n");
6213         ret = __delete_certinfo(pkgid);
6214         if (ret < 0) {
6215                 _LOGE("Certificate Deletion Failed\n");
6216         } else {
6217                 _LOGE("Certificate Deletion Success\n");
6218         }
6219         /*Commit transaction*/
6220         ret = sqlite3_exec(cert_db, "COMMIT", NULL, NULL, NULL);
6221         if (ret != SQLITE_OK) {
6222                 _LOGE("Failed to commit transaction, Rollback now\n");
6223                 sqlite3_exec(cert_db, "ROLLBACK", NULL, NULL, NULL);
6224                 ret = PMINFO_R_ERROR;
6225                 goto err;
6226         }
6227         _LOGE("Transaction Commit and End\n");
6228         ret = PMINFO_R_OK;
6229 err:
6230         sqlite3_close(cert_db);
6231         return ret;
6232 }
6233
6234 API int pkgmgrinfo_create_pkgdbinfo(const char *pkgid, pkgmgrinfo_pkgdbinfo_h *handle)
6235 {
6236         retvm_if(!pkgid, PMINFO_R_EINVAL, "pkgid is NULL");
6237         retvm_if(!handle, PMINFO_R_EINVAL, "Argument supplied is NULL");
6238
6239         char *manifest = NULL;
6240         manifest_x *mfx = NULL;
6241
6242         manifest = pkgmgr_parser_get_manifest_file(pkgid);
6243         retvm_if(manifest == NULL, PMINFO_R_EINVAL, "pkg[%s] dont have manifest file", pkgid);
6244
6245         mfx = pkgmgr_parser_process_manifest_xml(manifest);
6246         if (manifest) {
6247                 free(manifest);
6248                 manifest = NULL;
6249         }
6250         retvm_if(mfx == NULL, PMINFO_R_EINVAL, "pkg[%s] parsing fail", pkgid);
6251
6252         *handle = (void *)mfx;
6253
6254         return PMINFO_R_OK;
6255 }
6256
6257 API int pkgmgrinfo_set_type_to_pkgdbinfo(pkgmgrinfo_pkgdbinfo_h handle, const char *type)
6258 {
6259         retvm_if(!type, PMINFO_R_EINVAL, "Argument supplied is NULL");
6260         retvm_if(!handle, PMINFO_R_EINVAL, "Argument supplied is NULL");
6261
6262         int len = strlen(type);
6263         retvm_if(len > PKG_TYPE_STRING_LEN_MAX, PMINFO_R_EINVAL, "pkg type length exceeds the max limit");
6264
6265         manifest_x *mfx = (manifest_x *)handle;
6266
6267         mfx->type = strndup(type, PKG_TYPE_STRING_LEN_MAX);
6268         return PMINFO_R_OK;
6269 }
6270
6271 API int pkgmgrinfo_set_version_to_pkgdbinfo(pkgmgrinfo_pkgdbinfo_h handle, const char *version)
6272 {
6273         retvm_if(!version, PMINFO_R_EINVAL, "Argument supplied is NULL");
6274         retvm_if(!handle, PMINFO_R_EINVAL, "Argument supplied is NULL");
6275
6276         int len = strlen(version);
6277         retvm_if(len > PKG_TYPE_STRING_LEN_MAX, PMINFO_R_EINVAL, "pkg type length exceeds the max limit");
6278
6279         manifest_x *mfx = (manifest_x *)handle;
6280
6281         mfx->version = strndup(version, PKG_VERSION_STRING_LEN_MAX);
6282         return PMINFO_R_OK;
6283 }
6284
6285 API int pkgmgrinfo_set_install_location_to_pkgdbinfo(pkgmgrinfo_pkgdbinfo_h handle, INSTALL_LOCATION location)
6286 {
6287         retvm_if(!handle, PMINFO_R_EINVAL, "Argument supplied is NULL");
6288         retvm_if((location < 0) || (location > 1), PMINFO_R_EINVAL, "Argument supplied is NULL");
6289
6290         manifest_x *mfx = (manifest_x *)handle;
6291
6292         if (location == INSTALL_INTERNAL)
6293                 strcpy(mfx->installlocation, "internal-only");
6294         else if (location == INSTALL_EXTERNAL)
6295                 strcpy(mfx->installlocation, "prefer-external");
6296
6297         return PMINFO_R_OK;
6298 }
6299
6300 API int pkgmgrinfo_set_size_to_pkgdbinfo(pkgmgrinfo_pkgdbinfo_h handle, const char *size)
6301 {
6302         retvm_if(!handle, PMINFO_R_EINVAL, "Argument supplied is NULL");
6303         retvm_if(size == NULL, PMINFO_R_EINVAL, "Argument supplied is NULL");
6304
6305         manifest_x *mfx = (manifest_x *)handle;
6306
6307         mfx->package_size = strdup(size);
6308
6309         return PMINFO_R_OK;
6310 }
6311
6312 API int pkgmgrinfo_set_label_to_pkgdbinfo(pkgmgrinfo_pkgdbinfo_h handle, const char *label_txt, const char *locale)
6313 {
6314         retvm_if(!handle, PMINFO_R_EINVAL, "Argument supplied is NULL");
6315         retvm_if(!label_txt, PMINFO_R_EINVAL, "Argument supplied is NULL");
6316
6317         int len = strlen(label_txt);
6318         retvm_if(len > PKG_TYPE_STRING_LEN_MAX, PMINFO_R_EINVAL, "pkg type length exceeds the max limit");
6319
6320         manifest_x *mfx = (manifest_x *)handle;
6321
6322         label_x *label = calloc(1, sizeof(label_x));
6323         retvm_if(label == NULL, PMINFO_R_EINVAL, "Malloc Failed");
6324
6325         LISTADD(mfx->label, label);
6326         if (locale)
6327                 mfx->label->lang = strdup(locale);
6328         else
6329                 mfx->label->lang = strdup(DEFAULT_LOCALE);
6330         mfx->label->text = strdup(label_txt);
6331
6332         return PMINFO_R_OK;
6333 }
6334
6335 API int pkgmgrinfo_set_icon_to_pkgdbinfo(pkgmgrinfo_pkgdbinfo_h handle, const char *icon_txt, const char *locale)
6336 {
6337         retvm_if(!handle, PMINFO_R_EINVAL, "Argument supplied is NULL");
6338         retvm_if(!icon_txt, PMINFO_R_EINVAL, "Argument supplied is NULL");
6339
6340         int len = strlen(icon_txt);
6341         retvm_if(len > PKG_TYPE_STRING_LEN_MAX, PMINFO_R_EINVAL, "pkg type length exceeds the max limit");
6342
6343         manifest_x *mfx = (manifest_x *)handle;
6344
6345         icon_x *icon = calloc(1, sizeof(icon_x));
6346         retvm_if(icon == NULL, PMINFO_R_EINVAL, "Malloc Failed");
6347
6348         LISTADD(mfx->icon, icon);
6349         if (locale)
6350                 mfx->icon->lang = strdup(locale);
6351         else
6352                 mfx->icon->lang = strdup(DEFAULT_LOCALE);
6353         mfx->icon->text = strdup(icon_txt);
6354
6355         return PMINFO_R_OK;
6356 }
6357
6358 API int pkgmgrinfo_set_description_to_pkgdbinfo(pkgmgrinfo_pkgdbinfo_h handle, const char *desc_txt, const char *locale)
6359 {
6360         retvm_if(!handle, PMINFO_R_EINVAL, "Argument supplied is NULL");
6361         retvm_if(!desc_txt, PMINFO_R_EINVAL, "Argument supplied is NULL");
6362
6363         int len = strlen(desc_txt);
6364         retvm_if(len > PKG_TYPE_STRING_LEN_MAX, PMINFO_R_EINVAL, "pkg type length exceeds the max limit");
6365
6366         manifest_x *mfx = (manifest_x *)handle;
6367
6368         description_x *description = calloc(1, sizeof(description_x));
6369         retvm_if(description == NULL, PMINFO_R_EINVAL, "Malloc Failed");
6370
6371         LISTADD(mfx->description, description);
6372         if (locale)
6373                 mfx->description->lang = strdup(locale);
6374         else
6375                 mfx->description->lang = strdup(DEFAULT_LOCALE);
6376         mfx->description->text = strdup(desc_txt);
6377
6378         return PMINFO_R_OK;
6379 }
6380
6381 API int pkgmgrinfo_set_author_to_pkgdbinfo(pkgmgrinfo_pkgdbinfo_h handle, const char *author_name,
6382                 const char *author_email, const char *author_href, const char *locale)
6383 {
6384         retvm_if(!handle, PMINFO_R_EINVAL, "Argument supplied is NULL");
6385         manifest_x *mfx = (manifest_x *)handle;
6386         author_x *author = calloc(1, sizeof(author_x));
6387         retvm_if(author == NULL, PMINFO_R_EINVAL, "Argument supplied is NULL");
6388
6389         LISTADD(mfx->author, author);
6390         if (author_name)
6391                 mfx->author->text = strdup(author_name);
6392         if (author_email)
6393                 mfx->author->email = strdup(author_email);
6394         if (author_href)
6395                 mfx->author->href = strdup(author_href);
6396         if (locale)
6397                 mfx->author->lang = strdup(locale);
6398         else
6399                 mfx->author->lang = strdup(DEFAULT_LOCALE);
6400         return PMINFO_R_OK;
6401 }
6402
6403 API int pkgmgrinfo_set_removable_to_pkgdbinfo(pkgmgrinfo_pkgdbinfo_h handle, int removable)
6404 {
6405         retvm_if(!handle, PMINFO_R_EINVAL, "Argument supplied is NULL");
6406         retvm_if((removable < 0) || (removable > 1), PMINFO_R_EINVAL, "Argument supplied is NULL");
6407
6408         manifest_x *mfx = (manifest_x *)handle;
6409
6410         if (removable == 0)
6411                 strcpy(mfx->removable, "false");
6412         else if (removable == 1)
6413                 strcpy(mfx->removable, "true");
6414
6415         return PMINFO_R_OK;
6416 }
6417
6418 API int pkgmgrinfo_set_preload_to_pkgdbinfo(pkgmgrinfo_pkgdbinfo_h handle, int preload)
6419 {
6420         retvm_if(!handle, PMINFO_R_EINVAL, "Argument supplied is NULL");
6421         retvm_if((preload < 0) || (preload > 1), PMINFO_R_EINVAL, "Argument supplied is NULL");
6422
6423         manifest_x *mfx = (manifest_x *)handle;
6424
6425         if (preload == 0)
6426                 strcpy(mfx->preload, "false");
6427         else if (preload == 1)
6428                 strcpy(mfx->preload, "true");
6429
6430         return PMINFO_R_OK;
6431 }
6432
6433 API int pkgmgrinfo_set_installed_storage_to_pkgdbinfo(pkgmgrinfo_pkgdbinfo_h handle, INSTALL_LOCATION location)
6434 {
6435         retvm_if(!handle, PMINFO_R_EINVAL, "Argument supplied is NULL");
6436         retvm_if((location < 0) || (location > 1), PMINFO_R_EINVAL, "Argument supplied is NULL");
6437
6438         manifest_x *mfx = (manifest_x *)handle;
6439
6440         if (location == INSTALL_INTERNAL)
6441                 strcpy(mfx->installed_storage, "installed_internal");
6442         else if (location == INSTALL_EXTERNAL)
6443                 strcpy(mfx->installed_storage, "installed_external");
6444
6445         return PMINFO_R_OK;
6446 }
6447
6448 API int pkgmgrinfo_save_pkgdbinfo(pkgmgrinfo_pkgdbinfo_h handle)
6449 {
6450         retvm_if(!handle, PMINFO_R_EINVAL, "Argument supplied is NULL");
6451
6452         int ret = 0;
6453         manifest_x *mfx = NULL;
6454         mfx = (manifest_x *)handle;
6455
6456         ret = pkgmgr_parser_update_manifest_info_in_db(mfx);
6457         if (ret == 0) {
6458                 _LOGE("Successfully stored info in DB\n");
6459                 return PMINFO_R_OK;
6460         } else {
6461                 _LOGE("Failed to store info in DB\n");
6462                 return PMINFO_R_ERROR;
6463         }
6464 }
6465
6466 API int pkgmgrinfo_destroy_pkgdbinfo(pkgmgrinfo_pkgdbinfo_h handle)
6467 {
6468         retvm_if(!handle, PMINFO_R_EINVAL, "Argument supplied is NULL");
6469
6470         manifest_x *mfx = NULL;
6471         mfx = (manifest_x *)handle;
6472         pkgmgr_parser_free_manifest_xml(mfx);
6473         return PMINFO_R_OK;
6474 }
6475
6476 API int pkgmgrinfo_pkginfo_set_state_enabled(const char *pkgid, bool enabled)
6477 {
6478         /* Should be implemented later */
6479         return 0;
6480 }
6481
6482 API int pkgmgrinfo_appinfo_set_state_enabled(const char *appid, bool enabled)
6483 {
6484         retvm_if(appid == NULL, PMINFO_R_EINVAL, "appid is NULL\n");
6485         int ret = -1;
6486         char query[MAX_QUERY_LEN] = {'\0'};
6487         ret = __open_manifest_db();
6488
6489         if (access(MANIFEST_DB, F_OK) == 0) {
6490                 ret = db_util_open(MANIFEST_DB, &manifest_db,
6491                          DB_UTIL_REGISTER_HOOK_METHOD);
6492                 if (ret != SQLITE_OK) {
6493                         _LOGE("connect db [%s] failed! Manifest DB does not exists!!\n", MANIFEST_DB);
6494                         return PMINFO_R_ERROR;
6495                 }
6496         }
6497
6498         /*Begin transaction*/
6499         ret = sqlite3_exec(manifest_db, "BEGIN EXCLUSIVE", NULL, NULL, NULL);
6500         if (ret != SQLITE_OK) {
6501                 _LOGE("Failed to begin transaction\n");
6502                 sqlite3_close(manifest_db);
6503                 return PMINFO_R_ERROR;
6504         }
6505         _LOGD("Transaction Begin\n");
6506
6507         memset(query, '\0', MAX_QUERY_LEN);
6508         snprintf(query, MAX_QUERY_LEN,
6509                 "update package_app_info set app_enabled='%s' where app_id='%s'", enabled?"true":"false", appid);
6510
6511         char *error_message = NULL;
6512         if (SQLITE_OK !=
6513             sqlite3_exec(manifest_db, query, NULL, NULL, &error_message)) {
6514                 _LOGE("Don't execute query = %s error message = %s\n", query,
6515                        error_message);
6516                 sqlite3_free(error_message);
6517                 return PMINFO_R_ERROR;
6518         }
6519         sqlite3_free(error_message);
6520
6521         /*Commit transaction*/
6522         ret = sqlite3_exec(manifest_db, "COMMIT", NULL, NULL, NULL);
6523         if (ret != SQLITE_OK) {
6524                 _LOGE("Failed to commit transaction. Rollback now\n");
6525                 sqlite3_exec(manifest_db, "ROLLBACK", NULL, NULL, NULL);
6526                 sqlite3_close(manifest_db);
6527                 return PMINFO_R_ERROR;
6528         }
6529         _LOGD("Transaction Commit and End\n");
6530         sqlite3_close(manifest_db);
6531
6532         return PMINFO_R_OK;
6533 }
6534
6535
6536 API int pkgmgrinfo_datacontrol_get_info(const char *providerid, const char * type, char **appid, char **access)
6537 {
6538         retvm_if(providerid == NULL, PMINFO_R_EINVAL, "Argument supplied is NULL\n");
6539         retvm_if(type == NULL, PMINFO_R_EINVAL, "Argument supplied is NULL\n");
6540         retvm_if(appid == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
6541         retvm_if(access == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
6542         int ret = PMINFO_R_OK;
6543         char query[MAX_QUERY_LEN] = {'\0'};
6544         char *error_message = NULL;
6545         pkgmgr_datacontrol_x *data = NULL;
6546
6547         ret = __open_datacontrol_db();
6548         if (ret == -1) {
6549                 _LOGE("Fail to open datacontrol DB\n");
6550                 return PMINFO_R_ERROR;
6551         }
6552
6553         data = (pkgmgr_datacontrol_x *)calloc(1, sizeof(pkgmgr_datacontrol_x));
6554         if (data == NULL) {
6555                 _LOGE("Failed to allocate memory for pkgmgr_datacontrol_x\n");
6556                 sqlite3_close(datacontrol_db);
6557                 return PMINFO_R_ERROR;
6558         }
6559
6560         snprintf(query, MAX_QUERY_LEN,
6561                 "select appinfo.package_name, datacontrol.access from appinfo, datacontrol where datacontrol.id=appinfo.unique_id and datacontrol.provider_id = '%s' and datacontrol.type='%s' COLLATE NOCASE",
6562                 providerid, type);
6563
6564         if (SQLITE_OK !=
6565                 sqlite3_exec(datacontrol_db, query, __datacontrol_cb, (void *)data, &error_message)) {
6566                 _LOGE("Don't execute query = %s error message = %s\n", query,
6567                            error_message);
6568                 sqlite3_free(error_message);
6569                 sqlite3_close(datacontrol_db);
6570                 return PMINFO_R_ERROR;
6571         }
6572
6573         *appid = (char *)data->appid;
6574         *access = (char *)data->access;
6575         free(data);
6576         sqlite3_close(datacontrol_db);
6577
6578         return PMINFO_R_OK;
6579 }
6580
6581 API int pkgmgrinfo_appinfo_set_default_label(const char *appid, const char *label)
6582 {
6583         retvm_if(appid == NULL, PMINFO_R_EINVAL, "appid is NULL\n");
6584         int ret = -1;
6585         char query[MAX_QUERY_LEN] = {'\0'};
6586         char *error_message = NULL;
6587         ret = __open_manifest_db();
6588
6589         if (access(MANIFEST_DB, F_OK) == 0) {
6590                 ret = db_util_open(MANIFEST_DB, &manifest_db,
6591                          DB_UTIL_REGISTER_HOOK_METHOD);
6592                 if (ret != SQLITE_OK) {
6593                         _LOGE("connect db [%s] failed! Manifest DB does not exists!!\n", MANIFEST_DB);
6594                         return PMINFO_R_ERROR;
6595                 }
6596         }
6597
6598         /*Begin transaction*/
6599         ret = sqlite3_exec(manifest_db, "BEGIN EXCLUSIVE", NULL, NULL, NULL);
6600         if (ret != SQLITE_OK) {
6601                 _LOGE("Failed to begin transaction\n");
6602                 sqlite3_close(manifest_db);
6603                 return PMINFO_R_ERROR;
6604         }
6605         _LOGD("Transaction Begin\n");
6606
6607         memset(query, '\0', MAX_QUERY_LEN);
6608         snprintf(query, MAX_QUERY_LEN,
6609                 "update package_app_localized_info set app_label='%s' where app_id='%s' and app_locale='No Locale'", label, appid);
6610
6611         if (SQLITE_OK !=
6612             sqlite3_exec(manifest_db, query, NULL, NULL, &error_message)) {
6613                 _LOGE("Don't execute query = %s error message = %s\n", query,
6614                        error_message);
6615                 sqlite3_free(error_message);
6616                 return PMINFO_R_ERROR;
6617         }
6618
6619         /*Commit transaction*/
6620         ret = sqlite3_exec(manifest_db, "COMMIT", NULL, NULL, NULL);
6621         if (ret != SQLITE_OK) {
6622                 _LOGE("Failed to commit transaction. Rollback now\n");
6623                 sqlite3_exec(manifest_db, "ROLLBACK", NULL, NULL, NULL);
6624                 sqlite3_close(manifest_db);
6625                 return PMINFO_R_ERROR;
6626         }
6627         _LOGD("Transaction Commit and End\n");
6628         sqlite3_close(manifest_db);
6629
6630         return PMINFO_R_OK;
6631 }
6632
6633 API int pkgmgrinfo_appinfo_is_guestmode_visibility(pkgmgrinfo_appinfo_h handle, bool *status)
6634 {
6635         retvm_if(handle == NULL, PMINFO_R_EINVAL, "appinfo handle is NULL\n");
6636         retvm_if(status == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
6637         char *val = NULL;
6638         pkgmgr_appinfo_x *info = (pkgmgr_appinfo_x *)handle;
6639         val = (char *)info->uiapp_info->guestmode_visibility;
6640         if (val) {
6641                 if (strcasecmp(val, "true") == 0){
6642                         *status = 1;
6643                 }else if (strcasecmp(val, "false") == 0){
6644                         *status = 0;
6645                 }else{
6646                         *status = 1;
6647                 }
6648         }
6649         return PMINFO_R_OK;
6650 }
6651
6652 API int pkgmgrinfo_appinfo_set_guestmode_visibility(pkgmgrinfo_appinfo_h handle, bool status)
6653 {
6654         retvm_if(handle == NULL, PMINFO_R_EINVAL, "appinfo handle is NULL\n");
6655         char *val = NULL;
6656         int ret = 0;
6657         char *noti_string = NULL;
6658         int len = 0;
6659         char query[MAX_QUERY_LEN] = {'\0'};
6660         char *errmsg = NULL;
6661         sqlite3 *pkgmgr_parser_db;
6662
6663         pkgmgr_appinfo_x *info = (pkgmgr_appinfo_x *)handle;
6664         val = (char *)info->uiapp_info->guestmode_visibility;
6665         if (val ) {
6666                 ret =
6667                     db_util_open_with_options(MANIFEST_DB, &pkgmgr_parser_db,
6668                                  SQLITE_OPEN_READWRITE, NULL);
6669
6670                 if (ret != SQLITE_OK) {
6671                         _LOGE("DB Open Failed\n");
6672                         return PMINFO_R_ERROR;
6673                 }
6674
6675                 /*TODO: Write to DB here*/
6676                 if (status == true)
6677                         snprintf(query, MAX_QUERY_LEN, "update package_app_info set app_guestmodevisibility = 'true' where app_id = '%s'", (char *)info->uiapp_info->appid);
6678                 else
6679                         snprintf(query, MAX_QUERY_LEN, "update package_app_info set app_guestmodevisibility = 'false' where app_id = '%s'", (char *)info->uiapp_info->appid);
6680
6681                 if (SQLITE_OK != sqlite3_exec(pkgmgr_parser_db, query, NULL, NULL, &errmsg)) {
6682                         _LOGE("DB update [%s] failed, error message = %s\n", query, errmsg);
6683                         free(errmsg);
6684                         sqlite3_close(pkgmgr_parser_db);
6685                         return PMINFO_R_ERROR;
6686                 }else{
6687                         sqlite3_close(pkgmgr_parser_db);
6688                         len = strlen((char *)info->uiapp_info->appid) + 8;
6689                         noti_string = calloc(1, len);
6690                         if (noti_string == NULL){
6691                                 return PMINFO_R_ERROR;
6692                         }
6693                         snprintf(noti_string, len, "update:%s", (char *)info->uiapp_info->appid);
6694                 vconf_set_str(VCONFKEY_AIL_INFO_STATE, noti_string);
6695                         vconf_set_str(VCONFKEY_MENUSCREEN_DESKTOP, noti_string); // duplicate, will be removed
6696                         free(noti_string);
6697                 }
6698         }
6699         return PMINFO_R_OK;
6700 }