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_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
union	switch_cache_db_connection_options_t
Defines
#define	SWITCH_MAX_CORE_THREAD_SESSION_OBJS   128
#define	SWITCH_MAX_STREAMS   128
#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.
#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.
#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.
#define	switch_core_alloc(_pool, _mem)   switch_core_perform_alloc(_pool, _mem, __FILE__, __SWITCH_FUNC__, __LINE__)
	Allocate memory directly from a memory pool.
#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.
#define	switch_core_permanent_strdup(_todup)   switch_core_perform_permanent_strdup(_todup, __FILE__, __SWITCH_FUNC__, __LINE__)
	Copy a string using permanent memory allocation.
#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.
#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.
#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.
#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.
#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.
#define	switch_core_hash_init(_hash, _pool)   switch_core_hash_init_case(_hash, _pool, SWITCH_TRUE)
#define	switch_core_hash_init_nocase(_hash, _pool)   switch_core_hash_init_case(_hash, _pool, SWITCH_FALSE)
#define	switch_core_codec_init(_codec, _codec_name, _fmtp, _rate, _ms, _channels, _flags, _codec_settings, _pool)   switch_core_codec_init_with_bitrate(_codec, _codec_name, _fmtp, _rate, _ms, _channels, 0, _flags, _codec_settings, _pool)
	Initialize a codec handle.
#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.
#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_core_db_handle(_a)   _switch_core_db_handle(_a, __FILE__, __SWITCH_FUNC__, __LINE__)
Typedefs
typedef switch_cache_db_handle	switch_cache_db_handle_t
Enumerations
enum	cache_db_flag_t { CDF_INUSE = (1 << 0), CDF_PRUNE = (1 << 1) }
enum	switch_cache_db_handle_type_t { SCDB_TYPE_CORE_DB, SCDB_TYPE_ODBC }
Functions
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_count (switch_core_session_t *orig_session, const char *function)
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.
void	switch_core_media_bug_pause (switch_core_session_t *session)
	Pause a media bug on the session.
void	switch_core_media_bug_resume (switch_core_session_t *session)
	Resume a media bug on the session.
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.
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.
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.
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.
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.
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.
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.
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.
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.
switch_status_t	switch_core_media_bug_close (_Inout_ switch_media_bug_t **bug)
	Close and destroy a media bug.
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.
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_recordings (switch_core_session_t *orig_session, switch_core_session_t *new_session)
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.
void	switch_core_media_bug_flush (_In_ switch_media_bug_t *bug)
	Flush the read and write buffers for the bug.
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.
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_ 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.
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.
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.
void	switch_core_port_allocator_destroy (_Inout_ switch_core_port_allocator_t **alloc)
	destroythe port allocator
switch_status_t	switch_core_init (_In_ switch_core_flag_t flags, _In_ switch_bool_t console, _Out_ const char **err)
	Initilize the core.
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.
uint32_t	switch_core_session_limit (_In_ uint32_t new_limit)
	Set/Get Session Limit.
uint32_t	switch_core_sessions_per_second (_In_ uint32_t new_limit)
	Set/Get Session Rate Limit.
switch_status_t	switch_core_destroy (void)
	Destroy the core.
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.
switch_status_t	switch_core_session_read_lock_hangup (_In_ switch_core_session_t *session)
	Acquire a read lock on the session.
void	switch_core_session_write_lock (_In_ switch_core_session_t *session)
	Acquire a write lock on the session.
void	switch_core_session_rwunlock (_In_ switch_core_session_t *session)
	Unlock a read or write lock on as given session.
int	switch_core_add_state_handler (_In_ const switch_state_handler_table_t *state_handler)
	Add a global state handler.
void	switch_core_remove_state_handler (_In_ const switch_state_handler_table_t *state_handler)
	Remove a global state handler.
const switch_state_handler_table_t *	switch_core_get_state_handler (_In_ int index)
	Access a state handler.
void	switch_core_memory_pool_tag (switch_memory_pool_t *pool, const char *tag)
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.
unsigned int	switch_core_session_running (_In_ switch_core_session_t *session)
	determine if the session's state machine is running
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_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
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
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
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
switch_memory_pool_t *	switch_core_session_get_pool (_In_ switch_core_session_t *session)
	Retrieve the memory pool from a session.
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.
switch_status_t	switch_core_session_set_uuid (_In_ switch_core_session_t *session, _In_z_ const char *use_uuid)
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.
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.
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.
switch_status_t	switch_core_session_thread_launch (_In_ switch_core_session_t *session)
	Launch the session thread (state machine) on a given session.
_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.
switch_status_t	switch_core_session_wake_session_thread (_In_ switch_core_session_t *session)
	Signal a session's state machine thread that a state change has occured.
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.
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.
switch_log_level_t	switch_core_session_get_loglevel (switch_core_session_t *session)
	Get the log level for a session.
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_core_session_set_codec_slin (switch_core_session_t *session, switch_slin_data_t *data)
char *	switch_core_get_uuid (void)
	Retrieve the unique identifier from the core.
switch_core_session_t *	switch_core_session_locate (_In_z_ const char *uuid_str)
	Locate a session based on it's uuid.
switch_core_session_t *	switch_core_session_force_locate (_In_z_ const char *uuid_str)
	Locate a session based on it's uuid even if the channel is not ready.
char *	switch_core_get_variable (_In_z_ const char *varname)
	Retrieve a global variable from the core.
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)
void	switch_core_set_variable (_In_z_ const char *varname, _In_opt_z_ const char *value)
	Add a global variable to the core.
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.
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.
void	switch_core_session_hupall_matching_var (_In_ const char *var_name, _In_ const char *var_val, _In_ switch_call_cause_t cause)
	Hangup all sessions which match a specific channel variable.
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.
switch_status_t	switch_core_session_get_partner (switch_core_session_t *session, switch_core_session_t **partner)
	Get the session's partner (the session its bridged to).
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.
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.
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
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.
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.
switch_status_t	switch_core_session_flush_message (_In_ switch_core_session_t *session)
	Flush a message queue on a given session.
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.
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.
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.
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)
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.
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.
void *	switch_core_session_get_private (_In_ switch_core_session_t *session)
	Retrieve private user data from a session.
switch_status_t	switch_core_session_set_private (_In_ switch_core_session_t *session, _In_ void *private_info)
	Add private user data to a session.
int	switch_core_session_add_stream (_In_ switch_core_session_t *session, _In_opt_ void *private_info)
	Add a logical stream to a session.
void *	switch_core_session_get_stream (_In_ switch_core_session_t *session, _In_ int index)
	Retreive a logical stream from a session.
int	switch_core_session_get_stream_count (_In_ switch_core_session_t *session)
	Determine the number of logical streams a session has.
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.
void	switch_core_thread_session_end (_In_ switch_core_session_t *session)
	Signal a thread using a thread session to terminate.
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.
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.
switch_call_cause_t	switch_core_session_resurrect_channel (_In_z_ const char *endpoint_name, _Inout_ switch_core_session_t **new_session, _Inout_ switch_memory_pool_t **pool, _In_ void *data)
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.
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.
uint32_t	switch_core_session_event_count (_In_ switch_core_session_t *session)
	Indicate the number of waiting events on a session.
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.
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.
uint32_t	switch_core_session_private_event_count (_In_ switch_core_session_t *session)
	Indicate the number of waiting private events on a session.
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.
uint32_t	switch_core_session_flush_private_events (switch_core_session_t *session)
	Flush the private event queue of a session.
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.
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.
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.
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.
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.
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.
switch_status_t	switch_core_session_send_dtmf_string (switch_core_session_t *session, const char *dtmf_string)
	Send DTMF to a session.
switch_status_t	switch_core_session_recv_dtmf (_In_ switch_core_session_t *session, const switch_dtmf_t *dtmf)
	RECV DTMF on a session.
switch_status_t	switch_core_hash_init_case (_Out_ switch_hash_t **hash, _In_ switch_memory_pool_t *pool, switch_bool_t case_sensitive)
	Initialize a hash table.
switch_status_t	switch_core_hash_destroy (_Inout_ switch_hash_t **hash)
	Destroy an existing hash table.
switch_status_t	switch_core_hash_insert (_In_ switch_hash_t *hash, _In_z_ const char *key, _In_opt_ const void *data)
	Insert data into a hash.
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.
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.
switch_status_t	switch_core_hash_delete (_In_ switch_hash_t *hash, _In_z_ const char *key)
	Delete data from a hash based on desired key.
switch_status_t	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.
switch_status_t	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.
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.
void *	switch_core_hash_find (_In_ switch_hash_t *hash, _In_z_ const char *key)
	Retrieve data from a given hash.
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.
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.
switch_hash_index_t *	switch_hash_first (char *deprecate_me, _In_ switch_hash_t *hash)
	Gets the first element of a hashtable.
switch_hash_index_t *	switch_hash_next (_In_ switch_hash_index_t *hi)
	Gets the next element of a hashtable.
void	switch_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.
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.
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.
switch_status_t	switch_core_timer_step (switch_timer_t *timer)
	Step the timer one step.
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.
switch_status_t	switch_core_timer_destroy (switch_timer_t *timer)
	Destroy an allocated timer.
switch_status_t	switch_core_codec_init_with_bitrate (switch_codec_t *codec, const char *codec_name, const char *fmtp, 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, 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.
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.
switch_status_t	switch_core_codec_destroy (switch_codec_t *codec)
	Destroy an initalized codec handle.
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.
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.
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.
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.
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.
switch_codec_t *	switch_core_session_get_write_codec (_In_ switch_core_session_t *session)
	Retrieve the write codec from a given session.
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.
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.
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.
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.
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.
switch_core_db_t *	switch_core_db_open_file (const char *filename)
	Open a core db (SQLite) file.
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.
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
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_ uint8_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.
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.
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.
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.
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
switch_status_t	switch_core_file_close (_In_ switch_file_handle_t *fh)
	Close an open file handle.
switch_status_t	switch_core_file_truncate (switch_file_handle_t *fh, int64_t offset)
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, switch_speech_flag_t *flags, _In_opt_ switch_memory_pool_t *pool)
	Open a speech handle.
switch_status_t	switch_core_speech_feed_tts (switch_speech_handle_t *sh, char *text, switch_speech_flag_t *flags)
	Feed text to the TTS module.
void	switch_core_speech_flush_tts (switch_speech_handle_t *sh)
	Flush TTS audio on a given handle.
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.
void	switch_core_speech_numeric_param_tts (switch_speech_handle_t *sh, char *param, int val)
	Set a numeric parameter on a TTS handle.
void	switch_core_speech_float_param_tts (switch_speech_handle_t *sh, char *param, double val)
	Set a float parameter on a TTS handle.
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.
switch_status_t	switch_core_speech_close (switch_speech_handle_t *sh, switch_speech_flag_t *flags)
	Close an open speech handle.
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.
switch_status_t	switch_core_asr_close (switch_asr_handle_t *ah, switch_asr_flag_t *flags)
	Close an asr handle.
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.
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.
switch_status_t	switch_core_asr_check_results (switch_asr_handle_t *ah, switch_asr_flag_t *flags)
	Check an asr handle for results.
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.
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.
switch_status_t	switch_core_asr_unload_grammar (switch_asr_handle_t *ah, const char *name)
	Unload a grammar from an asr handle.
switch_status_t	switch_core_asr_enable_grammar (switch_asr_handle_t *ah, const char *name)
	Enable a grammar from an asr handle.
switch_status_t	switch_core_asr_disable_grammar (switch_asr_handle_t *ah, const char *name)
	Disable a grammar from an asr handle.
switch_status_t	switch_core_asr_disable_all_grammars (switch_asr_handle_t *ah)
	Disable all grammars from an asr handle.
switch_status_t	switch_core_asr_pause (switch_asr_handle_t *ah)
	Pause detection on an asr handle.
switch_status_t	switch_core_asr_resume (switch_asr_handle_t *ah)
	Resume detection on an asr handle.
switch_status_t	switch_core_asr_start_input_timers (switch_asr_handle_t *ah)
	Start input timers on an asr handle.
void	switch_core_asr_text_param (switch_asr_handle_t *ah, char *param, const char *val)
	Set a text parameter on an asr handle.
void	switch_core_asr_numeric_param (switch_asr_handle_t *ah, char *param, int val)
	Set a numeric parameter on an asr handle.
void	switch_core_asr_float_param (switch_asr_handle_t *ah, char *param, double val)
	Set a float parameter on an asr handle.
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.
switch_status_t	switch_core_directory_query (switch_directory_handle_t *dh, char *base, char *query)
	Query a directory handle.
switch_status_t	switch_core_directory_next (switch_directory_handle_t *dh)
	Obtain the next record in a lookup.
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.
switch_status_t	switch_core_directory_close (switch_directory_handle_t *dh)
	Close an open directory handle.
FILE *	switch_core_data_channel (switch_text_channel_t channel)
	Retrieve a FILE stream of a given text channel name.
switch_bool_t	switch_core_ready (void)
	Determines if the core is ready to take calls.
switch_bool_t	switch_core_ready_inbound (void)
	Determines if the core is ready to take inbound calls.
switch_bool_t	switch_core_ready_outbound (void)
	Determines if the core is ready to place outbound calls.
switch_core_flag_t	switch_core_flags (void)
	return core flags
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.
int32_t	set_normal_priority (void)
	Set the maximum priority the process can obtain.
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.
void	switch_core_runtime_loop (int bg)
	Run endlessly until the system is shutdown.
switch_status_t	switch_core_set_console (const char *console)
	Set the output console to the desired file.
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.
switch_time_t	switch_core_uptime (void)
	Number of microseconds the system has been up.
int32_t	switch_core_session_ctl (switch_session_ctl_t cmd, void *val)
	send a control message to the core
FILE *	switch_core_get_console (void)
	Get the output console.
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.
void	switch_core_set_globals (void)
	Initiate Globals.
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.
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.
switch_hash_index_t *	switch_core_mime_index (void)
const char *	switch_core_mime_ext2type (const char *ext)
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.
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.
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_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 (switch_bool_t 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)
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_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)
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.
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.
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.
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.
switch_status_t	switch_cache_db_execute_sql (switch_cache_db_handle_t *dbh, char *sql, char **err)
	Executes the sql.
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.
int	switch_cache_db_affected_rows (switch_cache_db_handle_t *dbh)
	Get the affected rows of the last performed query.
void	switch_cache_db_status (switch_stream_handle_t *stream)
	Provides some feedback as to the status of the db connection pool.
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.
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)
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 (switch_cache_db_handle_t *dbh, char *sql, uint32_t retries)
void	switch_core_set_signal_handlers (void)
uint32_t	switch_core_debug_level (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)
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)
	Add user registration.
switch_status_t	switch_core_del_registration (const char *user, const char *realm, const char *token)
	Delete user registration.
switch_status_t	switch_core_expire_registration (int force)
	Expire user registrations.
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)

---

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.

---

Define Documentation

#define CACHE_DB_LEN   256

Definition at line 2157 of file switch_core.h.

Referenced by _switch_cache_db_get_db_handle(), and switch_cache_db_status().

#define MESSAGE_STAMP_FFL

(

_m

)

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

Definition at line 64 of file switch_core.h.

Referenced by send_display().

#define MESSAGE_STRING_ARG_MAX   10

Definition at line 66 of file switch_core.h.

Referenced by switch_core_session_free_message().

#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 2237 of file switch_core.h.

#define switch_core_db_handle

(

_a

)

_switch_core_db_handle(_a, __FILE__, __SWITCH_FUNC__, __LINE__)

Definition at line 2279 of file switch_core.h.

Referenced by switch_console_complete(), switch_console_expand_alias(), switch_console_list_uuid(), switch_console_set_alias(), switch_console_set_complete(), switch_core_sql_thread(), and switch_core_sqldb_start().

#define SWITCH_MAX_CORE_THREAD_SESSION_OBJS   128

Definition at line 45 of file switch_core.h.

#define SWITCH_MAX_STREAMS   128

Definition at line 46 of file switch_core.h.

---

Typedef Documentation

typedef struct switch_cache_db_handle switch_cache_db_handle_t

Definition at line 2189 of file switch_core.h.

---

Enumeration Type Documentation

enum cache_db_flag_t

Enumerator:

CDF_INUSE
CDF_PRUNE

Definition at line 2158 of file switch_core.h.

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

enum switch_cache_db_handle_type_t

Enumerator:

SCDB_TYPE_CORE_DB
SCDB_TYPE_ODBC

Definition at line 2163 of file switch_core.h.

             {
        SCDB_TYPE_CORE_DB,
        SCDB_TYPE_ODBC
} switch_cache_db_handle_type_t;

---

Function Documentation

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

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

Parameters:

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

Definition at line 322 of file switch_core_sqldb.c.

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

Referenced by _switch_core_db_handle().

{
        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 *db_user = NULL;
        const char *db_pass = 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_ODBC:
                {
                        db_name = connection_options->odbc_options.dsn;
                        db_user = connection_options->odbc_options.user;
                        db_pass = connection_options->odbc_options.pass;
                }
                break;
        case SCDB_TYPE_CORE_DB:
                {
                        db_name = connection_options->core_db_options.db_path;
                        db_user = "";
                        db_pass = "";
                }
                break;
        }

        if (!db_name) {
                return SWITCH_STATUS_FALSE;
        }


        snprintf(db_str, sizeof(db_str) - 1, "db=\"%s\";user=\"%s\";pass=\"%s\"", db_name, db_user, db_pass);
        snprintf(db_callsite_str, sizeof(db_callsite_str) - 1, "%s:%d", file, line);
        snprintf(thread_str, sizeof(thread_str) - 1, "thread=\"%lu\"",  (unsigned long) (intptr_t) self); 

        if ((new_dbh = get_handle(db_str, db_callsite_str, thread_str))) {
                switch_log_printf(SWITCH_CHANNEL_ID_LOG, file, func, line, NULL, SWITCH_LOG_DEBUG10,
                                                  "Reuse Unused Cached DB handle %s [%s]\n", new_dbh->name, switch_cache_db_type_name(new_dbh->type));
        } else {
                switch_core_db_t *db = NULL;
                switch_odbc_handle_t *odbc_dbh = NULL;

                switch (type) {
                case SCDB_TYPE_ODBC:
                        {

                                if (!switch_odbc_available()) {
                                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Failure! ODBC NOT AVAILABLE! Can't connect to DSN %s\n", connection_options->odbc_options.dsn);
                                        goto end;
                                }

                                if ((odbc_dbh = switch_odbc_handle_new(connection_options->odbc_options.dsn,
                                                                                                           connection_options->odbc_options.user, connection_options->odbc_options.pass))) {
                                        if (switch_odbc_handle_connect(odbc_dbh) != SWITCH_ODBC_SUCCESS) {
                                                switch_odbc_handle_destroy(&odbc_dbh);
                                        }
                                }


                        }
                        break;
                case SCDB_TYPE_CORE_DB:
                        {
                                db = switch_core_db_open_file(connection_options->core_db_options.db_path);
                        }
                        break;

                default:
                        goto end;
                }

                if (!db && !odbc_dbh) {
                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Failure to connect to %s %s!\n", db?"SQLITE":"ODBC", db?connection_options->core_db_options.db_path:connection_options->odbc_options.dsn);
                        goto end;
                }

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

                new_dbh = create_handle(type);

                if (db) {
                        new_dbh->native_handle.core_db_dbh = db;
                } else {
                        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_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 182 of file switch_core_sqldb.c.

References _switch_cache_db_get_db_handle(), switch_cache_db_connection_options_t::core_db_options, switch_cache_db_core_db_options_t::db_path, switch_runtime::dbname, switch_cache_db_odbc_options_t::dsn, switch_runtime::odbc_dsn, switch_cache_db_connection_options_t::odbc_options, switch_runtime::odbc_pass, switch_runtime::odbc_user, switch_cache_db_odbc_options_t::pass, runtime, SCDB_TYPE_CORE_DB, SCDB_TYPE_ODBC, SCF_CORE_ODBC_REQ, sql_manager, SWITCH_CORE_DB, SWITCH_STATUS_FALSE, switch_test_flag, switch_cache_db_odbc_options_t::user, and zstr.

{
        switch_cache_db_connection_options_t options = { {0} };
        switch_status_t r;
        
        if (!sql_manager.manage) {
                return SWITCH_STATUS_FALSE;
        }

        if (zstr(runtime.odbc_dsn)) {
                if (switch_test_flag((&runtime), SCF_CORE_ODBC_REQ)) {
                        return SWITCH_STATUS_FALSE;
                }

                if (runtime.dbname) {
                        options.core_db_options.db_path = runtime.dbname;
                } else {
                        options.core_db_options.db_path = SWITCH_CORE_DB;
                }
                r = _switch_cache_db_get_db_handle(dbh, SCDB_TYPE_CORE_DB, &options, file, func, line);
                
        } else {
                options.odbc_options.dsn = runtime.odbc_dsn;
                options.odbc_options.user = runtime.odbc_user;
                options.odbc_options.pass = runtime.odbc_pass;

                r = _switch_cache_db_get_db_handle(dbh, SCDB_TYPE_ODBC, &options, file, func, line);
        }

        /* I *think* we can do without this now, if not let me know 
        if (r == SWITCH_STATUS_SUCCESS && !(*dbh)->io_mutex) {
                (*dbh)->io_mutex = sql_manager.io_mutex;
        }
        */

        return r;
}

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

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

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

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

References switch_cache_db_release_db_handle().

{
        switch_cache_db_release_db_handle(dbh);
}

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

Executes the sql.

Parameters:

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

Definition at line 578 of file switch_core_sqldb.c.

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

Referenced by switch_cache_db_persistant_execute_trans(), switch_cache_db_test_reactive(), switch_core_sql_thread(), and switch_core_sqldb_start().

{
        switch_status_t status = SWITCH_STATUS_FALSE;
        switch_mutex_t *io_mutex = dbh->io_mutex;

        if (io_mutex) switch_mutex_lock(io_mutex);

        switch (dbh->type) {
        default:
                {
                        status = switch_cache_db_execute_sql_chunked(dbh, (char *) sql, 32768, err);
                }
                break;
        }

        if (io_mutex) switch_mutex_unlock(io_mutex);

        return status;

}

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

Executes the sql and returns the result as a string.

Parameters:

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

Definition at line 618 of file switch_core_sqldb.c.

References io_mutex, running, SCDB_TYPE_CORE_DB, 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_mutex_lock(), switch_mutex_unlock(), switch_odbc_handle_exec_string(), SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

{
        switch_status_t status = SWITCH_STATUS_FALSE;
        switch_mutex_t *io_mutex = dbh->io_mutex;

        if (io_mutex) switch_mutex_lock(io_mutex);

        memset(str, 0, len);

        switch (dbh->type) {
        case SCDB_TYPE_CORE_DB:
                {
                        switch_core_db_stmt_t *stmt;

                        if (switch_core_db_prepare(dbh->native_handle.core_db_dbh, sql, -1, &stmt, 0)) {
                                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Statement Error [%s]!\n", sql);
                                goto end;
                        } else {
                                int running = 1;
                                int colcount;

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

                                        if (result == SWITCH_CORE_DB_ROW) {
                                                if ((colcount = switch_core_db_column_count(stmt)) > 0) {
                                                        if ((txt = switch_core_db_column_text(stmt, 0))) {
                                                                switch_copy_string(str, (char *) txt, len);
                                                                status = SWITCH_STATUS_SUCCESS;
                                                        } else {
                                                                goto end;
                                                        }
                                                }
                                                break;
                                        } else if (result == SWITCH_CORE_DB_BUSY) {
                                                running++;
                                                switch_cond_next();
                                                continue;
                                        }
                                        break;
                                }

                                switch_core_db_finalize(stmt);
                        }
                }
                break;
        case SCDB_TYPE_ODBC:
                {
                        status = switch_odbc_handle_exec_string(dbh->native_handle.odbc_dbh, sql, str, len, err);
                }
                break;
        }

 end:

        if (io_mutex) switch_mutex_unlock(io_mutex);

        return status == SWITCH_STATUS_SUCCESS ? str : NULL;

}

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

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

Parameters:

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

Definition at line 851 of file switch_core_sqldb.c.

References io_mutex, SCDB_TYPE_CORE_DB, 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_mutex_lock(), switch_mutex_unlock(), switch_odbc_handle_callback_exec, SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

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

{
        switch_status_t status = SWITCH_STATUS_FALSE;
        char *errmsg = NULL;
        switch_mutex_t *io_mutex = dbh->io_mutex;

        if (err) {
                *err = NULL;
        }

        if (io_mutex) switch_mutex_lock(io_mutex);


        switch (dbh->type) {
        case SCDB_TYPE_ODBC:
                {
                        status = switch_odbc_handle_callback_exec(dbh->native_handle.odbc_dbh, sql, callback, pdata, err);
                }
                break;
        case SCDB_TYPE_CORE_DB:
                {
                        int ret = switch_core_db_exec(dbh->native_handle.core_db_dbh, sql, callback, pdata, &errmsg);

                        if (ret == SWITCH_CORE_DB_OK || ret == SWITCH_CORE_DB_ABORT) {
                                status = SWITCH_STATUS_SUCCESS;
                        }

                        if (errmsg) {
                                dbh->last_used = switch_epoch_time_now(NULL) - (SQL_CACHE_TIMEOUT * 2);
                                if (!strstr(errmsg, "query abort")) {
                                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "SQL ERR: [%s] %s\n", sql, errmsg);
                                }
                                switch_core_db_free(errmsg);
                        }
                }
                break;
        }

        if (io_mutex) switch_mutex_unlock(io_mutex);

        return status;
}

void switch_cache_db_flush_handles

(

void

)

Definition at line 289 of file switch_core_sqldb.c.

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

Referenced by switch_core_session_ctl(), and switch_core_sqldb_stop().

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

switch_cache_db_handle_type_t switch_cache_db_get_type

(

switch_cache_db_handle_t *

dbh

)

Definition at line 284 of file switch_core_sqldb.c.

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

{
        return dbh->type;
}

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

Definition at line 680 of file switch_core_sqldb.c.

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

Referenced by switch_console_set_alias(), and switch_console_set_complete().

{
        char *errmsg = NULL;
        switch_status_t status = SWITCH_STATUS_FALSE;
        uint8_t forever = 0;
        switch_mutex_t *io_mutex = dbh->io_mutex;

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

        while (retries > 0) {

                if (io_mutex) switch_mutex_lock(io_mutex);
                switch_cache_db_execute_sql_real(dbh, sql, &errmsg);
                if (io_mutex) switch_mutex_unlock(io_mutex);

                
                if (errmsg) {
                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "SQL ERR [%s]\n", errmsg);
                        switch_safe_free(errmsg);
                        switch_yield(100000);
                        retries--;
                        if (retries == 0 && forever) {
                                retries = 1000;
                                continue;
                        }
                } else {
                        status = SWITCH_STATUS_SUCCESS;
                        break;
                }
        }
        
        return status;
}

switch_status_t switch_cache_db_persistant_execute_trans	(	switch_cache_db_handle_t *	dbh,
		char *	sql,
		uint32_t	retries
	)

Definition at line 718 of file switch_core_sqldb.c.

References switch_runtime::core_db_inner_post_trans_execute, switch_runtime::core_db_inner_pre_trans_execute, switch_runtime::core_db_post_trans_execute, switch_runtime::core_db_pre_trans_execute, DBTYPE_DEFAULT, io_mutex, switch_runtime::odbc_dbtype, runtime, switch_cache_db_execute_sql(), switch_cache_db_execute_sql_real(), SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, SWITCH_LOG_DEBUG, SWITCH_LOG_ERROR, switch_log_printf(), switch_mutex_lock(), switch_mutex_unlock(), switch_odbc_SQLEndTran(), switch_odbc_SQLSetAutoCommitAttr(), SWITCH_ODBC_SUCCESS, switch_snprintfv(), SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, switch_yield, and zstr.

Referenced by switch_core_sql_thread().

{
        char *errmsg = NULL;
        switch_status_t status = SWITCH_STATUS_FALSE;
        uint8_t forever = 0;
        unsigned begin_retries = 100;
        uint8_t again = 0;
        switch_mutex_t *io_mutex = dbh->io_mutex;

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

        if (io_mutex) switch_mutex_lock(io_mutex);

        if (!zstr(runtime.core_db_pre_trans_execute)) {
                switch_cache_db_execute_sql_real(dbh, runtime.core_db_pre_trans_execute, &errmsg);
                if (errmsg) {
                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "SQL PRE TRANS EXEC %s [%s]\n", runtime.core_db_pre_trans_execute, errmsg);
                        free(errmsg);
                }
        }

 again:

        while (begin_retries > 0) {
                again = 0;

                if (runtime.odbc_dbtype == DBTYPE_DEFAULT) {
                        switch_cache_db_execute_sql_real(dbh, "BEGIN", &errmsg);
                } else {
                        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);
                        }
                }

                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);
                        }
                        free(errmsg);
                        errmsg = NULL;

                        if (again) {
                                if (runtime.odbc_dbtype == DBTYPE_DEFAULT) {
                                        switch_cache_db_execute_sql_real(dbh, "COMMIT", NULL);
                                } else  {
                                        switch_odbc_SQLEndTran(dbh->native_handle.odbc_dbh, 1);
                                        switch_odbc_SQLSetAutoCommitAttr(dbh->native_handle.odbc_dbh, 1);
                                }

                                goto again;
                        }
                        
                        switch_yield(100000);

                        if (begin_retries == 0) {
                                goto done;
                        }

                        continue;
                }

                break;
        }


        if (!zstr(runtime.core_db_inner_pre_trans_execute)) {
                switch_cache_db_execute_sql_real(dbh, runtime.core_db_inner_pre_trans_execute, &errmsg);
                if (errmsg) {
                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "SQL PRE TRANS EXEC %s [%s]\n", runtime.core_db_inner_pre_trans_execute, errmsg);
                        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);
                        free(errmsg);
                        errmsg = NULL;
                        switch_yield(100000);
                        retries--;
                        if (retries == 0 && forever) {
                                retries = 1000;
                                continue;
                        }
                } else {
                        status = SWITCH_STATUS_SUCCESS;
                        break;
                }
        }

        if (!zstr(runtime.core_db_inner_post_trans_execute)) {
                switch_cache_db_execute_sql_real(dbh, runtime.core_db_inner_post_trans_execute, &errmsg);
                if (errmsg) {
                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "SQL POST TRANS EXEC %s [%s]\n", runtime.core_db_inner_post_trans_execute, errmsg);
                        free(errmsg);
                }
        }

 done:

        if (runtime.odbc_dbtype == DBTYPE_DEFAULT) {
                switch_cache_db_execute_sql_real(dbh, "COMMIT", NULL);
        } else {
                switch_odbc_SQLEndTran(dbh->native_handle.odbc_dbh, 1);
                switch_odbc_SQLSetAutoCommitAttr(dbh->native_handle.odbc_dbh, 1);
        }

        if (!zstr(runtime.core_db_post_trans_execute)) {
                switch_cache_db_execute_sql_real(dbh, runtime.core_db_post_trans_execute, &errmsg);
                if (errmsg) {
                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "SQL POST TRANS EXEC %s [%s]\n", runtime.core_db_post_trans_execute, errmsg);
                        free(errmsg);
                }
        }

        if (io_mutex) switch_mutex_unlock(io_mutex);

        return status;
}

void switch_cache_db_release_db_handle

(

switch_cache_db_handle_t **

dbh

)

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

Parameters:

[in]

The

handle

Definition at line 295 of file switch_core_sqldb.c.

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

Referenced by switch_cache_db_dismiss_db_handle(), switch_console_expand_alias(), switch_console_list_uuid(), switch_console_set_alias(), switch_console_set_complete(), switch_core_sql_thread(), and switch_core_sqldb_start().

{
        if (dbh && *dbh) {
                switch_mutex_lock(sql_manager.dbh_mutex);
                (*dbh)->last_used = switch_epoch_time_now(NULL);

                (*dbh)->io_mutex = NULL;
                
                if ((*dbh)->use_count) {
                        if (--(*dbh)->use_count == 0) {
                                (*dbh)->thread_hash = 1;
                        }
                }
                switch_mutex_unlock((*dbh)->mutex);
                sql_manager.total_used_handles--;
                *dbh = NULL;
                switch_mutex_unlock(sql_manager.dbh_mutex);
        }
}

void switch_cache_db_status

(

switch_stream_handle_t *

stream

)

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

Parameters:

[in]

stream

stream for status

Definition at line 2147 of file switch_core_sqldb.c.

References CACHE_DB_LEN, switch_cache_db_handle::creator, switch_cache_db_handle::last_used, switch_cache_db_handle::last_user, 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_TRUE, switch_cache_db_handle::type, and switch_cache_db_handle::use_count.

{
        /* 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 *needle = "pass=\"";
                time_t diff = 0;

                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));
                pos1 = strstr(dbh->name, needle) + strlen(needle);
                pos2 = strstr(pos1, "\"");
                strncpy(cleankey_str, dbh->name, pos1 - dbh->name);
                strcpy(&cleankey_str[pos1 - dbh->name], pos2);
                
                count++;
                
                if (dbh->use_count) {
                        used++;
                }
                
                stream->write_function(stream, "%s\n\tType: %s\n\tLast used: %d\n\tFlags: %s, %s(%d)\n"
                                                           "\tCreator: %s\n\tLast User: %s\n",
                                                           cleankey_str,
                                                           switch_cache_db_type_name(dbh->type),
                                                           diff,
                                                           locked ? "Locked" : "Unlocked",
                                                           dbh->use_count ? "Attached" : "Detached", dbh->use_count, dbh->creator, dbh->last_user);
        }

        stream->write_function(stream, "%d total. %d in use.\n", count, used);

        switch_mutex_unlock(sql_manager.dbh_mutex);
}

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

Definition at line 895 of file switch_core_sqldb.c.

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

Referenced by switch_core_sqldb_start().

{
        char *errmsg;
        switch_bool_t r = SWITCH_TRUE;
        switch_mutex_t *io_mutex = dbh->io_mutex;

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

        if (!switch_test_flag((&runtime), SCF_AUTO_SCHEMAS)) {
                switch_cache_db_execute_sql(dbh, (char *)test_sql, NULL);
                return SWITCH_TRUE;
        }

        if (io_mutex) switch_mutex_lock(io_mutex);

        switch (dbh->type) {
        case SCDB_TYPE_ODBC:
                {
                        if (switch_odbc_handle_exec(dbh->native_handle.odbc_dbh, test_sql, NULL, NULL) != SWITCH_ODBC_SUCCESS) {
                                r = SWITCH_FALSE;
                                if (drop_sql) {
                                        switch_odbc_handle_exec(dbh->native_handle.odbc_dbh, drop_sql, NULL, NULL);
                                }
                                switch_odbc_handle_exec(dbh->native_handle.odbc_dbh, reactive_sql, NULL, NULL);
                        }
                }
                break;
        case SCDB_TYPE_CORE_DB:
                {
                        if (test_sql) {
                                switch_core_db_exec(dbh->native_handle.core_db_dbh, test_sql, NULL, NULL, &errmsg);

                                if (errmsg) {
                                        r = SWITCH_FALSE;
                                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "SQL ERR [%s]\n[%s]\nAuto Generating Table!\n", errmsg, test_sql);
                                        switch_core_db_free(errmsg);
                                        errmsg = NULL;
                                        if (drop_sql) {
                                                switch_core_db_exec(dbh->native_handle.core_db_dbh, drop_sql, NULL, NULL, &errmsg);
                                        }
                                        if (errmsg) {
                                                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "SQL ERR [%s]\n[%s]\n", errmsg, drop_sql);
                                                switch_core_db_free(errmsg);
                                                errmsg = NULL;
                                        }
                                        switch_core_db_exec(dbh->native_handle.core_db_dbh, reactive_sql, NULL, NULL, &errmsg);
                                        if (errmsg) {
                                                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;
                                        }
                                }
                        }
                }
                break;
        }


        if (io_mutex) switch_mutex_unlock(io_mutex);

        return r;
}

static const char* switch_cache_db_type_name

(

switch_cache_db_handle_type_t

type

)

[inline, static]

Definition at line 2191 of file switch_core.h.

References SCDB_TYPE_CORE_DB, and SCDB_TYPE_ODBC.

Referenced by _switch_cache_db_get_db_handle(), and switch_cache_db_status().

{
        const char *type_str = "INVALID";

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

        return type_str;
}

void switch_close_extra_files	(	int *	keep,
		int	keep_ttl
	)

Definition at line 2521 of file switch_core.c.

References skip(), and switch_max_file_desc().

Referenced by preprocess_exec(), switch_stream_system_fork(), 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_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
	)

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
[out]	err	- Error if it exists

Definition at line 1845 of file switch_core_sqldb.c.

References switch_runtime::multiple_registrations, runtime, SCF_USE_SQL, sql_manager, switch_core_get_switchname(), switch_mprintf(), switch_queue_push(), SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, switch_str_nil, and switch_test_flag.

{
        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_queue_push(sql_manager.sql_queue[0], sql);
        
        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_queue_push(sql_manager.sql_queue[0], sql);
        
        return SWITCH_STATUS_SUCCESS;
}

const char* switch_core_banner

(

void

)

Definition at line 1884 of file switch_core.c.

Referenced by switch_core_init_and_modload().

{


        return ("\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");
}

uint32_t switch_core_debug_level

(

void

)

Definition at line 2040 of file switch_core.c.

References switch_runtime::debug_level, and runtime.

{
        return runtime.debug_level;
}

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

References switch_runtime::multiple_registrations, runtime, SCF_USE_SQL, sql_manager, switch_core_get_switchname(), switch_mprintf(), switch_queue_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_queue_push(sql_manager.sql_queue[0], sql);

        return SWITCH_STATUS_SUCCESS;
}

switch_status_t switch_core_expire_registration

(

int

force

)

Expire user registrations.

Parameters:

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

Definition at line 1903 of file switch_core_sqldb.c.

References runtime, SCF_USE_SQL, sql_manager, switch_core_get_switchname(), switch_epoch_time_now(), switch_mprintf(), switch_queue_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_queue_push(sql_manager.sql_queue[0], sql);

        return SWITCH_STATUS_SUCCESS;

}

switch_bool_t switch_core_session_in_thread

(

switch_core_session_t *

session

)

Definition at line 1392 of file switch_core_session.c.

References SWITCH_FALSE, switch_thread_equal(), switch_thread_self(), and SWITCH_TRUE.

Referenced by switch_channel_check_signal(), switch_channel_state_change_pending(), and switch_ivr_nomedia().

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

void switch_core_set_signal_handlers

(

void

)

Definition at line 2008 of file switch_core.c.

References handle_SIGCHLD(), handle_SIGHUP(), runtime, SCF_THREADED_SYSTEM_EXEC, and switch_test_flag.

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

{
        /* set signal handlers */
        signal(SIGINT, SIG_IGN);
#ifndef WIN32
        if (switch_test_flag((&runtime), SCF_THREADED_SYSTEM_EXEC)) {
                signal(SIGCHLD, SIG_DFL);
        } else {
                signal(SIGCHLD, handle_SIGCHLD);
        }
#endif
#ifdef SIGPIPE
        signal(SIGPIPE, 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_status_t switch_core_thread_set_cpu_affinity

(

int

cpu

)

Definition at line 1328 of file switch_core.c.

References SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

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

uint32_t switch_default_ptime	(	const char *	name,
		uint32_t	number
	)

Definition at line 1615 of file switch_core.c.

References switch_runtime::ptimes, runtime, and switch_core_hash_find().

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

int switch_max_file_desc

(

void

)

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

}

void switch_os_yield

(

void

)

Definition at line 143 of file switch_time.c.

Referenced by switch_cond_next(), SWITCH_MODULE_RUNTIME_FUNCTION(), and timer_next().

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

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

Definition at line 2443 of file switch_loadable_module.c.

References buf, and switch_vsnprintf().

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

        va_start(ap, fmt);
        
        if ((ret = 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 {
                        sh->stream.write_function(&sh->stream, "!%s.%s", buf, sh->ext);
                }

        }
        
        va_end(ap);
}

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 2420 of file switch_loadable_module.c.

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

void switch_say_file_handle_destroy

(

switch_say_file_handle_t **

sh

)

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

char* switch_say_file_handle_detach_path

(

switch_say_file_handle_t *

sh

)

Definition at line 2395 of file switch_loadable_module.c.

References switch_assert.

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

char* switch_say_file_handle_get_path

(

switch_say_file_handle_t *

sh

)

Definition at line 2390 of file switch_loadable_module.c.

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

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

Definition at line 2378 of file switch_loadable_module.c.

References switch_event_get_header.

{
        char *ret = NULL;

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

        return ret;
        
}

---