res_config_odbc.c File Reference

odbc+odbc plugin for portable configuration engine More...

#include "asterisk.h"
#include "asterisk/file.h"
#include "asterisk/channel.h"
#include "asterisk/pbx.h"
#include "asterisk/config.h"
#include "asterisk/module.h"
#include "asterisk/lock.h"
#include "asterisk/res_odbc.h"
#include "asterisk/utils.h"
#include "asterisk/stringfields.h"

Include dependency graph for res_config_odbc.c:

Go to the source code of this file.

Data Structures
struct	config_odbc_obj
struct	custom_prepare_struct
struct	update2_prepare_struct

Macros
#define	CHECK_SIZE(n)
#define	ENCODE_CHUNK(buffer, s)
#define	SQL_BUF_SIZE   1024
#define	warn_length(col, size)   ast_log(LOG_WARNING, "Realtime table %s@%s: column '%s' is not long enough to contain realtime data (needs %d)\n", table, database, col->name, size)
#define	warn_type(col, type)   ast_log(LOG_WARNING, "Realtime table %s@%s: column '%s' is of the incorrect type (%d) to contain the required realtime data\n", table, database, col->name, col->type)
#define	WARN_TYPE_OR_LENGTH(n)

Functions
static void	__init_rowdata_buf (void)
static void	__init_sql_buf (void)
static void	__reg_module (void)
static void	__unreg_module (void)
struct ast_module *	AST_MODULE_SELF_SYM (void)
static struct ast_config *	config_odbc (const char *database, const char *table, const char *file, struct ast_config *cfg, struct ast_flags flags, const char *sugg_incl, const char *who_asked)
static SQLHSTMT	config_odbc_prepare (struct odbc_obj *obj, void *data)
static SQLHSTMT	custom_prepare (struct odbc_obj *obj, void *data)
static void	decode_chunk (char *chunk)
static int	destroy_odbc (const char *database, const char *table, const char *keyfield, const char *lookup, const struct ast_variable *fields)
	Execute an DELETE query. More...
static int	is_text (const struct odbc_cache_columns *column)
static SQLHSTMT	length_determination_odbc_prepare (struct odbc_obj *obj, void *data)
static void	load_config (const char *filename)
static int	load_module (void)
static struct ast_config *	realtime_multi_odbc (const char *database, const char *table, const struct ast_variable *fields)
	Execute an Select query and return ast_config list. More...
static struct ast_variable *	realtime_odbc (const char *database, const char *table, const struct ast_variable *fields)
	Execute an SQL query and return ast_variable list. More...
static int	reload_module (void)
static int	require_odbc (const char *database, const char *table, va_list ap)
static int	store_odbc (const char *database, const char *table, const struct ast_variable *fields)
	Execute an INSERT query. More...
static int	unload_module (void)
static int	unload_odbc (const char *a, const char *b)
static int	update2_odbc (const char *database, const char *table, const struct ast_variable *lookup_fields, const struct ast_variable *update_fields)
	Execute an UPDATE query. More...
static SQLHSTMT	update2_prepare (struct odbc_obj *obj, void *data)
static int	update_odbc (const char *database, const char *table, const char *keyfield, const char *lookup, const struct ast_variable *fields)
	Execute an UPDATE query. More...

Variables
static struct ast_module_info	__mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_LOAD_ORDER , .description = "Realtime ODBC configuration" , .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_module, .load_pri = AST_MODPRI_REALTIME_DRIVER, .requires = "extconfig,res_odbc", }
static const struct ast_module_info *	ast_module_info = &__mod_info
static struct ast_config_engine	odbc_engine
static int	order_multi_row_results_by_initial_column = 1
static const char *	res_config_odbc_conf = "res_config_odbc.conf"
static struct ast_threadstorage	rowdata_buf = { .once = PTHREAD_ONCE_INIT , .key_init = __init_rowdata_buf , .custom_init = NULL , }
static struct ast_threadstorage	sql_buf = { .once = PTHREAD_ONCE_INIT , .key_init = __init_sql_buf , .custom_init = NULL , }

Detailed Description

odbc+odbc plugin for portable configuration engine

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

• http://www.unixodbc.org

Definition in file res_config_odbc.c.

Macro Definition Documentation

CHECK_SIZE

#define CHECK_SIZE

(

n

)

Value:

                        if (col->size < n) {      \
                            warn_length(col, n);  \
                        }                         \
                        break;

ENCODE_CHUNK

#define ENCODE_CHUNK	(		buffer,
			s
	)

Definition at line 68 of file res_config_odbc.c.

SQL_BUF_SIZE

#define SQL_BUF_SIZE   1024

Initial SQL query buffer size to allocate.

Definition at line 50 of file res_config_odbc.c.

warn_length

#define warn_length	(		col,
			size
	)		ast_log(LOG_WARNING, "Realtime table %s@%s: column '%s' is not long enough to contain realtime data (needs %d)\n", table, database, col->name, size)

Definition at line 1078 of file res_config_odbc.c.

warn_type

#define warn_type	(		col,
			type
	)		ast_log(LOG_WARNING, "Realtime table %s@%s: column '%s' is of the incorrect type (%d) to contain the required realtime data\n", table, database, col->name, col->type)

Definition at line 1079 of file res_config_odbc.c.

WARN_TYPE_OR_LENGTH

#define WARN_TYPE_OR_LENGTH

(

n

)

Value:

                        if (!ast_rq_is_int(type)) {  \
                            warn_type(col, type);    \
                        } else {                     \
                            warn_length(col, n);  \
                        }

Function Documentation

__init_rowdata_buf()

static void __init_rowdata_buf ( void  )

static

Definition at line 56 of file res_config_odbc.c.

{

__init_sql_buf()

static void __init_sql_buf ( void  )

static

Definition at line 55 of file res_config_odbc.c.

{

__reg_module()

static void __reg_module ( void  )

static

Definition at line 1307 of file res_config_odbc.c.

__unreg_module()

static void __unreg_module ( void  )

static

Definition at line 1307 of file res_config_odbc.c.

AST_MODULE_SELF_SYM()

struct ast_module * AST_MODULE_SELF_SYM

(

void

)

Definition at line 1307 of file res_config_odbc.c.

config_odbc()

static struct ast_config * config_odbc ( const char *  database, const char *  table, const char *  file, struct ast_config *  cfg, struct ast_flags  flags, const char *  sugg_incl, const char *  who_asked  )

static

Definition at line 946 of file res_config_odbc.c.

{
    struct ast_variable *new_v;
    struct ast_category *cur_cat;
    int res = 0;
    struct odbc_obj *obj;
    struct ast_str *sql = ast_str_thread_get(&sql_buf, SQL_BUF_SIZE);
    unsigned int last_cat_metric = 0;
    SQLSMALLINT rowcount = 0;
    SQLHSTMT stmt;
    char last[128] = "";
    struct config_odbc_obj q;
    struct ast_flags loader_flags = { 0 };
    struct ast_flags connected_flag = { RES_ODBC_CONNECTED };
 
    memset(&q, 0, sizeof(q));
 
    if (!file || !strcmp (file, res_config_odbc_conf) || !sql) {
        return NULL;        /* cant configure myself with myself ! */
    }
 
    obj = ast_odbc_request_obj2(database, connected_flag);
    if (!obj)
        return NULL;
 
    ast_str_set(&sql, 0, "SELECT MAX(LENGTH(var_val)) FROM %s WHERE filename='%s'",
        table, file);
    q.sql = ast_str_buffer(sql);
 
    stmt = ast_odbc_prepare_and_execute(obj, length_determination_odbc_prepare, &q);
    if (!stmt) {
        ast_log(LOG_WARNING, "SQL select error! [%s]\n", ast_str_buffer(sql));
        ast_odbc_release_obj(obj);
        return NULL;
    }
 
    res = SQLNumResultCols(stmt, &rowcount);
 
    if ((res != SQL_SUCCESS) && (res != SQL_SUCCESS_WITH_INFO)) {
        ast_log(LOG_WARNING, "SQL NumResultCols error! [%s]\n", ast_str_buffer(sql));
        SQLFreeHandle(SQL_HANDLE_STMT, stmt);
        ast_odbc_release_obj(obj);
        return NULL;
    }
 
    if (!rowcount) {
        ast_log(LOG_NOTICE, "found nothing\n");
        ast_odbc_release_obj(obj);
        return cfg;
    }
 
    /* There will be only one result for this, the maximum length of a variable value */
    if (SQLFetch(stmt) == SQL_NO_DATA) {
        ast_log(LOG_NOTICE, "Failed to determine maximum length of a configuration value\n");
        SQLFreeHandle(SQL_HANDLE_STMT, stmt);
        ast_odbc_release_obj(obj);
        return NULL;
    }
 
    /* Reset stuff to a fresh state for the actual query which will retrieve all configuration */
    SQLFreeHandle(SQL_HANDLE_STMT, stmt);
 
    ast_str_set(&sql, 0, "SELECT cat_metric, category, var_name, var_val FROM %s ", table);
    ast_str_append(&sql, 0, "WHERE filename='%s' AND commented=0 ", file);
    ast_str_append(&sql, 0, "ORDER BY cat_metric DESC, var_metric ASC, category, var_name ");
    q.sql = ast_str_buffer(sql);
 
    q.var_val_size += 1;
    q.var_val = ast_malloc(q.var_val_size);
    if (!q.var_val) {
        ast_log(LOG_WARNING, "Could not create buffer for reading in configuration values for '%s'\n", file);
        ast_odbc_release_obj(obj);
        return NULL;
    }
 
    stmt = ast_odbc_prepare_and_execute(obj, config_odbc_prepare, &q);
    if (!stmt) {
        ast_log(LOG_WARNING, "SQL select error! [%s]\n", ast_str_buffer(sql));
        ast_odbc_release_obj(obj);
        ast_free(q.var_val);
        return NULL;
    }
 
    res = SQLNumResultCols(stmt, &rowcount);
 
    if ((res != SQL_SUCCESS) && (res != SQL_SUCCESS_WITH_INFO)) {
        ast_log(LOG_WARNING, "SQL NumResultCols error! [%s]\n", ast_str_buffer(sql));
        SQLFreeHandle(SQL_HANDLE_STMT, stmt);
        ast_odbc_release_obj(obj);
        ast_free(q.var_val);
        return NULL;
    }
 
    if (!rowcount) {
        ast_log(LOG_NOTICE, "found nothing\n");
        ast_odbc_release_obj(obj);
        ast_free(q.var_val);
        return cfg;
    }
 
    cur_cat = ast_config_get_current_category(cfg);
 
    while ((res = SQLFetch(stmt)) != SQL_NO_DATA) {
        if (!strcmp (q.var_name, "#include")) {
            if (!ast_config_internal_load(q.var_val, cfg, loader_flags, "", who_asked)) {
                SQLFreeHandle(SQL_HANDLE_STMT, stmt);
                ast_odbc_release_obj(obj);
                ast_free(q.var_val);
                return NULL;
            }
            continue;
        }
        if (strcmp(last, q.category) || last_cat_metric != q.cat_metric) {
            cur_cat = ast_category_new_dynamic(q.category);
            if (!cur_cat) {
                break;
            }
            strcpy(last, q.category);
            last_cat_metric = q.cat_metric;
            ast_category_append(cfg, cur_cat);
        }
 
        new_v = ast_variable_new(q.var_name, q.var_val, "");
        ast_variable_append(cur_cat, new_v);
    }
 
    SQLFreeHandle(SQL_HANDLE_STMT, stmt);
    ast_odbc_release_obj(obj);
    ast_free(q.var_val);
    return cfg;
}

References ast_category_append(), ast_category_new_dynamic, ast_config_get_current_category(), ast_config_internal_load(), ast_free, ast_log, ast_malloc, ast_odbc_prepare_and_execute(), ast_odbc_release_obj(), ast_odbc_request_obj2, ast_str_append(), ast_str_buffer(), ast_str_set(), ast_str_thread_get(), ast_variable_append(), ast_variable_new, config_odbc_obj::cat_metric, config_odbc_obj::category, config_odbc_prepare(), make_ari_stubs::file, last, length_determination_odbc_prepare(), LOG_NOTICE, LOG_WARNING, NULL, res_config_odbc_conf, RES_ODBC_CONNECTED, config_odbc_obj::sql, sql_buf, SQL_BUF_SIZE, table, config_odbc_obj::var_name, config_odbc_obj::var_val, and config_odbc_obj::var_val_size.

config_odbc_prepare()

static SQLHSTMT config_odbc_prepare ( struct odbc_obj *  obj, void *  data  )

static

Definition at line 919 of file res_config_odbc.c.

{
    struct config_odbc_obj *q = data;
    SQLHSTMT sth;
    int res;
 
    res = SQLAllocHandle(SQL_HANDLE_STMT, obj->con, &sth);
    if ((res != SQL_SUCCESS) && (res != SQL_SUCCESS_WITH_INFO)) {
        ast_verb(4, "Failure in AllocStatement %d\n", res);
        return NULL;
    }
 
    res = ast_odbc_prepare(obj, sth, q->sql);
    if ((res != SQL_SUCCESS) && (res != SQL_SUCCESS_WITH_INFO)) {
        ast_verb(4, "Error in PREPARE %d\n", res);
        SQLFreeHandle(SQL_HANDLE_STMT, sth);
        return NULL;
    }
 
    SQLBindCol(sth, 1, SQL_C_ULONG, &q->cat_metric, sizeof(q->cat_metric), &q->err);
    SQLBindCol(sth, 2, SQL_C_CHAR, q->category, sizeof(q->category), &q->err);
    SQLBindCol(sth, 3, SQL_C_CHAR, q->var_name, sizeof(q->var_name), &q->err);
    SQLBindCol(sth, 4, SQL_C_CHAR, q->var_val, q->var_val_size, &q->err);
 
    return sth;
}

References ast_odbc_prepare(), ast_verb, config_odbc_obj::cat_metric, config_odbc_obj::category, odbc_obj::con, config_odbc_obj::err, NULL, config_odbc_obj::sql, config_odbc_obj::var_name, config_odbc_obj::var_val, and config_odbc_obj::var_val_size.

Referenced by config_odbc().

custom_prepare()

static SQLHSTMT custom_prepare ( struct odbc_obj *  obj, void *  data  )

static

Definition at line 104 of file res_config_odbc.c.

{
    int res, x = 1, count = 0;
    struct custom_prepare_struct *cps = data;
    const struct ast_variable *field;
    char encodebuf[1024];
    SQLHSTMT stmt;
 
    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!\n");
        return NULL;
    }
 
    ast_debug(1, "Skip: %llu; SQL: %s\n", cps->skip, cps->sql);
 
    res = ast_odbc_prepare(obj, stmt, cps->sql);
    if ((res != SQL_SUCCESS) && (res != SQL_SUCCESS_WITH_INFO)) {
        if (res == SQL_ERROR) {
            ast_odbc_print_errors(SQL_HANDLE_STMT, stmt, "SQL Prepare");
        }
        ast_log(LOG_WARNING, "SQL Prepare failed! [%s]\n", cps->sql);
        SQLFreeHandle (SQL_HANDLE_STMT, stmt);
        return NULL;
    }
 
    for (field = cps->fields; field; field = field->next) {
        const char *newval = field->value;
 
        if ((1LL << count++) & cps->skip) {
            ast_debug(1, "Skipping field '%s'='%s' (%llo/%llo)\n", field->name, newval, 1ULL << (count - 1), cps->skip);
            continue;
        }
        ast_debug(1, "Parameter %d ('%s') = '%s'\n", x, field->name, newval);
        if (strchr(newval, ';') || strchr(newval, '^')) {
            ENCODE_CHUNK(encodebuf, newval);
            ast_string_field_set(cps, encoding[x], encodebuf);
            newval = cps->encoding[x];
        }
        SQLBindParameter(stmt, x++, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_CHAR, strlen(newval), 0, (void *)newval, 0, NULL);
    }
 
    if (!ast_strlen_zero(cps->extra)) {
        const char *newval = cps->extra;
        ast_debug(1, "Parameter %d = '%s'\n", x, newval);
        if (strchr(newval, ';') || strchr(newval, '^')) {
            ENCODE_CHUNK(encodebuf, newval);
            ast_string_field_set(cps, encoding[x], encodebuf);
            newval = cps->encoding[x];
        }
        SQLBindParameter(stmt, x++, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_CHAR, strlen(newval), 0, (void *)newval, 0, NULL);
    }
 
    return stmt;
}

References ast_debug, ast_log, ast_odbc_prepare(), ast_odbc_print_errors(), ast_string_field_set, ast_strlen_zero(), odbc_obj::con, ENCODE_CHUNK, encoding, custom_prepare_struct::encoding, custom_prepare_struct::extra, custom_prepare_struct::fields, LOG_WARNING, ast_variable::name, ast_variable::next, NULL, custom_prepare_struct::skip, custom_prepare_struct::sql, and ast_variable::value.

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

decode_chunk()

static void decode_chunk ( char *  chunk )

static

Definition at line 88 of file res_config_odbc.c.

{
    for (; *chunk; chunk++) {
        if (*chunk == '^' && strchr("0123456789ABCDEF", chunk[1]) && strchr("0123456789ABCDEF", chunk[2])) {
            sscanf(chunk + 1, "%02hhX", (unsigned char *)chunk);
            memmove(chunk + 1, chunk + 3, strlen(chunk + 3) + 1);
        }
    }
}

Referenced by realtime_multi_odbc(), and realtime_odbc().

destroy_odbc()

static int destroy_odbc ( const char *  database, const char *  table, const char *  keyfield, const char *  lookup, const struct ast_variable *  fields  )

static

Execute an DELETE query.

Parameters

database
table
keyfield	where clause field
lookup	value of field for where clause
fields	list containing one or more field/value set(s)

Delete a row from a database table, prepare the sql statement using keyfield and lookup control the number of records to change. Additional params to match rows are stored in ap list. Sub-in the values to the prepared statement and execute it.

Returns

number of rows affected

Return values

-1	on failure

Definition at line 829 of file res_config_odbc.c.

{
    struct odbc_obj *obj;
    SQLHSTMT stmt;
    SQLLEN rowcount=0;
    struct ast_str *sql = ast_str_thread_get(&sql_buf, SQL_BUF_SIZE);
    const struct ast_variable *field;
    int res;
    struct custom_prepare_struct cps = { .extra = lookup, .fields = fields, };
    struct ast_flags connected_flag = { RES_ODBC_CONNECTED };
 
    if (!table || !sql) {
        return -1;
    }
 
    obj = ast_odbc_request_obj2(database, connected_flag);
    if (!obj) {
        return -1;
    }
 
    ast_str_set(&sql, 0, "DELETE FROM %s WHERE ", table);
    for (field = fields; field; field = field->next) {
        ast_str_append(&sql, 0, "%s=? AND ", field->name);
    }
    ast_str_append(&sql, 0, "%s=?", keyfield);
 
    cps.sql = ast_str_buffer(sql);
 
    if (ast_string_field_init(&cps, 256)) {
        ast_odbc_release_obj(obj);
        return -1;
    }
    stmt = ast_odbc_prepare_and_execute(obj, custom_prepare, &cps);
    ast_string_field_free_memory(&cps);
 
    if (!stmt) {
        ast_odbc_release_obj(obj);
        return -1;
    }
 
    res = SQLRowCount(stmt, &rowcount);
    SQLFreeHandle (SQL_HANDLE_STMT, stmt);
    ast_odbc_release_obj(obj);
 
    if ((res != SQL_SUCCESS) && (res != SQL_SUCCESS_WITH_INFO)) {
        ast_log(LOG_WARNING, "SQL Row Count error! [%s]\n", ast_str_buffer(sql));
        return -1;
    }
 
    if (rowcount >= 0)
        return (int)rowcount;
 
    return -1;
}

References ast_log, ast_odbc_prepare_and_execute(), ast_odbc_release_obj(), ast_odbc_request_obj2, ast_str_append(), ast_str_buffer(), ast_str_set(), ast_str_thread_get(), ast_string_field_free_memory, ast_string_field_init, custom_prepare(), custom_prepare_struct::extra, custom_prepare_struct::fields, LOG_WARNING, ast_variable::name, ast_variable::next, RES_ODBC_CONNECTED, custom_prepare_struct::sql, sql_buf, SQL_BUF_SIZE, and table.

is_text()

static int is_text ( const struct odbc_cache_columns *  column )

inlinestatic

Definition at line 98 of file res_config_odbc.c.

{
    return column->type == SQL_CHAR || column->type == SQL_VARCHAR || column->type == SQL_LONGVARCHAR
        || column->type == SQL_WCHAR || column->type == SQL_WVARCHAR || column->type == SQL_WLONGVARCHAR;
}

References odbc_cache_columns::type.

Referenced by update_odbc().

length_determination_odbc_prepare()

static SQLHSTMT length_determination_odbc_prepare ( struct odbc_obj *  obj, void *  data  )

static

Definition at line 895 of file res_config_odbc.c.

{
    struct config_odbc_obj *q = data;
    SQLHSTMT sth;
    int res;
 
    res = SQLAllocHandle(SQL_HANDLE_STMT, obj->con, &sth);
    if ((res != SQL_SUCCESS) && (res != SQL_SUCCESS_WITH_INFO)) {
        ast_verb(4, "Failure in AllocStatement %d\n", res);
        return NULL;
    }
 
    res = ast_odbc_prepare(obj, sth, q->sql);
    if ((res != SQL_SUCCESS) && (res != SQL_SUCCESS_WITH_INFO)) {
        ast_verb(4, "Error in PREPARE %d\n", res);
        SQLFreeHandle(SQL_HANDLE_STMT, sth);
        return NULL;
    }
 
    SQLBindCol(sth, 1, SQL_C_ULONG, &q->var_val_size, sizeof(q->var_val_size), &q->err);
 
    return sth;
}

References ast_odbc_prepare(), ast_verb, odbc_obj::con, config_odbc_obj::err, NULL, config_odbc_obj::sql, and config_odbc_obj::var_val_size.

Referenced by config_odbc().

load_config()

static void load_config ( const char *  filename )

static

Definition at line 1257 of file res_config_odbc.c.

{
    struct ast_config *config;
    struct ast_flags config_flags = { 0 };
    const char *s;
 
    config = ast_config_load(filename, config_flags);
    if (config == CONFIG_STATUS_FILEMISSING || config == CONFIG_STATUS_FILEINVALID) {
        if (config == CONFIG_STATUS_FILEINVALID) {
            ast_log(LOG_WARNING, "Unable to load config '%s'. Using defaults.\n", filename);
        }
        order_multi_row_results_by_initial_column = 1;
        return;
    }
 
    /* Result set ordering is enabled by default */
    s = ast_variable_retrieve(config, "general", "order_multi_row_results_by_initial_column");
    order_multi_row_results_by_initial_column = !s || ast_true(s);
 
    ast_config_destroy(config);
}

References ast_config_destroy(), ast_config_load, ast_log, ast_true(), ast_variable_retrieve(), config, CONFIG_STATUS_FILEINVALID, CONFIG_STATUS_FILEMISSING, LOG_WARNING, and order_multi_row_results_by_initial_column.

Referenced by load_module(), and reload_module().

load_module()

static int load_module ( void  )

static

Definition at line 1279 of file res_config_odbc.c.

{
    /* We'll either successfully load the configuration or fail with reasonable
     * defaults */
    load_config(res_config_odbc_conf);
    ast_config_engine_register(&odbc_engine);
    return 0;
}

References ast_config_engine_register(), load_config(), odbc_engine, and res_config_odbc_conf.

realtime_multi_odbc()

static struct ast_config * realtime_multi_odbc ( const char *  database, const char *  table, const struct ast_variable *  fields  )

static

Execute an Select query and return ast_config list.

Parameters

database
table
fields	list containing one or more field/operator/value set.

Select database and preform query on table, prepare the sql statement Sub-in the values to the prepared statement and execute it. Execute this prepared query against several ODBC connected databases. Return results as an ast_config variable.

Returns

var on success

Return values

NULL	on failure

Definition at line 345 of file res_config_odbc.c.

{
    struct odbc_obj *obj;
    SQLHSTMT stmt;
    char coltitle[256];
    struct ast_str *sql = ast_str_thread_get(&sql_buf, SQL_BUF_SIZE);
    struct ast_str *rowdata = ast_str_thread_get(&rowdata_buf, 128);
    const char *initfield;
    char *op;
    const struct ast_variable *field = fields;
    char *stringp;
    char *chunk;
    SQLSMALLINT collen;
    int res;
    int x;
    struct ast_variable *var=NULL;
    struct ast_config *cfg=NULL;
    struct ast_category *cat=NULL;
    struct ast_flags connected_flag = { RES_ODBC_CONNECTED };
    SQLULEN colsize;
    SQLSMALLINT colcount=0;
    SQLSMALLINT datatype;
    SQLSMALLINT decimaldigits;
    SQLSMALLINT nullable;
    SQLLEN indicator;
    struct custom_prepare_struct cps = { .fields = fields, };
 
    if (!table || !field || !sql || !rowdata) {
        return NULL;
    }
 
    obj = ast_odbc_request_obj2(database, connected_flag);
    if (!obj) {
        return NULL;
    }
 
    initfield = ast_strdupa(field->name);
    if ((op = strchr(initfield, ' '))) {
        *op = '\0';
    }
 
    op = !strchr(field->name, ' ') ? " =" : "";
    ast_str_set(&sql, 0, "SELECT * FROM %s WHERE %s%s ?%s", table, field->name, op,
        strcasestr(field->name, "LIKE") && !ast_odbc_backslash_is_escape(obj) ? " ESCAPE '\\\\'" : "");
    while ((field = field->next)) {
        op = !strchr(field->name, ' ') ? " =" : "";
        ast_str_append(&sql, 0, " AND %s%s ?%s", field->name, op,
            strcasestr(field->name, "LIKE") && !ast_odbc_backslash_is_escape(obj) ? " ESCAPE '\\\\'" : "");
    }
 
    if (order_multi_row_results_by_initial_column) {
        ast_str_append(&sql, 0, " ORDER BY %s", initfield);
    }
 
    cps.sql = ast_str_buffer(sql);
 
    if (ast_string_field_init(&cps, 256)) {
        ast_odbc_release_obj(obj);
        return NULL;
    }
    stmt = ast_odbc_prepare_and_execute(obj, custom_prepare, &cps);
    ast_string_field_free_memory(&cps);
 
    if (!stmt) {
        ast_odbc_release_obj(obj);
        return NULL;
    }
 
    res = SQLNumResultCols(stmt, &colcount);
    if ((res != SQL_SUCCESS) && (res != SQL_SUCCESS_WITH_INFO)) {
        ast_log(LOG_WARNING, "SQL Column Count error! [%s]\n", ast_str_buffer(sql));
        SQLFreeHandle(SQL_HANDLE_STMT, stmt);
        ast_odbc_release_obj(obj);
        return NULL;
    }
 
    cfg = ast_config_new();
    if (!cfg) {
        ast_log(LOG_WARNING, "Out of memory!\n");
        SQLFreeHandle(SQL_HANDLE_STMT, stmt);
        ast_odbc_release_obj(obj);
        return NULL;
    }
 
    while ((res=SQLFetch(stmt)) != SQL_NO_DATA) {
        var = NULL;
        if ((res != SQL_SUCCESS) && (res != SQL_SUCCESS_WITH_INFO)) {
            ast_log(LOG_WARNING, "SQL Fetch error! [%s]\n", ast_str_buffer(sql));
            continue;
        }
        cat = ast_category_new_anonymous();
        if (!cat) {
            continue;
        }
        for (x=0;x<colcount;x++) {
            colsize = 0;
            collen = sizeof(coltitle);
            res = SQLDescribeCol(stmt, x + 1, (unsigned char *)coltitle, sizeof(coltitle), &collen,
                        &datatype, &colsize, &decimaldigits, &nullable);
            if ((res != SQL_SUCCESS) && (res != SQL_SUCCESS_WITH_INFO)) {
                ast_log(LOG_WARNING, "SQL Describe Column error! [%s]\n", ast_str_buffer(sql));
                ast_category_destroy(cat);
                goto next_sql_fetch;
            }
 
            ast_str_reset(rowdata);
            indicator = 0;
 
            res = SQLGetData(stmt, x + 1, SQL_CHAR, ast_str_buffer(rowdata), ast_str_size(rowdata), &indicator);
            ast_str_update(rowdata);
            if (indicator == SQL_NULL_DATA) {
                continue;
            }
 
            if ((res == SQL_SUCCESS) || (res == SQL_SUCCESS_WITH_INFO)) {
                if (indicator != ast_str_strlen(rowdata)) {
                    /* If the available space was not enough to contain the row data enlarge and read in the rest */
                    ast_str_make_space(&rowdata, indicator + 1);
                    res = SQLGetData(stmt, x + 1, SQL_CHAR, ast_str_buffer(rowdata) + ast_str_strlen(rowdata),
                        ast_str_size(rowdata) - ast_str_strlen(rowdata), &indicator);
                    ast_str_update(rowdata);
                }
            }
 
            if ((res != SQL_SUCCESS) && (res != SQL_SUCCESS_WITH_INFO)) {
                ast_log(LOG_WARNING, "SQL Get Data error! [%s]\n", ast_str_buffer(sql));
                ast_category_destroy(cat);
                goto next_sql_fetch;
            }
            stringp = ast_str_buffer(rowdata);
            if (!strncmp(coltitle, "@", 1)) {
                /* The '@' prefix indicates it's a sorcery extended field.
                 * Because ast_load_realtime_fields eliminates empty entries and makes blank (single whitespace)
                 * entries empty and keeps them, the empty or NULL values are encoded
                 * as a string containing a single whitespace. */
                var = ast_variable_new(coltitle, S_OR(stringp," "), "");
                ast_variable_append(cat, var);
            } else {
                while (stringp) {
                    chunk = strsep(&stringp, ";");
                    if (!ast_strlen_zero(ast_strip(chunk))) {
                        if (strchr(chunk, '^')) {
                            decode_chunk(chunk);
                        }
                        if (!strcmp(initfield, coltitle)) {
                            ast_category_rename(cat, chunk);
                        }
                        var = ast_variable_new(coltitle, chunk, "");
                        ast_variable_append(cat, var);
                    }
                }
            }
        }
        ast_category_append(cfg, cat);
next_sql_fetch:;
    }
 
    SQLFreeHandle(SQL_HANDLE_STMT, stmt);
    ast_odbc_release_obj(obj);
    return cfg;
}

References ast_category_append(), ast_category_destroy(), ast_category_new_anonymous, ast_category_rename(), ast_config_new(), ast_log, ast_odbc_backslash_is_escape(), ast_odbc_prepare_and_execute(), ast_odbc_release_obj(), ast_odbc_request_obj2, ast_str_append(), ast_str_buffer(), ast_str_make_space, ast_str_reset(), ast_str_set(), ast_str_size(), ast_str_strlen(), ast_str_thread_get(), ast_str_update(), ast_strdupa, ast_string_field_free_memory, ast_string_field_init, ast_strip(), ast_strlen_zero(), ast_variable_append(), ast_variable_new, custom_prepare(), decode_chunk(), custom_prepare_struct::fields, indicator, LOG_WARNING, ast_variable::name, ast_variable::next, NULL, order_multi_row_results_by_initial_column, RES_ODBC_CONNECTED, rowdata_buf, S_OR, custom_prepare_struct::sql, sql_buf, SQL_BUF_SIZE, strcasestr(), strsep(), table, and var.

realtime_odbc()

static struct ast_variable * realtime_odbc ( const char *  database, const char *  table, const struct ast_variable *  fields  )

static

Execute an SQL query and return ast_variable list.

Parameters

database
table
fields	list containing one or more field/operator/value set.

Select database and preform query on table, prepare the sql statement Sub-in the values to the prepared statement and execute it. Return results as a ast_variable list.

Returns

var on success

Return values

NULL	on failure

Definition at line 173 of file res_config_odbc.c.

{
    struct odbc_obj *obj;
    SQLHSTMT stmt;
    char coltitle[256];
    struct ast_str *sql = ast_str_thread_get(&sql_buf, SQL_BUF_SIZE);
    struct ast_str *rowdata = ast_str_thread_get(&rowdata_buf, 128);
    char *op;
    const struct ast_variable *field = fields;
    char *stringp;
    char *chunk;
    SQLSMALLINT collen;
    int res;
    int x;
    struct ast_variable *var=NULL, *prev=NULL;
    SQLULEN colsize;
    SQLSMALLINT colcount=0;
    SQLSMALLINT datatype;
    SQLSMALLINT decimaldigits;
    SQLSMALLINT nullable;
    SQLLEN indicator;
    struct custom_prepare_struct cps = { .fields = fields, };
    struct ast_flags connected_flag = { RES_ODBC_CONNECTED };
 
    if (!table || !field || !sql || !rowdata) {
        return NULL;
    }
 
    obj = ast_odbc_request_obj2(database, connected_flag);
    if (!obj) {
        ast_log(LOG_ERROR, "No database handle available with the name of '%s' (check res_odbc.conf)\n", database);
        return NULL;
    }
 
    op = !strchr(field->name, ' ') ? " =" : "";
    ast_str_set(&sql, 0, "SELECT * FROM %s WHERE %s%s ?%s", table, field->name, op,
        strcasestr(field->name, "LIKE") && !ast_odbc_backslash_is_escape(obj) ? " ESCAPE '\\\\'" : "");
    while ((field = field->next)) {
        op = !strchr(field->name, ' ') ? " =" : "";
        ast_str_append(&sql, 0, " AND %s%s ?%s", field->name, op,
            strcasestr(field->name, "LIKE") && !ast_odbc_backslash_is_escape(obj) ? " ESCAPE '\\\\'" : "");
    }
 
    cps.sql = ast_str_buffer(sql);
 
    if (ast_string_field_init(&cps, 256)) {
        ast_odbc_release_obj(obj);
        return NULL;
    }
    stmt = ast_odbc_prepare_and_execute(obj, custom_prepare, &cps);
    ast_string_field_free_memory(&cps);
 
    if (!stmt) {
        ast_odbc_release_obj(obj);
        return NULL;
    }
 
    res = SQLNumResultCols(stmt, &colcount);
    if ((res != SQL_SUCCESS) && (res != SQL_SUCCESS_WITH_INFO)) {
        ast_log(LOG_WARNING, "SQL Column Count error! [%s]\n", ast_str_buffer(sql));
        SQLFreeHandle (SQL_HANDLE_STMT, stmt);
        ast_odbc_release_obj(obj);
        return NULL;
    }
 
    res = SQLFetch(stmt);
    if (res == SQL_NO_DATA) {
        SQLFreeHandle (SQL_HANDLE_STMT, stmt);
        ast_odbc_release_obj(obj);
        return NULL;
    }
    if ((res != SQL_SUCCESS) && (res != SQL_SUCCESS_WITH_INFO)) {
        ast_log(LOG_WARNING, "SQL Fetch error! [%s]\n", ast_str_buffer(sql));
        SQLFreeHandle (SQL_HANDLE_STMT, stmt);
        ast_odbc_release_obj(obj);
        return NULL;
    }
    for (x = 0; x < colcount; x++) {
        colsize = 0;
        collen = sizeof(coltitle);
        res = SQLDescribeCol(stmt, x + 1, (unsigned char *)coltitle, sizeof(coltitle), &collen,
                    &datatype, &colsize, &decimaldigits, &nullable);
        if ((res != SQL_SUCCESS) && (res != SQL_SUCCESS_WITH_INFO)) {
            ast_log(LOG_WARNING, "SQL Describe Column error! [%s]\n", ast_str_buffer(sql));
            if (var)
                ast_variables_destroy(var);
            ast_odbc_release_obj(obj);
            return NULL;
        }
 
        ast_str_reset(rowdata);
        indicator = 0;
 
        res = SQLGetData(stmt, x + 1, SQL_CHAR, ast_str_buffer(rowdata), ast_str_size(rowdata), &indicator);
        ast_str_update(rowdata);
        if (indicator == SQL_NULL_DATA) {
            ast_str_reset(rowdata);
        } else if (!ast_str_strlen(rowdata)) {
            /* Because we encode the empty string for a NULL, we will encode
             * actual empty strings as a string containing a single whitespace. */
            ast_str_set(&rowdata, -1, "%s", " ");
        } else if ((res == SQL_SUCCESS) || (res == SQL_SUCCESS_WITH_INFO)) {
            if (indicator != ast_str_strlen(rowdata)) {
                /* If the available space was not enough to contain the row data enlarge and read in the rest */
                ast_str_make_space(&rowdata, indicator + 1);
                res = SQLGetData(stmt, x + 1, SQL_CHAR, ast_str_buffer(rowdata) + ast_str_strlen(rowdata),
                    ast_str_size(rowdata) - ast_str_strlen(rowdata), &indicator);
                ast_str_update(rowdata);
            }
        }
 
        if ((res != SQL_SUCCESS) && (res != SQL_SUCCESS_WITH_INFO)) {
            ast_log(LOG_WARNING, "SQL Get Data error! [%s]\n", ast_str_buffer(sql));
            if (var)
                ast_variables_destroy(var);
            ast_odbc_release_obj(obj);
            return NULL;
        }
 
        stringp = ast_str_buffer(rowdata);
        if (!strncmp(coltitle, "@", 1)) {
            /* The '@' prefix indicates it's a sorcery extended field.
             * Because ast_load_realtime_fields eliminates empty entries and makes blank (single whitespace)
             * entries empty and keeps them, the empty or NULL values are encoded
             * as a string containing a single whitespace. */
            if (prev) {
                prev->next = ast_variable_new(coltitle, S_OR(stringp," "), "");
                if (prev->next) {
                    prev = prev->next;
                }
            } else {
                prev = var = ast_variable_new(coltitle, S_OR(stringp," "), "");
            }
        } else {
            while (stringp) {
                chunk = strsep(&stringp, ";");
                if (!ast_strlen_zero(ast_strip(chunk))) {
                    if (strchr(chunk, '^')) {
                        decode_chunk(chunk);
                    }
                    if (prev) {
                        prev->next = ast_variable_new(coltitle, chunk, "");
                        if (prev->next) {
                            prev = prev->next;
                        }
                    } else {
                        prev = var = ast_variable_new(coltitle, chunk, "");
                    }
                }
            }
        }
    }
 
    SQLFreeHandle(SQL_HANDLE_STMT, stmt);
    ast_odbc_release_obj(obj);
    return var;
}

References ast_log, ast_odbc_backslash_is_escape(), ast_odbc_prepare_and_execute(), ast_odbc_release_obj(), ast_odbc_request_obj2, ast_str_append(), ast_str_buffer(), ast_str_make_space, ast_str_reset(), ast_str_set(), ast_str_size(), ast_str_strlen(), ast_str_thread_get(), ast_str_update(), ast_string_field_free_memory, ast_string_field_init, ast_strip(), ast_strlen_zero(), ast_variable_new, ast_variables_destroy(), custom_prepare(), decode_chunk(), custom_prepare_struct::fields, indicator, LOG_ERROR, LOG_WARNING, ast_variable::name, ast_variable::next, NULL, RES_ODBC_CONNECTED, rowdata_buf, S_OR, custom_prepare_struct::sql, sql_buf, SQL_BUF_SIZE, strcasestr(), strsep(), table, and var.

reload_module()

static int reload_module ( void  )

static

Definition at line 1288 of file res_config_odbc.c.

{
    load_config(res_config_odbc_conf);
    return 0;
}

References load_config(), and res_config_odbc_conf.

require_odbc()

static int require_odbc ( const char *  database, const char *  table, va_list  ap  )

static

Definition at line 1081 of file res_config_odbc.c.

{
    struct odbc_cache_tables *tableptr = ast_odbc_find_table(database, table);
    struct odbc_cache_columns *col;
    char *elm;
    int type, size;
 
    if (!tableptr) {
        return -1;
    }
 
    while ((elm = va_arg(ap, char *))) {
        type = va_arg(ap, require_type);
        size = va_arg(ap, int);
        /* Check if the field matches the criteria */
        AST_RWLIST_TRAVERSE(&tableptr->columns, col, list) {
            if (strcmp(col->name, elm) == 0) {
                /* Type check, first.  Some fields are more particular than others */
                switch (col->type) {
                case SQL_CHAR:
                case SQL_VARCHAR:
                case SQL_LONGVARCHAR:
#ifdef HAVE_ODBC_WCHAR
                case SQL_WCHAR:
                case SQL_WVARCHAR:
                case SQL_WLONGVARCHAR:
#endif
                case SQL_BINARY:
                case SQL_VARBINARY:
                case SQL_LONGVARBINARY:
                case SQL_GUID:
#define CHECK_SIZE(n) \
                        if (col->size < n) {      \
                            warn_length(col, n);  \
                        }                         \
                        break;
                    switch (type) {
                    case RQ_UINTEGER1: CHECK_SIZE(3)  /*         255 */
                    case RQ_INTEGER1:  CHECK_SIZE(4)  /*        -128 */
                    case RQ_UINTEGER2: CHECK_SIZE(5)  /*       65535 */
                    case RQ_INTEGER2:  CHECK_SIZE(6)  /*      -32768 */
                    case RQ_UINTEGER3:                /*    16777215 */
                    case RQ_INTEGER3:  CHECK_SIZE(8)  /*    -8388608 */
                    case RQ_DATE:                     /*  2008-06-09 */
                    case RQ_UINTEGER4: CHECK_SIZE(10) /*  4200000000 */
                    case RQ_INTEGER4:  CHECK_SIZE(11) /* -2100000000 */
                    case RQ_DATETIME:                 /* 2008-06-09 16:03:47 */
                    case RQ_UINTEGER8: CHECK_SIZE(19) /* trust me    */
                    case RQ_INTEGER8:  CHECK_SIZE(20) /* ditto       */
                    case RQ_FLOAT:
                    case RQ_CHAR:      CHECK_SIZE(size)
                    }
#undef CHECK_SIZE
                    break;
                case SQL_TYPE_DATE:
                    if (type != RQ_DATE) {
                        warn_type(col, type);
                    }
                    break;
                case SQL_TYPE_TIMESTAMP:
                case SQL_TIMESTAMP:
                case SQL_DATETIME:
                    if (type != RQ_DATE && type != RQ_DATETIME) {
                        warn_type(col, type);
                    }
                    break;
                case SQL_BIT:
                    warn_length(col, size);
                    break;
#define WARN_TYPE_OR_LENGTH(n)  \
                        if (!ast_rq_is_int(type)) {  \
                            warn_type(col, type);    \
                        } else {                     \
                            warn_length(col, n);  \
                        }
                case SQL_TINYINT:
                    if (type != RQ_UINTEGER1) {
                        WARN_TYPE_OR_LENGTH(size)
                    }
                    break;
                case SQL_C_STINYINT:
                    if (type != RQ_INTEGER1) {
                        WARN_TYPE_OR_LENGTH(size)
                    }
                    break;
                case SQL_C_USHORT:
                    if (type != RQ_UINTEGER1 && type != RQ_INTEGER1 && type != RQ_UINTEGER2) {
                        WARN_TYPE_OR_LENGTH(size)
                    }
                    break;
                case SQL_SMALLINT:
                case SQL_C_SSHORT:
                    if (type != RQ_UINTEGER1 && type != RQ_INTEGER1 && type != RQ_INTEGER2) {
                        WARN_TYPE_OR_LENGTH(size)
                    }
                    break;
                case SQL_C_ULONG:
                    if (type != RQ_UINTEGER1 && type != RQ_INTEGER1 &&
                        type != RQ_UINTEGER2 && type != RQ_INTEGER2 &&
                        type != RQ_UINTEGER3 && type != RQ_INTEGER3 &&
                        type != RQ_INTEGER4) {
                        WARN_TYPE_OR_LENGTH(size)
                    }
                    break;
                case SQL_INTEGER:
                case SQL_C_SLONG:
                    if (type != RQ_UINTEGER1 && type != RQ_INTEGER1 &&
                        type != RQ_UINTEGER2 && type != RQ_INTEGER2 &&
                        type != RQ_UINTEGER3 && type != RQ_INTEGER3 &&
                        type != RQ_INTEGER4) {
                        WARN_TYPE_OR_LENGTH(size)
                    }
                    break;
                case SQL_C_UBIGINT:
                    if (type != RQ_UINTEGER1 && type != RQ_INTEGER1 &&
                        type != RQ_UINTEGER2 && type != RQ_INTEGER2 &&
                        type != RQ_UINTEGER3 && type != RQ_INTEGER3 &&
                        type != RQ_UINTEGER4 && type != RQ_INTEGER4 &&
                        type != RQ_INTEGER8) {
                        WARN_TYPE_OR_LENGTH(size)
                    }
                    break;
                case SQL_BIGINT:
                case SQL_C_SBIGINT:
                    if (type != RQ_UINTEGER1 && type != RQ_INTEGER1 &&
                        type != RQ_UINTEGER2 && type != RQ_INTEGER2 &&
                        type != RQ_UINTEGER3 && type != RQ_INTEGER3 &&
                        type != RQ_UINTEGER4 && type != RQ_INTEGER4 &&
                        type != RQ_INTEGER8) {
                        WARN_TYPE_OR_LENGTH(size)
                    }
                    break;
#undef WARN_TYPE_OR_LENGTH
                case SQL_NUMERIC:
                case SQL_DECIMAL:
                case SQL_FLOAT:
                case SQL_REAL:
                case SQL_DOUBLE:
                    if (!ast_rq_is_int(type) && type != RQ_FLOAT) {
                        warn_type(col, type);
                    }
                    break;
                default:
                    ast_log(LOG_WARNING, "Realtime table %s@%s: column type (%d) unrecognized for column '%s'\n", table, database, col->type, elm);
                }
                break;
            }
        }
        if (!col) {
            ast_log(LOG_WARNING, "Realtime table %s@%s requires column '%s', but that column does not exist!\n", table, database, elm);
        }
    }
    AST_RWLIST_UNLOCK(&tableptr->columns);
    return 0;
}

References ast_log, ast_odbc_find_table(), ast_rq_is_int(), AST_RWLIST_TRAVERSE, AST_RWLIST_UNLOCK, CHECK_SIZE, odbc_cache_tables::columns, LOG_WARNING, odbc_cache_columns::name, RQ_CHAR, RQ_DATE, RQ_DATETIME, RQ_FLOAT, RQ_INTEGER1, RQ_INTEGER2, RQ_INTEGER3, RQ_INTEGER4, RQ_INTEGER8, RQ_UINTEGER1, RQ_UINTEGER2, RQ_UINTEGER3, RQ_UINTEGER4, RQ_UINTEGER8, odbc_cache_columns::size, table, type, odbc_cache_columns::type, warn_length, warn_type, and WARN_TYPE_OR_LENGTH.

store_odbc()

static int store_odbc ( const char *  database, const char *  table, const struct ast_variable *  fields  )

static

Execute an INSERT query.

Parameters

database
table
fields	list containing one or more field/value set(s)

Insert a new record into database table, prepare the sql statement. All values to be changed are stored in ap list. Sub-in the values to the prepared statement and execute it.

Returns

number of rows affected

Return values

-1	on failure

Definition at line 746 of file res_config_odbc.c.

{
    struct odbc_obj *obj;
    SQLHSTMT stmt;
    SQLLEN rowcount=0;
    const struct ast_variable *field = fields;
    struct ast_str *keys;
    struct ast_str *vals;
    struct ast_str *sql = ast_str_thread_get(&sql_buf, SQL_BUF_SIZE);
    int res;
    struct custom_prepare_struct cps = { .fields = fields, };
    struct ast_flags connected_flag = { RES_ODBC_CONNECTED };
 
    keys = ast_str_create(SQL_BUF_SIZE / 2);
    vals = ast_str_create(SQL_BUF_SIZE / 4);
    if (!table || !field || !keys || !vals || !sql) {
        ast_free(vals);
        ast_free(keys);
        return -1;
    }
 
    obj = ast_odbc_request_obj2(database, connected_flag);
    if (!obj) {
        ast_free(vals);
        ast_free(keys);
        return -1;
    }
 
    ast_str_set(&keys, 0, "%s", field->name);
    ast_str_set(&vals, 0, "?");
    while ((field = field->next)) {
        ast_str_append(&keys, 0, ", %s", field->name);
        ast_str_append(&vals, 0, ", ?");
    }
    ast_str_set(&sql, 0, "INSERT INTO %s (%s) VALUES (%s)",
        table, ast_str_buffer(keys), ast_str_buffer(vals));
 
    ast_free(vals);
    ast_free(keys);
    cps.sql = ast_str_buffer(sql);
 
    if (ast_string_field_init(&cps, 256)) {
        ast_odbc_release_obj(obj);
        return -1;
    }
    stmt = ast_odbc_prepare_and_execute(obj, custom_prepare, &cps);
    ast_string_field_free_memory(&cps);
 
    if (!stmt) {
        ast_odbc_release_obj(obj);
        return -1;
    }
 
    res = SQLRowCount(stmt, &rowcount);
    SQLFreeHandle (SQL_HANDLE_STMT, stmt);
    ast_odbc_release_obj(obj);
 
    if ((res != SQL_SUCCESS) && (res != SQL_SUCCESS_WITH_INFO)) {
        ast_log(LOG_WARNING, "SQL Row Count error! [%s]\n", ast_str_buffer(sql));
        return -1;
    }
 
    if (rowcount >= 0)
        return (int)rowcount;
 
    return -1;
}

References ast_free, ast_log, ast_odbc_prepare_and_execute(), ast_odbc_release_obj(), ast_odbc_request_obj2, ast_str_append(), ast_str_buffer(), ast_str_create, ast_str_set(), ast_str_thread_get(), ast_string_field_free_memory, ast_string_field_init, custom_prepare(), custom_prepare_struct::fields, keys, LOG_WARNING, ast_variable::name, ast_variable::next, RES_ODBC_CONNECTED, custom_prepare_struct::sql, sql_buf, SQL_BUF_SIZE, and table.

unload_module()

static int unload_module ( void  )

static

Definition at line 1294 of file res_config_odbc.c.

{
    ast_config_engine_deregister(&odbc_engine);
    return 0;
}

References ast_config_engine_deregister(), and odbc_engine.

unload_odbc()

static int unload_odbc ( const char *  a, const char *  b  )

static

Definition at line 1239 of file res_config_odbc.c.

{
    return ast_odbc_clear_cache(a, b);
}

References a, ast_odbc_clear_cache(), and b.

update2_odbc()

static int update2_odbc ( const char *  database, const char *  table, const struct ast_variable *  lookup_fields, const struct ast_variable *  update_fields  )

static

Execute an UPDATE query.

Parameters

database,table,lookup_fields
update_fields	list containing one or more field/value set(s).

Update a database table, preparing the sql statement from a list of key/value pairs specified in ap. The lookup pairs are specified first and are separated from the update pairs by a sentinel value. Sub-in the values to the prepared statement and execute it.

Returns

number of rows affected

Return values

-1	on failure

Definition at line 680 of file res_config_odbc.c.

{
    struct odbc_obj *obj;
    SQLHSTMT stmt;
    struct update2_prepare_struct ups = {
        .database = database,
        .table = table,
        .lookup_fields = lookup_fields,
        .update_fields = update_fields,
    };
    struct ast_str *sql;
    int res;
    SQLLEN rowcount = 0;
 
    ups.tableptr = ast_odbc_find_table(database, table);
    if (!ups.tableptr) {
        ast_log(LOG_ERROR, "Could not retrieve metadata for table '%s@%s'. Update will fail!\n", table, database);
        return -1;
    }
 
    if (!(obj = ast_odbc_request_obj(database, 0))) {
        ast_odbc_release_table(ups.tableptr);
        return -1;
    }
 
    if (!(stmt = ast_odbc_prepare_and_execute(obj, update2_prepare, &ups))) {
        ast_odbc_release_obj(obj);
        ast_odbc_release_table(ups.tableptr);
        return -1;
    }
 
    /* We don't need the table anymore */
    ast_odbc_release_table(ups.tableptr);
 
    res = SQLRowCount(stmt, &rowcount);
    SQLFreeHandle(SQL_HANDLE_STMT, stmt);
    ast_odbc_release_obj(obj);
 
    if ((res != SQL_SUCCESS) && (res != SQL_SUCCESS_WITH_INFO)) {
        /* Since only a single thread can access this memory, we can retrieve what would otherwise be lost. */
        sql = ast_str_thread_get(&sql_buf, SQL_BUF_SIZE);
        ast_assert(sql != NULL);
        ast_log(LOG_WARNING, "SQL Row Count error! [%s]\n", ast_str_buffer(sql));
        return -1;
    }
 
    if (rowcount >= 0) {
        return (int) rowcount;
    }
 
    return -1;
}

References ast_assert, ast_log, ast_odbc_find_table(), ast_odbc_prepare_and_execute(), ast_odbc_release_obj(), ast_odbc_release_table, ast_odbc_request_obj, ast_str_buffer(), ast_str_thread_get(), update2_prepare_struct::database, LOG_ERROR, LOG_WARNING, update2_prepare_struct::lookup_fields, NULL, sql_buf, SQL_BUF_SIZE, table, update2_prepare_struct::tableptr, update2_prepare(), and update2_prepare_struct::update_fields.

update2_prepare()

static SQLHSTMT update2_prepare ( struct odbc_obj *  obj, void *  data  )

static

Definition at line 610 of file res_config_odbc.c.

{
    int res, x = 1, first = 1;
    struct update2_prepare_struct *ups = data;
    const struct ast_variable *field;
    struct ast_str *sql = ast_str_thread_get(&sql_buf, SQL_BUF_SIZE);
    SQLHSTMT stmt;
 
    if (!sql) {
        return NULL;
    }
 
    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!\n");
        return NULL;
    }
 
    ast_str_set(&sql, 0, "UPDATE %s SET ", ups->table);
 
    for (field = ups->update_fields; field; field = field->next) {
        if (ast_odbc_find_column(ups->tableptr, field->name)) {
            ast_str_append(&sql, 0, "%s%s=? ", first ? "" : ", ", field->name);
            SQLBindParameter(stmt, x++, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_CHAR, strlen(field->name), 0, (void *)field->value, 0, NULL);
            first = 0;
        } else {
            ast_log(LOG_NOTICE, "Not updating column '%s' in '%s@%s' because that column does not exist!\n", field->name, ups->table, ups->database);
        }
    }
 
    ast_str_append(&sql, 0, "WHERE");
    first = 1;
 
    for (field = ups->lookup_fields; field; field = field->next) {
        if (!ast_odbc_find_column(ups->tableptr, field->name)) {
            ast_log(LOG_ERROR, "One or more of the criteria columns '%s' on '%s@%s' for this update does not exist!\n", field->name, ups->table, ups->database);
            SQLFreeHandle(SQL_HANDLE_STMT, stmt);
            return NULL;
        }
        ast_str_append(&sql, 0, "%s %s=?", first ? "" : " AND", field->name);
        SQLBindParameter(stmt, x++, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_CHAR, strlen(field->value), 0, (void *)field->value, 0, NULL);
        first = 0;
    }
 
    res = ast_odbc_prepare(obj, stmt, ast_str_buffer(sql));
    if ((res != SQL_SUCCESS) && (res != SQL_SUCCESS_WITH_INFO)) {
        if (res == SQL_ERROR) {
            ast_odbc_print_errors(SQL_HANDLE_STMT, stmt, "SQL Prepare");
        }
        ast_log(LOG_WARNING, "SQL Prepare failed! [%s]\n", ast_str_buffer(sql));
        SQLFreeHandle(SQL_HANDLE_STMT, stmt);
        return NULL;
    }
 
    return stmt;
}

References ast_log, ast_odbc_find_column(), ast_odbc_prepare(), ast_odbc_print_errors(), ast_str_append(), ast_str_buffer(), ast_str_set(), ast_str_thread_get(), odbc_obj::con, update2_prepare_struct::database, first, LOG_ERROR, LOG_NOTICE, LOG_WARNING, update2_prepare_struct::lookup_fields, ast_variable::name, ast_variable::next, NULL, sql_buf, SQL_BUF_SIZE, update2_prepare_struct::table, update2_prepare_struct::tableptr, update2_prepare_struct::update_fields, and ast_variable::value.

Referenced by update2_odbc().

update_odbc()

static int update_odbc ( const char *  database, const char *  table, const char *  keyfield, const char *  lookup, const struct ast_variable *  fields  )

static

Execute an UPDATE query.

Parameters

database
table
keyfield	where clause field
lookup	value of field for where clause
fields	list containing one or more field/value set(s).

Update a database table, prepare the sql statement using keyfield and lookup control the number of records to change. All values to be changed are stored in ap list. Sub-in the values to the prepared statement and execute it.

Returns

number of rows affected

Return values

-1	on failure

Definition at line 522 of file res_config_odbc.c.

{
    struct odbc_obj *obj;
    SQLHSTMT stmt;
    SQLLEN rowcount=0;
    struct ast_str *sql = ast_str_thread_get(&sql_buf, SQL_BUF_SIZE);
    const struct ast_variable *field = fields;
    int res, count = 0, paramcount = 0;
    struct custom_prepare_struct cps = { .extra = lookup, .fields = fields, };
    struct odbc_cache_tables *tableptr;
    struct odbc_cache_columns *column = NULL;
    struct ast_flags connected_flag = { RES_ODBC_CONNECTED };
 
    if (!table || !field || !keyfield || !sql) {
        return -1;
    }
 
    tableptr = ast_odbc_find_table(database, table);
    if (!(obj = ast_odbc_request_obj2(database, connected_flag))) {
        ast_odbc_release_table(tableptr);
        return -1;
    }
 
    if (tableptr && !ast_odbc_find_column(tableptr, keyfield)) {
        ast_log(LOG_WARNING, "Key field '%s' does not exist in table '%s@%s'.  Update will fail\n", keyfield, table, database);
    }
 
    ast_str_set(&sql, 0, "UPDATE %s SET ", table);
    while (field) {
        if ((tableptr && (column = ast_odbc_find_column(tableptr, field->name))) || count >= 64) {
            if (paramcount++) {
                ast_str_append(&sql, 0, ", ");
            }
            /* NULL test for non-text columns */
            if (count < 64 && ast_strlen_zero(field->value) && column->nullable && !is_text(column)) {
                ast_str_append(&sql, 0, "%s=NULL", field->name);
                cps.skip |= (1LL << count);
            } else {
                /* Value is not an empty string, or column is of text type, or we couldn't fit any more into cps.skip (count >= 64 ?!). */
                ast_str_append(&sql, 0, "%s=?", field->name);
            }
        } else { /* the column does not exist in the table */
            cps.skip |= (1LL << count);
        }
        ++count;
        field = field->next;
    }
    ast_str_append(&sql, 0, " WHERE %s=?", keyfield);
    ast_odbc_release_table(tableptr);
 
    cps.sql = ast_str_buffer(sql);
 
    if (ast_string_field_init(&cps, 256)) {
        ast_odbc_release_obj(obj);
        return -1;
    }
    stmt = ast_odbc_prepare_and_execute(obj, custom_prepare, &cps);
    ast_string_field_free_memory(&cps);
 
    if (!stmt) {
        ast_odbc_release_obj(obj);
        return -1;
    }
 
    res = SQLRowCount(stmt, &rowcount);
    SQLFreeHandle (SQL_HANDLE_STMT, stmt);
    ast_odbc_release_obj(obj);
 
    if ((res != SQL_SUCCESS) && (res != SQL_SUCCESS_WITH_INFO)) {
        ast_log(LOG_WARNING, "SQL Row Count error! [%s]\n", ast_str_buffer(sql));
        return -1;
    }
 
    if (rowcount >= 0) {
        return (int) rowcount;
    }
 
    return -1;
}

References ast_log, ast_odbc_find_column(), ast_odbc_find_table(), ast_odbc_prepare_and_execute(), ast_odbc_release_obj(), ast_odbc_release_table, ast_odbc_request_obj2, ast_str_append(), ast_str_buffer(), ast_str_set(), ast_str_thread_get(), ast_string_field_free_memory, ast_string_field_init, ast_strlen_zero(), custom_prepare(), custom_prepare_struct::extra, custom_prepare_struct::fields, is_text(), LOG_WARNING, ast_variable::name, ast_variable::next, NULL, odbc_cache_columns::nullable, RES_ODBC_CONNECTED, custom_prepare_struct::skip, custom_prepare_struct::sql, sql_buf, SQL_BUF_SIZE, table, and ast_variable::value.

Variable Documentation

__mod_info

struct ast_module_info __mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_LOAD_ORDER , .description = "Realtime ODBC configuration" , .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_module, .load_pri = AST_MODPRI_REALTIME_DRIVER, .requires = "extconfig,res_odbc", }

static

Definition at line 1307 of file res_config_odbc.c.

ast_module_info

const struct ast_module_info* ast_module_info = &__mod_info

static

Definition at line 1307 of file res_config_odbc.c.

odbc_engine

struct ast_config_engine odbc_engine

static

Definition at line 1244 of file res_config_odbc.c.

Referenced by load_module(), and unload_module().

order_multi_row_results_by_initial_column

int order_multi_row_results_by_initial_column = 1

static

Definition at line 53 of file res_config_odbc.c.

Referenced by load_config(), and realtime_multi_odbc().

res_config_odbc_conf

const char* res_config_odbc_conf = "res_config_odbc.conf"

static

Definition at line 52 of file res_config_odbc.c.

Referenced by config_odbc(), load_module(), and reload_module().

rowdata_buf

struct ast_threadstorage rowdata_buf = { .once = PTHREAD_ONCE_INIT , .key_init = __init_rowdata_buf , .custom_init = NULL , }

static

Definition at line 56 of file res_config_odbc.c.

Referenced by realtime_multi_odbc(), and realtime_odbc().

sql_buf

struct ast_threadstorage sql_buf = { .once = PTHREAD_ONCE_INIT , .key_init = __init_sql_buf , .custom_init = NULL , }

static

Definition at line 55 of file res_config_odbc.c.

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