/* ** Implementation of the scalar function fts3_tokenizer_internal_test(). ** This function is used for testing only, it is not included in the ** build unless SQLITE4_TEST is defined. ** ** The purpose of this is to test that the fts3_tokenizer() function ** can be used as designed by the C-code in the queryTokenizer and ** registerTokenizer() functions above. These two functions are repeated ** in the README.tokenizer file as an example, so it is important to ** test them. ** ** To run the tests, evaluate the fts3_tokenizer_internal_test() scalar ** function with no arguments. An assert() will fail if a problem is ** detected. i.e.: ** ** SELECT fts3_tokenizer_internal_test(); ** */ static void intTestFunc( sqlite4_context *context, int argc, sqlite4_value **argv ){ int rc; const sqlite4_tokenizer_module *p1; const sqlite4_tokenizer_module *p2; sqlite4 *db = (sqlite4 *)sqlite4_user_data(context); UNUSED_PARAMETER(argc); UNUSED_PARAMETER(argv); /* Test the query function */ sqlite4Fts3SimpleTokenizerModule(&p1); rc = queryTokenizer(db, "simple", &p2); assert( rc==SQLITE4_OK ); assert( p1==p2 ); rc = queryTokenizer(db, "nosuchtokenizer", &p2); assert( rc==SQLITE4_ERROR ); assert( p2==0 ); assert( 0==strcmp(sqlite4_errmsg(db), "unknown tokenizer: nosuchtokenizer") ); /* Test the storage function */ rc = registerTokenizer(db, "nosuchtokenizer", p1); assert( rc==SQLITE4_OK ); rc = queryTokenizer(db, "nosuchtokenizer", &p2); assert( rc==SQLITE4_OK ); assert( p2==p1 ); sqlite4_result_text(context, "ok", -1, SQLITE4_STATIC); }
PyObject* pysqlite_backup_step(pysqlite_Backup* self, PyObject* args, PyObject* kwargs) { int npages; if (!PyArg_ParseTuple(args, "i", &npages)) { return NULL; } int rc = sqlite4_backup_step(self->backup, npages); if (rc == SQLITE4_DONE) { Py_RETURN_TRUE; } else if (rc == SQLITE4_OK) { Py_RETURN_FALSE; } else { PyErr_SetString(pysqlite_OperationalError, sqlite4_errmsg(self->source_con->db)); return NULL; } }
int main (int argc, char *argv[]) { int err; int res; sigset_t set; BIO *acc; SSL_CTX *sslctx; struct freeq_ctx *freeqctx; struct freeqd_state fst; pthread_t t_monitor; pthread_t t_status_logger; pthread_t t_sqlserver; pthread_t t_cliserver; static stralloc clients = {0}; err = freeq_new(&freeqctx, "appname", "identity", FREEQ_SERVER); if (err < 0) exit(EXIT_FAILURE); freeq_set_log_priority(freeqctx, 10); sigemptyset(&set); sigaddset(&set, SIGHUP); sigaddset(&set, SIGINT); sigaddset(&set, SIGUSR1); sigaddset(&set, SIGUSR2); sigaddset(&set, SIGALRM); pthread_sigmask(SIG_BLOCK, &set, NULL); dbg(freeqctx, "starting monitor thread\n"); pthread_create(&t_monitor, 0, &monitor, pDb); init_freeqd_state(freeqctx, &fst); dbg(freeqctx, "reading clients file\n"); if (control_readfile(&clients,(char *)"control/clients",1)) { dbg(freeqctx, "clients present, setting up agg database\n"); //pthread_create(&t_aggregator, 0, &aggregator, (void *)&ri); //res = sqlite4_open(0, ":memory:", &pDb, 0); res = sqlite4_open(0, "ondisk.db", &pDb, SQLITE4_OPEN_READWRITE | SQLITE4_OPEN_CREATE,NULL); if (res != SQLITE4_OK) { err(freeqctx, "failed to open in-memory db\n"); exit(res); } } else { dbg(freeqctx, "failed to read clients file, database not initialized\n"); } struct srv_ctx status_ctx; status_ctx.pDb = pDb; status_ctx.fst = &fst; status_ctx.freeqctx = freeqctx; struct srv_ctx *sctx = &status_ctx; pthread_create(&t_status_logger, 0, &status_logger, (void *)sctx); //if (control_readfile(&clients,"",1) != 1) // pthread_create(&t_receiver, 0, &receiver, (void *)&ri); // pthread_create(&t_recvinvite, 0, &recvinvite, (void *)recvinvite_nnuri); //} res = sqlite4_exec(pDb, "create table if not exists freeq_stats(int last);", NULL, NULL); if (res != SQLITE4_OK) { printf("creating freeq_stats failed: %d %s\n", res, sqlite4_errmsg(pDb)); } pthread_create(&t_sqlserver, 0, &sqlserver, (void *)sctx); pthread_create(&t_cliserver, 0, &cliserver, (void *)sctx); while (1) { sleep(1); } SSL_CTX_free(sslctx); BIO_free(acc); freeq_unref(freeqctx); return 0; }
void* sqlhandler(void *arg) { char sql[MAX_MSG]; int ret, err; SSL *ssl; sqlite4_stmt *pStmt; struct conn_ctx *conn = (struct conn_ctx *)arg; struct freeq_ctx *freeqctx = conn->srvctx->freeqctx; BIO *client = conn->client; if (!(ssl = freeq_ssl_new(freeqctx))) { err(freeqctx, "couldn't allocate new ssl instance"); BIO_free_all(client); free(conn); pthread_exit(NULL); } SSL_set_bio(ssl, client, client); if (SSL_accept(ssl) <= 0) { int_error("Error accepting SSL connection"); BIO_free_all(client); free(conn); pthread_exit(NULL); } if ((err = post_connection_check(freeqctx, ssl, "localhost")) != X509_V_OK) { err(freeqctx, "error: peer certificate: %s\n", X509_verify_cert_error_string(err)); BIO_free_all(client); free(conn); pthread_exit(NULL); } BIO *b, *ssl_bio; b = BIO_new(BIO_f_buffer()); ssl_bio = BIO_new(BIO_f_ssl()); BIO_set_ssl(ssl_bio, ssl, BIO_CLOSE); BIO_push(b, ssl_bio); memset(sql, 0, MAX_MSG); ret = BIO_gets(b, sql, MAX_MSG); ret = sqlite4_prepare(pDb, sql, strlen(sql), &pStmt, 0); if (ret != SQLITE4_OK) { dbg(freeqctx, "prepare failed for %s sending error, ret was %d\n", sql, ret); //freeq_error_write_sock(freeqctx, sqlite4_errmsg(pDb), b); dbg(freeqctx, sqlite4_errmsg(pDb)); //BIO_printf(b, "error: %s\n", sqlite4_errmsg(pDb)); sqlite4_finalize(pStmt); //pthread_exit(FREEQ_ERR); } freeq_sqlite_to_bio(freeqctx, b, pStmt); SSL_shutdown(ssl); SSL_free(ssl); BIO_free_all(client); free(conn); pthread_exit(FREEQ_OK); }
int tbl_to_db(struct freeq_ctx *ctx, struct freeq_table *tbl, sqlite4 *mDb) { sqlite4_stmt *stmt; GString *sql = g_string_sized_new(255); GSList *colp[tbl->numcols]; memset(colp, 0, tbl->numcols * sizeof(GSList *) ); for (int j = 0; j < tbl->numcols; j++) colp[j] = tbl->columns[j].data; int res; freeq_table_print(ctx, tbl, stdout); if (sqlite4_exec(mDb, "BEGIN TRANSACTION;", NULL, NULL) != SQLITE4_OK) { dbg(ctx, "unable to start transaction: %s\n", sqlite4_errmsg(mDb)); return 1; } g_string_printf(sql, "DROP TABLE %s;", tbl->name); if (sqlite4_exec(mDb, sql->str, NULL, NULL) != SQLITE4_OK) dbg(ctx, "failed to drop table, ignoring\n"); table_ddl(ctx, tbl, sql); if (sqlite4_exec(mDb, sql->str, NULL, NULL) != SQLITE4_OK) { dbg(ctx, "failed to create table, rolling back\n"); sqlite4_exec(mDb, "ROLLBACK;", NULL, NULL); g_string_free(sql, 1); return 1; } ddl_insert(ctx, tbl, sql); if ((res = sqlite4_prepare(mDb, sql->str, sql->len, &stmt, NULL)) != SQLITE4_OK) { dbg(ctx, "failed to create statement (%d), rolling back\n", res); sqlite4_exec(mDb, "ROLLBACK;", NULL, NULL); g_string_free(sql,1); return 1; } g_string_free(sql,1); for (uint32_t i = 0; i < tbl->numrows; i++) { for (uint32_t j = 0; j < tbl->numcols; j++) { switch (tbl->columns[j].coltype) { case FREEQ_COL_STRING: res = sqlite4_bind_text(stmt, j+1, colp[j]->data == NULL ? "" : colp[j]->data, colp[j]->data == NULL ? 0 : strlen(colp[j]->data), SQLITE4_TRANSIENT, NULL); if (res != SQLITE4_OK) { dbg(ctx, "stmt: %s\n", (char *)stmt); dbg(ctx, "row %d failed binding string column %d %s: %s (%d)\n", i, j, (char *)colp[j]->data, sqlite4_errmsg(mDb), res); } break; case FREEQ_COL_NUMBER: res = sqlite4_bind_int(stmt, j, GPOINTER_TO_INT(colp[j]->data)); if (res != SQLITE4_OK) { dbg(ctx, "row %d failed bind: %s\n", i, sqlite4_errmsg(mDb)); } break; default: break; } colp[j] = g_slist_next(colp[j]); } if (sqlite4_step(stmt) != SQLITE4_DONE) { dbg(ctx, "execute failed: %s\n", sqlite4_errmsg(mDb)); sqlite4_exec(mDb, "ROLLBACK;", NULL, NULL); sqlite4_finalize(stmt); return -1; } else { sqlite4_reset(stmt); } } dbg(ctx, "committing transaction\n"); res = sqlite4_exec(mDb, "COMMIT TRANSACTION;", NULL, NULL); dbg(ctx, "result of commit was %d\n", res); sqlite4_finalize(stmt); return 0; }