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; }