src/pkginfo_internal.c

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