switch_core.h File Reference

Core Library. More...

#include <switch.h>

Include dependency graph for switch_core.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	switch_core_time_duration
struct	switch_app_log
struct	switch_thread_data_s
struct	switch_hold_record_s
struct	device_uuid_node_s
struct	switch_device_stats_s
struct	switch_device_record_s
struct	dtls_fp_s
struct	switch_core_session_message
	A message object designed to allow unlike technologies to exchange data. More...
struct	switch_core_thread_session
	A generic object to pass as a thread's session object to allow mutiple arguements and a pool. More...
union	switch_cache_db_native_handle_t
struct	switch_cache_db_core_db_options_t
struct	switch_cache_db_odbc_options_t
struct	switch_cache_db_database_interface_options_t
union	switch_cache_db_connection_options_t

Macros
#define	SWITCH_MAX_CORE_THREAD_SESSION_OBJS   128
#define	SWITCH_MAX_STREAMS   128
#define	DTLS_SRTP_FNAME   "dtls-srtp"
#define	MAX_FPLEN   64
#define	MAX_FPSTRLEN   192
#define	MESSAGE_STAMP_FFL(_m)   _m->_file = __FILE__; _m->_func = __SWITCH_FUNC__; _m->_line = __LINE__
#define	MESSAGE_STRING_ARG_MAX   10
#define	switch_core_session_get_name(_s)   switch_channel_get_name(switch_core_session_get_channel(_s))
#define	switch_core_media_bug_remove_all(_s)   switch_core_media_bug_remove_all_function(_s, NULL)
#define	switch_core_new_memory_pool(p)   switch_core_perform_new_memory_pool(p, __FILE__, __SWITCH_FUNC__, __LINE__)
	Create a new sub memory pool from the core's master pool. More...
#define	switch_core_destroy_memory_pool(p)   switch_core_perform_destroy_memory_pool(p, __FILE__, __SWITCH_FUNC__, __LINE__)
	Returns a subpool back to the main pool. More...
#define	switch_core_permanent_alloc(_memory)   switch_core_perform_permanent_alloc(_memory, __FILE__, __SWITCH_FUNC__, __LINE__)
	Allocate memory from the main pool with no intention of returning it. More...
#define	switch_core_alloc(_pool, _mem)   switch_core_perform_alloc(_pool, _mem, __FILE__, __SWITCH_FUNC__, __LINE__)
	Allocate memory directly from a memory pool. More...
#define	switch_core_session_alloc(_session, _memory)   switch_core_perform_session_alloc(_session, _memory, __FILE__, __SWITCH_FUNC__, __LINE__)
	Allocate memory from a session's pool. More...
#define	switch_core_permanent_strdup(_todup)   switch_core_perform_permanent_strdup(_todup, __FILE__, __SWITCH_FUNC__, __LINE__)
	Copy a string using permanent memory allocation. More...
#define	switch_core_session_strdup(_session, _todup)   switch_core_perform_session_strdup(_session, _todup, __FILE__, __SWITCH_FUNC__, __LINE__)
	Copy a string using memory allocation from a session's pool. More...
#define	switch_core_strdup(_pool, _todup)   switch_core_perform_strdup(_pool, _todup, __FILE__, __SWITCH_FUNC__, __LINE__)
	Copy a string using memory allocation from a given pool. More...
#define	switch_core_strndup(_pool, _todup, _len)   switch_core_perform_strndup(_pool, _todup, _len, __FILE__, __SWITCH_FUNC__, __LINE__)
#define	switch_core_session_request(_ep, _d, _f, _p)   switch_core_session_request_uuid(_ep, _d, _f, _p, NULL)
#define	switch_core_session_destroy(session)   switch_core_session_perform_destroy(session, __FILE__, __SWITCH_FUNC__, __LINE__)
	Destroy a session and return the memory pool to the core. More...
#define	switch_core_session_locate(uuid_str)   switch_core_session_perform_locate(uuid_str, __FILE__, __SWITCH_FUNC__, __LINE__)
	Locate a session based on it's uuid. More...
#define	switch_core_session_force_locate(uuid_str)   switch_core_session_perform_force_locate(uuid_str, __FILE__, __SWITCH_FUNC__, __LINE__)
	Locate a session based on it's uuid even if the channel is not ready. More...
#define	switch_core_session_hupall_matching_var(_vn, _vv, _c)   switch_core_session_hupall_matching_var_ans(_vn, _vv, _c, SHT_UNANSWERED | SHT_ANSWERED)
#define	switch_core_session_hupall_matching_vars(_vs, _c)   switch_core_session_hupall_matching_vars_ans(_vs, _c, SHT_UNANSWERED | SHT_ANSWERED)
#define	switch_core_session_get_partner(_session, _partner)   switch_core_session_perform_get_partner(_session, _partner, __FILE__, __SWITCH_FUNC__, __LINE__)
#define	switch_core_session_execute_application(_a, _b, _c)   switch_core_session_execute_application_get_flags(_a, _b, _c, NULL)
	Execute an application on a session. More...
#define	switch_core_session_get_private(_s)   switch_core_session_get_private_class(_s, SWITCH_PVT_PRIMARY)
#define	switch_core_session_set_private(_s, _p)   switch_core_session_set_private_class(_s, _p, SWITCH_PVT_PRIMARY)
#define	switch_core_service_session(_s)   switch_core_service_session_av(_s, SWITCH_TRUE, SWITCH_FALSE)
#define	switch_core_session_receive_message(_session, _message)
#define	switch_core_session_kill_channel(session, sig)   switch_core_session_perform_kill_channel(session, __FILE__, __SWITCH_FUNC__, __LINE__, sig)
	Send a signal to a channel. More...
#define	switch_core_hash_init(_hash)   switch_core_hash_init_case(_hash, SWITCH_TRUE)
#define	switch_core_hash_init_nocase(_hash)   switch_core_hash_init_case(_hash, SWITCH_FALSE)
#define	switch_core_hash_insert(_h, _k, _d)   switch_core_hash_insert_destructor(_h, _k, _d, NULL)
#define	switch_core_hash_insert_alloc(_h, _k, _s)   switch_core_hash_insert_alloc_destructor(_h, _k, _s, NULL)
#define	switch_core_hash_insert_dup(_h, _k, _d)   switch_core_hash_insert_dup_destructor(_h, _k, _d, NULL)
#define	switch_core_hash_first(_h)   switch_core_hash_first_iter(_h, NULL)
#define	switch_core_codec_init(_codec, _codec_name, _modname, _fmtp, _rate, _ms, _channels, _flags, _codec_settings, _pool)   switch_core_codec_init_with_bitrate(_codec, _codec_name, _modname, _fmtp, _rate, _ms, _channels, 0, _flags, _codec_settings, _pool)
	Initialize a codec handle. More...
#define	switch_core_file_open(_fh, _file_path, _channels, _rate, _flags, _pool)   switch_core_perform_file_open(__FILE__, __SWITCH_FUNC__, __LINE__, _fh, _file_path, _channels, _rate, _flags, _pool)
	Open a media file using file format modules. More...
#define	switch_check_network_list_ip(_ip_str, _list_name)   switch_check_network_list_ip_token(_ip_str, _list_name, NULL)
#define	CACHE_DB_LEN   256
#define	switch_cache_db_get_db_handle(_a, _b, _c)   _switch_cache_db_get_db_handle(_a, _b, _c, __FILE__, __SWITCH_FUNC__, __LINE__)
#define	switch_cache_db_get_db_handle_dsn(_a, _b)   _switch_cache_db_get_db_handle_dsn(_a, _b, __FILE__, __SWITCH_FUNC__, __LINE__)
#define	switch_core_db_handle(_a)   _switch_core_db_handle(_a, __FILE__, __SWITCH_FUNC__, __LINE__)
#define	switch_cache_db_persistant_execute_trans(_d, _s, _r)   switch_cache_db_persistant_execute_trans_full(_d, _s, _r, NULL, NULL, NULL, NULL)
#define	switch_sql_queue_manager_init(_q, _n, _d, _m, _p1, _p2, _ip1, _ip2)   switch_sql_queue_manager_init_name(__FILE__, _q, _n, _d, _m, _p1, _p2, _ip1, _ip2)
#define	switch_core_session_request_video_refresh(_s)   _switch_core_session_request_video_refresh(_s, 0, __FILE__, __SWITCH_FUNC__, __LINE__)
#define	switch_core_session_force_request_video_refresh(_s)   _switch_core_session_request_video_refresh(_s, 1, __FILE__, __SWITCH_FUNC__, __LINE__)

Typedefs
typedef struct switch_thread_data_s	switch_thread_data_t
typedef struct switch_hold_record_s	switch_hold_record_t
typedef struct device_uuid_node_s	switch_device_node_t
typedef struct switch_device_stats_s	switch_device_stats_t
typedef struct switch_device_record_s	switch_device_record_t
typedef void(*	switch_device_state_function_t) (switch_core_session_t *session, switch_channel_callstate_t callstate, switch_device_record_t *drec)
typedef struct dtls_fp_s	dtls_fingerprint_t
typedef int(*	switch_core_db_event_callback_func_t) (void *pArg, switch_event_t *event)
typedef struct switch_cache_db_handle	switch_cache_db_handle_t

Enumerations
enum	dtls_type_t { DTLS_TYPE_CLIENT = (1 << 0), DTLS_TYPE_SERVER = (1 << 1), DTLS_TYPE_RTP = (1 << 2), DTLS_TYPE_RTCP = (1 << 3) }
enum	dtls_state_t {   DS_OFF, DS_HANDSHAKE, DS_SETUP, DS_READY,   DS_FAIL, DS_INVALID }
enum	switch_hup_type_t { SHT_NONE = 0, SHT_UNANSWERED = (1 << 0), SHT_ANSWERED = (1 << 1) }
enum	cache_db_flag_t { CDF_INUSE = (1 << 0), CDF_PRUNE = (1 << 1), CDF_NONEXPIRING = (1 << 2) }
enum	switch_cache_db_handle_type_t { SCDB_TYPE_CORE_DB, SCDB_TYPE_ODBC, SCDB_TYPE_DATABASE_INTERFACE }

Functions
static void *	switch_must_malloc (size_t _b)
static void *	switch_must_realloc (void *_b, size_t _z)
void	switch_core_screen_size (int *x, int *y)
void	switch_core_session_sched_heartbeat (switch_core_session_t *session, uint32_t seconds)
void	switch_core_session_unsched_heartbeat (switch_core_session_t *session)
void	switch_core_session_enable_heartbeat (switch_core_session_t *session, uint32_t seconds)
void	switch_core_session_disable_heartbeat (switch_core_session_t *session)
switch_status_t	switch_core_media_bug_pop (switch_core_session_t *orig_session, const char *function, switch_media_bug_t **pop)
switch_status_t	switch_core_media_bug_exec_all (switch_core_session_t *orig_session, const char *function, switch_media_bug_exec_cb_t cb, void *user_data)
uint32_t	switch_core_media_bug_patch_video (switch_core_session_t *orig_session, switch_frame_t *frame)
uint32_t	switch_core_media_bug_count (switch_core_session_t *orig_session, const char *function)
void	switch_media_bug_set_spy_fmt (switch_media_bug_t *bug, switch_vid_spy_fmt_t spy_fmt)
switch_status_t	switch_core_media_bug_push_spy_frame (switch_media_bug_t *bug, switch_frame_t *frame, switch_rw_t rw)
switch_status_t	switch_core_media_bug_patch_spy_frame (switch_media_bug_t *bug, switch_image_t *img, switch_rw_t rw)
switch_vid_spy_fmt_t	switch_media_bug_parse_spy_fmt (const char *name)
switch_status_t	switch_core_media_bug_add (_In_ switch_core_session_t *session, _In_ const char *function, _In_ const char *target, _In_ switch_media_bug_callback_t callback, _In_opt_ void *user_data, _In_ time_t stop_time, _In_ switch_media_bug_flag_t flags, _Out_ switch_media_bug_t **new_bug)
	Add a media bug to the session. More...
void	switch_core_media_bug_pause (switch_core_session_t *session)
	Pause a media bug on the session. More...
void	switch_core_media_bug_resume (switch_core_session_t *session)
	Resume a media bug on the session. More...
void	switch_core_media_bug_inuse (switch_media_bug_t *bug, switch_size_t *readp, switch_size_t *writep)
void *	switch_core_media_bug_get_user_data (_In_ switch_media_bug_t *bug)
	Obtain private data from a media bug. More...
switch_frame_t *	switch_core_media_bug_get_write_replace_frame (_In_ switch_media_bug_t *bug)
	Obtain a replace frame from a media bug. More...
switch_frame_t *	switch_core_media_bug_get_native_read_frame (switch_media_bug_t *bug)
switch_frame_t *	switch_core_media_bug_get_native_write_frame (switch_media_bug_t *bug)
switch_frame_t *	switch_core_media_bug_get_video_ping_frame (switch_media_bug_t *bug)
void	switch_core_media_bug_set_write_replace_frame (_In_ switch_media_bug_t *bug, _In_ switch_frame_t *frame)
	Set a return replace frame. More...
switch_frame_t *	switch_core_media_bug_get_read_replace_frame (_In_ switch_media_bug_t *bug)
	Obtain a replace frame from a media bug. More...
void	switch_core_media_bug_set_read_demux_frame (_In_ switch_media_bug_t *bug, _In_ switch_frame_t *frame)
switch_core_session_t *	switch_core_media_bug_get_session (_In_ switch_media_bug_t *bug)
	Obtain the session from a media bug. More...
void	switch_core_media_bug_set_media_params (switch_media_bug_t *bug, switch_mm_t *mm)
void	switch_core_media_bug_get_media_params (switch_media_bug_t *bug, switch_mm_t *mm)
const char *	switch_core_media_bug_get_text (switch_media_bug_t *bug)
uint32_t	switch_core_media_bug_test_flag (_In_ switch_media_bug_t *bug, _In_ uint32_t flag)
	Test for the existance of a flag on an media bug. More...
uint32_t	switch_core_media_bug_set_flag (_In_ switch_media_bug_t *bug, _In_ uint32_t flag)
uint32_t	switch_core_media_bug_clear_flag (_In_ switch_media_bug_t *bug, _In_ uint32_t flag)
void	switch_core_media_bug_set_read_replace_frame (_In_ switch_media_bug_t *bug, _In_ switch_frame_t *frame)
	Set a return replace frame. More...
uint32_t	switch_core_cpu_count (void)
switch_status_t	switch_core_media_bug_remove (_In_ switch_core_session_t *session, _Inout_ switch_media_bug_t **bug)
	Remove a media bug from the session. More...
uint32_t	switch_core_media_bug_prune (switch_core_session_t *session)
switch_status_t	switch_core_media_bug_remove_callback (switch_core_session_t *session, switch_media_bug_callback_t callback)
	Remove media bug callback. More...
switch_status_t	switch_core_media_bug_close (_Inout_ switch_media_bug_t **bug, switch_bool_t destroy)
	Close and destroy a media bug. More...
switch_status_t	switch_core_media_bug_remove_all_function (_In_ switch_core_session_t *session, const char *function)
	Remove all media bugs from the session. More...
switch_status_t	switch_core_media_bug_enumerate (switch_core_session_t *session, switch_stream_handle_t *stream)
switch_status_t	switch_core_media_bug_transfer_callback (switch_core_session_t *orig_session, switch_core_session_t *new_session, switch_media_bug_callback_t callback, void *(*user_data_dup_func)(switch_core_session_t *, void *))
switch_status_t	switch_core_media_bug_read (_In_ switch_media_bug_t *bug, _In_ switch_frame_t *frame, switch_bool_t fill)
	Read a frame from the bug. More...
void	switch_core_media_bug_flush (_In_ switch_media_bug_t *bug)
	Flush the read and write buffers for the bug. More...
switch_status_t	switch_core_media_bug_flush_all (_In_ switch_core_session_t *session)
	Flush the read/write buffers for all media bugs on the session. More...
switch_status_t	switch_core_media_bug_set_pre_buffer_framecount (switch_media_bug_t *bug, uint32_t framecount)
switch_status_t	switch_core_port_allocator_new (_In_ const char *ip, _In_ switch_port_t start, _In_ switch_port_t end, _In_ switch_port_flag_t flags, _Out_ switch_core_port_allocator_t **new_allocator)
	Initilize the port allocator. More...
switch_status_t	switch_core_port_allocator_request_port (_In_ switch_core_port_allocator_t *alloc, _Out_ switch_port_t *port_ptr)
	Get a port from the port allocator. More...
switch_status_t	switch_core_port_allocator_free_port (_In_ switch_core_port_allocator_t *alloc, _In_ switch_port_t port)
	Return unused port to the port allocator. More...
void	switch_core_port_allocator_destroy (_Inout_ switch_core_port_allocator_t **alloc)
	destroythe port allocator More...
int	switch_core_test_flag (int flag)
switch_status_t	switch_core_init (_In_ switch_core_flag_t flags, _In_ switch_bool_t console, _Out_ const char **err)
	Initilize the core. More...
switch_status_t	switch_core_init_and_modload (_In_ switch_core_flag_t flags, _In_ switch_bool_t console, _Out_ const char **err)
	Initilize the core and load modules. More...
uint32_t	switch_core_session_limit (_In_ uint32_t new_limit)
	Set/Get Session Limit. More...
uint32_t	switch_core_sessions_per_second (_In_ uint32_t new_limit)
	Set/Get Session Rate Limit. More...
switch_status_t	switch_core_destroy (void)
	Destroy the core. More...
switch_status_t	switch_core_session_io_read_lock (switch_core_session_t *session)
switch_status_t	switch_core_session_io_write_lock (switch_core_session_t *session)
switch_status_t	switch_core_session_io_rwunlock (switch_core_session_t *session)
switch_status_t	switch_core_session_read_lock (_In_ switch_core_session_t *session)
	Acquire a read lock on the session. More...
switch_status_t	switch_core_session_read_lock_hangup (_In_ switch_core_session_t *session)
	Acquire a read lock on the session. More...
void	switch_core_session_write_lock (_In_ switch_core_session_t *session)
	Acquire a write lock on the session. More...
void	switch_core_session_rwunlock (_In_ switch_core_session_t *session)
	Unlock a read or write lock on as given session. More...
int	switch_core_add_state_handler (_In_ const switch_state_handler_table_t *state_handler)
	Add a global state handler. More...
void	switch_core_remove_state_handler (_In_ const switch_state_handler_table_t *state_handler)
	Remove a global state handler. More...
const switch_state_handler_table_t *	switch_core_get_state_handler (_In_ int index)
	Access a state handler. More...
void	switch_core_memory_pool_tag (switch_memory_pool_t *pool, const char *tag)
void	switch_core_pool_stats (switch_stream_handle_t *stream)
switch_status_t	switch_core_perform_new_memory_pool (_Out_ switch_memory_pool_t **pool, _In_z_ const char *file, _In_z_ const char *func, _In_ int line)
int	switch_core_session_sync_clock (void)
switch_status_t	switch_core_perform_destroy_memory_pool (_Inout_ switch_memory_pool_t **pool, _In_z_ const char *file, _In_z_ const char *func, _In_ int line)
void	switch_core_memory_pool_set_data (switch_memory_pool_t *pool, const char *key, void *data)
void *	switch_core_memory_pool_get_data (switch_memory_pool_t *pool, const char *key)
void	switch_core_session_run (_In_ switch_core_session_t *session)
	Start the session's state machine. More...
unsigned int	switch_core_session_running (_In_ switch_core_session_t *session)
	determine if the session's state machine is running More...
unsigned int	switch_core_session_started (_In_ switch_core_session_t *session)
void *	switch_core_perform_permanent_alloc (_In_ switch_size_t memory, _In_z_ const char *file, _In_z_ const char *func, _In_ int line)
void *	switch_core_perform_alloc (_In_ switch_memory_pool_t *pool, _In_ switch_size_t memory, _In_z_ const char *file, _In_z_ const char *func, _In_ int line)
_Ret_ void *	switch_core_perform_session_alloc (_In_ switch_core_session_t *session, _In_ switch_size_t memory, const char *file, const char *func, int line)
char *	switch_core_perform_permanent_strdup (_In_z_ const char *todup, _In_z_ const char *file, _In_z_ const char *func, _In_ int line)
char *	switch_core_perform_session_strdup (_In_ switch_core_session_t *session, _In_z_ const char *todup, _In_z_ const char *file, _In_z_ const char *func, _In_ int line)
char *	switch_core_perform_strdup (_In_ switch_memory_pool_t *pool, _In_z_ const char *todup, _In_z_ const char *file, _In_z_ const char *func, _In_ int line)
char *	switch_core_perform_strndup (_In_ switch_memory_pool_t *pool, _In_z_ const char *todup, size_t len, _In_z_ const char *file, _In_z_ const char *func, _In_ int line)
char *	switch_core_session_sprintf (_In_ switch_core_session_t *session, _In_z_ _Printf_format_string_ const char *fmt,...)
	printf-style style printing routine. The data is output to a string allocated from the session More...
char *	switch_core_session_vsprintf (switch_core_session_t *session, const char *fmt, va_list ap)
	printf-style style printing routine. The data is output to a string allocated from the session More...
char *	switch_core_sprintf (_In_ switch_memory_pool_t *pool, _In_z_ _Printf_format_string_ const char *fmt,...)
	printf-style style printing routine. The data is output to a string allocated from the pool More...
char *	switch_core_vsprintf (switch_memory_pool_t *pool, _In_z_ _Printf_format_string_ const char *fmt, va_list ap)
	printf-style style printing routine. The data is output to a string allocated from the pool More...
switch_memory_pool_t *	switch_core_session_get_pool (_In_ switch_core_session_t *session)
	Retrieve the memory pool from a session. More...
switch_core_session_t *	switch_core_session_request_xml (switch_endpoint_interface_t *endpoint_interface, switch_memory_pool_t **pool, switch_xml_t xml)
switch_core_session_t *	switch_core_session_request_uuid (_In_ switch_endpoint_interface_t *endpoint_interface, _In_ switch_call_direction_t direction, switch_originate_flag_t originate_flags, _Inout_opt_ switch_memory_pool_t **pool, _In_opt_z_ const char *use_uuid)
	Allocate and return a new session from the core. More...
switch_status_t	switch_core_session_set_uuid (_In_ switch_core_session_t *session, _In_z_ const char *use_uuid)
switch_status_t	switch_core_session_set_external_id (_In_ switch_core_session_t *session, _In_z_ const char *use_external_id)
void	switch_core_session_perform_destroy (_Inout_ switch_core_session_t **session, _In_z_ const char *file, _In_z_ const char *func, _In_ int line)
void	switch_core_session_destroy_state (switch_core_session_t *session)
void	switch_core_session_reporting_state (switch_core_session_t *session)
void	switch_core_session_hangup_state (switch_core_session_t *session, switch_bool_t force)
uint32_t	switch_core_session_count (void)
	Provide the total number of sessions. More...
switch_size_t	switch_core_session_get_id (_In_ switch_core_session_t *session)
switch_size_t	switch_core_session_id (void)
	Provide the current session_id. More...
switch_size_t	switch_core_session_id_dec (void)
switch_core_session_t *	switch_core_session_request_by_name (_In_z_ const char *endpoint_name, _In_ switch_call_direction_t direction, _Inout_ switch_memory_pool_t **pool)
	Allocate and return a new session from the core based on a given endpoint module name. More...
switch_status_t	switch_core_session_thread_launch (_In_ switch_core_session_t *session)
	Launch the session thread (state machine) on a given session. More...
switch_status_t	switch_thread_pool_launch_thread (switch_thread_data_t **tdp)
switch_status_t	switch_core_session_thread_pool_launch (switch_core_session_t *session)
switch_status_t	switch_thread_pool_wait (switch_thread_data_t *td, int ms)
_Ret_ switch_channel_t *	switch_core_session_get_channel (_In_ switch_core_session_t *session)
	Retrieve a pointer to the channel object associated with a given session. More...
switch_mutex_t *	switch_core_session_get_mutex (switch_core_session_t *session)
	Signal a session's state machine thread that a state change has occured. More...
switch_status_t	switch_core_session_wake_session_thread (_In_ switch_core_session_t *session)
void	switch_core_session_signal_state_change (_In_ switch_core_session_t *session)
char *	switch_core_session_get_uuid (_In_ switch_core_session_t *session)
	Retrieve the unique identifier from a session. More...
const char *	switch_core_session_get_external_id (_In_ switch_core_session_t *session)
	Retrieve the unique external identifier from a session. More...
switch_status_t	switch_core_session_set_loglevel (switch_core_session_t *session, switch_log_level_t loglevel)
	Sets the log level for a session. More...
switch_log_level_t	switch_core_session_get_loglevel (switch_core_session_t *session)
	Get the log level for a session. More...
switch_jb_t *	switch_core_session_get_jb (switch_core_session_t *session, switch_media_type_t type)
void	switch_core_session_soft_lock (switch_core_session_t *session, uint32_t sec)
void	switch_core_session_soft_unlock (switch_core_session_t *session)
void	switch_core_session_set_dmachine (switch_core_session_t *session, switch_ivr_dmachine_t *dmachine, switch_digit_action_target_t target)
switch_ivr_dmachine_t *	switch_core_session_get_dmachine (switch_core_session_t *session, switch_digit_action_target_t target)
switch_digit_action_target_t	switch_ivr_dmachine_get_target (switch_ivr_dmachine_t *dmachine)
void	switch_ivr_dmachine_set_target (switch_ivr_dmachine_t *dmachine, switch_digit_action_target_t target)
switch_status_t	switch_ivr_dmachine_set_terminators (switch_ivr_dmachine_t *dmachine, const char *terminators)
switch_status_t	switch_core_session_set_codec_slin (switch_core_session_t *session, switch_slin_data_t *data)
void	switch_core_session_raw_read (switch_core_session_t *session)
char *	switch_core_get_uuid (void)
	Retrieve the unique identifier from the core. More...
switch_core_session_t *	switch_core_session_perform_locate (const char *uuid_str, const char *file, const char *func, int line)
switch_core_session_t *	switch_core_session_perform_force_locate (const char *uuid_str, const char *file, const char *func, int line)
char *	switch_core_get_variable (_In_z_ const char *varname)
	Retrieve a global variable from the core. More...
char *	switch_core_get_variable_dup (_In_z_ const char *varname)
char *	switch_core_get_variable_pdup (_In_z_ const char *varname, switch_memory_pool_t *pool)
const char *	switch_core_get_hostname (void)
const char *	switch_core_get_switchname (void)
char *	switch_core_get_domain (switch_bool_t dup)
void	switch_core_set_variable (_In_z_ const char *varname, _In_opt_z_ const char *value)
	Add a global variable to the core. More...
switch_status_t	switch_core_get_variables (switch_event_t **event)
switch_bool_t	switch_core_set_var_conditional (_In_z_ const char *varname, _In_opt_z_ const char *value, _In_opt_z_ const char *val2)
	Conditionally add a global variable to the core. More...
void	switch_core_dump_variables (_In_ switch_stream_handle_t *stream)
void	switch_core_session_hupall (_In_ switch_call_cause_t cause)
	Hangup all sessions. More...
uint32_t	switch_core_session_hupall_matching_var_ans (_In_ const char *var_name, _In_ const char *var_val, _In_ switch_call_cause_t cause, switch_hup_type_t type)
	Hangup all sessions which match a specific channel variable. More...
switch_console_callback_match_t *	switch_core_session_findall_matching_var (const char *var_name, const char *var_val)
switch_console_callback_match_t *	switch_core_session_findall (void)
uint32_t	switch_core_session_hupall_matching_vars_ans (_In_ switch_event_t *vars, _In_ switch_call_cause_t cause, switch_hup_type_t type)
	Hangup all sessions which match specific channel variable(s) More...
void	switch_core_session_hupall_endpoint (const switch_endpoint_interface_t *endpoint_interface, switch_call_cause_t cause)
	Hangup all sessions that belong to an endpoint. More...
switch_status_t	switch_core_session_perform_get_partner (switch_core_session_t *session, switch_core_session_t **partner, const char *file, const char *func, int line)
	Get the session's partner (the session its bridged to) More...
switch_status_t	switch_core_session_message_send (_In_z_ const char *uuid_str, _In_ switch_core_session_message_t *message)
	Send a message to another session using it's uuid. More...
switch_status_t	switch_core_session_queue_message (_In_ switch_core_session_t *session, _In_ switch_core_session_message_t *message)
	Queue a message on a session. More...
void	switch_core_session_free_message (switch_core_session_message_t **message)
switch_status_t	switch_core_session_queue_signal_data (switch_core_session_t *session, void *signal_data)
switch_status_t	switch_core_session_dequeue_signal_data (switch_core_session_t *session, void **signal_data)
switch_status_t	switch_core_session_pass_indication (_In_ switch_core_session_t *session, _In_ switch_core_session_message_types_t indication)
	pass an indication message on a session More...
switch_status_t	switch_core_session_queue_indication (_In_ switch_core_session_t *session, _In_ switch_core_session_message_types_t indication)
	Queue an indication message on a session. More...
switch_status_t	switch_core_session_dequeue_message (_In_ switch_core_session_t *session, _Out_ switch_core_session_message_t **message)
	DE-Queue an message on a given session. More...
switch_status_t	switch_core_session_flush_message (_In_ switch_core_session_t *session)
	Flush a message queue on a given session. More...
switch_status_t	switch_core_session_event_send (_In_z_ const char *uuid_str, _Inout_ switch_event_t **event)
	Queue an event on another session using its uuid. More...
switch_app_log_t *	switch_core_session_get_app_log (_In_ switch_core_session_t *session)
switch_status_t	switch_core_session_exec (_In_ switch_core_session_t *session, _In_ const switch_application_interface_t *application_interface, _In_opt_z_ const char *arg)
	Execute an application on a session. More...
void	switch_core_session_video_reset (switch_core_session_t *session)
switch_status_t	switch_core_session_execute_application_get_flags (_In_ switch_core_session_t *session, _In_ const char *app, _In_opt_z_ const char *arg, _Out_opt_ int32_t *flags)
	Execute an application on a session. More...
switch_status_t	switch_core_session_execute_application_async (switch_core_session_t *session, const char *app, const char *arg)
switch_status_t	switch_core_session_get_app_flags (const char *app, int32_t *flags)
uint32_t	switch_core_session_stack_count (switch_core_session_t *session, int x)
switch_status_t	switch_core_session_execute_exten (_In_ switch_core_session_t *session, _In_z_ const char *exten, _In_opt_z_ const char *dialplan, _In_opt_z_ const char *context)
	Run a dialplan and execute an extension. More...
switch_status_t	switch_core_session_receive_event (_In_ switch_core_session_t *session, _Inout_ switch_event_t **event)
	Send an event to a session translating it to it's native message format. More...
void *	switch_core_session_get_private_class (_In_ switch_core_session_t *session, _In_ switch_pvt_class_t index)
	Retrieve private user data from a session. More...
switch_status_t	switch_core_session_set_private_class (_In_ switch_core_session_t *session, _In_ void *private_info, _In_ switch_pvt_class_t index)
	Add private user data to a session. More...
int	switch_core_session_add_stream (_In_ switch_core_session_t *session, _In_opt_ void *private_info)
	Add a logical stream to a session. More...
void *	switch_core_session_get_stream (_In_ switch_core_session_t *session, _In_ int index)
	Retreive a logical stream from a session. More...
int	switch_core_session_get_stream_count (_In_ switch_core_session_t *session)
	Determine the number of logical streams a session has. More...
const char *	switch_core_session_get_text_buffer (switch_core_session_t *session)
void	switch_core_session_launch_thread (_In_ switch_core_session_t *session, _In_ void *(*func)(switch_thread_t *, void *), _In_opt_ void *obj)
	Launch a thread designed to exist within the scope of a given session. More...
void	switch_core_thread_session_end (_In_ switch_core_session_t *session)
	Signal a thread using a thread session to terminate. More...
void	switch_core_service_session_av (_In_ switch_core_session_t *session, switch_bool_t audio, switch_bool_t video)
	Launch a service thread on a session to drop inbound data. More...
switch_call_cause_t	switch_core_session_outgoing_channel (_In_opt_ switch_core_session_t *session, _In_opt_ switch_event_t *var_event, _In_z_ const char *endpoint_name, _In_ switch_caller_profile_t *caller_profile, _Inout_ switch_core_session_t **new_session, _Inout_ switch_memory_pool_t **pool, _In_ switch_originate_flag_t flags, switch_call_cause_t *cancel_cause)
	Request an outgoing session spawned from an existing session using a desired endpoing module. More...
switch_status_t	switch_core_session_perform_receive_message (_In_ switch_core_session_t *session, _In_ switch_core_session_message_t *message, const char *file, const char *func, int line)
	Receive a message on a given session. More...
switch_status_t	switch_core_session_queue_event (_In_ switch_core_session_t *session, _Inout_ switch_event_t **event)
	Queue an event on a given session. More...
uint32_t	switch_core_session_event_count (_In_ switch_core_session_t *session)
	Indicate the number of waiting events on a session. More...
uint32_t	switch_core_session_messages_waiting (switch_core_session_t *session)
switch_status_t	switch_core_session_dequeue_event (_In_ switch_core_session_t *session, _Out_ switch_event_t **event, switch_bool_t force)
	DE-Queue an event on a given session. More...
switch_status_t	switch_core_session_queue_private_event (_In_ switch_core_session_t *session, _Inout_ switch_event_t **event, switch_bool_t priority)
	Queue a private event on a given session. More...
uint32_t	switch_core_session_private_event_count (_In_ switch_core_session_t *session)
	Indicate the number of waiting private events on a session. More...
switch_status_t	switch_core_session_dequeue_private_event (_In_ switch_core_session_t *session, _Out_ switch_event_t **event)
	DE-Queue a private event on a given session. More...
uint32_t	switch_core_session_flush_private_events (switch_core_session_t *session)
	Flush the private event queue of a session. More...
switch_status_t	switch_core_session_read_frame (_In_ switch_core_session_t *session, switch_frame_t **frame, switch_io_flag_t flags, int stream_id)
	Read a frame from a session. More...
switch_bool_t	switch_core_session_transcoding (switch_core_session_t *session_a, switch_core_session_t *session_b, switch_media_type_t type)
void	switch_core_session_passthru (switch_core_session_t *session, switch_media_type_t type, switch_bool_t on)
switch_status_t	switch_core_session_read_video_frame (_In_ switch_core_session_t *session, switch_frame_t **frame, switch_io_flag_t flags, int stream_id)
	Read a video frame from a session. More...
switch_status_t	switch_core_session_write_video_frame (_In_ switch_core_session_t *session, switch_frame_t *frame, switch_io_flag_t flags, int stream_id)
	Write a video frame to a session. More...
switch_status_t	switch_core_session_write_encoded_video_frame (switch_core_session_t *session, switch_frame_t *frame, switch_io_flag_t flags, int stream_id)
switch_status_t	switch_core_session_set_read_impl (switch_core_session_t *session, const switch_codec_implementation_t *impp)
switch_status_t	switch_core_session_set_write_impl (switch_core_session_t *session, const switch_codec_implementation_t *impp)
switch_status_t	switch_core_session_set_video_read_impl (switch_core_session_t *session, const switch_codec_implementation_t *impp)
switch_status_t	switch_core_session_set_video_write_impl (switch_core_session_t *session, const switch_codec_implementation_t *impp)
void	switch_core_session_reset (_In_ switch_core_session_t *session, switch_bool_t flush_dtmf, switch_bool_t reset_read_codec)
	Reset the buffers and resampler on a session. More...
switch_status_t	switch_core_session_try_reset (switch_core_session_t *session, switch_bool_t flush_dtmf, switch_bool_t reset_read_codec)
	Reset the buffers and resampler on a session, fail if can not lock codec mutexes. More...
switch_status_t	switch_core_session_write_frame (_In_ switch_core_session_t *session, switch_frame_t *frame, switch_io_flag_t flags, int stream_id)
	Write a frame to a session. More...
switch_status_t	switch_core_session_perform_kill_channel (_In_ switch_core_session_t *session, const char *file, const char *func, int line, switch_signal_t sig)
switch_status_t	switch_core_session_send_dtmf (_In_ switch_core_session_t *session, const switch_dtmf_t *dtmf)
	Send DTMF to a session. More...
switch_status_t	switch_core_session_send_dtmf_string (switch_core_session_t *session, const char *dtmf_string)
	Send DTMF to a session. More...
switch_status_t	switch_core_session_recv_dtmf (_In_ switch_core_session_t *session, const switch_dtmf_t *dtmf)
	RECV DTMF on a session. More...
switch_status_t	switch_core_hash_init_case (_Out_ switch_hash_t **hash, switch_bool_t case_sensitive)
	Initialize a hash table. More...
switch_status_t	switch_core_hash_destroy (_Inout_ switch_hash_t **hash)
	Destroy an existing hash table. More...
switch_status_t	switch_core_hash_insert_pointer (switch_hash_t *hash, const void *data)
	Insert data into a hash with an auto-generated key based on the data pointer. More...
switch_status_t	switch_core_hash_insert_auto_free (switch_hash_t *hash, const char *key, const void *data)
	Insert data into a hash and set flags so the value is automatically freed on delete. More...
switch_status_t	switch_core_hash_insert_dup_auto_free (switch_hash_t *hash, const char *key, const char *str)
	Insert strdup(str) into a hash and set flags so the value is automatically freed on delete. More...
switch_status_t	switch_core_hash_insert_destructor (_In_ switch_hash_t *hash, _In_z_ const char *key, _In_opt_ const void *data, hashtable_destructor_t destructor)
	Insert data into a hash. More...
void *	switch_core_hash_insert_alloc_destructor (_In_ switch_hash_t *hash, _In_z_ const char *key, _In_opt_ size_t size, hashtable_destructor_t destructor)
	Allocate memory and insert into a hash. More...
switch_status_t	switch_core_hash_insert_dup_destructor (_In_ switch_hash_t *hash, _In_z_ const char *key, _In_opt_ const char *str, hashtable_destructor_t destructor)
	Insert strdup(str) into a hash. More...
switch_status_t	switch_core_hash_insert_locked (_In_ switch_hash_t *hash, _In_z_ const char *key, _In_opt_ const void *data, _In_opt_ switch_mutex_t *mutex)
	Insert data into a hash. More...
switch_status_t	switch_core_hash_insert_wrlock (switch_hash_t *hash, const char *key, const void *data, switch_thread_rwlock_t *rwlock)
	Retrieve data from a given hash. More...
void *	switch_core_hash_delete (_In_ switch_hash_t *hash, _In_z_ const char *key)
	Delete data from a hash based on desired key. More...
void *	switch_core_hash_delete_locked (_In_ switch_hash_t *hash, _In_z_ const char *key, _In_opt_ switch_mutex_t *mutex)
	Delete data from a hash based on desired key. More...
void *	switch_core_hash_delete_wrlock (_In_ switch_hash_t *hash, _In_z_ const char *key, _In_opt_ switch_thread_rwlock_t *rwlock)
	Delete data from a hash based on desired key. More...
switch_status_t	switch_core_hash_delete_multi (_In_ switch_hash_t *hash, _In_ switch_hash_delete_callback_t callback, _In_opt_ void *pData)
	Delete data from a hash based on callback function. More...
void *	switch_core_hash_find (_In_ switch_hash_t *hash, _In_z_ const char *key)
	Retrieve data from a given hash. More...
void *	switch_core_hash_find_locked (_In_ switch_hash_t *hash, _In_z_ const char *key, _In_ switch_mutex_t *mutex)
	Retrieve data from a given hash. More...
void *	switch_core_hash_find_rdlock (_In_ switch_hash_t *hash, _In_z_ const char *key, _In_ switch_thread_rwlock_t *rwlock)
	Retrieve data from a given hash. More...
switch_hash_index_t *	switch_core_hash_first_iter (_In_ switch_hash_t *hash, switch_hash_index_t *hi)
	Gets the first element of a hashtable. More...
switch_bool_t	switch_core_hash_empty (switch_hash_t *hash)
	tells if a hash is empty More...
switch_hash_index_t *	switch_core_hash_next (_In_ switch_hash_index_t **hi)
	Gets the next element of a hashtable. More...
void	switch_core_hash_this (_In_ switch_hash_index_t *hi, _Out_opt_ptrdiff_cap_(klen) const void **key, _Out_opt_ switch_ssize_t *klen, _Out_ void **val)
	Gets the key and value of the current hash element. More...
void	switch_core_hash_this_val (switch_hash_index_t *hi, void *val)
switch_status_t	switch_core_inthash_init (switch_inthash_t **hash)
switch_status_t	switch_core_inthash_destroy (switch_inthash_t **hash)
switch_status_t	switch_core_inthash_insert (switch_inthash_t *hash, uint32_t key, const void *data)
void *	switch_core_inthash_delete (switch_inthash_t *hash, uint32_t key)
void *	switch_core_inthash_find (switch_inthash_t *hash, uint32_t key)
switch_status_t	switch_core_timer_init (switch_timer_t *timer, const char *timer_name, int interval, int samples, switch_memory_pool_t *pool)
	Request a timer handle using given time module. More...
void	switch_time_calibrate_clock (void)
switch_status_t	switch_core_timer_next (switch_timer_t *timer)
	Wait for one cycle on an existing timer. More...
switch_status_t	switch_core_timer_step (switch_timer_t *timer)
	Step the timer one step. More...
switch_status_t	switch_core_timer_sync (switch_timer_t *timer)
switch_status_t	switch_core_timer_check (switch_timer_t *timer, switch_bool_t step)
	Check if the current step has been exceeded. More...
switch_status_t	switch_core_timer_destroy (switch_timer_t *timer)
	Destroy an allocated timer. More...
switch_status_t	switch_core_codec_init_with_bitrate (switch_codec_t *codec, const char *codec_name, const char *fmtp, const char *modname, uint32_t rate, int ms, int channels, uint32_t bitrate, uint32_t flags, const switch_codec_settings_t *codec_settings, switch_memory_pool_t *pool)
switch_status_t	switch_core_codec_copy (switch_codec_t *codec, switch_codec_t *new_codec, const switch_codec_settings_t *codec_settings, switch_memory_pool_t *pool)
switch_status_t	switch_core_codec_parse_fmtp (const char *codec_name, const char *fmtp, uint32_t rate, switch_codec_fmtp_t *codec_fmtp)
switch_status_t	switch_core_codec_reset (switch_codec_t *codec)
switch_status_t	switch_core_codec_encode (switch_codec_t *codec, switch_codec_t *other_codec, void *decoded_data, uint32_t decoded_data_len, uint32_t decoded_rate, void *encoded_data, uint32_t *encoded_data_len, uint32_t *encoded_rate, unsigned int *flag)
	Encode data using a codec handle. More...
switch_status_t	switch_core_codec_decode (switch_codec_t *codec, switch_codec_t *other_codec, void *encoded_data, uint32_t encoded_data_len, uint32_t encoded_rate, void *decoded_data, uint32_t *decoded_data_len, uint32_t *decoded_rate, unsigned int *flag)
	Decode data using a codec handle. More...
switch_status_t	switch_core_codec_encode_video (switch_codec_t *codec, switch_frame_t *frame)
	Encode video data using a codec handle. More...
switch_status_t	switch_core_codec_control (switch_codec_t *codec, switch_codec_control_command_t cmd, switch_codec_control_type_t ctype, void *cmd_data, switch_codec_control_type_t atype, void *cmd_arg, switch_codec_control_type_t *rtype, void **ret_data)
	send control data using a codec handle More...
switch_status_t	switch_core_codec_decode_video (switch_codec_t *codec, switch_frame_t *frame)
	Decode video data using a codec handle. More...
switch_status_t	switch_core_codec_destroy (switch_codec_t *codec)
	Destroy an initalized codec handle. More...
switch_status_t	switch_core_session_set_read_codec (_In_ switch_core_session_t *session, switch_codec_t *codec)
	Assign the read codec to a given session. More...
switch_status_t	switch_core_session_set_real_read_codec (_In_ switch_core_session_t *session, switch_codec_t *codec)
	Assign the original read codec to a given session. This is the read codec used by an endpoint. More...
void	switch_core_session_unset_read_codec (_In_ switch_core_session_t *session)
void	switch_core_session_unset_write_codec (_In_ switch_core_session_t *session)
void	switch_core_session_lock_codec_write (_In_ switch_core_session_t *session)
void	switch_core_session_unlock_codec_write (_In_ switch_core_session_t *session)
void	switch_core_session_lock_codec_read (_In_ switch_core_session_t *session)
void	switch_core_session_unlock_codec_read (_In_ switch_core_session_t *session)
switch_status_t	switch_core_session_get_read_impl (switch_core_session_t *session, switch_codec_implementation_t *impp)
switch_status_t	switch_core_session_get_real_read_impl (switch_core_session_t *session, switch_codec_implementation_t *impp)
switch_status_t	switch_core_session_get_write_impl (switch_core_session_t *session, switch_codec_implementation_t *impp)
switch_status_t	switch_core_session_get_video_read_impl (switch_core_session_t *session, switch_codec_implementation_t *impp)
switch_status_t	switch_core_session_get_video_write_impl (switch_core_session_t *session, switch_codec_implementation_t *impp)
switch_codec_t *	switch_core_session_get_read_codec (_In_ switch_core_session_t *session)
	Retrieve the read codec from a given session. More...
switch_codec_t *	switch_core_session_get_effective_read_codec (_In_ switch_core_session_t *session)
	Retrieve the effevtive read codec from a given session. More...
switch_status_t	switch_core_session_set_write_codec (_In_ switch_core_session_t *session, switch_codec_t *codec)
	Assign the write codec to a given session. More...
switch_codec_t *	switch_core_session_get_write_codec (_In_ switch_core_session_t *session)
	Retrieve the write codec from a given session. More...
switch_codec_t *	switch_core_session_get_effective_write_codec (_In_ switch_core_session_t *session)
	Retrieve the effevtive write codec from a given session. More...
switch_status_t	switch_core_session_set_video_read_codec (_In_ switch_core_session_t *session, switch_codec_t *codec)
	Assign the video_read codec to a given session. More...
switch_codec_t *	switch_core_session_get_video_read_codec (_In_ switch_core_session_t *session)
	Retrieve the video_read codec from a given session. More...
switch_status_t	switch_core_session_set_video_write_codec (_In_ switch_core_session_t *session, switch_codec_t *codec)
	Assign the video_write codec to a given session. More...
switch_codec_t *	switch_core_session_get_video_write_codec (_In_ switch_core_session_t *session)
	Retrieve the video_write codec from a given session. More...
switch_core_db_t *	switch_core_db_open_file (const char *filename)
	Open a core db (SQLite) file. More...
switch_core_db_t *	switch_core_db_open_in_memory (const char *uri)
	Open a core db (SQLite) in-memory. More...
switch_status_t	switch_core_db_persistant_execute (switch_core_db_t *db, char *sql, uint32_t retries)
	Execute a sql stmt until it is accepted. More...
switch_status_t	switch_core_db_persistant_execute_trans (switch_core_db_t *db, char *sql, uint32_t retries)
void	switch_core_db_test_reactive (switch_core_db_t *db, char *test_sql, char *drop_sql, char *reactive_sql)
	perform a test query then perform a reactive query if the first one fails More...
switch_status_t	switch_core_perform_file_open (const char *file, const char *func, int line, _In_ switch_file_handle_t *fh, _In_opt_z_ const char *file_path, _In_ uint32_t channels, _In_ uint32_t rate, _In_ unsigned int flags, _In_opt_ switch_memory_pool_t *pool)
switch_status_t	switch_core_file_read (_In_ switch_file_handle_t *fh, void *data, switch_size_t *len)
	Read media from a file handle. More...
switch_status_t	switch_core_file_write (_In_ switch_file_handle_t *fh, void *data, switch_size_t *len)
	Write media to a file handle. More...
switch_status_t	switch_core_file_write_video (_In_ switch_file_handle_t *fh, switch_frame_t *frame)
	Write media to a file handle. More...
switch_status_t	switch_core_file_read_video (switch_file_handle_t *fh, switch_frame_t *frame, switch_video_read_flag_t flags)
switch_status_t	switch_core_file_seek (_In_ switch_file_handle_t *fh, unsigned int *cur_pos, int64_t samples, int whence)
	Seek a position in a file. More...
switch_status_t	switch_core_file_set_string (_In_ switch_file_handle_t *fh, switch_audio_col_t col, const char *string)
	Set metadata to the desired string. More...
switch_status_t	switch_core_file_get_string (_In_ switch_file_handle_t *fh, switch_audio_col_t col, const char **string)
	get metadata of the desired string More...
switch_status_t	switch_core_file_pre_close (_In_ switch_file_handle_t *fh)
	Pre close an open file handle, then can get file size etc., no more wirte to the file. More...
switch_status_t	switch_core_file_handle_dup (switch_file_handle_t *oldfh, switch_file_handle_t **newfh, switch_memory_pool_t *pool)
	Duplicates a file handle using another pool. More...
switch_status_t	switch_core_file_close (_In_ switch_file_handle_t *fh)
	Close an open file handle. More...
switch_status_t	switch_core_file_command (switch_file_handle_t *fh, switch_file_command_t command)
switch_status_t	switch_core_file_truncate (switch_file_handle_t *fh, int64_t offset)
switch_bool_t	switch_core_file_has_video (switch_file_handle_t *fh, switch_bool_t CHECK_OPEN)
switch_status_t	switch_core_speech_open (_In_ switch_speech_handle_t *sh, const char *module_name, const char *voice_name, _In_ unsigned int rate, _In_ unsigned int interval, _In_ unsigned int channels, switch_speech_flag_t *flags, _In_opt_ switch_memory_pool_t *pool)
	Open a speech handle. More...
switch_status_t	switch_core_speech_feed_tts (switch_speech_handle_t *sh, const char *text, switch_speech_flag_t *flags)
	Feed text to the TTS module. More...
void	switch_core_speech_flush_tts (switch_speech_handle_t *sh)
	Flush TTS audio on a given handle. More...
void	switch_core_speech_text_param_tts (switch_speech_handle_t *sh, char *param, const char *val)
	Set a text parameter on a TTS handle. More...
void	switch_core_speech_numeric_param_tts (switch_speech_handle_t *sh, char *param, int val)
	Set a numeric parameter on a TTS handle. More...
void	switch_core_speech_float_param_tts (switch_speech_handle_t *sh, char *param, double val)
	Set a float parameter on a TTS handle. More...
switch_status_t	switch_core_speech_read_tts (switch_speech_handle_t *sh, void *data, switch_size_t *datalen, switch_speech_flag_t *flags)
	Read rendered audio from the TTS module. More...
switch_status_t	switch_core_speech_close (switch_speech_handle_t *sh, switch_speech_flag_t *flags)
	Close an open speech handle. More...
switch_status_t	switch_core_asr_open (switch_asr_handle_t *ah, const char *module_name, const char *codec, int rate, const char *dest, switch_asr_flag_t *flags, switch_memory_pool_t *pool)
	Open an asr handle. More...
switch_status_t	switch_core_asr_close (switch_asr_handle_t *ah, switch_asr_flag_t *flags)
	Close an asr handle. More...
switch_status_t	switch_core_asr_feed (switch_asr_handle_t *ah, void *data, unsigned int len, switch_asr_flag_t *flags)
	Feed audio data to an asr handle. More...
switch_status_t	switch_core_asr_feed_dtmf (switch_asr_handle_t *ah, const switch_dtmf_t *dtmf, switch_asr_flag_t *flags)
	Feed DTMF to an asr handle. More...
switch_status_t	switch_core_asr_check_results (switch_asr_handle_t *ah, switch_asr_flag_t *flags)
	Check an asr handle for results. More...
switch_status_t	switch_core_asr_get_results (switch_asr_handle_t *ah, char **xmlstr, switch_asr_flag_t *flags)
	Get results from an asr handle. More...
switch_status_t	switch_core_asr_get_result_headers (switch_asr_handle_t *ah, switch_event_t **headers, switch_asr_flag_t *flags)
	Get result headers from an asr handle. More...
switch_status_t	switch_core_asr_load_grammar (switch_asr_handle_t *ah, const char *grammar, const char *name)
	Load a grammar to an asr handle. More...
switch_status_t	switch_core_asr_unload_grammar (switch_asr_handle_t *ah, const char *name)
	Unload a grammar from an asr handle. More...
switch_status_t	switch_core_asr_enable_grammar (switch_asr_handle_t *ah, const char *name)
	Enable a grammar from an asr handle. More...
switch_status_t	switch_core_asr_disable_grammar (switch_asr_handle_t *ah, const char *name)
	Disable a grammar from an asr handle. More...
switch_status_t	switch_core_asr_disable_all_grammars (switch_asr_handle_t *ah)
	Disable all grammars from an asr handle. More...
switch_status_t	switch_core_asr_pause (switch_asr_handle_t *ah)
	Pause detection on an asr handle. More...
switch_status_t	switch_core_asr_resume (switch_asr_handle_t *ah)
	Resume detection on an asr handle. More...
switch_status_t	switch_core_asr_start_input_timers (switch_asr_handle_t *ah)
	Start input timers on an asr handle. More...
void	switch_core_asr_text_param (switch_asr_handle_t *ah, char *param, const char *val)
	Set a text parameter on an asr handle. More...
void	switch_core_asr_numeric_param (switch_asr_handle_t *ah, char *param, int val)
	Set a numeric parameter on an asr handle. More...
void	switch_core_asr_float_param (switch_asr_handle_t *ah, char *param, double val)
	Set a float parameter on an asr handle. More...
switch_status_t	switch_core_directory_open (switch_directory_handle_t *dh, char *module_name, char *source, char *dsn, char *passwd, switch_memory_pool_t *pool)
	Open a directory handle. More...
switch_status_t	switch_core_directory_query (switch_directory_handle_t *dh, char *base, char *query)
	Query a directory handle. More...
switch_status_t	switch_core_directory_next (switch_directory_handle_t *dh)
	Obtain the next record in a lookup. More...
switch_status_t	switch_core_directory_next_pair (switch_directory_handle_t *dh, char **var, char **val)
	Obtain the next name/value pair in the current record. More...
switch_status_t	switch_core_directory_close (switch_directory_handle_t *dh)
	Close an open directory handle. More...
FILE *	switch_core_data_channel (switch_text_channel_t channel)
	Retrieve a FILE stream of a given text channel name. More...
switch_bool_t	switch_core_ready (void)
	Determines if the core is ready to take calls. More...
switch_bool_t	switch_core_running (void)
switch_bool_t	switch_core_ready_inbound (void)
	Determines if the core is ready to take inbound calls. More...
switch_bool_t	switch_core_ready_outbound (void)
	Determines if the core is ready to place outbound calls. More...
switch_core_flag_t	switch_core_flags (void)
	return core flags More...
switch_status_t	switch_core_management_exec (char *relative_oid, switch_management_action_t action, char *data, switch_size_t datalen)
	Execute a management operation. More...
int32_t	switch_core_set_process_privileges (void)
	Switch on the privilege awareness for the process and request required privileges. More...
int32_t	set_normal_priority (void)
	Set the maximum priority the process can obtain. More...
int32_t	set_auto_priority (void)
int32_t	set_realtime_priority (void)
int32_t	set_low_priority (void)
int32_t	change_user_group (const char *user, const char *group)
	Change user and/or group of the running process. More...
void	switch_core_runtime_loop (int bg)
	Run endlessly until the system is shutdown. More...
switch_status_t	switch_core_set_console (const char *console)
	Set the output console to the desired file. More...
void	switch_core_measure_time (switch_time_t total_ms, switch_core_time_duration_t *duration)
	Breakdown a number of milliseconds into various time spec. More...
switch_time_t	switch_core_uptime (void)
	Number of microseconds the system has been up. More...
int32_t	switch_core_session_ctl (switch_session_ctl_t cmd, void *val)
	send a control message to the core More...
FILE *	switch_core_get_console (void)
	Get the output console. More...
switch_thread_t *	switch_core_launch_thread (void *(SWITCH_THREAD_FUNC *func)(switch_thread_t *, void *), void *obj, switch_memory_pool_t *pool)
	Launch a thread. More...
void	switch_core_set_globals (void)
	Initiate Globals. More...
uint8_t	switch_core_session_compare (switch_core_session_t *a, switch_core_session_t *b)
	Checks if 2 sessions are using the same endpoint module. More...
uint8_t	switch_core_session_check_interface (switch_core_session_t *session, const switch_endpoint_interface_t *endpoint_interface)
	Checks if a session is using a specific endpoint. More...
switch_status_t	switch_core_session_set_video_read_callback (switch_core_session_t *session, switch_core_video_thread_callback_func_t func, void *user_data)
switch_status_t	switch_core_session_video_read_callback (switch_core_session_t *session, switch_frame_t *frame)
switch_hash_index_t *	switch_core_mime_index (void)
const char *	switch_core_mime_ext2type (const char *ext)
const char *	switch_core_mime_type2ext (const char *type)
switch_status_t	switch_core_mime_add_type (const char *type, const char *ext)
switch_loadable_module_interface_t *	switch_loadable_module_create_module_interface (switch_memory_pool_t *pool, const char *name)
void *	switch_loadable_module_create_interface (switch_loadable_module_interface_t *mod, switch_module_interface_name_t iname)
switch_time_t	switch_micro_time_now (void)
	Get the current epoch time in microseconds. More...
switch_time_t	switch_mono_micro_time_now (void)
void	switch_core_memory_reclaim (void)
void	switch_core_memory_reclaim_events (void)
void	switch_core_memory_reclaim_logger (void)
void	switch_core_memory_reclaim_all (void)
void	switch_core_setrlimits (void)
switch_time_t	switch_time_ref (void)
void	switch_time_sync (void)
time_t	switch_epoch_time_now (time_t *t)
	Get the current epoch time. More...
const char *	switch_lookup_timezone (const char *tz_name)
switch_status_t	switch_strftime_tz (const char *tz, const char *format, char *date, size_t len, switch_time_t thetime)
switch_status_t	switch_time_exp_tz_name (const char *tz, switch_time_exp_t *tm, switch_time_t thetime)
void	switch_load_network_lists (switch_bool_t reload)
switch_bool_t	switch_check_network_list_ip_port_token (const char *ip_str, int port, const char *list_name, const char **token)
switch_bool_t	switch_check_network_list_ip_token (const char *ip_str, const char *list_name, const char **token)
void	switch_time_set_monotonic (switch_bool_t enable)
void	switch_time_set_timerfd (int enable)
void	switch_time_set_nanosleep (switch_bool_t enable)
void	switch_time_set_matrix (switch_bool_t enable)
void	switch_time_set_cond_yield (switch_bool_t enable)
void	switch_time_set_use_system_time (switch_bool_t enable)
uint32_t	switch_core_min_dtmf_duration (uint32_t duration)
uint32_t	switch_core_max_dtmf_duration (uint32_t duration)
double	switch_core_min_idle_cpu (double new_limit)
double	switch_core_idle_cpu (void)
uint32_t	switch_core_default_dtmf_duration (uint32_t duration)
switch_status_t	switch_console_set_complete (const char *string)
switch_status_t	switch_console_set_alias (const char *string)
int	switch_system (const char *cmd, switch_bool_t wait)
int	switch_stream_system (const char *cmd, switch_stream_handle_t *stream)
void	switch_cond_yield (switch_interval_time_t t)
void	switch_cond_next (void)
switch_status_t	switch_core_chat_send_args (const char *dest_proto, const char *proto, const char *from, const char *to, const char *subject, const char *body, const char *type, const char *hint, switch_bool_t blocking)
switch_status_t	switch_core_chat_send (const char *dest_proto, switch_event_t *message_event)
switch_status_t	switch_core_chat_deliver (const char *dest_proto, switch_event_t **message_event)
switch_status_t	switch_ivr_preprocess_session (switch_core_session_t *session, const char *cmds)
void	switch_core_sqldb_pause (void)
void	switch_core_sqldb_resume (void)
static const char *	switch_cache_db_type_name (switch_cache_db_handle_type_t type)
switch_cache_db_handle_type_t	switch_cache_db_get_type (switch_cache_db_handle_t *dbh)
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...
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...
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...
switch_status_t	_switch_cache_db_get_db_handle_dsn_ex (switch_cache_db_handle_t **dbh, const char *dsn, switch_bool_t make_module_no_unloadable, const char *file, const char *func, int line)
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_create_schema (switch_cache_db_handle_t *dbh, char *sql, char **err)
	Executes the create schema sql. 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_execute_sql (switch_cache_db_handle_t *dbh, char *sql, char **err)
	Executes the sql. More...
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...
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...
void	switch_cache_db_status (switch_stream_handle_t *stream)
	Provides some feedback as to the status of the db connection pool. More...
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...
switch_bool_t	switch_cache_db_test_reactive (switch_cache_db_handle_t *db, 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...
switch_bool_t	switch_cache_db_test_reactive_ex (switch_cache_db_handle_t *db, const char *test_sql, const char *drop_sql, const char *reactive_sql, const char *row_size_limited_reactive_sql)
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)
void	switch_cache_db_database_interface_flush_handles (switch_database_interface_t *database_interface)
switch_status_t	switch_core_check_core_db_dsn (void)
	Returns error if no suitable database interface found to serve core db dsn. More...
switch_status_t	switch_database_available (char *dsn)
	Returns error if no suitable database interface found for a dsn. More...
void	switch_core_set_signal_handlers (void)
uint32_t	switch_core_debug_level (void)
int32_t	switch_core_sps (void)
int32_t	switch_core_sps_last (void)
int32_t	switch_core_sps_peak (void)
int32_t	switch_core_sps_peak_fivemin (void)
int32_t	switch_core_sessions_peak (void)
int32_t	switch_core_sessions_peak_fivemin (void)
void	switch_cache_db_flush_handles (void)
const char *	switch_core_banner (void)
switch_bool_t	switch_core_session_in_thread (switch_core_session_t *session)
uint32_t	switch_default_ptime (const char *name, uint32_t number)
uint32_t	switch_default_rate (const char *name, uint32_t number)
uint32_t	switch_core_max_audio_channels (uint32_t limit)
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...
uint16_t	switch_core_get_rtp_port_range_start_port (void)
	Get RTP port range start value. More...
uint16_t	switch_core_get_rtp_port_range_end_port (void)
	Get RTP port range end value. More...
char *	switch_say_file_handle_get_variable (switch_say_file_handle_t *sh, const char *var)
char *	switch_say_file_handle_get_path (switch_say_file_handle_t *sh)
char *	switch_say_file_handle_detach_path (switch_say_file_handle_t *sh)
void	switch_say_file_handle_destroy (switch_say_file_handle_t **sh)
switch_status_t	switch_say_file_handle_create (switch_say_file_handle_t **sh, const char *ext, switch_event_t **var_event)
void	switch_say_file (switch_say_file_handle_t *sh, const char *fmt,...)
int	switch_max_file_desc (void)
void	switch_close_extra_files (int *keep, int keep_ttl)
switch_status_t	switch_core_thread_set_cpu_affinity (int cpu)
void	switch_os_yield (void)
switch_status_t	switch_core_get_stacksizes (switch_size_t *cur, switch_size_t *max)
void	switch_core_gen_encoded_silence (unsigned char *data, const switch_codec_implementation_t *read_impl, switch_size_t len)
switch_cache_db_handle_type_t	switch_core_dbtype (void)
void	switch_core_sql_exec (const char *sql)
int	switch_core_recovery_recover (const char *technology, const char *profile_name)
void	switch_core_recovery_untrack (switch_core_session_t *session, switch_bool_t force)
void	switch_core_recovery_track (switch_core_session_t *session)
void	switch_core_recovery_flush (const char *technology, const char *profile_name)
void	switch_sql_queue_manager_pause (switch_sql_queue_manager_t *qm, switch_bool_t flush)
void	switch_sql_queue_manager_resume (switch_sql_queue_manager_t *qm)
int	switch_sql_queue_manager_size (switch_sql_queue_manager_t *qm, uint32_t index)
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_push (switch_sql_queue_manager_t *qm, const char *sql, uint32_t pos, switch_bool_t dup)
switch_status_t	switch_sql_queue_manager_destroy (switch_sql_queue_manager_t **qmp)
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)
switch_status_t	switch_sql_queue_manager_start (switch_sql_queue_manager_t *qm)
switch_status_t	switch_sql_queue_manager_stop (switch_sql_queue_manager_t *qm)
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)
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)
pid_t	switch_fork (void)
int	switch_core_gen_certs (const char *prefix)
switch_bool_t	switch_core_check_dtls_pem (const char *file)
int	switch_core_cert_gen_fingerprint (const char *prefix, dtls_fingerprint_t *fp)
int	switch_core_cert_expand_fingerprint (dtls_fingerprint_t *fp, const char *str)
int	switch_core_cert_verify (dtls_fingerprint_t *fp)
switch_status_t	_switch_core_session_request_video_refresh (switch_core_session_t *session, int force, const char *file, const char *func, int line)
switch_status_t	switch_core_session_send_and_request_video_refresh (switch_core_session_t *session)
int	switch_stream_system_fork (const char *cmd, switch_stream_handle_t *stream)
int	switch_spawn (const char *cmd, switch_bool_t wait)
int	switch_stream_spawn (const char *cmd, switch_bool_t shell, switch_bool_t wait, switch_stream_handle_t *stream)
void	switch_core_session_debug_pool (switch_stream_handle_t *stream)
switch_status_t	switch_core_session_override_io_routines (switch_core_session_t *session, switch_io_routines_t *ior)
const char *	switch_version_major (void)
const char *	switch_version_minor (void)
const char *	switch_version_micro (void)
const char *	switch_version_revision (void)
const char *	switch_version_revision_human (void)
const char *	switch_version_full (void)
const char *	switch_version_full_human (void)
void	switch_core_autobind_cpu (void)
switch_status_t	switch_core_session_start_text_thread (switch_core_session_t *session)
const char *	switch_core_get_event_channel_key_separator (void)

Detailed Description

Core Library.

This module is the main core library and is the intended location of all fundamental operations.

Definition in file switch_core.h.

Macro Definition Documentation

CACHE_DB_LEN

#define CACHE_DB_LEN   256

Definition at line 2555 of file switch_core.h.

Referenced by _switch_cache_db_get_db_handle(), and switch_cache_db_status().

DTLS_SRTP_FNAME

#define DTLS_SRTP_FNAME   "dtls-srtp"

Definition at line 148 of file switch_core.h.

Referenced by generate_local_fingerprint(), switch_core_media_init(), and switch_rtp_add_dtls().

MAX_FPLEN

#define MAX_FPLEN   64

Definition at line 149 of file switch_core.h.

Referenced by switch_core_cert_expand_fingerprint(), and switch_core_cert_verify().

MAX_FPSTRLEN

#define MAX_FPSTRLEN   192

Definition at line 150 of file switch_core.h.

MESSAGE_STAMP_FFL

#define MESSAGE_STAMP_FFL

(

_m

)

_m->_file = __FILE__; _m->_func = __SWITCH_FUNC__; _m->_line = __LINE__

Definition at line 175 of file switch_core.h.

Referenced by hanguphook(), send_display(), switch_channel_perform_audio_sync(), and switch_channel_perform_video_sync().

MESSAGE_STRING_ARG_MAX

#define MESSAGE_STRING_ARG_MAX   10

Definition at line 177 of file switch_core.h.

Referenced by switch_core_session_free_message().

switch_cache_db_get_db_handle

#define switch_cache_db_get_db_handle	(		_a,
			_b,
			_c
	)		_switch_cache_db_get_db_handle(_a, _b, _c, __FILE__, __SWITCH_FUNC__, __LINE__)

Definition at line 2653 of file switch_core.h.

switch_cache_db_get_db_handle_dsn

#define switch_cache_db_get_db_handle_dsn	(		_a,
			_b
	)		_switch_cache_db_get_db_handle_dsn(_a, _b, __FILE__, __SWITCH_FUNC__, __LINE__)

Definition at line 2659 of file switch_core.h.

Referenced by sql_in_thread(), switch_sql_queue_manager_push_confirm(), and switch_user_sql_thread().

switch_cache_db_persistant_execute_trans

#define switch_cache_db_persistant_execute_trans	(		_d,
			_s,
			_r
	)		switch_cache_db_persistant_execute_trans_full(_d, _s, _r, NULL, NULL, NULL, NULL)

Definition at line 2741 of file switch_core.h.

switch_core_db_handle

#define switch_core_db_handle

(

_a

)

_switch_core_db_handle(_a, __FILE__, __SWITCH_FUNC__, __LINE__)

Definition at line 2729 of file switch_core.h.

Referenced by switch_console_complete(), switch_console_expand_alias(), switch_console_list_uuid(), switch_console_set_alias(), switch_core_recovery_flush(), switch_core_recovery_recover(), and switch_core_sqldb_start().

switch_core_session_force_request_video_refresh

#define switch_core_session_force_request_video_refresh

(

_s

)

_switch_core_session_request_video_refresh(_s, 1, __FILE__, __SWITCH_FUNC__, __LINE__)

Definition at line 2882 of file switch_core.h.

switch_core_session_request_video_refresh

#define switch_core_session_request_video_refresh

(

_s

)

_switch_core_session_request_video_refresh(_s, 0, __FILE__, __SWITCH_FUNC__, __LINE__)

Definition at line 2881 of file switch_core.h.

Referenced by check_jitter(), do_flush(), dtls_state_ready(), eavesdrop_callback(), jb_next_packet_by_seq(), process_rtcp_report(), read_rtp_packet(), record_callback(), rtp_common_write(), switch_channel_perform_video_sync(), switch_channel_set_flag_value(), switch_core_media_set_video_file(), switch_core_media_toggle_hold(), switch_core_session_execute_application_get_flags(), switch_core_session_passthru(), switch_core_session_read_video_frame(), switch_core_session_send_and_request_video_refresh(), switch_core_session_stop_media(), switch_core_session_video_reinit(), switch_core_session_video_reset(), switch_core_session_wait_for_video_input_params(), switch_ivr_eavesdrop_session(), switch_ivr_record_file_event(), switch_jb_get_packet(), switch_jb_reset(), switch_rtp_set_video_buffer_size(), text_bridge_thread(), video_helper_thread(), and video_write_thread().

SWITCH_MAX_CORE_THREAD_SESSION_OBJS

#define SWITCH_MAX_CORE_THREAD_SESSION_OBJS   128

Definition at line 47 of file switch_core.h.

SWITCH_MAX_STREAMS

#define SWITCH_MAX_STREAMS   128

Definition at line 48 of file switch_core.h.

switch_sql_queue_manager_init

#define switch_sql_queue_manager_init	(		_q,
			_n,
			_d,
			_m,
			_p1,
			_p2,
			_ip1,
			_ip2
	)		switch_sql_queue_manager_init_name(__FILE__, _q, _n, _d, _m, _p1, _p2, _ip1, _ip2)

Definition at line 2850 of file switch_core.h.

Typedef Documentation

dtls_fingerprint_t

typedef struct dtls_fp_s dtls_fingerprint_t

switch_cache_db_handle_t

typedef struct switch_cache_db_handle switch_cache_db_handle_t

Definition at line 2600 of file switch_core.h.

switch_core_db_event_callback_func_t

typedef int(* switch_core_db_event_callback_func_t) (void *pArg, switch_event_t *event)

Definition at line 2553 of file switch_core.h.

switch_device_node_t

typedef struct device_uuid_node_s switch_device_node_t

switch_device_record_t

typedef struct switch_device_record_s switch_device_record_t

switch_device_state_function_t

typedef void(* switch_device_state_function_t) (switch_core_session_t *session, switch_channel_callstate_t callstate, switch_device_record_t *drec)

Definition at line 145 of file switch_core.h.

switch_device_stats_t

typedef struct switch_device_stats_s switch_device_stats_t

switch_hold_record_t

typedef struct switch_hold_record_s switch_hold_record_t

switch_thread_data_t

typedef struct switch_thread_data_s switch_thread_data_t

Enumeration Type Documentation

cache_db_flag_t

enum cache_db_flag_t

Enumerator
CDF_INUSE
CDF_PRUNE
CDF_NONEXPIRING

Definition at line 2556 of file switch_core.h.

             {
        CDF_INUSE = (1 << 0),
        CDF_PRUNE = (1 << 1),
        CDF_NONEXPIRING = (1 << 2)
} cache_db_flag_t;

dtls_state_t

enum dtls_state_t

Enumerator
DS_OFF
DS_HANDSHAKE
DS_SETUP
DS_READY
DS_FAIL
DS_INVALID

Definition at line 166 of file switch_core.h.

             {
        DS_OFF,
        DS_HANDSHAKE,
        DS_SETUP,
        DS_READY,
        DS_FAIL,
        DS_INVALID,
} dtls_state_t;

dtls_type_t

enum dtls_type_t

Enumerator
DTLS_TYPE_CLIENT
DTLS_TYPE_SERVER
DTLS_TYPE_RTP
DTLS_TYPE_RTCP

Definition at line 159 of file switch_core.h.

             {
        DTLS_TYPE_CLIENT = (1 << 0),
        DTLS_TYPE_SERVER = (1 << 1),
        DTLS_TYPE_RTP = (1 << 2),
        DTLS_TYPE_RTCP = (1 << 3)
} dtls_type_t;

switch_cache_db_handle_type_t

enum switch_cache_db_handle_type_t

Enumerator
SCDB_TYPE_CORE_DB
SCDB_TYPE_ODBC
SCDB_TYPE_DATABASE_INTERFACE

Definition at line 2562 of file switch_core.h.

             {
        SCDB_TYPE_CORE_DB,
        SCDB_TYPE_ODBC,
        SCDB_TYPE_DATABASE_INTERFACE
} switch_cache_db_handle_type_t;

Function Documentation

_switch_cache_db_get_db_handle()

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 507 of file switch_core_sqldb.c.

References add_handle(), CACHE_DB_LEN, switch_database_interface_handle::connection_options, switch_cache_db_database_interface_options_t::connection_string, switch_cache_db_native_handle_t::core_db_dbh, switch_cache_db_connection_options_t::core_db_options, create_handle(), switch_cache_db_database_interface_options_t::database_interface, switch_cache_db_native_handle_t::database_interface_dbh, switch_cache_db_connection_options_t::database_interface_options, switch_runtime::db_handle_timeout, switch_cache_db_core_db_options_t::db_path, destroy_handle(), switch_cache_db_odbc_options_t::dsn, get_handle(), switch_coredb_handle::handle, switch_database_interface::handle_new, switch_coredb_handle::in_memory, switch_cache_db_core_db_options_t::in_memory, switch_cache_db_handle::last_used, switch_cache_db_database_interface_options_t::make_module_no_unloadable, switch_runtime::max_db_handles, switch_loadable_module_interface::module_name, switch_cache_db_handle::name, switch_cache_db_handle::native_handle, switch_cache_db_native_handle_t::odbc_dbh, switch_cache_db_connection_options_t::odbc_options, switch_cache_db_database_interface_options_t::original_dsn, switch_database_interface::parent, switch_cache_db_odbc_options_t::pass, switch_cache_db_handle::pool, switch_cache_db_database_interface_options_t::prefix, PROTECT_INTERFACE, runtime, SCDB_TYPE_CORE_DB, SCDB_TYPE_DATABASE_INTERFACE, SCDB_TYPE_ODBC, sql_manager, switch_cache_db_type_name(), SWITCH_CHANNEL_ID_LOG, SWITCH_CHANNEL_LOG, switch_core_alloc, switch_core_db_close(), switch_core_db_open_file(), switch_core_db_open_in_memory(), switch_epoch_time_now(), switch_loadable_module_protect(), 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_STATUS_FALSE, SWITCH_STATUS_SUCCESS, switch_thread_self(), SWITCH_TRUE, switch_yield, switch_cache_db_handle::type, UNPROTECT_INTERFACE, and switch_cache_db_odbc_options_t::user.

Referenced by _switch_cache_db_get_db_handle_dsn_ex(), and switch_cache_db_type_name().

{
        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_DATABASE_INTERFACE:
                {
                        db_name = connection_options->database_interface_options.connection_string;
                        odbc_user = NULL;
                        odbc_pass = NULL;
                        db_type = "database_interface";
                }
                break;
        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))) {
                if (type == SCDB_TYPE_DATABASE_INTERFACE) {
                        switch_log_printf(SWITCH_CHANNEL_ID_LOG, file, func, line, NULL, SWITCH_LOG_DEBUG10,
                                "Reuse Unused Cached DB handle %s [Database interface prefix: %s]\n", new_dbh->name, connection_options->database_interface_options.prefix);
                } else {
                        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_database_interface_handle_t *database_interface_dbh = NULL;              

                switch (type) {
                case SCDB_TYPE_DATABASE_INTERFACE:
                        {
                                switch_database_interface_t *database_interface = connection_options->database_interface_options.database_interface;

                                if (SWITCH_STATUS_SUCCESS != database_interface->handle_new(connection_options->database_interface_options, &database_interface_dbh)) {
                                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Failure! Can't create new handle! Can't connect to DSN %s\n", connection_options->database_interface_options.original_dsn);
                                        goto end;
                                }

                                if (database_interface_dbh) {
                                        database_interface_dbh->connection_options = connection_options->database_interface_options;
                                
                                        if (connection_options->database_interface_options.make_module_no_unloadable == SWITCH_TRUE)
                                        {
                                                PROTECT_INTERFACE(database_interface)
                                                        switch_loadable_module_protect(database_interface->parent->module_name);
                                                UNPROTECT_INTERFACE(database_interface)
                                        }
                                }
                        }
                        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:
                        {
                                if (!connection_options->core_db_options.in_memory) {
                                        db = switch_core_db_open_file(connection_options->core_db_options.db_path);
                                } else {
                                        db = switch_core_db_open_in_memory(connection_options->core_db_options.db_path);
                                }
                        }
                        break;

                default:
                        goto end;
                }

                if (!db && !odbc_dbh && !database_interface_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 (database_interface_dbh) {
                        new_dbh->native_handle.database_interface_dbh = database_interface_dbh;
                } else if (db) {
                        if (!(new_dbh->native_handle.core_db_dbh = switch_core_alloc(new_dbh->pool, sizeof(*new_dbh->native_handle.core_db_dbh)))) {
                                destroy_handle(&new_dbh);
                                switch_core_db_close(db);
                                goto end;
                        }
                        new_dbh->native_handle.core_db_dbh->handle = db;
                        new_dbh->native_handle.core_db_dbh->in_memory = connection_options->core_db_options.in_memory;
                } else if (odbc_dbh) {
                        new_dbh->native_handle.odbc_dbh = odbc_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_cache_db_get_db_handle_dsn()

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 427 of file switch_core_sqldb.c.

References _switch_cache_db_get_db_handle_dsn_ex(), and SWITCH_FALSE.

{
        return _switch_cache_db_get_db_handle_dsn_ex(dbh, dsn, SWITCH_FALSE, file, func, line);
}

_switch_cache_db_get_db_handle_dsn_ex()

switch_status_t _switch_cache_db_get_db_handle_dsn_ex	(	switch_cache_db_handle_t **	dbh,
		const char *	dsn,
		switch_bool_t	make_module_no_unloadable,
		const char *	file,
		const char *	func,
		int	line
	)

Definition at line 433 of file switch_core_sqldb.c.

References _switch_cache_db_get_db_handle(), switch_cache_db_database_interface_options_t::connection_string, switch_cache_db_connection_options_t::core_db_options, switch_cache_db_database_interface_options_t::database_interface, switch_cache_db_connection_options_t::database_interface_options, switch_cache_db_core_db_options_t::db_path, switch_cache_db_odbc_options_t::dsn, switch_cache_db_core_db_options_t::in_memory, switch_cache_db_database_interface_options_t::make_module_no_unloadable, MIN, switch_cache_db_connection_options_t::odbc_options, switch_cache_db_database_interface_options_t::original_dsn, switch_cache_db_odbc_options_t::pass, switch_cache_db_database_interface_options_t::prefix, SCDB_TYPE_CORE_DB, SCDB_TYPE_DATABASE_INTERFACE, SCDB_TYPE_ODBC, switch_loadable_module_get_database_interface(), switch_set_string, SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, SWITCH_TRUE, switch_cache_db_handle::type, UNPROTECT_INTERFACE, and switch_cache_db_odbc_options_t::user.

Referenced by _switch_cache_db_get_db_handle_dsn(), and _switch_core_db_handle().

{
        switch_cache_db_connection_options_t connection_options = { {0} };
        switch_cache_db_handle_type_t type = SCDB_TYPE_CORE_DB;
        switch_database_interface_t *database_interface = NULL;
        char tmp[256] = "";
        char *p;
        switch_status_t status = SWITCH_STATUS_FALSE;
        int i;

        char *colon_slashes = NULL;
        if ( NULL != (colon_slashes = strstr(dsn, "://")) )
        {
                char prefix[16] = "";
                strncpy(prefix, dsn, MIN(colon_slashes - dsn, 15));

                if ((database_interface = switch_loadable_module_get_database_interface(prefix, NULL))) {
                        type = SCDB_TYPE_DATABASE_INTERFACE;
                        connection_options.database_interface_options.make_module_no_unloadable = make_module_no_unloadable;
                        connection_options.database_interface_options.database_interface = database_interface;
                        connection_options.database_interface_options.original_dsn = dsn;
                        connection_options.database_interface_options.connection_string = colon_slashes + 3;
                        strcpy(connection_options.database_interface_options.prefix, prefix);
                        UNPROTECT_INTERFACE(database_interface);
                }
        }

        if (!connection_options.database_interface_options.connection_string)
        {
                if (!strncasecmp(dsn, "sqlite://", 9)) {
                        type = SCDB_TYPE_CORE_DB;
                        connection_options.core_db_options.db_path = (char *)(dsn + 9);
                        if (!strncasecmp(connection_options.core_db_options.db_path, "memory://", 9)) {
                                connection_options.core_db_options.in_memory = SWITCH_TRUE;
                                connection_options.core_db_options.db_path = (char *)(connection_options.core_db_options.db_path + 9);
                        }
                }
                else if ((!(i = strncasecmp(dsn, "odbc://", 7))) || (strchr(dsn + 2, ':') && !colon_slashes)) {
                        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_core_db_handle()

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 235 of file switch_core_sqldb.c.

References _switch_cache_db_get_db_handle_dsn_ex(), switch_runtime::dbname, switch_runtime::odbc_dsn, runtime, sql_manager, SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, SWITCH_TRUE, 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_ex(dbh, dsn, SWITCH_TRUE, file, func, line)) != SWITCH_STATUS_SUCCESS) {
                *dbh = NULL;
        }

        return r;
}

_switch_core_session_request_video_refresh()

switch_status_t _switch_core_session_request_video_refresh	(	switch_core_session_t *	session,
		int	force,
		const char *	file,
		const char *	func,
		int	line
	)

Definition at line 14529 of file switch_core_media.c.

References switch_core_session_message::_file, switch_core_session_message::_func, switch_core_session_message::_line, CF_VIDEO, switch_core_session::channel, switch_core_session_message::from, switch_media_handle_s::last_video_refresh_req, switch_core_session::media_handle, switch_core_session_message::message_id, switch_core_session_message::numeric_arg, switch_assert, switch_channel_get_name(), SWITCH_CHANNEL_ID_LOG, switch_channel_media_up, switch_channel_test_flag(), switch_core_session_get_channel(), switch_core_session_get_uuid(), switch_core_session_receive_message, SWITCH_LOG_DEBUG1, switch_log_printf(), SWITCH_MESSAGE_INDICATE_VIDEO_REFRESH_REQ, switch_micro_time_now(), SWITCH_STATUS_BREAK, SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, and VIDEO_REFRESH_FREQ.

{
        switch_channel_t *channel = switch_core_session_get_channel(session);
        switch_media_handle_t *smh = NULL;

        switch_assert(session);

        if (!(smh = session->media_handle)) {
                return SWITCH_STATUS_FALSE;
        }

        if (switch_channel_media_up(channel) && switch_channel_test_flag(channel, CF_VIDEO)) {
                switch_core_session_message_t msg = { 0 };
                switch_time_t now = switch_micro_time_now();

                if (!force && (smh->last_video_refresh_req && (now - smh->last_video_refresh_req) < VIDEO_REFRESH_FREQ)) {
                        return SWITCH_STATUS_BREAK;
                }

                smh->last_video_refresh_req = now;

                if (force) {
                        msg.numeric_arg = 1;
                }

                msg._file = file;
                msg._func = func;
                msg._line = line;
                switch_log_printf(SWITCH_CHANNEL_ID_LOG, file, func, line, switch_core_session_get_uuid(session), 
                                                  SWITCH_LOG_DEBUG1, "%s Video refresh requested.\n", switch_channel_get_name(session->channel));
                msg.from = __FILE__;
                msg.message_id = SWITCH_MESSAGE_INDICATE_VIDEO_REFRESH_REQ;
                switch_core_session_receive_message(session, &msg);
                return SWITCH_STATUS_SUCCESS;
        }

        return SWITCH_STATUS_FALSE;
}

switch_cache_db_affected_rows()

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 815 of file switch_core_sqldb.c.

References switch_database_interface::affected_rows, switch_database_interface_handle::connection_options, switch_cache_db_native_handle_t::core_db_dbh, switch_cache_db_database_interface_options_t::database_interface, switch_cache_db_native_handle_t::database_interface_dbh, switch_coredb_handle::handle, switch_cache_db_handle::native_handle, switch_cache_db_native_handle_t::odbc_dbh, SCDB_TYPE_CORE_DB, SCDB_TYPE_DATABASE_INTERFACE, SCDB_TYPE_ODBC, switch_core_db_changes(), switch_odbc_handle_affected_rows(), and switch_cache_db_handle::type.

{
        switch (dbh->type) {
        case SCDB_TYPE_CORE_DB:
                {
                        return switch_core_db_changes(dbh->native_handle.core_db_dbh->handle);
                }
                break;
        case SCDB_TYPE_ODBC:
                {
                        return switch_odbc_handle_affected_rows(dbh->native_handle.odbc_dbh);
                }
                break;
        case SCDB_TYPE_DATABASE_INTERFACE:
                {
                        switch_database_interface_t *database_interface = dbh->native_handle.database_interface_dbh->connection_options.database_interface;
                        int affected_rows = 0;
                        database_interface->affected_rows(dbh->native_handle.database_interface_dbh, &affected_rows);
                        return affected_rows;
                }
                break;
        }
        return 0;
}

switch_cache_db_create_schema()

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

switch_cache_db_database_interface_flush_handles()

void switch_cache_db_database_interface_flush_handles

(

switch_database_interface_t *

database_interface

)

Definition at line 148 of file switch_core_sqldb.c.

References switch_database_interface_handle::connection_options, switch_cache_db_database_interface_options_t::database_interface, switch_cache_db_native_handle_t::database_interface_dbh, del_handle(), destroy_handle(), switch_database_interface::handle_destroy, switch_cache_db_handle::mutex, switch_cache_db_handle::name, switch_cache_db_handle::native_handle, switch_cache_db_handle::next, SCDB_TYPE_DATABASE_INTERFACE, sql_manager, SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG10, switch_log_printf(), switch_mutex_lock(), switch_mutex_trylock(), switch_mutex_unlock(), SWITCH_STATUS_SUCCESS, and switch_cache_db_handle::type.

Referenced by switch_loadable_module_unprocess().

{
        switch_cache_db_handle_t *dbh_ptr = NULL;

        switch_mutex_lock(sql_manager.dbh_mutex);

top:

        for (dbh_ptr = sql_manager.handle_pool; dbh_ptr; dbh_ptr = dbh_ptr->next) {
                if (switch_mutex_trylock(dbh_ptr->mutex) == SWITCH_STATUS_SUCCESS) {
                        if (dbh_ptr->type != SCDB_TYPE_DATABASE_INTERFACE) {
                                switch_mutex_unlock(dbh_ptr->mutex);
                                continue;
                        }

                        if (dbh_ptr->native_handle.database_interface_dbh->connection_options.database_interface != database_interface) {
                                switch_mutex_unlock(dbh_ptr->mutex);
                                continue;
                        }

                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG10, "Dropping DB connection %s\n", dbh_ptr->name);

                        database_interface->handle_destroy(&dbh_ptr->native_handle.database_interface_dbh);

                        del_handle(dbh_ptr);
                        switch_mutex_unlock(dbh_ptr->mutex);
                        destroy_handle(&dbh_ptr);
                        goto top;
                }
        }

        switch_mutex_unlock(sql_manager.dbh_mutex);
}

switch_cache_db_dismiss_db_handle()

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 379 of file switch_core_sqldb.c.

References switch_cache_db_release_db_handle().

Referenced by switch_cache_db_type_name().

{
        switch_cache_db_release_db_handle(dbh);
}

switch_cache_db_execute_sql()

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 799 of file switch_core_sqldb.c.

References switch_cache_db_execute_sql_chunked(), SWITCH_STATUS_FALSE, and switch_cache_db_handle::type.

Referenced by do_flush(), do_trans(), switch_cache_db_create_schema(), switch_cache_db_persistant_execute_trans_full(), switch_cache_db_test_reactive_ex(), 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 (dbh->type) {
        default:
                {
                        status = switch_cache_db_execute_sql_chunked(dbh, (char *) sql, 32768, err);
                }
                break;
        }

        return status;
}

switch_cache_db_execute_sql2str()

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 864 of file switch_core_sqldb.c.

References switch_database_interface_handle::connection_options, switch_cache_db_native_handle_t::core_db_dbh, switch_cache_db_database_interface_options_t::database_interface, switch_cache_db_native_handle_t::database_interface_dbh, switch_database_interface::exec_string, switch_coredb_handle::handle, memset(), switch_cache_db_handle::native_handle, switch_cache_db_native_handle_t::odbc_dbh, running, SCDB_TYPE_CORE_DB, SCDB_TYPE_DATABASE_INTERFACE, SCDB_TYPE_ODBC, 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_odbc_handle_exec_string(), SWITCH_ODBC_SUCCESS, SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, and switch_cache_db_handle::type.

{
        switch_status_t status = SWITCH_STATUS_FALSE;

        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->handle, sql, -1, &stmt, 0)) {
                                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Statement Error [%s]!\n", sql);
                                goto end;
                        } else {
                                int running = 1;

                                while (running < 5000) {
                                        int result = switch_core_db_step(stmt);
                                        const unsigned char *txt;

                                        if (result == SWITCH_CORE_DB_ROW) {
                                                if (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;
                                                        }
                                                }
                                                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) == SWITCH_ODBC_SUCCESS ? SWITCH_STATUS_SUCCESS : SWITCH_STATUS_FALSE;
                }
                break;
        case SCDB_TYPE_DATABASE_INTERFACE:
                {
                        switch_database_interface_t *database_interface = dbh->native_handle.database_interface_dbh->connection_options.database_interface;
                        status = database_interface->exec_string(dbh->native_handle.database_interface_dbh, sql, str, len, err);
                }
                break;
        }

 end:

        return status == SWITCH_STATUS_SUCCESS ? str : NULL;

}

switch_cache_db_execute_sql_callback()

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 1285 of file switch_core_sqldb.c.

References switch_database_interface_handle::connection_options, switch_cache_db_native_handle_t::core_db_dbh, switch_cache_db_database_interface_options_t::database_interface, switch_cache_db_native_handle_t::database_interface_dbh, database_interface_handle_callback_exec, switch_coredb_handle::handle, switch_cache_db_handle::last_used, switch_cache_db_handle::native_handle, switch_cache_db_native_handle_t::odbc_dbh, SCDB_TYPE_CORE_DB, SCDB_TYPE_DATABASE_INTERFACE, SCDB_TYPE_ODBC, 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_odbc_handle_callback_exec, SWITCH_ODBC_SUCCESS, switch_snprintfv(), SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, and switch_cache_db_handle::type.

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;

        if (err) {
                *err = NULL;
        }

        switch (dbh->type) {
                case SCDB_TYPE_DATABASE_INTERFACE:
                {
                        switch_database_interface_t *database_interface = dbh->native_handle.database_interface_dbh->connection_options.database_interface;

                        if ((status = database_interface_handle_callback_exec(database_interface, dbh->native_handle.database_interface_dbh, sql, callback, pdata, err)) != SWITCH_STATUS_SUCCESS) {
                                char tmp[100];
                                switch_snprintfv(tmp, sizeof(tmp), "%q-%i", "Unable to execute_sql_callback", status);
                        }
                }
                break;
        case SCDB_TYPE_ODBC:
                {
                        status = switch_odbc_handle_callback_exec(dbh->native_handle.odbc_dbh, sql, callback, pdata, err) == SWITCH_ODBC_SUCCESS ? SWITCH_STATUS_SUCCESS : SWITCH_STATUS_FALSE;
                }
                break;
        case SCDB_TYPE_CORE_DB:
                {
                        int ret = switch_core_db_exec(dbh->native_handle.core_db_dbh->handle, 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;
        }

        return status;
}

switch_cache_db_execute_sql_callback_err()

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 1333 of file switch_core_sqldb.c.

References switch_database_interface_handle::connection_options, switch_cache_db_native_handle_t::core_db_dbh, switch_cache_db_database_interface_options_t::database_interface, switch_cache_db_native_handle_t::database_interface_dbh, database_interface_handle_callback_exec, switch_coredb_handle::handle, switch_cache_db_handle::last_used, switch_cache_db_handle::native_handle, switch_cache_db_native_handle_t::odbc_dbh, helper::pdata, SCDB_TYPE_CORE_DB, SCDB_TYPE_DATABASE_INTERFACE, SCDB_TYPE_ODBC, 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_odbc_handle_callback_exec, SWITCH_ODBC_SUCCESS, switch_snprintfv(), SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, and switch_cache_db_handle::type.

Referenced by sql_in_thread().

{
        switch_status_t status = SWITCH_STATUS_FALSE;
        char *errmsg = NULL;

        if (err) {
                *err = NULL;
        }

        switch (dbh->type) {
        case SCDB_TYPE_DATABASE_INTERFACE:
                {
                        switch_database_interface_t *database_interface = dbh->native_handle.database_interface_dbh->connection_options.database_interface;

                        if ((status = database_interface_handle_callback_exec(database_interface, dbh->native_handle.database_interface_dbh, sql, callback, pdata, err)) != SWITCH_STATUS_SUCCESS) {
                                char tmp[100];
                                switch_snprintfv(tmp, sizeof(tmp), "%q-%i", "Unable to execute_sql_callback_err", status);
                        }
                        
                        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) == SWITCH_ODBC_SUCCESS ? SWITCH_STATUS_SUCCESS : SWITCH_STATUS_FALSE;
                        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->handle, 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;
        }

        return status;
}

switch_cache_db_execute_sql_event_callback()

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 1165 of file switch_core_sqldb.c.

References helper::callback, switch_database_interface_handle::connection_options, switch_cache_db_native_handle_t::core_db_dbh, switch_cache_db_database_interface_options_t::database_interface, switch_cache_db_native_handle_t::database_interface_dbh, database_interface_handle_callback_exec, switch_coredb_handle::handle, helper_callback(), switch_cache_db_handle::last_used, switch_cache_db_handle::native_handle, switch_cache_db_native_handle_t::odbc_dbh, helper::pdata, SCDB_TYPE_CORE_DB, SCDB_TYPE_DATABASE_INTERFACE, SCDB_TYPE_ODBC, 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_odbc_handle_callback_exec, SWITCH_ODBC_SUCCESS, switch_snprintfv(), SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, and switch_cache_db_handle::type.

Referenced by sql_in_thread().

{
        switch_status_t status = SWITCH_STATUS_FALSE;
        char *errmsg = NULL;
        struct helper h = {0};

        if (err) {
                *err = NULL;
        }

        h.callback = callback;
        h.pdata = pdata;

        switch (dbh->type) {
                case SCDB_TYPE_DATABASE_INTERFACE:
                {
                        switch_database_interface_t *database_interface = dbh->native_handle.database_interface_dbh->connection_options.database_interface;

                        if ((status = database_interface_handle_callback_exec(database_interface, dbh->native_handle.database_interface_dbh, sql, helper_callback, &h, err)) != SWITCH_STATUS_SUCCESS) {
                                char tmp[100];
                                switch_snprintfv(tmp, sizeof(tmp), "%q-%i", "Unable to execute_sql_event_callback", status);
                        }
                }
                break;
        case SCDB_TYPE_ODBC:
                {
                        status = switch_odbc_handle_callback_exec(dbh->native_handle.odbc_dbh, sql, helper_callback, &h, err) == SWITCH_ODBC_SUCCESS ? SWITCH_STATUS_SUCCESS : SWITCH_STATUS_FALSE;
                }
                break;
        case SCDB_TYPE_CORE_DB:
                {
                        int ret = switch_core_db_exec(dbh->native_handle.core_db_dbh->handle, 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;
        }

        return status;
}

switch_cache_db_flush_handles()

void switch_cache_db_flush_handles

(

void

)

Definition at line 343 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_get_type()

switch_cache_db_handle_type_t switch_cache_db_get_type

(

switch_cache_db_handle_t *

dbh

)

Definition at line 338 of file switch_core_sqldb.c.

References switch_cache_db_handle::type.

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

{
        return dbh->type;
}

switch_cache_db_load_extension()

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 840 of file switch_core_sqldb.c.

References switch_cache_db_native_handle_t::core_db_dbh, switch_coredb_handle::handle, switch_cache_db_handle::native_handle, SCDB_TYPE_CORE_DB, SCDB_TYPE_DATABASE_INTERFACE, SCDB_TYPE_ODBC, SWITCH_CHANNEL_LOG, switch_core_db_load_extension(), SWITCH_LOG_DEBUG, SWITCH_LOG_ERROR, switch_log_printf(), and switch_cache_db_handle::type.

{
        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->handle, 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_DATABASE_INTERFACE:
                {
                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "load extension not supported by type DATABASE_INTERFACE!\n");
                }
                break;
        }
        return 0;
}

switch_cache_db_persistant_execute()

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

Definition at line 924 of file switch_core_sqldb.c.

References switch_cache_db_execute_sql_real(), SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, switch_log_printf(), 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;

        if (!retries) {
                forever = 1;
                retries = 1000;
        }

        while (retries > 0) {

                switch_cache_db_execute_sql_real(dbh, sql, &errmsg);

                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_cache_db_persistant_execute_trans_full()

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 958 of file switch_core_sqldb.c.

References switch_database_interface::commit, switch_database_interface_handle::connection_options, switch_cache_db_database_interface_options_t::database_interface, switch_cache_db_native_handle_t::database_interface_dbh, switch_cache_db_handle::native_handle, switch_cache_db_native_handle_t::odbc_dbh, SCDB_TYPE_CORE_DB, SCDB_TYPE_DATABASE_INTERFACE, SCDB_TYPE_ODBC, switch_database_interface::sql_set_auto_commit_attr, 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_odbc_SQLEndTran(), switch_odbc_SQLSetAutoCommitAttr(), SWITCH_ODBC_SUCCESS, switch_safe_free, switch_snprintfv(), SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, switch_yield, switch_cache_db_handle::type, and zstr.

{
        char *errmsg = NULL;
        switch_status_t status = SWITCH_STATUS_FALSE;
        uint8_t forever = 0;
        unsigned begin_retries = 100;
        uint8_t again = 0;

        if (!retries) {
                forever = 1;
                retries = 1000;
        }

        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_DATABASE_INTERFACE:
                        {
                                switch_database_interface_t *database_interface = dbh->native_handle.database_interface_dbh->connection_options.database_interface;
                                switch_status_t result;

                                if ((result = database_interface->sql_set_auto_commit_attr(dbh->native_handle.database_interface_dbh, 0)) != SWITCH_STATUS_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_DATABASE_INTERFACE:
                                        {
                                                switch_database_interface_t *database_interface = dbh->native_handle.database_interface_dbh->connection_options.database_interface;
                                                switch_status_t result;

                                                if ((result = database_interface->commit(dbh->native_handle.database_interface_dbh)) != SWITCH_STATUS_SUCCESS) {
                                                        char tmp[100];
                                                        switch_snprintfv(tmp, sizeof(tmp), "%q-%i", "Unable to commit transaction", result);
                                                }
                                        }
                                        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_DATABASE_INTERFACE:
                {
                        switch_database_interface_t *database_interface = dbh->native_handle.database_interface_dbh->connection_options.database_interface;
                        switch_status_t result;
        
                        if ((result = database_interface->commit(dbh->native_handle.database_interface_dbh)) != SWITCH_STATUS_SUCCESS) {
                                char tmp[100];
                                switch_snprintfv(tmp, sizeof(tmp), "%q-%i", "Unable to commit transaction", result);
                        }
                }
                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);
                }
        }

        return status;
}

switch_cache_db_release_db_handle()

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 349 of file switch_core_sqldb.c.

References switch_database_interface::flush, SCDB_TYPE_DATABASE_INTERFACE, sql_manager, switch_epoch_time_now(), switch_mutex_lock(), and switch_mutex_unlock().

Referenced by sql_in_thread(), switch_cache_db_dismiss_db_handle(), switch_cache_db_type_name(), 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_DATABASE_INTERFACE:
                        {
                                switch_database_interface_t *database_interface = (*dbh)->native_handle.database_interface_dbh->connection_options.database_interface;
                                database_interface->flush((*dbh)->native_handle.database_interface_dbh);
                        }
                break;
                default:
                        break;
                }

                (*dbh)->last_used = switch_epoch_time_now(NULL);
                if ((*dbh)->use_count) {
                        --(*dbh)->use_count;
                }

                switch_mutex_unlock((*dbh)->mutex);
                *dbh = NULL;

                switch_mutex_lock(sql_manager.dbh_mutex);
                sql_manager.total_used_handles--;
                switch_mutex_unlock(sql_manager.dbh_mutex);
        }
}

switch_cache_db_status()

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 3935 of file switch_core_sqldb.c.

References CACHE_DB_LEN, CDF_NONEXPIRING, count, switch_cache_db_handle::creator, dbh, switch_cache_db_handle::last_used, switch_cache_db_handle::last_user, memset(), switch_cache_db_handle::mutex, switch_cache_db_handle::name, switch_cache_db_handle::next, sql_manager, switch_cache_db_type_name(), switch_epoch_time_now(), SWITCH_FALSE, switch_mutex_lock(), switch_mutex_trylock(), switch_mutex_unlock(), SWITCH_STATUS_SUCCESS, switch_test_flag, SWITCH_TRUE, switch_cache_db_handle::total_used_count, switch_cache_db_handle::type, switch_cache_db_handle::use_count, and switch_stream_handle::write_function.

{
        /* 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) {
                        snprintf(cleankey_str, sizeof(cleankey_str), "%s", 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)%s\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, switch_test_flag(dbh, CDF_NONEXPIRING) ? ", Non-expiring" : "", 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_cache_db_test_reactive()

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 1422 of file switch_core_sqldb.c.

References switch_cache_db_test_reactive_ex().

Referenced by switch_core_sqldb_start().

{
        return switch_cache_db_test_reactive_ex(dbh, test_sql, drop_sql, reactive_sql, NULL);
}

switch_cache_db_test_reactive_ex()

switch_bool_t switch_cache_db_test_reactive_ex	(	switch_cache_db_handle_t *	db,
		const char *	test_sql,
		const char *	drop_sql,
		const char *	reactive_sql,
		const char *	row_size_limited_reactive_sql
	)

Definition at line 1428 of file switch_core_sqldb.c.

References switch_database_interface_handle::connection_options, switch_cache_db_native_handle_t::core_db_dbh, switch_cache_db_database_interface_options_t::database_interface, switch_cache_db_native_handle_t::database_interface_dbh, database_interface_handle_exec, switch_coredb_handle::handle, switch_cache_db_handle::native_handle, switch_cache_db_native_handle_t::odbc_dbh, runtime, SCDB_TYPE_CORE_DB, SCDB_TYPE_DATABASE_INTERFACE, SCDB_TYPE_ODBC, 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_DATABASE_FLAG_ROW_SIZE_LIMIT, SWITCH_FALSE, SWITCH_LOG_DEBUG, switch_log_printf(), switch_odbc_handle_exec(), SWITCH_ODBC_SUCCESS, switch_snprintfv(), SWITCH_STATUS_SUCCESS, switch_test_flag, SWITCH_TRUE, and switch_cache_db_handle::type.

Referenced by switch_cache_db_test_reactive(), and switch_core_sqldb_start().

{
        switch_bool_t r = SWITCH_TRUE;

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

        switch (dbh->type) {
        case SCDB_TYPE_DATABASE_INTERFACE:
                {
                        switch_database_interface_t *database_interface = dbh->native_handle.database_interface_dbh->connection_options.database_interface;
                        switch_status_t result;

                        if ((result = database_interface_handle_exec(database_interface, dbh->native_handle.database_interface_dbh, test_sql, NULL)) != SWITCH_STATUS_SUCCESS) {
                                char tmp[100];
                                switch_snprintfv(tmp, sizeof(tmp), "%q-%i", "Unable to test_reactive with test_sql", result);

                                if (drop_sql) {
                                        if ((result = database_interface_handle_exec(database_interface, dbh->native_handle.database_interface_dbh, drop_sql, NULL)) != SWITCH_STATUS_SUCCESS) {
                                                char tmp[100];
                                                switch_snprintfv(tmp, sizeof(tmp), "%q-%i", "Unable to test_reactive with drop_sql", result);
                                        }
                                }

                                if ((result = database_interface_handle_exec(database_interface, dbh->native_handle.database_interface_dbh, reactive_sql, NULL)) != SWITCH_STATUS_SUCCESS) {
                                        char tmp[100];
                                        switch_snprintfv(tmp, sizeof(tmp), "%q-%i", "Unable to test_reactive with reactive_sql", result);

                                        if (row_size_limited_reactive_sql && switch_test_flag(database_interface, SWITCH_DATABASE_FLAG_ROW_SIZE_LIMIT)) {
                                                if ((result = database_interface_handle_exec(database_interface, dbh->native_handle.database_interface_dbh, row_size_limited_reactive_sql, NULL)) != SWITCH_STATUS_SUCCESS) {
                                                        switch_snprintfv(tmp, sizeof(tmp), "%q-%i", "Unable to test_reactive with row_size_limited_reactive_sql", result);
                                                }
                                        }
                                }

                                r = (result == SWITCH_STATUS_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->handle, 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->handle, 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->handle, 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;
        }

        return r;
}

switch_cache_db_type_name()

static const char* switch_cache_db_type_name ( switch_cache_db_handle_type_t  type )

inlinestatic

Definition at line 2602 of file switch_core.h.

References _switch_cache_db_get_db_handle(), dbh, SCDB_TYPE_CORE_DB, SCDB_TYPE_DATABASE_INTERFACE, SCDB_TYPE_ODBC, switch_cache_db_dismiss_db_handle(), switch_cache_db_get_type(), switch_cache_db_release_db_handle(), SWITCH_DECLARE, and switch_cache_db_handle::type.

Referenced by _switch_cache_db_get_db_handle(), and switch_cache_db_status().

{
        const char *type_str = "INVALID";

        switch (type) {
        case SCDB_TYPE_DATABASE_INTERFACE:
                {
                        type_str = "DATABASE_INTERFACE";
                }
                break;
        case SCDB_TYPE_ODBC:
                {
                        type_str = "ODBC";
                }
                break;
        case SCDB_TYPE_CORE_DB:
                {
                        type_str = "CORE_DB";
                }
                break;
        }

        return type_str;
}

switch_close_extra_files()

void switch_close_extra_files	(	int *	keep,
		int	keep_ttl
	)

Definition at line 3244 of file switch_core.c.

References system_thread_handle::cmd, SWITCH_DECLARE, switch_fork(), switch_max_file_desc(), switch_system_fork(), and switch_system_thread().

Referenced by preprocess_exec(), and switch_system_fork().

{
        int open_max = switch_max_file_desc();
        int i, j;

        for (i = 3; i < open_max; i++) {
                if (keep) {
                        for (j = 0; j < keep_ttl; j++) {
                                if (i == keep[j]) {
                                        goto skip;
                                }
                        }
                }

                close(i);

        skip:

                continue;

        }
}

switch_core_add_registration()

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 3465 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_core_autobind_cpu()

void switch_core_autobind_cpu

(

void

)

Definition at line 7098 of file switch_core_media.c.

References core_video_globals_s::cpu_count, next_cpu(), and switch_core_thread_set_cpu_affinity().

Referenced by video_helper_thread().

{
        if (video_globals.cpu_count > 1) {
                switch_core_thread_set_cpu_affinity(next_cpu());
        }
}

switch_core_banner()

const char* switch_core_banner

(

void

)

Definition at line 2406 of file switch_core.c.

Referenced by switch_core_init_and_modload().

{

        return ("\n"
                        ".=============================================================.\n"
                        "|   _____              ______        _____ _____ ____ _   _   |\n"
                        "|  |  ___| __ ___  ___/ ___\\ \\      / /_ _|_   _/ ___| | | |  |\n"
                        "|  | |_ | '__/ _ \\/ _ \\___ \\\\ \\ /\\ / / | |  | || |   | |_| |  |\n"
                        "|  |  _|| | |  __/  __/___) |\\ V  V /  | |  | || |___|  _  |  |\n"
                        "|  |_|  |_|  \\___|\\___|____/  \\_/\\_/  |___| |_| \\____|_| |_|  |\n"
                        "|                                                             |\n"
                        ".=============================================================."
                        "\n"

                        "|   Anthony Minessale II, Michael Jerris, Brian West, Others  |\n"
                        "|   FreeSWITCH (http://www.freeswitch.org)                    |\n"
                        "|   Paypal Donations Appreciated: paypal@freeswitch.org       |\n"
                        "|   Brought to you by ClueCon http://www.cluecon.com/         |\n"
                        ".=============================================================.\n"
                        "\n");
}

switch_core_cert_expand_fingerprint()

int switch_core_cert_expand_fingerprint	(	dtls_fingerprint_t *	fp,
		const char *	str
	)

Definition at line 162 of file switch_core_cert.c.

References dtls_fp_s::data, and MAX_FPLEN.

Referenced by switch_rtp_add_dtls().

{
        char *tmp = strdup(str);
        char *p = tmp;
        int i = 0;
        char *v;

        while ((v = strsep(&p, ":")) && (i != (MAX_FPLEN - 1))) {
                sscanf(v, "%02x", (uint32_t *) &fp->data[i++]);
        }

        free(tmp);

        return i;
}

switch_core_cert_gen_fingerprint()

int switch_core_cert_gen_fingerprint	(	const char *	prefix,
		dtls_fingerprint_t *	fp
	)

Definition at line 199 of file switch_core_cert.c.

References switch_directories::certs_dir, mkcert(), SWITCH_CHANNEL_LOG, switch_core_cert_extract_fingerprint(), switch_file_exists(), SWITCH_GLOBAL_dirs, SWITCH_LOG_ERROR, switch_log_printf(), switch_mprintf(), SWITCH_PATH_SEPARATOR, and SWITCH_STATUS_SUCCESS.

Referenced by generate_local_fingerprint().

{
        X509* x509 = NULL;
        BIO* bio = NULL;
        int ret = 0;
        char *rsa;

        rsa = switch_mprintf("%s%s%s.pem", SWITCH_GLOBAL_dirs.certs_dir, SWITCH_PATH_SEPARATOR, prefix);

        if (switch_file_exists(rsa, NULL) != SWITCH_STATUS_SUCCESS) {
                free(rsa);
                rsa = switch_mprintf("%s%s%s.crt", SWITCH_GLOBAL_dirs.certs_dir, SWITCH_PATH_SEPARATOR, prefix);
        }

        if (!(bio = BIO_new(BIO_s_file()))) {
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "FP BIO ERR!\n");
                goto end;
        }

        if (BIO_read_filename(bio, rsa) != 1) {
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "FP FILE ERR!\n");
                goto end;
        }

        if (!(x509 = PEM_read_bio_X509(bio, NULL, 0, NULL))) {
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "FP READ ERR!\n");
                goto end;
        }

        switch_core_cert_extract_fingerprint(x509, fp);

        ret = 1;

 end:

        if (bio) {
                BIO_free_all(bio);
        }

        if (x509) {
                X509_free(x509);
        }

        free(rsa);

        return ret;
}

switch_core_cert_verify()

int switch_core_cert_verify

(

dtls_fingerprint_t *

fp

)

Definition at line 143 of file switch_core_cert.c.

References dtls_fp_s::data, MAX_FPLEN, and dtls_fp_s::str.

Referenced by do_dtls(), and dtls_state_setup().

{
        unsigned char fdata[MAX_FPLEN] = { 0 };
        char *tmp = strdup(fp->str);
        char *p = tmp;
        int i = 0;
        char *v;

        while ((v = strsep(&p, ":")) && (i != (MAX_FPLEN - 1))) {
                sscanf(v, "%02x", (uint32_t *) &fdata[i++]);
        }

        free(tmp);

        i = !memcmp(fdata, fp->data, i);

        return i;
}

switch_core_check_core_db_dsn()

switch_status_t switch_core_check_core_db_dsn

(

void

)

Returns error if no suitable database interface found to serve core db dsn.

Definition at line 422 of file switch_core_sqldb.c.

References switch_runtime::odbc_dsn, runtime, and switch_database_available().

Referenced by switch_core_sqldb_init().

{
        return switch_database_available(runtime.odbc_dsn);
}

switch_core_check_dtls_pem()

switch_bool_t switch_core_check_dtls_pem

(

const char *

file

)

Definition at line 338 of file switch_core_cert.c.

References switch_directories::certs_dir, SWITCH_CHANNEL_LOG, SWITCH_FALSE, switch_file_exists(), SWITCH_GLOBAL_dirs, switch_is_file_path(), SWITCH_LOG_DEBUG, SWITCH_LOG_ERROR, switch_log_printf(), SWITCH_LOG_WARNING, switch_mprintf(), SWITCH_PATH_SEPARATOR, switch_safe_free, SWITCH_STATUS_SUCCESS, and SWITCH_TRUE.

Referenced by switch_core_media_init().

{
        char *pem = NULL, *old_pem = NULL;
        FILE *fp = NULL;
        EVP_PKEY *pkey = NULL;
        int bits = 0;

        if (switch_is_file_path(file)) {
                pem = strdup(file);
        } else {
                pem = switch_mprintf("%s%s%s", SWITCH_GLOBAL_dirs.certs_dir, SWITCH_PATH_SEPARATOR, file);
        }

        if (switch_file_exists(pem, NULL) != SWITCH_STATUS_SUCCESS) {
                switch_safe_free(pem);

                return SWITCH_FALSE;
        }

        fp = fopen(pem, "r");
        if (!fp) {
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Cannot open %s: %s\n", pem, strerror(errno));
                goto rename_pem;
        }

        pkey = PEM_read_PrivateKey(fp, NULL, NULL, NULL);
        fclose(fp);

        if (!pkey) {
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Cannot read key %s: %s\n", pem, ERR_error_string(ERR_get_error(), NULL));
                goto rename_pem;
        }

        bits = EVP_PKEY_bits(pkey);
        EVP_PKEY_free(pkey);

        if (bits < 4096) {
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "%s cryptographic length is too short (%d), it will be regenerated\n", pem, bits);
                goto rename_pem;
        }

        switch_safe_free(pem);

        return SWITCH_TRUE;

rename_pem:

        old_pem = switch_mprintf("%s.old", pem);

        if (rename(pem, old_pem) != -1) {
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Renamed %s to %s\n", pem, old_pem);
        } else {
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Could not rename %s: %s\n", pem, strerror(errno));
        }

        switch_safe_free(old_pem);
        switch_safe_free(pem);

        return SWITCH_FALSE;
}

switch_core_dbtype()

switch_cache_db_handle_type_t switch_core_dbtype

(

void

)

Definition at line 3350 of file switch_core_sqldb.c.

References SCDB_TYPE_CORE_DB, sql_manager, switch_mutex_lock(), switch_mutex_unlock(), and switch_cache_db_handle::type.

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_core_debug_level()

uint32_t switch_core_debug_level

(

void

)

Definition at line 2607 of file switch_core.c.

References switch_runtime::debug_level.

{
        return runtime.debug_level;
}

switch_core_del_registration()

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 3520 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_core_expire_registration()

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 3541 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;

}

switch_core_gen_certs()

int switch_core_gen_certs

(

const char *

prefix

)

Definition at line 250 of file switch_core_cert.c.

References switch_directories::certs_dir, mkcert(), SWITCH_CHANNEL_LOG, switch_file_exists(), SWITCH_GLOBAL_dirs, switch_is_file_path(), SWITCH_LOG_ERROR, switch_log_printf(), switch_mprintf(), SWITCH_PATH_SEPARATOR, switch_safe_free, SWITCH_STATUS_SUCCESS, and switch_stristr().

Referenced by load_config(), and switch_core_media_init().

{
        //BIO *bio_err;
        X509 *x509 = NULL;
        EVP_PKEY *pkey = NULL;
        char *rsa = NULL, *pvt = NULL;
        FILE *fp;
        char *pem = NULL;

        if (switch_stristr(".pem", prefix)) {

                if (switch_is_file_path(prefix)) {
                        pem = strdup(prefix);
                } else {
                        pem = switch_mprintf("%s%s%s", SWITCH_GLOBAL_dirs.certs_dir, SWITCH_PATH_SEPARATOR, prefix);
                }

                if (switch_file_exists(pem, NULL) == SWITCH_STATUS_SUCCESS) {
                        goto end;
                }
        } else {
                if (switch_is_file_path(prefix)) {
                        pvt = switch_mprintf("%s.key", prefix);
                        rsa = switch_mprintf("%s.crt", prefix);
                } else {
                        pvt = switch_mprintf("%s%s%s.key", SWITCH_GLOBAL_dirs.certs_dir, SWITCH_PATH_SEPARATOR, prefix);
                        rsa = switch_mprintf("%s%s%s.crt", SWITCH_GLOBAL_dirs.certs_dir, SWITCH_PATH_SEPARATOR, prefix);
                }

                if (switch_file_exists(pvt, NULL) == SWITCH_STATUS_SUCCESS || switch_file_exists(rsa, NULL) == SWITCH_STATUS_SUCCESS) {
                        goto end;
                }
        }

#ifdef CRYPTO_MEM_CHECK_ON
        CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ON);
#endif

        //bio_err=BIO_new_fp(stderr, BIO_NOCLOSE);

        if (!mkcert(&x509, &pkey, 4096, 0, 36500)) {
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Certificate generation failed\n");
                goto end;
        }

        //RSA_print_fp(stdout, pkey->pkey.rsa, 0);
        //X509_print_fp(stdout, x509);

        if (pem) {
                if ((fp = fopen(pem, "w"))) {
                        PEM_write_PrivateKey(fp, pkey, NULL, NULL, 0, NULL, NULL);
                        PEM_write_X509(fp, x509);
                        fclose(fp);
                }

        } else {
                if (pvt && (fp = fopen(pvt, "w"))) {
                        PEM_write_PrivateKey(fp, pkey, NULL, NULL, 0, NULL, NULL);
                        fclose(fp);
                }

                if (rsa && (fp = fopen(rsa, "w"))) {
                        PEM_write_X509(fp, x509);
                        fclose(fp);
                }
        }

        X509_free(x509);
        EVP_PKEY_free(pkey);

#ifndef OPENSSL_NO_ENGINE
        ENGINE_cleanup();
#endif
        CRYPTO_cleanup_all_ex_data();

        //CRYPTO_mem_leaks(bio_err);
        //BIO_free(bio_err);


 end:

        switch_safe_free(pvt);
        switch_safe_free(rsa);
        switch_safe_free(pem);

        return(0);
}

switch_core_gen_encoded_silence()

void switch_core_gen_encoded_silence	(	unsigned char *	data,
		const switch_codec_implementation_t *	read_impl,
		switch_size_t	len
	)

Definition at line 39 of file switch_core_io.c.

References switch_codec_implementation::ianacode, switch_codec_implementation::iananame, memset(), and switch_stristr().

Referenced by record_callback(), and switch_core_session_read_frame().

{
        unsigned char g729_filler[] = {
                114, 170, 250, 103, 54, 211, 203, 194, 94, 64,
                229, 127, 79, 96, 207, 82, 216, 110, 245, 81,
                114, 170, 250, 103, 54, 211, 203, 194, 94, 64,
                229, 127, 79, 96, 207, 82, 216, 110, 245, 81,
                114, 170, 250, 103, 54, 211, 203, 194, 94, 64,
                229, 127, 79, 96, 207, 82, 216, 110, 245, 81,
                114, 170, 250, 103, 54, 211, 203, 194, 94, 64,
                229, 127, 79, 96, 207, 82, 216, 110, 245, 81,
                114, 170, 250, 103, 54, 211, 203, 194, 94, 64,
                229, 127, 79, 96, 207, 82, 216, 110, 245, 81,
                114, 170, 250, 103, 54, 211, 203, 194, 94, 64,
                229, 127, 79, 96, 207, 82, 216, 110, 245, 81,
                114, 170, 250, 103, 54, 211, 203, 194, 94, 64,
                229, 127, 79, 96, 207, 82, 216, 110, 245, 81
        };


        if (read_impl->ianacode == 18 || switch_stristr("g729", read_impl->iananame)) {
                memcpy(data, g729_filler, len);
        } else {
                memset(data, 255, len);
        }

}

switch_core_get_event_channel_key_separator()

const char* switch_core_get_event_channel_key_separator

(

void

)

Definition at line 3592 of file switch_core.c.

References switch_runtime::event_channel_key_separator.

Referenced by ecd_deliver().

{
        return runtime.event_channel_key_separator;
}

switch_core_get_rtp_port_range_end_port()

uint16_t switch_core_get_rtp_port_range_end_port

(

void

)

Get RTP port range end value.

Parameters

[in]	void
[out]	RTP	port range end value

Definition at line 3581 of file switch_core.c.

References switch_rtp_set_end_port().

{
        uint16_t end_port = 0;

        /* By default pass rtp port range end value as zero in order to get actual
         * RTP port range end value as configured */
        end_port = (uint16_t)switch_rtp_set_end_port((switch_port_t)end_port);

        return end_port;
}

switch_core_get_rtp_port_range_start_port()

uint16_t switch_core_get_rtp_port_range_start_port

(

void

)

Get RTP port range start value.

Parameters

[in]	void
[out]	RTP	port range start value

Definition at line 3570 of file switch_core.c.

References switch_rtp_set_start_port().

{
        uint16_t start_port = 0;

        /* By default pass rtp port range start value as zero in order to get actual
         * RTP port range start value as configured */
        start_port = (uint16_t)switch_rtp_set_start_port((switch_port_t)start_port);

        return start_port;
}

switch_core_get_stacksizes()

switch_status_t switch_core_get_stacksizes	(	switch_size_t *	cur,
		switch_size_t *	max
	)

Definition at line 3512 of file switch_core.c.

References memset(), SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

{
#ifdef HAVE_SETRLIMIT
        struct rlimit rlp;

        memset(&rlp, 0, sizeof(rlp));
        getrlimit(RLIMIT_STACK, &rlp);

        *cur = rlp.rlim_cur;
        *max = rlp.rlim_max;

        return SWITCH_STATUS_SUCCESS;

#else

        return SWITCH_STATUS_FALSE;

#endif



}

switch_core_max_audio_channels()

uint32_t switch_core_max_audio_channels

(

uint32_t

limit

)

Definition at line 2642 of file switch_core.c.

References switch_runtime::max_audio_channels.

Referenced by switch_core_media_negotiate_sdp(), switch_core_perform_file_open(), and switch_load_core_config().

{
        if (limit) {
                runtime.max_audio_channels = limit;
        }

        return runtime.max_audio_channels;
}

switch_core_recovery_flush()

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

Definition at line 3133 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);
}

switch_core_recovery_recover()

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

Definition at line 3270 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;

}

switch_core_recovery_track()

void switch_core_recovery_track

(

switch_core_session_t *

session

)

Definition at line 3415 of file switch_core_sqldb.c.

References CF_ANSWERED, CF_RECOVERING, CF_TRACKABLE, CF_TRACKED, CS_SOFT_EXECUTE, switch_core_session::endpoint_interface, switch_endpoint_interface::interface_name, 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);

        }

}

switch_core_recovery_untrack()

void switch_core_recovery_untrack	(	switch_core_session_t *	session,
		switch_bool_t	force
	)

Definition at line 3377 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_clear_flag(), switch_channel_get_state(), switch_channel_test_flag(), switch_core_get_uuid(), switch_core_session_get_channel(), switch_core_session_get_uuid(), SWITCH_FALSE, switch_mprintf(), and switch_sql_queue_manager_push().

Referenced by switch_core_standard_on_hangup().

{
        char *sql = NULL;
        switch_channel_t *channel = switch_core_session_get_channel(session);

        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_TRACKABLE)) {
                return;
        }

        if ((switch_channel_test_flag(channel, CF_RECOVERING))) {
                return;
        }

        if (switch_channel_test_flag(channel, CF_TRACKED) || force) {

                if (force) {
                        sql = switch_mprintf("delete from recovery where uuid='%q'", switch_core_session_get_uuid(session));

                } else {
                        sql = switch_mprintf("delete from recovery where runtime_uuid='%q' and uuid='%q'",
                                                                 switch_core_get_uuid(), switch_core_session_get_uuid(session));
                }

                switch_sql_queue_manager_push(sql_manager.qm, sql, 3, SWITCH_FALSE);

                switch_channel_clear_flag(channel, CF_TRACKED);
        }

}

switch_core_session_debug_pool()

void switch_core_session_debug_pool

(

switch_stream_handle_t *

stream

)

Definition at line 3122 of file switch_core_session.c.

References switch_session_manager::busy, switch_session_manager::running, session_manager, and switch_stream_handle::write_function.

{
        stream->write_function(stream, "Thread pool: running:%d busy:%d popping:%d\n",
                session_manager.running, session_manager.busy, session_manager.running - session_manager.busy);
}

switch_core_session_in_thread()

switch_bool_t switch_core_session_in_thread

(

switch_core_session_t *

session

)

Definition at line 1712 of file switch_core_session.c.

References SWITCH_FALSE, switch_thread_equal(), switch_thread_self(), SWITCH_TRUE, and switch_core_session::thread_id.

Referenced by switch_channel_perform_answer(), switch_channel_set_direction(), switch_channel_state_change_pending(), switch_ivr_3p_nomedia(), switch_ivr_nomedia(), and switch_ivr_parse_signal_data().

{
        return switch_thread_equal(switch_thread_self(), session->thread_id) ? SWITCH_TRUE : SWITCH_FALSE;
}

switch_core_session_override_io_routines()

switch_status_t switch_core_session_override_io_routines	(	switch_core_session_t *	session,
		switch_io_routines_t *	ior
	)

Definition at line 3142 of file switch_core_session.c.

References CC_IO_OVERRIDE, switch_core_session::channel, switch_core_session::endpoint_interface, switch_core_session::io_override, switch_channel_test_cap(), SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

{
        if (session->endpoint_interface && switch_channel_test_cap(session->channel, CC_IO_OVERRIDE)) {
                session->io_override = ior;
                return SWITCH_STATUS_SUCCESS;
        }

        return SWITCH_STATUS_FALSE;
}

switch_core_session_send_and_request_video_refresh()

switch_status_t switch_core_session_send_and_request_video_refresh

(

switch_core_session_t *

session

)

Definition at line 14568 of file switch_core_media.c.

References CF_VIDEO, switch_core_session::channel, switch_channel_test_flag(), switch_core_media_gen_key_frame, switch_core_session_request_video_refresh, SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

Referenced by switch_core_session_video_reinit().

{
        if (switch_channel_test_flag(session->channel, CF_VIDEO)) {
                switch_core_session_request_video_refresh(session);
                switch_core_media_gen_key_frame(session);
                return SWITCH_STATUS_SUCCESS;
        }

        return SWITCH_STATUS_FALSE;
}

switch_core_session_start_text_thread()

switch_status_t switch_core_session_start_text_thread

(

switch_core_session_t *

session

)

Definition at line 7396 of file switch_core_media.c.

References CF_HAS_TEXT, switch_core_session::channel, media_helper::cond, media_helper::cond_mutex, switch_media_handle_s::control_mutex, switch_rtp_engine_s::cur_payload_map, switch_media_handle_s::engines, switch_core_session::media_handle, switch_rtp_engine_s::media_thread, switch_rtp_engine_s::mh, core_video_globals_s::pool, payload_map_s::pt, media_helper::ready, switch_rtp_engine_s::rtp_session, media_helper::session, SWITCH_CHANNEL_SESSION_LOG, switch_channel_test_flag(), switch_cond_next(), switch_core_session_get_name, switch_core_session_get_pool(), SWITCH_LOG_DEBUG, switch_log_printf(), SWITCH_MEDIA_TYPE_TEXT, switch_mutex_init(), switch_mutex_lock(), SWITCH_MUTEX_NESTED, switch_mutex_unlock(), switch_rtp_set_default_payload(), SWITCH_STATUS_FALSE, SWITCH_STATUS_NOTIMPL, SWITCH_STATUS_SUCCESS, switch_thread_cond_create(), switch_thread_create(), SWITCH_THREAD_STACKSIZE, switch_threadattr_create(), switch_threadattr_stacksize_set(), and text_helper_thread().

Referenced by switch_core_media_activate_rtp(), switch_core_media_gen_local_sdp(), switch_core_media_negotiate_sdp(), switch_core_media_start_engine_function(), and switch_core_session_set_text_read_callback().

{
        switch_threadattr_t *thd_attr = NULL;
        switch_memory_pool_t *pool = switch_core_session_get_pool(session);
        switch_rtp_engine_t *t_engine = NULL;
        switch_media_handle_t *smh;

        if (!switch_channel_test_flag(session->channel, CF_HAS_TEXT)) {
                return SWITCH_STATUS_NOTIMPL;
        }

        if (!(smh = session->media_handle)) {
                return SWITCH_STATUS_FALSE;
        }

        t_engine = &smh->engines[SWITCH_MEDIA_TYPE_TEXT];

        switch_mutex_lock(smh->control_mutex);

        if (t_engine->media_thread) {
                switch_mutex_unlock(smh->control_mutex);
                return SWITCH_STATUS_FALSE;
        }

        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "%s Starting Text thread\n", switch_core_session_get_name(session));

        if (t_engine->rtp_session) {
                switch_rtp_set_default_payload(t_engine->rtp_session, t_engine->cur_payload_map->pt);
        }

        t_engine->mh.session = session;
        switch_threadattr_create(&thd_attr, pool);
        switch_threadattr_stacksize_set(thd_attr, SWITCH_THREAD_STACKSIZE);

        switch_thread_cond_create(&t_engine->mh.cond, pool);
        switch_mutex_init(&t_engine->mh.cond_mutex, SWITCH_MUTEX_NESTED, pool);
        //switch_mutex_init(&t_engine->mh.file_read_mutex, SWITCH_MUTEX_NESTED, pool);
        //switch_mutex_init(&t_engine->mh.file_write_mutex, SWITCH_MUTEX_NESTED, pool);
        //switch_mutex_init(&smh->read_mutex[SWITCH_MEDIA_TYPE_TEXT], SWITCH_MUTEX_NESTED, pool);
        //switch_mutex_init(&smh->write_mutex[SWITCH_MEDIA_TYPE_TEXT], SWITCH_MUTEX_NESTED, pool);

        t_engine->mh.ready = 0;

        if (switch_thread_create(&t_engine->media_thread, thd_attr, text_helper_thread, &t_engine->mh, 
                                                         switch_core_session_get_pool(session)) == SWITCH_STATUS_SUCCESS) {
                while(!t_engine->mh.ready) {
                        switch_cond_next();
                }
        }

        switch_mutex_unlock(smh->control_mutex);
        return SWITCH_STATUS_SUCCESS;
}

switch_core_sessions_peak()

int32_t switch_core_sessions_peak

(

void

)

Definition at line 2632 of file switch_core.c.

References switch_runtime::sessions_peak.

{
        return runtime.sessions_peak;
}

switch_core_sessions_peak_fivemin()

int32_t switch_core_sessions_peak_fivemin

(

void

)

Definition at line 2637 of file switch_core.c.

References switch_runtime::sessions_peak_fivemin.

{
        return runtime.sessions_peak_fivemin;
}

switch_core_set_signal_handlers()

void switch_core_set_signal_handlers

(

void

)

Definition at line 2579 of file switch_core.c.

References handle_SIGHUP().

Referenced by switch_core_init_and_modload(), switch_loadable_module_load_file(), and switch_system_fork().

{
        /* set signal handlers */
        signal(SIGINT, SIG_IGN);
#ifdef SIGPIPE
        signal(SIGPIPE, SIG_IGN);
#endif
#ifdef SIGALRM
        signal(SIGALRM, SIG_IGN);
#endif
#ifdef SIGQUIT
        signal(SIGQUIT, SIG_IGN);
#endif
#ifdef SIGPOLL
        signal(SIGPOLL, SIG_IGN);
#endif
#ifdef SIGIO
        signal(SIGIO, SIG_IGN);
#endif
#ifdef TRAP_BUS
        signal(SIGBUS, handle_SIGBUS);
#endif
#ifdef SIGUSR1
        signal(SIGUSR1, handle_SIGHUP);
#endif
        signal(SIGHUP, handle_SIGHUP);
}

switch_core_sps()

int32_t switch_core_sps

(

void

)

Definition at line 2612 of file switch_core.c.

References switch_runtime::sps.

{
        return runtime.sps;
}

switch_core_sps_last()

int32_t switch_core_sps_last

(

void

)

Definition at line 2617 of file switch_core.c.

References switch_runtime::sps_last.

{
        return runtime.sps_last;
}

switch_core_sps_peak()

int32_t switch_core_sps_peak

(

void

)

Definition at line 2622 of file switch_core.c.

References switch_runtime::sps_peak.

{
        return runtime.sps_peak;
}

switch_core_sps_peak_fivemin()

int32_t switch_core_sps_peak_fivemin

(

void

)

Definition at line 2627 of file switch_core.c.

References switch_runtime::sps_peak_fivemin.

{
        return runtime.sps_peak_fivemin;
}

switch_core_sql_exec()

void switch_core_sql_exec

(

const char *

sql

)

Definition at line 3363 of file switch_core_sqldb.c.

References runtime, SCF_USE_SQL, sql_manager, switch_sql_queue_manager_push(), switch_test_flag, and SWITCH_TRUE.

Referenced by switch_console_set_complete().

{
        if (!sql_manager.manage) {
                return;
        }

        if (!switch_test_flag((&runtime), SCF_USE_SQL)) {
                return;
        }


        switch_sql_queue_manager_push(sql_manager.qm, sql, 3, SWITCH_TRUE);
}

switch_core_thread_set_cpu_affinity()

switch_status_t switch_core_thread_set_cpu_affinity

(

int

cpu

)

Definition at line 1763 of file switch_core.c.

References SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

Referenced by switch_core_autobind_cpu(), and SWITCH_MODULE_RUNTIME_FUNCTION().

{
        switch_status_t status = SWITCH_STATUS_FALSE;

        if (cpu > -1) {

#ifdef HAVE_CPU_SET_MACROS
                cpu_set_t set;

                CPU_ZERO(&set);
                CPU_SET(cpu, &set);

                if (!sched_setaffinity(0, sizeof(set), &set)) {
                        status = SWITCH_STATUS_SUCCESS;
                }

#else
#if WIN32
                if (SetThreadAffinityMask(GetCurrentThread(), (DWORD_PTR) cpu)) {
                        status = SWITCH_STATUS_SUCCESS;
                }
#endif
#endif
        }

        return status;
}

switch_database_available()

switch_status_t switch_database_available

(

char *

dsn

)

Returns error if no suitable database interface found for a dsn.

Definition at line 388 of file switch_core_sqldb.c.

References MIN, switch_loadable_module_get_database_interface(), switch_odbc_available(), SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, and UNPROTECT_INTERFACE.

Referenced by switch_core_check_core_db_dsn().

{
        switch_status_t status = SWITCH_STATUS_FALSE;
        switch_database_interface_t *database_interface;

        if (!dsn) {
                status = SWITCH_STATUS_SUCCESS;
        }
        else {
                char *colon_slashes = NULL;
                if (NULL != (colon_slashes = strstr(dsn, "://")))
                {
                        char prefix[16] = "";
                        strncpy(prefix, dsn, MIN(colon_slashes - dsn, 15));

                        if (!strncasecmp(prefix, "odbc", 4)) {
                                if (switch_odbc_available()) status = SWITCH_STATUS_SUCCESS;
                        }
                        else if (!strncasecmp(prefix, "sqlite", 6)) {
                                status = SWITCH_STATUS_SUCCESS;
                        }
                        else if ((database_interface = switch_loadable_module_get_database_interface(prefix, NULL))) {
                                status = SWITCH_STATUS_SUCCESS;
                                UNPROTECT_INTERFACE(database_interface);
                        }
                }
                else if (strchr(dsn + 2, ':')) {
                        status = SWITCH_STATUS_SUCCESS;
                }
        }

        return status;
}

switch_default_ptime()

uint32_t switch_default_ptime	(	const char *	name,
		uint32_t	number
	)

Definition at line 2022 of file switch_core.c.

References switch_runtime::ptimes, and switch_core_hash_find().

Referenced by add_audio_codec(), switch_core_media_negotiate_sdp(), switch_loadable_module_get_codecs(), and switch_loadable_module_get_codecs_sorted().

{
        uint32_t *p;

        if ((p = switch_core_hash_find(runtime.ptimes, name))) {
                return *p;
        }

        return 20;
}

switch_default_rate()

uint32_t switch_default_rate	(	const char *	name,
		uint32_t	number
	)

Definition at line 2033 of file switch_core.c.

Referenced by switch_loadable_module_get_codecs_sorted().

{

        if (!strcasecmp(name, "opus")) {
                return 48000;
        } else if (!strncasecmp(name, "h26", 3)) { // h26x
                return 90000;
        } else if (!strncasecmp(name, "vp", 2)) {  // vp8, vp9
                return 90000;
        }

        return 8000;
}

switch_fork()

pid_t switch_fork

(

void

)

Definition at line 3282 of file switch_core.c.

References set_low_priority().

Referenced by daemonize(), preprocess_exec(), switch_close_extra_files(), and switch_system_fork().

{
        int i = fork();

        if (!i) {
                set_low_priority();
        }

        return i;
}

switch_max_file_desc()

int switch_max_file_desc

(

void

)

Definition at line 3228 of file switch_core.c.

Referenced by switch_close_extra_files().

{
        int max = 0;

#ifndef WIN32
#if defined(HAVE_GETDTABLESIZE)
        max = getdtablesize();
#else
        max = sysconf(_SC_OPEN_MAX);
#endif
#endif

        return max;

}

switch_must_malloc()

static void* switch_must_malloc ( size_t  _b )

inlinestatic

Definition at line 233 of file switch_core.h.

References switch_assert.

Referenced by preprocess(), switch_jwt_sign(), switch_jwt_verify(), switch_xml_add_child(), switch_xml_char_content(), switch_xml_decode(), switch_xml_internal_dtd(), switch_xml_locate_language(), switch_xml_new(), switch_xml_parse_fd(), switch_xml_parse_file_simple(), switch_xml_parse_fp(), switch_xml_parse_str(), switch_xml_proc_inst(), switch_xml_set_attr(), switch_xml_str2utf8(), switch_xml_tohtml_ex(), switch_xml_toxml_ex(), and switch_xml_toxml_nolock_ex().

{
        void *m = malloc(_b);
        switch_assert(m);
        return m;
}

switch_must_realloc()

static void* switch_must_realloc ( void *  _b, size_t  _z  )

inlinestatic

Definition at line 240 of file switch_core.h.

References switch_assert, switch_core_screen_size(), switch_core_session_disable_heartbeat(), switch_core_session_enable_heartbeat(), switch_core_session_sched_heartbeat(), switch_core_session_unsched_heartbeat(), and SWITCH_DECLARE.

Referenced by preprocess(), switch_xml_ampencode(), switch_xml_char_content(), switch_xml_decode(), switch_xml_internal_dtd(), switch_xml_locate_language(), switch_xml_parse_fp(), switch_xml_parse_str(), switch_xml_proc_inst(), switch_xml_set_attr(), switch_xml_str2utf8(), switch_xml_toxml_buf_ex(), and switch_xml_toxml_r().

{
        void *m = realloc(_b, _z);
        switch_assert(m);
        return m;
}

switch_os_yield()

void switch_os_yield

(

void

)

Definition at line 142 of file switch_time.c.

Referenced by switch_cond_next(), switch_core_session_read_frame(), switch_event_channel_deliver_thread(), switch_event_dispatch_thread(), SWITCH_MODULE_RUNTIME_FUNCTION(), and timer_next().

{
#if defined(WIN32)
        SwitchToThread();
#else
        sched_yield();
#endif
}

switch_say_file()

void switch_say_file	(	switch_say_file_handle_t *	sh,
		const char *	fmt,
			...
	)

Definition at line 3196 of file switch_loadable_module.c.

References buf, switch_say_file_handle::cnt, switch_say_file_handle::ext, switch_say_file_handle::stream, switch_vsnprintf(), and switch_stream_handle::write_function.

{
        char buf[256] = "";
        va_list ap;

        va_start(ap, fmt);

        if (switch_vsnprintf(buf, sizeof(buf), fmt, ap) > 0) {
                if (!sh->cnt++) {
                        sh->stream.write_function(&sh->stream, "file_string://%s.%s", buf, sh->ext);
                } else if (strstr(buf, "://")) {
                        sh->stream.write_function(&sh->stream, "!%s", buf);
                } else {
                        sh->stream.write_function(&sh->stream, "!%s.%s", buf, sh->ext);
                }
        }

        va_end(ap);
}

switch_say_file_handle_create()

switch_status_t switch_say_file_handle_create	(	switch_say_file_handle_t **	sh,
		const char *	ext,
		switch_event_t **	var_event
	)

Definition at line 3173 of file switch_loadable_module.c.

References memset(), switch_assert, SWITCH_STANDARD_STREAM, SWITCH_STATUS_SUCCESS, and zstr.

{
        switch_assert(sh);

        if (zstr(ext)) {
                ext = "wav";
        }

        *sh = malloc(sizeof(**sh));
        memset(*sh, 0, sizeof(**sh));

        SWITCH_STANDARD_STREAM((*sh)->stream);

        if (var_event) {
                (*sh)->param_event = *var_event;
                *var_event = NULL;
        }

        (*sh)->ext = strdup(ext);

        return SWITCH_STATUS_SUCCESS;
}

switch_say_file_handle_destroy()

void switch_say_file_handle_destroy

(

switch_say_file_handle_t **

sh

)

Definition at line 3159 of file switch_loadable_module.c.

References switch_assert, switch_event_destroy(), and switch_safe_free.

{
        switch_assert(sh);

        switch_safe_free((*sh)->stream.data);
        switch_safe_free((*sh)->ext);

        if ((*sh)->param_event) {
                switch_event_destroy(&(*sh)->param_event);
        }
        free(*sh);
        *sh = NULL;
}

switch_say_file_handle_detach_path()

char* switch_say_file_handle_detach_path

(

switch_say_file_handle_t *

sh

)

Definition at line 3148 of file switch_loadable_module.c.

References switch_stream_handle::data, path, switch_say_file_handle::stream, and switch_assert.

{
        char *path;

        switch_assert(sh);
        path = (char *) sh->stream.data;
        sh->stream.data = NULL;
        return path;
}

switch_say_file_handle_get_path()

char* switch_say_file_handle_get_path

(

switch_say_file_handle_t *

sh

)

Definition at line 3143 of file switch_loadable_module.c.

References switch_stream_handle::data, and switch_say_file_handle::stream.

{
        return (char *) sh->stream.data;
}

switch_say_file_handle_get_variable()

char* switch_say_file_handle_get_variable	(	switch_say_file_handle_t *	sh,
		const char *	var
	)

Definition at line 3131 of file switch_loadable_module.c.

References switch_say_file_handle::param_event, and switch_event_get_header.

{
        char *ret = NULL;

        if (sh->param_event) {
                ret = switch_event_get_header(sh->param_event, var);
        }

        return ret;

}

switch_spawn()

int switch_spawn	(	const char *	cmd,
		switch_bool_t	wait
	)

Definition at line 3507 of file switch_core.c.

References SWITCH_FALSE, and switch_stream_spawn().

{
        return switch_stream_spawn(cmd, SWITCH_FALSE, wait, NULL);
}

switch_sql_queue_manager_destroy()

switch_status_t switch_sql_queue_manager_destroy

(

switch_sql_queue_manager_t **

qmp

)

Definition at line 1858 of file switch_core_sqldb.c.

References do_flush(), switch_sql_queue_manager::name, switch_sql_queue_manager::numq, switch_cache_db_handle::pool, switch_sql_queue_manager::pool, qm, switch_assert, SWITCH_CHANNEL_LOG, switch_core_destroy_memory_pool, SWITCH_LOG_DEBUG, SWITCH_LOG_INFO, switch_log_printf(), switch_sql_queue_manager_stop(), SWITCH_STATUS_NOOP, and SWITCH_STATUS_SUCCESS.

Referenced by switch_core_sqldb_stop_thread().

{
        switch_sql_queue_manager_t *qm;
        switch_status_t status = SWITCH_STATUS_SUCCESS;
        switch_memory_pool_t *pool;
        uint32_t i;

        switch_assert(qmp);
        qm = *qmp;
        if (!qm) {
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "No SQL queue to destroy.\n");
                return SWITCH_STATUS_NOOP;
        }

        *qmp = NULL;

        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "%s Destroying SQL queue.\n", qm->name);

        switch_sql_queue_manager_stop(qm);



        for(i = 0; i < qm->numq; i++) {
                do_flush(qm, i, NULL);
        }

        pool = qm->pool;
        switch_core_destroy_memory_pool(&pool);

        return status;
}

switch_sql_queue_manager_execute_sql_callback()

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
	)

Definition at line 1700 of file switch_core_sqldb.c.

References new_job(), and switch_thread_pool_launch_thread().

{

        switch_thread_data_t *td;
        if ((td = new_job(qm, sql, callback, NULL, NULL, NULL, pdata))) {
                switch_thread_pool_launch_thread(&td);
        }
}

switch_sql_queue_manager_execute_sql_callback_err()

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
	)

Definition at line 1710 of file switch_core_sqldb.c.

References new_job(), and switch_thread_pool_launch_thread().

{

        switch_thread_data_t *td;
        if ((td = new_job(qm, sql, callback, err_callback, NULL, NULL, pdata))) {
                switch_thread_pool_launch_thread(&td);
        }
}

switch_sql_queue_manager_execute_sql_event_callback()

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
	)

Definition at line 1721 of file switch_core_sqldb.c.

References new_job(), and switch_thread_pool_launch_thread().

{

        switch_thread_data_t *td;
        if ((td = new_job(qm, sql, NULL, NULL, callback, NULL, pdata))) {
                switch_thread_pool_launch_thread(&td);
        }
}

switch_sql_queue_manager_execute_sql_event_callback_err()

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
	)

Definition at line 1731 of file switch_core_sqldb.c.

References new_job(), and switch_thread_pool_launch_thread().

{

        switch_thread_data_t *td;
        if ((td = new_job(qm, sql, NULL, NULL, callback, err_callback, pdata))) {
                switch_thread_pool_launch_thread(&td);
        }
}

switch_sql_queue_manager_init_name()

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
	)

Definition at line 2006 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_sql_queue_manager::dsn, switch_sql_queue_manager::inner_post_trans_execute, switch_sql_queue_manager::inner_pre_trans_execute, switch_sql_queue_manager::max_trans, switch_sql_queue_manager::mutex, switch_sql_queue_manager::name, switch_sql_queue_manager::numq, switch_cache_db_handle::pool, switch_sql_queue_manager::pool, switch_sql_queue_manager::post_trans_execute, switch_sql_queue_manager::pre_trans_execute, switch_sql_queue_manager::pre_written, qm, switch_sql_queue_manager::sql_queue, switch_core_alloc, switch_core_new_memory_pool, switch_core_strdup, switch_mutex_init(), SWITCH_MUTEX_NESTED, switch_queue_create(), SWITCH_SQL_QUEUE_LEN, SWITCH_STATUS_SUCCESS, switch_thread_cond_create(), and switch_sql_queue_manager::written.

Referenced by switch_core_sqldb_start_thread().

{
        switch_memory_pool_t *pool;
        switch_sql_queue_manager_t *qm;
        uint32_t i;

        if (!numq) numq = 1;

        switch_core_new_memory_pool(&pool);
        qm = switch_core_alloc(pool, sizeof(*qm));

        qm->pool = pool;
        qm->numq = numq;
        qm->dsn = switch_core_strdup(qm->pool, dsn);
        qm->name = switch_core_strdup(qm->pool, name);
        qm->max_trans = max_trans;

        switch_mutex_init(&qm->cond_mutex, SWITCH_MUTEX_NESTED, qm->pool);
        switch_mutex_init(&qm->cond2_mutex, SWITCH_MUTEX_NESTED, qm->pool);
        switch_mutex_init(&qm->mutex, SWITCH_MUTEX_NESTED, qm->pool);
        switch_thread_cond_create(&qm->cond, qm->pool);

        qm->sql_queue = switch_core_alloc(qm->pool, sizeof(switch_queue_t *) * numq);
        qm->written = switch_core_alloc(qm->pool, sizeof(uint32_t) * numq);
        qm->pre_written = switch_core_alloc(qm->pool, sizeof(uint32_t) * numq);

        for (i = 0; i < qm->numq; i++) {
                switch_queue_create(&qm->sql_queue[i], SWITCH_SQL_QUEUE_LEN, qm->pool);
        }

        if (pre_trans_execute) {
                qm->pre_trans_execute = switch_core_strdup(qm->pool, pre_trans_execute);
        }
        if (post_trans_execute) {
                qm->post_trans_execute = switch_core_strdup(qm->pool, post_trans_execute);
        }
        if (inner_pre_trans_execute) {
                qm->inner_pre_trans_execute = switch_core_strdup(qm->pool, inner_pre_trans_execute);
        }
        if (inner_post_trans_execute) {
                qm->inner_post_trans_execute = switch_core_strdup(qm->pool, inner_post_trans_execute);
        }

        *qmp = qm;

        return SWITCH_STATUS_SUCCESS;

}

switch_sql_queue_manager_pause()

void switch_sql_queue_manager_pause	(	switch_sql_queue_manager_t *	qm,
		switch_bool_t	flush
	)

Definition at line 1773 of file switch_core_sqldb.c.

References do_flush(), switch_sql_queue_manager::mutex, switch_sql_queue_manager::numq, switch_sql_queue_manager::paused, switch_mutex_lock(), and switch_mutex_unlock().

{
        uint32_t i;

        switch_mutex_lock(qm->mutex);
        qm->paused = 1;
        switch_mutex_unlock(qm->mutex);

        if (flush) {
                for(i = 0; i < qm->numq; i++) {
                        do_flush(qm, i, NULL);
                }
        }

}

switch_sql_queue_manager_push()

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

Definition at line 1890 of file switch_core_sqldb.c.

References switch_sql_queue_manager::mutex, switch_sql_queue_manager::numq, qm_wake(), sql_manager, switch_sql_queue_manager::sql_queue, SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG1, switch_log_printf(), switch_mutex_lock(), switch_mutex_unlock(), switch_queue_trypush(), SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, switch_yield, and switch_sql_queue_manager::thread_running.

Referenced by core_event_handler(), switch_core_add_registration(), switch_core_del_registration(), switch_core_expire_registration(), switch_core_recovery_track(), switch_core_recovery_untrack(), and switch_core_sql_exec().

{
        char *sqlptr = NULL;
        switch_status_t status;
        int x = 0;

        if (sql_manager.paused || qm->thread_running != 1) {
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG1, "DROP [%s]\n", sql);
                if (!dup) free((char *)sql);
                qm_wake(qm);
                return SWITCH_STATUS_SUCCESS;
        }

        if (qm->thread_running != 1) {
                if (!dup) free((char *)sql);
                return SWITCH_STATUS_FALSE;
        }

        if (pos > qm->numq - 1) {
                pos = 0;
        }

        sqlptr = dup ? strdup(sql) : (char *)sql;

        do {
                switch_mutex_lock(qm->mutex);
                status = switch_queue_trypush(qm->sql_queue[pos], sqlptr);
                switch_mutex_unlock(qm->mutex);
                if (status != SWITCH_STATUS_SUCCESS) {
                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG1, "Delay %d sending sql\n", x);
                        if (x++) {
                                switch_yield(1000000 * x);
                        }
                }
        } while(status != SWITCH_STATUS_SUCCESS);

        qm_wake(qm);

        return SWITCH_STATUS_SUCCESS;
}

switch_sql_queue_manager_push_confirm()

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
	)

Definition at line 1932 of file switch_core_sqldb.c.

References switch_sql_queue_manager::confirm, dbh, switch_sql_queue_manager::dsn, switch_sql_queue_manager::mutex, switch_sql_queue_manager::numq, switch_sql_queue_manager::pre_written, qm_wake(), sql_manager, switch_sql_queue_manager::sql_queue, switch_cache_db_execute_sql(), switch_cache_db_get_db_handle_dsn, switch_cache_db_release_db_handle(), SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG1, switch_log_printf(), switch_mutex_lock(), switch_mutex_unlock(), switch_queue_push(), switch_sql_queue_manager_size(), SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, switch_yield, switch_sql_queue_manager::thread_running, and switch_sql_queue_manager::written.

{
#define EXEC_NOW
#ifdef EXEC_NOW
        switch_cache_db_handle_t *dbh;

        if (sql_manager.paused || qm->thread_running != 1) {
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG1, "DROP [%s]\n", sql);
                if (!dup) free((char *)sql);
                qm_wake(qm);
                return SWITCH_STATUS_SUCCESS;
        }

        if (switch_cache_db_get_db_handle_dsn(&dbh, qm->dsn) == SWITCH_STATUS_SUCCESS) {
                switch_cache_db_execute_sql(dbh, (char *)sql, NULL);
                switch_cache_db_release_db_handle(&dbh);
        }

        if (!dup) free((char *)sql);

#else

        int size, x = 0, sanity = 0;
        uint32_t written, want;

        if (sql_manager.paused) {
                if (!dup) free((char *)sql);
                qm_wake(qm);
                return SWITCH_STATUS_SUCCESS;
        }

        if (qm->thread_running != 1) {
                if (!dup) free((char *)sql);
                return SWITCH_STATUS_FALSE;
        }

        if (pos > qm->numq - 1) {
                pos = 0;
        }

        switch_mutex_lock(qm->mutex);
        qm->confirm++;
        switch_queue_push(qm->sql_queue[pos], dup ? strdup(sql) : (char *)sql);
        written = qm->pre_written[pos];
        size = switch_sql_queue_manager_size(qm, pos);
        want = written + size;
        switch_mutex_unlock(qm->mutex);

        qm_wake(qm);

        while((qm->written[pos] < want) || (qm->written[pos] >= written && want < written && qm->written[pos] > want)) {
                switch_yield(5000);

                if (++x == 200) {
                        qm_wake(qm);
                        x = 0;
                        if (++sanity == 20) {
                                break;
                        }
                }
        }

        switch_mutex_lock(qm->mutex);
        qm->confirm--;
        switch_mutex_unlock(qm->mutex);
#endif

        return SWITCH_STATUS_SUCCESS;
}

switch_sql_queue_manager_resume()

void switch_sql_queue_manager_resume

(

switch_sql_queue_manager_t *

qm

)

Definition at line 1763 of file switch_core_sqldb.c.

References switch_sql_queue_manager::mutex, switch_sql_queue_manager::paused, qm_wake(), switch_mutex_lock(), and switch_mutex_unlock().

{
        switch_mutex_lock(qm->mutex);
        qm->paused = 0;
        switch_mutex_unlock(qm->mutex);

        qm_wake(qm);

}

switch_sql_queue_manager_size()

int switch_sql_queue_manager_size	(	switch_sql_queue_manager_t *	qm,
		uint32_t	index
	)

Definition at line 1789 of file switch_core_sqldb.c.

References switch_sql_queue_manager::mutex, switch_sql_queue_manager::sql_queue, switch_mutex_lock(), switch_mutex_unlock(), and switch_queue_size().

Referenced by switch_sql_queue_manager_push_confirm().

{
        int size = 0;

        switch_mutex_lock(qm->mutex);
        if (index < qm->numq) {
                size = switch_queue_size(qm->sql_queue[index]);
        }
        switch_mutex_unlock(qm->mutex);

        return size;
}

switch_sql_queue_manager_start()

switch_status_t switch_sql_queue_manager_start

(

switch_sql_queue_manager_t *

qm

)

Definition at line 1835 of file switch_core_sqldb.c.

References switch_sql_queue_manager::event_db, switch_sql_queue_manager::name, switch_sql_queue_manager::pool, SWITCH_CHANNEL_LOG, switch_cond_next(), SWITCH_LOG_INFO, switch_log_printf(), SWITCH_PRI_NORMAL, SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, switch_thread_create(), SWITCH_THREAD_STACKSIZE, switch_threadattr_create(), switch_threadattr_priority_set(), switch_threadattr_stacksize_set(), switch_user_sql_thread(), switch_sql_queue_manager::thread, switch_sql_queue_manager::thread_initiated, and switch_sql_queue_manager::thread_running.

Referenced by switch_core_sqldb_start_thread().

{
        switch_threadattr_t *thd_attr;

        if (!qm->thread_running) {
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "%s Starting SQL thread.\n", qm->name);
                switch_threadattr_create(&thd_attr, qm->pool);
                switch_threadattr_stacksize_set(thd_attr, SWITCH_THREAD_STACKSIZE);
                switch_threadattr_priority_set(thd_attr, SWITCH_PRI_NORMAL);
                if (switch_thread_create(&qm->thread, thd_attr, switch_user_sql_thread, qm, qm->pool) == SWITCH_STATUS_SUCCESS) {
                        while (!qm->thread_initiated) {
                                switch_cond_next();
                        }

                        if (qm->event_db) {
                                return SWITCH_STATUS_SUCCESS;
                        }
                }
        }

        return SWITCH_STATUS_FALSE;
}

switch_sql_queue_manager_stop()

switch_status_t switch_sql_queue_manager_stop

(

switch_sql_queue_manager_t *

qm

)

Definition at line 1802 of file switch_core_sqldb.c.

References switch_sql_queue_manager::name, switch_sql_queue_manager::numq, qm_wake(), switch_sql_queue_manager::sql_queue, SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, switch_log_printf(), switch_queue_interrupt_all(), switch_queue_push(), SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, switch_thread_join(), switch_yield, switch_sql_queue_manager::thread, and switch_sql_queue_manager::thread_running.

Referenced by switch_sql_queue_manager_destroy().

{
        switch_status_t status = SWITCH_STATUS_FALSE;
        uint32_t i, sanity = 100;

        if (qm->thread_running == 1) {
                qm->thread_running = -1;

                while(--sanity && qm->thread_running == -1) {
                        for(i = 0; i < qm->numq; i++) {
                                switch_queue_push(qm->sql_queue[i], NULL);
                                switch_queue_interrupt_all(qm->sql_queue[i]);
                        }
                        qm_wake(qm);

                        if (qm->thread_running == -1) {
                                switch_yield(100000);
                        }
                }
                status = SWITCH_STATUS_SUCCESS;
        }

        if (qm->thread) {
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "%s Stopping SQL thread.\n", qm->name);
                qm_wake(qm);
                switch_thread_join(&status, qm->thread);
                qm->thread = NULL;
                status = SWITCH_STATUS_SUCCESS;
        }

        return status;
}

switch_stream_spawn()

int switch_stream_spawn	(	const char *	cmd,
		switch_bool_t	shell,
		switch_bool_t	wait,
		switch_stream_handle_t *	stream
	)

Definition at line 3372 of file switch_core.c.

References buffer, memset(), switch_stream_handle::raw_write_function, SWITCH_CHANNEL_LOG, switch_core_get_variable(), SWITCH_LOG_ERROR, switch_log_printf(), SWITCH_LOG_WARNING, switch_safe_free, switch_separate_string(), and zstr.

Referenced by switch_spawn(), switch_stream_system(), and switch_system().

{
#ifndef __linux__
        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "posix_spawn is unsupported on current platform\n");
        return 1;
#else
        int status = 0;
        char buffer[1024];
        pid_t pid;
        char *pdata = NULL, *argv[64];
        posix_spawn_file_actions_t action;
        posix_spawnattr_t *attr;
        int cout_pipe[2];
        int cerr_pipe[2];
        struct pollfd pfds[2] = { {0} };

        if (zstr(cmd)) {
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "Failed to execute switch_spawn_stream because of empty command\n");
                return 1;
        }

        if (shell) {
                argv[0] = switch_core_get_variable("spawn_system_shell");
                argv[1] = "-c";
                argv[2] = (char *)cmd;
                argv[3] = NULL;
                if (zstr(argv[0])) {
                        argv[0] = "/bin/sh";
                }
        } else {
                if (!(pdata = strdup(cmd))) {
                        return 1;
                }
                if (!switch_separate_string(pdata, ' ', argv, (sizeof(argv) / sizeof(argv[0])))) {
                        free(pdata);
                        return 1;
                }
        }

        if (!(attr = malloc(sizeof(posix_spawnattr_t)))) {
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Failed to execute switch_spawn_stream because of a memory error: %s\n", cmd);
                switch_safe_free(pdata);
                return 1;
        }

        if (stream) {
                if (pipe(cout_pipe)) {
                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Failed to execute switch_spawn_stream because of a pipe error: %s\n", cmd);
                        free(attr);
                        switch_safe_free(pdata);
                        return 1;
                }

                if (pipe(cerr_pipe)) {
                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Failed to execute switch_spawn_stream because of a pipe error: %s\n", cmd);
                        close(cout_pipe[0]);
                        close(cout_pipe[1]);
                        free(attr);
                        switch_safe_free(pdata);
                        return 1;
                }
        }

        memset(attr, 0, sizeof(posix_spawnattr_t));
        posix_spawnattr_init(attr);
        posix_spawnattr_setflags(attr, POSIX_SPAWN_USEVFORK);

        posix_spawn_file_actions_init(&action);

        if (stream) {
                posix_spawn_file_actions_addclose(&action, cout_pipe[0]);
                posix_spawn_file_actions_addclose(&action, cerr_pipe[0]);
                posix_spawn_file_actions_adddup2(&action, cout_pipe[1], 1);
                posix_spawn_file_actions_adddup2(&action, cerr_pipe[1], 2);

                posix_spawn_file_actions_addclose(&action, cout_pipe[1]);
                posix_spawn_file_actions_addclose(&action, cerr_pipe[1]);
        }

        if (posix_spawnp(&pid, argv[0], &action, attr, argv, environ) != 0) {
                status = 1;
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "Failed to execute posix_spawnp: %s\n", cmd);
                if (stream) {
                        close(cout_pipe[0]), close(cerr_pipe[0]);
                        close(cout_pipe[1]), close(cerr_pipe[1]);
                }
        } else {
                if (stream) {
                        close(cout_pipe[1]), close(cerr_pipe[1]); /* close child-side of pipes */

                        pfds[0] = (struct pollfd) {
                                .fd = cout_pipe[0],
                                        .events = POLLIN,
                                        .revents = 0
                        };

                        pfds[1] = (struct pollfd) {
                                .fd = cerr_pipe[0],
                                        .events = POLLIN,
                                        .revents = 0
                        };

                        while (poll(pfds, 2, /*timeout*/-1) > 0) {
                                if (pfds[0].revents & POLLIN) {
                                        int bytes_read = read(cout_pipe[0], buffer, sizeof(buffer));
                                        stream->raw_write_function(stream, (unsigned char *)buffer, bytes_read);
                                } else if (pfds[1].revents & POLLIN) {
                                        int bytes_read = read(cerr_pipe[0], buffer, sizeof(buffer));
                                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "STDERR of cmd (%s): %.*s\n", cmd, bytes_read, buffer);
                                } else {
                                        break; /* nothing left to read */
                                }
                        }

                        close(cout_pipe[0]), close(cerr_pipe[0]);
                }

                if (wait) {
                        if (waitpid(pid, &status, 0) != pid) {
                                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "waitpid failed: %s\n", cmd);
                        } else if (status != 0) {
                                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "Exit status (%d): %s\n", status, cmd);
                        }
                }
        }

        posix_spawnattr_destroy(attr);
        free(attr);
        posix_spawn_file_actions_destroy(&action);
        switch_safe_free(pdata);

        return status;
#endif
}

switch_stream_system_fork()

int switch_stream_system_fork	(	const char *	cmd,
		switch_stream_handle_t *	stream
	)

Definition at line 3363 of file switch_core.c.

References switch_stream_system().

{
        return switch_stream_system(cmd, stream);
}

switch_version_full()

const char* switch_version_full

(

void

)

Definition at line 53 of file switch_version.c.

References switch_version_full_str.

Referenced by main(), send_heartbeat(), and switch_core_init_and_modload().

{return switch_version_full_str;}

switch_version_full_human()

const char* switch_version_full_human

(

void

)

Definition at line 54 of file switch_version.c.

References switch_version_full_human_str.

{return switch_version_full_human_str;}

switch_version_major()

const char* switch_version_major

(

void

)

Definition at line 47 of file switch_version.c.

References switch_version_major_str.

{return switch_version_major_str;}

switch_version_micro()

const char* switch_version_micro

(

void

)

Definition at line 49 of file switch_version.c.

References switch_version_micro_str.

{return switch_version_micro_str;}

switch_version_minor()

const char* switch_version_minor

(

void

)

Definition at line 48 of file switch_version.c.

References switch_version_minor_str.

{return switch_version_minor_str;}

switch_version_revision()

const char* switch_version_revision

(

void

)

Definition at line 51 of file switch_version.c.

References switch_version_revision_str.

{return switch_version_revision_str;}

switch_version_revision_human()

const char* switch_version_revision_human

(

void

)

Definition at line 52 of file switch_version.c.

References switch_version_revision_human_str.

Referenced by ice_out(), main(), and switch_core_init_and_modload().

{return switch_version_revision_human_str;}