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