void SQLiteDatabase::enableAuthorizer(bool enable) { if (m_authorizer && enable) sqlite3_set_authorizer(m_db, SQLiteDatabase::authorizerFunction, m_authorizer.get()); else sqlite3_set_authorizer(m_db, NULL, 0); }
bool PDOSqliteConnection::create(CArrRef options) { String filename = data_source.substr(0,1) == ":" ? String(data_source) : File::TranslatePath(data_source); if (filename.empty()) { throw_pdo_exception(0, Array(), "safe_mode/open_basedir prohibits opening %s", data_source.c_str()); return false; } if (sqlite3_open(filename.data(), &m_db) != SQLITE_OK) { handleError(__FILE__, __LINE__); return false; } sqlite3_set_authorizer(m_db, authorizer, NULL); long timeout = 60; if (options.exists(PDO_ATTR_TIMEOUT)) { timeout = options[PDO_ATTR_TIMEOUT].toInt64(); } sqlite3_busy_timeout(m_db, timeout * 1000); return true; }
static int pdo_sqlite_handle_factory(pdo_dbh_t *dbh, zval *driver_options) /* {{{ */ { pdo_sqlite_db_handle *H; int i, ret = 0; zend_long timeout = 60, flags; char *filename; H = pecalloc(1, sizeof(pdo_sqlite_db_handle), dbh->is_persistent); H->einfo.errcode = 0; H->einfo.errmsg = NULL; dbh->driver_data = H; filename = make_filename_safe(dbh->data_source); if (!filename) { zend_throw_exception_ex(php_pdo_get_exception(), 0, "open_basedir prohibits opening %s", dbh->data_source); goto cleanup; } flags = pdo_attr_lval(driver_options, PDO_SQLITE_ATTR_OPEN_FLAGS, SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE); #if SQLITE_VERSION_NUMBER >= 3005000 i = sqlite3_open_v2(filename, &H->db, flags, NULL); #else i = sqlite3_open(filename, &H->db); #endif efree(filename); if (i != SQLITE_OK) { pdo_sqlite_error(dbh); goto cleanup; } if (PG(open_basedir) && *PG(open_basedir)) { sqlite3_set_authorizer(H->db, authorizer, NULL); } if (driver_options) { timeout = pdo_attr_lval(driver_options, PDO_ATTR_TIMEOUT, timeout); } sqlite3_busy_timeout(H->db, timeout * 1000); dbh->alloc_own_columns = 1; dbh->max_escaped_char_length = 2; ret = 1; cleanup: dbh->methods = &sqlite_methods; return ret; }
int main(int argc, char **argv) { sqlite3 *db; int rc; char *sql; int is_fine = 1; if (access("demo.db", R_OK|W_OK)) { is_fine = 0; } rc = sqlite3_open("demo.db", &db); if(rc) { fprintf(stderr, "Can't open database: %s\n", sqlite3_errmsg(db)); goto quit; } /* initialize db */ if (!is_fine) { rc = _db_init(db); if (rc) { goto quit; } } _db_show_all(db); char name[32]; db_get_account_name_by_id(db, name, 2); fprintf(stdout, "name of id %d is %s\n", 2, name); /* register hooks */ char *data = "this is a hook test"; sqlite3_commit_hook(db, _db_commit_hook, data); sqlite3_update_hook(db, _db_update_hook, data); sqlite3_set_authorizer(db, _db_auth_hook, data); puts("insert"); sql = "insert into account (name,rank) values ('guest',2);"; rc = sqlite3_exec(db, sql, NULL, NULL, NULL); _db_show_all(db); puts("update"); sql = "update account set name='test' where id=4;"; rc = sqlite3_exec(db, sql, NULL, NULL, NULL); _db_show_all(db); puts("delete"); sql = "delete from account where name='test';"; rc = sqlite3_exec(db, sql, NULL, NULL, NULL); _db_show_all(db); quit: sqlite3_close(db); return 0; }
/* call-seq: set_authorizer = auth * * Set the authorizer for this database. +auth+ must respond to +call+, and * +call+ must take 5 arguments. * * Installs (or removes) a block that will be invoked for every access * to the database. If the block returns 0 (or +true+), the statement * is allowed to proceed. Returning 1 or false causes an authorization error to * occur, and returning 2 or nil causes the access to be silently denied. */ static VALUE set_authorizer(VALUE self, VALUE authorizer) { sqlite3RubyPtr ctx; int status; Data_Get_Struct(self, sqlite3Ruby, ctx); REQUIRE_OPEN_DB(ctx); status = sqlite3_set_authorizer( ctx->db, NIL_P(authorizer) ? NULL : rb_sqlite3_auth, (void *)self ); CHECK(ctx->db, status); rb_iv_set(self, "@authorizer", authorizer); return self; }
void database::set_authorize_handler(authorize_handler h) { ah_ = h; sqlite3_set_authorizer(db_, ah_ ? authorizer_impl : 0, &ah_); }
/*-------------------------------------------------------------------------*/ svalue_t * f_sl_open (svalue_t *sp) /* EFUN sl_open * * int sl_open(string filename) * * Opens the file <filename> for use as a SQLite database. * If the file doesn't exists it will be created. * Only one open file per object is allowed. On success this * function returns 1, otherwise usually an error is thrown. */ { string_t *file; sqlite3 *db; sqlite_dbs_t *tmp; int err; file = check_valid_path(sp->u.str, current_object, STR_SQLITE_OPEN , MY_TRUE); if (!file) errorf("Illegal use of sl_open('%s')\n", get_txt(sp->u.str)); tmp = find_db (current_object); if (tmp) { free_mstring(file); errorf("The current object already has a database open.\n"); } err = sqlite3_open (get_txt(file), &db); free_mstring(file); if (err) { const char* msg = sqlite3_errmsg(db); sqlite3_close(db); errorf("sl_open: %s\n", msg ); /* NOTREACHED */ } /* create a new chain link and hang on the old chain */ tmp = new_db(); if(!tmp) { sqlite3_close(db); errorf("(sl_open) Out of memory: (%lu bytes)\n", (unsigned long) sizeof(*tmp)); } tmp->db = db; tmp->obj = current_object; current_object->open_sqlite_db = MY_TRUE; /* Synchronous is damn slow. Forget it. */ sqlite3_exec(db, "PRAGMA synchronous = OFF", NULL, NULL, NULL); sqlite3_set_authorizer(db, my_sqlite3_authorizer, NULL); free_string_svalue (sp); put_number (sp, 1); return sp; } /* f_sl_open() */
DLL_FUNCTION(int32_t) BU_SQLite_Set_Authorizer(sqlite3* db, int(*xAuth)(void*, int, const char*, const char*, const char*, const char*), void *pArg) { #pragma comment(linker, "/EXPORT:BU_SQLite_Set_Authorizer=_BU_SQLite_Set_Authorizer@12") return sqlite3_set_authorizer(db, xAuth, pArg); }
/** @SYMTestCaseID SYSLIB-SQLITE3-UT-4004 @SYMTestCaseDesc Database handle SQLITE3 tests. List of called SQLITE3 functions: - sqlite3_config; - sqlite3_initialize; - sqlite3_threadsafe; - sqlite3_vfs_find; - sqlite3_open; - sqlite3_db_config; - sqlite3_libversion; - sqlite3_libversion_number; - sqlite3_set_authorizer; - sqlite3_commit_hook; - sqlite3_rollback_hook; - sqlite3_update_hook; - sqlite3_close; - sqlite3_shutdown; @SYMTestPriority High @SYMTestActions Database handle SQLITE3 tests. @SYMTestExpectedResults Test must not fail @SYMREQ REQ8782 */ static void TestSqliteApi() { void* prev = 0; const char* libverstr = 0; int libvernum = 0; int err; int threadSafe = -1; sqlite3_vfs* vfs = 0; TEST(!TheDb); TestStart("@SYMTestCaseID:SYSLIB-SQLITE3-UT-4004: Test \"sqlite3_config()\""); err = sqlite3_config(SQLITE_CONFIG_MEMSTATUS, 0); TEST2(err, SQLITE_OK); TestNext("Test \"sqlite3_initialize()\""); err = sqlite3_initialize(); TEST2(err, SQLITE_OK); TestNext("Test \"sqlite3_threadsafe()\""); threadSafe = sqlite3_threadsafe(); PrintI("SQLITE_THREADSAFE=%d\r\n", threadSafe); vfs = sqlite3_vfs_find(0); TEST(vfs != NULL); PrintS("Vfs name=\"%s\"\r\n", vfs->zName); err = sqlite3_open(TheTestDbName, &TheDb); TEST2(err, SQLITE_OK); TEST(TheDb != 0); err = sqlite3_db_config(TheDb, SQLITE_DBCONFIG_LOOKASIDE, 0, 128, 100); TEST2(err, SQLITE_OK); libverstr = sqlite3_libversion(); libvernum = sqlite3_libversion_number(); PrintSI("SQLITE version: \"%s\", Number: %d\r\n", libverstr, libvernum); err = sqlite3_set_authorizer(TheDb, &authorizer_callback, 0); TEST2(err, SQLITE_OK); prev = sqlite3_commit_hook(TheDb, &commit_hook, 0); TEST(!prev); prev = sqlite3_rollback_hook(TheDb, &rollback_hook, 0); TEST(!prev); prev = sqlite3_update_hook(TheDb, &update_hook, 0); TEST(!prev); TestNext("@SYMTestCaseID:SYSLIB-SQLITE3-UT-4001: Test \"sqlite3\" handle API"); TestExec(); TestNext("@SYMTestCaseID:SYSLIB-SQLITE3-UT-4002: Test \"sqlite3_stmt\" handle API-1"); TestStatement1(); TestNext("@SYMTestCaseID:SYSLIB-SQLITE3-UT-4003: Test \"sqlite3_stmt\" handle API-2"); TestStatement2(); TestNext("@SYMTestCaseID:PDS-SQLITE3-UT-4038: Test more sqlite3 API"); TestSqliteApi2(); TestNext("@SYMTestCaseID:PDS-SQLITE3-UT-4039: Test blob API"); TestSqliteBlobApi(); TestNext("@SYMTestCaseID:PDS-SQLITE3-UT-4040: Test mutex API"); TestSqliteMutexApi(); err = sqlite3_close(TheDb); TEST2(err, SQLITE_OK); TheDb = 0; TestNext("Test \"sqlite3_shutdown()\""); err = sqlite3_shutdown(); TEST2(err, SQLITE_OK); err = remove(TheTestDbName); TEST2(err, 0); }