main/kamailio: added initial sqlite support

(cherry picked from commit dbf41463486771f239ff2b8c16603ca1dd7cd0cf)

2 files changed, 724 insertions, 4 deletions

diff --git a/main/kamailio/APKBUILD b/main/kamailio/APKBUILD
index 220f7ad8f4..90d044eada 100644
--- a/main/kamailio/APKBUILD
+++ b/main/kamailio/APKBUILD
@@ -2,7 +2,7 @@
 # Maintainer: Natanael Copa <ncopa@alpinelinux.org>
 pkgname=kamailio
 pkgver=3.0.3
-pkgrel=0
+pkgrel=1
 pkgdesc="Open Source SIP Server"
 url="http://www.kamailio.org/"
 pkgusers="kamailio"
@@ -10,7 +10,7 @@ pkggroups="kamailio"
 license="GPL"
 depends=
 makedepends="bison flex expat-dev postgresql-dev pcre-dev mysql-dev
-	libxml2-dev curl-dev unixodbc-dev confuse-dev ncurses-dev"
+	libxml2-dev curl-dev unixodbc-dev confuse-dev ncurses-dev sqlite-dev"
 install="$pkgname.pre-install $pkgname.pre-upgrade"
 subpackages="$pkgname-doc $pkgname-postgres $pkgname-presence $pkgname-pcre
 	$pkgname-mediaproxy $pkgname-unixodbc $pkgname-mysql"
@@ -18,6 +18,7 @@ source="http://www.kamailio.org/pub/kamailio/$pkgver/src/kamailio-${pkgver}_src.
 	kamailio.cfg
 	kamailio.initd
 	kamailio-3-backslash.patch
+	sqlite.patch
 	"
 
 _builddir="$srcdir"/$pkgname-$pkgver
@@ -36,7 +37,14 @@ _modules="$_default $_postgres $_mediaproxy $_odbc $_presence $_mysql $_pcre"
 
 prepare() {
 	cd "$_builddir"
-	patch -p1 -i "$srcdir"/kamailio-3-backslash.patch || return 1
+	for i in $source; do
+		case $i in
+		*.patch)
+			msg "Apllying $i"
+			patch -p1 -i "$srcdir"/$i || return 1
+			;;
+		esac
+	done
 
 	sed -i \
 		-e "s:-O9 -funroll-loops:$CFLAGS:g" \
@@ -159,4 +167,5 @@ unixodbc() {
 md5sums="eac755ba385d9ed68388abbf74b2b1c1  kamailio-3.0.3_src.tar.gz
 a3c959ec568c43a905710e7d25cd8c25  kamailio.cfg
 81100c479890a2a8c2628db22fdd1a0c  kamailio.initd
-36f81be3a082a81497e261ac8e6c5414  kamailio-3-backslash.patch"
+36f81be3a082a81497e261ac8e6c5414  kamailio-3-backslash.patch
+ed43b0d8d60b1e87199ce18ba326ccee  sqlite.patch"
diff --git a/main/kamailio/sqlite.patch b/main/kamailio/sqlite.patch
new file mode 100644
index 0000000000..68338ea96f
--- /dev/null
+++ b/main/kamailio/sqlite.patch
@@ -0,0 +1,711 @@
+commit 09d0be81bbc95caf323b2ce3da8bf4f1ee8aa9d4
+Author: Natanael Copa <ncopa@alpinelinux.org>
+Date:   Tue Aug 24 13:13:34 2010 +0000
+
+    add support for sqlite
+
+diff --git a/modules_k/db_sqlite/Makefile b/modules_k/db_sqlite/Makefile
+new file mode 100644
+index 0000000..9a75593
+--- /dev/null
++++ b/modules_k/db_sqlite/Makefile
+@@ -0,0 +1,15 @@
++# $Id$
++#
++# WARNING: do not run this directly, it should be run by the master Makefile
++
++include ../../Makefile.defs
++auto_gen=
++NAME=db_sqlite.so
++
++LIBS +=-lsqlite3
++
++DEFS+=-DOPENSER_MOD_INTERFACE
++
++SERLIBPATH=../../lib
++SER_LIBS+=$(SERLIBPATH)/srdb1/srdb1
++include ../../Makefile.modules
+diff --git a/modules_k/db_sqlite/db_sqlite.c b/modules_k/db_sqlite/db_sqlite.c
+new file mode 100644
+index 0000000..1ec1267
+--- /dev/null
++++ b/modules_k/db_sqlite/db_sqlite.c
+@@ -0,0 +1,92 @@
++/*
++ * $Id$
++ *
++ * SQlite module interface
++ *
++ * Copyright (C) 2010 Timo Teräs
++ *
++ * This file is part of Kamailio, a free SIP server.
++ *
++ * Kamailio is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; either version 2 of the License, or
++ * (at your option) any later version
++ *
++ * Kamailio is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program; if not, write to the Free Software
++ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
++ */
++
++#include <sys/time.h>
++#include <sqlite3.h>
++
++#include "../../sr_module.h"
++#include "../../lib/srdb1/db.h"
++#include "dbase.h"
++
++MODULE_VERSION
++
++static int sqlite_bind_api(db_func_t *dbb)
++{
++	if(dbb==NULL)
++		return -1;
++
++	memset(dbb, 0, sizeof(db_func_t));
++
++	dbb->use_table		= db_sqlite_use_table;
++	dbb->init		= db_sqlite_init;
++	dbb->close		= db_sqlite_close;
++	dbb->free_result	= db_sqlite_free_result;
++	dbb->query		= db_sqlite_query;
++	dbb->insert		= db_sqlite_insert;
++	dbb->delete		= db_sqlite_delete; 
++	dbb->update		= db_sqlite_update;
++#if 0
++	dbb->raw_query		= db_oracle_raw_query;
++#endif
++
++	return 0;
++}
++
++static cmd_export_t cmds[] = {
++	{"db_bind_api", (cmd_function)sqlite_bind_api, 0, 0, 0, 0},
++	{0, 0, 0, 0, 0, 0}
++};
++
++static int sqlite_mod_init(void)
++{
++	sqlite3_initialize();
++
++	LM_INFO("SQlite library version %s (compiled using %s)\n",
++		sqlite3_libversion(),
++		SQLITE_VERSION);
++	return 0;
++}
++
++
++static void sqlite_mod_destroy(void)
++{
++	LM_INFO("SQlite terminate\n");
++
++	sqlite3_shutdown();
++}
++
++struct module_exports exports = {
++	"db_sqlite",
++	DEFAULT_DLFLAGS,	/* dlopen flags */
++	cmds,			/* module commands */
++	0,			/* module parameters */
++	0,			/* exported statistics */
++	0,			/* exported MI functions */
++	0,			/* exported pseudo-variables */
++	0,			/* extra processes */
++	sqlite_mod_init,	/* module initialization function */
++	0,			/* response function*/
++	sqlite_mod_destroy,	/* destroy function */
++	0			/* per-child init function */
++};
+diff --git a/modules_k/db_sqlite/dbase.c b/modules_k/db_sqlite/dbase.c
+new file mode 100644
+index 0000000..9ae1bdb
+--- /dev/null
++++ b/modules_k/db_sqlite/dbase.c
+@@ -0,0 +1,504 @@
++/*
++ * $Id$
++ *
++ * SQlite module core functions
++ *
++ * Copyright (C) 2010 Timo Teräs
++ *
++ * This file is part of Kamailio, a free SIP server.
++ *
++ * Kamailio is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; either version 2 of the License, or
++ * (at your option) any later version
++ *
++ * Kamailio is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program; if not, write to the Free Software
++ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
++ */
++
++#include "../../mem/mem.h"
++#include "../../dprint.h"
++#include "../../lib/srdb1/db_pool.h"
++#include "../../lib/srdb1/db_ut.h"
++#include "../../lib/srdb1/db_res.h"
++#include "../../lib/srdb1/db_query.h"
++#include "dbase.h"
++
++static time_t sqlite_to_timet(double rT)
++{
++	return 86400.0*(rT - 2440587.5) + 0.5;
++}
++
++static double timet_to_sqlite(time_t t)
++{
++	return ((((double) t) - 0.5) / 86400.0) + 2440587.5;
++}
++
++/*
++ * Initialize database module
++ * No function should be called before this
++ */
++
++static struct sqlite_connection * db_sqlite_new_connection(const struct db_id* id)
++{
++	struct sqlite_connection *con;
++	int rc;
++
++	con = pkg_malloc(sizeof(*con));
++	if (!con) {
++		LM_ERR("failed to allocate driver connection\n");
++		return NULL;
++	}
++
++	memset(con, 0, sizeof(*con));
++	con->hdr.ref = 1;
++	con->hdr.id = (struct db_id*) id; /* set here - freed on error */
++
++	rc = sqlite3_open_v2(id->database, &con->conn,
++		SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, NULL);
++	if (rc != SQLITE_OK) {
++		pkg_free(con);
++		LM_ERR("failed to open sqlite database '%s'\n", id->database);
++		return NULL;
++	}
++
++	return con;
++}
++
++db1_con_t* db_sqlite_init(const str* _url)
++{
++	return db_do_init(_url, (void *) db_sqlite_new_connection);
++}
++
++
++/*
++ * Shut down database module
++ * No function should be called after this
++ */
++
++static void db_sqlite_free_connection(struct sqlite_connection* con)
++{
++	if (!con) return;
++
++	sqlite3_close(con->conn);
++	free_db_id(con->hdr.id);
++	pkg_free(con);
++}
++
++void db_sqlite_close(db1_con_t* _h)
++{
++	db_do_close(_h, db_sqlite_free_connection);
++}
++
++/*
++ * Release a result set from memory
++ */
++int db_sqlite_free_result(db1_con_t* _h, db1_res_t* _r)
++{
++	if (!_h || !_r) {
++		LM_ERR("invalid parameter value\n");
++		return -1;
++	}
++
++	if (db_free_result(_r) < 0)
++	{
++		LM_ERR("failed to free result structure\n");
++		return -1;
++	}
++	return 0;
++}
++
++/*
++ * Store name of table that will be used by
++ * subsequent database functions
++ */
++int db_sqlite_use_table(db1_con_t* _h, const str* _t)
++{
++	return db_use_table(_h, _t);
++}
++
++/*
++ * Reset query context
++ */
++static void db_sqlite_cleanup_query(const db1_con_t* _c)
++{
++	struct sqlite_connection *conn = CON_SQLITE(_c);
++	int rc;
++
++	if (conn->stmt != NULL) {
++		rc = sqlite3_finalize(conn->stmt);
++		if (rc != SQLITE_OK)
++			LM_ERR("finalize failed: %s\n",
++				sqlite3_errmsg(conn->conn));
++	}
++
++	conn->stmt = NULL;
++	conn->bindpos = 0;
++}
++
++/*
++ * Convert value to sql-string as db bind index
++ */
++static int db_sqlite_val2str(const db1_con_t* _c, const db_val_t* _v, char* _s, int* _len)
++{
++	struct sqlite_connection *conn;
++	int ret;
++
++	if (!_c || !_v || !_s || !_len || *_len <= 0) {
++		LM_ERR("invalid parameter value\n");
++		return -1;
++	}
++
++	conn = CON_SQLITE(_c);
++	if (conn->bindpos >= DB_SQLITE_MAX_BINDS) {
++		LM_ERR("too many bindings, recompile with larger DB_SQLITE_MAX_BINDS\n");
++		return -2;
++	}
++
++	conn->bindarg[conn->bindpos] = _v;
++	ret = snprintf(_s, *_len, "?%u", ++conn->bindpos);
++	if ((unsigned)ret >= (unsigned) *_len)
++		return -11;
++
++	*_len = ret;
++	return 0;
++}
++
++/*
++ * Send an SQL query to the server
++ */
++static int db_sqlite_submit_query(const db1_con_t* _h, const str* _s)
++{
++	struct sqlite_connection *conn = CON_SQLITE(_h);
++	sqlite3_stmt *stmt;
++	const db_val_t *val;
++	int rc, i;
++
++	LM_DBG("submit_query: %.*s\n", _s->len, _s->s);
++
++	rc = sqlite3_prepare_v2(conn->conn, _s->s, _s->len, &stmt, NULL);
++	if (rc != SQLITE_OK) {
++		LM_ERR("failed to prepare statement: %s\n",
++			sqlite3_errmsg(conn->conn));
++		return -1;
++	}
++	conn->stmt = stmt;
++
++	for (i = 1; i <= conn->bindpos; i++) {
++		val = conn->bindarg[i-1];
++		if (VAL_NULL(val)) {
++			rc = sqlite3_bind_null(stmt, i);
++		} else switch (VAL_TYPE(val)) {
++		case DB1_INT:
++			rc = sqlite3_bind_int(stmt, i, VAL_INT(val));
++			break;
++		case DB1_BIGINT:
++			rc = sqlite3_bind_int64(stmt, i, VAL_BIGINT(val));
++			break;
++		case DB1_DOUBLE:
++			rc = sqlite3_bind_double(stmt, i, VAL_DOUBLE(val));
++			break;
++		case DB1_STRING:
++			rc = sqlite3_bind_text(stmt, i,
++				VAL_STRING(val), -1, NULL);
++			break;
++		case DB1_STR:
++			rc = sqlite3_bind_text(stmt, i,
++				VAL_STR(val).s, VAL_STR(val).len, NULL);
++			break;
++		case DB1_DATETIME:
++			rc = sqlite3_bind_double(stmt, i, timet_to_sqlite(VAL_TIME(val)));
++			break;
++		case DB1_BLOB:
++			rc = sqlite3_bind_blob(stmt, i,
++				VAL_BLOB(val).s, VAL_BLOB(val).len,
++				NULL);
++			break;
++		case DB1_BITMAP:
++			rc = sqlite3_bind_int(stmt, i, VAL_BITMAP(val));
++			break;
++		default:
++			LM_ERR("unknown bind value type %d\n", VAL_TYPE(val));
++			return -1;
++		}
++		if (rc != SQLITE_OK) {
++			LM_ERR("Parameter bind failed: %s\n",
++				sqlite3_errmsg(conn->conn));
++			return -1;
++		}
++	}
++
++	return 0;
++}
++
++static int decltype_to_dbtype(const char *decltype)
++{
++	/* SQlite3 has dynamic typing. It does not store the actual
++	 * exact type, instead it uses 'affinity' depending on the
++	 * value. We have to go through the declaration types to see
++	 * what to return. */
++	if (strstr(decltype, "INT") != NULL ||
++	    strncasecmp(decltype, "SERIAL", 6) == 0)
++		return DB1_INT;
++	if (strstr(decltype, "CHAR") != NULL ||
++	    strstr(decltype, "TEXT") != NULL)
++		return DB1_STR;
++	if (strstr(decltype, "REAL") != NULL ||
++	    strstr(decltype, "FLOA") != NULL ||
++	    strstr(decltype, "DOUB") != NULL)
++		return DB1_DOUBLE;
++	if (strstr(decltype, "BLOB") != NULL)
++		return DB1_BLOB;
++	if (strncasecmp(decltype, "TIME", 4) == 0 ||
++	    strncasecmp(decltype, "DATE", 4) == 0)
++		return DB1_DATETIME;
++
++	LM_ERR("sqlite decltype '%s' not recognized, defaulting to int",
++	       decltype);
++	return DB1_INT;
++}
++
++static str* str_dup(const char *_s)
++{
++	str *s;
++	int len = strlen(_s);
++
++	s = (str*) pkg_malloc(sizeof(str)+len+1);
++	s->len = len;
++	s->s = ((char*)s) + sizeof(str);
++	memcpy(s->s, _s, len);
++	s->s[len] = '\0';
++
++	return s;
++}
++
++static void str_assign(str* s, const char *_s, int len)
++{
++	s->s = (char *) pkg_malloc(len);
++	s->len = len;
++	memcpy(s->s, _s, len);
++}
++
++/*
++ * Read database answer and fill the structure
++ */
++int db_sqlite_store_result(const db1_con_t* _h, db1_res_t** _r)
++{
++	struct sqlite_connection *conn = CON_SQLITE(_h);
++	db1_res_t *res;
++	int i, rc, num_rows = 0, num_alloc = 0;
++	db_row_t *rows = NULL, *row;
++	db_val_t *val;
++
++	res = db_new_result();
++	if (res == NULL)
++		goto no_mem;
++
++	while (1) {
++		rc = sqlite3_step(conn->stmt);
++		if (rc == SQLITE_DONE) {
++			*_r = res;
++			return 0;
++		}
++		if (rc != SQLITE_ROW) {
++			LM_INFO("sqlite3_step failed: %s\n", sqlite3_errmsg(conn->conn));
++			goto err;
++		}
++		if (num_rows == 0) {
++			/* get column types */
++			rc = sqlite3_column_count(conn->stmt);
++			if (db_allocate_columns(res, rc) != 0)
++				goto err;
++			RES_COL_N(res) = rc;
++
++			for (i = 0; i < RES_COL_N(res); i++) {
++				RES_NAMES(res)[i] = str_dup(sqlite3_column_name(conn->stmt, i));
++				RES_TYPES(res)[i] = decltype_to_dbtype(sqlite3_column_decltype(conn->stmt, i));
++			}
++		}
++		if (num_rows >= num_alloc) {
++			if (num_alloc)
++				num_alloc *= 2;
++			else
++				num_alloc = 8;
++			rows = pkg_realloc(rows, sizeof(db_row_t) * num_alloc);
++			if (rows == NULL)
++				goto no_mem;
++			RES_ROWS(res) = rows;
++		}
++
++		row = &RES_ROWS(res)[num_rows];
++		num_rows++;
++		RES_ROW_N(res) = num_rows;		/* rows in this result set */
++		RES_NUM_ROWS(res) = num_rows;		/* rows in total */
++
++		if (db_allocate_row(res, row) != 0)
++			goto no_mem;
++
++		for (i = 0, val = ROW_VALUES(row); i < RES_COL_N(res); i++, val++) {
++			VAL_TYPE(val) = RES_TYPES(res)[i];
++			VAL_NULL(val) = 0;
++			VAL_FREE(val) = 0;
++			if (sqlite3_column_type(conn->stmt, i) == SQLITE_NULL) {
++				VAL_NULL(val) = 1;
++			} else switch (VAL_TYPE(val)) {
++			case DB1_INT:
++				VAL_INT(val) = sqlite3_column_int(conn->stmt, i);
++				break;
++			case DB1_BIGINT:
++				VAL_BIGINT(val) = sqlite3_column_int64(conn->stmt, i);
++				break;
++			case DB1_STR:
++				str_assign(&VAL_STR(val),
++					(const char*) sqlite3_column_text(conn->stmt, i),
++					sqlite3_column_bytes(conn->stmt, i));
++				VAL_FREE(val) = 1;
++				break;
++			case DB1_DOUBLE:
++				VAL_DOUBLE(val) = sqlite3_column_double(conn->stmt, i);
++				break;
++			case DB1_DATETIME:
++				VAL_TIME(val) = sqlite_to_timet(sqlite3_column_double(conn->stmt, i));
++				break;
++			case DB1_BLOB:
++				str_assign(&VAL_BLOB(val),
++					(const char*) sqlite3_column_blob(conn->stmt, i),
++					sqlite3_column_bytes(conn->stmt, i));
++				VAL_FREE(val) = 1;
++				break;
++			default:
++				LM_ERR("unhandled db-type\n");
++				goto err;
++			}
++		}
++	}
++
++no_mem:
++	LM_ERR("no private memory left\n");
++err:
++	if (res)
++		db_free_result(res);
++	return -1;
++}
++
++/*
++ * Query table for specified rows
++ * _h: structure representing database connection
++ * _k: key names
++ * _op: operators
++ * _v: values of the keys that must match
++ * _c: column names to return
++ * _n: number of key=values pairs to compare
++ * _nc: number of columns to return
++ * _o: order by the specified column
++ */
++int db_sqlite_query(const db1_con_t* _h, const db_key_t* _k, const db_op_t* _op,
++		const db_val_t* _v, const db_key_t* _c, int _n, int _nc,
++		const db_key_t _o, db1_res_t** _r)
++{
++	int rc;
++
++	rc = db_do_query(_h, _k, _op, _v, _c, _n, _nc, _o, _r,
++			 db_sqlite_val2str,
++			 db_sqlite_submit_query,
++			 db_sqlite_store_result);
++	db_sqlite_cleanup_query(_h);
++
++	return rc;
++}
++
++static int db_sqlite_commit(const db1_con_t* _h)
++{
++	struct sqlite_connection *conn = CON_SQLITE(_h);
++	int rc;
++
++	rc = sqlite3_step(conn->stmt);
++	if (rc != SQLITE_DONE && rc != SQLITE_OK) {
++		LM_ERR("sqlite commit failed: %s\n",
++		       sqlite3_errmsg(conn->conn));
++		return -1;
++	}
++
++	return 0;
++}
++
++/*
++ * Insert a row into specified table
++ * _h: structure representing database connection
++ * _k: key names
++ * _v: values of the keys
++ * _n: number of key=value pairs
++ */
++int db_sqlite_insert(const db1_con_t* _h, const db_key_t* _k, const db_val_t* _v,
++		int _n)
++{
++	int rc = -1;
++
++	rc = db_do_insert(_h, _k, _v, _n,
++			  db_sqlite_val2str,
++			  db_sqlite_submit_query);
++	if (rc == 0)
++		rc = db_sqlite_commit(_h);
++	db_sqlite_cleanup_query(_h);
++
++	return rc;
++}
++
++
++/*
++ * Delete a row from the specified table
++ * _h: structure representing database connection
++ * _k: key names
++ * _o: operators
++ * _v: values of the keys that must match
++ * _n: number of key=value pairs
++ */
++int db_sqlite_delete(const db1_con_t* _h, const db_key_t* _k, const db_op_t* _o,
++		const db_val_t* _v, int _n)
++{
++	int rc;
++
++	rc = db_do_delete(_h, _k, _o, _v, _n,
++			  db_sqlite_val2str,
++			  db_sqlite_submit_query);
++	if (rc == 0)
++		rc = db_sqlite_commit(_h);
++	db_sqlite_cleanup_query(_h);
++
++	return rc;
++}
++
++
++/*
++ * Update some rows in the specified table
++ * _h: structure representing database connection
++ * _k: key names
++ * _o: operators
++ * _v: values of the keys that must match
++ * _uk: updated columns
++ * _uv: updated values of the columns
++ * _n: number of key=value pairs
++ * _un: number of columns to update
++ */
++int db_sqlite_update(const db1_con_t* _h, const db_key_t* _k, const db_op_t* _o,
++		const db_val_t* _v, const db_key_t* _uk, const db_val_t* _uv,
++		int _n, int _un)
++{
++	int rc;
++
++	rc = db_do_update(_h, _k, _o, _v, _uk, _uv, _n, _un,
++			  db_sqlite_val2str,
++			  db_sqlite_submit_query);
++	if (rc == 0)
++		rc = db_sqlite_commit(_h);
++	db_sqlite_cleanup_query(_h);
++
++	return rc;
++}
++
+diff --git a/modules_k/db_sqlite/dbase.h b/modules_k/db_sqlite/dbase.h
+new file mode 100644
+index 0000000..d1e57f4
+--- /dev/null
++++ b/modules_k/db_sqlite/dbase.h
+@@ -0,0 +1,70 @@
++/*
++ * $Id$
++ *
++ * SQlite module core functions
++ *
++ * Copyright (C) 2010 Timo Teräs
++ *
++ * This file is part of Kamailio, a free SIP server.
++ *
++ * Kamailio is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; either version 2 of the License, or
++ * (at your option) any later version
++ *
++ * Kamailio is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program; if not, write to the Free Software
++ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
++ */
++
++
++#ifndef DBASE_H
++#define DBASE_H
++
++#include <sqlite3.h>
++
++#include "../../lib/srdb1/db_pool.h"
++#include "../../lib/srdb1/db_con.h"
++#include "../../lib/srdb1/db_res.h"
++#include "../../lib/srdb1/db_key.h"
++#include "../../lib/srdb1/db_op.h"
++#include "../../lib/srdb1/db_val.h"
++
++#define DB_SQLITE_MAX_BINDS 64
++
++struct sqlite_connection {
++	struct pool_con hdr;
++
++	sqlite3 *conn;
++	int bindpos;
++
++	sqlite3_stmt *stmt;
++	const db_val_t *bindarg[DB_SQLITE_MAX_BINDS];
++};
++
++#define CON_SQLITE(db_con)	((struct sqlite_connection *) db_con->tail)
++
++db1_con_t* db_sqlite_init(const str* _sqlurl);
++void db_sqlite_close(db1_con_t* _h);
++
++int db_sqlite_free_result(db1_con_t* _h, db1_res_t* _r);
++
++int db_sqlite_query(const db1_con_t* _h, const db_key_t* _k, const db_op_t* _op,
++		const db_val_t* _v, const db_key_t* _c, int _n, int _nc,
++		const db_key_t _o, db1_res_t** _r);
++int db_sqlite_insert(const db1_con_t* _h, const db_key_t* _k, const db_val_t* _v,
++		int _n);
++int db_sqlite_delete(const db1_con_t* _h, const db_key_t* _k, const db_op_t* _o,
++		const db_val_t* _v, int _n);
++int db_sqlite_update(const db1_con_t* _h, const db_key_t* _k, const db_op_t* _o,
++		const db_val_t* _v, const db_key_t* _uk, const db_val_t* _uv,
++		int _n, int _un);
++int db_sqlite_use_table(db1_con_t* _h, const str* _t);
++
++
++#endif /* DBASE_H */