#include <switch.h>
#include <switch_ssl.h>
#include <switch_stun.h>
#include <switch_nat.h>
#include "private/switch_core_pvt.h"
#include <switch_curl.h>
#include <switch_private.h>
#include <errno.h>
#include <sqlite3.h>
#include "cc.h"

Include dependency graph for switch_core.c:

Data Structures
struct	switch_ip_list_t

struct	system_thread_handle

Macros
#define	BUFSIZE 1024

Functions
static void	switch_load_core_config (const char *file)

static void	send_heartbeat (void)

static void	check_ip (void)

	SWITCH_STANDARD_SCHED_FUNC (heartbeat_callback)

	SWITCH_STANDARD_SCHED_FUNC (check_ip_callback)

switch_status_t	switch_core_set_console (const char *console)
	Set the output console to the desired file. More...

FILE *	switch_core_get_console (void)
	Get the output console. More...

void	switch_core_screen_size (int x, int y)

FILE *	switch_core_data_channel (switch_text_channel_t channel)
	Retrieve a FILE stream of a given text channel name. More...

void	switch_core_remove_state_handler (const switch_state_handler_table_t *state_handler)

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)

void	switch_core_dump_variables (switch_stream_handle_t *stream)

const char *	switch_core_get_hostname (void)

const char *	switch_core_get_switchname (void)

char *	switch_core_get_domain (switch_bool_t dup)

switch_status_t	switch_core_get_variables (switch_event_t **event)

char *	switch_core_get_variable (const char *varname)

char *	switch_core_get_variable_dup (const char *varname)

char *	switch_core_get_variable_pdup (const char varname, switch_memory_pool_t pool)

static void	switch_core_unset_variables (void)

void	switch_core_set_variable (const char varname, const char value)

switch_bool_t	switch_core_set_var_conditional (const char varname, const char value, const char *val2)

char *	switch_core_get_uuid (void)
	Retrieve the unique identifier from the core. More...

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

void	switch_core_thread_session_end (switch_core_session_t *session)

void	switch_core_service_session_av (switch_core_session_t *session, switch_bool_t audio, switch_bool_t video)

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

void	switch_core_set_globals (void)
	Initiate Globals. More...

int32_t	switch_core_set_process_privileges (void)
	Switch on the privilege awareness for the process and request required privileges. More...

int32_t	set_low_priority (void)

int32_t	set_realtime_priority (void)

uint32_t	switch_core_cpu_count (void)

int32_t	set_normal_priority (void)
	Set the maximum priority the process can obtain. More...

int32_t	set_auto_priority (void)

int32_t	change_user_group (const char user, const char group)
	Change user and/or group of the running process. More...

void	switch_core_runtime_loop (int bg)
	Run endlessly until the system is shutdown. More...

const char *	switch_core_mime_ext2type (const char *ext)

const char *	switch_core_mime_type2ext (const char *mime)

switch_hash_index_t *	switch_core_mime_index (void)

switch_status_t	switch_core_mime_add_type (const char type, const char ext)

static void	load_mime_types (void)

void	switch_core_setrlimits (void)

switch_bool_t	switch_check_network_list_ip_token (const char ip_str, const char list_name, const char **token)

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)

uint32_t	switch_core_min_dtmf_duration (uint32_t duration)

switch_status_t	switch_core_thread_set_cpu_affinity (int cpu)

int	switch_core_test_flag (int flag)

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

static void	handle_SIGHUP (int sig)

uint32_t	switch_default_ptime (const char *name, uint32_t number)

uint32_t	switch_default_rate (const char *name, uint32_t number)

const char *	switch_core_banner (void)

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. More...

switch_time_t	switch_core_uptime (void)
	Number of microseconds the system has been up. More...

void	switch_core_set_signal_handlers (void)

uint32_t	switch_core_debug_level (void)

int32_t	switch_core_session_ctl (switch_session_ctl_t cmd, void *val)
	send a control message to the core More...

switch_core_flag_t	switch_core_flags (void)
	return core flags More...

switch_bool_t	switch_core_running (void)

switch_bool_t	switch_core_ready (void)
	Determines if the core is ready to take calls. More...

switch_bool_t	switch_core_ready_inbound (void)
	Determines if the core is ready to take inbound calls. More...

switch_bool_t	switch_core_ready_outbound (void)
	Determines if the core is ready to place outbound calls. More...

switch_status_t	switch_core_destroy (void)
	Destroy the core. More...

switch_status_t	switch_core_management_exec (char relative_oid, switch_management_action_t action, char data, switch_size_t datalen)
	Execute a management operation. More...

void	switch_core_memory_reclaim_all (void)

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

static int	switch_system_thread (const char *cmd, switch_bool_t wait)

int	switch_max_file_desc (void)

void	switch_close_extra_files (int *keep, int keep_ttl)

pid_t	switch_fork (void)

static int	switch_system_fork (const char *cmd, switch_bool_t wait)

int	switch_system (const char *cmd, switch_bool_t wait)

int	switch_stream_system_fork (const char cmd, switch_stream_handle_t stream)

switch_status_t	switch_core_get_stacksizes (switch_size_t cur, switch_size_t max)

int	switch_stream_system (const char cmd, switch_stream_handle_t stream)

uint16_t	switch_core_get_rtp_port_range_start_port ()
	Get RTP port range start value. More...

uint16_t	switch_core_get_rtp_port_range_end_port ()
	Get RTP port range end value. More...

Variables
switch_directories	SWITCH_GLOBAL_dirs = { 0 }

switch_filenames	SWITCH_GLOBAL_filenames = { 0 }

struct switch_runtime	runtime = { 0 }

static char	main_ip4 [256] = ""

static char	main_ip6 [256] = ""

static switch_ip_list_t	IP_LIST = { 0 }

static uint32_t	d_30 = 30

Macro Definition Documentation

#define BUFSIZE 1024

Referenced by switch_core_set_globals().

Function Documentation

static void check_ip ( void )

static

Definition at line 109 of file switch_core.c.

References switch_runtime::hostname, main_ip4, main_ip6, switch_core_get_variable(), switch_core_set_variable(), switch_event_add_header(), switch_event_add_header_string(), switch_event_create, switch_event_fire, SWITCH_EVENT_TRAP, switch_find_local_ip(), switch_set_string, SWITCH_STACK_BOTTOM, SWITCH_STATUS_SUCCESS, and zstr.

Referenced by SWITCH_STANDARD_SCHED_FUNC().

 {
         char guess_ip4[256] = "";
         char guess_ip6[256] = "";
         char old_ip4[256] = "";
         char old_ip6[256] = "";
         int ok4 = 1, ok6 = 1;
         int mask = 0;
         switch_status_t check6, check4;
         switch_event_t *event;
         char *hostname = switch_core_get_variable("hostname");
 
         gethostname(runtime.hostname, sizeof(runtime.hostname));
 
         if (zstr(hostname)) {
                 switch_core_set_variable("hostname", runtime.hostname);
         } else if (strcmp(hostname, runtime.hostname)) {
                 if (switch_event_create(&event, SWITCH_EVENT_TRAP) == SWITCH_STATUS_SUCCESS) {
                         switch_event_add_header(event, SWITCH_STACK_BOTTOM, "condition", "hostname-change");
                         switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "old-hostname", hostname ? hostname : "nil");
                         switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "new-hostname", runtime.hostname);
                         switch_event_fire(&event);
                 }
 
                 switch_core_set_variable("hostname", runtime.hostname);
         }
 
         check4 = switch_find_local_ip(guess_ip4, sizeof(guess_ip4), &mask, AF_INET);
         check6 = switch_find_local_ip(guess_ip6, sizeof(guess_ip6), NULL, AF_INET6);
 
         if (check6 != SWITCH_STATUS_SUCCESS && (zstr(main_ip6) || !strcasecmp(main_ip6, "::1"))) {
                 check6 = SWITCH_STATUS_SUCCESS;
         }
 
         if (check4 != SWITCH_STATUS_SUCCESS) {
                 ok4 = 2;
         } else if (!*main_ip4) {
                 switch_set_string(main_ip4, guess_ip4);
         } else {
                 if (!(ok4 = !strcmp(main_ip4, guess_ip4))) {
                         struct in_addr in;
 
                         in.s_addr = mask;
                         switch_set_string(old_ip4, main_ip4);
                         switch_set_string(main_ip4, guess_ip4);
                         switch_core_set_variable("local_ip_v4", guess_ip4);
                         switch_core_set_variable("local_mask_v4", inet_ntoa(in));
                 }
         }
 
         if (check6 != SWITCH_STATUS_SUCCESS) {
                 ok6 = 2;
         } else if (!*main_ip6) {
                 switch_set_string(main_ip6, guess_ip6);
         } else {
                 if (!(ok6 = !strcmp(main_ip6, guess_ip6))) {
                         switch_set_string(old_ip6, main_ip6);
                         switch_set_string(main_ip6, guess_ip6);
                         switch_core_set_variable("local_ip_v6", guess_ip6);
                 }
         }
 
         if (!ok4 || !ok6) {
                 if (switch_event_create(&event, SWITCH_EVENT_TRAP) == SWITCH_STATUS_SUCCESS) {
                         switch_event_add_header(event, SWITCH_STACK_BOTTOM, "condition", "network-address-change");
                         if (!ok4) {
                                 switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "network-address-previous-v4", old_ip4);
                                 switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "network-address-change-v4", main_ip4);
                         }
                         if (!ok6) {
                                 switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "network-address-previous-v6", old_ip6);
                                 switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "network-address-change-v6", main_ip6);
                         }
                         switch_event_fire(&event);
                 }
         }
 
         if (ok4 == 2 || ok6 == 2) {
                 if (switch_event_create(&event, SWITCH_EVENT_TRAP) == SWITCH_STATUS_SUCCESS) {
                         switch_event_add_header(event, SWITCH_STACK_BOTTOM, "condition", "network-outage");
 
                         switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "network-status-v4", ok4 == 2 ? "disconnected" : "active");
                         switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "network-address-v4", main_ip4);
 
                         switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "network-status-v6", ok6 == 2 ? "disconnected" : "active");
                         switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "network-address-v6", main_ip6);
 
                         switch_event_fire(&event);
                 }
         }
 
 }

static void handle_SIGHUP ( int sig )

static

Definition at line 2012 of file switch_core.c.

References switch_event_add_header(), switch_event_create, switch_event_fire, SWITCH_EVENT_TRAP, SWITCH_STACK_BOTTOM, and SWITCH_STATUS_SUCCESS.

Referenced by switch_core_session_ctl(), and switch_core_set_signal_handlers().

 {
         if (sig) {
                 switch_event_t *event;
 
                 if (switch_event_create(&event, SWITCH_EVENT_TRAP) == SWITCH_STATUS_SUCCESS) {
                         switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Trapped-Signal", "HUP");
                         switch_event_fire(&event);
                 }
         }
         return;
 }

static void load_mime_types ( void )

static

Definition at line 1260 of file switch_core.c.

References switch_directories::conf_dir, switch_assert, switch_core_mime_add_type(), switch_fp_read_dline(), SWITCH_GLOBAL_dirs, switch_mprintf(), and switch_safe_free.

Referenced by switch_core_init().

 {
         char *cf = "mime.types";
         FILE *fd = NULL;
         char *line_buf = NULL;
         switch_size_t llen = 0;
         char *mime_path = NULL;
 
         mime_path = switch_mprintf("%s/%s", SWITCH_GLOBAL_dirs.conf_dir, cf);
         switch_assert(mime_path);
 
         fd = fopen(mime_path, "rb");
 
         if (fd == NULL) {
                 goto end;
         }
 
         while ((switch_fp_read_dline(fd, &line_buf, &llen))) {
                 char *p;
                 char *type = line_buf;
 
                 if (*line_buf == '#') {
                         continue;
                 }
 
                 if ((p = strchr(line_buf, '\r')) || (p = strchr(line_buf, '\n'))) {
                         *p = '\0';
                 }
 
                 if ((p = strchr(type, '\t')) || (p = strchr(type, ' '))) {
                         *p++ = '\0';
 
                         while (*p == ' ' || *p == '\t') {
                                 p++;
                         }
 
                         switch_core_mime_add_type(type, p);
                 }
 
         }
 
         switch_safe_free(line_buf);
 
         if (fd) {
                 fclose(fd);
                 fd = NULL;
         }
 
   end:
 
         switch_safe_free(mime_path);
 
 }

static void send_heartbeat ( void )

static

Definition at line 67 of file switch_core.c.

References switch_core_time_duration::day, switch_core_time_duration::hr, switch_core_time_duration::min, switch_core_time_duration::mms, switch_core_time_duration::ms, switch_core_time_duration::sec, switch_runtime::sessions_peak, switch_runtime::sessions_peak_fivemin, switch_runtime::sps, switch_runtime::sps_peak, switch_runtime::sps_peak_fivemin, switch_core_idle_cpu(), switch_core_measure_time(), switch_core_session_count(), switch_core_session_id(), switch_core_session_limit(), switch_core_uptime(), switch_event_add_header(), switch_event_create, switch_event_fire, SWITCH_EVENT_HEARTBEAT, SWITCH_SIZE_T_FMT, SWITCH_STACK_BOTTOM, SWITCH_STATUS_SUCCESS, SWITCH_TIME_T_FMT, switch_version_full(), and switch_core_time_duration::yr.

Referenced by SWITCH_STANDARD_SCHED_FUNC().

 {
         switch_event_t *event;
         switch_core_time_duration_t duration;
 
         switch_core_measure_time(switch_core_uptime(), &duration);
 
         if (switch_event_create(&event, SWITCH_EVENT_HEARTBEAT) == SWITCH_STATUS_SUCCESS) {
                 switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Event-Info", "System Ready");
                 switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Up-Time",
                                                                 "%u year%s, "
                                                                 "%u day%s, "
                                                                 "%u hour%s, "
                                                                 "%u minute%s, "
                                                                 "%u second%s, "
                                                                 "%u millisecond%s, "
                                                                 "%u microsecond%s",
                                                                 duration.yr, duration.yr == 1 ? "" : "s",
                                                                 duration.day, duration.day == 1 ? "" : "s",
                                                                 duration.hr, duration.hr == 1 ? "" : "s",
                                                                 duration.min, duration.min == 1 ? "" : "s",
                                                                 duration.sec, duration.sec == 1 ? "" : "s",
                                                                 duration.ms, duration.ms == 1 ? "" : "s", duration.mms, duration.mms == 1 ? "" : "s");
 
                 switch_event_add_header(event, SWITCH_STACK_BOTTOM, "FreeSWITCH-Version", "%s", switch_version_full());
                 switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Uptime-msec", "%"SWITCH_TIME_T_FMT, switch_core_uptime() / 1000);
                 switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Session-Count", "%u", switch_core_session_count());
                 switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Max-Sessions", "%u", switch_core_session_limit(0));
                 switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Session-Per-Sec", "%u", runtime.sps);
                 switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Session-Per-Sec-Max", "%u", runtime.sps_peak);
                 switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Session-Per-Sec-FiveMin", "%u", runtime.sps_peak_fivemin);
                 switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Session-Since-Startup", "%" SWITCH_SIZE_T_FMT, switch_core_session_id() - 1);
                 switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Session-Peak-Max", "%u", runtime.sessions_peak);
                 switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Session-Peak-FiveMin", "%u", runtime.sessions_peak_fivemin);
                 switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Idle-CPU", "%f", switch_core_idle_cpu());
                 switch_event_fire(&event);
         }
 }

void switch_close_extra_files	(	int *	keep,
		int	keep_ttl
	)

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

int switch_core_add_state_handler ( const switch_state_handler_table_t * state_handler )

Definition at line 306 of file switch_core.c.

References switch_runtime::global_mutex, switch_runtime::state_handler_index, switch_runtime::state_handlers, SWITCH_MAX_STATE_HANDLERS, switch_mutex_lock(), and switch_mutex_unlock().

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

const char* switch_core_banner ( void )

Definition at line 2342 of file switch_core.c.

Referenced by switch_core_init_and_modload().

 {
 
         return ("\n"
                         ".=============================================================.\n"
                         "|   _____              ______        _____ _____ ____ _   _   |\n"
                         "|  |  ___| __ ___  ___/ ___\\ \\      / /_ _|_   _/ ___| | | |  |\n"
                         "|  | |_ | '__/ _ \\/ _ \\___ \\\\ \\ /\\ / / | |  | || |   | |_| |  |\n"
                         "|  |  _|| | |  __/  __/___) |\\ V  V /  | |  | || |___|  _  |  |\n"
                         "|  |_|  |_|  \\___|\\___|____/  \\_/\\_/  |___| |_| \\____|_| |_|  |\n"
                         "|                                                             |\n"
                         ".=============================================================."
                         "\n"
 
                         "|   Anthony Minessale II, Michael Jerris, Brian West, Others  |\n"
                         "|   FreeSWITCH (http://www.freeswitch.org)                    |\n"
                         "|   Paypal Donations Appreciated: paypal@freeswitch.org       |\n"
                         "|   Brought to you by ClueCon http://www.cluecon.com/         |\n" 
                         ".=============================================================.\n" 
                         "\n");
 }

uint32_t switch_core_debug_level ( void )

Definition at line 2522 of file switch_core.c.

References switch_runtime::debug_level.

 {
         return runtime.debug_level;
 }

void switch_core_dump_variables ( switch_stream_handle_t * stream )

Definition at line 333 of file switch_core.c.

References switch_runtime::global_mutex, switch_runtime::global_vars, switch_event::headers, switch_event_header::name, switch_event_header::next, switch_mutex_lock(), switch_mutex_unlock(), and switch_event_header::value.

 {
         switch_event_header_t *hi;
 
         switch_mutex_lock(runtime.global_mutex);
         for (hi = runtime.global_vars->headers; hi; hi = hi->next) {
                 stream->write_function(stream, "%s=%s\n", hi->name, hi->value);
         }
         switch_mutex_unlock(runtime.global_mutex);
 }

uint16_t switch_core_get_rtp_port_range_end_port ( void )

Get RTP port range end value.

Parameters

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

Definition at line 3295 of file switch_core.c.

References switch_rtp_set_end_port().

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

uint16_t switch_core_get_rtp_port_range_start_port ( void )

Get RTP port range start value.

Parameters

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

Definition at line 3284 of file switch_core.c.

References switch_rtp_set_start_port().

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

switch_status_t switch_core_get_stacksizes	(	switch_size_t *	cur,
		switch_size_t *	max
	)

Definition at line 3249 of file switch_core.c.

References memset(), SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

 {
 #ifdef HAVE_SETRLIMIT
         struct rlimit rlp;
 
         memset(&rlp, 0, sizeof(rlp));
         getrlimit(RLIMIT_STACK, &rlp);
 
         *cur = rlp.rlim_cur;
         *max = rlp.rlim_max;
 
         return SWITCH_STATUS_SUCCESS;
 
 #else
 
         return SWITCH_STATUS_FALSE;
 
 #endif
 
 }

const switch_state_handler_table_t* switch_core_get_state_handler ( int index )

Definition at line 323 of file switch_core.c.

References switch_runtime::state_handler_index, switch_runtime::state_handlers, and SWITCH_MAX_STATE_HANDLERS.

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

Definition at line 383 of file switch_core.c.

References switch_runtime::global_var_rwlock, switch_runtime::global_vars, switch_event_get_header, switch_thread_rwlock_rdlock(), and switch_thread_rwlock_unlock().

Referenced by check_ip(), and switch_core_get_domain().

 {
         char *val;
         switch_thread_rwlock_rdlock(runtime.global_var_rwlock);
         val = (char *) switch_event_get_header(runtime.global_vars, varname);
         switch_thread_rwlock_unlock(runtime.global_var_rwlock);
         return val;
 }

char* switch_core_get_variable_dup ( const char * varname )

Definition at line 392 of file switch_core.c.

References switch_runtime::global_var_rwlock, switch_runtime::global_vars, switch_event_get_header, switch_thread_rwlock_rdlock(), and switch_thread_rwlock_unlock().

Referenced by switch_core_init_and_modload().

 {
         char *val = NULL, *v;
 
         if (varname) {
                 switch_thread_rwlock_rdlock(runtime.global_var_rwlock);
                 if ((v = (char *) switch_event_get_header(runtime.global_vars, varname))) {
                         val = strdup(v);
                 }
                 switch_thread_rwlock_unlock(runtime.global_var_rwlock);
         }
 
         return val;
 }

char* switch_core_get_variable_pdup	(	const char *	varname,
		switch_memory_pool_t *	pool
	)

Definition at line 407 of file switch_core.c.

References switch_runtime::global_var_rwlock, switch_runtime::global_vars, switch_core_strdup, switch_event_get_header, switch_thread_rwlock_rdlock(), and switch_thread_rwlock_unlock().

 {
         char *val = NULL, *v;
 
         if (varname) {
                 switch_thread_rwlock_rdlock(runtime.global_var_rwlock);
                 if ((v = (char *) switch_event_get_header(runtime.global_vars, varname))) {
                         val = switch_core_strdup(pool, v);
                 }
                 switch_thread_rwlock_unlock(runtime.global_var_rwlock);
         }
 
         return val;
 }

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

Definition at line 1806 of file switch_core.c.

Referenced by switch_core_init_and_modload().

 {
         switch_uuid_t uuid;
         char guess_ip[256];
         int mask = 0;
         struct in_addr in;
 
 
         if (runtime.runlevel > 0) {
                 /* one per customer */
                 return SWITCH_STATUS_SUCCESS;
         }
         
         memset(&runtime, 0, sizeof(runtime));
         gethostname(runtime.hostname, sizeof(runtime.hostname));
 
         runtime.max_db_handles = 50;
         runtime.db_handle_timeout = 5000000;
         
         runtime.runlevel++;
         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.dbname = "core";
         switch_set_flag((&runtime.dummy_cng_frame), SFF_CNG);
         switch_set_flag((&runtime), SCF_AUTO_SCHEMAS);
         switch_set_flag((&runtime), SCF_CLEAR_SQL);
         switch_set_flag((&runtime), SCF_API_EXPANSION);
         switch_set_flag((&runtime), SCF_SESSION_THREAD_POOL);
 #ifdef WIN32
         switch_set_flag((&runtime), SCF_THREADED_SYSTEM_EXEC);
 #endif
         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;
         runtime.min_dtmf_duration = SWITCH_MIN_DTMF_DURATION;
         runtime.odbc_dbtype = DBTYPE_DEFAULT;
         runtime.dbname = NULL;
 #ifndef WIN32
         runtime.cpu_count = sysconf (_SC_NPROCESSORS_ONLN);
 #else
         {
                 SYSTEM_INFO sysinfo;
                 GetSystemInfo( &sysinfo );
                 runtime.cpu_count = sysinfo.dwNumberOfProcessors;
         }
 #endif  
 
         if (!runtime.cpu_count) runtime.cpu_count = 1;
 
         if (sqlite3_initialize() != SQLITE_OK) {
                 *err = "FATAL ERROR! Could not initialize SQLite\n";
                 return SWITCH_STATUS_MEMERR;
         }
 
         /* 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_dir_make_recursive(SWITCH_GLOBAL_dirs.base_dir, SWITCH_DEFAULT_DIR_PERMS, runtime.memory_pool);
         switch_dir_make_recursive(SWITCH_GLOBAL_dirs.mod_dir, SWITCH_DEFAULT_DIR_PERMS, runtime.memory_pool);
         switch_dir_make_recursive(SWITCH_GLOBAL_dirs.conf_dir, SWITCH_DEFAULT_DIR_PERMS, runtime.memory_pool);
         switch_dir_make_recursive(SWITCH_GLOBAL_dirs.log_dir, SWITCH_DEFAULT_DIR_PERMS, runtime.memory_pool);
         switch_dir_make_recursive(SWITCH_GLOBAL_dirs.run_dir, SWITCH_DEFAULT_DIR_PERMS, runtime.memory_pool);
         switch_dir_make_recursive(SWITCH_GLOBAL_dirs.db_dir, SWITCH_DEFAULT_DIR_PERMS, runtime.memory_pool);
         switch_dir_make_recursive(SWITCH_GLOBAL_dirs.script_dir, SWITCH_DEFAULT_DIR_PERMS, runtime.memory_pool);
         switch_dir_make_recursive(SWITCH_GLOBAL_dirs.htdocs_dir, SWITCH_DEFAULT_DIR_PERMS, runtime.memory_pool);
         switch_dir_make_recursive(SWITCH_GLOBAL_dirs.grammar_dir, SWITCH_DEFAULT_DIR_PERMS, runtime.memory_pool);
         switch_dir_make_recursive(SWITCH_GLOBAL_dirs.fonts_dir, SWITCH_DEFAULT_DIR_PERMS, runtime.memory_pool);
         switch_dir_make_recursive(SWITCH_GLOBAL_dirs.images_dir, SWITCH_DEFAULT_DIR_PERMS, runtime.memory_pool);
         switch_dir_make_recursive(SWITCH_GLOBAL_dirs.recordings_dir, SWITCH_DEFAULT_DIR_PERMS, runtime.memory_pool);
         switch_dir_make_recursive(SWITCH_GLOBAL_dirs.sounds_dir, SWITCH_DEFAULT_DIR_PERMS, runtime.memory_pool);
         switch_dir_make_recursive(SWITCH_GLOBAL_dirs.temp_dir, SWITCH_DEFAULT_DIR_PERMS, runtime.memory_pool);
         switch_dir_make_recursive(SWITCH_GLOBAL_dirs.certs_dir, SWITCH_DEFAULT_DIR_PERMS, runtime.memory_pool);
 
         switch_mutex_init(&runtime.uuid_mutex, SWITCH_MUTEX_NESTED, runtime.memory_pool);
 
         switch_mutex_init(&runtime.throttle_mutex, SWITCH_MUTEX_NESTED, runtime.memory_pool);
 
         switch_mutex_init(&runtime.session_hash_mutex, SWITCH_MUTEX_NESTED, runtime.memory_pool);
         switch_mutex_init(&runtime.global_mutex, SWITCH_MUTEX_NESTED, runtime.memory_pool);
 
         switch_thread_rwlock_create(&runtime.global_var_rwlock, runtime.memory_pool);
         switch_core_set_globals();
         switch_core_session_init(runtime.memory_pool);
         switch_event_create_plain(&runtime.global_vars, SWITCH_EVENT_CHANNEL_DATA);
         switch_core_hash_init_case(&runtime.mime_types, SWITCH_FALSE);
         switch_core_hash_init_case(&runtime.mime_type_exts, SWITCH_FALSE);
         switch_core_hash_init_case(&runtime.ptimes, SWITCH_FALSE);
         load_mime_types();
         runtime.flags |= flags;
         runtime.sps_total = 30;
 
         *err = NULL;
 
         if (console) {
                 runtime.console = stdout;
         }
 
         SSL_library_init();
         switch_ssl_init_ssl_locks();
         switch_curl_init();
 
         switch_core_set_variable("hostname", runtime.hostname);
         switch_find_local_ip(guess_ip, sizeof(guess_ip), &mask, AF_INET);
         switch_core_set_variable("local_ip_v4", guess_ip);
         in.s_addr = mask;
         switch_core_set_variable("local_mask_v4", inet_ntoa(in));
 
 
         switch_find_local_ip(guess_ip, sizeof(guess_ip), NULL, AF_INET6);
         switch_core_set_variable("local_ip_v6", guess_ip);
         switch_core_set_variable("base_dir", SWITCH_GLOBAL_dirs.base_dir);
         switch_core_set_variable("recordings_dir", SWITCH_GLOBAL_dirs.recordings_dir);
         switch_core_set_variable("sound_prefix", SWITCH_GLOBAL_dirs.sounds_dir);
         switch_core_set_variable("sounds_dir", SWITCH_GLOBAL_dirs.sounds_dir);
         switch_core_set_variable("conf_dir", SWITCH_GLOBAL_dirs.conf_dir);
         switch_core_set_variable("log_dir", SWITCH_GLOBAL_dirs.log_dir);
         switch_core_set_variable("run_dir", SWITCH_GLOBAL_dirs.run_dir);
         switch_core_set_variable("db_dir", SWITCH_GLOBAL_dirs.db_dir);
         switch_core_set_variable("mod_dir", SWITCH_GLOBAL_dirs.mod_dir);
         switch_core_set_variable("htdocs_dir", SWITCH_GLOBAL_dirs.htdocs_dir);
         switch_core_set_variable("script_dir", SWITCH_GLOBAL_dirs.script_dir);
         switch_core_set_variable("temp_dir", SWITCH_GLOBAL_dirs.temp_dir);
         switch_core_set_variable("grammar_dir", SWITCH_GLOBAL_dirs.grammar_dir);
         switch_core_set_variable("fonts_dir", SWITCH_GLOBAL_dirs.fonts_dir);
         switch_core_set_variable("images_dir", SWITCH_GLOBAL_dirs.images_dir);
         switch_core_set_variable("certs_dir", SWITCH_GLOBAL_dirs.certs_dir);
         switch_core_set_variable("storage_dir", SWITCH_GLOBAL_dirs.storage_dir);
         switch_core_set_variable("cache_dir", SWITCH_GLOBAL_dirs.cache_dir);
         switch_core_set_variable("data_dir", SWITCH_GLOBAL_dirs.data_dir);
         switch_core_set_variable("localstate_dir", SWITCH_GLOBAL_dirs.localstate_dir);
 #ifdef ENABLE_ZRTP
         switch_core_set_serial();
 #endif
         switch_console_init(runtime.memory_pool);
         switch_event_init(runtime.memory_pool);
         switch_channel_global_init(runtime.memory_pool);
 
         if (switch_xml_init(runtime.memory_pool, err) != SWITCH_STATUS_SUCCESS) {
                 apr_terminate();
                 return SWITCH_STATUS_MEMERR;
         }
 
         if (switch_test_flag((&runtime), SCF_USE_AUTO_NAT)) {
                 switch_nat_init(runtime.memory_pool, switch_test_flag((&runtime), SCF_USE_NAT_MAPPING));
         }
 
         switch_log_init(runtime.memory_pool, runtime.colorize_console);
                         
         runtime.tipping_point = 0;
         runtime.timer_affinity = -1;
         runtime.microseconds_per_tick = 20000;
 
         if (flags & SCF_MINIMAL) return SWITCH_STATUS_SUCCESS;
 
         switch_load_core_config("switch.conf");
 
         switch_core_state_machine_init(runtime.memory_pool);
 
         if (switch_core_sqldb_start(runtime.memory_pool, switch_test_flag((&runtime), SCF_USE_SQL) ? SWITCH_TRUE : SWITCH_FALSE) != SWITCH_STATUS_SUCCESS) {
                 *err = "Error activating database";
                 return SWITCH_STATUS_FALSE;
         }
         switch_core_media_init();
         switch_scheduler_task_thread_start();
 
         switch_nat_late_init();
 
         switch_rtp_init(runtime.memory_pool);
 
         runtime.running = 1;
         runtime.initiated = switch_mono_micro_time_now();
         
         switch_scheduler_add_task(switch_epoch_time_now(NULL), heartbeat_callback, "heartbeat", "core", 0, NULL, SSHF_NONE | SSHF_NO_DEL);
 
         switch_scheduler_add_task(switch_epoch_time_now(NULL), check_ip_callback, "check_ip", "core", 0, NULL, SSHF_NONE | SSHF_NO_DEL | SSHF_OWN_THREAD);
 
         switch_uuid_get(&uuid);
         switch_uuid_format(runtime.uuid_str, &uuid);
         switch_core_set_variable("core_uuid", runtime.uuid_str);
 
 
         return SWITCH_STATUS_SUCCESS;
 }

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

Definition at line 2365 of file switch_core.c.

References cc, cc_s, switch_stream_handle::data, switch_runtime::events_use_dispatch, switch_runtime::runlevel, SCF_NO_NEW_SESSIONS, SCF_USE_SQL, SWITCH_CHANNEL_LOG, switch_clear_flag, switch_console_execute(), switch_core_banner(), switch_core_get_variable_dup(), switch_core_init(), switch_core_screen_size(), switch_core_session_limit(), switch_core_sessions_per_second(), switch_core_set_signal_handlers(), switch_event_add_header(), switch_event_create, switch_event_fire, SWITCH_EVENT_STARTUP, SWITCH_FALSE, switch_load_core_config(), switch_load_network_lists(), switch_loadable_module_init(), SWITCH_LOG_CONSOLE, SWITCH_LOG_INFO, switch_log_printf(), SWITCH_SEQ_BBLUE, SWITCH_SEQ_DEFAULT_COLOR, SWITCH_SEQ_FYELLOW, SWITCH_STACK_BOTTOM, SWITCH_STANDARD_STREAM, SWITCH_STATUS_GENERR, SWITCH_STATUS_SUCCESS, switch_test_flag, SWITCH_TRUE, switch_version_full(), and switch_version_revision_human().

 {
         switch_event_t *event;
         char *cmd;
         int x = 0;
         const char *use = NULL;
 #include "cc.h"
 
 
         if (switch_core_init(flags, console, err) != SWITCH_STATUS_SUCCESS) {
                 return SWITCH_STATUS_GENERR;
         }
         
         if (runtime.runlevel > 1) {
                 /* one per customer */
                 return SWITCH_STATUS_SUCCESS;
         }
 
         runtime.runlevel++;
         runtime.events_use_dispatch = 1;
 
         switch_core_set_signal_handlers();
         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_TRUE) != SWITCH_STATUS_SUCCESS) {
                 *err = "Cannot load modules";
                 switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "Error: %s\n", *err);
                 return SWITCH_STATUS_GENERR;
         }
 
         switch_load_network_lists(SWITCH_FALSE);
 
         switch_load_core_config("post_load_switch.conf");
 
         switch_core_set_signal_handlers();
 
         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_core_screen_size(&x, NULL);
 
         use = (x > 100) ? cc : cc_s;
 
 #ifdef WIN32
         switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "%s%s\n\n", switch_core_banner(), use);
 #else
         switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "%s%s%s%s%s%s\n\n", 
                                           SWITCH_SEQ_DEFAULT_COLOR,
                                           SWITCH_SEQ_FYELLOW, SWITCH_SEQ_BBLUE,
                                           switch_core_banner(), 
                                           use, SWITCH_SEQ_DEFAULT_COLOR);
         
 #endif
 
 
         switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO,
                                           "\nFreeSWITCH Version %s (%s)\n\nFreeSWITCH Started\nMax Sessions [%u]\nSession Rate [%d]\nSQL [%s]\n",
                                           switch_version_full(), switch_version_revision_human(),
                                           switch_core_session_limit(0),
                                           switch_core_sessions_per_second(0), switch_test_flag((&runtime), SCF_USE_SQL) ? "Enabled" : "Disabled");
 
 
         if (x < 160) {
                 switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "\n[This app Best viewed at 160x60 or more..]\n");
         }
 
         switch_clear_flag((&runtime), SCF_NO_NEW_SESSIONS);
 
         if ((cmd = switch_core_get_variable_dup("api_on_startup"))) {
                 switch_stream_handle_t stream = { 0 };
                 SWITCH_STANDARD_STREAM(stream);
                 switch_console_execute(cmd, 0, &stream);
                 switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "Startup command [%s] executed. Output:\n%s\n", cmd, (char *)stream.data);
                 free(stream.data);
                 free(cmd);
         }
 
         return SWITCH_STATUS_SUCCESS;
 
 }

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

Definition at line 588 of file switch_core.c.

References switch_core_thread_session::objs, pool, switch_core_thread_session::pool, SWITCH_CHANNEL_LOG, switch_core_alloc, switch_core_new_memory_pool, SWITCH_LOG_CRIT, switch_log_printf(), SWITCH_PRI_REALTIME, SWITCH_STATUS_SUCCESS, switch_thread_create(), SWITCH_THREAD_STACKSIZE, switch_threadattr_create(), switch_threadattr_priority_set(), switch_threadattr_stacksize_set(), and thread.

 {
         switch_thread_t *thread = NULL;
         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 NULL;
         }
 
         switch_threadattr_create(&thd_attr, pool);
 
         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;
                 ts->objs[1] = thread;
                 switch_threadattr_stacksize_set(thd_attr, SWITCH_THREAD_STACKSIZE);
                 switch_threadattr_priority_set(thd_attr, SWITCH_PRI_REALTIME);
                 switch_thread_create(&thread, thd_attr, func, ts, pool);
         }
 
         return thread;
 }

void switch_core_remove_state_handler ( const switch_state_handler_table_t * state_handler )

Definition at line 281 of file switch_core.c.

References cur, switch_runtime::global_mutex, switch_runtime::state_handler_index, switch_runtime::state_handlers, SWITCH_MAX_STATE_HANDLERS, switch_mutex_lock(), and switch_mutex_unlock().

 {
         int index, tmp_index = 0;
         const switch_state_handler_table_t *tmp[SWITCH_MAX_STATE_HANDLERS + 1] = { 0 };
 
         switch_mutex_lock(runtime.global_mutex);
 
         for (index = 0; index < runtime.state_handler_index; index++) {
                 const switch_state_handler_table_t *cur = runtime.state_handlers[index];
                 runtime.state_handlers[index] = NULL;
                 if (cur == state_handler) {
                         continue;
                 }
                 tmp[tmp_index++] = cur;
         }
 
         runtime.state_handler_index = 0;
 
         for (index = 0; index < tmp_index; index++) {
                 runtime.state_handlers[runtime.state_handler_index++] = tmp[index];
         }
         switch_mutex_unlock(runtime.global_mutex);
 }

void switch_core_service_session_av	(	switch_core_session_t *	session,
		switch_bool_t	audio,
		switch_bool_t	video
	)

Definition at line 560 of file switch_core.c.

References CF_SERVICE_AUDIO, CF_SERVICE_VIDEO, switch_assert, switch_channel_set_flag, switch_core_service_thread(), switch_core_session_get_channel(), and switch_core_session_launch_thread().

 {
         switch_channel_t *channel;
         switch_assert(session);
 
         channel = switch_core_session_get_channel(session);
         switch_assert(channel);
 
         if (audio) switch_channel_set_flag(channel, CF_SERVICE_AUDIO);
         if (video) switch_channel_set_flag(channel, CF_SERVICE_VIDEO);
 
         switch_core_session_launch_thread(session, (void *(*)(switch_thread_t *,void *))switch_core_service_thread, session);
 }

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

static

Definition at line 488 of file switch_core.c.

References CF_SERVICE, CF_SERVICE_AUDIO, CF_SERVICE_VIDEO, CF_VIDEO, switch_core_session::frame_read_mutex, switch_channel_clear_flag(), switch_channel_set_flag, switch_channel_test_flag(), switch_core_session_get_channel(), switch_core_session_read_frame(), switch_core_session_read_lock(), switch_core_session_read_video_frame(), switch_core_session_rwunlock(), SWITCH_IO_FLAG_NONE, switch_mutex_lock(), switch_mutex_unlock(), SWITCH_STATUS_BREAK, SWITCH_STATUS_SUCCESS, and SWITCH_STATUS_TIMEOUT.

Referenced by switch_core_service_session_av().

 {
         switch_core_session_t *session = obj;
         switch_channel_t *channel;
         switch_frame_t *read_frame;
 
 //  switch_assert(thread != NULL);
 //  switch_assert(session != NULL);
 
         if (switch_core_session_read_lock(session) != SWITCH_STATUS_SUCCESS) {
                 return NULL;
         }
 
         switch_mutex_lock(session->frame_read_mutex);
 
         channel = switch_core_session_get_channel(session);
 
         switch_channel_set_flag(channel, CF_SERVICE);
         while (switch_channel_test_flag(channel, CF_SERVICE)) {
 
                 if (switch_channel_test_flag(channel, CF_SERVICE_AUDIO)) {
                         switch (switch_core_session_read_frame(session, &read_frame, SWITCH_IO_FLAG_NONE, 0)) {
                         case SWITCH_STATUS_SUCCESS:
                         case SWITCH_STATUS_TIMEOUT:
                         case SWITCH_STATUS_BREAK:
                                 break;
                         default:
                                 switch_channel_clear_flag(channel, CF_SERVICE);
                                 break;
                         }
                 }
 
                 if (switch_channel_test_flag(channel, CF_SERVICE_VIDEO) && switch_channel_test_flag(channel, CF_VIDEO)) {
                         switch (switch_core_session_read_video_frame(session, &read_frame, SWITCH_IO_FLAG_NONE, 0)) {
                         case SWITCH_STATUS_SUCCESS:
                         case SWITCH_STATUS_TIMEOUT:
                         case SWITCH_STATUS_BREAK:
                                 break;
                         default:
                                 switch_channel_clear_flag(channel, CF_SERVICE);
                                 break;
                         }
                 }
         }
 
         switch_mutex_unlock(session->frame_read_mutex);
 
         switch_channel_clear_flag(channel, CF_SERVICE_AUDIO);
         switch_channel_clear_flag(channel, CF_SERVICE_VIDEO);
 
         switch_core_session_rwunlock(session);
 
         return NULL;
 }

void switch_core_set_signal_handlers ( void )

Definition at line 2494 of file switch_core.c.

References handle_SIGHUP().

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

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

switch_bool_t switch_core_set_var_conditional	(	const char *	varname,
		const char *	value,
		const char *	val2
	)

Definition at line 451 of file switch_core.c.

References switch_runtime::global_var_rwlock, switch_runtime::global_vars, switch_event_add_header_string(), switch_event_del_header, switch_event_get_header, SWITCH_FALSE, SWITCH_STACK_BOTTOM, SWITCH_STACK_NODUP, switch_string_var_check(), switch_thread_rwlock_unlock(), switch_thread_rwlock_wrlock(), SWITCH_TRUE, and zstr.

 {
         char *val;
 
         if (varname) {
                 switch_thread_rwlock_wrlock(runtime.global_var_rwlock);
                 val = (char *) switch_event_get_header(runtime.global_vars, varname);
 
                 if (val) {
                         if (!val2 || strcmp(val, val2) != 0) {
                                 switch_thread_rwlock_unlock(runtime.global_var_rwlock);
                                 return SWITCH_FALSE;
                         }
                         switch_event_del_header(runtime.global_vars, varname);
                 } else if (!zstr(val2)) {
                         switch_thread_rwlock_unlock(runtime.global_var_rwlock);
                         return SWITCH_FALSE;
                 }
 
                 if (value) {
                         char *v = strdup(value);
                         switch_string_var_check(v, SWITCH_TRUE);
                         switch_event_add_header_string(runtime.global_vars, SWITCH_STACK_BOTTOM | SWITCH_STACK_NODUP, varname, v);
                 } else {
                         switch_event_del_header(runtime.global_vars, varname);
                 }
                 switch_thread_rwlock_unlock(runtime.global_var_rwlock);
         }
         return SWITCH_TRUE;
 }

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

Definition at line 430 of file switch_core.c.

References switch_runtime::global_var_rwlock, switch_runtime::global_vars, switch_event_add_header_string(), switch_event_del_header, switch_event_get_header, SWITCH_STACK_BOTTOM, SWITCH_STACK_NODUP, switch_string_var_check(), switch_thread_rwlock_unlock(), switch_thread_rwlock_wrlock(), and SWITCH_TRUE.

Referenced by check_ip(), switch_core_init(), and switch_load_core_config().

 {
         char *val;
 
         if (varname) {
                 switch_thread_rwlock_wrlock(runtime.global_var_rwlock);
                 val = (char *) switch_event_get_header(runtime.global_vars, varname);
                 if (val) {
                         switch_event_del_header(runtime.global_vars, varname);
                 }
                 if (value) {
                         char *v = strdup(value);
                         switch_string_var_check(v, SWITCH_TRUE);
                         switch_event_add_header_string(runtime.global_vars, SWITCH_STACK_BOTTOM | SWITCH_STACK_NODUP, varname, v);
                 } else {
                         switch_event_del_header(runtime.global_vars, varname);
                 }
                 switch_thread_rwlock_unlock(runtime.global_var_rwlock);
         }
 }

void switch_core_thread_session_end ( switch_core_session_t * session )

Definition at line 544 of file switch_core.c.

References CF_SERVICE, CF_SERVICE_AUDIO, CF_SERVICE_VIDEO, switch_assert, switch_channel_clear_flag(), switch_core_session_get_channel(), switch_core_session_kill_channel, and SWITCH_SIG_BREAK.

 {
         switch_channel_t *channel;
         switch_assert(session);
 
         channel = switch_core_session_get_channel(session);
         switch_assert(channel);
 
         switch_channel_clear_flag(channel, CF_SERVICE);
         switch_channel_clear_flag(channel, CF_SERVICE_AUDIO);
         switch_channel_clear_flag(channel, CF_SERVICE_VIDEO);
 
         switch_core_session_kill_channel(session, SWITCH_SIG_BREAK);
         
 }

switch_status_t switch_core_thread_set_cpu_affinity ( int cpu )

Definition at line 1723 of file switch_core.c.

References SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

Referenced by switch_core_autobind_cpu(), and SWITCH_MODULE_RUNTIME_FUNCTION().

 {
         switch_status_t status = SWITCH_STATUS_FALSE;
 
         if (cpu > -1) {
 
 #ifdef HAVE_CPU_SET_MACROS
                 cpu_set_t set;
 
                 CPU_ZERO(&set);
                 CPU_SET(cpu, &set);
 
                 if (!sched_setaffinity(0, sizeof(set), &set)) {
                         status = SWITCH_STATUS_SUCCESS;
                 }
                 
 #else
 #if WIN32
                 if (SetThreadAffinityMask(GetCurrentThread(), (DWORD_PTR) cpu)) {
                         status = SWITCH_STATUS_SUCCESS;
                 }
 #endif
 #endif
         }
 
         return status;
 }

static void switch_core_unset_variables ( void )

static

Definition at line 422 of file switch_core.c.

References switch_runtime::global_var_rwlock, switch_runtime::global_vars, SWITCH_EVENT_CHANNEL_DATA, switch_event_create_plain(), switch_event_destroy(), switch_thread_rwlock_unlock(), and switch_thread_rwlock_wrlock().

Referenced by switch_core_destroy().

 {
         switch_thread_rwlock_wrlock(runtime.global_var_rwlock);
         switch_event_destroy(&runtime.global_vars);
         switch_event_create_plain(&runtime.global_vars, SWITCH_EVENT_CHANNEL_DATA);
         switch_thread_rwlock_unlock(runtime.global_var_rwlock);
 }

uint32_t switch_default_ptime	(	const char *	name,
		uint32_t	number
	)

Definition at line 2026 of file switch_core.c.

References switch_runtime::ptimes, and switch_core_hash_find().

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

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

uint32_t switch_default_rate	(	const char *	name,
		uint32_t	number
	)

Definition at line 2037 of file switch_core.c.

Referenced by switch_loadable_module_get_codecs_sorted().

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

pid_t switch_fork ( void )

Definition at line 3134 of file switch_core.c.

References set_low_priority().

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

 {
         int i = fork();
 
         if (!i) {
                 set_low_priority();
         }
 
         return i;
 }

static void switch_load_core_config ( const char * file )

static

Definition at line 2053 of file switch_core.c.

References switch_runtime::colorize_console, 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, switch_runtime::cpu_count, switch_runtime::cpu_idle_smoothing_depth, switch_runtime::db_handle_timeout, switch_runtime::dbname, DBTYPE_DEFAULT, DBTYPE_MSSQL, switch_runtime::events_use_dispatch, switch_runtime::mailer_app, switch_runtime::mailer_app_args, switch_runtime::max_db_handles, switch_runtime::memory_pool, memset(), switch_runtime::microseconds_per_tick, switch_runtime::multiple_registrations, switch_xml::next, switch_runtime::odbc_dbtype, switch_runtime::odbc_dsn, switch_runtime::port_alloc_flags, switch_runtime::ptimes, SCF_API_EXPANSION, SCF_AUTO_SCHEMAS, SCF_CLEAR_SQL, SCF_CORE_NON_SQLITE_DB_REQ, SCF_DIALPLAN_TIMESTAMPS, SCF_EARLY_HANGUP, SCF_SESSION_THREAD_POOL, SCF_THREADED_SYSTEM_EXEC, SCF_VERBOSE_EVENTS, SCSC_DEBUG_LEVEL, SCSC_LOGLEVEL, SPF_ROBUST_UDP, switch_atoul(), SWITCH_CHANNEL_LOG, switch_clear_flag, switch_core_alloc, switch_core_default_dtmf_duration(), switch_core_hash_insert, switch_core_max_dtmf_duration(), switch_core_min_dtmf_duration(), switch_core_min_idle_cpu(), switch_core_session_ctl(), switch_core_session_limit(), switch_core_sessions_per_second(), switch_core_set_variable(), switch_core_strdup, switch_event_launch_dispatch_threads(), SWITCH_LOG_CRIT, SWITCH_LOG_ERROR, SWITCH_LOG_INVALID, SWITCH_LOG_NOTICE, switch_log_printf(), switch_log_str2level(), SWITCH_LOG_WARNING, switch_odbc_available(), switch_pgsql_available(), switch_rtp_set_end_port(), switch_rtp_set_start_port(), switch_set_flag, switch_time_set_cond_yield(), switch_time_set_matrix(), switch_time_set_monotonic(), switch_time_set_nanosleep(), switch_time_set_timerfd(), switch_time_set_use_system_time(), SWITCH_TRUE, switch_true(), switch_xml_attr_soft(), switch_xml_child(), switch_xml_free(), switch_xml_open_cfg(), switch_runtime::switchname, switch_runtime::timer_affinity, switch_runtime::tipping_point, and zstr.

Referenced by switch_core_init(), and switch_core_init_and_modload().

 {
         switch_xml_t xml = NULL, cfg = NULL;
 
         switch_core_hash_insert(runtime.ptimes, "ilbc", &d_30);
         switch_core_hash_insert(runtime.ptimes, "isac", &d_30);
         switch_core_hash_insert(runtime.ptimes, "G723", &d_30);
 
 
         if ((xml = switch_xml_open_cfg(file, &cfg, NULL))) {
                 switch_xml_t settings, param;
 
                 if ((settings = switch_xml_child(cfg, "default-ptimes"))) {
                         for (param = switch_xml_child(settings, "codec"); param; param = param->next) {
                                 const char *var = switch_xml_attr_soft(param, "name");
                                 const char *val = switch_xml_attr_soft(param, "ptime");
                                 
                                 if (!zstr(var) && !zstr(val)) {
                                         uint32_t *p;
                                         uint32_t v = switch_atoul(val);
 
                                         if (!strcasecmp(var, "G723") || !strcasecmp(var, "iLBC")) {
                                                 switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Error adding %s, defaults cannot be changed\n", var);
                                                 continue;
                                         }
                                         
                                         if (v == 0) {
                                                 switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Error adding %s, invalid ptime\n", var);
                                                 continue;
                                         }
 
                                         p = switch_core_alloc(runtime.memory_pool, sizeof(*p));
                                         *p = v;
                                         switch_core_hash_insert(runtime.ptimes, var, p);
                                 }
 
                         }
                 }
 
                 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, "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") && switch_true(val)) {
                                         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, "debug-level")) {
                                         int tmp = atoi(val);
                                         if (tmp > -1 && tmp < 11) {
                                                 switch_core_session_ctl(SCSC_DEBUG_LEVEL, &tmp);
                                         }
                                 } else if (!strcasecmp(var, "max-db-handles")) {
                                         long tmp = atol(val);
 
                                         if (tmp > 4 && tmp < 5001) {
                                                 runtime.max_db_handles = (uint32_t) tmp;
                                         } else {
                                                 switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "max-db-handles must be between 5 and 5000\n");
                                         }
                                 } else if (!strcasecmp(var, "db-handle-timeout")) {
                                         long tmp = atol(val);
                                         
                                         if (tmp > 0 && tmp < 5001) {
                                                 runtime.db_handle_timeout = (uint32_t) tmp * 1000000;
                                         } else {
                                                 switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "db-handle-timeout must be between 1 and 5000\n");
                                         }
                                         
                                 } else if (!strcasecmp(var, "multiple-registrations")) {
                                         runtime.multiple_registrations = switch_true(val);
                                 } else if (!strcasecmp(var, "auto-create-schemas")) {
                                         if (switch_true(val)) {
                                                 switch_set_flag((&runtime), SCF_AUTO_SCHEMAS);
                                         } else {
                                                 switch_clear_flag((&runtime), SCF_AUTO_SCHEMAS);
                                         }
                                 } else if (!strcasecmp(var, "session-thread-pool")) {
                                         if (switch_true(val)) {
                                                 switch_set_flag((&runtime), SCF_SESSION_THREAD_POOL);
                                         } else {
                                                 switch_clear_flag((&runtime), SCF_SESSION_THREAD_POOL);
                                         }
                                 } else if (!strcasecmp(var, "auto-clear-sql")) {
                                         if (switch_true(val)) {
                                                 switch_set_flag((&runtime), SCF_CLEAR_SQL);
                                         } else {
                                                 switch_clear_flag((&runtime), SCF_CLEAR_SQL);
                                         }
                                 } else if (!strcasecmp(var, "api-expansion")) {
                                         if (switch_true(val)) {
                                                 switch_set_flag((&runtime), SCF_API_EXPANSION);
                                         } else {
                                                 switch_clear_flag((&runtime), SCF_API_EXPANSION);
                                         }
                                 } else if (!strcasecmp(var, "enable-early-hangup") && switch_true(val)) {
                                         switch_set_flag((&runtime), SCF_EARLY_HANGUP);
                                 } else if (!strcasecmp(var, "colorize-console") && switch_true(val)) {
                                         runtime.colorize_console = SWITCH_TRUE;
                                 } else if (!strcasecmp(var, "core-db-pre-trans-execute") && !zstr(val)) {
                                         runtime.core_db_pre_trans_execute = switch_core_strdup(runtime.memory_pool, val);
                                 } else if (!strcasecmp(var, "core-db-post-trans-execute") && !zstr(val)) {
                                         runtime.core_db_post_trans_execute = switch_core_strdup(runtime.memory_pool, val);
                                 } else if (!strcasecmp(var, "core-db-inner-pre-trans-execute") && !zstr(val)) {
                                         runtime.core_db_inner_pre_trans_execute = switch_core_strdup(runtime.memory_pool, val);
                                 } else if (!strcasecmp(var, "core-db-inner-post-trans-execute") && !zstr(val)) {
                                         runtime.core_db_inner_post_trans_execute = switch_core_strdup(runtime.memory_pool, val);
                                 } else if (!strcasecmp(var, "dialplan-timestamps")) {
                                         if (switch_true(val)) {
                                                 switch_set_flag((&runtime), SCF_DIALPLAN_TIMESTAMPS);
                                         } else {
                                                 switch_clear_flag((&runtime), SCF_DIALPLAN_TIMESTAMPS);
                                         }
                                 } else if (!strcasecmp(var, "mailer-app") && !zstr(val)) {
                                         runtime.mailer_app = switch_core_strdup(runtime.memory_pool, val);
                                 } else if (!strcasecmp(var, "mailer-app-args") && val) {
                                         runtime.mailer_app_args = switch_core_strdup(runtime.memory_pool, val);
                                 } else if (!strcasecmp(var, "sessions-per-second") && !zstr(val)) {
                                         switch_core_sessions_per_second(atoi(val));
                                 } else if (!strcasecmp(var, "max-dtmf-duration") && !zstr(val)) {
                                         int tmp = atoi(val);
                                         if (tmp > 0) {
                                                 switch_core_max_dtmf_duration((uint32_t) tmp);
                                         }
                                 } else if (!strcasecmp(var, "min-dtmf-duration") && !zstr(val)) {
                                         int tmp = atoi(val);
                                         if (tmp > 0) {
                                                 switch_core_min_dtmf_duration((uint32_t) tmp);
                                         }
                                 } else if (!strcasecmp(var, "default-dtmf-duration") && !zstr(val)) {
                                         int tmp = atoi(val);
                                         if (tmp > 0) {
                                                 switch_core_default_dtmf_duration((uint32_t) tmp);
                                         }
                                 } else if (!strcasecmp(var, "enable-use-system-time")) {
                                         switch_time_set_use_system_time(switch_true(val));
                                 } else if (!strcasecmp(var, "enable-monotonic-timing")) {
                                         switch_time_set_monotonic(switch_true(val));
                                 } else if (!strcasecmp(var, "enable-softtimer-timerfd")) {
                                         int ival = 0;
                                         if (val) {
                                                 if (switch_true(val)) {
                                                         ival = 2;
                                                 } else {
                                                         if (strcasecmp(val, "broadcast")) {
                                                                 ival = 1;
                                                         } else if (strcasecmp(val, "fd-per-timer")) {
                                                                 ival = 2;
                                                         }
                                                 }
                                         }
                                         switch_time_set_timerfd(ival);
                                 } else if (!strcasecmp(var, "enable-clock-nanosleep")) {
                                         switch_time_set_nanosleep(switch_true(val));
                                 } else if (!strcasecmp(var, "enable-cond-yield")) {
                                         switch_time_set_cond_yield(switch_true(val));
                                 } else if (!strcasecmp(var, "enable-timer-matrix")) {
                                         switch_time_set_matrix(switch_true(val));
                                 } else if (!strcasecmp(var, "max-sessions") && !zstr(val)) {
                                         switch_core_session_limit(atoi(val));
                                 } else if (!strcasecmp(var, "verbose-channel-events") && !zstr(val)) {
                                         int v = switch_true(val);
                                         if (v) {
                                                 switch_set_flag((&runtime), SCF_VERBOSE_EVENTS);
                                         } else {
                                                 switch_clear_flag((&runtime), SCF_VERBOSE_EVENTS);
                                         }
                                 } else if (!strcasecmp(var, "threaded-system-exec") && !zstr(val)) {
 #ifdef WIN32
                                         switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "threaded-system-exec is not implemented on this platform\n");
 #else
                                         int v = switch_true(val);
                                         if (v) {
                                                 switch_set_flag((&runtime), SCF_THREADED_SYSTEM_EXEC);
                                         } else {
                                                 switch_clear_flag((&runtime), SCF_THREADED_SYSTEM_EXEC);
                                         }
 #endif
                                 } else if (!strcasecmp(var, "min-idle-cpu") && !zstr(val)) {
                                         switch_core_min_idle_cpu(atof(val));
                                 } else if (!strcasecmp(var, "tipping-point") && !zstr(val)) {
                                         runtime.tipping_point = atoi(val);
                                 } else if (!strcasecmp(var, "cpu-idle-smoothing-depth") && !zstr(val)) {
                                         runtime.cpu_idle_smoothing_depth = atoi(val);
                                 } else if (!strcasecmp(var, "events-use-dispatch") && !zstr(val)) {
                                         runtime.events_use_dispatch = switch_true(val);
                                 } else if (!strcasecmp(var, "initial-event-threads") && !zstr(val)) {
                                         int tmp;
 
                                         if (!runtime.events_use_dispatch) {
                                                 runtime.events_use_dispatch = 1;
                                                 switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING,
                                                                                   "Implicitly setting events-use-dispatch based on usage of this initial-event-threads parameter.\n");
                                         }
 
                                         tmp = atoi(val);
 
                                         if (tmp > runtime.cpu_count / 2) {
                                                 tmp = runtime.cpu_count / 2;
                                                 switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "This value cannot be higher than %d so setting it to that value\n", 
                                                                                   runtime.cpu_count / 2);
                                         }
 
                                         if (tmp < 1) {
                                                 tmp = 1;
                                                 switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "This value cannot be lower than 1 so setting it to that level\n");
                                         }
 
                                         switch_event_launch_dispatch_threads(tmp);
 
                                 } else if (!strcasecmp(var, "1ms-timer") && switch_true(val)) {
                                         runtime.microseconds_per_tick = 1000;
                                 } else if (!strcasecmp(var, "timer-affinity") && !zstr(val)) {
                                         if (!strcasecmp(val, "disabled")) {
                                                 runtime.timer_affinity = -1;
                                         } else {
                                                 runtime.timer_affinity = atoi(val);
                                         }
                                 } else if (!strcasecmp(var, "rtp-start-port") && !zstr(val)) {
                                         switch_rtp_set_start_port((switch_port_t) atoi(val));
                                 } else if (!strcasecmp(var, "rtp-end-port") && !zstr(val)) {
                                         switch_rtp_set_end_port((switch_port_t) atoi(val));
                                 } else if (!strcasecmp(var, "rtp-port-usage-robustness") && switch_true(val)) {
                                         runtime.port_alloc_flags |= SPF_ROBUST_UDP;
                                 } else if (!strcasecmp(var, "core-db-name") && !zstr(val)) {
                                         runtime.dbname = switch_core_strdup(runtime.memory_pool, val);
                                 } else if (!strcasecmp(var, "core-db-dsn") && !zstr(val)) {
                                         if (switch_odbc_available() || switch_pgsql_available()) {
                                                 runtime.odbc_dsn = switch_core_strdup(runtime.memory_pool, val);
                                         } else {
                                                 switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "ODBC AND PGSQL ARE NOT AVAILABLE!\n");
                                         }
                                 } else if (!strcasecmp(var, "core-non-sqlite-db-required") && !zstr(val)) {
                                         switch_set_flag((&runtime), SCF_CORE_NON_SQLITE_DB_REQ);
                                 } else if (!strcasecmp(var, "core-dbtype") && !zstr(val)) {
                                         if (!strcasecmp(val, "MSSQL")) {
                                                 runtime.odbc_dbtype = DBTYPE_MSSQL;
                                         } else {
                                                 runtime.odbc_dbtype = DBTYPE_DEFAULT;
                                         }
 #ifdef ENABLE_ZRTP
                                 } else if (!strcasecmp(var, "rtp-enable-zrtp")) {
                                         switch_core_set_variable("zrtp_enabled", val);
 #endif
                                 } else if (!strcasecmp(var, "switchname") && !zstr(val)) {
                                         runtime.switchname = switch_core_strdup(runtime.memory_pool, val);
                                         switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "Set switchname to %s\n", runtime.switchname);
                                 } else if (!strcasecmp(var, "rtp-retain-crypto-keys")) {
                                         if (switch_true(val)) {
                                                 switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING,
                                                                                   "rtp-retain-crypto-keys enabled. Could be used to decrypt secure media.\n");
                                         }
                                         switch_core_set_variable("rtp_retain_crypto_keys", 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");
                                 if (var && val) {
                                         switch_core_set_variable(var, val);
                                 }
                         }
                 }
 
                 switch_xml_free(xml);
         }
 
 
 }

int switch_max_file_desc ( void )

Definition at line 3080 of file switch_core.c.

Referenced by switch_close_extra_files().

 {
         int max = 0;
 
 #ifndef WIN32
 #if defined(HAVE_GETDTABLESIZE)
         max = getdtablesize();
 #else
         max = sysconf(_SC_OPEN_MAX);
 #endif
 #endif
 
         return max;
 
 }

SWITCH_STANDARD_SCHED_FUNC ( heartbeat_callback )

Definition at line 202 of file switch_core.c.

References send_heartbeat(), and switch_epoch_time_now().

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

SWITCH_STANDARD_SCHED_FUNC ( check_ip_callback )

Definition at line 211 of file switch_core.c.

References check_ip(), and switch_epoch_time_now().

 {
         check_ip();
 
         /* reschedule this task */
         task->runtime = switch_epoch_time_now(NULL) + 60;
 }

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

Definition at line 3206 of file switch_core.c.

References switch_close_extra_files(), switch_fork(), switch_system(), and SWITCH_TRUE.

Referenced by preprocess_exec_set(), and switch_stream_system().

 {
 #ifdef WIN32
         return switch_system(cmd, SWITCH_TRUE);
 #else
         int fds[2], pid = 0;
 
         if (pipe(fds)) {
                 goto end;
         } else {                                        /* good to go */
                 pid = switch_fork();
 
                 if (pid < 0) {                  /* ok maybe not */
                         close(fds[0]);
                         close(fds[1]);
                         goto end;
                 } else if (pid) {               /* parent */
                         char buf[1024] = "";
                         int bytes;
                         close(fds[1]);
                         while ((bytes = read(fds[0], buf, sizeof(buf))) > 0) {
                                 stream->raw_write_function(stream, (unsigned char *)buf, bytes);
                         }
                         close(fds[0]);
                         waitpid(pid, NULL, 0);
                 } else {                                /*  child */
                         switch_close_extra_files(fds, 2);
                         close(fds[0]);
                         dup2(fds[1], STDOUT_FILENO);
                         switch_system(cmd, SWITCH_TRUE);
                         close(fds[1]);
                         exit(0);
                 }
         }
 
  end:
 
         return 0;
 
 #endif
 
 }

static int switch_system_fork	(	const char *	cmd,
		switch_bool_t	wait
	)

static

Definition at line 3147 of file switch_core.c.

References memset(), SWITCH_CHANNEL_LOG, switch_close_extra_files(), switch_core_set_signal_handlers(), switch_fork(), SWITCH_LOG_ERROR, and switch_log_printf().

Referenced by switch_system().

 {
         int pid;
         char *dcmd = strdup(cmd);
 #if defined(HAVE_SETRLIMIT) && !defined(__FreeBSD__)
         struct rlimit rlim;
         struct rlimit rlim_save;
 #endif
 
         switch_core_set_signal_handlers();
 
         pid = switch_fork();
         
         if (pid) {
                 if (wait) {
                         waitpid(pid, NULL, 0);
                 }
                 free(dcmd);
         } else {
                 switch_close_extra_files(NULL, 0);
 
 #if defined(HAVE_SETRLIMIT) && !defined(__FreeBSD__)
                 memset(&rlim, 0, sizeof(rlim));
                 getrlimit(RLIMIT_STACK, &rlim);
 
                 memset(&rlim_save, 0, sizeof(rlim_save));
                 getrlimit(RLIMIT_STACK, &rlim_save);
 
                 rlim.rlim_cur = rlim.rlim_max;
                 if (setrlimit(RLIMIT_STACK, &rlim) < 0) {
                         switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Setting stack size failed! (%s)\n", strerror(errno));
                 }
 #endif
 
                 if (system(dcmd) == -1) {
                         switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Failed to execute because of a command error : %s\n", dcmd);
                 }
                 free(dcmd);
                 exit(0);
         }
 
         return 0;
 }

static int switch_system_thread	(	const char *	cmd,
		switch_bool_t	wait
	)

static

Definition at line 3041 of file switch_core.c.

References system_thread_handle::cmd, system_thread_handle::cond, system_thread_handle::mutex, pool, system_thread_handle::pool, system_thread_handle::ret, SWITCH_CHANNEL_LOG, switch_core_alloc, switch_core_destroy_memory_pool, switch_core_new_memory_pool, switch_core_strdup, SWITCH_LOG_CRIT, switch_log_printf(), switch_mutex_init(), switch_mutex_lock(), SWITCH_MUTEX_NESTED, switch_mutex_unlock(), SWITCH_STATUS_SUCCESS, SWITCH_SYSTEM_THREAD_STACKSIZE, switch_thread_cond_create(), switch_thread_cond_wait(), switch_thread_create(), switch_threadattr_create(), switch_threadattr_detach_set(), switch_threadattr_stacksize_set(), system_thread(), and thread.

Referenced by switch_system().

 {
         switch_thread_t *thread;
         switch_threadattr_t *thd_attr;
         int ret = 0;
         struct system_thread_handle *sth;
         switch_memory_pool_t *pool;
 
         if (switch_core_new_memory_pool(&pool) != SWITCH_STATUS_SUCCESS) {
                 switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Pool Failure\n");
                 return 1;
         }
 
         if (!(sth = switch_core_alloc(pool, sizeof(struct system_thread_handle)))) {
                 switch_core_destroy_memory_pool(&pool);
                 return 1;
         }
 
         sth->pool = pool;
         sth->cmd = switch_core_strdup(pool, cmd);
 
         switch_thread_cond_create(&sth->cond, sth->pool);
         switch_mutex_init(&sth->mutex, SWITCH_MUTEX_NESTED, sth->pool);
         switch_mutex_lock(sth->mutex);
 
         switch_threadattr_create(&thd_attr, sth->pool);
         switch_threadattr_stacksize_set(thd_attr, SWITCH_SYSTEM_THREAD_STACKSIZE);
         switch_threadattr_detach_set(thd_attr, 1);
         switch_thread_create(&thread, thd_attr, system_thread, sth, sth->pool);
 
         if (wait) {
                 switch_thread_cond_wait(sth->cond, sth->mutex);
                 ret = sth->ret;
         }
         switch_mutex_unlock(sth->mutex);
 
         return ret;
 }

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

static

Definition at line 2999 of file switch_core.c.

References system_thread_handle::cmd, system_thread_handle::cond, system_thread_handle::fds, memset(), system_thread_handle::mutex, system_thread_handle::pool, system_thread_handle::ret, SWITCH_CHANNEL_LOG, switch_core_destroy_memory_pool, SWITCH_LOG_ERROR, switch_log_printf(), switch_mutex_lock(), switch_mutex_unlock(), and switch_thread_cond_signal().

Referenced by switch_system_thread().

 {
         struct system_thread_handle *sth = (struct system_thread_handle *) obj;
 
 #if defined(HAVE_SETRLIMIT) && !defined(__FreeBSD__)
         struct rlimit rlim;
         struct rlimit rlim_save;
 
         memset(&rlim, 0, sizeof(rlim));
         getrlimit(RLIMIT_STACK, &rlim);
 
         memset(&rlim_save, 0, sizeof(rlim_save));
         getrlimit(RLIMIT_STACK, &rlim_save);
 
         rlim.rlim_cur = rlim.rlim_max;
         if (setrlimit(RLIMIT_STACK, &rlim) < 0) {
                 switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Setting stack size failed! (%s)\n", strerror(errno));
         }
 #endif
 
         if (sth->fds) {
                 dup2(sth->fds[1], STDOUT_FILENO);
         }
 
         sth->ret = system(sth->cmd);
 
 #if defined(HAVE_SETRLIMIT) && !defined(__FreeBSD__)
         if (setrlimit(RLIMIT_STACK, &rlim_save) < 0) {
                 switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Setting stack size failed! (%s)\n", strerror(errno));
         }
 #endif
 
         switch_mutex_lock(sth->mutex);
         switch_thread_cond_signal(sth->cond);
         switch_mutex_unlock(sth->mutex);
 
         switch_core_destroy_memory_pool(&sth->pool);
 
         return NULL;
 }

Variable Documentation

uint32_t d_30 = 30

static

Definition at line 2051 of file switch_core.c.

switch_ip_list_t IP_LIST = { 0 }

static

Definition at line 1364 of file switch_core.c.

char main_ip4[256] = ""

static

Definition at line 106 of file switch_core.c.

Referenced by check_ip().

char main_ip6[256] = ""

static

Definition at line 107 of file switch_core.c.

Referenced by check_ip().

struct switch_runtime runtime = { 0 }

Definition at line 64 of file switch_core.c.

switch_filenames SWITCH_GLOBAL_filenames = { 0 }

Definition at line 61 of file switch_core.c.

Referenced by __switch_xml_open_root(), main(), switch_core_set_globals(), and switch_xml_parse_file().

Data Structures

Macros

Functions

Variables

Macro Definition Documentation

Function Documentation

Variable Documentation