func_odbc.c File Reference

ODBC lookups. More...

#include "asterisk.h"
#include "asterisk/module.h"
#include "asterisk/file.h"
#include "asterisk/channel.h"
#include "asterisk/pbx.h"
#include "asterisk/config.h"
#include "asterisk/res_odbc.h"
#include "asterisk/app.h"

Include dependency graph for func_odbc.c:

Go to the source code of this file.

Data Structures
struct	acf_odbc_query
struct	odbc_datastore
struct	odbc_datastore_row
struct	queries
Enumerations
enum	{ OPT_ESCAPECOMMAS = (1 << 0), OPT_MULTIROW = (1 << 1) }
Functions
static void	__init_coldata_buf (void)
static void	__init_colnames_buf (void)
static void	__reg_module (void)
static void	__unreg_module (void)
static int	acf_escape (struct ast_channel *chan, const char *cmd, char *data, char *buf, size_t len)
static int	acf_fetch (struct ast_channel *chan, const char *cmd, char *data, char *buf, size_t len)
static int	acf_odbc_read (struct ast_channel *chan, const char *cmd, char *s, char *buf, size_t len)
static int	acf_odbc_write (struct ast_channel *chan, const char *cmd, char *s, const char *value)
static int	exec_odbcfinish (struct ast_channel *chan, void *data)
static int	free_acf_query (struct acf_odbc_query *query)
static SQLHSTMT	generic_execute (struct odbc_obj *obj, void *data)
static int	init_acf_query (struct ast_config *cfg, char *catg, struct acf_odbc_query **query)
static int	load_module (void)
static void	odbc_datastore_free (void *data)
static int	reload (void)
static int	unload_module (void)
Variables
static struct ast_module_info	__mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_DEFAULT , .description = "ODBC lookups" , .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 = "a9c98e5d177805051735cb5b0b16b0a0" , .load = load_module, .unload = unload_module, .reload = reload, }
static char *	app_odbcfinish = "ODBCFinish"
static struct ast_module_info *	ast_module_info = &__mod_info
static struct ast_threadstorage	coldata_buf = { .once = { PTHREAD_ONCE_INIT } , .key_init = __init_coldata_buf , .custom_init = NULL , }
static struct ast_threadstorage	colnames_buf = { .once = { PTHREAD_ONCE_INIT } , .key_init = __init_colnames_buf , .custom_init = NULL , }
static char *	config = "func_odbc.conf"
static char *	desc_odbcfinish
static struct ast_custom_function	escape_function
static struct ast_custom_function	fetch_function
struct ast_datastore_info	odbc_info
enum { ... }	odbc_option_flags
static int	resultcount = 0
static char *	syn_odbcfinish = "Clear the resultset of a successful multirow query"

---

Detailed Description

ODBC lookups.

Author:

Tilghman Lesher <func_odbc__200508@the-tilghman.com>

Definition in file func_odbc.c.

---

Enumeration Type Documentation

anonymous enum

Enumerator:

OPT_ESCAPECOMMAS
OPT_MULTIROW

Definition at line 49 of file func_odbc.c.

     {
   OPT_ESCAPECOMMAS =   (1 << 0),
   OPT_MULTIROW     =   (1 << 1),
} odbc_option_flags;

---

Function Documentation

static void __init_coldata_buf

(

void

)

[static]

Definition at line 88 of file func_odbc.c.

{

static void __init_colnames_buf

(

void

)

[static]

Definition at line 89 of file func_odbc.c.

{

static void __reg_module

(

void

)

[static]

Definition at line 955 of file func_odbc.c.

static void __unreg_module

(

void

)

[static]

Definition at line 955 of file func_odbc.c.

static int acf_escape	(	struct ast_channel *	chan,
		const char *	cmd,
		char *	data,
		char *	buf,
		size_t	len
	)			[static]

Definition at line 549 of file func_odbc.c.

{
   char *out = buf;

   for (; *data && out - buf < len; data++) {
      if (*data == '\'') {
         *out = '\'';
         out++;
      }
      *out++ = *data;
   }
   *out = '\0';

   return 0;
}

static int acf_fetch	(	struct ast_channel *	chan,
		const char *	cmd,
		char *	data,
		char *	buf,
		size_t	len
	)			[static]

Definition at line 577 of file func_odbc.c.

References ast_channel_datastore_find(), ast_channel_datastore_remove(), ast_copy_string(), ast_datastore_free(), ast_free, AST_LIST_LOCK, AST_LIST_REMOVE_HEAD, AST_LIST_UNLOCK, odbc_datastore_row::data, ast_datastore::data, acf_odbc_query::list, odbc_datastore::names, odbc_info, and pbx_builtin_setvar_helper().

{
   struct ast_datastore *store;
   struct odbc_datastore *resultset;
   struct odbc_datastore_row *row;
   store = ast_channel_datastore_find(chan, &odbc_info, data);
   if (!store) {
      return -1;
   }
   resultset = store->data;
   AST_LIST_LOCK(resultset);
   row = AST_LIST_REMOVE_HEAD(resultset, list);
   AST_LIST_UNLOCK(resultset);
   if (!row) {
      /* Cleanup datastore */
      ast_channel_datastore_remove(chan, store);
      ast_datastore_free(store);
      return -1;
   }
   pbx_builtin_setvar_helper(chan, "~ODBCFIELDS~", resultset->names);
   ast_copy_string(buf, row->data, len);
   ast_free(row);
   return 0;
}

static int acf_odbc_read	(	struct ast_channel *	chan,
		const char *	cmd,
		char *	s,
		char *	buf,
		size_t	len
	)			[static]

Definition at line 258 of file func_odbc.c.

References acf_odbc_query::acf, AST_APP_ARG, ast_atomic_fetchadd_int(), ast_autoservice_start(), ast_autoservice_stop(), ast_calloc, ast_channel_alloc, ast_channel_datastore_add(), ast_channel_free(), ast_copy_string(), ast_datastore_alloc, ast_debug, AST_DECLARE_APP_ARGS, ast_free, AST_LIST_HEAD_INIT, AST_LIST_INSERT_TAIL, ast_log(), ast_odbc_direct_execute(), ast_odbc_release_obj(), ast_odbc_request_obj(), ast_realloc, AST_RWLIST_RDLOCK, AST_RWLIST_TRAVERSE, AST_RWLIST_UNLOCK, AST_STANDARD_APP_ARGS, ast_str_append(), ast_str_create(), ast_str_make_space(), ast_str_reset(), ast_str_thread_get(), ast_strlen_zero(), ast_test_flag, ast_verb, coldata_buf, colnames_buf, ast_datastore::data, dsn, generic_execute(), ast_str::len, acf_odbc_query::list, LOG_ERROR, LOG_WARNING, ast_custom_function::name, odbc_datastore_free(), odbc_info, OPT_ESCAPECOMMAS, OPT_MULTIROW, pbx_builtin_pushvar_helper(), pbx_builtin_setvar_helper(), pbx_substitute_variables_helper(), acf_odbc_query::readhandle, resultcount, acf_odbc_query::rowlimit, acf_odbc_query::sql_read, ast_str::str, and ast_str::used.

Referenced by init_acf_query().

{
   struct odbc_obj *obj = NULL;
   struct acf_odbc_query *query;
   char varname[15], rowcount[12] = "-1";
   struct ast_str *colnames = ast_str_thread_get(&colnames_buf, 16);
   int res, x, y, buflen = 0, escapecommas, rowlimit = 1, dsn, bogus_chan = 0;
   AST_DECLARE_APP_ARGS(args,
      AST_APP_ARG(field)[100];
   );
   SQLHSTMT stmt = NULL;
   SQLSMALLINT colcount=0;
   SQLLEN indicator;
   SQLSMALLINT collength;
   struct odbc_datastore *resultset = NULL;
   struct odbc_datastore_row *row = NULL;
   struct ast_str *sql = ast_str_create(16);

   if (!sql) {
      return -1;
   }

   ast_str_reset(colnames);

   AST_RWLIST_RDLOCK(&queries);
   AST_RWLIST_TRAVERSE(&queries, query, list) {
      if (!strcmp(query->acf->name, cmd)) {
         break;
      }
   }

   if (!query) {
      ast_log(LOG_ERROR, "No such function '%s'\n", cmd);
      AST_RWLIST_UNLOCK(&queries);
      pbx_builtin_setvar_helper(chan, "ODBCROWS", rowcount);
      ast_free(sql);
      return -1;
   }

   if (!chan) {
      if ((chan = ast_channel_alloc(0, 0, "", "", "", "", "", 0, "Bogus/func_odbc")))
         bogus_chan = 1;
   }

   if (chan)
      ast_autoservice_start(chan);

   AST_STANDARD_APP_ARGS(args, s);
   for (x = 0; x < args.argc; x++) {
      snprintf(varname, sizeof(varname), "ARG%d", x + 1);
      pbx_builtin_pushvar_helper(chan, varname, args.field[x]);
   }

   ast_str_make_space(&sql, strlen(query->sql_read) * 2);
   pbx_substitute_variables_helper(chan, query->sql_read, sql->str, sql->len - 1);

   /* Restore prior values */
   for (x = 0; x < args.argc; x++) {
      snprintf(varname, sizeof(varname), "ARG%d", x + 1);
      pbx_builtin_setvar_helper(chan, varname, NULL);
   }

   /* Save these flags, so we can release the lock */
   escapecommas = ast_test_flag(query, OPT_ESCAPECOMMAS);
   if (ast_test_flag(query, OPT_MULTIROW)) {
      resultset = ast_calloc(1, sizeof(*resultset));
      AST_LIST_HEAD_INIT(resultset);
      if (query->rowlimit)
         rowlimit = query->rowlimit;
      else
         rowlimit = INT_MAX;
   }
   AST_RWLIST_UNLOCK(&queries);

   for (dsn = 0; dsn < 5; dsn++) {
      if (!ast_strlen_zero(query->readhandle[dsn])) {
         obj = ast_odbc_request_obj(query->readhandle[dsn], 0);
         if (obj)
            stmt = ast_odbc_direct_execute(obj, generic_execute, sql->str);
      }
      if (stmt)
         break;
   }

   if (!stmt) {
      ast_log(LOG_ERROR, "Unable to execute query [%s]\n", sql->str);
      if (obj)
         ast_odbc_release_obj(obj);
      pbx_builtin_setvar_helper(chan, "ODBCROWS", rowcount);
      if (chan)
         ast_autoservice_stop(chan);
      if (bogus_chan)
         ast_channel_free(chan);
      ast_free(sql);
      return -1;
   }

   res = SQLNumResultCols(stmt, &colcount);
   if ((res != SQL_SUCCESS) && (res != SQL_SUCCESS_WITH_INFO)) {
      ast_log(LOG_WARNING, "SQL Column Count error!\n[%s]\n\n", sql->str);
      SQLCloseCursor(stmt);
      SQLFreeHandle (SQL_HANDLE_STMT, stmt);
      ast_odbc_release_obj(obj);
      pbx_builtin_setvar_helper(chan, "ODBCROWS", rowcount);
      if (chan)
         ast_autoservice_stop(chan);
      if (bogus_chan)
         ast_channel_free(chan);
      ast_free(sql);
      return -1;
   }

   res = SQLFetch(stmt);
   if ((res != SQL_SUCCESS) && (res != SQL_SUCCESS_WITH_INFO)) {
      int res1 = -1;
      if (res == SQL_NO_DATA) {
         ast_verb(4, "Found no rows [%s]\n", sql->str);
         res1 = 0;
         buf[0] = '\0';
         ast_copy_string(rowcount, "0", sizeof(rowcount));
      } else {
         ast_log(LOG_WARNING, "Error %d in FETCH [%s]\n", res, sql->str);
      }
      SQLCloseCursor(stmt);
      SQLFreeHandle(SQL_HANDLE_STMT, stmt);
      ast_odbc_release_obj(obj);
      pbx_builtin_setvar_helper(chan, "ODBCROWS", rowcount);
      if (chan)
         ast_autoservice_stop(chan);
      if (bogus_chan)
         ast_channel_free(chan);
      ast_free(sql);
      return res1;
   }

   for (y = 0; y < rowlimit; y++) {
      buf[0] = '\0';
      for (x = 0; x < colcount; x++) {
         int i;
         struct ast_str *coldata = ast_str_thread_get(&coldata_buf, 16);

         if (y == 0) {
            char colname[256];
            SQLULEN maxcol;

            res = SQLDescribeCol(stmt, x + 1, (unsigned char *)colname, sizeof(colname), &collength, NULL, &maxcol, NULL, NULL);
            ast_debug(3, "Got collength of %d and maxcol of %d for column '%s' (offset %d)\n", (int)collength, (int)maxcol, colname, x);
            if (((res != SQL_SUCCESS) && (res != SQL_SUCCESS_WITH_INFO)) || collength == 0) {
               snprintf(colname, sizeof(colname), "field%d", x);
            }

            if (coldata->len < maxcol + 1) {
               ast_str_make_space(&coldata, maxcol + 1);
            }

            if (colnames->used) {
               ast_str_append(&colnames, 0, ",");
            }
            ast_str_make_space(&colnames, strlen(colname) * 2 + 1 + colnames->used);

            /* Copy data, encoding '\' and ',' for the argument parser */
            for (i = 0; i < sizeof(colname); i++) {
               if (escapecommas && (colname[i] == '\\' || colname[i] == ',')) {
                  colnames->str[colnames->used++] = '\\';
               }
               colnames->str[colnames->used++] = colname[i];

               if (colname[i] == '\0') {
                  colnames->used--;
                  break;
               }
            }

            if (resultset) {
               void *tmp = ast_realloc(resultset, sizeof(*resultset) + colnames->used + 1);
               if (!tmp) {
                  ast_log(LOG_ERROR, "No space for a new resultset?\n");
                  ast_free(resultset);
                  SQLCloseCursor(stmt);
                  SQLFreeHandle(SQL_HANDLE_STMT, stmt);
                  ast_odbc_release_obj(obj);
                  pbx_builtin_setvar_helper(chan, "ODBCROWS", rowcount);
                  if (chan)
                     ast_autoservice_stop(chan);
                  if (bogus_chan)
                     ast_channel_free(chan);
                  ast_free(sql);
                  return -1;
               }
               resultset = tmp;
               strcpy((char *)resultset + sizeof(*resultset), colnames->str);
            }
         }

         buflen = strlen(buf);
         res = SQLGetData(stmt, x + 1, SQL_CHAR, coldata->str, coldata->len, &indicator);
         if (indicator == SQL_NULL_DATA) {
            ast_debug(3, "Got NULL data\n");
            ast_str_reset(coldata);
            res = SQL_SUCCESS;
         }

         if ((res != SQL_SUCCESS) && (res != SQL_SUCCESS_WITH_INFO)) {
            ast_log(LOG_WARNING, "SQL Get Data error!\n[%s]\n\n", sql->str);
            y = -1;
            buf[0] = '\0';
            goto end_acf_read;
         }

         ast_debug(2, "Got coldata of '%s'\n", coldata->str);
         coldata->used = strlen(coldata->str);

         /* Copy data, encoding '\' and ',' for the argument parser */
         for (i = 0; i < coldata->used; i++) {
            if (escapecommas && (coldata->str[i] == '\\' || coldata->str[i] == ',')) {
               buf[buflen++] = '\\';
            }
            buf[buflen++] = coldata->str[i];

            if (buflen >= len - 2)
               break;

            if (coldata->str[i] == '\0')
               break;
         }

         buf[buflen++] = ',';
         buf[buflen] = '\0';
         ast_debug(2, "buf is now set to '%s'\n", buf);
      }
      /* Trim trailing comma */
      buf[buflen - 1] = '\0';
      ast_debug(2, "buf is now set to '%s'\n", buf);

      if (resultset) {
         row = ast_calloc(1, sizeof(*row) + buflen);
         if (!row) {
            ast_log(LOG_ERROR, "Unable to allocate space for more rows in this resultset.\n");
            goto end_acf_read;
         }
         strcpy((char *)row + sizeof(*row), buf);
         AST_LIST_INSERT_TAIL(resultset, row, list);

         /* Get next row */
         res = SQLFetch(stmt);
         if ((res != SQL_SUCCESS) && (res != SQL_SUCCESS_WITH_INFO)) {
            if (res != SQL_NO_DATA)
               ast_log(LOG_WARNING, "Error %d in FETCH [%s]\n", res, sql->str);
            y++;
            break;
         }
      }
   }

end_acf_read:
   snprintf(rowcount, sizeof(rowcount), "%d", y);
   pbx_builtin_setvar_helper(chan, "ODBCROWS", rowcount);
   pbx_builtin_setvar_helper(chan, "~ODBCFIELDS~", colnames->str);
   if (resultset) {
      int uid;
      struct ast_datastore *odbc_store;
      uid = ast_atomic_fetchadd_int(&resultcount, +1) + 1;
      snprintf(buf, len, "%d", uid);
      odbc_store = ast_datastore_alloc(&odbc_info, buf);
      if (!odbc_store) {
         ast_log(LOG_ERROR, "Rows retrieved, but unable to store it in the channel.  Results fail.\n");
         odbc_datastore_free(resultset);
         SQLCloseCursor(stmt);
         SQLFreeHandle(SQL_HANDLE_STMT, stmt);
         ast_odbc_release_obj(obj);
         if (chan)
            ast_autoservice_stop(chan);
         if (bogus_chan)
            ast_channel_free(chan);
         ast_free(sql);
         return -1;
      }
      odbc_store->data = resultset;
      ast_channel_datastore_add(chan, odbc_store);
   }
   SQLCloseCursor(stmt);
   SQLFreeHandle(SQL_HANDLE_STMT, stmt);
   ast_odbc_release_obj(obj);
   if (chan)
      ast_autoservice_stop(chan);
   if (bogus_chan)
      ast_channel_free(chan);
   ast_free(sql);
   return 0;
}

static int acf_odbc_write	(	struct ast_channel *	chan,
		const char *	cmd,
		char *	s,
		const char *	value
	)			[static]

Definition at line 130 of file func_odbc.c.

References acf_odbc_query::acf, AST_APP_ARG, ast_autoservice_start(), ast_autoservice_stop(), ast_channel_alloc, ast_channel_free(), AST_DECLARE_APP_ARGS, ast_free, ast_log(), ast_odbc_direct_execute(), ast_odbc_release_obj(), ast_odbc_request_obj(), AST_RWLIST_RDLOCK, AST_RWLIST_TRAVERSE, AST_RWLIST_UNLOCK, AST_STANDARD_APP_ARGS, ast_str_create(), ast_str_make_space(), ast_strdupa, ast_strlen_zero(), buf, dsn, generic_execute(), ast_str::len, acf_odbc_query::list, LOG_ERROR, ast_custom_function::name, pbx_builtin_pushvar_helper(), pbx_builtin_setvar_helper(), pbx_substitute_variables_helper(), acf_odbc_query::sql_write, ast_str::str, and acf_odbc_query::writehandle.

Referenced by init_acf_query().

{
   struct odbc_obj *obj = NULL;
   struct acf_odbc_query *query;
   char *t, varname[15];
   int i, dsn, bogus_chan = 0;
   AST_DECLARE_APP_ARGS(values,
      AST_APP_ARG(field)[100];
   );
   AST_DECLARE_APP_ARGS(args,
      AST_APP_ARG(field)[100];
   );
   SQLHSTMT stmt = NULL;
   SQLLEN rows=0;
   struct ast_str *buf = ast_str_create(16);

   if (!buf) {
      return -1;
   }

   AST_RWLIST_RDLOCK(&queries);
   AST_RWLIST_TRAVERSE(&queries, query, list) {
      if (!strcmp(query->acf->name, cmd)) {
         break;
      }
   }

   if (!query) {
      ast_log(LOG_ERROR, "No such function '%s'\n", cmd);
      AST_RWLIST_UNLOCK(&queries);
      ast_free(buf);
      return -1;
   }

   if (!chan) {
      if ((chan = ast_channel_alloc(0, 0, "", "", "", "", "", 0, "Bogus/func_odbc")))
         bogus_chan = 1;
   }

   if (chan)
      ast_autoservice_start(chan);

   ast_str_make_space(&buf, strlen(query->sql_write) * 2);

   /* Parse our arguments */
   t = value ? ast_strdupa(value) : "";

   if (!s || !t) {
      ast_log(LOG_ERROR, "Out of memory\n");
      AST_RWLIST_UNLOCK(&queries);
      if (chan)
         ast_autoservice_stop(chan);
      if (bogus_chan)
         ast_channel_free(chan);
      ast_free(buf);
      return -1;
   }

   AST_STANDARD_APP_ARGS(args, s);
   for (i = 0; i < args.argc; i++) {
      snprintf(varname, sizeof(varname), "ARG%d", i + 1);
      pbx_builtin_pushvar_helper(chan, varname, args.field[i]);
   }

   /* Parse values, just like arguments */
   AST_STANDARD_APP_ARGS(values, t);
   for (i = 0; i < values.argc; i++) {
      snprintf(varname, sizeof(varname), "VAL%d", i + 1);
      pbx_builtin_pushvar_helper(chan, varname, values.field[i]);
   }

   /* Additionally set the value as a whole (but push an empty string if value is NULL) */
   pbx_builtin_pushvar_helper(chan, "VALUE", value ? value : "");

   pbx_substitute_variables_helper(chan, query->sql_write, buf->str, buf->len - 1);

   /* Restore prior values */
   for (i = 0; i < args.argc; i++) {
      snprintf(varname, sizeof(varname), "ARG%d", i + 1);
      pbx_builtin_setvar_helper(chan, varname, NULL);
   }

   for (i = 0; i < values.argc; i++) {
      snprintf(varname, sizeof(varname), "VAL%d", i + 1);
      pbx_builtin_setvar_helper(chan, varname, NULL);
   }
   pbx_builtin_setvar_helper(chan, "VALUE", NULL);

   AST_RWLIST_UNLOCK(&queries);

   for (dsn = 0; dsn < 5; dsn++) {
      if (!ast_strlen_zero(query->writehandle[dsn])) {
         obj = ast_odbc_request_obj(query->writehandle[dsn], 0);
         if (obj)
            stmt = ast_odbc_direct_execute(obj, generic_execute, buf->str);
      }
      if (stmt)
         break;
   }

   if (stmt) {
      /* Rows affected */
      SQLRowCount(stmt, &rows);
   }

   /* Output the affected rows, for all cases.  In the event of failure, we
    * flag this as -1 rows.  Note that this is different from 0 affected rows
    * which would be the case if we succeeded in our query, but the values did
    * not change. */
   snprintf(varname, sizeof(varname), "%d", (int)rows);
   pbx_builtin_setvar_helper(chan, "ODBCROWS", varname);

   if (stmt) {
      SQLCloseCursor(stmt);
      SQLFreeHandle(SQL_HANDLE_STMT, stmt);
   }
   if (obj)
      ast_odbc_release_obj(obj);

   if (chan)
      ast_autoservice_stop(chan);
   if (bogus_chan)
      ast_channel_free(chan);
   ast_free(buf);

   return 0;
}

static int exec_odbcfinish	(	struct ast_channel *	chan,
		void *	data
	)			[static]

Definition at line 621 of file func_odbc.c.

References ast_channel_datastore_find(), ast_channel_datastore_remove(), ast_datastore_free(), and odbc_info.

Referenced by load_module().

{
   struct ast_datastore *store = ast_channel_datastore_find(chan, &odbc_info, data);
   if (!store) /* Already freed; no big deal. */
      return 0;
   ast_channel_datastore_remove(chan, store);
   ast_datastore_free(store);
   return 0;
}

static int free_acf_query

(

struct acf_odbc_query *

query

)

[static]

Definition at line 819 of file func_odbc.c.

References acf_odbc_query::acf, ast_free, ast_custom_function::desc, ast_custom_function::name, and ast_custom_function::syntax.

Referenced by reload(), and unload_module().

{
   if (query) {
      if (query->acf) {
         if (query->acf->name)
            ast_free((char *)query->acf->name);
         if (query->acf->syntax)
            ast_free((char *)query->acf->syntax);
         if (query->acf->desc)
            ast_free((char *)query->acf->desc);
         ast_free(query->acf);
      }
      ast_free(query);
   }
   return 0;
}

static SQLHSTMT generic_execute	(	struct odbc_obj *	obj,
		void *	data
	)			[static]

Definition at line 104 of file func_odbc.c.

References ast_log(), odbc_obj::con, and LOG_WARNING.

Referenced by acf_odbc_read(), and acf_odbc_write().

{
   int res;
   char *sql = data;
   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;
   }

   res = SQLExecDirect(stmt, (unsigned char *)sql, SQL_NTS);
   if ((res != SQL_SUCCESS) && (res != SQL_SUCCESS_WITH_INFO)) {
      ast_log(LOG_WARNING, "SQL Exec Direct failed![%s]\n", sql);
      SQLCloseCursor(stmt);
      SQLFreeHandle (SQL_HANDLE_STMT, stmt);
      return NULL;
   }

   return stmt;
}

static int init_acf_query	(	struct ast_config *	cfg,
		char *	catg,
		struct acf_odbc_query **	query
	)			[static]

Definition at line 631 of file func_odbc.c.

References acf_odbc_query::acf, acf_odbc_read(), acf_odbc_write(), asprintf, AST_APP_ARG, ast_calloc, ast_clear_flag, ast_copy_string(), AST_DECLARE_APP_ARGS, ast_false(), ast_free, ast_log(), ast_set_flag, AST_STANDARD_APP_ARGS, ast_strdupa, ast_strlen_zero(), ast_variable_retrieve(), dsn, errno, LOG_ERROR, LOG_WARNING, OPT_ESCAPECOMMAS, OPT_MULTIROW, ast_custom_function::read, and ast_custom_function::synopsis.

Referenced by load_module(), and reload().

{
   const char *tmp;
   int i;
   int res;

   if (!cfg || !catg) {
      return EINVAL;
   }

   *query = ast_calloc(1, sizeof(struct acf_odbc_query));
   if (! (*query))
      return ENOMEM;

   if (((tmp = ast_variable_retrieve(cfg, catg, "writehandle"))) || ((tmp = ast_variable_retrieve(cfg, catg, "dsn")))) {
      char *tmp2 = ast_strdupa(tmp);
      AST_DECLARE_APP_ARGS(writeconf,
         AST_APP_ARG(dsn)[5];
      );
      AST_STANDARD_APP_ARGS(writeconf, tmp2);
      for (i = 0; i < 5; i++) {
         if (!ast_strlen_zero(writeconf.dsn[i]))
            ast_copy_string((*query)->writehandle[i], writeconf.dsn[i], sizeof((*query)->writehandle[i]));
      }
   }

   if ((tmp = ast_variable_retrieve(cfg, catg, "readhandle"))) {
      char *tmp2 = ast_strdupa(tmp);
      AST_DECLARE_APP_ARGS(readconf,
         AST_APP_ARG(dsn)[5];
      );
      AST_STANDARD_APP_ARGS(readconf, tmp2);
      for (i = 0; i < 5; i++) {
         if (!ast_strlen_zero(readconf.dsn[i]))
            ast_copy_string((*query)->readhandle[i], readconf.dsn[i], sizeof((*query)->readhandle[i]));
      }
   } else {
      /* If no separate readhandle, then use the writehandle for reading */
      for (i = 0; i < 5; i++) {
         if (!ast_strlen_zero((*query)->writehandle[i]))
            ast_copy_string((*query)->readhandle[i], (*query)->writehandle[i], sizeof((*query)->readhandle[i]));
      }
   }

   if ((tmp = ast_variable_retrieve(cfg, catg, "readsql")))
      ast_copy_string((*query)->sql_read, tmp, sizeof((*query)->sql_read));
   else if ((tmp = ast_variable_retrieve(cfg, catg, "read"))) {
      ast_log(LOG_WARNING, "Parameter 'read' is deprecated for category %s.  Please use 'readsql' instead.\n", catg);
      ast_copy_string((*query)->sql_read, tmp, sizeof((*query)->sql_read));
   }

   if (!ast_strlen_zero((*query)->sql_read) && ast_strlen_zero((*query)->readhandle[0])) {
      ast_free(*query);
      *query = NULL;
      ast_log(LOG_ERROR, "There is SQL, but no ODBC class to be used for reading: %s\n", catg);
      return EINVAL;
   }

   if ((tmp = ast_variable_retrieve(cfg, catg, "writesql")))
      ast_copy_string((*query)->sql_write, tmp, sizeof((*query)->sql_write));
   else if ((tmp = ast_variable_retrieve(cfg, catg, "write"))) {
      ast_log(LOG_WARNING, "Parameter 'write' is deprecated for category %s.  Please use 'writesql' instead.\n", catg);
      ast_copy_string((*query)->sql_write, tmp, sizeof((*query)->sql_write));
   }

   if (!ast_strlen_zero((*query)->sql_write) && ast_strlen_zero((*query)->writehandle[0])) {
      ast_free(*query);
      *query = NULL;
      ast_log(LOG_ERROR, "There is SQL, but no ODBC class to be used for writing: %s\n", catg);
      return EINVAL;
   }

   /* Allow escaping of embedded commas in fields to be turned off */
   ast_set_flag((*query), OPT_ESCAPECOMMAS);
   if ((tmp = ast_variable_retrieve(cfg, catg, "escapecommas"))) {
      if (ast_false(tmp))
         ast_clear_flag((*query), OPT_ESCAPECOMMAS);
   }

   if ((tmp = ast_variable_retrieve(cfg, catg, "mode"))) {
      if (strcasecmp(tmp, "multirow") == 0)
         ast_set_flag((*query), OPT_MULTIROW);
      if ((tmp = ast_variable_retrieve(cfg, catg, "rowlimit")))
         sscanf(tmp, "%30d", &((*query)->rowlimit));
   }

   (*query)->acf = ast_calloc(1, sizeof(struct ast_custom_function));
   if (! (*query)->acf) {
      ast_free(*query);
      *query = NULL;
      return ENOMEM;
   }

   if ((tmp = ast_variable_retrieve(cfg, catg, "prefix")) && !ast_strlen_zero(tmp)) {
      if (asprintf((char **)&((*query)->acf->name), "%s_%s", tmp, catg) < 0) {
         ast_log(LOG_WARNING, "asprintf() failed: %s\n", strerror(errno));
      }
   } else {
      if (asprintf((char **)&((*query)->acf->name), "ODBC_%s", catg) < 0) {
         ast_log(LOG_WARNING, "asprintf() failed: %s\n", strerror(errno));
      }
   }

   if (!((*query)->acf->name)) {
      ast_free((*query)->acf);
      ast_free(*query);
      *query = NULL;
      return ENOMEM;
   }

   if (asprintf((char **)&((*query)->acf->syntax), "%s(<arg1>[...[,<argN>]])", (*query)->acf->name) < 0) {
      ast_log(LOG_WARNING, "asprintf() failed: %s\n", strerror(errno));
      (*query)->acf->syntax = NULL;
   }

   if (!((*query)->acf->syntax)) {
      ast_free((char *)(*query)->acf->name);
      ast_free((*query)->acf);
      ast_free(*query);
      *query = NULL;
      return ENOMEM;
   }

   (*query)->acf->synopsis = "Runs the referenced query with the specified arguments";

   res = 0;
   if (!ast_strlen_zero((*query)->sql_read) && !ast_strlen_zero((*query)->sql_write)) {
      res = asprintf((char **)&((*query)->acf->desc),
                "Runs the following query, as defined in func_odbc.conf, performing\n"
                "substitution of the arguments into the query as specified by ${ARG1},\n"
                "${ARG2}, ... ${ARGn}.  When setting the function, the values are provided\n"
                "either in whole as ${VALUE} or parsed as ${VAL1}, ${VAL2}, ... ${VALn}.\n"
                "\nRead:\n%s\n\nWrite:\n%s\n",
                (*query)->sql_read,
                (*query)->sql_write);
   } else if (!ast_strlen_zero((*query)->sql_read)) {
      res = asprintf((char **)&((*query)->acf->desc),
                "Runs the following query, as defined in func_odbc.conf, performing\n"
                "substitution of the arguments into the query as specified by ${ARG1},\n"
                "${ARG2}, ... ${ARGn}.  This function may only be read, not set.\n\nSQL:\n%s\n",
                (*query)->sql_read);
   } else if (!ast_strlen_zero((*query)->sql_write)) {
      res = asprintf((char **)&((*query)->acf->desc),
                "Runs the following query, as defined in func_odbc.conf, performing\n"
                "substitution of the arguments into the query as specified by ${ARG1},\n"
                "${ARG2}, ... ${ARGn}.  The values are provided either in whole as\n"
                "${VALUE} or parsed as ${VAL1}, ${VAL2}, ... ${VALn}.\n"
                "This function may only be set.\nSQL:\n%s\n",
                (*query)->sql_write);
   } else {
      ast_free((char *)(*query)->acf->syntax);
      ast_free((char *)(*query)->acf->name);
      ast_free((*query)->acf);
      ast_free(*query);
      ast_log(LOG_WARNING, "Section %s was found, but there was no SQL to execute.  Ignoring.\n", catg);
      return EINVAL;
   }

   if (res < 0) {
      ast_log(LOG_WARNING, "asprintf() failed: %s\n", strerror(errno));
      (*query)->acf->desc = NULL;
   }


   if (!((*query)->acf->desc)) {
      ast_free((char *)(*query)->acf->syntax);
      ast_free((char *)(*query)->acf->name);
      ast_free((*query)->acf);
      ast_free(*query);
      *query = NULL;
      return ENOMEM;
   }

   if (ast_strlen_zero((*query)->sql_read)) {
      (*query)->acf->read = NULL;
   } else {
      (*query)->acf->read = acf_odbc_read;
   }

   if (ast_strlen_zero((*query)->sql_write)) {
      (*query)->acf->write = NULL;
   } else {
      (*query)->acf->write = acf_odbc_write;
   }

   return 0;
}

static int load_module

(

void

)

[static]

Definition at line 836 of file func_odbc.c.

References acf_odbc_query::acf, app_odbcfinish, ast_category_browse(), ast_config_destroy(), ast_config_load, ast_custom_function_register, ast_log(), AST_MODULE_LOAD_DECLINE, ast_register_application, AST_RWLIST_INSERT_HEAD, AST_RWLIST_UNLOCK, AST_RWLIST_WRLOCK, desc_odbcfinish, escape_function, exec_odbcfinish(), fetch_function, init_acf_query(), acf_odbc_query::list, LOG_ERROR, LOG_NOTICE, and syn_odbcfinish.

{
   int res = 0;
   struct ast_config *cfg;
   char *catg;
   struct ast_flags config_flags = { 0 };

   res |= ast_custom_function_register(&fetch_function);
   res |= ast_register_application(app_odbcfinish, exec_odbcfinish, syn_odbcfinish, desc_odbcfinish);
   AST_RWLIST_WRLOCK(&queries);

   cfg = ast_config_load(config, config_flags);
   if (!cfg) {
      ast_log(LOG_NOTICE, "Unable to load config for func_odbc: %s\n", config);
      AST_RWLIST_UNLOCK(&queries);
      return AST_MODULE_LOAD_DECLINE;
   }

   for (catg = ast_category_browse(cfg, NULL);
        catg;
        catg = ast_category_browse(cfg, catg)) {
      struct acf_odbc_query *query = NULL;
      int err;

      if ((err = init_acf_query(cfg, catg, &query))) {
         if (err == ENOMEM)
            ast_log(LOG_ERROR, "Out of memory\n");
         else if (err == EINVAL)
            ast_log(LOG_ERROR, "Invalid parameters for category %s\n", catg);
         else
            ast_log(LOG_ERROR, "%s (%d)\n", strerror(err), err);
      } else {
         AST_RWLIST_INSERT_HEAD(&queries, query, list);
         ast_custom_function_register(query->acf);
      }
   }

   ast_config_destroy(cfg);
   res |= ast_custom_function_register(&escape_function);

   AST_RWLIST_UNLOCK(&queries);
   return res;
}

static void odbc_datastore_free

(

void *

data

)

[static]

Definition at line 91 of file func_odbc.c.

References ast_free, AST_LIST_HEAD_DESTROY, AST_LIST_LOCK, AST_LIST_REMOVE_HEAD, AST_LIST_UNLOCK, and acf_odbc_query::list.

Referenced by acf_odbc_read().

{
   struct odbc_datastore *result = data;
   struct odbc_datastore_row *row;
   AST_LIST_LOCK(result);
   while ((row = AST_LIST_REMOVE_HEAD(result, list))) {
      ast_free(row);
   }
   AST_LIST_UNLOCK(result);
   AST_LIST_HEAD_DESTROY(result);
   ast_free(result);
}

static int reload

(

void

)

[static]

Definition at line 905 of file func_odbc.c.

References acf_odbc_query::acf, ast_category_browse(), ast_config_destroy(), ast_config_load, ast_custom_function_register, ast_custom_function_unregister(), ast_log(), AST_RWLIST_EMPTY, AST_RWLIST_INSERT_HEAD, AST_RWLIST_REMOVE_HEAD, AST_RWLIST_UNLOCK, AST_RWLIST_WRLOCK, CONFIG_FLAG_FILEUNCHANGED, CONFIG_STATUS_FILEUNCHANGED, free_acf_query(), init_acf_query(), acf_odbc_query::list, LOG_ERROR, and LOG_WARNING.

{
   int res = 0;
   struct ast_config *cfg;
   struct acf_odbc_query *oldquery;
   char *catg;
   struct ast_flags config_flags = { CONFIG_FLAG_FILEUNCHANGED };

   cfg = ast_config_load(config, config_flags);
   if (cfg == CONFIG_STATUS_FILEUNCHANGED)
      return 0;

   AST_RWLIST_WRLOCK(&queries);

   while (!AST_RWLIST_EMPTY(&queries)) {
      oldquery = AST_RWLIST_REMOVE_HEAD(&queries, list);
      ast_custom_function_unregister(oldquery->acf);
      free_acf_query(oldquery);
   }

   if (!cfg) {
      ast_log(LOG_WARNING, "Unable to load config for func_odbc: %s\n", config);
      goto reload_out;
   }

   for (catg = ast_category_browse(cfg, NULL);
        catg;
        catg = ast_category_browse(cfg, catg)) {
      struct acf_odbc_query *query = NULL;

      if (init_acf_query(cfg, catg, &query)) {
         ast_log(LOG_ERROR, "Cannot initialize query %s\n", catg);
      } else {
         AST_RWLIST_INSERT_HEAD(&queries, query, list);
         ast_custom_function_register(query->acf);
      }
   }

   ast_config_destroy(cfg);
reload_out:
   AST_RWLIST_UNLOCK(&queries);
   return res;
}

static int unload_module

(

void

)

[static]

Definition at line 880 of file func_odbc.c.

References acf_odbc_query::acf, app_odbcfinish, ast_custom_function_unregister(), AST_RWLIST_EMPTY, AST_RWLIST_REMOVE_HEAD, AST_RWLIST_UNLOCK, AST_RWLIST_WRLOCK, ast_unregister_application(), escape_function, fetch_function, free_acf_query(), and acf_odbc_query::list.

{
   struct acf_odbc_query *query;
   int res = 0;

   AST_RWLIST_WRLOCK(&queries);
   while (!AST_RWLIST_EMPTY(&queries)) {
      query = AST_RWLIST_REMOVE_HEAD(&queries, list);
      ast_custom_function_unregister(query->acf);
      free_acf_query(query);
   }

   res |= ast_custom_function_unregister(&escape_function);
   res |= ast_custom_function_unregister(&fetch_function);
   res |= ast_unregister_application(app_odbcfinish);

   /* Allow any threads waiting for this lock to pass (avoids a race) */
   AST_RWLIST_UNLOCK(&queries);
   usleep(1);
   AST_RWLIST_WRLOCK(&queries);

   AST_RWLIST_UNLOCK(&queries);
   return 0;
}

---

Variable Documentation

struct ast_module_info __mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_DEFAULT , .description = "ODBC lookups" , .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 = "a9c98e5d177805051735cb5b0b16b0a0" , .load = load_module, .unload = unload_module, .reload = reload, } [static]

Definition at line 955 of file func_odbc.c.

char* app_odbcfinish = "ODBCFinish" [static]

Definition at line 614 of file func_odbc.c.

Referenced by load_module(), and unload_module().

struct ast_module_info* ast_module_info = &__mod_info [static]

Definition at line 955 of file func_odbc.c.

struct ast_threadstorage coldata_buf = { .once = { PTHREAD_ONCE_INIT } , .key_init = __init_coldata_buf , .custom_init = NULL , } [static]

Definition at line 88 of file func_odbc.c.

Referenced by acf_odbc_read().

struct ast_threadstorage colnames_buf = { .once = { PTHREAD_ONCE_INIT } , .key_init = __init_colnames_buf , .custom_init = NULL , } [static]

Definition at line 89 of file func_odbc.c.

Referenced by acf_odbc_read().

char* config = "func_odbc.conf" [static]

Definition at line 47 of file func_odbc.c.

char* desc_odbcfinish [static]

Initial value:

"ODBCFinish(<result-id>)\n"
"  Clears any remaining rows of the specified resultset\n"

Definition at line 616 of file func_odbc.c.

Referenced by load_module().

struct ast_custom_function escape_function [static]

Definition at line 565 of file func_odbc.c.

Referenced by load_module(), and unload_module().

struct ast_custom_function fetch_function [static]

Definition at line 602 of file func_odbc.c.

Referenced by load_module(), and unload_module().

struct ast_datastore_info odbc_info

Initial value:

 {
   .type = "FUNC_ODBC",
   .destroy = odbc_datastore_free,
}

Definition at line 67 of file func_odbc.c.

Referenced by acf_fetch(), acf_odbc_read(), and exec_odbcfinish().

enum { ... } odbc_option_flags

int resultcount = 0 [static]

Definition at line 86 of file func_odbc.c.

Referenced by acf_odbc_read().

char* syn_odbcfinish = "Clear the resultset of a successful multirow query" [static]

Definition at line 615 of file func_odbc.c.

Referenced by load_module().