change odbc handling in code to be runtime instead of build time

git-svn-id: http://svn.freeswitch.org/svn/freeswitch/trunk@13936 d0543943-73ff-0310-b7d9-9358b9ac24b2

diff --git a/Makefile.am b/Makefile.am
index 66367ea6eae2087f9c7cea0f4f0aa2ae6f19d333..a0b44237690a1dae82b54ec7aa5c0ed7418c7833 100644 (file)
--- a/Makefile.am
+++ b/Makefile.am
@@ -97,6 +97,7 @@ src/switch_xml.c\
 src/switch_xml_config.c\
 src/switch_config.c\
 src/switch_time.c\
+src/switch_odbc.c \
 libs/stfu/stfu.c\
 src/switch_cpp.cpp\
 src/g711.c\
@@ -204,7 +205,6 @@ endif
 
 if ADD_ODBC
 CORE_CFLAGS    += -DSWITCH_HAVE_ODBC $(ODBC_INC_FLAGS)
-libfreeswitch_la_SOURCES += src/switch_odbc.c
 libfreeswitch_la_LDFLAGS     += $(ODBC_LIB_FLAGS)
 endif
 

diff --git a/src/include/switch.h b/src/include/switch.h
index 32f3d61c0fbed42a6426d7d1f84716c89f633005..9e608bdae7e7b6f1f7fc416c53dae9f864cad254 100644 (file)
--- a/src/include/switch.h
+++ b/src/include/switch.h
@@ -130,6 +130,8 @@
 #include "switch_scheduler.h"
 #include "switch_config.h"
 #include "switch_nat.h"
+#include "switch_odbc.h"
+
 #include <libteletone.h>
 
 /** \mainpage FreeSWITCH

diff --git a/src/include/switch_odbc.h b/src/include/switch_odbc.h
index 9c518153b1e8d3382ee603a844ea1cd776277c56..071f053fb206b2abeaf699e07e0f11934675e35d 100644 (file)
--- a/src/include/switch_odbc.h
+++ b/src/include/switch_odbc.h
@@ -33,18 +33,11 @@
 #define SWITCH_ODBC_H
 
 #include <switch.h>
-#include <sql.h>
-#ifdef _MSC_VER
-#pragma warning(push)
-#pragma warning(disable:4201)
-#include <sqlext.h>
-#pragma warning(pop)
-#else
-#include <sqlext.h>
-#endif
-#include <sqltypes.h>
 
-SWITCH_BEGIN_EXTERN_C struct switch_odbc_handle;
+SWITCH_BEGIN_EXTERN_C 
+
+struct switch_odbc_handle;
+typedef void * switch_odbc_statement_handle_t;
 
 typedef enum {
        SWITCH_ODBC_STATE_INIT,
@@ -63,7 +56,13 @@ SWITCH_DECLARE(switch_odbc_status_t) switch_odbc_handle_disconnect(switch_odbc_h
 SWITCH_DECLARE(switch_odbc_status_t) switch_odbc_handle_connect(switch_odbc_handle_t *handle);
 SWITCH_DECLARE(void) switch_odbc_handle_destroy(switch_odbc_handle_t **handlep);
 SWITCH_DECLARE(switch_odbc_state_t) switch_odbc_handle_get_state(switch_odbc_handle_t *handle);
-SWITCH_DECLARE(switch_odbc_status_t) switch_odbc_handle_exec(switch_odbc_handle_t *handle, char *sql, SQLHSTMT * rstmt);
+SWITCH_DECLARE(switch_odbc_status_t) switch_odbc_handle_exec(switch_odbc_handle_t *handle, char *sql, switch_odbc_statement_handle_t * rstmt);
+SWITCH_DECLARE(switch_odbc_status_t) switch_odbc_handle_exec_string(switch_odbc_handle_t *handle,
+                                                                                                                                       char *sql,
+                                                                                                                                       char *resbuf,
+                                                                                                                                       size_t len);
+SWITCH_DECLARE(switch_bool_t) switch_odbc_available(void);
+SWITCH_DECLARE(switch_odbc_status_t) switch_odbc_statement_handle_free(switch_odbc_statement_handle_t * stmt);
 
 /*!
   \brief Execute the sql query and issue a callback for each row returned
@@ -93,7 +92,7 @@ SWITCH_DECLARE(switch_odbc_status_t) switch_odbc_handle_callback_exec_detailed(c
                                                                                                  handle, sql, callback, pdata)
 
                                                                                                                                          
-SWITCH_DECLARE(char *) switch_odbc_handle_get_error(switch_odbc_handle_t *handle, SQLHSTMT stmt);
+SWITCH_DECLARE(char *) switch_odbc_handle_get_error(switch_odbc_handle_t *handle, switch_odbc_statement_handle_t stmt);
 SWITCH_END_EXTERN_C
 #endif
 /* For Emacs:

diff --git a/src/include/switch_types.h b/src/include/switch_types.h
index ecda252f90d0d14d55962e8902c2c3b0a954df89..e1bc9b1d7884e3bd8d3c1ea410714fb058a4d332 100644 (file)
--- a/src/include/switch_types.h
+++ b/src/include/switch_types.h
@@ -1490,7 +1490,7 @@ struct switch_network_list;
 typedef struct switch_network_list switch_network_list_t;
 
 
-#define SWITCH_API_VERSION 3
+#define SWITCH_API_VERSION 4
 #define SWITCH_MODULE_LOAD_ARGS (switch_loadable_module_interface_t **module_interface, switch_memory_pool_t *pool)
 #define SWITCH_MODULE_RUNTIME_ARGS (void)
 #define SWITCH_MODULE_SHUTDOWN_ARGS (void)

diff --git a/src/mod/applications/mod_cidlookup/Makefile b/src/mod/applications/mod_cidlookup/Makefile
index 0b32bd2570fd6519b4df509b30105184f05f2678..5ffe1d8476756d5bc197f1e6ef02e1fb68801aac 100644 (file)
--- a/src/mod/applications/mod_cidlookup/Makefile
+++ b/src/mod/applications/mod_cidlookup/Makefile
@@ -1,5 +1,4 @@
 WANT_CURL=yes
-
 BASE=../../../..
 include $(BASE)/build/modmake.rules
-LOCAL_CFLAGS += `if test -f $(BASE)/.libs/libfreeswitch_la-switch_odbc.o ; then echo -DSWITCH_HAVE_ODBC; fi ;`
+

diff --git a/src/mod/applications/mod_cidlookup/mod_cidlookup.c b/src/mod/applications/mod_cidlookup/mod_cidlookup.c
index d1ded040eaf042dadf1b60210a695286f80fc57d..3debdd606bfd71fe5135fce9c27f7022e562e3e5 100755 (executable)
--- a/src/mod/applications/mod_cidlookup/mod_cidlookup.c
+++ b/src/mod/applications/mod_cidlookup/mod_cidlookup.c
@@ -30,9 +30,6 @@
  */
  
 #include <switch.h>
-#ifdef SWITCH_HAVE_ODBC
-#include <switch_odbc.h>
-#endif
 #include <curl/curl.h>
 
 /* Prototypes */
@@ -56,33 +53,11 @@ static struct {
        char *odbc_dsn;
        char *sql;
 
-#ifdef SWITCH_HAVE_ODBC
        switch_mutex_t *db_mutex;
-#else
-       void *filler1;
-#endif
        switch_memory_pool_t *pool;
-#ifdef SWITCH_HAVE_ODBC
        switch_odbc_handle_t *master_odbc;
-#else
-       void *filler2;
-#endif
 } globals;
 
-#ifdef SWITCH_HAVE_ODBC
-struct odbc_obj {
-       switch_odbc_handle_t *handle;
-       SQLHSTMT stmt;
-       SQLCHAR *colbuf;
-       int32_t cblen;
-       SQLCHAR *code;
-       int32_t codelen;
-};
-
-typedef struct odbc_obj  odbc_obj_t;
-typedef odbc_obj_t *odbc_handle;
-#endif
-
 struct http_data {
        switch_stream_handle_t stream;
        switch_size_t bytes;
@@ -103,13 +78,17 @@ static switch_event_node_t *reload_xml_event = NULL;
 static switch_status_t config_callback_dsn(switch_xml_config_item_t *data, const char *newvalue, switch_config_callback_type_t callback_type, switch_bool_t changed)
 {
        switch_status_t status = SWITCH_STATUS_SUCCESS;
-#ifdef SWITCH_HAVE_ODBC
        char *odbc_user = NULL;
        char *odbc_pass = NULL;
        char *odbc_dsn = NULL;
        
        switch_odbc_handle_t *odbc = NULL;
 
+       if (!switch_odbc_available()) {
+               switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "ODBC is not compiled in.  Do not configure odbc-dsn parameter!\n");
+               return SWITCH_STATUS_FALSE;
+       }
+
        if (globals.db_mutex) {
                switch_mutex_lock(globals.db_mutex);
        }
@@ -152,18 +131,12 @@ static switch_status_t config_callback_dsn(switch_xml_config_item_t *data, const
        }
 
        switch_goto_status(SWITCH_STATUS_SUCCESS, done);
-#else
-       switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "ODBC is not compiled in.  Do not configure odbc-dsn parameter!\n");
-       switch_goto_status(SWITCH_STATUS_FALSE, done);
-#endif 
        
 done:
-#ifdef SWITCH_HAVE_ODBC
        if (globals.db_mutex) {
                switch_mutex_unlock(globals.db_mutex);
        }
        switch_safe_free(odbc_dsn);
-#endif
        return status;
 }
 
@@ -193,7 +166,6 @@ static void event_handler(switch_event_t *event)
        do_config(SWITCH_TRUE);
 }
 
-#ifdef SWITCH_HAVE_ODBC
 static switch_bool_t cidlookup_execute_sql_callback(char *sql, switch_core_db_callback_func_t callback, void *pdata)
 {
        switch_bool_t retval = SWITCH_FALSE;
@@ -227,7 +199,6 @@ static int cidlookup_callback(void *pArg, int argc, char **argv, char **columnNa
        
        return SWITCH_STATUS_SUCCESS;
 }
-#endif
 
 /* make a new string with digits only */
 static char *string_digitsonly(switch_memory_pool_t *pool, const char *str) 
@@ -365,7 +336,6 @@ static char *do_lookup_url(switch_memory_pool_t *pool, switch_event_t *event, co
        return name;
 }
 
-#ifdef SWITCH_HAVE_ODBC
 static char *do_db_lookup(switch_memory_pool_t *pool, switch_event_t *event, const char *num) {
        char *name = NULL;
        char *newsql = NULL;
@@ -386,7 +356,6 @@ static char *do_db_lookup(switch_memory_pool_t *pool, switch_event_t *event, con
        }
        return name;
 }
-#endif
 
 static char *do_lookup(switch_memory_pool_t *pool, switch_event_t *event, const char *num, switch_bool_t skipurl) {
        char *number = NULL;
@@ -395,12 +364,11 @@ static char *do_lookup(switch_memory_pool_t *pool, switch_event_t *event, const
        number = string_digitsonly(pool, num);
        switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "caller_id_number", number);
 
-#ifdef SWITCH_HAVE_ODBC
        /* database always wins */
-       if (globals.master_odbc && globals.sql) {
+       if (switch_odbc_available() && globals.master_odbc && globals.sql) {
                name = do_db_lookup(pool, event, number);
        }
-#endif
+
        if (!name && globals.url) {
                if (globals.cache) {
                        name = check_cache(pool, number);
@@ -510,11 +478,7 @@ SWITCH_STANDARD_API(cidlookup_function)
                        stream->write_function(stream, " odbc-dsn: %s\n sql: %s\n", 
                                                                        globals.odbc_dsn,
                                                                        globals.sql);
-#ifdef SWITCH_HAVE_ODBC
-                       stream->write_function(stream, " ODBC Compiled: true\n");
-#else
-                       stream->write_function(stream, " ODBC Compiled: false\n");
-#endif
+                       stream->write_function(stream, " ODBC Compiled: %s\n", switch_odbc_available() ? "true" : "false");
 
                        switch_goto_status(SWITCH_STATUS_SUCCESS, done);
                }
@@ -556,13 +520,11 @@ SWITCH_MODULE_LOAD_FUNCTION(mod_cidlookup_load)
        
        globals.pool = pool;
 
-#ifdef SWITCH_HAVE_ODBC
-       if (!globals.db_mutex) {
+       if (switch_odbc_available() && !globals.db_mutex) {
                if (switch_mutex_init(&globals.db_mutex, SWITCH_MUTEX_UNNESTED, globals.pool) != SWITCH_STATUS_SUCCESS) {
                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "failed to initialize db_mutex\n");
                }
        }
-#endif
 
        do_config(SWITCH_FALSE);
        
@@ -585,7 +547,7 @@ SWITCH_MODULE_LOAD_FUNCTION(mod_cidlookup_load)
 SWITCH_MODULE_SHUTDOWN_FUNCTION(mod_cidlookup_shutdown)
 {
        /* Cleanup dynamically allocated config settings */
-#ifdef SWITCH_HAVE_ODBC
+
        if (globals.db_mutex) {
                switch_mutex_destroy(globals.db_mutex);
        }
@@ -593,7 +555,7 @@ SWITCH_MODULE_SHUTDOWN_FUNCTION(mod_cidlookup_shutdown)
                switch_odbc_handle_disconnect(globals.master_odbc);
                switch_odbc_handle_destroy(&globals.master_odbc);
        }
-#endif
+
        switch_event_unbind(&reload_xml_event);
        return SWITCH_STATUS_SUCCESS;
 }

diff --git a/src/mod/applications/mod_easyroute/Makefile b/src/mod/applications/mod_easyroute/Makefile
deleted file mode 100644 (file)
index 215d377..0000000
--- a/src/mod/applications/mod_easyroute/Makefile
+++ /dev/null
@@ -1,3 +0,0 @@
-BASE=../../../..
-include $(BASE)/build/modmake.rules
-LOCAL_CFLAGS += `if test -f $(BASE)/.libs/libfreeswitch_la-switch_odbc.o ; then echo -DSWITCH_HAVE_ODBC; fi ;`

diff --git a/src/mod/applications/mod_easyroute/mod_easyroute.c b/src/mod/applications/mod_easyroute/mod_easyroute.c
index 832d96f4c3734cce59a15bc9e2fbac1932863fe2..48446ff5d2fa043c031fc71a62b8c282a49babd6 100644 (file)
--- a/src/mod/applications/mod_easyroute/mod_easyroute.c
+++ b/src/mod/applications/mod_easyroute/mod_easyroute.c
@@ -38,10 +38,6 @@
 
 #include <switch.h>
 
-#ifdef SWITCH_HAVE_ODBC
-#include <switch_odbc.h>
-#endif
-
 typedef struct easyroute_results{
        char    limit[16];
        char    dialstring[256];
@@ -68,11 +64,7 @@ static struct {
        char *default_gateway;
        switch_mutex_t *mutex;
        char *custom_query;
-#ifdef SWITCH_HAVE_ODBC
        switch_odbc_handle_t *master_odbc;
-#else   
-       void *filler1;
-#endif
 } globals;
 
 SWITCH_MODULE_LOAD_FUNCTION(mod_easyroute_load);
@@ -86,7 +78,6 @@ SWITCH_DECLARE_GLOBAL_STRING_FUNC(set_global_default_techprofile, globals.defaul
 SWITCH_DECLARE_GLOBAL_STRING_FUNC(set_global_default_gateway, globals.default_gateway);
 SWITCH_DECLARE_GLOBAL_STRING_FUNC(set_global_custom_query, globals.custom_query);
 
-#ifdef SWITCH_HAVE_ODBC
 static int route_callback(void *pArg, int argc, char **argv, char **columnNames)
 {
        route_callback_t *cbt = (route_callback_t *) pArg;
@@ -100,7 +91,6 @@ static int route_callback(void *pArg, int argc, char **argv, char **columnNames)
 
        return 0;
 }
-#endif
 
 static switch_status_t load_config(void)
 {
@@ -145,9 +135,7 @@ done:
                set_global_db_dsn("easyroute");
        }
 
-
-#ifdef SWITCH_HAVE_ODBC
-       if (globals.db_dsn) {
+       if (switch_odbc_available() && globals.db_dsn) {
                if (!(globals.master_odbc = switch_odbc_handle_new(globals.db_dsn, globals.db_username, globals.db_password))) {
                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Cannot Open ODBC Database!\n");
                        status = SWITCH_STATUS_FALSE;
@@ -171,15 +159,12 @@ done:
                                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Cannot find  SQL Database! (Where\'s the gateways table\?\?)\n");
                        }
                }
-       } else {
-#endif
+       } else if (globals.db_dsn) {
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Cannot Open ODBC Connection (did you enable it?!)\n");
-#ifdef SWITCH_HAVE_ODBC
        }
 
 reallydone:
 
-#endif
        if (xml) {
                switch_xml_free(xml);
        }
@@ -192,17 +177,20 @@ reallydone:
        return status;
 }
 
-#ifdef SWITCH_HAVE_ODBC
 static char SQL_LOOKUP[] = "SELECT gateways.gateway_ip, gateways.group, gateways.limit, gateways.techprofile, numbers.acctcode, numbers.translated from gateways, numbers where numbers.number = '%q' and numbers.gateway_id = gateways.gateway_id limit 1;";
-#endif
 
 static switch_status_t route_lookup(char *dn, easyroute_results_t *results, int noat, char *seperator)
 {      
        switch_status_t sstatus = SWITCH_STATUS_SUCCESS;
-#ifdef SWITCH_HAVE_ODBC
        char *sql = NULL;
        route_callback_t pdata;
 
+       if (!switch_odbc_available()) {
+               switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, 
+                                                 "mod_easyroute requires core ODBC support. Please refer to the documentation on how to enable this\n");
+               return sstatus;
+       }
+
        memset(&pdata, 0, sizeof(pdata));
        if (!globals.custom_query){
                sql = switch_mprintf(SQL_LOOKUP, dn);
@@ -278,9 +266,6 @@ static switch_status_t route_lookup(char *dn, easyroute_results_t *results, int
        }
 
        switch_safe_free(sql);
-#else
-       switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "mod_easyroute requires core ODBC support. Please refer to the documentation on how to enable this\n");
-#endif
 
        if (globals.mutex){
                switch_mutex_unlock(globals.mutex);
@@ -347,11 +332,11 @@ SWITCH_STANDARD_API(easyroute_function)
                goto done;
        }
 
-#ifndef SWITCH_HAVE_ODBC
-       stream->write_function(stream, "mod_easyroute requires you enable core odbc support\n");
-       status = SWITCH_STATUS_SUCCESS;
-       goto done;
-#endif
+       if (!switch_odbc_available()) {
+               stream->write_function(stream, "mod_easyroute requires you enable core odbc support\n");
+               status = SWITCH_STATUS_SUCCESS;
+               goto done;
+       }
        
        if (!cmd || !(mydata = strdup(cmd))) {
                stream->write_function(stream, "Usage: easyroute <number>\n");
@@ -430,10 +415,7 @@ SWITCH_MODULE_LOAD_FUNCTION(mod_easyroute_load)
 
 SWITCH_MODULE_SHUTDOWN_FUNCTION(mod_easyroute_shutdown)
 {      
-#ifdef SWITCH_HAVE_ODBC
        switch_odbc_handle_disconnect(globals.master_odbc);
-#endif
-       
        switch_safe_free(globals.db_username);
        switch_safe_free(globals.db_password);
        switch_safe_free(globals.db_dsn);

diff --git a/src/mod/applications/mod_fifo/mod_fifo.c b/src/mod/applications/mod_fifo/mod_fifo.c
index 6d7dd9eae98d793895659005e8f79ebd15c45bba..99a415ddc3e1460b7c7b7dce348120889f9f0fde 100644 (file)
--- a/src/mod/applications/mod_fifo/mod_fifo.c
+++ b/src/mod/applications/mod_fifo/mod_fifo.c
@@ -29,9 +29,6 @@
  *
  */
 #include <switch.h>
-#ifdef SWITCH_HAVE_ODBC
-#include <switch_odbc.h>
-#endif
 
 SWITCH_MODULE_SHUTDOWN_FUNCTION(mod_fifo_shutdown);
 SWITCH_MODULE_LOAD_FUNCTION(mod_fifo_load);
@@ -264,12 +261,7 @@ static struct {
        char *dbname;
        char *odbc_dsn;
        int node_thread_running;
-       
-#ifdef SWITCH_HAVE_ODBC
        switch_odbc_handle_t *master_odbc;
-#else
-       void *filler1;
-#endif
 } globals;
 
 
@@ -282,9 +274,9 @@ static switch_status_t fifo_execute_sql(char *sql, switch_mutex_t *mutex)
        if (mutex) {
                switch_mutex_lock(mutex);
        }
-#ifdef SWITCH_HAVE_ODBC
-       if (globals.odbc_dsn) {
-               SQLHSTMT stmt;
+
+       if (switch_odbc_available() && globals.odbc_dsn) {
+               switch_odbc_statement_handle_t stmt;
                if (switch_odbc_handle_exec(globals.master_odbc, sql, &stmt) != SWITCH_ODBC_SUCCESS) {
                        
                        err_str = switch_odbc_handle_get_error(globals.master_odbc, stmt);
@@ -294,9 +286,8 @@ static switch_status_t fifo_execute_sql(char *sql, switch_mutex_t *mutex)
                        switch_safe_free(err_str);
                        status = SWITCH_STATUS_FALSE;
                }
-               SQLFreeHandle(SQL_HANDLE_STMT, stmt);
+               switch_odbc_statement_handle_free(&stmt);
        } else {
-#endif
                if (!(db = switch_core_db_open_file(globals.dbname))) {
                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error Opening DB %s\n", globals.dbname);
                        status = SWITCH_STATUS_FALSE;
@@ -309,12 +300,8 @@ static switch_status_t fifo_execute_sql(char *sql, switch_mutex_t *mutex)
                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error [%s]\n[%s]\n", sql, err_str);
                        free(err_str);
                }
-
                switch_core_db_close(db);
-
-#ifdef SWITCH_HAVE_ODBC
        }
-#endif
 
   end:
        if (mutex) {
@@ -334,11 +321,9 @@ static switch_bool_t fifo_execute_sql_callback(switch_mutex_t *mutex, char *sql,
                switch_mutex_lock(mutex);
        }
 
-#ifdef SWITCH_HAVE_ODBC
-       if (globals.odbc_dsn) {
+       if (switch_odbc_available() && globals.odbc_dsn) {
                switch_odbc_handle_callback_exec(globals.master_odbc, sql, callback, pdata);
        } else {
-#endif
                if (!(db = switch_core_db_open_file(globals.dbname))) {
                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error Opening DB %s\n", globals.dbname);
                        goto end;
@@ -354,9 +339,7 @@ static switch_bool_t fifo_execute_sql_callback(switch_mutex_t *mutex, char *sql,
                if (db) {
                        switch_core_db_close(db);
                }
-#ifdef SWITCH_HAVE_ODBC
        }
-#endif
 
   end:
        if (mutex) {
@@ -1766,17 +1749,17 @@ static switch_status_t load_config(int reload, int del_all)
                        val = (char *) switch_xml_attr_soft(param, "value");
 
                        if (!strcasecmp(var, "odbc-dsn") && !switch_strlen_zero(val)) {
-#ifdef SWITCH_HAVE_ODBC
-                               globals.odbc_dsn = switch_core_strdup(globals.pool, val);
-                               if ((odbc_user = strchr(globals.odbc_dsn, ':'))) {
-                                       *odbc_user++ = '\0';
-                                       if ((odbc_pass = strchr(odbc_user, ':'))) {
-                                               *odbc_pass++ = '\0';
+                               if (switch_odbc_available()) {
+                                       globals.odbc_dsn = switch_core_strdup(globals.pool, val);
+                                       if ((odbc_user = strchr(globals.odbc_dsn, ':'))) {
+                                               *odbc_user++ = '\0';
+                                               if ((odbc_pass = strchr(odbc_user, ':'))) {
+                                                       *odbc_pass++ = '\0';
+                                               }
                                        }
+                               } else {
+                                       switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "ODBC IS NOT AVAILABLE!\n");
                                }
-#else
-                               switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "ODBC IS NOT AVAILABLE!\n");
-#endif
                        }
                }
        }
@@ -1786,8 +1769,7 @@ static switch_status_t load_config(int reload, int del_all)
                globals.dbname = "fifo";
        }
 
-#ifdef SWITCH_HAVE_ODBC
-       if (globals.odbc_dsn) {
+       if (switch_odbc_available() && globals.odbc_dsn) {
                if (!(globals.master_odbc = switch_odbc_handle_new(globals.odbc_dsn, odbc_user, odbc_pass))) {
                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Cannot Open ODBC Database!\n");
                        status = SWITCH_STATUS_FALSE;
@@ -1806,7 +1788,6 @@ static switch_status_t load_config(int reload, int del_all)
                        }
                }
        } else {
-#endif
                if ((db = switch_core_db_open_file(globals.dbname))) {
                        switch_core_db_test_reactive(db, "delete from fifo_outbound", NULL, (char *)outbound_sql);
                } else {
@@ -1815,9 +1796,7 @@ static switch_status_t load_config(int reload, int del_all)
                        goto done;
                }
                switch_core_db_close(db);
-#ifdef SWITCH_HAVE_ODBC
        }
-#endif
 
        if (reload) {
                switch_hash_index_t *hi;

diff --git a/src/mod/applications/mod_lcr/Makefile b/src/mod/applications/mod_lcr/Makefile
deleted file mode 100644 (file)
index 57467f4..0000000
--- a/src/mod/applications/mod_lcr/Makefile
+++ /dev/null
@@ -1,3 +0,0 @@
-BASE=../../../..
-LOCAL_CFLAGS += `if test -f $(BASE)/.libs/libfreeswitch_la-switch_odbc.o ; then echo -DSWITCH_HAVE_ODBC; fi ;`
-include $(BASE)/build/modmake.rules

diff --git a/src/mod/applications/mod_lcr/mod_lcr.c b/src/mod/applications/mod_lcr/mod_lcr.c
index bacb24543f1dc1b4f4aa4641a03b4ea311002534..28599581b6d6da59839fb72dda8b169704246627 100644 (file)
--- a/src/mod/applications/mod_lcr/mod_lcr.c
+++ b/src/mod/applications/mod_lcr/mod_lcr.c
@@ -31,8 +31,6 @@
  */
 
 #include <switch.h>
-#include <switch_odbc.h>
-
 
 #define LCR_SYNTAX "lcr <digits> [<lcr profile>] [caller_id] [intrastate]"
 #define LCR_ADMIN_SYNTAX "lcr_admin show profiles"
@@ -75,15 +73,6 @@ static char headers[LCR_HEADERS_COUNT][32] = {
 /* sql for random function */
 static char *db_random = NULL;
 
-struct odbc_obj {
-       switch_odbc_handle_t *handle;
-       SQLHSTMT stmt;
-       SQLCHAR *colbuf;
-       int32_t cblen;
-       SQLCHAR *code;
-       int32_t codelen;
-};
-
 struct lcr_obj {
        char *carrier_name;
        char *gw_prefix;
@@ -112,9 +101,6 @@ struct max_obj {
        size_t dialstring;
 };
 
-typedef struct odbc_obj  odbc_obj_t;
-typedef odbc_obj_t *odbc_handle;
-
 typedef struct lcr_obj lcr_obj_t;
 typedef lcr_obj_t *lcr_route;
 
@@ -1384,11 +1370,11 @@ SWITCH_MODULE_LOAD_FUNCTION(mod_lcr_load)
        
        *module_interface = switch_loadable_module_create_module_interface(pool, modname);
 
-#ifndef SWITCH_HAVE_ODBC
-       switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "You must have ODBC support in FreeSWITCH to use this module\n");
-       switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "\t./configure --enable-core-odbc-support\n");
-       return SWITCH_STATUS_FALSE;
-#endif
+       if (!switch_odbc_available()) {
+               switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "You must have ODBC support in FreeSWITCH to use this module\n");
+               switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "\t./configure --enable-core-odbc-support\n");
+               return SWITCH_STATUS_FALSE;
+       }
 
        globals.pool = pool;
 
@@ -1417,10 +1403,8 @@ SWITCH_MODULE_LOAD_FUNCTION(mod_lcr_load)
 SWITCH_MODULE_SHUTDOWN_FUNCTION(mod_lcr_shutdown)
 {
 
-#ifdef SWITCH_HAVE_ODBC
        switch_odbc_handle_disconnect(globals.master_odbc);
        switch_odbc_handle_destroy(&globals.master_odbc);
-#endif
        switch_core_hash_destroy(&globals.profile_hash);
 
        return SWITCH_STATUS_SUCCESS;

diff --git a/src/mod/applications/mod_limit/Makefile b/src/mod/applications/mod_limit/Makefile
deleted file mode 100644 (file)
index 215d377..0000000
--- a/src/mod/applications/mod_limit/Makefile
+++ /dev/null
@@ -1,3 +0,0 @@
-BASE=../../../..
-include $(BASE)/build/modmake.rules
-LOCAL_CFLAGS += `if test -f $(BASE)/.libs/libfreeswitch_la-switch_odbc.o ; then echo -DSWITCH_HAVE_ODBC; fi ;`

diff --git a/src/mod/applications/mod_limit/mod_limit.c b/src/mod/applications/mod_limit/mod_limit.c
index bde5a9eacb62411e3e575621efe8b0122751ed22..9432894cbd967f27a935d605281056403eaf6afc 100644 (file)
--- a/src/mod/applications/mod_limit/mod_limit.c
+++ b/src/mod/applications/mod_limit/mod_limit.c
@@ -33,9 +33,6 @@
  */
 
 #include <switch.h>
-#ifdef SWITCH_HAVE_ODBC
-#include <switch_odbc.h>
-#endif
 
 #define LIMIT_EVENT_USAGE "limit::usage"
 
@@ -53,11 +50,7 @@ static struct {
        switch_hash_t *limit_hash;      
        switch_mutex_t *db_hash_mutex;
        switch_hash_t *db_hash; 
-#ifdef SWITCH_HAVE_ODBC
        switch_odbc_handle_t *master_odbc;
-#else
-       void *filler1;
-#endif
 } globals;
 
 typedef struct  {
@@ -102,9 +95,9 @@ static switch_status_t limit_execute_sql(char *sql, switch_mutex_t *mutex)
        if (mutex) {
                switch_mutex_lock(mutex);
        }
-#ifdef SWITCH_HAVE_ODBC
-       if (globals.odbc_dsn) {
-               SQLHSTMT stmt;
+
+       if (switch_odbc_available() && globals.odbc_dsn) {
+               switch_odbc_statement_handle_t stmt;
                if (switch_odbc_handle_exec(globals.master_odbc, sql, &stmt) != SWITCH_ODBC_SUCCESS) {
                        char *err_str;
                        err_str = switch_odbc_handle_get_error(globals.master_odbc, stmt);
@@ -114,21 +107,16 @@ static switch_status_t limit_execute_sql(char *sql, switch_mutex_t *mutex)
                        switch_safe_free(err_str);
                        status = SWITCH_STATUS_FALSE;
                }
-               SQLFreeHandle(SQL_HANDLE_STMT, stmt);
+               switch_odbc_statement_handle_free(&stmt);
        } else {
-#endif
                if (!(db = switch_core_db_open_file(globals.dbname))) {
                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error Opening DB %s\n", globals.dbname);
                        status = SWITCH_STATUS_FALSE;
                        goto end;
                }
-
                status = switch_core_db_persistant_execute(db, sql, 1);
                switch_core_db_close(db);
-
-#ifdef SWITCH_HAVE_ODBC
        }
-#endif
 
   end:
        if (mutex) {
@@ -148,11 +136,9 @@ static switch_bool_t limit_execute_sql_callback(switch_mutex_t *mutex, char *sql
                switch_mutex_lock(mutex);
        }
 
-#ifdef SWITCH_HAVE_ODBC
-       if (globals.odbc_dsn) {
+       if (switch_odbc_available() && globals.odbc_dsn) {
                switch_odbc_handle_callback_exec(globals.master_odbc, sql, callback, pdata);
        } else {
-#endif
                if (!(db = switch_core_db_open_file(globals.dbname))) {
                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error Opening DB %s\n", globals.dbname);
                        goto end;
@@ -168,9 +154,7 @@ static switch_bool_t limit_execute_sql_callback(switch_mutex_t *mutex, char *sql
                if (db) {
                        switch_core_db_close(db);
                }
-#ifdef SWITCH_HAVE_ODBC
        }
-#endif
 
   end:
        if (mutex) {
@@ -202,17 +186,15 @@ static switch_status_t do_config()
                return SWITCH_STATUS_TERM;
        }
        
-       if (globals.odbc_dsn) {
-#ifdef SWITCH_HAVE_ODBC
+       if (switch_odbc_available() && globals.odbc_dsn) {
                if ((odbc_user = strchr(globals.odbc_dsn, ':'))) {
                        *odbc_user++ = '\0';
                        if ((odbc_pass = strchr(odbc_user, ':'))) {
                                *odbc_pass++ = '\0';
                        }
                }
-#else
+       } else if (globals.odbc_dsn) {
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "ODBC IS NOT AVAILABLE!\n");
-#endif
        }
        
 
@@ -220,8 +202,7 @@ static switch_status_t do_config()
                globals.dbname = "call_limit";
        }
 
-#ifdef SWITCH_HAVE_ODBC
-       if (globals.odbc_dsn) {
+       if (switch_odbc_available() && globals.odbc_dsn) {
                int x;
                char *indexes[] = {
                        "create index ld_hostname on limit_data (hostname)",
@@ -269,7 +250,6 @@ static switch_status_t do_config()
                        switch_odbc_handle_exec(globals.master_odbc, indexes[x], NULL);
                }
        } else {
-#endif
                if ((db = switch_core_db_open_file(globals.dbname))) {
                        switch_core_db_test_reactive(db, "select * from limit_data", NULL, limit_sql);
                        switch_core_db_test_reactive(db, "select * from db_data", NULL, db_sql);
@@ -292,9 +272,7 @@ static switch_status_t do_config()
                        goto done;
                }
                switch_core_db_close(db);
-#ifdef SWITCH_HAVE_ODBC
        }
-#endif
 
   done:
 
@@ -1129,11 +1107,9 @@ SWITCH_MODULE_LOAD_FUNCTION(mod_limit_load)
 SWITCH_MODULE_SHUTDOWN_FUNCTION(mod_limit_shutdown) 
 {
        
-       #ifdef SWITCH_HAVE_ODBC
        if (globals.master_odbc) {
                switch_odbc_handle_destroy(&globals.master_odbc);
        }
-       #endif
        
        switch_event_free_subclass(LIMIT_EVENT_USAGE);
        

diff --git a/src/mod/applications/mod_nibblebill/Makefile b/src/mod/applications/mod_nibblebill/Makefile
deleted file mode 100644 (file)
index 215d377..0000000
--- a/src/mod/applications/mod_nibblebill/Makefile
+++ /dev/null
@@ -1,3 +0,0 @@
-BASE=../../../..
-include $(BASE)/build/modmake.rules
-LOCAL_CFLAGS += `if test -f $(BASE)/.libs/libfreeswitch_la-switch_odbc.o ; then echo -DSWITCH_HAVE_ODBC; fi ;`

diff --git a/src/mod/applications/mod_nibblebill/mod_nibblebill.c b/src/mod/applications/mod_nibblebill/mod_nibblebill.c
index 9946d127b80d280ab098fa3a7145a0738a924515..e0150a45ad91dfccad2828ab1ac9e167d06cf2ac 100644 (file)
--- a/src/mod/applications/mod_nibblebill/mod_nibblebill.c
+++ b/src/mod/applications/mod_nibblebill/mod_nibblebill.c
@@ -49,15 +49,9 @@
 
 #include <switch.h>
 
-#ifdef SWITCH_HAVE_ODBC
-#include <switch_odbc.h>
-#endif
-
 /* Defaults */
-#ifdef SWITCH_HAVE_ODBC
 static char SQL_LOOKUP[] = "SELECT %s FROM %s WHERE %s='%s'";
 static char SQL_SAVE[] = "UPDATE %s SET %s=%s-%f WHERE %s='%s'";
-#endif
 
 typedef struct
 {
@@ -109,11 +103,7 @@ static struct
        char *db_table;
        char *db_column_cash;
        char *db_column_account;
-#ifdef SWITCH_HAVE_ODBC
        switch_odbc_handle_t *master_odbc;
-#else   
-       void *padding1;  /* Keep structures same size */
-#endif
 } globals;
 
 static void nibblebill_pause(switch_core_session_t *session);
@@ -141,7 +131,6 @@ SWITCH_DECLARE_GLOBAL_STRING_FUNC(set_global_percall_action, globals.percall_act
 SWITCH_DECLARE_GLOBAL_STRING_FUNC(set_global_lowbal_action, globals.lowbal_action);
 SWITCH_DECLARE_GLOBAL_STRING_FUNC(set_global_nobal_action, globals.nobal_action);
 
-#ifdef SWITCH_HAVE_ODBC
 static int nibblebill_callback(void *pArg, int argc, char **argv, char **columnNames)
 {
        nibblebill_results_t *cbt = (nibblebill_results_t *) pArg;
@@ -150,7 +139,6 @@ static int nibblebill_callback(void *pArg, int argc, char **argv, char **columnN
 
        return 0;
 }
-#endif
 
 static switch_status_t load_config(void)
 {
@@ -220,8 +208,7 @@ setdefaults:
                set_global_nobal_action("hangup");
        }
 
-#ifdef SWITCH_HAVE_ODBC
-       if (globals.db_dsn) {
+       if (switch_odbc_available() && globals.db_dsn) {
                if (!(globals.master_odbc = switch_odbc_handle_new(globals.db_dsn, globals.db_username, globals.db_password))) {
                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Cannot create handle to ODBC Database!\n");
                        status = SWITCH_STATUS_FALSE;
@@ -231,7 +218,9 @@ setdefaults:
                }
 
                if (switch_odbc_handle_connect(globals.master_odbc) != SWITCH_ODBC_SUCCESS) {
-                       switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Cannot connect to ODBC driver/database %s (user: %s / pass %s)!\n", globals.db_dsn, globals.db_username, globals.db_password);
+                       switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, 
+                                                         "Cannot connect to ODBC driver/database %s (user: %s / pass %s)!\n",
+                                                         globals.db_dsn, globals.db_username, globals.db_password);
                        status = SWITCH_STATUS_FALSE;
                        goto done;
                } else {
@@ -239,16 +228,11 @@ setdefaults:
                }
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "Connected ODBC DSN: %s\n", globals.db_dsn);
        } else {
-#endif
-               switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "ODBC does not appear to be installed in the core. You need to run ./configure --enable-core-odbc-support\n");
-#ifdef SWITCH_HAVE_ODBC
+               switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT,
+                                                 "ODBC does not appear to be installed in the core. You need to run ./configure --enable-core-odbc-support\n");
        }
-#endif
 
-#ifdef SWITCH_HAVE_ODBC
 done:
-#endif
-
        if (xml) {
                switch_xml_free(xml);
        }
@@ -314,9 +298,12 @@ static void transfer_call(switch_core_session_t *session, char *destination)
 /* At this time, billing never succeeds if you don't have a database. */
 static switch_status_t bill_event(float billamount, const char *billaccount)
 {
-#ifdef SWITCH_HAVE_ODBC
        char sql[1024] = "";
-       SQLHSTMT stmt;
+       switch_odbc_statement_handle_t stmt;
+
+       if (!switch_odbc_available()) {
+               return SWITCH_STATUS_SUCCESS;
+       }
 
        switch_snprintf(sql, 1024, SQL_SAVE, globals.db_table, globals.db_column_cash, globals.db_column_cash, billamount, globals.db_column_account, billaccount);
        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG,  "Doing update query\n[%s]\n", sql);
@@ -327,36 +314,35 @@ static switch_status_t bill_event(float billamount, const char *billaccount)
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "ERR: [%s]\n[%s]\n", sql, switch_str_nil(err_str));
                switch_safe_free(err_str);
        } else {
-#endif
                /* TODO: Failover to a flat/text file if DB is unavailable */
 
                return SWITCH_STATUS_SUCCESS;
-#ifdef SWITCH_HAVE_ODBC
        }
 
-       SQLFreeHandle(SQL_HANDLE_STMT, stmt);
-#endif
+       switch_odbc_statement_handle_free(&stmt);
+
        return SWITCH_STATUS_SUCCESS;
 }
 
 
 static float get_balance(const char *billaccount)
 {
-#ifdef SWITCH_HAVE_ODBC
        char sql[1024] = "";
        nibblebill_results_t pdata;
        float balance = 0.00f;
 
+       if (!switch_odbc_available()) {
+               return -1.00f;
+       }
+
        memset(&pdata, 0, sizeof(pdata));
        snprintf(sql, 1024, SQL_LOOKUP, globals.db_column_cash, globals.db_table, globals.db_column_account, billaccount);
 
        if (switch_odbc_handle_callback_exec(globals.master_odbc, sql, nibblebill_callback, &pdata) != SWITCH_ODBC_SUCCESS) {
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error running this query: [%s]\n", sql);
-#endif
                /* Return -1 for safety */
 
-               return -1.00;
-#ifdef SWITCH_HAVE_ODBC
+               return -1.00f;
        } else {
                /* Successfully retrieved! */
                balance = pdata.balance;
@@ -365,7 +351,6 @@ static float get_balance(const char *billaccount)
        }
        
        return balance;
-#endif
 }
 
 /* This is where we actually charge the guy 
@@ -879,10 +864,7 @@ SWITCH_MODULE_SHUTDOWN_FUNCTION(mod_nibblebill_shutdown)
 {      
        switch_event_unbind(&globals.node);
        switch_core_remove_state_handler(&nibble_state_handler);
-
-#ifdef SWITCH_HAVE_ODBC
        switch_odbc_handle_disconnect(globals.master_odbc);
-#endif
 
        return SWITCH_STATUS_UNLOAD;
 }

diff --git a/src/mod/applications/mod_voicemail/Makefile b/src/mod/applications/mod_voicemail/Makefile
deleted file mode 100644 (file)
index 215d377..0000000
--- a/src/mod/applications/mod_voicemail/Makefile
+++ /dev/null
@@ -1,3 +0,0 @@
-BASE=../../../..
-include $(BASE)/build/modmake.rules
-LOCAL_CFLAGS += `if test -f $(BASE)/.libs/libfreeswitch_la-switch_odbc.o ; then echo -DSWITCH_HAVE_ODBC; fi ;`

diff --git a/src/mod/applications/mod_voicemail/mod_voicemail.c b/src/mod/applications/mod_voicemail/mod_voicemail.c
index da974af9057ad10144035ba314a1361b128ea158..1980d4dd1259f95c4f76d998351c6316f6cc1fe6 100644 (file)
--- a/src/mod/applications/mod_voicemail/mod_voicemail.c
+++ b/src/mod/applications/mod_voicemail/mod_voicemail.c
@@ -33,10 +33,6 @@
  */
 #include <switch.h>
 
-#ifdef SWITCH_HAVE_ODBC
-#include <switch_odbc.h>
-#endif
-
 #ifdef _MSC_VER                                        /* compilers are stupid sometimes */
 #define TRY_CODE(code) for(;;) {status = code; if (status != SWITCH_STATUS_SUCCESS && status != SWITCH_STATUS_BREAK) { goto end; } break;}
 #else
@@ -156,9 +152,8 @@ static switch_status_t vm_execute_sql(vm_profile_t *profile, char *sql, switch_m
                switch_mutex_lock(mutex);
        }
 
-       if (profile->odbc_dsn) {
-#ifdef SWITCH_HAVE_ODBC
-               SQLHSTMT stmt;
+       if (switch_odbc_available() && profile->odbc_dsn) {
+               switch_odbc_statement_handle_t stmt;
                if (switch_odbc_handle_exec(profile->master_odbc, sql, &stmt) != SWITCH_ODBC_SUCCESS) {
                        char *err_str;
                        err_str = switch_odbc_handle_get_error(profile->master_odbc, stmt);
@@ -166,8 +161,7 @@ static switch_status_t vm_execute_sql(vm_profile_t *profile, char *sql, switch_m
                        switch_safe_free(err_str);
                        status = SWITCH_STATUS_FALSE;
                }
-               SQLFreeHandle(SQL_HANDLE_STMT, stmt);
-#endif
+               switch_odbc_statement_handle_free(&stmt);
        } else {
                if (!(db = switch_core_db_open_file(profile->dbname))) {
                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error Opening DB %s\n", profile->dbname);
@@ -196,10 +190,8 @@ static switch_bool_t vm_execute_sql_callback(vm_profile_t *profile, switch_mutex
                switch_mutex_lock(mutex);
        }
 
-       if (profile->odbc_dsn) {
-#ifdef SWITCH_HAVE_ODBC
+       if (switch_odbc_available() && profile->odbc_dsn) {
                switch_odbc_handle_callback_exec(profile->master_odbc, sql, callback, pdata);
-#endif
        } else {
                if (!(db = switch_core_db_open_file(profile->dbname))) {
                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error Opening DB %s\n", profile->dbname);
@@ -266,12 +258,10 @@ static char *vm_index_list[] = {
 static void free_profile(vm_profile_t *profile)
 {
        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Destroying Profile %s\n", profile->name);
-#ifdef SWITCH_HAVE_ODBC
-       if (profile->odbc_dsn && profile->master_odbc) {
+       if (switch_odbc_available() && profile->odbc_dsn && profile->master_odbc) {
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Closing ODBC Database! %s\n", profile->name);
                switch_odbc_handle_destroy(&profile->master_odbc);
        }
-#endif
        switch_core_destroy_memory_pool(&profile->pool);
 }
 
@@ -669,8 +659,7 @@ static vm_profile_t * load_profile(const char *profile_name)
                }
 
                profile->dbname = switch_core_sprintf(profile->pool, "voicemail_%s", profile_name);
-               if (profile->odbc_dsn) {
-#ifdef SWITCH_HAVE_ODBC
+               if (switch_odbc_available() && profile->odbc_dsn) {
                        if (!(profile->master_odbc = switch_odbc_handle_new(profile->odbc_dsn, profile->odbc_user, profile->odbc_pass))) {
                                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Cannot Open ODBC Database!\n");
                                goto end;
@@ -713,7 +702,6 @@ static vm_profile_t * load_profile(const char *profile_name)
                        for (x = 0; vm_index_list[x]; x++) {
                                switch_odbc_handle_exec(profile->master_odbc, vm_index_list[x], NULL);
                        }
-#endif
                } else {
                        if ((db = switch_core_db_open_file(profile->dbname))) {
                                char *errmsg;
@@ -4006,12 +3994,11 @@ SWITCH_MODULE_SHUTDOWN_FUNCTION(mod_voicemail_shutdown)
                switch_thread_rwlock_wrlock(profile->rwlock);
                
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Destroying Profile %s\n", profile->name);
-#ifdef SWITCH_HAVE_ODBC
-               if (profile->odbc_dsn && profile->master_odbc) {
+
+               if (switch_odbc_available() && profile->odbc_dsn && profile->master_odbc) {
                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Closing ODBC Database! %s\n", profile->name);
                        switch_odbc_handle_destroy(&profile->master_odbc);
                }
-#endif
                switch_core_destroy_memory_pool(&profile->pool);
                profile = NULL;
        }

diff --git a/src/mod/endpoints/mod_dingaling/Makefile b/src/mod/endpoints/mod_dingaling/Makefile
index 784eafb374c78e3176897d6f2bc583790551000f..d23c3b200c12090748054652ff134f90cba9c903 100644 (file)
--- a/src/mod/endpoints/mod_dingaling/Makefile
+++ b/src/mod/endpoints/mod_dingaling/Makefile
@@ -2,7 +2,6 @@ BASE=../../../..
 
 LOCAL_CFLAGS     = `$(BASE)/libs/apr/apr-1-config --cflags --cppflags --includes`
 LOCAL_CFLAGS    += `$(BASE)/libs/apr-util/apu-1-config --includes`
-LOCAL_CFLAGS += `if test -f $(BASE)/.libs/libfreeswitch_la-switch_odbc.o ; then echo -DSWITCH_HAVE_ODBC; fi ;`
 #LOCAL_CFLAGS += -w
 
 IKS_DIR=$(BASE)/libs/iksemel

diff --git a/src/mod/endpoints/mod_dingaling/mod_dingaling.c b/src/mod/endpoints/mod_dingaling/mod_dingaling.c
index 930d0d95933b5422faf9366d892d1645bd3a30a8..3c29170e24f05d06b572577d8101e43c11d1e019 100644 (file)
--- a/src/mod/endpoints/mod_dingaling/mod_dingaling.c
+++ b/src/mod/endpoints/mod_dingaling/mod_dingaling.c
@@ -32,9 +32,6 @@
 #include <switch.h>
 #include <switch_stun.h>
 #include <libdingaling.h>
-#ifdef SWITCH_HAVE_ODBC
-#include <switch_odbc.h>
-#endif
 
 #define DL_CAND_WAIT 10000000
 #define DL_CAND_INITIAL_WAIT 2000000
@@ -128,17 +125,10 @@ struct mdl_profile {
        char *timer_name;
        char *dbname;
        char *avatar;
-#ifdef SWITCH_HAVE_ODBC
        char *odbc_dsn;
        char *odbc_user;
        char *odbc_pass;
        switch_odbc_handle_t *master_odbc;
-#else
-       void *filler1;
-       void *filler2;
-       void *filler3;
-       void *filler4;
-#endif
        switch_mutex_t *mutex;
        ldl_handle_t *handle;
        uint32_t flags;
@@ -273,30 +263,24 @@ static void mdl_execute_sql(mdl_profile_t *profile, char *sql, switch_mutex_t *m
        if (mutex) {
                switch_mutex_lock(mutex);
        }
-#ifdef SWITCH_HAVE_ODBC
-       if (profile->odbc_dsn) {
-               SQLHSTMT stmt;
+
+       if (switch_odbc_available() && profile->odbc_dsn) {
+               switch_odbc_statement_handle_t stmt;
                if (switch_odbc_handle_exec(profile->master_odbc, sql, &stmt) != SWITCH_ODBC_SUCCESS) {
                        char *err_str;
                        err_str = switch_odbc_handle_get_error(profile->master_odbc, stmt);
                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "ERR: [%s]\n[%s]\n", sql, switch_str_nil(err_str));
                        switch_safe_free(err_str);
                }
-               SQLFreeHandle(SQL_HANDLE_STMT, stmt);
+               switch_odbc_statement_handle_free(&stmt);
        } else {
-#endif
                if (!(db = switch_core_db_open_file(profile->dbname))) {
                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error Opening DB %s\n", profile->dbname);
                        goto end;
                }
-
                switch_core_db_persistant_execute(db, sql, 1);
                switch_core_db_close(db);
-
-#ifdef SWITCH_HAVE_ODBC
        }
-#endif
-
 
   end:
        if (mutex) {
@@ -316,20 +300,13 @@ static switch_bool_t mdl_execute_sql_callback(mdl_profile_t *profile,
                switch_mutex_lock(mutex);
        }
 
-#ifdef SWITCH_HAVE_ODBC
-       if (profile->odbc_dsn) {
+       if (switch_odbc_available() && profile->odbc_dsn) {
                switch_odbc_handle_callback_exec(profile->master_odbc, sql, callback, pdata);
        } else {
-#endif
-
-
-
                if (!(db = switch_core_db_open_file(profile->dbname))) {
                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error Opening DB %s\n", profile->dbname);
                        goto end;
                }
-
-
                switch_core_db_exec(db, sql, callback, pdata, &errmsg);
 
                if (errmsg) {
@@ -340,10 +317,7 @@ static switch_bool_t mdl_execute_sql_callback(mdl_profile_t *profile,
                if (db) {
                        switch_core_db_close(db);
                }
-#ifdef SWITCH_HAVE_ODBC
        }
-#endif
-
 
   end:
 
@@ -351,10 +325,7 @@ static switch_bool_t mdl_execute_sql_callback(mdl_profile_t *profile,
                switch_mutex_unlock(mutex);
        }
 
-
-
        return ret;
-
 }
 
 static int sub_callback(void *pArg, int argc, char **argv, char **columnNames)
@@ -1949,18 +1920,17 @@ static void set_profile_val(mdl_profile_t *profile, char *var, char *val)
        } else if (!strcasecmp(var, "avatar")) {
                profile->avatar = switch_core_strdup(module_pool, val);
        } else if (!strcasecmp(var, "odbc-dsn") && !switch_strlen_zero(val)) {
-#ifdef SWITCH_HAVE_ODBC
-               profile->odbc_dsn = switch_core_strdup(module_pool, val);
-               if ((profile->odbc_user = strchr(profile->odbc_dsn, ':'))) {
-                       *profile->odbc_user++ = '\0';
-                       if ((profile->odbc_pass = strchr(profile->odbc_user, ':'))) {
-                               *profile->odbc_pass++ = '\0';
+               if (switch_odbc_available()) {
+                       profile->odbc_dsn = switch_core_strdup(module_pool, val);
+                       if ((profile->odbc_user = strchr(profile->odbc_dsn, ':'))) {
+                               *profile->odbc_user++ = '\0';
+                               if ((profile->odbc_pass = strchr(profile->odbc_user, ':'))) {
+                                       *profile->odbc_pass++ = '\0';
+                               }
                        }
+               } else {
+                       switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "ODBC IS NOT AVAILABLE!\n");
                }
-
-#else
-               switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "ODBC IS NOT AVAILABLE!\n");
-#endif
        } else if (!strcasecmp(var, "use-rtp-timer") && switch_true(val)) {
                switch_set_flag(profile, TFLAG_TIMER);
        } else if (!strcasecmp(var, "dialplan") && !switch_strlen_zero(val)) {
@@ -2282,9 +2252,7 @@ static switch_status_t load_config(void)
                        switch_snprintf(dbname, sizeof(dbname), "dingaling_%s", profile->name);
                        profile->dbname = switch_core_strdup(module_pool, dbname);
 
-
-#ifdef SWITCH_HAVE_ODBC
-                       if (profile->odbc_dsn) {
+                       if (switch_odbc_available() && profile->odbc_dsn) {
                                if (!(profile->master_odbc = switch_odbc_handle_new(profile->odbc_dsn, profile->odbc_user, profile->odbc_pass))) {
                                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Cannot Open ODBC Database!\n");
                                        continue;
@@ -2299,7 +2267,6 @@ static switch_status_t load_config(void)
                                switch_odbc_handle_exec(profile->master_odbc, sub_sql, NULL);
                                //mdl_execute_sql(profile, sub_sql, NULL);
                        } else {
-#endif
                                if ((db = switch_core_db_open_file(profile->dbname))) {
                                        switch_core_db_test_reactive(db, "select * from jabber_subscriptions", NULL, sub_sql);
                                } else {
@@ -2307,9 +2274,7 @@ static switch_status_t load_config(void)
                                        continue;
                                }
                                switch_core_db_close(db);
-#ifdef SWITCH_HAVE_ODBC
                        }
-#endif
                }
 
                if (profile) {

diff --git a/src/mod/endpoints/mod_sofia/mod_sofia.h b/src/mod/endpoints/mod_sofia/mod_sofia.h
index c5a2e47123793f21fcf0fbf4692227fcc4642c8c..d6233bd9e71666a2136d740096375f631b86fcd9 100644 (file)
--- a/src/mod/endpoints/mod_sofia/mod_sofia.h
+++ b/src/mod/endpoints/mod_sofia/mod_sofia.h
@@ -42,9 +42,6 @@
 #define HAVE_APR
 #include <switch.h>
 #include <switch_version.h>
-#ifdef SWITCH_HAVE_ODBC
-#include <switch_odbc.h>
-#endif
 #define SOFIA_NAT_SESSION_TIMEOUT 20
 #define SOFIA_MAX_ACL 100
 #ifdef _MSC_VER

diff --git a/src/mod/endpoints/mod_sofia/sofia.c b/src/mod/endpoints/mod_sofia/sofia.c
index c1ee729f688e92792706ad639d20fd2a1199f7f1..94f4592b18dfcfb12aedcc2d3831173f9668d936 100644 (file)
--- a/src/mod/endpoints/mod_sofia/sofia.c
+++ b/src/mod/endpoints/mod_sofia/sofia.c
@@ -2068,17 +2068,17 @@ switch_status_t config_sofia(int reload, char *profile_name)
                                        } else if (!strcasecmp(var, "sip-trace") && switch_true(val)) {
                                                sofia_set_flag(profile, TFLAG_TPORT_LOG);
                                        } else if (!strcasecmp(var, "odbc-dsn") && !switch_strlen_zero(val)) {
-#ifdef SWITCH_HAVE_ODBC
-                                               profile->odbc_dsn = switch_core_strdup(profile->pool, val);
-                                               if ((profile->odbc_user = strchr(profile->odbc_dsn, ':'))) {
-                                                       *profile->odbc_user++ = '\0';
-                                                       if ((profile->odbc_pass = strchr(profile->odbc_user, ':'))) {
-                                                               *profile->odbc_pass++ = '\0';
+                                               if (switch_odbc_available()) {
+                                                       profile->odbc_dsn = switch_core_strdup(profile->pool, val);
+                                                       if ((profile->odbc_user = strchr(profile->odbc_dsn, ':'))) {
+                                                               *profile->odbc_user++ = '\0';
+                                                               if ((profile->odbc_pass = strchr(profile->odbc_user, ':'))) {
+                                                                       *profile->odbc_pass++ = '\0';
+                                                               }
                                                        }
+                                               } else {
+                                                       switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "ODBC IS NOT AVAILABLE!\n");
                                                }
-#else
-                                               switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "ODBC IS NOT AVAILABLE!\n");
-#endif
                                        } else if (!strcasecmp(var, "user-agent-string")) {
                                                profile->user_agent = switch_core_strdup(profile->pool, val);
                                        } else if (!strcasecmp(var, "auto-restart")) {

diff --git a/src/mod/endpoints/mod_sofia/sofia_glue.c b/src/mod/endpoints/mod_sofia/sofia_glue.c
index c332c2a92977bee139b9219906de8b49c1711fc0..b7fa4f76ce24a3625cdf58d0143366700fe91118 100644 (file)
--- a/src/mod/endpoints/mod_sofia/sofia_glue.c
+++ b/src/mod/endpoints/mod_sofia/sofia_glue.c
@@ -3616,8 +3616,7 @@ int sofia_glue_init_sql(sofia_profile_t *profile)
                "   expires           INTEGER\n"
                ");\n";
 
-       if (profile->odbc_dsn) {
-#ifdef SWITCH_HAVE_ODBC
+       if (switch_odbc_available() && profile->odbc_dsn) {
                int x;
                char *indexes[] = {
                        "create index sr_call_id on sip_registrations (call_id)",
@@ -3735,9 +3734,8 @@ int sofia_glue_init_sql(sofia_profile_t *profile)
                }
 
 
-#else
+       } else if (profile->odbc_dsn) {
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "ODBC IS NOT AVAILABLE!\n");
-#endif
        } else {
                if (!(profile->master_db = switch_core_db_open_file(profile->dbname))) {
                        return 0;
@@ -3835,28 +3833,23 @@ int sofia_glue_init_sql(sofia_profile_t *profile)
                switch_core_db_exec(profile->master_db, "create index if not exists sa_hostname on sip_authentication (hostname)", NULL, NULL, NULL);
        }
 
-#ifdef SWITCH_HAVE_ODBC
-       if (profile->odbc_dsn) {
+       if (switch_odbc_available() && profile->odbc_dsn) {
                return profile->master_odbc ? 1 : 0;
        }
-#endif
 
        return profile->master_db ? 1 : 0;
 }
 
 void sofia_glue_sql_close(sofia_profile_t *profile)
 {
-#ifdef SWITCH_HAVE_ODBC
-       if (profile->master_odbc) {
+       if (switch_odbc_available() && profile->master_odbc) {
                switch_odbc_handle_destroy(&profile->master_odbc);
+       } else {
+               switch_core_db_close(profile->master_db);
+               profile->master_db = NULL;
        }
-#else
-       switch_core_db_close(profile->master_db);
-       profile->master_db = NULL;
-#endif
 }
 
-
 void sofia_glue_execute_sql(sofia_profile_t *profile, char **sqlp, switch_bool_t sql_already_dynamic)
 {
        switch_status_t status = SWITCH_STATUS_FALSE;
@@ -3899,9 +3892,8 @@ void sofia_glue_actually_execute_sql(sofia_profile_t *profile, switch_bool_t mas
                switch_mutex_lock(mutex);
        }
 
-       if (profile->odbc_dsn) {
-#ifdef SWITCH_HAVE_ODBC
-               SQLHSTMT stmt;
+       if (switch_odbc_available() && profile->odbc_dsn) {
+               switch_odbc_statement_handle_t stmt;
                if (switch_odbc_handle_exec(profile->master_odbc, sql, &stmt) != SWITCH_ODBC_SUCCESS) {
                        char *err_str;
                        err_str = switch_odbc_handle_get_error(profile->master_odbc, stmt);
@@ -3910,10 +3902,9 @@ void sofia_glue_actually_execute_sql(sofia_profile_t *profile, switch_bool_t mas
                        }
                        switch_safe_free(err_str);
                }
-               SQLFreeHandle(SQL_HANDLE_STMT, stmt);
-#else
+               switch_odbc_statement_handle_free(&stmt);
+       } else if (profile->odbc_dsn) {
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "ODBC IS NOT AVAILABLE!\n");
-#endif
        } else {
                if (master) {
                        db = profile->master_db;
@@ -3948,12 +3939,10 @@ switch_bool_t sofia_glue_execute_sql_callback(sofia_profile_t *profile,
        }
 
 
-       if (profile->odbc_dsn) {
-#ifdef SWITCH_HAVE_ODBC
+       if (switch_odbc_available() && profile->odbc_dsn) {
                switch_odbc_handle_callback_exec(profile->master_odbc, sql, callback, pdata);
-#else
+       } else if (profile->odbc_dsn) {
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "ODBC IS NOT AVAILABLE!\n");
-#endif
        } else {
 
                if (master) {
@@ -3984,36 +3973,17 @@ switch_bool_t sofia_glue_execute_sql_callback(sofia_profile_t *profile,
        return ret;
 }
 
-#ifdef SWITCH_HAVE_ODBC
 static char *sofia_glue_execute_sql2str_odbc(sofia_profile_t *profile, switch_mutex_t *mutex, char *sql, char *resbuf, size_t len)
 {
        char *ret = NULL;
-       SQLHSTMT stmt;
-       SQLCHAR name[1024];
-       SQLLEN m = 0;
-
-       if (switch_odbc_handle_exec(profile->master_odbc, sql, &stmt) == SWITCH_ODBC_SUCCESS) {
-               SQLSMALLINT NameLength, DataType, DecimalDigits, Nullable;
-               SQLULEN ColumnSize;
-               SQLRowCount(stmt, &m);
 
-               if (m <= 0) {
-                       return NULL;
-               }
-
-               if (SQLFetch(stmt) != SQL_SUCCESS) {
-                       return NULL;
-               }
-
-               SQLDescribeCol(stmt, 1, name, sizeof(name), &NameLength, &DataType, &ColumnSize, &DecimalDigits, &Nullable);
-               SQLGetData(stmt, 1, SQL_C_CHAR, (SQLCHAR *) resbuf, (SQLLEN) len, NULL);
-               SQLFreeHandle(SQL_HANDLE_STMT, stmt);
+       if (switch_odbc_handle_exec_string(profile->master_odbc, sql, resbuf, len) == SWITCH_ODBC_SUCCESS) {
                ret = resbuf;
        }
 
        return ret;
 }
-#endif
+
 
 char *sofia_glue_execute_sql2str(sofia_profile_t *profile, switch_mutex_t *mutex, char *sql, char *resbuf, size_t len)
 {
@@ -4021,11 +3991,9 @@ char *sofia_glue_execute_sql2str(sofia_profile_t *profile, switch_mutex_t *mutex
        switch_core_db_stmt_t *stmt;
        char *ret = NULL;
 
-#ifdef SWITCH_HAVE_ODBC
-       if (profile->odbc_dsn) {
+       if (switch_odbc_available() && profile->odbc_dsn) {
                return sofia_glue_execute_sql2str_odbc(profile, mutex, sql, resbuf, len);
        }
-#endif
 
        if (mutex) {
                switch_mutex_lock(mutex);

diff --git a/src/mod/endpoints/mod_sofia/sofia_reg.c b/src/mod/endpoints/mod_sofia/sofia_reg.c
index 537d44550a97980aa87a5e67e18c9d1b5d86fe8d..40e118ec584f7d774abcad79bbaec1c166742227 100644 (file)
--- a/src/mod/endpoints/mod_sofia/sofia_reg.c
+++ b/src/mod/endpoints/mod_sofia/sofia_reg.c
@@ -581,22 +581,17 @@ void sofia_reg_check_expire(sofia_profile_t *profile, time_t now, int reboot)
 {
        char sql[1024];
 
-#ifdef SWITCH_HAVE_ODBC
-       if (profile->odbc_dsn) {
+       if (switch_odbc_available() && profile->odbc_dsn) {
                if (!profile->master_odbc) {
                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error Opening DB %s\n", profile->dbname);
                        return;
                }
        } else {
-#endif
                if (!profile->master_db) {
                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error Opening DB %s\n", profile->dbname);
                        return;
                }
-#ifdef SWITCH_HAVE_ODBC
        }
-#endif
-
 
        switch_mutex_lock(profile->ireg_mutex);
 

diff --git a/src/mod/languages/mod_spidermonkey_odbc/mod_spidermonkey_odbc.c b/src/mod/languages/mod_spidermonkey_odbc/mod_spidermonkey_odbc.c
index 77101828844261ec21424ad317474a2ccc43a5e5..8ca2f479b237b39266dd772fce707bcab219c899 100644 (file)
--- a/src/mod/languages/mod_spidermonkey_odbc/mod_spidermonkey_odbc.c
+++ b/src/mod/languages/mod_spidermonkey_odbc/mod_spidermonkey_odbc.c
@@ -30,7 +30,17 @@
  *
  */
 #include "mod_spidermonkey.h"
-#include <switch_odbc.h>
+
+#include <sql.h>
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable:4201)
+#include <sqlext.h>
+#pragma warning(pop)
+#else
+#include <sqlext.h>
+#endif
+#include <sqltypes.h>
 
 static const char modname[] = "ODBC";
 

diff --git a/src/switch_odbc.c b/src/switch_odbc.c
index edbf76429db5fd460850b0b9839cbc450689450e..0c0b7d2a6a154ee9d61026d29e8849442a3c8a65 100644 (file)
--- a/src/switch_odbc.c
+++ b/src/switch_odbc.c
@@ -30,7 +30,18 @@
  */
 
 #include <switch.h>
-#include <switch_odbc.h>
+
+#ifdef SWITCH_HAVE_ODBC
+#include <sql.h>
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable:4201)
+#include <sqlext.h>
+#pragma warning(pop)
+#else
+#include <sqlext.h>
+#endif
+#include <sqltypes.h>
 
 #if (ODBCVER < 0x0300)
 #define SQL_NO_DATA SQL_SUCCESS
@@ -46,9 +57,11 @@ struct switch_odbc_handle {
        char odbc_driver[256];
        BOOL is_firebird;
 };
+#endif
 
 SWITCH_DECLARE(switch_odbc_handle_t *) switch_odbc_handle_new(char *dsn, char *username, char *password)
 {
+#ifdef SWITCH_HAVE_ODBC
        switch_odbc_handle_t *new_handle;
 
        if (!(new_handle = malloc(sizeof(*new_handle)))) {
@@ -86,13 +99,20 @@ SWITCH_DECLARE(switch_odbc_handle_t *) switch_odbc_handle_new(char *dsn, char *u
                switch_safe_free(new_handle);
        }
 
+#endif
        return NULL;
 }
 
 SWITCH_DECLARE(switch_odbc_status_t) switch_odbc_handle_disconnect(switch_odbc_handle_t *handle)
 {
+#ifdef SWITCH_HAVE_ODBC
+
        int result;
 
+       if (!handle) {
+               return SWITCH_ODBC_FAIL;
+       }
+
        if (handle->state == SWITCH_ODBC_STATE_CONNECTED) {
                result = SQLDisconnect(handle->con);
                if (result == SWITCH_ODBC_SUCCESS) {
@@ -105,10 +125,14 @@ SWITCH_DECLARE(switch_odbc_status_t) switch_odbc_handle_disconnect(switch_odbc_h
        handle->state = SWITCH_ODBC_STATE_DOWN;
 
        return SWITCH_ODBC_SUCCESS;
+#else
+       return SWITCH_ODBC_FAIL;
+#endif
 }
 
 SWITCH_DECLARE(switch_odbc_status_t) switch_odbc_handle_connect(switch_odbc_handle_t *handle)
 {
+#ifdef SWITCH_HAVE_ODBC
        int result;
        SQLINTEGER err;
        int16_t mlen;
@@ -186,10 +210,14 @@ SWITCH_DECLARE(switch_odbc_status_t) switch_odbc_handle_connect(switch_odbc_hand
        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Connected to [%s]\n", handle->dsn);
        handle->state = SWITCH_ODBC_STATE_CONNECTED;
        return SWITCH_ODBC_SUCCESS;
+#else
+       return SWITCH_ODBC_FAIL;
+#endif
 }
 
 static int db_is_up(switch_odbc_handle_t *handle)
 {
+#ifdef SWITCH_HAVE_ODBC
        int ret = 0;
        SQLHSTMT stmt = NULL;
        SQLLEN m = 0;
@@ -288,10 +316,68 @@ static int db_is_up(switch_odbc_handle_t *handle)
        }
 
        return ret;
+#else
+       return SWITCH_ODBC_FAIL;
+#endif
 }
 
-SWITCH_DECLARE(switch_odbc_status_t) switch_odbc_handle_exec(switch_odbc_handle_t *handle, char *sql, SQLHSTMT * rstmt)
+SWITCH_DECLARE(switch_odbc_status_t) switch_odbc_statement_handle_free(switch_odbc_statement_handle_t * stmt)
 {
+       if (!stmt || ! *stmt) {
+               return SWITCH_ODBC_FAIL;
+       }
+#ifdef SWITCH_HAVE_ODBC
+       SQLFreeHandle(SQL_HANDLE_STMT, *stmt);
+       *stmt = NULL;
+       return SWITCH_ODBC_SUCCESS;
+#else
+       return SWITCH_ODBC_FAIL;
+#endif
+}
+
+
+SWITCH_DECLARE(switch_odbc_status_t) switch_odbc_handle_exec_string(switch_odbc_handle_t *handle,
+                                                                                                                                       char *sql,
+                                                                                                                                       char *resbuf,
+                                                                                                                                       size_t len)
+{
+#ifdef SWITCH_HAVE_ODBC
+       switch_odbc_status_t sstatus = SWITCH_ODBC_FAIL;
+       switch_odbc_statement_handle_t stmt = NULL;
+       SQLCHAR name[1024];
+       SQLLEN m = 0;
+
+       if (switch_odbc_handle_exec(handle, sql, &stmt) == SWITCH_ODBC_SUCCESS) {
+               SQLSMALLINT NameLength, DataType, DecimalDigits, Nullable;
+               SQLULEN ColumnSize;
+               SQLRowCount(stmt, &m);
+
+               if (m <= 0) {
+                       goto done;
+               }
+
+               if (SQLFetch(stmt) != SQL_SUCCESS) {
+                       goto done;
+               }
+
+               SQLDescribeCol(stmt, 1, name, sizeof(name), &NameLength, &DataType, &ColumnSize, &DecimalDigits, &Nullable);
+               SQLGetData(stmt, 1, SQL_C_CHAR, (SQLCHAR *) resbuf, (SQLLEN) len, NULL);
+               sstatus = SWITCH_ODBC_SUCCESS;
+       } else {
+               return sstatus;
+       }
+
+ done:
+       switch_odbc_statement_handle_free(&stmt);
+       return sstatus;
+#else
+       return SWITCH_ODBC_FAIL;
+#endif
+}
+
+SWITCH_DECLARE(switch_odbc_status_t) switch_odbc_handle_exec(switch_odbc_handle_t *handle, char *sql, switch_odbc_statement_handle_t * rstmt)
+{
+#ifdef SWITCH_HAVE_ODBC
        SQLHSTMT stmt = NULL;
        int result;
 
@@ -327,6 +413,7 @@ SWITCH_DECLARE(switch_odbc_status_t) switch_odbc_handle_exec(switch_odbc_handle_
        } else if (stmt) {
                SQLFreeHandle(SQL_HANDLE_STMT, stmt);
        }
+#endif
        return SWITCH_ODBC_FAIL;
 }
 
@@ -334,6 +421,7 @@ SWITCH_DECLARE(switch_odbc_status_t) switch_odbc_handle_callback_exec_detailed(c
                                                                                                                                                           switch_odbc_handle_t *handle,
                                                                                                                                                           char *sql, switch_core_db_callback_func_t callback, void *pdata)
 {
+#ifdef SWITCH_HAVE_ODBC
        SQLHSTMT stmt = NULL;
        SQLSMALLINT c = 0, x = 0;
        SQLLEN m = 0, t = 0;
@@ -445,11 +533,14 @@ SWITCH_DECLARE(switch_odbc_status_t) switch_odbc_handle_callback_exec_detailed(c
                SQLFreeHandle(SQL_HANDLE_STMT, stmt);
        }
 
+#endif
        return SWITCH_ODBC_FAIL;
 }
 
 SWITCH_DECLARE(void) switch_odbc_handle_destroy(switch_odbc_handle_t **handlep)
 {
+#ifdef SWITCH_HAVE_ODBC
+
        switch_odbc_handle_t *handle = NULL;
 
        if (!handlep) {
@@ -468,15 +559,24 @@ SWITCH_DECLARE(void) switch_odbc_handle_destroy(switch_odbc_handle_t **handlep)
                free(handle);
        }
        *handlep = NULL;
+#else
+       return;
+#endif
 }
 
 SWITCH_DECLARE(switch_odbc_state_t) switch_odbc_handle_get_state(switch_odbc_handle_t *handle)
 {
+#ifdef SWITCH_HAVE_ODBC
        return handle ? handle->state : SWITCH_ODBC_STATE_INIT;
+#else
+       return SWITCH_ODBC_STATE_ERROR;
+#endif
 }
 
-SWITCH_DECLARE(char *) switch_odbc_handle_get_error(switch_odbc_handle_t *handle, SQLHSTMT stmt)
+SWITCH_DECLARE(char *) switch_odbc_handle_get_error(switch_odbc_handle_t *handle, switch_odbc_statement_handle_t stmt)
 {
+#ifdef SWITCH_HAVE_ODBC
+
        char buffer[SQL_MAX_MESSAGE_LENGTH + 1] = "";
        char sqlstate[SQL_SQLSTATE_SIZE + 1] = "";
        SQLINTEGER sqlcode;
@@ -488,6 +588,18 @@ SWITCH_DECLARE(char *) switch_odbc_handle_get_error(switch_odbc_handle_t *handle
        };
 
        return ret;
+#else
+       return NULL;
+#endif
+}
+
+SWITCH_DECLARE(switch_bool_t) switch_odbc_available(void)
+{
+#ifdef SWITCH_HAVE_ODBC
+       return SWITCH_TRUE;
+#else
+       return SWITCH_FALSE;
+#endif
 }