static void check_csync_statedb_check(void **state)
{
int rc;
(void) state; /* unused */
rc = system("mkdir -p /tmp/check_csync1");
/* old db */
rc = system("echo \"SQLite format 2\" > /tmp/check_csync1/test.db");
assert_int_equal(rc, 0);
rc = _csync_statedb_check(TESTDB);
assert_int_equal(rc, 1);
/* db already exists */
rc = _csync_statedb_check(TESTDB);
assert_int_equal(rc, 1);
/* no db exists */
rc = system("rm -f /tmp/check_csync1/test.db");
assert_int_equal(rc, 0);
rc = _csync_statedb_check(TESTDB);
assert_int_equal(rc, 1);
rc = _csync_statedb_check("/tmp/check_csync1/");
assert_int_equal(rc, -1);
rc = system("rm -rf /tmp/check_csync1");
assert_int_equal(rc, 0);
}
int csync_statedb_load(CSYNC *ctx, const char *statedb, sqlite3 **pdb) {
int rc = -1;
int check_rc = -1;
c_strlist_t *result = NULL;
sqlite3 *db = NULL;
if( !ctx ) {
return -1;
}
/* csync_statedb_check tries to open the statedb and creates it in case
* its not there.
*/
check_rc = _csync_statedb_check(statedb);
if (check_rc < 0) {
CSYNC_LOG(CSYNC_LOG_PRIORITY_NOTICE, "ERR: checking csync database failed - bail out.");
rc = -1;
goto out;
}
/* Open or create the temporary database */
if (sqlite3_open(statedb, &db) != SQLITE_OK) {
const char *errmsg= sqlite3_errmsg(ctx->statedb.db);
CSYNC_LOG(CSYNC_LOG_PRIORITY_NOTICE, "ERR: Failed to sqlite3 open statedb - bail out: %s.",
errmsg ? errmsg : "<no sqlite3 errormsg>");
rc = -1;
goto out;
}
/* If check_rc == 1 the database is new and empty as a result. */
if ((check_rc == 1) || _csync_statedb_is_empty(db)) {
CSYNC_LOG(CSYNC_LOG_PRIORITY_NOTICE, "statedb doesn't exist");
csync_set_statedb_exists(ctx, 0);
} else {
csync_set_statedb_exists(ctx, 1);
}
/* optimization for speeding up SQLite */
result = csync_statedb_query(db, "PRAGMA synchronous = FULL;");
c_strlist_destroy(result);
result = csync_statedb_query(db, "PRAGMA case_sensitive_like = ON;");
c_strlist_destroy(result);
#ifndef NDEBUG
sqlite3_profile(db, sqlite_profile, 0 );
#endif
*pdb = db;
return 0;
out:
sqlite3_close(db);
return rc;
}
int csync_statedb_load(CSYNC *ctx, const char *statedb) {
int rc = -1;
c_strlist_t *result = NULL;
char *statedb_tmp = NULL;
if (_csync_statedb_check(statedb) < 0) {
rc = -1;
goto out;
}
/*
* We want a two phase commit for the jounal, so we create a temporary copy
* of the database.
* The intention is that if something goes wrong we will not loose the
* statedb.
*/
if (asprintf(&statedb_tmp, "%s.ctmp", statedb) < 0) {
rc = -1;
goto out;
}
if (c_copy(statedb, statedb_tmp, 0644) < 0) {
rc = -1;
goto out;
}
/* Open the temporary database */
if (sqlite3_open(statedb_tmp, &ctx->statedb.db) != SQLITE_OK) {
rc = -1;
goto out;
}
if (_csync_statedb_is_empty(ctx)) {
CSYNC_LOG(CSYNC_LOG_PRIORITY_NOTICE, "statedb doesn't exist");
csync_set_statedb_exists(ctx, 0);
} else {
csync_set_statedb_exists(ctx, 1);
}
/* optimization for speeding up SQLite */
result = csync_statedb_query(ctx, "PRAGMA default_synchronous = OFF;");
c_strlist_destroy(result);
rc = 0;
out:
SAFE_FREE(statedb_tmp);
return rc;
}
int csync_statedb_close(const char *statedb, sqlite3 *db, int jwritten) {
char *statedb_tmp = NULL;
mbchar_t* wstatedb_tmp = NULL;
int rc = 0;
mbchar_t *mb_statedb = NULL;
/* deallocate query resources */
rc = sqlite3_finalize(_by_hash_stmt);
_by_hash_stmt = NULL;
/* close the temporary database */
sqlite3_close(db);
if (asprintf(&statedb_tmp, "%s.ctmp", statedb) < 0) {
return -1;
}
/* If we successfully synchronized, overwrite the original statedb */
/*
* Check the integrity of the tmp db. If ok, overwrite the old database with
* the tmp db.
*/
if (jwritten) {
/* statedb check returns either
* 0 : database exists and is fine
* 1 : new database was set up
* -1 : error.
*/
if (_csync_statedb_check(statedb_tmp) >= 0) {
/* New statedb is valid. */
mb_statedb = c_utf8_to_locale(statedb);
/* Move the tmp-db to the real one. */
if (c_rename(statedb_tmp, statedb) < 0) {
CSYNC_LOG(CSYNC_LOG_PRIORITY_DEBUG,
"Renaming tmp db to original db failed. (errno=%d)", errno);
rc = -1;
} else {
CSYNC_LOG(CSYNC_LOG_PRIORITY_DEBUG,
"Successfully moved tmp db to original db.");
}
} else {
mb_statedb = c_utf8_to_locale(statedb_tmp);
_tunlink(mb_statedb);
/* new statedb_tmp is not integer. */
CSYNC_LOG(CSYNC_LOG_PRIORITY_ERROR, " ## csync tmp statedb corrupt. Original one is not replaced. ");
rc = -1;
}
c_free_locale_string(mb_statedb);
}
wstatedb_tmp = c_utf8_to_locale(statedb_tmp);
if (wstatedb_tmp) {
_tunlink(wstatedb_tmp);
c_free_locale_string(wstatedb_tmp);
}
SAFE_FREE(statedb_tmp);
return rc;
}
int csync_statedb_load(CSYNC *ctx, const char *statedb, sqlite3 **pdb) {
int rc = -1;
int check_rc = -1;
c_strlist_t *result = NULL;
char *statedb_tmp = NULL;
sqlite3 *db = NULL;
/* csync_statedb_check tries to open the statedb and creates it in case
* its not there.
*/
check_rc = _csync_statedb_check(statedb);
if (check_rc < 0) {
CSYNC_LOG(CSYNC_LOG_PRIORITY_NOTICE, "ERR: checking csync database failed - bail out.");
rc = -1;
goto out;
}
/*
* We want a two phase commit for the jounal, so we create a temporary copy
* of the database.
* The intention is that if something goes wrong we will not loose the
* statedb.
*/
rc = asprintf(&statedb_tmp, "%s.ctmp", statedb);
if (rc < 0) {
CSYNC_LOG(CSYNC_LOG_PRIORITY_NOTICE, "ERR: could not create statedb name - bail out.");
rc = -1;
goto out;
}
if (c_copy(statedb, statedb_tmp, 0644) < 0) {
CSYNC_LOG(CSYNC_LOG_PRIORITY_NOTICE, "ERR: Failed to copy statedb -> statedb_tmp - bail out.");
rc = -1;
goto out;
}
_csync_win32_hide_file( statedb_tmp );
/* Open or create the temporary database */
if (sqlite3_open(statedb_tmp, &db) != SQLITE_OK) {
const char *errmsg= sqlite3_errmsg(ctx->statedb.db);
CSYNC_LOG(CSYNC_LOG_PRIORITY_NOTICE, "ERR: Failed to sqlite3 open statedb - bail out: %s.",
errmsg ? errmsg : "<no sqlite3 errormsg>");
rc = -1;
goto out;
}
SAFE_FREE(statedb_tmp);
/* If check_rc == 1 the database is new and empty as a result. */
if ((check_rc == 1) || _csync_statedb_is_empty(db)) {
CSYNC_LOG(CSYNC_LOG_PRIORITY_NOTICE, "statedb doesn't exist");
csync_set_statedb_exists(ctx, 0);
} else {
csync_set_statedb_exists(ctx, 1);
}
/* optimization for speeding up SQLite */
result = csync_statedb_query(db, "PRAGMA synchronous = FULL;");
c_strlist_destroy(result);
result = csync_statedb_query(db, "PRAGMA case_sensitive_like = ON;");
c_strlist_destroy(result);
#ifndef NDEBUG
sqlite3_profile(db, sqlite_profile, 0 );
#endif
*pdb = db;
return 0;
out:
sqlite3_close(db);
SAFE_FREE(statedb_tmp);
return rc;
}
