switch_core.c File Reference

Data Structures
struct	switch_ip_list_t
Defines
#define	BUFSIZE   1024
Functions
	SWITCH_STANDARD_SCHED_FUNC (heartbeat_callback)
switch_status_t	switch_core_set_console (const char *console)
	Set the output console to the desired file.
FILE *	switch_core_get_console (void)
	Get the output console.
FILE *	switch_core_data_channel (switch_text_channel_t channel)
	Retrieve a FILE stream of a given text channel name.
int	switch_core_add_state_handler (const switch_state_handler_table_t *state_handler)
const switch_state_handler_table_t *	switch_core_get_state_handler (int index)
char *	switch_core_get_variable (const char *varname)
void	switch_core_set_variable (const char *varname, const char *value)
char *	switch_core_get_uuid (void)
	Retrieve the unique identifier from the core.
void	switch_core_thread_session_end (switch_core_thread_session_t *thread_session)
void	switch_core_service_session (switch_core_session_t *session, switch_core_thread_session_t *thread_session, int stream_id)
void	switch_core_launch_thread (switch_thread_start_t func, void *obj, switch_memory_pool_t *pool)
void	switch_core_set_globals (void)
	Initiate Globals.
int32_t	set_high_priority (void)
	Set the maximum priority the process can obtain.
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.
const char *	switch_core_mime_ext2type (const char *ext)
switch_hash_index_t *	switch_core_mime_index (void)
switch_status_t	switch_core_mime_add_type (const char *type, const char *ext)
void	switch_core_setrlimits (void)
switch_bool_t	switch_check_network_list_ip (const char *ip_str, const char *list_name)
void	switch_load_network_lists (switch_bool_t reload)
uint32_t	switch_core_max_dtmf_duration (uint32_t duration)
uint32_t	switch_core_default_dtmf_duration (uint32_t duration)
switch_status_t	switch_core_init (switch_core_flag_t flags, switch_bool_t console, const char **err)
switch_status_t	switch_core_init_and_modload (switch_core_flag_t flags, switch_bool_t console, const char **err)
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, int32_t *val)
	send a control message to the core
switch_core_flag_t	switch_core_flags (void)
	return core flags
switch_bool_t	switch_core_ready (void)
	Determines if the core is ready to take calls.
switch_status_t	switch_core_destroy (void)
	Destroy the core.
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.
void	switch_core_memory_reclaim_all (void)
Variables
SWITCH_DECLARE_DATA switch_directories	SWITCH_GLOBAL_dirs = { 0 }
switch_runtime	runtime

---

Define Documentation

#define BUFSIZE   1024

---

Function Documentation

int switch_core_add_state_handler (  const switch_state_handler_table_t *  state_handler  )

{ int index = runtime.state_handler_index++; if (runtime.state_handler_index >= SWITCH_MAX_STATE_HANDLERS) { return -1; } runtime.state_handlers[index] = state_handler; return index; }

const switch_state_handler_table_t* switch_core_get_state_handler (  int  index  )

{ if (index >= SWITCH_MAX_STATE_HANDLERS || index > runtime.state_handler_index) { return NULL; } return runtime.state_handlers[index]; }

char* switch_core_get_variable (  const char *  varname  )

{ char *val; switch_mutex_lock(runtime.global_mutex); val = (char *) switch_core_hash_find(runtime.global_vars, varname); switch_mutex_unlock(runtime.global_mutex); return val; }

Here is the call graph for this function:

switch_status_t switch_core_init (  switch_core_flag_t  flags, switch_bool_t  console, const char **  err )

{ switch_xml_t xml = NULL, cfg = NULL; switch_uuid_t uuid; char guess_ip[256]; memset(&runtime, 0, sizeof(runtime)); runtime.dummy_cng_frame.data = runtime.dummy_data; runtime.dummy_cng_frame.datalen= sizeof(runtime.dummy_data); runtime.dummy_cng_frame.buflen= sizeof(runtime.dummy_data); runtime.dummy_cng_frame.flags = SFF_CNG; switch_set_flag((&runtime), SCF_NO_NEW_SESSIONS); runtime.hard_log_level = SWITCH_LOG_DEBUG; runtime.mailer_app = "sendmail"; runtime.mailer_app_args = "-t"; runtime.max_dtmf_duration = SWITCH_MAX_DTMF_DURATION; runtime.default_dtmf_duration = SWITCH_DEFAULT_DTMF_DURATION; /* INIT APR and Create the pool context */ if (apr_initialize() != SWITCH_STATUS_SUCCESS) { *err = "FATAL ERROR! Could not initialize APR\n"; return SWITCH_STATUS_MEMERR; } if (!(runtime.memory_pool = switch_core_memory_init())) { *err = "FATAL ERROR! Could not allocate memory pool\n"; return SWITCH_STATUS_MEMERR; } switch_assert(runtime.memory_pool != NULL); switch_mutex_init(&runtime.throttle_mutex, SWITCH_MUTEX_NESTED, runtime.memory_pool); switch_mutex_init(&runtime.global_mutex, SWITCH_MUTEX_NESTED, runtime.memory_pool); switch_core_set_globals(); switch_core_session_init(runtime.memory_pool); switch_core_hash_init(&runtime.global_vars, runtime.memory_pool); switch_core_hash_init(&runtime.mime_types, runtime.memory_pool); load_mime_types(); runtime.flags = flags; runtime.sps_total = 30; switch_find_local_ip(guess_ip, sizeof(guess_ip), AF_INET); switch_core_set_variable("local_ip_v4", guess_ip); switch_find_local_ip(guess_ip, sizeof(guess_ip), AF_INET6); switch_core_set_variable("local_ip_v6", guess_ip); switch_core_set_variable("base_dir", SWITCH_GLOBAL_dirs.base_dir); switch_log_init(runtime.memory_pool); switch_event_init(runtime.memory_pool); if (switch_xml_init(runtime.memory_pool, err) != SWITCH_STATUS_SUCCESS) { apr_terminate(); return SWITCH_STATUS_MEMERR; } if ((xml = switch_xml_open_cfg("switch.conf", &cfg, NULL))) { switch_xml_t settings, param; if ((settings = switch_xml_child(cfg, "settings"))) { for (param = switch_xml_child(settings, "param"); param; param = param->next) { const char *var = switch_xml_attr_soft(param, "name"); const char *val = switch_xml_attr_soft(param, "value"); if (!strcasecmp(var, "crash-protection")) { if (switch_true(val)) { switch_set_flag((&runtime), SCF_CRASH_PROT); } } else if (!strcasecmp(var, "loglevel")) { int level; if (*val > 47 && *val < 58) { level = atoi(val); } else { level = switch_log_str2level(val); } if (level != SWITCH_LOG_INVALID) { switch_core_session_ctl(SCSC_LOGLEVEL, &level); } #ifdef HAVE_SETRLIMIT } else if (!strcasecmp(var, "dump-cores")) { struct rlimit rlp; memset(&rlp, 0, sizeof(rlp)); rlp.rlim_cur = RLIM_INFINITY; rlp.rlim_max = RLIM_INFINITY; setrlimit(RLIMIT_CORE, &rlp); #endif } else if (!strcasecmp(var, "mailer-app")) { runtime.mailer_app = switch_core_strdup(runtime.memory_pool, val); } else if (!strcasecmp(var, "mailer-app-args")) { runtime.mailer_app_args = switch_core_strdup(runtime.memory_pool, val); } else if (!strcasecmp(var, "sessions-per-second")) { switch_core_sessions_per_second(atoi(val)); } else if (!strcasecmp(var, "max_dtmf_duration")) { int tmp = atoi(val); if (tmp > 0) { switch_core_max_dtmf_duration((uint32_t)tmp); } } else if (!strcasecmp(var, "default_dtmf_duration")) { int tmp = atoi(val); if (tmp > 0) { switch_core_default_dtmf_duration((uint32_t)tmp); } } else if (!strcasecmp(var, "disable-monotonic-timing")) { switch_time_set_monotonic(SWITCH_FALSE); } else if (!strcasecmp(var, "max-sessions")) { switch_core_session_limit(atoi(val)); } else if (!strcasecmp(var, "rtp-start-port")) { switch_rtp_set_start_port((switch_port_t)atoi(val)); } else if (!strcasecmp(var, "rtp-end-port")) { switch_rtp_set_end_port((switch_port_t)atoi(val)); } } } if ((settings = switch_xml_child(cfg, "variables"))) { for (param = switch_xml_child(settings, "variable"); param; param = param->next) { const char *var = switch_xml_attr_soft(param, "name"); const char *val = switch_xml_attr_soft(param, "value"); char *varr = NULL, *vall = NULL; varr = switch_core_strdup(runtime.memory_pool, var); vall = switch_core_strdup(runtime.memory_pool, val); switch_core_hash_insert(runtime.global_vars, varr, vall); } } switch_xml_free(xml); } switch_core_state_machine_init(runtime.memory_pool); *err = NULL; if (console) { runtime.console = stdout; } if (switch_test_flag((&runtime), SCF_USE_SQL)) { switch_core_sqldb_start(runtime.memory_pool); } switch_rtp_init(runtime.memory_pool); runtime.running = 1; switch_scheduler_task_thread_start(); runtime.initiated = switch_time_now(); switch_scheduler_add_task(switch_timestamp(NULL), heartbeat_callback, "heartbeat", "core", 0, NULL, SSHF_NONE | SSHF_NO_DEL); switch_uuid_get(&uuid); switch_uuid_format(runtime.uuid_str, &uuid); return SWITCH_STATUS_SUCCESS; }

Here is the call graph for this function:

switch_status_t switch_core_init_and_modload (  switch_core_flag_t  flags, switch_bool_t  console, const char **  err )

{ switch_event_t *event; if (switch_core_init(flags, console, err) != SWITCH_STATUS_SUCCESS) { return SWITCH_STATUS_GENERR; } /* set signal handlers */ signal(SIGINT, handle_SIGINT); #ifdef SIGPIPE signal(SIGPIPE, handle_SIGPIPE); #endif #ifdef SIGQUIT signal(SIGQUIT, handle_SIGQUIT); #endif #ifdef SIGPOLL signal(SIGPOLL, handle_SIGPOLL); #endif #ifdef SIGIO signal(SIGIO, handle_SIGIO); #endif #ifdef TRAP_BUS signal(SIGBUS, handle_SIGBUS); #endif signal(SIGHUP, handle_SIGHUP); switch_load_network_lists(SWITCH_FALSE); switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "Bringing up environment.\n"); switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "Loading Modules.\n"); if (switch_loadable_module_init() != SWITCH_STATUS_SUCCESS) { *err = "Cannot load modules"; switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "Error: %s\n", *err); return SWITCH_STATUS_GENERR; } if (switch_event_create(&event, SWITCH_EVENT_STARTUP) == SWITCH_STATUS_SUCCESS) { switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Event-Info", "System Ready"); switch_event_fire(&event); } switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "\nFreeSWITCH Version %s Started.\nCrash Protection [%s]\nMax Sessions[%u]\nSession Rate[%d]\nSQL [%s]\n", SWITCH_VERSION_FULL, switch_test_flag((&runtime), SCF_CRASH_PROT) ? "Enabled" : "Disabled", switch_core_session_limit(0), switch_core_sessions_per_second(0), switch_test_flag((&runtime), SCF_USE_SQL) ? "Enabled" : "Disabled" ); switch_clear_flag((&runtime), SCF_NO_NEW_SESSIONS); return SWITCH_STATUS_SUCCESS; }

Here is the call graph for this function:

void switch_core_launch_thread (  switch_thread_start_t  func, void *  obj, switch_memory_pool_t *  pool )

{ switch_thread_t *thread; switch_threadattr_t *thd_attr = NULL; switch_core_thread_session_t *ts; int mypool; mypool = pool ? 0 : 1; if (!pool && switch_core_new_memory_pool(&pool) != SWITCH_STATUS_SUCCESS) { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Could not allocate memory pool\n"); return; } switch_threadattr_create(&thd_attr, pool); switch_threadattr_detach_set(thd_attr, 1); if ((ts = switch_core_alloc(pool, sizeof(*ts))) == 0) { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Could not allocate memory\n"); } else { if (mypool) { ts->pool = pool; } ts->objs[0] = obj; switch_threadattr_stacksize_set(thd_attr, SWITCH_THREAD_STACKSIZE); switch_thread_create(&thread, thd_attr, func, ts, pool); } }

Here is the call graph for this function:

void switch_core_service_session (  switch_core_session_t *  session, switch_core_thread_session_t *  thread_session, int  stream_id )

{ thread_session->running = 1; thread_session->objs[0] = session; thread_session->objs[1] = &stream_id; switch_core_session_launch_thread(session, switch_core_service_thread, thread_session); }

Here is the call graph for this function:

void switch_core_set_variable (  const char *  varname, const char *  value )

{ char *val; if (varname) { switch_mutex_lock(runtime.global_mutex); val = (char *) switch_core_hash_find(runtime.global_vars, varname); if (val) { free(val); } if (value) { switch_core_hash_insert(runtime.global_vars, varname, strdup(value)); } else { switch_core_hash_delete(runtime.global_vars, varname); } switch_mutex_unlock(runtime.global_mutex); } }

Here is the call graph for this function:

void switch_core_thread_session_end (  switch_core_thread_session_t *  thread_session  )

{ if (thread_session->running > 0) { thread_session->running = -1; while (thread_session->running) { switch_yield(1000); } } }

SWITCH_STANDARD_SCHED_FUNC (  heartbeat_callback   )

{ send_heartbeat(); /* reschedule this task */ task->runtime = switch_timestamp(NULL) + 20; }

Here is the call graph for this function:

---

Variable Documentation

struct switch_runtime runtime

SWITCH_DECLARE_DATA switch_directories SWITCH_GLOBAL_dirs = { 0 }

---