Misc

Collaboration diagram for Misc:

Macros
#define	switch_check_network_list_ip(_ip_str, _list_name)   switch_check_network_list_ip_token(_ip_str, _list_name, NULL)

Functions
FILE *	switch_core_data_channel (switch_text_channel_t channel)
	Retrieve a FILE stream of a given text channel name. More...
switch_bool_t	switch_core_ready (void)
	Determines if the core is ready to take calls. More...
switch_bool_t	switch_core_running (void)
switch_bool_t	switch_core_ready_inbound (void)
	Determines if the core is ready to take inbound calls. More...
switch_bool_t	switch_core_ready_outbound (void)
	Determines if the core is ready to place outbound calls. More...
switch_core_flag_t	switch_core_flags (void)
	return core flags More...
switch_status_t	switch_core_management_exec (char *relative_oid, switch_management_action_t action, char *data, switch_size_t datalen)
	Execute a management operation. More...
int32_t	switch_core_set_process_privileges (void)
	Switch on the privilege awareness for the process and request required privileges. More...
int32_t	set_normal_priority (void)
	Set the maximum priority the process can obtain. More...
int32_t	set_auto_priority (void)
int32_t	set_realtime_priority (void)
int32_t	set_low_priority (void)
int32_t	change_user_group (const char *user, const char *group)
	Change user and/or group of the running process. More...
void	switch_core_runtime_loop (int bg)
	Run endlessly until the system is shutdown. More...
switch_status_t	switch_core_set_console (const char *console)
	Set the output console to the desired file. More...
void	switch_core_measure_time (switch_time_t total_ms, switch_core_time_duration_t *duration)
	Breakdown a number of milliseconds into various time spec. More...
switch_time_t	switch_core_uptime (void)
	Number of microseconds the system has been up. More...
int32_t	switch_core_session_ctl (switch_session_ctl_t cmd, void *val)
	send a control message to the core More...
FILE *	switch_core_get_console (void)
	Get the output console. More...
switch_thread_t *	switch_core_launch_thread (void *(SWITCH_THREAD_FUNC *func)(switch_thread_t *, void *), void *obj, switch_memory_pool_t *pool)
	Launch a thread. More...
void	switch_core_set_globals (void)
	Initiate Globals. More...
uint8_t	switch_core_session_compare (switch_core_session_t *a, switch_core_session_t *b)
	Checks if 2 sessions are using the same endpoint module. More...
uint8_t	switch_core_session_check_interface (switch_core_session_t *session, const switch_endpoint_interface_t *endpoint_interface)
	Checks if a session is using a specific endpoint. More...
switch_status_t	switch_core_session_set_video_read_callback (switch_core_session_t *session, switch_core_video_thread_callback_func_t func, void *user_data)
switch_status_t	switch_core_session_video_read_callback (switch_core_session_t *session, switch_frame_t *frame)
switch_hash_index_t *	switch_core_mime_index (void)
const char *	switch_core_mime_ext2type (const char *ext)
const char *	switch_core_mime_type2ext (const char *type)
switch_status_t	switch_core_mime_add_type (const char *type, const char *ext)
switch_loadable_module_interface_t *	switch_loadable_module_create_module_interface (switch_memory_pool_t *pool, const char *name)
void *	switch_loadable_module_create_interface (switch_loadable_module_interface_t *mod, switch_module_interface_name_t iname)
switch_time_t	switch_micro_time_now (void)
	Get the current epoch time in microseconds. More...
switch_time_t	switch_mono_micro_time_now (void)
void	switch_core_memory_reclaim (void)
void	switch_core_memory_reclaim_events (void)
void	switch_core_memory_reclaim_logger (void)
void	switch_core_memory_reclaim_all (void)
void	switch_core_setrlimits (void)
switch_time_t	switch_time_ref (void)
void	switch_time_sync (void)
time_t	switch_epoch_time_now (time_t *t)
	Get the current epoch time. More...
const char *	switch_lookup_timezone (const char *tz_name)
switch_status_t	switch_strftime_tz (const char *tz, const char *format, char *date, size_t len, switch_time_t thetime)
switch_status_t	switch_time_exp_tz_name (const char *tz, switch_time_exp_t *tm, switch_time_t thetime)
void	switch_load_network_lists (switch_bool_t reload)
switch_bool_t	switch_check_network_list_ip_token (const char *ip_str, const char *list_name, const char **token)
void	switch_time_set_monotonic (switch_bool_t enable)
void	switch_time_set_timerfd (int enable)
void	switch_time_set_nanosleep (switch_bool_t enable)
void	switch_time_set_matrix (switch_bool_t enable)
void	switch_time_set_cond_yield (switch_bool_t enable)
void	switch_time_set_use_system_time (switch_bool_t enable)
uint32_t	switch_core_min_dtmf_duration (uint32_t duration)
uint32_t	switch_core_max_dtmf_duration (uint32_t duration)
double	switch_core_min_idle_cpu (double new_limit)
double	switch_core_idle_cpu (void)
uint32_t	switch_core_default_dtmf_duration (uint32_t duration)
switch_status_t	switch_console_set_complete (const char *string)
switch_status_t	switch_console_set_alias (const char *string)
int	switch_system (const char *cmd, switch_bool_t wait)
int	switch_stream_system (const char *cmd, switch_stream_handle_t *stream)
void	switch_cond_yield (switch_interval_time_t t)
void	switch_cond_next (void)
switch_status_t	switch_core_chat_send_args (const char *dest_proto, const char *proto, const char *from, const char *to, const char *subject, const char *body, const char *type, const char *hint, switch_bool_t blocking)
switch_status_t	switch_core_chat_send (const char *dest_proto, switch_event_t *message_event)
switch_status_t	switch_core_chat_deliver (const char *dest_proto, switch_event_t **message_event)
switch_status_t	switch_ivr_preprocess_session (switch_core_session_t *session, const char *cmds)
void	switch_core_sqldb_pause (void)
void	switch_core_sqldb_resume (void)

Detailed Description

Macro Definition Documentation

#define switch_check_network_list_ip	(		_ip_str,
			_list_name
	)		switch_check_network_list_ip_token(_ip_str, _list_name, NULL)

Definition at line 2404 of file switch_core.h.

Referenced by check_ice(), and switch_core_media_check_nat().

Function Documentation

int32_t change_user_group	(	const char *	user,
		const char *	group
	)

Change user and/or group of the running process.

Parameters

user	name of the user to switch to (or NULL)
group	name of the group to switch to (or NULL)

Returns

0 on success, -1 otherwise

Several possible combinations:

• user only (group NULL): switch to user and his primary group (and supplementary groups, if supported)
• user and group: switch to user and specified group (only)
• group only (user NULL): switch group only

Definition at line 1070 of file switch_core.c.

Referenced by main().

{
#ifndef WIN32
        uid_t runas_uid = 0;
        gid_t runas_gid = 0;
        struct passwd *runas_pw = NULL;

        if (user) {
                /*
                 * Lookup user information in the system's db
                 */
                runas_pw = getpwnam(user);
                if (!runas_pw) {
                        fprintf(stderr, "ERROR: Unknown user \"%s\"\n", user);
                        return -1;
                }
                runas_uid = runas_pw->pw_uid;
        }

        if (group) {
                struct group *gr = NULL;

                /*
                 * Lookup group information in the system's db
                 */
                gr = getgrnam(group);
                if (!gr) {
                        fprintf(stderr, "ERROR: Unknown group \"%s\"\n", group);
                        return -1;
                }
                runas_gid = gr->gr_gid;
        }

        if (runas_uid && getuid() == runas_uid && (!runas_gid || runas_gid == getgid())) {
                /* already running as the right user and group, nothing to do! */
                return 0;
        }

        if (runas_uid) {
#ifdef SOLARIS_PRIVILEGES
                /* request the privilege to set the UID */
                if (priv_set(PRIV_ON, PRIV_EFFECTIVE, PRIV_PROC_SETID, NULL) < 0) {
                        fprintf(stderr, "ERROR: Failed to acquire proc_setid privilege (%s)\n", strerror(errno));
                        return -1;
                }
#endif
#ifdef HAVE_SETGROUPS
                /*
                 * Drop all group memberships prior to changing anything
                 * or else we're going to inherit the parent's list of groups
                 * (which is not what we want...)
                 */
                if (setgroups(0, NULL) < 0) {
                        fprintf(stderr, "ERROR: Failed to drop group access list\n");
                        return -1;
                }
#endif
                if (runas_gid) {
                        /*
                         * A group has been passed, switch to it
                         * (without loading the user's other groups)
                         */
                        if (setgid(runas_gid) < 0) {
                                fprintf(stderr, "ERROR: Failed to change gid!\n");
                                return -1;
                        }
                } else {
                        /*
                         * No group has been passed, use the user's primary group in this case
                         */
                        if (setgid(runas_pw->pw_gid) < 0) {
                                fprintf(stderr, "ERROR: Failed to change gid!\n");
                                return -1;
                        }
#ifdef HAVE_INITGROUPS
                        /*
                         * Set all the other groups the user is a member of
                         * (This can be really useful for fine-grained access control)
                         */
                        if (initgroups(runas_pw->pw_name, runas_pw->pw_gid) < 0) {
                                fprintf(stderr, "ERROR: Failed to set group access list for user\n");
                                return -1;
                        }
#endif
                }

                /*
                 * Finally drop all privileges by switching to the new userid
                 */
                if (setuid(runas_uid) < 0) {
                        fprintf(stderr, "ERROR: Failed to change uid!\n");
                        return -1;
                }
#ifdef HAVE_SYS_PRCTL_H
                if (prctl(PR_SET_DUMPABLE, 1) < 0) {
                        fprintf(stderr, "ERROR: Failed to enable core dumps!\n");
                        return -1;
                }
#endif
        }
#endif
        return 0;
}

int32_t set_auto_priority

(

void

)

Definition at line 1052 of file switch_core.c.

References switch_runtime::cpu_count, and set_realtime_priority().

Referenced by main().

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

        return set_realtime_priority();


        // ERROR: code not reachable on Windows Visual Studio Express 2008 return 0;
}

int32_t set_low_priority

(

void

)

Definition at line 932 of file switch_core.c.

Referenced by main(), and switch_fork().

{
#ifdef WIN32
        return SetPriorityClass(GetCurrentProcess(), BELOW_NORMAL_PRIORITY_CLASS);
#else
#if defined(USE_SCHED_SETSCHEDULER) && ! defined(SOLARIS_PRIVILEGES)
        /*
         * Try to use a normal scheduler
         */
        struct sched_param sched = { 0 };
        sched.sched_priority = 0;
        if (sched_setscheduler(0, SCHED_OTHER, &sched) < 0) {
                fprintf(stderr, "ERROR: Failed to set SCHED_OTHER scheduler (%s)\n", strerror(errno));
                return -1;
        }
#endif

#ifdef HAVE_SETPRIORITY
        /*
         * setpriority() works on FreeBSD (6.2), nice() doesn't
         */
        if (setpriority(PRIO_PROCESS, getpid(), 19) < 0) {
                fprintf(stderr, "ERROR: Could not set nice level\n");
                return -1;
        }
#else
        if (nice(19) != 19) {
                fprintf(stderr, "ERROR: Could not set nice level\n");
                return -1;
        }
#endif

        return 0;
#endif
}

int32_t set_normal_priority

(

void

)

Set the maximum priority the process can obtain.

Returns

0 on success

Definition at line 1047 of file switch_core.c.

Referenced by main().

{
        return 0;
}

int32_t set_realtime_priority

(

void

)

Definition at line 968 of file switch_core.c.

References SWITCH_PRI_LOW.

Referenced by main(), and set_auto_priority().

{
#ifdef WIN32
        return SetPriorityClass(GetCurrentProcess(), HIGH_PRIORITY_CLASS);
#else
#ifdef USE_SCHED_SETSCHEDULER
        /*
         * Try to use a round-robin scheduler
         * with a fallback if that does not work
         */
        struct sched_param sched = { 0 };
        sched.sched_priority = SWITCH_PRI_LOW;
#endif

#ifdef SOLARIS_PRIVILEGES
        /* request the privileges to elevate the priority */
        if (priv_set(PRIV_ON, PRIV_EFFECTIVE, PRIV_PROC_PRIOCNTL, NULL) < 0) {
#ifdef PRIV_PROC_PRIOUP
                /* fallback to PRIV_PROC_PRIOUP on SmartOS */
                fprintf(stderr, "WARN: Failed to acquire proc_priocntl privilege (%s)\n", strerror(errno));
                if (priv_set(PRIV_ON, PRIV_EFFECTIVE, PRIV_PROC_PRIOUP, NULL) < 0) {
                        fprintf(stderr, "ERROR: Failed to acquire proc_prioup privilege (%s)\n", strerror(errno));
                        return -1;
                }
#else
                fprintf(stderr, "ERROR: Failed to acquire proc_priocntl privilege (%s)\n", strerror(errno));
                return -1;
#endif
        }

        if (sched_setscheduler(0, SCHED_FIFO, &sched) < 0) {
                fprintf(stderr, "WARN: Failed to set SCHED_FIFO scheduler (%s)\n", strerror(errno));
        } else {
                return 0;
        }

        if (setpriority(PRIO_PROCESS, 0, -10) < 0) {
                fprintf(stderr, "ERROR: Could not set nice level\n");
                return -1;
        }

        return 0;
#else

#ifdef USE_SCHED_SETSCHEDULER
        if (sched_setscheduler(0, SCHED_FIFO, &sched) < 0) {
                fprintf(stderr, "ERROR: Failed to set SCHED_FIFO scheduler (%s)\n", strerror(errno));
                sched.sched_priority = 0;
                if (sched_setscheduler(0, SCHED_OTHER, &sched) < 0 ) {
                        fprintf(stderr, "ERROR: Failed to set SCHED_OTHER scheduler (%s)\n", strerror(errno));
                        return -1;
                }
        }
#endif

#ifdef HAVE_SETPRIORITY
        /*
         * setpriority() works on FreeBSD (6.2), nice() doesn't
         */
        if (setpriority(PRIO_PROCESS, getpid(), -10) < 0) {
                fprintf(stderr, "ERROR: Could not set nice level\n");
                return -1;
        }
#else
        if (nice(-10) != -10) {
                fprintf(stderr, "ERROR: Could not set nice level\n");
                return -1;
        }
#endif
#endif
        return 0;
#endif
}

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

Definition at line 1366 of file switch_core.c.

References switch_runtime::global_mutex, switch_ip_list_t::hash, switch_assert, switch_core_hash_find(), SWITCH_FALSE, switch_inet_pton(), switch_mutex_lock(), switch_mutex_unlock(), switch_network_ipv4_mapped_ipv6_addr(), switch_network_list_validate_ip6_token(), switch_network_list_validate_ip_token(), switch_parse_cidr(), switch_safe_free, switch_separate_string(), switch_test_subnet, switch_testv6_subnet(), and ip_t::v4.

{
        switch_network_list_t *list;
        ip_t  ip, mask, net;
        uint32_t bits;
        char *ipv6 = strchr(ip_str,':');
        switch_bool_t ok = SWITCH_FALSE;
        char *ipv4 = NULL;

        if ((ipv4 = switch_network_ipv4_mapped_ipv6_addr(ip_str))) {
                ip_str = ipv4;
                ipv6 = NULL;
        }

        switch_mutex_lock(runtime.global_mutex);
        if (ipv6) {
                switch_inet_pton(AF_INET6, ip_str, &ip);
        } else {
                switch_inet_pton(AF_INET, ip_str, &ip);
                ip.v4 = htonl(ip.v4);
        }

        if ((list = switch_core_hash_find(IP_LIST.hash, list_name))) {
                if (ipv6) {
                        ok = switch_network_list_validate_ip6_token(list, ip, token);
                } else {
                        ok = switch_network_list_validate_ip_token(list, ip.v4, token);
                }
        } else if (strchr(list_name, '/')) {
                if (strchr(list_name, ',')) {
                        char *list_name_dup = strdup(list_name);
                        char *argv[32];
                        int argc;

                        switch_assert(list_name_dup);

                        if ((argc = switch_separate_string(list_name_dup, ',', argv, (sizeof(argv) / sizeof(argv[0]))))) {
                                int i;
                                for (i = 0; i < argc; i++) {
                                        switch_parse_cidr(argv[i], &net, &mask, &bits);
                                        if (ipv6) {
                                                if ((ok = switch_testv6_subnet(ip, net, mask))){
                                                        break;
                                                }
                                        } else {
                                                if ((ok = switch_test_subnet(ip.v4, net.v4, mask.v4))) {
                                                        break;
                                                }
                                        }
                                }
                        }
                        free(list_name_dup);
                } else {
                        switch_parse_cidr(list_name, &net, &mask, &bits);

                        if (ipv6) {
                                ok = switch_testv6_subnet(ip, net, mask);
                        } else {
                                ok = switch_test_subnet(ip.v4, net.v4, mask.v4);
                        }
                }
        }

        switch_safe_free(ipv4);
        switch_mutex_unlock(runtime.global_mutex);

        return ok;
}

void switch_cond_next

(

void

)

Definition at line 638 of file switch_time.c.

References do_sleep(), globals, mutex, runtime, switch_mutex_lock(), switch_mutex_unlock(), switch_os_yield(), switch_thread_cond_wait(), switch_runtime::timestamp, and switch_runtime::tipping_point.

Referenced by careful_set(), chat_thread_run(), check_dispatch(), handle_rfc2833(), qm_wake(), rtp_common_read(), sql_close(), switch_cache_db_execute_sql2str(), switch_channel_wait_for_flag(), switch_channel_wait_for_state(), switch_channel_wait_for_state_timeout(), switch_core_file_read_video(), switch_core_memory_init(), switch_core_session_execute_application_get_flags(), switch_core_session_read_frame(), switch_core_session_read_video_frame(), switch_core_session_wake_session_thread(), switch_ivr_collect_digits_callback(), switch_ivr_collect_digits_count(), switch_ivr_multi_threaded_bridge(), switch_ivr_originate(), switch_ivr_park(), switch_ivr_wait_for_answer(), switch_log_init(), switch_log_shutdown(), switch_rtp_set_local_address(), switch_stun_lookup(), and video_helper_thread().

{
        if (runtime.tipping_point && globals.timer_count >= runtime.tipping_point) {
                switch_os_yield();
                return;
        }
#ifdef DISABLE_1MS_COND
        do_sleep(1000);
#else
        if (globals.RUNNING != 1 || !runtime.timestamp || globals.use_cond_yield != 1) {
                do_sleep(1000);
                return;
        }
        switch_mutex_lock(TIMER_MATRIX[1].mutex);
        switch_thread_cond_wait(TIMER_MATRIX[1].cond, TIMER_MATRIX[1].mutex);
        switch_mutex_unlock(TIMER_MATRIX[1].mutex);
#endif
}

void switch_cond_yield

(

switch_interval_time_t

t

)

Definition at line 657 of file switch_time.c.

References do_sleep(), globals, mutex, runtime, switch_mutex_lock(), switch_mutex_unlock(), switch_thread_cond_wait(), and switch_runtime::timestamp.

Referenced by switch_sleep().

{
        switch_time_t want;
        if (!t)
                return;

        if (globals.RUNNING != 1 || !runtime.timestamp || globals.use_cond_yield != 1) {
                do_sleep(t);
                return;
        }
        want = runtime.timestamp + t;
        while (globals.RUNNING == 1 && globals.use_cond_yield == 1 && runtime.timestamp < want) {
                switch_mutex_lock(TIMER_MATRIX[1].mutex);
                if (runtime.timestamp < want) {
                        switch_thread_cond_wait(TIMER_MATRIX[1].cond, TIMER_MATRIX[1].mutex);
                }
                switch_mutex_unlock(TIMER_MATRIX[1].mutex);
        }


}

switch_status_t switch_console_set_alias

(

const char *

string

)

Definition at line 1916 of file switch_console.c.

References SCDB_TYPE_CORE_DB, switch_cache_db_get_type(), switch_cache_db_persistant_execute(), switch_cache_db_release_db_handle(), SWITCH_CHANNEL_LOG, switch_core_db_handle, switch_core_get_switchname(), SWITCH_LOG_ERROR, switch_log_printf(), switch_mprintf(), switch_safe_free, switch_separate_string(), SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

{
        char *mydata = NULL, *argv[3] = { 0 };
        int argc;
        switch_status_t status = SWITCH_STATUS_FALSE;

        if (string && (mydata = strdup(string))) {
                if ((argc = switch_separate_string(mydata, ' ', argv, (sizeof(argv) / sizeof(argv[0])))) >= 2) {
                        switch_cache_db_handle_t *db = NULL;
                        char *sql = NULL;

                        if (argc > 2 && !strcmp(argv[1], argv[2])) {
                                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Alias and command cannot be the same, this will cause loop!\n");
                                return SWITCH_STATUS_FALSE;
                        }

                        if (switch_core_db_handle(&db) != SWITCH_STATUS_SUCCESS) {
                                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Database Error\n");
                                free(mydata);
                                return SWITCH_STATUS_FALSE;
                        }
                        
                        if (!strcasecmp(argv[0], "stickyadd") && argc == 3) {
                                sql = switch_mprintf("delete from aliases where alias='%q' and hostname='%q'", argv[1], switch_core_get_switchname());
                                switch_cache_db_persistant_execute(db, sql, 5);
                                switch_safe_free(sql);
                                if (switch_cache_db_get_type(db) == SCDB_TYPE_CORE_DB) {
                                        sql = switch_mprintf("insert into aliases (sticky, alias, command, hostname) values (1, '%q','%q','%q')",
                                                                                 argv[1], argv[2], switch_core_get_switchname());
                                } else {
                                        sql = switch_mprintf("insert into aliases (sticky, alias, command, hostname) values (1, '%w','%w','%w')",
                                                                                 argv[1], argv[2], switch_core_get_switchname());
                                }
                                switch_cache_db_persistant_execute(db, sql, 5);
                                status = SWITCH_STATUS_SUCCESS;
                        } else if (!strcasecmp(argv[0], "add") && argc == 3) {
                                sql = switch_mprintf("delete from aliases where alias='%q' and hostname='%q'", argv[1], switch_core_get_switchname());
                                switch_cache_db_persistant_execute(db, sql, 5);
                                switch_safe_free(sql);
                                if (switch_cache_db_get_type(db) == SCDB_TYPE_CORE_DB) {
                                        sql = switch_mprintf("insert into aliases (sticky, alias, command, hostname) values (0, '%q','%q','%q')",
                                                                                 argv[1], argv[2], switch_core_get_switchname());
                                } else {
                                        sql = switch_mprintf("insert into aliases (sticky, alias, command, hostname) values (0, '%w','%w','%w')",
                                                                                 argv[1], argv[2], switch_core_get_switchname());
                                }
                                switch_cache_db_persistant_execute(db, sql, 5);
                                status = SWITCH_STATUS_SUCCESS;
                        } else if (!strcasecmp(argv[0], "del") && argc == 2) {
                                char *what = argv[1];
                                if (!strcasecmp(what, "*")) {
                                        sql = switch_mprintf("delete from aliases where hostname='%q'", switch_core_get_switchname());
                                        switch_cache_db_persistant_execute(db, sql, 1);
                                } else {
                                        sql = switch_mprintf("delete from aliases where alias='%q' and hostname='%q'", argv[1], switch_core_get_switchname());
                                        switch_cache_db_persistant_execute(db, sql, 5);
                                }
                                status = SWITCH_STATUS_SUCCESS;
                        }
                        switch_safe_free(sql);
                        switch_cache_db_release_db_handle(&db);
                }
        }

        switch_safe_free(mydata);

        return status;

}

switch_status_t switch_console_set_complete

(

const char *

string

)

Definition at line 1832 of file switch_console.c.

References switch_stream_handle::data, SCDB_TYPE_CORE_DB, SCF_USE_SQL, switch_core_dbtype(), switch_core_flags(), switch_core_get_hostname(), switch_core_sql_exec(), switch_safe_free, switch_separate_string(), SWITCH_STANDARD_STREAM, SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, switch_str_nil, switch_stream_handle::write_function, and zstr.

{
        char *mydata = NULL, *argv[11] = { 0 };
        int argc, x;
        switch_status_t status = SWITCH_STATUS_FALSE;
        switch_core_flag_t cflags = switch_core_flags();

        if (!(cflags & SCF_USE_SQL)) {
                return SWITCH_STATUS_FALSE;
        }

        if (string && (mydata = strdup(string))) {
                if ((argc = switch_separate_string(mydata, ' ', argv, (sizeof(argv) / sizeof(argv[0]))))) {
                        switch_stream_handle_t mystream = { 0 };
                        SWITCH_STANDARD_STREAM(mystream);
                        
                        if (!strcasecmp(argv[0], "stickyadd")) {
                                mystream.write_function(&mystream, "insert into complete values (1,");
                                for (x = 0; x < 10; x++) {
                                        if (argv[x + 1] && !strcasecmp(argv[x + 1], "_any_")) {
                                                mystream.write_function(&mystream, "%s", "'', ");
                                        } else {
                                                if (switch_core_dbtype() == SCDB_TYPE_CORE_DB) {
                                                        mystream.write_function(&mystream, "'%q', ", switch_str_nil(argv[x + 1]));
                                                } else {
                                                        mystream.write_function(&mystream, "'%w', ", switch_str_nil(argv[x + 1]));
                                                }
                                        }
                                }
                                mystream.write_function(&mystream, " '%s')", switch_core_get_hostname());
                                switch_core_sql_exec(mystream.data);
                                status = SWITCH_STATUS_SUCCESS;
                        } else if (!strcasecmp(argv[0], "add")) {
                                mystream.write_function(&mystream, "insert into complete values (0,");
                                for (x = 0; x < 10; x++) {
                                        if (argv[x + 1] && !strcasecmp(argv[x + 1], "_any_")) {
                                                mystream.write_function(&mystream, "%s", "'', ");
                                        } else {
                                                if (switch_core_dbtype() == SCDB_TYPE_CORE_DB) {
                                                        mystream.write_function(&mystream, "'%q', ", switch_str_nil(argv[x + 1]));
                                                } else {
                                                        mystream.write_function(&mystream, "'%w', ", switch_str_nil(argv[x + 1]));
                                                }
                                        }
                                }
                                mystream.write_function(&mystream, " '%s')", switch_core_get_hostname());

                                switch_core_sql_exec(mystream.data);
                                status = SWITCH_STATUS_SUCCESS;
                        } else if (!strcasecmp(argv[0], "del")) {
                                char *what = argv[1];
                                if (zstr(what)) {
                                        switch_safe_free(mystream.data);  
                                        switch_safe_free(mydata); 
                                        return SWITCH_STATUS_FALSE;
                                } else if (!strcasecmp(what, "*")) {
                                        mystream.write_function(&mystream, "delete from complete where hostname='%s'", switch_core_get_hostname());
                                        switch_core_sql_exec(mystream.data);
                                } else {
                                        mystream.write_function(&mystream, "delete from complete where ");
                                        for (x = 0; x < argc - 1; x++) {
                                                if (switch_core_dbtype() == SCDB_TYPE_CORE_DB) {
                                                        mystream.write_function(&mystream, "a%d = '%q'%q", x + 1, switch_str_nil(argv[x + 1]), x == argc - 2 ? "" : " and ");
                                                } else {
                                                        mystream.write_function(&mystream, "a%d = '%w'%w", x + 1, switch_str_nil(argv[x + 1]), x == argc - 2 ? "" : " and ");
                                                }
                                        }
                                        mystream.write_function(&mystream, " and hostname='%s'", switch_core_get_hostname());
                                        switch_core_sql_exec(mystream.data);
                                }
                                status = SWITCH_STATUS_SUCCESS;
                        }

                        switch_safe_free(mystream.data);
                }
        }

        switch_safe_free(mydata);

        return status;

}

switch_status_t switch_core_chat_deliver	(	const char *	dest_proto,
		switch_event_t **	message_event
	)

Definition at line 915 of file switch_loadable_module.c.

References chat_queue_message(), switch_event_add_header_string(), SWITCH_STACK_BOTTOM, and SWITCH_STATUS_SUCCESS.

{

        if (dest_proto) {
                switch_event_add_header_string(*message_event, SWITCH_STACK_BOTTOM, "dest_proto", dest_proto);
        }

        chat_queue_message(message_event);

        return SWITCH_STATUS_SUCCESS;
}

switch_status_t switch_core_chat_send	(	const char *	dest_proto,
		switch_event_t *	message_event
	)

Definition at line 900 of file switch_loadable_module.c.

References chat_queue_message(), switch_event_add_header_string(), switch_event_dup(), SWITCH_STACK_BOTTOM, and SWITCH_STATUS_SUCCESS.

Referenced by Event::chat_send().

{
        switch_event_t *dup;

        switch_event_dup(&dup, message_event);

        if (dest_proto) {
                switch_event_add_header_string(dup, SWITCH_STACK_BOTTOM, "dest_proto", dest_proto);
        }

        chat_queue_message(&dup);
        return SWITCH_STATUS_SUCCESS;
}

switch_status_t switch_core_chat_send_args	(	const char *	dest_proto,
		const char *	proto,
		const char *	from,
		const char *	to,
		const char *	subject,
		const char *	body,
		const char *	type,
		const char *	hint,
		switch_bool_t	blocking
	)

Definition at line 858 of file switch_loadable_module.c.

References chat_process_event(), chat_queue_message(), switch_event_add_body(), switch_event_add_header_string(), switch_event_create, SWITCH_EVENT_MESSAGE, SWITCH_STACK_BOTTOM, and SWITCH_STATUS_SUCCESS.

{
        switch_event_t *message_event;
        switch_status_t status;

        if (switch_event_create(&message_event, SWITCH_EVENT_MESSAGE) == SWITCH_STATUS_SUCCESS) {
                switch_event_add_header_string(message_event, SWITCH_STACK_BOTTOM, "proto", proto);
                switch_event_add_header_string(message_event, SWITCH_STACK_BOTTOM, "from", from);
                switch_event_add_header_string(message_event, SWITCH_STACK_BOTTOM, "to", to);
                switch_event_add_header_string(message_event, SWITCH_STACK_BOTTOM, "subject", subject);
                switch_event_add_header_string(message_event, SWITCH_STACK_BOTTOM, "type", type);
                switch_event_add_header_string(message_event, SWITCH_STACK_BOTTOM, "hint", hint);
                switch_event_add_header_string(message_event, SWITCH_STACK_BOTTOM, "skip_global_process", "true");
                if (blocking) {
                        switch_event_add_header_string(message_event, SWITCH_STACK_BOTTOM, "blocking", "true");
                }
                
                if (body) {
                        switch_event_add_body(message_event, "%s", body);
                }
        } else {
                abort();
        }       

        if (dest_proto) {
                switch_event_add_header_string(message_event, SWITCH_STACK_BOTTOM, "dest_proto", dest_proto);
        }

        
        if (blocking) {
                status = chat_process_event(&message_event);
        } else {
                chat_queue_message(&message_event);
                status = SWITCH_STATUS_SUCCESS;
        }

        return status;
        
}

FILE* switch_core_data_channel

(

switch_text_channel_t

channel

)

Retrieve a FILE stream of a given text channel name.

Parameters

channel

text channel enumeration

Returns

a FILE stream

Definition at line 263 of file switch_core.c.

References switch_runtime::console, SWITCH_CHANNEL_ID_LOG, and SWITCH_CHANNEL_ID_LOG_CLEAN.

Referenced by switch_console_printf(), and switch_log_vprintf().

{
        FILE *handle = stdout;

        switch (channel) {
        case SWITCH_CHANNEL_ID_LOG:
        case SWITCH_CHANNEL_ID_LOG_CLEAN:
                handle = runtime.console;
                break;
        default:
                handle = runtime.console;
                break;
        }

        return handle;
}

uint32_t switch_core_default_dtmf_duration

(

uint32_t

duration

)

Definition at line 1681 of file switch_core.c.

References switch_runtime::default_dtmf_duration, switch_runtime::max_dtmf_duration, switch_runtime::min_dtmf_duration, SWITCH_MAX_DTMF_DURATION, and SWITCH_MIN_DTMF_DURATION.

Referenced by inband_dtmf_generate_callback(), speech_thread(), switch_channel_dequeue_dtmf(), switch_channel_queue_dtmf(), switch_channel_queue_dtmf_string(), switch_core_session_ctl(), switch_core_session_recv_dtmf(), switch_core_session_send_dtmf(), switch_core_session_send_dtmf_string(), and switch_load_core_config().

{
        if (duration) {
                if (duration < SWITCH_MIN_DTMF_DURATION) {
                        duration = SWITCH_MIN_DTMF_DURATION;
                }
                if (duration > SWITCH_MAX_DTMF_DURATION) {
                        duration = SWITCH_MAX_DTMF_DURATION;
                }
                runtime.default_dtmf_duration = duration;

                if (duration < runtime.min_dtmf_duration) {
                        runtime.min_dtmf_duration = duration;
                }

                if (duration > runtime.max_dtmf_duration) {
                        runtime.max_dtmf_duration = duration;
                }

        }
        return runtime.default_dtmf_duration;
}

switch_core_flag_t switch_core_flags

(

void

)

return core flags

Returns

core flags

Definition at line 2852 of file switch_core.c.

References switch_runtime::flags.

Referenced by do_shutdown(), switch_console_expand_alias(), and switch_console_set_complete().

{
        return runtime.flags;
}

FILE* switch_core_get_console

(

void

)

Get the output console.

Returns

the FILE stream

Definition at line 230 of file switch_core.c.

References switch_runtime::console.

Referenced by switch_console_process(), and switch_log_init().

{
        return runtime.console;
}

double switch_core_idle_cpu

(

void

)

Definition at line 2448 of file switch_core_session.c.

References switch_runtime::profile_time, and runtime.

Referenced by send_heartbeat().

{
        return runtime.profile_time;
}

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

Launch a thread.

Referenced by switch_loadable_module_build_dynamic(), switch_loadable_module_load_module_ex(), and switch_loadable_module_runtime().

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.

Parameters

relative_oid	the relative oid of the operation.
action	the action to perform.
data	input/output string.
datalen	size in bytes of data.

Returns

SUCCESS on sucess.

Definition at line 2970 of file switch_core.c.

References switch_management_interface::management_function, switch_loadable_module_get_management_interface(), and SWITCH_STATUS_FALSE.

{
        const switch_management_interface_t *ptr;
        switch_status_t status = SWITCH_STATUS_FALSE;

        if ((ptr = switch_loadable_module_get_management_interface(relative_oid))) {
                status = ptr->management_function(relative_oid, action, data, datalen);
        }

        return status;
}

uint32_t switch_core_max_dtmf_duration

(

uint32_t

duration

)

Definition at line 1664 of file switch_core.c.

References switch_runtime::max_dtmf_duration, switch_runtime::min_dtmf_duration, SWITCH_MAX_DTMF_DURATION, and SWITCH_MIN_DTMF_DURATION.

Referenced by inband_dtmf_generate_callback(), switch_channel_dequeue_dtmf(), switch_channel_queue_dtmf(), switch_channel_queue_dtmf_string(), switch_core_session_ctl(), switch_core_session_recv_dtmf(), switch_core_session_send_dtmf(), switch_core_session_send_dtmf_string(), and switch_load_core_config().

{
        if (duration) {
                if (duration > SWITCH_MAX_DTMF_DURATION) {
                        duration = SWITCH_MAX_DTMF_DURATION;
                }
                if (duration < SWITCH_MIN_DTMF_DURATION) {
                        duration = SWITCH_MIN_DTMF_DURATION;
                }
                runtime.max_dtmf_duration = duration;
                if (duration < runtime.min_dtmf_duration) {
                        runtime.min_dtmf_duration = duration;
                }
        }
        return runtime.max_dtmf_duration;
}

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.

Parameters

total_ms	a number of milliseconds
duration	an object to store the results

Definition at line 2450 of file switch_core.c.

References memset().

Referenced by send_heartbeat().

{
        switch_time_t temp = total_ms / 1000;
        memset(duration, 0, sizeof(*duration));
        duration->mms = (uint32_t) (total_ms % 1000);
        duration->ms = (uint32_t) (temp % 1000);
        temp = temp / 1000;
        duration->sec = (uint32_t) (temp % 60);
        temp = temp / 60;
        duration->min = (uint32_t) (temp % 60);
        temp = temp / 60;
        duration->hr = (uint32_t) (temp % 24);
        temp = temp / 24;
        duration->day = (uint32_t) (temp % 365);
        duration->yr = (uint32_t) (temp / 365);
}

void switch_core_memory_reclaim

(

void

)

Definition at line 479 of file switch_core_memory.c.

References memory_manager, pool, SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, switch_log_printf(), switch_mutex_lock(), switch_mutex_unlock(), switch_queue_size(), switch_queue_trypop(), and SWITCH_STATUS_SUCCESS.

Referenced by pool_thread(), and switch_core_memory_reclaim_all().

{
#if !defined(PER_POOL_LOCK) && !defined(INSTANTLY_DESTROY_POOLS)
        switch_memory_pool_t *pool;
        void *pop = NULL;
        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "Returning %d recycled memory pool(s)\n",
                                          switch_queue_size(memory_manager.pool_recycle_queue) + switch_queue_size(memory_manager.pool_queue));

        while (switch_queue_trypop(memory_manager.pool_recycle_queue, &pop) == SWITCH_STATUS_SUCCESS) {
                pool = (switch_memory_pool_t *) pop;
                if (!pool) {
                        break;
                }
#ifdef USE_MEM_LOCK
                switch_mutex_lock(memory_manager.mem_lock);
#endif
                apr_pool_destroy(pool);
#ifdef USE_MEM_LOCK
                switch_mutex_unlock(memory_manager.mem_lock);
#endif
        }
#endif
        return;
}

void switch_core_memory_reclaim_all

(

void

)

Definition at line 2982 of file switch_core.c.

References switch_core_memory_reclaim(), switch_core_memory_reclaim_events(), and switch_core_memory_reclaim_logger().

Referenced by switch_core_session_ctl().

{
        switch_core_memory_reclaim_logger();
        switch_core_memory_reclaim_events();
        switch_core_memory_reclaim();
}

void switch_core_memory_reclaim_events

(

void

)

Definition at line 499 of file switch_event.c.

References SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, switch_log_printf(), switch_queue_size(), switch_queue_trypop(), and SWITCH_STATUS_SUCCESS.

Referenced by switch_core_memory_reclaim_all(), and switch_event_shutdown().

{
#ifdef SWITCH_EVENT_RECYCLE

        void *pop;
        int size;
        size = switch_queue_size(EVENT_RECYCLE_QUEUE);

        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "Returning %d recycled event(s) %d bytes\n", size, (int) sizeof(switch_event_t) * size);
        size = switch_queue_size(EVENT_HEADER_RECYCLE_QUEUE);
        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "Returning %d recycled event header(s) %d bytes\n",
                                          size, (int) sizeof(switch_event_header_t) * size);

        while (switch_queue_trypop(EVENT_HEADER_RECYCLE_QUEUE, &pop) == SWITCH_STATUS_SUCCESS && pop) {
                free(pop);
        }
        while (switch_queue_trypop(EVENT_RECYCLE_QUEUE, &pop) == SWITCH_STATUS_SUCCESS && pop) {
                free(pop);
        }
#else
        return;
#endif

}

void switch_core_memory_reclaim_logger

(

void

)

Definition at line 544 of file switch_log.c.

References SWITCH_CHANNEL_SESSION_LOG, SWITCH_LOG_CONSOLE, switch_log_node_free(), switch_log_printf(), switch_queue_size(), switch_queue_trypop(), and SWITCH_STATUS_SUCCESS.

Referenced by switch_core_memory_reclaim_all(), and switch_log_shutdown().

{
#ifdef SWITCH_LOG_RECYCLE
        void *pop;
        int size = switch_queue_size(LOG_RECYCLE_QUEUE);
        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_CONSOLE, "Returning %d recycled log node(s) %d bytes\n", size,
                                          (int) sizeof(switch_log_node_t) * size);
        while (switch_queue_trypop(LOG_RECYCLE_QUEUE, &pop) == SWITCH_STATUS_SUCCESS) {
                switch_log_node_free(&pop);
        }
#else
        return;
#endif

}

switch_status_t switch_core_mime_add_type	(	const char *	type,
		const char *	ext
	)

Definition at line 1220 of file switch_core.c.

References switch_runtime::mime_type_exts, switch_runtime::mime_types, switch_assert, switch_core_hash_find(), switch_core_hash_insert, switch_core_permanent_strdup, switch_separate_string(), SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

Referenced by load_mime_types().

{
        char *ptype = NULL;
        char *ext_list = NULL;
        int argc = 0;
        char *argv[20] = { 0 };
        int x;
        switch_status_t status = SWITCH_STATUS_FALSE;

        switch_assert(type);
        switch_assert(ext);

        ptype = switch_core_permanent_strdup(type);
        ext_list = strdup(ext);

        switch_assert(ext_list);

        /* Map each file extension to this MIME type if not already mapped.  Map the MIME type to the first file extension in the list if not already mapped. */
        if ((argc = switch_separate_string(ext_list, ' ', argv, (sizeof(argv) / sizeof(argv[0]))))) {
                int is_mapped_type = switch_core_hash_find(runtime.mime_type_exts, ptype) != NULL;
                for (x = 0; x < argc; x++) {
                        if (argv[x] && ptype) {
                                if (!switch_core_hash_find(runtime.mime_types, ext)) {
                                        switch_core_hash_insert(runtime.mime_types, argv[x], ptype);
                                }
                                if (!is_mapped_type) {
                                        switch_core_hash_insert(runtime.mime_type_exts, ptype, switch_core_permanent_strdup(argv[x]));
                                        is_mapped_type = 1;
                                }
                        }
                }

                status = SWITCH_STATUS_SUCCESS;
        }

        free(ext_list);

        return status;
}

const char* switch_core_mime_ext2type

(

const char *

ext

)

Definition at line 1199 of file switch_core.c.

References switch_runtime::mime_types, and switch_core_hash_find().

Referenced by switch_simple_email().

{
        if (!ext) {
                return NULL;
        }
        return (const char *) switch_core_hash_find(runtime.mime_types, ext);
}

switch_hash_index_t* switch_core_mime_index

(

void

)

Definition at line 1215 of file switch_core.c.

References switch_runtime::mime_types, and switch_core_hash_first.

{
        return switch_core_hash_first(runtime.mime_types);
}

const char* switch_core_mime_type2ext

(

const char *

type

)

Definition at line 1207 of file switch_core.c.

References switch_runtime::mime_type_exts, and switch_core_hash_find().

{
        if (!mime) {
                return NULL;
        }
        return (const char *) switch_core_hash_find(runtime.mime_type_exts, mime);
}

uint32_t switch_core_min_dtmf_duration

(

uint32_t

duration

)

Definition at line 1704 of file switch_core.c.

References switch_runtime::max_dtmf_duration, switch_runtime::min_dtmf_duration, SWITCH_MAX_DTMF_DURATION, and SWITCH_MIN_DTMF_DURATION.

Referenced by handle_rfc2833(), switch_channel_dequeue_dtmf(), switch_channel_queue_dtmf(), switch_channel_queue_dtmf_string(), switch_core_session_ctl(), switch_core_session_recv_dtmf(), switch_core_session_send_dtmf(), switch_core_session_send_dtmf_string(), switch_load_core_config(), switch_rtp_queue_rfc2833(), and switch_rtp_queue_rfc2833_in().

{
        if (duration) {
                if (duration < SWITCH_MIN_DTMF_DURATION) {
                        duration = SWITCH_MIN_DTMF_DURATION;
                }
                if (duration > SWITCH_MAX_DTMF_DURATION) {
                        duration = SWITCH_MAX_DTMF_DURATION;
                }

                runtime.min_dtmf_duration = duration;

                if (duration > runtime.max_dtmf_duration) {
                        runtime.max_dtmf_duration = duration;
                }
        }
        return runtime.min_dtmf_duration;
}

double switch_core_min_idle_cpu

(

double

new_limit

)

Definition at line 2438 of file switch_core_session.c.

References switch_runtime::min_idle_time, and runtime.

Referenced by switch_core_session_ctl(), and switch_load_core_config().

{
        if (new_limit >= 0) {
                runtime.min_idle_time = new_limit;
        }

        return runtime.min_idle_time;
}

switch_bool_t switch_core_ready

(

void

)

Determines if the core is ready to take calls.

Returns

SWITCH_TRUE or SWITCH_FALSE

Definition at line 2862 of file switch_core.c.

References SCF_NO_NEW_SESSIONS, SCF_SHUTTING_DOWN, SWITCH_FALSE, switch_test_flag, and SWITCH_TRUE.

Referenced by switch_core_session_ctl(), and switch_core_session_request_uuid().

{
        return (switch_test_flag((&runtime), SCF_SHUTTING_DOWN) || switch_test_flag((&runtime), SCF_NO_NEW_SESSIONS) == SCF_NO_NEW_SESSIONS) ? SWITCH_FALSE : SWITCH_TRUE;
}

switch_bool_t switch_core_ready_inbound

(

void

)

Determines if the core is ready to take inbound calls.

Returns

SWITCH_TRUE or SWITCH_FALSE

Definition at line 2867 of file switch_core.c.

References SCF_NO_NEW_INBOUND_SESSIONS, SCF_SHUTTING_DOWN, SWITCH_FALSE, switch_test_flag, and SWITCH_TRUE.

Referenced by switch_core_session_request_uuid().

{
        return (switch_test_flag((&runtime), SCF_SHUTTING_DOWN) || switch_test_flag((&runtime), SCF_NO_NEW_INBOUND_SESSIONS)) ? SWITCH_FALSE : SWITCH_TRUE;
}

switch_bool_t switch_core_ready_outbound

(

void

)

Determines if the core is ready to place outbound calls.

Returns

SWITCH_TRUE or SWITCH_FALSE

Definition at line 2872 of file switch_core.c.

References SCF_NO_NEW_OUTBOUND_SESSIONS, SCF_SHUTTING_DOWN, SWITCH_FALSE, switch_test_flag, and SWITCH_TRUE.

Referenced by switch_core_session_request_uuid().

{
        return (switch_test_flag((&runtime), SCF_SHUTTING_DOWN) || switch_test_flag((&runtime), SCF_NO_NEW_OUTBOUND_SESSIONS)) ? SWITCH_FALSE : SWITCH_TRUE;
}

switch_bool_t switch_core_running

(

void

)

Definition at line 2857 of file switch_core.c.

References switch_runtime::running, SWITCH_FALSE, and SWITCH_TRUE.

Referenced by running().

{
        return runtime.running ? SWITCH_TRUE : SWITCH_FALSE;
}

void switch_core_runtime_loop

(

int

bg

)

Run endlessly until the system is shutdown.

Parameters

bg	divert console to the background

Definition at line 1174 of file switch_core.c.

References FALSE, switch_runtime::running, switch_console_loop(), switch_snprintf(), and switch_yield.

Referenced by main().

{
#ifdef WIN32
        HANDLE shutdown_event;
        char path[256] = "";
#endif
        if (bg) {
#ifdef WIN32
                switch_snprintf(path, sizeof(path), "Global\\Freeswitch.%d", getpid());
                shutdown_event = CreateEvent(NULL, FALSE, FALSE, path);
                if (shutdown_event) {
                        WaitForSingleObject(shutdown_event, INFINITE);
                }
#else
                runtime.running = 1;
                while (runtime.running) {
                        switch_yield(1000000);
                }
#endif
        } else {
                /* wait for console input */
                switch_console_loop();
        }
}

uint8_t switch_core_session_check_interface	(	switch_core_session_t *	session,
		const switch_endpoint_interface_t *	endpoint_interface
	)

Checks if a session is using a specific endpoint.

Parameters

session	the session
endpoint_interface	interface of the endpoint to check

Returns

TRUE or FALSE

Definition at line 2414 of file switch_core_session.c.

References switch_assert.

{
        switch_assert(session != NULL);
        switch_assert(endpoint_interface != NULL);

        return (uint8_t) (session->endpoint_interface == endpoint_interface);
}

uint8_t switch_core_session_compare	(	switch_core_session_t *	a,
		switch_core_session_t *	b
	)

Checks if 2 sessions are using the same endpoint module.

Parameters

a	the first session
b	the second session

Returns

TRUE or FALSE

Definition at line 2406 of file switch_core_session.c.

References switch_assert.

{
        switch_assert(a != NULL);
        switch_assert(b != NULL);

        return (uint8_t) (a->endpoint_interface == b->endpoint_interface);
}

int32_t switch_core_session_ctl	(	switch_session_ctl_t	cmd,
		void *	val
	)

send a control message to the core

Parameters

cmd	the command
val	the command arguement (if needed)

Returns

0 on success nonzero on error

Definition at line 2528 of file switch_core.c.

References switch_runtime::debug_level, handle_SIGHUP(), switch_runtime::hard_log_level, switch_runtime::running, SCF_API_EXPANSION, SCF_DEBUG_SQL, SCF_NO_NEW_INBOUND_SESSIONS, SCF_NO_NEW_OUTBOUND_SESSIONS, SCF_NO_NEW_SESSIONS, SCF_RESTART, SCF_SHUTDOWN_REQUESTED, SCF_SHUTTING_DOWN, SCF_THREADED_SYSTEM_EXEC, SCF_VERBOSE_EVENTS, SCSC_API_EXPANSION, SCSC_CALIBRATE_CLOCK, SCSC_CANCEL_SHUTDOWN, SCSC_CHECK_RUNNING, SCSC_CRASH, SCSC_DEBUG_LEVEL, SCSC_DEBUG_SQL, SCSC_DEFAULT_DTMF_DURATION, SCSC_FLUSH_DB_HANDLES, SCSC_HUPALL, SCSC_LAST_SPS, SCSC_LOGLEVEL, SCSC_MAX_DTMF_DURATION, SCSC_MAX_SESSIONS, SCSC_MIN_DTMF_DURATION, SCSC_MIN_IDLE_CPU, SCSC_PAUSE_ALL, SCSC_PAUSE_CHECK, SCSC_PAUSE_INBOUND, SCSC_PAUSE_INBOUND_CHECK, SCSC_PAUSE_OUTBOUND, SCSC_PAUSE_OUTBOUND_CHECK, SCSC_READY_CHECK, SCSC_RECLAIM, SCSC_RECOVER, SCSC_REINCARNATE_NOW, SCSC_SAVE_HISTORY, SCSC_SEND_SIGHUP, SCSC_SESSIONS_PEAK, SCSC_SESSIONS_PEAK_FIVEMIN, SCSC_SHUTDOWN, SCSC_SHUTDOWN_ASAP, SCSC_SHUTDOWN_CHECK, SCSC_SHUTDOWN_ELEGANT, SCSC_SHUTDOWN_NOW, SCSC_SPS, SCSC_SPS_PEAK, SCSC_SPS_PEAK_FIVEMIN, SCSC_SQL, SCSC_SYNC_CLOCK, SCSC_SYNC_CLOCK_WHEN_IDLE, SCSC_THREADED_SYSTEM_EXEC, SCSC_VERBOSE_EVENTS, switch_runtime::sessions_peak, switch_runtime::sessions_peak_fivemin, switch_runtime::sps_last, switch_runtime::sps_peak, switch_runtime::sps_peak_fivemin, switch_runtime::sps_total, switch_cache_db_flush_handles(), SWITCH_CAUSE_MANAGER_REQUEST, SWITCH_CHANNEL_LOG, switch_clear_flag, switch_console_save_history(), switch_core_default_dtmf_duration(), switch_core_max_dtmf_duration(), switch_core_memory_reclaim_all(), switch_core_min_dtmf_duration(), switch_core_min_idle_cpu(), switch_core_ready(), switch_core_recovery_flush(), switch_core_recovery_recover(), switch_core_session_count(), switch_core_session_hupall(), switch_core_session_limit(), switch_core_session_sync_clock(), switch_core_sqldb_pause(), switch_core_sqldb_resume(), SWITCH_LOG_CRIT, SWITCH_LOG_DEBUG, SWITCH_LOG_INFO, switch_log_printf(), SWITCH_LOG_WARNING, switch_mutex_lock(), switch_mutex_unlock(), switch_safe_free, switch_set_flag, SWITCH_STATUS_RESTART, switch_test_flag, switch_time_calibrate_clock(), switch_time_sync(), switch_yield, switch_runtime::throttle_mutex, and zstr.

Referenced by handle_SIGILL(), switch_channel_event_set_extended_data(), switch_console_loop(), and switch_load_core_config().

{
        int *intval = (int *) val;
        int oldintval = 0, newintval = 0;
        
        if (intval) {
                oldintval = *intval;
        }

        if (switch_test_flag((&runtime), SCF_SHUTTING_DOWN)) {
                return -1;
        }

        switch (cmd) {
        case SCSC_RECOVER:
                {
                        char *arg = (char *) val;
                        char *tech = NULL, *prof = NULL;
                        int r, flush = 0;

                        if (!zstr(arg)) {
                                tech = strdup(arg);
                                
                                if ((prof = strchr(tech, ':'))) {
                                        *prof++ = '\0';
                                }

                                if (!strcasecmp(tech, "flush")) {
                                        flush++;
                                        tech = NULL;

                                        if (prof) {
                                                tech = prof;
                                                if ((prof = strchr(tech, ':'))) {
                                                        *prof++ = '\0';
                                                }
                                        }
                                }

                        }

                        if (flush) {
                                switch_core_recovery_flush(tech, prof);
                                r = -1;
                        } else {
                                r = switch_core_recovery_recover(tech, prof);
                        }

                        switch_safe_free(tech);
                        return r;

                }
                break;
        case SCSC_DEBUG_SQL:
                {
                        if (switch_test_flag((&runtime), SCF_DEBUG_SQL)) {
                                switch_clear_flag((&runtime), SCF_DEBUG_SQL);
                                newintval = 0;
                        } else {
                                switch_set_flag((&runtime), SCF_DEBUG_SQL);
                                newintval = 1;
                        }
                }
                break;
        case SCSC_VERBOSE_EVENTS:
                if (intval) {
                        if (oldintval > -1) {
                                if (oldintval) {
                                        switch_set_flag((&runtime), SCF_VERBOSE_EVENTS);
                                } else {
                                        switch_clear_flag((&runtime), SCF_VERBOSE_EVENTS);
                                }
                        }
                        newintval = switch_test_flag((&runtime), SCF_VERBOSE_EVENTS);
                }
                break;
        case SCSC_API_EXPANSION:
                if (intval) {
                        if (oldintval > -1) {
                                if (oldintval) {
                                        switch_set_flag((&runtime), SCF_API_EXPANSION);
                                } else {
                                        switch_clear_flag((&runtime), SCF_API_EXPANSION);
                                }
                        }
                        newintval = switch_test_flag((&runtime), SCF_API_EXPANSION);
                }
                break;
        case SCSC_THREADED_SYSTEM_EXEC:
                if (intval) {
                        if (oldintval > -1) {
                                if (oldintval) {
                                        switch_set_flag((&runtime), SCF_THREADED_SYSTEM_EXEC);
                                } else {
                                        switch_clear_flag((&runtime), SCF_THREADED_SYSTEM_EXEC);
                                }
                        }
                        newintval = switch_test_flag((&runtime), SCF_THREADED_SYSTEM_EXEC);
                }
                break;
        case SCSC_CALIBRATE_CLOCK:
                switch_time_calibrate_clock();
                break;
        case SCSC_FLUSH_DB_HANDLES:
                switch_cache_db_flush_handles();
                break;
        case SCSC_SEND_SIGHUP:
                handle_SIGHUP(1);
                break;
        case SCSC_SYNC_CLOCK:
                switch_time_sync();
                newintval = 0;
                break;
        case SCSC_SYNC_CLOCK_WHEN_IDLE:
                newintval = switch_core_session_sync_clock();
                break;
        case SCSC_SQL:
                if (oldintval) {
                        switch_core_sqldb_resume();
                } else {
                        switch_core_sqldb_pause();
                }
                break;
        case SCSC_PAUSE_ALL:
                if (oldintval) {
                        switch_set_flag((&runtime), SCF_NO_NEW_SESSIONS);
                } else {
                        switch_clear_flag((&runtime), SCF_NO_NEW_SESSIONS);
                }
                break;
        case SCSC_PAUSE_INBOUND:
                if (oldintval) {
                        switch_set_flag((&runtime), SCF_NO_NEW_INBOUND_SESSIONS);
                } else {
                        switch_clear_flag((&runtime), SCF_NO_NEW_INBOUND_SESSIONS);
                }
                break;
        case SCSC_PAUSE_OUTBOUND:
                if (oldintval) {
                        switch_set_flag((&runtime), SCF_NO_NEW_OUTBOUND_SESSIONS);
                } else {
                        switch_clear_flag((&runtime), SCF_NO_NEW_OUTBOUND_SESSIONS);
                }
                break;
        case SCSC_HUPALL:
                switch_core_session_hupall(SWITCH_CAUSE_MANAGER_REQUEST);
                break;
        case SCSC_CANCEL_SHUTDOWN:
                switch_clear_flag((&runtime), SCF_SHUTDOWN_REQUESTED);
                break;
        case SCSC_SAVE_HISTORY:
                switch_console_save_history();
                break;
        case SCSC_CRASH:
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Declinatio Mortuus Obfirmo!\n");
                switch_console_save_history();
                abort();
                break;
        case SCSC_SHUTDOWN_NOW:
                switch_console_save_history();
                exit(0);
                break;
        case SCSC_REINCARNATE_NOW:
                switch_console_save_history();
                exit(SWITCH_STATUS_RESTART);
                break;
        case SCSC_SHUTDOWN_ELEGANT:
        case SCSC_SHUTDOWN_ASAP:
                {
                        int x = 19;
                        uint32_t count;

                        switch_set_flag((&runtime), SCF_SHUTDOWN_REQUESTED);
                        if (cmd == SCSC_SHUTDOWN_ASAP) {
                                switch_set_flag((&runtime), SCF_NO_NEW_SESSIONS);
                        }

                        while (runtime.running && switch_test_flag((&runtime), SCF_SHUTDOWN_REQUESTED) && (count = switch_core_session_count())) {
                                switch_yield(500000);
                                if (++x == 20) {
                                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING,
                                                                          "Shutdown in progress, %u session(s) remain.\nShutting down %s\n",
                                                                          count, cmd == SCSC_SHUTDOWN_ASAP ? "ASAP" : "once there are no active calls.");
                                        x = 0;
                                }
                        }

                        if (switch_test_flag((&runtime), SCF_SHUTDOWN_REQUESTED)) {
                                switch_set_flag((&runtime), SCF_NO_NEW_SESSIONS);
#ifdef _MSC_VER
                                win_shutdown();
#endif

                                if (oldintval) {
                                        switch_set_flag((&runtime), SCF_RESTART);
                                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "Restarting\n");
                                } else {
                                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "Shutting down\n");
#ifdef _MSC_VER
                                        fclose(stdin);
#endif
                                }
                                runtime.running = 0;
                        } else {
                                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "Shutdown Cancelled\n");
                                switch_clear_flag((&runtime), SCF_NO_NEW_SESSIONS);
                        }
                }
                break;
        case SCSC_PAUSE_CHECK:
                newintval = !!(switch_test_flag((&runtime), SCF_NO_NEW_SESSIONS) == SCF_NO_NEW_SESSIONS);
                break;
        case SCSC_PAUSE_INBOUND_CHECK:
                newintval = !!switch_test_flag((&runtime), SCF_NO_NEW_INBOUND_SESSIONS);
                break;
        case SCSC_PAUSE_OUTBOUND_CHECK:
                newintval = !!switch_test_flag((&runtime), SCF_NO_NEW_OUTBOUND_SESSIONS);
                break;
        case SCSC_READY_CHECK:
                newintval = switch_core_ready();
                break;
        case SCSC_SHUTDOWN_CHECK:
                newintval = !!switch_test_flag((&runtime), SCF_SHUTDOWN_REQUESTED);
                break;
        case SCSC_SHUTDOWN:

#ifdef _MSC_VER
                win_shutdown();
#endif

                if (oldintval) {
                        switch_set_flag((&runtime), SCF_RESTART);
                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "Restarting\n");
                } else {
                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "Shutting down\n");
#ifdef _MSC_VER
                        fclose(stdin);
#endif
                }
                runtime.running = 0;
                break;
        case SCSC_CHECK_RUNNING:
                newintval = runtime.running;
                break;
        case SCSC_LOGLEVEL:
                if (oldintval > -1) {
                        runtime.hard_log_level = oldintval;
                }

                if (runtime.hard_log_level > SWITCH_LOG_DEBUG) {
                        runtime.hard_log_level = SWITCH_LOG_DEBUG;
                }
                newintval = runtime.hard_log_level;
                break;
        case SCSC_DEBUG_LEVEL:
                if (oldintval > -1) {
                        if (oldintval > 10)
                                newintval = 10;
                        runtime.debug_level = oldintval;
                }
                newintval = runtime.debug_level;
                break;
        case SCSC_MIN_IDLE_CPU:
                {
                        double *dval = (double *) val;
                        if (dval) {
                                *dval = switch_core_min_idle_cpu(*dval);
                        }
                        intval = NULL;
                }
                break;
        case SCSC_MAX_SESSIONS:
                newintval = switch_core_session_limit(oldintval);
                break;
        case SCSC_LAST_SPS:
                newintval = runtime.sps_last;
                break;
        case SCSC_SPS_PEAK:
                if (oldintval == -1) {
                        runtime.sps_peak = 0;
                }
                newintval = runtime.sps_peak;
                break;
        case SCSC_SPS_PEAK_FIVEMIN:
                newintval = runtime.sps_peak_fivemin;
                break;
        case SCSC_SESSIONS_PEAK:
                newintval = runtime.sessions_peak;
                break;
        case SCSC_SESSIONS_PEAK_FIVEMIN:
                newintval = runtime.sessions_peak_fivemin;
                break;
        case SCSC_MAX_DTMF_DURATION:
                newintval = switch_core_max_dtmf_duration(oldintval);
                break;
        case SCSC_MIN_DTMF_DURATION:
                newintval = switch_core_min_dtmf_duration(oldintval);
                break;
        case SCSC_DEFAULT_DTMF_DURATION:
                newintval = switch_core_default_dtmf_duration(oldintval);
                break;
        case SCSC_SPS:
                switch_mutex_lock(runtime.throttle_mutex);
                if (oldintval > 0) {
                        runtime.sps_total = oldintval;
                }
                newintval = runtime.sps_total;
                switch_mutex_unlock(runtime.throttle_mutex);
                break;

        case SCSC_RECLAIM:
                switch_core_memory_reclaim_all();
                newintval = 0;
                break;
        }

        if (intval) {
                *intval = newintval;
        }


        return 0;
}

switch_status_t switch_core_session_set_video_read_callback	(	switch_core_session_t *	session,
		switch_core_video_thread_callback_func_t	func,
		void *	user_data
	)

Definition at line 11511 of file switch_core_media.c.

References switch_media_handle_s::control_mutex, switch_core_session_start_video_thread(), switch_mutex_lock(), switch_mutex_unlock(), SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

Referenced by eavesdrop_callback().

{
        switch_status_t status = SWITCH_STATUS_SUCCESS;
        switch_media_handle_t *smh;

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

        switch_mutex_lock(smh->control_mutex);
        if (!func) {
                session->video_read_callback = NULL;
                session->video_read_user_data = NULL;
        } else if (session->video_read_callback) {
                status = SWITCH_STATUS_FALSE;
        } else {
                session->video_read_callback = func;
                session->video_read_user_data = user_data;
        }

        switch_core_session_start_video_thread(session);
        switch_mutex_unlock(smh->control_mutex);

        return status;
}

switch_status_t switch_core_session_video_read_callback	(	switch_core_session_t *	session,
		switch_frame_t *	frame
	)

Definition at line 11538 of file switch_core_media.c.

References switch_media_handle_s::control_mutex, switch_mutex_lock(), switch_mutex_unlock(), SWITCH_STATUS_CONTINUE, and SWITCH_STATUS_FALSE.

Referenced by switch_core_session_read_video_frame().

{
        switch_media_handle_t *smh;
        switch_status_t status = SWITCH_STATUS_CONTINUE;

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

        switch_mutex_lock(smh->control_mutex);

        if (session->video_read_callback) {
                status = session->video_read_callback(session, frame, session->video_read_user_data);
        }

        switch_mutex_unlock(smh->control_mutex);

        return status;
}

switch_status_t switch_core_set_console

(

const char *

console

)

Set the output console to the desired file.

Parameters

console

the file path

Definition at line 220 of file switch_core.c.

References switch_runtime::console, SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

{
        if ((runtime.console = fopen(console, "a")) == 0) {
                fprintf(stderr, "Cannot open output file %s.\n", console);
                return SWITCH_STATUS_FALSE;
        }

        return SWITCH_STATUS_SUCCESS;
}

void switch_core_set_globals

(

void

)

Initiate Globals.

Definition at line 620 of file switch_core.c.

References switch_directories::base_dir, BUFSIZE, switch_directories::cache_dir, switch_directories::certs_dir, switch_directories::conf_dir, switch_filenames::conf_name, switch_directories::data_dir, switch_directories::db_dir, switch_directories::fonts_dir, switch_directories::grammar_dir, switch_directories::htdocs_dir, switch_directories::images_dir, switch_directories::lib_dir, switch_directories::localstate_dir, switch_directories::log_dir, switch_directories::mod_dir, switch_directories::recordings_dir, switch_directories::run_dir, switch_directories::script_dir, switch_directories::sounds_dir, switch_directories::storage_dir, switch_assert, SWITCH_CACHE_DIR, SWITCH_CERTS_DIR, SWITCH_CONF_DIR, SWITCH_DATA_DIR, SWITCH_DB_DIR, SWITCH_FONTS_DIR, SWITCH_GLOBAL_dirs, SWITCH_GLOBAL_filenames, SWITCH_GRAMMAR_DIR, SWITCH_HTDOCS_DIR, SWITCH_IMAGES_DIR, SWITCH_LOCALSTATE_DIR, SWITCH_LOG_DIR, SWITCH_MOD_DIR, SWITCH_PATH_SEPARATOR, SWITCH_PREFIX_DIR, SWITCH_RECORDINGS_DIR, SWITCH_RUN_DIR, SWITCH_SCRIPT_DIR, switch_snprintf(), SWITCH_SOUNDS_DIR, SWITCH_STORAGE_DIR, switch_string_replace(), and switch_directories::temp_dir.

Referenced by freeswitch_kill_background(), fs_core_set_globals(), main(), and switch_core_init().

{
#define BUFSIZE 1024
#ifdef WIN32
        char lpPathBuffer[BUFSIZE];
        DWORD dwBufSize = BUFSIZE;
        char base_dir[1024];
        char *lastbacklash;
        char *tmp;

        GetModuleFileName(NULL, base_dir, BUFSIZE);
        lastbacklash = strrchr(base_dir, '\\');
        base_dir[(lastbacklash - base_dir)] = '\0';
        /* set base_dir as cwd, to be able to use relative paths in scripting languages (e.g. mod_lua) when FS is running as a service or while debugging FS using visual studio */
        SetCurrentDirectory(base_dir);
        tmp = switch_string_replace(base_dir, "\\", "/");
        strcpy(base_dir, tmp);
        free(tmp);

#else
        char base_dir[1024] = SWITCH_PREFIX_DIR;
#endif

        /* Order of precedence for, eg, rundir:
         *   -run
         *   -base
         *   --with-rundir
         *   --prefix
         */

        if (!SWITCH_GLOBAL_dirs.mod_dir && (SWITCH_GLOBAL_dirs.mod_dir = (char *) malloc(BUFSIZE))) {
                if (SWITCH_GLOBAL_dirs.base_dir)
                        switch_snprintf(SWITCH_GLOBAL_dirs.mod_dir, BUFSIZE, "%s%smod", SWITCH_GLOBAL_dirs.base_dir, SWITCH_PATH_SEPARATOR);
                else
#ifdef SWITCH_MOD_DIR
                        switch_snprintf(SWITCH_GLOBAL_dirs.mod_dir, BUFSIZE, "%s", SWITCH_MOD_DIR);
#else
                        switch_snprintf(SWITCH_GLOBAL_dirs.mod_dir, BUFSIZE, "%s%smod", base_dir, SWITCH_PATH_SEPARATOR);
#endif
        }

        if (!SWITCH_GLOBAL_dirs.lib_dir && (SWITCH_GLOBAL_dirs.lib_dir = (char *) malloc(BUFSIZE))) {
                if (SWITCH_GLOBAL_dirs.base_dir)
                        switch_snprintf(SWITCH_GLOBAL_dirs.lib_dir, BUFSIZE, "%s%slib", SWITCH_GLOBAL_dirs.base_dir, SWITCH_PATH_SEPARATOR);
                else
#ifdef SWITCH_LIB_DIR
                        switch_snprintf(SWITCH_GLOBAL_dirs.lib_dir, BUFSIZE, "%s", SWITCH_LIB_DIR);
#else
                        switch_snprintf(SWITCH_GLOBAL_dirs.lib_dir, BUFSIZE, "%s%slib", base_dir, SWITCH_PATH_SEPARATOR);
#endif
        }

        if (!SWITCH_GLOBAL_dirs.conf_dir && (SWITCH_GLOBAL_dirs.conf_dir = (char *) malloc(BUFSIZE))) {
                if (SWITCH_GLOBAL_dirs.base_dir)
                        switch_snprintf(SWITCH_GLOBAL_dirs.conf_dir, BUFSIZE, "%s%sconf", SWITCH_GLOBAL_dirs.base_dir, SWITCH_PATH_SEPARATOR);
                else
#ifdef SWITCH_CONF_DIR
                        switch_snprintf(SWITCH_GLOBAL_dirs.conf_dir, BUFSIZE, "%s", SWITCH_CONF_DIR);
#else
                        switch_snprintf(SWITCH_GLOBAL_dirs.conf_dir, BUFSIZE, "%s%sconf", base_dir, SWITCH_PATH_SEPARATOR);
#endif
        }

        if (!SWITCH_GLOBAL_dirs.log_dir && (SWITCH_GLOBAL_dirs.log_dir = (char *) malloc(BUFSIZE))) {
                if (SWITCH_GLOBAL_dirs.base_dir)
                        switch_snprintf(SWITCH_GLOBAL_dirs.log_dir, BUFSIZE, "%s%slog", SWITCH_GLOBAL_dirs.base_dir, SWITCH_PATH_SEPARATOR);
                else
#ifdef SWITCH_LOG_DIR
                        switch_snprintf(SWITCH_GLOBAL_dirs.log_dir, BUFSIZE, "%s", SWITCH_LOG_DIR);
#else
                        switch_snprintf(SWITCH_GLOBAL_dirs.log_dir, BUFSIZE, "%s%slog", base_dir, SWITCH_PATH_SEPARATOR);
#endif
        }

        if (!SWITCH_GLOBAL_dirs.run_dir && (SWITCH_GLOBAL_dirs.run_dir = (char *) malloc(BUFSIZE))) {
                if (SWITCH_GLOBAL_dirs.base_dir)
                        switch_snprintf(SWITCH_GLOBAL_dirs.run_dir, BUFSIZE, "%s%srun", SWITCH_GLOBAL_dirs.base_dir, SWITCH_PATH_SEPARATOR);
                else
#ifdef SWITCH_RUN_DIR
                        switch_snprintf(SWITCH_GLOBAL_dirs.run_dir, BUFSIZE, "%s", SWITCH_RUN_DIR);
#else
                        switch_snprintf(SWITCH_GLOBAL_dirs.run_dir, BUFSIZE, "%s%srun", base_dir, SWITCH_PATH_SEPARATOR);
#endif
        }

        if (!SWITCH_GLOBAL_dirs.recordings_dir && (SWITCH_GLOBAL_dirs.recordings_dir = (char *) malloc(BUFSIZE))) {
                if (SWITCH_GLOBAL_dirs.base_dir)
                        switch_snprintf(SWITCH_GLOBAL_dirs.recordings_dir, BUFSIZE, "%s%srecordings", SWITCH_GLOBAL_dirs.base_dir, SWITCH_PATH_SEPARATOR);
                else
#ifdef SWITCH_RECORDINGS_DIR
                        switch_snprintf(SWITCH_GLOBAL_dirs.recordings_dir, BUFSIZE, "%s", SWITCH_RECORDINGS_DIR);
#else
                        switch_snprintf(SWITCH_GLOBAL_dirs.recordings_dir, BUFSIZE, "%s%srecordings", base_dir, SWITCH_PATH_SEPARATOR);
#endif
        }

        if (!SWITCH_GLOBAL_dirs.sounds_dir && (SWITCH_GLOBAL_dirs.sounds_dir = (char *) malloc(BUFSIZE))) {
                if (SWITCH_GLOBAL_dirs.base_dir)
                        switch_snprintf(SWITCH_GLOBAL_dirs.sounds_dir, BUFSIZE, "%s%ssounds", SWITCH_GLOBAL_dirs.base_dir, SWITCH_PATH_SEPARATOR);
                else
#ifdef SWITCH_SOUNDS_DIR
                        switch_snprintf(SWITCH_GLOBAL_dirs.sounds_dir, BUFSIZE, "%s", SWITCH_SOUNDS_DIR);
#else
                        switch_snprintf(SWITCH_GLOBAL_dirs.sounds_dir, BUFSIZE, "%s%ssounds", base_dir, SWITCH_PATH_SEPARATOR);
#endif
        }

        if (!SWITCH_GLOBAL_dirs.storage_dir && (SWITCH_GLOBAL_dirs.storage_dir = (char *) malloc(BUFSIZE))) {
                if (SWITCH_GLOBAL_dirs.base_dir)
                        switch_snprintf(SWITCH_GLOBAL_dirs.storage_dir, BUFSIZE, "%s%sstorage", SWITCH_GLOBAL_dirs.base_dir, SWITCH_PATH_SEPARATOR);
                else
#ifdef SWITCH_STORAGE_DIR
                        switch_snprintf(SWITCH_GLOBAL_dirs.storage_dir, BUFSIZE, "%s", SWITCH_STORAGE_DIR);
#else
                        switch_snprintf(SWITCH_GLOBAL_dirs.storage_dir, BUFSIZE, "%s%sstorage", base_dir, SWITCH_PATH_SEPARATOR);
#endif
        }

        if (!SWITCH_GLOBAL_dirs.cache_dir && (SWITCH_GLOBAL_dirs.cache_dir = (char *) malloc(BUFSIZE))) {
                if (SWITCH_GLOBAL_dirs.base_dir)
                        switch_snprintf(SWITCH_GLOBAL_dirs.cache_dir, BUFSIZE, "%s%scache", SWITCH_GLOBAL_dirs.base_dir, SWITCH_PATH_SEPARATOR);
                else
#ifdef SWITCH_CACHE_DIR
                        switch_snprintf(SWITCH_GLOBAL_dirs.cache_dir, BUFSIZE, "%s", SWITCH_CACHE_DIR);
#else
                        switch_snprintf(SWITCH_GLOBAL_dirs.cache_dir, BUFSIZE, "%s%scache", base_dir, SWITCH_PATH_SEPARATOR);
#endif
        }

        if (!SWITCH_GLOBAL_dirs.db_dir && (SWITCH_GLOBAL_dirs.db_dir = (char *) malloc(BUFSIZE))) {
                if (SWITCH_GLOBAL_dirs.base_dir)
                        switch_snprintf(SWITCH_GLOBAL_dirs.db_dir, BUFSIZE, "%s%sdb", SWITCH_GLOBAL_dirs.base_dir, SWITCH_PATH_SEPARATOR);
                else
#ifdef SWITCH_DB_DIR
                        switch_snprintf(SWITCH_GLOBAL_dirs.db_dir, BUFSIZE, "%s", SWITCH_DB_DIR);
#else
                        switch_snprintf(SWITCH_GLOBAL_dirs.db_dir, BUFSIZE, "%s%sdb", base_dir, SWITCH_PATH_SEPARATOR);
#endif
        }

        if (!SWITCH_GLOBAL_dirs.script_dir && (SWITCH_GLOBAL_dirs.script_dir = (char *) malloc(BUFSIZE))) {
                if (SWITCH_GLOBAL_dirs.base_dir)
                        switch_snprintf(SWITCH_GLOBAL_dirs.script_dir, BUFSIZE, "%s%sscripts", SWITCH_GLOBAL_dirs.base_dir, SWITCH_PATH_SEPARATOR);
                else
#ifdef SWITCH_SCRIPT_DIR
                        switch_snprintf(SWITCH_GLOBAL_dirs.script_dir, BUFSIZE, "%s", SWITCH_SCRIPT_DIR);
#else
                        switch_snprintf(SWITCH_GLOBAL_dirs.script_dir, BUFSIZE, "%s%sscripts", base_dir, SWITCH_PATH_SEPARATOR);
#endif
        }

        if (!SWITCH_GLOBAL_dirs.htdocs_dir && (SWITCH_GLOBAL_dirs.htdocs_dir = (char *) malloc(BUFSIZE))) {
                if (SWITCH_GLOBAL_dirs.base_dir)
                        switch_snprintf(SWITCH_GLOBAL_dirs.htdocs_dir, BUFSIZE, "%s%shtdocs", SWITCH_GLOBAL_dirs.base_dir, SWITCH_PATH_SEPARATOR);
                else
#ifdef SWITCH_HTDOCS_DIR
                        switch_snprintf(SWITCH_GLOBAL_dirs.htdocs_dir, BUFSIZE, "%s", SWITCH_HTDOCS_DIR);
#else
                        switch_snprintf(SWITCH_GLOBAL_dirs.htdocs_dir, BUFSIZE, "%s%shtdocs", base_dir, SWITCH_PATH_SEPARATOR);
#endif
        }

        if (!SWITCH_GLOBAL_dirs.grammar_dir && (SWITCH_GLOBAL_dirs.grammar_dir = (char *) malloc(BUFSIZE))) {
                if (SWITCH_GLOBAL_dirs.base_dir)
                        switch_snprintf(SWITCH_GLOBAL_dirs.grammar_dir, BUFSIZE, "%s%sgrammar", SWITCH_GLOBAL_dirs.base_dir, SWITCH_PATH_SEPARATOR);
                else
#ifdef SWITCH_GRAMMAR_DIR
                        switch_snprintf(SWITCH_GLOBAL_dirs.grammar_dir, BUFSIZE, "%s", SWITCH_GRAMMAR_DIR);
#else
                        switch_snprintf(SWITCH_GLOBAL_dirs.grammar_dir, BUFSIZE, "%s%sgrammar", base_dir, SWITCH_PATH_SEPARATOR);
#endif
        }

        if (!SWITCH_GLOBAL_dirs.fonts_dir && (SWITCH_GLOBAL_dirs.fonts_dir = (char *) malloc(BUFSIZE))) {
                if (SWITCH_GLOBAL_dirs.base_dir)
                        switch_snprintf(SWITCH_GLOBAL_dirs.fonts_dir, BUFSIZE, "%s%sfonts", SWITCH_GLOBAL_dirs.base_dir, SWITCH_PATH_SEPARATOR);
                else
#ifdef SWITCH_FONTS_DIR
                        switch_snprintf(SWITCH_GLOBAL_dirs.fonts_dir, BUFSIZE, "%s", SWITCH_FONTS_DIR);
#else
                        switch_snprintf(SWITCH_GLOBAL_dirs.fonts_dir, BUFSIZE, "%s%sfonts", base_dir, SWITCH_PATH_SEPARATOR);
#endif
        }

        if (!SWITCH_GLOBAL_dirs.images_dir && (SWITCH_GLOBAL_dirs.images_dir = (char *) malloc(BUFSIZE))) {
                if (SWITCH_GLOBAL_dirs.base_dir)
                        switch_snprintf(SWITCH_GLOBAL_dirs.images_dir, BUFSIZE, "%s%simages", SWITCH_GLOBAL_dirs.base_dir, SWITCH_PATH_SEPARATOR);
                else
#ifdef SWITCH_IMAGES_DIR
                        switch_snprintf(SWITCH_GLOBAL_dirs.images_dir, BUFSIZE, "%s", SWITCH_IMAGES_DIR);
#else
                        switch_snprintf(SWITCH_GLOBAL_dirs.images_dir, BUFSIZE, "%s%simages", base_dir, SWITCH_PATH_SEPARATOR);
#endif
        }

        if (!SWITCH_GLOBAL_dirs.data_dir && (SWITCH_GLOBAL_dirs.data_dir = (char *) malloc(BUFSIZE))) {
                if (SWITCH_GLOBAL_dirs.base_dir)
                        switch_snprintf(SWITCH_GLOBAL_dirs.data_dir, BUFSIZE, "%s", SWITCH_GLOBAL_dirs.base_dir);
                else
#ifdef SWITCH_DATA_DIR
                        switch_snprintf(SWITCH_GLOBAL_dirs.data_dir, BUFSIZE, "%s", SWITCH_DATA_DIR);
#else
                        switch_snprintf(SWITCH_GLOBAL_dirs.data_dir, BUFSIZE, "%s", base_dir);
#endif
        }

        if (!SWITCH_GLOBAL_dirs.localstate_dir && (SWITCH_GLOBAL_dirs.localstate_dir = (char *) malloc(BUFSIZE))) {
                if (SWITCH_GLOBAL_dirs.base_dir)
                        switch_snprintf(SWITCH_GLOBAL_dirs.localstate_dir, BUFSIZE, "%s", SWITCH_GLOBAL_dirs.base_dir);
                else
#ifdef SWITCH_LOCALSTATE_DIR
                        switch_snprintf(SWITCH_GLOBAL_dirs.localstate_dir, BUFSIZE, "%s", SWITCH_LOCALSTATE_DIR);
#else
                        switch_snprintf(SWITCH_GLOBAL_dirs.localstate_dir, BUFSIZE, "%s", base_dir);
#endif
        }

        if (!SWITCH_GLOBAL_dirs.certs_dir && (SWITCH_GLOBAL_dirs.certs_dir = (char *) malloc(BUFSIZE))) {
                if (SWITCH_GLOBAL_dirs.base_dir)
                        switch_snprintf(SWITCH_GLOBAL_dirs.certs_dir, BUFSIZE, "%s%scert", SWITCH_GLOBAL_dirs.base_dir, SWITCH_PATH_SEPARATOR);
                else
#ifdef SWITCH_CERTS_DIR
                        switch_snprintf(SWITCH_GLOBAL_dirs.certs_dir, BUFSIZE, "%s", SWITCH_CERTS_DIR);
#else
                        switch_snprintf(SWITCH_GLOBAL_dirs.certs_dir, BUFSIZE, "%s%scert", base_dir, SWITCH_PATH_SEPARATOR);
#endif
        }

        if (!SWITCH_GLOBAL_dirs.temp_dir && (SWITCH_GLOBAL_dirs.temp_dir = (char *) malloc(BUFSIZE))) {
#ifdef SWITCH_TEMP_DIR
                switch_snprintf(SWITCH_GLOBAL_dirs.temp_dir, BUFSIZE, "%s", SWITCH_TEMP_DIR);
#else
#ifdef WIN32
                GetTempPath(dwBufSize, lpPathBuffer);
                lpPathBuffer[strlen(lpPathBuffer)-1] = 0;
                tmp = switch_string_replace(lpPathBuffer, "\\", "/");
                strcpy(lpPathBuffer, tmp);
                free(tmp);
                switch_snprintf(SWITCH_GLOBAL_dirs.temp_dir, BUFSIZE, "%s", lpPathBuffer);
#else
                switch_snprintf(SWITCH_GLOBAL_dirs.temp_dir, BUFSIZE, "%s", "/tmp");
#endif
#endif
        }

        if (!SWITCH_GLOBAL_filenames.conf_name && (SWITCH_GLOBAL_filenames.conf_name = (char *) malloc(BUFSIZE))) {
                switch_snprintf(SWITCH_GLOBAL_filenames.conf_name, BUFSIZE, "%s", "freeswitch.xml");
        }

        /* Do this last because it being empty is part of the above logic */
        if (!SWITCH_GLOBAL_dirs.base_dir && (SWITCH_GLOBAL_dirs.base_dir = (char *) malloc(BUFSIZE))) {
                switch_snprintf(SWITCH_GLOBAL_dirs.base_dir, BUFSIZE, "%s", base_dir);
        }

        switch_assert(SWITCH_GLOBAL_dirs.base_dir);
        switch_assert(SWITCH_GLOBAL_dirs.mod_dir);
        switch_assert(SWITCH_GLOBAL_dirs.lib_dir);
        switch_assert(SWITCH_GLOBAL_dirs.conf_dir);
        switch_assert(SWITCH_GLOBAL_dirs.log_dir);
        switch_assert(SWITCH_GLOBAL_dirs.run_dir);
        switch_assert(SWITCH_GLOBAL_dirs.db_dir);
        switch_assert(SWITCH_GLOBAL_dirs.script_dir);
        switch_assert(SWITCH_GLOBAL_dirs.htdocs_dir);
        switch_assert(SWITCH_GLOBAL_dirs.grammar_dir);
        switch_assert(SWITCH_GLOBAL_dirs.fonts_dir);
        switch_assert(SWITCH_GLOBAL_dirs.images_dir);
        switch_assert(SWITCH_GLOBAL_dirs.recordings_dir);
        switch_assert(SWITCH_GLOBAL_dirs.sounds_dir);
        switch_assert(SWITCH_GLOBAL_dirs.certs_dir);
        switch_assert(SWITCH_GLOBAL_dirs.temp_dir);
        switch_assert(SWITCH_GLOBAL_dirs.data_dir);
        switch_assert(SWITCH_GLOBAL_dirs.localstate_dir);

        switch_assert(SWITCH_GLOBAL_filenames.conf_name);
}

int32_t switch_core_set_process_privileges

(

void

)

Switch on the privilege awareness for the process and request required privileges.

Returns

0 on success

Definition at line 897 of file switch_core.c.

Referenced by main().

{
#ifdef SOLARIS_PRIVILEGES
        priv_set_t *basicset;
        
        /* make the process privilege-aware */
        setpflags(PRIV_AWARE, 1);

        /* reset the privileges to basic */
        basicset = priv_str_to_set("basic", ",", NULL);
        if (setppriv(PRIV_SET, PRIV_EFFECTIVE, basicset) != 0) {
                fprintf(stderr, "ERROR: Failed to acquire basic privileges (%s)\n", strerror(errno));
        }
        
        /* we need high-resolution clock, and this requires a non-basic privilege */
        if (priv_set(PRIV_ON, PRIV_EFFECTIVE, PRIV_PROC_CLOCK_HIGHRES, NULL) < 0) {
                fprintf(stderr, "ERROR: Failed to acquire proc_clock_highres privilege (%s)\n", strerror(errno));
                return -1;
        }

        /* need this for setrlimit */
        if (priv_set(PRIV_ON, PRIV_EFFECTIVE, PRIV_SYS_RESOURCE, NULL) < 0) {
                fprintf(stderr, "ERROR: Failed to acquire sys_resource privilege (%s)\n", strerror(errno));
                return -1;
        }
        
        /* we need to read directories belonging to other uid */
        if (priv_set(PRIV_ON, PRIV_EFFECTIVE, PRIV_FILE_DAC_SEARCH, NULL) < 0) {
                fprintf(stderr, "ERROR: Failed to acquire file_dac_search privilege (%s)\n", strerror(errno));
                return -1;
        }
#endif
        return 0;
}

void switch_core_setrlimits

(

void

)

Definition at line 1314 of file switch_core.c.

References memset(), SWITCH_SYSTEM_THREAD_STACKSIZE, and SWITCH_THREAD_STACKSIZE.

Referenced by main().

{
#ifdef HAVE_SETRLIMIT
        struct rlimit rlp;

        /* 
           Setting the stack size on FreeBSD results in an instant crash.

           If anyone knows how to fix this,
           feel free to submit a patch to https://freeswitch.org/jira 
         */

#ifndef __FreeBSD__
        memset(&rlp, 0, sizeof(rlp));
        rlp.rlim_cur = SWITCH_THREAD_STACKSIZE;
        rlp.rlim_max = SWITCH_SYSTEM_THREAD_STACKSIZE;
        setrlimit(RLIMIT_STACK, &rlp);
#endif

        memset(&rlp, 0, sizeof(rlp));
        rlp.rlim_cur = 999999;
        rlp.rlim_max = 999999;
        setrlimit(RLIMIT_NOFILE, &rlp);

        memset(&rlp, 0, sizeof(rlp));
        rlp.rlim_cur = RLIM_INFINITY;
        rlp.rlim_max = RLIM_INFINITY;

        setrlimit(RLIMIT_CPU, &rlp);
        setrlimit(RLIMIT_DATA, &rlp);
        setrlimit(RLIMIT_FSIZE, &rlp);
#ifdef RLIMIT_NPROC
        setrlimit(RLIMIT_NPROC, &rlp);
#endif
#ifdef RLIMIT_RTPRIO
        setrlimit(RLIMIT_RTPRIO, &rlp);
#endif

#if !defined(__OpenBSD__) && !defined(__NetBSD__)
        setrlimit(RLIMIT_AS, &rlp);
#endif
#endif
        return;
}

void switch_core_sqldb_pause

(

void

)

Definition at line 3635 of file switch_core_sqldb.c.

References sql_manager, SWITCH_CHANNEL_LOG, switch_log_printf(), and SWITCH_LOG_WARNING.

Referenced by switch_core_session_ctl().

{
        if (sql_manager.paused) {
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "SQL is already paused.\n");
        }
        sql_manager.paused = 1;
}

void switch_core_sqldb_resume

(

void

)

Definition at line 3643 of file switch_core_sqldb.c.

References sql_manager, SWITCH_CHANNEL_LOG, switch_log_printf(), and SWITCH_LOG_WARNING.

Referenced by switch_core_session_ctl().

{
        if (!sql_manager.paused) {
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "SQL is already running.\n");
        }
        sql_manager.paused = 0;
}

switch_time_t switch_core_uptime

(

void

)

Number of microseconds the system has been up.

Returns

a number of microseconds

Definition at line 2467 of file switch_core.c.

References switch_runtime::initiated, and switch_mono_micro_time_now().

Referenced by send_heartbeat().

{
        return switch_mono_micro_time_now() - runtime.initiated;
}

time_t switch_epoch_time_now

(

time_t *

t

)

Get the current epoch time.

Parameters

[out]

(optional)

The current epoch time

Returns

The current epoch time

Definition at line 321 of file switch_time.c.

References switch_micro_time_now().

Referenced by _switch_cache_db_get_db_handle(), audio_bridge_thread(), check_per_channel_timeouts(), core_event_handler(), meta_on_dtmf(), perform_write(), rtp_common_write(), switch_cache_db_execute_sql_callback(), switch_cache_db_execute_sql_callback_err(), switch_cache_db_execute_sql_event_callback(), switch_cache_db_execute_sql_event_callback_err(), switch_cache_db_flush_handles(), switch_cache_db_release_db_handle(), switch_cache_db_status(), switch_core_expire_registration(), switch_core_init(), switch_core_media_bug_patch_video(), switch_core_media_bug_transfer_recordings(), switch_core_media_gen_local_sdp(), switch_core_media_get_video_fps(), switch_core_media_patch_sdp(), switch_core_media_read_frame(), switch_core_media_set_udptl_image_sdp(), switch_core_session_dequeue_message(), switch_core_session_read_frame(), switch_core_session_read_video_frame(), switch_core_session_sched_heartbeat(), switch_core_session_write_frame(), switch_core_session_write_video_frame(), switch_core_sql_db_thread(), switch_ivr_displace_session(), switch_ivr_originate(), switch_ivr_park(), switch_ivr_record_file(), switch_ivr_record_session(), switch_ivr_session_transfer(), switch_ivr_uuid_bridge(), switch_nat_late_init(), switch_rtp_create(), switch_rtp_enable_vad(), switch_rtp_init(), switch_scheduler_add_task(), switch_scheduler_execute(), switch_simple_email(), SWITCH_STANDARD_SCHED_FUNC(), task_thread_loop(), and video_bug_thread().

{
        time_t now = switch_micro_time_now() / APR_USEC_PER_SEC;
        if (t) {
                *t = now;
        }
        return now;
}

switch_status_t switch_ivr_preprocess_session	(	switch_core_session_t *	session,
		const char *	cmds
	)

Definition at line 2835 of file switch_ivr_async.c.

References pp_cb_t::done, mutex, preprocess_callback(), pp_cb_t::read_ec, pp_cb_t::read_mutex, pp_cb_t::read_st, switch_codec_implementation::samples_per_packet, switch_codec_implementation::samples_per_second, SMBF_NO_PAUSE, SMBF_READ_REPLACE, SMBF_WRITE_REPLACE, switch_channel_get_private(), SWITCH_CHANNEL_SESSION_LOG, switch_channel_set_private(), switch_core_media_bug_add(), switch_core_session_alloc, switch_core_session_get_channel(), switch_core_session_get_read_impl(), SWITCH_LOG_DEBUG, SWITCH_LOG_ERROR, switch_log_printf(), SWITCH_LOG_WARNING, switch_mutex_lock(), switch_mutex_unlock(), switch_safe_free, switch_separate_string(), SWITCH_STATUS_SUCCESS, switch_true(), pp_cb_t::write_ec, pp_cb_t::write_mutex, and pp_cb_t::write_st.

{
        switch_channel_t *channel = switch_core_session_get_channel(session);
        switch_media_bug_t *bug;
        switch_status_t status;
        time_t to = 0;
        switch_media_bug_flag_t flags = SMBF_NO_PAUSE;
        switch_codec_implementation_t read_impl = { 0 };
        pp_cb_t *cb;
        int update = 0;
        int argc;
        char *mydata = NULL, *argv[5];
        int i = 0;

        switch_core_session_get_read_impl(session, &read_impl);

        if ((cb = switch_channel_get_private(channel, "_preprocess"))) {
                update = 1;
        } else {
                cb = switch_core_session_alloc(session, sizeof(*cb));
        }


        if (update) {
                if (!strcasecmp(cmds, "stop")) {
                        cb->done = 1;
                        return SWITCH_STATUS_SUCCESS;
                }
        }

        mydata = strdup(cmds);
        argc = switch_separate_string(mydata, ',', argv, (sizeof(argv) / sizeof(argv[0])));

        for (i = 0; i < argc; i++) {
                char *var = argv[i];
                char *val = NULL;
                char rw;
                int tr;
                int err = 1;
                SpeexPreprocessState *st = NULL;
                SpeexEchoState *ec = NULL;
                switch_mutex_t *mutex = NULL;
                int r = 0;

                if (var) {
                        if ((val = strchr(var, '='))) {
                                *val++ = '\0';

                                rw = *var++;
                                while (*var == '.' || *var == '_') {
                                        var++;
                                }

                                if (rw == 'r') {
                                        if (!cb->read_st) {
                                                cb->read_st = speex_preprocess_state_init(read_impl.samples_per_packet, read_impl.samples_per_second);
                                                flags |= SMBF_READ_REPLACE;
                                        }
                                        st = cb->read_st;
                                        ec = cb->read_ec;
                                        mutex = cb->read_mutex;
                                } else if (rw == 'w') {
                                        if (!cb->write_st) {
                                                cb->write_st = speex_preprocess_state_init(read_impl.samples_per_packet, read_impl.samples_per_second);
                                                flags |= SMBF_WRITE_REPLACE;
                                        }
                                        st = cb->write_st;
                                        ec = cb->write_ec;
                                        mutex = cb->write_mutex;
                                }

                                if (mutex)
                                        switch_mutex_lock(mutex);

                                if (st) {
                                        err = 0;
                                        tr = switch_true(val);
                                        if (!strcasecmp(var, "agc")) {
                                                int l = read_impl.samples_per_second;
                                                int tmp = atoi(val);

                                                if (!tr) {
                                                        l = tmp;
                                                }

                                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Setting AGC on %c to %d\n", rw, tr);
                                                speex_preprocess_ctl(st, SPEEX_PREPROCESS_SET_AGC, &tr);
                                                speex_preprocess_ctl(st, SPEEX_PREPROCESS_SET_AGC_LEVEL, &l);

                                        } else if (!strcasecmp(var, "noise_suppress")) {
                                                int db = atoi(val);
                                                if (db < 0) {
                                                        r = speex_preprocess_ctl(st, SPEEX_PREPROCESS_SET_NOISE_SUPPRESS, &db);
                                                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Setting NOISE_SUPPRESS on %c to %d [%d]\n", rw, db,
                                                                                          r);
                                                } else {
                                                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Syntax error noise_suppress should be in -db\n");
                                                }
                                        } else if (!strcasecmp(var, "echo_cancel")) {
                                                int tail = 1024;
                                                int tmp = atoi(val);

                                                if (!tr && tmp > 0) {
                                                        tail = tmp;
                                                } else if (!tr) {
                                                        if (ec) {
                                                                if (rw == 'r') {
                                                                        speex_echo_state_destroy(cb->read_ec);
                                                                        cb->read_ec = NULL;
                                                                } else {
                                                                        speex_echo_state_destroy(cb->write_ec);
                                                                        cb->write_ec = NULL;
                                                                }
                                                        }

                                                        ec = NULL;
                                                }

                                                if (!ec) {
                                                        if (rw == 'r') {
                                                                ec = cb->read_ec = speex_echo_state_init(read_impl.samples_per_packet, tail);
                                                                speex_echo_ctl(ec, SPEEX_ECHO_SET_SAMPLING_RATE, &read_impl.samples_per_second);
                                                                flags |= SMBF_WRITE_REPLACE;
                                                        } else {
                                                                ec = cb->write_ec = speex_echo_state_init(read_impl.samples_per_packet, tail);
                                                                speex_echo_ctl(ec, SPEEX_ECHO_SET_SAMPLING_RATE, &read_impl.samples_per_second);
                                                                flags |= SMBF_READ_REPLACE;
                                                        }
                                                        speex_preprocess_ctl(st, SPEEX_PREPROCESS_SET_ECHO_STATE, ec);
                                                }


                                        } else if (!strcasecmp(var, "echo_suppress")) {
                                                int db = atoi(val);
                                                if (db < 0) {
                                                        speex_preprocess_ctl(st, SPEEX_PREPROCESS_SET_ECHO_SUPPRESS, &db);
                                                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Setting ECHO_SUPPRESS on %c to %d [%d]\n", rw, db,
                                                                                          r);
                                                } else {
                                                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Syntax error echo_suppress should be in -db\n");
                                                }
                                        } else {
                                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_WARNING, "Warning unknown parameter [%s] \n", var);
                                        }
                                }
                        }

                        if (mutex)
                                switch_mutex_unlock(mutex);

                        if (err) {
                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Syntax error parsing preprocessor commands\n");
                        }

                } else {
                        break;
                }
        }


        switch_safe_free(mydata);

        if (update) {
                return SWITCH_STATUS_SUCCESS;
        }


        if ((status = switch_core_media_bug_add(session, "preprocess", NULL,
                                                                                        preprocess_callback, cb, to, flags, &bug)) != SWITCH_STATUS_SUCCESS) {
                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Error adding media bug.\n");
                if (cb->read_st) {
                        speex_preprocess_state_destroy(cb->read_st);
                }

                if (cb->write_st) {
                        speex_preprocess_state_destroy(cb->write_st);
                }

                if (cb->read_ec) {
                        speex_echo_state_destroy(cb->read_ec);
                }

                if (cb->write_ec) {
                        speex_echo_state_destroy(cb->write_ec);
                }

                return status;
        }

        switch_channel_set_private(channel, "_preprocess", cb);

        return SWITCH_STATUS_SUCCESS;
}

void switch_load_network_lists

(

switch_bool_t

reload

)

Definition at line 1436 of file switch_core.c.

References switch_runtime::global_mutex, switch_ip_list_t::hash, memset(), switch_xml::next, switch_ip_list_t::pool, switch_assert, SWITCH_CHANNEL_LOG, switch_core_destroy_memory_pool, switch_core_hash_destroy(), switch_core_hash_init, switch_core_hash_insert, switch_core_new_memory_pool, switch_event_add_header_string(), switch_event_create, switch_event_destroy(), SWITCH_EVENT_GENERAL, SWITCH_FALSE, switch_find_local_ip(), SWITCH_LOG_CONSOLE, SWITCH_LOG_NOTICE, switch_log_printf(), SWITCH_LOG_WARNING, switch_mprintf(), switch_mutex_lock(), switch_mutex_unlock(), switch_network_list_add_cidr, switch_network_list_add_cidr_token(), switch_network_list_add_host_mask(), switch_network_list_create(), switch_set_string, SWITCH_STACK_BOTTOM, SWITCH_STATUS_SUCCESS, SWITCH_TRUE, switch_true(), switch_xml_attr(), switch_xml_child(), switch_xml_free(), switch_xml_locate_domain(), switch_xml_open_cfg(), and zstr.

Referenced by switch_core_init_and_modload().

{
        switch_xml_t xml = NULL, x_lists = NULL, x_list = NULL, x_node = NULL, cfg = NULL;
        switch_network_list_t *rfc_list, *list;
        char guess_ip[16] = "";
        int mask = 0;
        char guess_mask[16] = "";
        char *tmp_name;
        struct in_addr in;

        switch_find_local_ip(guess_ip, sizeof(guess_ip), &mask, AF_INET);
        in.s_addr = mask;
        switch_set_string(guess_mask, inet_ntoa(in));

        switch_mutex_lock(runtime.global_mutex);

        if (IP_LIST.hash) {
                switch_core_hash_destroy(&IP_LIST.hash);
        }

        if (IP_LIST.pool) {
                switch_core_destroy_memory_pool(&IP_LIST.pool);
        }

        memset(&IP_LIST, 0, sizeof(IP_LIST));
        switch_core_new_memory_pool(&IP_LIST.pool);
        switch_core_hash_init(&IP_LIST.hash);


        tmp_name = "rfc6598.auto";
        switch_network_list_create(&rfc_list, tmp_name, SWITCH_FALSE, IP_LIST.pool);
        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "Created ip list %s default (deny)\n", tmp_name);
        switch_network_list_add_cidr(rfc_list, "100.64.0.0/10", SWITCH_TRUE);
        switch_core_hash_insert(IP_LIST.hash, tmp_name, rfc_list);

        tmp_name = "rfc1918.auto";
        switch_network_list_create(&rfc_list, tmp_name, SWITCH_FALSE, IP_LIST.pool);
        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "Created ip list %s default (deny)\n", tmp_name);
        switch_network_list_add_cidr(rfc_list, "10.0.0.0/8", SWITCH_TRUE);
        switch_network_list_add_cidr(rfc_list, "172.16.0.0/12", SWITCH_TRUE);
        switch_network_list_add_cidr(rfc_list, "192.168.0.0/16", SWITCH_TRUE);
        switch_network_list_add_cidr(rfc_list, "fe80::/10", SWITCH_TRUE);
        switch_core_hash_insert(IP_LIST.hash, tmp_name, rfc_list);

        tmp_name = "wan.auto";
        switch_network_list_create(&rfc_list, tmp_name, SWITCH_TRUE, IP_LIST.pool);
        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "Created ip list %s default (allow)\n", tmp_name);
        switch_network_list_add_cidr(rfc_list, "0.0.0.0/8", SWITCH_FALSE);
        switch_network_list_add_cidr(rfc_list, "10.0.0.0/8", SWITCH_FALSE);
        switch_network_list_add_cidr(rfc_list, "172.16.0.0/12", SWITCH_FALSE);
        switch_network_list_add_cidr(rfc_list, "192.168.0.0/16", SWITCH_FALSE);
        switch_network_list_add_cidr(rfc_list, "169.254.0.0/16", SWITCH_FALSE);
        switch_network_list_add_cidr(rfc_list, "fe80::/10", SWITCH_FALSE);
        switch_core_hash_insert(IP_LIST.hash, tmp_name, rfc_list);

        tmp_name = "wan_v6.auto";
        switch_network_list_create(&rfc_list, tmp_name, SWITCH_TRUE, IP_LIST.pool);
        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "Created ip list %s default (allow)\n", tmp_name);
        switch_network_list_add_cidr(rfc_list, "0.0.0.0/0", SWITCH_FALSE);
        switch_network_list_add_cidr(rfc_list, "fe80::/10", SWITCH_FALSE);
        switch_core_hash_insert(IP_LIST.hash, tmp_name, rfc_list);


        tmp_name = "wan_v4.auto";
        switch_network_list_create(&rfc_list, tmp_name, SWITCH_TRUE, IP_LIST.pool);
        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "Created ip list %s default (allow)\n", tmp_name);
        switch_network_list_add_cidr(rfc_list, "0.0.0.0/8", SWITCH_FALSE);
        switch_network_list_add_cidr(rfc_list, "10.0.0.0/8", SWITCH_FALSE);
        switch_network_list_add_cidr(rfc_list, "172.16.0.0/12", SWITCH_FALSE);
        switch_network_list_add_cidr(rfc_list, "192.168.0.0/16", SWITCH_FALSE);
        switch_network_list_add_cidr(rfc_list, "169.254.0.0/16", SWITCH_FALSE);
        switch_network_list_add_cidr(rfc_list, "::/0", SWITCH_FALSE);
        switch_core_hash_insert(IP_LIST.hash, tmp_name, rfc_list);


        tmp_name = "any_v6.auto";
        switch_network_list_create(&rfc_list, tmp_name, SWITCH_TRUE, IP_LIST.pool);
        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "Created ip list %s default (allow)\n", tmp_name);
        switch_network_list_add_cidr(rfc_list, "0.0.0.0/0", SWITCH_FALSE);
        switch_core_hash_insert(IP_LIST.hash, tmp_name, rfc_list);


        tmp_name = "any_v4.auto";
        switch_network_list_create(&rfc_list, tmp_name, SWITCH_TRUE, IP_LIST.pool);
        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "Created ip list %s default (allow)\n", tmp_name);
        switch_network_list_add_cidr(rfc_list, "::/0", SWITCH_FALSE);
        switch_core_hash_insert(IP_LIST.hash, tmp_name, rfc_list);


        tmp_name = "nat.auto";
        switch_network_list_create(&rfc_list, tmp_name, SWITCH_FALSE, IP_LIST.pool);
        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "Created ip list %s default (deny)\n", tmp_name);
        if (switch_network_list_add_host_mask(rfc_list, guess_ip, guess_mask, SWITCH_FALSE) == SWITCH_STATUS_SUCCESS) {
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "Adding %s/%s (deny) to list %s\n", guess_ip, guess_mask, tmp_name);
        }
        switch_network_list_add_cidr(rfc_list, "10.0.0.0/8", SWITCH_TRUE);
        switch_network_list_add_cidr(rfc_list, "172.16.0.0/12", SWITCH_TRUE);
        switch_network_list_add_cidr(rfc_list, "192.168.0.0/16", SWITCH_TRUE);
        switch_network_list_add_cidr(rfc_list, "100.64.0.0/10", SWITCH_TRUE);
        switch_core_hash_insert(IP_LIST.hash, tmp_name, rfc_list);

        tmp_name = "loopback.auto";
        switch_network_list_create(&rfc_list, tmp_name, SWITCH_FALSE, IP_LIST.pool);
        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "Created ip list %s default (deny)\n", tmp_name);
        switch_network_list_add_cidr(rfc_list, "127.0.0.0/8", SWITCH_TRUE);
        switch_network_list_add_cidr(rfc_list, "::1/128", SWITCH_TRUE);
        switch_core_hash_insert(IP_LIST.hash, tmp_name, rfc_list);

        tmp_name = "localnet.auto";
        switch_network_list_create(&list, tmp_name, SWITCH_FALSE, IP_LIST.pool);
        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "Created ip list %s default (deny)\n", tmp_name);

        if (switch_network_list_add_host_mask(list, guess_ip, guess_mask, SWITCH_TRUE) == SWITCH_STATUS_SUCCESS) {
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "Adding %s/%s (allow) to list %s\n", guess_ip, guess_mask, tmp_name);
        }
        switch_core_hash_insert(IP_LIST.hash, tmp_name, list);


        if ((xml = switch_xml_open_cfg("acl.conf", &cfg, NULL))) {
                if ((x_lists = switch_xml_child(cfg, "network-lists"))) {
                        for (x_list = switch_xml_child(x_lists, "list"); x_list; x_list = x_list->next) {
                                const char *name = switch_xml_attr(x_list, "name");
                                const char *dft = switch_xml_attr(x_list, "default");
                                switch_bool_t default_type = SWITCH_TRUE;

                                if (zstr(name)) {
                                        continue;
                                }

                                if (dft) {
                                        default_type = switch_true(dft);
                                }

                                if (switch_network_list_create(&list, name, default_type, IP_LIST.pool) != SWITCH_STATUS_SUCCESS) {
                                        abort();
                                }

                                if (reload) {
                                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "Created ip list %s default (%s)\n", name, default_type ? "allow" : "deny");
                                } else {
                                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "Created ip list %s default (%s)\n", name, default_type ? "allow" : "deny");
                                }


                                for (x_node = switch_xml_child(x_list, "node"); x_node; x_node = x_node->next) {
                                        const char *cidr = NULL, *host = NULL, *mask = NULL, *domain = NULL;
                                        switch_bool_t ok = default_type;
                                        const char *type = switch_xml_attr(x_node, "type");

                                        if (type) {
                                                ok = switch_true(type);
                                        }

                                        cidr = switch_xml_attr(x_node, "cidr");
                                        host = switch_xml_attr(x_node, "host");
                                        mask = switch_xml_attr(x_node, "mask");
                                        domain = switch_xml_attr(x_node, "domain");

                                        if (domain) {
                                                switch_event_t *my_params = NULL;
                                                switch_xml_t x_domain, xml_root;
                                                switch_xml_t gt, gts, ut, uts;

                                                switch_event_create(&my_params, SWITCH_EVENT_GENERAL);
                                                switch_assert(my_params);
                                                switch_event_add_header_string(my_params, SWITCH_STACK_BOTTOM, "domain", domain);
                                                switch_event_add_header_string(my_params, SWITCH_STACK_BOTTOM, "purpose", "network-list");

                                                if (switch_xml_locate_domain(domain, my_params, &xml_root, &x_domain) != SWITCH_STATUS_SUCCESS) {
                                                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "Cannot locate domain %s\n", domain);
                                                        switch_event_destroy(&my_params);
                                                        continue;
                                                }

                                                switch_event_destroy(&my_params);

                                                if ((ut = switch_xml_child(x_domain, "users"))) {
                                                        x_domain = ut;
                                                }

                                                for (ut = switch_xml_child(x_domain, "user"); ut; ut = ut->next) {
                                                        const char *user_cidr = switch_xml_attr(ut, "cidr");
                                                        const char *id = switch_xml_attr(ut, "id");

                                                        if (id && user_cidr) {
                                                                char *token = switch_mprintf("%s@%s", id, domain);
                                                                switch_assert(token);
                                                                switch_network_list_add_cidr_token(list, user_cidr, ok, token);
                                                                free(token);
                                                        }
                                                }

                                                for (gts = switch_xml_child(x_domain, "groups"); gts; gts = gts->next) {
                                                        for (gt = switch_xml_child(gts, "group"); gt; gt = gt->next) {
                                                                for (uts = switch_xml_child(gt, "users"); uts; uts = uts->next) {
                                                                        for (ut = switch_xml_child(uts, "user"); ut; ut = ut->next) {
                                                                                const char *user_cidr = switch_xml_attr(ut, "cidr");
                                                                                const char *id = switch_xml_attr(ut, "id");

                                                                                if (id && user_cidr) {
                                                                                        char *token = switch_mprintf("%s@%s", id, domain);
                                                                                        switch_assert(token);
                                                                                        switch_network_list_add_cidr_token(list, user_cidr, ok, token);
                                                                                        free(token);
                                                                                }
                                                                        }
                                                                }
                                                        }
                                                }

                                                switch_xml_free(xml_root);
                                        } else if (cidr) {
                                                switch_network_list_add_cidr(list, cidr, ok);
                                        } else if (host && mask) {
                                                switch_network_list_add_host_mask(list, host, mask, ok);
                                        }

                                        switch_core_hash_insert(IP_LIST.hash, name, list);
                                }
                        }
                }

                switch_xml_free(xml);
        }

        switch_mutex_unlock(runtime.global_mutex);
}

void* switch_loadable_module_create_interface	(	switch_loadable_module_interface_t *	mod,
		switch_module_interface_name_t	iname
	)

Definition at line 2650 of file switch_loadable_module.c.

References ALLOC_INTERFACE, SWITCH_API_INTERFACE, SWITCH_APPLICATION_INTERFACE, SWITCH_ASR_INTERFACE, SWITCH_CHANNEL_LOG, SWITCH_CHAT_APPLICATION_INTERFACE, SWITCH_CHAT_INTERFACE, SWITCH_CODEC_INTERFACE, SWITCH_DIALPLAN_INTERFACE, SWITCH_DIRECTORY_INTERFACE, SWITCH_ENDPOINT_INTERFACE, SWITCH_FILE_INTERFACE, SWITCH_JSON_API_INTERFACE, SWITCH_LIMIT_INTERFACE, switch_log_printf(), SWITCH_LOG_WARNING, SWITCH_MANAGEMENT_INTERFACE, SWITCH_SAY_INTERFACE, SWITCH_SPEECH_INTERFACE, and SWITCH_TIMER_INTERFACE.

Referenced by SWITCH_MODULE_LOAD_FUNCTION().

{

        switch (iname) {
        case SWITCH_ENDPOINT_INTERFACE:
                ALLOC_INTERFACE(endpoint)

        case SWITCH_TIMER_INTERFACE:
                ALLOC_INTERFACE(timer)

        case SWITCH_DIALPLAN_INTERFACE:
                ALLOC_INTERFACE(dialplan)

        case SWITCH_CODEC_INTERFACE:
                ALLOC_INTERFACE(codec)

        case SWITCH_APPLICATION_INTERFACE:
                ALLOC_INTERFACE(application)

        case SWITCH_CHAT_APPLICATION_INTERFACE:
                ALLOC_INTERFACE(chat_application)

        case SWITCH_API_INTERFACE:
                ALLOC_INTERFACE(api)

        case SWITCH_JSON_API_INTERFACE:
                ALLOC_INTERFACE(json_api)

        case SWITCH_FILE_INTERFACE:
                ALLOC_INTERFACE(file)

        case SWITCH_SPEECH_INTERFACE:
                ALLOC_INTERFACE(speech)

        case SWITCH_DIRECTORY_INTERFACE:
                ALLOC_INTERFACE(directory)

        case SWITCH_CHAT_INTERFACE:
                ALLOC_INTERFACE(chat)

        case SWITCH_SAY_INTERFACE:
                ALLOC_INTERFACE(say)

        case SWITCH_ASR_INTERFACE:
                ALLOC_INTERFACE(asr)

        case SWITCH_MANAGEMENT_INTERFACE:
                ALLOC_INTERFACE(management)

        case SWITCH_LIMIT_INTERFACE:
                ALLOC_INTERFACE(limit)

        default:
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "Invalid Module Type!\n");
                return NULL;
        }
}

switch_loadable_module_interface_t* switch_loadable_module_create_module_interface	(	switch_memory_pool_t *	pool,
		const char *	name
	)

Definition at line 2620 of file switch_loadable_module.c.

References switch_loadable_module_interface::module_name, switch_loadable_module_interface::pool, pool, switch_loadable_module_interface::rwlock, switch_assert, switch_core_alloc, switch_core_strdup, and switch_thread_rwlock_create().

Referenced by SWITCH_MODULE_LOAD_FUNCTION().

{
        switch_loadable_module_interface_t *mod;

        mod = switch_core_alloc(pool, sizeof(switch_loadable_module_interface_t));
        switch_assert(mod != NULL);

        mod->pool = pool;

        mod->module_name = switch_core_strdup(mod->pool, name);
        switch_thread_rwlock_create(&mod->rwlock, mod->pool);
        return mod;
}

const char* switch_lookup_timezone

(

const char *

tz_name

)

Definition at line 1361 of file switch_time.c.

References switch_timezones_list_t::hash, SWITCH_CHANNEL_LOG, switch_core_hash_find(), SWITCH_LOG_ERROR, switch_log_printf(), and zstr.

Referenced by switch_strftime_tz(), and switch_time_exp_tz_name().

{
        char *value = NULL;

        if (zstr(tz_name) || !TIMEZONES_LIST.hash) {
                return NULL;
        }
        
        if ((value = switch_core_hash_find(TIMEZONES_LIST.hash, tz_name)) == NULL) {
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Timezone '%s' not found!\n", tz_name);
        }

        return value;
}

switch_time_t switch_micro_time_now

(

void

)

Get the current epoch time in microseconds.

Returns

the current epoch time in microseconds

Definition at line 310 of file switch_time.c.

References globals, runtime, switch_time_now(), and switch_runtime::timestamp.

Referenced by check_jitter(), check_rtcp_and_ice(), API::getTime(), handle_ice(), ice_out(), read_rtp_packet(), record_callback(), rtp_common_write(), switch_channel_check_device_state(), switch_channel_perform_mark_answered(), switch_channel_perform_mark_pre_answered(), switch_channel_perform_mark_ring_ready_value(), switch_channel_set_bridge_time(), switch_channel_set_caller_profile(), switch_channel_set_hangup_time(), switch_console_printf(), switch_core_media_codec_control(), switch_core_port_allocator_request_port(), switch_core_session_request_video_refresh(), switch_core_session_write_video_frame(), switch_epoch_time_now(), switch_event_prep_for_delivery_detailed(), switch_generate_sln_silence(), switch_ivr_collect_digits_callback(), switch_ivr_collect_digits_count(), switch_ivr_digit_stream_parser_feed(), switch_ivr_parse_event(), switch_ivr_sleep(), switch_ivr_tone_detect_session(), switch_ivr_wait_for_answer(), switch_log_vprintf(), switch_pgsql_next_result_timed(), switch_rtp_activate_ice(), switch_rtp_create(), switch_rtp_sync_stats(), switch_str_time(), switch_strftime_tz(), switch_stun_lookup(), switch_time_exp_tz_name(), switch_xml_locate_user_cache(), switch_xml_locate_user_merged(), switch_xml_std_datetime_check(), timer_init(), and tone_detect_set_total_time().

{
        return (globals.RUNNING == 1 && runtime.timestamp) ? runtime.timestamp : switch_time_now();
}

switch_time_t switch_mono_micro_time_now

(

void

)

Definition at line 315 of file switch_time.c.

References time_now().

Referenced by switch_core_init(), switch_core_uptime(), SWITCH_MODULE_LOAD_FUNCTION(), SWITCH_MODULE_RUNTIME_FUNCTION(), switch_time_ref(), and switch_time_sync().

{
        return time_now(-1);
}

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

Definition at line 3273 of file switch_core.c.

References switch_stream_system_fork(), switch_system(), and SWITCH_TRUE.

{
#ifdef WIN32
        stream->write_function(stream, "Capturing output not supported.\n");
        return switch_system(cmd, SWITCH_TRUE);
#else
        return switch_stream_system_fork(cmd, stream);
#endif

}

switch_status_t switch_strftime_tz	(	const char *	tz,
		const char *	format,
		char *	date,
		size_t	len,
		switch_time_t	thetime
	)

Definition at line 1458 of file switch_time.c.

References switch_lookup_timezone(), switch_micro_time_now(), SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, switch_strftime_nocheck(), tm2switchtime(), tztime(), zstr, and zstr_buf.

{
        time_t timep;

        const char *tz_name = tz;
        const char *tzdef;

        switch_size_t retsize;

        struct tm tm = { 0 };
        switch_time_exp_t stm;

        if (!thetime) {
                thetime = switch_micro_time_now();
        }

        timep = (thetime) / (int64_t) (1000000);

        if (!zstr(tz_name)) {
                tzdef = switch_lookup_timezone(tz_name);
        } else {
                /* We set the default timezone to GMT. */
                tz_name = "GMT";
                tzdef = "GMT";
        }

        if (tzdef) {                            /* The lookup of the zone may fail. */
                tztime(&timep, tzdef, &tm);
                tm2switchtime(&tm, &stm);
                switch_strftime_nocheck(date, &retsize, len, zstr(format) ? "%Y-%m-%d %T" : format, &stm);
                if (!zstr_buf(date)) {
                        return SWITCH_STATUS_SUCCESS;
                }
        }
        return SWITCH_STATUS_FALSE;
}

int switch_system	(	const char *	cmd,
		switch_bool_t	wait
	)

Definition at line 3194 of file switch_core.c.

References SCF_THREADED_SYSTEM_EXEC, switch_system_fork(), switch_system_thread(), and switch_test_flag.

Referenced by preprocess_exec(), switch_simple_email(), switch_stream_system(), and switch_stream_system_fork().

{
        int (*sys_p)(const char *cmd, switch_bool_t wait);

        sys_p = switch_test_flag((&runtime), SCF_THREADED_SYSTEM_EXEC) ? switch_system_thread : switch_system_fork;

        return sys_p(cmd, wait);

}

switch_status_t switch_time_exp_tz_name	(	const char *	tz,
		switch_time_exp_t *	tm,
		switch_time_t	thetime
	)

Definition at line 1427 of file switch_time.c.

References switch_lookup_timezone(), switch_micro_time_now(), SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, tm2switchtime(), tztime(), and zstr.

Referenced by switch_xml_std_datetime_check().

{
        struct tm xtm = { 0 };
        const char *tz_name = tz;
        const char *tzdef;
        time_t timep;

        if (!thetime) {
                thetime = switch_micro_time_now();
        }

        timep = (thetime) / (int64_t) (1000000);

        if (!zstr(tz_name)) {
                tzdef = switch_lookup_timezone(tz_name);
        } else {
                /* We set the default timezone to GMT. */
                tz_name = "GMT";
                tzdef = "GMT";
        }

        if (tzdef) {                            /* The lookup of the zone may fail. */
                tztime(&timep, tzdef, &xtm);
                tm2switchtime(&xtm, tm);
                return SWITCH_STATUS_SUCCESS;
        }

        return SWITCH_STATUS_FALSE;

}

switch_time_t switch_time_ref

(

void

)

Definition at line 576 of file switch_time.c.

References switch_mono_micro_time_now(), SYSTEM_TIME, and time_now().

Referenced by average_time(), and SWITCH_MODULE_RUNTIME_FUNCTION().

{
        if (SYSTEM_TIME) {
                /* Return system time reference */
                return time_now(0);
        } else {
                /* Return monotonic time reference (when available) */
                return switch_mono_micro_time_now();
        }
}

void switch_time_set_cond_yield

(

switch_bool_t

enable

)

Definition at line 372 of file switch_time.c.

References COND, MATRIX, and switch_time_sync().

Referenced by switch_load_core_config(), SWITCH_MODULE_LOAD_FUNCTION(), and switch_time_calibrate_clock().

{
        COND = enable ? 1 : 0;
        if (COND) {
                MATRIX = 1;
        }
        switch_time_sync();
}

void switch_time_set_matrix

(

switch_bool_t

enable

)

Definition at line 359 of file switch_time.c.

References MATRIX, and switch_time_sync().

Referenced by switch_load_core_config().

{
        MATRIX = enable ? 1 : 0;
        switch_time_sync();
}

void switch_time_set_monotonic

(

switch_bool_t

enable

)

Definition at line 330 of file switch_time.c.

References MONO, and switch_time_sync().

Referenced by switch_load_core_config().

{
#if (defined(HAVE_CLOCK_GETTIME) && defined(CLOCK_MONOTONIC)) || defined(WIN32)
        MONO = enable ? 1 : 0;
        switch_time_sync();
#else
        MONO = 0;
#endif
}

void switch_time_set_nanosleep

(

switch_bool_t

enable

)

Definition at line 365 of file switch_time.c.

References NANO.

Referenced by switch_load_core_config(), and SWITCH_MODULE_LOAD_FUNCTION().

{
#if defined(HAVE_CLOCK_NANOSLEEP)
        NANO = enable ? 1 : 0;
#endif
}

void switch_time_set_timerfd

(

int

enable

)

Definition at line 347 of file switch_time.c.

References switch_time_sync(), and TFD.

Referenced by switch_load_core_config().

{
#if defined(HAVE_TIMERFD_CREATE)
        TFD = enable;
        switch_time_sync();

#else
        TFD = 0;
#endif
}

void switch_time_set_use_system_time

(

switch_bool_t

enable

)

Definition at line 341 of file switch_time.c.

References SYSTEM_TIME.

Referenced by switch_load_core_config().

{
        SYSTEM_TIME = enable;
}

void switch_time_sync

(

void

)

Definition at line 589 of file switch_time.c.

References switch_runtime::offset, switch_runtime::reference, runtime, SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, switch_log_printf(), switch_mono_micro_time_now(), switch_time_now(), SYSTEM_TIME, time_now(), and switch_runtime::time_sync.

Referenced by switch_core_session_ctl(), switch_core_session_perform_destroy(), switch_core_session_sync_clock(), SWITCH_MODULE_RUNTIME_FUNCTION(), switch_time_set_cond_yield(), switch_time_set_matrix(), switch_time_set_monotonic(), switch_time_set_timerfd(), and timer_init().

{
        runtime.time_sync++; /* Indicate that we are syncing time right now */

        runtime.reference = switch_time_now();

        if (SYSTEM_TIME) {
                runtime.reference = time_now(0);
                runtime.offset = 0;
        } else {
                runtime.offset = runtime.reference - switch_mono_micro_time_now(); /* Get the offset between system time and the monotonic clock (when available) */
                runtime.reference = time_now(runtime.offset);
        }

        if (runtime.reference - last_time > 1000000 || last_time == 0) {
                if (SYSTEM_TIME) {
                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "Clock is already configured to always report system time.\n");
                } else {
                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "Clock synchronized to system time.\n");
                }
        }
        last_time = runtime.reference;

        runtime.time_sync++; /* Indicate that we are finished syncing time */
}