res_odbc.c File Reference

ODBC resource manager. More...

#include "asterisk.h"
#include "asterisk/file.h"
#include "asterisk/channel.h"
#include "asterisk/config.h"
#include "asterisk/pbx.h"
#include "asterisk/module.h"
#include "asterisk/cli.h"
#include "asterisk/lock.h"
#include "asterisk/res_odbc.h"
#include "asterisk/time.h"
#include "asterisk/astobj2.h"
#include "asterisk/app.h"
#include "asterisk/strings.h"
#include "asterisk/threadstorage.h"

Include dependency graph for res_odbc.c:

Go to the source code of this file.

Data Structures
struct	odbc_class
struct	odbc_tables
struct	odbc_txn_frame

Functions
static void	__init_errors_buf (void)
static void	__reg_module (void)
static void	__unreg_module (void)
struct odbc_obj *	_ast_odbc_request_obj (const char *name, int check, const char *file, const char *function, int lineno)
struct odbc_obj *	_ast_odbc_request_obj2 (const char *name, struct ast_flags flags, const char *file, const char *function, int lineno)
static int	aoro2_class_cb (void *obj, void *arg, int flags)
struct ast_module *	AST_MODULE_SELF_SYM (void)
SQLRETURN	ast_odbc_ast_str_SQLGetData (struct ast_str **buf, int pmaxlen, SQLHSTMT StatementHandle, SQLUSMALLINT ColumnNumber, SQLSMALLINT TargetType, SQLLEN *StrLen_or_Ind)
	Wrapper for SQLGetData to use with dynamic strings. More...
int	ast_odbc_backslash_is_escape (struct odbc_obj *obj)
	Checks if the database natively supports backslash as an escape character. More...
unsigned int	ast_odbc_class_get_forcecommit (struct odbc_class *class)
	Get the transaction forcecommit setting for an ODBC class. More...
unsigned int	ast_odbc_class_get_isolation (struct odbc_class *class)
	Get the transaction isolation setting for an ODBC class. More...
const char *	ast_odbc_class_get_name (struct odbc_class *class)
	Get the name of an ODBC class. More...
int	ast_odbc_clear_cache (const char *database, const char *tablename)
	Remove a cache entry from memory This function may be called to clear entries created and cached by the ast_odbc_find_table() API call. More...
SQLHSTMT	ast_odbc_direct_execute (struct odbc_obj *obj, SQLHSTMT(*exec_cb)(struct odbc_obj *obj, void *data), void *data)
	Executes an non prepared statement and returns the resulting statement handle. More...
SQLRETURN	ast_odbc_execute_sql (struct odbc_obj *obj, SQLHSTMT *stmt, const char *sql)
	Execute a unprepared SQL query. More...
struct odbc_cache_columns *	ast_odbc_find_column (struct odbc_cache_tables *table, const char *colname)
	Find a column entry within a cached table structure. More...
struct odbc_cache_tables *	ast_odbc_find_table (const char *database, const char *tablename)
	Find or create an entry describing the table specified. More...
unsigned int	ast_odbc_get_max_connections (const char *name)
	Return the current configured maximum number of connections for a class. More...
const char *	ast_odbc_isolation2text (int iso)
	Convert from numeric transaction isolation values to their textual counterparts. More...
int	ast_odbc_prepare (struct odbc_obj *obj, SQLHSTMT *stmt, const char *sql)
	Prepares a SQL query on a statement. More...
SQLHSTMT	ast_odbc_prepare_and_execute (struct odbc_obj *obj, SQLHSTMT(*prepare_cb)(struct odbc_obj *obj, void *data), void *data)
	Prepares, executes, and returns the resulting statement handle. More...
struct ast_str *	ast_odbc_print_errors (SQLSMALLINT handle_type, SQLHANDLE handle, const char *operation)
	Shortcut for printing errors to logs after a failed SQL operation. More...
void	ast_odbc_release_obj (struct odbc_obj *obj)
	Releases an ODBC object previously allocated by ast_odbc_request_obj() More...
int	ast_odbc_smart_execute (struct odbc_obj *obj, SQLHSTMT stmt)
	Executes a prepared statement handle. More...
int	ast_odbc_text2isolation (const char *txt)
	Convert from textual transaction isolation values to their numeric constants. More...
static int	connection_dead (struct odbc_obj *connection, struct odbc_class *class)
	Determine if the connection has died. More...
static void	destroy_table_cache (struct odbc_cache_tables *table)
static char *	handle_cli_odbc_show (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static int	load_module (void)
static int	load_odbc_config (void)
static void	odbc_class_destructor (void *data)
static odbc_status	odbc_obj_connect (struct odbc_obj *obj)
static void	odbc_obj_destructor (void *data)
static odbc_status	odbc_obj_disconnect (struct odbc_obj *obj)
static void	odbc_register_class (struct odbc_class *class, int connect)
static int	reload (void)
static int	unload_module (void)

Variables
static struct ast_module_info	__mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_GLOBAL_SYMBOLS | AST_MODFLAG_LOAD_ORDER , .description = "ODBC resource" , .key = "This paragraph is copyright (c) 2006 by Digium, Inc. \In order for your module to load, it must return this \key via a function called \"key\". Any code which \includes this paragraph must be licensed under the GNU \General Public License version 2 or later (at your \option). In addition to Digium's general reservations \of rights, Digium expressly reserves the right to \allow other parties to license this paragraph under \different terms. Any use of Digium, Inc. trademarks or \logos (including \"Asterisk\" or \"Digium\") without \express written permission of Digium, Inc. is prohibited.\n" , .buildopt_sum = AST_BUILDOPT_SUM, .support_level = AST_MODULE_SUPPORT_CORE, .load = load_module, .unload = unload_module, .reload = reload, .load_pri = AST_MODPRI_REALTIME_DEPEND, .requires = "res_odbc_transaction", }
static const struct ast_module_info *	ast_module_info = &__mod_info
static struct ao2_container *	class_container
static struct ast_cli_entry	cli_odbc []
static struct ast_threadstorage	errors_buf = { .once = PTHREAD_ONCE_INIT , .key_init = __init_errors_buf , .custom_init = NULL , }
static struct odbc_tables	odbc_tables = { .first = NULL, .last = NULL, .lock = { PTHREAD_RWLOCK_INITIALIZER , NULL, {1, 0} } , }

Detailed Description

ODBC resource manager.

Author

Mark Spencer marks.nosp@m.ter@.nosp@m.digiu.nosp@m.m.co.nosp@m.m

Anthony Minessale II anthm.nosp@m.ct@y.nosp@m.ahoo..nosp@m.com

Tilghman Lesher tilgh.nosp@m.man@.nosp@m.digiu.nosp@m.m.co.nosp@m.m

• See also: cdr_odbc.c

Definition in file res_odbc.c.

Function Documentation

__init_errors_buf()

static void __init_errors_buf ( void  )

static

Definition at line 118 of file res_odbc.c.

{

__reg_module()

static void __reg_module ( void  )

static

Definition at line 1219 of file res_odbc.c.

__unreg_module()

static void __unreg_module ( void  )

static

Definition at line 1219 of file res_odbc.c.

_ast_odbc_request_obj()

struct odbc_obj * _ast_odbc_request_obj	(	const char *	name,
		int	check,
		const char *	file,
		const char *	function,
		int	lineno
	)

Definition at line 1054 of file res_odbc.c.

{
    struct ast_flags flags = { check ? RES_ODBC_SANITY_CHECK : 0 };
    /* XXX New flow means that the "check" parameter doesn't do anything. We're requesting
     * a connection from ODBC. We'll either get a new one, which obviously is already connected, or
     * we'll get one from the ODBC connection pool. In that case, it will ensure to only give us a
     * live connection
     */
    return _ast_odbc_request_obj2(name, flags, file, function, lineno);
}

References _ast_odbc_request_obj2(), make_ari_stubs::file, ast_flags::flags, name, and RES_ODBC_SANITY_CHECK.

_ast_odbc_request_obj2()

struct odbc_obj * _ast_odbc_request_obj2	(	const char *	name,
		struct ast_flags	flags,
		const char *	file,
		const char *	function,
		int	lineno
	)

Definition at line 959 of file res_odbc.c.

{
    struct odbc_obj *obj = NULL;
    struct odbc_class *class;
 
    if (!(class = ao2_callback(class_container, 0, aoro2_class_cb, (char *) name))) {
        ast_debug(1, "Class '%s' not found!\n", name);
        return NULL;
    }
 
    while (!obj) {
        ast_mutex_lock(&class->lock);
 
        obj = AST_LIST_REMOVE_HEAD(&class->connections, list);
        if (obj) {
            --class->cur_cache;
        }
 
        ast_mutex_unlock(&class->lock);
 
        if (!obj) {
            ast_mutex_lock(&class->lock);
 
            if (class->connection_cnt < class->maxconnections) {
                /* If no connection is immediately available establish a new
                 * one if allowed. If we try and fail we give up completely as
                 * we could go into an infinite loop otherwise.
                 */
                obj = ao2_alloc(sizeof(*obj), odbc_obj_destructor);
                if (!obj) {
                    ast_mutex_unlock(&class->lock);
                    break;
                }
 
                obj->parent = ao2_bump(class);
 
                class->connection_cnt++;
 
                ast_mutex_unlock(&class->lock);
 
                if (odbc_obj_connect(obj) == ODBC_FAIL) {
                    ast_mutex_lock(&class->lock);
                    class->connection_cnt--;
                    ast_cond_signal(&class->cond);
                    ast_mutex_unlock(&class->lock);
                    ao2_ref(obj->parent, -1);
                    ao2_ref(obj, -1);
                    obj = NULL;
                    break;
                }
 
                ast_mutex_lock(&class->lock);
 
                ast_debug(2, "Created ODBC handle %p on class '%s', new count is %zd\n", obj,
                    name, class->connection_cnt);
 
            } else {
                /* Otherwise if we're not allowed to create a new one we
                 * wait for another thread to give up the connection they
                 * own.
                 */
                ast_cond_wait(&class->cond, &class->lock);
            }
 
            ast_mutex_unlock(&class->lock);
 
        } else if (connection_dead(obj, class)) {
            /* If the connection is dead try to grab another functional one from the
             * pool instead of trying to resurrect this one.
             */
            ast_mutex_lock(&class->lock);
 
            class->connection_cnt--;
            /* this thread will re-acquire, and if that fails will signal,
             * thus no need to signal class->cond here */
            ast_debug(2, "ODBC handle %p dead - removing from class '%s', new count is %zd\n",
                obj, name, class->connection_cnt);
 
            ast_mutex_unlock(&class->lock);
 
            ao2_ref(obj, -1);
            obj = NULL;
        } else {
            /* We successfully grabbed a connection from the pool and all is well!
             */
            obj->parent = ao2_bump(class);
            ast_debug(2, "Reusing ODBC handle %p from class '%s'\n", obj, name);
        }
    }
 
    ao2_ref(class, -1);
 
    return obj;
}

References ao2_alloc, ao2_bump, ao2_callback, ao2_ref, aoro2_class_cb(), ast_cond_signal, ast_cond_wait, ast_debug, AST_LIST_REMOVE_HEAD, ast_mutex_lock, ast_mutex_unlock, class_container, connection_dead(), odbc_class::list, name, NULL, ODBC_FAIL, odbc_obj_connect(), odbc_obj_destructor(), and odbc_obj::parent.

Referenced by _ast_odbc_request_obj().

aoro2_class_cb()

static int aoro2_class_cb ( void *  obj, void *  arg, int  flags  )

static

Definition at line 889 of file res_odbc.c.

{
    struct odbc_class *class = obj;
    char *name = arg;
    if (!strcmp(class->name, name) && !class->delme) {
        return CMP_MATCH | CMP_STOP;
    }
    return 0;
}

References CMP_MATCH, CMP_STOP, and name.

Referenced by _ast_odbc_request_obj2(), and ast_odbc_get_max_connections().

AST_MODULE_SELF_SYM()

struct ast_module * AST_MODULE_SELF_SYM

(

void

)

Definition at line 1219 of file res_odbc.c.

ast_odbc_ast_str_SQLGetData()

SQLRETURN ast_odbc_ast_str_SQLGetData	(	struct ast_str **	buf,
		int	pmaxlen,
		SQLHSTMT	StatementHandle,
		SQLUSMALLINT	ColumnNumber,
		SQLSMALLINT	TargetType,
		SQLLEN *	StrLen_or_Ind
	)

Wrapper for SQLGetData to use with dynamic strings.

Parameters

buf	Address of the pointer to the ast_str structure.
pmaxlen	The maximum size of the resulting string, or 0 for no limit.
StatementHandle	The statement handle from which to retrieve data.
ColumnNumber	Column number (1-based offset) for which to retrieve data.
TargetType	The SQL constant indicating what kind of data is to be retrieved (usually SQL_CHAR)
StrLen_or_Ind	A pointer to a length indicator, specifying the total length of data.

Definition at line 503 of file res_odbc.c.

{
    SQLRETURN res;
 
    if (pmaxlen == 0) {
        if (SQLGetData(StatementHandle, ColumnNumber, TargetType, ast_str_buffer(*buf), 0, StrLen_or_Ind) == SQL_SUCCESS_WITH_INFO) {
            ast_str_make_space(buf, *StrLen_or_Ind + 1);
        }
    } else if (pmaxlen > 0) {
        ast_str_make_space(buf, pmaxlen);
    }
    res = SQLGetData(StatementHandle, ColumnNumber, TargetType, ast_str_buffer(*buf), ast_str_size(*buf), StrLen_or_Ind);
    ast_str_update(*buf);
 
    return res;
}

References ast_str_buffer(), ast_str_make_space, ast_str_size(), ast_str_update(), and buf.

Referenced by acf_odbc_read(), and cli_odbc_read().

ast_odbc_backslash_is_escape()

int ast_odbc_backslash_is_escape

(

struct odbc_obj *

obj

)

Checks if the database natively supports backslash as an escape character.

Parameters

obj	The ODBC object

Return values

1	if backslash is a native escape character
0	if an ESCAPE clause is needed to support '\'

Definition at line 884 of file res_odbc.c.

{
    return obj->parent->backslash_is_escape;
}

References odbc_class::backslash_is_escape, and odbc_obj::parent.

Referenced by odbc_log(), realtime_multi_odbc(), and realtime_odbc().

ast_odbc_class_get_forcecommit()

unsigned int ast_odbc_class_get_forcecommit

(

struct odbc_class *

class

)

Get the transaction forcecommit setting for an ODBC class.

Definition at line 550 of file res_odbc.c.

{
    return class->forcecommit;
}

Referenced by create_transaction().

ast_odbc_class_get_isolation()

unsigned int ast_odbc_class_get_isolation

(

struct odbc_class *

class

)

Get the transaction isolation setting for an ODBC class.

Definition at line 545 of file res_odbc.c.

{
    return class->isolation;
}

Referenced by create_transaction().

ast_odbc_class_get_name()

const char * ast_odbc_class_get_name

(

struct odbc_class *

class

)

Get the name of an ODBC class.

Definition at line 555 of file res_odbc.c.

{
    return class->name;
}

Referenced by ast_odbc_retrieve_transaction_obj().

ast_odbc_clear_cache()

int ast_odbc_clear_cache	(	const char *	database,
		const char *	tablename
	)

Remove a cache entry from memory This function may be called to clear entries created and cached by the ast_odbc_find_table() API call.

Parameters

database	Name of an ODBC class (used to ensure like-named tables in different databases are not confused)
tablename	Tablename for which a cached record should be removed

Return values

0	if the cache entry was removed.
-1	if no matching entry was found.

Since

1.6.1

Definition at line 348 of file res_odbc.c.

{
    struct odbc_cache_tables *tableptr;
 
    AST_RWLIST_WRLOCK(&odbc_tables);
    AST_RWLIST_TRAVERSE_SAFE_BEGIN(&odbc_tables, tableptr, list) {
        if (strcmp(tableptr->connection, database) == 0 && strcmp(tableptr->table, tablename) == 0) {
            AST_LIST_REMOVE_CURRENT(list);
            destroy_table_cache(tableptr);
            break;
        }
    }
    AST_RWLIST_TRAVERSE_SAFE_END
    AST_RWLIST_UNLOCK(&odbc_tables);
    return tableptr ? 0 : -1;
}

References AST_LIST_REMOVE_CURRENT, AST_RWLIST_TRAVERSE_SAFE_BEGIN, AST_RWLIST_TRAVERSE_SAFE_END, AST_RWLIST_UNLOCK, AST_RWLIST_WRLOCK, odbc_cache_tables::connection, destroy_table_cache(), and odbc_cache_tables::table.

Referenced by unload_odbc().

ast_odbc_direct_execute()

SQLHSTMT ast_odbc_direct_execute	(	struct odbc_obj *	obj,
		SQLHSTMT(*)(struct odbc_obj *obj, void *data)	exec_cb,
		void *	data
	)

Executes an non prepared statement and returns the resulting statement handle.

Parameters

obj	The ODBC object
exec_cb	A function callback, which, when called, should return a statement handle with result columns bound.
data	A parameter to be passed to the exec_cb parameter function, indicating which statement handle is to be prepared.

Returns

a statement handle

Return values

NULL

on error

Definition at line 365 of file res_odbc.c.

{
    struct timeval start;
    SQLHSTMT stmt;
 
    if (obj->parent->logging) {
        start = ast_tvnow();
    }
 
    stmt = exec_cb(obj, data);
 
    if (obj->parent->logging) {
        long execution_time = ast_tvdiff_ms(ast_tvnow(), start);
 
        if (obj->parent->slowquerylimit && execution_time > obj->parent->slowquerylimit) {
            ast_log(LOG_WARNING, "SQL query '%s' took %ld milliseconds to execute on class '%s', this may indicate a database problem\n",
                obj->sql_text, execution_time, obj->parent->name);
        }
 
        ast_mutex_lock(&obj->parent->lock);
        if (execution_time > obj->parent->longest_query_execution_time || !obj->parent->sql_text) {
            obj->parent->longest_query_execution_time = execution_time;
            /* Due to the callback nature of the res_odbc API it's not possible to ensure that
             * the SQL text is removed from the connection in all cases, so only if it becomes the
             * new longest executing query do we steal the SQL text. In other cases what will happen
             * is that the SQL text will be freed if the connection is released back to the class or
             * if a new query is done on the connection.
             */
            ast_free(obj->parent->sql_text);
            obj->parent->sql_text = obj->sql_text;
            obj->sql_text = NULL;
        }
        ast_mutex_unlock(&obj->parent->lock);
    }
 
    return stmt;
}

References ast_free, ast_log, ast_mutex_lock, ast_mutex_unlock, ast_tvdiff_ms(), ast_tvnow(), odbc_class::lock, LOG_WARNING, odbc_class::logging, odbc_class::longest_query_execution_time, odbc_class::name, NULL, odbc_obj::parent, odbc_class::slowquerylimit, odbc_obj::sql_text, and odbc_class::sql_text.

Referenced by acf_odbc_read(), acf_odbc_write(), cli_odbc_read(), cli_odbc_write(), connection_dead(), and odbc_log().

ast_odbc_execute_sql()

SQLRETURN ast_odbc_execute_sql	(	struct odbc_obj *	obj,
		SQLHSTMT *	stmt,
		const char *	sql
	)

Execute a unprepared SQL query.

Parameters

obj	The ODBC object
stmt	The statement
sql	The SQL query

Note

This should be used in place of SQLExecDirect

Definition at line 474 of file res_odbc.c.

{
    if (obj->parent->logging) {
        ast_free(obj->sql_text);
        obj->sql_text = ast_strdup(sql);
        ast_atomic_fetchadd_int(&obj->parent->queries_executed, +1);
    }
 
    return SQLExecDirect(stmt, (unsigned char *)sql, SQL_NTS);
}

References ast_atomic_fetchadd_int(), ast_free, ast_strdup, odbc_class::logging, odbc_obj::parent, odbc_class::queries_executed, and odbc_obj::sql_text.

Referenced by execute(), and execute_cb().

ast_odbc_find_column()

struct odbc_cache_columns * ast_odbc_find_column	(	struct odbc_cache_tables *	table,
		const char *	colname
	)

Find a column entry within a cached table structure.

Parameters

table	Cached table structure, as returned from ast_odbc_find_table()
colname	The column name requested

Returns

A structure describing the column type, or NULL, if the column is not found.

Since

1.6.1

Definition at line 337 of file res_odbc.c.

{
    struct odbc_cache_columns *col;
    AST_RWLIST_TRAVERSE(&table->columns, col, list) {
        if (strcasecmp(col->name, colname) == 0) {
            return col;
        }
    }
    return NULL;
}

References AST_RWLIST_TRAVERSE, odbc_cache_columns::name, NULL, and table.

Referenced by update2_prepare(), and update_odbc().

ast_odbc_find_table()

struct odbc_cache_tables * ast_odbc_find_table	(	const char *	database,
		const char *	tablename
	)

Find or create an entry describing the table specified.

XXX This creates a connection and disconnects it. In some situations, the caller of this function has its own connection and could donate it to this function instead of needing to create another one.

XXX The automatic readlock of the columns is awkward. It's done because it's possible for multiple threads to have references to the table, and the table is not refcounted. Possible changes here would be

• Eliminate the table cache entirely. The use of ast_odbc_find_table() is generally questionable. The only real good use right now is from ast_realtime_require_field() in order to make sure the DB has the expected columns in it. Since that is only used sparingly, the need to cache tables is questionable. Instead, the table structure can be fetched from the DB directly each time, resulting in a single owner of the data.
• Make odbc_cache_tables a refcounted object.

Definition at line 237 of file res_odbc.c.

{
    struct odbc_cache_tables *tableptr;
    struct odbc_cache_columns *entry;
    char columnname[80];
    SQLLEN sqlptr;
    SQLHSTMT stmt = NULL;
    int res = 0, error = 0;
    struct odbc_obj *obj;
 
    AST_RWLIST_RDLOCK(&odbc_tables);
    AST_RWLIST_TRAVERSE(&odbc_tables, tableptr, list) {
        if (strcmp(tableptr->connection, database) == 0 && strcmp(tableptr->table, tablename) == 0) {
            break;
        }
    }
    if (tableptr) {
        AST_RWLIST_RDLOCK(&tableptr->columns);
        AST_RWLIST_UNLOCK(&odbc_tables);
        return tableptr;
    }
 
    if (!(obj = ast_odbc_request_obj(database, 0))) {
        ast_log(LOG_WARNING, "Unable to retrieve database handle for table description '%s@%s'\n", tablename, database);
        AST_RWLIST_UNLOCK(&odbc_tables);
        return NULL;
    }
 
    /* Table structure not already cached; build it now. */
    do {
        res = SQLAllocHandle(SQL_HANDLE_STMT, obj->con, &stmt);
        if ((res != SQL_SUCCESS) && (res != SQL_SUCCESS_WITH_INFO)) {
            ast_log(LOG_WARNING, "SQL Alloc Handle failed on connection '%s'!\n", database);
            break;
        }
 
        res = SQLColumns(stmt, NULL, 0, NULL, 0, (unsigned char *)tablename, SQL_NTS, (unsigned char *)"%", SQL_NTS);
        if ((res != SQL_SUCCESS) && (res != SQL_SUCCESS_WITH_INFO)) {
            SQLFreeHandle(SQL_HANDLE_STMT, stmt);
            ast_log(LOG_ERROR, "Unable to query database columns on connection '%s'.\n", database);
            break;
        }
 
        if (!(tableptr = ast_calloc(sizeof(char), sizeof(*tableptr) + strlen(database) + 1 + strlen(tablename) + 1))) {
            ast_log(LOG_ERROR, "Out of memory creating entry for table '%s' on connection '%s'\n", tablename, database);
            break;
        }
 
        tableptr->connection = (char *)tableptr + sizeof(*tableptr);
        tableptr->table = (char *)tableptr + sizeof(*tableptr) + strlen(database) + 1;
        strcpy(tableptr->connection, database); /* SAFE */
        strcpy(tableptr->table, tablename); /* SAFE */
        AST_RWLIST_HEAD_INIT(&(tableptr->columns));
 
        while ((res = SQLFetch(stmt)) != SQL_NO_DATA && res != SQL_ERROR) {
            SQLGetData(stmt,  4, SQL_C_CHAR, columnname, sizeof(columnname), &sqlptr);
 
            if (!(entry = ast_calloc(sizeof(char), sizeof(*entry) + strlen(columnname) + 1))) {
                ast_log(LOG_ERROR, "Out of memory creating entry for column '%s' in table '%s' on connection '%s'\n", columnname, tablename, database);
                error = 1;
                break;
            }
            entry->name = (char *)entry + sizeof(*entry);
            strcpy(entry->name, columnname);
 
            SQLGetData(stmt,  5, SQL_C_SHORT, &entry->type, sizeof(entry->type), NULL);
            SQLGetData(stmt,  7, SQL_C_LONG, &entry->size, sizeof(entry->size), NULL);
            SQLGetData(stmt,  9, SQL_C_SHORT, &entry->decimals, sizeof(entry->decimals), NULL);
            SQLGetData(stmt, 10, SQL_C_SHORT, &entry->radix, sizeof(entry->radix), NULL);
            SQLGetData(stmt, 11, SQL_C_SHORT, &entry->nullable, sizeof(entry->nullable), NULL);
            SQLGetData(stmt, 16, SQL_C_LONG, &entry->octetlen, sizeof(entry->octetlen), NULL);
 
            /* Specification states that the octenlen should be the maximum number of bytes
             * returned in a char or binary column, but it seems that some drivers just set
             * it to NULL. (Bad Postgres! No biscuit!) */
            if (entry->octetlen == 0) {
                entry->octetlen = entry->size;
            }
 
            ast_debug(3, "Found %s column with type %hd with len %ld, octetlen %ld, and numlen (%hd,%hd)\n", entry->name, entry->type, (long) entry->size, (long) entry->octetlen, entry->decimals, entry->radix);
            /* Insert column info into column list */
            AST_LIST_INSERT_TAIL(&(tableptr->columns), entry, list);
        }
        SQLFreeHandle(SQL_HANDLE_STMT, stmt);
 
        AST_RWLIST_INSERT_TAIL(&odbc_tables, tableptr, list);
        AST_RWLIST_RDLOCK(&(tableptr->columns));
        break;
    } while (1);
 
    AST_RWLIST_UNLOCK(&odbc_tables);
 
    if (error) {
        destroy_table_cache(tableptr);
        tableptr = NULL;
    }
    ast_odbc_release_obj(obj);
    return tableptr;
}

References ast_calloc, ast_debug, AST_LIST_INSERT_TAIL, ast_log, ast_odbc_release_obj(), ast_odbc_request_obj, AST_RWLIST_HEAD_INIT, AST_RWLIST_INSERT_TAIL, AST_RWLIST_RDLOCK, AST_RWLIST_TRAVERSE, AST_RWLIST_UNLOCK, odbc_cache_tables::columns, odbc_obj::con, odbc_cache_tables::connection, odbc_cache_columns::decimals, destroy_table_cache(), error(), odbc_obj::list, LOG_ERROR, LOG_WARNING, odbc_cache_columns::name, NULL, odbc_cache_columns::nullable, odbc_cache_columns::octetlen, odbc_cache_columns::radix, odbc_cache_columns::size, odbc_cache_tables::table, and odbc_cache_columns::type.

Referenced by require_odbc(), update2_odbc(), and update_odbc().

ast_odbc_get_max_connections()

unsigned int ast_odbc_get_max_connections

(

const char *

name

)

Return the current configured maximum number of connections for a class.

Definition at line 899 of file res_odbc.c.

{
    struct odbc_class *class;
    unsigned int max_connections;
 
    class = ao2_callback(class_container, 0, aoro2_class_cb, (char *) name);
    if (!class) {
        return 0;
    }
 
    max_connections = class->maxconnections;
    ao2_ref(class, -1);
 
    return max_connections;
}

References ao2_callback, ao2_ref, aoro2_class_cb(), class_container, and name.

Referenced by release_obj_or_dsn().

ast_odbc_isolation2text()

const char * ast_odbc_isolation2text

(

int

iso

)

Convert from numeric transaction isolation values to their textual counterparts.

Definition at line 137 of file res_odbc.c.

{
    if (iso == SQL_TXN_READ_COMMITTED) {
        return "read_committed";
    } else if (iso == SQL_TXN_READ_UNCOMMITTED) {
        return "read_uncommitted";
    } else if (iso == SQL_TXN_SERIALIZABLE) {
        return "serializable";
    } else if (iso == SQL_TXN_REPEATABLE_READ) {
        return "repeatable_read";
    } else {
        return "unknown";
    }
}

Referenced by acf_transaction_read().

ast_odbc_prepare()

int ast_odbc_prepare	(	struct odbc_obj *	obj,
		SQLHSTMT *	stmt,
		const char *	sql
	)

Prepares a SQL query on a statement.

Parameters

obj	The ODBC object
stmt	The statement
sql	The SQL query

Note

This should be used in place of SQLPrepare

Definition at line 459 of file res_odbc.c.

{
    if (obj->parent->logging) {
        /* It is possible for this connection to be reused without being
         * released back to the class, so we free what may already exist
         * and place the new SQL in.
         */
        ast_free(obj->sql_text);
        obj->sql_text = ast_strdup(sql);
        ast_atomic_fetchadd_int(&obj->parent->prepares_executed, +1);
    }
 
    return SQLPrepare(stmt, (unsigned char *)sql, SQL_NTS);
}

References ast_atomic_fetchadd_int(), ast_free, ast_strdup, odbc_class::logging, odbc_obj::parent, odbc_class::prepares_executed, and odbc_obj::sql_text.

Referenced by config_odbc_prepare(), custom_prepare(), generic_prepare(), length_determination_odbc_prepare(), and update2_prepare().

ast_odbc_prepare_and_execute()

SQLHSTMT ast_odbc_prepare_and_execute	(	struct odbc_obj *	obj,
		SQLHSTMT(*)(struct odbc_obj *obj, void *data)	prepare_cb,
		void *	data
	)

Prepares, executes, and returns the resulting statement handle.

Parameters

obj	The ODBC object
prepare_cb	A function callback, which, when called, should return a statement handle prepared, with any necessary parameters or result columns bound.
data	A parameter to be passed to the prepare_cb parameter function, indicating which statement handle is to be prepared.

Returns

a statement handle

Return values

NULL

on error

Definition at line 403 of file res_odbc.c.

{
    struct timeval start;
    int res = 0;
    SQLHSTMT stmt;
 
    if (obj->parent->logging) {
        start = ast_tvnow();
    }
 
    /* This prepare callback may do more than just prepare -- it may also
     * bind parameters, bind results, etc.  The real key, here, is that
     * when we disconnect, all handles become invalid for most databases.
     * We must therefore redo everything when we establish a new
     * connection. */
    stmt = prepare_cb(obj, data);
    if (!stmt) {
        return NULL;
    }
 
    res = SQLExecute(stmt);
    if ((res != SQL_SUCCESS) && (res != SQL_SUCCESS_WITH_INFO) && (res != SQL_NO_DATA)) {
        if (res == SQL_ERROR) {
            ast_odbc_print_errors(SQL_HANDLE_STMT, stmt, "SQL Execute");
        }
 
        ast_log(LOG_WARNING, "SQL Execute error %d!\n", res);
        SQLFreeHandle(SQL_HANDLE_STMT, stmt);
        stmt = NULL;
    } else if (obj->parent->logging) {
        long execution_time = ast_tvdiff_ms(ast_tvnow(), start);
 
        if (obj->parent->slowquerylimit && execution_time > obj->parent->slowquerylimit) {
            ast_log(LOG_WARNING, "SQL query '%s' took %ld milliseconds to execute on class '%s', this may indicate a database problem\n",
                obj->sql_text, execution_time, obj->parent->name);
        }
 
        ast_mutex_lock(&obj->parent->lock);
 
        /* If this takes the record on longest query execution time, update the parent class
         * with the information.
         */
        if (execution_time > obj->parent->longest_query_execution_time || !obj->parent->sql_text) {
            obj->parent->longest_query_execution_time = execution_time;
            ast_free(obj->parent->sql_text);
            obj->parent->sql_text = obj->sql_text;
            obj->sql_text = NULL;
        }
        ast_mutex_unlock(&obj->parent->lock);
 
        ast_atomic_fetchadd_int(&obj->parent->queries_executed, +1);
    }
 
    return stmt;
}

References ast_atomic_fetchadd_int(), ast_free, ast_log, ast_mutex_lock, ast_mutex_unlock, ast_odbc_print_errors(), ast_tvdiff_ms(), ast_tvnow(), odbc_class::lock, LOG_WARNING, odbc_class::logging, odbc_class::longest_query_execution_time, odbc_class::name, NULL, odbc_obj::parent, odbc_class::queries_executed, odbc_class::slowquerylimit, odbc_obj::sql_text, and odbc_class::sql_text.

Referenced by config_odbc(), destroy_odbc(), odbc_log(), realtime_multi_odbc(), realtime_odbc(), store_odbc(), update2_odbc(), and update_odbc().

ast_odbc_print_errors()

struct ast_str * ast_odbc_print_errors	(	SQLSMALLINT	handle_type,
		SQLHANDLE	handle,
		const char *	operation
	)

Shortcut for printing errors to logs after a failed SQL operation.

Parameters

handle_type	The type of SQL handle on which to gather diagnostics
handle	The SQL handle to gather diagnostics from
operation	The name of the failed operation.

Returns

The error string that was printed to the logs

Definition at line 520 of file res_odbc.c.

{
    struct ast_str *errors = ast_str_thread_get(&errors_buf, 16);
    SQLINTEGER nativeerror = 0;
    SQLSMALLINT diagbytes = 0;
    SQLSMALLINT i;
    unsigned char state[10];
    unsigned char diagnostic[256];
 
    ast_str_reset(errors);
    i = 0;
    while (SQLGetDiagRec(handle_type, handle, ++i, state, &nativeerror,
        diagnostic, sizeof(diagnostic), &diagbytes) == SQL_SUCCESS) {
        ast_str_append(&errors, 0, "%s%s", ast_str_strlen(errors) ? "," : "", state);
        ast_log(LOG_WARNING, "%s returned an error: %s: %s\n", operation, state, diagnostic);
        /* XXX Why is this here? */
        if (i > 10) {
            ast_log(LOG_WARNING, "There are more than 10 diagnostic records! Ignore the rest.\n");
            break;
        }
    }
 
    return errors;
}

References ast_log, ast_str_append(), ast_str_reset(), ast_str_strlen(), ast_str_thread_get(), errors_buf, and LOG_WARNING.

Referenced by acf_transaction_write(), ast_odbc_prepare_and_execute(), ast_odbc_smart_execute(), commit_exec(), create_transaction(), custom_prepare(), release_transaction(), rollback_exec(), and update2_prepare().

ast_odbc_release_obj()

void ast_odbc_release_obj

(

struct odbc_obj *

obj

)

Releases an ODBC object previously allocated by ast_odbc_request_obj()

Parameters

obj	The ODBC object

Definition at line 828 of file res_odbc.c.

{
    struct odbc_class *class = obj->parent;
 
    ast_debug(2, "Releasing ODBC handle %p into pool\n", obj);
 
    /* The odbc_obj only holds a reference to the class when it is
     * actively being used. This guarantees no circular reference
     * between odbc_class and odbc_obj. Since it is being released
     * we also release our class reference. If a reload occurred before
     * the class will go away automatically once all odbc_obj are
     * released back.
     */
    obj->parent = NULL;
 
    /* Free the SQL text so that the next user of this connection has
     * a fresh start.
     */
    ast_free(obj->sql_text);
    obj->sql_text = NULL;
 
    ast_mutex_lock(&class->lock);
    if (class->cache_is_queue) {
        AST_LIST_INSERT_TAIL(&class->connections, obj, list);
    } else {
        AST_LIST_INSERT_HEAD(&class->connections, obj, list);
    }
 
    if (class->cur_cache >= class->max_cache_size) {
        /* cache is full */
        if (class->cache_is_queue) {
            /* HEAD will be oldest */
            obj = AST_LIST_REMOVE_HEAD(&class->connections, list);
        } else {
            /* TAIL will be oldest */
            obj = AST_LIST_LAST(&class->connections);
            AST_LIST_REMOVE(&class->connections, obj, list);
        }
        --class->connection_cnt;
        ast_mutex_unlock(&class->lock);
 
        ast_debug(2, "ODBC Pool '%s' exceeded cache size, dropping '%p', connection count is %zd (%u cached)\n",
            class->name, obj, class->connection_cnt, class->cur_cache);
 
        ao2_ref(obj, -1);
 
        ast_mutex_lock(&class->lock);
    } else {
        ++class->cur_cache;
    }
    ast_cond_signal(&class->cond);
    ast_mutex_unlock(&class->lock);
 
    ao2_ref(class, -1);
}

References ao2_ref, ast_cond_signal, ast_debug, ast_free, AST_LIST_INSERT_HEAD, AST_LIST_INSERT_TAIL, AST_LIST_LAST, AST_LIST_REMOVE, AST_LIST_REMOVE_HEAD, ast_mutex_lock, ast_mutex_unlock, NULL, odbc_obj::parent, and odbc_obj::sql_text.

Referenced by ast_odbc_find_table(), config_odbc(), create_transaction(), destroy_odbc(), dsn_destructor(), get_dsn(), load_config(), odbc_log(), odbc_register_class(), realtime_multi_odbc(), realtime_odbc(), release_obj_or_dsn(), release_transaction(), store_odbc(), update2_odbc(), and update_odbc().

ast_odbc_smart_execute()

int ast_odbc_smart_execute	(	struct odbc_obj *	obj,
		SQLHSTMT	stmt
	)

Executes a prepared statement handle.

Parameters

obj	The non-NULL result of odbc_request_obj()
stmt	The prepared statement handle

Return values

0	on success
-1	on failure

This function was originally designed simply to execute a prepared statement handle and to retry if the initial execution failed. Unfortunately, it did this by disconnecting and reconnecting the database handle which on most databases causes the statement handle to become invalid. Therefore, this method has been deprecated in favor of odbc_prepare_and_execute() which allows the statement to be prepared multiple times, if necessary, in case of a loss of connection.

This function really only ever worked with MySQL, where the statement handle is not prepared on the server. If you are not using MySQL, you should avoid it.

Definition at line 485 of file res_odbc.c.

{
    int res = 0;
 
    res = SQLExecute(stmt);
    if ((res != SQL_SUCCESS) && (res != SQL_SUCCESS_WITH_INFO) && (res != SQL_NO_DATA)) {
        if (res == SQL_ERROR) {
            ast_odbc_print_errors(SQL_HANDLE_STMT, stmt, "SQL Execute");
        }
    }
 
    if (obj->parent->logging) {
        ast_atomic_fetchadd_int(&obj->parent->queries_executed, +1);
    }
 
    return res;
}

References ast_atomic_fetchadd_int(), ast_odbc_print_errors(), odbc_class::logging, odbc_obj::parent, and odbc_class::queries_executed.

ast_odbc_text2isolation()

int ast_odbc_text2isolation

(

const char *

txt

)

Convert from textual transaction isolation values to their numeric constants.

Definition at line 152 of file res_odbc.c.

{
    if (strncasecmp(txt, "read_", 5) == 0) {
        if (strncasecmp(txt + 5, "c", 1) == 0) {
            return SQL_TXN_READ_COMMITTED;
        } else if (strncasecmp(txt + 5, "u", 1) == 0) {
            return SQL_TXN_READ_UNCOMMITTED;
        } else {
            return 0;
        }
    } else if (strncasecmp(txt, "ser", 3) == 0) {
        return SQL_TXN_SERIALIZABLE;
    } else if (strncasecmp(txt, "rep", 3) == 0) {
        return SQL_TXN_REPEATABLE_READ;
    } else {
        return 0;
    }
}

Referenced by acf_transaction_write(), and load_odbc_config().

connection_dead()

static int connection_dead ( struct odbc_obj *  connection, struct odbc_class *  class  )

static

Determine if the connection has died.

Parameters

connection	The connection to check
class	The ODBC class

Return values

1	Yep, it's dead
0	It's alive and well

Definition at line 923 of file res_odbc.c.

{
    char *test_sql = "select 1";
    SQLINTEGER dead;
    SQLRETURN res;
    SQLHSTMT stmt;
 
    res = SQLGetConnectAttr(connection->con, SQL_ATTR_CONNECTION_DEAD, &dead, 0, 0);
    if (SQL_SUCCEEDED(res)) {
        return dead == SQL_CD_TRUE ? 1 : 0;
    }
 
    /* If the Driver doesn't support SQL_ATTR_CONNECTION_DEAD do a
     * probing query instead
     */
    res = SQLAllocHandle(SQL_HANDLE_STMT, connection->con, &stmt);
    if (!SQL_SUCCEEDED(res)) {
        return 1;
    }
 
    if (!ast_strlen_zero(class->sanitysql)) {
        test_sql = class->sanitysql;
    }
 
    res = SQLPrepare(stmt, (unsigned char *)test_sql, SQL_NTS);
    if (!SQL_SUCCEEDED(res)) {
        SQLFreeHandle(SQL_HANDLE_STMT, stmt);
        return 1;
    }
 
    res = SQLExecute(stmt);
    SQLFreeHandle(SQL_HANDLE_STMT, stmt);
 
    return SQL_SUCCEEDED(res) ? 0 : 1;
}

References ast_strlen_zero(), and odbc_obj::con.

Referenced by _ast_odbc_request_obj2().

destroy_table_cache()

static void destroy_table_cache ( struct odbc_cache_tables *  table )

static

Definition at line 206 of file res_odbc.c.

{
    struct odbc_cache_columns *col;
 
    ast_debug(1, "Destroying table cache for %s\n", table->table);
 
    AST_RWLIST_WRLOCK(&table->columns);
    while ((col = AST_RWLIST_REMOVE_HEAD(&table->columns, list))) {
        ast_free(col);
    }
    AST_RWLIST_UNLOCK(&table->columns);
    AST_RWLIST_HEAD_DESTROY(&table->columns);
 
    ast_free(table);
}

References ast_debug, ast_free, AST_RWLIST_HEAD_DESTROY, AST_RWLIST_REMOVE_HEAD, AST_RWLIST_UNLOCK, AST_RWLIST_WRLOCK, and table.

Referenced by ast_odbc_clear_cache(), ast_odbc_find_table(), and reload().

handle_cli_odbc_show()

static char * handle_cli_odbc_show ( struct ast_cli_entry *  e, int  cmd, struct ast_cli_args *  a  )

static

Definition at line 728 of file res_odbc.c.

{
    struct ao2_iterator aoi;
    struct odbc_class *class;
    int length = 0;
    int which = 0;
    char *ret = NULL;
 
    switch (cmd) {
    case CLI_INIT:
        e->command = "odbc show";
        e->usage =
                "Usage: odbc show [class]\n"
                "       List settings of a particular ODBC class or,\n"
                "       if not specified, all classes.\n";
        return NULL;
    case CLI_GENERATE:
        if (a->pos != 2)
            return NULL;
        length = strlen(a->word);
        aoi = ao2_iterator_init(class_container, 0);
        while ((class = ao2_iterator_next(&aoi))) {
            if (!strncasecmp(a->word, class->name, length) && ++which > a->n) {
                ret = ast_strdup(class->name);
            }
            ao2_ref(class, -1);
            if (ret) {
                break;
            }
        }
        ao2_iterator_destroy(&aoi);
        if (!ret && !strncasecmp(a->word, "all", length) && ++which > a->n) {
            ret = ast_strdup("all");
        }
        return ret;
    }
 
    ast_cli(a->fd, "\nODBC DSN Settings\n");
    ast_cli(a->fd,   "-----------------\n\n");
    aoi = ao2_iterator_init(class_container, 0);
    while ((class = ao2_iterator_next(&aoi))) {
        if ((a->argc == 2) || (a->argc == 3 && !strcmp(a->argv[2], "all")) || (!strcmp(a->argv[2], class->name))) {
            char timestr[80];
            struct ast_tm tm;
 
            ast_cli(a->fd, "  Name:   %s\n  DSN:    %s\n", class->name, class->dsn);
 
            if (class->last_negative_connect.tv_sec > 0) {
                ast_localtime(&class->last_negative_connect, &tm, NULL);
                ast_strftime(timestr, sizeof(timestr), "%Y-%m-%d %T", &tm);
                ast_cli(a->fd, "    Last fail connection attempt: %s\n", timestr);
            }
 
            ast_cli(a->fd, "    Number of active connections: %zd (out of %d)\n", class->connection_cnt, class->maxconnections);
            ast_cli(a->fd, "    Cache Type: %s\n", class->cache_is_queue ? "round-robin queue" : "stack (last release, first re-use)");
            ast_cli(a->fd, "    Cache Usage: %u cached out of %u\n", class->cur_cache,
                    class->max_cache_size < class->maxconnections ? class->max_cache_size : class->maxconnections);
            ast_cli(a->fd, "    Logging: %s\n", class->logging ? "Enabled" : "Disabled");
            if (class->logging) {
                ast_cli(a->fd, "    Number of prepares executed: %d\n", class->prepares_executed);
                ast_cli(a->fd, "    Number of queries executed: %d\n", class->queries_executed);
                ast_mutex_lock(&class->lock);
                if (class->sql_text) {
                    ast_cli(a->fd, "    Longest running SQL query: %s (%ld milliseconds)\n", class->sql_text, class->longest_query_execution_time);
                }
                ast_mutex_unlock(&class->lock);
            }
            ast_cli(a->fd, "\n");
        }
        ao2_ref(class, -1);
    }
    ao2_iterator_destroy(&aoi);
 
    return CLI_SUCCESS;
}

References a, ao2_iterator_destroy(), ao2_iterator_init(), ao2_iterator_next, ao2_ref, ast_cli(), ast_localtime(), ast_mutex_lock, ast_mutex_unlock, ast_strdup, ast_strftime(), class_container, CLI_GENERATE, CLI_INIT, CLI_SUCCESS, ast_cli_entry::command, test_val::name, NULL, and ast_cli_entry::usage.

load_module()

static int load_module ( void  )

static

Definition at line 1195 of file res_odbc.c.

{
    class_container = ao2_container_alloc_list(AO2_ALLOC_OPT_LOCK_MUTEX, 0, NULL, ao2_match_by_addr);
    if (!class_container) {
        return AST_MODULE_LOAD_DECLINE;
    }
 
    if (load_odbc_config() == -1) {
        return AST_MODULE_LOAD_DECLINE;
    }
 
    ast_module_shutdown_ref(ast_module_info->self);
    ast_cli_register_multiple(cli_odbc, ARRAY_LEN(cli_odbc));
 
    return AST_MODULE_LOAD_SUCCESS;
}

References AO2_ALLOC_OPT_LOCK_MUTEX, ao2_container_alloc_list, ao2_match_by_addr(), ARRAY_LEN, ast_cli_register_multiple, AST_MODULE_LOAD_DECLINE, AST_MODULE_LOAD_SUCCESS, ast_module_shutdown_ref, class_container, cli_odbc, load_odbc_config(), NULL, and ast_module_info::self.

load_odbc_config()

static int load_odbc_config ( void  )

static

Definition at line 560 of file res_odbc.c.

{
    static char *cfg = "res_odbc.conf";
    struct ast_config *config;
    struct ast_variable *v;
    char *cat;
    const char *dsn, *username, *password, *sanitysql;
    int enabled, bse, conntimeout, forcecommit, isolation, maxconnections, logging, slowquerylimit;
    struct timeval ncache = { 0, 0 };
    int preconnect = 0, res = 0, cache_is_queue = 0;
    struct ast_flags config_flags = { 0 };
    unsigned int max_cache_size;
 
    struct odbc_class *new;
 
    config = ast_config_load(cfg, config_flags);
    if (config == CONFIG_STATUS_FILEMISSING || config == CONFIG_STATUS_FILEINVALID) {
        ast_log(LOG_WARNING, "Unable to load config file res_odbc.conf\n");
        return -1;
    }
    for (cat = ast_category_browse(config, NULL); cat; cat=ast_category_browse(config, cat)) {
        if (!strcasecmp(cat, "ENV")) {
            for (v = ast_variable_browse(config, cat); v; v = v->next) {
                setenv(v->name, v->value, 1);
                ast_log(LOG_NOTICE, "Adding ENV var: %s=%s\n", v->name, v->value);
            }
        } else {
            /* Reset all to defaults for each class of odbc connections */
            dsn = username = password = sanitysql = NULL;
            enabled = 1;
            preconnect = 0;
            bse = 1;
            conntimeout = 10;
            forcecommit = 0;
            isolation = SQL_TXN_READ_COMMITTED;
            maxconnections = 1;
            logging = 0;
            slowquerylimit = 5000;
            cache_is_queue = 0;
            max_cache_size = UINT_MAX;
            for (v = ast_variable_browse(config, cat); v; v = v->next) {
                if (!strcasecmp(v->name, "pooling") ||
                        !strncasecmp(v->name, "share", 5) ||
                        !strcasecmp(v->name, "limit") ||
                        !strcasecmp(v->name, "idlecheck")) {
                    ast_log(LOG_WARNING, "The 'pooling', 'shared_connections', 'limit', and 'idlecheck' options were replaced by 'max_connections'.  See res_odbc.conf.sample.\n");
                } else if (!strcasecmp(v->name, "enabled")) {
                    enabled = ast_true(v->value);
                } else if (!strcasecmp(v->name, "pre-connect")) {
                    preconnect = ast_true(v->value);
                } else if (!strcasecmp(v->name, "dsn")) {
                    dsn = v->value;
                } else if (!strcasecmp(v->name, "username")) {
                    username = v->value;
                } else if (!strcasecmp(v->name, "password")) {
                    password = v->value;
                } else if (!strcasecmp(v->name, "sanitysql")) {
                    sanitysql = v->value;
                } else if (!strcasecmp(v->name, "backslash_is_escape")) {
                    bse = ast_true(v->value);
                } else if (!strcasecmp(v->name, "connect_timeout")) {
                    if (sscanf(v->value, "%d", &conntimeout) != 1 || conntimeout < 1) {
                        ast_log(LOG_WARNING, "connect_timeout must be a positive integer\n");
                        conntimeout = 10;
                    }
                } else if (!strcasecmp(v->name, "negative_connection_cache")) {
                    double dncache;
                    if (sscanf(v->value, "%lf", &dncache) != 1 || dncache < 0) {
                        ast_log(LOG_WARNING, "negative_connection_cache must be a non-negative integer\n");
                        /* 5 minutes sounds like a reasonable default */
                        ncache.tv_sec = 300;
                        ncache.tv_usec = 0;
                    } else {
                        ncache.tv_sec = (int)dncache;
                        ncache.tv_usec = (dncache - ncache.tv_sec) * 1000000;
                    }
                } else if (!strcasecmp(v->name, "forcecommit")) {
                    forcecommit = ast_true(v->value);
                } else if (!strcasecmp(v->name, "isolation")) {
                    if ((isolation = ast_odbc_text2isolation(v->value)) == 0) {
                        ast_log(LOG_ERROR, "Unrecognized value for 'isolation': '%s' in section '%s'\n", v->value, cat);
                        isolation = SQL_TXN_READ_COMMITTED;
                    }
                } else if (!strcasecmp(v->name, "max_connections")) {
                    if (sscanf(v->value, "%30d", &maxconnections) != 1 || maxconnections < 1) {
                        ast_log(LOG_WARNING, "max_connections must be a positive integer\n");
                        maxconnections = 1;
                                        }
                } else if (!strcasecmp(v->name, "logging")) {
                    logging = ast_true(v->value);
                } else if (!strcasecmp(v->name, "slow_query_limit")) {
                    if (sscanf(v->value, "%30d", &slowquerylimit) != 1) {
                        ast_log(LOG_WARNING, "slow_query_limit must be a positive integer\n");
                        slowquerylimit = 5000;
                    }
                } else if (!strcasecmp(v->name, "cache_type")) {
                    cache_is_queue = !strcasecmp(v->value, "rr") ||
                        !strcasecmp(v->value, "roundrobin") ||
                        !strcasecmp(v->value, "queue");
                } else if (!strcasecmp(v->name, "cache_size")) {
                    if (!strcasecmp(v->value, "-1")) {
                        max_cache_size = UINT_MAX;
                    } else if (sscanf(v->value, "%u", &max_cache_size) != 1) {
                        ast_log(LOG_WARNING, "cache_size must be a non-negative integer or -1 (infinite)\n");
                    }
                }
            }
 
            if (enabled && !ast_strlen_zero(dsn)) {
                new = ao2_alloc(sizeof(*new), odbc_class_destructor);
 
                if (!new) {
                    res = -1;
                    break;
                }
 
                SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE, &new->env);
                res = SQLSetEnvAttr(new->env, SQL_ATTR_ODBC_VERSION, (void *) SQL_OV_ODBC3, 0);
 
                if ((res != SQL_SUCCESS) && (res != SQL_SUCCESS_WITH_INFO)) {
                    ast_log(LOG_WARNING, "res_odbc: Error SetEnv\n");
                    ao2_ref(new, -1);
                    return res;
                }
 
                new->backslash_is_escape = bse ? 1 : 0;
                new->forcecommit = forcecommit ? 1 : 0;
                new->isolation = isolation;
                new->conntimeout = conntimeout;
                new->negative_connection_cache = ncache;
                new->maxconnections = maxconnections;
                new->logging = logging;
                new->slowquerylimit = slowquerylimit;
                new->cache_is_queue = cache_is_queue;
                new->max_cache_size = max_cache_size;
                new->cur_cache = 0;
 
                if (cat)
                    ast_copy_string(new->name, cat, sizeof(new->name));
                if (dsn)
                    ast_copy_string(new->dsn, dsn, sizeof(new->dsn));
                if (username && !(new->username = ast_strdup(username))) {
                    ao2_ref(new, -1);
                    break;
                }
                if (password && !(new->password = ast_strdup(password))) {
                    ao2_ref(new, -1);
                    break;
                }
                if (sanitysql && !(new->sanitysql = ast_strdup(sanitysql))) {
                    ao2_ref(new, -1);
                    break;
                }
 
                ast_mutex_init(&new->lock);
                ast_cond_init(&new->cond, NULL);
 
                odbc_register_class(new, preconnect);
                ast_log(LOG_NOTICE, "Registered ODBC class '%s' dsn->[%s]\n", cat, dsn);
                ao2_ref(new, -1);
                new = NULL;
            }
        }
    }
    ast_config_destroy(config);
    return res;
}

References ao2_alloc, ao2_ref, ast_category_browse(), ast_cond_init, ast_config_destroy(), ast_config_load, ast_copy_string(), ast_log, ast_mutex_init, ast_odbc_text2isolation(), ast_strdup, ast_strlen_zero(), ast_true(), ast_variable_browse(), odbc_class::cache_is_queue, config, CONFIG_STATUS_FILEINVALID, CONFIG_STATUS_FILEMISSING, odbc_class::conntimeout, dsn, enabled, odbc_class::forcecommit, odbc_class::isolation, LOG_ERROR, LOG_NOTICE, LOG_WARNING, odbc_class::logging, odbc_class::max_cache_size, odbc_class::maxconnections, ast_variable::name, ast_variable::next, NULL, odbc_class_destructor(), odbc_register_class(), odbc_class::password, odbc_class::sanitysql, setenv(), odbc_class::slowquerylimit, odbc_class::username, and ast_variable::value.

Referenced by load_module(), and reload().

odbc_class_destructor()

static void odbc_class_destructor ( void *  data )

static

Definition at line 171 of file res_odbc.c.

{
    struct odbc_class *class = data;
    struct odbc_obj *obj;
 
    /* Due to refcounts, we can safely assume that any objects with a reference
     * to us will prevent our destruction, so we don't need to worry about them.
     */
    if (class->username) {
        ast_free(class->username);
    }
    if (class->password) {
        ast_free(class->password);
    }
    if (class->sanitysql) {
        ast_free(class->sanitysql);
    }
 
    while ((obj = AST_LIST_REMOVE_HEAD(&class->connections, list))) {
        ao2_ref(obj, -1);
    }
 
    SQLFreeHandle(SQL_HANDLE_ENV, class->env);
    ast_mutex_destroy(&class->lock);
    ast_cond_destroy(&class->cond);
    ast_free(class->sql_text);
}

References ao2_ref, ast_cond_destroy, ast_free, AST_LIST_REMOVE_HEAD, ast_mutex_destroy, and odbc_obj::list.

Referenced by load_odbc_config().

odbc_obj_connect()

static odbc_status odbc_obj_connect ( struct odbc_obj *  obj )

static

Definition at line 1092 of file res_odbc.c.

{
    int res;
    SQLINTEGER err;
    short int mlen;
    unsigned char msg[200], state[10];
#ifdef NEEDTRACE
    SQLINTEGER enable = 1;
    char *tracefile = "/tmp/odbc.trace";
#endif
    SQLHDBC con;
    long int negative_cache_expiration;
 
    ast_assert(obj->con == NULL);
    ast_debug(3, "Connecting %s(%p)\n", obj->parent->name, obj);
 
    /* Dont connect while server is marked as unreachable via negative_connection_cache */
    negative_cache_expiration = obj->parent->last_negative_connect.tv_sec + obj->parent->negative_connection_cache.tv_sec;
    if (time(NULL) < negative_cache_expiration) {
        char secs[AST_TIME_T_LEN];
        ast_time_t_to_string(negative_cache_expiration - time(NULL), secs, sizeof(secs));
        ast_log(LOG_WARNING, "Not connecting to %s. Negative connection cache for %s seconds\n", obj->parent->name, secs);
        return ODBC_FAIL;
    }
 
    res = SQLAllocHandle(SQL_HANDLE_DBC, obj->parent->env, &con);
 
    if ((res != SQL_SUCCESS) && (res != SQL_SUCCESS_WITH_INFO)) {
        ast_log(LOG_WARNING, "res_odbc: Error AllocHDB %d\n", res);
        obj->parent->last_negative_connect = ast_tvnow();
        return ODBC_FAIL;
    }
    SQLSetConnectAttr(con, SQL_LOGIN_TIMEOUT, (SQLPOINTER *)(long) obj->parent->conntimeout, 0);
    SQLSetConnectAttr(con, SQL_ATTR_CONNECTION_TIMEOUT, (SQLPOINTER *)(long) obj->parent->conntimeout, 0);
#ifdef NEEDTRACE
    SQLSetConnectAttr(con, SQL_ATTR_TRACE, &enable, SQL_IS_INTEGER);
    SQLSetConnectAttr(con, SQL_ATTR_TRACEFILE, tracefile, strlen(tracefile));
#endif
 
    res = SQLConnect(con,
           (SQLCHAR *) obj->parent->dsn, SQL_NTS,
           (SQLCHAR *) obj->parent->username, SQL_NTS,
           (SQLCHAR *) obj->parent->password, SQL_NTS);
 
    if ((res != SQL_SUCCESS) && (res != SQL_SUCCESS_WITH_INFO)) {
        SQLGetDiagRec(SQL_HANDLE_DBC, con, 1, state, &err, msg, 100, &mlen);
        obj->parent->last_negative_connect = ast_tvnow();
        ast_log(LOG_WARNING, "res_odbc: Error SQLConnect=%d errno=%d %s\n", res, (int)err, msg);
        if ((res = SQLFreeHandle(SQL_HANDLE_DBC, con)) != SQL_SUCCESS) {
            SQLGetDiagRec(SQL_HANDLE_DBC, con, 1, state, &err, msg, 100, &mlen);
            ast_log(LOG_WARNING, "Unable to deallocate database handle %p? %d errno=%d %s\n", con, res, (int)err, msg);
        }
        return ODBC_FAIL;
    } else {
        ast_debug(3, "res_odbc: Connected to %s [%s (%p)]\n", obj->parent->name, obj->parent->dsn, obj);
    }
 
    obj->con = con;
    return ODBC_SUCCESS;
}

References ast_assert, ast_debug, ast_log, AST_TIME_T_LEN, ast_time_t_to_string(), ast_tvnow(), odbc_obj::con, odbc_class::conntimeout, odbc_class::dsn, odbc_class::env, odbc_class::last_negative_connect, LOG_WARNING, odbc_class::name, odbc_class::negative_connection_cache, NULL, ODBC_FAIL, ODBC_SUCCESS, odbc_obj::parent, odbc_class::password, and odbc_class::username.

Referenced by _ast_odbc_request_obj2().

odbc_obj_destructor()

static void odbc_obj_destructor ( void *  data )

static

Definition at line 199 of file res_odbc.c.

{
    struct odbc_obj *obj = data;
 
    odbc_obj_disconnect(obj);
}

References odbc_obj_disconnect().

Referenced by _ast_odbc_request_obj2().

odbc_obj_disconnect()

static odbc_status odbc_obj_disconnect ( struct odbc_obj *  obj )

static

Definition at line 1065 of file res_odbc.c.

{
    int res;
    SQLINTEGER err;
    short int mlen;
    unsigned char msg[200], state[10];
    SQLHDBC con;
 
    /* Nothing to disconnect */
    if (!obj->con) {
        return ODBC_SUCCESS;
    }
 
    con = obj->con;
    obj->con = NULL;
    res = SQLDisconnect(con);
 
    if ((res = SQLFreeHandle(SQL_HANDLE_DBC, con)) == SQL_SUCCESS) {
        ast_debug(3, "Database handle %p (connection %p) deallocated\n", obj, con);
    } else {
        SQLGetDiagRec(SQL_HANDLE_DBC, con, 1, state, &err, msg, 100, &mlen);
        ast_log(LOG_WARNING, "Unable to deallocate database handle %p? %d errno=%d %s\n", con, res, (int)err, msg);
    }
 
    return ODBC_SUCCESS;
}

References ast_debug, ast_log, odbc_obj::con, LOG_WARNING, NULL, and ODBC_SUCCESS.

Referenced by odbc_obj_destructor().

odbc_register_class()

static void odbc_register_class ( struct odbc_class *  class, int  connect  )

static

Definition at line 808 of file res_odbc.c.

{
    struct odbc_obj *obj;
 
    ao2_link(class_container, class);
    /* I still have a reference in the caller, so a deref is NOT missing here. */
 
    if (!preconnect) {
        return;
    }
 
    /* Request and release builds a connection */
    obj = ast_odbc_request_obj(class->name, 0);
    if (obj) {
        ast_odbc_release_obj(obj);
    }
 
    return;
}

References ao2_link, ast_odbc_release_obj(), ast_odbc_request_obj, and class_container.

Referenced by load_odbc_config().

reload()

static int reload ( void  )

static

Definition at line 1153 of file res_odbc.c.

{
    struct odbc_cache_tables *table;
    struct odbc_class *class;
    struct ao2_iterator aoi = ao2_iterator_init(class_container, 0);
 
    /* First, mark all to be purged */
    while ((class = ao2_iterator_next(&aoi))) {
        class->delme = 1;
        ao2_ref(class, -1);
    }
    ao2_iterator_destroy(&aoi);
 
    load_odbc_config();
 
    aoi = ao2_iterator_init(class_container, 0);
    while ((class = ao2_iterator_next(&aoi))) {
        if (class->delme) {
            ao2_unlink(class_container, class);
        }
        ao2_ref(class, -1);
    }
    ao2_iterator_destroy(&aoi);
 
    /* Empty the cache; it will get rebuilt the next time the tables are needed. */
    AST_RWLIST_WRLOCK(&odbc_tables);
    while ((table = AST_RWLIST_REMOVE_HEAD(&odbc_tables, list))) {
        destroy_table_cache(table);
    }
    AST_RWLIST_UNLOCK(&odbc_tables);
 
    return 0;
}

References ao2_iterator_destroy(), ao2_iterator_init(), ao2_iterator_next, ao2_ref, ao2_unlink, AST_RWLIST_REMOVE_HEAD, AST_RWLIST_UNLOCK, AST_RWLIST_WRLOCK, class_container, destroy_table_cache(), load_odbc_config(), and table.

unload_module()

static int unload_module ( void  )

static

Definition at line 1187 of file res_odbc.c.

{
    ao2_cleanup(class_container);
    ast_cli_unregister_multiple(cli_odbc, ARRAY_LEN(cli_odbc));
 
    return 0;
}

References ao2_cleanup, ARRAY_LEN, ast_cli_unregister_multiple(), class_container, and cli_odbc.

Variable Documentation

__mod_info

struct ast_module_info __mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_GLOBAL_SYMBOLS | AST_MODFLAG_LOAD_ORDER , .description = "ODBC resource" , .key = "This paragraph is copyright (c) 2006 by Digium, Inc. \In order for your module to load, it must return this \key via a function called \"key\". Any code which \includes this paragraph must be licensed under the GNU \General Public License version 2 or later (at your \option). In addition to Digium's general reservations \of rights, Digium expressly reserves the right to \allow other parties to license this paragraph under \different terms. Any use of Digium, Inc. trademarks or \logos (including \"Asterisk\" or \"Digium\") without \express written permission of Digium, Inc. is prohibited.\n" , .buildopt_sum = AST_BUILDOPT_SUM, .support_level = AST_MODULE_SUPPORT_CORE, .load = load_module, .unload = unload_module, .reload = reload, .load_pri = AST_MODPRI_REALTIME_DEPEND, .requires = "res_odbc_transaction", }

static

Definition at line 1219 of file res_odbc.c.

ast_module_info

const struct ast_module_info* ast_module_info = &__mod_info

static

Definition at line 1219 of file res_odbc.c.

class_container

struct ao2_container* class_container

static

Definition at line 110 of file res_odbc.c.

Referenced by _ast_odbc_request_obj2(), ast_odbc_get_max_connections(), handle_cli_odbc_show(), load_module(), odbc_register_class(), reload(), and unload_module().

cli_odbc

struct ast_cli_entry cli_odbc[]

static

Initial value:

= {
    { .handler =  handle_cli_odbc_show , .summary =  "List ODBC DSN(s)" ,}
}

Definition at line 804 of file res_odbc.c.

Referenced by load_module(), and unload_module().

errors_buf

struct ast_threadstorage errors_buf = { .once = PTHREAD_ONCE_INIT , .key_init = __init_errors_buf , .custom_init = NULL , }

static

Definition at line 118 of file res_odbc.c.

Referenced by ast_odbc_print_errors().

odbc_tables

struct odbc_tables odbc_tables = { .first = NULL, .last = NULL, .lock = { PTHREAD_RWLOCK_INITIALIZER , NULL, {1, 0} } , }

static