Misc
[Core Library]

Defines
#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.
switch_bool_t	switch_core_ready (void)
	Determines if the core is ready to take calls.
switch_core_flag_t	switch_core_flags (void)
	return core flags
switch_status_t	switch_core_management_exec (char *relative_oid, switch_management_action_t action, char *data, switch_size_t datalen)
	Execute a management operation.
int32_t	set_high_priority (void)
	Set the maximum priority the process can obtain.
int32_t	change_user_group (const char *user, const char *group)
	Change user and/or group of the running process.
void	switch_core_runtime_loop (int bg)
	Run endlessly until the system is shutdown.
switch_status_t	switch_core_set_console (const char *console)
	Set the output console to the desired file.
void	switch_core_measure_time (switch_time_t total_ms, switch_core_time_duration_t *duration)
	Breakdown a number of milliseconds into various time spec.
switch_time_t	switch_core_uptime (void)
	Number of microseconds the system has been up.
int32_t	switch_core_session_ctl (switch_session_ctl_t cmd, int32_t *val)
	send a control message to the core
FILE *	switch_core_get_console (void)
	Get the output console.
void	switch_core_launch_thread (void *(*func)(switch_thread_t *, void *), void *obj, switch_memory_pool_t *pool)
	Launch a thread.
void	switch_core_set_globals (void)
	Initiate Globals.
uint8_t	switch_core_session_compare (switch_core_session_t *a, switch_core_session_t *b)
	indicate if 2 sessions are the same type
uint8_t	switch_core_session_check_interface (switch_core_session_t *session, const switch_endpoint_interface_t *endpoint_interface)
switch_hash_index_t *	switch_core_mime_index (void)
const char *	switch_core_mime_ext2type (const char *ext)
switch_status_t	switch_core_mime_add_type (const char *type, const char *ext)
switch_loadable_module_interface_t *	switch_loadable_module_create_module_interface (switch_memory_pool_t *pool, const char *name)
void *	switch_loadable_module_create_interface (switch_loadable_module_interface_t *mod, switch_module_interface_name_t iname)
switch_time_t	switch_timestamp_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)
void	switch_time_sync (void)
time_t	switch_timestamp (time_t *t)
switch_status_t	switch_strftime_tz (const char *tz, const char *format, char *date, size_t len)
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)
uint32_t	switch_core_max_dtmf_duration (uint32_t duration)
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)

---

Define Documentation

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

---

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 { #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) { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "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) { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "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 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) { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "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) { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "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) { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "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) { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "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) { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Failed to change uid!\n"); return -1; } } #endif return 0; }

Here is the call graph for this function:

int32_t set_high_priority (  void   )

Set the maximum priority the process can obtain. Returns: 0 on success { #ifdef WIN32 SetPriorityClass(GetCurrentProcess(), HIGH_PRIORITY_CLASS); #else #ifdef USE_SETRLIMIT struct rlimit lim = { RLIM_INFINITY, RLIM_INFINITY }; #endif #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 = 1; if (sched_setscheduler(0, SCHED_RR, &sched)) { sched.sched_priority = 0; if (sched_setscheduler(0, SCHED_OTHER, &sched)) { return -1; } } #endif #ifdef HAVE_SETPRIORITY /* * setpriority() works on FreeBSD (6.2), nice() doesn't */ if (setpriority(PRIO_PROCESS, getpid(), -10) < 0) { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Could not set nice level\n"); } #else if (nice(-10) != -10) { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Could not set nice level\n"); } #endif #ifdef USE_SETRLIMIT /* * The amount of memory which can be mlocked is limited for non-root users. * FS will segfault (= hitting the limit) soon after mlockall has been called * and we've switched to a different user. * So let's try to remove the mlock limit here... */ if (setrlimit(RLIMIT_MEMLOCK, &lim) < 0) { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Failed to disable memlock limit, application may crash if run as non-root user!\n"); } #endif #ifdef USE_MLOCKALL /* * Pin memory pages to RAM to prevent being swapped to disk */ mlockall(MCL_CURRENT | MCL_FUTURE); #endif #endif return 0; }

Here is the call graph for this function:

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

{ switch_network_list_t *list; uint32_t ip, net, mask, bits; switch_bool_t ok = SWITCH_FALSE; switch_mutex_lock(runtime.global_mutex); switch_inet_pton(AF_INET, ip_str, &ip); ip = htonl(ip); if ((list = switch_core_hash_find(IP_LIST.hash, list_name))) { ok = switch_network_list_validate_ip_token(list, ip, token); } else if (strchr(list_name, '/')) { switch_parse_cidr(list_name, &net, &mask, &bits); ok = switch_test_subnet(ip, net, mask); } switch_mutex_unlock(runtime.global_mutex); return ok; }

Here is the call graph for this function:

switch_status_t switch_console_set_alias (  const char *  string  )

{ return SWITCH_STATUS_FALSE; }

switch_status_t switch_console_set_complete (  const char *  string  )

{ return SWITCH_STATUS_FALSE; }

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

{ if (duration) { if (duration < SWITCH_DEFAULT_DTMF_DURATION) { duration = SWITCH_DEFAULT_DTMF_DURATION; } runtime.default_dtmf_duration = duration; } return runtime.default_dtmf_duration; }

switch_core_flag_t switch_core_flags (  void   )

return core flags Returns: core flags { return runtime.flags; }

FILE* switch_core_get_console (  void   )

Get the output console. Returns: the FILE stream { return runtime.console; }

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

Launch a thread.

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

Here is the call graph for this function:

uint32_t switch_core_max_dtmf_duration (  uint32_t  duration  )

{ if (duration) { if (duration > SWITCH_MAX_DTMF_DURATION) { duration = SWITCH_MAX_DTMF_DURATION; } runtime.max_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 { 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   )

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

Here is the call graph for this function:

void switch_core_memory_reclaim_all (  void   )

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

Here is the call graph for this function:

void switch_core_memory_reclaim_events (  void   )

{ 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) { free(pop); } while (switch_queue_trypop(EVENT_RECYCLE_QUEUE, &pop) == SWITCH_STATUS_SUCCESS) { free(pop); } }

Here is the call graph for this function:

void switch_core_memory_reclaim_logger (  void   )

{ void *pop; int size = switch_queue_size(LOG_RECYCLE_QUEUE); switch_log_printf(SWITCH_CHANNEL_LOG, 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) { free(pop); } }

Here is the call graph for this function:

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

{ const char *check; switch_status_t status = SWITCH_STATUS_FALSE; switch_assert(type); switch_assert(ext); check = (const char *) switch_core_hash_find(runtime.mime_types, ext); if (!check) { char *ptype = switch_core_permanent_strdup(type); char *ext_list = strdup(ext); int argc = 0; char *argv[20] = { 0 }; int x; switch_assert(ext_list); if ((argc = switch_separate_string(ext_list, ' ', argv, (sizeof(argv) / sizeof(argv[0]))))) { for (x = 0; x < argc; x++) { if (argv[x] && ptype) { switch_core_hash_insert(runtime.mime_types, argv[x], ptype); } } status = SWITCH_STATUS_SUCCESS; } free(ext_list); } return status; }

Here is the call graph for this function:

const char* switch_core_mime_ext2type (  const char *  ext  )

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

Here is the call graph for this function:

switch_hash_index_t* switch_core_mime_index (  void   )

{ return switch_hash_first(NULL, runtime.mime_types); }

Here is the call graph for this function:

switch_bool_t switch_core_ready (  void   )

Determines if the core is ready to take calls. Returns: SWITCH_TRUE or SWITCH_FALSE { return (switch_test_flag((&runtime), SCF_SHUTTING_DOWN) || switch_test_flag((&runtime), SCF_NO_NEW_SESSIONS)) ? SWITCH_FALSE : SWITCH_TRUE; }

void switch_core_runtime_loop (  int  bg  )

Run endlessly until the system is shutdown. Parameters: bg  divert console to the background { #ifdef WIN32 HANDLE shutdown_event; char path[256] = ""; #endif if (bg) { bg = 0; #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(); } }

Here is the call graph for this function:

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

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

indicate if 2 sessions are the same type Parameters: a  the first session b  the second session Returns: TRUE or FALSE { 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, int32_t *  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 { if (switch_test_flag((&runtime), SCF_SHUTTING_DOWN)) { return -1; } switch (cmd) { case SCSC_SYNC_CLOCK: switch_time_sync(); *val = 0; break; case SCSC_PAUSE_INBOUND: if (*val) { switch_set_flag((&runtime), SCF_NO_NEW_SESSIONS); } else { switch_clear_flag((&runtime), SCF_NO_NEW_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_SHUTDOWN_ELEGANT: { int x = 19; switch_set_flag((&runtime), SCF_SHUTDOWN_REQUESTED); switch_set_flag((&runtime), SCF_NO_NEW_SESSIONS); while(runtime.running && switch_test_flag((&runtime), SCF_SHUTDOWN_REQUESTED) && switch_core_session_count()) { switch_yield(500000); if (++x == 20) { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "Shutdown in progress.....\n"); x = 0; } } if (switch_test_flag((&runtime), SCF_SHUTDOWN_REQUESTED)) { if (*val) { 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"); } 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_SHUTDOWN: if (*val) { 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"); } runtime.running = 0; break; case SCSC_CHECK_RUNNING: *val = runtime.running; break; case SCSC_LOGLEVEL: if (*val > -1) { runtime.hard_log_level = *val; } if (runtime.hard_log_level > SWITCH_LOG_DEBUG) { runtime.hard_log_level = SWITCH_LOG_DEBUG; } *val = runtime.hard_log_level; break; case SCSC_MAX_SESSIONS: *val = switch_core_session_limit(*val); break; case SCSC_LAST_SPS: *val = runtime.sps_last; break; case SCSC_MAX_DTMF_DURATION: *val = switch_core_max_dtmf_duration(*val); break; case SCSC_DEFAULT_DTMF_DURATION: *val = switch_core_default_dtmf_duration(*val); break; case SCSC_SPS: switch_mutex_lock(runtime.throttle_mutex); if (*val > 0) { runtime.sps_total = *val; } *val = runtime.sps_total; switch_mutex_unlock(runtime.throttle_mutex); break; case SCSC_RECLAIM: switch_core_memory_reclaim_all(); *val = 0; break; } return 0; }

Here is the call graph for this function:

switch_status_t switch_core_set_console (  const char *  console  )

Set the output console to the desired file. Parameters: console  the file path { 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. { #define BUFSIZE 1024 #ifdef WIN32 char lpPathBuffer[BUFSIZE]; DWORD dwBufSize = BUFSIZE; char base_dir[1024]; char *lastbacklash; GetModuleFileName(NULL, base_dir, BUFSIZE); lastbacklash = strrchr(base_dir, '\\'); base_dir[(lastbacklash - base_dir)] = '\0'; #else char base_dir[1024] = SWITCH_PREFIX_DIR; #endif 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); } if (!SWITCH_GLOBAL_dirs.mod_dir && (SWITCH_GLOBAL_dirs.mod_dir = (char *) malloc(BUFSIZE))) { #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.conf_dir && (SWITCH_GLOBAL_dirs.conf_dir = (char *) malloc(BUFSIZE))) { #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))) { #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.storage_dir && (SWITCH_GLOBAL_dirs.storage_dir = (char *) malloc(BUFSIZE))) { #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.db_dir && (SWITCH_GLOBAL_dirs.db_dir = (char *) malloc(BUFSIZE))) { #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))) { #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))) { #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))) { #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.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); switch_snprintf(SWITCH_GLOBAL_dirs.temp_dir, BUFSIZE, "%s", lpPathBuffer); #else switch_snprintf(SWITCH_GLOBAL_dirs.temp_dir, BUFSIZE, "%s", "/tmp/"); #endif #endif } switch_assert(SWITCH_GLOBAL_dirs.base_dir); switch_assert(SWITCH_GLOBAL_dirs.mod_dir); switch_assert(SWITCH_GLOBAL_dirs.conf_dir); switch_assert(SWITCH_GLOBAL_dirs.log_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.temp_dir); }

Here is the call graph for this function:

void switch_core_setrlimits (  void   )

{ #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 http://jira.freeswitch.org */ #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); #ifndef __OpenBSD__ setrlimit(RLIMIT_AS, &rlp); #endif #endif return; }

switch_time_t switch_core_uptime (  void   )

Number of microseconds the system has been up. Returns: a number of microseconds { return switch_timestamp_now() - runtime.initiated; }

Here is the call graph for this function:

void switch_load_network_lists (  switch_bool_t  reload  )

{ switch_xml_t xml = NULL, x_lists = NULL, x_list = NULL, x_node = NULL, cfg = NULL; switch_network_list_t *list; 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, IP_LIST.pool); 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 (switch_strlen_zero(name)) { continue; } if (dft) { default_type = switch_true(dft); } if (switch_network_list_create(&list, 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 ut; 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); 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); if (switch_network_list_add_cidr_token(list, user_cidr, ok, token) == SWITCH_STATUS_SUCCESS) { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "Adding %s (%s) [%s] to list %s\n", user_cidr, ok ? "allow" : "deny", switch_str_nil(token), name); } else { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error Adding %s (%s) [%s] to list %s\n", user_cidr, ok ? "allow" : "deny", switch_str_nil(token), name); } free(token); } } switch_xml_free(xml_root); } else if (cidr) { if (switch_network_list_add_cidr(list, cidr, ok) == SWITCH_STATUS_SUCCESS) { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "Adding %s (%s) to list %s\n", cidr, ok ? "allow" : "deny", name); } else { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error Adding %s (%s) to list %s\n", cidr, ok ? "allow" : "deny", name); } } else if (host && mask) { if (switch_network_list_add_host_mask(list, host, mask, ok) == SWITCH_STATUS_SUCCESS) { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "Adding %s/%s (%s) to list %s\n", host, mask, ok ? "allow" : "deny", name); } } switch_core_hash_insert(IP_LIST.hash, name, list); } } } switch_xml_free(xml); }