kenmirrors
/
freeswitch
mirror of https://github.com/signalwire/freeswitch.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

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
This commit is contained in:
Michael Jerris 2009-06-24 16:02:43 +00:00
parent f7d99cf948
commit 6348359d95
25 changed files with 262 additions and 379 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Makefile.am
View File

@ -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

2
src/include/switch.h
View File

@ -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

25
src/include/switch_odbc.h
View File

@ -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:

2
src/include/switch_types.h
View File

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

3
src/mod/applications/mod_cidlookup/Makefile
View File

@ -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 ;`

60
src/mod/applications/mod_cidlookup/mod_cidlookup.c
View File

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

3
src/mod/applications/mod_easyroute/Makefile
View File

@ -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 ;`

38
src/mod/applications/mod_easyroute/mod_easyroute.c
View File

@ -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
if (!switch_odbc_available()) {
stream->write_function(stream, "mod_easyroute requires you enable core odbc support\n");
status = SWITCH_STATUS_SUCCESS;
goto done;
#endif
}
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);

39
src/mod/applications/mod_fifo/mod_fifo.c
View File

@ -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,7 +1749,7 @@ 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
if (switch_odbc_available()) {
globals.odbc_dsn = switch_core_strdup(globals.pool, val);
if ((odbc_user = strchr(globals.odbc_dsn, ':'))) {
*odbc_user++ = '\0';
@ -1774,9 +1757,9 @@ static switch_status_t load_config(int reload, int del_all)
*odbc_pass++ = '\0';
}
}
#else
} 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;

3
src/mod/applications/mod_lcr/Makefile
View File

@ -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

20
src/mod/applications/mod_lcr/mod_lcr.c
View File

@ -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
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;
#endif
}
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;

3
src/mod/applications/mod_limit/Makefile
View File

@ -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 ;`

40
src/mod/applications/mod_limit/mod_limit.c
View File

@ -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);

3
src/mod/applications/mod_nibblebill/Makefile
View File

@ -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 ;`

54
src/mod/applications/mod_nibblebill/mod_nibblebill.c
View File

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

3
src/mod/applications/mod_voicemail/Makefile
View File

@ -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 ;`

29
src/mod/applications/mod_voicemail/mod_voicemail.c
View File

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

1
src/mod/endpoints/mod_dingaling/Makefile
View File

@ -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

53
src/mod/endpoints/mod_dingaling/mod_dingaling.c
View File

@ -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,7 +1920,7 @@ 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
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';
@ -1957,10 +1928,9 @@ static void set_profile_val(mdl_profile_t *profile, char *var, char *val)
*profile->odbc_pass++ = '\0';
}
}
#else
} 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) {

3
src/mod/endpoints/mod_sofia/mod_sofia.h
View File

@ -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

6
src/mod/endpoints/mod_sofia/sofia.c
View File

@ -2068,7 +2068,7 @@ 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
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';
@ -2076,9 +2076,9 @@ switch_status_t config_sofia(int reload, char *profile_name)
*profile->odbc_pass++ = '\0';
}
}
#else
} 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")) {

62
src/mod/endpoints/mod_sofia/sofia_glue.c
View File

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

7
src/mod/endpoints/mod_sofia/sofia_reg.c
View File

@ -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);

12
src/mod/languages/mod_spidermonkey_odbc/mod_spidermonkey_odbc.c
View File

@ -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";

118
src/switch_odbc.c
View File

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