switch_core.c File Reference

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

Include dependency graph for switch_core.c:

Go to the source code of this file.

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_port_token (const char *ip_str, int port, const char *list_name, const char **token)
switch_bool_t	switch_check_network_list_ip_token (const char *ip_str, const char *list_name, const char **token)
void	switch_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_sqldb_init (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. 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_sps (void)
int32_t	switch_core_sps_last (void)
int32_t	switch_core_sps_peak (void)
int32_t	switch_core_sps_peak_fivemin (void)
int32_t	switch_core_sessions_peak (void)
int32_t	switch_core_sessions_peak_fivemin (void)
uint32_t	switch_core_max_audio_channels (uint32_t limit)
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...
void	switch_core_sqldb_destroy (void)
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)
int	switch_stream_spawn (const char *cmd, switch_bool_t shell, switch_bool_t wait, switch_stream_handle_t *stream)
int	switch_spawn (const char *cmd, switch_bool_t wait)
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 (void)
	Get RTP port range start value. More...
uint16_t	switch_core_get_rtp_port_range_end_port (void)
	Get RTP port range end value. More...
const char *	switch_core_get_event_channel_key_separator (void)

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

BUFSIZE

#define BUFSIZE   1024

Referenced by switch_core_set_globals().

Function Documentation

check_ip()

static void check_ip ( void  )

static

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

}

handle_SIGHUP()

static void handle_SIGHUP ( int  sig )

static

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

load_mime_types()

static void load_mime_types ( void  )

static

Definition at line 1272 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);
        fclose(fd);

  end:

        switch_safe_free(mime_path);

}

send_heartbeat()

static void send_heartbeat ( void  )

static

Definition at line 89 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_last, 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-Last", "%u", runtime.sps_last);
                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);
        }
}

switch_close_extra_files()

void switch_close_extra_files	(	int *	keep,
		int	keep_ttl
	)

Definition at line 3244 of file switch_core.c.

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

Referenced by preprocess_exec(), and switch_system_fork().

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

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

                close(i);

        skip:

                continue;

        }
}

switch_core_add_state_handler()

int switch_core_add_state_handler

(

const switch_state_handler_table_t *

state_handler

)

Definition at line 317 of file switch_core.c.

References switch_runtime::global_mutex, index, 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 (index > (SWITCH_MAX_STATE_HANDLERS - 1)) {
                index = -1;
        } else {
                runtime.state_handlers[index] = state_handler;
                runtime.state_handler_index++;
        }

        switch_mutex_unlock(runtime.global_mutex);
        return index;
}

switch_core_banner()

const char* switch_core_banner

(

void

)

Definition at line 2406 of file switch_core.c.

Referenced by switch_core_init_and_modload().

{

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

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

switch_core_debug_level()

uint32_t switch_core_debug_level

(

void

)

Definition at line 2607 of file switch_core.c.

References switch_runtime::debug_level.

{
        return runtime.debug_level;
}

switch_core_dump_variables()

void switch_core_dump_variables

(

switch_stream_handle_t *

stream

)

Definition at line 345 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(), switch_event_header::value, and switch_stream_handle::write_function.

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

switch_core_get_event_channel_key_separator()

const char* switch_core_get_event_channel_key_separator

(

void

)

Definition at line 3592 of file switch_core.c.

References switch_runtime::event_channel_key_separator.

Referenced by ecd_deliver().

{
        return runtime.event_channel_key_separator;
}

switch_core_get_rtp_port_range_end_port()

uint16_t switch_core_get_rtp_port_range_end_port

(

void

)

Get RTP port range end value.

Parameters

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

Definition at line 3581 of file switch_core.c.

References switch_rtp_set_end_port().

{
        uint16_t end_port = 0;

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

        return end_port;
}

switch_core_get_rtp_port_range_start_port()

uint16_t switch_core_get_rtp_port_range_start_port

(

void

)

Get RTP port range start value.

Parameters

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

Definition at line 3570 of file switch_core.c.

References switch_rtp_set_start_port().

{
        uint16_t start_port = 0;

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

        return start_port;
}

switch_core_get_stacksizes()

switch_status_t switch_core_get_stacksizes	(	switch_size_t *	cur,
		switch_size_t *	max
	)

Definition at line 3512 of file switch_core.c.

References memset(), SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

{
#ifdef HAVE_SETRLIMIT
        struct rlimit rlp;

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

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

        return SWITCH_STATUS_SUCCESS;

#else

        return SWITCH_STATUS_FALSE;

#endif



}

switch_core_get_state_handler()

const switch_state_handler_table_t* switch_core_get_state_handler

(

int

index

)

Definition at line 335 of file switch_core.c.

References index, 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];
}

switch_core_get_variable()

char* switch_core_get_variable

(

const char *

varname

)

Definition at line 395 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(), switch_core_get_domain(), switch_stream_spawn(), switch_stream_system(), and switch_system().

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

switch_core_get_variable_dup()

char* switch_core_get_variable_dup

(

const char *

varname

)

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

switch_core_get_variable_pdup()

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

Definition at line 419 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_core_init()

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

Definition at line 1798 of file switch_core.c.

References switch_directories::base_dir, switch_frame::buflen, switch_directories::cache_dir, switch_directories::certs_dir, switch_runtime::colorize_console, switch_directories::conf_dir, switch_runtime::console, switch_runtime::cpu_count, switch_frame::data, switch_directories::data_dir, switch_frame::datalen, switch_directories::db_dir, switch_runtime::db_handle_timeout, switch_runtime::dbname, DBTYPE_DEFAULT, switch_runtime::default_dtmf_duration, switch_runtime::dummy_cng_frame, switch_runtime::dummy_data, switch_runtime::event_heartbeat_interval, switch_runtime::flags, switch_directories::fonts_dir, switch_runtime::global_mutex, switch_runtime::global_var_rwlock, switch_runtime::global_vars, switch_directories::grammar_dir, switch_runtime::hard_log_level, switch_runtime::hostname, switch_directories::htdocs_dir, switch_directories::images_dir, switch_runtime::initiated, load_mime_types(), switch_directories::localstate_dir, switch_directories::log_dir, switch_runtime::mailer_app, switch_runtime::mailer_app_args, switch_runtime::max_db_handles, switch_runtime::max_dtmf_duration, switch_runtime::memory_pool, memset(), switch_runtime::microseconds_per_tick, switch_runtime::mime_type_exts, switch_runtime::mime_types, switch_runtime::min_dtmf_duration, switch_directories::mod_dir, switch_runtime::odbc_dbtype, switch_runtime::ptimes, switch_directories::recordings_dir, switch_directories::run_dir, switch_runtime::runlevel, switch_runtime::running, SCF_API_EXPANSION, SCF_AUTO_SCHEMAS, SCF_CLEAR_SQL, SCF_LOG_DISABLE, SCF_MINIMAL, SCF_NO_NEW_SESSIONS, SCF_SESSION_THREAD_POOL, SCF_THREADED_SYSTEM_EXEC, SCF_USE_AUTO_NAT, SCF_USE_NAT_MAPPING, switch_directories::script_dir, switch_runtime::session_hash_mutex, SFF_CNG, switch_runtime::shutdown_cause, switch_directories::sounds_dir, switch_runtime::sps_total, SSHF_NO_DEL, SSHF_NONE, SSHF_OWN_THREAD, switch_directories::storage_dir, switch_assert, SWITCH_CAUSE_SYSTEM_SHUTDOWN, switch_channel_global_init(), SWITCH_CHANNEL_LOG, switch_console_init(), switch_core_hash_init_case(), switch_core_media_init(), switch_core_memory_init(), switch_core_session_init(), switch_core_set_globals(), switch_core_set_variable(), switch_core_state_machine_init(), switch_curl_init(), SWITCH_DEFAULT_DIR_PERMS, SWITCH_DEFAULT_DTMF_DURATION, switch_dir_make_recursive(), switch_epoch_time_now(), SWITCH_EVENT_CHANNEL_DATA, switch_event_create_plain(), switch_event_init(), SWITCH_FALSE, switch_find_local_ip(), SWITCH_GLOBAL_dirs, switch_load_core_config(), SWITCH_LOG_DEBUG, SWITCH_LOG_DEBUG1, SWITCH_LOG_DISABLE, switch_log_init(), switch_log_printf(), SWITCH_MAX_DTMF_DURATION, SWITCH_MIN_DTMF_DURATION, switch_mono_micro_time_now(), switch_mutex_init(), SWITCH_MUTEX_NESTED, switch_nat_init(), switch_nat_late_init(), switch_rtp_init(), switch_scheduler_add_task(), switch_scheduler_task_thread_start(), switch_set_flag, switch_ssl_init_ssl_locks(), SWITCH_STATUS_MEMERR, SWITCH_STATUS_SUCCESS, switch_test_flag, switch_thread_rwlock_create(), switch_uuid_format(), switch_uuid_get(), switch_xml_init(), switch_directories::temp_dir, switch_runtime::throttle_mutex, switch_runtime::timer_affinity, switch_runtime::tipping_point, switch_runtime::uuid_mutex, and switch_runtime::uuid_str.

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.shutdown_cause = SWITCH_CAUSE_SYSTEM_SHUTDOWN;
        runtime.max_db_handles = 50;
        runtime.db_handle_timeout = 5000000;
        runtime.event_heartbeat_interval = 20;

        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);
        if (flags & SCF_LOG_DISABLE) {
                runtime.hard_log_level = SWITCH_LOG_DISABLE;
                flags &= ~SCF_LOG_DISABLE;
        } else {
                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 (fspr_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();
        OpenSSL_add_all_algorithms();
        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);
        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) {
                /* allow missing configuration if MINIMAL */
                if (!(flags & SCF_MINIMAL)) {
                        fspr_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);

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

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

Definition at line 2443 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_msrp_init(), 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_msrp_init();

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

#ifdef HAVE_SYSTEMD
        sd_notifyf(0, "READY=1\n"
                "MAINPID=%lu\n", (unsigned long) getpid());
#endif

        return SWITCH_STATUS_SUCCESS;

}

switch_core_launch_thread()

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

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

switch_core_max_audio_channels()

uint32_t switch_core_max_audio_channels

(

uint32_t

limit

)

Definition at line 2642 of file switch_core.c.

References switch_runtime::max_audio_channels.

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

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

        return runtime.max_audio_channels;
}

switch_core_remove_state_handler()

void switch_core_remove_state_handler

(

const switch_state_handler_table_t *

state_handler

)

Definition at line 292 of file switch_core.c.

References cur, switch_runtime::global_mutex, index, 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);
}

switch_core_service_session_av()

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

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

switch_core_service_thread()

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

static

Definition at line 501 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 = NULL;

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

switch_core_sessions_peak()

int32_t switch_core_sessions_peak

(

void

)

Definition at line 2632 of file switch_core.c.

References switch_runtime::sessions_peak.

{
        return runtime.sessions_peak;
}

switch_core_sessions_peak_fivemin()

int32_t switch_core_sessions_peak_fivemin

(

void

)

Definition at line 2637 of file switch_core.c.

References switch_runtime::sessions_peak_fivemin.

{
        return runtime.sessions_peak_fivemin;
}

switch_core_set_signal_handlers()

void switch_core_set_signal_handlers

(

void

)

Definition at line 2579 of file switch_core.c.

References handle_SIGHUP().

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

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

switch_core_set_var_conditional()

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

Definition at line 464 of file switch_core.c.

References switch_runtime::global_var_rwlock, switch_runtime::global_vars, switch_event_add_header_string_nodup(), switch_event_del_header, switch_event_get_header, SWITCH_FALSE, SWITCH_STACK_BOTTOM, 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_nodup(runtime.global_vars, SWITCH_STACK_BOTTOM, varname, v);
                } else {
                        switch_event_del_header(runtime.global_vars, varname);
                }
                switch_thread_rwlock_unlock(runtime.global_var_rwlock);
        }
        return SWITCH_TRUE;
}

switch_core_set_variable()

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

Definition at line 442 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_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, varname, v);
                        free(v);
                } else {
                        switch_event_del_header(runtime.global_vars, varname);
                }
                switch_thread_rwlock_unlock(runtime.global_var_rwlock);
        }
}

switch_core_sps()

int32_t switch_core_sps

(

void

)

Definition at line 2612 of file switch_core.c.

References switch_runtime::sps.

{
        return runtime.sps;
}

switch_core_sps_last()

int32_t switch_core_sps_last

(

void

)

Definition at line 2617 of file switch_core.c.

References switch_runtime::sps_last.

{
        return runtime.sps_last;
}

switch_core_sps_peak()

int32_t switch_core_sps_peak

(

void

)

Definition at line 2622 of file switch_core.c.

References switch_runtime::sps_peak.

{
        return runtime.sps_peak;
}

switch_core_sps_peak_fivemin()

int32_t switch_core_sps_peak_fivemin

(

void

)

Definition at line 2627 of file switch_core.c.

References switch_runtime::sps_peak_fivemin.

{
        return runtime.sps_peak_fivemin;
}

switch_core_sqldb_destroy()

void switch_core_sqldb_destroy

(

void

)

Definition at line 3013 of file switch_core.c.

References SCF_USE_SQL, switch_core_sqldb_stop(), and switch_test_flag.

Referenced by switch_loadable_module_shutdown().

{
        if (switch_test_flag((&runtime), SCF_USE_SQL)) {
                switch_core_sqldb_stop();
        }
}

switch_core_sqldb_init()

switch_status_t switch_core_sqldb_init

(

const char **

err

)

Definition at line 2428 of file switch_core.c.

References switch_runtime::memory_pool, SCF_USE_SQL, switch_core_check_core_db_dsn(), switch_core_sqldb_start(), SWITCH_FALSE, SWITCH_STATUS_GENERR, SWITCH_STATUS_SUCCESS, switch_test_flag, and SWITCH_TRUE.

Referenced by switch_loadable_module_init().

{
        if (switch_core_check_core_db_dsn() != SWITCH_STATUS_SUCCESS) {
                *err = "NO SUITABLE DATABASE INTERFACE IS AVAILABLE TO SERVE 'core-db-dsn'!\n";
                return SWITCH_STATUS_GENERR;
        }

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

        return SWITCH_STATUS_SUCCESS;
}

switch_core_thread_session_end()

void switch_core_thread_session_end

(

switch_core_session_t *

session

)

Definition at line 557 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_core_thread_set_cpu_affinity()

switch_status_t switch_core_thread_set_cpu_affinity

(

int

cpu

)

Definition at line 1763 of file switch_core.c.

References SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

Referenced by switch_core_autobind_cpu(), and SWITCH_MODULE_RUNTIME_FUNCTION().

{
        switch_status_t status = SWITCH_STATUS_FALSE;

        if (cpu > -1) {

#ifdef HAVE_CPU_SET_MACROS
                cpu_set_t set;

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

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

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

        return status;
}

switch_core_unset_variables()

static void switch_core_unset_variables ( void  )

static

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

switch_default_ptime()

uint32_t switch_default_ptime	(	const char *	name,
		uint32_t	number
	)

Definition at line 2022 of file switch_core.c.

References switch_runtime::ptimes, and switch_core_hash_find().

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

{
        uint32_t *p;

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

        return 20;
}

switch_default_rate()

uint32_t switch_default_rate	(	const char *	name,
		uint32_t	number
	)

Definition at line 2033 of file switch_core.c.

Referenced by switch_loadable_module_get_codecs_sorted().

{

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

        return 8000;
}

switch_fork()

pid_t switch_fork

(

void

)

Definition at line 3282 of file switch_core.c.

References set_low_priority().

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

{
        int i = fork();

        if (!i) {
                set_low_priority();
        }

        return i;
}

switch_load_core_config()

static void switch_load_core_config ( const char *  file )

static

Definition at line 2049 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, d_30, switch_runtime::db_handle_timeout, switch_runtime::dbname, DBTYPE_DEFAULT, DBTYPE_MSSQL, switch_runtime::event_channel_key_separator, switch_runtime::event_heartbeat_interval, 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_CPF_SOFT_LOOKUP, SCF_CPF_SOFT_PREFIX, SCF_DIALPLAN_TIMESTAMPS, SCF_EARLY_HANGUP, SCF_EVENT_CHANNEL_ENABLE_HIERARCHY_DELIVERY, SCF_EVENT_CHANNEL_HIERARCHY_DELIVERY_ONCE, SCF_EVENT_CHANNEL_LOG_UNDELIVERABLE_JSON, 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_audio_channels(), switch_core_max_dtmf_duration(), switch_core_media_set_resolveice(), 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_skip_autocommit_flip(), 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, "odbc-skip-autocommit-flip")) {
                                        if (switch_true(val)) {
                                                switch_odbc_skip_autocommit_flip();
                                        }
                                } 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, "event-heartbeat-interval")) {
                                        long tmp = atol(val);

                                        if (tmp > 0) {
                                                runtime.event_heartbeat_interval = (uint32_t) tmp;
                                        } else {
                                                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "heartbeat-interval must be a greater than 0\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, "spawn-instead-of-system") && !zstr(val)) {
#ifdef WIN32
                                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "spawn-instead-of-system is not implemented on this platform\n");
#else
                                        int v = switch_true(val);
                                        if (v) {
                                                switch_core_set_variable("spawn_instead_of_system", "true");
                                        } else {
                                                switch_core_set_variable("spawn_instead_of_system", "false");
                                        }
#endif
                                } else if (!strcasecmp(var, "exclude-error-log-from-xml-cdr") && !zstr(val)) {
                                        int v = switch_true(val);
                                        if (v) {
                                                switch_core_set_variable("exclude_error_log_from_xml_cdr", "true");
                                        } else {
                                                switch_core_set_variable("exclude_error_log_from_xml_cdr", "false");
                                        }
                                } 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, "ice-resolve-candidate")) {
                                        switch_core_media_set_resolveice(switch_true(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)) {
                                        runtime.odbc_dsn = switch_core_strdup(runtime.memory_pool, val);
                                } 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;
                                        }
                                } 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);
                                } else if (!strcasecmp(var, "caller-profile-soft-variables-uses-prefix") && !zstr(val)) {
                                        int v = switch_true(val);
                                        if (v) {
                                                switch_set_flag((&runtime), SCF_CPF_SOFT_PREFIX);
                                        } else {
                                                switch_clear_flag((&runtime), SCF_CPF_SOFT_PREFIX);
                                        }
                                } else if (!strcasecmp(var, "caller-profile-soft-lookup-values") && !zstr(val)) {
                                        int v = switch_true(val);
                                        if (v) {
                                                switch_set_flag((&runtime), SCF_CPF_SOFT_LOOKUP);
                                        } else {
                                                switch_clear_flag((&runtime), SCF_CPF_SOFT_LOOKUP);
                                        }
                                } else if (!strcasecmp(var, "event-channel-key-separator") && !zstr(val)) {
                                        runtime.event_channel_key_separator = switch_core_strdup(runtime.memory_pool, val);
                                } else if (!strcasecmp(var, "event-channel-enable-hierarchy-deliver") && !zstr(val)) {
                                        int v = switch_true(val);
                                        if (v) {
                                                switch_set_flag((&runtime), SCF_EVENT_CHANNEL_ENABLE_HIERARCHY_DELIVERY);
                                        } else {
                                                switch_clear_flag((&runtime), SCF_EVENT_CHANNEL_ENABLE_HIERARCHY_DELIVERY);
                                        }
                                } else if (!strcasecmp(var, "event-channel-hierarchy-deliver-once") && !zstr(val)) {
                                        int v = switch_true(val);
                                        if (v) {
                                                switch_set_flag((&runtime), SCF_EVENT_CHANNEL_HIERARCHY_DELIVERY_ONCE);
                                        } else {
                                                switch_clear_flag((&runtime), SCF_EVENT_CHANNEL_HIERARCHY_DELIVERY_ONCE);
                                        }
                                } else if (!strcasecmp(var, "event-channel-log-undeliverable-json") && !zstr(val)) {
                                        int v = switch_true(val);
                                        if (v) {
                                                switch_set_flag((&runtime), SCF_EVENT_CHANNEL_LOG_UNDELIVERABLE_JSON);
                                        } else {
                                                switch_clear_flag((&runtime), SCF_EVENT_CHANNEL_LOG_UNDELIVERABLE_JSON);
                                        }
                                } else if (!strcasecmp(var, "max-audio-channels") && !zstr(val)) {
                                        switch_core_max_audio_channels(atoi(val));
                                }
                        }
                }

                if (runtime.event_channel_key_separator == NULL) {
                        runtime.event_channel_key_separator = switch_core_strdup(runtime.memory_pool, ".");
                }

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


}

switch_max_file_desc()

int switch_max_file_desc

(

void

)

Definition at line 3228 of file switch_core.c.

Referenced by switch_close_extra_files().

{
        int max = 0;

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

        return max;

}

switch_spawn()

int switch_spawn	(	const char *	cmd,
		switch_bool_t	wait
	)

Definition at line 3507 of file switch_core.c.

References SWITCH_FALSE, and switch_stream_spawn().

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

SWITCH_STANDARD_SCHED_FUNC() [1/2]

SWITCH_STANDARD_SCHED_FUNC

(

heartbeat_callback

)

Definition at line 225 of file switch_core.c.

References switch_runtime::event_heartbeat_interval, send_heartbeat(), and switch_epoch_time_now().

{
        send_heartbeat();

        /* reschedule this task */
        task->runtime = switch_epoch_time_now(NULL) + runtime.event_heartbeat_interval;
}

SWITCH_STANDARD_SCHED_FUNC() [2/2]

SWITCH_STANDARD_SCHED_FUNC

(

check_ip_callback

)

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

switch_stream_spawn()

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

Definition at line 3372 of file switch_core.c.

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

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

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

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

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

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

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

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

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

        posix_spawn_file_actions_init(&action);

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

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

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

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

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

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

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

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

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

        return status;
#endif
}

switch_stream_system_fork()

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

Definition at line 3363 of file switch_core.c.

References switch_stream_system().

{
        return switch_stream_system(cmd, stream);
}

switch_system_fork()

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

static

Definition at line 3295 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_close_extra_files(), and 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;
}

switch_system_thread()

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

static

Definition at line 3189 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_close_extra_files(), and 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;
}

system_thread()

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

static

Definition at line 3147 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

d_30

uint32_t d_30 = 30

static

Definition at line 2047 of file switch_core.c.

Referenced by switch_load_core_config().

IP_LIST

switch_ip_list_t IP_LIST = { 0 }

static

Definition at line 1372 of file switch_core.c.

main_ip4

char main_ip4[256] = ""

static

Definition at line 129 of file switch_core.c.

Referenced by check_ip().

main_ip6

char main_ip6[256] = ""

static

Definition at line 130 of file switch_core.c.

Referenced by check_ip().

runtime

struct switch_runtime runtime = { 0 }

Definition at line 86 of file switch_core.c.

Referenced by _switch_cache_db_get_db_handle(), _switch_core_db_handle(), switch_cache_db_create_schema(), switch_cache_db_test_reactive_ex(), switch_cond_next(), switch_cond_yield(), switch_core_add_registration(), switch_core_check_core_db_dsn(), switch_core_db_test_reactive(), switch_core_del_registration(), switch_core_expire_registration(), switch_core_idle_cpu(), switch_core_min_idle_cpu(), switch_core_pool_stats(), switch_core_port_allocator_new(), switch_core_session_event_send(), switch_core_session_findall(), switch_core_session_findall_matching_var(), switch_core_session_hangup_state(), switch_core_session_hupall(), switch_core_session_hupall_endpoint(), switch_core_session_hupall_matching_vars_ans(), switch_core_session_id_dec(), switch_core_session_message_send(), switch_core_session_perform_destroy(), switch_core_session_perform_force_locate(), switch_core_session_perform_locate(), switch_core_session_read_frame(), switch_core_session_read_text_frame(), switch_core_session_read_video_frame(), switch_core_session_request_uuid(), switch_core_session_set_external_id(), switch_core_session_set_uuid(), switch_core_session_sync_clock(), switch_core_session_thread_launch(), switch_core_sessions_per_second(), switch_core_sql_db_thread(), switch_core_sql_exec(), switch_core_sqldb_start(), switch_core_sqldb_start_thread(), switch_event_fire_detailed(), switch_event_shutdown(), switch_log_meta_vprintf(), switch_micro_time_now(), SWITCH_MODULE_LOAD_FUNCTION(), SWITCH_MODULE_RUNTIME_FUNCTION(), switch_new_profile_timer(), switch_simple_email(), switch_sql_concat(), switch_time_calibrate_clock(), switch_time_sync(), switch_user_sql_thread(), switch_uuid_get(), timer_destroy(), timer_init(), and timer_next().

SWITCH_GLOBAL_dirs

switch_directories SWITCH_GLOBAL_dirs = { 0 }

Definition at line 82 of file switch_core.c.

Referenced by __switch_xml_open_root(), db_pick_path(), freeswitch_kill_background(), fs_encode_cleanup(), fs_tts_cleanup(), fst_init_core_and_modload(), load_config(), load_mime_types(), main(), switch_config_open_file(), switch_console_list_available_modules(), switch_console_save_history(), switch_core_cert_gen_fingerprint(), switch_core_check_dtls_pem(), switch_core_destroy(), switch_core_gen_certs(), switch_core_init(), switch_core_set_globals(), switch_img_txt_handle_create(), switch_ivr_displace_session(), switch_ivr_insert_file(), switch_ivr_play_file(), switch_ivr_record_file_event(), switch_ivr_record_session_event(), switch_loadable_module_init(), switch_loadable_module_load_file(), switch_rtp_add_dtls(), switch_simple_email(), SWITCH_STANDARD_APP(), switch_stream_write_file_contents(), and switch_xml_parse_file().

SWITCH_GLOBAL_filenames

switch_filenames SWITCH_GLOBAL_filenames = { 0 }

Definition at line 83 of file switch_core.c.

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