src/ail_db.c

   1 /*
   2  * ail
   3  *
   4  * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Contact: Jayoun Lee <airjany@samsung.com>, Sewook Park <sewook7.park@samsung.com>, Jaeho Lee <jaeho81.lee@samsung.com>
   7  *
   8  * Licensed under the Apache License, Version 2.0 (the "License");
   9  * you may not use this file except in compliance with the License.
  10  * You may obtain a copy of the License at
  11  *
  12  * http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing, software
  15  * distributed under the License is distributed on an "AS IS" BASIS,
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  * See the License for the specific language governing permissions and
  18  * limitations under the License.
  19  *
  20  */
  21
  22
  23
  24
  25 #include <stdlib.h>
  26 #include <string.h>
  27 #include <db-util.h>
  28 #include <errno.h>
  29 #include <glib.h>
  30 #include <grp.h>
  31 #include <pwd.h>
  32 #include <sys/smack.h>
  33 #include <sys/stat.h>
  34 #include <tzplatform_config.h>
  35 #include "ail_private.h"
  36 #include "ail_db.h"
  37
  38 #define GLOBAL_USER tzplatform_getuid(TZ_SYS_GLOBALAPP_USER)
  39 #define BUFSIZE 4096
  40 #define QUERY_ATTACH "attach database '%s' as Global"
  41 #define QUERY_CREATE_VIEW_APP "CREATE temp VIEW app_info as select distinct * from (select  * from main.app_info m union select * from Global.app_info g)"
  42
  43 #define QUERY_CREATE_VIEW_LOCAL "CREATE temp VIEW localname as select distinct * from (select  * from main.localname m union select * from Global.localname g)"
  44
  45 #define SET_SMACK_LABEL(x,uid) \
  46         do { \
  47                 if (smack_setlabel((x), (((uid) == GLOBAL_USER) ? "*" : "User"), SMACK_LABEL_ACCESS)) \
  48                         _E("failed chsmack -a \"User/*\" %s", x); \
  49                 else \
  50                         _D("chsmack -a \"User/*\" %s", x); \
  51         } while (0)
  52
  53 #define retv_with_dbmsg_if(expr, val) \
  54         do { \
  55                 if (expr) { \
  56                         _E("db_info.dbUserro: %s", sqlite3_errmsg(db_info.dbUserro)); \
  57                         _E("db_info.dbGlobalro: %s", sqlite3_errmsg(db_info.dbGlobalro)); \
  58                         _E("db_info.dbUserrw: %s", sqlite3_errmsg(db_info.dbUserrw)); \
  59                         _E("db_info.dbGlobalrw: %s", sqlite3_errmsg(db_info.dbGlobalrw)); \
  60                         _E("db_info.dbUserro errcode: %d", sqlite3_extended_errcode(db_info.dbUserro)); \
  61                         _E("db_info.dbGlobalro errcode: %d", sqlite3_extended_errcode(db_info.dbGlobalro)); \
  62                         _E("db_info.dbUserrw errcode: %d", sqlite3_extended_errcode(db_info.dbUserrw)); \
  63                         _E("db_info.dbGlobalrw errcode: %d", sqlite3_extended_errcode(db_info.dbGlobalrw)); \
  64                         return (val); \
  65                 } \
  66         } while (0)
  67
  68 #define tryvm_with_dbmsg_if(expr, val) \
  69         do { \
  70                 if (expr) { \
  71                         _E("db_info.dbUserro: %s", sqlite3_errmsg(db_info.dbUserro)); \
  72                         _E("db_info.dbGlobalro: %s", sqlite3_errmsg(db_info.dbGlobalro)); \
  73                         _E("db_info.dbUserrw: %s", sqlite3_errmsg(db_info.dbUserrw)); \
  74                         _E("db_info.dbGlobalrw: %s", sqlite3_errmsg(db_info.dbGlobalrw)); \
  75                         _E("db_info.dbUserro errcode: %d", sqlite3_extended_errcode(db_info.dbUserro)); \
  76                         _E("db_info.dbGlobalro errcode: %d", sqlite3_extended_errcode(db_info.dbGlobalro)); \
  77                         _E("db_info.dbUserrw errcode: %d", sqlite3_extended_errcode(db_info.dbUserrw)); \
  78                         _E("db_info.dbGlobalrw errcode: %d", sqlite3_extended_errcode(db_info.dbGlobalrw)); \
  79                         goto catch; \
  80                 } \
  81         } while (0)
  82
  83 static __thread struct {
  84         sqlite3 *dbUserro;
  85         sqlite3 *dbGlobalro;
  86         sqlite3 *dbUserrw;
  87         sqlite3 *dbGlobalrw;
  88 } db_info = {
  89         .dbUserro = NULL,
  90         .dbGlobalro = NULL,
  91         .dbUserrw = NULL,
  92         .dbGlobalrw = NULL
  93 };
  94
  95 static __thread sqlite3 *dbInit = NULL;
  96
  97 static int ail_db_change_perm(const char *db_file, uid_t uid)
  98 {
  99         char buf[BUFSIZE];
 100         char journal_file[BUFSIZE];
 101         char *files[3];
 102         int ret;
 103         int i;
 104         struct passwd pwd;
 105         struct passwd *userinfo = NULL;
 106         char *pwd_buf = NULL;
 107         int pwd_bufsize;
 108
 109         files[0] = (char *)db_file;
 110         files[1] = journal_file;
 111         files[2] = NULL;
 112
 113         retv_if(!db_file, AIL_ERROR_FAIL);
 114         if (getuid() != OWNER_ROOT) /* At this time we should be root to apply this */
 115                 return AIL_ERROR_OK;
 116
 117         pwd_bufsize = sysconf(_SC_GETPW_R_SIZE_MAX);
 118         if (pwd_bufsize <= 0)
 119                 pwd_bufsize = 16384;
 120
 121         pwd_buf = (char *)malloc(pwd_bufsize);
 122         if (pwd_buf == NULL) {
 123                 _E("out of memory");
 124                 return AIL_ERROR_OUT_OF_MEMORY;
 125         }
 126
 127         if (getpwuid_r(uid, &pwd, pwd_buf, pwd_bufsize, &userinfo) != 0) {
 128                 _E("FAIL: user %d doesn't exist", uid);
 129                 free(pwd_buf);
 130                 return AIL_ERROR_FAIL;
 131         }
 132         snprintf(journal_file, sizeof(journal_file), "%s%s", db_file, "-journal");
 133
 134         for (i = 0; files[i]; i++) {
 135                 /* Compare git_t type and not group name */
 136                 ret = chown(files[i], uid, userinfo->pw_gid);
 137                 SET_SMACK_LABEL(files[i],uid);
 138                 if (ret == -1) {
 139                         strerror_r(errno, buf, sizeof(buf));
 140                         _E("FAIL : chown %s %d.%d, because %s", db_file, uid, userinfo->pw_gid, buf);
 141                         free(pwd_buf);
 142                         return AIL_ERROR_FAIL;
 143                 }
 144
 145                 ret = chmod(files[i], S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
 146                 if (ret == -1) {
 147                         strerror_r(errno, buf, sizeof(buf));
 148                         _E("FAIL : chmod %s 0664, because %s", db_file, buf);
 149                         free(pwd_buf);
 150                         return AIL_ERROR_FAIL;
 151                 }
 152         }
 153
 154         free(pwd_buf);
 155
 156         return AIL_ERROR_OK;
 157 }
 158
 159 char *ail_get_icon_path(uid_t uid)
 160 {
 161         char *result = NULL;
 162         struct group grpbuf;
 163         struct group *grpinfo = NULL;
 164         char *dir = NULL;
 165         struct passwd pwd;
 166         struct passwd *userinfo = NULL;
 167         int buflen;
 168         char *buf = NULL;
 169         char *pwd_buf;
 170
 171         if (uid == 0) {
 172                 _E("FAIL : Root is not allowed user! please fix it replacing with DEFAULT_USER");
 173                 return NULL;
 174         }
 175
 176         if (uid != GLOBAL_USER) {
 177                 buflen = sysconf(_SC_GETPW_R_SIZE_MAX);
 178                 if (buflen <= 0)
 179                         buflen = 16384;
 180
 181                 pwd_buf = (char *)malloc(buflen);
 182                 if (pwd_buf == NULL) {
 183                         _E("out of memory");
 184                         return NULL;
 185                 }
 186
 187                 if (getpwuid_r(uid, &pwd, pwd_buf, buflen, &userinfo) != 0) {
 188                         _E("getpwuid(%d) returns NULL !", uid);
 189                         free(pwd_buf);
 190                         return NULL;
 191                 }
 192
 193                 buflen = sysconf(_SC_GETGR_R_SIZE_MAX);
 194                 if (buflen <= 0)
 195                         buflen = 1024;
 196
 197                 buf = (char *)malloc(buflen);
 198                 if (buf == NULL) {
 199                         _E("out of memory");
 200                         free(pwd_buf);
 201                         return NULL;
 202                 }
 203
 204                 if (getgrnam_r("users", &grpbuf, buf, buflen, &grpinfo) != 0) {
 205                         _E("getgrnam_r(users) returns NULL !");
 206                         free(pwd_buf);
 207                         free(buf);
 208                         return NULL;
 209                 }
 210
 211                 /* Compare git_t type and not group name */
 212                 if (grpinfo->gr_gid != userinfo->pw_gid) {
 213                         _E("UID [%d] does not belong to 'users' group!", uid);
 214                         free(pwd_buf);
 215                         free(buf);
 216                         return NULL;
 217                 }
 218
 219                 asprintf(&result, "%s/.applications/icons/", userinfo->pw_dir);
 220                 free(pwd_buf);
 221         } else {
 222                 result = strdup(tzplatform_mkpath(TZ_SYS_RW_ICONS, "/"));
 223                 if (result == NULL) {
 224                         _E("out of memory");
 225                         return NULL;
 226                 }
 227         }
 228
 229         int ret = mkdir(result, S_IRWXU | S_IRGRP | S_IXGRP | S_IXOTH);
 230         if (ret == -1 && errno != EEXIST) {
 231                 _E("FAIL : to create directory %s %d", result, errno);
 232         } else if (getuid() == OWNER_ROOT) {
 233                 ret = chown(result, uid, grpinfo ? grpinfo->gr_gid : 0);
 234                 SET_SMACK_LABEL(result, uid);
 235                 if (ret == -1) {
 236                         char buf[BUFSIZE];
 237                         strerror_r(errno, buf, sizeof(buf));
 238                         _E("FAIL : chown %s %d.%d, because %s", result, uid,
 239                                         grpinfo ? grpinfo->gr_gid : 0, buf);
 240                 }
 241         }
 242
 243         free(buf);
 244
 245         return result;
 246 }
 247
 248 char *ail_get_app_DB_journal(uid_t uid)
 249 {
 250         char *app_path = ail_get_app_DB(uid);
 251         char *result = NULL;
 252
 253         asprintf(&result, "%s-journal", app_path);
 254         free(app_path);
 255
 256         return  result;
 257 }
 258
 259 char *ail_get_app_DB(uid_t uid)
 260 {
 261         char *result = NULL;
 262         struct group grpbuf;
 263         struct group *grpinfo = NULL;
 264         char *dir = NULL;
 265         char *temp = NULL;
 266         struct passwd pwd;
 267         struct passwd *userinfo;
 268         int buflen;
 269         char *buf = NULL;
 270         char *pwd_buf;
 271
 272         if (uid == 0) {
 273                 _E("FAIL : Root is not allowed! switch to DEFAULT_USER");
 274                 return NULL;
 275         }
 276
 277         if (uid != GLOBAL_USER) {
 278                 buflen = sysconf(_SC_GETPW_R_SIZE_MAX);
 279                 if (buflen <= 0)
 280                         buflen = 16384;
 281
 282                 pwd_buf = (char *)malloc(buflen);
 283                 if (pwd_buf == NULL) {
 284                         _E("out of memory");
 285                         return NULL;
 286                 }
 287
 288                 if (getpwuid_r(uid, &pwd, pwd_buf, buflen, &userinfo) != 0) {
 289                         _E("getpwuid(%d) returns NULL !", uid);
 290                         free(pwd_buf);
 291                         return NULL;
 292                 }
 293
 294                 buflen = sysconf(_SC_GETGR_R_SIZE_MAX);
 295                 if (buflen <= 0)
 296                         buflen = 1024;
 297
 298                 buf = (char *)malloc(buflen);
 299                 if (buf == NULL) {
 300                         _E("out of memory");
 301                         free(pwd_buf);
 302                         return NULL;
 303                 }
 304
 305                 if (getgrnam_r("users", &grpbuf, buf, buflen, &grpinfo) != 0) {
 306                         _E("getgrnam(users) returns NULL !");
 307                         free(pwd_buf);
 308                         free(buf);
 309                         return NULL;
 310                 }
 311
 312                 /* Compare git_t type and not group name */
 313                 if (grpinfo->gr_gid != userinfo->pw_gid) {
 314                         _E("UID [%d] does not belong to 'users' group!", uid);
 315                         free(pwd_buf);
 316                         free(buf);
 317                         return NULL;
 318                 }
 319
 320                 asprintf(&result, "%s/.applications/dbspace/.app_info.db", userinfo->pw_dir);
 321                 free(pwd_buf);
 322         } else {
 323                 result = strdup(APP_INFO_DB_FILE);
 324                 if (result == NULL) {
 325                         _E("ouf of memory");
 326                         return NULL;
 327                 }
 328         }
 329
 330         temp = strdup(result);
 331         if (temp == NULL) {
 332                 free(buf);
 333                 return result;
 334         }
 335
 336         dir = strrchr(temp, '/');
 337         if (!dir) {
 338                 free(temp);
 339                 free(buf);
 340                 return result;
 341         }
 342         *dir = 0;
 343
 344         int ret = mkdir(temp, S_IRWXU | S_IRGRP | S_IXGRP | S_IXOTH);
 345         if (ret == -1 && errno != EEXIST) {
 346                 _E("FAIL : to create directory %s %d", temp, errno);
 347         } else if (getuid() == OWNER_ROOT) {
 348                 ret = chown(temp, uid, grpinfo ? grpinfo->gr_gid : 0);
 349                 SET_SMACK_LABEL(temp,uid);
 350                 if (ret == -1) {
 351                         char buf[BUFSIZE];
 352                         strerror_r(errno, buf, sizeof(buf));
 353                         _E("FAIL : chown %s %d.%d, because %s", temp, uid,
 354                                         grpinfo ? grpinfo->gr_gid : 0, buf);
 355                 }
 356         }
 357
 358         free(temp);
 359         free(buf);
 360
 361         return result;
 362 }
 363
 364 char *ail_get_desktop_path(uid_t uid)
 365 {
 366         char *result = NULL;
 367         struct group grpbuf;
 368         struct group *grpinfo = NULL;
 369         char *dir = NULL;
 370         struct passwd pwd;
 371         struct passwd *userinfo = NULL;
 372         int buflen;
 373         char *buf = NULL;
 374         char *pwd_buf;
 375
 376         if (uid == 0) {
 377                 _E("FAIL : Root is not allowed user! please fix it replacing with DEFAULT_USER");
 378                 return NULL;
 379         }
 380
 381         if (uid != GLOBAL_USER) {
 382                 buflen = sysconf(_SC_GETPW_R_SIZE_MAX);
 383                 if (buflen <= 0)
 384                         buflen = 16384;
 385
 386                 pwd_buf = (char *)malloc(buflen);
 387                 if (pwd_buf == NULL) {
 388                         _E("out of memory");
 389                         return NULL;
 390                 }
 391
 392                 if (getpwuid_r(uid, &pwd, pwd_buf, buflen, &userinfo) != 0) {
 393                         _E("getpwuid(%d) returns NULL !", uid);
 394                         free(pwd_buf);
 395                         return NULL;
 396                 }
 397
 398                 buflen = sysconf(_SC_GETGR_R_SIZE_MAX);
 399                 if (buflen <= 0)
 400                         buflen = 1024;
 401
 402                 buf = (char *)malloc(buflen);
 403                 if (buf == NULL) {
 404                         _E("out of memory");
 405                         free(pwd_buf);
 406                         return NULL;
 407                 }
 408
 409                 if (getgrnam_r("users", &grpbuf, buf, buflen, &grpinfo) != 0) {
 410                         _E("getgrnam(users) returns NULL !");
 411                         free(pwd_buf);
 412                         free(buf);
 413                         return NULL;
 414                 }
 415
 416                 /* Compare git_t type and not group name */
 417                 if (grpinfo->gr_gid != userinfo->pw_gid) {
 418                         _E("UID [%d] does not belong to 'users' group!", uid);
 419                         free(pwd_buf);
 420                         free(buf);
 421                         return NULL;
 422                 }
 423
 424                 asprintf(&result, "%s/.applications/desktop/", userinfo->pw_dir);
 425                 free(pwd_buf);
 426         } else {
 427                 result = strdup(tzplatform_mkpath(TZ_SYS_RW_DESKTOP_APP, "/"));
 428                 if (result == NULL) {
 429                         _E("out of memory");
 430                         return NULL;
 431                 }
 432         }
 433
 434         int ret = mkdir(result, S_IRWXU | S_IRGRP | S_IXGRP | S_IXOTH);
 435         if (ret == -1 && errno != EEXIST) {
 436                 _E("FAIL : to create directory %s %d", result, errno);
 437         } else if (getuid() == OWNER_ROOT) {
 438                 ret = chown(result, uid, grpinfo ? grpinfo->gr_gid : 0);
 439                 SET_SMACK_LABEL(result,uid);
 440                 if (ret == -1) {
 441                         char buf[BUFSIZE];
 442                         strerror_r(errno, buf, sizeof(buf));
 443                         _E("FAIL : chown %s %d.%d, because %s", result, uid,
 444                                         grpinfo ? grpinfo->gr_gid : 0, buf);
 445                 }
 446         }
 447
 448         free(buf);
 449
 450         return result;
 451 }
 452
 453
 454 static ail_error_e db_do_prepare(sqlite3 *db, const char *query, sqlite3_stmt **stmt)
 455 {
 456         int ret;
 457
 458         retv_if(!query, AIL_ERROR_INVALID_PARAMETER);
 459         retv_if(!stmt, AIL_ERROR_INVALID_PARAMETER);
 460         retv_if(!db, AIL_ERROR_DB_FAILED);
 461
 462         ret = sqlite3_prepare_v2(db, query, strlen(query), stmt, NULL);
 463         if (ret != SQLITE_OK) {
 464                 _E("%s\n", sqlite3_errmsg(db));
 465                 return AIL_ERROR_DB_FAILED;
 466         } else
 467                 return AIL_ERROR_OK;
 468 }
 469
 470 ail_error_e db_open(db_open_mode mode, uid_t uid)
 471 {
 472         int ret;
 473         int changed = 0;
 474         int i;
 475         char *db;
 476         char *global_db;
 477         const char *tbls[3] = {
 478                 "CREATE TABLE app_info "
 479                 "(package TEXT PRIMARY KEY, "
 480                 "exec TEXT DEFAULT 'No Exec', "
 481                 "name TEXT DEFAULT 'No Name', "
 482                 "type TEXT DEFAULT 'Application', "
 483                 "icon TEXT DEFAULT 'No Icon', "
 484                 "categories TEXT, "
 485                 "version TEXT, "
 486                 "mimetype TEXT, "
 487                 "x_slp_service TEXT, "
 488                 "x_slp_packagetype TEXT, "
 489                 "x_slp_packagecategories TEXT, "
 490                 "x_slp_packageid TEXT, "
 491                 "x_slp_uri TEXT, "
 492                 "x_slp_svc TEXT, "
 493                 "x_slp_exe_path TEXT, "
 494                 "x_slp_appid TEXT, "
 495                 "x_slp_pkgid TEXT, "
 496                 "x_slp_domain TEXT, "
 497                 "x_slp_submodemainid TEXT, "
 498                 "x_slp_installedstorage TEXT, "
 499                 "x_slp_baselayoutwidth INTEGER DEFAULT 0, "
 500                 "x_slp_installedtime INTEGER DEFAULT 0, "
 501                 "nodisplay INTEGER DEFAULT 0, "
 502                 "x_slp_taskmanage INTEGER DEFAULT 1, "
 503                 "x_slp_multiple INTEGER DEFAULT 0, "
 504                 "x_slp_removable INTEGER DEFAULT 1, "
 505                 "x_slp_ishorizontalscale INTEGER DEFAULT 0, "
 506                 "x_slp_enabled INTEGER DEFAULT 1, "
 507                 "x_slp_submode INTEGER DEFAULT 0, "
 508                 "desktop TEXT UNIQUE NOT NULL);",
 509                 "CREATE TABLE localname (package TEXT NOT NULL, "
 510                 "locale TEXT NOT NULL, "
 511                 "name TEXT NOT NULL, "
 512                 "x_slp_pkgid TEXT NOT NULL, PRIMARY KEY (package, locale));",
 513
 514                 NULL
 515         };
 516
 517         db = ail_get_app_DB(uid);
 518         if (db == NULL) {
 519                 _E("Failed to get app DB");
 520                 return AIL_ERROR_DB_FAILED;
 521         }
 522
 523         global_db = ail_get_app_DB(GLOBAL_USER);
 524         if (global_db == NULL) {
 525                 _E("Failed to get global app DB");
 526                 free(db);
 527                 return AIL_ERROR_DB_FAILED;
 528         }
 529
 530         if (access(db, F_OK)) {
 531                 if (AIL_ERROR_OK == db_util_open_with_options(db, &dbInit, SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, NULL))
 532                 {
 533                         for (i = 0; tbls[i] != NULL; i++) {
 534                                 ret = do_db_exec(tbls[i], dbInit);
 535                                 if (ret != AIL_ERROR_OK)
 536                                         goto catch;
 537                         }
 538                         if(getuid() == OWNER_ROOT && AIL_ERROR_OK != ail_db_change_perm(db, uid)) {
 539                                 _E("Failed to change permission\n");
 540                         }
 541                 } else {
 542                         dbInit = NULL;
 543                         _E("Failed to create table %s\n", db);
 544                 }
 545         }
 546
 547         if (dbInit) {
 548                 ret = sqlite3_close(dbInit);
 549                 tryvm_with_dbmsg_if(ret != SQLITE_OK, AIL_ERROR_DB_FAILED);
 550                 dbInit = NULL;
 551         }
 552         if(mode & DB_OPEN_RO) {
 553                 if(uid != GLOBAL_USER) {
 554                         if (!db_info.dbUserro) {
 555                                 db_util_open_with_options(db, &db_info.dbUserro, SQLITE_OPEN_READONLY, NULL);
 556                                 char query_attach[AIL_SQL_QUERY_MAX_LEN];
 557                                 char query_view_app[AIL_SQL_QUERY_MAX_LEN];
 558                                 char query_view_local[AIL_SQL_QUERY_MAX_LEN];
 559                                 snprintf(query_attach, AIL_SQL_QUERY_MAX_LEN, QUERY_ATTACH, global_db);
 560                                 if (db_exec_usr_ro(query_attach) < 0) {
 561                                         _D("executing query_attach : %s", query_attach);
 562                                         goto catch;
 563                                 }
 564                                 snprintf(query_view_app, AIL_SQL_QUERY_MAX_LEN, QUERY_CREATE_VIEW_APP);
 565                                 if (db_exec_usr_ro(query_view_app) < 0) {
 566                                         _D("executing query_attach : %s", query_view_app);
 567                                         goto catch;
 568                                 }
 569
 570                                 snprintf(query_view_local, AIL_SQL_QUERY_MAX_LEN, QUERY_CREATE_VIEW_LOCAL);
 571                                 if (db_exec_usr_ro(query_view_local) < 0) {
 572                                         _D("executing query_attach : %s", query_view_local);
 573                                         goto catch;
 574                                 }
 575                         }
 576                 } else {
 577                         if (!db_info.dbGlobalro) {
 578                                 ret = db_util_open_with_options(global_db, &db_info.dbGlobalro, SQLITE_OPEN_READONLY, NULL);
 579                                 tryvm_with_dbmsg_if(ret != SQLITE_OK, AIL_ERROR_DB_FAILED);
 580                         }
 581                 }
 582         }
 583
 584         if (mode & DB_OPEN_RW) {
 585                 if (uid != GLOBAL_USER) {
 586                         if (!db_info.dbUserrw) {
 587                                 ret = db_util_open(db, &db_info.dbUserrw, 0);
 588                                 tryvm_with_dbmsg_if(ret != SQLITE_OK, AIL_ERROR_DB_FAILED);
 589                         }
 590                 } else {
 591                         if (!db_info.dbGlobalrw) {
 592                                 ret = db_util_open(global_db, &db_info.dbGlobalrw, 0);
 593                                 tryvm_with_dbmsg_if(ret != SQLITE_OK, AIL_ERROR_DB_FAILED);
 594                         }
 595                 }
 596         }
 597
 598         free(global_db);
 599         free(db);
 600
 601         return AIL_ERROR_OK;
 602
 603 catch:
 604         free(global_db);
 605         free(db);
 606
 607         return AIL_ERROR_DB_FAILED;
 608 }
 609
 610 ail_error_e db_prepare(const char *query, sqlite3_stmt **stmt)
 611 {
 612         return db_do_prepare(db_info.dbUserro, query, stmt);
 613 }
 614
 615 ail_error_e db_prepare_globalro(const char *query, sqlite3_stmt **stmt)
 616 {
 617         return db_do_prepare(db_info.dbGlobalro, query, stmt);
 618 }
 619
 620 ail_error_e db_prepare_rw(const char *query, sqlite3_stmt **stmt)
 621 {
 622         return db_do_prepare(db_info.dbUserrw, query, stmt);
 623 }
 624
 625 ail_error_e db_prepare_globalrw(const char *query, sqlite3_stmt **stmt)
 626 {
 627         return db_do_prepare(db_info.dbGlobalrw, query, stmt);
 628 }
 629
 630 ail_error_e db_bind_bool(sqlite3_stmt *stmt, int idx, bool value)
 631 {
 632         int ret;
 633
 634         retv_if(!stmt, AIL_ERROR_INVALID_PARAMETER);
 635
 636         ret = sqlite3_bind_int(stmt, idx, (int) value);
 637         retv_with_dbmsg_if(ret != SQLITE_OK, AIL_ERROR_DB_FAILED);
 638
 639         return AIL_ERROR_OK;
 640 }
 641
 642 ail_error_e db_bind_int(sqlite3_stmt *stmt, int idx, int value)
 643 {
 644         int ret;
 645
 646         retv_if(!stmt, AIL_ERROR_INVALID_PARAMETER);
 647
 648         ret = sqlite3_bind_int(stmt, idx, value);
 649         retv_with_dbmsg_if(ret != SQLITE_OK, AIL_ERROR_DB_FAILED);
 650
 651         return AIL_ERROR_OK;
 652 }
 653
 654 ail_error_e db_bind_text(sqlite3_stmt *stmt, int idx, char* value)
 655 {
 656         int ret;
 657
 658         retv_if(!stmt, AIL_ERROR_INVALID_PARAMETER);
 659
 660         ret = sqlite3_bind_text(stmt, idx, value, strlen(value), 0);
 661         retv_with_dbmsg_if(ret != SQLITE_OK, AIL_ERROR_DB_FAILED);
 662
 663         return AIL_ERROR_OK;
 664 }
 665
 666 ail_error_e db_step(sqlite3_stmt *stmt)
 667 {
 668         int ret;
 669
 670         retv_if(!stmt, AIL_ERROR_INVALID_PARAMETER);
 671
 672         ret = sqlite3_step(stmt);
 673         switch (ret) {
 674                 case SQLITE_DONE:
 675                         return AIL_ERROR_NO_DATA;
 676                 case SQLITE_ROW:
 677                         return AIL_ERROR_OK;
 678         }
 679
 680         retv_with_dbmsg_if(1, AIL_ERROR_DB_FAILED);
 681 }
 682
 683 ail_error_e db_column_bool(sqlite3_stmt *stmt, int index, bool *value)
 684 {
 685         int out_val;
 686
 687         retv_if(!stmt, AIL_ERROR_INVALID_PARAMETER);
 688         retv_if(!value, AIL_ERROR_INVALID_PARAMETER);
 689
 690         out_val = sqlite3_column_int(stmt, index);
 691         *value = (out_val == 1)? true:false;
 692
 693         return AIL_ERROR_OK;
 694 }
 695
 696 ail_error_e db_column_int(sqlite3_stmt *stmt, int index, int *value)
 697 {
 698         retv_if(!stmt, AIL_ERROR_INVALID_PARAMETER);
 699         retv_if(!value, AIL_ERROR_INVALID_PARAMETER);
 700
 701         *value = sqlite3_column_int(stmt, index);
 702
 703         return AIL_ERROR_OK;
 704 }
 705
 706 ail_error_e db_column_str(sqlite3_stmt *stmt, int index, char **str)
 707 {
 708         retv_if(!stmt, AIL_ERROR_INVALID_PARAMETER);
 709         retv_if(!str, AIL_ERROR_INVALID_PARAMETER);
 710
 711         *str = (char *)sqlite3_column_text(stmt, index);
 712
 713         return AIL_ERROR_OK;
 714 }
 715
 716 ail_error_e db_reset(sqlite3_stmt *stmt)
 717 {
 718         int ret;
 719
 720         retv_if(!stmt, AIL_ERROR_INVALID_PARAMETER);
 721
 722         sqlite3_clear_bindings(stmt);
 723
 724         ret = sqlite3_reset(stmt);
 725         retv_with_dbmsg_if(ret != SQLITE_OK, AIL_ERROR_DB_FAILED);
 726
 727         return AIL_ERROR_OK;
 728 }
 729
 730 ail_error_e db_finalize(sqlite3_stmt *stmt)
 731 {
 732         int ret;
 733
 734         retv_if(!stmt, AIL_ERROR_INVALID_PARAMETER);
 735
 736         ret = sqlite3_finalize(stmt);
 737         retv_with_dbmsg_if(ret != SQLITE_OK, AIL_ERROR_DB_FAILED);
 738
 739         return AIL_ERROR_OK;
 740 }
 741
 742 ail_error_e do_db_exec(const char *query, sqlite3 * fileSQL)
 743 {
 744         int ret;
 745         char *errmsg = NULL;
 746
 747         retv_if(!query, AIL_ERROR_INVALID_PARAMETER);
 748         retv_if(!fileSQL, AIL_ERROR_DB_FAILED);
 749
 750         ret = sqlite3_exec(fileSQL, query, NULL, NULL, &errmsg);
 751         if (ret != SQLITE_OK) {
 752                 _E("Cannot execute this query - %s. because %s",
 753                                 query, errmsg? errmsg:"uncatched error");
 754                 if(errmsg)
 755                         sqlite3_free(errmsg);
 756                 return AIL_ERROR_DB_FAILED;
 757         }
 758
 759         return AIL_ERROR_OK;
 760 }
 761
 762 ail_error_e db_exec_usr_rw(const char *query)
 763 {
 764         return do_db_exec(query, db_info.dbUserrw);
 765 }
 766
 767 ail_error_e db_exec_usr_ro(const char *query)
 768 {
 769         return do_db_exec(query, db_info.dbUserro);
 770 }
 771
 772 ail_error_e db_exec_glo_ro(const char *query)
 773 {
 774         return do_db_exec(query, db_info.dbGlobalro);
 775 }
 776
 777 ail_error_e db_exec_glo_rw(const char *query)
 778 {
 779         return do_db_exec(query, db_info.dbGlobalrw);
 780 }
 781
 782 ail_error_e db_close(void)
 783 {
 784         int ret;
 785
 786         if(db_info.dbUserro) {
 787                 ret = sqlite3_close(db_info.dbUserro);
 788                 retv_with_dbmsg_if(ret != SQLITE_OK, AIL_ERROR_DB_FAILED);
 789
 790                 db_info.dbUserro = NULL;
 791         }
 792         if(db_info.dbGlobalrw) {
 793                 ret = sqlite3_close(db_info.dbGlobalrw);
 794                 retv_with_dbmsg_if(ret != SQLITE_OK, AIL_ERROR_DB_FAILED);
 795
 796                 db_info.dbGlobalrw = NULL;
 797         }
 798         if(db_info.dbUserrw) {
 799                 ret = sqlite3_close(db_info.dbUserrw);
 800                 retv_with_dbmsg_if(ret != SQLITE_OK, AIL_ERROR_DB_FAILED);
 801
 802                 db_info.dbUserrw = NULL;
 803         }
 804
 805         return AIL_ERROR_OK;
 806 }
 807
 808 EXPORT_API ail_error_e ail_db_close(void)
 809 {
 810         return db_close();
 811 }
 812
 813 int db_exec_sqlite_query(char *query, sqlite_query_callback callback, void *data)
 814 {
 815         char *error_message = NULL;
 816         if(db_info.dbGlobalro) {
 817                 if (SQLITE_OK !=
 818                         sqlite3_exec(db_info.dbGlobalro, query, callback, data, &error_message)) {
 819                         _E("Don't execute query = %s error message = %s\n", query,
 820                                 error_message);
 821                         sqlite3_free(error_message);
 822                         return -1;
 823                 }
 824         }
 825         if(db_info.dbUserro) {
 826                 if (SQLITE_OK !=
 827                         sqlite3_exec(db_info.dbUserro, query, callback, data, &error_message)) {
 828                         _E("Don't execute query = %s error message = %s\n", query,
 829                                 error_message);
 830                         sqlite3_free(error_message);
 831                         return -1;
 832                 }
 833         }
 834         sqlite3_free(error_message);
 835         return 0;
 836 }