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)
	Get a ODBC connection object. More...
struct odbc_obj *	_ast_odbc_request_obj2 (const char *name, struct ast_flags flags, const char *file, const char *function, int lineno)
	Retrieves a connected ODBC object. More...
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 nonprepared 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)
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 = "30ef0c93b36035ec78c9cfd712d36d9b" , .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

Definition in file res_odbc.c.

Function Documentation

__init_errors_buf()

static void __init_errors_buf ( void  )

static

Definition at line 113 of file res_odbc.c.

{

__reg_module()

static void __reg_module ( void  )

static

Definition at line 1147 of file res_odbc.c.

__unreg_module()

static void __unreg_module ( void  )

static

Definition at line 1147 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
	)

Get a ODBC connection object.

The "check" parameter is leftover from an earlier implementation where database connections were cached by res_odbc. Since connections are managed by unixODBC now, this parameter is only kept around for API compatibility.

Parameters

name	The name of the res_odbc.conf section describing the database to connect to
check	unused

Returns

A connection to the database. Call ast_odbc_release_obj() when finished.

Definition at line 984 of file res_odbc.c.

References _ast_odbc_request_obj2(), and RES_ODBC_SANITY_CHECK.

{
   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);
}

_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
	)

Retrieves a connected ODBC object.

Deprecated:

This is only around for backwards-compatibility with older versions of Asterisk.

Definition at line 917 of file res_odbc.c.

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

Referenced by _ast_odbc_request_obj().

{
   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;
   }

   ast_mutex_lock(&class->lock);

   while (!obj) {
      obj = AST_LIST_REMOVE_HEAD(&class->connections, list);

      if (!obj) {
         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) {
               break;
            }

            obj->parent = ao2_bump(class);
            if (odbc_obj_connect(obj) == ODBC_FAIL) {
               ao2_ref(obj->parent, -1);
               ao2_ref(obj, -1);
               obj = NULL;
               break;
            }

            class->connection_cnt++;
            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);
         }
      } 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.
          */
         ao2_ref(obj, -1);
         obj = NULL;
         class->connection_cnt--;
         ast_debug(2, "ODBC handle %p dead - removing from class '%s', new count is %zd\n",
            obj, name, class->connection_cnt);
      } 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);
      }
   }

   ast_mutex_unlock(&class->lock);
   ao2_ref(class, -1);

   return obj;
}

aoro2_class_cb()

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

static

Definition at line 847 of file res_odbc.c.

References CMP_MATCH, CMP_STOP, and odbc_class::name.

Referenced by _ast_odbc_request_obj2().

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

AST_MODULE_SELF_SYM()

struct ast_module* AST_MODULE_SELF_SYM

(

void

)

Definition at line 1147 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 507 of file res_odbc.c.

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

Referenced by acf_odbc_read(), and cli_odbc_read().

{
   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;
}

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

Returns

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

Definition at line 842 of file res_odbc.c.

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

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

{
   return obj->parent->backslash_is_escape;
}

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 554 of file res_odbc.c.

Referenced by create_transaction().

{
   return class->forcecommit;
}

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 549 of file res_odbc.c.

Referenced by create_transaction().

{
   return class->isolation;
}

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 559 of file res_odbc.c.

Referenced by ast_odbc_retrieve_transaction_obj().

{
   return class->name;
}

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, or -1 if no matching entry was found.

Since

1.6.1

Definition at line 352 of file res_odbc.c.

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(), odbc_class::list, and odbc_cache_tables::table.

Referenced by unload_odbc().

{
   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;
}

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.

Return values

a	statement handle
NULL	on error

Definition at line 369 of file res_odbc.c.

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().

{
   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;
}

ast_odbc_execute_sql()

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

Execute a nonprepared SQL query.

Parameters

obj	The ODBC object
sql	The SQL query

Note

This should be used in place of SQLExecDirect

Definition at line 478 of file res_odbc.c.

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().

{
   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);
}

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

Return values

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

Since

1.6.1

Definition at line 341 of file res_odbc.c.

References AST_RWLIST_TRAVERSE, odbc_cache_tables::columns, odbc_class::list, odbc_cache_columns::name, and NULL.

Referenced by update2_prepare(), and update_odbc().

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

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.

Parameters

database	Name of an ODBC class on which to query the table
tablename	Tablename to describe

Return values

A	structure describing the table layout, or NULL, if the table is not found or another error occurs. When a structure is returned, the contained columns list will be rdlock'ed, to ensure that it will be retained in memory.

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.

Since

1.6.1

Definition at line 241 of file res_odbc.c.

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_class::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().

{
   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;
}

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 857 of file res_odbc.c.

References ao2_callback, and ao2_ref.

Referenced by release_obj_or_dsn().

{
   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;
}

ast_odbc_isolation2text()

const char* ast_odbc_isolation2text

(

int

iso

)

Convert from numeric transaction isolation values to their textual counterparts.

Definition at line 132 of file res_odbc.c.

Referenced by acf_transaction_read().

{
   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";
   }
}

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 463 of file res_odbc.c.

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().

{
   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);
}

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.

Return values

a	statement handle
NULL	on error

Definition at line 407 of file res_odbc.c.

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(), free_zone(), odbc_log(), realtime_multi_odbc(), realtime_odbc(), store_odbc(), update2_odbc(), and update_odbc().

{
   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;
}

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 524 of file res_odbc.c.

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().

{
   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;
}

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 813 of file res_odbc.c.

References ao2_ref, ast_cond_signal, ast_debug, ast_free, AST_LIST_INSERT_HEAD, ast_mutex_lock, ast_mutex_unlock, odbc_class::list, NULL, odbc_obj::parent, and odbc_obj::sql_text.

Referenced by ast_odbc_find_table(), config_odbc(), create_transaction(), destroy_odbc(), dsn_destructor(), free_zone(), 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().

{
   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);
   AST_LIST_INSERT_HEAD(&class->connections, obj, list);
   ast_cond_signal(&class->cond);
   ast_mutex_unlock(&class->lock);

   ao2_ref(class, -1);
}

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 489 of file res_odbc.c.

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

{
   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;
}

ast_odbc_text2isolation()

int ast_odbc_text2isolation

(

const char *

txt

)

Convert from textual transaction isolation values to their numeric constants.

Definition at line 147 of file res_odbc.c.

Referenced by acf_transaction_write(), and load_odbc_config().

{
   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;
   }
}

connection_dead()

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

static

Definition at line 881 of file res_odbc.c.

References ast_strlen_zero, and odbc_obj::con.

Referenced by _ast_odbc_request_obj2().

{
   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;
}

destroy_table_cache()

static void destroy_table_cache ( struct odbc_cache_tables *  table )

static

Definition at line 201 of file res_odbc.c.

References ast_debug, ast_free, AST_RWLIST_HEAD_DESTROY, AST_RWLIST_REMOVE_HEAD, AST_RWLIST_UNLOCK, AST_RWLIST_WRLOCK, odbc_cache_tables::columns, odbc_class::list, and odbc_cache_tables::table.

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

{
   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);
}

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 716 of file res_odbc.c.

References ao2_iterator_destroy(), ao2_iterator_init(), ao2_iterator_next, ao2_ref, ast_cli_args::argc, ast_cli_args::argv, ast_cli(), ast_localtime(), ast_mutex_lock, ast_mutex_unlock, ast_strdup, ast_strftime(), CLI_GENERATE, CLI_INIT, CLI_SUCCESS, ast_cli_entry::command, ast_cli_args::fd, ast_cli_args::n, NULL, ast_cli_args::pos, ast_cli_entry::usage, and ast_cli_args::word.

{
   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, "    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;
}

load_module()

static int load_module ( void  )

static

Definition at line 1123 of file res_odbc.c.

References AO2_ALLOC_OPT_LOCK_MUTEX, ao2_container_alloc_list, ao2_match_by_addr(), ARRAY_LEN, ast_cli_register_multiple, AST_MODFLAG_GLOBAL_SYMBOLS, AST_MODFLAG_LOAD_ORDER, AST_MODPRI_REALTIME_DEPEND, AST_MODULE_INFO(), AST_MODULE_LOAD_DECLINE, AST_MODULE_LOAD_SUCCESS, ast_module_shutdown_ref, AST_MODULE_SUPPORT_CORE, ASTERISK_GPL_KEY, load_odbc_config(), NULL, reload(), ast_module_info::self, and unload_module().

{
   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;
}

load_odbc_config()

static int load_odbc_config ( void  )

static

Definition at line 564 of file res_odbc.c.

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(), config, CONFIG_STATUS_FILEINVALID, CONFIG_STATUS_FILEMISSING, odbc_class::conntimeout, odbc_class::dsn, enabled, odbc_class::forcecommit, odbc_class::isolation, LOG_ERROR, LOG_NOTICE, LOG_WARNING, odbc_class::logging, 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().

{
   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;
   struct ast_flags config_flags = { 0 };

   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;
         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;
               }
            }
         }

         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;

            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;
}

odbc_class_destructor()

static void odbc_class_destructor ( void *  data )

static

Definition at line 166 of file res_odbc.c.

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

Referenced by load_odbc_config().

{
   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);
}

odbc_obj_connect()

static odbc_status odbc_obj_connect ( struct odbc_obj *  obj )

static

Definition at line 1022 of file res_odbc.c.

References ast_assert, ast_debug, ast_log, 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().

{
   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) {
      ast_log(LOG_WARNING, "Not connecting to %s. Negative connection cache for %ld seconds\n", obj->parent->name, negative_cache_expiration - time(NULL));
      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;
}

odbc_obj_destructor()

static void odbc_obj_destructor ( void *  data )

static

Definition at line 194 of file res_odbc.c.

References odbc_obj_disconnect().

Referenced by _ast_odbc_request_obj2().

{
   struct odbc_obj *obj = data;

   odbc_obj_disconnect(obj);
}

odbc_obj_disconnect()

static odbc_status odbc_obj_disconnect ( struct odbc_obj *  obj )

static

Definition at line 995 of file res_odbc.c.

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

Referenced by odbc_obj_destructor().

{
   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;
}

odbc_register_class()

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

static

Definition at line 793 of file res_odbc.c.

References ao2_link, ast_odbc_release_obj(), and ast_odbc_request_obj.

Referenced by load_odbc_config().

{
   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;
}

reload()

static int reload ( void  )

static

Definition at line 1081 of file res_odbc.c.

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

Referenced by load_module().

{
   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;
}

unload_module()

static int unload_module ( void  )

static

Definition at line 1115 of file res_odbc.c.

References ao2_cleanup, ARRAY_LEN, and ast_cli_unregister_multiple().

Referenced by load_module().

{
   ao2_cleanup(class_container);
   ast_cli_unregister_multiple(cli_odbc, ARRAY_LEN(cli_odbc));

   return 0;
}

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 = "30ef0c93b36035ec78c9cfd712d36d9b" , .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 1147 of file res_odbc.c.

ast_module_info

const struct ast_module_info* ast_module_info = &__mod_info

static

Definition at line 1147 of file res_odbc.c.

class_container

struct ao2_container* class_container

static

Definition at line 105 of file res_odbc.c.

cli_odbc

struct ast_cli_entry cli_odbc[]

static

Initial value:

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

Definition at line 789 of file res_odbc.c.

errors_buf

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

static

Definition at line 113 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