/*
* Copyright (C) 2001-2003 FhG Fokus
* Copyright (C) 2007-2008 1&1 Internet AG
*
* 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
/**
* \file lib/srdb1/db.c
* \ingroup db1
* \brief Generic Database Interface
*
*/
/*! \defgroup db DB: The Kamailio generic database interface
* This is a generic database interface for modules that need to utilize a
* database. The interface should be used by all modules that access database.
* The interface will be independent of the underlying database server.
* Notes:
* If possible, use the predefined macros if you need to access any structure
* attributes.
* For additional description, see the comments in the sources of mysql module.
*
* If you want to see more complicated examples of how the API could be used,
* take a look at the sources of the usrloc or auth modules.
* - \ref usrloc
* - \ref auth
*
* Implemented modules
* - \ref ../modules/db_berkeley
* - \ref ../modules/db_flatstore
* - \ref ../modules/db_text
* - \ref ../modules/db_mysql
* - \ref ../modules/db_oracle
* - \ref ../modules/db_postgres
* - \ref ../modules/db_unixodbc
*/
#include "../../core/dprint.h"
#include "../../core/sr_module.h"
#include "../../core/mem/mem.h"
#include "../../core/ut.h"
#include "../../core/globals.h"
#include "db_cap.h"
#include "db_id.h"
#include "db_pool.h"
#include "db_query.h"
#include "db.h"
static unsigned int MAX_URL_LENGTH = 1023; /*!< maximum length of a SQL URL */
int db_check_api(db_func_t* dbf, char *mname)
{
if(dbf==NULL)
return -1;
/* All modules must export db_use_table */
if (dbf->use_table == 0) {
LM_ERR("module %s does not export db_use_table function. Please check if module is loaded.\n", mname);
goto error;
}
/* All modules must export db_init */
if (dbf->init == 0) {
LM_ERR("module %s does not export db_init function. Please check if module is loaded.\n", mname);
goto error;
}
/* All modules must export db_close */
if (dbf->close == 0) {
LM_ERR("module %s does not export db_close function. Please check if module is loaded.\n", mname);
goto error;
}
if (dbf->query) {
dbf->cap |= DB_CAP_QUERY;
}
if (dbf->fetch_result) {
dbf->cap |= DB_CAP_FETCH;
}
if (dbf->raw_query) {
dbf->cap |= DB_CAP_RAW_QUERY;
}
/* Free result must be exported if DB_CAP_QUERY or
* DB_CAP_RAW_QUERY is set */
if ((dbf->cap & (DB_CAP_QUERY|DB_CAP_RAW_QUERY)) && (dbf->free_result==0)) {
LM_ERR("module %s supports queries but does not export free_result\n",
mname);
goto error;
}
if (dbf->insert) {
dbf->cap |= DB_CAP_INSERT;
}
if (dbf->delete) {
dbf->cap |= DB_CAP_DELETE;
}
if (dbf->update) {
dbf->cap |= DB_CAP_UPDATE;
}
if (dbf->replace) {
dbf->cap |= DB_CAP_REPLACE;
}
if (dbf->last_inserted_id) {
dbf->cap |= DB_CAP_LAST_INSERTED_ID;
}
if (dbf->insert_update) {
dbf->cap |= DB_CAP_INSERT_UPDATE;
}
if (dbf->insert_delayed) {
dbf->cap |= DB_CAP_INSERT_DELAYED;
}
if (dbf->affected_rows) {
dbf->cap |= DB_CAP_AFFECTED_ROWS;
}
return 0;
error:
return -1;
}
/*! \brief fills mydbf with the corresponding db module callbacks
* \param mod
* \param mydbf
* \return returns 0 on success, -1 on error
* \note on error mydbf will contain only 0s */
int db_bind_mod(const str* mod, db_func_t* mydbf)
{
char *name, *tmp, *p;
int len;
db_func_t dbf;
db_bind_api_f dbind;
if (!mod || !mod->s) {
LM_CRIT("null database module name\n");
return -1;
}
if (mydbf==0) {
LM_CRIT("null dbf parameter\n");
return -1;
}
/* for safety we initialize mydbf with 0 (this will cause
* a segfault immediately if someone tries to call a function
* from it without checking the return code from bind_dbmod */
memset((void*)mydbf, 0, sizeof(db_func_t));
if (mod->len > MAX_URL_LENGTH)
{
LM_ERR("SQL URL too long\n");
return -1;
}
// add the prefix
name = pkg_malloc(mod->len + 4);
if (!name) {
PKG_MEM_ERROR;
return -1;
}
memcpy(name, "db_", 3);
memcpy(name+3, mod->s, mod->len);
name[mod->len+3] = 0;
p = strchr(name, ':');
if (p) {
len = p - name;
tmp = (char*)pkg_malloc(len + 4);
if (!tmp) {
PKG_MEM_ERROR;
pkg_free(name);
return -1;
}
memcpy(tmp, name, len);
tmp[len] = '\0';
pkg_free(name);
} else {
tmp = name;
}
if (!find_module_by_name(tmp)) {
LM_ERR("Module %s not found. Missing loadmodule? \n", tmp);
goto error;
}
dbind = (db_bind_api_f)find_mod_export(tmp, "db_bind_api", 0, 0);
if(dbind != NULL)
{
LM_DBG("using db bind api for %s\n", tmp);
if(dbind(&dbf)<0)
{
LM_ERR("db_bind_api returned error for module %s\n", tmp);
goto error;
}
} else {
memset(&dbf, 0, sizeof(db_func_t));
LM_DBG("using export interface to bind %s\n", tmp);
dbf.use_table = (db_use_table_f)find_mod_export(tmp,
"db_use_table", 2, 0);
dbf.init = (db_init_f)find_mod_export(tmp, "db_init", 1, 0);
dbf.init2 = (db_init2_f)find_mod_export(tmp, "db_init2", 1, 0);
dbf.close = (db_close_f)find_mod_export(tmp, "db_close", 2, 0);
dbf.query = (db_query_f)find_mod_export(tmp, "db_query", 2, 0);
dbf.fetch_result = (db_fetch_result_f)find_mod_export(tmp,
"db_fetch_result", 2, 0);
dbf.raw_query = (db_raw_query_f)find_mod_export(tmp,
"db_raw_query", 2, 0);
dbf.free_result = (db_free_result_f)find_mod_export(tmp,
"db_free_result", 2, 0);
dbf.insert = (db_insert_f)find_mod_export(tmp, "db_insert", 2, 0);
dbf.delete = (db_delete_f)find_mod_export(tmp, "db_delete", 2, 0);
dbf.update = (db_update_f)find_mod_export(tmp, "db_update", 2, 0);
dbf.replace = (db_replace_f)find_mod_export(tmp, "db_replace", 2, 0);
dbf.last_inserted_id= (db_last_inserted_id_f)find_mod_export(tmp,
"db_last_inserted_id", 1, 0);
dbf.affected_rows = (db_affected_rows_f)find_mod_export(tmp,
"db_affected_rows", 1, 0);
dbf.insert_update = (db_insert_update_f)find_mod_export(tmp,
"db_insert_update", 2, 0);
dbf.insert_delayed = (db_insert_delayed_f)find_mod_export(tmp,
"db_insert_delayed", 2, 0);
dbf.start_transaction = (db_start_transaction_f)find_mod_export(tmp,
"db_start_transaction", 2, 0);
dbf.end_transaction = (db_end_transaction_f)find_mod_export(tmp,
"db_end_transaction", 1, 0);
dbf.abort_transaction = (db_abort_transaction_f)find_mod_export(tmp,
"db_abort_transaction", 1, 0);
dbf.query_lock = (db_query_f)find_mod_export(tmp, "db_query_lock", 2, 0);
}
if(db_check_api(&dbf, tmp)!=0)
goto error;
*mydbf=dbf; /* copy */
pkg_free(tmp);
return 0;
error:
pkg_free(tmp);
return -1;
}
/*! \brief
* Initialize database module
* \note No function should be called before this
*/
db1_con_t* db_do_init(const str* url, void* (*new_connection)())
{
return db_do_init2(url, *new_connection, DB_POOLING_PERMITTED);
}
/*! \brief
* Initialize database module
* \note No function should be called before this
*/
db1_con_t* db_do_init2(const str* url, void* (*new_connection)(), db_pooling_t pooling)
{
struct db_id* id;
void* con;
db1_con_t* res;
int con_size = sizeof(db1_con_t) + sizeof(void *);
id = 0;
res = 0;
if (!url || !url->s || !new_connection) {
LM_ERR("invalid parameter value\n");
return 0;
}
if (url->len > MAX_URL_LENGTH)
{
LM_ERR("The configured db_url is too long\n");
return 0;
}
/* this is the root memory for this database connection. */
res = (db1_con_t*)pkg_malloc(con_size);
if (!res) {
PKG_MEM_ERROR;
return 0;
}
memset(res, 0, con_size);
id = new_db_id(url, pooling);
if (!id) {
LM_ERR("cannot parse URL '%.*s'\n", url->len, url->s);
goto err;
}
/* Find the connection in the pool */
con = pool_get(id);
if (!con) {
LM_DBG("connection %p not found in pool\n", id);
/* Not in the pool yet */
con = new_connection(id);
if (!con) {
LM_ERR("could not add connection to the pool\n");
goto err;
}
pool_insert((struct pool_con*)con);
} else {
LM_DBG("connection %p found in pool\n", id);
free_db_id(id); // free the new id, as we use the pool instead
id = 0;
}
res->tail = (unsigned long)con;
return res;
err:
if (id) free_db_id(id);
if (res) pkg_free(res);
return 0;
}
/*! \brief
* Shut down database module
* \note No function should be called after this
*/
void db_do_close(db1_con_t* _h, void (*free_connection)())
{
struct pool_con* con;
if (!_h || !_h->tail) {
LM_ERR("invalid parameter value\n");
return;
}
con = (struct pool_con*)_h->tail;
if (pool_remove(con) == 1) {
free_connection(con);
}
pkg_free(_h);
}
/**
* \brief Get the version of a table.
*
* Returns the version number of a given table from the version table.
* Instead of this function you should use db_check_table_version!
* \see db_check_table_version
* \param dbf database module callbacks
* \param con database connection handle
* \param table checked table
* \return the version number if present, 0 if no version data available, < 0 on error
*/
int db_table_version(const db_func_t* dbf, db1_con_t* connection, const str* table)
{
db_key_t key[1], col[1];
db_val_t val[1];
db1_res_t* res = NULL;
db_val_t* ver = 0;
str *version = &version_table;
str tmp1 = str_init(TABLENAME_COLUMN);
str tmp2 = str_init(VERSION_COLUMN);
int ret = 0;
int val_type;
if (!dbf||!connection || !table || !table->s) {
LM_CRIT("invalid parameter value\n");
return -1;
}
if (dbf->use_table(connection, version) < 0) {
LM_ERR("error while changing table\n");
return -1;
}
key[0] = &tmp1;
VAL_TYPE(val) = DB1_STR;
VAL_NULL(val) = 0;
VAL_STR(val) = *table;
col[0] = &tmp2;
if (dbf->query(connection, key, 0, val, col, 1, 1, 0, &res) < 0) {
LM_ERR("error in db_query\n");
return -1;
}
if (RES_ROW_N(res) == 0) {
LM_DBG("no row for table %.*s found\n",
table->len, ZSW(table->s));
return 0;
}
if (RES_ROW_N(res) != 1) {
LM_ERR("invalid number of rows received:"
" %d, %.*s\n", RES_ROW_N(res), table->len, ZSW(table->s));
dbf->free_result(connection, res);
return -1;
}
ver = ROW_VALUES(RES_ROWS(res));
val_type = VAL_TYPE(ver);
if ( (val_type!=DB1_INT && val_type!=DB1_DOUBLE && val_type!=DB1_BIGINT
&& val_type!=DB1_UINT && val_type!=DB1_UBIGINT)
|| VAL_NULL(ver) ) {
LM_ERR("invalid type (%d) or nul (%d) version "
"columns for %.*s\n", VAL_TYPE(ver), VAL_NULL(ver),
table->len, ZSW(table->s));
dbf->free_result(connection, res);
return -1;
}
if (val_type == DB1_INT) {
ret = VAL_INT(ver);
} else if (val_type == DB1_UINT) {
ret = (int)VAL_UINT(ver);
} else if (val_type == DB1_BIGINT) {
ret = (int)VAL_BIGINT(ver);
} else if (val_type == DB1_UBIGINT) {
ret = (int)VAL_UBIGINT(ver);
} else if (val_type == DB1_DOUBLE) {
ret = (int)VAL_DOUBLE(ver);
}
dbf->free_result(connection, res);
return ret;
}
/**
* \brief Check the table version, including user error logging.
*
* Small helper function to check the table version, including user error logging.
* \param dbf database module callbacks
* \param dbh database connection handle
* \param table checked table
* \param version checked version
* \return 0 means ok, -1 means an error occurred
*/
int db_check_table_version(db_func_t* dbf, db1_con_t* dbh, const str* table,
const unsigned int version)
{
int ver = db_table_version(dbf, dbh, table);
if (ver < 0) {
LM_ERR("querying version for table %.*s\n", table->len, table->s);
return -1;
} else if (ver != (int)version) {
LM_ERR("invalid version %d for table %.*s found, expected %u"
" (check table structure and table \"version\")\n",
ver, table->len, table->s, version);
return -1;
}
return 0;
}
/*! \brief
* Store name of table that will be used by
* subsequent database functions
*/
int db_use_table(db1_con_t* _h, const str* _t)
{
if (!_h) {
LM_ERR("invalid connection parameter\n");
return -1;
}
if (!_t || !_t->s) {
LM_ERR("invalid table parameter value\n");
return -1;
}
CON_TABLE(_h) = _t;
return 0;
}
/*! \brief Generic query helper for load bulk data
*
* Generic query helper method for load bulk data, e.g. lcr tables
* \param binding database module binding
* \param handle database connection
* \param name database table name
* \param cols queried columns
* \param count number of queried columns
* \param strict if set to 1 an error is returned when no data could be loaded,
otherwise just a warning is logged
* \param res database result, unchanged on failure and if no data could be found
* \return 0 if the query was run successful, -1 otherwise
*/
int db_load_bulk_data(db_func_t* binding, db1_con_t* handle, str* name, db_key_t* cols,
unsigned int count, unsigned int strict, db1_res_t* res)
{
if (binding == NULL) {
LM_ERR("invalid database module binding\n");
return -1;
}
if(handle == NULL) {
LM_ERR("invalid database handle\n");
return -1;
}
if (binding->use_table(handle, name) < 0) {
LM_ERR("error in use_table for database\n");
return -1;
}
/* select the whole table and all the columns */
if(binding->query(handle, 0, 0, 0, cols, 0, count, 0, &res) < 0) {
LM_ERR("error while querying database\n");
return -1;
}
if(RES_ROW_N(res) == 0) {
binding->free_result(handle, res);
if (strict == 1) {
LM_ERR("no data in the database table %.*s\n", name->len, name->s);
return -1;
} else {
LM_WARN("no data in the database table %.*s, use an empty set\n", name->len, name->s);
return 0;
}
}
return 0;
}
/**
* \brief DB API init function.
*
* This function must be executed by DB connector modules at load time to
* initialize the internals of DB API library.
* \return returns 0 on successful initialization, -1 on error.
*/
int db_api_init(void)
{
if(db_query_init()<0)
return -1;
return 0;
}