static void *sqlite_open_conn(const DBConf *db_conf)
{
sqlite *db = NULL;
SQLiteConf *conf = db_conf->sqlite; /* make compiler happy */
char *errmsg = 0;
/* sanity check */
if (conf == NULL)
return NULL;
if ((db = sqlite_open(octstr_get_cstr(conf->file), 0, &errmsg)) == NULL) {
error(0, "SQLite: can not open database file `%s'!",
octstr_get_cstr(conf->file));
error(0, "SQLite: %s", errmsg);
goto failed;
}
if (conf->lock_timeout > 0) {
info(0, "SQLite: Setting lock timeout to %ld", conf->lock_timeout);
sqlite_busy_timeout(db, conf->lock_timeout);
}
info(0, "SQLite: Opened database file `%s'.", octstr_get_cstr(conf->file));
info(0, "SQLite: library version %s.", sqlite_version);
return db;
failed:
return NULL;
}
static apr_dbd_t *dbd_sqlite_open(apr_pool_t * pool, const char *params_)
{
apr_dbd_t *sql;
sqlite *conn = NULL;
char *perm;
int iperms = 600;
char* params = apr_pstrdup(pool, params_);
/* params = "[filename]:[permissions]"
* example: "shopping.db:600"
*/
perm = strstr(params, ":");
if (perm) {
*(perm++) = '\x00'; /* split the filename and permissions */
if (strlen(perm) > 0)
iperms = atoi(perm);
}
conn = sqlite_open(params, iperms, NULL);
sql = apr_pcalloc(pool, sizeof(*sql));
sql->conn = conn;
return sql;
}
/* _sqlite2_init */
static SQLite2 * _sqlite2_init(Config * config, char const * section)
{
SQLite2 * sqlite;
char const * name;
char * error = NULL;
if((sqlite = object_new(sizeof(*sqlite))) == NULL)
return NULL;
sqlite->handle = NULL;
if((name = config_get(config, section, "filename")) != NULL
&& (sqlite->handle = sqlite_open(name, 0, &error))
== NULL)
{
error_set_code(1, "%s: %s", name, (error != NULL) ? error
: "Unknown error");
free(error);
}
/* check for errors */
if(sqlite->handle == NULL)
{
_sqlite2_destroy(sqlite);
return NULL;
}
return sqlite;
}
bool cSQLiteDriver::open( int )
{
char* error = NULL;
close();
connection = sqlite_open( _dbname.latin1(), 0, &error );
if ( !connection )
{
if ( error )
{
QString err( error );
sqlite_freemem( error );
throw err;
}
else
{
throw QString( "Unknown SQLite error while opening database." );
}
}
exec( "PRAGMA synchronous = OFF;" );
exec( "PRAGMA default_synchronous = OFF;" );
exec( "PRAGMA full_column_names = OFF;" );
exec( "PRAGMA show_datatypes = OFF;" );
exec( "PRAGMA parser_trace = OFF;" );
return true;
}
void SqliteDatabaseConnector::openDatabase()
{
#if defined(HAVE_SQLITE3_H)
int result = sqlite3_open(db_name.c_str(), &db);
if (result != SQLITE_OK) {
std::string error = sqlite3_errmsg(db);
logger << ERROR << "Unable to open database: " << db_name << " : " << endl;
throw SqliteDatabaseConnectorException(error);
}
#elif defined(HAVE_SQLITE_H)
char* errormsg = 0;
db = sqlite_open(db_name.c_str(), 0, &errormsg);
if (db == 0) {
std::string error;
if (errormsg != 0) {
error = errormsg;
}
#ifdef HAVE_STDLIB_H
free(errormsg);
#endif
logger << ERROR << "Unable to open database: " << db_name << " : " << endl;
throw SqliteDatabaseConnectorException(error);
}
#endif
}
/*
SQLite dbs have no user name, passwords, hosts or ports.
just file names.
*/
bool QSQLite2Driver::open(const QString & db, const QString &, const QString &, const QString &, int, const QString &)
{
if (isOpen())
close();
if (db.isEmpty())
return false;
char* err = 0;
d->access = sqlite_open(QFile::encodeName(db), 0, &err);
if (err) {
setLastError(QSqlError(tr("Error opening database"), QString::fromAscii(err),
QSqlError::ConnectionError));
sqlite_freemem(err);
err = 0;
}
if (d->access) {
setOpen(true);
setOpenError(false);
return true;
}
setOpenError(true);
return false;
}
IoObject *IoSQLite_open(IoSQLite *self, IoObject *locals, IoMessage *m)
{
/*doc SQLite open(optionalPathString)
Opens the database.Returns self on success or nil upon failure.
If the databse is locked, "yield" will be called until it is
accessable or timeoutSeconds has expired.
*/
char *zErrMsg;
if (DATA(self)->debugOn)
{
IoState_print_(IOSTATE, "IoSQLite opening '%s'\n", CSTRING(DATA(self)->path));
}
DATA(self)->db = sqlite_open(CSTRING(DATA(self)->path), 0, &zErrMsg);
if (!DATA(self)->db)
{
IoSQLite_error_(self, zErrMsg);
}
else
{
IoSQLite_error_(self, "");
}
sqlite_busy_handler(DATA(self)->db, IoSQLite_busyHandler, self);
sqlite_busy_timeout(DATA(self)->db, DATA(self)->timeoutSeconds*1000);
return self;
}
int main(int argc, char **argv){
int i;
sqlite *db;
char *zErr;
int status;
int parent = getpid();
unlink("test.db");
unlink("test.db-journal");
db = sqlite_open("test.db", 0, &zErr);
if( db==0 ){
printf("Cannot initialize: %s\n", zErr);
return 1;
}
sqlite_exec(db, "CREATE TABLE t1(a,b)", 0, 0, 0);
sqlite_close(db);
for(i=0; i<10000; i++){
int pid = fork();
if( pid==0 ){
sched_yield();
do_some_sql(parent);
return 0;
}
printf("test %d, pid=%d\n", i, pid);
usleep(rand()%10000 + 1000);
kill(pid, SIGKILL);
waitpid(pid, &status, 0);
}
return 0;
}
bool kr_dbConnect (KR_API *db) {
db->c = sqlite_open (db->database, 0644, &db->dberr);
if ( db->c == NULL ) {
kr_dbError (db);
return false;
}
return true;
}
/*
** Make sure the database is open. If it is not, then open it. If
** the database fails to open, print an error message and exit.
*/
static void open_db(struct callback_data *p){
if( p->db==0 ){
char *zErrMsg = 0;
p->db = db = sqlite_open(p->zDbFilename, 0666, &zErrMsg);
if( db==0 ){
p->db = db = sqlite_open(p->zDbFilename, 0444, &zErrMsg);
if( db==0 ){
if( zErrMsg ){
fprintf(stderr,"Unable to open database \"%s\": %s\n",
p->zDbFilename, zErrMsg);
}else{
fprintf(stderr,"Unable to open database %s\n", p->zDbFilename);
}
exit(1);
}else{
fprintf(stderr,"Database \"%s\" opened READ ONLY!\n", p->zDbFilename);
}
}
}
}
/*
* smb_nic_dbcreate
*
* Creates the host database based on the defined SQL statement.
* It also initializes db_info table.
*/
static int
smb_nic_dbcreate(void)
{
sqlite *db = NULL;
char *errmsg = NULL;
int rc, err = SMB_NIC_SUCCESS;
(void) unlink(SMB_NIC_DB_NAME);
db = sqlite_open(SMB_NIC_DB_NAME, 0600, &errmsg);
if (db == NULL) {
syslog(LOG_ERR, "Failed to create host database (%s).",
NULL_MSGCHK(errmsg));
sqlite_freemem(errmsg);
return (SMB_NIC_DBOPEN_FAILED);
}
sqlite_busy_timeout(db, SMB_NIC_DB_TIMEOUT);
rc = sqlite_exec(db, "BEGIN TRANSACTION", NULL, NULL, &errmsg);
if (rc != SQLITE_OK) {
syslog(LOG_ERR, "Failed to create host database. Unable to " \
"begin database transaction (%s).", NULL_MSGCHK(errmsg));
sqlite_freemem(errmsg);
sqlite_close(db);
return (SMB_NIC_DBEXEC_FAILED);
}
if (sqlite_exec(db, SMB_NIC_DB_SQL, NULL, NULL, &errmsg) == SQLITE_OK) {
rc = sqlite_exec(db, "COMMIT TRANSACTION", NULL, NULL,
&errmsg);
if (rc == SQLITE_OK)
err = smb_nic_dbsetinfo(db);
if (err != SMB_NIC_SUCCESS)
rc = sqlite_exec(db, "ROLLBACK TRANSACTION", NULL, NULL,
&errmsg);
} else {
syslog(LOG_ERR, "Failed to create host database. Unable to " \
"initialize host database (%s).", NULL_MSGCHK(errmsg));
sqlite_freemem(errmsg);
rc = sqlite_exec(db, "ROLLBACK TRANSACTION", NULL, NULL,
&errmsg);
}
if (rc != SQLITE_OK) {
/* this is bad - database may be left in a locked state */
syslog(LOG_ERR, "Failed to create host database. Unable to " \
"close a transaction (%s).", NULL_MSGCHK(errmsg));
sqlite_freemem(errmsg);
err = SMB_NIC_DBINIT_FAILED;
}
(void) sqlite_close(db);
return (err);
}
static void *worker_bee(void *pArg){
const char *zFilename = (char*)pArg;
char *azErr;
int i, cnt;
int t = atoi(zFilename);
char **az;
sqlite *db;
pthread_mutex_lock(&lock);
thread_cnt++;
pthread_mutex_unlock(&lock);
printf("%s: START\n", zFilename);
fflush(stdout);
for(cnt=0; cnt<10; cnt++){
db = sqlite_open(&zFilename[2], 0, &azErr);
if( db==0 ){
fprintf(stdout,"%s: can't open\n", zFilename);
Exit(1);
}
sqlite_busy_handler(db, db_is_locked, zFilename);
db_execute(db, zFilename, "CREATE TABLE t%d(a,b,c);", t);
for(i=1; i<=100; i++){
db_execute(db, zFilename, "INSERT INTO t%d VALUES(%d,%d,%d);",
t, i, i*2, i*i);
}
az = db_query(db, zFilename, "SELECT count(*) FROM t%d", t);
db_check(zFilename, "tX size", az, "100", 0);
az = db_query(db, zFilename, "SELECT avg(b) FROM t%d", t);
db_check(zFilename, "tX avg", az, "101", 0);
db_execute(db, zFilename, "DELETE FROM t%d WHERE a>50", t);
az = db_query(db, zFilename, "SELECT avg(b) FROM t%d", t);
db_check(zFilename, "tX avg2", az, "51", 0);
for(i=1; i<=50; i++){
char z1[30], z2[30];
az = db_query(db, zFilename, "SELECT b, c FROM t%d WHERE a=%d", t, i);
sprintf(z1, "%d", i*2);
sprintf(z2, "%d", i*i);
db_check(zFilename, "readback", az, z1, z2, 0);
}
db_execute(db, zFilename, "DROP TABLE t%d;", t);
sqlite_close(db);
}
printf("%s: END\n", zFilename);
/* unlink(zFilename); */
fflush(stdout);
pthread_mutex_lock(&lock);
thread_cnt--;
if( thread_cnt<=0 ){
pthread_cond_signal(&sig);
}
pthread_mutex_unlock(&lock);
return 0;
}
int SqliteDatabase::connect() {
disconnect();
if (conn = sqlite_open(db.c_str(),0,NULL)) {
//cout << "Connected!\n";
char* err=NULL;
if (setErr(sqlite_exec(getHandle(),"PRAGMA empty_result_callbacks=ON",NULL,NULL,&err),"PRAGMA empty_result_callbacks=ON") != SQLITE_OK) {
return DB_CONNECTION_NONE;
}
active = true;
return DB_CONNECTION_OK;
}
return DB_CONNECTION_NONE;
};
static apr_dbd_t *dbd_sqlite_open(apr_pool_t * pool, const char *params_,
const char **error)
{
apr_dbd_t *sql;
sqlite *conn = NULL;
char *perm;
int iperms = 600;
char* params = apr_pstrdup(pool, params_);
/* params = "[filename]:[permissions]"
* example: "shopping.db:600"
*/
perm = strstr(params, ":");
if (perm) {
*(perm++) = '\x00'; /* split the filename and permissions */
if (strlen(perm) > 0)
iperms = atoi(perm);
}
if (error) {
*error = NULL;
conn = sqlite_open(params, iperms, (char **)error);
if (*error) {
apr_pool_cleanup_register(pool, *error, error_free,
apr_pool_cleanup_null);
}
}
else {
conn = sqlite_open(params, iperms, NULL);
}
sql = apr_pcalloc(pool, sizeof(*sql));
sql->conn = conn;
return sql;
}
// Make sure the database is open. If it is not, then open it. If
// the database fails to open, print an error message and exit.
static void open_db(struct callback_data *p){
if( p->db==0 ){
char *zErrMsg=0;
db=p->db=sqlite_open(p->zDbFilename, 0, &zErrMsg);
if( p->db==0 ){
if( zErrMsg ){
fprintf(stderr,"Unable to open database \"%s\": %s\n",
p->zDbFilename, zErrMsg);
}else{
fprintf(stderr,"Unable to open database %s\n", p->zDbFilename);
}
exit(1);
}
}
}
/*
* smb_nic_dbopen
*
* Opens host database with the given mode.
*/
static sqlite *
smb_nic_dbopen(int mode)
{
sqlite *db;
char *errmsg = NULL;
db = sqlite_open(SMB_NIC_DB_NAME, mode, &errmsg);
if (db == NULL) {
syslog(LOG_ERR, "Failed to open host database: %s (%s).",
SMB_NIC_DB_NAME, NULL_MSGCHK(errmsg));
sqlite_freemem(errmsg);
}
return (db);
}
bool DatabaseSqlite::Initialize(const char *infoString)
{
char *errmsg;
mSqlite = sqlite_open(infoString, 0, &errmsg);
if (!mSqlite)
{
if (errmsg)
sqlite_freemem(errmsg);
return false;
}
return true;
}
static int sqlite_load_module(void)
{
char *zErr;
char fn[PATH_MAX];
int res;
/* is the database there? */
snprintf(fn, sizeof(fn), "%s/astdb.db", ast_config_AST_LOG_DIR);
db = sqlite_open(fn, 0660, &zErr);
if (!db) {
ast_log(LOG_ERROR, "app_dbsqlite: %s\n", zErr);
free(zErr);
return -1;
}
/* is the table there? */
res = sqlite_exec(db, "SELECT COUNT(Id) FROM astdb;", NULL, NULL, &zErr);
if (res) {
res = sqlite_exec(db, sql_create_table, NULL, NULL, &zErr);
if (res) {
ast_log(LOG_ERROR, "app_dbsqlite: Unable to create table 'astdb': %s\n", zErr);
free(zErr);
goto err;
}
/* TODO: here we should probably create an index */
}
res = ast_register_application (g_app, sqliteget_exec, g_synopsis, g_descrip);
if (!res)
res = ast_register_application (p_app, sqliteput_exec, p_synopsis, p_descrip);
if (!res)
res = ast_register_application (d_app, sqlitedel_exec, d_synopsis, d_descrip);
if (!res)
res = ast_register_application (dt_app, sqlitedeltree_exec, dt_synopsis, dt_descrip);
if (res) {
ast_log(LOG_ERROR, "Unable to register app_dbsqlite\n");
return -1;
}
return 0;
err:
if (db)
sqlite_close(db);
return -1;
}
static int SQLite2_connect (dbconn_t * c, const char * host, const char * database, const char * username, const char * password)
{
c->SQLite2.handle = sqlite_open(database, 0666, &c->SQLite2.errormsg);
if (!c->SQLite2.handle) {
sqlite_close(c->SQLite2.handle);
return 0;
}
c->SQLite2.nrows = 0;
c->SQLite2.ncolumns = 0;
c->SQLite2.last_row = 0;
c->SQLite2.step_res = 0;
c->SQLite2.values = NULL;
c->SQLite2.col_names = NULL;
c->SQLite2.vm = NULL;
return 1;
}
static int load_module(void)
{
char *zErr;
char fn[PATH_MAX];
int res;
/* is the database there? */
snprintf(fn, sizeof(fn), "%s/cdr.db", ast_config_AST_LOG_DIR);
db = sqlite_open(fn, 0660, &zErr);
if (!db) {
ast_log(LOG_ERROR, "cdr_sqlite: %s\n", zErr);
free(zErr);
return -1;
}
/* is the table there? */
res = sqlite_exec(db, "SELECT COUNT(id) FROM cdr;", NULL, NULL, NULL);
if (res) {
res = sqlite_exec(db, sql_create_table, NULL, NULL, &zErr);
if (res) {
ast_log(LOG_ERROR, "cdr_sqlite: Unable to create table 'cdr': %s\n", zErr);
free(zErr);
goto err;
}
/*res = sqlite_exec(db, sql_create_trigger, NULL, NULL, &zErr);
if (res) {
ast_log(LOG_ERROR, "cdr_sqlite: Unable to create maxentries trigger: %s\n", zErr);
free(zErr);
goto err;
}*/
/* TODO: here we should probably create an index */
}
res = ast_cdr_register(name, ast_module_info->description, sqlite_log);
if (res) {
ast_log(LOG_ERROR, "Unable to register SQLite CDR handling\n");
return -1;
}
return 0;
err:
if (db)
sqlite_close(db);
return -1;
}
SmoothedCountPlugin::SmoothedCountPlugin(Configuration* config, ContextTracker* ct)
: Plugin(config,
ct,
"SmoothedCountPlugin",
"SmoothedCountPlugin, a linear interpolating unigram bigram trigram plugin",
"SmoothedCountPlugin, long description." )
{
Value value;
try {
value = config->get(LOGGER);
logger << setlevel(value);
logger << INFO << "LOGGER: " << value << endl;
} catch (Configuration::ConfigurationException ex) {
logger << WARN << "Caught ConfigurationException: " << ex.what() << endl;
}
try {
value = config->get(UNIGRAM_WEIGHT);
unigram_weight = toDouble(value);
value = config->get(BIGRAM_WEIGHT);
bigram_weight = toDouble(value);
value = config->get(TRIGRAM_WEIGHT);
trigram_weight = toDouble(value);
value = config->get(DBFILENAME);
dbfilename = value;
} catch (Configuration::ConfigurationException ex) {
logger << ERROR << "Caught fatal ConfigurationException: " << ex.what() << endl;
throw PresageException("Unable to init " + name + " predictive plugin.");
}
// open database
#if defined(HAVE_SQLITE3_H)
int result = sqlite3_open(dbfilename.c_str(), &db);
assert(result == SQLITE_OK);
#elif defined(HAVE_SQLITE_H)
db = sqlite_open(dbfilename.c_str(), 0777, NULL);
assert(db != NULL);
#endif
}
/*
** Connects to a data source.
*/
static int env_connect(lua_State *L)
{
const char *sourcename;
sqlite *conn;
char *errmsg;
getenvironment(L); /* validate environment */
sourcename = luaL_checkstring(L, 2);
conn = sqlite_open(sourcename, 0, &errmsg);
if (conn == NULL)
{
lua_pushnil(L);
lua_pushliteral(L, LUASQL_PREFIX);
lua_pushstring(L, errmsg);
sqlite_freemem(errmsg);
lua_concat(L, 2);
return 2;
}
return create_connection(L, 1, conn);
}
static int load_module(void)
{
char *zErr;
char fn[PATH_MAX];
int res;
ast_log(LOG_NOTICE, "This module has been marked deprecated in favor of "
"using cdr_sqlite3_custom.\n");
/* is the database there? */
snprintf(fn, sizeof(fn), "%s/cdr.db", ast_config_AST_LOG_DIR);
db = sqlite_open(fn, AST_FILE_MODE, &zErr);
if (!db) {
ast_log(LOG_ERROR, "cdr_sqlite: %s\n", zErr);
ast_free(zErr);
return AST_MODULE_LOAD_DECLINE;
}
/* is the table there? */
res = sqlite_exec(db, "SELECT COUNT(AcctId) FROM cdr;", NULL, NULL, NULL);
if (res) {
res = sqlite_exec(db, sql_create_table, NULL, NULL, &zErr);
if (res) {
ast_log(LOG_ERROR, "cdr_sqlite: Unable to create table 'cdr': %s\n", zErr);
ast_free(zErr);
goto err;
}
/* TODO: here we should probably create an index */
}
res = ast_cdr_register(name, ast_module_info->description, sqlite_log);
if (res) {
ast_log(LOG_ERROR, "Unable to register SQLite CDR handling\n");
return AST_MODULE_LOAD_DECLINE;
}
return AST_MODULE_LOAD_SUCCESS;
err:
if (db)
sqlite_close(db);
return AST_MODULE_LOAD_DECLINE;
}
/*
** Make sure the database is open. If it is not, then open it. If
** the database fails to open, print an error message and exit.
*/
static void open_db(struct callback_data *p){
if( p->db==0 ){
char *zErrMsg = 0;
#ifdef SQLITE_HAS_CODEC
int n = p->zKey ? strlen(p->zKey) : 0;
db = p->db = sqlite_open_encrypted(p->zDbFilename, p->zKey, n, 0, &zErrMsg);
#else
db = p->db = sqlite_open(p->zDbFilename, 0, &zErrMsg);
#endif
if( p->db==0 ){
if( zErrMsg ){
fprintf(stderr,"Unable to open database \"%s\": %s\n",
p->zDbFilename, zErrMsg);
}else{
fprintf(stderr,"Unable to open database %s\n", p->zDbFilename);
}
exit(1);
}
}
}
static void do_some_sql(int parent){
char *zErr;
int rc = SQLITE_OK;
sqlite *db;
int cnt = 0;
static char zBig[] =
"-abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
"-abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
if( access("./test.db-journal",0)==0 ){
/*printf("pid %d: journal exists. rollback will be required\n",getpid());*/ unlink("test.db-saved");
system("cp test.db test.db-saved");
unlink("test.db-journal-saved");
system("cp test.db-journal test.db-journal-saved");
}
db = sqlite_open("./test.db", 0, &zErr);
if( db==0 ){
printf("ERROR: %s\n", zErr);
if( strcmp(zErr,"database disk image is malformed")==0 ){
kill(parent, SIGKILL);
}
exit(1);
}
srand(getpid());
while( rc==SQLITE_OK ){
cnt++;
rc = sqlite_exec_printf(db,
"INSERT INTO t1 VALUES(%d,'%d%s')", 0, 0, &zErr,
rand(), rand(), zBig);
}
if( rc!=SQLITE_OK ){
printf("ERROR #%d: %s\n", rc, zErr);
if( rc==SQLITE_CORRUPT ){
kill(parent, SIGKILL);
}
}
printf("pid %d: cnt=%d\n", getpid(), cnt);
}
/*
** Usage: sqlite_open filename
**
** Returns: The name of an open database.
*/
static int sqlite_test_open(
void *NotUsed,
Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
int argc, /* Number of arguments */
char **argv /* Text of each argument */
){
sqlite *db;
char *zErr = 0;
char zBuf[100];
if( argc!=2 ){
Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
" FILENAME\"", 0);
return TCL_ERROR;
}
db = sqlite_open(argv[1], 0666, &zErr);
if( db==0 ){
Tcl_AppendResult(interp, zErr, 0);
free(zErr);
return TCL_ERROR;
}
if( makePointerStr(interp, zBuf, db) ) return TCL_ERROR;
Tcl_AppendResult(interp, zBuf, 0);
return TCL_OK;
}
/*
SQLite dbs have no user name, passwords, hosts or ports.
just file names.
*/
bool QSQLiteDriver::open(const QString & db, const QString &, const QString &, const QString &, int, const QString &)
{
if (isOpen())
close();
if (db.isEmpty())
return FALSE;
char* err = 0;
d->access = sqlite_open(QFile::encodeName(db), 0, &err);
if (err) {
setLastError(QSqlError("Error to open database", err, QSqlError::Connection));
sqlite_freemem(err);
err = 0;
}
if (d->access) {
setOpen(TRUE);
setOpenError(FALSE);
return TRUE;
}
setOpenError(TRUE);
return FALSE;
}
static int sqlite_odbx_bind( odbx_t* handle, const char* database, const char* who, const char* cred, int method )
{
struct sconn* aux = handle->aux;
if( aux == NULL ) { return -ODBX_ERR_PARAM; }
if( method != ODBX_BIND_SIMPLE ) { return -ODBX_ERR_NOTSUP; }
aux->errmsg = NULL;
size_t flen = strlen( database ) + 1;
if( ( aux->path = realloc( aux->path, aux->pathlen + flen + 1 ) ) == NULL )
{
return -ODBX_ERR_NOMEM;
}
snprintf( aux->path + aux->pathlen, flen + 1, "%s", database );
/* The second parameter is currently unused. */
if( ( handle->generic = (void*) sqlite_open( aux->path, 0, NULL ) ) == NULL )
{
aux->errno = SQLITE_CANTOPEN;
aux->errmsg = (char*) dgettext( "opendbx", sqlite_odbx_errmsg[0] );
return -ODBX_ERR_BACKEND;
}
int err;
if( ( err = sqlite_exec( (sqlite*) handle->generic, "PRAGMA empty_result_callbacks = ON;", NULL, NULL, NULL ) ) != SQLITE_OK )
{
aux->errno = err;
aux->errmsg = (char*) sqlite_error_string( err );
return -ODBX_ERR_BACKEND;
}
return ODBX_ERR_SUCCESS;
}
/*
** sqlite DBNAME FILENAME ?MODE? ?-key KEY?
**
** This is the main Tcl command. When the "sqlite" Tcl command is
** invoked, this routine runs to process that command.
**
** The first argument, DBNAME, is an arbitrary name for a new
** database connection. This command creates a new command named
** DBNAME that is used to control that connection. The database
** connection is deleted when the DBNAME command is deleted.
**
** The second argument is the name of the directory that contains
** the sqlite database that is to be accessed.
**
** For testing purposes, we also support the following:
**
** sqlite -encoding
**
** Return the encoding used by LIKE and GLOB operators. Choices
** are UTF-8 and iso8859.
**
** sqlite -version
**
** Return the version number of the SQLite library.
**
** sqlite -tcl-uses-utf
**
** Return "1" if compiled with a Tcl uses UTF-8. Return "0" if
** not. Used by tests to make sure the library was compiled
** correctly.
*/
static int DbMain(void *cd, Tcl_Interp *interp, int objc,Tcl_Obj *const*objv){
int mode;
SqliteDb *p;
void *pKey = 0;
int nKey = 0;
const char *zArg;
char *zErrMsg;
const char *zFile;
char zBuf[80];
if( objc==2 ){
zArg = Tcl_GetStringFromObj(objv[1], 0);
if( strcmp(zArg,"-encoding")==0 ){
Tcl_AppendResult(interp,sqlite_encoding,0);
return TCL_OK;
}
if( strcmp(zArg,"-version")==0 ){
Tcl_AppendResult(interp,sqlite_version,0);
return TCL_OK;
}
if( strcmp(zArg,"-has-codec")==0 ){
#ifdef SQLITE_HAS_CODEC
Tcl_AppendResult(interp,"1",0);
#else
Tcl_AppendResult(interp,"0",0);
#endif
return TCL_OK;
}
if( strcmp(zArg,"-tcl-uses-utf")==0 ){
#ifdef TCL_UTF_MAX
Tcl_AppendResult(interp,"1",0);
#else
Tcl_AppendResult(interp,"0",0);
#endif
return TCL_OK;
}
}
if( objc==5 || objc==6 ){
zArg = Tcl_GetStringFromObj(objv[objc-2], 0);
if( strcmp(zArg,"-key")==0 ){
pKey = Tcl_GetByteArrayFromObj(objv[objc-1], &nKey);
objc -= 2;
}
}
if( objc!=3 && objc!=4 ){
Tcl_WrongNumArgs(interp, 1, objv,
#ifdef SQLITE_HAS_CODEC
"HANDLE FILENAME ?-key CODEC-KEY?"
#else
"HANDLE FILENAME ?MODE?"
#endif
);
return TCL_ERROR;
}
if( objc==3 ){
mode = 0666;
}else if( Tcl_GetIntFromObj(interp, objv[3], &mode)!=TCL_OK ){
return TCL_ERROR;
}
zErrMsg = 0;
p = (SqliteDb*)Tcl_Alloc( sizeof(*p) );
if( p==0 ){
Tcl_SetResult(interp, "malloc failed", TCL_STATIC);
return TCL_ERROR;
}
memset(p, 0, sizeof(*p));
zFile = Tcl_GetStringFromObj(objv[2], 0);
#ifdef SQLITE_HAS_CODEC
p->db = sqlite_open_encrypted(zFile, pKey, nKey, 0, &zErrMsg);
#else
p->db = sqlite_open(zFile, mode, &zErrMsg);
#endif
if( p->db==0 ){
Tcl_SetResult(interp, zErrMsg, TCL_VOLATILE);
Tcl_Free((char*)p);
free(zErrMsg);
return TCL_ERROR;
}
zArg = Tcl_GetStringFromObj(objv[1], 0);
Tcl_CreateObjCommand(interp, zArg, DbObjCmd, (char*)p, DbDeleteCmd);
/* The return value is the value of the sqlite* pointer
*/
sprintf(zBuf, "%p", p->db);
if( strncmp(zBuf,"0x",2) ){
sprintf(zBuf, "0x%p", p->db);
}
Tcl_AppendResult(interp, zBuf, 0);
/* If compiled with SQLITE_TEST turned on, then register the "md5sum"
** SQL function.
*/
#ifdef SQLITE_TEST
{
extern void Md5_Register(sqlite*);
Md5_Register(p->db);
}
#endif
return TCL_OK;
}
int csync_statedb_load(CSYNC *ctx, const char *statedb, sqlite3 **pdb) {
int rc = -1;
c_strlist_t *result = NULL;
sqlite3 *db = NULL;
if( !ctx ) {
return -1;
}
if (ctx->statedb.db) {
CSYNC_LOG(CSYNC_LOG_PRIORITY_NOTICE, "ERR: DB already open");
ctx->status_code = CSYNC_STATUS_PARAM_ERROR;
return -1;
}
ctx->statedb.lastReturnValue = SQLITE_OK;
/* Openthe database */
if (sqlite_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;
ctx->status_code = CSYNC_STATUS_STATEDB_LOAD_ERROR;
goto out;
}
if (_csync_check_db_integrity(db) != 0) {
const char *errmsg= sqlite3_errmsg(db);
CSYNC_LOG(CSYNC_LOG_PRIORITY_NOTICE, "ERR: sqlite3 integrity check failed - bail out: %s.",
errmsg ? errmsg : "<no sqlite3 errormsg>");
rc = -1;
ctx->status_code = CSYNC_STATUS_STATEDB_CORRUPTED;
goto out;
}
if (_csync_statedb_is_empty(db)) {
CSYNC_LOG(CSYNC_LOG_PRIORITY_NOTICE, "statedb contents doesn't exist");
csync_set_statedb_exists(ctx, 0);
} else {
csync_set_statedb_exists(ctx, 1);
}
/* Print out the version */
//
result = csync_statedb_query(db, "SELECT sqlite_version();");
if (result && result->count >= 1) {
CSYNC_LOG(CSYNC_LOG_PRIORITY_NOTICE, "sqlite3 version \"%s\"", *result->vector);
}
c_strlist_destroy(result);
/* optimization for speeding up SQLite */
result = csync_statedb_query(db, "PRAGMA synchronous = NORMAL;");
c_strlist_destroy(result);
result = csync_statedb_query(db, "PRAGMA case_sensitive_like = ON;");
c_strlist_destroy(result);
/* set a busy handler with 5 seconds timeout */
sqlite3_busy_timeout(db, 5000);
#ifndef NDEBUG
sqlite3_profile(db, sqlite_profile, 0 );
#endif
*pdb = db;
CSYNC_LOG(CSYNC_LOG_PRIORITY_NOTICE, "Success");
return 0;
out:
sqlite3_close(db);
return rc;
}
