parser/src/pkgmgr_parser_db.c

   1 /*
   2  * pkgmgr-info
   3  *
   4  * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Contact: Jayoun Lee <airjany@samsung.com>, Sewook Park <sewook7.park@samsung.com>,
   7  * Jaeho Lee <jaeho81.lee@samsung.com>, Shobhit Srivastava <shobhit.s@samsung.com>
   8  *
   9  * Licensed under the Apache License, Version 2.0 (the "License");
  10  * you may not use this file except in compliance with the License.
  11  * You may obtain a copy of the License at
  12  *
  13  * http://www.apache.org/licenses/LICENSE-2.0
  14  *
  15  * Unless required by applicable law or agreed to in writing, software
  16  * distributed under the License is distributed on an "AS IS" BASIS,
  17  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  18  * See the License for the specific language governing permissions and
  19  * limitations under the License.
  20  *
  21  */
  22
  23 #define _GNU_SOURCE
  24 #include <stdio.h>
  25 #include <stdlib.h>
  26 #include <string.h>
  27 #include <sys/types.h>
  28 #include <sys/smack.h>
  29 #include <sys/stat.h>
  30 #include <fcntl.h>
  31 #include <unistd.h>
  32 #include <grp.h>
  33 #include <pwd.h>
  34
  35 #include <db-util.h>
  36 #include <glib.h>
  37 #include <system_info.h>
  38
  39 /* For multi-user support */
  40 #include <tzplatform_config.h>
  41
  42 #include "pkgmgr-info.h"
  43 #include "pkgmgrinfo_basic.h"
  44 #include "pkgmgr_parser_internal.h"
  45 #include "pkgmgr_parser_db.h"
  46 #include "pkgmgr_parser_debug.h"
  47
  48 #define PKGMGR_PARSER_DB_FILE tzplatform_mkpath(TZ_SYS_DB, ".pkgmgr_parser.db")
  49 #define PKGMGR_CERT_DB_FILE tzplatform_mkpath(TZ_SYS_DB, ".pkgmgr_cert.db")
  50 #define MAX_QUERY_LEN           4096
  51 #define BUFSIZE 4096
  52 #define OWNER_ROOT 0
  53 #define APPFW_USER "app_fw"
  54 #define MAX_INTEGER_LENGTH 10
  55
  56 #define LDPI "ldpi"
  57 #define MDPI "mdpi"
  58 #define HDPI "hdpi"
  59 #define XHDPI "xhdpi"
  60 #define XXHDPI "xxhdpi"
  61
  62 #define LDPI_MIN 0
  63 #define LDPI_MAX 240
  64 #define MDPI_MIN 241
  65 #define MDPI_MAX 300
  66 #define HDPI_MIN 301
  67 #define HDPI_MAX 380
  68 #define XHDPI_MIN 381
  69 #define XHDPI_MAX 480
  70 #define XXHDPI_MIN 481
  71 #define XXHDPI_MAX 600
  72
  73 #define DB_LABEL "User::Home"
  74 #define SET_SMACK_LABEL(x) \
  75 do { \
  76         if (smack_setlabel((x), DB_LABEL, SMACK_LABEL_ACCESS)) \
  77                 _LOGE("failed chsmack -a %s %s", DB_LABEL, x); \
  78         else \
  79                 _LOGD("chsmack -a %s %s", DB_LABEL, x); \
  80 } while (0)
  81
  82 sqlite3 *pkgmgr_parser_db;
  83 sqlite3 *pkgmgr_cert_db;
  84
  85
  86 #define QUERY_CREATE_TABLE_PACKAGE_INFO "CREATE TABLE IF NOT EXISTS package_info " \
  87                                                 "(package TEXT PRIMARY KEY NOT NULL, " \
  88                                                 "package_type TEXT DEFAULT 'tpk', " \
  89                                                 "package_version TEXT, " \
  90                                                 "package_api_version TEXT, " \
  91                                                 "package_tep_name TEXT, " \
  92                                                 "package_zip_mount_file TEXT, " \
  93                                                 "install_location TEXT NOT NULL , " \
  94                                                 "package_size TEXT, " \
  95                                                 "package_removable TEXT NOT NULL DEFAULT 'true', " \
  96                                                 "package_preload TEXT NOT NULL DEFAULT 'false', " \
  97                                                 "package_readonly TEXT NOT NULL DEFAULT 'false', " \
  98                                                 "package_update TEXT NOT NULL DEFAULT 'false', " \
  99                                                 "package_appsetting TEXT NOT NULL DEFAULT 'false', " \
 100                                                 "package_nodisplay TEXT NOT NULL DEFAULT 'false', " \
 101                                                 "package_system TEXT NOT NULL DEFAULT 'false', " \
 102                                                 "author_name TEXT, " \
 103                                                 "author_email TEXT, " \
 104                                                 "author_href TEXT," \
 105                                                 "installed_time TEXT, " \
 106                                                 "installed_storage TEXT, " \
 107                                                 "storeclient_id TEXT, " \
 108                                                 "mainapp_id TEXT, " \
 109                                                 "package_url TEXT, " \
 110                                                 "root_path TEXT, " \
 111                                                 "external_path TEXT, " \
 112                                                 "csc_path TEXT, " \
 113                                                 "package_support_mode TEXT, " \
 114                                                 "package_support_disable TEXT NOT NULL DEFAULT 'false', " \
 115                                                 "package_disable TEXT NOT NULL DEFAULT 'false')"
 116
 117 #define QUERY_CREATE_TABLE_PACKAGE_LOCALIZED_INFO "CREATE TABLE IF NOT EXISTS package_localized_info " \
 118                                                 "(package TEXT NOT NULL, " \
 119                                                 "package_locale TEXT NOT NULL DEFAULT 'No Locale', " \
 120                                                 "package_label TEXT, " \
 121                                                 "package_icon TEXT, " \
 122                                                 "package_description TEXT, " \
 123                                                 "package_license TEXT, " \
 124                                                 "package_author TEXT, " \
 125                                                 "PRIMARY KEY(package, package_locale), " \
 126                                                 "FOREIGN KEY(package) " \
 127                                                 "REFERENCES package_info(package) " \
 128                                                 "ON DELETE CASCADE)"
 129
 130 #define QUERY_CREATE_TABLE_PACKAGE_PRIVILEGE_INFO "CREATE TABLE IF NOT EXISTS package_privilege_info " \
 131                                                 "(package TEXT NOT NULL, " \
 132                                                 "privilege TEXT NOT NULL, " \
 133                                                 "type TEXT NOT NULL, " \
 134                                                 "PRIMARY KEY(package, privilege, type) " \
 135                                                 "FOREIGN KEY(package) " \
 136                                                 "REFERENCES package_info(package) " \
 137                                                 "ON DELETE CASCADE)"
 138
 139 #define QUERY_CREATE_TABLE_PACKAGE_UPDATE_INFO "CREATE TABLE IF NOT EXISTS package_update_info " \
 140                                                 "(package TEXT PRIMARY KEY, " \
 141                                                 "update_version TEXT NOT NULL, " \
 142                                                 "update_type TEXT NOT NULL DEFAULT 'none', " \
 143                                                 "FOREIGN KEY(package) " \
 144                                                 "REFERENCES package_info(package) " \
 145                                                 "ON DELETE CASCADE)"
 146
 147 #define QUERY_CREATE_TABLE_PACKAGE_APP_INFO "CREATE TABLE IF NOT EXISTS package_app_info " \
 148                                                 "(app_id TEXT PRIMARY KEY NOT NULL, " \
 149                                                 "app_component TEXT NOT NULL, " \
 150                                                 "app_exec TEXT, " \
 151                                                 "app_nodisplay TEXT NOT NULL DEFAULT 'false', " \
 152                                                 "app_type TEXT, " \
 153                                                 "app_onboot TEXT NOT NULL DEFAULT 'false', " \
 154                                                 "app_multiple TEXT NOT NULL DEFAULT 'false', " \
 155                                                 "app_autorestart TEXT NOT NULL DEFAULT 'false', " \
 156                                                 "app_taskmanage TEXT NOT NULL DEFAULT 'false', " \
 157                                                 "app_hwacceleration TEXT NOT NULL DEFAULT 'use-system-setting', " \
 158                                                 "app_screenreader TEXT NOT NULL DEFAULT 'use-system-setting', " \
 159                                                 "app_mainapp TEXT NOT NULL, " \
 160                                                 "app_recentimage TEXT NOT NULL DEFAULT 'false', " \
 161                                                 "app_launchcondition TEXT, " \
 162                                                 "app_indicatordisplay TEXT NOT NULL DEFAULT 'true', " \
 163                                                 "app_portraitimg TEXT, " \
 164                                                 "app_landscapeimg TEXT, " \
 165                                                 "app_guestmodevisibility TEXT NOT NULL DEFAULT 'true', " \
 166                                                 "app_permissiontype TEXT NOT NULL DEFAULT 'normal', " \
 167                                                 "app_preload TEXT NOT NULL DEFAULT 'false', " \
 168                                                 "app_submode TEXT NOT NULL DEFAULT 'false', " \
 169                                                 "app_submode_mainid TEXT, " \
 170                                                 "app_installed_storage TEXT NOT NULL, " \
 171                                                 "app_process_pool TEXT NOT NULL DEFAULT 'false', " \
 172                                                 "app_launch_mode TEXT NOT NULL DEFAULT 'caller', " \
 173                                                 "app_ui_gadget TEXT NOT NULL DEFAULT 'false', " \
 174                                                 "app_support_mode TEXT, " \
 175                                                 "app_support_disable TEXT NOT NULL DEFAULT 'false', " \
 176                                                 "app_disable TEXT NOT NULL DEFAULT 'false', " \
 177                                                 "app_package_type TEXT DEFAULT 'tpk', " \
 178                                                 "app_package_system TEXT NOT NULL, " \
 179                                                 "app_removable TEXT NOT NULL DEFAULT 'false', " \
 180                                                 "app_package_installed_time TEXT, " \
 181                                                 "app_support_ambient TEXT NOT NULL DEFAULT 'false', " \
 182                                                 "component_type TEXT, " \
 183                                                 "package TEXT NOT NULL, " \
 184                                                 "app_tep_name TEXT, " \
 185                                                 "app_zip_mount_file TEXT, " \
 186                                                 "app_background_category INTEGER DEFAULT 0, " \
 187                                                 "app_root_path TEXT, " \
 188                                                 "app_api_version TEXT, " \
 189                                                 "app_effective_appid TEXT, " \
 190                                                 "app_splash_screen_display TEXT NOT NULL DEFAULT 'true', " \
 191                                                 "app_external_path TEXT, " \
 192                                                 "app_setup_appid TEXT, " \
 193                                                 "FOREIGN KEY(package) " \
 194                                                 "REFERENCES package_info(package) " \
 195                                                 "ON DELETE CASCADE)"
 196
 197 #define QUERY_CREATE_TABLE_PACKAGE_APP_LOCALIZED_INFO "CREATE TABLE IF NOT EXISTS package_app_localized_info " \
 198                                                 "(app_id TEXT NOT NULL, " \
 199                                                 "app_locale TEXT NOT NULL DEFAULT 'No Locale', " \
 200                                                 "app_label TEXT, " \
 201                                                 "app_icon TEXT, " \
 202                                                 "PRIMARY KEY(app_id,app_locale) " \
 203                                                 "FOREIGN KEY(app_id) " \
 204                                                 "REFERENCES package_app_info(app_id) " \
 205                                                 "ON DELETE CASCADE)"
 206
 207 #define QUERY_CREATE_TABLE_PACKAGE_APP_ICON_SECTION_INFO "CREATE TABLE IF NOT EXISTS package_app_icon_section_info " \
 208                                                 "(app_id TEXT NOT NULL, " \
 209                                                 "app_icon TEXT, " \
 210                                                 "app_icon_section TEXT NOT NULL, " \
 211                                                 "app_icon_resolution TEXT NOT NULL, " \
 212                                                 "PRIMARY KEY(app_id,app_icon_section,app_icon_resolution) " \
 213                                                 "FOREIGN KEY(app_id) " \
 214                                                 "REFERENCES package_app_info(app_id) " \
 215                                                 "ON DELETE CASCADE)"
 216
 217 #define QUERY_CREATE_TABLE_PACKAGE_APP_IMAGE_INFO "CREATE TABLE IF NOT EXISTS package_app_image_info " \
 218                                                 "(app_id TEXT NOT NULL, " \
 219                                                 "app_locale TEXT DEFAULT 'No Locale', " \
 220                                                 "app_image_section TEXT NOT NULL, " \
 221                                                 "app_image TEXT, " \
 222                                                 "PRIMARY KEY(app_id,app_image_section) " \
 223                                                 "FOREIGN KEY(app_id) " \
 224                                                 "REFERENCES package_app_info(app_id) " \
 225                                                 "ON DELETE CASCADE)"
 226
 227 #define QUERY_CREATE_TABLE_PACKAGE_APP_APP_CONTROL "CREATE TABLE IF NOT EXISTS package_app_app_control " \
 228                                                 "(app_id TEXT NOT NULL, " \
 229                                                 "app_control TEXT NOT NULL, " \
 230                                                 "PRIMARY KEY(app_id,app_control) " \
 231                                                 "FOREIGN KEY(app_id) " \
 232                                                 "REFERENCES package_app_info(app_id) " \
 233                                                 "ON DELETE CASCADE)"
 234
 235 #define QUERY_CREATE_TABLE_PACKAGE_APP_APP_CATEGORY "CREATE TABLE IF NOT EXISTS package_app_app_category " \
 236                                                 "(app_id TEXT NOT NULL, " \
 237                                                 "category TEXT NOT NULL, " \
 238                                                 "PRIMARY KEY(app_id,category) " \
 239                                                 "FOREIGN KEY(app_id) " \
 240                                                 "REFERENCES package_app_info(app_id) " \
 241                                                 "ON DELETE CASCADE)"
 242
 243 #define QUERY_CREATE_TABLE_PACKAGE_APP_APP_METADATA "CREATE TABLE IF NOT EXISTS package_app_app_metadata " \
 244                                                 "(app_id TEXT NOT NULL, " \
 245                                                 "md_key TEXT NOT NULL, " \
 246                                                 "md_value TEXT, " \
 247                                                 "PRIMARY KEY(app_id, md_key, md_value) " \
 248                                                 "FOREIGN KEY(app_id) " \
 249                                                 "REFERENCES package_app_info(app_id) " \
 250                                                 "ON DELETE CASCADE)"
 251
 252 #define QUERY_CREATE_TABLE_PACKAGE_APP_APP_PERMISSION "CREATE TABLE IF NOT EXISTS package_app_app_permission " \
 253                                                 "(app_id TEXT NOT NULL, " \
 254                                                 "pm_type TEXT NOT NULL, " \
 255                                                 "pm_value TEXT NOT NULL, " \
 256                                                 "PRIMARY KEY(app_id, pm_type, pm_value) " \
 257                                                 "FOREIGN KEY(app_id) " \
 258                                                 "REFERENCES package_app_info(app_id) " \
 259                                                 "ON DELETE CASCADE)"
 260
 261 #define QUERY_CREATE_TABLE_PACKAGE_APP_SHARE_ALLOWED "CREATE TABLE IF NOT EXISTS package_app_share_allowed " \
 262                                                 "(app_id TEXT NOT NULL, " \
 263                                                 "data_share_path TEXT NOT NULL, " \
 264                                                 "data_share_allowed TEXT NOT NULL, " \
 265                                                 "PRIMARY KEY(app_id,data_share_path,data_share_allowed) " \
 266                                                 "FOREIGN KEY(app_id) " \
 267                                                 "REFERENCES package_app_info(app_id) " \
 268                                                 "ON DELETE CASCADE)"
 269
 270 #define QUERY_CREATE_TABLE_PACKAGE_APP_SHARE_REQUEST "CREATE TABLE IF NOT EXISTS package_app_share_request " \
 271                                                 "(app_id TEXT NOT NULL, " \
 272                                                 "data_share_request TEXT NOT NULL, " \
 273                                                 "PRIMARY KEY(app_id,data_share_request) " \
 274                                                 "FOREIGN KEY(app_id) " \
 275                                                 "REFERENCES package_app_info(app_id) " \
 276                                                 "ON DELETE CASCADE)"
 277
 278 #define QUERY_CREATE_TABLE_PACKAGE_APP_DATA_CONTROL "CREATE TABLE IF NOT EXISTS package_app_data_control " \
 279                                                 "(app_id TEXT NOT NULL, " \
 280                                                 "providerid TEXT NOT NULL, " \
 281                                                 "access TEXT NOT NULL, " \
 282                                                 "type TEXT NOT NULL, " \
 283                                                 "trusted TEXT NOT NULL, " \
 284                                                 "PRIMARY KEY(providerid, type) " \
 285                                                 "FOREIGN KEY(app_id) " \
 286                                                 "REFERENCES package_app_info(app_id) " \
 287                                                 "ON DELETE CASCADE)"
 288
 289 #define QUERY_CREATE_TABLE_PACKAGE_APP_INFO_FOR_UID "CREATE TABLE IF NOT EXISTS package_app_info_for_uid " \
 290                                                 "(app_id TEXT NOT NULL, " \
 291                                                 "uid INTEGER NOT NULL, " \
 292                                                 "is_disabled TEXT NOT NULL DEFAULT 'false', " \
 293                                                 "is_splash_screen_enabled TEXT NOT NULL, " \
 294                                                 "PRIMARY KEY(app_id, uid))"
 295
 296 #define QUERY_CREATE_TRIGGER_UPDATE_PACKAGE_APP_INFO_FOR_UID \
 297                                                 "CREATE TRIGGER IF NOT EXISTS update_package_appinfo_for_uid "\
 298                                                 "AFTER UPDATE ON package_app_info_for_uid " \
 299                                                 "BEGIN" \
 300                                                 " DELETE FROM package_app_info_for_uid WHERE " \
 301                                                 "       is_splash_screen_enabled=" \
 302                                                 "       (SELECT package_app_info.app_splash_screen_display FROM " \
 303                                                 "       package_app_info, package_app_info_for_uid WHERE " \
 304                                                 "       package_app_info.app_id=OLD.app_id) AND is_disabled='false';" \
 305                                                 "END;"
 306
 307 #define QUERY_CREATE_TABLE_PACKAGE_APP_SPLASH_SCREEN \
 308                                                 "CREATE TABLE IF NOT EXISTS package_app_splash_screen " \
 309                                                 "(app_id TEXT NOT NULL, " \
 310                                                 "src TEXT NOT NULL, " \
 311                                                 "type TEXT NOT NULL, " \
 312                                                 "orientation TEXT NOT NULL, " \
 313                                                 "indicatordisplay TEXT, " \
 314                                                 "operation TEXT NOT NULL, " \
 315                                                 "color_depth TEXT NOT NULL DEFAULT '24', " \
 316                                                 "PRIMARY KEY(app_id, orientation, operation) " \
 317                                                 "FOREIGN KEY(app_id) " \
 318                                                 "REFERENCES package_app_info(app_id) " \
 319                                                 "ON DELETE CASCADE)"
 320
 321
 322 /* FIXME: duplicated at pkgmgrinfo_db.c */
 323 #define QUERY_CREATE_TABLE_PACKAGE_CERT_INDEX_INFO \
 324                                                 "CREATE TABLE IF NOT EXISTS package_cert_index_info( " \
 325                                                 " cert_info TEXT UNIQUE, " \
 326                                                 " cert_id INTEGER PRIMARY KEY, " \
 327                                                 " cert_ref_count INTEGER NOT NULL)"
 328
 329 #define QUERY_CREATE_TABLE_PACKAGE_CERT_INFO \
 330                                                 "CREATE TABLE IF NOT EXISTS package_cert_info( " \
 331                                                 " package TEXT PRIMARY KEY, " \
 332                                                 " package_count INTEGER, " \
 333                                                 " author_root_cert INTEGER, " \
 334                                                 " author_im_cert INTEGER, " \
 335                                                 " author_signer_cert INTEGER, " \
 336                                                 " dist_root_cert INTEGER, " \
 337                                                 " dist_im_cert INTEGER, " \
 338                                                 " dist_signer_cert INTEGER, " \
 339                                                 " dist2_root_cert INTEGER, " \
 340                                                 " dist2_im_cert INTEGER, " \
 341                                                 " dist2_signer_cert INTEGER)"
 342
 343 #define QUERY_CREATE_TRIGGER_UPDATE_CERT_INFO \
 344                                                 "CREATE TRIGGER IF NOT EXISTS update_cert_info " \
 345                                                 "AFTER UPDATE ON package_cert_info " \
 346                                                 "WHEN (NEW.package_count = 0) " \
 347                                                 "BEGIN" \
 348                                                 " DELETE FROM package_cert_info WHERE package=OLD.package;" \
 349                                                 "END;"
 350
 351 #define QUERY_CREATE_TRIGGER_UPDATE_CERT_INFO2 \
 352                                                 "CREATE TRIGGER IF NOT EXISTS update_cert_info2 " \
 353                                                 "AFTER UPDATE ON package_cert_info " \
 354                                                 "WHEN (NEW.package_count = OLD.package_count + 1) " \
 355                                                 "BEGIN" \
 356                                                 " UPDATE package_cert_index_info SET" \
 357                                                 "  cert_ref_count = cert_ref_count - 1" \
 358                                                 " WHERE cert_id = OLD.author_root_cert" \
 359                                                 "  OR cert_id = OLD.author_im_cert" \
 360                                                 "  OR cert_id = OLD.author_signer_cert" \
 361                                                 "  OR cert_id = OLD.dist_root_cert" \
 362                                                 "  OR cert_id = OLD.dist_im_cert" \
 363                                                 "  OR cert_id = OLD.dist_signer_cert" \
 364                                                 "  OR cert_id = OLD.dist2_root_cert" \
 365                                                 "  OR cert_id = OLD.dist2_im_cert" \
 366                                                 "  OR cert_id = OLD.dist2_signer_cert;" \
 367                                                 "END;"
 368
 369 #define QUERY_CREATE_TRIGGER_DELETE_CERT_INFO \
 370                                                 "CREATE TRIGGER IF NOT EXISTS delete_cert_info " \
 371                                                 "AFTER DELETE ON package_cert_info " \
 372                                                 "BEGIN" \
 373                                                 " UPDATE package_cert_index_info SET" \
 374                                                 "  cert_ref_count = cert_ref_count - 1" \
 375                                                 " WHERE cert_id = OLD.author_root_cert" \
 376                                                 "  OR cert_id = OLD.author_im_cert" \
 377                                                 "  OR cert_id = OLD.author_signer_cert" \
 378                                                 "  OR cert_id = OLD.dist_root_cert" \
 379                                                 "  OR cert_id = OLD.dist_im_cert" \
 380                                                 "  OR cert_id = OLD.dist_signer_cert" \
 381                                                 "  OR cert_id = OLD.dist2_root_cert" \
 382                                                 "  OR cert_id = OLD.dist2_im_cert" \
 383                                                 "  OR cert_id = OLD.dist2_signer_cert;" \
 384                                                 "END;"
 385
 386 #define QUERY_CREATE_TRIGGER_UPDATE_CERT_INDEX_INFO \
 387                                                 "CREATE TRIGGER IF NOT EXISTS update_cert_index_info " \
 388                                                 "AFTER UPDATE ON package_cert_index_info " \
 389                                                 "WHEN ((SELECT cert_ref_count FROM package_cert_index_info " \
 390                                                 "       WHERE cert_id = OLD.cert_id) = 0) "\
 391                                                 "BEGIN" \
 392                                                 " DELETE FROM package_cert_index_info WHERE cert_id = OLD.cert_id;" \
 393                                                 "END;"
 394
 395 static int __insert_application_info(manifest_x *mfx);
 396 static int __insert_application_appcategory_info(manifest_x *mfx);
 397 static int __insert_application_appcontrol_info(manifest_x *mfx);
 398 static int __insert_application_appmetadata_info(manifest_x *mfx);
 399 static int __insert_application_share_allowed_info(manifest_x *mfx);
 400 static int __insert_application_share_request_info(manifest_x *mfx);
 401 static int __insert_application_datacontrol_info(manifest_x *mfx);
 402 static void __insert_application_locale_info(gpointer data, gpointer userdata);
 403 static void __insert_pkglocale_info(gpointer data, gpointer userdata);
 404 static int __insert_manifest_info_in_db(manifest_x *mfx, uid_t uid);
 405 static int __delete_manifest_info_from_db(manifest_x *mfx, uid_t uid);
 406 static int __delete_subpkg_info_from_db(char *appid);
 407 static int __delete_appinfo_from_db(char *db_table, const char *appid);
 408 static int __initialize_db(sqlite3 *db_handle, const char *db_query);
 409 static int __exec_query(char *query);
 410 static void __extract_data(gpointer data, GList *lbl, GList *lcn, GList *icn, GList *dcn, GList *ath,
 411                 char **label, char **license, char **icon, char **description, char **author);
 412 static gint __comparefunc(gconstpointer a, gconstpointer b, gpointer userdata);
 413 static GList *__create_locale_list(GList *locale, GList *lbl, GList *lcn, GList *icn, GList *dcn, GList *ath);
 414 static void __preserve_guestmode_visibility_value(manifest_x *mfx);
 415 static int __guestmode_visibility_cb(void *data, int ncols, char **coltxt, char **colname);
 416 static int __pkgmgr_parser_create_db(sqlite3 **db_handle, const char *db_path);
 417 static int __parserdb_change_perm(const char *db_file, uid_t uid);
 418
 419 #define REGULAR_USER 5000
 420 static inline uid_t _getuid(void)
 421 {
 422         uid_t uid = getuid();
 423
 424         if (uid < REGULAR_USER)
 425                 return tzplatform_getuid(TZ_SYS_GLOBALAPP_USER);
 426         else
 427                 return uid;
 428 }
 429
 430 static int __delete_subpkg_list_cb(void *data, int ncols, char **coltxt, char **colname)
 431 {
 432         if (coltxt[0])
 433                 __delete_subpkg_info_from_db(coltxt[0]);
 434
 435         return 0;
 436 }
 437
 438 static int __pkgmgr_parser_create_db(sqlite3 **db_handle, const char *db_path)
 439 {
 440         int ret = -1;
 441         sqlite3 *handle;
 442         char *query = NULL;
 443         char *error_message = NULL;
 444
 445         ret = db_util_open(db_path, &handle,  DB_UTIL_REGISTER_HOOK_METHOD);
 446         if (ret != SQLITE_OK) {
 447                 _LOGD("connect db [%s] failed!\n", db_path);
 448                 return -1;
 449         }
 450         *db_handle = handle;
 451
 452         /* add user_version for db upgrade*/
 453         query = sqlite3_mprintf("PRAGMA user_version=%d", (atoi(TIZEN_MAJOR_VER) * 10000 + atoi(TIZEN_MINOR_VER) * 100 + atoi(TIZEN_PATCH_VER)));
 454         if (SQLITE_OK !=
 455             sqlite3_exec(handle, query, NULL, NULL, &error_message)) {
 456                 _LOGE("Don't execute query = %s error message = %s\n", query,
 457                        error_message);
 458         }
 459         sqlite3_free(error_message);
 460         sqlite3_free(query);
 461
 462         return 0;
 463 }
 464
 465 static int __guestmode_visibility_cb(void *data, int ncols, char **coltxt, char **colname)
 466 {
 467         manifest_x *mfx = (manifest_x *)data;
 468         int i = 0;
 469         char *appid = NULL;
 470         char *status = NULL;
 471         application_x *app;
 472         GList *tmp;
 473         if (mfx->application == NULL)
 474                 return -1;
 475         app = (application_x *)mfx->application->data;
 476         for (i = 0; i < ncols; i++) {
 477                 if (strcmp(colname[i], "app_id") == 0) {
 478                         if (coltxt[i])
 479                                 appid = strdup(coltxt[i]);
 480                 } else if (strcmp(colname[i], "app_guestmodevisibility") == 0) {
 481                         if (coltxt[i])
 482                                 status = strdup(coltxt[i]);
 483                 }
 484         }
 485         if (appid == NULL) {
 486                 if (status != NULL)
 487                         free(status);
 488                 _LOGD("app id is NULL\n");
 489                 return -1;
 490         }
 491         /*update guest mode visibility*/
 492         for (tmp = mfx->application; tmp; tmp = tmp->next) {
 493                 app = (application_x *)tmp->data;
 494                 if (app == NULL)
 495                         continue;
 496                 if (strcmp(app->appid, appid) == 0) {
 497                         free((void *)app->guestmode_visibility);
 498                         app->guestmode_visibility = strdup(status);
 499                         break;
 500                 }
 501         }
 502         if (appid) {
 503                 free(appid);
 504                 appid = NULL;
 505         }
 506         if (status) {
 507                 free(status);
 508                 status = NULL;
 509         }
 510
 511         return 0;
 512 }
 513
 514 static void __preserve_guestmode_visibility_value(manifest_x *mfx)
 515 {
 516         char *error_message = NULL;
 517         char query[MAX_QUERY_LEN] = {'\0'};
 518         sqlite3_snprintf(MAX_QUERY_LEN, query,
 519                         "SELECT app_id, app_guestmodevisibility FROM package_app_info " \
 520                         "WHERE package=%Q", mfx->package);
 521         if (SQLITE_OK !=
 522             sqlite3_exec(pkgmgr_parser_db, query,
 523                          __guestmode_visibility_cb, (void *)mfx, &error_message)) {
 524                 _LOGD("Don't execute query = %s error message = %s\n",
 525                        query, error_message);
 526                 sqlite3_free(error_message);
 527         }
 528         return;
 529 }
 530
 531 static int __initialize_db(sqlite3 *db_handle, const char *db_query)
 532 {
 533         char *error_message = NULL;
 534         if (SQLITE_OK !=
 535             sqlite3_exec(db_handle, db_query,
 536                          NULL, NULL, &error_message)) {
 537                 _LOGD("Don't execute query = %s error message = %s\n",
 538                        db_query, error_message);
 539                 sqlite3_free(error_message);
 540                 return -1;
 541         }
 542         sqlite3_free(error_message);
 543         return 0;
 544 }
 545
 546 static int __exec_query(char *query)
 547 {
 548         char *error_message = NULL;
 549         if (SQLITE_OK !=
 550             sqlite3_exec(pkgmgr_parser_db, query, NULL, NULL, &error_message)) {
 551                 _LOGE("Don't execute query = %s error message = %s\n", query,
 552                        error_message);
 553                 sqlite3_free(error_message);
 554                 return -1;
 555         }
 556         sqlite3_free(error_message);
 557
 558         if (strncmp(query, "DELETE", 6) && sqlite3_changes(pkgmgr_parser_db) == 0) {
 559                 _LOGE("No such record matches with given query : %s\n", query);
 560                 return -1;
 561         }
 562         return 0;
 563 }
 564
 565 static GList *__create_locale_list(GList *locale, GList *lbls, GList *lcns, GList *icns, GList *dcns, GList *aths)
 566 {
 567         GList *tmp;
 568         label_x *lbl;
 569         license_x *lcn;
 570         icon_x *icn;
 571         description_x *dcn;
 572         author_x *ath;
 573         for (tmp = lbls; tmp; tmp = tmp->next) {
 574                 lbl = (label_x *)tmp->data;
 575                 if (lbl == NULL)
 576                         continue;
 577                 if (lbl->lang)
 578                         locale = g_list_insert_sorted_with_data(locale, (gpointer)lbl->lang, __comparefunc, NULL);
 579         }
 580         for (tmp = lcns; tmp; tmp = tmp->next) {
 581                 lcn = (license_x *)tmp->data;
 582                 if (lcn == NULL)
 583                         continue;
 584                 if (lcn->lang)
 585                         locale = g_list_insert_sorted_with_data(locale, (gpointer)lcn->lang, __comparefunc, NULL);
 586         }
 587         for (tmp = icns; tmp; tmp = tmp->next) {
 588                 icn = (icon_x *)tmp->data;
 589                 if (icn == NULL)
 590                         continue;
 591                 if (icn->lang)
 592                         locale = g_list_insert_sorted_with_data(locale, (gpointer)icn->lang, __comparefunc, NULL);
 593         }
 594         for (tmp = dcns; tmp; tmp = tmp->next) {
 595                 dcn = (description_x *)tmp->data;
 596                 if (dcn == NULL)
 597                         continue;
 598                 if (dcn->lang)
 599                         locale = g_list_insert_sorted_with_data(locale, (gpointer)dcn->lang, __comparefunc, NULL);
 600         }
 601         for (tmp = aths; tmp; tmp = tmp->next) {
 602                 ath = (author_x *)tmp->data;
 603                 if (ath == NULL)
 604                         continue;
 605                 if (ath->lang)
 606                         locale = g_list_insert_sorted_with_data(locale, (gpointer)ath->lang, __comparefunc, NULL);
 607         }
 608         return locale;
 609
 610 }
 611
 612 static GList *__create_icon_list(GList *appicon, GList *icns)
 613 {
 614         GList *tmp;
 615         icon_x *icn;
 616
 617         for (tmp = icns; tmp; tmp = tmp->next) {
 618                 icn = (icon_x *)tmp->data;
 619                 if (icn == NULL)
 620                         continue;
 621                 if (icn->section)
 622                         appicon = g_list_insert_sorted_with_data(appicon, (gpointer)icn->section, __comparefunc, NULL);
 623         }
 624         return appicon;
 625 }
 626
 627 static GList *__create_image_list(GList *appimage, GList *imgs)
 628 {
 629         GList *tmp;
 630         image_x *img;
 631
 632         for (tmp = imgs; tmp; tmp = tmp->next) {
 633                 img = (image_x *)tmp->data;
 634                 if (img == NULL)
 635                         continue;
 636                 if (img->section)
 637                         appimage = g_list_insert_sorted_with_data(appimage, (gpointer)img->section, __comparefunc, NULL);
 638         }
 639         return appimage;
 640 }
 641
 642 static void __trimfunc(GList *trim_list)
 643 {
 644         char *trim_data = NULL;
 645         char *prev = NULL;
 646
 647         GList *list = NULL;
 648         list = g_list_first(trim_list);
 649
 650         while (list) {
 651                 trim_data = (char *)list->data;
 652                 if (trim_data) {
 653                         if (prev) {
 654                                 if (strcmp(trim_data, prev) == 0) {
 655                                         trim_list = g_list_remove(trim_list, trim_data);
 656                                         list = g_list_first(trim_list);
 657                                         prev = NULL;
 658                                         continue;
 659                                 } else
 660                                         prev = trim_data;
 661                         } else {
 662                                 prev = trim_data;
 663                         }
 664                 }
 665                 list = g_list_next(list);
 666         }
 667 }
 668
 669 static gint __comparefunc(gconstpointer a, gconstpointer b, gpointer userdata)
 670 {
 671         if (a == NULL || b == NULL)
 672                 return 0;
 673         if (strcmp((char *)a, (char *)b) == 0)
 674                 return 0;
 675         if (strcmp((char *)a, (char *)b) < 0)
 676                 return -1;
 677         if (strcmp((char *)a, (char *)b) > 0)
 678                 return 1;
 679         return 0;
 680 }
 681
 682 static int __check_dpi(const char *dpi_char, int dpi_int)
 683 {
 684         if (dpi_char == NULL)
 685                 return -1;
 686
 687         if (strcasecmp(dpi_char, LDPI) == 0) {
 688                 if (dpi_int >= LDPI_MIN && dpi_int <= LDPI_MAX)
 689                         return 0;
 690                 else
 691                         return -1;
 692         } else if (strcasecmp(dpi_char, MDPI) == 0) {
 693                 if (dpi_int >= MDPI_MIN && dpi_int <= MDPI_MAX)
 694                         return 0;
 695                 else
 696                         return -1;
 697         } else if (strcasecmp(dpi_char, HDPI) == 0) {
 698                 if (dpi_int >= HDPI_MIN && dpi_int <= HDPI_MAX)
 699                         return 0;
 700                 else
 701                         return -1;
 702         } else if (strcasecmp(dpi_char, XHDPI) == 0) {
 703                 if (dpi_int >= XHDPI_MIN && dpi_int <= XHDPI_MAX)
 704                         return 0;
 705                 else
 706                         return -1;
 707         } else if (strcasecmp(dpi_char, XXHDPI) == 0) {
 708                 if (dpi_int >= XXHDPI_MIN && dpi_int <= XXHDPI_MAX)
 709                         return 0;
 710                 else
 711                         return -1;
 712         } else
 713                 return -1;
 714 }
 715
 716 static gint __check_icon_folder(const char *orig_icon_path, char **new_icon_path)
 717 {
 718         char *dpi_path[2];
 719         char *icon_filename = NULL;
 720         char modified_iconpath[BUFSIZE] = { '\0' };
 721         char icon_path[BUFSIZE] = { '\0' };
 722         int i;
 723         int dpi = -1;
 724
 725         if (orig_icon_path == NULL)
 726                 return -1;
 727
 728         system_info_get_platform_int("http://tizen.org/feature/screen.dpi", &dpi);
 729         if (!dpi)
 730                 return -1;
 731
 732         if (dpi >= LDPI_MIN && dpi <= LDPI_MAX) {
 733                 dpi_path[0] = "LDPI";
 734                 dpi_path[1] = "ldpi";
 735         } else if (dpi >= MDPI_MIN && dpi <= MDPI_MAX) {
 736                 dpi_path[0] = "MDPI";
 737                 dpi_path[1] = "mdpi";
 738         } else if (dpi >= HDPI_MIN && dpi <= HDPI_MAX) {
 739                 dpi_path[0] = "HDPI";
 740                 dpi_path[1] = "hdpi";
 741         } else if (dpi >= XHDPI_MIN && dpi <= XHDPI_MAX) {
 742                 dpi_path[0] = "XHDPI";
 743                 dpi_path[1] = "xhdpi";
 744         } else if (dpi >= XXHDPI_MIN && dpi <= XXHDPI_MAX) {
 745                 dpi_path[0] = "XXHDPI";
 746                 dpi_path[1] = "xxhdpi";
 747         } else {
 748                 _LOGE("Unidentified dpi[%d]", dpi);
 749                 return -1;
 750         }
 751
 752         icon_filename = strrchr(orig_icon_path, '/');
 753         if (icon_filename == NULL)
 754                 return -1;
 755
 756         snprintf(icon_path, strlen(orig_icon_path) - (strlen(icon_filename) - 1), "%s", orig_icon_path);
 757         for (i = 0; i < 2; i++) {
 758                 snprintf(modified_iconpath, BUFSIZE - 1, "%s/%s%s", icon_path, dpi_path[i], icon_filename);
 759                 if (access(modified_iconpath, F_OK) != -1) {
 760                         /* if exists, return modified icon path */
 761                         *new_icon_path = strdup(modified_iconpath);
 762                         return 0;
 763                 }
 764         }
 765
 766         return -1;
 767 }
 768
 769 static gint __compare_icon(gconstpointer a, gconstpointer b)
 770 {
 771         icon_x *icon = (icon_x *)a;
 772
 773         char *icon_folder_path = NULL;
 774
 775         if (icon->lang != NULL && strcasecmp(icon->lang, DEFAULT_LOCALE) != 0)
 776                 return -1;
 777
 778         if (icon->dpi != NULL)
 779                 return -1;
 780
 781         if (__check_icon_folder(icon->text, &icon_folder_path) == 0) {
 782                 free(icon->text);
 783                 icon->text = icon_folder_path;
 784         }
 785
 786         return 0;
 787 }
 788
 789 static gint __compare_icon_with_dpi(gconstpointer a, gconstpointer b)
 790 {
 791         icon_x *icon = (icon_x *)a;
 792         int dpi = GPOINTER_TO_INT(b);
 793
 794         if (icon->lang != NULL && strcasecmp(icon->lang, DEFAULT_LOCALE) != 0)
 795                 return -1;
 796
 797         if (icon->dpi == NULL)
 798                 return -1;
 799
 800         if (__check_dpi(icon->dpi, dpi) == 0)
 801                 return 0;
 802
 803         return -1;
 804 }
 805
 806 static gint __compare_icon_with_lang(gconstpointer a, gconstpointer b)
 807 {
 808         icon_x *icon = (icon_x *)a;
 809         char *lang = (char *)b;
 810         char *icon_folder_path = NULL;
 811
 812         if (icon->dpi != NULL)
 813                 return -1;
 814
 815         if (strcasecmp(icon->lang, lang) == 0) {
 816                 if (strcasecmp(icon->lang, DEFAULT_LOCALE) == 0) {
 817                         /* icon for no locale. check existance of folder-hierachied default icons */
 818                         if (__check_icon_folder(icon->text, &icon_folder_path) == 0) {
 819                                 free(icon->text);
 820                                 icon->text = icon_folder_path;
 821                         }
 822                 }
 823                 return 0;
 824         }
 825
 826         return -1;
 827 }
 828
 829 static gint __compare_icon_with_lang_dpi(gconstpointer a, gconstpointer b)
 830 {
 831         icon_x *icon = (icon_x *)a;
 832         char *lang = (char *)b;
 833         int dpi = -1;
 834
 835         system_info_get_platform_int("http://tizen.org/feature/screen.dpi", &dpi);
 836         if (!dpi)
 837                 return -1;
 838
 839         if (strcasecmp(icon->lang, lang) == 0 && __check_dpi(icon->dpi, dpi) == 0)
 840                 return 0;
 841
 842         return -1;
 843 }
 844
 845 static char *__find_icon(GList *icons, const char *lang)
 846 {
 847         GList *tmp;
 848         icon_x *icon = NULL;
 849         int dpi = 0;
 850         int ret;
 851
 852         /* first, find icon whose locale and dpi with given lang and system's dpi has matched */
 853         tmp = g_list_find_custom(icons, lang, (GCompareFunc)__compare_icon_with_lang_dpi);
 854         if (tmp != NULL) {
 855                 icon = (icon_x *)tmp->data;
 856                 return (char *)icon->text;
 857         }
 858
 859         /* if first has failed, find icon whose locale has matched */
 860         tmp = g_list_find_custom(icons, lang, (GCompareFunc)__compare_icon_with_lang);
 861         if (tmp != NULL) {
 862                 icon = (icon_x *)tmp->data;
 863                 return (char *)icon->text;
 864         }
 865
 866         /* if second has failed, find icon whose dpi has matched with system's dpi */
 867         ret = system_info_get_platform_int("http://tizen.org/feature/screen.dpi", &dpi);
 868         if (ret == SYSTEM_INFO_ERROR_NONE) {
 869                 tmp = g_list_find_custom(icons, GINT_TO_POINTER(dpi), (GCompareFunc)__compare_icon_with_dpi);
 870                 if (tmp != NULL) {
 871                         icon = (icon_x *)tmp->data;
 872                         return (char *)icon->text;
 873                 }
 874         }
 875
 876         /* last, find default icon marked as "No Locale" */
 877         tmp = g_list_find_custom(icons, NULL, (GCompareFunc)__compare_icon);
 878         if (tmp != NULL) {
 879                 icon = (icon_x *)tmp->data;
 880                 return (char *)icon->text;
 881         }
 882
 883         return NULL;
 884 }
 885
 886 static void __extract_data(gpointer data, GList *lbls, GList *lcns, GList *icns, GList *dcns, GList *aths,
 887                 char **label, char **license, char **icon, char **description, char **author)
 888 {
 889         GList *tmp;
 890         label_x *lbl;
 891         license_x *lcn;
 892         description_x *dcn;
 893         author_x *ath;
 894         for (tmp = lbls; tmp; tmp = tmp->next) {
 895                 lbl = (label_x *)tmp->data;
 896                 if (lbl == NULL)
 897                         continue;
 898                 if (lbl->lang) {
 899                         if (strcmp(lbl->lang, (char *)data) == 0) {
 900                                 *label = (char *)lbl->text;
 901                                 break;
 902                         }
 903                 }
 904         }
 905         for (tmp = lcns; tmp; tmp = tmp->next) {
 906                 lcn = (license_x *)tmp->data;
 907                 if (lcn == NULL)
 908                         continue;
 909                 if (lcn->lang) {
 910                         if (strcmp(lcn->lang, (char *)data) == 0) {
 911                                 *license = (char *)lcn->text;
 912                                 break;
 913                         }
 914                 }
 915         }
 916
 917         *icon = __find_icon(icns, (char *)data);
 918
 919         for (tmp = dcns; tmp; tmp = tmp->next) {
 920                 dcn = (description_x *)tmp->data;
 921                 if (dcn == NULL)
 922                         continue;
 923                 if (dcn->lang) {
 924                         if (strcmp(dcn->lang, (char *)data) == 0) {
 925                                 *description = (char *)dcn->text;
 926                                 break;
 927                         }
 928                 }
 929         }
 930         for (tmp = aths; tmp; tmp = tmp->next) {
 931                 ath = (author_x *)tmp->data;
 932                 if (ath == NULL)
 933                         continue;
 934                 if (ath->lang) {
 935                         if (strcmp(ath->lang, (char *)data) == 0) {
 936                                 *author = (char *)ath->text;
 937                                 break;
 938                         }
 939                 }
 940         }
 941
 942 }
 943
 944 static void __extract_icon_data(gpointer data, GList *icns, char **icon, char **resolution)
 945 {
 946         GList *tmp;
 947         icon_x *icn;
 948         for (tmp = icns; tmp; tmp = tmp->next) {
 949                 icn = (icon_x *)tmp->data;
 950                 if (icn == NULL)
 951                         continue;
 952                 if (icn->section) {
 953                         if (strcmp(icn->section, (char *)data) == 0) {
 954                                 *icon = (char *)icn->text;
 955                                 *resolution = (char *)icn->resolution;
 956                                 break;
 957                         }
 958                 }
 959         }
 960 }
 961
 962 static void __extract_image_data(gpointer data, GList *imgs, char **lang, char **image)
 963 {
 964         GList *tmp;
 965         image_x *img;
 966         for (tmp = imgs; tmp; tmp = tmp->next) {
 967                 img = (image_x *)tmp->data;
 968                 if (img == NULL)
 969                         continue;
 970                 if (img->section) {
 971                         if (strcmp(img->section, (char *)data) == 0) {
 972                                 *lang = (char *)img->lang;
 973                                 *image = (char *)img->text;
 974                                 break;
 975                         }
 976                 }
 977         }
 978 }
 979
 980 static void __insert_pkglocale_info(gpointer data, gpointer userdata)
 981 {
 982         int ret = -1;
 983         char *label = NULL;
 984         char *icon = NULL;
 985         char *description = NULL;
 986         char *license = NULL;
 987         char *author = NULL;
 988         char *query = NULL;
 989
 990         manifest_x *mfx = (manifest_x *)userdata;
 991         GList *lbl = mfx->label;
 992         GList *lcn = mfx->license;
 993         GList *icn = mfx->icon;
 994         GList *dcn = mfx->description;
 995         GList *ath = mfx->author;
 996
 997         __extract_data(data, lbl, lcn, icn, dcn, ath, &label, &license, &icon, &description, &author);
 998         if (!label && !description && !icon && !license && !author)
 999                 return;
1000
1001         query = sqlite3_mprintf("INSERT INTO package_localized_info(package, package_locale, " \
1002                 "package_label, package_icon, package_description, package_license, package_author) VALUES" \
1003                 "(%Q, %Q, %Q, %Q, %Q, %Q, %Q)",
1004                 mfx->package,
1005                 (char *)data,
1006                 label,
1007                 icon,
1008                 description,
1009                 license,
1010                 author);
1011
1012         ret = __exec_query(query);
1013         if (ret == -1)
1014                 _LOGD("Package Localized Info DB Insert failed\n");
1015
1016         sqlite3_free(query);
1017 }
1018
1019 static void __insert_application_locale_info(gpointer data, gpointer userdata)
1020 {
1021         int ret = -1;
1022         char *label = NULL;
1023         char *icon = NULL;
1024         char *query = NULL;
1025         char *locale = (char *)data;
1026
1027         application_x *app = (application_x *)userdata;
1028         GList *lbl = app->label;
1029         GList *icn = app->icon;
1030
1031         __extract_data(data, lbl, NULL, icn, NULL, NULL, &label, NULL, &icon, NULL, NULL);
1032         if (!label && !icon)
1033                 return;
1034
1035         query = sqlite3_mprintf("INSERT INTO package_app_localized_info(app_id, app_locale, " \
1036                 "app_label, app_icon) VALUES" \
1037                 "(%Q, %Q, %Q, %Q)", app->appid, (char *)data,
1038                 label, icon);
1039         ret = __exec_query(query);
1040         if (ret == -1)
1041                 _LOGD("Package UiApp Localized Info DB Insert failed\n");
1042
1043         sqlite3_free(query);
1044
1045         /*insert ui app locale info to pkg locale to get mainapp data */
1046         if (strcasecmp(app->mainapp, "true") == 0) {
1047                 query = sqlite3_mprintf("INSERT OR REPLACE INTO package_localized_info(package, package_locale, "
1048                         "package_label, package_icon, package_description, package_license, package_author) VALUES"
1049                         "(%Q, %Q, "
1050                         "COALESCE((SELECT package_label FROM package_localized_info WHERE package=%Q AND package_locale=%Q), %Q), "
1051                         "COALESCE((SELECT package_icon FROM package_localized_info WHERE package=%Q AND package_locale=%Q), %Q), "
1052                         "(SELECT package_description FROM package_localized_info WHERE package=%Q AND package_locale=%Q), "
1053                         "(SELECT package_license FROM package_localized_info WHERE package=%Q AND package_locale=%Q), "
1054                         "(SELECT package_author FROM package_localized_info WHERE package=%Q AND package_locale=%Q))",
1055                         app->package, locale,
1056                         app->package, locale, label,
1057                         app->package, locale, icon,
1058                         app->package, locale,
1059                         app->package, locale,
1060                         app->package, locale);
1061
1062                 ret = __exec_query(query);
1063                 if (ret == -1)
1064                         _LOGE("Package Localized Info DB Insert failed");
1065                 sqlite3_free(query);
1066         }
1067 }
1068
1069 static void __insert_application_icon_section_info(gpointer data, gpointer userdata)
1070 {
1071         int ret = -1;
1072         char *icon = NULL;
1073         char *resolution = NULL;
1074         char query[MAX_QUERY_LEN] = {'\0'};
1075
1076         application_x *app = (application_x *)userdata;
1077         GList *icn = app->icon;
1078
1079         __extract_icon_data(data, icn, &icon, &resolution);
1080         if (!icon && !resolution)
1081                 return;
1082         sqlite3_snprintf(MAX_QUERY_LEN, query, "INSERT INTO package_app_icon_section_info(app_id, " \
1083                 "app_icon, app_icon_section, app_icon_resolution) VALUES " \
1084                 "(%Q, %Q, %Q, %Q)", app->appid,
1085                 icon, (char *)data, resolution);
1086
1087         ret = __exec_query(query);
1088         if (ret == -1)
1089                 _LOGD("Package UiApp Localized Info DB Insert failed\n");
1090
1091 }
1092
1093 static void __insert_application_image_info(gpointer data, gpointer userdata)
1094 {
1095         int ret = -1;
1096         char *lang = NULL;
1097         char *img = NULL;
1098         char query[MAX_QUERY_LEN] = {'\0'};
1099
1100         application_x *app = (application_x *)userdata;
1101         GList *image = app->image;
1102
1103         __extract_image_data(data, image, &lang, &img);
1104         if (!lang && !img)
1105                 return;
1106         sqlite3_snprintf(MAX_QUERY_LEN, query,
1107                 "INSERT INTO package_app_image_info(app_id, app_locale, " \
1108                 "app_image_section, app_image) VALUES" \
1109                 "(%Q, %Q, %Q, %Q)", app->appid, lang, (char *)data, img);
1110
1111         ret = __exec_query(query);
1112         if (ret == -1)
1113                 _LOGD("Package UiApp image Info DB Insert failed\n");
1114
1115 }
1116
1117
1118 static int __insert_mainapp_info(manifest_x *mfx)
1119 {
1120         GList *tmp;
1121         application_x *app;
1122         int ret = -1;
1123         char query[MAX_QUERY_LEN] = {'\0'};
1124         for (tmp = mfx->application; tmp; tmp = tmp->next) {
1125                 app = (application_x *)tmp->data;
1126                 if (app == NULL)
1127                         continue;
1128                 if (strcasecmp(app->mainapp, "True") == 0)
1129                         mfx->mainapp_id = strdup(app->appid);
1130         }
1131
1132         if (mfx->mainapp_id == NULL) {
1133                 if (mfx->application == NULL)
1134                         return -1;
1135                 app = (application_x *)mfx->application->data;
1136                 if (app == NULL)
1137                         return -1;
1138                 free((void *)app->mainapp);
1139                 app->mainapp = strdup("true");
1140                 mfx->mainapp_id = strdup(app->appid);
1141         }
1142
1143         memset(query, '\0', MAX_QUERY_LEN);
1144         sqlite3_snprintf(MAX_QUERY_LEN, query,
1145                         "UPDATE package_info SET mainapp_id=%Q WHERE package=%Q", mfx->mainapp_id, mfx->package);
1146         ret = __exec_query(query);
1147         if (ret == -1) {
1148                 _LOGD("Package Info DB update Failed\n");
1149                 return -1;
1150         }
1151
1152         return 0;
1153 }
1154
1155 static int __convert_background_category(GList *category_list)
1156 {
1157         int ret = 0;
1158         GList *tmp_list = category_list;
1159         char *category_data = NULL;
1160
1161         if (category_list == NULL)
1162                 return 0;
1163
1164         while (tmp_list != NULL) {
1165                 category_data = (char *)tmp_list->data;
1166                 if (strcmp(category_data, APP_BG_CATEGORY_MEDIA_STR) == 0)
1167                         ret = ret | APP_BG_CATEGORY_MEDIA_VAL;
1168                 else if (strcmp(category_data, APP_BG_CATEGORY_DOWNLOAD_STR) == 0)
1169                         ret = ret | APP_BG_CATEGORY_DOWNLOAD_VAL;
1170                 else if (strcmp(category_data, APP_BG_CATEGORY_BGNETWORK_STR) == 0)
1171                         ret = ret | APP_BG_CATEGORY_BGNETWORK_VAL;
1172                 else if (strcmp(category_data, APP_BG_CATEGORY_LOCATION_STR) == 0)
1173                         ret = ret | APP_BG_CATEGORY_LOCATION_VAL;
1174                 else if (strcmp(category_data, APP_BG_CATEGORY_SENSOR_STR) == 0)
1175                         ret = ret | APP_BG_CATEGORY_SENSOR_VAL;
1176                 else if (strcmp(category_data, APP_BG_CATEGORY_IOTCOMM_STR) == 0)
1177                         ret = ret | APP_BG_CATEGORY_IOTCOMM_VAL;
1178                 else if (strcmp(category_data, APP_BG_CATEGORY_SYSTEM) == 0)
1179                         ret = ret | APP_BG_CATEGORY_SYSTEM_VAL;
1180                 else
1181                         _LOGE("Unidentified category [%s]", category_data);
1182                 tmp_list = g_list_next(tmp_list);
1183         }
1184
1185         return ret;
1186 }
1187
1188 static const char *__find_effective_appid(GList *metadata_list)
1189 {
1190         GList *tmp_list;
1191         metadata_x *md;
1192
1193         for (tmp_list = metadata_list; tmp_list; tmp_list = tmp_list->next) {
1194                 md = (metadata_x *)tmp_list->data;
1195                 if (md == NULL || md->key == NULL)
1196                         continue;
1197
1198                 if (strcmp(md->key, "http://tizen.org/metadata/effective-appid") == 0) {
1199                         if (md->value)
1200                                 return md->value;
1201                 }
1202         }
1203
1204         return NULL;
1205 }
1206
1207 static char *__get_bool(char *value, bool is_true)
1208 {
1209         if (value != NULL) {
1210                 if (!strcmp(value, ""))
1211                         return (is_true) ? "true" : "false";
1212                 return value;
1213         }
1214
1215         return (is_true) ? "true" : "false";
1216 }
1217
1218 static int __insert_pkg_updateinfo_in_db(manifest_x *mfx, uid_t uid)
1219 {
1220         char query[MAX_QUERY_LEN] = {'\0'};
1221         int ret;
1222
1223         if (mfx == NULL)
1224                 return -1;
1225
1226         sqlite3_snprintf(MAX_QUERY_LEN, query,
1227                         "INSERT INTO package_update_info(" \
1228                         "package, update_version) VALUES(%Q, %Q)",
1229                         mfx->package, mfx->version);
1230         ret = __exec_query(query);
1231
1232         return ret;
1233 }
1234
1235 /* _PRODUCT_LAUNCHING_ENHANCED_
1236 *  app->indicatordisplay, app->portraitimg, app->landscapeimg, app->guestmode_appstatus
1237 */
1238 static int __insert_application_info(manifest_x *mfx)
1239 {
1240         GList *tmp;
1241         application_x *app;
1242         int ret = -1;
1243         int background_value = 0;
1244         char query[MAX_QUERY_LEN] = {'\0'};
1245         char *type = NULL;
1246         const char *effective_appid;
1247
1248         if (mfx->type)
1249                 type = strdup(mfx->type);
1250         else
1251                 type = strdup("tpk");
1252
1253         for (tmp = mfx->application; tmp; tmp = tmp->next) {
1254                 app = (application_x *)tmp->data;
1255                 if (app == NULL)
1256                         continue;
1257
1258                 background_value = __convert_background_category(app->background_category);
1259                 if (background_value < 0) {
1260                         _LOGE("Failed to retrieve background value[%d]", background_value);
1261                         background_value = 0;
1262                 }
1263
1264                 effective_appid = __find_effective_appid(app->metadata);
1265
1266                 sqlite3_snprintf(MAX_QUERY_LEN, query,
1267                         "INSERT INTO package_app_info(" \
1268                         "app_id, app_component, app_exec, app_nodisplay, app_type, " \
1269                         "app_onboot, app_multiple, app_autorestart, app_taskmanage, " \
1270                         "app_hwacceleration, app_screenreader, app_mainapp, app_recentimage, app_launchcondition, " \
1271                         "app_indicatordisplay, app_portraitimg, app_landscapeimg, app_guestmodevisibility, app_permissiontype, " \
1272                         "app_preload, app_submode, app_submode_mainid, app_installed_storage, app_process_pool, " \
1273                         "app_launch_mode, app_ui_gadget, app_support_mode, app_support_disable, component_type, package, " \
1274                         "app_tep_name, app_zip_mount_file, app_background_category, app_package_type, app_root_path, " \
1275                         "app_api_version, app_effective_appid, app_splash_screen_display, app_package_system, app_removable, " \
1276                         "app_package_installed_time, app_support_ambient, app_setup_appid) " \
1277                         "VALUES(" \
1278                         "%Q, %Q, %Q, LOWER(%Q), %Q, " \
1279                         "LOWER(%Q), LOWER(%Q), LOWER(%Q), LOWER(%Q), " \
1280                         "%Q, %Q, %Q, %Q, %Q, " \
1281                         "LOWER(%Q), %Q, %Q, LOWER(%Q), %Q, " \
1282                         "LOWER(%Q), LOWER(%Q), %Q, %Q, LOWER(%Q), " \
1283                         "COALESCE(%Q, 'caller'), LOWER(%Q), %Q, LOWER(%Q), %Q, %Q, " \
1284                         "%Q, %Q, %d, %Q, %Q, " \
1285                         "%Q, %Q, LOWER(%Q), LOWER(%Q), LOWER(%Q), " \
1286                         "%Q, LOWER(%Q), %Q)", \
1287                         app->appid, app->component_type, app->exec, __get_bool(app->nodisplay, false), app->type,
1288                         __get_bool(app->onboot, false), __get_bool(app->multiple, false), __get_bool(app->autorestart, false), __get_bool(app->taskmanage, false),
1289                         app->hwacceleration, app->screenreader, app->mainapp, app->recentimage, app->launchcondition,
1290                         __get_bool(app->indicatordisplay, true), app->portraitimg, app->landscapeimg,
1291                         __get_bool(app->guestmode_visibility, true), app->permission_type,
1292                         __get_bool(mfx->preload, false), __get_bool(app->submode, false), app->submode_mainid, mfx->installed_storage, __get_bool(app->process_pool, false),
1293                         app->launch_mode, __get_bool(app->ui_gadget, false), mfx->support_mode, __get_bool(mfx->support_disable, false), app->component_type, mfx->package,
1294                         mfx->tep_name, mfx->zip_mount_file, background_value, type, mfx->root_path, mfx->api_version,
1295                         effective_appid, __get_bool(app->splash_screen_display, false), __get_bool(mfx->system, false), __get_bool(mfx->removable, true),
1296                         mfx->installed_time, __get_bool(app->support_ambient, false), app->setup_appid);
1297
1298                 ret = __exec_query(query);
1299                 if (ret == -1) {
1300                         _LOGD("Package UiApp Info DB Insert Failed\n");
1301                         if (type)
1302                                 free(type);
1303                         return -1;
1304                 }
1305                 memset(query, '\0', MAX_QUERY_LEN);
1306         }
1307
1308         if (type)
1309                 free(type);
1310
1311         return 0;
1312 }
1313
1314 static int __insert_application_appcategory_info(manifest_x *mfx)
1315 {
1316         GList *app_tmp;
1317         application_x *app;
1318         GList *ct_tmp;
1319         const char *ct;
1320         int ret = -1;
1321         char query[MAX_QUERY_LEN] = {'\0'};
1322         for (app_tmp = mfx->application; app_tmp; app_tmp = app_tmp->next) {
1323                 app = (application_x *)app_tmp->data;
1324                 if (app == NULL)
1325                         continue;
1326                 for (ct_tmp = app->category; ct_tmp; ct_tmp = ct_tmp->next) {
1327                         ct = (const char *)ct_tmp->data;
1328                         if (ct == NULL)
1329                                 continue;
1330                         sqlite3_snprintf(MAX_QUERY_LEN, query,
1331                                 "INSERT INTO package_app_app_category(app_id, category) " \
1332                                 "VALUES(%Q, %Q)",\
1333                                  app->appid, ct);
1334                         ret = __exec_query(query);
1335                         if (ret == -1) {
1336                                 _LOGD("Package UiApp Category Info DB Insert Failed\n");
1337                                 return -1;
1338                         }
1339                         memset(query, '\0', MAX_QUERY_LEN);
1340                 }
1341         }
1342         return 0;
1343 }
1344
1345 static int __insert_application_appmetadata_info(manifest_x *mfx)
1346 {
1347         GList *app_tmp;
1348         application_x *app;
1349         GList *md_tmp;
1350         metadata_x *md;
1351         int ret = -1;
1352         char query[MAX_QUERY_LEN] = {'\0'};
1353         for (app_tmp = mfx->application; app_tmp; app_tmp = app_tmp->next) {
1354                 app = (application_x *)app_tmp->data;
1355                 if (app == NULL)
1356                         continue;
1357                 for (md_tmp = app->metadata; md_tmp; md_tmp = md_tmp->next) {
1358                         md = (metadata_x *)md_tmp->data;
1359                         if (md == NULL)
1360                                 continue;
1361                         if (md->key) {
1362                                 sqlite3_snprintf(MAX_QUERY_LEN, query,
1363                                         "INSERT INTO package_app_app_metadata(app_id, md_key, md_value) " \
1364                                         "VALUES(%Q, %Q, %Q)",\
1365                                          app->appid, md->key, md->value ? md->value : NULL);
1366                                 ret = __exec_query(query);
1367                                 if (ret == -1) {
1368                                         _LOGD("Package UiApp Metadata Info DB Insert Failed\n");
1369                                         return -1;
1370                                 }
1371                         }
1372                         memset(query, '\0', MAX_QUERY_LEN);
1373                 }
1374         }
1375         return 0;
1376 }
1377
1378 static int __insert_application_apppermission_info(manifest_x *mfx)
1379 {
1380         GList *app_tmp;
1381         application_x *app;
1382         GList *pm_tmp;
1383         permission_x *pm;
1384         int ret = -1;
1385         char query[MAX_QUERY_LEN] = {'\0'};
1386         for (app_tmp = mfx->application; app_tmp; app_tmp = app_tmp->next) {
1387                 app = (application_x *)app_tmp->data;
1388                 if (app == NULL)
1389                         continue;
1390                 for (pm_tmp = app->permission; pm_tmp; pm_tmp = pm_tmp->next) {
1391                         pm = (permission_x *)pm_tmp->data;
1392                         if (pm == NULL)
1393                                 continue;
1394                         sqlite3_snprintf(MAX_QUERY_LEN, query,
1395                                 "INSERT INTO package_app_app_permission(app_id, pm_type, pm_value) " \
1396                                 "VALUES(%Q, %Q, %Q)",\
1397                                  app->appid, pm->type, pm->value);
1398                         ret = __exec_query(query);
1399                         if (ret == -1) {
1400                                 _LOGD("Package UiApp permission Info DB Insert Failed\n");
1401                                 return -1;
1402                         }
1403                         memset(query, '\0', MAX_QUERY_LEN);
1404                 }
1405         }
1406         return 0;
1407 }
1408
1409 static int __insert_application_appcontrol_info(manifest_x *mfx)
1410 {
1411         GList *app_tmp;
1412         application_x *app;
1413         GList *acontrol_tmp;
1414         appcontrol_x *acontrol;
1415         int ret = -1;
1416         char query[MAX_QUERY_LEN] = {'\0'};
1417         char buf[BUFSIZE] = {'\0'};
1418         for (app_tmp = mfx->application; app_tmp; app_tmp = app_tmp->next) {
1419                 app = (application_x *)app_tmp->data;
1420                 if (app == NULL)
1421                         continue;
1422                 for (acontrol_tmp = app->appcontrol; acontrol_tmp; acontrol_tmp = acontrol_tmp->next) {
1423                         acontrol = (appcontrol_x *)acontrol_tmp->data;
1424                         if (acontrol == NULL)
1425                                 continue;
1426                         snprintf(buf, BUFSIZE, "%s|%s|%s",\
1427                                         acontrol->operation ? (strlen(acontrol->operation) > 0 ? acontrol->operation : "NULL") : "NULL",
1428                                         acontrol->uri ? (strlen(acontrol->uri) > 0 ? acontrol->uri : "NULL") : "NULL",
1429                                         acontrol->mime ? (strlen(acontrol->mime) > 0 ? acontrol->mime : "NULL") : "NULL");
1430                         sqlite3_snprintf(MAX_QUERY_LEN, query,
1431                                         "INSERT INTO package_app_app_control(app_id, app_control) " \
1432                                         "VALUES(%Q, %Q)",\
1433                                         app->appid, buf);
1434                         ret = __exec_query(query);
1435                         if (ret == -1) {
1436                                 _LOGD("Package UiApp AppSvc DB Insert Failed\n");
1437                                 return -1;
1438                         }
1439                         memset(query, '\0', MAX_QUERY_LEN);
1440                 }
1441         }
1442         return 0;
1443 }
1444
1445 static int __insert_application_datacontrol_info(manifest_x *mfx)
1446 {
1447         GList *app_tmp;
1448         application_x *app;
1449         GList *dc_tmp;
1450         datacontrol_x *dc;
1451         int ret = -1;
1452         char query[MAX_QUERY_LEN] = {'\0'};
1453
1454         for (app_tmp = mfx->application; app_tmp; app_tmp = app_tmp->next) {
1455                 app = (application_x *)app_tmp->data;
1456                 if (app == NULL)
1457                         continue;
1458                 for (dc_tmp = app->datacontrol; dc_tmp; dc_tmp = dc_tmp->next) {
1459                         dc = (datacontrol_x *)dc_tmp->data;
1460                         if (dc == NULL)
1461                                 continue;
1462                         sqlite3_snprintf(MAX_QUERY_LEN, query,
1463                                         "INSERT INTO package_app_data_control(app_id, providerid, access, type, trusted) " \
1464                                         "VALUES(%Q, %Q, %Q, %Q, %Q)",\
1465                                         app->appid,
1466                                         dc->providerid,
1467                                         dc->access,
1468                                         dc->type,
1469                                         __get_bool(dc->trusted, false));
1470
1471                         ret = __exec_query(query);
1472                         if (ret == -1) {
1473                                 _LOGD("Package UiApp Data Control DB Insert Failed\n");
1474                                 return -1;
1475                         }
1476                         memset(query, '\0', MAX_QUERY_LEN);
1477                 }
1478         }
1479         return 0;
1480 }
1481
1482 static int __insert_application_share_request_info(manifest_x *mfx)
1483 {
1484         GList *app_tmp;
1485         application_x *app;
1486         GList *ds_tmp;
1487         datashare_x *ds;
1488         GList *rq_tmp;
1489         const char *rq;
1490         int ret = -1;
1491         char query[MAX_QUERY_LEN] = {'\0'};
1492         for (app_tmp = mfx->application; app_tmp; app_tmp = app_tmp->next) {
1493                 app = (application_x *)app_tmp->data;
1494                 if (app == NULL)
1495                         continue;
1496                 for (ds_tmp = app->datashare; ds_tmp; ds_tmp = ds_tmp->next) {
1497                         ds = (datashare_x *)ds_tmp->data;
1498                         if (ds == NULL)
1499                                 continue;
1500                         for (rq_tmp = ds->request; rq_tmp; rq_tmp = rq_tmp->next) {
1501                                 rq = (const char *)rq_tmp->data;
1502                                 if (rq == NULL)
1503                                         continue;
1504                                 sqlite3_snprintf(MAX_QUERY_LEN, query,
1505                                                 "INSERT INTO package_app_share_request(app_id, data_share_request) " \
1506                                                 "VALUEES(%Q, %Q)",\
1507                                          app->appid, rq);
1508                                 ret = __exec_query(query);
1509                                 if (ret == -1) {
1510                                         _LOGD("Package UiApp Share Request DB Insert Failed\n");
1511                                         return -1;
1512                                 }
1513                                 memset(query, '\0', MAX_QUERY_LEN);
1514                         }
1515                 }
1516         }
1517         return 0;
1518 }
1519
1520 static int __insert_application_share_allowed_info(manifest_x *mfx)
1521 {
1522         GList *app_tmp;
1523         application_x *app;
1524         GList *ds_tmp;
1525         datashare_x *ds;
1526         GList *df_tmp;
1527         define_x *df;
1528         GList *al_tmp;
1529         const char *al;
1530         int ret = -1;
1531         char query[MAX_QUERY_LEN] = {'\0'};
1532         for (app_tmp = mfx->application; app_tmp; app_tmp = app_tmp->next) {
1533                 app = (application_x *)app_tmp->data;
1534                 if (app == NULL)
1535                         continue;
1536                 for (ds_tmp = app->datashare; ds_tmp; ds_tmp = ds_tmp->next) {
1537                         ds = (datashare_x *)ds_tmp->data;
1538                         if (ds == NULL)
1539                                 continue;
1540                         for (df_tmp = ds->define; df_tmp; df_tmp = df_tmp->next) {
1541                                 df = (define_x *)df_tmp->data;
1542                                 if (df == NULL)
1543                                         continue;
1544                                 for (al_tmp = df->allowed; al_tmp; al_tmp = al_tmp->next) {
1545                                         al = (const char *)al_tmp->data;
1546                                         if (al == NULL)
1547                                                 continue;
1548                                         sqlite3_snprintf(MAX_QUERY_LEN, query,
1549                                                         "INSERT INTO package_app_share_allowed(app_id, data_share_path, data_share_allowed) " \
1550                                                         "VALUES(%Q, %Q, %Q)",\
1551                                                  app->appid, df->path, al);
1552                                         ret = __exec_query(query);
1553                                         if (ret == -1) {
1554                                                 _LOGD("Package UiApp Share Allowed DB Insert Failed\n");
1555                                                 return -1;
1556                                         }
1557                                         memset(query, '\0', MAX_QUERY_LEN);
1558                                 }
1559                         }
1560                 }
1561         }
1562         return 0;
1563 }
1564
1565 static gint __compare_splashscreen_with_orientation_dpi(gconstpointer a, gconstpointer b)
1566 {
1567         splashscreen_x *ss = (splashscreen_x *)a;
1568         const char *orientation = (const char *)b;
1569         int dpi = -1;
1570
1571         if (ss->operation || ss->dpi == NULL)
1572                 return -1;
1573
1574         system_info_get_platform_int("http://tizen.org/feature/screen.dpi", &dpi);
1575         if (!dpi)
1576                 return -1;
1577
1578         if (strcasecmp(ss->orientation, orientation) == 0 && __check_dpi(ss->dpi, dpi) == 0)
1579                 return 0;
1580
1581         return -1;
1582 }
1583
1584 static gint __compare_splashscreen_with_orientation(gconstpointer a, gconstpointer b)
1585 {
1586         splashscreen_x *ss = (splashscreen_x *)a;
1587         const char *orientation = (const char *)b;
1588
1589         if (ss->operation || ss->dpi)
1590                 return -1;
1591
1592         if (strcasecmp(ss->orientation, orientation) == 0)
1593                 return 0;
1594
1595         return -1;
1596 }
1597
1598 static splashscreen_x *__find_default_splashscreen(GList *splashscreens,
1599                                         const char *orientation)
1600 {
1601         GList *tmp;
1602
1603         tmp = g_list_find_custom(splashscreens, orientation,
1604                         (GCompareFunc)__compare_splashscreen_with_orientation_dpi);
1605         if (tmp)
1606                 return (splashscreen_x *)tmp->data;
1607
1608         tmp = g_list_find_custom(splashscreens, orientation,
1609                         (GCompareFunc)__compare_splashscreen_with_orientation);
1610         if (tmp)
1611                 return (splashscreen_x *)tmp->data;
1612
1613         return NULL;
1614 }
1615
1616 static void __find_appcontrol_splashscreen_with_dpi(gpointer data, gpointer user_data)
1617 {
1618         splashscreen_x *ss = (splashscreen_x *)data;
1619         GList **list = (GList **)user_data;
1620         int dpi = -1;
1621
1622         if (ss->operation == NULL || ss->dpi == NULL)
1623                 return;
1624
1625         system_info_get_platform_int("http://tizen.org/feature/screen.dpi", &dpi);
1626         if (!dpi)
1627                 return;
1628
1629         if (__check_dpi(ss->dpi, dpi) != 0)
1630                 return;
1631
1632         *list = g_list_append(*list, ss);
1633 }
1634
1635 static void __find_appcontrol_splashscreen(gpointer data, gpointer user_data)
1636 {
1637         splashscreen_x *ss = (splashscreen_x *)data;
1638         GList **list = (GList **)user_data;
1639         splashscreen_x *ss_tmp;
1640         GList *tmp;
1641
1642         if (ss->operation == NULL || ss->dpi)
1643                 return;
1644
1645         for (tmp = *list; tmp; tmp = tmp->next) {
1646                 ss_tmp = (splashscreen_x *)tmp->data;
1647                 if (ss_tmp->operation
1648                         && strcmp(ss_tmp->operation, ss->operation) == 0
1649                         && strcmp(ss_tmp->orientation, ss->orientation) == 0)
1650                         return;
1651         }
1652
1653         *list = g_list_append(*list, ss);
1654 }
1655
1656 static GList *__find_splashscreens(GList *splashscreens)
1657 {
1658         GList *list = NULL;
1659         splashscreen_x *ss;
1660
1661         g_list_foreach(splashscreens,
1662                         __find_appcontrol_splashscreen_with_dpi, &list);
1663         g_list_foreach(splashscreens,
1664                         __find_appcontrol_splashscreen, &list);
1665
1666         ss = __find_default_splashscreen(splashscreens, "portrait");
1667         if (ss)
1668                 list = g_list_append(list, ss);
1669         ss = __find_default_splashscreen(splashscreens, "landscape");
1670         if (ss)
1671                 list = g_list_append(list, ss);
1672
1673         return list;
1674 }
1675
1676 static int __insert_application_splashscreen_info(manifest_x *mfx)
1677 {
1678         GList *app_tmp;
1679         application_x *app;
1680         GList *ss_tmp;
1681         splashscreen_x *ss;
1682         GList *tmp;
1683         int ret = -1;
1684         char query[MAX_QUERY_LEN] = {'\0'};
1685
1686         for (app_tmp = mfx->application; app_tmp; app_tmp = app_tmp->next) {
1687                 app = (application_x *)app_tmp->data;
1688                 if (app == NULL || app->splashscreens == NULL)
1689                         continue;
1690
1691                 ss_tmp = __find_splashscreens(app->splashscreens);
1692                 if (ss_tmp == NULL)
1693                         continue;
1694
1695                 for (tmp = ss_tmp; tmp; tmp = tmp->next) {
1696                         ss = (splashscreen_x *)tmp->data;
1697                         sqlite3_snprintf(MAX_QUERY_LEN, query,
1698                                         "INSERT INTO package_app_splash_screen" \
1699                                         "(app_id, src, type, orientation, indicatordisplay, " \
1700                                         "operation, color_depth) " \
1701                                         "VALUES(%Q, %Q, %Q, %Q, %Q, %Q, %Q)",
1702                                         app->appid, ss->src, ss->type, ss->orientation,
1703                                         ss->indicatordisplay, ss->operation,
1704                                         ss->color_depth);
1705
1706                         ret = __exec_query(query);
1707                         if (ret == -1) {
1708                                 _LOGD("Package UiApp Splash Screen DB Insert Failed");
1709                                 return -1;
1710                         }
1711                         memset(query, '\0', MAX_QUERY_LEN);
1712                 }
1713                 g_list_free(ss_tmp);
1714         }
1715         return 0;
1716 }
1717
1718 static int __insert_manifest_info_in_db(manifest_x *mfx, uid_t uid)
1719 {
1720         GList *tmp;
1721         application_x *app;
1722         privilege_x *pv = NULL;
1723         char query[MAX_QUERY_LEN] = { '\0' };
1724         int ret = -1;
1725         author_x *author;
1726         const char *auth_name = NULL;
1727         const char *auth_email = NULL;
1728         const char *auth_href = NULL;
1729
1730         GList *pkglocale = NULL;
1731         GList *applocale = NULL;
1732         GList *appicon = NULL;
1733         GList *appimage = NULL;
1734
1735         int temp_pkg_mode = 0;
1736         int temp_app_mode = 0;
1737         char pkg_mode[MAX_INTEGER_LENGTH] = {'\0'};
1738         application_x *up_support_mode = NULL;
1739         GList *list_up = NULL;
1740
1741         if (mfx->author && mfx->author->data) {
1742                 author = (author_x *)mfx->author->data;
1743                 if (author->text)
1744                         auth_name = author->text;
1745                 if (author->email)
1746                         auth_email = author->email;
1747                 if (author->href)
1748                         auth_href = author->href;
1749         }
1750
1751         if (mfx->support_mode)
1752                 temp_pkg_mode = atoi(mfx->support_mode);
1753
1754         /* FIXME : OR-ing should be fixed to not to store whole support mode */
1755         list_up = mfx->application;
1756         while (list_up != NULL) {
1757                 up_support_mode = (application_x *)list_up->data;
1758                 if (up_support_mode->support_mode) {
1759                         temp_app_mode = atoi(up_support_mode->support_mode);
1760                         temp_pkg_mode |= temp_app_mode;
1761                 }
1762                 list_up = list_up->next;
1763         }
1764         snprintf(pkg_mode, MAX_INTEGER_LENGTH, "%d", temp_pkg_mode);
1765
1766         if (mfx->support_mode)
1767                 free((void *)mfx->support_mode);
1768         mfx->support_mode = strdup(pkg_mode);
1769
1770         /*Insert in the package_info DB*/
1771         sqlite3_snprintf(MAX_QUERY_LEN, query,
1772                 "INSERT INTO package_info(" \
1773                 "package, package_type, package_version, package_api_version, package_tep_name, package_zip_mount_file, " \
1774                 "install_location, package_size, package_removable, package_preload, package_readonly, " \
1775                 "package_update, package_appsetting, package_nodisplay, package_system, author_name, " \
1776                 "author_email, author_href, installed_time, installed_storage, storeclient_id, " \
1777                 "mainapp_id, package_url, root_path, csc_path, package_support_mode, package_support_disable) " \
1778                 "VALUES(" \
1779                 "%Q, %Q, %Q, %Q, %Q, %Q, " \
1780                 "%Q, %Q, LOWER(%Q), LOWER(%Q), LOWER(%Q), " \
1781                 "LOWER(%Q), LOWER(%Q), LOWER(%Q), LOWER(%Q), %Q, " \
1782                 "%Q, %Q, %Q, %Q, %Q, " \
1783                 "%Q, %Q, %Q, %Q, %Q, LOWER(%Q))",
1784                 mfx->package, mfx->type, mfx->version, mfx->api_version, mfx->tep_name, mfx->zip_mount_file,
1785                 mfx->installlocation, mfx->package_size, __get_bool(mfx->removable, true), __get_bool(mfx->preload, false), __get_bool(mfx->readonly, false),
1786                 __get_bool(mfx->update, false), __get_bool(mfx->appsetting, false), __get_bool(mfx->nodisplay_setting, false), __get_bool(mfx->system, false), auth_name,
1787                 auth_email, auth_href, mfx->installed_time, mfx->installed_storage,
1788                 mfx->storeclient_id,
1789                 mfx->mainapp_id, mfx->package_url, mfx->root_path, mfx->csc_path, mfx->support_mode, __get_bool(mfx->support_disable, false));
1790
1791         ret = __exec_query(query);
1792         if (ret == -1) {
1793                 _LOGD("Package Info DB Insert Failed\n");
1794                 return -1;
1795         }
1796
1797         ret = __insert_pkg_updateinfo_in_db(mfx, uid);
1798         if (ret == -1) {
1799                 _LOGE("Package Update Info DB Insert Failed\n");
1800                 return -1;
1801         }
1802
1803         /*Insert in the package_privilege_info DB*/
1804         for (tmp = mfx->privileges; tmp; tmp = tmp->next) {
1805                 pv = (privilege_x *)tmp->data;
1806                 if (pv == NULL)
1807                         continue;
1808                 memset(query, '\0', MAX_QUERY_LEN);
1809                 sqlite3_snprintf(MAX_QUERY_LEN, query,
1810                         "INSERT INTO package_privilege_info(package, privilege, type) " \
1811                         "VALUES(%Q, %Q, %Q)",\
1812                          mfx->package, pv->value, pv->type);
1813                 ret = __exec_query(query);
1814                 if (ret == -1) {
1815                         _LOGD("Package Privilege Info DB Insert Failed\n");
1816                         return -1;
1817                 }
1818         }
1819
1820         if (mfx->application != NULL) {
1821                 ret = __insert_mainapp_info(mfx);
1822                 if (ret == -1)
1823                         return -1;
1824         }
1825
1826         /*Insert the package locale*/
1827         pkglocale = __create_locale_list(pkglocale, mfx->label, mfx->license, mfx->icon, mfx->description, mfx->author);
1828         /*remove duplicated data in pkglocale*/
1829         __trimfunc(pkglocale);
1830
1831         /*Insert the app locale, icon, image info */
1832         for (tmp = mfx->application; tmp; tmp = tmp->next) {
1833                 app = (application_x *)tmp->data;
1834                 if (app == NULL)
1835                         continue;
1836                 applocale = __create_locale_list(applocale, app->label, NULL, app->icon, NULL, NULL);
1837                 appicon = __create_icon_list(appicon, app->icon);
1838                 appimage = __create_image_list(appimage, app->image);
1839         }
1840         /*remove duplicated data in applocale*/
1841         __trimfunc(applocale);
1842         __trimfunc(appicon);
1843         __trimfunc(appimage);
1844
1845         g_list_foreach(pkglocale, __insert_pkglocale_info, (gpointer)mfx);
1846
1847         /*native app locale info*/
1848         for (tmp = mfx->application; tmp; tmp = tmp->next) {
1849                 app = (application_x *)tmp->data;
1850                 if (app == NULL)
1851                         continue;
1852                 g_list_foreach(applocale, __insert_application_locale_info, (gpointer)app);
1853                 g_list_foreach(appicon, __insert_application_icon_section_info, (gpointer)app);
1854                 g_list_foreach(appimage, __insert_application_image_info, (gpointer)app);
1855         }
1856
1857         g_list_free(pkglocale);
1858         pkglocale = NULL;
1859         g_list_free(applocale);
1860         applocale = NULL;
1861         g_list_free(appicon);
1862         appicon = NULL;
1863         g_list_free(appimage);
1864         appimage = NULL;
1865
1866         /*Insert in the package_app_info DB*/
1867         ret = __insert_application_info(mfx);
1868         if (ret == -1)
1869                 return -1;
1870         /*Insert in the package_app_app_control DB*/
1871         ret = __insert_application_appcontrol_info(mfx);
1872         if (ret == -1)
1873                 return -1;
1874
1875         /*Insert in the package_app_app_category DB*/
1876         ret = __insert_application_appcategory_info(mfx);
1877         if (ret == -1)
1878                 return -1;
1879
1880         /*Insert in the package_app_app_metadata DB*/
1881         ret = __insert_application_appmetadata_info(mfx);
1882         if (ret == -1)
1883                 return -1;
1884
1885         /*Insert in the package_app_app_permission DB*/
1886         ret = __insert_application_apppermission_info(mfx);
1887         if (ret == -1)
1888                 return -1;
1889
1890         /*Insert in the package_app_share_allowed DB*/
1891         ret = __insert_application_share_allowed_info(mfx);
1892         if (ret == -1)
1893                 return -1;
1894
1895         /*Insert in the package_app_share_request DB*/
1896         ret = __insert_application_share_request_info(mfx);
1897         if (ret == -1)
1898                 return -1;
1899
1900         /*Insert in the package_app_data_control DB*/
1901         ret = __insert_application_datacontrol_info(mfx);
1902         if (ret == -1)
1903                 return -1;
1904
1905         /*Insert in the package_app_splash_screen DB*/
1906         ret = __insert_application_splashscreen_info(mfx);
1907         if (ret == -1)
1908                 return -1;
1909
1910         return 0;
1911
1912 }
1913
1914 static int __delete_appinfo_from_db(char *db_table, const char *appid)
1915 {
1916         char query[MAX_QUERY_LEN] = { '\0' };
1917         int ret = -1;
1918
1919         sqlite3_snprintf(MAX_QUERY_LEN, query,
1920                  "DELETE FROM %q where app_id=%Q", db_table, appid);
1921         ret = __exec_query(query);
1922         if (ret == -1) {
1923                 _LOGD("DB Deletion from table (%s) Failed\n", db_table);
1924                 return -1;
1925         }
1926         return 0;
1927 }
1928
1929 static int __delete_subpkg_info_from_db(char *appid)
1930 {
1931         int ret = -1;
1932
1933         ret = __delete_appinfo_from_db("package_app_info", appid);
1934         if (ret < 0)
1935                 return ret;
1936         ret = __delete_appinfo_from_db("package_app_localized_info", appid);
1937         if (ret < 0)
1938                 return ret;
1939         ret = __delete_appinfo_from_db("package_app_icon_section_info", appid);
1940         if (ret < 0)
1941                 return ret;
1942         ret = __delete_appinfo_from_db("package_app_image_info", appid);
1943         if (ret < 0)
1944                 return ret;
1945         ret = __delete_appinfo_from_db("package_app_app_control", appid);
1946         if (ret < 0)
1947                 return ret;
1948         ret = __delete_appinfo_from_db("package_app_app_category", appid);
1949         if (ret < 0)
1950                 return ret;
1951         ret = __delete_appinfo_from_db("package_app_app_metadata", appid);
1952         if (ret < 0)
1953                 return ret;
1954         ret = __delete_appinfo_from_db("package_app_app_permission", appid);
1955         if (ret < 0)
1956                 return ret;
1957         ret = __delete_appinfo_from_db("package_app_share_allowed", appid);
1958         if (ret < 0)
1959                 return ret;
1960         ret = __delete_appinfo_from_db("package_app_share_request", appid);
1961         if (ret < 0)
1962                 return ret;
1963         ret = __delete_appinfo_from_db("package_app_data_control", appid);
1964         if (ret < 0)
1965                 return ret;
1966         ret = __delete_appinfo_from_db("package_app_splash_screen", appid);
1967         if (ret < 0)
1968                 return ret;
1969
1970         return 0;
1971 }
1972
1973 static int __delete_subpkg_from_db(manifest_x *mfx)
1974 {
1975         char query[MAX_QUERY_LEN] = { '\0' };
1976         char *error_message = NULL;
1977
1978         sqlite3_snprintf(MAX_QUERY_LEN, query, "SELECT app_id FROM package_app_info WHERE package=%Q", mfx->package);
1979         if (SQLITE_OK !=
1980             sqlite3_exec(pkgmgr_parser_db, query, __delete_subpkg_list_cb, NULL, &error_message)) {
1981                 _LOGE("Don't execute query = %s error message = %s\n", query,
1982                        error_message);
1983                 sqlite3_free(error_message);
1984                 return -1;
1985         }
1986         sqlite3_free(error_message);
1987
1988         return 0;
1989 }
1990
1991 static int __delete_manifest_info_from_db(manifest_x *mfx, uid_t uid)
1992 {
1993         char query[MAX_QUERY_LEN] = { '\0' };
1994         int ret = -1;
1995         GList *tmp;
1996         application_x *app;
1997
1998         /*Delete from Package Info DB*/
1999         sqlite3_snprintf(MAX_QUERY_LEN, query,
2000                  "DELETE FROM package_info WHERE package=%Q", mfx->package);
2001         ret = __exec_query(query);
2002         if (ret == -1) {
2003                 _LOGD("Package Info DB Delete Failed\n");
2004                 return -1;
2005         }
2006         memset(query, '\0', MAX_QUERY_LEN);
2007
2008         /*Delete from Package Update Info DB*/
2009         sqlite3_snprintf(MAX_QUERY_LEN, query,
2010                  "DELETE FROM package_update_info WHERE package=%Q", mfx->package);
2011         ret = __exec_query(query);
2012         if (ret == -1) {
2013                 _LOGD("Package Update Info DB Delete Failed\n");
2014                 return -1;
2015         }
2016         memset(query, '\0', MAX_QUERY_LEN);
2017
2018         /*Delete from Package Localized Info*/
2019         sqlite3_snprintf(MAX_QUERY_LEN, query,
2020                  "DELETE FROM package_localized_info WHERE package=%Q", mfx->package);
2021         ret = __exec_query(query);
2022         if (ret == -1) {
2023                 _LOGD("Package Localized Info DB Delete Failed\n");
2024                 return -1;
2025         }
2026
2027         /*Delete from Package Privilege Info*/
2028         sqlite3_snprintf(MAX_QUERY_LEN, query,
2029                  "DELETE FROM package_privilege_info WHERE package=%Q", mfx->package);
2030         ret = __exec_query(query);
2031         if (ret == -1) {
2032                 _LOGD("Package Privilege Info DB Delete Failed\n");
2033                 return -1;
2034         }
2035
2036         for (tmp = mfx->application; tmp; tmp = tmp->next) {
2037                 app = (application_x *)tmp->data;
2038                 if (app == NULL)
2039                         continue;
2040                 ret = __delete_appinfo_from_db("package_app_info", app->appid);
2041                 if (ret < 0)
2042                         return ret;
2043                 ret = __delete_appinfo_from_db("package_app_localized_info", app->appid);
2044                 if (ret < 0)
2045                         return ret;
2046                 ret = __delete_appinfo_from_db("package_app_icon_section_info", app->appid);
2047                 if (ret < 0)
2048                         return ret;
2049                 ret = __delete_appinfo_from_db("package_app_image_info", app->appid);
2050                 if (ret < 0)
2051                         return ret;
2052                 ret = __delete_appinfo_from_db("package_app_app_control", app->appid);
2053                 if (ret < 0)
2054                         return ret;
2055                 ret = __delete_appinfo_from_db("package_app_app_category", app->appid);
2056                 if (ret < 0)
2057                         return ret;
2058                 ret = __delete_appinfo_from_db("package_app_app_metadata", app->appid);
2059                 if (ret < 0)
2060                         return ret;
2061                 ret = __delete_appinfo_from_db("package_app_app_permission", app->appid);
2062                 if (ret < 0)
2063                         return ret;
2064                 ret = __delete_appinfo_from_db("package_app_share_allowed", app->appid);
2065                 if (ret < 0)
2066                         return ret;
2067                 ret = __delete_appinfo_from_db("package_app_share_request", app->appid);
2068                 if (ret < 0)
2069                         return ret;
2070                 ret = __delete_appinfo_from_db("package_app_data_control", app->appid);
2071                 if (ret < 0)
2072                         return ret;
2073                 ret = __delete_appinfo_from_db("package_app_splash_screen", app->appid);
2074                 if (ret < 0)
2075                         return ret;
2076         }
2077
2078         /* if main package has sub pkg, delete sub pkg data*/
2079         __delete_subpkg_from_db(mfx);
2080
2081         return 0;
2082 }
2083
2084 static int __disable_app(const char *appid)
2085 {
2086         int ret = -1;
2087         char query[MAX_QUERY_LEN] = {'\0'};
2088         sqlite3_snprintf(MAX_QUERY_LEN, query,
2089                         "UPDATE package_app_info SET app_disable='true' WHERE app_id=%Q",
2090                         appid);
2091         ret = __exec_query(query);
2092         if (ret == -1)
2093                 _LOGD("Insert global app disable failed\n");
2094
2095         return ret;
2096 }
2097
2098 static int __enable_app(const char *appid)
2099 {
2100         int ret = -1;
2101         char query[MAX_QUERY_LEN] = {'\0'};
2102         sqlite3_snprintf(MAX_QUERY_LEN, query,
2103                         "UPDATE package_app_info SET app_disable='false' WHERE app_id=%Q",
2104                         appid);
2105         ret = __exec_query(query);
2106         if (ret == -1)
2107                 _LOGD("Insert global app disable failed\n");
2108
2109         return ret;
2110 }
2111
2112 static int __disable_pkg(const char *pkgid)
2113 {
2114         int ret = -1;
2115         char query[MAX_QUERY_LEN] = {'\0'};
2116         sqlite3_snprintf(MAX_QUERY_LEN, query,
2117                         "UPDATE package_info SET package_disable='true' WHERE package=%Q",
2118                         pkgid);
2119         ret = __exec_query(query);
2120         if (ret == -1)
2121                 _LOGD("Update pkg disable info has failed\n");
2122
2123         return ret;
2124 }
2125
2126 static int __enable_pkg(const char *pkgid)
2127 {
2128         int ret = -1;
2129         char query[MAX_QUERY_LEN] = {'\0'};
2130         sqlite3_snprintf(MAX_QUERY_LEN, query,
2131                         "UPDATE package_info SET package_disable='false' WHERE package=%Q",
2132                         pkgid);
2133         ret = __exec_query(query);
2134         if (ret == -1)
2135                 _LOGD("Update pkg disable info has failed\n");
2136
2137         return ret;
2138 }
2139
2140 static int __check_appinfo_for_uid_table(const char *appid, uid_t uid)
2141 {
2142         int ret = -1;
2143         char query[MAX_QUERY_LEN] = { '\0', };
2144         sqlite3_stmt *stmt;
2145         const char *val = NULL;
2146
2147         if (appid == NULL)
2148                 return -1;
2149
2150         sqlite3_snprintf(MAX_QUERY_LEN, query,
2151                         "SELECT COUNT(*) FROM "
2152                         "package_app_info_for_uid WHERE app_id=%Q "
2153                         "AND uid=%d", appid, (int)uid);
2154
2155         ret = sqlite3_prepare_v2(pkgmgr_parser_db, query, strlen(query), &stmt, NULL);
2156         if (ret != SQLITE_OK) {
2157                 LOGE("prepare failed: %s", sqlite3_errmsg(pkgmgr_parser_db));
2158                 return PMINFO_R_ERROR;
2159         }
2160
2161         if (sqlite3_step(stmt) != SQLITE_ROW) {
2162                 LOGE("failed to step");
2163                 sqlite3_finalize(stmt);
2164                 return PMINFO_R_ERROR;
2165         }
2166
2167         val = (const char *)sqlite3_column_text(stmt, 0);
2168         ret = atoi(val);
2169         sqlite3_finalize(stmt);
2170
2171         return ret;
2172 }
2173
2174 static int __disable_global_app_for_user(const char *appid, uid_t uid)
2175 {
2176         int ret = -1;
2177         char query[MAX_QUERY_LEN] = { '\0', };
2178
2179         ret = __check_appinfo_for_uid_table(appid, uid);
2180         if (ret < 0) {
2181                 _LOGE("Failed to check package_app_info_for_uid with appid[%s], uid[%d]",
2182                                 appid, (int)uid);
2183                 return -1;
2184         } else if (ret == 0) {
2185                 sqlite3_snprintf(MAX_QUERY_LEN, query, "INSERT INTO "
2186                                 "package_app_info_for_uid(app_id, uid, is_disabled, is_splash_screen_enabled) "
2187                                 "VALUES(%Q, %d, 'true', "
2188                                 "(SELECT app_splash_screen_display FROM package_app_info WHERE app_id=%Q))",
2189                                 appid, (int)uid, appid);
2190         } else {
2191                 sqlite3_snprintf(MAX_QUERY_LEN, query, "UPDATE "
2192                                 "package_app_info_for_uid SET is_disabled='true' "
2193                                 "WHERE app_id=%Q AND uid=%d", appid, (int)uid);
2194         }
2195
2196         ret = __exec_query(query);
2197         if (ret == -1)
2198                 _LOGD("Add global app disable info failed\n");
2199
2200         return ret;
2201 }
2202
2203 static int __enable_global_app_for_user(const char *appid, uid_t uid)
2204 {
2205         int ret = -1;
2206         char query[MAX_QUERY_LEN] = {'\0'};
2207
2208         ret = __check_appinfo_for_uid_table(appid, uid);
2209         if (ret < 0) {
2210                 _LOGE("Failed to check package_app_info_for_uid with appid[%s], uid[%d]",
2211                                 appid, (int)uid);
2212                 return -1;
2213         } else if (ret > 0) {
2214                 sqlite3_snprintf(MAX_QUERY_LEN, query,
2215                                 "UPDATE package_app_info_for_uid SET "
2216                                 "is_disabled='false' WHERE app_id=%Q AND "
2217                                 "uid=%d", appid, (int)uid);
2218         }
2219
2220         ret = __exec_query(query);
2221         if (ret == -1)
2222                 _LOGD("Remove global app disable info failed\n");
2223
2224         return ret;
2225 }
2226
2227 static int __update_global_app_splash_screen_for_user(const char *appid,
2228                 uid_t uid, int flag)
2229 {
2230         int ret = -1;
2231         char query[MAX_QUERY_LEN] = { '\0', };
2232
2233         ret = __check_appinfo_for_uid_table(appid, uid);
2234         if (ret < 0) {
2235                 _LOGE("Failed to check package_app_info_for_uid with appid[%s], uid[%d]",
2236                                 appid, (int)uid);
2237                 return -1;
2238         } else if (ret == 0) {
2239                 sqlite3_snprintf(MAX_QUERY_LEN, query, "INSERT INTO "
2240                                 "package_app_info_for_uid(app_id, uid, is_splash_screen_enabled) "
2241                                 "VALUES(%Q, %d, %Q)", appid, (int)uid,
2242                                 flag ? "true" : "false");
2243         } else {
2244                 sqlite3_snprintf(MAX_QUERY_LEN, query,
2245                                 "UPDATE package_app_info_for_uid SET "
2246                                 "is_splash_screen_enabled=%Q WHERE app_id=%Q AND "
2247                                 "uid=%d", flag ? "true" : "false", appid, (int)uid);
2248         }
2249
2250         ret = __exec_query(query);
2251         if (ret == -1)
2252                 _LOGD("update global app splash screen info failed\n");
2253
2254         return ret;
2255 }
2256
2257 static int __disable_app_splash_screen(const char *appid)
2258 {
2259         int ret;
2260         char query[MAX_QUERY_LEN] = {'\0'};
2261
2262         sqlite3_snprintf(MAX_QUERY_LEN, query,
2263                         "UPDATE package_app_info SET app_splash_screen_display='false' WHERE app_id=%Q",
2264                         appid);
2265         ret = __exec_query(query);
2266         if (ret == -1)
2267                 _LOGD("Failed to update app_palsh_screen_display");
2268
2269         return ret;
2270 }
2271
2272 static int __enable_app_splash_screen(const char *appid)
2273 {
2274         int ret;
2275         char query[MAX_QUERY_LEN] = {'\0'};
2276
2277         sqlite3_snprintf(MAX_QUERY_LEN, query,
2278                         "UPDATE package_app_info SET app_splash_screen_display='true' WHERE app_id=%Q",
2279                         appid);
2280         ret = __exec_query(query);
2281         if (ret == -1)
2282                 _LOGD("Failed to update app_splash_screen_display");
2283
2284         return ret;
2285 }
2286
2287 API int pkgmgr_parser_initialize_db(uid_t uid)
2288 {
2289         int ret = -1;
2290         char *db_path;
2291
2292         /*Manifest DB*/
2293         ret = __initialize_db(pkgmgr_parser_db, QUERY_CREATE_TABLE_PACKAGE_INFO);
2294         if (ret == -1) {
2295                 _LOGD("package info DB initialization failed\n");
2296                 return ret;
2297         }
2298         ret = __initialize_db(pkgmgr_parser_db, QUERY_CREATE_TABLE_PACKAGE_LOCALIZED_INFO);
2299         if (ret == -1) {
2300                 _LOGD("package localized info DB initialization failed\n");
2301                 return ret;
2302         }
2303         ret = __initialize_db(pkgmgr_parser_db, QUERY_CREATE_TABLE_PACKAGE_PRIVILEGE_INFO);
2304         if (ret == -1) {
2305                 _LOGD("package app app privilege DB initialization failed\n");
2306                 return ret;
2307         }
2308         ret = __initialize_db(pkgmgr_parser_db, QUERY_CREATE_TABLE_PACKAGE_UPDATE_INFO);
2309         if (ret == -1) {
2310                 _LOGD("package update info DB initialization failed\n");
2311                 return ret;
2312         }
2313         ret = __initialize_db(pkgmgr_parser_db, QUERY_CREATE_TABLE_PACKAGE_APP_INFO);
2314         if (ret == -1) {
2315                 _LOGD("package app info DB initialization failed\n");
2316                 return ret;
2317         }
2318         ret = __initialize_db(pkgmgr_parser_db, QUERY_CREATE_TABLE_PACKAGE_APP_LOCALIZED_INFO);
2319         if (ret == -1) {
2320                 _LOGD("package app localized info DB initialization failed\n");
2321                 return ret;
2322         }
2323         ret = __initialize_db(pkgmgr_parser_db, QUERY_CREATE_TABLE_PACKAGE_APP_ICON_SECTION_INFO);
2324         if (ret == -1) {
2325                 _LOGD("package app icon localized info DB initialization failed\n");
2326                 return ret;
2327         }
2328         ret = __initialize_db(pkgmgr_parser_db, QUERY_CREATE_TABLE_PACKAGE_APP_IMAGE_INFO);
2329         if (ret == -1) {
2330                 _LOGD("package app image info DB initialization failed\n");
2331                 return ret;
2332         }
2333         ret = __initialize_db(pkgmgr_parser_db, QUERY_CREATE_TABLE_PACKAGE_APP_APP_CONTROL);
2334         if (ret == -1) {
2335                 _LOGD("package app app control DB initialization failed\n");
2336                 return ret;
2337         }
2338         ret = __initialize_db(pkgmgr_parser_db, QUERY_CREATE_TABLE_PACKAGE_APP_APP_CATEGORY);
2339         if (ret == -1) {
2340                 _LOGD("package app app category DB initialization failed\n");
2341                 return ret;
2342         }
2343         ret = __initialize_db(pkgmgr_parser_db, QUERY_CREATE_TABLE_PACKAGE_APP_APP_METADATA);
2344         if (ret == -1) {
2345                 _LOGD("package app app category DB initialization failed\n");
2346                 return ret;
2347         }
2348         ret = __initialize_db(pkgmgr_parser_db, QUERY_CREATE_TABLE_PACKAGE_APP_APP_PERMISSION);
2349         if (ret == -1) {
2350                 _LOGD("package app app permission DB initialization failed\n");
2351                 return ret;
2352         }
2353         ret = __initialize_db(pkgmgr_parser_db, QUERY_CREATE_TABLE_PACKAGE_APP_SHARE_ALLOWED);
2354         if (ret == -1) {
2355                 _LOGD("package app share allowed DB initialization failed\n");
2356                 return ret;
2357         }
2358         ret = __initialize_db(pkgmgr_parser_db, QUERY_CREATE_TABLE_PACKAGE_APP_SHARE_REQUEST);
2359         if (ret == -1) {
2360                 _LOGD("package app share request DB initialization failed\n");
2361                 return ret;
2362         }
2363         ret = __initialize_db(pkgmgr_parser_db, QUERY_CREATE_TABLE_PACKAGE_APP_DATA_CONTROL);
2364         if (ret == -1) {
2365                 _LOGD("package app data control DB initialization failed\n");
2366                 return ret;
2367         }
2368
2369         ret = __initialize_db(pkgmgr_parser_db, QUERY_CREATE_TABLE_PACKAGE_APP_INFO_FOR_UID);
2370         if (ret == -1) {
2371                 _LOGD("package_app_info_for_uid for user DB initialization failed\n");
2372                 return ret;
2373         }
2374
2375         ret = __initialize_db(pkgmgr_parser_db, QUERY_CREATE_TABLE_PACKAGE_APP_SPLASH_SCREEN);
2376         if (ret == -1) {
2377                 _LOGD("package app splash screen DB initialization failed\n");
2378                 return ret;
2379         }
2380
2381         /* Trigger package_app_info_for_uid */
2382         ret = __initialize_db(pkgmgr_parser_db, QUERY_CREATE_TRIGGER_UPDATE_PACKAGE_APP_INFO_FOR_UID);
2383         if (ret == -1) {
2384                 _LOGD("package app info for uid DB initialization failed\n");
2385                 return ret;
2386         }
2387
2388         /*Cert DB*/
2389         /* TODO: refactor this code */
2390         ret = __initialize_db(pkgmgr_cert_db, QUERY_CREATE_TABLE_PACKAGE_CERT_INFO);
2391         if (ret == -1) {
2392                 _LOGD("package cert info DB initialization failed\n");
2393                 return ret;
2394         }
2395         ret = __initialize_db(pkgmgr_cert_db, QUERY_CREATE_TABLE_PACKAGE_CERT_INDEX_INFO);
2396         if (ret == -1) {
2397                 _LOGD("package cert index info DB initialization failed\n");
2398                 return ret;
2399         }
2400         ret = __initialize_db(pkgmgr_cert_db, QUERY_CREATE_TRIGGER_UPDATE_CERT_INFO);
2401         if (ret == -1) {
2402                 _LOGD("package cert info DB initialization failed\n");
2403                 return ret;
2404         }
2405         ret = __initialize_db(pkgmgr_cert_db, QUERY_CREATE_TRIGGER_UPDATE_CERT_INFO2);
2406         if (ret == -1) {
2407                 _LOGD("package cert info DB initialization failed\n");
2408                 return ret;
2409         }
2410         ret = __initialize_db(pkgmgr_cert_db, QUERY_CREATE_TRIGGER_DELETE_CERT_INFO);
2411         if (ret == -1) {
2412                 _LOGD("package cert info DB initialization failed\n");
2413                 return ret;
2414         }
2415         ret = __initialize_db(pkgmgr_cert_db, QUERY_CREATE_TRIGGER_UPDATE_CERT_INDEX_INFO);
2416         if (ret == -1) {
2417                 _LOGD("package cert index info DB initialization failed\n");
2418                 return ret;
2419         }
2420
2421         db_path = getUserPkgCertDBPathUID(GLOBAL_USER);
2422         if (db_path == NULL) {
2423                 _LOGD("Failed to get user cert db path - GLOBAL_USER");
2424         } else {
2425                 ret = __parserdb_change_perm(db_path, GLOBAL_USER);
2426                 if (ret != 0)
2427                          _LOGD("Failed to change cert db permission");
2428                 free(db_path);
2429         }
2430
2431         db_path = getUserPkgParserDBPathUID(uid);
2432         if (db_path == NULL) {
2433                 _LOGD("Failed to get user pkg parser db path - %d", uid);
2434         } else {
2435                 ret = __parserdb_change_perm(db_path, uid);
2436                 if (ret != 0)
2437                         _LOGD("Failed to change parser db permission\n");
2438                 free(db_path);
2439         }
2440
2441         return 0;
2442 }
2443
2444 static int __parserdb_change_perm(const char *db_file, uid_t uid)
2445 {
2446         char buf[BUFSIZE];
2447         char pwuid_buf[1024];
2448         char journal_file[BUFSIZE];
2449         int fd;
2450         struct stat sb;
2451         char *files[3];
2452         int ret, i;
2453         struct passwd userinfo, *result = NULL;
2454         files[0] = (char *)db_file;
2455         files[1] = journal_file;
2456         files[2] = NULL;
2457         mode_t mode;
2458
2459         if (db_file == NULL)
2460                 return -1;
2461
2462         if (getuid() != OWNER_ROOT) /* At this time we should be root to apply this */
2463                 return 0;
2464         snprintf(journal_file, sizeof(journal_file), "%s%s", db_file, "-journal");
2465         if (uid == OWNER_ROOT || uid == GLOBAL_USER) {
2466                 ret = getpwnam_r(APPFW_USER, &userinfo, buf, sizeof(buf), &result);
2467                 if (ret != 0 || result == NULL)
2468                         return -1;
2469                 uid = userinfo.pw_uid;
2470         }
2471
2472         ret = getpwuid_r(uid, &userinfo, pwuid_buf, sizeof(pwuid_buf), &result);
2473         if (ret != 0 || result == NULL) {
2474                 _LOGE("FAIL: user %d doesn't exist", uid);
2475                 return -1;
2476         }
2477         snprintf(journal_file, sizeof(journal_file), "%s%s", db_file, "-journal");
2478
2479         for (i = 0; files[i]; i++) {
2480                 fd = open(files[i], O_RDONLY);
2481                 if (fd == -1) {
2482                         if (strerror_r(errno, buf, sizeof(buf)))
2483                                 strncpy(buf, "", BUFSIZE - 1);
2484                         _LOGD("FAIL : open %s : %s", files[i], buf);
2485                         return -1;
2486                 }
2487                 ret = fstat(fd, &sb);
2488                 if (ret == -1) {
2489                         if (strerror_r(errno, buf, sizeof(buf)))
2490                                 strncpy(buf, "", BUFSIZE - 1);
2491                         _LOGD("FAIL : fstat %s : %s", files[i], buf);
2492                         close(fd);
2493                         return -1;
2494                 }
2495                 if (S_ISLNK(sb.st_mode)) {
2496                         _LOGE("FAIL : %s is symlink!", files[i]);
2497                         close(fd);
2498                         return -1;
2499                 }
2500                 ret = fchown(fd, uid, userinfo.pw_gid);
2501                 if (ret == -1) {
2502                         if (strerror_r(errno, buf, sizeof(buf)))
2503                                 strncpy(buf, "", BUFSIZE - 1);
2504                         _LOGD("FAIL : fchown %s %d.%d : %s", files[i], uid,
2505                                         userinfo.pw_gid, buf);
2506                         close(fd);
2507                         return -1;
2508                 }
2509
2510                 mode = S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH;
2511                 if (!strcmp(db_file, getUserPkgCertDBPathUID(GLOBAL_USER)))
2512                         mode |= S_IWOTH;
2513                 ret = fchmod(fd, mode);
2514                 if (ret == -1) {
2515                         if (strerror_r(errno, buf, sizeof(buf)))
2516                                 strncpy(buf, "", BUFSIZE - 1);
2517                         _LOGD("FAIL : fchmod %s 0664 : %s", files[i], buf);
2518                         close(fd);
2519                         return -1;
2520                 }
2521                 close(fd);
2522                 SET_SMACK_LABEL(files[i]);
2523         }
2524         return 0;
2525 }
2526
2527 API int pkgmgr_parser_create_and_initialize_db(uid_t uid)
2528 {
2529         int ret;
2530         char *db_path;
2531
2532         if (getuid() != OWNER_ROOT) {
2533                 _LOGE("Only root user is allowed");
2534                 return -1;
2535         }
2536
2537         db_path = getUserPkgParserDBPathUID(uid);
2538         if (db_path == NULL) {
2539                 _LOGE("Failed to get pkg parser db path - %d", uid);
2540                 return -1;
2541         }
2542
2543         if (access(db_path, F_OK) != -1) {
2544                 _LOGE("Manifest db for user %d is already exists", uid);
2545                 free(db_path);
2546                 return -1;
2547         }
2548         free(db_path);
2549
2550         db_path = getUserPkgCertDBPathUID(uid);
2551         if (db_path == NULL) {
2552                 _LOGE("Failed to get pkg cert db path - %d", uid);
2553                 return -1;
2554         }
2555
2556         if (access(db_path, F_OK) != -1) {
2557                 _LOGE("Cert db for user %d is already exists", uid);
2558                 free(db_path);
2559                 return -1;
2560         }
2561         free(db_path);
2562
2563         ret = pkgmgr_parser_check_and_create_db(uid);
2564         if (ret < 0)
2565                 return -1;
2566         ret = pkgmgr_parser_initialize_db(uid);
2567         if (ret < 0) {
2568                 pkgmgr_parser_close_db();
2569                 return -1;
2570         }
2571         pkgmgr_parser_close_db();
2572
2573         return 0;
2574 }
2575
2576 API int pkgmgr_parser_check_and_create_db(uid_t uid)
2577 {
2578         int ret = -1;
2579         char *db_path;
2580
2581         db_path = getUserPkgParserDBPathUID(uid);
2582         if (db_path == NULL) {
2583                 _LOGD("Failed to get pkg parser db path - %d", uid);
2584                 return -1;
2585         }
2586
2587         /*Manifest DB*/
2588         ret = __pkgmgr_parser_create_db(&pkgmgr_parser_db, db_path);
2589         if (ret) {
2590                 _LOGD("Manifest DB creation Failed\n");
2591                 free(db_path);
2592                 return -1;
2593         }
2594         free(db_path);
2595
2596         db_path = getUserPkgCertDBPathUID(GLOBAL_USER);
2597         if (db_path == NULL) {
2598                 _LOGE("Failed to get pkg cert db path - GLOBAL_USER");
2599                 return -1;
2600         }
2601
2602         /*Cert DB*/
2603         ret = __pkgmgr_parser_create_db(&pkgmgr_cert_db, db_path);
2604         if (ret) {
2605                 _LOGD("Cert DB creation Failed\n");
2606                 free(db_path);
2607                 return -1;
2608         }
2609
2610         free(db_path);
2611
2612         return 0;
2613 }
2614
2615 void pkgmgr_parser_close_db(void)
2616 {
2617         sqlite3_close(pkgmgr_parser_db);
2618         sqlite3_close(pkgmgr_cert_db);
2619 }
2620
2621
2622 API int pkgmgr_parser_insert_manifest_info_in_db(manifest_x *mfx)
2623 {
2624         _LOGD("pkgmgr_parser_insert_manifest_info_in_db\n");
2625         if (mfx == NULL) {
2626                 _LOGD("manifest pointer is NULL\n");
2627                 return -1;
2628         }
2629         int ret = 0;
2630         ret = pkgmgr_parser_check_and_create_db(GLOBAL_USER);
2631         if (ret == -1) {
2632                 _LOGD("Failed to open DB\n");
2633                 return ret;
2634         }
2635         ret = pkgmgr_parser_initialize_db(GLOBAL_USER);
2636         if (ret == -1)
2637                 goto err;
2638         /*Begin transaction*/
2639         ret = sqlite3_exec(pkgmgr_parser_db, "BEGIN EXCLUSIVE", NULL, NULL, NULL);
2640         if (ret != SQLITE_OK) {
2641                 _LOGD("Failed to begin transaction\n");
2642                 ret = -1;
2643                 goto err;
2644         }
2645         _LOGD("Transaction Begin\n");
2646         ret = __insert_manifest_info_in_db(mfx, GLOBAL_USER);
2647         if (ret == -1) {
2648                 _LOGD("Insert into DB failed. Rollback now\n");
2649                 sqlite3_exec(pkgmgr_parser_db, "ROLLBACK", NULL, NULL, NULL);
2650                 goto err;
2651         }
2652         /*Commit transaction*/
2653         ret = sqlite3_exec(pkgmgr_parser_db, "COMMIT", NULL, NULL, NULL);
2654         if (ret != SQLITE_OK) {
2655                 _LOGD("Failed to commit transaction. Rollback now\n");
2656                 sqlite3_exec(pkgmgr_parser_db, "ROLLBACK", NULL, NULL, NULL);
2657                 ret = -1;
2658                 goto err;
2659         }
2660         _LOGD("Transaction Commit and End\n");
2661 err:
2662         pkgmgr_parser_close_db();
2663         return ret;
2664 }
2665
2666 API int pkgmgr_parser_insert_manifest_info_in_usr_db(manifest_x *mfx, uid_t uid)
2667 {
2668         _LOGD("pkgmgr_parser_insert_manifest_info_in_usr_db\n");
2669         if (mfx == NULL) {
2670                 _LOGD("manifest pointer is NULL\n");
2671                 return -1;
2672         }
2673         int ret = 0;
2674         ret = pkgmgr_parser_check_and_create_db(uid);
2675         if (ret == -1) {
2676                 _LOGD("Failed to open DB\n");
2677                 return ret;
2678         }
2679         ret = pkgmgr_parser_initialize_db(uid);
2680         if (ret == -1)
2681                 goto err;
2682         /*Begin transaction*/
2683         ret = sqlite3_exec(pkgmgr_parser_db, "BEGIN EXCLUSIVE", NULL, NULL, NULL);
2684         if (ret != SQLITE_OK) {
2685                 _LOGD("Failed to begin transaction\n");
2686                 ret = -1;
2687                 goto err;
2688         }
2689         _LOGD("Transaction Begin\n");
2690         ret = __insert_manifest_info_in_db(mfx, uid);
2691         if (ret == -1) {
2692                 _LOGD("Insert into DB failed. Rollback now\n");
2693                 sqlite3_exec(pkgmgr_parser_db, "ROLLBACK", NULL, NULL, NULL);
2694                 goto err;
2695         }
2696         /*Commit transaction*/
2697         ret = sqlite3_exec(pkgmgr_parser_db, "COMMIT", NULL, NULL, NULL);
2698         if (ret != SQLITE_OK) {
2699                 _LOGD("Failed to commit transaction. Rollback now\n");
2700                 sqlite3_exec(pkgmgr_parser_db, "ROLLBACK", NULL, NULL, NULL);
2701                 ret = -1;
2702                 goto err;
2703         }
2704         _LOGD("Transaction Commit and End\n");
2705 err:
2706         pkgmgr_parser_close_db();
2707         return ret;
2708 }
2709
2710 API int pkgmgr_parser_update_tep_info_in_db(const char *pkgid, const char *tep_path)
2711 {
2712         return pkgmgr_parser_update_tep_info_in_usr_db(pkgid, tep_path, _getuid());
2713 }
2714
2715 API int pkgmgr_parser_update_tep_info_in_usr_db(const char *pkgid, const char *tep_path, uid_t uid)
2716 {
2717         if (pkgid == NULL || tep_path == NULL) {
2718                 _LOGE("invalid parameter");
2719                 return -1;
2720         }
2721
2722         int ret = -1;
2723         char *query = NULL;
2724
2725         ret = pkgmgr_parser_check_and_create_db(uid);
2726         if (ret == -1) {
2727                 _LOGD("Failed to open DB\n");
2728                 return ret;
2729         }
2730         ret = pkgmgr_parser_initialize_db(uid);
2731         if (ret == -1)
2732                 goto err;
2733
2734         /*Begin transaction*/
2735         ret = sqlite3_exec(pkgmgr_parser_db, "BEGIN EXCLUSIVE", NULL, NULL, NULL);
2736         if (ret != SQLITE_OK) {
2737                 _LOGD("Failed to begin transaction\n");
2738                 ret = -1;
2739                 goto err;
2740         }
2741         _LOGD("Transaction Begin\n");
2742
2743
2744         /* Updating TEP info in "package_info" table */
2745         query = sqlite3_mprintf("UPDATE package_info "\
2746                                                 "SET package_tep_name = %Q "\
2747                                                 "WHERE package = %Q", tep_path, pkgid);
2748
2749         ret = __exec_query(query);
2750         sqlite3_free(query);
2751         if (ret != SQLITE_OK) {
2752                 ret = PM_PARSER_R_ERROR;
2753                 _LOGE("sqlite exec failed to insert entries into package_info!!");
2754                 goto err;
2755         }
2756
2757         /* Updating TEP info in "package_app_info" table */
2758         query = sqlite3_mprintf("UPDATE package_app_info "\
2759                                                 "SET app_tep_name = %Q "\
2760                                                 "WHERE package = %Q", tep_path, pkgid);
2761
2762         ret = __exec_query(query);
2763         sqlite3_free(query);
2764         if (ret != SQLITE_OK) {
2765                 ret = PM_PARSER_R_ERROR;
2766                 _LOGE("sqlite exec failed to insert entries into package_app_info!!");
2767                 goto err;
2768         }
2769
2770         /*Commit transaction*/
2771         ret = sqlite3_exec(pkgmgr_parser_db, "COMMIT", NULL, NULL, NULL);
2772         if (ret != SQLITE_OK) {
2773                 _LOGE("Failed to commit transaction, Rollback now\n");
2774                 ret = sqlite3_exec(pkgmgr_parser_db, "ROLLBACK", NULL, NULL, NULL);
2775                 if (ret != SQLITE_OK)
2776                         _LOGE("Failed to Rollback\n");
2777
2778                 ret = PM_PARSER_R_ERROR;
2779                 goto err;
2780         }
2781         _LOGD("Transaction Commit and End\n");
2782         ret =  PM_PARSER_R_OK;
2783
2784 err:
2785         pkgmgr_parser_close_db();
2786         return ret;
2787 }
2788
2789
2790 API int pkgmgr_parser_update_manifest_info_in_usr_db(manifest_x *mfx, uid_t uid)
2791 {
2792         if (mfx == NULL) {
2793                 _LOGD("manifest pointer is NULL\n");
2794                 return -1;
2795         }
2796         int ret = 0;
2797         ret = pkgmgr_parser_check_and_create_db(uid);
2798         if (ret == -1) {
2799                 _LOGD("Failed to open DB\n");
2800                 return ret;
2801         }
2802         ret = pkgmgr_parser_initialize_db(uid);
2803         if (ret == -1)
2804                 goto err;
2805         /*Preserve guest mode visibility*/
2806         __preserve_guestmode_visibility_value(mfx);
2807         /*Begin transaction*/
2808         ret = sqlite3_exec(pkgmgr_parser_db, "BEGIN EXCLUSIVE", NULL, NULL, NULL);
2809         if (ret != SQLITE_OK) {
2810                 _LOGD("Failed to begin transaction\n");
2811                 ret = -1;
2812                 goto err;
2813         }
2814         _LOGD("Transaction Begin\n");
2815         ret = __delete_manifest_info_from_db(mfx, uid);
2816         if (ret == -1) {
2817                 _LOGD("Delete from DB failed. Rollback now\n");
2818                 sqlite3_exec(pkgmgr_parser_db, "ROLLBACK", NULL, NULL, NULL);
2819                 goto err;
2820         }
2821         ret = __insert_manifest_info_in_db(mfx, uid);
2822         if (ret == -1) {
2823                 _LOGD("Insert into DB failed. Rollback now\n");
2824                 sqlite3_exec(pkgmgr_parser_db, "ROLLBACK", NULL, NULL, NULL);
2825                 goto err;
2826         }
2827
2828         /*Commit transaction*/
2829         ret = sqlite3_exec(pkgmgr_parser_db, "COMMIT", NULL, NULL, NULL);
2830         if (ret != SQLITE_OK) {
2831                 _LOGD("Failed to commit transaction. Rollback now\n");
2832                 sqlite3_exec(pkgmgr_parser_db, "ROLLBACK", NULL, NULL, NULL);
2833                 ret = -1;
2834                 goto err;
2835         }
2836         _LOGD("Transaction Commit and End\n");
2837 err:
2838         pkgmgr_parser_close_db();
2839         return ret;
2840 }
2841
2842 API int pkgmgr_parser_update_manifest_info_in_db(manifest_x *mfx)
2843 {
2844         return pkgmgr_parser_update_manifest_info_in_usr_db(mfx, _getuid());
2845 }
2846
2847 API int pkgmgr_parser_delete_manifest_info_from_usr_db(manifest_x *mfx, uid_t uid)
2848 {
2849         if (mfx == NULL) {
2850                 _LOGD("manifest pointer is NULL\n");
2851                 return -1;
2852         }
2853         int ret = 0;
2854         ret = pkgmgr_parser_check_and_create_db(uid);
2855         if (ret == -1) {
2856                 _LOGD("Failed to open DB\n");
2857                 return ret;
2858         }
2859         /*Begin transaction*/
2860         ret = sqlite3_exec(pkgmgr_parser_db, "BEGIN EXCLUSIVE", NULL, NULL, NULL);
2861         if (ret != SQLITE_OK) {
2862                 _LOGD("Failed to begin transaction\n");
2863                 ret = -1;
2864                 goto err;
2865         }
2866         _LOGD("Transaction Begin\n");
2867         ret = __delete_manifest_info_from_db(mfx, uid);
2868         if (ret == -1) {
2869                 _LOGD("Delete from DB failed. Rollback now\n");
2870                 sqlite3_exec(pkgmgr_parser_db, "ROLLBACK", NULL, NULL, NULL);
2871                 goto err;
2872         }
2873         /*Commit transaction*/
2874         ret = sqlite3_exec(pkgmgr_parser_db, "COMMIT", NULL, NULL, NULL);
2875         if (ret != SQLITE_OK) {
2876                 _LOGD("Failed to commit transaction, Rollback now\n");
2877                 sqlite3_exec(pkgmgr_parser_db, "ROLLBACK", NULL, NULL, NULL);
2878                 ret = -1;
2879                 goto err;
2880         }
2881         _LOGD("Transaction Commit and End\n");
2882 err:
2883         pkgmgr_parser_close_db();
2884         return ret;
2885 }
2886
2887 API int pkgmgr_parser_delete_manifest_info_from_db(manifest_x *mfx)
2888 {
2889         return pkgmgr_parser_delete_manifest_info_from_usr_db(mfx, _getuid());
2890 }
2891
2892 static int _convert_update_type(pkgmgrinfo_updateinfo_update_type type, char **convert_type)
2893 {
2894         if (type == PMINFO_UPDATEINFO_NONE)
2895                 *convert_type = PMINFO_UPDATEINFO_TYPE_NONE;
2896         else if (type == PMINFO_UPDATEINFO_FORCE)
2897                 *convert_type = PMINFO_UPDATEINFO_TYPE_FORCE;
2898         else if (type == PMINFO_UPDATEINFO_OPTIONAL)
2899                 *convert_type = PMINFO_UPDATEINFO_TYPE_OPTIONAL;
2900         else
2901                 return -1;
2902         return 0;
2903 }
2904
2905 API int pkgmgr_parser_register_pkg_update_info_in_usr_db(pkgmgrinfo_updateinfo_h handle, uid_t uid)
2906 {
2907         int ret;
2908         updateinfo_x *update_info;
2909         updateinfo_x *prev_update_info;
2910         pkgmgrinfo_updateinfo_h prev_update_handle;
2911         pkgmgrinfo_pkginfo_h pkginfo;
2912         pkgmgrinfo_version_compare_type compare_result;
2913         bool is_global_pkg;
2914         char query[MAX_QUERY_LEN] = {'\0'};
2915         char *convert_type;
2916
2917         if (handle == NULL)
2918                 return PMINFO_R_EINVAL;
2919
2920         update_info = (updateinfo_x *)handle;
2921         if (update_info->pkgid == NULL || update_info->version == NULL)
2922                 return PMINFO_R_EINVAL;
2923         if (_convert_update_type(update_info->type, &convert_type) != 0)
2924                 return PMINFO_R_EINVAL;
2925
2926         ret = pkgmgrinfo_updateinfo_get_usr_updateinfo(update_info->pkgid,
2927                         &prev_update_handle, uid);
2928         if (ret != PMINFO_R_OK)
2929                 return PMINFO_R_ERROR;
2930
2931         prev_update_info = (updateinfo_x *)prev_update_handle;
2932         ret = pkgmgrinfo_compare_package_version(update_info->version,
2933                         prev_update_info->version, &compare_result);
2934         if (ret != PMINFO_R_OK) {
2935                 pkgmgrinfo_updateinfo_destroy(prev_update_handle);
2936                 return PMINFO_R_ERROR;
2937         }
2938
2939         if (compare_result == PMINFO_VERSION_SAME &&
2940                         prev_update_info->type == PMINFO_UPDATEINFO_NONE) {
2941                 _LOGI("Given update info version[%s] of pkgid[%s] will be ignored",
2942                                 update_info->version, update_info->pkgid);
2943                 pkgmgrinfo_updateinfo_destroy(prev_update_handle);
2944                 return PMINFO_R_OK;
2945         }
2946         pkgmgrinfo_updateinfo_destroy(prev_update_handle);
2947
2948         ret = pkgmgrinfo_pkginfo_get_usr_pkginfo(update_info->pkgid, uid,
2949                         &pkginfo);
2950         if (ret != PMINFO_R_OK)
2951                 return PMINFO_R_ERROR;
2952
2953         ret = pkgmgrinfo_pkginfo_is_global(pkginfo, &is_global_pkg);
2954         if (ret != PMINFO_R_OK) {
2955                 pkgmgrinfo_pkginfo_destroy_pkginfo(pkginfo);
2956                 return PMINFO_R_ERROR;
2957         }
2958         pkgmgrinfo_pkginfo_destroy_pkginfo(pkginfo);
2959
2960         ret = pkgmgr_parser_check_and_create_db(
2961                         (is_global_pkg) ? GLOBAL_USER : uid);
2962         if (ret != PMINFO_R_OK)
2963                 return PMINFO_R_ERROR;
2964
2965         sqlite3_snprintf(MAX_QUERY_LEN, query,
2966                         "UPDATE package_update_info SET update_version=%Q, " \
2967                         "update_type=%Q WHERE package=%Q",
2968                         update_info->version,
2969                         convert_type,
2970                         update_info->pkgid);
2971
2972         ret = __exec_query(query);
2973         pkgmgr_parser_close_db();
2974
2975         return ret;
2976 }
2977
2978 API int pkgmgr_parser_register_pkg_update_info_in_db(pkgmgrinfo_updateinfo_h handle)
2979 {
2980         return pkgmgr_parser_register_pkg_update_info_in_usr_db(handle, _getuid());
2981 }
2982
2983 API int pkgmgr_parser_unregister_pkg_update_info_in_usr_db(const char *pkgid, uid_t uid)
2984 {
2985         pkgmgrinfo_pkginfo_h pkginfo = NULL;
2986         int ret;
2987         bool is_global_pkg;
2988         char query[MAX_QUERY_LEN] = {'\0'};
2989
2990         if (pkgid == NULL)
2991                 return PMINFO_R_EINVAL;
2992
2993         ret = pkgmgrinfo_pkginfo_get_usr_pkginfo(pkgid, uid, &pkginfo);
2994         if (ret != PMINFO_R_OK)
2995                 return -1;
2996
2997         ret = pkgmgrinfo_pkginfo_is_global(pkginfo, &is_global_pkg);
2998         if (ret != PMINFO_R_OK) {
2999                 pkgmgrinfo_pkginfo_destroy_pkginfo(pkginfo);
3000                 return PMINFO_R_ERROR;
3001         }
3002         pkgmgrinfo_pkginfo_destroy_pkginfo(pkginfo);
3003         ret = pkgmgr_parser_check_and_create_db((is_global_pkg) ? GLOBAL_USER : uid);
3004         if (ret != PMINFO_R_OK)
3005                 return ret;
3006
3007         sqlite3_snprintf(MAX_QUERY_LEN, query,
3008                         "UPDATE package_update_info SET update_type='none' " \
3009                         "WHERE package=%Q", pkgid);
3010
3011         ret = __exec_query(query);
3012         pkgmgr_parser_close_db();
3013
3014         return ret;
3015 }
3016
3017 API int pkgmgr_parser_unregister_pkg_update_info_in_db(const char *pkgid)
3018 {
3019         return pkgmgr_parser_unregister_pkg_update_info_in_usr_db(pkgid, _getuid());
3020 }
3021
3022 API int pkgmgr_parser_unregister_all_pkg_update_info_in_usr_db(uid_t uid)
3023 {
3024         int ret;
3025         char query[MAX_QUERY_LEN] = {'\0'};
3026         char *error_message = NULL;
3027
3028         ret = pkgmgr_parser_check_and_create_db(uid);
3029         if (ret != 0)
3030                 return PMINFO_R_ERROR;
3031
3032         sqlite3_snprintf(MAX_QUERY_LEN, query,
3033                         "UPDATE package_update_info SET update_type='none'");
3034         ret = sqlite3_exec(pkgmgr_parser_db, query, NULL, NULL, &error_message);
3035         if (ret != SQLITE_OK) {
3036                 _LOGE("Don't execute query = %s error message = %s\n", query,
3037                        error_message);
3038                 sqlite3_free(error_message);
3039                 pkgmgr_parser_close_db();
3040                 return PMINFO_R_ERROR;
3041         }
3042         sqlite3_free(error_message);
3043         error_message = NULL;
3044         pkgmgr_parser_close_db();
3045
3046         return PMINFO_R_OK;
3047 }
3048
3049 API int pkgmgr_parser_unregister_all_pkg_update_info_in_db(void)
3050 {
3051         return pkgmgr_parser_unregister_all_pkg_update_info_in_usr_db(_getuid());
3052 }
3053
3054 API int pkgmgr_parser_update_global_app_disable_for_uid_info_in_db(const char *appid, uid_t uid, int is_disable)
3055 {
3056         int ret = -1;
3057
3058         ret = pkgmgr_parser_check_and_create_db(GLOBAL_USER);
3059         if (ret == -1) {
3060                 _LOGD("Failed to open DB\n");
3061                 return ret;
3062         }
3063
3064         /*Begin transaction*/
3065         ret = sqlite3_exec(pkgmgr_parser_db, "BEGIN EXCLUSIVE", NULL, NULL, NULL);
3066         if (ret != SQLITE_OK) {
3067                 _LOGD("Failed to begin transaction\n");
3068                 ret = -1;
3069                 goto err;
3070         }
3071         _LOGD("Transaction Begin\n");
3072         if (is_disable)
3073                 ret = __disable_global_app_for_user(appid, uid);
3074         else
3075                 ret = __enable_global_app_for_user(appid, uid);
3076         if (ret == -1) {
3077                 _LOGD("__update_global_app_disable_condition_in_db failed. Rollback now\n");
3078                 sqlite3_exec(pkgmgr_parser_db, "ROLLBACK", NULL, NULL, NULL);
3079                 goto err;
3080         }
3081         /*Commit transaction*/
3082         ret = sqlite3_exec(pkgmgr_parser_db, "COMMIT", NULL, NULL, NULL);
3083         if (ret != SQLITE_OK) {
3084                 _LOGD("Failed to commit transaction, Rollback now\n");
3085                 sqlite3_exec(pkgmgr_parser_db, "ROLLBACK", NULL, NULL, NULL);
3086                 ret = -1;
3087                 goto err;
3088         }
3089         _LOGD("Transaction Commit and End\n");
3090 err:
3091         pkgmgr_parser_close_db();
3092         return ret;
3093
3094 }
3095
3096 API int pkgmgr_parser_update_app_disable_info_in_db(const char *appid, int is_disable)
3097 {
3098         return pkgmgr_parser_update_app_disable_info_in_usr_db(appid, _getuid(), is_disable);
3099 }
3100
3101 API int pkgmgr_parser_update_pkg_disable_info_in_usr_db(const char *pkgid, uid_t uid, int is_disable)
3102 {
3103         int ret = -1;
3104
3105         ret = pkgmgr_parser_check_and_create_db(uid);
3106         if (ret == -1) {
3107                 _LOGD("Failed to open DB\n");
3108                 return ret;
3109         }
3110
3111         /*Begin transaction*/
3112         ret = sqlite3_exec(pkgmgr_parser_db, "BEGIN EXCLUSIVE", NULL, NULL, NULL);
3113         if (ret != SQLITE_OK) {
3114                 _LOGD("Failed to begin transaction\n");
3115                 ret = -1;
3116                 goto err;
3117         }
3118
3119         _LOGD("Transaction Begin\n");
3120         if (is_disable)
3121                 ret = __disable_pkg(pkgid);
3122         else
3123                 ret = __enable_pkg(pkgid);
3124
3125         if (ret == -1) {
3126                 _LOGD("__update_pkg_disable_condition_in_db failed. Rollback now\n");
3127                 sqlite3_exec(pkgmgr_parser_db, "ROLLBACK", NULL, NULL, NULL);
3128                 goto err;
3129         }
3130
3131         /*Commit transaction*/
3132         ret = sqlite3_exec(pkgmgr_parser_db, "COMMIT", NULL, NULL, NULL);
3133         if (ret != SQLITE_OK) {
3134                 _LOGD("Failed to commit transaction, Rollback now\n");
3135                 sqlite3_exec(pkgmgr_parser_db, "ROLLBACK", NULL, NULL, NULL);
3136                 ret = -1;
3137                 goto err;
3138         }
3139         _LOGD("Transaction Commit and End\n");
3140
3141 err:
3142         pkgmgr_parser_close_db();
3143         return ret;
3144 }
3145
3146 API int pkgmgr_parser_update_pkg_disable_info_in_db(const char *pkgid, int is_disable)
3147 {
3148         return pkgmgr_parser_update_pkg_disable_info_in_usr_db(pkgid, _getuid(), is_disable);
3149 }
3150
3151 API int pkgmgr_parser_update_app_disable_info_in_usr_db(const char *appid, uid_t uid, int is_disable)
3152 {
3153         int ret = -1;
3154
3155         ret = pkgmgr_parser_check_and_create_db(uid);
3156         if (ret == -1) {
3157                 _LOGD("Failed to open DB\n");
3158                 return ret;
3159         }
3160
3161         /*Begin transaction*/
3162         ret = sqlite3_exec(pkgmgr_parser_db, "BEGIN EXCLUSIVE", NULL, NULL, NULL);
3163         if (ret != SQLITE_OK) {
3164                 _LOGD("Failed to begin transaction\n");
3165                 ret = -1;
3166                 goto err;
3167         }
3168         _LOGD("Transaction Begin\n");
3169         if (is_disable)
3170                 ret = __disable_app(appid);
3171         else
3172                 ret = __enable_app(appid);
3173         if (ret == -1) {
3174                 _LOGD("__update_app_disable_condition_in_db failed. Rollback now\n");
3175                 sqlite3_exec(pkgmgr_parser_db, "ROLLBACK", NULL, NULL, NULL);
3176                 goto err;
3177         }
3178         /*Commit transaction*/
3179         ret = sqlite3_exec(pkgmgr_parser_db, "COMMIT", NULL, NULL, NULL);
3180         if (ret != SQLITE_OK) {
3181                 _LOGD("Failed to commit transaction, Rollback now\n");
3182                 sqlite3_exec(pkgmgr_parser_db, "ROLLBACK", NULL, NULL, NULL);
3183                 ret = -1;
3184                 goto err;
3185         }
3186         _LOGD("Transaction Commit and End\n");
3187 err:
3188         pkgmgr_parser_close_db();
3189         return ret;
3190
3191 }
3192
3193 API int pkgmgr_parser_update_global_app_splash_screen_display_info_in_usr_db(const char *appid, uid_t uid, int flag)
3194 {
3195         int ret = -1;
3196
3197         if (appid == NULL) {
3198                 _LOGD("Invalid parameter");
3199                 return -1;
3200         }
3201
3202         ret = pkgmgr_parser_check_and_create_db(GLOBAL_USER);
3203         if (ret == -1) {
3204                 _LOGD("Failed to open DB\n");
3205                 return ret;
3206         }
3207
3208         /* Begin transaction */
3209         ret = sqlite3_exec(pkgmgr_parser_db, "BEGIN EXCLUSIVE", NULL, NULL, NULL);
3210         if (ret != SQLITE_OK) {
3211                 _LOGD("Failed to begin transaction\n");
3212                 ret = -1;
3213                 goto err;
3214         }
3215         _LOGD("Transaction Begin\n");
3216
3217         ret = __update_global_app_splash_screen_for_user(appid, uid, flag);
3218         if (ret == -1) {
3219                 _LOGD("__update_splash_screen_disable_condition_in_db failed. Rollback now\n");
3220                 sqlite3_exec(pkgmgr_parser_db, "ROLLBACK", NULL, NULL, NULL);
3221                 goto err;
3222         }
3223         /* Commit transaction */
3224         ret = sqlite3_exec(pkgmgr_parser_db, "COMMIT", NULL, NULL, NULL);
3225         if (ret != SQLITE_OK) {
3226                 _LOGD("Failed to commit transaction, Rollback now\n");
3227                 sqlite3_exec(pkgmgr_parser_db, "ROLLBACK", NULL, NULL, NULL);
3228                 ret = -1;
3229                 goto err;
3230         }
3231         _LOGD("Transaction Commit and End\n");
3232 err:
3233         pkgmgr_parser_close_db();
3234         return ret;
3235 }
3236
3237 API int pkgmgr_parser_update_app_splash_screen_display_info_in_db(const char *appid, int flag)
3238 {
3239         return pkgmgr_parser_update_app_splash_screen_display_info_in_usr_db(appid, _getuid(), flag);
3240 }
3241
3242 API int pkgmgr_parser_update_app_splash_screen_display_info_in_usr_db(const char *appid, uid_t uid, int flag)
3243 {
3244         int ret;
3245
3246         if (appid == NULL) {
3247                 _LOGD("Invalid parameter");
3248                 return -1;
3249         }
3250
3251         ret = pkgmgr_parser_check_and_create_db(uid);
3252         if (ret == -1) {
3253                 _LOGD("Failed to open DB");
3254                 return -1;
3255         }
3256
3257         /* Begin transaction */
3258         ret = sqlite3_exec(pkgmgr_parser_db, "BEGIN EXCLUSIVE", NULL, NULL, NULL);
3259         if (ret != SQLITE_OK) {
3260                 _LOGD("Failed to begin transaction");
3261                 ret = -1;
3262                 goto err;
3263         }
3264         _LOGD("Transaction Begin");
3265
3266         if (flag)
3267                 ret = __enable_app_splash_screen(appid);
3268         else
3269                 ret = __disable_app_splash_screen(appid);
3270         if (ret == -1) {
3271                 _LOGD("__update_app_splash_screen_condition_in_db. Rollback now");
3272                 sqlite3_exec(pkgmgr_parser_db, "ROLLBACK", NULL, NULL, NULL);
3273                 goto err;
3274         }
3275         /* Commit transaction */
3276         ret = sqlite3_exec(pkgmgr_parser_db, "COMMIT", NULL, NULL, NULL);
3277         if (ret != SQLITE_OK) {
3278                 _LOGD("Failed to commit transaction, Rollback now");
3279                 sqlite3_exec(pkgmgr_parser_db, "ROLLBACK", NULL, NULL, NULL);
3280                 ret = -1;
3281                 goto err;
3282         }
3283         _LOGD("Transaction Commit and End");
3284
3285 err:
3286         pkgmgr_parser_close_db();
3287         return ret;
3288 }
3289
3290 API int pkgmgr_parser_update_app_label_info_in_usr_db(const char *appid, uid_t uid, const char *label)
3291 {
3292         int ret;
3293         char query[MAX_QUERY_LEN] = {'\0'};
3294
3295         if (appid == NULL || label == NULL) {
3296                 _LOGE("Invalid parameter");
3297                 return -1;
3298         }
3299
3300         ret = pkgmgr_parser_check_and_create_db(uid);
3301         if (ret == -1) {
3302                 _LOGD("Failed to open DB");
3303                 return -1;
3304         }
3305
3306         /*Begin transaction*/
3307         ret = sqlite3_exec(pkgmgr_parser_db, "BEGIN EXCLUSIVE", NULL, NULL, NULL);
3308         if (ret != SQLITE_OK) {
3309                 _LOGD("Failed to begin transaction\n");
3310                 ret = -1;
3311                 goto err;
3312         }
3313
3314         sqlite3_snprintf(MAX_QUERY_LEN, query,
3315                         "UPDATE package_app_localized_info SET app_label=%Q WHERE " \
3316                         "app_id=%Q AND app_label IS NOT NULL",
3317                         label, appid);
3318         ret = __exec_query(query);
3319         if (ret == -1) {
3320                 sqlite3_exec(pkgmgr_parser_db, "ROLLBACK", NULL, NULL, NULL);
3321                 goto err;
3322         }
3323
3324         /* Commit transaction */
3325         ret = sqlite3_exec(pkgmgr_parser_db, "COMMIT", NULL, NULL, NULL);
3326         if (ret != SQLITE_OK) {
3327                 _LOGD("Failed to commit transaction, Rollback now");
3328                 sqlite3_exec(pkgmgr_parser_db, "ROLLBACK", NULL, NULL, NULL);
3329                 ret = -1;
3330                 goto err;
3331         }
3332         _LOGD("Transaction Commit and End");
3333
3334 err:
3335         pkgmgr_parser_close_db();
3336         return ret;
3337 }
3338
3339 API int pkgmgr_parser_update_app_label_info_in_db(const char *appid, const char *label)
3340 {
3341         return pkgmgr_parser_update_app_label_info_in_usr_db(appid, _getuid(), label);
3342 }
3343