#include <switch.h>
#include "private/switch_core_pvt.h"

Include dependency graph for switch_core_sqldb.c:

Data Structures
struct	switch_cache_db_handle

struct	helper

struct	switch_sql_queue_manager

struct	db_job

Macros
#define	SWITCH_SQL_QUEUE_LEN 100000

#define	SWITCH_SQL_QUEUE_PAUSE_LEN 90000

#define	SQL_CACHE_TIMEOUT 30

#define	SQL_REG_TIMEOUT 15

#define	EXEC_NOW

#define	MAX_SQL 5

#define	new_sql() switch_assert(sql_idx+1 < MAX_SQL); if (exists) sql[sql_idx++]

#define	new_sql_a() switch_assert(sql_idx+1 < MAX_SQL); sql[sql_idx++]

Functions
static void	switch_core_sqldb_start_thread (void)

static void	switch_core_sqldb_stop_thread (void)

static switch_cache_db_handle_t *	create_handle (switch_cache_db_handle_type_t type)

static void	add_handle (switch_cache_db_handle_t dbh, const char db_str, const char db_callsite_str, const char thread_str)

static void	del_handle (switch_cache_db_handle_t *dbh)

static switch_cache_db_handle_t *	get_handle (const char db_str, const char user_str, const char *thread_str)

switch_status_t	_switch_core_db_handle (switch_cache_db_handle_t *dbh, const char file, const char *func, int line)
	Open the default system database. More...

static void	sql_close (time_t prune)

switch_cache_db_handle_type_t	switch_cache_db_get_type (switch_cache_db_handle_t *dbh)

void	switch_cache_db_flush_handles (void)

void	switch_cache_db_release_db_handle (switch_cache_db_handle_t **dbh)
	Returns the handle to the pool, handle is NOT available to other threads until the allocating thread actually terminates. More...

void	switch_cache_db_dismiss_db_handle (switch_cache_db_handle_t **dbh)
	Returns the handle to the pool, immediately available for other threads to use. More...

switch_status_t	_switch_cache_db_get_db_handle_dsn (switch_cache_db_handle_t *dbh, const char dsn, const char file, const char func, int line)

switch_status_t	_switch_cache_db_get_db_handle (switch_cache_db_handle_t *dbh, switch_cache_db_handle_type_t type, switch_cache_db_connection_options_t connection_options, const char file, const char func, int line)
	Gets a new cached handle from the pool, potentially creating a new connection. The connection is bound to the thread until it (the thread) terminates unless you dismiss rather than release. More...

static switch_status_t	switch_cache_db_execute_sql_real (switch_cache_db_handle_t dbh, const char sql, char **err)

static switch_status_t	switch_cache_db_execute_sql_chunked (switch_cache_db_handle_t dbh, char sql, uint32_t chunk_size, char **err)

switch_status_t	switch_cache_db_execute_sql (switch_cache_db_handle_t dbh, char sql, char **err)
	Executes the sql. More...

int	switch_cache_db_affected_rows (switch_cache_db_handle_t *dbh)
	Get the affected rows of the last performed query. More...

int	switch_cache_db_load_extension (switch_cache_db_handle_t dbh, const char extension)
	load an external extension to db More...

char *	switch_cache_db_execute_sql2str (switch_cache_db_handle_t dbh, char sql, char str, size_t len, char *err)
	Executes the sql and returns the result as a string. More...

switch_status_t	switch_cache_db_persistant_execute (switch_cache_db_handle_t dbh, const char sql, uint32_t retries)

switch_status_t	switch_cache_db_persistant_execute_trans_full (switch_cache_db_handle_t dbh, char sql, uint32_t retries, const char pre_trans_execute, const char post_trans_execute, const char inner_pre_trans_execute, const char inner_post_trans_execute)

static int	helper_callback (void pArg, int argc, char argv, char *columnNames)

switch_status_t	switch_cache_db_execute_sql_event_callback (switch_cache_db_handle_t dbh, const char sql, switch_core_db_event_callback_func_t callback, void pdata, char *err)

switch_status_t	switch_cache_db_execute_sql_event_callback_err (switch_cache_db_handle_t dbh, const char sql, switch_core_db_event_callback_func_t callback, switch_core_db_err_callback_func_t err_callback, void pdata, char *err)

switch_status_t	switch_cache_db_execute_sql_callback (switch_cache_db_handle_t dbh, const char sql, switch_core_db_callback_func_t callback, void pdata, char *err)
	Executes the sql and uses callback for row-by-row processing. More...

switch_status_t	switch_cache_db_execute_sql_callback_err (switch_cache_db_handle_t dbh, const char sql, switch_core_db_callback_func_t callback, switch_core_db_err_callback_func_t err_callback, void pdata, char *err)
	Executes the sql and uses callback for row-by-row processing. More...

switch_status_t	switch_cache_db_create_schema (switch_cache_db_handle_t dbh, char sql, char **err)
	Executes the create schema sql. More...

switch_bool_t	switch_cache_db_test_reactive (switch_cache_db_handle_t dbh, const char test_sql, const char drop_sql, const char reactive_sql)
	Performs test_sql and if it fails performs drop_sql and reactive_sql. More...

static void *SWITCH_THREAD_FUNC	switch_core_sql_db_thread (switch_thread_t thread, void obj)

static void *SWITCH_THREAD_FUNC	switch_user_sql_thread (switch_thread_t thread, void obj)

static int	qm_wake (switch_sql_queue_manager_t *qm)

static uint32_t	qm_ttl (switch_sql_queue_manager_t *qm)

static void *SWITCH_THREAD_FUNC	sql_in_thread (switch_thread_t thread, void obj)

static switch_thread_data_t *	new_job (switch_sql_queue_manager_t qm, const char sql, switch_core_db_callback_func_t callback, switch_core_db_err_callback_func_t err_callback, switch_core_db_event_callback_func_t event_callback, switch_core_db_err_callback_func_t event_err_callback, void *pdata)

void	switch_sql_queue_manager_execute_sql_callback (switch_sql_queue_manager_t qm, const char sql, switch_core_db_callback_func_t callback, void *pdata)

void	switch_sql_queue_manager_execute_sql_callback_err (switch_sql_queue_manager_t qm, const char sql, switch_core_db_callback_func_t callback, switch_core_db_err_callback_func_t err_callback, void *pdata)

void	switch_sql_queue_manager_execute_sql_event_callback (switch_sql_queue_manager_t qm, const char sql, switch_core_db_event_callback_func_t callback, void *pdata)

void	switch_sql_queue_manager_execute_sql_event_callback_err (switch_sql_queue_manager_t qm, const char sql, switch_core_db_event_callback_func_t callback, switch_core_db_err_callback_func_t err_callback, void *pdata)

static void	do_flush (switch_sql_queue_manager_t qm, int i, switch_cache_db_handle_t dbh)

void	switch_sql_queue_manager_resume (switch_sql_queue_manager_t *qm)

void	switch_sql_queue_manager_pause (switch_sql_queue_manager_t *qm, switch_bool_t flush)

int	switch_sql_queue_manager_size (switch_sql_queue_manager_t *qm, uint32_t index)

switch_status_t	switch_sql_queue_manager_stop (switch_sql_queue_manager_t *qm)

switch_status_t	switch_sql_queue_manager_start (switch_sql_queue_manager_t *qm)

switch_status_t	switch_sql_queue_manager_destroy (switch_sql_queue_manager_t **qmp)

switch_status_t	switch_sql_queue_manager_push (switch_sql_queue_manager_t qm, const char sql, uint32_t pos, switch_bool_t dup)

switch_status_t	switch_sql_queue_manager_push_confirm (switch_sql_queue_manager_t qm, const char sql, uint32_t pos, switch_bool_t dup)

switch_status_t	switch_sql_queue_manager_init_name (const char name, switch_sql_queue_manager_t qmp, uint32_t numq, const char dsn, uint32_t max_trans, const char pre_trans_execute, const char post_trans_execute, const char inner_pre_trans_execute, const char inner_post_trans_execute)

static uint32_t	do_trans (switch_sql_queue_manager_t *qm)

static char *	parse_presence_data_cols (switch_event_t *event)

static void	core_event_handler (switch_event_t *event)

void	switch_core_recovery_flush (const char technology, const char profile_name)

static int	recover_callback (void pArg, int argc, char argv, char *columnNames)

int	switch_core_recovery_recover (const char technology, const char profile_name)

switch_cache_db_handle_type_t	switch_core_dbtype (void)

void	switch_core_sql_exec (const char *sql)

void	switch_core_recovery_untrack (switch_core_session_t *session, switch_bool_t force)

void	switch_core_recovery_track (switch_core_session_t *session)

switch_status_t	switch_core_add_registration (const char user, const char realm, const char token, const char url, uint32_t expires, const char network_ip, const char network_port, const char network_proto, const char metadata)
	Add user registration. More...

switch_status_t	switch_core_del_registration (const char user, const char realm, const char *token)
	Delete user registration. More...

switch_status_t	switch_core_expire_registration (int force)
	Expire user registrations. More...

switch_status_t	switch_core_sqldb_start (switch_memory_pool_t *pool, switch_bool_t manage)

void	switch_core_sqldb_pause (void)

void	switch_core_sqldb_resume (void)

void	switch_core_sqldb_stop (void)

void	switch_cache_db_status (switch_stream_handle_t *stream)
	Provides some feedback as to the status of the db connection pool. More...

char *	switch_sql_concat (void)

Variables
struct {
switch_memory_pool_t * memory_pool

switch_thread_t * db_thread

int db_thread_running

switch_bool_t manage

switch_mutex_t * io_mutex

switch_mutex_t * dbh_mutex

switch_mutex_t * ctl_mutex

switch_cache_db_handle_t * handle_pool

uint32_t total_handles

uint32_t total_used_handles

switch_cache_db_handle_t * dbh

switch_sql_queue_manager_t * qm

int paused

}	sql_manager

static char	create_complete_sql []

static char	create_alias_sql []

static char	create_channels_sql []

static char	create_calls_sql []

static char	create_interfaces_sql []

static char	create_tasks_sql []

static char	create_nat_sql []

static char	create_registrations_sql []

static char	detailed_calls_sql []

static char	recovery_sql []

static char	basic_calls_sql []

Macro Definition Documentation

#define EXEC_NOW

#define MAX_SQL 5

Definition at line 2203 of file switch_core_sqldb.c.

Referenced by core_event_handler().

#define new_sql ( ) switch_assert(sql_idx+1 < MAX_SQL); if (exists) sql[sql_idx++]

Definition at line 2204 of file switch_core_sqldb.c.

Referenced by core_event_handler().

#define new_sql_a ( ) switch_assert(sql_idx+1 < MAX_SQL); sql[sql_idx++]

Definition at line 2205 of file switch_core_sqldb.c.

Referenced by core_event_handler().

#define SQL_CACHE_TIMEOUT 30

Definition at line 208 of file switch_core_sqldb.c.

Referenced by sql_close(), switch_cache_db_execute_sql_callback(), switch_cache_db_execute_sql_callback_err(), switch_cache_db_execute_sql_event_callback(), switch_cache_db_execute_sql_event_callback_err(), switch_cache_db_flush_handles(), and switch_core_sql_db_thread().

#define SQL_REG_TIMEOUT 15

Definition at line 209 of file switch_core_sqldb.c.

Referenced by switch_core_sql_db_thread().

#define SWITCH_SQL_QUEUE_LEN 100000

Definition at line 39 of file switch_core_sqldb.c.

Referenced by switch_sql_queue_manager_init_name().

#define SWITCH_SQL_QUEUE_PAUSE_LEN 90000

Definition at line 40 of file switch_core_sqldb.c.

Function Documentation

switch_status_t _switch_cache_db_get_db_handle	(	switch_cache_db_handle_t **	dbh,
		switch_cache_db_handle_type_t	type,
		switch_cache_db_connection_options_t *	connection_options,
		const char *	file,
		const char *	func,
		int	line
	)

Gets a new cached handle from the pool, potentially creating a new connection. The connection is bound to the thread until it (the thread) terminates unless you dismiss rather than release.

Parameters

[out]	dbh	The handle
[in]	type	- ODBC or SQLLITE
[in]	connection_options	(userid, password, etc)

Definition at line 384 of file switch_core_sqldb.c.

References add_handle(), CACHE_DB_LEN, switch_cache_db_native_handle_t::core_db_dbh, create_handle(), switch_runtime::db_handle_timeout, get_handle(), switch_cache_db_handle::last_used, switch_runtime::max_db_handles, switch_cache_db_handle::name, switch_cache_db_handle::native_handle, switch_cache_db_native_handle_t::odbc_dbh, switch_cache_db_native_handle_t::pgsql_dbh, runtime, SCDB_TYPE_CORE_DB, SCDB_TYPE_ODBC, SCDB_TYPE_PGSQL, sql_manager, switch_cache_db_type_name(), SWITCH_CHANNEL_ID_LOG, SWITCH_CHANNEL_LOG, switch_core_db_open_file(), switch_epoch_time_now(), SWITCH_LOG_CRIT, SWITCH_LOG_DEBUG10, SWITCH_LOG_ERROR, switch_log_printf(), SWITCH_LOG_WARNING, switch_odbc_available(), switch_odbc_handle_connect(), switch_odbc_handle_destroy(), switch_odbc_handle_new(), SWITCH_ODBC_SUCCESS, switch_pgsql_available(), switch_pgsql_handle_connect(), switch_pgsql_handle_destroy(), switch_pgsql_handle_new(), SWITCH_PGSQL_SUCCESS, SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, switch_thread_self(), switch_yield, and switch_cache_db_handle::type.

Referenced by _switch_cache_db_get_db_handle_dsn().

 {
         switch_thread_id_t self = switch_thread_self();
         char thread_str[CACHE_DB_LEN] = "";
         char db_str[CACHE_DB_LEN] = "";
         char db_callsite_str[CACHE_DB_LEN] = "";
         switch_cache_db_handle_t *new_dbh = NULL;
         int waiting = 0;
         uint32_t yield_len = 100000, total_yield = 0;
 
         const char *db_name = NULL;
         const char *odbc_user = NULL;
         const char *odbc_pass = NULL;
         const char *db_type = NULL;
 
         while(runtime.max_db_handles && sql_manager.total_handles >= runtime.max_db_handles && sql_manager.total_used_handles >= sql_manager.total_handles) {
                 if (!waiting++) {
                         switch_log_printf(SWITCH_CHANNEL_ID_LOG, file, func, line, NULL, SWITCH_LOG_WARNING, "Max handles %u exceeded, blocking....\n", 
                                                           runtime.max_db_handles);
                 }
 
                 switch_yield(yield_len);
                 total_yield += yield_len;
                 
                 if (runtime.db_handle_timeout && total_yield > runtime.db_handle_timeout) {
                         switch_log_printf(SWITCH_CHANNEL_ID_LOG, file, func, line, NULL, SWITCH_LOG_ERROR, "Error connecting\n");
                         *dbh = NULL;
                         return SWITCH_STATUS_FALSE;
                 }
         }
 
         switch (type) {
         case SCDB_TYPE_PGSQL:
                 {
                         db_name = connection_options->pgsql_options.dsn;
                         odbc_user = NULL;
                         odbc_pass = NULL;
                         db_type = "pgsql";
                 }
         case SCDB_TYPE_ODBC:
                 {
                         db_name = connection_options->odbc_options.dsn;
                         odbc_user = connection_options->odbc_options.user;
                         odbc_pass = connection_options->odbc_options.pass;
                         db_type = "odbc";
                 }
                 break;
         case SCDB_TYPE_CORE_DB:
                 {
                         db_name = connection_options->core_db_options.db_path;
                         odbc_user = NULL;
                         odbc_pass = NULL;
                         db_type = "core_db";
                 }
                 break;
         }
 
         if (!db_name) {
                 return SWITCH_STATUS_FALSE;
         }
 
         if (odbc_user || odbc_pass) {
                 snprintf(db_str, sizeof(db_str) - 1, "db=\"%s\";type=\"%s\"user=\"%s\";pass=\"%s\"", db_name, db_type, odbc_user, odbc_pass);
         } else {
                 snprintf(db_str, sizeof(db_str) - 1, "db=\"%s\",type=\"%s\"", db_name, db_type);
         }
         snprintf(db_callsite_str, sizeof(db_callsite_str) - 1, "%s:%d", file, line);
         snprintf(thread_str, sizeof(thread_str) - 1, "thread=\"%lu\"",  (unsigned long) (intptr_t) self); 
 
         if ((new_dbh = get_handle(db_str, db_callsite_str, thread_str))) {
                 switch_log_printf(SWITCH_CHANNEL_ID_LOG, file, func, line, NULL, SWITCH_LOG_DEBUG10,
                                                   "Reuse Unused Cached DB handle %s [%s]\n", new_dbh->name, switch_cache_db_type_name(new_dbh->type));
         } else {
                 switch_core_db_t *db = NULL;
                 switch_odbc_handle_t *odbc_dbh = NULL;
                 switch_pgsql_handle_t *pgsql_dbh = NULL;
 
                 switch (type) {
                 case SCDB_TYPE_PGSQL:
                         {
                                 if (!switch_pgsql_available()) {
                                         switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Failure! PGSQL NOT AVAILABLE! Can't connect to DSN %s\n", connection_options->pgsql_options.dsn);
                                         goto end;
                                 }
 
                                 if ((pgsql_dbh = switch_pgsql_handle_new(connection_options->pgsql_options.dsn))) {
                                         if (switch_pgsql_handle_connect(pgsql_dbh) != SWITCH_PGSQL_SUCCESS) {
                                                 switch_pgsql_handle_destroy(&pgsql_dbh);
                                         }
                                 }
                         }
                         break;
                 case SCDB_TYPE_ODBC:
                         {
 
                                 if (!switch_odbc_available()) {
                                         switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Failure! ODBC NOT AVAILABLE! Can't connect to DSN %s\n", connection_options->odbc_options.dsn);
                                         goto end;
                                 }
 
                                 if ((odbc_dbh = switch_odbc_handle_new(connection_options->odbc_options.dsn,
                                                                                                            connection_options->odbc_options.user, connection_options->odbc_options.pass))) {
                                         if (switch_odbc_handle_connect(odbc_dbh) != SWITCH_ODBC_SUCCESS) {
                                                 switch_odbc_handle_destroy(&odbc_dbh);
                                         }
                                 }
 
 
                         }
                         break;
                 case SCDB_TYPE_CORE_DB:
                         {
                                 db = switch_core_db_open_file(connection_options->core_db_options.db_path);
                         }
                         break;
 
                 default:
                         goto end;
                 }
 
                 if (!db && !odbc_dbh && !pgsql_dbh) {
                         switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Failure to connect to %s %s!\n", switch_cache_db_type_name(type), db_name);
                         goto end;
                 }
 
                 new_dbh = create_handle(type);
 
                 switch_log_printf(SWITCH_CHANNEL_ID_LOG, file, func, line, NULL, SWITCH_LOG_DEBUG10,
                                                   "Create Cached DB handle %s [%s] %s:%d\n", new_dbh->name, switch_cache_db_type_name(type), file, line);
 
                 if (db) {
                         new_dbh->native_handle.core_db_dbh = db;
                 } else if (odbc_dbh) {
                         new_dbh->native_handle.odbc_dbh = odbc_dbh;
                 } else {
                         new_dbh->native_handle.pgsql_dbh = pgsql_dbh;
                 }
 
                 add_handle(new_dbh, db_str, db_callsite_str, thread_str);
         }
 
  end:
 
         if (new_dbh) {
                 new_dbh->last_used = switch_epoch_time_now(NULL);
         }
         
         *dbh = new_dbh;
 
         return *dbh ? SWITCH_STATUS_SUCCESS : SWITCH_STATUS_FALSE;
 }

switch_status_t _switch_cache_db_get_db_handle_dsn	(	switch_cache_db_handle_t **	dbh,
		const char *	dsn,
		const char *	file,
		const char *	func,
		int	line
	)

Definition at line 335 of file switch_core_sqldb.c.

References _switch_cache_db_get_db_handle(), switch_cache_db_connection_options_t::core_db_options, switch_cache_db_core_db_options_t::db_path, switch_cache_db_odbc_options_t::dsn, switch_cache_db_pgsql_options_t::dsn, switch_cache_db_connection_options_t::odbc_options, switch_cache_db_odbc_options_t::pass, switch_cache_db_connection_options_t::pgsql_options, SCDB_TYPE_CORE_DB, SCDB_TYPE_ODBC, SCDB_TYPE_PGSQL, switch_set_string, SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, and switch_cache_db_odbc_options_t::user.

Referenced by _switch_core_db_handle().

 {
         switch_cache_db_connection_options_t connection_options = { {0} };
         switch_cache_db_handle_type_t type;
         char tmp[256] = "";
         char *p;
         switch_status_t status = SWITCH_STATUS_FALSE;
         int i;
 
         if (!strncasecmp(dsn, "pgsql://", 8)) {
                 type = SCDB_TYPE_PGSQL;
                 connection_options.pgsql_options.dsn = (char *)(dsn + 8);
         } else if (!strncasecmp(dsn, "sqlite://", 9)) {
                 type = SCDB_TYPE_CORE_DB;
                 connection_options.core_db_options.db_path = (char *)(dsn + 9);
         } else if ((!(i = strncasecmp(dsn, "odbc://", 7))) || strchr(dsn+2, ':')) {
                 type = SCDB_TYPE_ODBC;
 
                 if (i) {
                         switch_set_string(tmp, dsn);
                 } else {
                         switch_set_string(tmp, dsn+7);
                 }
                 
                 connection_options.odbc_options.dsn = tmp;
 
                 if ((p = strchr(tmp, ':'))) {
                         *p++ = '\0';
                         connection_options.odbc_options.user = p;
                         
                         if ((p = strchr(connection_options.odbc_options.user, ':'))) {
                                 *p++ = '\0';
                                 connection_options.odbc_options.pass = p;
                         }
                 }
         } else {
                 type = SCDB_TYPE_CORE_DB;
                 connection_options.core_db_options.db_path = (char *)dsn;
         }
 
         status = _switch_cache_db_get_db_handle(dbh, type, &connection_options, file, func, line);
 
         if (status != SWITCH_STATUS_SUCCESS) *dbh = NULL;
 
         return status;
 }

switch_status_t _switch_core_db_handle	(	switch_cache_db_handle_t **	dbh,
		const char *	file,
		const char *	func,
		int	line
	)

Open the default system database.

Definition at line 184 of file switch_core_sqldb.c.

References _switch_cache_db_get_db_handle_dsn(), switch_runtime::dbname, switch_runtime::odbc_dsn, runtime, sql_manager, SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, and zstr.

 {
         switch_status_t r;
         char *dsn;
         
         if (!sql_manager.manage) {
                 return SWITCH_STATUS_FALSE;
         }
 
         if (!zstr(runtime.odbc_dsn)) {
                 dsn = runtime.odbc_dsn;
         } else if (!zstr(runtime.dbname)) {
                 dsn = runtime.dbname;
         } else {
                 dsn = "core";
         }
 
         if ((r = _switch_cache_db_get_db_handle_dsn(dbh, dsn, file, func, line)) != SWITCH_STATUS_SUCCESS) {
                 *dbh = NULL;
         }
         
         return r;
 }

static void add_handle	(	switch_cache_db_handle_t *	dbh,
		const char *	db_str,
		const char *	db_callsite_str,
		const char *	thread_str
	)

static

Definition at line 94 of file switch_core_sqldb.c.

References switch_cache_db_handle::creator, dbh, switch_cache_db_handle::hash, switch_cache_db_handle::mutex, switch_cache_db_handle::name, switch_cache_db_handle::next, sql_manager, switch_ci_hashfunc_default(), switch_mutex_lock(), switch_mutex_unlock(), switch_set_string, switch_cache_db_handle::thread_hash, switch_cache_db_handle::total_used_count, and switch_cache_db_handle::use_count.

Referenced by _switch_cache_db_get_db_handle().

 {
         switch_ssize_t hlen = -1;
 
         switch_mutex_lock(sql_manager.dbh_mutex);
 
         switch_set_string(dbh->creator, db_callsite_str);
 
         switch_set_string(dbh->name, db_str);
         dbh->hash = switch_ci_hashfunc_default(db_str, &hlen);
         dbh->thread_hash = switch_ci_hashfunc_default(thread_str, &hlen);
 
         dbh->use_count++;
         dbh->total_used_count++;
         sql_manager.total_used_handles++;
         dbh->next = sql_manager.handle_pool;
 
         sql_manager.handle_pool = dbh;
         sql_manager.total_handles++;
         switch_mutex_lock(dbh->mutex);
         switch_mutex_unlock(sql_manager.dbh_mutex);
 }

static void core_event_handler ( switch_event_t * event )

static

Definition at line 2207 of file switch_core_sqldb.c.

Referenced by switch_core_sqldb_start(), and switch_core_sqldb_stop().

 {
         char *sql[MAX_SQL] = { 0 };
         int sql_idx = 0;
         char *extra_cols;
         int exists = 1;
         char *uuid = NULL;
 
         switch_assert(event);
 
         switch (event->event_id) {
         case SWITCH_EVENT_CHANNEL_UUID:
         case SWITCH_EVENT_CHANNEL_CREATE:
         case SWITCH_EVENT_CHANNEL_ANSWER:
         case SWITCH_EVENT_CHANNEL_PROGRESS_MEDIA:
         case SWITCH_EVENT_CHANNEL_HOLD:
         case SWITCH_EVENT_CHANNEL_UNHOLD:
         case SWITCH_EVENT_CHANNEL_EXECUTE:
         case SWITCH_EVENT_CHANNEL_ORIGINATE:
         case SWITCH_EVENT_CALL_UPDATE:
         case SWITCH_EVENT_CHANNEL_CALLSTATE:
         case SWITCH_EVENT_CHANNEL_STATE:
         case SWITCH_EVENT_CHANNEL_BRIDGE:
         case SWITCH_EVENT_CHANNEL_UNBRIDGE:
         case SWITCH_EVENT_CALL_SECURE:
                 {
                         if ((uuid = switch_event_get_header(event, "unique-id"))) {
                                 exists = switch_ivr_uuid_exists(uuid);
                         }
                 }
                 break;
         default:
                 break;
         }
 
         switch (event->event_id) {
         case SWITCH_EVENT_ADD_SCHEDULE:
                 {
                         const char *id = switch_event_get_header(event, "task-id");
                         const char *manager = switch_event_get_header(event, "task-sql_manager");
 
                         if (id) {
                                 new_sql() = switch_mprintf("insert into tasks (task_id, task_desc, task_group, task_runtime, task_sql_manager, hostname) "
                                                                                    "values(%q,'%q','%q',%q,%q,'%q')",
                                                                                    id,
                                                                                    switch_event_get_header_nil(event, "task-desc"),
                                                                                    switch_event_get_header_nil(event, "task-group"),
                                                                                    switch_event_get_header_nil(event, "task-runtime"),
                                                                                    manager ? manager : "0",
                                                                                    switch_core_get_hostname()
                                                                                    );
                         }
                 }
                 break;
         case SWITCH_EVENT_DEL_SCHEDULE:
         case SWITCH_EVENT_EXE_SCHEDULE:
                 new_sql() = switch_mprintf("delete from tasks where task_id=%q and hostname='%q'",
                                                                    switch_event_get_header_nil(event, "task-id"), switch_core_get_hostname());
                 break;
         case SWITCH_EVENT_RE_SCHEDULE:
                 {
                         const char *id = switch_event_get_header(event, "task-id");
                         const char *manager = switch_event_get_header(event, "task-sql_manager");
 
                         if (id) {
                                 new_sql() = switch_mprintf("update tasks set task_desc='%q',task_group='%q', task_runtime=%q, task_sql_manager=%q where task_id=%q and hostname='%q'",
                                                                                    switch_event_get_header_nil(event, "task-desc"),
                                                                                    switch_event_get_header_nil(event, "task-group"),
                                                                                    switch_event_get_header_nil(event, "task-runtime"),
                                                                                    manager ? manager : "0",
                                                                                    id,
                                                                                    switch_core_get_hostname()
                                                                                    );
                         }
                 }
                 break;
         case SWITCH_EVENT_CHANNEL_DESTROY:
                 {
                         const char *uuid = switch_event_get_header(event, "unique-id");
                         
                         if (uuid) {
                                 new_sql() = switch_mprintf("delete from channels where uuid='%q'",
                                                                                    uuid);
 
                                 new_sql() = switch_mprintf("delete from calls where (caller_uuid='%q' or callee_uuid='%q')",
                                                                                    uuid, uuid);
 
                         }
                 }
                 break;
         case SWITCH_EVENT_CHANNEL_UUID:
                 {
                         new_sql() = switch_mprintf("update channels set uuid='%q' where uuid='%q'",
                                                                            switch_event_get_header_nil(event, "unique-id"),
                                                                            switch_event_get_header_nil(event, "old-unique-id")
                                                                            );
 
                         new_sql() = switch_mprintf("update channels set call_uuid='%q' where call_uuid='%q'",
                                                                            switch_event_get_header_nil(event, "unique-id"),
                                                                            switch_event_get_header_nil(event, "old-unique-id")
                                                                            );
                         break;
                 }
         case SWITCH_EVENT_CHANNEL_CREATE:
                 new_sql() = switch_mprintf("insert into channels (uuid,direction,created,created_epoch, name,state,callstate,dialplan,context,hostname,initial_cid_name,initial_cid_num,initial_ip_addr,initial_dest,initial_dialplan,initial_context) "
                                                                    "values('%q','%q','%q','%ld','%q','%q','%q','%q','%q','%q','%q','%q','%q','%q','%q','%q')",
                                                                    switch_event_get_header_nil(event, "unique-id"),
                                                                    switch_event_get_header_nil(event, "call-direction"),
                                                                    switch_event_get_header_nil(event, "event-date-local"),
                                                                    (long) switch_epoch_time_now(NULL),
                                                                    switch_event_get_header_nil(event, "channel-name"),
                                                                    switch_event_get_header_nil(event, "channel-state"),
                                                                    switch_event_get_header_nil(event, "channel-call-state"),
                                                                    switch_event_get_header_nil(event, "caller-dialplan"),
                                                                    switch_event_get_header_nil(event, "caller-context"), switch_core_get_switchname(),
                                                                    switch_event_get_header_nil(event, "caller-caller-id-name"),
                                                                    switch_event_get_header_nil(event, "caller-caller-id-number"),
                                                                    switch_event_get_header_nil(event, "caller-network-addr"),
                                                                    switch_event_get_header_nil(event, "caller-destination-number"),
                                                                    switch_event_get_header_nil(event, "caller-dialplan"),
                                                                    switch_event_get_header_nil(event, "caller-context")
                                                                    );
                 break;
         case SWITCH_EVENT_CHANNEL_ANSWER:
         case SWITCH_EVENT_CHANNEL_PROGRESS_MEDIA:
         case SWITCH_EVENT_CODEC:
                 new_sql() =
                         switch_mprintf
                         ("update channels set read_codec='%q',read_rate='%q',read_bit_rate='%q',write_codec='%q',write_rate='%q',write_bit_rate='%q' where uuid='%q'",
                          switch_event_get_header_nil(event, "channel-read-codec-name"),
                          switch_event_get_header_nil(event, "channel-read-codec-rate"),
                          switch_event_get_header_nil(event, "channel-read-codec-bit-rate"),
                          switch_event_get_header_nil(event, "channel-write-codec-name"),
                          switch_event_get_header_nil(event, "channel-write-codec-rate"),
                          switch_event_get_header_nil(event, "channel-write-codec-bit-rate"),
                          switch_event_get_header_nil(event, "unique-id"));
                 break;
         case SWITCH_EVENT_CHANNEL_HOLD:
         case SWITCH_EVENT_CHANNEL_UNHOLD:
         case SWITCH_EVENT_CHANNEL_EXECUTE: {
                 
                 new_sql() = switch_mprintf("update channels set application='%q',application_data='%q',"
                                                                    "presence_id='%q',presence_data='%q' where uuid='%q'",
                                                                    switch_event_get_header_nil(event, "application"),
                                                                    switch_event_get_header_nil(event, "application-data"),
                                                                    switch_event_get_header_nil(event, "channel-presence-id"),
                                                                    switch_event_get_header_nil(event, "channel-presence-data"),
                                                                    switch_event_get_header_nil(event, "unique-id")
                                                                    );
 
         }
                 break;
 
         case SWITCH_EVENT_CHANNEL_ORIGINATE:
                 {
                         if ((extra_cols = parse_presence_data_cols(event))) {
                                 new_sql() = switch_mprintf("update channels set "
                                                                                    "presence_id='%q',presence_data='%q', call_uuid='%q',%s where uuid='%q'",
                                                                                    switch_event_get_header_nil(event, "channel-presence-id"),
                                                                                    switch_event_get_header_nil(event, "channel-presence-data"),
                                                                                    switch_event_get_header_nil(event, "channel-call-uuid"),
                                                                                    extra_cols,
                                                                                    switch_event_get_header_nil(event, "unique-id"));
                                 free(extra_cols);
                         } else {
                                 new_sql() = switch_mprintf("update channels set "
                                                                                    "presence_id='%q',presence_data='%q', call_uuid='%q' where uuid='%q'",
                                                                                    switch_event_get_header_nil(event, "channel-presence-id"),
                                                                                    switch_event_get_header_nil(event, "channel-presence-data"),
                                                                                    switch_event_get_header_nil(event, "channel-call-uuid"),
                                                                                    switch_event_get_header_nil(event, "unique-id"));
                         }
 
                 }
 
                 break;
         case SWITCH_EVENT_CALL_UPDATE:
                 {
                         new_sql() = switch_mprintf("update channels set callee_name='%q',callee_num='%q',sent_callee_name='%q',sent_callee_num='%q',callee_direction='%q',"
                                                                            "cid_name='%q',cid_num='%q' where uuid='%s'",
                                                                            switch_event_get_header_nil(event, "caller-callee-id-name"),
                                                                            switch_event_get_header_nil(event, "caller-callee-id-number"),
                                                                            switch_event_get_header_nil(event, "sent-callee-id-name"),
                                                                            switch_event_get_header_nil(event, "sent-callee-id-number"),
                                                                            switch_event_get_header_nil(event, "direction"),
                                                                            switch_event_get_header_nil(event, "caller-caller-id-name"),
                                                                            switch_event_get_header_nil(event, "caller-caller-id-number"),
                                                                            switch_event_get_header_nil(event, "unique-id")
                                                                            );
                 }
                 break;
         case SWITCH_EVENT_CHANNEL_CALLSTATE:
                 {
                         char *num = switch_event_get_header_nil(event, "channel-call-state-number");
                         switch_channel_callstate_t callstate = CCS_DOWN;
 
                         if (num) {
                                 callstate = atoi(num);
                         }
 
                         if (callstate != CCS_DOWN && callstate != CCS_HANGUP) {
                                 if ((extra_cols = parse_presence_data_cols(event))) {
                                         new_sql() = switch_mprintf("update channels set callstate='%q',%s where uuid='%q'",
                                                                                            switch_event_get_header_nil(event, "channel-call-state"),
                                                                                            extra_cols,
                                                                                            switch_event_get_header_nil(event, "unique-id"));
                                         free(extra_cols);
                                 } else {
                                         new_sql() = switch_mprintf("update channels set callstate='%q' where uuid='%q'",
                                                                                            switch_event_get_header_nil(event, "channel-call-state"),
                                                                                            switch_event_get_header_nil(event, "unique-id"));
                                 }
                         }
 
                 }
                 break;
         case SWITCH_EVENT_CHANNEL_STATE:
                 {
                         char *state = switch_event_get_header_nil(event, "channel-state-number");
                         switch_channel_state_t state_i = CS_DESTROY;
 
                         if (!zstr(state)) {
                                 state_i = atoi(state);
                         }
 
                         switch (state_i) {
                         case CS_NEW:
                         case CS_DESTROY:
                         case CS_REPORTING:
 #ifndef SWITCH_DEPRECATED_CORE_DB
                         case CS_HANGUP: /* marked for deprication */
 #endif
                         case CS_INIT:
                                 break;
 #ifdef SWITCH_DEPRECATED_CORE_DB
                         case CS_HANGUP: /* marked for deprication */
                                 new_sql_a() = switch_mprintf("update channels set state='%s' where uuid='%s'",
                                                                                          switch_event_get_header_nil(event, "channel-state"),
                                                                                          switch_event_get_header_nil(event, "unique-id"));
                                 break;
 #endif
                         case CS_EXECUTE:
                                 if ((extra_cols = parse_presence_data_cols(event))) {
                                         new_sql() = switch_mprintf("update channels set state='%s',%s where uuid='%q'",
                                                                                            switch_event_get_header_nil(event, "channel-state"),
                                                                                            extra_cols,
                                                                                            switch_event_get_header_nil(event, "unique-id"));
                                         free(extra_cols);
                                         
                                 } else {
                                         new_sql() = switch_mprintf("update channels set state='%s' where uuid='%s'",
                                                                                            switch_event_get_header_nil(event, "channel-state"),
                                                                                            switch_event_get_header_nil(event, "unique-id"));
                                 }
                                 break;
                         case CS_ROUTING:
                                 if ((extra_cols = parse_presence_data_cols(event))) {
                                         new_sql() = switch_mprintf("update channels set state='%s',cid_name='%q',cid_num='%q',callee_name='%q',callee_num='%q',"
                                                                                            "sent_callee_name='%q',sent_callee_num='%q',"
                                                                                            "ip_addr='%s',dest='%q',dialplan='%q',context='%q',presence_id='%q',presence_data='%q',%s "
                                                                                            "where uuid='%s'",
                                                                                            switch_event_get_header_nil(event, "channel-state"),
                                                                                            switch_event_get_header_nil(event, "caller-caller-id-name"),
                                                                                            switch_event_get_header_nil(event, "caller-caller-id-number"),
                                                                                            switch_event_get_header_nil(event, "caller-callee-id-name"),
                                                                                            switch_event_get_header_nil(event, "caller-callee-id-number"),
                                                                                            switch_event_get_header_nil(event, "sent-callee-id-name"),
                                                                                            switch_event_get_header_nil(event, "sent-callee-id-number"),
                                                                                            switch_event_get_header_nil(event, "caller-network-addr"),
                                                                                            switch_event_get_header_nil(event, "caller-destination-number"),
                                                                                            switch_event_get_header_nil(event, "caller-dialplan"),
                                                                                            switch_event_get_header_nil(event, "caller-context"),
                                                                                            switch_event_get_header_nil(event, "channel-presence-id"),
                                                                                            switch_event_get_header_nil(event, "channel-presence-data"),
                                                                                            extra_cols,
                                                                                            switch_event_get_header_nil(event, "unique-id"));
                                         free(extra_cols);
                                 } else {
                                         new_sql() = switch_mprintf("update channels set state='%s',cid_name='%q',cid_num='%q',callee_name='%q',callee_num='%q',"
                                                                                            "sent_callee_name='%q',sent_callee_num='%q',"
                                                                                            "ip_addr='%s',dest='%q',dialplan='%q',context='%q',presence_id='%q',presence_data='%q' "
                                                                                            "where uuid='%s'",
                                                                                            switch_event_get_header_nil(event, "channel-state"),
                                                                                            switch_event_get_header_nil(event, "caller-caller-id-name"),
                                                                                            switch_event_get_header_nil(event, "caller-caller-id-number"),
                                                                                            switch_event_get_header_nil(event, "caller-callee-id-name"),
                                                                                            switch_event_get_header_nil(event, "caller-callee-id-number"),
                                                                                            switch_event_get_header_nil(event, "sent-callee-id-name"),
                                                                                            switch_event_get_header_nil(event, "sent-callee-id-number"),
                                                                                            switch_event_get_header_nil(event, "caller-network-addr"),
                                                                                            switch_event_get_header_nil(event, "caller-destination-number"),
                                                                                            switch_event_get_header_nil(event, "caller-dialplan"),
                                                                                            switch_event_get_header_nil(event, "caller-context"),
                                                                                            switch_event_get_header_nil(event, "channel-presence-id"),
                                                                                            switch_event_get_header_nil(event, "channel-presence-data"),
                                                                                            switch_event_get_header_nil(event, "unique-id"));
                                 }
                                 break;
                         default:
                                 new_sql() = switch_mprintf("update channels set state='%s' where uuid='%s'",
                                                                                    switch_event_get_header_nil(event, "channel-state"),
                                                                                    switch_event_get_header_nil(event, "unique-id"));
                                 break;
                         }
 
                         break;
 
 
                 }
         case SWITCH_EVENT_CHANNEL_BRIDGE:
                 {
                         const char *a_uuid, *b_uuid, *uuid;
 
                         a_uuid = switch_event_get_header(event, "Bridge-A-Unique-ID");
                         b_uuid = switch_event_get_header(event, "Bridge-B-Unique-ID");
                         uuid = switch_event_get_header(event, "unique-id");
 
                         if (zstr(a_uuid) || zstr(b_uuid)) {
                                 a_uuid = switch_event_get_header_nil(event, "caller-unique-id");
                                 b_uuid = switch_event_get_header_nil(event, "other-leg-unique-id");
                         }
 
                         if (uuid && (extra_cols = parse_presence_data_cols(event))) {
                                 new_sql() = switch_mprintf("update channels set %s where uuid='%s'", extra_cols, uuid);
                                 switch_safe_free(extra_cols);
                         } 
 
                         new_sql() = switch_mprintf("update channels set call_uuid='%q' where uuid='%s' or uuid='%s'",
                                                                            switch_event_get_header_nil(event, "channel-call-uuid"), a_uuid, b_uuid);
                         
 
                         new_sql() = switch_mprintf("insert into calls (call_uuid,call_created,call_created_epoch,"
                                                                            "caller_uuid,callee_uuid,hostname) "
                                                                            "values ('%s','%s','%ld','%q','%q','%q')",
                                                                            switch_event_get_header_nil(event, "channel-call-uuid"),
                                                                            switch_event_get_header_nil(event, "event-date-local"),
                                                                            (long) switch_epoch_time_now(NULL),
                                                                            a_uuid,
                                                                            b_uuid,
                                                                            switch_core_get_switchname()
                                                                            );
                 }
                 break;
         case SWITCH_EVENT_CHANNEL_UNBRIDGE:
                 {
                         char *cuuid = switch_event_get_header_nil(event, "caller-unique-id");
                         char *uuid = switch_event_get_header(event, "unique-id");
 
                         if (uuid && (extra_cols = parse_presence_data_cols(event))) {
                                 new_sql() = switch_mprintf("update channels set %s where uuid='%s'", extra_cols, uuid);
                                 switch_safe_free(extra_cols);
                         } 
 
                         new_sql() = switch_mprintf("update channels set call_uuid=uuid where call_uuid='%s'",
                                                                            switch_event_get_header_nil(event, "channel-call-uuid"));
                         
                         new_sql() = switch_mprintf("delete from calls where (caller_uuid='%q' or callee_uuid='%q')",
                                                                            cuuid, cuuid);
                         break;
                 }
         case SWITCH_EVENT_SHUTDOWN:
                 new_sql() = switch_mprintf("delete from channels where hostname='%q';"
                                                                    "delete from interfaces where hostname='%q';"
                                                                    "delete from calls where hostname='%q'",
                                                                    switch_core_get_switchname(), switch_core_get_hostname(), switch_core_get_switchname()
                                                                    );
                 break;
         case SWITCH_EVENT_LOG:
                 return;
         case SWITCH_EVENT_MODULE_LOAD:
                 {
                         const char *type = switch_event_get_header_nil(event, "type");
                         const char *name = switch_event_get_header_nil(event, "name");
                         const char *description = switch_event_get_header_nil(event, "description");
                         const char *syntax = switch_event_get_header_nil(event, "syntax");
                         const char *key = switch_event_get_header_nil(event, "key");
                         const char *filename = switch_event_get_header_nil(event, "filename");
                         if (!zstr(type) && !zstr(name)) {
                                 new_sql() =
                                         switch_mprintf
                                         ("insert into interfaces (type,name,description,syntax,ikey,filename,hostname) values('%q','%q','%q','%q','%q','%q','%q')", type, name,
                                          switch_str_nil(description), switch_str_nil(syntax), switch_str_nil(key), switch_str_nil(filename),
                                          switch_core_get_hostname()
                                          );
                         }
                         break;
                 }
         case SWITCH_EVENT_MODULE_UNLOAD:
                 {
                         const char *type = switch_event_get_header_nil(event, "type");
                         const char *name = switch_event_get_header_nil(event, "name");
                         if (!zstr(type) && !zstr(name)) {
                                 new_sql() = switch_mprintf("delete from interfaces where type='%q' and name='%q' and hostname='%q'", type, name,
                                                                                    switch_core_get_hostname());
                         }
                         break;
                 }
         case SWITCH_EVENT_CALL_SECURE:
                 {
                         const char *type = switch_event_get_header_nil(event, "secure_type");
                         switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Secure Type: %s\n", type);
                         if (zstr(type)) {
                                 break;
                         }
                         new_sql() = switch_mprintf("update channels set secure='%s' where uuid='%s'",
                                                                            type, switch_event_get_header_nil(event, "caller-unique-id")
                                                                            );
                         break;
                 }
         case SWITCH_EVENT_NAT:
                 {
                         const char *op = switch_event_get_header_nil(event, "op");
                         switch_bool_t sticky = switch_true(switch_event_get_header_nil(event, "sticky"));
                         if (!strcmp("add", op)) {
                                 new_sql() = switch_mprintf("insert into nat (port, proto, sticky, hostname) values (%s, %s, %d,'%q')",
                                                                                    switch_event_get_header_nil(event, "port"),
                                                                                    switch_event_get_header_nil(event, "proto"), sticky, switch_core_get_hostname()
                                                                                    );
                         } else if (!strcmp("del", op)) {
                                 new_sql() = switch_mprintf("delete from nat where port=%s and proto=%s and hostname='%q'",
                                                                                    switch_event_get_header_nil(event, "port"),
                                                                                    switch_event_get_header_nil(event, "proto"), switch_core_get_hostname());
                         } else if (!strcmp("status", op)) {
                                 /* call show nat api */
                         } else if (!strcmp("status_response", op)) {
                                 /* ignore */
                         } else {
                                 switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Unknown op for SWITCH_EVENT_NAT: %s\n", op);
                         }
                         break;
                 }
         default:
                 break;
         }
 
         if (sql_idx) {
                 int i = 0;
                 
 
                 for (i = 0; i < sql_idx; i++) {
                         if (switch_stristr("update channels", sql[i]) || switch_stristr("delete from channels", sql[i])) {
                                 switch_sql_queue_manager_push(sql_manager.qm, sql[i], 1, SWITCH_FALSE);
                         } else {
                                 switch_sql_queue_manager_push(sql_manager.qm, sql[i], 0, SWITCH_FALSE);
                         }
                         sql[i] = NULL;
                 }
         }
 }

static switch_cache_db_handle_t* create_handle ( switch_cache_db_handle_type_t type )

static

Definition at line 80 of file switch_core_sqldb.c.

References switch_cache_db_handle::mutex, switch_cache_db_handle::pool, pool, switch_core_alloc, switch_core_new_memory_pool, switch_mutex_init(), SWITCH_MUTEX_NESTED, and switch_cache_db_handle::type.

Referenced by _switch_cache_db_get_db_handle().

 {
         switch_cache_db_handle_t *new_dbh = NULL;
         switch_memory_pool_t *pool = NULL;
 
         switch_core_new_memory_pool(&pool);
         new_dbh = switch_core_alloc(pool, sizeof(*new_dbh));
         new_dbh->pool = pool;
         new_dbh->type = type;
         switch_mutex_init(&new_dbh->mutex, SWITCH_MUTEX_NESTED, new_dbh->pool);
 
         return new_dbh;
 }

static void del_handle ( switch_cache_db_handle_t * dbh )

static

Definition at line 117 of file switch_core_sqldb.c.

References switch_cache_db_handle::next, sql_manager, switch_mutex_lock(), and switch_mutex_unlock().

Referenced by sql_close().

 {
         switch_cache_db_handle_t *dbh_ptr, *last = NULL;
 
         switch_mutex_lock(sql_manager.dbh_mutex);
         for (dbh_ptr = sql_manager.handle_pool; dbh_ptr; dbh_ptr = dbh_ptr->next) {
                 if (dbh_ptr == dbh) {
                         if (last) {
                                 last->next = dbh_ptr->next;
                         } else {
                                 sql_manager.handle_pool = dbh_ptr->next;
                         }
                         sql_manager.total_handles--;
                         break;
                 }
                 
                 last = dbh_ptr;
         }
         switch_mutex_unlock(sql_manager.dbh_mutex);
 }

static void do_flush	(	switch_sql_queue_manager_t *	qm,
		int	i,
		switch_cache_db_handle_t *	dbh
	)

static

Definition at line 1597 of file switch_core_sqldb.c.

References switch_sql_queue_manager::mutex, switch_sql_queue_manager::sql_queue, switch_cache_db_execute_sql(), switch_mutex_lock(), switch_mutex_unlock(), switch_queue_trypop(), switch_safe_free, and SWITCH_STATUS_SUCCESS.

Referenced by switch_sql_queue_manager_destroy(), switch_sql_queue_manager_pause(), and switch_user_sql_thread().

 {
         void *pop = NULL;
         switch_queue_t *q = qm->sql_queue[i];
 
         switch_mutex_lock(qm->mutex);
         while (switch_queue_trypop(q, &pop) == SWITCH_STATUS_SUCCESS) {
                 if (pop) {
                         if (dbh) {
                                 switch_cache_db_execute_sql(dbh, (char *) pop, NULL);
                         }
                         switch_safe_free(pop);
                 }
         }
         switch_mutex_unlock(qm->mutex);
 
 }

static uint32_t do_trans ( switch_sql_queue_manager_t * qm )

static

Definition at line 1902 of file switch_core_sqldb.c.

Referenced by switch_user_sql_thread().

 {
         char *errmsg = NULL;
         void *pop;
         switch_status_t status;
         uint32_t ttl = 0;
         switch_mutex_t *io_mutex = qm->event_db->io_mutex;
         uint32_t i;
 
         if (io_mutex) switch_mutex_lock(io_mutex);
 
         if (!zstr(qm->pre_trans_execute)) {
                 switch_cache_db_execute_sql_real(qm->event_db, qm->pre_trans_execute, &errmsg);
                 if (errmsg) {
                         switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "SQL PRE TRANS EXEC %s [%s]\n", qm->pre_trans_execute, errmsg);
                         switch_safe_free(errmsg);
                 }
         }
 
         switch(qm->event_db->type) {
         case SCDB_TYPE_CORE_DB:
                 {
                         switch_cache_db_execute_sql_real(qm->event_db, "BEGIN EXCLUSIVE", &errmsg);
                 }
                 break;
         case SCDB_TYPE_ODBC:
                 {
                         switch_odbc_status_t result;
                         
                         if ((result = switch_odbc_SQLSetAutoCommitAttr(qm->event_db->native_handle.odbc_dbh, 0)) != SWITCH_ODBC_SUCCESS) {
                                 char tmp[100];
                                 switch_snprintfv(tmp, sizeof(tmp), "%q-%i", "Unable to Set AutoCommit Off", result);
                                 errmsg = strdup(tmp);
                         }
                 }
                 break;
         case SCDB_TYPE_PGSQL:
                 {
                         switch_pgsql_status_t result;
                         
                         if ((result = switch_pgsql_SQLSetAutoCommitAttr(qm->event_db->native_handle.pgsql_dbh, 0)) != SWITCH_PGSQL_SUCCESS) {
                                 char tmp[100];
                                 switch_snprintfv(tmp, sizeof(tmp), "%q-%i", "Unable to Set AutoCommit Off", result);
                                 errmsg = strdup(tmp);
                         }
                 }
                 break;
         }
 
         if (errmsg) {
                 switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "ERROR [%s]\n", errmsg);
                 switch_safe_free(errmsg);
                 goto end;
         }
 
 
         if (!zstr(qm->inner_pre_trans_execute)) {
                 switch_cache_db_execute_sql_real(qm->event_db, qm->inner_pre_trans_execute, &errmsg);
                 if (errmsg) {
                         switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "SQL PRE TRANS EXEC %s [%s]\n", qm->inner_pre_trans_execute, errmsg);
                         switch_safe_free(errmsg);
                 }
         }
 
 
         while(qm->max_trans == 0 || ttl <= qm->max_trans) {
                 pop = NULL;
 
                 for (i = 0; (qm->max_trans == 0 || ttl <= qm->max_trans) && (i < qm->numq); i++) {
                         switch_mutex_lock(qm->mutex);
                         switch_queue_trypop(qm->sql_queue[i], &pop);
                         switch_mutex_unlock(qm->mutex);
                         if (pop) break;
                 }
 
                 if (pop) {
                         if ((status = switch_cache_db_execute_sql(qm->event_db, (char *) pop, NULL)) == SWITCH_STATUS_SUCCESS) {
                                 switch_mutex_lock(qm->mutex);
                                 qm->pre_written[i]++;
                                 switch_mutex_unlock(qm->mutex);
                                 ttl++;
                         }
                         switch_safe_free(pop);
                         if (status != SWITCH_STATUS_SUCCESS) break;
                 } else {
                         break;
                 }
         }
 
         if (!zstr(qm->inner_post_trans_execute)) {
                 switch_cache_db_execute_sql_real(qm->event_db, qm->inner_post_trans_execute, &errmsg);
                 if (errmsg) {
                         switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "SQL POST TRANS EXEC %s [%s]\n", qm->inner_post_trans_execute, errmsg);
                         switch_safe_free(errmsg);
                 }
         }
 
 
  end:
 
         switch(qm->event_db->type) {
         case SCDB_TYPE_CORE_DB:
                 {
                         switch_cache_db_execute_sql_real(qm->event_db, "COMMIT", NULL);
                 }
                 break;
         case SCDB_TYPE_ODBC:
                 {
                         switch_odbc_SQLEndTran(qm->event_db->native_handle.odbc_dbh, 1);
                         switch_odbc_SQLSetAutoCommitAttr(qm->event_db->native_handle.odbc_dbh, 1);
                 }
                 break;
         case SCDB_TYPE_PGSQL:
                 {
                         switch_pgsql_SQLEndTran(qm->event_db->native_handle.pgsql_dbh, 1);
                         switch_pgsql_SQLSetAutoCommitAttr(qm->event_db->native_handle.pgsql_dbh, 1);
                         switch_pgsql_finish_results(qm->event_db->native_handle.pgsql_dbh);
                 }
                 break;
         }
 
 
         if (!zstr(qm->post_trans_execute)) {
                 switch_cache_db_execute_sql_real(qm->event_db, qm->post_trans_execute, &errmsg);
                 if (errmsg) {
                         switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "SQL POST TRANS EXEC %s [%s]\n", qm->post_trans_execute, errmsg);
                         switch_safe_free(errmsg);
                 }
         }
 
 
         switch_mutex_lock(qm->mutex);
         for (i = 0; i < qm->numq; i++) {
                 qm->written[i] = qm->pre_written[i];
         }
         switch_mutex_unlock(qm->mutex);
 
 
         if (io_mutex) switch_mutex_unlock(io_mutex);
 
         return ttl;
 }

static switch_cache_db_handle_t* get_handle	(	const char *	db_str,
		const char *	user_str,
		const char *	thread_str
	)

static

Definition at line 138 of file switch_core_sqldb.c.

References CDF_PRUNE, switch_cache_db_handle::hash, hash, switch_cache_db_handle::last_user, switch_cache_db_handle::mutex, switch_cache_db_handle::next, SCDB_TYPE_PGSQL, sql_manager, switch_ci_hashfunc_default(), switch_mutex_lock(), switch_mutex_trylock(), switch_mutex_unlock(), switch_set_string, SWITCH_STATUS_SUCCESS, switch_test_flag, switch_cache_db_handle::thread_hash, switch_cache_db_handle::total_used_count, switch_cache_db_handle::type, and switch_cache_db_handle::use_count.

Referenced by _switch_cache_db_get_db_handle().

 {
         switch_ssize_t hlen = -1;
         unsigned long hash = 0, thread_hash = 0;
         switch_cache_db_handle_t *dbh_ptr, *r = NULL;
 
         hash = switch_ci_hashfunc_default(db_str, &hlen);
         thread_hash = switch_ci_hashfunc_default(thread_str, &hlen);
         
         switch_mutex_lock(sql_manager.dbh_mutex);
 
         for (dbh_ptr = sql_manager.handle_pool; dbh_ptr; dbh_ptr = dbh_ptr->next) {
                 if (dbh_ptr->thread_hash == thread_hash && dbh_ptr->hash == hash && !dbh_ptr->use_count &&
                         !switch_test_flag(dbh_ptr, CDF_PRUNE) && switch_mutex_trylock(dbh_ptr->mutex) == SWITCH_STATUS_SUCCESS) {
                         r = dbh_ptr;
                 }
         }
 
         if (!r) {
                 for (dbh_ptr = sql_manager.handle_pool; dbh_ptr; dbh_ptr = dbh_ptr->next) {
                         if (dbh_ptr->hash == hash && (dbh_ptr->type != SCDB_TYPE_PGSQL || !dbh_ptr->use_count) && !switch_test_flag(dbh_ptr, CDF_PRUNE) && 
                                 switch_mutex_trylock(dbh_ptr->mutex) == SWITCH_STATUS_SUCCESS) {
                                 r = dbh_ptr;
                                 break;
                         }
                 }       
         }
         
         if (r) {
                 r->use_count++;
                 r->total_used_count++;
                 sql_manager.total_used_handles++;
                 r->hash = switch_ci_hashfunc_default(db_str, &hlen);
                 r->thread_hash = thread_hash;
                 switch_set_string(r->last_user, user_str);
         }
 
         switch_mutex_unlock(sql_manager.dbh_mutex);
 
         return r;
         
 }

static int helper_callback	(	void *	pArg,
		int	argc,
		char **	argv,
		char **	columnNames
	)

static

Definition at line 1027 of file switch_core_sqldb.c.

References helper::callback, helper::pdata, switch_event_create_array_pair(), and switch_event_destroy().

Referenced by switch_cache_db_execute_sql_event_callback(), and switch_cache_db_execute_sql_event_callback_err().

 {
         struct helper *h = (struct helper *) pArg;
         int r = 0;
         switch_event_t *event;
 
         switch_event_create_array_pair(&event, columnNames, argv, argc);
 
         r = h->callback(h->pdata, event);
 
         switch_event_destroy(&event);
         
         return r;
 }

static switch_thread_data_t* new_job	(	switch_sql_queue_manager_t *	qm,
		const char *	sql,
		switch_core_db_callback_func_t	callback,
		switch_core_db_err_callback_func_t	err_callback,
		switch_core_db_event_callback_func_t	event_callback,
		switch_core_db_err_callback_func_t	event_err_callback,
		void *	pdata
	)

static

Definition at line 1517 of file switch_core_sqldb.c.

References db_job::callback, db_job::err_callback, db_job::event_callback, db_job::event_err_callback, switch_thread_data_s::func, switch_thread_data_s::obj, db_job::pdata, pool, db_job::pool, qm, db_job::qm, db_job::sql, sql_in_thread(), switch_core_alloc, switch_core_new_memory_pool, and switch_core_strdup.

Referenced by switch_sql_queue_manager_execute_sql_callback(), switch_sql_queue_manager_execute_sql_callback_err(), switch_sql_queue_manager_execute_sql_event_callback(), and switch_sql_queue_manager_execute_sql_event_callback_err().

 {
         switch_memory_pool_t *pool;
         switch_thread_data_t *td;
         struct db_job *job;
         switch_core_new_memory_pool(&pool);
 
         td = switch_core_alloc(pool, sizeof(*td));
         job = switch_core_alloc(pool, sizeof(*job));
 
         td->func = sql_in_thread;
         td->obj = job;
 
         job->sql = switch_core_strdup(pool, sql);
         job->qm = qm;
 
         if (callback) {
                 job->callback = callback;
                 job->err_callback = err_callback;
         } else if (event_callback) {
                 job->event_callback = event_callback;
                 job->event_err_callback = event_err_callback;
         }
 
         job->pdata = pdata;
         job->pool = pool;
 
         return td;
 }

static char* parse_presence_data_cols ( switch_event_t * event )

static

Definition at line 2157 of file switch_core_sqldb.c.

References switch_stream_handle::data, end_of, if(), switch_event_get_header, switch_event_get_header_nil, switch_safe_free, switch_snprintfv(), switch_split, SWITCH_STANDARD_STREAM, switch_stream_handle::write_function, and zstr.

Referenced by core_event_handler().

 {
         char *cols[128] = { 0 };
         int col_count = 0;
         char *data_copy;
         switch_stream_handle_t stream = { 0 };
         int i;
         char *r;
         char col_name[128] = "";
         const char *data = switch_event_get_header(event, "presence-data-cols");
 
         if (zstr(data)) {
                 return NULL;
         }
 
         data_copy = strdup(data);
         
         col_count = switch_split(data_copy, ':', cols);
 
         SWITCH_STANDARD_STREAM(stream);
 
         for (i = 0; i < col_count; i++) {
                 const char *val = NULL;
 
                 switch_snprintfv(col_name, sizeof(col_name), "PD-%q", cols[i]);
                 val = switch_event_get_header_nil(event, col_name);
                 if (zstr(val)) {
                         stream.write_function(&stream, "%q=NULL,", cols[i]);
                 } else {
                         stream.write_function(&stream, "%q='%q',", cols[i], val);
                 }
         }
 
         r = (char *) stream.data;
 
         if (end_of(r) == ',') {
                 end_of(r) = '\0';
         }
 
         switch_safe_free(data_copy);
         
         return r;
         
 }

static uint32_t qm_ttl ( switch_sql_queue_manager_t * qm )

static

Definition at line 1456 of file switch_core_sqldb.c.

References switch_sql_queue_manager::numq, switch_sql_queue_manager::sql_queue, and switch_queue_size().

Referenced by switch_user_sql_thread().

 {
         uint32_t ttl = 0;
         uint32_t i;
 
         for (i = 0; i < qm->numq; i++) {
                 ttl += switch_queue_size(qm->sql_queue[i]);
         }
 
         return ttl;
 }

static int qm_wake ( switch_sql_queue_manager_t * qm )

static

Definition at line 1429 of file switch_core_sqldb.c.

References switch_sql_queue_manager::cond, switch_sql_queue_manager::cond2_mutex, switch_sql_queue_manager::cond_mutex, switch_cond_next(), switch_mutex_trylock(), switch_mutex_unlock(), SWITCH_STATUS_SUCCESS, and switch_thread_cond_signal().

Referenced by switch_sql_queue_manager_push(), switch_sql_queue_manager_push_confirm(), switch_sql_queue_manager_resume(), and switch_sql_queue_manager_stop().

 {
         switch_status_t status;
         int tries = 0;
 
  top:
         
         status = switch_mutex_trylock(qm->cond_mutex);
 
         if (status == SWITCH_STATUS_SUCCESS) {
                 switch_thread_cond_signal(qm->cond);
                 switch_mutex_unlock(qm->cond_mutex);
                 return 1;
         } else {
                 if (switch_mutex_trylock(qm->cond2_mutex) == SWITCH_STATUS_SUCCESS) {
                         switch_mutex_unlock(qm->cond2_mutex);
                 } else {
                         if (++tries < 10) {
                                 switch_cond_next();
                                 goto top;
                         }
                 }
         }
 
         return 0;
 }

static int recover_callback	(	void *	pArg,
		int	argc,
		char **	argv,
		char **	columnNames
	)

static

Definition at line 2950 of file switch_core_sqldb.c.

References CF_RECOVERING, CF_RECOVERING_BRIDGE, switch_core_session::channel, CS_INIT, ep, switch_xml::next, switch_endpoint_interface::recover_callback, switch_caller_extension_add_application(), switch_caller_extension_new(), switch_channel_get_name(), switch_channel_get_partner_uuid(), switch_channel_get_variable, SWITCH_CHANNEL_LOG, SWITCH_CHANNEL_SESSION_LOG, switch_channel_set_caller_extension(), switch_channel_set_flag, switch_channel_set_state, switch_channel_test_flag(), switch_core_get_secondary_recover_callback(), switch_core_media_recover_session(), switch_core_session_get_channel(), switch_core_session_request_xml(), switch_core_session_thread_launch(), switch_loadable_module_get_endpoint_interface(), SWITCH_LOG_NOTICE, switch_log_printf(), SWITCH_LOG_WARNING, SWITCH_TRUE, switch_xml_attr_soft(), switch_xml_child(), switch_xml_free(), switch_xml_parse_str_dynamic(), and UNPROTECT_INTERFACE.

Referenced by switch_core_recovery_recover().

 {
         int *rp = (int *) pArg;
         switch_xml_t xml;
         switch_endpoint_interface_t *ep;
         switch_core_session_t *session;
 
         if (argc < 4) {
                 return 0;
         }
         
         if (!(xml = switch_xml_parse_str_dynamic(argv[4], SWITCH_TRUE))) {
                 switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "XML ERROR\n");
                 return 0;
         }
 
         if (!(ep = switch_loadable_module_get_endpoint_interface(argv[0]))) {
                 switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "EP ERROR\n");
                 return 0;
         }
 
         if (!(session = switch_core_session_request_xml(ep, NULL, xml))) {
                 switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "Invalid cdr data, call not recovered\n");
                 goto end;
         }
 
         if (ep->recover_callback) {
                 switch_caller_extension_t *extension = NULL;
                 switch_channel_t *channel = switch_core_session_get_channel(session);
                 int r = 0;
 
                 if ((r = ep->recover_callback(session)) > 0) {
                         const char *cbname;
 
                         switch_channel_set_flag(session->channel, CF_RECOVERING);
                         
 
                         if (switch_channel_get_partner_uuid(channel)) {
                                 switch_channel_set_flag(channel, CF_RECOVERING_BRIDGE);
                         }
 
                         switch_core_media_recover_session(session);
 
                         if ((cbname = switch_channel_get_variable(channel, "secondary_recovery_module"))) {
                                 switch_core_recover_callback_t recover_callback;
                                 
                                 if ((recover_callback = switch_core_get_secondary_recover_callback(cbname))) {
                                         r = recover_callback(session);
                                 }
                         }
                         
                         
                 }
                 
                 if (r > 0) {
 
                         if (!switch_channel_test_flag(channel, CF_RECOVERING_BRIDGE)) {
                                 switch_xml_t callflow, param, x_extension;
                                 if ((extension = switch_caller_extension_new(session, "recovery", "recovery")) == 0) {
                                         abort();
                                 }
 
                                 if ((callflow = switch_xml_child(xml, "callflow")) && (x_extension = switch_xml_child(callflow, "extension"))) {
                                         for (param = switch_xml_child(x_extension, "application"); param; param = param->next) {
                                                 const char *var = switch_xml_attr_soft(param, "app_name");
                                                 const char *val = switch_xml_attr_soft(param, "app_data");
                                                 /* skip announcement type apps */
                                                 if (strcasecmp(var, "speak") && strcasecmp(var, "playback") && strcasecmp(var, "gentones") && strcasecmp(var, "say")) {
                                                         switch_caller_extension_add_application(session, extension, var, val);
                                                 }
                                         }
                                 }
 
                                 switch_channel_set_caller_extension(channel, extension);
                         }
 
                         switch_channel_set_state(channel, CS_INIT);
                         switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_NOTICE, 
                                                           "Resurrecting fallen channel %s\n", switch_channel_get_name(channel));
                         switch_core_session_thread_launch(session);
 
                         *rp = (*rp) + 1;
                         
                 }
 
         } else {
                 switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "Endpoint %s has no recovery function\n", argv[0]);
         }
 
 
  end:
 
         UNPROTECT_INTERFACE(ep);
 
         switch_xml_free(xml);
 
         return 0;
 }

static void sql_close ( time_t prune )

static

Definition at line 212 of file switch_core_sqldb.c.

Referenced by switch_cache_db_flush_handles(), switch_core_sql_db_thread(), and switch_core_sqldb_stop().

 {
         switch_cache_db_handle_t *dbh = NULL;
         int locked = 0;
         int sanity = 10000;
 
         switch_mutex_lock(sql_manager.dbh_mutex);
  top:
         locked = 0;
 
         for (dbh = sql_manager.handle_pool; dbh; dbh = dbh->next) {
                 time_t diff = 0;
 
                 if (prune > 0 && prune > dbh->last_used) {
                         diff = (time_t) prune - dbh->last_used;
                 }
 
                 if (prune > 0 && (dbh->use_count || (diff < SQL_CACHE_TIMEOUT && !switch_test_flag(dbh, CDF_PRUNE)))) {
                         continue;
                 }
 
                 if (switch_mutex_trylock(dbh->mutex) == SWITCH_STATUS_SUCCESS) {
                         switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG10, "Dropping idle DB connection %s\n", dbh->name);
 
                         switch (dbh->type) {
                         case SCDB_TYPE_PGSQL:
                                 {
                                         switch_pgsql_handle_destroy(&dbh->native_handle.pgsql_dbh);
                                 }
                                 break;
                         case SCDB_TYPE_ODBC:
                                 {
                                         switch_odbc_handle_destroy(&dbh->native_handle.odbc_dbh);
                                 }
                                 break;
                         case SCDB_TYPE_CORE_DB:
                                 {
                                         switch_core_db_close(dbh->native_handle.core_db_dbh);
                                         dbh->native_handle.core_db_dbh = NULL;
                                 }
                                 break;
                         }
 
                         del_handle(dbh);
                         switch_mutex_unlock(dbh->mutex);
                         switch_core_destroy_memory_pool(&dbh->pool);
                         goto top;
 
                 } else {
                         if (!prune) {
                                 if (!sanity) {
                                         switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "SANITY CHECK FAILED!  Handle %s (%s;%s) was not properly released.\n", 
                                                                           dbh->name, dbh->creator, dbh->last_user);
                                 } else {
                                         locked++;
                                 }
                         }
                         continue;
                 }
                 
         }
 
         if (locked) {
                 if (!prune) {
                         switch_cond_next();
                         if (sanity) sanity--;
                 }
                 goto top;
         }
 
         switch_mutex_unlock(sql_manager.dbh_mutex);
 }

static void* SWITCH_THREAD_FUNC sql_in_thread	(	switch_thread_t *	thread,
		void *	obj
	)

static

Definition at line 1480 of file switch_core_sqldb.c.

References db_job::callback, dbh, switch_sql_queue_manager::dsn, db_job::err_callback, db_job::event_callback, db_job::event_err_callback, db_job::pdata, pool, db_job::pool, db_job::qm, db_job::sql, switch_cache_db_execute_sql_callback(), switch_cache_db_execute_sql_callback_err(), switch_cache_db_execute_sql_event_callback(), switch_cache_db_execute_sql_event_callback_err(), switch_cache_db_get_db_handle_dsn, switch_cache_db_release_db_handle(), SWITCH_CHANNEL_LOG, switch_core_destroy_memory_pool, SWITCH_LOG_ERROR, switch_log_printf(), switch_safe_free, and SWITCH_STATUS_SUCCESS.

Referenced by new_job().

 {
         struct db_job *job = (struct db_job *) obj;
         switch_memory_pool_t *pool = job->pool;
         char *err = NULL;
         switch_cache_db_handle_t *dbh;
 
 
         if (switch_cache_db_get_db_handle_dsn(&dbh, job->qm->dsn) != SWITCH_STATUS_SUCCESS) {
                 switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Cannot connect DSN %s\n", job->qm->dsn);
                 return NULL;
         }
 
         if (job->callback && !job->err_callback) {
                 switch_cache_db_execute_sql_callback(dbh, job->sql, job->callback, job->pdata, &err);
         } else if (job->callback && job->err_callback) {
                 switch_cache_db_execute_sql_callback_err(dbh, job->sql, job->callback, job->err_callback, job->pdata, &err);
         } else if (job->event_callback && !job->event_err_callback) {
                 switch_cache_db_execute_sql_event_callback(dbh, job->sql, job->event_callback, job->pdata, &err);
         } else if (job->event_callback && job->event_err_callback) {
                 switch_cache_db_execute_sql_event_callback_err(dbh, job->sql, job->event_callback, job->event_err_callback, job->pdata, &err);
         }
 
         if (err) {
                 switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "SQL ERR: [%s] %s\n", job->sql, err);
                 switch_safe_free(err);
         }
         
         switch_cache_db_release_db_handle(&dbh);
         
         if (pool) {
                 switch_core_destroy_memory_pool(&pool);
         }
 
         return NULL;
 }

int switch_cache_db_affected_rows ( switch_cache_db_handle_t * dbh )

Get the affected rows of the last performed query.

Parameters

[in]	dbh	The handle
[out]	the	number of affected rows

Definition at line 688 of file switch_core_sqldb.c.

References SCDB_TYPE_CORE_DB, SCDB_TYPE_ODBC, SCDB_TYPE_PGSQL, switch_core_db_changes(), switch_odbc_handle_affected_rows(), and switch_pgsql_handle_affected_rows().

 {
         switch (dbh->type) {
         case SCDB_TYPE_CORE_DB:
                 {
                         return switch_core_db_changes(dbh->native_handle.core_db_dbh);
                 }
                 break;
         case SCDB_TYPE_ODBC:
                 {
                         return switch_odbc_handle_affected_rows(dbh->native_handle.odbc_dbh);
                 }
                 break;
         case SCDB_TYPE_PGSQL:
                 {
                         return switch_pgsql_handle_affected_rows(dbh->native_handle.pgsql_dbh);
                 }
                 break;
         }
         return 0;
 }

switch_status_t switch_cache_db_create_schema	(	switch_cache_db_handle_t *	dbh,
		char *	sql,
		char **	err
	)

Executes the create schema sql.

Parameters

[in]	dbh	The handle
[in]	sql	- sql to run
[out]	err	- Error if it exists

Definition at line 1271 of file switch_core_sqldb.c.

References runtime, SCF_AUTO_SCHEMAS, switch_assert, switch_cache_db_execute_sql(), SWITCH_STATUS_SUCCESS, and switch_test_flag.

Referenced by switch_core_sqldb_start().

 {
         switch_status_t r = SWITCH_STATUS_SUCCESS;
 
         switch_assert(sql != NULL);
 
         if (switch_test_flag((&runtime), SCF_AUTO_SCHEMAS)) {
                 r = switch_cache_db_execute_sql(dbh, sql, err);
         }
 
         return r;
 }

void switch_cache_db_dismiss_db_handle ( switch_cache_db_handle_t ** dbh )

Returns the handle to the pool, immediately available for other threads to use.

Parameters

[in] The handle

Definition at line 329 of file switch_core_sqldb.c.

References switch_cache_db_release_db_handle().

 {
         switch_cache_db_release_db_handle(dbh);
 }

switch_status_t switch_cache_db_execute_sql	(	switch_cache_db_handle_t *	dbh,
		char *	sql,
		char **	err
	)

Executes the sql.

Parameters

[in]	dbh	The handle
[in]	sql	- sql to run
[out]	err	- Error if it exists

Definition at line 666 of file switch_core_sqldb.c.

References io_mutex, switch_cache_db_execute_sql_chunked(), switch_mutex_lock(), switch_mutex_unlock(), and SWITCH_STATUS_FALSE.

Referenced by do_flush(), do_trans(), switch_cache_db_create_schema(), switch_cache_db_persistant_execute_trans_full(), switch_cache_db_test_reactive(), switch_core_recovery_flush(), switch_core_recovery_recover(), switch_core_sqldb_start(), switch_sql_queue_manager_push_confirm(), and switch_user_sql_thread().

 {
         switch_status_t status = SWITCH_STATUS_FALSE;
         switch_mutex_t *io_mutex = dbh->io_mutex;
 
         if (io_mutex) switch_mutex_lock(io_mutex);
 
         switch (dbh->type) {
         default:
                 {
                         status = switch_cache_db_execute_sql_chunked(dbh, (char *) sql, 32768, err);
                 }
                 break;
         }
 
         if (io_mutex) switch_mutex_unlock(io_mutex);
 
         return status;
 
 }

char* switch_cache_db_execute_sql2str	(	switch_cache_db_handle_t *	dbh,
		char *	sql,
		char *	str,
		size_t	len,
		char **	err
	)

Executes the sql and returns the result as a string.

Parameters

[in]	dbh	The handle
[in]	sql	- sql to run
[out]	str	- buffer for result
[in]	len	- length of str buffer
[out]	err	- Error if it exists

Definition at line 734 of file switch_core_sqldb.c.

References io_mutex, memset(), running, SCDB_TYPE_CORE_DB, SCDB_TYPE_ODBC, SCDB_TYPE_PGSQL, SWITCH_CHANNEL_LOG, switch_cond_next(), switch_copy_string(), SWITCH_CORE_DB_BUSY, switch_core_db_column_count(), switch_core_db_column_text(), switch_core_db_finalize(), switch_core_db_prepare(), SWITCH_CORE_DB_ROW, switch_core_db_step(), SWITCH_LOG_ERROR, switch_log_printf(), switch_mutex_lock(), switch_mutex_unlock(), switch_odbc_handle_exec_string(), switch_pgsql_handle_exec_string, SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

 {
         switch_status_t status = SWITCH_STATUS_FALSE;
         switch_mutex_t *io_mutex = dbh->io_mutex;
 
         if (io_mutex) switch_mutex_lock(io_mutex);
 
         memset(str, 0, len);
 
         switch (dbh->type) {
         case SCDB_TYPE_CORE_DB:
                 {
                         switch_core_db_stmt_t *stmt;
 
                         if (switch_core_db_prepare(dbh->native_handle.core_db_dbh, sql, -1, &stmt, 0)) {
                                 switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Statement Error [%s]!\n", sql);
                                 goto end;
                         } else {
                                 int running = 1;
                                 int colcount;
 
                                 while (running < 5000) {
                                         int result = switch_core_db_step(stmt);
                                         const unsigned char *txt;
 
                                         if (result == SWITCH_CORE_DB_ROW) {
                                                 if ((colcount = switch_core_db_column_count(stmt)) > 0) {
                                                         if ((txt = switch_core_db_column_text(stmt, 0))) {
                                                                 switch_copy_string(str, (char *) txt, len);
                                                                 status = SWITCH_STATUS_SUCCESS;
                                                         } else {
                                                                 goto end;
                                                         }
                                                 }
                                                 break;
                                         } else if (result == SWITCH_CORE_DB_BUSY) {
                                                 running++;
                                                 switch_cond_next();
                                                 continue;
                                         }
                                         break;
                                 }
 
                                 switch_core_db_finalize(stmt);
                         }
                 }
                 break;
         case SCDB_TYPE_ODBC:
                 {
                         status = switch_odbc_handle_exec_string(dbh->native_handle.odbc_dbh, sql, str, len, err);
                 }
                 break;
         case SCDB_TYPE_PGSQL:
                 {
                         status = switch_pgsql_handle_exec_string(dbh->native_handle.pgsql_dbh, sql, str, len, err);
                 }
                 break;
         }
 
  end:
 
         if (io_mutex) switch_mutex_unlock(io_mutex);
 
         return status == SWITCH_STATUS_SUCCESS ? str : NULL;
 
 }

switch_status_t switch_cache_db_execute_sql_callback	(	switch_cache_db_handle_t *	dbh,
		const char *	sql,
		switch_core_db_callback_func_t	callback,
		void *	pdata,
		char **	err
	)

Executes the sql and uses callback for row-by-row processing.

Parameters

[in]	dbh	The handle
[in]	sql	- sql to run
[in]	callback	- function pointer to callback
[in]	pdata	- data to pass to callback
[out]	err	- Error if it exists

Definition at line 1161 of file switch_core_sqldb.c.

References io_mutex, SCDB_TYPE_CORE_DB, SCDB_TYPE_ODBC, SCDB_TYPE_PGSQL, SQL_CACHE_TIMEOUT, SWITCH_CHANNEL_LOG, SWITCH_CORE_DB_ABORT, switch_core_db_exec(), switch_core_db_free(), SWITCH_CORE_DB_OK, switch_epoch_time_now(), SWITCH_LOG_ERROR, switch_log_printf(), switch_mutex_lock(), switch_mutex_unlock(), switch_odbc_handle_callback_exec, switch_pgsql_handle_callback_exec, SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

Referenced by sql_in_thread(), switch_console_complete(), switch_console_expand_alias(), switch_console_list_uuid(), and switch_core_recovery_recover().

 {
         switch_status_t status = SWITCH_STATUS_FALSE;
         char *errmsg = NULL;
         switch_mutex_t *io_mutex = dbh->io_mutex;
 
         if (err) {
                 *err = NULL;
         }
 
         if (io_mutex) switch_mutex_lock(io_mutex);
 
 
         switch (dbh->type) {
         case SCDB_TYPE_PGSQL:
                 {
                         status = switch_pgsql_handle_callback_exec(dbh->native_handle.pgsql_dbh, sql, callback, pdata, err);
                 }
                 break;
         case SCDB_TYPE_ODBC:
                 {
                         status = switch_odbc_handle_callback_exec(dbh->native_handle.odbc_dbh, sql, callback, pdata, err);
                 }
                 break;
         case SCDB_TYPE_CORE_DB:
                 {
                         int ret = switch_core_db_exec(dbh->native_handle.core_db_dbh, sql, callback, pdata, &errmsg);
 
                         if (ret == SWITCH_CORE_DB_OK || ret == SWITCH_CORE_DB_ABORT) {
                                 status = SWITCH_STATUS_SUCCESS;
                         }
 
                         if (errmsg) {
                                 dbh->last_used = switch_epoch_time_now(NULL) - (SQL_CACHE_TIMEOUT * 2);
                                 if (!strstr(errmsg, "query abort")) {
                                         switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "SQL ERR: [%s] %s\n", sql, errmsg);
                                 }
                                 switch_core_db_free(errmsg);
                         }
                 }
                 break;
         }
 
         if (io_mutex) switch_mutex_unlock(io_mutex);
 
         return status;
 }

switch_status_t switch_cache_db_execute_sql_callback_err	(	switch_cache_db_handle_t *	dbh,
		const char *	sql,
		switch_core_db_callback_func_t	callback,
		switch_core_db_err_callback_func_t	err_callback,
		void *	pdata,
		char **	err
	)

Executes the sql and uses callback for row-by-row processing.

Parameters

[in]	dbh	The handle
[in]	sql	- sql to run
[in]	callback	- function pointer to callback
[in]	err_callback	- function pointer to callback when error occurs
[in]	pdata	- data to pass to callback
[out]	err	- Error if it exists

Definition at line 1210 of file switch_core_sqldb.c.

References io_mutex, helper::pdata, SCDB_TYPE_CORE_DB, SCDB_TYPE_ODBC, SCDB_TYPE_PGSQL, SQL_CACHE_TIMEOUT, SWITCH_CHANNEL_LOG, SWITCH_CORE_DB_ABORT, switch_core_db_exec(), switch_core_db_free(), SWITCH_CORE_DB_OK, switch_epoch_time_now(), SWITCH_LOG_ERROR, switch_log_printf(), switch_mutex_lock(), switch_mutex_unlock(), switch_odbc_handle_callback_exec, switch_pgsql_handle_callback_exec, SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

Referenced by sql_in_thread().

 {
         switch_status_t status = SWITCH_STATUS_FALSE;
         char *errmsg = NULL;
         switch_mutex_t *io_mutex = dbh->io_mutex;
 
         if (err) {
                 *err = NULL;
         }
 
         if (io_mutex) switch_mutex_lock(io_mutex);
 
 
         switch (dbh->type) {
         case SCDB_TYPE_PGSQL:
                 {
                         status = switch_pgsql_handle_callback_exec(dbh->native_handle.pgsql_dbh, sql, callback, pdata, err);
                         if (err && *err) {
                                 (*err_callback)(pdata, (const char*)*err);
                         }
                 }
                 break;
         case SCDB_TYPE_ODBC:
                 {
                         status = switch_odbc_handle_callback_exec(dbh->native_handle.odbc_dbh, sql, callback, pdata, err);
                         if (err && *err) {
                                 (*err_callback)(pdata, (const char*)*err);
                         }
                 }
                 break;
         case SCDB_TYPE_CORE_DB:
                 {
                         int ret = switch_core_db_exec(dbh->native_handle.core_db_dbh, sql, callback, pdata, &errmsg);
 
                         if (ret == SWITCH_CORE_DB_OK || ret == SWITCH_CORE_DB_ABORT) {
                                 status = SWITCH_STATUS_SUCCESS;
                         }
 
                         if (errmsg) {
                                 dbh->last_used = switch_epoch_time_now(NULL) - (SQL_CACHE_TIMEOUT * 2);
                                 if (!strstr(errmsg, "query abort")) {
                                         switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "SQL ERR: [%s] %s\n", sql, errmsg);
                                 }
                         }
                         if ((ret == SWITCH_CORE_DB_ABORT || errmsg) && err_callback) {
                                 (*err_callback)(pdata, errmsg);
                         }
                         if (errmsg) {
                                 switch_core_db_free(errmsg);
                         }
                 }
                 break;
         }
 
         if (io_mutex) switch_mutex_unlock(io_mutex);
 
         return status;
 }

static switch_status_t switch_cache_db_execute_sql_chunked	(	switch_cache_db_handle_t *	dbh,
		char *	sql,
		uint32_t	chunk_size,
		char **	err
	)

static

OMFG you cruel bastards. Who chooses 64k as a max buffer len for a sql statement, have you ever heard of transactions?

Definition at line 605 of file switch_core_sqldb.c.

References end_of_p, switch_assert, switch_cache_db_execute_sql_real(), SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

Referenced by switch_cache_db_execute_sql().

 {
         switch_status_t status = SWITCH_STATUS_FALSE;
         char *p, *s, *e;
         switch_size_t chunk_count;
         switch_size_t len;
 
         switch_assert(chunk_size);
 
         if (err)
                 *err = NULL;
 
         len = strlen(sql);
 
         if (chunk_size > len) {
                 return switch_cache_db_execute_sql_real(dbh, sql, err);
         }
 
         if (!(chunk_count = strlen(sql) / chunk_size)) {
                 return SWITCH_STATUS_FALSE;
         }
 
         e = end_of_p(sql);
         s = sql;
 
         while (s && s < e) {
                 p = s + chunk_size;
 
                 if (p > e) {
                         p = e;
                 }
 
                 while (p > s) {
                         if (*p == '\n' && *(p - 1) == ';') {
                                 *p = '\0';
                                 *(p - 1) = '\0';
                                 p++;
                                 break;
                         }
 
                         p--;
                 }
 
                 if (p <= s)
                         break;
 
 
                 status = switch_cache_db_execute_sql_real(dbh, s, err);
                 if (status != SWITCH_STATUS_SUCCESS || (err && *err)) {
                         break;
                 }
 
                 s = p;
 
         }
 
         return status;
 
 }

switch_status_t switch_cache_db_execute_sql_event_callback	(	switch_cache_db_handle_t *	dbh,
		const char *	sql,
		switch_core_db_event_callback_func_t	callback,
		void *	pdata,
		char **	err
	)

Definition at line 1042 of file switch_core_sqldb.c.

References helper::callback, helper_callback(), io_mutex, helper::pdata, SCDB_TYPE_CORE_DB, SCDB_TYPE_ODBC, SCDB_TYPE_PGSQL, SQL_CACHE_TIMEOUT, SWITCH_CHANNEL_LOG, SWITCH_CORE_DB_ABORT, switch_core_db_exec(), switch_core_db_free(), SWITCH_CORE_DB_OK, switch_epoch_time_now(), SWITCH_LOG_ERROR, switch_log_printf(), switch_mutex_lock(), switch_mutex_unlock(), switch_odbc_handle_callback_exec, switch_pgsql_handle_callback_exec, SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

Referenced by sql_in_thread().

 {
         switch_status_t status = SWITCH_STATUS_FALSE;
         char *errmsg = NULL;
         switch_mutex_t *io_mutex = dbh->io_mutex;
         struct helper h = {0};
 
 
         if (err) {
                 *err = NULL;
         }
 
         if (io_mutex) switch_mutex_lock(io_mutex);
 
         h.callback = callback;
         h.pdata = pdata;
         
         switch (dbh->type) {
         case SCDB_TYPE_PGSQL:
                 {
                         status = switch_pgsql_handle_callback_exec(dbh->native_handle.pgsql_dbh, sql, helper_callback, &h, err);
                 }
                 break;
         case SCDB_TYPE_ODBC:
                 {
                         status = switch_odbc_handle_callback_exec(dbh->native_handle.odbc_dbh, sql, helper_callback, &h, err);
                 }
                 break;
         case SCDB_TYPE_CORE_DB:
                 {
                         int ret = switch_core_db_exec(dbh->native_handle.core_db_dbh, sql, helper_callback, &h, &errmsg);
 
                         if (ret == SWITCH_CORE_DB_OK || ret == SWITCH_CORE_DB_ABORT) {
                                 status = SWITCH_STATUS_SUCCESS;
                         }
 
                         if (errmsg) {
                                 dbh->last_used = switch_epoch_time_now(NULL) - (SQL_CACHE_TIMEOUT * 2);
                                 if (!strstr(errmsg, "query abort")) {
                                         switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "SQL ERR: [%s] %s\n", sql, errmsg);
                                 }
                                 switch_core_db_free(errmsg);
                         }
                 }
                 break;
         }
 
         if (io_mutex) switch_mutex_unlock(io_mutex);
 
         return status;
 }

switch_status_t switch_cache_db_execute_sql_event_callback_err	(	switch_cache_db_handle_t *	dbh,
		const char *	sql,
		switch_core_db_event_callback_func_t	callback,
		switch_core_db_err_callback_func_t	err_callback,
		void *	pdata,
		char **	err
	)

Definition at line 1095 of file switch_core_sqldb.c.

References helper::callback, helper_callback(), io_mutex, helper::pdata, SCDB_TYPE_CORE_DB, SCDB_TYPE_ODBC, SCDB_TYPE_PGSQL, SQL_CACHE_TIMEOUT, SWITCH_CHANNEL_LOG, SWITCH_CORE_DB_ABORT, switch_core_db_exec(), switch_core_db_free(), SWITCH_CORE_DB_OK, switch_epoch_time_now(), SWITCH_LOG_ERROR, switch_log_printf(), switch_mutex_lock(), switch_mutex_unlock(), switch_odbc_handle_callback_exec, switch_pgsql_handle_callback_exec, SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

Referenced by sql_in_thread().

 {
         switch_status_t status = SWITCH_STATUS_FALSE;
         char *errmsg = NULL;
         switch_mutex_t *io_mutex = dbh->io_mutex;
         struct helper h;
 
 
         if (err) {
                 *err = NULL;
         }
 
         if (io_mutex) switch_mutex_lock(io_mutex);
 
         h.callback = callback;
         h.pdata = pdata;
         
         switch (dbh->type) {
         case SCDB_TYPE_PGSQL:
                 {
                         status = switch_pgsql_handle_callback_exec(dbh->native_handle.pgsql_dbh, sql, helper_callback, &h, err);
                         if (err && *err) {
                                 (*err_callback)(pdata, (const char*)*err);
                         }
                 }
                 break;
         case SCDB_TYPE_ODBC:
                 {
                         status = switch_odbc_handle_callback_exec(dbh->native_handle.odbc_dbh, sql, helper_callback, &h, err);
                         if (err && *err) {
                                 (*err_callback)(pdata, (const char*)*err);
                         }
                 }
                 break;
         case SCDB_TYPE_CORE_DB:
                 {
                         int ret = switch_core_db_exec(dbh->native_handle.core_db_dbh, sql, helper_callback, &h, &errmsg);
 
                         if (ret == SWITCH_CORE_DB_OK || ret == SWITCH_CORE_DB_ABORT) {
                                 status = SWITCH_STATUS_SUCCESS;
                         }
 
                         if (errmsg) {
                                 dbh->last_used = switch_epoch_time_now(NULL) - (SQL_CACHE_TIMEOUT * 2);
                                 if (!strstr(errmsg, "query abort")) {
                                         switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "SQL ERR: [%s] %s\n", sql, errmsg);
                                 }
                         }
                         if ((ret == SWITCH_CORE_DB_ABORT || errmsg) && err_callback) {
                                 (*err_callback)(pdata, errmsg);
                         }
                         if (errmsg) {
                                 switch_core_db_free(errmsg);
                         }
                 }
                 break;
         }
 
         if (io_mutex) switch_mutex_unlock(io_mutex);
 
         return status;
 }

static switch_status_t switch_cache_db_execute_sql_real	(	switch_cache_db_handle_t *	dbh,
		const char *	sql,
		char **	err
	)

static

Definition at line 540 of file switch_core_sqldb.c.

References switch_cache_db_native_handle_t::core_db_dbh, switch_cache_db_handle::io_mutex, io_mutex, switch_cache_db_handle::native_handle, switch_cache_db_native_handle_t::odbc_dbh, switch_cache_db_native_handle_t::pgsql_dbh, SCDB_TYPE_CORE_DB, SCDB_TYPE_ODBC, SCDB_TYPE_PGSQL, SWITCH_CHANNEL_LOG, switch_core_db_exec(), switch_core_db_free(), SWITCH_CORE_DB_OK, SWITCH_LOG_ERROR, switch_log_printf(), switch_mutex_lock(), switch_mutex_unlock(), switch_odbc_handle_exec(), switch_pgsql_handle_exec, switch_safe_free, SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, switch_strdup, switch_stristr(), and switch_cache_db_handle::type.

Referenced by do_trans(), switch_cache_db_execute_sql_chunked(), switch_cache_db_persistant_execute(), switch_cache_db_persistant_execute_trans_full(), and switch_core_sqldb_start().

 {
         switch_status_t status = SWITCH_STATUS_FALSE;
         char *errmsg = NULL;
         char *tmp = NULL;
         char *type = NULL;
         switch_mutex_t *io_mutex = dbh->io_mutex;
         
         if (io_mutex) switch_mutex_lock(io_mutex);
 
         if (err) {
                 *err = NULL;
         }
 
         switch (dbh->type) {
         case SCDB_TYPE_PGSQL:
                 {
                         type = "PGSQL";
                         status = switch_pgsql_handle_exec(dbh->native_handle.pgsql_dbh, sql, &errmsg);
                 }
                 break;
         case SCDB_TYPE_ODBC:
                 {
                         type = "ODBC";
                         status = switch_odbc_handle_exec(dbh->native_handle.odbc_dbh, sql, NULL, &errmsg);
                 }
                 break;
         case SCDB_TYPE_CORE_DB:
                 {
                         int ret = switch_core_db_exec(dbh->native_handle.core_db_dbh, sql, NULL, NULL, &errmsg);
                         type = "NATIVE";
 
                         if (ret == SWITCH_CORE_DB_OK) {
                                 status = SWITCH_STATUS_SUCCESS;
                         }
 
                         if (errmsg) {
                                 switch_strdup(tmp, errmsg);
                                 switch_core_db_free(errmsg);
                                 errmsg = tmp;
                         }
                 }
                 break;
         }
 
         if (errmsg) {
                 if (!switch_stristr("already exists", errmsg) && !switch_stristr("duplicate key name", errmsg)) {
                         switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "%s SQL ERR [%s]\n%s\n", (type ? type : "Unknown"), errmsg, sql);
                 }
                 if (err) {
                         *err = errmsg;
                 } else {
                         switch_safe_free(errmsg);
                 }
         }
 
 
         if (io_mutex) switch_mutex_unlock(io_mutex);
 
         return status;
 }

void switch_cache_db_flush_handles ( void )

Definition at line 291 of file switch_core_sqldb.c.

References SQL_CACHE_TIMEOUT, sql_close(), and switch_epoch_time_now().

Referenced by switch_core_session_ctl(), and switch_core_sqldb_stop().

 {
         sql_close(switch_epoch_time_now(NULL) + SQL_CACHE_TIMEOUT + 1);
 }

switch_cache_db_handle_type_t switch_cache_db_get_type ( switch_cache_db_handle_t * dbh )

Definition at line 286 of file switch_core_sqldb.c.

Referenced by switch_console_complete(), switch_console_expand_alias(), and switch_console_set_alias().

 {
         return dbh->type;
 }

int switch_cache_db_load_extension	(	switch_cache_db_handle_t *	dbh,
		const char *	extension
	)

load an external extension to db

Parameters

[in]	dbh	The handle
[out]	the	path to the extension

Definition at line 710 of file switch_core_sqldb.c.

References SCDB_TYPE_CORE_DB, SCDB_TYPE_ODBC, SCDB_TYPE_PGSQL, SWITCH_CHANNEL_LOG, switch_core_db_load_extension(), SWITCH_LOG_DEBUG, SWITCH_LOG_ERROR, and switch_log_printf().

 {
         switch (dbh->type) {
         case SCDB_TYPE_CORE_DB:
                 {
                         switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "try to load extension [%s]!\n", extension);
                         return switch_core_db_load_extension(dbh->native_handle.core_db_dbh, extension);
                 }
                 break;
         case SCDB_TYPE_ODBC:
                 {
                         switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "load extension not supported by type ODBC!\n");
                 }
                 break;
         case SCDB_TYPE_PGSQL:
                 {
                         switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "load extension not supported by type PGSQL!\n");
                 }
                 break;
         }
         return 0;
 }

switch_status_t switch_cache_db_persistant_execute	(	switch_cache_db_handle_t *	dbh,
		const char *	sql,
		uint32_t	retries
	)

Definition at line 801 of file switch_core_sqldb.c.

References io_mutex, switch_cache_db_execute_sql_real(), SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, switch_log_printf(), switch_mutex_lock(), switch_mutex_unlock(), switch_safe_free, SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, and switch_yield.

Referenced by switch_console_set_alias().

 {
         char *errmsg = NULL;
         switch_status_t status = SWITCH_STATUS_FALSE;
         uint8_t forever = 0;
         switch_mutex_t *io_mutex = dbh->io_mutex;
 
         if (!retries) {
                 forever = 1;
                 retries = 1000;
         }
 
         while (retries > 0) {
 
                 if (io_mutex) switch_mutex_lock(io_mutex);
                 switch_cache_db_execute_sql_real(dbh, sql, &errmsg);
                 if (io_mutex) switch_mutex_unlock(io_mutex);
 
                 
                 if (errmsg) {
                         switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "SQL ERR [%s]\n", errmsg);
                         switch_safe_free(errmsg);
                         switch_yield(100000);
                         retries--;
                         if (retries == 0 && forever) {
                                 retries = 1000;
                                 continue;
                         }
                 } else {
                         status = SWITCH_STATUS_SUCCESS;
                         break;
                 }
         }
         
         return status;
 }

switch_status_t switch_cache_db_persistant_execute_trans_full	(	switch_cache_db_handle_t *	dbh,
		char *	sql,
		uint32_t	retries,
		const char *	pre_trans_execute,
		const char *	post_trans_execute,
		const char *	inner_pre_trans_execute,
		const char *	inner_post_trans_execute
	)

Definition at line 839 of file switch_core_sqldb.c.

References io_mutex, SCDB_TYPE_CORE_DB, SCDB_TYPE_ODBC, SCDB_TYPE_PGSQL, switch_cache_db_execute_sql(), switch_cache_db_execute_sql_real(), SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, SWITCH_LOG_DEBUG, SWITCH_LOG_ERROR, switch_log_printf(), switch_mutex_lock(), switch_mutex_unlock(), switch_odbc_SQLEndTran(), switch_odbc_SQLSetAutoCommitAttr(), SWITCH_ODBC_SUCCESS, switch_pgsql_finish_results, switch_pgsql_SQLEndTran(), switch_pgsql_SQLSetAutoCommitAttr(), SWITCH_PGSQL_SUCCESS, switch_safe_free, switch_snprintfv(), SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, switch_yield, and zstr.

 {
         char *errmsg = NULL;
         switch_status_t status = SWITCH_STATUS_FALSE;
         uint8_t forever = 0;
         unsigned begin_retries = 100;
         uint8_t again = 0;
         switch_mutex_t *io_mutex = dbh->io_mutex;
 
         if (!retries) {
                 forever = 1;
                 retries = 1000;
         }
 
         if (io_mutex) switch_mutex_lock(io_mutex);
 
         if (!zstr(pre_trans_execute)) {
                 switch_cache_db_execute_sql_real(dbh, pre_trans_execute, &errmsg);
                 if (errmsg) {
                         switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "SQL PRE TRANS EXEC %s [%s]\n", pre_trans_execute, errmsg);
                         switch_safe_free(errmsg);
                 }
         }
 
  again:
 
         while (begin_retries > 0) {
                 again = 0;
 
                 switch(dbh->type) {
                 case SCDB_TYPE_CORE_DB:
                         {
                                 switch_cache_db_execute_sql_real(dbh, "BEGIN EXCLUSIVE", &errmsg);
                         }
                         break;
                 case SCDB_TYPE_ODBC:
                         {
                                 switch_odbc_status_t result;
                                 
                                 if ((result = switch_odbc_SQLSetAutoCommitAttr(dbh->native_handle.odbc_dbh, 0)) != SWITCH_ODBC_SUCCESS) {
                                         char tmp[100];
                                         switch_snprintfv(tmp, sizeof(tmp), "%q-%i", "Unable to Set AutoCommit Off", result);
                                         errmsg = strdup(tmp);
                                 }
                         }
                         break;
                 case SCDB_TYPE_PGSQL:
                         {
                                 switch_pgsql_status_t result;
                                 
                                 if ((result = switch_pgsql_SQLSetAutoCommitAttr(dbh->native_handle.pgsql_dbh, 0)) != SWITCH_PGSQL_SUCCESS) {
                                         char tmp[100];
                                         switch_snprintfv(tmp, sizeof(tmp), "%q-%i", "Unable to Set AutoCommit Off", result);
                                         errmsg = strdup(tmp);
                                 }
                         }
                         break;
                 }
 
                 if (errmsg) {
                         begin_retries--;
                         if (strstr(errmsg, "cannot start a transaction within a transaction")) {
                                 again = 1;
                         } else {
                                 switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "SQL Retry [%s]\n", errmsg);
                         }
                         switch_safe_free(errmsg);
 
                         if (again) {
                                 switch(dbh->type) {
                                 case SCDB_TYPE_CORE_DB:
                                         {
                                                 switch_cache_db_execute_sql_real(dbh, "COMMIT", NULL);
                                         }
                                         break;
                                 case SCDB_TYPE_ODBC:
                                         {
                                                 switch_odbc_SQLEndTran(dbh->native_handle.odbc_dbh, 1);
                                                 switch_odbc_SQLSetAutoCommitAttr(dbh->native_handle.odbc_dbh, 1);
                                         }
                                         break;
                                 case SCDB_TYPE_PGSQL:
                                         {
                                                 switch_pgsql_SQLEndTran(dbh->native_handle.pgsql_dbh, 1);
                                                 switch_pgsql_SQLSetAutoCommitAttr(dbh->native_handle.pgsql_dbh, 1);
                                                 switch_pgsql_finish_results(dbh->native_handle.pgsql_dbh);
                                         }
                                         break;
                                 }
 
                                 goto again;
                         }
                         
                         switch_yield(100000);
 
                         if (begin_retries == 0) {
                                 goto done;
                         }
 
                         continue;
                 }
 
                 break;
         }
 
 
         if (!zstr(inner_pre_trans_execute)) {
                 switch_cache_db_execute_sql_real(dbh, inner_pre_trans_execute, &errmsg);
                 if (errmsg) {
                         switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "SQL PRE TRANS EXEC %s [%s]\n", inner_pre_trans_execute, errmsg);
                         switch_safe_free(errmsg);
                 }
         }
 
         while (retries > 0) {
 
                 switch_cache_db_execute_sql(dbh, sql, &errmsg);
 
                 if (errmsg) {
                         switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "SQL ERR [%s]\n", errmsg);
                         switch_safe_free(errmsg);
                         errmsg = NULL;
                         switch_yield(100000);
                         retries--;
                         if (retries == 0 && forever) {
                                 retries = 1000;
                                 continue;
                         }
                 } else {
                         status = SWITCH_STATUS_SUCCESS;
                         break;
                 }
         }
 
         if (!zstr(inner_post_trans_execute)) {
                 switch_cache_db_execute_sql_real(dbh, inner_post_trans_execute, &errmsg);
                 if (errmsg) {
                         switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "SQL POST TRANS EXEC %s [%s]\n", inner_post_trans_execute, errmsg);
                         switch_safe_free(errmsg);
                 }
         }
 
  done:
 
         switch(dbh->type) {
         case SCDB_TYPE_CORE_DB:
                 {
                         switch_cache_db_execute_sql_real(dbh, "COMMIT", NULL);
                 }
                 break;
         case SCDB_TYPE_ODBC:
                 {
                         switch_odbc_SQLEndTran(dbh->native_handle.odbc_dbh, 1);
                         switch_odbc_SQLSetAutoCommitAttr(dbh->native_handle.odbc_dbh, 1);
                 }
                 break;
         case SCDB_TYPE_PGSQL:
                 {
                         switch_pgsql_SQLEndTran(dbh->native_handle.pgsql_dbh, 1);
                         switch_pgsql_SQLSetAutoCommitAttr(dbh->native_handle.pgsql_dbh, 1);
                         switch_pgsql_finish_results(dbh->native_handle.pgsql_dbh);
                 }
                 break;
         }
 
         if (!zstr(post_trans_execute)) {
                 switch_cache_db_execute_sql_real(dbh, post_trans_execute, &errmsg);
                 if (errmsg) {
                         switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "SQL POST TRANS EXEC %s [%s]\n", post_trans_execute, errmsg);
                         switch_safe_free(errmsg);
                 }
         }
 
         if (io_mutex) switch_mutex_unlock(io_mutex);
 
         return status;
 }

void switch_cache_db_release_db_handle ( switch_cache_db_handle_t ** dbh )

Returns the handle to the pool, handle is NOT available to other threads until the allocating thread actually terminates.

Parameters

[in] The handle

Definition at line 297 of file switch_core_sqldb.c.

References SCDB_TYPE_PGSQL, sql_manager, switch_epoch_time_now(), switch_mutex_lock(), switch_mutex_unlock(), and switch_pgsql_flush().

Referenced by sql_in_thread(), switch_cache_db_dismiss_db_handle(), switch_console_complete(), switch_console_expand_alias(), switch_console_list_uuid(), switch_console_set_alias(), switch_core_recovery_flush(), switch_core_recovery_recover(), switch_core_sqldb_start(), switch_sql_queue_manager_push_confirm(), and switch_user_sql_thread().

 {
         if (dbh && *dbh) {
 
                 switch((*dbh)->type) {
                 case SCDB_TYPE_PGSQL:
                         {
                                 switch_pgsql_flush((*dbh)->native_handle.pgsql_dbh);
                         }
                         break;
                 default:
                         break;
                 }
 
                 switch_mutex_lock(sql_manager.dbh_mutex);
                 (*dbh)->last_used = switch_epoch_time_now(NULL);
 
                 (*dbh)->io_mutex = NULL;
                 
                 if ((*dbh)->use_count) {
                         if (--(*dbh)->use_count == 0) {
                                 (*dbh)->thread_hash = 1;
                         }
                 }
                 switch_mutex_unlock((*dbh)->mutex);
                 sql_manager.total_used_handles--;
                 *dbh = NULL;
                 switch_mutex_unlock(sql_manager.dbh_mutex);
         }
 }

void switch_cache_db_status ( switch_stream_handle_t * stream )

Provides some feedback as to the status of the db connection pool.

Parameters

[in] stream stream for status

Definition at line 3716 of file switch_core_sqldb.c.

 {
         /* return some status info suitable for the cli */
         switch_cache_db_handle_t *dbh = NULL;
         switch_bool_t locked = SWITCH_FALSE;
         time_t now = switch_epoch_time_now(NULL);
         char cleankey_str[CACHE_DB_LEN];
         char *pos1 = NULL;
         char *pos2 = NULL;
         int count = 0, used = 0;
 
         switch_mutex_lock(sql_manager.dbh_mutex);
 
         for (dbh = sql_manager.handle_pool; dbh; dbh = dbh->next) {
                 char *needles[3];
                 time_t diff = 0;
                 int i = 0;
 
                 needles[0] = "pass=\"";
                 needles[1] = "password=";
                 needles[2] = "password='";
 
                 diff = now - dbh->last_used;
 
                 if (switch_mutex_trylock(dbh->mutex) == SWITCH_STATUS_SUCCESS) {
                         switch_mutex_unlock(dbh->mutex);
                         locked = SWITCH_FALSE;
                 } else {
                         locked = SWITCH_TRUE;
                 }
 
                 /* sanitize password */
                 memset(cleankey_str, 0, sizeof(cleankey_str));
                 for (i = 0; i < 3; i++) {
                         if((pos1 = strstr(dbh->name, needles[i]))) {
                                 pos1 += strlen(needles[i]);
 
                                 if (!(pos2 = strstr(pos1, "\""))) {
                                         if (!(pos2 = strstr(pos1, "'"))) {
                                                 if (!(pos2 = strstr(pos1, " "))) {
                                                         pos2 = pos1 + strlen(pos1);
                                                 }
                                         }
                                 }
                                 strncpy(cleankey_str, dbh->name, pos1 - dbh->name);
                                 strcpy(&cleankey_str[pos1 - dbh->name], pos2);
                                 break;
                         }
                 }
                 if (i == 3) {
                         strncpy(cleankey_str, dbh->name, strlen(dbh->name));
                 }
 
                 count++;
                 
                 if (dbh->use_count) {
                         used++;
                 }
                 
                 stream->write_function(stream, "%s\n\tType: %s\n\tLast used: %d\n\tTotal used: %ld\n\tFlags: %s, %s(%d)\n"
                                                            "\tCreator: %s\n\tLast User: %s\n",
                                                            cleankey_str,
                                                            switch_cache_db_type_name(dbh->type),
                                                            diff,
                                                            dbh->total_used_count,
                                                            locked ? "Locked" : "Unlocked",
                                                            dbh->use_count ? "Attached" : "Detached", dbh->use_count, dbh->creator, dbh->last_user);
         }
 
         stream->write_function(stream, "%d total. %d in use.\n", count, used);
 
         switch_mutex_unlock(sql_manager.dbh_mutex);
 }

switch_bool_t switch_cache_db_test_reactive	(	switch_cache_db_handle_t *	dbh,
		const char *	test_sql,
		const char *	drop_sql,
		const char *	reactive_sql
	)

Performs test_sql and if it fails performs drop_sql and reactive_sql.

If auto-clear-sql is disabled, then this function will do nothing and it is assumed that the queries are not needed. If auto-create-schemas is disabled, then just test_sql is executed, but drop_sql and reactive_sql are not.

Otherwise, test_sql gets executed. If that succeeds, then there is nothing to do. Otherwise drop_sql is executed (its result is ignored) and then finally reactive_sql is executed.

Returns: If auto-create-schemas is enabled, SWITCH_TRUE is returned if test_sql succeeds, SWITCH_FALSE otherwise. If reactive_sql is executed successfully SWITCH_TRUE is returned, otherwise SWITCH_FALSE is returned.

Definition at line 1299 of file switch_core_sqldb.c.

References io_mutex, runtime, SCDB_TYPE_CORE_DB, SCDB_TYPE_ODBC, SCDB_TYPE_PGSQL, SCF_AUTO_SCHEMAS, SCF_CLEAR_SQL, switch_assert, switch_cache_db_execute_sql(), SWITCH_CHANNEL_LOG, switch_core_db_exec(), switch_core_db_free(), SWITCH_FALSE, SWITCH_LOG_DEBUG, switch_log_printf(), switch_mutex_lock(), switch_mutex_unlock(), switch_odbc_handle_exec(), SWITCH_ODBC_SUCCESS, switch_pgsql_handle_exec, SWITCH_PGSQL_SUCCESS, SWITCH_STATUS_SUCCESS, switch_test_flag, and SWITCH_TRUE.

Referenced by switch_core_sqldb_start().

 {
         switch_bool_t r = SWITCH_TRUE;
         switch_mutex_t *io_mutex = dbh->io_mutex;
 
         switch_assert(test_sql != NULL);
         switch_assert(reactive_sql != NULL);
 
         if (!switch_test_flag((&runtime), SCF_CLEAR_SQL)) {
                 return SWITCH_TRUE;
         }
 
         if (!switch_test_flag((&runtime), SCF_AUTO_SCHEMAS)) {
                 switch_status_t status = switch_cache_db_execute_sql(dbh, (char *)test_sql, NULL);
 
                 return (status == SWITCH_STATUS_SUCCESS) ? SWITCH_TRUE : SWITCH_FALSE;
         }
 
         if (io_mutex) switch_mutex_lock(io_mutex);
 
         switch (dbh->type) {
         case SCDB_TYPE_PGSQL:
                 {
                         if (switch_pgsql_handle_exec(dbh->native_handle.pgsql_dbh, test_sql, NULL) != SWITCH_PGSQL_SUCCESS) {
                                 if (drop_sql) {
                                         switch_pgsql_handle_exec(dbh->native_handle.pgsql_dbh, drop_sql, NULL);
                                 }
                                 r = switch_pgsql_handle_exec(dbh->native_handle.pgsql_dbh, reactive_sql, NULL) == SWITCH_PGSQL_SUCCESS;
                         }
                 }
                 break;
         case SCDB_TYPE_ODBC:
                 {
                         if (switch_odbc_handle_exec(dbh->native_handle.odbc_dbh, test_sql, NULL, NULL) != SWITCH_ODBC_SUCCESS) {
                                 if (drop_sql) {
                                         switch_odbc_handle_exec(dbh->native_handle.odbc_dbh, drop_sql, NULL, NULL);
                                 }
                                 r = switch_odbc_handle_exec(dbh->native_handle.odbc_dbh, reactive_sql, NULL, NULL) == SWITCH_ODBC_SUCCESS;
                         }
                 }
                 break;
         case SCDB_TYPE_CORE_DB:
                 {
                         char *errmsg = NULL;
                         switch_core_db_exec(dbh->native_handle.core_db_dbh, test_sql, NULL, NULL, &errmsg);
 
                         if (errmsg) {
                                 switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "SQL ERR [%s]\n[%s]\nAuto Generating Table!\n", errmsg, test_sql);
                                 switch_core_db_free(errmsg);
                                 errmsg = NULL;
                                 if (drop_sql) {
                                         switch_core_db_exec(dbh->native_handle.core_db_dbh, drop_sql, NULL, NULL, &errmsg);
                                 }
                                 if (errmsg) {
                                         switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Ignoring SQL ERR [%s]\n[%s]\n", errmsg, drop_sql);
                                         switch_core_db_free(errmsg);
                                         errmsg = NULL;
                                 }
                                 switch_core_db_exec(dbh->native_handle.core_db_dbh, reactive_sql, NULL, NULL, &errmsg);
                                 if (errmsg) {
                                         r = SWITCH_FALSE;
                                         switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "SQL ERR [%s]\n[%s]\n", errmsg, reactive_sql);
                                         switch_core_db_free(errmsg);
                                         errmsg = NULL;
                                 } else {
                                         r = SWITCH_TRUE;
                                 }
                         }
                 }
                 break;
         }
 
 
         if (io_mutex) switch_mutex_unlock(io_mutex);
 
         return r;
 }

switch_status_t switch_core_add_registration	(	const char *	user,
		const char *	realm,
		const char *	token,
		const char *	url,
		uint32_t	expires,
		const char *	network_ip,
		const char *	network_port,
		const char *	network_proto,
		const char *	metadata
	)

Add user registration.

Parameters

[in]	user
[in]	realm
[in]	token
[in]	url	- a freeswitch dial string
[in]	expires
[in]	network_ip
[in]	network_port
[in]	network_proto	- one of tls, tcp, udp
[in]	metadata	- generic metadata supplied by module
[out]	err	- Error if it exists

Definition at line 3244 of file switch_core_sqldb.c.

References switch_runtime::multiple_registrations, runtime, SCF_USE_SQL, db_job::sql, sql_manager, switch_core_get_switchname(), SWITCH_FALSE, switch_mprintf(), switch_sql_queue_manager_push(), SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, switch_str_nil, switch_test_flag, and zstr.

 {
         char *sql;
 
         if (!switch_test_flag((&runtime), SCF_USE_SQL)) {
                 return SWITCH_STATUS_FALSE;
         }
 
         if (runtime.multiple_registrations) {
                 sql = switch_mprintf("delete from registrations where hostname='%q' and (url='%q' or token='%q')", 
                                                          switch_core_get_switchname(), url, switch_str_nil(token));
         } else {
                 sql = switch_mprintf("delete from registrations where reg_user='%q' and realm='%q' and hostname='%q'", 
                                                          user, realm, switch_core_get_switchname());
         }
 
         switch_sql_queue_manager_push(sql_manager.qm, sql, 0, SWITCH_FALSE);
 
         if ( !zstr(metadata) ) {
                 sql = switch_mprintf("insert into registrations (reg_user,realm,token,url,expires,network_ip,network_port,network_proto,hostname,metadata) "
                                                          "values ('%q','%q','%q','%q',%ld,'%q','%q','%q','%q','%q')",
                                                          switch_str_nil(user),
                                                          switch_str_nil(realm),
                                                          switch_str_nil(token),
                                                          switch_str_nil(url),
                                                          expires,
                                                          switch_str_nil(network_ip),
                                                          switch_str_nil(network_port),
                                                          switch_str_nil(network_proto),
                                                          switch_core_get_switchname(),
                                                          metadata
                                                          );
         } else {
                 sql = switch_mprintf("insert into registrations (reg_user,realm,token,url,expires,network_ip,network_port,network_proto,hostname) "
                                                          "values ('%q','%q','%q','%q',%ld,'%q','%q','%q','%q')",
                                                          switch_str_nil(user),
                                                          switch_str_nil(realm),
                                                          switch_str_nil(token),
                                                          switch_str_nil(url),
                                                          expires,
                                                          switch_str_nil(network_ip),
                                                          switch_str_nil(network_port),
                                                          switch_str_nil(network_proto),
                                                          switch_core_get_switchname()
                                                          );
         }
 
         
         switch_sql_queue_manager_push(sql_manager.qm, sql, 0, SWITCH_FALSE);
         
         return SWITCH_STATUS_SUCCESS;
 }

switch_cache_db_handle_type_t switch_core_dbtype ( void )

Definition at line 3129 of file switch_core_sqldb.c.

References SCDB_TYPE_CORE_DB, sql_manager, switch_mutex_lock(), and switch_mutex_unlock().

Referenced by switch_console_set_complete().

 {
         switch_cache_db_handle_type_t type = SCDB_TYPE_CORE_DB;
 
         switch_mutex_lock(sql_manager.ctl_mutex);
         if (sql_manager.qm && sql_manager.qm->event_db) {
                 type = sql_manager.qm->event_db->type;
         }
         switch_mutex_unlock(sql_manager.ctl_mutex);
 
         return type;
 }

switch_status_t switch_core_del_registration	(	const char *	user,
		const char *	realm,
		const char *	token
	)

Delete user registration.

Parameters

[in]	user
[in]	realm
[in]	token
[out]	err	- Error if it exists

Definition at line 3299 of file switch_core_sqldb.c.

References switch_runtime::multiple_registrations, runtime, SCF_USE_SQL, db_job::sql, sql_manager, switch_core_get_switchname(), SWITCH_FALSE, switch_mprintf(), switch_sql_queue_manager_push(), SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, switch_test_flag, and zstr.

 {
 
         char *sql;
 
         if (!switch_test_flag((&runtime), SCF_USE_SQL)) {
                 return SWITCH_STATUS_FALSE;
         }
 
         if (!zstr(token) && runtime.multiple_registrations) {
                 sql = switch_mprintf("delete from registrations where reg_user='%q' and realm='%q' and hostname='%q' and token='%q'", user, realm, switch_core_get_switchname(), token);
         } else {
                 sql = switch_mprintf("delete from registrations where reg_user='%q' and realm='%q' and hostname='%q'", user, realm, switch_core_get_switchname());
         }
 
         switch_sql_queue_manager_push(sql_manager.qm, sql, 0, SWITCH_FALSE);
 
 
         return SWITCH_STATUS_SUCCESS;
 }

switch_status_t switch_core_expire_registration ( int force )

Expire user registrations.

Parameters

[in]	force	delete all registrations
[out]	err	- Error if it exists

Definition at line 3320 of file switch_core_sqldb.c.

References runtime, SCF_USE_SQL, db_job::sql, sql_manager, switch_core_get_switchname(), switch_epoch_time_now(), SWITCH_FALSE, switch_mprintf(), switch_sql_queue_manager_push(), SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, and switch_test_flag.

Referenced by switch_core_sql_db_thread().

 {
         
         char *sql;
         time_t now;
 
         if (!switch_test_flag((&runtime), SCF_USE_SQL)) {
                 return SWITCH_STATUS_FALSE;
         }
 
         now = switch_epoch_time_now(NULL);
 
         if (force) {
                 sql = switch_mprintf("delete from registrations where hostname='%q'", switch_core_get_switchname());
         } else {
                 sql = switch_mprintf("delete from registrations where expires > 0 and expires <= %ld and hostname='%q'", now, switch_core_get_switchname());
         }
 
         switch_sql_queue_manager_push(sql_manager.qm, sql, 0, SWITCH_FALSE);
 
         return SWITCH_STATUS_SUCCESS;
 
 }

void switch_core_recovery_flush	(	const char *	technology,
		const char *	profile_name
	)

Definition at line 2915 of file switch_core_sqldb.c.

References dbh, db_job::sql, switch_cache_db_execute_sql(), switch_cache_db_release_db_handle(), SWITCH_CHANNEL_LOG, switch_core_db_handle, SWITCH_LOG_ERROR, switch_log_printf(), SWITCH_LOG_WARNING, switch_mprintf(), switch_safe_free, SWITCH_STATUS_SUCCESS, and zstr.

Referenced by switch_core_session_ctl().

 {
         char *sql = NULL;
         switch_cache_db_handle_t *dbh;
 
         if (switch_core_db_handle(&dbh) != SWITCH_STATUS_SUCCESS) {
                 switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error Opening DB!\n");
                 return;
         }
 
         if (zstr(technology)) {
 
                 if (zstr(profile_name)) {
                         sql = switch_mprintf("delete from recovery");
                 } else {
                         switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "INVALID\n");
                 }
 
         } else {
                 if (zstr(profile_name)) {
                         sql = switch_mprintf("delete from recovery where technology='%q' ", technology);
                 } else {
                         sql = switch_mprintf("delete from recovery where technology='%q' and profile_name='%q'", technology, profile_name);
                 }
         }
 
         if (sql) {
                 switch_cache_db_execute_sql(dbh, sql, NULL);
                 switch_safe_free(sql);
         }
         
         switch_cache_db_release_db_handle(&dbh);
 }

int switch_core_recovery_recover	(	const char *	technology,
		const char *	profile_name
	)

Definition at line 3049 of file switch_core_sqldb.c.

References dbh, recover_callback(), db_job::sql, sql_manager, switch_cache_db_execute_sql(), switch_cache_db_execute_sql_callback(), switch_cache_db_release_db_handle(), SWITCH_CHANNEL_LOG, switch_core_db_handle, switch_core_get_uuid(), SWITCH_LOG_ERROR, switch_log_printf(), switch_mprintf(), switch_safe_free, SWITCH_STATUS_SUCCESS, and zstr.

Referenced by switch_core_session_ctl().

 {
         char *sql = NULL;
         char *errmsg = NULL;
         switch_cache_db_handle_t *dbh;
         int r = 0;
 
         if (!sql_manager.manage) {
                 switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "DATABASE NOT AVAIALBLE, REVCOVERY NOT POSSIBLE\n");
                 return 0;
         }
 
         if (switch_core_db_handle(&dbh) != SWITCH_STATUS_SUCCESS) {
                 switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error Opening DB!\n");
                 return 0;
         }
 
         if (zstr(technology)) {
                 
                 if (zstr(profile_name)) {
                         sql = switch_mprintf("select technology, profile_name, hostname, uuid, metadata "
                                                                  "from recovery where runtime_uuid!='%q'", 
                                                                  switch_core_get_uuid());
                 } else {
                         sql = switch_mprintf("select technology, profile_name, hostname, uuid, metadata "
                                                                  "from recovery where runtime_uuid!='%q' and profile_name='%q'", 
                                                                  switch_core_get_uuid(), profile_name);
                 }
 
         } else {
 
                 if (zstr(profile_name)) {
                         sql = switch_mprintf("select technology, profile_name, hostname, uuid, metadata "
                                                                  "from recovery where technology='%q' and runtime_uuid!='%q'", 
                                                                  technology, switch_core_get_uuid());
                 } else {
                         sql = switch_mprintf("select technology, profile_name, hostname, uuid, metadata "
                                                                  "from recovery where technology='%q' and runtime_uuid!='%q' and profile_name='%q'", 
                                                                  technology, switch_core_get_uuid(), profile_name);
                 }
         }
 
 
         switch_cache_db_execute_sql_callback(dbh, sql, recover_callback, &r, &errmsg);
         
         if (errmsg) {
                 switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "SQL ERR: [%s] %s\n", sql, errmsg);
                 switch_safe_free(errmsg);
         }
 
         switch_safe_free(sql);
 
         if (zstr(technology)) {
                 if (zstr(profile_name)) {
                         sql = switch_mprintf("delete from recovery where runtime_uuid!='%q'", 
                                                                  switch_core_get_uuid());
                 } else {
                         sql = switch_mprintf("delete from recovery where runtime_uuid!='%q' and profile_name='%q'", 
                                                                  switch_core_get_uuid(), profile_name);
                 }
         } else {
                 if (zstr(profile_name)) {
                         sql = switch_mprintf("delete from recovery where runtime_uuid!='%q' and technology='%q' ", 
                                                                  switch_core_get_uuid(), technology);
                 } else {
                         sql = switch_mprintf("delete from recovery where runtime_uuid!='%q' and technology='%q' and profile_name='%q'", 
                                                                  switch_core_get_uuid(), technology, profile_name);
                 }
         }
 
         switch_cache_db_execute_sql(dbh, sql, NULL);
         switch_safe_free(sql);
 
         switch_cache_db_release_db_handle(&dbh);
 
         return r;
 
 }

void switch_core_recovery_track ( switch_core_session_t * session )

Definition at line 3194 of file switch_core_sqldb.c.

References CF_ANSWERED, CF_RECOVERING, CF_TRACKABLE, CF_TRACKED, CS_SOFT_EXECUTE, db_job::sql, sql_manager, switch_channel_get_state(), switch_channel_get_variable_dup(), switch_channel_set_flag, switch_channel_test_flag(), switch_core_get_switchname(), switch_core_get_uuid(), switch_core_session_get_channel(), switch_core_session_get_uuid(), SWITCH_FALSE, switch_ivr_generate_xml_cdr(), switch_mprintf(), switch_safe_free, switch_sql_queue_manager_push(), SWITCH_STATUS_SUCCESS, switch_str_nil, switch_xml_free(), and switch_xml_toxml_nolock().

Referenced by switch_channel_clear_flag(), switch_channel_perform_mark_answered(), switch_core_media_activate_rtp(), and switch_core_session_perform_receive_message().

 {
         switch_xml_t cdr = NULL;
         char *xml_cdr_text = NULL;
         char *sql = NULL;
         switch_channel_t *channel = switch_core_session_get_channel(session);
         const char *profile_name;
         const char *technology;
 
         if (!sql_manager.manage) {
                 return;
         }
 
         if (!switch_channel_test_flag(channel, CF_ANSWERED) || switch_channel_get_state(channel) < CS_SOFT_EXECUTE) {
                 return;
         }
 
         if (switch_channel_test_flag(channel, CF_RECOVERING) || !switch_channel_test_flag(channel, CF_TRACKABLE)) {
                 return;
         }
 
         profile_name = switch_channel_get_variable_dup(channel, "recovery_profile_name", SWITCH_FALSE, -1);
         technology = session->endpoint_interface->interface_name;
 
         if (switch_ivr_generate_xml_cdr(session, &cdr) == SWITCH_STATUS_SUCCESS) {
                 xml_cdr_text = switch_xml_toxml_nolock(cdr, SWITCH_FALSE);
                 switch_xml_free(cdr);
         }
 
         if (xml_cdr_text) {
                 if (switch_channel_test_flag(channel, CF_TRACKED)) {
                         sql = switch_mprintf("update recovery set metadata='%q' where uuid='%q'",  xml_cdr_text, switch_core_session_get_uuid(session));
                 } else {
                         sql = switch_mprintf("insert into recovery (runtime_uuid, technology, profile_name, hostname, uuid, metadata) "
                                                                  "values ('%q','%q','%q','%q','%q','%q')",
                                                                  switch_core_get_uuid(), switch_str_nil(technology), 
                                                                  switch_str_nil(profile_name), switch_core_get_switchname(), switch_core_session_get_uuid(session), xml_cdr_text);
                 }
 
                 switch_sql_queue_manager_push(sql_manager.qm, sql, 2, SWITCH_FALSE);
 
                 switch_safe_free(xml_cdr_text);
                 switch_channel_set_flag(channel, CF_TRACKED);
                 
         }
         
 }

Data Structures

Macros

Functions

Variables

Macro Definition Documentation

Function Documentation