src/server/pkginfo_internal.c

   1 /*
   2  * Copyright (c) 2021 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #define _GNU_SOURCE
  18 #include <stdio.h>
  19 #include <stdlib.h>
  20 #include <string.h>
  21 #include <stdbool.h>
  22 #include <unistd.h>
  23 #include <ctype.h>
  24 #include <sys/smack.h>
  25 #include <linux/limits.h>
  26 #include <sys/stat.h>
  27
  28 #include <sqlite3.h>
  29 #include <glib.h>
  30
  31 #include <system_info.h>
  32
  33 #include "pkgmgr_parser.h"
  34 #include "pkgmgrinfo_basic.h"
  35 #include "pkgmgrinfo_internal.h"
  36 #include "pkgmgrinfo_private.h"
  37 #include "pkgmgrinfo_debug.h"
  38 #include "pkgmgr-info.h"
  39
  40 #define LDPI "ldpi"
  41 #define MDPI "mdpi"
  42 #define HDPI "hdpi"
  43 #define XHDPI "xhdpi"
  44 #define XXHDPI "xxhdpi"
  45
  46 #define LDPI_MIN 0
  47 #define LDPI_MAX 240
  48 #define MDPI_MIN 241
  49 #define MDPI_MAX 300
  50 #define HDPI_MIN 301
  51 #define HDPI_MAX 380
  52 #define XHDPI_MIN 381
  53 #define XHDPI_MAX 480
  54 #define XXHDPI_MIN 481
  55 #define XXHDPI_MAX 600
  56
  57 static const char join_localized_info[] =
  58         " LEFT OUTER JOIN package_localized_info"
  59         "  ON pi.package=package_localized_info.package"
  60         "  AND package_localized_info.package_locale=?";
  61 static const char join_privilege_info[] =
  62         " LEFT OUTER JOIN package_privilege_info"
  63         "  ON pi.package=package_privilege_info.package";
  64 static const char join_res_info[] =
  65         " LEFT OUTER JOIN package_res_info"
  66         "  ON pi.package=package_res_info.package";
  67
  68 static int _get_filtered_query(pkgmgrinfo_filter_x *filter,
  69                 const char *locale, uid_t uid,
  70                 char **query, GList **bind_params)
  71 {
  72         int joined = 0;
  73         int size;
  74         char buf[MAX_QUERY_LEN] = { '\0' };
  75         char buf2[MAX_QUERY_LEN] = { '\0' };
  76         char *condition = NULL;
  77         GList *tmp_params = NULL;
  78         GSList *list = NULL;
  79
  80         if (!filter)
  81                 return PMINFO_R_OK;
  82
  83         if (filter->cache_flag) {
  84                 joined = E_PMINFO_PKGINFO_JOIN_LOCALIZED_INFO |
  85                         E_PMINFO_PKGINFO_JOIN_PRIVILEGE_INFO |
  86                         E_PMINFO_PKGINFO_JOIN_RES_INFO;
  87         }
  88
  89         snprintf(buf, sizeof(buf), "%s", " WHERE 1=1 ");
  90         for (list = filter->list; list; list = list->next) {
  91                 joined |= __get_filter_condition(list->data, uid, &condition,
  92                                 &tmp_params);
  93                 if (condition == NULL)
  94                         continue;
  95
  96                 strncat(buf, " AND ", sizeof(buf) - strlen(buf) - 1);
  97
  98                 strncat(buf, condition, sizeof(buf) - strlen(buf) - 1);
  99                 free(condition);
 100                 condition = NULL;
 101         }
 102
 103         if (joined & E_PMINFO_PKGINFO_JOIN_LOCALIZED_INFO) {
 104                 strncat(buf2, join_localized_info,
 105                                 sizeof(buf2) - strlen(buf2) - 1);
 106                 *bind_params = g_list_append(*bind_params, strdup(locale));
 107         }
 108         if (joined & E_PMINFO_PKGINFO_JOIN_PRIVILEGE_INFO)
 109                 strncat(buf2, join_privilege_info,
 110                                 sizeof(buf2) - strlen(buf2) - 1);
 111         if (joined & E_PMINFO_PKGINFO_JOIN_RES_INFO)
 112                 strncat(buf2, join_res_info,
 113                                 sizeof(buf2) - strlen(buf2) - 1);
 114
 115         *bind_params = g_list_concat(*bind_params, tmp_params);
 116         size = strlen(buf2) + strlen(buf) + 1;
 117         *query = (char *)calloc(1, size);
 118         if (*query == NULL)
 119                 return PMINFO_R_ERROR;
 120         snprintf(*query, size, "%s%s", buf2, buf);
 121
 122         return PMINFO_R_OK;
 123 }
 124
 125 static int __bind_params(sqlite3_stmt *stmt, GList *params)
 126 {
 127         GList *tmp_list = NULL;
 128         int idx = 0;
 129         int ret;
 130
 131         if (stmt == NULL || params == NULL)
 132                 return PMINFO_R_EINVAL;
 133
 134         tmp_list = params;
 135         while (tmp_list) {
 136                 ret = sqlite3_bind_text(stmt, ++idx,
 137                                 (char *)tmp_list->data, -1, SQLITE_STATIC);
 138                 if (ret != SQLITE_OK)
 139                         return PMINFO_R_ERROR;
 140                 tmp_list = tmp_list->next;
 141         }
 142
 143         return PMINFO_R_OK;
 144 }
 145
 146 bool __check_package_storage_status(pkgmgrinfo_filter_x *tmp_filter)
 147 {
 148         GSList *tmp_list = NULL;
 149         pkgmgrinfo_node_x *tmp_node = NULL;
 150         int property = -1;
 151
 152         if (tmp_filter->cache_flag)
 153                 return false;
 154
 155         property = _pminfo_pkginfo_convert_to_prop_bool(
 156                                 PMINFO_PKGINFO_PROP_PACKAGE_CHECK_STORAGE);
 157         for (tmp_list = tmp_filter->list; tmp_list != NULL;
 158                         tmp_list = g_slist_next(tmp_list)) {
 159                 tmp_node = (pkgmgrinfo_node_x *)tmp_list->data;
 160                 if (property == tmp_node->prop) {
 161                         if (strcmp(tmp_node->value, "true") == 0)
 162                                 return true;
 163                         else
 164                                 return false;
 165                 }
 166         }
 167         return true;
 168 }
 169
 170 static int _pkginfo_add_description_info_into_list(const char *locale,
 171                 char *record, GList **description)
 172 {
 173         description_x *info;
 174
 175         info = calloc(1, sizeof(description_x));
 176         if (info == NULL) {
 177                 LOGE("out of memory");
 178                 return PMINFO_R_ERROR;
 179         }
 180         info->lang = strdup(locale);
 181         info->text = record;
 182         *description = g_list_prepend(*description, info);
 183
 184         return PMINFO_R_OK;
 185 }
 186
 187 static int _pkginfo_get_plugin_execution_info(sqlite3 *db, const char *pkgid,
 188                 GList **plugins)
 189 {
 190         static const char query_raw[] =
 191                 "SELECT appid, plugin_type, plugin_name FROM package_plugin_info "
 192                 "WHERE pkgid=%Q";
 193         int ret;
 194         char *query;
 195         sqlite3_stmt *stmt;
 196         plugin_x *plugin;
 197
 198         query = sqlite3_mprintf(query_raw, pkgid);
 199         if (query == NULL) {
 200                 LOGE("out of memory");
 201                 return PMINFO_R_ERROR;
 202         }
 203
 204         ret = sqlite3_prepare_v2(db, query, strlen(query),
 205                         &stmt, NULL);
 206         sqlite3_free(query);
 207         if (ret != SQLITE_OK) {
 208                 LOGE("prepare failed: %s", sqlite3_errmsg(db));
 209                 return PMINFO_R_ERROR;
 210         }
 211
 212         while (sqlite3_step(stmt) == SQLITE_ROW) {
 213                 plugin = calloc(1, sizeof(plugin_x));
 214                 if (!plugin) {
 215                         LOGE("out of memory");
 216                         sqlite3_finalize(stmt);
 217                         return PMINFO_R_ERROR;
 218                 }
 219                 plugin->pkgid = strdup(pkgid);
 220                 _save_column_str(stmt, 0, &plugin->appid);
 221                 _save_column_str(stmt, 1, &plugin->plugin_type);
 222                 _save_column_str(stmt, 2, &plugin->plugin_name);
 223                 *plugins = g_list_prepend(*plugins,
 224                                 (gpointer)plugin);
 225         }
 226
 227         sqlite3_finalize(stmt);
 228
 229         return PMINFO_R_OK;
 230 }
 231
 232 static int _pkginfo_get_privilege(sqlite3 *db, const char *pkgid,
 233                 GList **privileges)
 234 {
 235         static const char query_raw[] =
 236                 "SELECT DISTINCT privilege, type FROM package_privilege_info "
 237                 "WHERE package=%Q";
 238         int ret;
 239         char *query;
 240         sqlite3_stmt *stmt;
 241         privilege_x *privilege;
 242
 243         query = sqlite3_mprintf(query_raw, pkgid);
 244         if (query == NULL) {
 245                 LOGE("out of memory");
 246                 return PMINFO_R_ERROR;
 247         }
 248
 249         ret = sqlite3_prepare_v2(db, query, strlen(query),
 250                         &stmt, NULL);
 251         sqlite3_free(query);
 252         if (ret != SQLITE_OK) {
 253                 LOGE("prepare failed: %s", sqlite3_errmsg(db));
 254                 return PMINFO_R_ERROR;
 255         }
 256
 257         while (sqlite3_step(stmt) == SQLITE_ROW) {
 258                 privilege = calloc(1, sizeof(privilege_x));
 259                 if (!privilege) {
 260                         LOGE("failed to alloc memory");
 261                         sqlite3_finalize(stmt);
 262                         return PMINFO_R_ERROR;
 263                 }
 264                 _save_column_str(stmt, 0, &privilege->value);
 265                 _save_column_str(stmt, 1, &privilege->type);
 266                 *privileges = g_list_prepend(*privileges,
 267                                 (gpointer)privilege);
 268         }
 269
 270         sqlite3_finalize(stmt);
 271
 272         return PMINFO_R_OK;
 273 }
 274
 275 static int _pkginfo_get_appdefined_privilege(sqlite3 *db, const char *pkgid,
 276                 GList **privileges)
 277 {
 278         static const char query_raw[] =
 279                 "SELECT DISTINCT privilege, license, type FROM "
 280                 "package_appdefined_privilege_info WHERE package=%Q";
 281         int ret;
 282         char *query;
 283         sqlite3_stmt *stmt;
 284         appdefined_privilege_x *privilege;
 285
 286         query = sqlite3_mprintf(query_raw, pkgid);
 287         if (query == NULL) {
 288                 LOGE("out of memory");
 289                 return PMINFO_R_ERROR;
 290         }
 291
 292         ret = sqlite3_prepare_v2(db, query, strlen(query),
 293                         &stmt, NULL);
 294         sqlite3_free(query);
 295         if (ret != SQLITE_OK) {
 296                 LOGE("prepare failed: %s", sqlite3_errmsg(db));
 297                 return PMINFO_R_ERROR;
 298         }
 299
 300         while (sqlite3_step(stmt) == SQLITE_ROW) {
 301                 privilege = calloc(1, sizeof(appdefined_privilege_x));
 302                 if (!privilege) {
 303                         LOGE("failed to alloc memory");
 304                         sqlite3_finalize(stmt);
 305                         return PMINFO_R_ERROR;
 306                 }
 307                 _save_column_str(stmt, 0, &privilege->value);
 308                 _save_column_str(stmt, 1, &privilege->license);
 309                 _save_column_str(stmt, 2, &privilege->type);
 310                 *privileges = g_list_prepend(*privileges,
 311                                 (gpointer)privilege);
 312         }
 313
 314         sqlite3_finalize(stmt);
 315
 316         return PMINFO_R_OK;
 317 }
 318
 319 static int _pkginfo_get_dependency(sqlite3 *db, const char *pkgid,
 320                 GList **dependencies)
 321 {
 322         static const char query_raw[] =
 323                 "SELECT DISTINCT depends_on, type, required_version "
 324                 "FROM package_dependency_info WHERE package=%Q";
 325         int ret;
 326         char *query;
 327         sqlite3_stmt *stmt;
 328         dependency_x *dependency;
 329
 330         query = sqlite3_mprintf(query_raw, pkgid);
 331         if (query == NULL) {
 332                 LOGE("out of memory");
 333                 return PMINFO_R_ERROR;
 334         }
 335
 336         ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
 337         sqlite3_free(query);
 338         if (ret != SQLITE_OK) {
 339                 LOGE("prepare failed: %s", sqlite3_errmsg(db));
 340                 return PMINFO_R_ERROR;
 341         }
 342
 343         while (sqlite3_step(stmt) == SQLITE_ROW) {
 344                 dependency = calloc(1, sizeof(dependency_x));
 345                 if (!dependency) {
 346                         LOGE("failed to alloc memory");
 347                         sqlite3_finalize(stmt);
 348                         return PMINFO_R_ERROR;
 349                 }
 350                 _save_column_str(stmt, 0, &dependency->depends_on);
 351                 _save_column_str(stmt, 1, &dependency->type);
 352                 _save_column_str(stmt, 2, &dependency->required_version);
 353                 *dependencies = g_list_prepend(*dependencies,
 354                                 (gpointer)dependency);
 355         }
 356
 357         sqlite3_finalize(stmt);
 358
 359         return PMINFO_R_OK;
 360 }
 361
 362 static int _pkginfo_get_res_allowed_packages(sqlite3 *db, const char *pkgid,
 363                 GList **allowed_packages)
 364 {
 365         static const char query_raw[] =
 366                 "SELECT DISTINCT allowed_package, required_privilege "
 367                 "FROM package_res_allowed_package WHERE package=%Q";
 368         int ret;
 369         char *query;
 370         char *package;
 371         char *privilege;
 372         sqlite3_stmt *stmt;
 373         res_allowed_package_x *allowed_package_x;
 374         GList *l;
 375
 376         query = sqlite3_mprintf(query_raw, pkgid);
 377         if (query == NULL) {
 378                 LOGE("out of memory");
 379                 return PMINFO_R_ERROR;
 380         }
 381
 382         ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
 383         sqlite3_free(query);
 384         if (ret != SQLITE_OK) {
 385                 LOGE("prepare failed: %s", sqlite3_errmsg(db));
 386                 return PMINFO_R_ERROR;
 387         }
 388
 389         while (sqlite3_step(stmt) == SQLITE_ROW) {
 390                 allowed_package_x = NULL;
 391                 package = NULL;
 392                 privilege = NULL;
 393
 394                 _save_column_str(stmt, 0, &package);
 395                 if (!package)
 396                         continue;
 397
 398                 for (l = *allowed_packages; l; l = l->next) {
 399                         allowed_package_x = (res_allowed_package_x *)l->data;
 400                         if (!strcmp(package, (char *)l->data))
 401                                 break;
 402                         allowed_package_x = NULL;
 403                 }
 404
 405                 if (allowed_package_x) {
 406                         free(package);
 407                 } else {
 408                         allowed_package_x = calloc(1,
 409                                         sizeof(res_allowed_package_x));
 410                         if (allowed_package_x == NULL) {
 411                                 LOGE("failed to alloc memory");
 412                                 sqlite3_finalize(stmt);
 413                                 free(package);
 414                                 return PMINFO_R_ERROR;
 415                         }
 416                         allowed_package_x->allowed_package = package;
 417                         *allowed_packages = g_list_prepend(*allowed_packages,
 418                                         (gpointer)allowed_package_x);
 419                 }
 420
 421                 _save_column_str(stmt, 1, &privilege);
 422                 if (!privilege)
 423                         continue;
 424
 425                 allowed_package_x->required_privileges = g_list_prepend(
 426                                 allowed_package_x->required_privileges,
 427                                 privilege);
 428         }
 429
 430         sqlite3_finalize(stmt);
 431
 432         return PMINFO_R_OK;
 433 }
 434
 435 static int _pkginfo_get_res_info(sqlite3 *db, const char *pkgid,
 436                 char **res_type, char **res_version,
 437                 GList **res_allowed_packages)
 438 {
 439         static const char query_raw[] =
 440                 "SELECT DISTINCT res_type, res_version "
 441                 "FROM package_res_info WHERE package=%Q";
 442         int ret;
 443         char *query;
 444         sqlite3_stmt *stmt;
 445
 446         query = sqlite3_mprintf(query_raw, pkgid);
 447         if (query == NULL) {
 448                 LOGE("out of memory");
 449                 return PMINFO_R_ERROR;
 450         }
 451
 452         ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
 453         sqlite3_free(query);
 454         if (ret != SQLITE_OK) {
 455                 LOGE("prepare failed: %s", sqlite3_errmsg(db));
 456                 return PMINFO_R_ERROR;
 457         }
 458
 459         if (sqlite3_step(stmt) != SQLITE_ROW) {
 460                 sqlite3_finalize(stmt);
 461                 return PMINFO_R_OK;
 462         }
 463
 464         _save_column_str(stmt, 0, res_type);
 465         _save_column_str(stmt, 1, res_version);
 466
 467         if (_pkginfo_get_res_allowed_packages(db, pkgid,
 468                         res_allowed_packages) != PMINFO_R_OK) {
 469                 sqlite3_finalize(stmt);
 470                 return PMINFO_R_ERROR;
 471         }
 472
 473         sqlite3_finalize(stmt);
 474
 475         return PMINFO_R_OK;
 476 }
 477
 478 static int _pkginfo_get_packages(sqlite3 *db, uid_t uid, const char *locale,
 479                 pkgmgrinfo_filter_x *filter, int flag, GHashTable *packages)
 480 {
 481         static const char query_raw[] =
 482                 "SELECT DISTINCT pi.package, pi.installed_storage, pi.external_path";
 483         static const char query_basic[] =
 484                 ", pi.package_version, pi.install_location, "
 485                 "pi.package_removable, pi.package_preload, pi.package_readonly, "
 486                 "pi.package_update, pi.package_appsetting, pi.package_system, "
 487                 "pi.package_type, pi.package_size, pi.installed_time, "
 488                 "pi.storeclient_id, pi.mainapp_id, pi.package_url, pi.root_path, "
 489                 "pi.csc_path, pi.package_nodisplay, pi.package_api_version, "
 490                 "pi.package_support_disable, pi.package_tep_name, "
 491                 "pi.package_zip_mount_file, pi.package_support_mode, pi.package_disable, "
 492                 "pi.light_user_switch_mode";
 493         static const char query_author[] =
 494                 ", pi.author_name, pi.author_email, pi.author_href";
 495         static const char query_label[] =
 496                 ", COALESCE("
 497                 "(SELECT package_label FROM package_localized_info WHERE pi.package=package AND package_locale=?), "
 498                 "(SELECT package_label FROM package_localized_info WHERE pi.package=package AND package_locale='No Locale'))";
 499         static const char query_icon[] =
 500                 ", COALESCE("
 501                 "(SELECT package_icon FROM package_localized_info WHERE pi.package=package AND package_locale=?), "
 502                 "(SELECT package_icon FROM package_localized_info WHERE pi.package=package AND package_locale='No Locale'))";
 503         static const char query_description[] =
 504                 ", COALESCE("
 505                 "(SELECT package_description FROM package_localized_info WHERE pi.package=package AND package_locale=?), "
 506                 "(SELECT package_description FROM package_localized_info WHERE pi.package=package AND package_locale='No Locale'))";
 507         static const char query_res_type[] =
 508                 ", (SELECT res_type FROM package_res_info WHERE pi.package=package)";
 509         static const char query_res_version[] =
 510                 ", (SELECT res_version FROM package_res_info WHERE pi.package=package)";
 511         static const char query_from_clause[] = " FROM package_info as pi";
 512         int ret = PMINFO_R_ERROR;
 513         int idx = 0;
 514         char *tmp_record = NULL;
 515         char *constraints = NULL;
 516         char query[MAX_QUERY_LEN] = { '\0' };
 517         package_x *info = NULL;
 518         author_x *author = NULL;
 519         GList *bind_params = NULL;
 520         sqlite3_stmt *stmt = NULL;
 521         bool is_check_storage = true;
 522         const uid_t global_user_uid = GLOBAL_USER;
 523
 524         if (db == NULL || locale == NULL || filter == NULL) {
 525                 LOGE("Invalid parameter");
 526                 return PMINFO_R_EINVAL;
 527         }
 528
 529         is_check_storage = __check_package_storage_status(filter);
 530
 531         snprintf(query, MAX_QUERY_LEN - 1, "%s", query_raw);
 532         if (flag & PMINFO_APPINFO_GET_BASICINFO)
 533                 strncat(query, query_basic, sizeof(query) - strlen(query) - 1);
 534         if (flag & PMINFO_PKGINFO_GET_AUTHOR)
 535                 strncat(query, query_author, sizeof(query) - strlen(query) - 1);
 536         if (flag & PMINFO_PKGINFO_GET_LABEL) {
 537                 strncat(query, query_label, sizeof(query) - strlen(query) - 1);
 538                 bind_params = g_list_append(bind_params, strdup(locale));
 539         }
 540         if (flag & PMINFO_PKGINFO_GET_ICON) {
 541                 strncat(query, query_icon, sizeof(query) - strlen(query) - 1);
 542                 bind_params = g_list_append(bind_params, strdup(locale));
 543         }
 544         if (flag & PMINFO_PKGINFO_GET_DESCRIPTION) {
 545                 strncat(query, query_description,
 546                                 sizeof(query) - strlen(query) - 1);
 547                 bind_params = g_list_append(bind_params, strdup(locale));
 548         }
 549         if (flag & PMINFO_PKGINFO_GET_RES_INFO) {
 550                 strncat(query, query_res_type,
 551                                 sizeof(query) - strlen(query) - 1);
 552                 strncat(query, query_res_version,
 553                                 sizeof(query) - strlen(query) - 1);
 554         }
 555
 556         strncat(query, query_from_clause, sizeof(query) - strlen(query) - 1);
 557
 558         ret = _get_filtered_query(filter, locale, uid,
 559                         &constraints, &bind_params);
 560         if (ret != PMINFO_R_OK) {
 561                 LOGE("Failed to get WHERE clause");
 562                 goto catch;
 563         }
 564
 565         if (constraints)
 566                 strncat(query, constraints, sizeof(query) - strlen(query) - 1);
 567
 568         ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
 569         if (ret != SQLITE_OK) {
 570                 LOGE("prepare failed: %s", sqlite3_errmsg(db));
 571                 ret = PMINFO_R_ERROR;
 572                 goto catch;
 573         }
 574
 575         ret = __bind_params(stmt, bind_params);
 576         if (ret != SQLITE_OK) {
 577                 LOGE("Failed to bind parameters");
 578                 goto catch;
 579         }
 580
 581         while (sqlite3_step(stmt) == SQLITE_ROW) {
 582                 info = calloc(1, sizeof(package_x));
 583                 if (info == NULL) {
 584                         LOGE("out of memory");
 585                         ret = PMINFO_R_ERROR;
 586                         goto catch;
 587                 }
 588                 info->locale = strdup(locale);
 589                 if (info->locale == NULL) {
 590                         LOGE("Out of memory");
 591                         ret = PMINFO_R_ERROR;
 592                         goto catch;
 593                 }
 594
 595                 idx = 0;
 596                 _save_column_str(stmt, idx++, &info->package);
 597                 _save_column_str(stmt, idx++, &info->installed_storage);
 598                 _save_column_str(stmt, idx++, &info->external_path);
 599
 600                 if (flag & PMINFO_APPINFO_GET_BASICINFO) {
 601                         _save_column_str(stmt, idx++, &info->version);
 602                         _save_column_str(stmt, idx++, &info->installlocation);
 603                         _save_column_str(stmt, idx++, &info->removable);
 604                         _save_column_str(stmt, idx++, &info->preload);
 605                         _save_column_str(stmt, idx++, &info->readonly);
 606                         _save_column_str(stmt, idx++, &info->update);
 607                         _save_column_str(stmt, idx++, &info->appsetting);
 608                         _save_column_str(stmt, idx++, &info->system);
 609                         _save_column_str(stmt, idx++, &info->type);
 610                         _save_column_str(stmt, idx++, &info->package_size);
 611                         _save_column_str(stmt, idx++, &info->installed_time);
 612                         _save_column_str(stmt, idx++, &info->storeclient_id);
 613                         _save_column_str(stmt, idx++, &info->mainapp_id);
 614                         _save_column_str(stmt, idx++, &info->package_url);
 615                         _save_column_str(stmt, idx++, &info->root_path);
 616                         _save_column_str(stmt, idx++, &info->csc_path);
 617                         _save_column_str(stmt, idx++, &info->nodisplay_setting);
 618                         _save_column_str(stmt, idx++, &info->api_version);
 619                         _save_column_str(stmt, idx++, &info->support_disable);
 620                         _save_column_str(stmt, idx++, &info->tep_name);
 621                         _save_column_str(stmt, idx++, &info->zip_mount_file);
 622                         _save_column_str(stmt, idx++, &info->support_mode);
 623                         _save_column_str(stmt, idx++, &info->is_disabled);
 624                         _save_column_str(stmt, idx++, &info->light_user_switch_mode);
 625                 }
 626
 627                 info->for_all_users =
 628                         strdup((uid != global_user_uid) ? "false" : "true");
 629
 630                 if (_pkginfo_get_plugin_execution_info(db,
 631                                 info->package, &info->plugin)) {
 632                         ret = PMINFO_R_ERROR;
 633                         goto catch;
 634                 }
 635
 636                 if (flag & PMINFO_PKGINFO_GET_AUTHOR) {
 637                         /* TODO : author should be retrieved at package_localized_info */
 638                         author = calloc(1, sizeof(author_x));
 639                         if (author == NULL) {
 640                                 ret = PMINFO_R_ERROR;
 641                                 goto catch;
 642                         }
 643                         _save_column_str(stmt, idx++, &author->text);
 644                         _save_column_str(stmt, idx++, &author->email);
 645                         _save_column_str(stmt, idx++, &author->href);
 646                         info->author = g_list_prepend(info->author, author);
 647                 }
 648
 649                 if (flag & PMINFO_PKGINFO_GET_LABEL) {
 650                         tmp_record = NULL;
 651                         _save_column_str(stmt, idx++, &tmp_record);
 652
 653                         if (_add_label_info_into_list(locale,
 654                                         tmp_record, &info->label)) {
 655                                 ret = PMINFO_R_ERROR;
 656                                 goto catch;
 657                         }
 658                 }
 659
 660                 if (flag & PMINFO_PKGINFO_GET_ICON) {
 661                         tmp_record = NULL;
 662                         _save_column_str(stmt, idx++, &tmp_record);
 663                         if (_add_icon_info_into_list(locale,
 664                                         tmp_record, &info->icon)) {
 665                                 ret = PMINFO_R_ERROR;
 666                                 goto catch;
 667                         }
 668                 }
 669
 670                 if (flag & PMINFO_PKGINFO_GET_DESCRIPTION) {
 671                         tmp_record = NULL;
 672                         _save_column_str(stmt, idx++, &tmp_record);
 673                         if (_pkginfo_add_description_info_into_list(locale,
 674                                         tmp_record, &info->description)) {
 675                                 ret = PMINFO_R_ERROR;
 676                                 goto catch;
 677                         }
 678                 }
 679
 680                 if (flag & PMINFO_PKGINFO_GET_PRIVILEGE) {
 681                         if (_pkginfo_get_privilege(db, info->package,
 682                                                 &info->privileges)) {
 683                                 ret = PMINFO_R_ERROR;
 684                                 goto catch;
 685                         }
 686                 }
 687
 688                 if (flag & PMINFO_PKGINFO_GET_APPDEFINED_PRIVILEGE) {
 689                         if (_pkginfo_get_appdefined_privilege(db, info->package,
 690                                                 &info->appdefined_privileges)) {
 691                                 ret = PMINFO_R_ERROR;
 692                                 goto catch;
 693                         }
 694                 }
 695
 696                 if (flag & PMINFO_PKGINFO_GET_DEPENDENCY) {
 697                         if (_pkginfo_get_dependency(db, info->package,
 698                                                 &info->dependencies)) {
 699                                 ret = PMINFO_R_ERROR;
 700                                 goto catch;
 701                         }
 702                 }
 703
 704                 if (flag & PMINFO_PKGINFO_GET_RES_INFO) {
 705                         if (_pkginfo_get_res_info(db, info->package,
 706                                         &info->res_type,
 707                                         &info->res_version,
 708                                         &info->res_allowed_packages) < 0) {
 709                                 ret = PMINFO_R_ERROR;
 710                                 goto catch;
 711                         }
 712                 }
 713
 714                 if (is_check_storage &&
 715                                 __pkginfo_check_installed_storage(info) !=
 716                                                 PMINFO_R_OK) {
 717                         ret = PMINFO_R_ERROR;
 718                         pkgmgrinfo_basic_free_package(info);
 719                         info = NULL;
 720                         continue;
 721                 }
 722
 723                 g_hash_table_insert(packages, (gpointer)info->package,
 724                                 (gpointer)info);
 725         }
 726
 727         ret = PMINFO_R_OK;
 728
 729 catch:
 730         sqlite3_finalize(stmt);
 731
 732         if (constraints)
 733                 free(constraints);
 734
 735         if (ret != PMINFO_R_OK && info != NULL)
 736                 pkgmgrinfo_basic_free_package(info);
 737
 738         g_list_free_full(bind_params, free);
 739
 740         return ret;
 741 }
 742
 743 API int pkginfo_internal_filter_get_list(
 744                 sqlite3 *db, pkgmgrinfo_pkginfo_filter_h filter,
 745                 uid_t uid, const char *locale, GHashTable *pkginfo_list)
 746 {
 747         int ret;
 748
 749         if (filter == NULL || pkginfo_list == NULL) {
 750                 LOGE("Invalid argument");
 751                 return PMINFO_R_EINVAL;
 752         }
 753
 754         ret = _pkginfo_get_packages(db, uid, locale, filter,
 755                         PMINFO_PKGINFO_GET_ALL, pkginfo_list);
 756         return ret;
 757 }
 758
 759 API int get_query_result(sqlite3 *db, const char *query, GList *param,
 760                 GList **list, int *row, int *col)
 761 {
 762         int ret = 0;
 763         int col_cnt = 0;
 764         int row_cnt = 0;
 765         int idx = 0;
 766         sqlite3_stmt *stmt = NULL;
 767         char *result = NULL;
 768
 769         if (db == NULL || query == NULL) {
 770                 LOGE("Invalid parameter");
 771                 return PMINFO_R_EINVAL;
 772         }
 773
 774         ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
 775         if (ret != SQLITE_OK) {
 776                 LOGE("prepare failed: %s", sqlite3_errmsg(db));
 777                 return PMINFO_R_ERROR;
 778         }
 779
 780         if (g_list_length(param) != 0) {
 781                 ret = __bind_params(stmt, param);
 782                 if (ret != PMINFO_R_OK) {
 783                         LOGE("failed to bind parameters: %s", sqlite3_errmsg(db));
 784                         sqlite3_finalize(stmt);
 785                         return ret;
 786                 }
 787         }
 788
 789         col_cnt = sqlite3_column_count(stmt);
 790
 791         while (sqlite3_step(stmt) == SQLITE_ROW) {
 792                 row_cnt++;
 793                 for (idx = 0; idx < col_cnt; ++idx) {
 794                         _save_column_str(stmt, idx, &result);
 795                         *list = g_list_append(*list, result);
 796                         result = NULL;
 797                 }
 798         }
 799
 800         *row = row_cnt;
 801         *col = col_cnt;
 802
 803         sqlite3_finalize(stmt);
 804
 805         return PMINFO_R_OK;
 806 }
 807
 808 static int _get_depends_on(sqlite3 *db, const char *pkgid, GQueue **queue,
 809                 GHashTable **table, GList **pkg_list)
 810 {
 811         static const char query[] =
 812                 "SELECT package, depends_on, type, required_version "
 813                 "FROM package_dependency_info WHERE depends_on=?";
 814         int ret;
 815         sqlite3_stmt *stmt;
 816         dependency_x *req;
 817
 818         /* already checked */
 819         if (!g_hash_table_insert(*table, strdup(pkgid), GINT_TO_POINTER(1)))
 820                 return PMINFO_R_OK;
 821
 822         ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
 823         if (ret != SQLITE_OK) {
 824                 LOGE("prepare failed: %s", sqlite3_errmsg(db));
 825                 return PMINFO_R_ERROR;
 826         }
 827
 828         ret = sqlite3_bind_text(stmt, 1, pkgid, -1, SQLITE_STATIC);
 829         if (ret != SQLITE_OK) {
 830                 LOGE("bind failed: %s", sqlite3_errmsg(db));
 831                 sqlite3_finalize(stmt);
 832                 return PMINFO_R_ERROR;
 833         }
 834
 835         while (sqlite3_step(stmt) == SQLITE_ROW) {
 836                 req = calloc(1, sizeof(dependency_x));
 837                 if (req == NULL) {
 838                         LOGE("out of memory");
 839                         sqlite3_finalize(stmt);
 840                         return PMINFO_R_ERROR;
 841                 }
 842                 _save_column_str(stmt, 0, &req->pkgid);
 843                 _save_column_str(stmt, 1, &req->depends_on);
 844                 _save_column_str(stmt, 2, &req->type);
 845                 _save_column_str(stmt, 3, &req->required_version);
 846
 847                 *pkg_list = g_list_prepend(*pkg_list, req);
 848                 g_queue_push_tail(*queue, strdup(req->pkgid));
 849         }
 850
 851         sqlite3_finalize(stmt);
 852
 853         return PMINFO_R_OK;
 854 }
 855
 856 static void __free_depends_on(gpointer data)
 857 {
 858         struct dependency_x *dep = (struct dependency_x *)data;
 859
 860         free(dep->pkgid);
 861         free(dep->depends_on);
 862         free(dep->type);
 863         free(dep->required_version);
 864         free(dep);
 865 }
 866
 867 API int pkginfo_internal_filter_get_depends_on(sqlite3 *db, const char *pkgid,
 868                 GList **list)
 869 {
 870         GQueue *queue;
 871         GHashTable *table;
 872         char *item;
 873         int ret;
 874
 875         if (db == NULL || pkgid == NULL) {
 876                 LOGE("Invalid parameter");
 877                 return PMINFO_R_EINVAL;
 878         }
 879
 880         queue = g_queue_new();
 881         if (queue == NULL) {
 882                 LOGE("out of memory");
 883                 return PMINFO_R_ERROR;
 884         }
 885         table = g_hash_table_new_full(g_str_hash, g_str_equal, free, NULL);
 886
 887         g_queue_push_tail(queue, strdup(pkgid));
 888         while (!g_queue_is_empty(queue)) {
 889                 item = g_queue_pop_head(queue);
 890                 ret = _get_depends_on(db, item, &queue, &table, list);
 891                 free(item);
 892                 if (ret != PMINFO_R_OK) {
 893                         LOGE("failed to get pkgs depends on %s", pkgid);
 894                         g_hash_table_destroy(table);
 895                         g_list_free_full(*list, __free_depends_on);
 896                         g_queue_free_full(queue, free);
 897                         return PMINFO_R_ERROR;
 898                 }
 899         }
 900
 901         g_hash_table_destroy(table);
 902         g_queue_free_full(queue, free);
 903         return PMINFO_R_OK;
 904 }
 905
 906 static int __execute_query(sqlite3 *db, const char *query, GList *param)
 907 {
 908         int ret = 0;
 909         sqlite3_stmt *stmt = NULL;
 910
 911         ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
 912         if (ret != SQLITE_OK) {
 913                 LOGE("prepare failed: %s", sqlite3_errmsg(db));
 914                 return -1;
 915         }
 916
 917         if (g_list_length(param) != 0) {
 918                 ret = __bind_params(stmt, param);
 919                 if (ret != PMINFO_R_OK) {
 920                         LOGE("failed to bind parameters: %s", sqlite3_errmsg(db));
 921                         sqlite3_finalize(stmt);
 922                         return ret;
 923                 }
 924         }
 925
 926         ret = sqlite3_step(stmt);
 927         if (ret != SQLITE_DONE && ret != SQLITE_OK) {
 928                 LOGE("step failed:%d %s", ret, sqlite3_errmsg(db));
 929                 sqlite3_finalize(stmt);
 930                 return -1;
 931         }
 932
 933         sqlite3_finalize(stmt);
 934
 935         return PMINFO_R_OK;
 936 }
 937
 938 API int execute_write_queries(sqlite3 *db, GList *queries, GList *params_list)
 939 {
 940         int i;
 941         query_args *tmp_ptr = NULL;
 942
 943         if (db == NULL || queries == NULL) {
 944                 _LOGE("Invalid parameter");
 945                 return PMINFO_R_EINVAL;
 946         }
 947
 948         __BEGIN_TRANSACTION(db);
 949         for (i = 0; i < g_list_length(queries); ++i) {
 950                 tmp_ptr = (query_args *)g_list_nth_data(params_list, i);
 951                 if (tmp_ptr == NULL) {
 952                         _LOGE("Failed to get parameter list");
 953                         sqlite3_exec(db, "ROLLBACK", NULL, NULL, NULL);
 954                         return PMINFO_R_ERROR;
 955                 }
 956
 957                 __DO_TRANSACTION(db,
 958                                 __execute_query(db, g_list_nth_data(queries, i),
 959                                                 tmp_ptr->argument));
 960         }
 961         __END_TRANSACTION(db);
 962
 963         return PMINFO_R_OK;
 964 }
 965
 966 static int __check_dpi(const char *dpi_char, int dpi_int)
 967 {
 968         if (dpi_char == NULL)
 969                 return -1;
 970
 971         if (strcasecmp(dpi_char, LDPI) == 0) {
 972                 if (dpi_int >= LDPI_MIN && dpi_int <= LDPI_MAX)
 973                         return 0;
 974                 else
 975                         return -1;
 976         } else if (strcasecmp(dpi_char, MDPI) == 0) {
 977                 if (dpi_int >= MDPI_MIN && dpi_int <= MDPI_MAX)
 978                         return 0;
 979                 else
 980                         return -1;
 981         } else if (strcasecmp(dpi_char, HDPI) == 0) {
 982                 if (dpi_int >= HDPI_MIN && dpi_int <= HDPI_MAX)
 983                         return 0;
 984                 else
 985                         return -1;
 986         } else if (strcasecmp(dpi_char, XHDPI) == 0) {
 987                 if (dpi_int >= XHDPI_MIN && dpi_int <= XHDPI_MAX)
 988                         return 0;
 989                 else
 990                         return -1;
 991         } else if (strcasecmp(dpi_char, XXHDPI) == 0) {
 992                 if (dpi_int >= XXHDPI_MIN && dpi_int <= XXHDPI_MAX)
 993                         return 0;
 994                 else
 995                         return -1;
 996         } else
 997                 return -1;
 998 }
 999
1000 static void __find_appcontrol_splashscreen_with_dpi(gpointer data,
1001                 gpointer user_data)
1002 {
1003         splashscreen_x *ss = (splashscreen_x *)data;
1004         GList **list = (GList **)user_data;
1005         int dpi = -1;
1006         int ret;
1007
1008         if (ss->operation == NULL || ss->dpi == NULL)
1009                 return;
1010
1011         ret = system_info_get_platform_int(
1012                         "http://tizen.org/feature/screen.dpi", &dpi);
1013         if (ret != SYSTEM_INFO_ERROR_NONE)
1014                 return;
1015
1016         if (__check_dpi(ss->dpi, dpi) != 0)
1017                 return;
1018
1019         *list = g_list_prepend(*list, ss);
1020 }
1021
1022 static void __find_appcontrol_splashscreen(gpointer data, gpointer user_data)
1023 {
1024         splashscreen_x *ss = (splashscreen_x *)data;
1025         GList **list = (GList **)user_data;
1026         splashscreen_x *ss_tmp;
1027         GList *tmp;
1028
1029         if (ss->operation == NULL || ss->dpi)
1030                 return;
1031
1032         for (tmp = *list; tmp; tmp = tmp->next) {
1033                 ss_tmp = (splashscreen_x *)tmp->data;
1034                 if (ss_tmp->operation
1035                         && strcmp(ss_tmp->operation, ss->operation) == 0
1036                         && strcmp(ss_tmp->orientation, ss->orientation) == 0)
1037                         return;
1038         }
1039
1040         *list = g_list_prepend(*list, ss);
1041 }
1042
1043 static gint __compare_splashscreen_with_orientation_dpi(gconstpointer a,
1044                 gconstpointer b)
1045 {
1046         splashscreen_x *ss = (splashscreen_x *)a;
1047         const char *orientation = (const char *)b;
1048         int dpi = -1;
1049         int ret;
1050
1051         if (ss->operation || ss->dpi == NULL)
1052                 return -1;
1053
1054         ret = system_info_get_platform_int(
1055                         "http://tizen.org/feature/screen.dpi", &dpi);
1056         if (ret != SYSTEM_INFO_ERROR_NONE)
1057                 return -1;
1058
1059         if (strcasecmp(ss->orientation, orientation) == 0 &&
1060                         __check_dpi(ss->dpi, dpi) == 0)
1061                 return 0;
1062
1063         return -1;
1064 }
1065
1066 static gint __compare_splashscreen_with_orientation(gconstpointer a,
1067                 gconstpointer b)
1068 {
1069         splashscreen_x *ss = (splashscreen_x *)a;
1070         const char *orientation = (const char *)b;
1071
1072         if (ss->operation || ss->dpi)
1073                 return -1;
1074
1075         if (strcasecmp(ss->orientation, orientation) == 0)
1076                 return 0;
1077
1078         return -1;
1079 }
1080
1081 static splashscreen_x *__find_default_splashscreen(GList *splashscreens,
1082                 const char *orientation)
1083 {
1084         GList *tmp;
1085
1086         tmp = g_list_find_custom(splashscreens, orientation,
1087                         (GCompareFunc)
1088                         __compare_splashscreen_with_orientation_dpi);
1089         if (tmp)
1090                 return (splashscreen_x *)tmp->data;
1091
1092         tmp = g_list_find_custom(splashscreens, orientation,
1093                         (GCompareFunc)__compare_splashscreen_with_orientation);
1094         if (tmp)
1095                 return (splashscreen_x *)tmp->data;
1096
1097         return NULL;
1098 }
1099
1100 static GList *__find_splashscreens(GList *splashscreens)
1101 {
1102         GList *list = NULL;
1103         splashscreen_x *ss;
1104
1105         if (splashscreens == NULL)
1106                 return NULL;
1107
1108         g_list_foreach(splashscreens,
1109                         __find_appcontrol_splashscreen_with_dpi, &list);
1110         g_list_foreach(splashscreens,
1111                         __find_appcontrol_splashscreen, &list);
1112
1113         ss = __find_default_splashscreen(splashscreens, "portrait");
1114         if (ss)
1115                 list = g_list_prepend(list, ss);
1116         ss = __find_default_splashscreen(splashscreens, "landscape");
1117         if (ss)
1118                 list = g_list_prepend(list, ss);
1119
1120         return list;
1121 }
1122
1123 static int __insert_splashscreen_info(sqlite3 *db, application_x *app,
1124                 GList *ss_list)
1125 {
1126         static const char query[] =
1127                 "INSERT INTO package_app_splash_screen (app_id, src, type,"
1128                 "  orientation, indicatordisplay, operation, color_depth) "
1129                 "VALUES (?, ?, ?, ?, ?, ?, ?)";
1130         int ret;
1131         sqlite3_stmt *stmt;
1132         int idx;
1133         GList *tmp;
1134         splashscreen_x *ss;
1135
1136         if (app->splashscreens == NULL)
1137                 return 0;
1138
1139         if (ss_list == NULL)
1140                 return 0;
1141
1142         ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
1143         if (ret != SQLITE_OK) {
1144                 _LOGE("prepare failed: %s", sqlite3_errmsg(db));
1145                 return -1;
1146         }
1147
1148         for (tmp = ss_list; tmp; tmp = tmp->next) {
1149                 ss = (splashscreen_x *)tmp->data;
1150                 if (ss == NULL)
1151                         continue;
1152                 idx = 1;
1153                 __BIND_TEXT(db, stmt, idx++, app->appid);
1154                 __BIND_TEXT(db, stmt, idx++, ss->src);
1155                 __BIND_TEXT(db, stmt, idx++, ss->type);
1156                 __BIND_TEXT(db, stmt, idx++, ss->orientation);
1157                 __BIND_TEXT(db, stmt, idx++, ss->indicatordisplay);
1158                 __BIND_TEXT(db, stmt, idx++, ss->operation);
1159                 __BIND_TEXT(db, stmt, idx++, ss->color_depth);
1160
1161                 ret = sqlite3_step(stmt);
1162                 if (ret != SQLITE_DONE) {
1163                         _LOGE("step failed: %s", sqlite3_errmsg(db));
1164                         sqlite3_finalize(stmt);
1165                         return -1;
1166                 }
1167
1168                 sqlite3_reset(stmt);
1169         }
1170
1171         sqlite3_finalize(stmt);
1172
1173         return 0;
1174 }
1175
1176 static void __trimfunc(GList *trim_list)
1177 {
1178         char *trim_data;
1179         char *prev = NULL;
1180         GList *list = g_list_first(trim_list);
1181
1182         while (list) {
1183                 trim_data = (char *)list->data;
1184                 if (trim_data) {
1185                         if (prev) {
1186                                 if (strcmp(trim_data, prev) == 0) {
1187                                         trim_list = g_list_remove(trim_list,
1188                                                         trim_data);
1189                                         list = g_list_first(trim_list);
1190                                         prev = NULL;
1191                                         continue;
1192                                 } else
1193                                         prev = trim_data;
1194                         } else {
1195                                 prev = trim_data;
1196                         }
1197                 }
1198                 list = g_list_next(list);
1199         }
1200 }
1201
1202 static int __insert_package_appdefined_privilege_info(sqlite3 *db,
1203                 manifest_x *mfx)
1204 {
1205         static const char query[] =
1206                 "INSERT INTO package_appdefined_privilege_info "
1207                 "(package, privilege, license, type) "
1208                 "VALUES (?, ?, ?, ?)";
1209         int ret;
1210         sqlite3_stmt *stmt;
1211         int idx;
1212         GList *tmp;
1213         appdefined_privilege_x *priv;
1214
1215         ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
1216         if (ret != SQLITE_OK) {
1217                 _LOGE("prepare failed: %s", sqlite3_errmsg(db));
1218                 return -1;
1219         }
1220
1221         for (tmp = mfx->appdefined_privileges; tmp; tmp = tmp->next) {
1222                 priv = (appdefined_privilege_x *)tmp->data;
1223                 if (priv == NULL)
1224                         continue;
1225
1226                 idx = 1;
1227                 __BIND_TEXT(db, stmt, idx++, mfx->package);
1228                 __BIND_TEXT(db, stmt, idx++, priv->value);
1229                 __BIND_TEXT(db, stmt, idx++, priv->license);
1230                 __BIND_TEXT(db, stmt, idx++, priv->type);
1231
1232                 ret = sqlite3_step(stmt);
1233                 if (ret != SQLITE_DONE) {
1234                         _LOGE("step failed: %s", sqlite3_errmsg(db));
1235                         sqlite3_finalize(stmt);
1236                         return -1;
1237                 }
1238                 sqlite3_reset(stmt);
1239         }
1240
1241         sqlite3_finalize(stmt);
1242
1243         return 0;
1244 }
1245
1246 static int __insert_package_dependency_info(sqlite3 *db, manifest_x *mfx)
1247 {
1248         static const char query[] =
1249                 "INSERT INTO package_dependency_info"
1250                 "  (package, depends_on, type, required_version) "
1251                 "VALUES (?, ?, ?, ?)";
1252         int ret;
1253         sqlite3_stmt *stmt;
1254         int idx;
1255         GList *tmp;
1256         dependency_x *dep;
1257
1258         ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
1259         if (ret != SQLITE_OK) {
1260                 _LOGE("prepare failed: %s", sqlite3_errmsg(db));
1261                 return -1;
1262         }
1263
1264         for (tmp = mfx->dependencies; tmp; tmp = tmp->next) {
1265                 dep = (dependency_x *)tmp->data;
1266                 if (dep == NULL)
1267                         continue;
1268
1269                 idx = 1;
1270                 __BIND_TEXT(db, stmt, idx++, mfx->package);
1271                 __BIND_TEXT(db, stmt, idx++, dep->depends_on);
1272                 __BIND_TEXT(db, stmt, idx++, dep->type);
1273                 __BIND_TEXT(db, stmt, idx++, dep->required_version);
1274
1275                 ret = sqlite3_step(stmt);
1276                 if (ret != SQLITE_DONE) {
1277                         _LOGE("step failed: %s", sqlite3_errmsg(db));
1278                         sqlite3_finalize(stmt);
1279                         return -1;
1280                 }
1281                 sqlite3_reset(stmt);
1282         }
1283
1284         sqlite3_finalize(stmt);
1285
1286         return 0;
1287 }
1288
1289 static int __insert_mainapp_localized_info(sqlite3 *db, application_x *app,
1290                 const char *locale, const char *label, const char *icon)
1291 {
1292         static const char query[] =
1293                 "INSERT OR REPLACE INTO package_localized_info ("
1294                 "  package, package_locale, package_label, package_icon,"
1295                 "  package_description, package_license, package_author) "
1296                 "VALUES (?, ?,"
1297                 "  COALESCE((SELECT package_label FROM package_localized_info"
1298                 "            WHERE package=? AND package_locale=?), ?),"
1299                 "  COALESCE((SELECT package_icon FROM package_localized_info"
1300                 "            WHERE package=? AND package_icon=?), ?),"
1301                 "  (SELECT package_description FROM package_localized_info"
1302                 "   WHERE package=? AND package_locale=?),"
1303                 "  (SELECT package_description FROM package_localized_info"
1304                 "   WHERE package=? AND package_locale=?),"
1305                 "  (SELECT package_description FROM package_localized_info"
1306                 "   WHERE package=? AND package_locale=?))";
1307         int ret;
1308         sqlite3_stmt *stmt;
1309         int idx = 1;
1310
1311         ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
1312         if (ret != SQLITE_OK) {
1313                 _LOGE("prepare failed: %s", sqlite3_errmsg(db));
1314                 return -1;
1315         }
1316
1317         __BIND_TEXT(db, stmt, idx++, app->package);
1318         __BIND_TEXT(db, stmt, idx++, locale);
1319         __BIND_TEXT(db, stmt, idx++, app->package);
1320         __BIND_TEXT(db, stmt, idx++, locale);
1321         __BIND_TEXT(db, stmt, idx++, label);
1322         __BIND_TEXT(db, stmt, idx++, app->package);
1323         __BIND_TEXT(db, stmt, idx++, locale);
1324         __BIND_TEXT(db, stmt, idx++, icon);
1325         __BIND_TEXT(db, stmt, idx++, app->package);
1326         __BIND_TEXT(db, stmt, idx++, locale);
1327         __BIND_TEXT(db, stmt, idx++, app->package);
1328         __BIND_TEXT(db, stmt, idx++, locale);
1329         __BIND_TEXT(db, stmt, idx++, app->package);
1330         __BIND_TEXT(db, stmt, idx++, locale);
1331
1332         ret = sqlite3_step(stmt);
1333         if (ret != SQLITE_DONE) {
1334                 _LOGE("step failed: %s", sqlite3_errmsg(db));
1335                 sqlite3_finalize(stmt);
1336                 return -1;
1337         }
1338
1339         sqlite3_finalize(stmt);
1340
1341         return 0;
1342 }
1343
1344 static gint __comparefunc(gconstpointer a, gconstpointer b, gpointer userdata)
1345 {
1346         if (a == NULL || b == NULL)
1347                 return 0;
1348         if (strcmp((char *)a, (char *)b) == 0)
1349                 return 0;
1350         if (strcmp((char *)a, (char *)b) < 0)
1351                 return -1;
1352         if (strcmp((char *)a, (char *)b) > 0)
1353                 return 1;
1354         return 0;
1355 }
1356
1357 static GList *__create_locale_list(GList *lbls, GList *lcns, GList *icns,
1358                 GList *dcns, GList *aths)
1359 {
1360         GList *locale = NULL;
1361         GList *tmp;
1362         label_x *lbl;
1363         license_x *lcn;
1364         icon_x *icn;
1365         description_x *dcn;
1366         author_x *ath;
1367
1368         for (tmp = lbls; tmp; tmp = tmp->next) {
1369                 lbl = (label_x *)tmp->data;
1370                 if (lbl == NULL)
1371                         continue;
1372                 if (lbl->lang)
1373                         locale = g_list_insert_sorted_with_data(
1374                                         locale, (gpointer)lbl->lang,
1375                                         __comparefunc, NULL);
1376         }
1377         for (tmp = lcns; tmp; tmp = tmp->next) {
1378                 lcn = (license_x *)tmp->data;
1379                 if (lcn == NULL)
1380                         continue;
1381                 if (lcn->lang)
1382                         locale = g_list_insert_sorted_with_data(
1383                                         locale, (gpointer)lcn->lang,
1384                                         __comparefunc, NULL);
1385         }
1386         for (tmp = icns; tmp; tmp = tmp->next) {
1387                 icn = (icon_x *)tmp->data;
1388                 if (icn == NULL)
1389                         continue;
1390                 if (icn->lang)
1391                         locale = g_list_insert_sorted_with_data(
1392                                         locale, (gpointer)icn->lang,
1393                                         __comparefunc, NULL);
1394         }
1395         for (tmp = dcns; tmp; tmp = tmp->next) {
1396                 dcn = (description_x *)tmp->data;
1397                 if (dcn == NULL)
1398                         continue;
1399                 if (dcn->lang)
1400                         locale = g_list_insert_sorted_with_data(
1401                                         locale, (gpointer)dcn->lang,
1402                                         __comparefunc, NULL);
1403         }
1404         for (tmp = aths; tmp; tmp = tmp->next) {
1405                 ath = (author_x *)tmp->data;
1406                 if (ath == NULL)
1407                         continue;
1408                 if (ath->lang)
1409                         locale = g_list_insert_sorted_with_data(
1410                                         locale, (gpointer)ath->lang,
1411                                         __comparefunc, NULL);
1412         }
1413         __trimfunc(locale);
1414         return locale;
1415 }
1416
1417 static gint __check_icon_resolution(const char *orig_icon_path,
1418                 char **new_icon_path)
1419 {
1420         int ret;
1421         char *dpi_path[2];
1422         char *icon_filename;
1423         char modified_iconpath[BUFSIZE];
1424         char icon_path[BUFSIZE];
1425         int i;
1426         int dpi = -1;
1427
1428         if (orig_icon_path == NULL)
1429                 return -1;
1430
1431         ret = system_info_get_platform_int(
1432                         "http://tizen.org/feature/screen.dpi", &dpi);
1433         if (ret != SYSTEM_INFO_ERROR_NONE)
1434                 return -1;
1435
1436         if (dpi >= LDPI_MIN && dpi <= LDPI_MAX) {
1437                 dpi_path[0] = "LDPI";
1438                 dpi_path[1] = "ldpi";
1439         } else if (dpi >= MDPI_MIN && dpi <= MDPI_MAX) {
1440                 dpi_path[0] = "MDPI";
1441                 dpi_path[1] = "mdpi";
1442         } else if (dpi >= HDPI_MIN && dpi <= HDPI_MAX) {
1443                 dpi_path[0] = "HDPI";
1444                 dpi_path[1] = "hdpi";
1445         } else if (dpi >= XHDPI_MIN && dpi <= XHDPI_MAX) {
1446                 dpi_path[0] = "XHDPI";
1447                 dpi_path[1] = "xhdpi";
1448         } else if (dpi >= XXHDPI_MIN && dpi <= XXHDPI_MAX) {
1449                 dpi_path[0] = "XXHDPI";
1450                 dpi_path[1] = "xxhdpi";
1451         } else {
1452                 _LOGE("Unidentified dpi[%d]", dpi);
1453                 return -1;
1454         }
1455
1456         icon_filename = strrchr(orig_icon_path, '/');
1457         if (icon_filename == NULL)
1458                 return -1;
1459
1460         snprintf(icon_path,
1461                         strlen(orig_icon_path) - (strlen(icon_filename) - 1),
1462                         "%s", orig_icon_path);
1463         for (i = 0; i < 2; i++) {
1464                 ret = snprintf(modified_iconpath, BUFSIZE - 1, "%s/%s%s",
1465                                 icon_path, dpi_path[i], icon_filename);
1466                 if (ret < 0 || ret > BUFSIZE - 1) {
1467                         _LOGE("snprintf fail");
1468                         return -1;
1469                 }
1470                 if (access(modified_iconpath, F_OK) != -1) {
1471                         /* if exists, return modified icon path */
1472                         *new_icon_path = strdup(modified_iconpath);
1473                         return 0;
1474                 }
1475         }
1476
1477         return -1;
1478 }
1479
1480 static gint __compare_icon(gconstpointer a, gconstpointer b)
1481 {
1482         icon_x *icon = (icon_x *)a;
1483         char *icon_path;
1484
1485         if (icon->lang != NULL && strcasecmp(icon->lang, DEFAULT_LOCALE) != 0)
1486                 return -1;
1487
1488         if (icon->dpi != NULL)
1489                 return -1;
1490
1491         if (__check_icon_resolution(icon->text, &icon_path) == 0) {
1492                 free(icon->text);
1493                 icon->text = icon_path;
1494         }
1495
1496         return 0;
1497 }
1498
1499 static gint __compare_icon_with_lang(gconstpointer a, gconstpointer b)
1500 {
1501         icon_x *icon = (icon_x *)a;
1502         char *lang = (char *)b;
1503         char *icon_path;
1504
1505         if (icon->dpi != NULL)
1506                 return -1;
1507
1508         if (strcasecmp(icon->lang, lang) == 0) {
1509                 if (strcasecmp(icon->lang, DEFAULT_LOCALE) == 0) {
1510                         /* icon for no locale. check existance of
1511                          * folder-hierachied default icons
1512                          */
1513                         if (__check_icon_resolution(icon->text,
1514                                                 &icon_path) == 0) {
1515                                 free(icon->text);
1516                                 icon->text = icon_path;
1517                         }
1518                 }
1519                 return 0;
1520         }
1521
1522         return -1;
1523 }
1524
1525 static gint __compare_icon_with_dpi(gconstpointer a, gconstpointer b)
1526 {
1527         icon_x *icon = (icon_x *)a;
1528         int dpi = GPOINTER_TO_INT(b);
1529
1530         if (icon->lang != NULL && strcasecmp(icon->lang, DEFAULT_LOCALE) != 0)
1531                 return -1;
1532
1533         if (icon->dpi == NULL)
1534                 return -1;
1535
1536         if (__check_dpi(icon->dpi, dpi) == 0)
1537                 return 0;
1538
1539         return -1;
1540 }
1541
1542 static gint __compare_icon_with_lang_dpi(gconstpointer a, gconstpointer b)
1543 {
1544         int ret;
1545         icon_x *icon = (icon_x *)a;
1546         char *lang = (char *)b;
1547         int dpi = -1;
1548
1549         ret = system_info_get_platform_int(
1550                         "http://tizen.org/feature/screen.dpi", &dpi);
1551         if (ret != SYSTEM_INFO_ERROR_NONE)
1552                 return -1;
1553
1554         if (strcasecmp(icon->lang, lang) == 0 &&
1555                         __check_dpi(icon->dpi, dpi) == 0)
1556                 return 0;
1557
1558         return -1;
1559 }
1560
1561 static char *__find_icon(GList *icons, const char *lang)
1562 {
1563         GList *tmp;
1564         icon_x *icon;
1565         int dpi = 0;
1566         int ret;
1567
1568         /* first, find icon whose locale and dpi with given lang and
1569          * system's dpi has matched
1570          */
1571         tmp = g_list_find_custom(icons, lang,
1572                         (GCompareFunc)__compare_icon_with_lang_dpi);
1573         if (tmp != NULL) {
1574                 icon = (icon_x *)tmp->data;
1575                 return (char *)icon->text;
1576         }
1577
1578         /* if first has failed, find icon whose locale has matched */
1579         tmp = g_list_find_custom(icons, lang,
1580                         (GCompareFunc)__compare_icon_with_lang);
1581         if (tmp != NULL) {
1582                 icon = (icon_x *)tmp->data;
1583                 return (char *)icon->text;
1584         }
1585
1586         /* if second has failed, find icon whose dpi has matched with
1587          * system's dpi
1588          */
1589         ret = system_info_get_platform_int(
1590                         "http://tizen.org/feature/screen.dpi", &dpi);
1591         if (ret == SYSTEM_INFO_ERROR_NONE) {
1592                 tmp = g_list_find_custom(icons, GINT_TO_POINTER(dpi),
1593                                 (GCompareFunc)__compare_icon_with_dpi);
1594                 if (tmp != NULL) {
1595                         icon = (icon_x *)tmp->data;
1596                         return (char *)icon->text;
1597                 }
1598         }
1599
1600         /* last, find default icon marked as "No Locale" */
1601         tmp = g_list_find_custom(icons, NULL, (GCompareFunc)__compare_icon);
1602         if (tmp != NULL) {
1603                 icon = (icon_x *)tmp->data;
1604                 return (char *)icon->text;
1605         }
1606
1607         return NULL;
1608 }
1609
1610 static void __extract_data(const char *locale, GList *lbls, GList *lcns,
1611                 GList *icns, GList *dcns, GList *aths, char **label,
1612                 char **license, char **icon, char **description, char **author)
1613 {
1614         GList *tmp;
1615         label_x *lbl;
1616         license_x *lcn;
1617         description_x *dcn;
1618         author_x *ath;
1619
1620         for (tmp = lbls; tmp; tmp = tmp->next) {
1621                 lbl = (label_x *)tmp->data;
1622                 if (lbl == NULL)
1623                         continue;
1624                 if (lbl->lang) {
1625                         if (strcmp(lbl->lang, locale) == 0) {
1626                                 *label = (char *)lbl->text;
1627                                 break;
1628                         }
1629                 }
1630         }
1631         for (tmp = lcns; tmp; tmp = tmp->next) {
1632                 lcn = (license_x *)tmp->data;
1633                 if (lcn == NULL)
1634                         continue;
1635                 if (lcn->lang) {
1636                         if (strcmp(lcn->lang, locale) == 0) {
1637                                 *license = (char *)lcn->text;
1638                                 break;
1639                         }
1640                 }
1641         }
1642
1643         *icon = __find_icon(icns, locale);
1644
1645         for (tmp = dcns; tmp; tmp = tmp->next) {
1646                 dcn = (description_x *)tmp->data;
1647                 if (dcn == NULL)
1648                         continue;
1649                 if (dcn->lang) {
1650                         if (strcmp(dcn->lang, locale) == 0) {
1651                                 *description = (char *)dcn->text;
1652                                 break;
1653                         }
1654                 }
1655         }
1656         for (tmp = aths; tmp; tmp = tmp->next) {
1657                 ath = (author_x *)tmp->data;
1658                 if (ath == NULL)
1659                         continue;
1660                 if (ath->lang) {
1661                         if (strcmp(ath->lang, locale) == 0) {
1662                                 *author = (char *)ath->text;
1663                                 break;
1664                         }
1665                 }
1666         }
1667 }
1668
1669 static int __insert_app_localized_info(sqlite3 *db, application_x *app)
1670 {
1671         static const char query[] =
1672                 "INSERT INTO package_app_localized_info (app_id, app_locale,"
1673                 "  app_label, app_icon) "
1674                 "VALUES (?, ?, ?, ?)";
1675         int ret;
1676         sqlite3_stmt *stmt;
1677         int idx;
1678         GList *tmp;
1679         GList *locales;
1680         const char *locale;
1681         char *label;
1682         char *icon;
1683
1684         ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
1685         if (ret != SQLITE_OK) {
1686                 _LOGE("prepare failed: %s", sqlite3_errmsg(db));
1687                 return -1;
1688         }
1689
1690         locales = __create_locale_list(app->label, NULL, app->icon, NULL, NULL);
1691         for (tmp = locales; tmp; tmp = tmp->next) {
1692                 locale = (const char *)tmp->data;
1693                 label = NULL;
1694                 icon = NULL;
1695                 __extract_data(locale, app->label, NULL, app->icon, NULL, NULL,
1696                                 &label, NULL, &icon, NULL, NULL);
1697                 if (!label && !icon)
1698                         continue;
1699
1700                 idx = 1;
1701                 __BIND_TEXT(db, stmt, idx++, app->appid);
1702                 __BIND_TEXT(db, stmt, idx++, locale);
1703                 __BIND_TEXT(db, stmt, idx++, label);
1704                 __BIND_TEXT(db, stmt, idx++, icon);
1705
1706                 ret = sqlite3_step(stmt);
1707                 if (ret != SQLITE_DONE) {
1708                         _LOGE("step failed: %s", sqlite3_errmsg(db));
1709                         g_list_free(locales);
1710                         sqlite3_finalize(stmt);
1711                         return -1;
1712                 }
1713
1714                 sqlite3_reset(stmt);
1715
1716                 if (strcasecmp(app->mainapp, "true") == 0) {
1717                         if (__insert_mainapp_localized_info(db, app, locale,
1718                                                 label, icon))
1719                                 _LOGE("insert mainapp localized info failed");
1720                 }
1721         }
1722
1723         g_list_free(locales);
1724         sqlite3_finalize(stmt);
1725
1726         return 0;
1727 }
1728
1729 static int __insert_app_res_control(sqlite3 *db, application_x *app)
1730 {
1731         static const char query[] =
1732                 "INSERT INTO package_app_res_control (app_id, res_type,"
1733                 "  min_res_version, max_res_version, auto_close) "
1734                 "VALUES (?, ?, ?, ?, ?)";
1735         int ret;
1736         sqlite3_stmt *stmt;
1737         int idx;
1738         GList *tmp;
1739         res_control_x *rc;
1740
1741         if (app->res_control == NULL)
1742                 return 0;
1743
1744         ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
1745         if (ret != SQLITE_OK) {
1746                 _LOGE("prepare failed: %s", sqlite3_errmsg(db));
1747                 return -1;
1748         }
1749
1750         for (tmp = app->res_control; tmp; tmp = tmp->next) {
1751                 rc = (res_control_x *)tmp->data;
1752                 if (rc == NULL)
1753                         continue;
1754                 idx = 1;
1755                 __BIND_TEXT(db, stmt, idx++, app->appid);
1756                 __BIND_TEXT(db, stmt, idx++, rc->res_type);
1757                 __BIND_TEXT(db, stmt, idx++, rc->min_res_version);
1758                 __BIND_TEXT(db, stmt, idx++, rc->max_res_version);
1759                 __BIND_TEXT(db, stmt, idx++, rc->auto_close);
1760
1761                 ret = sqlite3_step(stmt);
1762                 if (ret != SQLITE_DONE) {
1763                         _LOGE("step failed: %s", sqlite3_errmsg(db));
1764                         sqlite3_finalize(stmt);
1765                         return -1;
1766                 }
1767
1768                 sqlite3_reset(stmt);
1769         }
1770
1771         sqlite3_finalize(stmt);
1772
1773         return 0;
1774 }
1775
1776 static int __insert_package_privilege_info(sqlite3 *db, manifest_x *mfx)
1777 {
1778         static const char query[] =
1779                 "INSERT INTO package_privilege_info (package, privilege, type) "
1780                 "VALUES (?, ?, ?)";
1781         int ret;
1782         sqlite3_stmt *stmt;
1783         int idx;
1784         GList *tmp;
1785         privilege_x *priv;
1786
1787         ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
1788         if (ret != SQLITE_OK) {
1789                 _LOGE("prepare failed: %s", sqlite3_errmsg(db));
1790                 return -1;
1791         }
1792
1793         for (tmp = mfx->privileges; tmp; tmp = tmp->next) {
1794                 priv = (privilege_x *)tmp->data;
1795                 if (priv == NULL)
1796                         continue;
1797
1798                 idx = 1;
1799                 __BIND_TEXT(db, stmt, idx++, mfx->package);
1800                 __BIND_TEXT(db, stmt, idx++, priv->value);
1801                 __BIND_TEXT(db, stmt, idx++, priv->type);
1802
1803                 ret = sqlite3_step(stmt);
1804                 if (ret != SQLITE_DONE) {
1805                         _LOGE("step failed: %s", sqlite3_errmsg(db));
1806                         sqlite3_finalize(stmt);
1807                         return -1;
1808                 }
1809                 sqlite3_reset(stmt);
1810         }
1811
1812         sqlite3_finalize(stmt);
1813
1814         return 0;
1815 }
1816
1817 static int __insert_app_data_control_privilege_info(sqlite3 *db,
1818                 datacontrol_x *datacontrol)
1819 {
1820         static const char query[] =
1821                 "INSERT INTO package_app_data_control_privilege (providerid,"
1822                 "  privilege, type) VALUES (?, ?, ?)";
1823
1824         int ret;
1825         sqlite3_stmt *stmt;
1826         int idx;
1827         GList *privileges;
1828         char *priv;
1829
1830         if (datacontrol == NULL)
1831                 return 0;
1832
1833         ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
1834         if (ret != SQLITE_OK) {
1835                 _LOGE("prepare failed: %s", sqlite3_errmsg(db));
1836                 return -1;
1837         }
1838
1839         for (privileges = datacontrol->privileges; privileges;
1840                         privileges = privileges->next) {
1841                 priv = (char *)privileges->data;
1842                 if (priv == NULL)
1843                         continue;
1844
1845                 idx = 1;
1846                 __BIND_TEXT(db, stmt, idx++, datacontrol->providerid);
1847                 __BIND_TEXT(db, stmt, idx++, priv);
1848                 __BIND_TEXT(db, stmt, idx++, datacontrol->type);
1849
1850                 ret = sqlite3_step(stmt);
1851                 if (ret != SQLITE_DONE) {
1852                         _LOGE("step failed: %s", sqlite3_errmsg(db));
1853                         sqlite3_finalize(stmt);
1854                         return -1;
1855                 }
1856
1857                 sqlite3_reset(stmt);
1858         }
1859
1860         sqlite3_finalize(stmt);
1861         return 0;
1862 }
1863
1864 static int __insert_datacontrol_info(sqlite3 *db, application_x *app)
1865 {
1866         static const char query[] =
1867                 "INSERT INTO package_app_data_control (app_id, providerid,"
1868                 "  access, type, trusted) VALUES (?, ?, ?, ?, ?)";
1869         int ret;
1870         sqlite3_stmt *stmt;
1871         int idx;
1872         GList *tmp;
1873         datacontrol_x *dc;
1874
1875         if (app->datacontrol == NULL)
1876                 return 0;
1877
1878         ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
1879         if (ret != SQLITE_OK) {
1880                 _LOGE("prepare failed: %s", sqlite3_errmsg(db));
1881                 return -1;
1882         }
1883
1884         for (tmp = app->datacontrol; tmp; tmp = tmp->next) {
1885                 dc = (datacontrol_x *)tmp->data;
1886                 if (dc == NULL)
1887                         continue;
1888                 idx = 1;
1889                 __BIND_TEXT(db, stmt, idx++, app->appid);
1890                 __BIND_TEXT(db, stmt, idx++, dc->providerid);
1891                 __BIND_TEXT(db, stmt, idx++, dc->access);
1892                 __BIND_TEXT(db, stmt, idx++, dc->type);
1893                 __BIND_TEXT(db, stmt, idx++, dc->trusted);
1894
1895                 ret = sqlite3_step(stmt);
1896                 if (ret != SQLITE_DONE) {
1897                         _LOGE("step failed: %s", sqlite3_errmsg(db));
1898                         sqlite3_finalize(stmt);
1899                         return -1;
1900                 }
1901
1902                 if (dc->privileges &&
1903                                 __insert_app_data_control_privilege_info(
1904                                                 db, dc)) {
1905                         sqlite3_finalize(stmt);
1906                         return -1;
1907                 }
1908
1909                 sqlite3_reset(stmt);
1910         }
1911
1912         sqlite3_finalize(stmt);
1913
1914         return 0;
1915 }
1916
1917 static int __insert_category_info(sqlite3 *db, application_x *app)
1918 {
1919         static const char query[] =
1920                 "INSERT INTO package_app_app_category (app_id, category) "
1921                 "VALUES (?, ?)";
1922         int ret;
1923         sqlite3_stmt *stmt;
1924         int idx;
1925         GList *tmp;
1926         const char *category;
1927
1928         if (app->category == NULL)
1929                 return 0;
1930
1931         ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
1932         if (ret != SQLITE_OK) {
1933                 _LOGE("prepare failed: %s", sqlite3_errmsg(db));
1934                 return -1;
1935         }
1936
1937         for (tmp = app->category; tmp; tmp = tmp->next) {
1938                 category = (const char *)tmp->data;
1939                 if (category == NULL)
1940                         continue;
1941                 idx = 1;
1942                 __BIND_TEXT(db, stmt, idx++, app->appid);
1943                 __BIND_TEXT(db, stmt, idx++, category);
1944
1945                 ret = sqlite3_step(stmt);
1946                 if (ret != SQLITE_DONE) {
1947                         _LOGE("step failed: %s", sqlite3_errmsg(db));
1948                         sqlite3_finalize(stmt);
1949                         return -1;
1950                 }
1951
1952                 sqlite3_reset(stmt);
1953         }
1954
1955         sqlite3_finalize(stmt);
1956
1957         return 0;
1958 }
1959
1960 static int __insert_metadata_info(sqlite3 *db, application_x *app)
1961 {
1962         static const char query[] =
1963                 "INSERT INTO package_app_app_metadata (app_id,"
1964                 "  md_key, md_value) VALUES (?, ?, ?)";
1965         int ret;
1966         sqlite3_stmt *stmt;
1967         int idx;
1968         GList *tmp;
1969         metadata_x *md;
1970
1971         if (app->metadata == NULL)
1972                 return 0;
1973
1974         ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
1975         if (ret != SQLITE_OK) {
1976                 _LOGE("prepare failed: %s", sqlite3_errmsg(db));
1977                 return -1;
1978         }
1979
1980         for (tmp = app->metadata; tmp; tmp = tmp->next) {
1981                 md = (metadata_x *)tmp->data;
1982                 if (md == NULL)
1983                         continue;
1984                 idx = 1;
1985                 __BIND_TEXT(db, stmt, idx++, app->appid);
1986                 __BIND_TEXT(db, stmt, idx++, md->key);
1987                 __BIND_TEXT(db, stmt, idx++, md->value);
1988
1989                 ret = sqlite3_step(stmt);
1990                 if (ret != SQLITE_DONE) {
1991                         _LOGE("step failed: %s", sqlite3_errmsg(db));
1992                         sqlite3_finalize(stmt);
1993                         return -1;
1994                 }
1995
1996                 sqlite3_reset(stmt);
1997         }
1998
1999         sqlite3_finalize(stmt);
2000
2001         return 0;
2002 }
2003
2004 static int __insert_appcontrol_privilege_info(sqlite3 *db, const char *appid,
2005                 appcontrol_x *ac)
2006 {
2007         static const char query[] =
2008                 "INSERT INTO package_app_app_control_privilege (app_id,"
2009                 "  app_control, privilege) VALUES (?, ?, ?)";
2010         int ret;
2011         sqlite3_stmt *stmt;
2012         int idx;
2013         char app_control[BUFSIZE];
2014         GList *tmp;
2015         char *privilege;
2016
2017         if (ac == NULL)
2018                 return 0;
2019
2020         ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
2021         if (ret != SQLITE_OK) {
2022                 _LOGE("prepare failed: %s", sqlite3_errmsg(db));
2023                 return -1;
2024         }
2025
2026         for (tmp = ac->privileges; tmp; tmp = tmp->next) {
2027                 privilege = (char *)tmp->data;
2028                 if (privilege == NULL || !strlen(privilege))
2029                         continue;
2030
2031                 idx = 1;
2032                 snprintf(app_control, sizeof(app_control), "%s|%s|%s",
2033                                 ac->operation ? (strlen(ac->operation) > 0 ?
2034                                         ac->operation : "NULL") : "NULL",
2035                                 ac->uri ? (strlen(ac->uri) > 0 ?
2036                                         ac->uri : "NULL") : "NULL",
2037                                 ac->mime ? (strlen(ac->mime) > 0 ?
2038                                         ac->mime : "NULL") : "NULL");
2039                 __BIND_TEXT(db, stmt, idx++, appid);
2040                 __BIND_TEXT(db, stmt, idx++, app_control);
2041                 __BIND_TEXT(db, stmt, idx++, privilege);
2042
2043                 ret = sqlite3_step(stmt);
2044                 if (ret != SQLITE_DONE) {
2045                         _LOGE("step failed: %s", sqlite3_errmsg(db));
2046                         sqlite3_finalize(stmt);
2047                         return -1;
2048                 }
2049
2050                 sqlite3_reset(stmt);
2051         }
2052
2053         sqlite3_finalize(stmt);
2054
2055         return 0;
2056 }
2057
2058 static int __insert_appcontrol_info(sqlite3 *db, application_x *app)
2059 {
2060         static const char query[] =
2061                 "INSERT INTO package_app_app_control (app_id, app_control,"
2062                 "  visibility, app_control_id) "
2063                 "VALUES (?, ?, ?, ?)";
2064         int ret;
2065         sqlite3_stmt *stmt;
2066         int idx;
2067         char app_control[BUFSIZE];
2068         GList *tmp;
2069         appcontrol_x *ac;
2070
2071         if (app->appcontrol == NULL)
2072                 return 0;
2073
2074         ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
2075         if (ret != SQLITE_OK) {
2076                 _LOGE("prepare failed: %s", sqlite3_errmsg(db));
2077                 return -1;
2078         }
2079
2080         for (tmp = app->appcontrol; tmp; tmp = tmp->next) {
2081                 ac = (appcontrol_x *)tmp->data;
2082                 if (ac == NULL)
2083                         continue;
2084                 idx = 1;
2085                 snprintf(app_control, sizeof(app_control), "%s|%s|%s",
2086                                 ac->operation ? (strlen(ac->operation) > 0 ?
2087                                         ac->operation : "NULL") : "NULL",
2088                                 ac->uri ? (strlen(ac->uri) > 0 ?
2089                                         ac->uri : "NULL") : "NULL",
2090                                 ac->mime ? (strlen(ac->mime) > 0 ?
2091                                         ac->mime : "NULL") : "NULL");
2092                 __BIND_TEXT(db, stmt, idx++, app->appid);
2093                 __BIND_TEXT(db, stmt, idx++, app_control);
2094                 __BIND_TEXT(db, stmt, idx++, ac->visibility);
2095                 __BIND_TEXT(db, stmt, idx++, ac->id);
2096
2097                 ret = sqlite3_step(stmt);
2098                 if (ret != SQLITE_DONE) {
2099                         _LOGE("step failed: %s", sqlite3_errmsg(db));
2100                         sqlite3_finalize(stmt);
2101                         return -1;
2102                 }
2103
2104                 if (__insert_appcontrol_privilege_info(db, app->appid, ac)) {
2105                         sqlite3_finalize(stmt);
2106                         return -1;
2107                 }
2108
2109                 sqlite3_reset(stmt);
2110         }
2111
2112         sqlite3_finalize(stmt);
2113
2114         return 0;
2115 }
2116
2117 static const char *__get_bool(char *value, bool is_true)
2118 {
2119         if (value != NULL) {
2120                 if (!strcmp(value, ""))
2121                         return (is_true) ? "true" : "false";
2122                 return value;
2123         }
2124
2125         return (is_true) ? "true" : "false";
2126 }
2127
2128 #define EFFECTIVE_APPID_KEY "http://tizen.org/metadata/effective-appid"
2129 static const char *__find_effective_appid(GList *metadata_list)
2130 {
2131         GList *tmp;
2132         metadata_x *md;
2133
2134         for (tmp = metadata_list; tmp; tmp = tmp->next) {
2135                 md = (metadata_x *)tmp->data;
2136                 if (md == NULL || md->key == NULL)
2137                         continue;
2138
2139                 if (strcmp(md->key, EFFECTIVE_APPID_KEY) == 0) {
2140                         if (md->value)
2141                                 return md->value;
2142                 }
2143         }
2144
2145         return NULL;
2146 }
2147
2148 static int __convert_background_category(GList *category_list)
2149 {
2150         int ret = 0;
2151         GList *tmp;
2152         char *category_data;
2153
2154         if (category_list == NULL)
2155                 return 0;
2156
2157         for (tmp = category_list; tmp; tmp = tmp->next) {
2158                 category_data = (char *)tmp->data;
2159                 if (category_data == NULL)
2160                         continue;
2161                 if (!strcmp(category_data, APP_BG_CATEGORY_MEDIA_STR))
2162                         ret |= APP_BG_CATEGORY_MEDIA_VAL;
2163                 else if (!strcmp(category_data, APP_BG_CATEGORY_DOWNLOAD_STR))
2164                         ret |= APP_BG_CATEGORY_DOWNLOAD_VAL;
2165                 else if (!strcmp(category_data, APP_BG_CATEGORY_BGNETWORK_STR))
2166                         ret |= APP_BG_CATEGORY_BGNETWORK_VAL;
2167                 else if (!strcmp(category_data, APP_BG_CATEGORY_LOCATION_STR))
2168                         ret |= APP_BG_CATEGORY_LOCATION_VAL;
2169                 else if (!strcmp(category_data, APP_BG_CATEGORY_SENSOR_STR))
2170                         ret |= APP_BG_CATEGORY_SENSOR_VAL;
2171                 else if (!strcmp(category_data, APP_BG_CATEGORY_IOTCOMM_STR))
2172                         ret |= APP_BG_CATEGORY_IOTCOMM_VAL;
2173                 else if (!strcmp(category_data, APP_BG_CATEGORY_SYSTEM))
2174                         ret |= APP_BG_CATEGORY_SYSTEM_VAL;
2175                 else
2176                         _LOGE("Unidentified category [%s]", category_data);
2177         }
2178
2179         return ret;
2180 }
2181
2182 static int __insert_package_res_info_allowed_package(sqlite3 *db,
2183                 const char *pkgid, GList *rap_list)
2184 {
2185         static const char query[] =
2186                 "INSERT INTO package_res_allowed_package (package,"
2187                 "  allowed_package, required_privilege) VALUES (?, ?, ?)";
2188         int ret;
2189         int idx;
2190         sqlite3_stmt *stmt;
2191         GList *tmp;
2192         GList *priv_list;
2193         res_allowed_package_x *rap;
2194
2195         if (rap_list == NULL)
2196                 return 0;
2197
2198         ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
2199         if (ret != SQLITE_OK) {
2200                 _LOGE("prepare failed: %s", sqlite3_errmsg(db));
2201                 return -1;
2202         }
2203
2204         for (tmp = rap_list; tmp; tmp = tmp->next) {
2205                 rap = (res_allowed_package_x *)tmp->data;
2206                 if (rap == NULL)
2207                         continue;
2208
2209                 if (!rap->required_privileges) {
2210                         idx = 1;
2211                         __BIND_TEXT(db, stmt, idx++, pkgid);
2212                         __BIND_TEXT(db, stmt, idx++, rap->allowed_package);
2213                         __BIND_TEXT(db, stmt, idx++, NULL);
2214
2215                         ret = sqlite3_step(stmt);
2216                         if (ret != SQLITE_DONE) {
2217                                 _LOGE("step failed: %s", sqlite3_errmsg(db));
2218                                 sqlite3_finalize(stmt);
2219                                 return -1;
2220                         }
2221
2222                         sqlite3_reset(stmt);
2223                         continue;
2224                 }
2225
2226                 for (priv_list = rap->required_privileges; priv_list;
2227                                 priv_list = priv_list->next) {
2228                         idx = 1;
2229                         __BIND_TEXT(db, stmt, idx++, pkgid);
2230                         __BIND_TEXT(db, stmt, idx++, rap->allowed_package);
2231                         __BIND_TEXT(db, stmt, idx++, (char *)priv_list->data);
2232
2233                         ret = sqlite3_step(stmt);
2234                         if (ret != SQLITE_DONE) {
2235                                 _LOGE("step failed: %s", sqlite3_errmsg(db));
2236                                 sqlite3_finalize(stmt);
2237                                 return -1;
2238                         }
2239
2240                         sqlite3_reset(stmt);
2241                 }
2242         }
2243
2244         sqlite3_finalize(stmt);
2245
2246         return 0;
2247 }
2248
2249 static int __insert_package_res_info(sqlite3 *db, manifest_x *mfx)
2250 {
2251         static const char query[] =
2252                 "INSERT INTO package_res_info (package, res_type,"
2253                 "  res_version) VALUES (?, ?, ?)";
2254         int ret;
2255         sqlite3_stmt *stmt;
2256         int idx;
2257
2258         if (mfx->res_type == NULL || mfx->res_version == NULL)
2259                 return 0;
2260
2261         ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
2262         if (ret != SQLITE_OK) {
2263                 _LOGE("prepare failed: %s", sqlite3_errmsg(db));
2264                 return -1;
2265         }
2266
2267         idx = 1;
2268         __BIND_TEXT(db, stmt, idx++, mfx->package);
2269         __BIND_TEXT(db, stmt, idx++, mfx->res_type);
2270         __BIND_TEXT(db, stmt, idx++, mfx->res_version);
2271
2272         ret = sqlite3_step(stmt);
2273         if (ret != SQLITE_DONE) {
2274                 _LOGE("step failed: %s", sqlite3_errmsg(db));
2275                 sqlite3_finalize(stmt);
2276                 return -1;
2277         }
2278
2279         if (__insert_package_res_info_allowed_package(db, mfx->package,
2280                         mfx->res_allowed_packages) < 0) {
2281                 sqlite3_finalize(stmt);
2282                 return -1;
2283         }
2284
2285         sqlite3_finalize(stmt);
2286
2287         return 0;
2288 }
2289
2290 static int __insert_application_info(sqlite3 *db, manifest_x *mfx)
2291 {
2292         static const char query[] =
2293                 "INSERT INTO package_app_info (app_id, app_component,"
2294                 "  app_exec, app_nodisplay, app_type, app_onboot, app_multiple,"
2295                 "  app_autorestart, app_taskmanage, app_hwacceleration,"
2296                 "  app_screenreader, app_mainapp, app_recentimage,"
2297                 "  app_launchcondition, app_indicatordisplay, app_portraitimg,"
2298                 "  app_landscapeimg, app_guestmodevisibility,"
2299                 "  app_permissiontype, app_preload, app_submode,"
2300                 "  app_submode_mainid, app_installed_storage, app_process_pool,"
2301                 "  app_launch_mode, app_ui_gadget, app_support_mode,"
2302                 "  app_support_disable, component_type, package, app_tep_name,"
2303                 "  app_zip_mount_file, app_background_category,"
2304                 "  app_package_type, app_root_path, app_api_version,"
2305                 "  app_effective_appid, app_splash_screen_display,"
2306                 "  app_package_system, app_removable,"
2307                 "  app_package_installed_time, app_support_ambient,"
2308                 "  app_external_path, app_setup_appid, light_user_switch_mode) "
2309                 "VALUES (?, ?, "
2310                 "  ?, LOWER(?), ?, LOWER(?), LOWER(?),"
2311                 "  LOWER(?), LOWER(?), ?,"
2312                 "  ?, LOWER(?), ?,"
2313                 "  ?, LOWER(?), ?,"
2314                 "  ?, LOWER(?),"
2315                 "  ?, LOWER(?), LOWER(?),"
2316                 "  ?, ?, LOWER(?),"
2317                 "  COALESCE(?, 'single'), LOWER(?), ?,"
2318                 "  LOWER(?), ?, ?, ?,"
2319                 "  ?, ?,"
2320                 "  ?, ?, ?,"
2321                 "  ?, LOWER(?),"
2322                 "  LOWER(?), LOWER(?),"
2323                 "  ?, LOWER(?),"
2324                 "  ?, ?, ?)";
2325         int ret;
2326         sqlite3_stmt *stmt;
2327         int idx;
2328         GList *tmp;
2329         application_x *app;
2330         int bg_category;
2331         const char *effective_appid;
2332         GList *ss_list;
2333
2334         ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
2335         if (ret != SQLITE_OK) {
2336                 _LOGE("prepare failed: %s", sqlite3_errmsg(db));
2337                 return -1;
2338         }
2339
2340         for (tmp = mfx->application; tmp; tmp = tmp->next) {
2341                 app = (application_x *)tmp->data;
2342                 if (app == NULL)
2343                         continue;
2344
2345                 bg_category = __convert_background_category(
2346                                 app->background_category);
2347                 effective_appid = __find_effective_appid(app->metadata);
2348
2349                 idx = 1;
2350                 __BIND_TEXT(db, stmt, idx++, app->appid);
2351                 __BIND_TEXT(db, stmt, idx++, app->component_type);
2352                 __BIND_TEXT(db, stmt, idx++, app->exec);
2353                 __BIND_TEXT(db, stmt, idx++, __get_bool(app->nodisplay, false));
2354                 __BIND_TEXT(db, stmt, idx++, app->type);
2355                 __BIND_TEXT(db, stmt, idx++, __get_bool(app->onboot, false));
2356                 __BIND_TEXT(db, stmt, idx++, __get_bool(app->multiple, false));
2357                 __BIND_TEXT(db, stmt, idx++,
2358                                 __get_bool(app->autorestart, false));
2359                 __BIND_TEXT(db, stmt, idx++,
2360                                 __get_bool(app->taskmanage, false));
2361                 __BIND_TEXT(db, stmt, idx++, app->hwacceleration);
2362                 __BIND_TEXT(db, stmt, idx++, app->screenreader);
2363                 __BIND_TEXT(db, stmt, idx++, __get_bool(app->mainapp, false));
2364                 __BIND_TEXT(db, stmt, idx++, app->recentimage);
2365                 __BIND_TEXT(db, stmt, idx++, app->launchcondition);
2366                 __BIND_TEXT(db, stmt, idx++,
2367                                 __get_bool(app->indicatordisplay, true));
2368                 __BIND_TEXT(db, stmt, idx++, app->portraitimg);
2369                 __BIND_TEXT(db, stmt, idx++, app->landscapeimg);
2370                 __BIND_TEXT(db, stmt, idx++,
2371                                 __get_bool(app->guestmode_visibility, true));
2372                 __BIND_TEXT(db, stmt, idx++, app->permission_type);
2373                 __BIND_TEXT(db, stmt, idx++, __get_bool(mfx->preload, false));
2374                 __BIND_TEXT(db, stmt, idx++, __get_bool(app->submode, false));
2375                 __BIND_TEXT(db, stmt, idx++, app->submode_mainid);
2376                 __BIND_TEXT(db, stmt, idx++, mfx->installed_storage);
2377                 __BIND_TEXT(db, stmt, idx++,
2378                                 __get_bool(app->process_pool, false));
2379                 __BIND_TEXT(db, stmt, idx++, app->launch_mode);
2380                 __BIND_TEXT(db, stmt, idx++, __get_bool(app->ui_gadget, false));
2381                 __BIND_TEXT(db, stmt, idx++,
2382                                 app->support_mode ? app->support_mode : "0");
2383                 __BIND_TEXT(db, stmt, idx++,
2384                                 __get_bool(mfx->support_disable, false));
2385                 __BIND_TEXT(db, stmt, idx++, app->component_type);
2386                 __BIND_TEXT(db, stmt, idx++, mfx->package);
2387                 __BIND_TEXT(db, stmt, idx++, mfx->tep_name);
2388                 __BIND_TEXT(db, stmt, idx++, mfx->zip_mount_file);
2389                 __BIND_INT(db, stmt, idx++, bg_category);
2390                 __BIND_TEXT(db, stmt, idx++, mfx->type ? mfx->type : "tpk");
2391                 __BIND_TEXT(db, stmt, idx++, mfx->root_path);
2392                 __BIND_TEXT(db, stmt, idx++, app->api_version);
2393                 __BIND_TEXT(db, stmt, idx++, effective_appid);
2394                 __BIND_TEXT(db, stmt, idx++,
2395                                 __get_bool(app->splash_screen_display, true));
2396                 __BIND_TEXT(db, stmt, idx++, __get_bool(mfx->system, false));
2397                 __BIND_TEXT(db, stmt, idx++, __get_bool(mfx->removable, false));
2398                 __BIND_TEXT(db, stmt, idx++, mfx->installed_time);
2399                 __BIND_TEXT(db, stmt, idx++,
2400                                 __get_bool(app->support_ambient, false));
2401                 __BIND_TEXT(db, stmt, idx++, mfx->external_path);
2402                 __BIND_TEXT(db, stmt, idx++, app->setup_appid);
2403                 __BIND_TEXT(db, stmt, idx++, mfx->light_user_switch_mode);
2404
2405                 ret = sqlite3_step(stmt);
2406                 if (ret != SQLITE_DONE) {
2407                         _LOGE("step failed: %s", sqlite3_errmsg(db));
2408                         sqlite3_finalize(stmt);
2409                         return -1;
2410                 }
2411
2412                 sqlite3_reset(stmt);
2413
2414                 if (__insert_appcontrol_info(db, app)) {
2415                         sqlite3_finalize(stmt);
2416                         return -1;
2417                 }
2418                 if (__insert_category_info(db, app)) {
2419                         sqlite3_finalize(stmt);
2420                         return -1;
2421                 }
2422                 if (__insert_metadata_info(db, app)) {
2423                         sqlite3_finalize(stmt);
2424                         return -1;
2425                 }
2426                 if (__insert_datacontrol_info(db, app)) {
2427                         sqlite3_finalize(stmt);
2428                         return -1;
2429                 }
2430                 ss_list = __find_splashscreens(app->splashscreens);
2431                 if (__insert_splashscreen_info(db, app, ss_list)) {
2432                         g_list_free(ss_list);
2433                         sqlite3_finalize(stmt);
2434                         return -1;
2435                 }
2436                 g_list_free(ss_list);
2437                 if (__insert_app_localized_info(db, app)) {
2438                         sqlite3_finalize(stmt);
2439                         return -1;
2440                 }
2441                 if (__insert_app_res_control(db, app)) {
2442                         sqlite3_finalize(stmt);
2443                         return -1;
2444                 }
2445         }
2446
2447         sqlite3_finalize(stmt);
2448
2449         return 0;
2450 }
2451
2452 static int __insert_package_update_info(sqlite3 *db, manifest_x *mfx)
2453 {
2454         static const char query[] =
2455                 "INSERT INTO package_update_info (package, update_version) "
2456                 "VALUES (?, ?)";
2457         int ret;
2458         int idx;
2459         sqlite3_stmt *stmt;
2460
2461         ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
2462         if (ret != SQLITE_OK) {
2463                 _LOGE("prepare failed: %s", sqlite3_errmsg(db));
2464                 return -1;
2465         }
2466
2467         idx = 1;
2468         __BIND_TEXT(db, stmt, idx++, mfx->package);
2469         __BIND_TEXT(db, stmt, idx, mfx->version);
2470         ret = sqlite3_step(stmt);
2471         if (ret != SQLITE_DONE) {
2472                 _LOGE("step failed: %s", sqlite3_errmsg(db));
2473                 sqlite3_finalize(stmt);
2474                 return -1;
2475         }
2476         sqlite3_finalize(stmt);
2477
2478         return 0;
2479 }
2480
2481 static int __insert_package_localized_info(sqlite3 *db, manifest_x *mfx)
2482 {
2483         static const char query[] =
2484                 "INSERT INTO package_localized_info (package, package_locale,"
2485                 "  package_label, package_icon, package_description,"
2486                 "  package_license, package_author) "
2487                 "VALUES (?, ?, ?, ?, ?, ?, ?)";
2488         int ret;
2489         sqlite3_stmt *stmt;
2490         int idx;
2491         GList *tmp;
2492         GList *locales;
2493         const char *locale;
2494         char *label;
2495         char *icon;
2496         char *description;
2497         char *license;
2498         char *author;
2499
2500         ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
2501         if (ret != SQLITE_OK) {
2502                 _LOGE("prepare failed: %s", sqlite3_errmsg(db));
2503                 return -1;
2504         }
2505
2506         locales = __create_locale_list(mfx->label, mfx->license, mfx->icon,
2507                         mfx->description, mfx->author);
2508         for (tmp = locales; tmp; tmp = tmp->next) {
2509                 locale = (const char *)tmp->data;
2510                 label = NULL;
2511                 icon = NULL;
2512                 description = NULL;
2513                 license = NULL;
2514                 author = NULL;
2515                 __extract_data(locale, mfx->label, mfx->license, mfx->icon,
2516                                 mfx->description, mfx->author,
2517                                 &label, &license, &icon, &description, &author);
2518                 if (!label && !license && !icon && !description && !author)
2519                         continue;
2520
2521                 idx = 1;
2522                 __BIND_TEXT(db, stmt, idx++, mfx->package);
2523                 __BIND_TEXT(db, stmt, idx++, locale);
2524                 __BIND_TEXT(db, stmt, idx++, label);
2525                 __BIND_TEXT(db, stmt, idx++, icon);
2526                 __BIND_TEXT(db, stmt, idx++, description);
2527                 __BIND_TEXT(db, stmt, idx++, license);
2528                 __BIND_TEXT(db, stmt, idx++, author);
2529
2530                 ret = sqlite3_step(stmt);
2531                 if (ret != SQLITE_DONE) {
2532                         _LOGE("step failed: %s", sqlite3_errmsg(db));
2533                         g_list_free(locales);
2534                         sqlite3_finalize(stmt);
2535                         return -1;
2536                 }
2537
2538                 sqlite3_reset(stmt);
2539         }
2540
2541         g_list_free(locales);
2542         sqlite3_finalize(stmt);
2543
2544         return 0;
2545 }
2546
2547 static int __insert_package_info(sqlite3 *db, manifest_x *mfx)
2548 {
2549         static const char query[] =
2550                 "INSERT INTO package_info (package, package_type,"
2551                 "  package_version, package_api_version, package_tep_name,"
2552                 "  package_zip_mount_file, install_location, package_size,"
2553                 "  package_removable, package_preload, package_readonly,"
2554                 "  package_update, package_appsetting, package_nodisplay,"
2555                 "  package_system, author_name, author_email, author_href,"
2556                 "  installed_time, installed_storage, storeclient_id,"
2557                 "  mainapp_id, package_url, root_path, external_path,"
2558                 "  csc_path, package_support_mode, package_support_disable,"
2559                 "  light_user_switch_mode)"
2560                 "VALUES (?, ?,"
2561                 "  ?, ?, ?,"
2562                 "  ?, ?, ?,"
2563                 "  LOWER(?), LOWER(?), LOWER(?),"
2564                 "  LOWER(?), LOWER(?), LOWER(?),"
2565                 "  LOWER(?), ?, ?, ?,"
2566                 "  ?, ?, ?,"
2567                 "  ?, ?, ?, ?,"
2568                 "  ?, ?, LOWER(?), ?)";
2569         int ret;
2570         sqlite3_stmt *stmt;
2571         int idx = 1;
2572         const char *author_name = NULL;
2573         const char *author_email = NULL;
2574         const char *author_href = NULL;
2575
2576         ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
2577         if (ret != SQLITE_OK) {
2578                 _LOGE("prepare failed: %s", sqlite3_errmsg(db));
2579                 return -1;
2580         }
2581
2582         if (mfx->author && mfx->author->data) {
2583                 author_name = ((author_x *)mfx->author->data)->text;
2584                 author_email = ((author_x *)mfx->author->data)->email;
2585                 author_href = ((author_x *)mfx->author->data)->href;
2586         }
2587
2588         __BIND_TEXT(db, stmt, idx++, mfx->package);
2589         __BIND_TEXT(db, stmt, idx++, mfx->type);
2590         __BIND_TEXT(db, stmt, idx++, mfx->version);
2591         __BIND_TEXT(db, stmt, idx++, mfx->api_version);
2592         __BIND_TEXT(db, stmt, idx++, mfx->tep_name);
2593         __BIND_TEXT(db, stmt, idx++, mfx->zip_mount_file);
2594         __BIND_TEXT(db, stmt, idx++, mfx->installlocation);
2595         __BIND_TEXT(db, stmt, idx++, mfx->package_size);
2596         __BIND_TEXT(db, stmt, idx++, __get_bool(mfx->removable, true));
2597         __BIND_TEXT(db, stmt, idx++, __get_bool(mfx->preload, false));
2598         __BIND_TEXT(db, stmt, idx++, __get_bool(mfx->readonly, false));
2599         __BIND_TEXT(db, stmt, idx++, __get_bool(mfx->update, false));
2600         __BIND_TEXT(db, stmt, idx++, __get_bool(mfx->appsetting, false));
2601         __BIND_TEXT(db, stmt, idx++, __get_bool(mfx->nodisplay_setting, false));
2602         __BIND_TEXT(db, stmt, idx++, __get_bool(mfx->system, false));
2603         __BIND_TEXT(db, stmt, idx++, author_name);
2604         __BIND_TEXT(db, stmt, idx++, author_email);
2605         __BIND_TEXT(db, stmt, idx++, author_href);
2606         __BIND_TEXT(db, stmt, idx++, mfx->installed_time);
2607         __BIND_TEXT(db, stmt, idx++, mfx->installed_storage);
2608         __BIND_TEXT(db, stmt, idx++, mfx->storeclient_id);
2609         __BIND_TEXT(db, stmt, idx++, mfx->mainapp_id);
2610         __BIND_TEXT(db, stmt, idx++, mfx->package_url);
2611         __BIND_TEXT(db, stmt, idx++, mfx->root_path);
2612         __BIND_TEXT(db, stmt, idx++, mfx->external_path);
2613         __BIND_TEXT(db, stmt, idx++, mfx->csc_path);
2614         __BIND_TEXT(db, stmt, idx++,
2615                         mfx->support_mode ? mfx->support_mode : "0");
2616         __BIND_TEXT(db, stmt, idx++, __get_bool(mfx->support_disable, false));
2617         __BIND_TEXT(db, stmt, idx++, mfx->light_user_switch_mode);
2618
2619         ret = sqlite3_step(stmt);
2620         if (ret != SQLITE_DONE) {
2621                 _LOGE("step failed: %s", sqlite3_errmsg(db));
2622                 sqlite3_finalize(stmt);
2623                 return -1;
2624         }
2625
2626         sqlite3_finalize(stmt);
2627
2628         if (__insert_package_update_info(db, mfx))
2629                 return -1;
2630         if (__insert_package_localized_info(db, mfx))
2631                 return -1;
2632         if (__insert_application_info(db, mfx))
2633                 return -1;
2634         if (__insert_package_privilege_info(db, mfx))
2635                 return -1;
2636         if (__insert_package_appdefined_privilege_info(db, mfx))
2637                 return -1;
2638         if (__insert_package_dependency_info(db, mfx))
2639                 return -1;
2640         if (__insert_package_res_info(db, mfx))
2641                 return -1;
2642
2643         return 0;
2644 }
2645
2646 static int __delete_package_info(sqlite3 *db, const char *pkgid)
2647 {
2648         static const char query[] =
2649                 "DELETE FROM package_info WHERE package=?";
2650         int ret;
2651         sqlite3_stmt *stmt;
2652
2653         ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
2654         if (ret != SQLITE_OK) {
2655                 _LOGE("prepare failed: %s", sqlite3_errmsg(db));
2656                 return -1;
2657         }
2658
2659         __BIND_TEXT(db, stmt, 1, pkgid);
2660
2661         ret = sqlite3_step(stmt);
2662         if (ret != SQLITE_DONE) {
2663                 _LOGE("step failed: %s", sqlite3_errmsg(db));
2664                 sqlite3_finalize(stmt);
2665                 return -1;
2666         }
2667
2668         sqlite3_finalize(stmt);
2669
2670         return 0;
2671 }
2672
2673 API int pkgmgr_parser_delete_pkg_info(sqlite3 *db,
2674                 const char *package, uid_t uid)
2675 {
2676         if (db == NULL || package == NULL) {
2677                 _LOGE("invalid parameter");
2678                 return PM_PARSER_R_EINVAL;
2679         }
2680
2681         __BEGIN_TRANSACTION(db);
2682         __DO_TRANSACTION(db, __delete_package_info(db, package));
2683         __END_TRANSACTION(db);
2684
2685         return PM_PARSER_R_OK;
2686 }
2687
2688 API int pkgmgr_parser_update_pkg_info(sqlite3 *db, manifest_x *mfx, uid_t uid)
2689 {
2690         if (db == NULL || mfx == NULL) {
2691                 _LOGE("invalid parameter");
2692                 return PM_PARSER_R_EINVAL;
2693         }
2694
2695         __BEGIN_TRANSACTION(db);
2696         __DO_TRANSACTION(db, __delete_package_info(db, mfx->package));
2697         __DO_TRANSACTION(db, __insert_package_info(db, mfx));
2698         __END_TRANSACTION(db);
2699
2700         return PM_PARSER_R_OK;
2701 }
2702
2703 API int pkgmgr_parser_insert_pkg_info(sqlite3 *db, manifest_x *mfx, uid_t uid)
2704 {
2705         if (db == NULL || mfx == NULL) {
2706                 _LOGE("invalid parameter");
2707                 return PM_PARSER_R_EINVAL;
2708         }
2709
2710         __BEGIN_TRANSACTION(db);
2711         __DO_TRANSACTION(db, __insert_package_info(db, mfx));
2712         __END_TRANSACTION(db);
2713
2714         return PM_PARSER_R_OK;
2715 }