Compatability and Helper Code. More...

#include <switch.h>
#include <math.h>

Include dependency graph for switch_utils.h:

This graph shows which files directly or indirectly include this file:

Data Structures
struct	switch_network_port_range

union	ip_t

struct	switch_http_request_s

struct	switch_cputime

Macros
#define	SWITCH_URL_UNSAFE "\r\n #%&+:;<=>?@[\\]^`{\|}\""

#define	MAX_NETWORK_PORTS 10

#define	switch_goto_status(_status, _label) status = _status; goto _label

#define	switch_goto_int(_n, _i, _label) _n = _i; goto _label

#define	switch_samples_per_packet(rate, interval) ((uint32_t)((float)rate / (1000.0f / (float)interval)))

#define	SWITCH_SMAX 32767

#define	SWITCH_SMIN -32768

#define	switch_normalize_to_16bit(n) if (n > SWITCH_SMAX) n = SWITCH_SMAX; else if (n < SWITCH_SMIN) n = SWITCH_SMIN;

#define	switch_codec2str(codec, buf, len)

#define	zstr(x) _zstr(x)

#define	switch_strlen_zero(x) zstr(x)

#define	switch_strlen_zero_buf(x) zstr_buf(x)

#define	zstr_buf(s) (*(s) == '\0')

#define	zset(_a, _b) if (!zstr(_b)) _a = _b

#define	switch_arraylen(_a) (sizeof(_a) / sizeof(_a[0]))

#define	switch_split(_data, _delim, _array) switch_separate_string(_data, _delim, _array, switch_arraylen(_array))

#define	switch_split_cheap(_data, _delim, _array, _larray) switch_separate_string_cheap(_data, _delim, (const char **)_array, _larray, switch_arraylen(_array))

#define	switch_is_valid_rate(_tmp) (_tmp == 8000 \|\| _tmp == 12000 \|\| _tmp == 16000 \|\| _tmp == 24000 \|\| _tmp == 32000 \|\| _tmp == 11025 \|\| _tmp == 22050 \|\| _tmp == 44100 \|\| _tmp == 48000)

#define	switch_true_buf(expr)

#define	SWITCH_STATUS_IS_BREAK(x) (x == SWITCH_STATUS_BREAK \|\| x == 730035 \|\| x == 35 \|\| x == SWITCH_STATUS_INTR)

#define	switch_errno() errno

#define	is_dtmf(key) ((key > 47 && key < 58) \|\| (key > 64 && key < 69) \|\| (key > 96 && key < 101) \|\| key == 35 \|\| key == 42 \|\| key == 87 \|\| key == 119 \|\| key == 70 \|\| key == 102)
	determine if a character is a valid DTMF key More...

#define	end_of(_s) (_s == '\0' ? _s : _s + strlen(_s) - 1)

#define	end_of_p(_s) (*_s == '\0' ? _s : _s + strlen(_s) - 1)

#define	switch_test_flag(obj, flag) ((obj)->flags & flag)
	Test for the existance of a flag on an arbitary object. More...

#define	switch_set_flag(obj, flag) (obj)->flags \|= (flag)
	Set a flag on an arbitrary object. More...

#define	switch_set_flag_locked(obj, flag)
	Set a flag on an arbitrary object while locked. More...

#define	switch_clear_flag_locked(obj, flag) switch_mutex_lock((obj)->flag_mutex); (obj)->flags &= ~(flag); switch_mutex_unlock((obj)->flag_mutex);
	Clear a flag on an arbitrary object. More...

#define	switch_clear_flag(obj, flag) (obj)->flags &= ~(flag)
	Clear a flag on an arbitrary object while locked. More...

#define	switch_copy_flags(dest, src, flags) (dest)->flags &= ~(flags); (dest)->flags \|= ((src)->flags & (flags))
	Copy flags from one arbitrary object to another. More...

#define	switch_set_string(_dst, _src) switch_copy_string(_dst, _src, sizeof(_dst))

#define	switch_safe_free(it) if (it) {free(it);it=NULL;}
	Free a pointer and set it to NULL unless it already is NULL. More...

#define	switch_str_nil(s) (s ? s : "")
	Make a null string a blank string instead. More...

#define	switch_yield(ms) switch_sleep(ms);
	Wait a desired number of microseconds and yield the CPU. More...

#define	switch_time_from_sec(sec) ((switch_time_t)(sec) * 1000000)

#define	SWITCH_DECLARE_GLOBAL_STRING_FUNC(fname, vname)
	Declares a function designed to set a dynamic global string. More...

#define	SWITCH_READ_ACCEPTABLE(status) (status == SWITCH_STATUS_SUCCESS \|\| status == SWITCH_STATUS_BREAK \|\| status == SWITCH_STATUS_INUSE)

#define	switch_calc_video_fps(fpsP, fps) switch_calc_fps(fpsP, fps, 90000)

#define	switch_network_list_add_cidr(_list, _cidr_str, _ok) switch_network_list_add_cidr_token(_list, _cidr_str, _ok, NULL)

#define	switch_network_list_validate_ip(_list, _ip) switch_network_list_validate_ip_token(_list, _ip, NULL);

#define	switch_test_subnet(_ip, _net, _mask) (_mask ? ((_net & _mask) == (_ip & _mask)) : _net ? _net == _ip : 1)

#define	switch_malloc(ptr, len) (void)(switch_assert(((ptr) = malloc((len)))),ptr)

#define	switch_zmalloc(ptr, len) (void)(switch_assert((ptr = calloc(1, (len)))),ptr)

#define	switch_strdup(ptr, s) (void)(switch_assert(((ptr) = strdup((s)))),ptr)

#define	DUMP_EVENT(_e) {char *event_str;switch_event_serialize(_e, &event_str, SWITCH_FALSE);switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "DUMP\n%s\n", event_str);free(event_str);}

#define	switch_inet_ntop inet_ntop

Typedefs
typedef struct switch_network_port_range	switch_network_port_range_t

typedef switch_network_port_range_t *	switch_network_port_range_p

typedef struct switch_http_request_s	switch_http_request_t

Enumerations
enum	switch_uri_flags { SWITCH_URI_NUMERIC_HOST = 1, SWITCH_URI_NUMERIC_PORT = 2, SWITCH_URI_NO_SCOPE = 4 }
	flags to be used with switch_build_uri() More...

Functions
static char *	switch_get_hex_bytes (switch_byte_t buf, switch_size_t datalen, char new_buf, switch_size_t new_datalen)

static uint32_t	switch_round_to_step (uint32_t num, uint32_t step)

static uint32_t	switch_toupper (uint32_t eax)

static uint32_t	switch_tolower (uint32_t eax)

static void	switch_toupper_max (char *s)

static void	switch_tolower_max (char *s)

int	old_switch_toupper (int c)

int	old_switch_tolower (int c)

int	switch_isalnum (int c)

int	switch_isalpha (int c)

int	switch_iscntrl (int c)

int	switch_isdigit (int c)

int	switch_isgraph (int c)

int	switch_islower (int c)

int	switch_isprint (int c)

int	switch_ispunct (int c)

int	switch_isspace (int c)

int	switch_isupper (int c)

int	switch_isxdigit (int c)

switch_bool_t	switch_testv6_subnet (ip_t _ip, ip_t _net, ip_t _mask)

char *	switch_print_host (switch_sockaddr_t addr, char buf, switch_size_t len)

static _Check_return_ int	_zstr (_In_opt_z_ const char *s)
	Test for NULL or zero length string. More...

static switch_bool_t	switch_is_moh (const char *s)

static char *	switch_strchr_strict (const char in, char find, const char allowed)

static int	switch_string_has_escaped_data (const char *in)

switch_status_t	switch_b64_encode (unsigned char in, switch_size_t ilen, unsigned char out, switch_size_t olen)

switch_size_t	switch_b64_decode (const char in, char out, switch_size_t olen)

char *	switch_amp_encode (char s, char buf, switch_size_t len)

static char *	switch_print_bits (const unsigned char byte, char buf, switch_size_t buflen)

static switch_bool_t	switch_is_digit_string (const char *s)

static char	switch_itodtmf (char i)

static int	switch_dtmftoi (char *s)

static uint32_t	switch_known_bitrate (switch_payload_t payload)

switch_size_t	switch_fd_read_line (int fd, char *buf, switch_size_t len)

switch_size_t	switch_fd_read_dline (int fd, char *buf, switch_size_t len)

switch_size_t	switch_fp_read_dline (FILE fd, char buf, switch_size_t len)

switch_status_t	switch_frame_alloc (switch_frame_t **frame, switch_size_t size)

switch_status_t	switch_frame_dup (switch_frame_t orig, switch_frame_t *clone)

switch_status_t	switch_frame_free (switch_frame_t **frame)

switch_bool_t	switch_is_uint_in_range (const char *str, unsigned int from, unsigned int to)
	Check if a 32 bit unsigned number is in a range. More...

switch_bool_t	switch_is_number (const char *str)

switch_bool_t	switch_is_leading_number (const char *str)

char *	switch_find_parameter (const char str, const char param, switch_memory_pool_t *pool)

static switch_bool_t	switch_true (const char *expr)
	Evaluate the truthfullness of a string expression. More...

static switch_byte_t	switch_true_byte (const char *expr)

static int	switch_false (const char *expr)
	Evaluate the falsefullness of a string expression. More...

switch_status_t	switch_resolve_host (const char host, char buf, size_t buflen)

switch_status_t	switch_find_local_ip (_Out_opt_bytecapcount_(len) char buf, _In_ int len, _In_opt_ int mask, _In_ int family)
	find local ip of the box More...

switch_status_t	switch_find_interface_ip (_Out_opt_bytecapcount_(len) char buf, _In_ int len, _In_opt_ int mask, _In_ const char *ifname, _In_ int family)
	find primary ip of the specified interface More...

char *	get_addr (char buf, switch_size_t len, struct sockaddr sa, socklen_t salen)
	find the char representation of an ip adress More...

char *	get_addr6 (char buf, switch_size_t len, struct sockaddr_in6 sa, socklen_t salen)

int	get_addr_int (switch_sockaddr_t *sa)

int	switch_cmp_addr (switch_sockaddr_t sa1, switch_sockaddr_t sa2, switch_bool_t ip_only)

int	switch_cp_addr (switch_sockaddr_t sa1, switch_sockaddr_t sa2)

unsigned short	get_port (struct sockaddr *sa)
	get the port number of an ip address More...

int	switch_build_uri (char uri, switch_size_t size, const char scheme, const char user, const switch_sockaddr_t sa, int flags)
	build a URI string from components More...

static int	switch_errno_is_break (int errcode)

const char *	switch_priority_name (switch_priority_t priority)
	Return a printable name of a switch_priority_t. More...

char	switch_rfc2833_to_char (int event)
	Return the RFC2833 character based on an event id. More...

unsigned char	switch_char_to_rfc2833 (char key)
	Return the RFC2833 event based on an key character. More...

static char *	switch_sanitize_number (char *number)

static switch_bool_t	switch_string_var_check (char *s, switch_bool_t disable)

static switch_bool_t	switch_string_var_check_const (const char *s)

static char *	switch_var_clean_string (char *s)

static char *	switch_clean_string (char *s)

static char *	switch_clean_name_string (char *s)

static int	switch_safe_atoi (const char *nptr, int dft)
	Turn a string into an integer (default if NULL) More...

static long int	switch_safe_atol (const char *nptr, long int dft)
	Turn a string into a long integer (default if NULL) More...

static long long int	switch_safe_atoll (const char *nptr, long long int dft)
	Turn a string into a long long integer (default if NULL) More...

static char *	switch_safe_strdup (const char *it)

static char *	switch_lc_strdup (const char *it)

static char *	switch_uc_strdup (const char *it)

static switch_bool_t	switch_strstr (char s, char q)
	Test if one string is inside another with extra case checking. More...

switch_time_t	switch_str_time (const char *in)
	Converts a string representation of a date into a switch_time_t. More...

unsigned int	switch_separate_string (_In_ char buf, char delim, _Post_count_(return) char *array, unsigned int arraylen)
	Separate a string into an array based on a character delimiter. More...

unsigned int	switch_separate_string_string (char buf, char delim, _Post_count_(return) char **array, unsigned int arraylen)

unsigned int	switch_separate_string_cheap (_In_ const char buf, char delim, _Post_count_(return) const char *array, _Post_count_(return) unsigned int larray[], unsigned int arraylen)
	Separate a string into an array based on a character delimiter, no memory corruption! DOESN'T support removing quotes like what's in switch_separate_string()! More...

char *	switch_strip_spaces (char *str, switch_bool_t dup)

char *	switch_strip_whitespace (const char *str)

char *	switch_strip_commas (char in, char out, switch_size_t len)

char *	switch_strip_nonnumerics (char in, char out, switch_size_t len)

char *	switch_separate_paren_args (char *str)

const char *	switch_stristr (const char instr, const char str)

switch_bool_t	switch_is_lan_addr (const char *ip)

char *	switch_replace_char (char *str, char from, char to, switch_bool_t dup)

switch_bool_t	switch_ast2regex (const char pat, char rbuf, size_t len)

char *	switch_pool_strip_whitespace (switch_memory_pool_t pool, const char str)

char *	switch_escape_char (switch_memory_pool_t pool, char in, const char *delim, char esc)
	Escape a string by prefixing a list of characters with an escape character. More...

char *	switch_escape_string (const char in, char out, switch_size_t outlen)

char *	switch_escape_string_pool (const char in, switch_memory_pool_t pool)

int	switch_socket_waitfor (switch_pollfd_t *poll, int ms)
	Wait for a socket. More...

const char *	switch_cut_path (const char *in)
	Create a pointer to the file name in a given file path eliminating the directory name. More...

char *	switch_string_replace (const char string, const char search, const char *replace)

switch_status_t	switch_string_match (const char string, size_t string_len, const char search, size_t search_len)

int	switch_strcasecmp_any (const char *str,...)

char *	switch_util_quote_shell_arg (const char *string)
	Quote shell argument. More...

char *	switch_util_quote_shell_arg_pool (const char string, switch_memory_pool_t pool)
	Quote shell argument, allocating from pool if provided. More...

static int32_t	switch_calc_bitrate (int w, int h, float quality, double fps)

static void	switch_calc_fps (switch_fps_t *fpsP, float fps, int samplerate)

static int32_t	switch_parse_bandwidth_string (const char *bwv)

static uint32_t	switch_parse_cpu_string (const char *cpu)

static int	switch_needs_url_encode (const char *s)

char *	switch_url_encode_opt (const char url, char buf, size_t len, switch_bool_t double_encode)

char *	switch_url_encode (const char url, char buf, size_t len)

char *	switch_url_decode (char *s)

char *	switch_core_url_encode_opt (switch_memory_pool_t pool, const char url, switch_bool_t double_encode)

char *	switch_core_url_encode (switch_memory_pool_t pool, const char url)

char *	switch_core_session_url_encode_opt (switch_core_session_t session, const char url, switch_bool_t double_encode)

char *	switch_core_session_url_encode (switch_core_session_t session, const char url)

switch_bool_t	switch_simple_email (const char to, const char from, const char headers, const char body, const char file, const char convert_cmd, const char *convert_ext)

char *	switch_find_end_paren (const char *s, char open, char close)

static void	switch_separate_file_params (const char file, char file_portion, char *params_portion)

static switch_bool_t	switch_is_file_path (const char *file)

static int	switch_filecmp (const char a, const char b)

static const char *	switch_parse_audio_col (switch_audio_col_t col)

int	switch_parse_cidr (const char string, ip_t ip, ip_t mask, uint32_t bitp)

switch_status_t	switch_network_list_create (switch_network_list_t *list, const char name, switch_bool_t default_type, switch_memory_pool_t *pool)

switch_status_t	switch_network_list_add_cidr_token (switch_network_list_t list, const char cidr_str, switch_bool_t ok, const char *token)

char *	switch_network_ipv4_mapped_ipv6_addr (const char *ip_str)

switch_status_t	switch_network_list_add_host_mask (switch_network_list_t list, const char host, const char *mask_str, switch_bool_t ok)

switch_status_t	switch_network_list_add_cidr_port_token (switch_network_list_t list, const char cidr_str, switch_bool_t ok, const char *token, switch_network_port_range_p port)

switch_status_t	switch_network_list_add_host_port_mask (switch_network_list_t list, const char host, const char *mask_str, switch_bool_t ok, switch_network_port_range_p port)

switch_bool_t	switch_network_list_validate_ip_port_token (switch_network_list_t list, uint32_t ip, int port, const char *token)

switch_bool_t	switch_network_list_validate_ip6_port_token (switch_network_list_t list, ip_t ip, int port, const char *token)

switch_bool_t	switch_network_list_validate_ip_token (switch_network_list_t list, uint32_t ip, const char *token)

switch_bool_t	switch_network_list_validate_ip6_token (switch_network_list_t list, ip_t ip, const char *token)

int	switch_inet_pton (int af, const char src, void dst)

const char *	switch_dow_int2str (int val)

int	switch_dow_str2int (const char *exp)

switch_bool_t	switch_dow_cmp (const char *exp, int val)

int	switch_number_cmp (const char *exp, int val)

int	switch_tod_cmp (const char *exp, int val)

int	switch_fulldate_cmp (const char exp, switch_time_t ts)

void	switch_split_date (const char exp, int year, int month, int day)

void	switch_split_time (const char exp, int hour, int min, int sec)

int	switch_split_user_domain (char in, char user, char *domain)
	Split a user string as user and domain. More...

void *	switch_calloc (size_t nmemb, size_t size)

char *	switch_uuid_str (char *buf, switch_size_t len)

char *	switch_format_number (const char *num)

unsigned int	switch_atoui (const char *nptr)

unsigned long	switch_atoul (const char *nptr)

char *	switch_strerror_r (int errnum, char *buf, switch_size_t buflen)

int	switch_wait_sock (switch_os_socket_t sock, uint32_t ms, switch_poll_t flags)

int	switch_wait_socklist (switch_waitlist_t *waitlist, uint32_t len, uint32_t ms)

switch_status_t	switch_http_parse_header (char buffer, uint32_t datalen, switch_http_request_t request)

void	switch_http_free_request (switch_http_request_t *request)

void	switch_http_dump_request (switch_http_request_t *request)

void	switch_http_parse_qs (switch_http_request_t request, char qs)

switch_status_t	switch_frame_buffer_free (switch_frame_buffer_t fb, switch_frame_t *frameP)

switch_status_t	switch_frame_buffer_dup (switch_frame_buffer_t fb, switch_frame_t orig, switch_frame_t **clone)

switch_status_t	switch_frame_buffer_destroy (switch_frame_buffer_t **fbP)

switch_status_t	switch_frame_buffer_create (switch_frame_buffer_t **fbP, switch_size_t qlen)

switch_status_t	switch_frame_buffer_push (switch_frame_buffer_t fb, void ptr)

switch_status_t	switch_frame_buffer_trypush (switch_frame_buffer_t fb, void ptr)

switch_status_t	switch_frame_buffer_pop (switch_frame_buffer_t fb, void *ptr)

switch_status_t	switch_frame_buffer_trypop (switch_frame_buffer_t fb, void *ptr)

int	switch_frame_buffer_size (switch_frame_buffer_t *fb)

void	switch_getcputime (switch_cputime *t)

char *	switch_html_strip (const char *str)

unsigned long	switch_getpid (void)

switch_status_t	switch_digest (const char digest_name, unsigned char digest, const void input, switch_size_t inputLen, unsigned int *outputlen)

switch_status_t	switch_digest_string (const char digest_name, char digest_str, const void input, switch_size_t inputLen, unsigned int *outputlen)

cJSON *	switch_jwt_verify (const char secret, const char token)

char *	switch_jwt_sign (const char secret, const uint8_t payload, switch_size_t size)

char *	switch_must_strdup (const char *_s)

const char *	switch_memory_usage_stream (switch_stream_handle_t *stream)

Detailed Description

Compatability and Helper Code.

Just a miscelaneaous set of general utility/helper functions.

Definition in file switch_utils.h.

Macro Definition Documentation

◆ DUMP_EVENT

#define DUMP_EVENT ( _e ) {char *event_str;switch_event_serialize(_e, &event_str, SWITCH_FALSE);switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "DUMP\n%s\n", event_str);free(event_str);}

Definition at line 1431 of file switch_utils.h.

Referenced by switch_ivr_uuid_bridge().

◆ end_of

#define end_of ( _s ) *(*_s == '\0' ? _s : _s + strlen(_s) - 1)

Definition at line 685 of file switch_utils.h.

Referenced by generate_m(), parse_presence_data_cols(), switch_channel_get_cap_string(), switch_channel_get_flag_string(), switch_channel_set_timestamps(), switch_channel_set_variable_strip_quotes_var_check(), switch_core_media_gen_local_sdp(), switch_core_perform_file_open(), and switch_img_write_text_img().

◆ end_of_p

#define end_of_p ( _s ) (*_s == '\0' ? _s : _s + strlen(_s) - 1)

Definition at line 686 of file switch_utils.h.

Referenced by find_pt(), switch_cache_db_execute_sql_chunked(), switch_channel_expand_variables_check(), switch_console_complete(), switch_core_media_filter_sdp(), switch_core_perform_file_open(), switch_core_url_encode_opt(), switch_event_expand_headers_check(), switch_needs_url_encode(), and switch_url_encode_opt().

◆ is_dtmf

#define is_dtmf ( key ) ((key > 47 && key < 58) || (key > 64 && key < 69) || (key > 96 && key < 101) || key == 35 || key == 42 || key == 87 || key == 119 || key == 70 || key == 102)

determine if a character is a valid DTMF key

Parameters

key	the key to test

Returns: TRUE or FALSE

Definition at line 683 of file switch_utils.h.

Referenced by meta_on_dtmf(), speech_thread(), switch_channel_queue_dtmf(), switch_channel_queue_dtmf_string(), switch_core_session_send_dtmf(), switch_core_session_send_dtmf_string(), and switch_ivr_bind_dtmf_meta_session().

◆ MAX_NETWORK_PORTS

#define MAX_NETWORK_PORTS 10

Definition at line 49 of file switch_utils.h.

Referenced by is_port_in_node(), switch_load_network_lists(), and switch_network_port_range_to_string().

◆ switch_arraylen

#define switch_arraylen ( _a ) (sizeof(_a) / sizeof(_a[0]))

Definition at line 374 of file switch_utils.h.

Referenced by switch_dow_int2str(), and switch_dow_str2int().

◆ switch_calc_video_fps

#define switch_calc_video_fps	(	fpsP,
		fps
	)	switch_calc_fps(fpsP, fps, 90000)

Definition at line 1135 of file switch_utils.h.

Referenced by video_bug_thread(), and video_write_thread().

◆ switch_clear_flag

#define switch_clear_flag	(	obj,
		flag
	)	(obj)->flags &= ~(flag)

Clear a flag on an arbitrary object while locked.

Parameters

obj	the object to test
flag	the or'd list of flags to clear

Definition at line 724 of file switch_utils.h.

◆ switch_clear_flag_locked

#define switch_clear_flag_locked	(	obj,
		flag
	)	switch_mutex_lock((obj)->flag_mutex); (obj)->flags &= ~(flag); switch_mutex_unlock((obj)->flag_mutex);

Clear a flag on an arbitrary object.

Parameters

obj	the object to test
flag	the or'd list of flags to clear

Definition at line 717 of file switch_utils.h.

Referenced by switch_core_file_close(), switch_core_file_pre_close(), switch_core_file_read(), switch_core_perform_file_open(), switch_ivr_deactivate_unicast(), switch_ivr_play_file(), switch_ivr_process_fh(), switch_ivr_record_file_event(), and unicast_thread_run().

◆ switch_codec2str

#define switch_codec2str	(	codec,
		buf,
		len
	)

Value:

snprintf(buf, len, "%s@%uh@%ui", \
                                                 codec->implementation->iananame, \
                                                 codec->implementation->samples_per_second, \
                                                 codec->implementation->microseconds_per_packet / 1000)

Definition at line 293 of file switch_utils.h.

Referenced by switch_core_session_outgoing_channel().

◆ switch_copy_flags

#define switch_copy_flags	(	dest,
		src,
		flags
	)	(dest)->flags &= ~(flags); (dest)->flags \|= ((src)->flags & (flags))

Copy flags from one arbitrary object to another.

Parameters

dest	the object to copy the flags to
src	the object to copy the flags from
flags	the flags to copy

Definition at line 732 of file switch_utils.h.

◆ SWITCH_DECLARE_GLOBAL_STRING_FUNC

#define SWITCH_DECLARE_GLOBAL_STRING_FUNC	(	fname,
		vname
	)

Value:

static void fname(const char *string) { if (!string) return;\

if (vname) {free(vname); vname = NULL;}vname = strdup(string);} static void fname(const char *string)

Declares a function designed to set a dynamic global string.

Parameters

fname	the function name to declare
vname	the name of the global pointer to modify with the new function

Definition at line 1013 of file switch_utils.h.

◆ switch_errno

#define switch_errno ( ) errno

Definition at line 647 of file switch_utils.h.

Referenced by switch_util_quote_shell_arg_pool(), switch_wait_sock(), and switch_wait_socklist().

◆ switch_goto_int

#define switch_goto_int	(	_n,
		_i,
		_label
	)	_n = _i; goto _label

Definition at line 288 of file switch_utils.h.

◆ switch_goto_status

#define switch_goto_status	(	_status,
		_label
	)	status = _status; goto _label

Definition at line 287 of file switch_utils.h.

Referenced by setup_ringback(), switch_core_execute_chat_app(), switch_core_file_handle_dup(), switch_core_media_proxy_remote_addr(), switch_core_media_read_frame(), switch_core_media_set_codec(), switch_core_media_set_video_codec(), switch_core_perform_file_open(), switch_core_session_execute_application_get_flags(), switch_core_session_write_text_frame(), switch_core_session_write_video_frame(), switch_event_reserve_subclass_detailed(), switch_ivr_eavesdrop_session(), switch_ivr_enterprise_originate(), switch_ivr_menu_execute(), switch_ivr_originate(), switch_ivr_park(), switch_ivr_record_session_event(), switch_ivr_say_ip(), switch_ivr_sleep(), switch_jb_get_packet(), switch_limit_incr(), switch_limit_interval_reset(), switch_limit_release(), switch_limit_reset(), switch_limit_status(), switch_memory_usage_stream(), switch_regex_match_partial(), switch_rtp_add_dtls(), switch_rtp_del_dtls(), and switch_sockaddr_new().

◆ switch_inet_ntop

#define switch_inet_ntop inet_ntop

Definition at line 1434 of file switch_utils.h.

◆ switch_is_valid_rate

#define switch_is_valid_rate ( _tmp ) (_tmp == 8000 || _tmp == 12000 || _tmp == 16000 || _tmp == 24000 || _tmp == 32000 || _tmp == 11025 || _tmp == 22050 || _tmp == 44100 || _tmp == 48000)

Definition at line 378 of file switch_utils.h.

Referenced by switch_ivr_record_file_event(), and switch_ivr_record_session_event().

◆ switch_malloc

#define switch_malloc	(	ptr,
		len
	)	(void)(switch_assert(((ptr) = malloc((len)))),ptr)

Definition at line 1425 of file switch_utils.h.

Referenced by switch_msrp_msg_set_payload().

◆ switch_network_list_add_cidr

#define switch_network_list_add_cidr	(	_list,
		_cidr_str,
		_ok
	)	switch_network_list_add_cidr_token(_list, _cidr_str, _ok, NULL)

Definition at line 1366 of file switch_utils.h.

Referenced by switch_load_network_lists().

◆ switch_network_list_validate_ip

#define switch_network_list_validate_ip	(	_list,
		_ip
	)	switch_network_list_validate_ip_token(_list, _ip, NULL);

Definition at line 1378 of file switch_utils.h.

◆ switch_normalize_to_16bit

#define switch_normalize_to_16bit ( n ) if (n > SWITCH_SMAX) n = SWITCH_SMAX; else if (n < SWITCH_SMIN) n = SWITCH_SMIN;

Definition at line 292 of file switch_utils.h.

Referenced by early_thread_run(), read_displace_callback(), switch_change_sln_volume(), switch_change_sln_volume_granular(), switch_core_media_bug_read(), switch_merge_sln(), switch_mux_channels(), and write_displace_callback().

◆ SWITCH_READ_ACCEPTABLE

#define SWITCH_READ_ACCEPTABLE ( status ) (status == SWITCH_STATUS_SUCCESS || status == SWITCH_STATUS_BREAK || status == SWITCH_STATUS_INUSE)

◆ switch_safe_free

#define switch_safe_free ( it ) if (it) {free(it);it=NULL;}

Free a pointer and set it to NULL unless it already is NULL.

Parameters

it	the pointer

Definition at line 885 of file switch_utils.h.

Referenced by _switch_hashtable_remove(), api_hook(), check_channel_status(), comp_callback(), core_event_handler(), CoreSession::destroy(), destroy_ecd(), do_chat_send(), do_flush(), do_trans(), ecd_deliver(), API::executeString(), fs_encode_cleanup(), fs_tts_cleanup(), CoreSession::getXMLCDR(), hashtable_expand(), load_mime_types(), main(), msrp_msg_serialize(), CoreSession::originate(), parse_presence_data_cols(), play_and_collect(), preprocess(), preprocess_exec_set(), preprocess_glob(), record_helper_post_process(), Event::serialize(), CoreSession::set_tts_params(), CoreSession::set_tts_parms(), setup_ringback(), speech_thread(), sql_in_thread(), Stream::Stream(), switch_api_execute(), switch_buffer_destroy(), switch_cache_db_execute_sql_real(), switch_cache_db_persistant_execute(), switch_cache_db_persistant_execute_trans_full(), switch_caller_extension_add_application_printf(), switch_channel_build_param_string(), switch_channel_expand_variables_check(), switch_channel_export_variable_var_check(), switch_channel_pass_sdp(), switch_channel_set_presence_data_vals(), switch_channel_set_timestamps(), switch_channel_set_variable_strip_quotes_var_check(), switch_channel_uninit(), switch_check_network_list_ip_port_token(), switch_console_complete(), switch_console_execute(), switch_console_expand_alias(), switch_console_process(), switch_console_set_alias(), switch_console_set_complete(), switch_core_asr_close(), switch_core_asr_load_grammar(), switch_core_check_dtls_pem(), switch_core_destroy(), switch_core_file_close(), switch_core_gen_certs(), switch_core_hash_insert_alloc_destructor(), switch_core_hash_insert_auto_free(), switch_core_hash_insert_destructor(), switch_core_hash_insert_dup_auto_free(), switch_core_hash_insert_dup_destructor(), switch_core_hash_insert_pointer(), switch_core_media_bug_destroy(), switch_core_media_ext_address_lookup(), switch_core_media_gen_local_sdp(), switch_core_media_media_params(), switch_core_media_negotiate_sdp(), switch_core_media_process_sdp_filter(), switch_core_media_set_r_sdp_codec_string(), switch_core_perform_file_open(), switch_core_recovery_flush(), switch_core_recovery_recover(), switch_core_recovery_track(), switch_core_session_ctl(), switch_core_session_exec(), switch_core_session_free_message(), switch_core_session_printf(), switch_core_session_reporting_state(), switch_core_speech_feed_tts(), switch_core_sqldb_start(), switch_dial_handle_list_create_json_obj(), switch_digest(), switch_digest_string(), switch_event_add_body(), switch_event_add_presence_data_cols(), switch_event_base_add_header(), switch_event_build_param_string(), switch_event_expand_headers_check(), switch_event_serialize(), switch_event_set_body(), switch_event_set_subclass_name(), switch_find_local_ip(), switch_frame_free(), switch_fulldate_cmp(), switch_hashtable_destroy(), switch_http_parse_qs(), switch_img_free(), switch_img_write_text_img(), switch_ivr_broadcast(), switch_ivr_collect_digits_count(), switch_ivr_digit_stream_destroy(), switch_ivr_eavesdrop_session(), switch_ivr_insert_file(), switch_ivr_multi_threaded_bridge(), switch_ivr_originate(), switch_ivr_park(), switch_ivr_phrase_macro_event(), switch_ivr_play_file(), switch_ivr_preprocess_session(), switch_ivr_record_file_event(), switch_ivr_set_json_chan_vars(), switch_ivr_sleep(), switch_ivr_speak_text_handle(), switch_ivr_wait_for_answer(), switch_jb_pop_nack(), switch_json_add_presence_data_cols(), switch_jwt_verify(), switch_loadable_module_enumerate_available(), switch_loadable_module_get_codecs(), switch_loadable_module_load_file(), switch_log_meta_vprintf(), switch_log_node_free(), switch_log_node_to_json(), switch_msrp_destroy(), switch_msrp_msg_destroy(), switch_nat_init(), switch_nat_multicast_runtime(), switch_nat_republish(), switch_nat_shutdown(), switch_network_list_add_cidr_port_token(), switch_network_list_perform_add_cidr_token(), switch_odbc_handle_callback_exec_detailed(), switch_odbc_handle_destroy(), switch_odbc_handle_disconnect(), switch_odbc_handle_new(), switch_play_and_get_digits(), switch_regex_match_partial(), switch_regex_perform(), switch_rtp_destroy(), switch_say_file_handle_destroy(), switch_simple_email(), switch_split_date(), switch_split_time(), SWITCH_STANDARD_APP(), switch_stream_spawn(), switch_stream_write_file_contents(), switch_strstr(), switch_tod_cmp(), switch_xml_clear_user_cache(), switch_xml_config_cleanup(), switch_xml_config_parse_event(), switch_xml_free(), switch_xml_locate_language(), switch_xml_locate_user_merged(), switch_xml_parse_file(), switch_xml_tohtml_ex(), switch_xml_user_cache(), task_thread_loop(), text_bridge_thread(), tone_detect_set_total_time(), and unsub_all_switch_event_channel().

◆ switch_samples_per_packet

#define switch_samples_per_packet	(	rate,
		interval
	)	((uint32_t)((float)rate / (1000.0f / (float)interval)))

Definition at line 289 of file switch_utils.h.

Referenced by switch_core_speech_open().

◆ switch_set_flag

#define switch_set_flag	(	obj,
		flag
	)	(obj)->flags \|= (flag)

Set a flag on an arbitrary object.

Parameters

obj	the object to set the flags on
flag	the or'd list of flags to set

Definition at line 700 of file switch_utils.h.

◆ switch_set_flag_locked

#define switch_set_flag_locked	(	obj,
		flag
	)

Value:

assert((obj)->flag_mutex != NULL); \
switch_mutex_lock((obj)->flag_mutex);                                                           \
(obj)->flags |= (flag);\
switch_mutex_unlock((obj)->flag_mutex);

Set a flag on an arbitrary object while locked.

Parameters

obj	the object to set the flags on
flag	the or'd list of flags to set

Definition at line 707 of file switch_utils.h.

Referenced by switch_core_file_pre_close(), switch_core_file_read(), switch_core_file_seek(), switch_core_perform_file_open(), switch_ivr_activate_unicast(), switch_ivr_play_file(), switch_ivr_process_fh(), unicast_thread_launch(), and video_write_thread().

◆ switch_set_string

#define switch_set_string	(	_dst,
		_src
	)	switch_copy_string(_dst, _src, sizeof(_dst))

Definition at line 734 of file switch_utils.h.

Referenced by _switch_cache_db_get_db_handle_dsn_ex(), add_handle(), check_ice(), check_ip(), get_handle(), switch_config_open_file(), switch_core_session_request_uuid(), switch_core_session_set_uuid(), switch_core_speech_open(), switch_ivr_dmachine_check_match(), switch_ivr_dmachine_ping(), switch_load_network_lists(), switch_loadable_module_get_codecs_sorted(), switch_log_meta_vprintf(), and switch_nat_multicast_runtime().

◆ SWITCH_SMAX

#define SWITCH_SMAX 32767

Definition at line 290 of file switch_utils.h.

Referenced by switch_core_media_bug_read().

◆ SWITCH_SMIN

#define SWITCH_SMIN -32768

Definition at line 291 of file switch_utils.h.

Referenced by switch_core_media_bug_read().

◆ switch_split

#define switch_split	(	_data,
		_delim,
		_array
	)	switch_separate_string(_data, _delim, _array, switch_arraylen(_array))

Definition at line 375 of file switch_utils.h.

Referenced by check_ice(), main(), parse_presence_data_cols(), switch_channel_handle_cause(), switch_channel_set_presence_data_vals(), switch_core_media_process_sdp_filter(), switch_core_session_parse_crypto_prefs(), switch_core_session_reporting_state(), switch_event_add_presence_data_cols(), switch_img_write_text_img(), switch_json_add_presence_data_cols(), and switch_xml_locate_user_merged().

◆ switch_split_cheap

#define switch_split_cheap	(	_data,
		_delim,
		_array,
		_larray
	)	switch_separate_string_cheap(_data, _delim, (const char **)_array, _larray, switch_arraylen(_array))

Definition at line 376 of file switch_utils.h.

◆ SWITCH_STATUS_IS_BREAK

#define SWITCH_STATUS_IS_BREAK ( x ) (x == SWITCH_STATUS_BREAK || x == 730035 || x == 35 || x == SWITCH_STATUS_INTR)

Definition at line 633 of file switch_utils.h.

Referenced by rtp_common_read(), switch_ivr_menu_execute(), and switch_nat_multicast_runtime().

◆ switch_str_nil

#define switch_str_nil ( s ) (s ? s : "")

Make a null string a blank string instead.

Parameters

s	the string to test

Returns: the original string or blank string.

Definition at line 993 of file switch_utils.h.

Referenced by api_hook(), EventConsumer::bind(), console_clean_log(), console_log(), console_log2(), CoreSession::consoleLog(), CoreSession::consoleLog2(), core_event_handler(), do_api_on(), is_valid_action(), msrp_reply(), msrp_report(), CoreSession::print(), CoreSession::set_tts_params(), switch_channel_flip_cid(), switch_channel_set_timestamps(), switch_console_complete(), switch_console_set_complete(), switch_core_add_registration(), switch_core_media_activate_rtp(), switch_core_media_negotiate_sdp(), switch_core_recovery_track(), switch_core_session_exec(), switch_core_session_execute_application_get_flags(), switch_core_session_execute_exten(), switch_event_create_array_pair(), switch_ivr_displace_session(), switch_ivr_generate_json_cdr(), switch_ivr_originate(), switch_ivr_parse_event(), switch_ivr_phrase_macro_event(), switch_ivr_play_file(), switch_ivr_record_file_event(), switch_ivr_record_session_event(), switch_loadable_module_get_codecs_sorted(), switch_loadable_module_load_module_ex(), switch_loadable_module_process(), switch_loadable_module_unprocess(), switch_network_list_perform_add_cidr_token(), switch_odbc_handle_callback_exec_detailed(), switch_odbc_handle_disconnect(), switch_odbc_handle_exec(), switch_scheduler_add_task_ex(), switch_scheduler_execute(), switch_stun_host_lookup(), switch_xml_set_attr_d(), and task_thread_loop().

◆ switch_strdup

#define switch_strdup	(	ptr,
		s
	)	(void)(switch_assert(((ptr) = strdup((s)))),ptr)

Definition at line 1427 of file switch_utils.h.

Referenced by switch_cache_db_execute_sql_real().

◆ switch_strlen_zero

#define switch_strlen_zero ( x ) zstr(x)

Definition at line 316 of file switch_utils.h.

Referenced by main().

◆ switch_strlen_zero_buf

#define switch_strlen_zero_buf ( x ) zstr_buf(x)

Definition at line 317 of file switch_utils.h.

◆ switch_test_flag

#define switch_test_flag	(	obj,
		flag
	)	((obj)->flags & flag)

Test for the existance of a flag on an arbitary object.

Parameters

obj	the object to test
flag	the or'd list of flags to test

Returns: true value if the object has the flags defined

Definition at line 693 of file switch_utils.h.

◆ switch_test_subnet

#define switch_test_subnet	(	_ip,
		_net,
		_mask
	)	(_mask ? ((_net & _mask) == (_ip & _mask)) : _net ? _net == _ip : 1)

Definition at line 1380 of file switch_utils.h.

Referenced by switch_check_network_list_ip_port_token(), and switch_network_list_validate_ip_port_token().

◆ switch_time_from_sec

#define switch_time_from_sec ( sec ) ((switch_time_t)(sec) * 1000000)

Definition at line 1006 of file switch_utils.h.

◆ switch_true_buf

#define switch_true_buf ( expr )

Value:

((( !strcasecmp(expr, "yes") ||\
!strcasecmp(expr, "on") ||\
!strcasecmp(expr, "true") ||\
!strcasecmp(expr, "t") ||\
!strcasecmp(expr, "enabled") ||\
!strcasecmp(expr, "active") ||\
!strcasecmp(expr, "allow") ||\
(switch_is_number(expr) && atoi(expr)))) ? SWITCH_TRUE : SWITCH_FALSE)

Definition at line 536 of file switch_utils.h.

◆ SWITCH_URL_UNSAFE

#define SWITCH_URL_UNSAFE "\r\n #%&+:;<=>?@[\\]^`{|}\""

Definition at line 47 of file switch_utils.h.

Referenced by switch_core_url_encode_opt(), switch_needs_url_encode(), and switch_url_encode_opt().

◆ switch_yield

#define switch_yield ( ms ) switch_sleep(ms);

Wait a desired number of microseconds and yield the CPU.

Definition at line 998 of file switch_utils.h.

Referenced by _switch_cache_db_get_db_handle(), audio_bridge_thread(), media_thread_run(), msrp_worker(), originate_on_consume_media_transmit(), pool_thread(), record_callback(), rtp_common_read(), signal_bridge_on_hibernate(), switch_cache_db_persistant_execute(), switch_cache_db_persistant_execute_trans_full(), switch_channel_clear_device_record(), switch_console_save_history(), switch_core_db_exec(), switch_core_db_persistant_execute(), switch_core_db_persistant_execute_trans(), switch_core_media_end_engine_function(), switch_core_media_ext_address_lookup(), switch_core_media_read_frame(), switch_core_media_set_codec(), switch_core_media_toggle_hold(), switch_core_media_write_frame(), switch_core_runtime_loop(), switch_core_session_ctl(), switch_core_session_read_frame(), switch_core_session_run(), switch_core_session_send_dtmf(), switch_core_session_thread(), switch_core_session_write_blank_video(), switch_core_sql_db_thread(), switch_core_standard_on_reset(), switch_event_launch_dispatch_threads(), switch_event_shutdown(), switch_ivr_3p_media(), switch_ivr_3p_nomedia(), switch_ivr_deactivate_unicast(), switch_ivr_eavesdrop_session(), switch_ivr_enterprise_originate(), switch_ivr_media(), switch_ivr_nomedia(), switch_ivr_originate(), switch_ivr_park(), switch_ivr_play_file(), switch_ivr_sleep(), switch_ivr_speak_text_handle(), switch_ivr_wait_for_answer(), switch_loadable_module_shutdown(), switch_loadable_module_unload_module(), switch_msrp_session_destroy(), switch_msrp_session_pop_msg(), switch_nat_multicast_runtime(), switch_nat_thread_stop(), switch_odbc_handle_disconnect(), switch_scheduler_task_thread_stop(), switch_socket_send(), switch_sql_queue_manager_push(), switch_sql_queue_manager_push_confirm(), switch_sql_queue_manager_stop(), SWITCH_STANDARD_APP(), switch_thread_rwlock_trywrlock_timeout(), switch_user_sql_thread(), uuid_bridge_on_soft_execute(), video_helper_thread(), and wait_for_cause().

◆ switch_zmalloc

#define switch_zmalloc	(	ptr,
		len
	)	(void)(switch_assert((ptr = calloc(1, (len)))),ptr)

Definition at line 1426 of file switch_utils.h.

Referenced by generate_on_dtmf(), switch_channel_queue_dtmf(), switch_chromakey_create(), switch_console_push_match(), switch_core_inthash_insert(), switch_core_media_bug_add(), switch_core_media_gen_local_sdp(), switch_event_bind_removable(), switch_event_channel_broadcast(), switch_event_channel_deliver(), switch_event_channel_sub_channel(), switch_event_reserve_subclass_detailed(), switch_frame_alloc(), switch_hashtable_first_iter(), switch_img_data_url(), switch_ivr_collect_digits_count(), switch_ivr_detect_audio(), switch_ivr_detect_silence(), switch_ivr_digit_stream_new(), switch_ivr_insert_file(), switch_ivr_originate(), switch_ivr_park(), switch_ivr_play_file(), switch_ivr_schedule_broadcast(), switch_ivr_schedule_hangup(), switch_ivr_schedule_transfer(), switch_ivr_sleep(), switch_ivr_wait_for_answer(), switch_ivr_wait_for_silence(), switch_live_array_add(), switch_mux_channels(), switch_resample_perform_create(), switch_scheduler_add_task_ex(), and text_bridge_thread().

◆ zset

#define zset	(	_a,
		_b
	)	if (!zstr(_b)) _a = _b

Definition at line 328 of file switch_utils.h.

◆ zstr

#define zstr ( x ) _zstr(x)

Definition at line 314 of file switch_utils.h.

◆ zstr_buf

#define zstr_buf ( s ) (*(s) == '\0')

Definition at line 318 of file switch_utils.h.

Referenced by get_upnp_pubaddr(), switch_log_node_to_json(), switch_simple_email(), and switch_strftime_tz().

Typedef Documentation

◆ switch_http_request_t

typedef struct switch_http_request_s switch_http_request_t

◆ switch_network_port_range_p

typedef switch_network_port_range_t* switch_network_port_range_p

Definition at line 58 of file switch_utils.h.

◆ switch_network_port_range_t

typedef struct switch_network_port_range switch_network_port_range_t

Definition at line 57 of file switch_utils.h.

Enumeration Type Documentation

◆ switch_uri_flags

enum switch_uri_flags

flags to be used with switch_build_uri()

Enumerator
SWITCH_URI_NUMERIC_HOST
SWITCH_URI_NUMERIC_PORT
SWITCH_URI_NO_SCOPE

Definition at line 615 of file switch_utils.h.

                                {
                  SWITCH_URI_NUMERIC_HOST = 1,
                  SWITCH_URI_NUMERIC_PORT = 2,
                  SWITCH_URI_NO_SCOPE = 4
          };

Function Documentation

◆ _zstr()

static _Check_return_ int _zstr ( _In_opt_z_ const char * s )

inlinestatic

Test for NULL or zero length string.

Parameters

s	the string to test

Returns: true value if the string is NULL or zero length

Definition at line 305 of file switch_utils.h.

 {
         if (!s) return 1;
         if (*s == '\0') return 1;
         return 0;
 }

◆ get_addr()

char* get_addr	(	char *	buf,
		switch_size_t	len,
		struct sockaddr *	sa,
		socklen_t	salen
	)

find the char representation of an ip adress

Parameters

buf	the buffer to write the ip adress found into
len	the length of the buf
sa	the struct sockaddr * to get the adress from
salen	the length of sa

Returns: the ip adress string

Definition at line 2494 of file switch_utils.c.

References buf, and switch_assert.

Referenced by switch_false(), switch_find_local_ip(), switch_get_addr(), and switch_resolve_host().

 {
         switch_assert(buf);
         *buf = '\0';
 
         if (sa) {
                 getnameinfo(sa, salen, buf, (socklen_t) len, NULL, 0, NI_NUMERICHOST);
         }
         return buf;
 }

◆ get_addr6()

char* get_addr6	(	char *	buf,
		switch_size_t	len,
		struct sockaddr_in6 *	sa,
		socklen_t	salen
	)

Definition at line 2478 of file switch_utils.c.

References buf, and switch_assert.

Referenced by switch_false(), and switch_get_addr().

 {
         switch_assert(buf);
         *buf = '\0';
 
         if (sa) {
 #if defined(NTDDI_VERSION)
                         switch_inet_ntop6((unsigned char*)&(sa->sin6_addr), buf, len);
 #else
                 inet_ntop(AF_INET6, &(sa->sin6_addr), buf, len);
 #endif
         }
 
         return buf;
 }

◆ get_addr_int()

int get_addr_int ( switch_sockaddr_t * sa )

Definition at line 2367 of file switch_utils.c.

Referenced by switch_false().

 {
         struct sockaddr_in *s = (struct sockaddr_in *) &sa->sa;
 
         return ntohs((unsigned short) s->sin_addr.s_addr);
 }

◆ get_port()

unsigned short get_port ( struct sockaddr * sa )

get the port number of an ip address

Parameters

sa	the struct sockaddr * to get the port from

Returns: the ip adress string

Definition at line 2505 of file switch_utils.c.

Referenced by switch_false().

 {
         unsigned short port = 0;
         if (sa) {
                 switch (sa->sa_family) {
                 case AF_INET:
                         port = ntohs(((struct sockaddr_in *) sa)->sin_port);
                         break;
                 case AF_INET6:
                         port = ntohs(((struct sockaddr_in6 *) sa)->sin6_port);
                         break;
                 }
         }
         return port;
 }

◆ old_switch_tolower()

int old_switch_tolower ( int c )

Definition at line 3877 of file switch_utils.c.

Referenced by switch_tolower_max().

 {
         if ((unsigned int) c > 255)
                 return (c);
         if (c < -1)
                 return EOF;
         return ((_switch_tolower_tab_ + 1)[c]);
 }

◆ old_switch_toupper()

int old_switch_toupper ( int c )

Definition at line 3830 of file switch_utils.c.

Referenced by switch_tolower_max().

 {
         if ((unsigned int) c > 255)
                 return (c);
         if (c < -1)
                 return EOF;
         return ((_switch_toupper_tab_ + 1)[c]);
 }

◆ switch_amp_encode()

char* switch_amp_encode	(	char *	s,
		char *	buf,
		switch_size_t	len
	)

Definition at line 939 of file switch_utils.c.

References buf, and switch_assert.

Referenced by switch_string_has_escaped_data().

 {
         char *p, *q;
         switch_size_t x = 0;
         switch_assert(s);
 
         q = buf;
 
         for (p = s; x < len; p++) {
                 switch (*p) {
 
                 case '"':
                         if (x + 6 > len - 1) {
                                 goto end;
                         }
                         *q++ = '&';
                         *q++ = 'q';
                         *q++ = 'u';
                         *q++ = 'o';
                         *q++ = 't';
                         *q++ = ';';
                         x += 6;
                         break;
                 case '\'':
                         if (x + 6 > len - 1) {
                                 goto end;
                         }
                         *q++ = '&';
                         *q++ = 'a';
                         *q++ = 'p';
                         *q++ = 'o';
                         *q++ = 's';
                         *q++ = ';';
                         x += 6;
                         break;
                 case '&':
                         if (x + 5 > len - 1) {
                                 goto end;
                         }
                         *q++ = '&';
                         *q++ = 'a';
                         *q++ = 'm';
                         *q++ = 'p';
                         *q++ = ';';
                         x += 5;
                         break;
                 case '<':
                         if (x + 4 > len - 1) {
                                 goto end;
                         }
                         *q++ = '&';
                         *q++ = 'l';
                         *q++ = 't';
                         *q++ = ';';
                         x += 4;
                         break;
                 case '>':
                         if (x + 4 > len - 1) {
                                 goto end;
                         }
                         *q++ = '&';
                         *q++ = 'g';
                         *q++ = 't';
                         *q++ = ';';
                         x += 4;
                         break;
                 default:
                         if (x + 1 > len - 1) {
                                 goto end;
                         }
                         *q++ = *p;
                         x++;
                         if (*p == '\0') {
                                 goto end;
                         }
                         break;
                 }
         }
 
   end:
 
         return buf;
 }

◆ switch_ast2regex()

switch_bool_t switch_ast2regex	(	const char *	pat,
		char *	rbuf,
		size_t	len
	)

Definition at line 1388 of file switch_utils.c.

References memset(), SWITCH_FALSE, and SWITCH_TRUE.

Referenced by switch_regex_perform().

 {
         const char *p = pat;
 
         if (!pat) {
                 return SWITCH_FALSE;
         }
 
         memset(rbuf, 0, len);
 
         *(rbuf + strlen(rbuf)) = '^';
 
         while (p && *p) {
                 if (*p == 'N') {
                         strncat(rbuf, "[2-9]", len - strlen(rbuf));
                 } else if (*p == 'X') {
                         strncat(rbuf, "[0-9]", len - strlen(rbuf));
                 } else if (*p == 'Z') {
                         strncat(rbuf, "[1-9]", len - strlen(rbuf));
                 } else if (*p == '.') {
                         strncat(rbuf, ".*", len - strlen(rbuf));
                 } else if (strlen(rbuf) < len - 1) {
                         *(rbuf + strlen(rbuf)) = *p;
                 }
                 p++;
         }
         *(rbuf + strlen(rbuf)) = '$';
 
         return strcmp(pat, rbuf) ? SWITCH_TRUE : SWITCH_FALSE;
 }

◆ switch_atoui()

unsigned int switch_atoui ( const char * nptr )

Definition at line 4293 of file switch_utils.c.

Referenced by switch_ivr_process_fh().

 {
         int tmp = atoi(nptr);
         if (tmp < 0) return 0;
         else return (unsigned int) tmp;
 }

◆ switch_atoul()

unsigned long switch_atoul ( const char * nptr )

Definition at line 4300 of file switch_utils.c.

Referenced by switch_load_core_config().

 {
         long tmp = atol(nptr);
         if (tmp < 0) return 0;
         else return (unsigned long) tmp;
 }

◆ switch_b64_decode()

switch_size_t switch_b64_decode	(	const char *	in,
		char *	out,
		switch_size_t	olen
	)

Definition at line 1064 of file switch_utils.c.

References b, switch_network_node::ip, and switch_b64_table.

Referenced by switch_core_media_add_crypto(), switch_jwt_verify(), and switch_string_has_escaped_data().

 {
 
         char l64[256];
         int b = 0, c, l = 0, i;
         const char *ip;
         char *op = out;
         size_t ol = 0;
 
         for (i = 0; i < 256; i++) {
                 l64[i] = -1;
         }
 
         for (i = 0; i < 64; i++) {
                 l64[(int) switch_b64_table[i]] = (char) i;
         }
 
         for (ip = in; ip && *ip; ip++) {
                 c = l64[(int) *ip];
                 if (c == -1) {
                         continue;
                 }
 
                 b = (b << 6) + c;
                 l += 6;
 
                 while (l >= 8) {
                         op[ol++] = (char) ((b >> (l -= 8)) % 256);
                         if (ol >= olen - 1) {
                                 goto end;
                         }
                 }
         }
 
   end:
 
         op[ol+1] = '\0';
 
         return ol;
 }

◆ switch_b64_encode()

switch_status_t switch_b64_encode	(	unsigned char *	in,
		switch_size_t	ilen,
		unsigned char *	out,
		switch_size_t	olen
	)

Definition at line 1025 of file switch_utils.c.

References b, switch_b64_table, and SWITCH_STATUS_SUCCESS.

Referenced by switch_core_media_build_crypto(), switch_img_data_url(), switch_jwt_sign(), switch_rtp_add_crypto_key(), and switch_string_has_escaped_data().

 {
         int y = 0, bytes = 0;
         size_t x = 0;
         unsigned int b = 0, l = 0;
 
         for (x = 0; x < ilen; x++) {
                 b = (b << 8) + in[x];
                 l += 8;
 
                 while (l >= 6) {
                         out[bytes++] = switch_b64_table[(b >> (l -= 6)) % 64];
                         if (bytes >= (int)olen - 1) {
                                 goto end;
                         }
                         if (++y != 72) {
                                 continue;
                         }
                         /* out[bytes++] = '\n'; */
                         y = 0;
                 }
         }
 
         if (l > 0) {
                 out[bytes++] = switch_b64_table[((b % 16) << (6 - l)) % 64];
         }
         if (l != 0) {
                 while (l < 6 && bytes < (int)olen - 1) {
                         out[bytes++] = '=', l += 2;
                 }
         }
 
   end:
 
         out[bytes] = '\0';
 
         return SWITCH_STATUS_SUCCESS;
 }

◆ switch_build_uri()

int switch_build_uri	(	char *	uri,
		switch_size_t	size,
		const char *	scheme,
		const char *	user,
		const switch_sockaddr_t *	sa,
		int	flags
	)

build a URI string from components

Parameters

uri	output string
size	maximum size of output string (including trailing null)
scheme	URI scheme
user	user part or null if none
sa	host address
flags	logical OR-ed combination of flags from switch_uri_flags

Returns: number of characters printed (not including the trailing null)

Definition at line 2521 of file switch_utils.c.

References switch_snprintf(), SWITCH_URI_NO_SCOPE, SWITCH_URI_NUMERIC_HOST, and SWITCH_URI_NUMERIC_PORT.

 {
         char host[NI_MAXHOST], serv[NI_MAXSERV];
         struct sockaddr_in6 si6;
         const struct sockaddr *addr;
         const char *colon;
 
         if (flags & SWITCH_URI_NO_SCOPE && sa->family == AF_INET6) {
                 memcpy(&si6, &sa->sa, sa->salen);
                 si6.sin6_scope_id = 0;
 
                 addr = (const struct sockaddr *) &si6;
         } else {
                 addr = (const struct sockaddr *) (intptr_t) & sa->sa;
         }
 
         if (getnameinfo(addr, sa->salen, host, sizeof(host), serv, sizeof(serv),
                                         ((flags & SWITCH_URI_NUMERIC_HOST) ? NI_NUMERICHOST : 0) | ((flags & SWITCH_URI_NUMERIC_PORT) ? NI_NUMERICSERV : 0)) != 0) {
                 return 0;
         }
 
         colon = strchr(host, ':');
 
         return switch_snprintf(uri, size, "%s:%s%s%s%s%s%s%s", scheme,
                                                    user ? user : "", user ? "@" : "", colon ? "[" : "", host, colon ? "]" : "", serv[0] ? ":" : "", serv[0] ? serv : "");
 }

◆ switch_calc_bitrate()

static int32_t switch_calc_bitrate	(	int	w,
		int	h,
		float	quality,
		double	fps
	)

inlinestatic

Definition at line 1100 of file switch_utils.h.

Referenced by video_write_thread().

 {   
     int r;
 
     if (quality == 0) {
         quality = 1;
     }
 
     /* KUSH GAUGE*/
 
     if (!fps) fps = 15;
 
     r = (int32_t)((double)(w * h * fps * quality) * 0.07) / 1000;
 
     if (!quality) r /= 2;
 
     if (quality < 0.0f) {
         r = (int) ((float)r * quality);
     }
 
     return r;
 
 }

◆ switch_calc_fps()

static void switch_calc_fps	(	switch_fps_t *	fpsP,
		float	fps,
		int	samplerate
	)

inlinestatic

Definition at line 1124 of file switch_utils.h.

References switch_fps_s::fps, switch_fps_s::ms, and switch_fps_s::samples.

 {
         /*
           implicit/truncf() - leave us with equal-or-smaller ms and thus equal-or-bigger fps, which is better for quality (than roundf()).
           also equal-or-bigger fps is better for things like (int)fps
         */
         fpsP->ms = (int)(1000.0f / fps);
         fpsP->fps = 1000.0f / fpsP->ms;
         fpsP->samples = (int)(samplerate / 1000 * fpsP->ms); // samplerate 99.99% is a factor of 1000, so we safe here with integer div by 1000
         return;
 }

◆ switch_calloc()

void* switch_calloc	(	size_t	nmemb,
		size_t	size
	)

Definition at line 86 of file switch_utils.c.

 {
         return calloc(nmemb, size);
 }

◆ switch_char_to_rfc2833()

unsigned char switch_char_to_rfc2833 ( char key )

Return the RFC2833 event based on an key character.

Parameters

key	the charecter to encode

Returns: the event id for the specified character or -1 on an invalid input

Definition at line 2556 of file switch_utils.c.

References RFC2833_CHARS, and switch_toupper().

Referenced by do_2833(), and switch_errno_is_break().

 {
         char *c;
         unsigned char counter = 0;
 
         key = (char) switch_toupper(key);
         for (c = RFC2833_CHARS; *c; c++) {
                 if (*c == key) {
                         return counter;
                 }
                 counter++;
         }
         return '\0';
 }

◆ switch_clean_name_string()

static char* switch_clean_name_string ( char * s )

inlinestatic

Definition at line 827 of file switch_utils.h.

 {
         char *p;
         for (p = s; p && *p; p++) {
                 uint8_t x = (uint8_t) * p;
                 if ((x < 32) || x == '\'' || x == '"' || x == '<' || x == '>' || x == '\\' || x == ':' || x == '@' || x == '/') {
                         *p = ' ';
                 }
                 if ( (p == s) && (*p == ' ') ) {
                         s++;
                 }
         }
 
         return s;
 }

◆ switch_clean_string()

static char* switch_clean_string ( char * s )

inlinestatic

Definition at line 813 of file switch_utils.h.

 {
         char *p;
         for (p = s; p && *p; p++) {
                 uint8_t x = (uint8_t) * p;
                 if ((x < 32) && x != '\n' && x != '\r') {
                         *p = ' ';
                 }
         }
 
         return s;
 }

◆ switch_cmp_addr()

int switch_cmp_addr	(	switch_sockaddr_t *	sa1,
		switch_sockaddr_t *	sa2,
		switch_bool_t	ip_only
	)

Definition at line 2374 of file switch_utils.c.

Referenced by do_dtls(), handle_ice(), read_rtcp_packet(), rtp_common_read(), and switch_false().

 {
         struct sockaddr_in *s1;
         struct sockaddr_in *s2;
 
         struct sockaddr_in6 *s16;
         struct sockaddr_in6 *s26;
 
         struct sockaddr *ss1;
         struct sockaddr *ss2;
 
         if (!(sa1 && sa2))
                 return 0;
 
         s1 = (struct sockaddr_in *) &sa1->sa;
         s2 = (struct sockaddr_in *) &sa2->sa;
 
         s16 = (struct sockaddr_in6 *) &sa1->sa;
         s26 = (struct sockaddr_in6 *) &sa2->sa;
 
         ss1 = (struct sockaddr *) &sa1->sa;
         ss2 = (struct sockaddr *) &sa2->sa;
 
         if (ss1->sa_family != ss2->sa_family)
                 return 0;
 
         switch (ss1->sa_family) {
         case AF_INET:
                 if (ip_only) {
                         return (s1->sin_addr.s_addr == s2->sin_addr.s_addr);
                 } else {
                         return (s1->sin_addr.s_addr == s2->sin_addr.s_addr && s1->sin_port == s2->sin_port);
                 }
         case AF_INET6:
                 {
                         int i;
 
                         if (!ip_only) {
                                 if (s16->sin6_port != s26->sin6_port) return 0;
                         }
 
                         for (i = 0; i < 4; i++) {
                                 if (*((int32_t *) s16->sin6_addr.s6_addr + i) != *((int32_t *) s26->sin6_addr.s6_addr + i)) return 0;
                         }
 
                         return 1;
                 }
         }
 
         return 0;
 }

◆ switch_core_session_url_encode()

char* switch_core_session_url_encode	(	switch_core_session_t *	session,
		const char *	url
	)

Definition at line 3550 of file switch_utils.c.

References switch_core_session_get_pool(), switch_core_url_encode_opt(), and SWITCH_FALSE.

Referenced by switch_needs_url_encode().

 {
         return switch_core_url_encode_opt(switch_core_session_get_pool(session), url, SWITCH_FALSE);
 }

◆ switch_core_session_url_encode_opt()

char* switch_core_session_url_encode_opt	(	switch_core_session_t *	session,
		const char *	url,
		switch_bool_t	double_encode
	)

Definition at line 3555 of file switch_utils.c.

References switch_core_session_get_pool(), and switch_core_url_encode_opt().

Referenced by switch_needs_url_encode().

 {
         return switch_core_url_encode_opt(switch_core_session_get_pool(session), url, double_encode);
 }

◆ switch_core_url_encode()

char* switch_core_url_encode	(	switch_memory_pool_t *	pool,
		const char *	url
	)

Definition at line 3560 of file switch_utils.c.

References switch_core_url_encode_opt(), and SWITCH_FALSE.

Referenced by switch_needs_url_encode().

 {
         return switch_core_url_encode_opt(pool, url, SWITCH_FALSE);
 }

◆ switch_core_url_encode_opt()

char* switch_core_url_encode_opt	(	switch_memory_pool_t *	pool,
		const char *	url,
		switch_bool_t	double_encode
	)

Definition at line 3565 of file switch_utils.c.

References end_of_p, switch_network_node::ok, switch_core_alloc, switch_core_strdup, switch_url_encode_opt(), and SWITCH_URL_UNSAFE.

Referenced by switch_core_session_url_encode(), switch_core_session_url_encode_opt(), switch_core_url_encode(), and switch_needs_url_encode().

 {
         const char hex[] = "0123456789ABCDEF";
         switch_size_t len = 0;
         switch_size_t slen = 0;
         const char *p, *e;
 
         if (!url) return NULL;
         if (!pool) return NULL;
 
         e = end_of_p(url);
 
         for (p = url; *p; p++) {
                 int ok = 0;
 
                 len++;
                 slen++;
 
                 if (!double_encode && *p == '%' && e-p > 1) {
                         if (strchr(hex, *(p+1)) && strchr(hex, *(p+2))) {
                                 ok = 1;
                         }
                 }
 
                 if (!ok && (*p < ' ' || *p > '~' || strchr(SWITCH_URL_UNSAFE, *p))) {
                         len += 2;
                 }
         }
 
         slen++;
         len++; /* NULL Terminatior */
 
         if (slen == len) {
                 return switch_core_strdup(pool, url);
         } else {
                 return switch_url_encode_opt(url, switch_core_alloc(pool, sizeof(char) * len), len, double_encode);
         }
 }

◆ switch_cp_addr()

int switch_cp_addr	(	switch_sockaddr_t *	sa1,
		switch_sockaddr_t *	sa2
	)

Definition at line 2427 of file switch_utils.c.

Referenced by read_rtp_packet(), and switch_false().

 {
         struct sockaddr_in *s1;
         struct sockaddr_in *s2;
 
         struct sockaddr_in6 *s16;
         struct sockaddr_in6 *s26;
 
         struct sockaddr *ss1;
         //struct sockaddr *ss2;
 
         if (!(sa1 && sa2))
                 return 0;
 
         s1 = (struct sockaddr_in *) &sa1->sa;
         s2 = (struct sockaddr_in *) &sa2->sa;
 
         s16 = (struct sockaddr_in6 *) &sa1->sa;
         s26 = (struct sockaddr_in6 *) &sa2->sa;
 
         ss1 = (struct sockaddr *) &sa1->sa;
         //ss2 = (struct sockaddr *) &sa2->sa;
 
         sa1->port = sa2->port;
         sa1->family = sa2->family;
 
         sa1->sa.sin.sin_family = sa2->family;
 
         switch (ss1->sa_family) {
         case AF_INET:
                 s1->sin_addr.s_addr = s2->sin_addr.s_addr;
                 s1->sin_port = s2->sin_port;
 
                 return 1;
         case AF_INET6:
                 {
                         int i;
 
                         s16->sin6_port = s26->sin6_port;
 
                         for (i = 0; i < 4; i++) {
                                 *((int32_t *) s16->sin6_addr.s6_addr + i) = *((int32_t *) s26->sin6_addr.s6_addr + i);
                         }
 
                         return 1;
                 }
         }
 
         return 0;
 }

◆ switch_cut_path()

const char* switch_cut_path ( const char * in )

Create a pointer to the file name in a given file path eliminating the directory name.

Returns: the pointer to the next character after the final / or \ characters

Definition at line 3005 of file switch_utils.c.

References in.

Referenced by switch_console_printf(), switch_event_prep_for_delivery_detailed(), switch_loadable_module_load_module_ex(), switch_log_meta_vprintf(), and switch_simple_email().

 {
         const char *p, *ret = in;
         const char delims[] = "/\\";
         const char *i;
 
         if (in) {
                 for (i = delims; *i; i++) {
                         p = in;
                         while ((p = strchr(p, *i)) != 0) {
                                 ret = ++p;
                         }
                 }
                 return ret;
         } else {
                 return NULL;
         }
 }

◆ switch_digest()

switch_status_t switch_digest	(	const char *	digest_name,
		unsigned char **	digest,
		const void *	input,
		switch_size_t	inputLen,
		unsigned int *	outputlen
	)

Definition at line 4715 of file switch_utils.c.

References switch_assert, SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, switch_log_printf(), switch_safe_free, SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

Referenced by switch_digest_string().

 {
 #if defined(HAVE_OPENSSL)
         EVP_MD_CTX *mdctx;
         const EVP_MD *md;
         int size;
 
         switch_assert(digest);
 
         if (!digest_name) {
                 switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Message digest is not set\n");
                 return SWITCH_STATUS_FALSE;
         }
 
         md = EVP_get_digestbyname(digest_name);
 
         if (!md) {
                 switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Unknown message digest %s\n", digest_name);                    
                 return SWITCH_STATUS_FALSE;
         }
 
         size = EVP_MD_size(md);
         if (!size || !(*digest = malloc(size))) {
                 switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Zero digest size or can't allocate memory to store results %s\n", digest_name);
                 return SWITCH_STATUS_FALSE;
         }
 
 #if OPENSSL_VERSION_NUMBER >= 0x10100000L
         mdctx = EVP_MD_CTX_new();
 #else
         mdctx = EVP_MD_CTX_create();
 #endif
 
         if (!mdctx) {
                 switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "EVP_MD_CTX_new error\n");
                 switch_safe_free(*digest);
                 return SWITCH_STATUS_FALSE;
         }
 
         EVP_MD_CTX_init(mdctx);
         EVP_DigestInit_ex(mdctx, md, NULL);
         EVP_DigestUpdate(mdctx, input, inputLen);
         EVP_DigestFinal_ex(mdctx, *digest, outputlen);
 
 #if OPENSSL_VERSION_NUMBER >= 0x10100000L
         EVP_MD_CTX_free(mdctx);
 #else
         EVP_MD_CTX_destroy(mdctx);
 #endif
 
         return SWITCH_STATUS_SUCCESS;
 #else
         return SWITCH_STATUS_FALSE;
 #endif
 }

◆ switch_digest_string()

switch_status_t switch_digest_string	(	const char *	digest_name,
		char **	digest_str,
		const void *	input,
		switch_size_t	inputLen,
		unsigned int *	outputlen
	)

Definition at line 4771 of file switch_utils.c.

References b, switch_digest(), switch_safe_free, SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

 {
         unsigned char *digest = NULL;
         switch_status_t status;
         short i = 0, x;
         uint8_t b;
 
         status = switch_digest(digest_name, &digest, input, inputLen, outputlen);
 
         if (status == SWITCH_STATUS_SUCCESS) {
                 if ((*digest_str = malloc(*outputlen * 2 + 1))) {
                         for (x = i = 0; x < *outputlen; x++) {
                                 b = (digest[x] >> 4) & 15;
                                 (*digest_str)[i++] = b + (b > 9 ? 'a' - 10 : '0');
                                 b = digest[x] & 15;
                                 (*digest_str)[i++] = b + (b > 9 ? 'a' - 10 : '0');
                         }
 
                         (*digest_str)[i] = '\0';
                 } else {
                         switch_safe_free(digest);
                         *outputlen = 0;
                         return SWITCH_STATUS_FALSE;
                 }
         }
 
         switch_safe_free(digest);
         *outputlen = i;
 
         return status;
 }

◆ switch_dow_cmp()

switch_bool_t switch_dow_cmp	(	const char *	exp,
		int	val
	)

Definition at line 4100 of file switch_utils.c.

References _dow_read_token(), cur, DOW_COMA, DOW_EOF, DOW_ERR, DOW_HYPHEN, SWITCH_CHANNEL_LOG, SWITCH_FALSE, SWITCH_LOG_ERROR, switch_log_printf(), and SWITCH_TRUE.

Referenced by switch_xml_std_datetime_check().

 {
         dow_t cur, prev = DOW_EOF, range_start = DOW_EOF;
         const char *p = exp;
 
         while ((cur = _dow_read_token(&p)) != DOW_EOF) {
                 if (cur == DOW_COMA) {
                         /* Reset state */
                         cur = DOW_EOF;
                 } else if (cur == DOW_HYPHEN) {
                         /* Save the previous token and move to the next one */
                         range_start = prev;
                 } else if (cur == DOW_ERR) {
                         switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Parse error for [%s] at position %ld (%.6s)\n", exp, (long) (p - exp), p);
                         break;
                 } else {
                         /* Valid day found */
                         if (range_start != DOW_EOF) { /* Evaluating a range */
                                 if (range_start <= cur ? (val >= range_start && val <= cur) : (val >= range_start || val <= cur)) {
                                         return SWITCH_TRUE;
                                 }
                                 range_start = DOW_EOF;
                         } else if (val == cur) {
                                 return SWITCH_TRUE;
                         }
                 }
 
                 prev = cur;
         }
 
         return SWITCH_FALSE;
 }

◆ switch_dow_int2str()

const char* switch_dow_int2str ( int val )

Definition at line 4042 of file switch_utils.c.

References switch_arraylen.

Referenced by switch_xml_std_datetime_check().

                                                          {
         if (val >= switch_arraylen(DOW)) {
                 val = val % switch_arraylen(DOW);
         }
         return DOW[val];
 }

◆ switch_dow_str2int()

int switch_dow_str2int ( const char * exp )

Definition at line 4049 of file switch_utils.c.

References switch_arraylen.

Referenced by _dow_read_token().

                                                         {
         int ret = -1;
         int x;
 
         for (x = 0; x < switch_arraylen(DOW); x++) {
                 if (!strncasecmp(DOW[x], exp, 3)) {
                         ret = x + 1;
                         break;
                 }
         }
         return ret;
 }

◆ switch_dtmftoi()

static int switch_dtmftoi ( char * s )

inlinestatic

Definition at line 463 of file switch_utils.h.

References switch_assert.

Referenced by meta_on_dtmf(), and switch_ivr_bind_dtmf_meta_session().

 {
         int r;
 
         switch_assert(s);
 
         if (!(r = atoi(s))) {
                 int l = tolower((unsigned char)*s);
                 if (l > 96 && l < 101) {
                         r = l - 87;
                 }
         }
 
         return r;
 }

◆ switch_errno_is_break()

static int switch_errno_is_break ( int errcode )

inlinestatic

Definition at line 649 of file switch_utils.h.

References key, switch_char_to_rfc2833(), SWITCH_DECLARE, switch_priority_name(), and switch_rfc2833_to_char().

Referenced by switch_util_quote_shell_arg_pool(), switch_wait_sock(), and switch_wait_socklist().

 {
   return errcode == EAGAIN || errcode == EWOULDBLOCK || errcode == EINPROGRESS || errcode == EINTR || errcode == ETIMEDOUT;
 }

◆ switch_escape_char()

char* switch_escape_char	(	switch_memory_pool_t *	pool,
		char *	in,
		const char *	delim,
		char	esc
	)

Escape a string by prefixing a list of characters with an escape character.

Parameters

pool	a memory pool to use
in	the string
delim	the list of characters to escape
esc	the escape character

Returns: the escaped string

Definition at line 2571 of file switch_utils.c.

References count, in, and switch_core_alloc.

 {
         char *data;
         const char *p, *d;
         int count = 1, i = 0;
 
         p = in;
         while (*p) {
                 d = delim;
                 while (*d) {
                         if (*p == *d) {
                                 count++;
                         }
                         d++;
                 }
                 p++;
         }
 
         if (count == 1) {
                 return in;
         }
 
         data = switch_core_alloc(pool, strlen(in) + count);
 
         p = in;
         while (*p) {
                 d = delim;
                 while (*d) {
                         if (*p == *d) {
                                 data[i++] = esc;
                         }
                         d++;
                 }
                 data[i++] = *p;
                 p++;
         }
         return data;
 }

◆ switch_escape_string()

char* switch_escape_string	(	const char *	in,
		char *	out,
		switch_size_t	outlen
	)

Definition at line 2642 of file switch_utils.c.

Referenced by switch_escape_string_pool().

 {
         const char *p;
         char *o = out;
 
         for (p = in; *p; p++) {
                 switch (*p) {
                 case '\n':
                         *o++ = '\\';
                         *o++ = 'n';
                         break;
                 case '\r':
                         *o++ = '\\';
                         *o++ = 'r';
                         break;
                 case '\t':
                         *o++ = '\\';
                         *o++ = 't';
                         break;
                 case ' ':
                         *o++ = '\\';
                         *o++ = 's';
                         break;
                 case '$':
                         *o++ = '\\';
                         *o++ = '$';
                         break;
                 default:
                         *o++ = *p;
                         break;
                 }
         }
 
         *o++ = '\0';
 
         return out;
 }

◆ switch_escape_string_pool()

char* switch_escape_string_pool	(	const char *	in,
		switch_memory_pool_t *	pool
	)

Definition at line 2680 of file switch_utils.c.

References buf, switch_core_alloc, and switch_escape_string().

 {
         size_t len = strlen(in) * 2 + 1;
         char *buf = switch_core_alloc(pool, len);
         return switch_escape_string(in, buf, len);
 }

◆ switch_false()

static int switch_false ( const char * expr )

inlinestatic

Evaluate the falsefullness of a string expression.

Parameters

expr	a string expression

Returns: true or false

Definition at line 551 of file switch_utils.h.

References _In_, _In_opt_, _Out_opt_bytecapcount_, buf, buflen, get_addr(), get_addr6(), get_addr_int(), get_port(), switch_cmp_addr(), switch_cp_addr(), SWITCH_DECLARE, SWITCH_FALSE, switch_find_interface_ip(), switch_find_local_ip(), switch_is_number(), switch_resolve_host(), and SWITCH_TRUE.

Referenced by check_jb(), switch_channel_var_false(), switch_core_media_gen_local_sdp(), switch_core_media_negotiate_sdp(), switch_core_media_receive_message(), switch_core_perform_file_open(), switch_core_session_parse_crypto_prefs(), switch_ivr_originate(), switch_xml_config_parse_event(), and video_helper_thread().

 {
         return ((expr && ( !strcasecmp(expr, "no") ||
                                            !strcasecmp(expr, "off") ||
                                            !strcasecmp(expr, "false") ||
                                            !strcasecmp(expr, "f") ||
                                            !strcasecmp(expr, "disabled") ||
                                            !strcasecmp(expr, "inactive") ||
                                            !strcasecmp(expr, "disallow") ||
                                            (switch_is_number(expr) && !atoi(expr)))) ? SWITCH_TRUE : SWITCH_FALSE);
 }

◆ switch_fd_read_dline()

switch_size_t switch_fd_read_dline	(	int	fd,
		char **	buf,
		switch_size_t *	len
	)

Definition at line 844 of file switch_utils.c.

References buf, cur, DLINE_BLOCK_SIZE, DLINE_MAX_SIZE, memset(), switch_assert, SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, and switch_log_printf().

Referenced by switch_known_bitrate().

 {
         char c, *p;
         int cur;
         switch_size_t total = 0;
         char *data = *buf;
         switch_size_t ilen = *len;
 
         if (!data) {
                 *len = ilen = DLINE_BLOCK_SIZE;
                 data = malloc(ilen);
                 memset(data, 0, ilen);
         }
 
         p = data;
         while ((cur = read(fd, &c, 1)) == 1) {
 
                 if (total + 2 >= ilen) {
                         if (ilen + DLINE_BLOCK_SIZE > DLINE_MAX_SIZE) {
                                 switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Single line limit reached!\n");
                                 break;
                         }
 
                         ilen += DLINE_BLOCK_SIZE;
                         data = realloc(data, ilen);
                         switch_assert(data);
                         p = data + total;
 
                 }
 
                 total += cur;
                 *p++ = c;
 
                 if (c == '\r' || c == '\n') {
                         break;
                 }
         }
 
         *p++ = '\0';
 
         *len = ilen;
         *buf = data;
 
         return total;
 }

◆ switch_fd_read_line()

switch_size_t switch_fd_read_line	(	int	fd,
		char *	buf,
		switch_size_t	len
	)

Definition at line 822 of file switch_utils.c.

References buf, and cur.

Referenced by switch_known_bitrate().

 {
         char c, *p;
         int cur;
         switch_size_t total = 0;
 
         p = buf;
         while (total + 2 < len && (cur = read(fd, &c, 1)) == 1) {
                 total += cur;
                 *p++ = c;
                 if (c == '\r' || c == '\n') {
                         break;
                 }
         }
 
         *p++ = '\0';
         assert(total < len);
         return total;
 }

◆ switch_filecmp()

static int switch_filecmp	(	const char *	a,
		const char *	b
	)

inlinestatic

Definition at line 1306 of file switch_utils.h.

References switch_find_end_paren(), and zstr.

 {
         const char *e;
 
         if (zstr(a) || zstr(b)) {
                 return -1;
         }
 
         while(*a == '{') {
                 if ((e = switch_find_end_paren(a, '{', '}'))) {
                         a = e + 1;
                         while(*a == ' ') a++;
                 }
         }
 
         while(*b == '{') {
                 if ((e = switch_find_end_paren(b, '{', '}'))) {
                         b = e + 1;
                         while(*b == ' ') b++;
                 }
         }
 
         return strcmp(a, b);
 }

◆ switch_find_end_paren()

char* switch_find_end_paren	(	const char *	s,
		char	open,
		char	close
	)

Definition at line 796 of file switch_utils.c.

Referenced by expand_vars(), switch_core_asr_load_grammar(), switch_core_media_process_sdp_filter(), switch_core_speech_feed_tts(), switch_event_create_brackets(), switch_filecmp(), switch_is_file_path(), switch_ivr_displace_session(), switch_ivr_originate(), switch_ivr_play_file(), switch_ivr_record_file_event(), switch_ivr_record_session_event(), switch_needs_url_encode(), and switch_separate_file_params().

 {
         const char *e = NULL;
         int depth = 0;
 
         while (s && *s && *s == ' ') {
                 s++;
         }
 
         if (s && *s == open) {
                 depth++;
                 for (e = s + 1; e && *e; e++) {
                         if (*e == open && open != close) {
                                 depth++;
                         } else if (*e == close) {
                                 depth--;
                                 if (!depth) {
                                         break;
                                 }
                         }
                 }
         }
 
         return (e && *e == close) ? (char *) e : NULL;
 }

◆ switch_find_interface_ip()

switch_status_t switch_find_interface_ip	(	_Out_opt_bytecapcount_(len) char *	buf,
		_In_ int	len,
		_In_opt_ int *	mask,
		_In_ const char *	ifname,
		_In_ int	family
	)

find primary ip of the specified interface

Parameters

buf	the buffer to write the ip address found into
len	the length of the buf
mask	the CIDR found (AF_INET only)
ifname	interface name to check
family	the address family to return (AF_INET or AF_INET6)

Returns: SWITCH_STATUS_SUCCESSS for success, otherwise failure

Referenced by switch_false().

◆ switch_find_local_ip()

switch_status_t switch_find_local_ip	(	_Out_opt_bytecapcount_(len) char *	buf,
		_In_ int	len,
		_In_opt_ int *	mask,
		_In_ int	family
	)

find local ip of the box

Parameters

buf	the buffer to write the ip address found into
len	the length of the buf
mask	the CIDR found (AF_INET only)
family	the address family to return (AF_INET or AF_INET6)

Returns: SWITCH_STATUS_SUCCESSS for success, otherwise failure

Referenced by check_ip(), switch_core_init(), switch_event_init(), switch_false(), switch_load_network_lists(), switch_nat_init(), and switch_stun_ip_lookup().

◆ switch_find_parameter()

char* switch_find_parameter	(	const char *	str,
		const char *	param,
		switch_memory_pool_t *	pool
	)

Definition at line 415 of file switch_utils.c.

References switch_network_node::next, switch_core_alloc, and switch_snprintf().

Referenced by switch_known_bitrate().

 {
         char *e, *r = NULL, *ptr = NULL, *next = NULL;
         size_t len;
 
         ptr = (char *) str;
 
         while (ptr) {
                 len = strlen(param);
                 e = ptr+len;
                 next = strchr(ptr, ';');
 
                 if (!strncasecmp(ptr, param, len) && *e == '=') {
                         size_t mlen;
 
                         ptr = ++e;
 
                         if (next) {
                                 e = next;
                         } else {
                                 e = ptr + strlen(ptr);
                         }
 
                         mlen = (e - ptr) + 1;
 
                         if (pool) {
                                 r = switch_core_alloc(pool, mlen);
                         } else {
                                 r = malloc(mlen);
                         }
 
                         switch_snprintf(r, mlen, "%s", ptr);
 
                         break;
                 }
 
                 if (next) {
                         ptr = next + 1;
                 } else break;
         }
 
         return r;
 }

◆ switch_format_number()

char* switch_format_number ( const char * num )

Definition at line 4256 of file switch_utils.c.

References switch_is_number(), switch_mprintf(), and zstr.

 {
         char *r;
         size_t len;
         const char *p = num;
 
         if (!p) {
                 return (char*)p;
         }
 
         if (zstr(p)) {
                 return strdup(p);
         }
 
         if (*p == '+') {
                 p++;
         }
 
         if (!switch_is_number(p)) {
                 return strdup(p);
         }
 
         len = strlen(p);
 
         /* region 1, TBD add more....*/
         if (len == 11 && p[0] == '1') {
                 r = switch_mprintf("%c (%c%c%c) %c%c%c-%c%c%c%c", p[0],p[1],p[2],p[3],p[4],p[5],p[6],p[7],p[8],p[9],p[10]);
         } else if (len == 10) {
                 r = switch_mprintf("1 (%c%c%c) %c%c%c-%c%c%c%c", p[0],p[1],p[2],p[3],p[4],p[5],p[6],p[7],p[8],p[9]);
         } else {
                 r = strdup(num);
         }
 
         return r;
 }

◆ switch_fp_read_dline()

switch_size_t switch_fp_read_dline	(	FILE *	fd,
		char **	buf,
		switch_size_t *	len
	)

Definition at line 892 of file switch_utils.c.

References buf, DLINE_BLOCK_SIZE, DLINE_MAX_SIZE, memset(), switch_assert, SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, and switch_log_printf().

Referenced by load_mime_types(), preprocess(), switch_known_bitrate(), and switch_stream_write_file_contents().

 {
         char c, *p;
         switch_size_t total = 0;
         char *data = *buf;
         switch_size_t ilen = *len;
 
         if (!data) {
                 *len = ilen = DLINE_BLOCK_SIZE;
                 data = malloc(ilen);
                 memset(data, 0, ilen);
         }
 
         p = data;
         //while ((c = fgetc(fd)) != EOF) {
 
         while (fread(&c, 1, 1, fd) == 1) {
 
                 if (total + 2 >= ilen) {
                         if (ilen + DLINE_BLOCK_SIZE > DLINE_MAX_SIZE) {
                                 switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Single line limit reached!\n");
                                 break;
                         }
 
                         ilen += DLINE_BLOCK_SIZE;
                         data = realloc(data, ilen);
                         switch_assert(data);
                         p = data + total;
 
                 }
 
                 total++;
                 *p++ = c;
 
                 if (c == '\r' || c == '\n') {
                         break;
                 }
         }
 
         *p++ = '\0';
 
         *len = ilen;
         *buf = data;
 
         return total;
 }

◆ switch_frame_alloc()

switch_status_t switch_frame_alloc	(	switch_frame_t **	frame,
		switch_size_t	size
	)

Definition at line 109 of file switch_utils.c.

References switch_frame::buflen, switch_frame::data, SFF_DYNAMIC, switch_assert, switch_set_flag, SWITCH_STATUS_SUCCESS, and switch_zmalloc.

Referenced by switch_known_bitrate().

 {
         switch_frame_t *new_frame;
 
         switch_zmalloc(new_frame, sizeof(*new_frame));
 
         switch_set_flag(new_frame, SFF_DYNAMIC);
         new_frame->buflen = (uint32_t)size;
         new_frame->data = malloc(size);
         switch_assert(new_frame->data);
 
         *frame = new_frame;
 
         return SWITCH_STATUS_SUCCESS;
 }

◆ switch_frame_buffer_create()

switch_status_t switch_frame_buffer_create	(	switch_frame_buffer_t **	fbP,
		switch_size_t	qlen
	)

Definition at line 303 of file switch_utils.c.

References switch_frame_buffer_s::mutex, pool, switch_frame_buffer_s::pool, switch_frame_buffer_s::queue, switch_core_alloc, switch_core_new_memory_pool, switch_mutex_init(), SWITCH_MUTEX_NESTED, switch_queue_create(), and SWITCH_STATUS_SUCCESS.

Referenced by audio_write_thread().

 {
         switch_frame_buffer_t *fb;
         switch_memory_pool_t *pool;
 
         if (!qlen) qlen = 500;
 
         switch_core_new_memory_pool(&pool);
         fb = switch_core_alloc(pool, sizeof(*fb));
         fb->pool = pool;
         switch_queue_create(&fb->queue, qlen, fb->pool);
         switch_mutex_init(&fb->mutex, SWITCH_MUTEX_NESTED, pool);
         *fbP = fb;
 
         return SWITCH_STATUS_SUCCESS;
 }

◆ switch_frame_buffer_destroy()

switch_status_t switch_frame_buffer_destroy ( switch_frame_buffer_t ** fbP )

Definition at line 292 of file switch_utils.c.

References pool, switch_frame_buffer_s::pool, switch_core_destroy_memory_pool, and SWITCH_STATUS_SUCCESS.

Referenced by switch_media_handle_destroy().

 {
         switch_frame_buffer_t *fb = *fbP;
         switch_memory_pool_t *pool;
         *fbP = NULL;
         pool = fb->pool;
         switch_core_destroy_memory_pool(&pool);
 
         return SWITCH_STATUS_SUCCESS;
 }

◆ switch_frame_buffer_dup()

switch_status_t switch_frame_buffer_dup	(	switch_frame_buffer_t *	fb,
		switch_frame_t *	orig,
		switch_frame_t **	clone
	)

Definition at line 250 of file switch_utils.c.

References switch_frame::buflen, find_free_frame(), switch_assert, SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

Referenced by perform_write().

 {
         switch_frame_t *new_frame;
 
         if (!orig) {
                 return SWITCH_STATUS_FALSE;
         }
 
         switch_assert(orig->buflen);
 
         new_frame = find_free_frame(fb, orig);
 
         *clone = new_frame;
 
         return SWITCH_STATUS_SUCCESS;
 }

◆ switch_frame_buffer_free()

switch_status_t switch_frame_buffer_free	(	switch_frame_buffer_t *	fb,
		switch_frame_t **	frameP
	)

Definition at line 217 of file switch_utils.c.

References switch_frame::extra_data, switch_frame_node_s::frame, switch_frame_buffer_s::head, switch_frame::img, switch_frame_node_s::inuse, switch_frame_buffer_s::mutex, switch_frame_node_s::next, switch_frame_node_s::prev, switch_assert, switch_img_free(), switch_mutex_lock(), switch_mutex_unlock(), SWITCH_STATUS_SUCCESS, and switch_frame_buffer_s::total.

Referenced by audio_write_thread().

 {
         switch_frame_t *old_frame;
         switch_frame_node_t *node;
 
         switch_mutex_lock(fb->mutex);
 
         old_frame = *frameP;
         *frameP = NULL;
 
         node = (switch_frame_node_t *) old_frame->extra_data;
         node->inuse = 0;
         switch_img_free(&node->frame->img);
 
         fb->total++;
 
         if (fb->head) {
                 fb->head->prev = node;
         }
 
         node->next = fb->head;
         node->prev = NULL;
         fb->head = node;
 
         switch_assert(node->next != node);
         switch_assert(node->prev != node);
 
 
         switch_mutex_unlock(fb->mutex);
 
         return SWITCH_STATUS_SUCCESS;
 }

◆ switch_frame_buffer_pop()

switch_status_t switch_frame_buffer_pop	(	switch_frame_buffer_t *	fb,
		void **	ptr
	)

Definition at line 277 of file switch_utils.c.

References switch_frame_buffer_s::queue, and switch_queue_pop().

 {
         return switch_queue_pop(fb->queue, ptr);
 }

◆ switch_frame_buffer_push()

switch_status_t switch_frame_buffer_push	(	switch_frame_buffer_t *	fb,
		void *	ptr
	)

Definition at line 267 of file switch_utils.c.

References switch_frame_buffer_s::queue, and switch_queue_push().

Referenced by perform_write(), and switch_core_media_deactivate_rtp().

 {
         return switch_queue_push(fb->queue, ptr);
 }

◆ switch_frame_buffer_size()

int switch_frame_buffer_size ( switch_frame_buffer_t * fb )

Definition at line 287 of file switch_utils.c.

References switch_frame_buffer_s::queue, and switch_queue_size().

 {
         return switch_queue_size(fb->queue);
 }

◆ switch_frame_buffer_trypop()

switch_status_t switch_frame_buffer_trypop	(	switch_frame_buffer_t *	fb,
		void **	ptr
	)

Definition at line 282 of file switch_utils.c.

References switch_frame_buffer_s::queue, and switch_queue_trypop().

Referenced by audio_write_thread().

 {
         return switch_queue_trypop(fb->queue, ptr);
 }

◆ switch_frame_buffer_trypush()

switch_status_t switch_frame_buffer_trypush	(	switch_frame_buffer_t *	fb,
		void *	ptr
	)

Definition at line 272 of file switch_utils.c.

References switch_frame_buffer_s::queue, and switch_queue_trypush().

 {
         return switch_queue_trypush(fb->queue, ptr);
 }

◆ switch_frame_dup()

switch_status_t switch_frame_dup	(	switch_frame_t *	orig,
		switch_frame_t **	clone
	)

Definition at line 321 of file switch_utils.c.

References switch_frame::buflen, switch_frame::codec, switch_frame::data, switch_frame::datalen, switch_frame::img, switch_frame::packet, switch_frame::packetlen, switch_frame::pmap, SFF_DYNAMIC, SFF_ENCODED, switch_assert, switch_img_copy(), SWITCH_RTP_MAX_BUF_LEN, switch_set_flag, SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, and switch_test_flag.

Referenced by switch_known_bitrate().

 {
         switch_frame_t *new_frame;
 
         if (!orig) {
                 return SWITCH_STATUS_FALSE;
         }
 
         switch_assert(orig->buflen);
 
         new_frame = malloc(sizeof(*new_frame));
         switch_assert(new_frame);
 
         *new_frame = *orig;
         switch_set_flag(new_frame, SFF_DYNAMIC);
 
         if (orig->packet) {
                 new_frame->packet = malloc(SWITCH_RTP_MAX_BUF_LEN);
                 switch_assert(new_frame->packet);
                 memcpy(new_frame->packet, orig->packet, orig->packetlen);
                 new_frame->data = ((unsigned char *)new_frame->packet) + 12;
         } else {
                 new_frame->packet = NULL;
                 new_frame->data = malloc(new_frame->buflen);
                 switch_assert(new_frame->data);
                 memcpy(new_frame->data, orig->data, orig->datalen);
         }
 
 
         new_frame->codec = orig->codec;
         new_frame->pmap = orig->pmap;
         new_frame->img = NULL;
 
 
         if (orig->img && !switch_test_flag(orig, SFF_ENCODED)) {
                 switch_img_copy(orig->img, &new_frame->img);
         }
         *clone = new_frame;
 
         return SWITCH_STATUS_SUCCESS;
 }

◆ switch_frame_free()

switch_status_t switch_frame_free ( switch_frame_t ** frame )

Definition at line 363 of file switch_utils.c.

References switch_frame::data, switch_frame::img, switch_frame::packet, SFF_DYNAMIC, switch_img_free(), switch_safe_free, SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, and switch_test_flag.

Referenced by switch_known_bitrate().

 {
         switch_frame_t * f;
 
         if (!frame) {
                 return SWITCH_STATUS_FALSE;
         }
 
         f = *frame;
 
         if (!f || !switch_test_flag(f, SFF_DYNAMIC)) {
                 return SWITCH_STATUS_FALSE;
         }
 
         *frame = NULL;
 
         if (f->img) {
                 switch_img_free(&(f->img));
         }
 
         if (f->packet) {
                 switch_safe_free(f->packet);
         } else {
                 switch_safe_free(f->data);
         }
 
         free(f);
 
         return SWITCH_STATUS_SUCCESS;
 }

◆ switch_fulldate_cmp()

int switch_fulldate_cmp	(	const char *	exp,
		switch_time_t *	ts
	)

Definition at line 3739 of file switch_utils.c.

References cur, switch_assert, SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, switch_log_printf(), switch_safe_free, and switch_str_time().

Referenced by switch_xml_std_datetime_check().

 {
         char *dup = strdup(exp);
         char *sStart;
         char *sEnd;
         char *cur;
         char *p;
         switch_time_t tsStart = 0;
         switch_time_t tsEnd = 0;
         int ret = 0;
 
         switch_assert(dup);
 
         cur = dup;
         if ((p = strchr(cur, ','))) {
                 *p++ = '\0';
         }
 
         while (cur) {
                 sStart = cur;
                 if ((sEnd = strchr(cur, '~'))) {
                         *sEnd++ = '\0';
 
                         tsStart = switch_str_time(sStart);
                         tsEnd = switch_str_time(sEnd);
 
 
                         if (tsStart == 0 || tsEnd == 0) {
                                 switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Parse error for date time range (%s~%s)\n", sStart, sEnd);
                                 break;
                         }
 
                         if (tsStart <= *ts && tsEnd > *ts) {
                                 ret = 1;
                                 break;
                         }
                 }
 
                 if ((cur = p)) {
                         if ((p = strchr(p, ','))) {
                                 *p++ = '\0';
                         }
                 }
         }
 
         switch_safe_free(dup);
         return ret;
 }

◆ switch_get_hex_bytes()

static char* switch_get_hex_bytes	(	switch_byte_t *	buf,
		switch_size_t	datalen,
		char *	new_buf,
		switch_size_t	new_datalen
	)

inlinestatic

Definition at line 60 of file switch_utils.h.

 {
         switch_byte_t *p, *e;
         char *pp, *ee;
 
         e = buf + datalen;
         ee = new_buf + new_datalen;
         pp = new_buf;
 
         for (p = buf; p < e && pp < ee - 4; p++) {
                 if (snprintf(pp, 4, "%.2x ", (int)*p) < 0) {
                         return NULL;
                 }
                 pp += 3;
         }
         *(pp-1) = '\0';
 
         return new_buf;
 }

◆ switch_getcputime()

void switch_getcputime ( switch_cputime * t )

/ Return used CPU time in this process for user and kernel code

Definition at line 4591 of file switch_utils.c.

References switch_cputime::kernelms, switch_cputime::userms, and switch_stream_handle::write_function.

 {
 #if defined(_WIN32)
         FILETIME ct, et, kt, ut; // Times are in 100-ns ticks (div 10000 to get ms)
         GetProcessTimes(GetCurrentProcess(), &ct, &et, &kt, &ut);
         t->userms = ((int64_t)ut.dwLowDateTime | ((int64_t)ut.dwHighDateTime << 32)) / 10000;
         t->kernelms = ((int64_t)kt.dwLowDateTime | ((int64_t)kt.dwHighDateTime << 32)) / 10000;
 #elif defined(HAVE_GETRUSAGE)
         struct rusage r;
         getrusage(RUSAGE_SELF, &r);
         t->userms = r.ru_utime.tv_sec * 1000 + r.ru_utime.tv_usec / 1000;
         t->kernelms = r.ru_stime.tv_sec * 1000 + r.ru_stime.tv_usec / 1000;
 #else
         t->userms = -1;
         t->kernelms = -1;
 #endif
 }

◆ switch_getpid()

unsigned long switch_getpid ( void )

Definition at line 4704 of file switch_utils.c.

Referenced by fst_init_core_and_modload().

 {
 #ifndef WIN32
         pid_t pid = getpid();
 #else
         int pid = _getpid();
 #endif
 
         return (unsigned long)pid;
 }

◆ switch_html_strip()

char* switch_html_strip ( const char * str )

Definition at line 4658 of file switch_utils.c.

References switch_stream_handle::data, SWITCH_CHANNEL_LOG, switch_log_printf(), SWITCH_LOG_WARNING, switch_safe_strdup(), and SWITCH_STANDARD_STREAM.

 {
         char *p, *html = NULL, *text = NULL;
         int x = 0, got_ct = 0;
 #ifdef SWITCH_HAVE_GUMBO
         GumboOutput *output;
         switch_stream_handle_t stream;
 
         SWITCH_STANDARD_STREAM(stream);
 #endif
 
         for(p = (char *)str; p && *p; p++) {
 
                 if (!strncasecmp(p, "Content-Type:", 13)) {
                         got_ct++;
                 }
 
                 if (!got_ct) continue;
 
                 if (*p == '\n') {
                         x++;
                         if (x == 2) {
                                 break;
                         }
                 } else if (x && (*p != '\r')) {
                         x = 0;
                 }
         }
 
         html = p;
 
 #ifdef SWITCH_HAVE_GUMBO
         if ((output = gumbo_parse_with_options(&kGumboDefaultOptions, html, strlen(html)))) {
                 process(output->root, &stream);
                 gumbo_destroy_output(&kGumboDefaultOptions, output);
         }
 
         text = (char *)stream.data;
 #else
         switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "Support for html parser is not compiled.\n");
         text = switch_safe_strdup(html);
 #endif
 
         return text;
 }

◆ switch_http_dump_request()

void switch_http_dump_request ( switch_http_request_t * request )

Definition at line 4561 of file switch_utils.c.

 {
         switch_assert(request->method);
 
         printf("method: %s\n", request->method);
 
         if (request->uri) printf("uri: %s\n", request->uri);
         if (request->qs)  printf("qs: %s\n", request->qs);
         if (request->host) printf("host: %s\n", request->host);
         if (request->port) printf("port: %d\n", request->port);
         if (request->from) printf("from: %s\n", request->from);
         if (request->user_agent) printf("user_agent: %s\n", request->user_agent);
         if (request->referer) printf("referer: %s\n", request->referer);
         if (request->user) printf("user: %s\n", request->user);
         if (request->keepalive) printf("uri: %d\n", request->keepalive);
         if (request->content_type) printf("uri: %s\n", request->content_type);
         if (request->content_length) printf("uri: %" SWITCH_SIZE_T_FMT "\n", request->content_length);
 
         {
                 switch_event_header_t *header = request->headers->headers;
 
                 printf("headers:\n-------------------------\n");
 
                 while(header) {
                         printf("%s: %s\n", header->name, header->value);
                         header = header->next;
                 }
         }
 }

◆ switch_http_free_request()

void switch_http_free_request ( switch_http_request_t * request )

Definition at line 4552 of file switch_utils.c.

References switch_http_request_s::_buffer, switch_http_request_s::_destroy_headers, switch_http_request_s::headers, and switch_event_destroy().

Referenced by switch_http_parse_header().

 {
         if (request->_buffer) free(request->_buffer);
         if (request->_destroy_headers && request->headers) {
                 switch_event_destroy(&request->headers);
         }
 }

◆ switch_http_parse_header()

switch_status_t switch_http_parse_header	(	char *	buffer,
		uint32_t	datalen,
		switch_http_request_t *	request
	)

parse http headers in a buffer return status of success or not

Parameters

[in]	buffer	the buffer start from the very begining of the http request, e.g. 'GET '
[in]	datalen	the buffer length
[out]	the	http request pointer or null, need destroy later if got non-NULL pointer

Returns: SWITCH_STATUS_SUCCESS | SWITCH_STATUS_FALSE

Definition at line 4411 of file switch_utils.c.

 {
         switch_status_t status = SWITCH_STATUS_FALSE;
         char *p = buffer;
         int i = 10;
         char *http = NULL;
         int header_count;
         char *headers[64] = { 0 };
         int argc;
         char *argv[2] = { 0 };
         char *body = NULL;
 
         if (datalen < 16)       return status; /* minimum GET / HTTP/1.1\r\n */
 
         while(i--) { // sanity check
                 if (*p++ == ' ') break;
         }
 
         if (i == 0) return status;
 
         if ((body = strstr(buffer, "\r\n\r\n"))) {
                 *body = '\0';
                 body += 4;
         } else if (( body = strstr(buffer, "\n\n"))) {
                 *body = '\0';
                 body += 2;
         } else {
                 return status;
         }
 
         request->_buffer = strdup(buffer);
         switch_assert(request->_buffer);
         request->method = request->_buffer;
         request->bytes_buffered = datalen;
         request->bytes_header = body - buffer;
         request->bytes_read = body - buffer;
 
         p = strchr(request->method, ' ');
 
         if (!p) goto err;
 
         *p++ = '\0';
 
         if (*p != '/') goto err; /* must start from '/' */
 
         request->uri = p;
         p = strchr(request->uri, ' ');
 
         if (!p) goto err;
 
         *p++ = '\0';
         http = p;
 
         p = strchr(request->uri, '?');
 
         if (p) {
                 *p++ = '\0';
                 request->qs = p;
         }
 
         if (clean_uri((char *)request->uri) != SWITCH_STATUS_SUCCESS) {
                 goto err;
         }
 
         if (!strncmp(http, "HTTP/1.1", 8)) {
                 request->keepalive = SWITCH_TRUE;
         } else if (strncmp(http, "HTTP/1.0", 8)) {
                 goto err;
         }
 
         if (!request->headers) {
                 if (switch_event_create(&request->headers, SWITCH_EVENT_CHANNEL_DATA) != SWITCH_STATUS_SUCCESS) {
                         goto err;
                 }
                 request->_destroy_headers = SWITCH_TRUE;
         }
 
         p = strchr(http, '\n');
 
         if (p) {
                 *p++ = '\0'; // now the first header
         } else {
                 goto noheader;
         }
 
         header_count = switch_separate_string(p, '\n', headers, sizeof(headers)/ sizeof(headers[0]));
 
         if (header_count < 1) goto err;
 
         for (i = 0; i < header_count; i++) {
                 char *header, *value;
                 int len;
 
                 argc = switch_separate_string(headers[i], ':', argv, 2);
 
                 if (argc != 2) goto err;
 
                 header = argv[0];
                 value = argv[1];
 
                 if (*value == ' ') value++;
 
                 len = strlen(value);
 
                 if (len && *(value + len - 1) == '\r') *(value + len - 1) = '\0';
 
                 switch_event_add_header_string(request->headers, SWITCH_STACK_BOTTOM, header, value);
 
                 if (!strncasecmp(header, "User-Agent", 10)) {
                         request->user_agent = value;
                 } else if (!strncasecmp(header, "Host", 4)) {
                         request->host = value;
                         p = strchr(value, ':');
 
                         if (p) {
                                 *p++ = '\0';
 
                                 if (*p) request->port = (switch_port_t)atoi(p);
                         }
                 } else if (!strncasecmp(header, "Content-Type", 12)) {
                         request->content_type = value;
                 } else if (!strncasecmp(header, "Content-Length", 14)) {
                         request->content_length = atoi(value);
                 } else if (!strncasecmp(header, "Referer", 7)) {
                         request->referer = value;
                 }
         }
 
 noheader:
 
         if (request->qs) {
                 switch_http_parse_qs(request, NULL);
         }
 
         return SWITCH_STATUS_SUCCESS;
 
 err:
         switch_http_free_request(request);
         return status;
 }

◆ switch_http_parse_qs()

void switch_http_parse_qs	(	switch_http_request_t *	request,
		char *	qs
	)

parse http query string

Parameters

[in]	request	the http request object
[in]	qs	the query string buffer

qs buffer will be modified, so be sure to dup the qs before passing into this function if you want to keep the original string untouched if qs is NULL, the it will parse request->qs, request->qs will be duplicated before parse to avoid being modified

Definition at line 4337 of file switch_utils.c.

References switch_http_request_s::headers, name, switch_network_node::next, switch_http_request_s::qs, switch_assert, switch_event_add_header_string(), switch_safe_free, SWITCH_STACK_BOTTOM, and switch_url_decode().

Referenced by switch_http_parse_header().

 {
         char *q;
         char *next;
         char *name, *val;
         char *dup = NULL;
 
         if (qs) {
                 q = qs;
         } else { /*parse our own qs, dup to avoid modify the original string */
                 dup = q = strdup(request->qs);
         }
 
         switch_assert(q);
         next = q;
 
         do {
                 char *p;
 
                 if ((next = strchr(next, '&'))) {
                         *next++ = '\0';
                 }
 
                 for (p = q; p && *p; p++) {
                         if (*p == '+') *p = ' ';
                 }
 
                 switch_url_decode(q);
 
                 name = q;
                 if ((val = strchr(name, '='))) {
                         *val++ = '\0';
                         switch_event_add_header_string(request->headers, SWITCH_STACK_BOTTOM, name, val);
                 }
                 q = next;
         } while (q);
 
         switch_safe_free(dup);
 }

◆ switch_inet_pton()

int switch_inet_pton	(	int	af,
		const char *	src,
		void *	dst
	)

Definition at line 74 of file inet_pton.c.

References inet_pton4().

Referenced by check_ice(), switch_check_network_list_ip_port_token(), switch_find_local_ip(), switch_network_list_add_host_port_mask(), and switch_parse_cidr().

 {
         switch (af) {
         case AF_INET:
                 return (inet_pton4(src, (unsigned char *) dst));
 #ifdef ENABLE_IPV6
 #ifndef AF_INET6
 #define AF_INET6        (AF_MAX+1)      /* just to let this compile */
 #endif
         case AF_INET6:
                 return (inet_pton6(src, (unsigned char *) dst));
 #endif
         default:
                 errno = EAFNOSUPPORT;
                 return (-1);
         }
         /* NOTREACHED */
 }

◆ switch_is_digit_string()

static switch_bool_t switch_is_digit_string ( const char * s )

inlinestatic

Definition at line 437 of file switch_utils.h.

References SWITCH_FALSE, and SWITCH_TRUE.

 {
 
         while (s && *s) {
                 if (*s < 48 || *s > 57) {
                         return SWITCH_FALSE;
                 }
                 s++;
         }
 
         return SWITCH_TRUE;
 }

◆ switch_is_file_path()

static switch_bool_t switch_is_file_path ( const char * file )

inlinestatic

Definition at line 1281 of file switch_utils.h.

References SWITCH_FALSE, switch_find_end_paren(), SWITCH_TRUE, SWITCH_URL_SEPARATOR, and zstr.

Referenced by db_pick_path(), enterprise_originate_ringback_thread(), preprocess_glob(), setup_ringback(), switch_config_open_file(), switch_core_check_dtls_pem(), switch_core_gen_certs(), switch_img_txt_handle_create(), switch_ivr_displace_session(), switch_ivr_play_file(), switch_ivr_record_file_event(), switch_ivr_record_session_event(), switch_ivr_wait_for_answer(), switch_loadable_module_load_module_ex(), and switch_stream_write_file_contents().

 {
         const char *e;
         int r;
 
         if (zstr(file)) {
                 return SWITCH_FALSE;
         }
 
         while(*file == '{') {
                 if ((e = switch_find_end_paren(file, '{', '}'))) {
                         file = e + 1;
                         while(*file == ' ') file++;
                 }
         }
 
 #ifdef WIN32
         r = (*file == '\\' || *(file + 1) == ':' || *file == '/' || strstr(file, SWITCH_URL_SEPARATOR));
 #else
         r = ((*file == '/') || strstr(file, SWITCH_URL_SEPARATOR));
 #endif
 
         return r ? SWITCH_TRUE : SWITCH_FALSE;
 }

◆ switch_is_lan_addr()

switch_bool_t switch_is_lan_addr ( const char * ip )

Definition at line 1355 of file switch_utils.c.

References SWITCH_FALSE, SWITCH_TRUE, and zstr.

 {
         if (zstr(ip))
                 return SWITCH_FALSE;
 
         return (strncmp(ip, "10.", 3) &&       /* 10.0.0.0        -   10.255.255.255  (10/8 prefix)       */
                         strncmp(ip, "192.168.", 8) &&  /* 192.168.0.0     -   192.168.255.255 (192.168/16 prefix) */
                         strncmp(ip, "127.", 4) &&      /* 127.0.0.0       -   127.255.255.255 (127/8 prefix)      */
                         strncmp(ip, "255.", 4) &&
                         strncmp(ip, "0.", 2) &&
                         strncmp(ip, "1.", 2) &&
                         strncmp(ip, "2.", 2) &&
                         strncmp(ip, "172.16.", 7) &&   /* 172.16.0.0      -   172.31.255.255  (172.16/12 prefix)  */
                         strncmp(ip, "172.17.", 7) &&
                         strncmp(ip, "172.18.", 7) &&
                         strncmp(ip, "172.19.", 7) &&
                         strncmp(ip, "172.20.", 7) &&
                         strncmp(ip, "172.21.", 7) &&
                         strncmp(ip, "172.22.", 7) &&
                         strncmp(ip, "172.23.", 7) &&
                         strncmp(ip, "172.24.", 7) &&
                         strncmp(ip, "172.25.", 7) &&
                         strncmp(ip, "172.26.", 7) &&
                         strncmp(ip, "172.27.", 7) &&
                         strncmp(ip, "172.28.", 7) &&
                         strncmp(ip, "172.29.", 7) &&
                         strncmp(ip, "172.30.", 7) &&
                         strncmp(ip, "172.31.", 7) &&
                         strncmp(ip, "192.0.2.", 8) &&  /* 192.0.2.0       -   192.0.2.255      (192.0.2/24 prefix) */
                         strncmp(ip, "169.254.", 8)     /* 169.254.0.0     -   169.254.255.255  (169.254/16 prefix) */
                 )? SWITCH_FALSE : SWITCH_TRUE;
 }

◆ switch_is_leading_number()

switch_bool_t switch_is_leading_number ( const char * str )

Definition at line 1654 of file switch_utils.c.

References SWITCH_FALSE, and SWITCH_TRUE.

Referenced by switch_core_media_filter_sdp(), and switch_known_bitrate().

 {
         const char *p;
         switch_bool_t r = SWITCH_FALSE;
 
         if (*str == '-' || *str == '+') {
                 str++;
         }
 
         for (p = str; p && *p; p++) {
                 if ((*p == '.' || (*p > 47 && *p < 58))) {
                         r = SWITCH_TRUE;
                         break;
                 }
         }
 
         return r;
 }

◆ switch_is_moh()

static switch_bool_t switch_is_moh ( const char * s )

inlinestatic

Definition at line 319 of file switch_utils.h.

References SWITCH_FALSE, SWITCH_TRUE, and zstr.

Referenced by switch_ivr_parse_event().

 {
         if (zstr(s) || !strcasecmp(s, "silence") || !strcasecmp(s, "indicate_hold")) {
                 return SWITCH_FALSE;
         }
         return SWITCH_TRUE;
 }

◆ switch_is_number()

switch_bool_t switch_is_number ( const char * str )

Definition at line 1635 of file switch_utils.c.

References SWITCH_FALSE, and SWITCH_TRUE.

Referenced by check_channel_status(), load_configuration(), switch_channel_perform_mark_answered(), switch_false(), switch_format_number(), switch_ivr_originate(), switch_ivr_phrase_macro_event(), switch_known_bitrate(), switch_log_str2level(), switch_speex_fmtp_parse(), switch_true(), switch_xml_config_parse_event(), switch_xml_locate_user_merged(), and switch_xml_std_datetime_check().

 {
         const char *p;
         switch_bool_t r = SWITCH_TRUE;
 
         if (*str == '-' || *str == '+') {
                 str++;
         }
 
         for (p = str; p && *p; p++) {
                 if (!(*p == '.' || (*p > 47 && *p < 58))) {
                         r = SWITCH_FALSE;
                         break;
                 }
         }
 
         return r;
 }

◆ switch_is_uint_in_range()

switch_bool_t switch_is_uint_in_range	(	const char *	str,
		unsigned int	from,
		unsigned int	to
	)

Check if a 32 bit unsigned number is in a range.

Parameters

str	string to check. Should not contain non-digit characters.
from	start of range including this number
to	end of range including this number

Returns: true or false

Definition at line 1611 of file switch_utils.c.

References number, switch_network_node::str, SWITCH_FALSE, and SWITCH_TRUE.

Referenced by check_ice(), and switch_known_bitrate().

 {
         unsigned int number;
         const char *original_str = str;
 
         if (str == NULL || *str == '\0' || from > to) {
                 return SWITCH_FALSE;
         }
 
         for (; *str != '\0'; str++) {
                 if (!isdigit(*str)) {
                         return SWITCH_FALSE;
                 }
         }
 
         number = atoi(original_str);
 
         if (number < from || number > to) {
                 return SWITCH_FALSE;
         }
 
         return SWITCH_TRUE;
 }

◆ switch_isalnum()

int switch_isalnum ( int c )

Definition at line 3978 of file switch_utils.c.

References _L, _N, and _U.

Referenced by switch_tolower_max().

 {
         return (c < 0 ? 0 : c > 255 ? 0 : ((_switch_ctype_ + 1)[(unsigned char) c] & (_U | _L | _N)));
 }

◆ switch_isalpha()

int switch_isalpha ( int c )

Definition at line 3983 of file switch_utils.c.

References _L, and _U.

Referenced by switch_tolower_max().

 {
         return (c < 0 ? 0 : c > 255 ? 0 : ((_switch_ctype_ + 1)[(unsigned char) c] & (_U | _L)));
 }

◆ switch_iscntrl()

int switch_iscntrl ( int c )

Definition at line 3988 of file switch_utils.c.

References _C.

Referenced by switch_tolower_max().

 {
         return (c < 0 ? 0 : c > 255 ? 0 : ((_switch_ctype_ + 1)[(unsigned char) c] & _C));
 }

◆ switch_isdigit()

int switch_isdigit ( int c )

Definition at line 3993 of file switch_utils.c.

References _N.

Referenced by switch_tolower_max().

 {
         return (c < 0 ? 0 : c > 255 ? 0 : ((_switch_ctype_ + 1)[(unsigned char) c] & _N));
 }

◆ switch_isgraph()

int switch_isgraph ( int c )

Definition at line 3998 of file switch_utils.c.

References _L, _N, and _U.

Referenced by switch_tolower_max().

 {
         return (c < 0 ? 0 : c > 255 ? 0 : ((_switch_ctype_ + 1)[(unsigned char) c] & (_P | _U | _L | _N)));
 }

◆ switch_islower()

int switch_islower ( int c )

Definition at line 4003 of file switch_utils.c.

References _L.

Referenced by switch_tolower_max().

 {
         return (c < 0 ? 0 : c > 255 ? 0 : ((_switch_ctype_ + 1)[(unsigned char) c] & _L));
 }

◆ switch_isprint()

int switch_isprint ( int c )

Definition at line 4008 of file switch_utils.c.

References _B, _L, _N, and _U.

Referenced by switch_tolower_max().

 {
         return (c < 0 ? 0 : c > 255 ? 0 : ((_switch_ctype_ + 1)[(unsigned char) c] & (_P | _U | _L | _N | _B)));
 }

◆ switch_ispunct()

int switch_ispunct ( int c )

Definition at line 4013 of file switch_utils.c.

Referenced by switch_tolower_max().

 {
         return (c < 0 ? 0 : c > 255 ? 0 : ((_switch_ctype_ + 1)[(unsigned char) c] & _P));
 }

◆ switch_isspace()

int switch_isspace ( int c )

Definition at line 4018 of file switch_utils.c.

References _S.

Referenced by switch_tolower_max().

 {
         return (c < 0 ? 0 : c > 255 ? 0 : ((_switch_ctype_ + 1)[(unsigned char) c] & _S));
 }

◆ switch_isupper()

int switch_isupper ( int c )

Definition at line 4023 of file switch_utils.c.

References _U.

Referenced by switch_tolower_max().

 {
         return (c < 0 ? 0 : c > 255 ? 0 : ((_switch_ctype_ + 1)[(unsigned char) c] & _U));
 }

◆ switch_isxdigit()

int switch_isxdigit ( int c )

Definition at line 4028 of file switch_utils.c.

References _N, and _X.

Referenced by switch_tolower_max().

 {
         return (c < 0 ? 0 : c > 255 ? 0 : ((_switch_ctype_ + 1)[(unsigned char) c] & (_N | _X)));
 }

◆ switch_itodtmf()

static char switch_itodtmf ( char i )

inlinestatic

Definition at line 450 of file switch_utils.h.

Referenced by switch_ivr_bind_dtmf_meta_session().

 {
         char r = i;
 
         if (i > 9 && i < 14) {
                 r += 55;
         } else {
                 r += 48;
         }
 
         return r;
 }

◆ switch_jwt_sign()

char* switch_jwt_sign	(	const char *	secret,
		const uint8_t *	payload,
		switch_size_t	size
	)

Parameters

[in]	secret	the secret string
[in]	payload	the payload
[in]	size	the payload size

Returns: NULL or signed token

Definition at line 5007 of file switch_utils.c.

References SHA256_LENGTH, switch_assert, switch_b64_encode(), switch_mprintf(), and switch_must_malloc().

 {
         cJSON *json;
         switch_size_t need;
         char *header;
         uint8_t *bheader;
         uint8_t *bpayload;
         char *to_sign;
         unsigned int len = 0;
         unsigned char signature[SHA256_LENGTH];
         unsigned char *bsignature;
         char *result = NULL;
 
         if (!secret || !payload) return NULL;
 
         json = cJSON_CreateObject();
         switch_assert(json);
         cJSON_AddStringToObject(json, "alg", "HS256");
         cJSON_AddStringToObject(json, "typ", "JWT");
         header = cJSON_Print(json);
         cJSON_Delete(json);
         if (!header) return NULL;
 
         need = ((strlen(header) + 3 - 1) / 3) * 4 + 1; // with extra NULL
         bheader = (uint8_t *)switch_must_malloc(need);
         switch_b64_encode((unsigned char *)header, strlen(header), bheader, need);
         free(header);
         header = NULL;
 
         need = ((size + 3 - 1) / 3) * 4 + 1; // with extra NULL
         bpayload = (uint8_t *)switch_must_malloc(need);
         switch_b64_encode((unsigned char *)payload, size, bpayload, need);
 
         to_sign = switch_mprintf("%s.%s", (char *)bheader, (char *)bpayload);
         switch_assert(to_sign);
 
         HMAC(EVP_sha256(), secret, strlen(secret), (unsigned char *)to_sign, strlen(to_sign), signature, &len);
         switch_assert(len == SHA256_LENGTH);
         free(to_sign);
         to_sign = NULL;
 
         need = ((len + 3 - 1) / 3) * 4 + 1; // with extra NULL
         bsignature = (uint8_t *)switch_must_malloc(need);
         switch_b64_encode((unsigned char *)signature, len, bsignature, need);
         result = switch_mprintf("%s.%s.%s", bheader, bpayload, bsignature);
 
         free(bheader);
         free(bpayload);
         free(bsignature);
 
         return result;
 }

◆ switch_jwt_verify()

cJSON* switch_jwt_verify	(	const char *	secret,
		const char *	token
	)

Parameters

[in]	secret	the secret string
[in]	token	the jwt token, only alg: HS256 is supported

Returns: NULL or payload in cJSON

Definition at line 4943 of file switch_utils.c.

References cJSON_GetObjectCstr(), switch_network_node::ok, SHA256_LENGTH, switch_assert, switch_b64_decode(), switch_must_malloc(), and switch_safe_free.

 {
         int ok = 0;
         cJSON *json = NULL;
         cJSON *payload = NULL;
         char *out = NULL;
         unsigned int len = 0;
         unsigned char signature[SHA256_LENGTH];
         const char *alg = NULL;
         const char *typ = NULL;
         char *header = strdup(token);
         char *dot;
 
         switch_assert(header);
         dot = strchr(header, '.');
         if (!dot) goto end;
         *dot = '\0';
         out = (char *)switch_must_malloc(strlen(header) + 1);
         len = switch_b64_decode((const char *)header, out, strlen(header) + 1);
         if (len == 0) goto end;
         json = cJSON_Parse(out); // header
         free(out);
         out = NULL;
         if (!json) goto end;
         alg = cJSON_GetObjectCstr(json, "alg");
         if (!alg || strcmp(alg, "HS256")) goto end;
         typ = cJSON_GetObjectCstr(json, "typ");
         if (!typ || strcmp(typ, "JWT")) goto end;
         cJSON_Delete(json);
         json = NULL;
         dot++; // payload
         dot = strrchr(token, '.');
         if (!dot) goto end;
         HMAC(EVP_sha256(), secret, strlen(secret), (unsigned char *)token, dot - token, signature, &len);
         if (len != SHA256_LENGTH) goto end;
         dot++; // signature
         out = (char *)switch_must_malloc(strlen(dot) + 1);
         len = switch_b64_decode((const char *)dot, out, strlen(dot) + 1);
         if (len != SHA256_LENGTH) goto end;
         ok = !memcmp(out, signature, len);
         free(out);
         out = NULL;
 
         if (ok) {
                 char *p = strchr(token, '.');
 
                 if (p) {
                         p++;
                         out = (char *)switch_must_malloc(strlen(p));
                         len = switch_b64_decode((const char *)p, out, strlen(p));
                         payload = cJSON_Parse(out);
                         free(out);
                         out = NULL;
                 }
         }
 
 end:
         switch_safe_free(header);
         switch_safe_free(out);
         if (json) cJSON_Delete(json);
 
         return payload;
 }

◆ switch_known_bitrate()

static uint32_t switch_known_bitrate ( switch_payload_t payload )

inlinestatic

Definition at line 479 of file switch_utils.h.

References buf, pool, SWITCH_DECLARE, switch_fd_read_dline(), switch_fd_read_line(), switch_find_parameter(), switch_fp_read_dline(), switch_frame_alloc(), switch_frame_dup(), switch_frame_free(), switch_is_leading_number(), switch_is_number(), switch_is_uint_in_range(), and to.

Referenced by add_audio_codec(), and switch_core_media_negotiate_sdp().

 {
         switch(payload) {
         case 0: /* PCMU */ return 64000;
         case 3: /* GSM */ return 13200;
         case 4: /* G723 */ return 6300;
         case 7: /* LPC */ return 2400;
         case 8: /* PCMA */ return 64000;
         case 9: /* G722 */ return 64000;
         case 18: /* G729 */ return 8000;
         default: break;
         }
 
         return 0;
 }

◆ switch_lc_strdup()

static char* switch_lc_strdup ( const char * it )

inlinestatic

Definition at line 900 of file switch_utils.h.

References switch_tolower_max().

 {
         char *dup;
 
         if (it) {
                 dup = strdup(it);
                 switch_tolower_max(dup);
                 return dup;
         }
 
         return NULL;
 }

◆ switch_memory_usage_stream()

const char* switch_memory_usage_stream ( switch_stream_handle_t * stream )

Definition at line 4810 of file switch_utils.c.

References FALSE, switch_goto_status, SWITCH_SIZE_T_FMT, and switch_stream_handle::write_function.

 {
         const char *status = NULL;
 #ifdef __GLIBC__
 /*
  *  The mallinfo2() function was added in glibc 2.33.
  *  https://man7.org/linux/man-pages/man3/mallinfo.3.html
  */
 #if defined(__GLIBC_PREREQ) && __GLIBC_PREREQ(2, 33)
         struct mallinfo2 mi;
 
         mi = mallinfo2();
 
         stream->write_function(stream, "Total non-mmapped bytes (arena):       %" SWITCH_SIZE_T_FMT "\n", mi.arena);
         stream->write_function(stream, "# of free chunks (ordblks):            %" SWITCH_SIZE_T_FMT "\n", mi.ordblks);
         stream->write_function(stream, "# of free fastbin blocks (smblks):     %" SWITCH_SIZE_T_FMT "\n", mi.smblks);
         stream->write_function(stream, "# of mapped regions (hblks):           %" SWITCH_SIZE_T_FMT "\n", mi.hblks);
         stream->write_function(stream, "Bytes in mapped regions (hblkhd):      %" SWITCH_SIZE_T_FMT "\n", mi.hblkhd);
         stream->write_function(stream, "Max. total allocated space (usmblks):  %" SWITCH_SIZE_T_FMT "\n", mi.usmblks);
         stream->write_function(stream, "Free bytes held in fastbins (fsmblks): %" SWITCH_SIZE_T_FMT "\n", mi.fsmblks);
         stream->write_function(stream, "Total allocated space (uordblks):      %" SWITCH_SIZE_T_FMT "\n", mi.uordblks);
         stream->write_function(stream, "Total free space (fordblks):           %" SWITCH_SIZE_T_FMT "\n", mi.fordblks);
         stream->write_function(stream, "Topmost releasable block (keepcost):   %" SWITCH_SIZE_T_FMT "\n", mi.keepcost);
 #else
         struct mallinfo mi;
 
         mi = mallinfo();
 
         stream->write_function(stream, "Total non-mmapped bytes (arena):       %u\n", mi.arena);
         stream->write_function(stream, "# of free chunks (ordblks):            %u\n", mi.ordblks);
         stream->write_function(stream, "# of free fastbin blocks (smblks):     %u\n", mi.smblks);
         stream->write_function(stream, "# of mapped regions (hblks):           %u\n", mi.hblks);
         stream->write_function(stream, "Bytes in mapped regions (hblkhd):      %u\n", mi.hblkhd);
         stream->write_function(stream, "Max. total allocated space (usmblks):  %u\n", mi.usmblks);
         stream->write_function(stream, "Free bytes held in fastbins (fsmblks): %u\n", mi.fsmblks);
         stream->write_function(stream, "Total allocated space (uordblks):      %u\n", mi.uordblks);
         stream->write_function(stream, "Total free space (fordblks):           %u\n", mi.fordblks);
         stream->write_function(stream, "Topmost releasable block (keepcost):   %u\n", mi.keepcost);
 
 #endif
 
         switch_goto_status(NULL, done);
 #else
 #ifdef WIN32
         /* Based on: https://docs.microsoft.com/en-us/windows/win32/memory/enumerating-a-heap and https://docs.microsoft.com/en-us/windows/win32/memory/getting-process-heaps */
         PHANDLE aHeaps;
         SIZE_T BytesToAllocate;
         DWORD HeapsIndex;
         DWORD HeapsLength;
         DWORD NumberOfHeaps;
         HRESULT Result;
         HANDLE hDefaultProcessHeap;
         size_t CommittedSizeTotal = 0;
         size_t UnCommittedSizeTotal = 0;
         size_t SizeTotal = 0;
         size_t OverheadTotal = 0;
 
         NumberOfHeaps = GetProcessHeaps(0, NULL);
         Result = SIZETMult(NumberOfHeaps, sizeof(*aHeaps), &BytesToAllocate);
         if (Result != S_OK) {
                 switch_goto_status("SIZETMult failed.", done);
         }
 
         hDefaultProcessHeap = GetProcessHeap();
         if (hDefaultProcessHeap == NULL) {
                 switch_goto_status("Failed to retrieve the default process heap", done);
         }
 
         aHeaps = (PHANDLE)HeapAlloc(hDefaultProcessHeap, 0, BytesToAllocate);
         if (aHeaps == NULL) {
                 switch_goto_status("HeapAlloc failed to allocate space for heaps", done);
         }
 
         HeapsLength = NumberOfHeaps;
         NumberOfHeaps = GetProcessHeaps(HeapsLength, aHeaps);
 
         if (NumberOfHeaps == 0) {
                 switch_goto_status("Failed to retrieve heaps", cleanup);
         } else if (NumberOfHeaps > HeapsLength) {
                 /*
                  * Compare the latest number of heaps with the original number of heaps.
                  * If the latest number is larger than the original number, another
                  * component has created a new heap and the buffer is too small.
                  */
                 switch_goto_status("Another component created a heap between calls.", cleanup);
         }
 
         stream->write_function(stream, "Process has %d heaps.\n", HeapsLength);
         for (HeapsIndex = 0; HeapsIndex < HeapsLength; ++HeapsIndex) {
                 PROCESS_HEAP_ENTRY Entry;
                 HANDLE hHeap = aHeaps[HeapsIndex];
 
                 stream->write_function(stream, "Heap %d at address: %#p.\n", HeapsIndex, aHeaps[HeapsIndex]);
 
                 /* Lock the heap to prevent other threads from accessing the heap during enumeration. */
                 if (HeapLock(hHeap) == FALSE) {
                         switch_goto_status("Failed to lock heap.", cleanup);
                 }
 
                 Entry.lpData = NULL;
                 while (HeapWalk(hHeap, &Entry) != FALSE) {
                         if ((Entry.wFlags & PROCESS_HEAP_ENTRY_BUSY) != 0) {
                         } else if ((Entry.wFlags & PROCESS_HEAP_REGION) != 0) {
                                 CommittedSizeTotal += Entry.Region.dwCommittedSize;
                                 UnCommittedSizeTotal += Entry.Region.dwUnCommittedSize;
                         }
 
                         SizeTotal += Entry.cbData;
                         OverheadTotal += Entry.cbOverhead;
                 }
 
                 /* Unlock the heap to allow other threads to access the heap after enumeration has completed. */
                 if (HeapUnlock(hHeap) == FALSE) {
                         abort();
                 }
         }
 
         stream->write_function(stream, "Committed bytes:   %" SWITCH_SIZE_T_FMT "\n", CommittedSizeTotal);
         stream->write_function(stream, "Uncommited bytes:  %" SWITCH_SIZE_T_FMT "\n", UnCommittedSizeTotal);
         stream->write_function(stream, "Size:              %" SWITCH_SIZE_T_FMT "\n", SizeTotal);
         stream->write_function(stream, "Overhead:          %" SWITCH_SIZE_T_FMT"\n", OverheadTotal);
 
 cleanup:
         HeapFree(hDefaultProcessHeap, 0, aHeaps);
 #else
         switch_goto_status("Memory usage statistics is not implemented on the current platform.", done);
 #endif
 #endif
 done:
         return status;
 }

◆ switch_must_strdup()

char* switch_must_strdup ( const char * _s )

Definition at line 4803 of file switch_utils.c.

References switch_assert.

Referenced by preprocess_glob(), switch_xml_locate_user_merged(), switch_xml_parse_str_dynamic(), switch_xml_proc_inst(), switch_xml_set_attr(), switch_xml_set_attr_d(), and switch_xml_set_attr_d_buf().

 {
         char *s = strdup(_s);
         switch_assert(s);
         return s;
 }

◆ switch_needs_url_encode()

static int switch_needs_url_encode ( const char * s )

inlinestatic

Definition at line 1214 of file switch_utils.h.

References end_of_p, pool, switch_core_session_url_encode(), switch_core_session_url_encode_opt(), switch_core_url_encode(), switch_core_url_encode_opt(), SWITCH_DECLARE, switch_find_end_paren(), switch_simple_email(), switch_url_decode(), switch_url_encode(), switch_url_encode_opt(), SWITCH_URL_UNSAFE, and to.

 {
         const char hex[] = "0123456789ABCDEF";
         const char *p, *e = end_of_p(s);
 
 
         for(p = s; p && *p; p++) {
                 if (*p == '%' && e-p > 1) {
                         if (strchr(hex, *(p+1)) && strchr(hex, *(p+2))) {
                                 p++;
                                 continue;
                         }
                 }
 
                 if (strchr(SWITCH_URL_UNSAFE, *p)) {
                         return 1;
                 }
         }
 
         return 0;
 }

◆ switch_network_ipv4_mapped_ipv6_addr()

char* switch_network_ipv4_mapped_ipv6_addr ( const char * ip_str )

Definition at line 582 of file switch_utils.c.

Referenced by switch_check_network_list_ip_port_token(), and switch_network_list_perform_add_cidr_token().

 {
         /* ipv4 mapped ipv6 address */
 
         if (strncasecmp(ip_str, "::ffff:", 7)) {
                 return NULL;
         }
 
         return strdup(ip_str + 7);
 }

◆ switch_network_list_add_cidr_port_token()

switch_status_t switch_network_list_add_cidr_port_token	(	switch_network_list_t *	list,
		const char *	cidr_str,
		switch_bool_t	ok,
		const char *	token,
		switch_network_port_range_p	port
	)

Definition at line 675 of file switch_utils.c.

References switch_assert, switch_network_list_perform_add_cidr_token(), switch_safe_free, switch_separate_string(), and SWITCH_STATUS_SUCCESS.

Referenced by switch_load_network_lists(), and switch_network_list_add_cidr_token().

 {
         char *cidr_str_dup = NULL;
         switch_status_t status = SWITCH_STATUS_SUCCESS;
 
         if (strchr(cidr_str, ',')) {
                 char *argv[32] = { 0 };
                 int i, argc;
                 cidr_str_dup = strdup(cidr_str);
 
                 switch_assert(cidr_str_dup);
                 if ((argc = switch_separate_string(cidr_str_dup, ',', argv, (sizeof(argv) / sizeof(argv[0]))))) {
                         for (i = 0; i < argc; i++) {
                                 switch_status_t this_status;
                                 if ((this_status = switch_network_list_perform_add_cidr_token(list, argv[i], ok, token, port)) != SWITCH_STATUS_SUCCESS) {
                                         status = this_status;
                                 }
                         }
                 }
         } else {
                 status = switch_network_list_perform_add_cidr_token(list, cidr_str, ok, token, port);
         }
 
         switch_safe_free(cidr_str_dup);
         return status;
 }

◆ switch_network_list_add_cidr_token()

switch_status_t switch_network_list_add_cidr_token	(	switch_network_list_t *	list,
		const char *	cidr_str,
		switch_bool_t	ok,
		const char *	token
	)

Definition at line 702 of file switch_utils.c.

References switch_network_list_add_cidr_port_token().

Referenced by switch_load_network_lists(), and switch_parse_audio_col().

 {
         return switch_network_list_add_cidr_port_token(list, cidr_str, ok, token, NULL);
 }

◆ switch_network_list_add_host_mask()

switch_status_t switch_network_list_add_host_mask	(	switch_network_list_t *	list,
		const char *	host,
		const char *	mask_str,
		switch_bool_t	ok
	)

Definition at line 737 of file switch_utils.c.

References switch_network_list_add_host_port_mask().

Referenced by switch_load_network_lists().

 {
         return switch_network_list_add_host_port_mask(list, host, mask_str, ok, NULL);
 }

◆ switch_network_list_add_host_port_mask()

switch_status_t switch_network_list_add_host_port_mask	(	switch_network_list_t *	list,
		const char *	host,
		const char *	mask_str,
		switch_bool_t	ok,
		switch_network_port_range_p	port
	)

Definition at line 707 of file switch_utils.c.

References switch_network_node::bits, switch_network_node::ip, switch_network_node::mask, switch_network_node::next, switch_network_list::node_head, switch_network_node::ok, switch_network_list::pool, switch_network_node::port_range, switch_network_node::str, switch_core_alloc, switch_core_sprintf(), switch_inet_pton(), SWITCH_STATUS_SUCCESS, and ip_t::v4.

Referenced by switch_load_network_lists(), and switch_network_list_add_host_mask().

 {
         ip_t ip, mask;
         switch_network_node_t *node;
 
         switch_inet_pton(AF_INET, host, &ip);
         switch_inet_pton(AF_INET, mask_str, &mask);
 
         node = switch_core_alloc(list->pool, sizeof(*node));
 
         node->ip.v4 = ntohl(ip.v4);
         node->mask.v4 = ntohl(mask.v4);
         node->ok = ok;
         if(port) {
                 memcpy(&node->port_range, port, sizeof(switch_network_port_range_t));
         }
 
         /* http://graphics.stanford.edu/~seander/bithacks.html */
         mask.v4 = mask.v4 - ((mask.v4 >> 1) & 0x55555555);
         mask.v4 = (mask.v4 & 0x33333333) + ((mask.v4 >> 2) & 0x33333333);
         node->bits = (((mask.v4 + (mask.v4 >> 4)) & 0xF0F0F0F) * 0x1010101) >> 24;
 
         node->str = switch_core_sprintf(list->pool, "%s:%s", host, mask_str);
 
         node->next = list->node_head;
         list->node_head = node;
 
         return SWITCH_STATUS_SUCCESS;
 }

◆ switch_network_list_create()

switch_status_t switch_network_list_create	(	switch_network_list_t **	list,
		const char *	name,
		switch_bool_t	default_type,
		switch_memory_pool_t *	pool
	)

Definition at line 459 of file switch_utils.c.

References switch_network_list::default_type, switch_network_list::name, pool, switch_network_list::pool, switch_core_alloc, switch_core_new_memory_pool, switch_core_strdup, and SWITCH_STATUS_SUCCESS.

Referenced by switch_load_network_lists(), and switch_parse_audio_col().

 {
         switch_network_list_t *new_list;
 
         if (!pool) {
                 switch_core_new_memory_pool(&pool);
         }
 
         new_list = switch_core_alloc(pool, sizeof(**list));
         new_list->pool = pool;
         new_list->default_type = default_type;
         new_list->name = switch_core_strdup(new_list->pool, name);
 
         *list = new_list;
 
         return SWITCH_STATUS_SUCCESS;
 }

◆ switch_network_list_validate_ip6_port_token()

switch_bool_t switch_network_list_validate_ip6_port_token	(	switch_network_list_t *	list,
		ip_t	ip,
		int	port,
		const char **	token
	)

Definition at line 497 of file switch_utils.c.

References switch_network_node::bits, switch_network_list::default_type, switch_network_node::family, switch_network_node::ip, switch_network_node::mask, switch_network_node::next, switch_network_list::node_head, switch_network_node::ok, SWITCH_FALSE, switch_testv6_subnet(), SWITCH_TRUE, and switch_network_node::token.

Referenced by switch_check_network_list_ip_port_token(), and switch_network_list_validate_ip6_token().

 {
         switch_network_node_t *node;
         switch_bool_t ok = list->default_type;
         uint32_t bits = 0;
 
         for (node = list->node_head; node; node = node->next) {
                 if (node->family == AF_INET) continue;
 
                 if (node->bits >= bits && switch_testv6_subnet(ip, node->ip, node->mask)) {
                         if (node->ok) {
                                 ok = SWITCH_TRUE;
                         } else {
                                 ok = SWITCH_FALSE;
                         }
 
                         bits = node->bits;
 
                         if (token) {
                                 *token = node->token;
                         }
                 }
         }
 
         return ok;
 }

◆ switch_network_list_validate_ip6_token()

switch_bool_t switch_network_list_validate_ip6_token	(	switch_network_list_t *	list,
		ip_t	ip,
		const char **	token
	)

Definition at line 572 of file switch_utils.c.

References switch_network_list_validate_ip6_port_token().

 {
         return switch_network_list_validate_ip6_port_token(list, ip, 0, token);
 }

◆ switch_network_list_validate_ip_port_token()

switch_bool_t switch_network_list_validate_ip_port_token	(	switch_network_list_t *	list,
		uint32_t	ip,
		int	port,
		const char **	token
	)

Definition at line 546 of file switch_utils.c.

References switch_network_node::bits, switch_network_list::default_type, switch_network_node::family, switch_network_node::ip, is_port_in_node(), switch_network_node::mask, switch_network_node::next, switch_network_list::node_head, switch_network_node::ok, SWITCH_FALSE, switch_test_subnet, SWITCH_TRUE, switch_network_node::token, and ip_t::v4.

Referenced by switch_check_network_list_ip_port_token(), and switch_network_list_validate_ip_token().

 {
         switch_network_node_t *node;
         switch_bool_t ok = list->default_type;
         uint32_t bits = 0;
 
         for (node = list->node_head; node; node = node->next) {
                 if (node->family == AF_INET6) continue; /* want AF_INET */
                 if (node->bits >= bits && switch_test_subnet(ip, node->ip.v4, node->mask.v4) && is_port_in_node(port, node)) {
                         if (node->ok) {
                                 ok = SWITCH_TRUE;
                         } else {
                                 ok = SWITCH_FALSE;
                         }
 
                         bits = node->bits;
 
                         if (token) {
                                 *token = node->token;
                         }
                 }
         }
 
         return ok;
 }

◆ switch_network_list_validate_ip_token()

switch_bool_t switch_network_list_validate_ip_token	(	switch_network_list_t *	list,
		uint32_t	ip,
		const char **	token
	)

Definition at line 577 of file switch_utils.c.

References switch_network_list_validate_ip_port_token().

 {
         return switch_network_list_validate_ip_port_token(list, ip, 0, token);
 }

◆ switch_number_cmp()

int switch_number_cmp	(	const char *	exp,
		int	val
	)

Definition at line 4133 of file switch_utils.c.

References b.

Referenced by switch_xml_std_datetime_check().

 {
         // Expression exp must be a comma separated list of numbers or ranges.
         // To match numbers not in range 9-17, enter the reversed range 18-8.
         for (;; ++exp) {
                 int a = strtol(exp, (char **)&exp, 10);
                 if (*exp != '-') {
                         if (a == val)
                                 return 1;
                 } else {
                         int b = strtol(++exp, (char **)&exp, 10);
                         if (a <= b ? (val >= a && val <=b ) : (val >= a || val <= b))
                                 return 1;
                 }
                 if (*exp != ',')
                         return 0;
         }
 }

◆ switch_parse_audio_col()

static const char* switch_parse_audio_col ( switch_audio_col_t col )

inlinestatic

Definition at line 1332 of file switch_utils.h.

References ip, name, SWITCH_AUDIO_COL_STR_ARTIST, SWITCH_AUDIO_COL_STR_COMMENT, SWITCH_AUDIO_COL_STR_COPYRIGHT, SWITCH_AUDIO_COL_STR_DATE, SWITCH_AUDIO_COL_STR_SOFTWARE, SWITCH_AUDIO_COL_STR_TITLE, SWITCH_DECLARE, switch_network_list_add_cidr_token(), switch_network_list_create(), and switch_parse_cidr().

 {
         const char *field = NULL;
 
         switch (col) {
         case SWITCH_AUDIO_COL_STR_TITLE:
                 field = "title";
                 break;
         case SWITCH_AUDIO_COL_STR_COMMENT:
                 field = "comment";
                 break;
         case SWITCH_AUDIO_COL_STR_ARTIST:
                 field = "artist";
                 break;
         case SWITCH_AUDIO_COL_STR_DATE:
                 field = "date";
                 break;
         case SWITCH_AUDIO_COL_STR_SOFTWARE:
                 field = "software";
                 break;
         case SWITCH_AUDIO_COL_STR_COPYRIGHT:
                 field = "copyright";
                 break;
         default:
                 break;
         }
 
         return field;
 }

◆ switch_parse_bandwidth_string()

static int32_t switch_parse_bandwidth_string ( const char * bwv )

inlinestatic

Definition at line 1137 of file switch_utils.h.

Referenced by switch_core_media_gen_local_sdp(), and switch_core_session_parse_codec_settings().

 {
         float bw = 0;
 
         if (!bwv) return 0;
 
         if (!strcasecmp(bwv, "auto")) {
                 return -1;
         }
 
         if ((bw = (float) atof(bwv))) {
                 if (bw < 0) return 0;
 
                 if (strstr(bwv, "KB")) {
                         bw *= 8;
                 } else if (strstr(bwv, "mb")) {
                         bw *= 1024;
                 } else if (strstr(bwv, "MB")) {
                         bw *= 8192;
                 }
         }
 
         return (int32_t) roundf(bw);
 }

◆ switch_parse_cidr()

int switch_parse_cidr	(	const char *	string,
		ip_t *	ip,
		ip_t *	mask,
		uint32_t *	bitp
	)

Definition at line 743 of file switch_utils.c.

References switch_network_node::bits, switch_network_node::ip, switch_network_node::mask, switch_copy_string(), switch_inet_pton(), ip_t::v4, and ip_t::v6.

Referenced by switch_check_network_list_ip_port_token(), switch_network_list_perform_add_cidr_token(), and switch_parse_audio_col().

 {
         char host[128];
         char *bit_str;
         int32_t bits;
         const char *ipv6;
         ip_t *maskv = mask;
         ip_t *ipv = ip;
 
         switch_copy_string(host, string, sizeof(host) - 1);
         bit_str = strchr(host, '/');
 
         if (!bit_str) {
                 return -1;
         }
 
         *bit_str++ = '\0';
         bits = atoi(bit_str);
         ipv6 = strchr(string, ':');
         if (ipv6) {
                 int32_t i, n;
                 uint32_t k;
 
                 if (bits < 0 || bits > 128) {
                         return -2;
                 }
 
                 bits = atoi(bit_str);
                 switch_inet_pton(AF_INET6, host, (unsigned char *)ip);
 
                 for (n = bits, i = 0; i < 16; i++) {
                         k = (n > 8) ? 8 : n;
                         maskv->v6.s6_addr[i] = 0xFF & ~(0xFF >> k);     /* k = 0 gives 0x00, k = 8 gives 0xFF */
                         n -= k;
                 }
         } else {
                 if (bits < 0 || bits > 32) {
                         return -2;
                 }
 
                 bits = atoi(bit_str);
                 switch_inet_pton(AF_INET, host, (unsigned char *)ip);
                 ipv->v4 = htonl(ipv->v4);
 
                 maskv->v4 = 0xFFFFFFFF & ~(0xFFFFFFFF >> bits);
         }
 
         *bitp = bits;
 
         return 0;
 }

◆ switch_parse_cpu_string()

static uint32_t switch_parse_cpu_string ( const char * cpu )

inlinestatic

Definition at line 1162 of file switch_utils.h.

References switch_core_cpu_count().

 {
         int cpu_count = switch_core_cpu_count();
         int ncpu;
 
         if (!cpu) return 1;
 
         if (!strcasecmp(cpu, "auto")) {
                 return (uint32_t)((cpu_count * 3) / 2);
         }
 
         if (!strncasecmp(cpu, "cpu/", 4)) { /* cpu/2 or cpu/2/<max>  */
                 const char *has_max = cpu;
                 float divisor;
                 int max = cpu_count;
 
                 cpu +=4;
 
                 has_max = strchr(cpu, '/');
 
                 if (has_max > cpu) {
                         max = atoi(has_max + 1);
                 }
 
                 divisor = (float)atof(cpu);
 
                 if (divisor <= 0) divisor = 1;
 
                 ncpu = (int)(cpu_count / divisor);
 
                 if (ncpu <= 0) return 1;
 
                 if (ncpu > max) return (uint32_t)max;
 
                 return (uint32_t)ncpu;
         } else if (!strcasecmp(cpu, "cpu")) {
                 ncpu = cpu_count;
         } else {
                 ncpu = atoi(cpu);
 
                 if (strrchr(cpu, '%')) {
                         ncpu = (int) (cpu_count * ((float)ncpu / 100));
                 }
         }
 
         if (ncpu > cpu_count) return (uint32_t)cpu_count;
 
         if (ncpu <= 0) return 1;
 
         return ncpu;
 }

◆ switch_pool_strip_whitespace()

char* switch_pool_strip_whitespace	(	switch_memory_pool_t *	pool,
		const char *	str
	)

Definition at line 1439 of file switch_utils.c.

References switch_network_node::str, switch_assert, SWITCH_BLANK_STRING, switch_core_strdup, and zstr.

 {
         const char *sp = str;
         char *p, *s = NULL;
         size_t len;
 
         if (zstr(sp)) {
                 return switch_core_strdup(pool, SWITCH_BLANK_STRING);
         }
 
         while ((*sp == 13 ) || (*sp == 10 ) || (*sp == 9 ) || (*sp == 32) || (*sp == 11) ) {
                 sp++;
         }
 
         if (zstr(sp)) {
                 return switch_core_strdup(pool, SWITCH_BLANK_STRING);
         }
 
         s = switch_core_strdup(pool, sp);
         switch_assert(s);
 
         if ((len = strlen(s)) > 0) {
                 p = s + (len - 1);
 
                 while ((p >= s) && ((*p == 13 ) || (*p == 10 ) || (*p == 9 ) || (*p == 32) || (*p == 11))) {
                         *p-- = '\0';
                 }
         }
 
         return s;
 }

◆ switch_print_bits()

static char* switch_print_bits	(	const unsigned char *	byte,
		char *	buf,
		switch_size_t	buflen
	)

inlinestatic

Definition at line 412 of file switch_utils.h.

References buf.

 {
         int i;
         switch_size_t j = 0, k = 0, l = 0;
 
         while(k < buflen) {
                 l = 0;
                 for (i = 7; i >= 0; i--) {
                         buf[j++] = (*byte & (1 << i)) ? '1' : '0';
                         if (++l % 4 == 0) {
                                 buf[j++] = ' ';
                         }
                 }
                 k++;
                 byte++;
         }
 
         if (buf[j-1] == ' ') j--;
         buf[j++] = '\0';
         return buf;
 }

◆ switch_print_host()

char* switch_print_host	(	switch_sockaddr_t *	addr,
		char *	buf,
		switch_size_t	len
	)

Definition at line 98 of file switch_utils.c.

References buf, switch_get_addr(), and switch_sockaddr_get_port().

 {
         switch_port_t port;
 
         switch_get_addr(buf, len, addr);
         port = switch_sockaddr_get_port(addr);
 
         snprintf(buf + strlen(buf), len - strlen(buf), ":%d", port);
         return buf;
 }

◆ switch_priority_name()

const char* switch_priority_name ( switch_priority_t priority )

Return a printable name of a switch_priority_t.

Parameters

priority the priority to get the name of

Returns: the printable form of the priority

Definition at line 2173 of file switch_utils.c.

References SWITCH_PRIORITY_HIGH, SWITCH_PRIORITY_LOW, and SWITCH_PRIORITY_NORMAL.

Referenced by switch_errno_is_break(), and switch_event_set_priority().

 {
         switch (priority) {                     /*lol */
         case SWITCH_PRIORITY_NORMAL:
                 return "NORMAL";
         case SWITCH_PRIORITY_LOW:
                 return "LOW";
         case SWITCH_PRIORITY_HIGH:
                 return "HIGH";
         default:
                 return "INVALID";
         }
 }

◆ switch_replace_char()

char* switch_replace_char	(	char *	str,
		char	from,
		char	to,
		switch_bool_t	dup
	)

Definition at line 1419 of file switch_utils.c.

References switch_network_node::str, switch_assert, and to.

 {
         char *p;
 
         if (dup) {
                 p = strdup(str);
                 switch_assert(p);
         } else {
                 p = str;
         }
 
         for (; p && *p; p++) {
                 if (*p == from) {
                         *p = to;
                 }
         }
 
         return p;
 }

◆ switch_resolve_host()

switch_status_t switch_resolve_host	(	const char *	host,
		char *	buf,
		size_t	buflen
	)

Definition at line 1841 of file switch_utils.c.

References get_addr(), SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

Referenced by check_ice(), and switch_false().

 {
 
         struct addrinfo *ai;
 
         if (getaddrinfo(host, 0, 0, &ai)) {
                 return SWITCH_STATUS_FALSE;
         }
 
         get_addr(buf, buflen, ai->ai_addr, sizeof(struct sockaddr_storage));
 
         freeaddrinfo(ai);
 
         return SWITCH_STATUS_SUCCESS;
 }

◆ switch_rfc2833_to_char()

char switch_rfc2833_to_char ( int event )

Return the RFC2833 character based on an event id.

Parameters

event the event id to convert

Returns: the character represented by the event or null for an invalid event

Definition at line 2548 of file switch_utils.c.

References RFC2833_CHARS.

Referenced by handle_rfc2833(), and switch_errno_is_break().

 {
         if (event > -1 && event < (int32_t) sizeof(RFC2833_CHARS)) {
                 return RFC2833_CHARS[event];
         }
         return '\0';
 }

◆ switch_round_to_step()

static uint32_t switch_round_to_step	(	uint32_t	num,
		uint32_t	step
	)

inlinestatic

Definition at line 81 of file switch_utils.h.

Referenced by switch_core_media_get_video_fps().

 {
         uint32_t r;
         uint32_t x;
 
         if (!num) return 0;
 
         r = (num % step);
         x = num - r;
 
         if (r > step / 2) {
                 x += step;
         }
 
         return x;
 }

◆ switch_safe_atoi()

static int switch_safe_atoi	(	const char *	nptr,
		int	dft
	)

inlinestatic

Turn a string into an integer (default if NULL)

Parameters

nptr	the string
dft	the default

Returns: the integer version of the string or the default

Definition at line 851 of file switch_utils.h.

Referenced by switch_core_media_process_udptl().

 {
         return nptr ? atoi(nptr) : dft;
 }

◆ switch_safe_atol()

static long int switch_safe_atol	(	const char *	nptr,
		long int	dft
	)

inlinestatic

Turn a string into a long integer (default if NULL)

Parameters

nptr	the string
dft	the default

Returns: the long integer version of the string or the default

Definition at line 863 of file switch_utils.h.

 {
         return nptr ? atol(nptr) : dft;
 }

◆ switch_safe_atoll()

static long long int switch_safe_atoll	(	const char *	nptr,
		long long int	dft
	)

inlinestatic

Turn a string into a long long integer (default if NULL)

Parameters

nptr	the string
dft	the default

Returns: the long long integer version of the string or the default

Definition at line 875 of file switch_utils.h.

 {
         return nptr ? atoll(nptr) : dft;
 }

◆ switch_safe_strdup()

static char* switch_safe_strdup ( const char * it )

inlinestatic

Definition at line 887 of file switch_utils.h.

Referenced by switch_html_strip().

 {
         if (it) {
                 return strdup(it);
         }
 
         return NULL;
 }

◆ switch_sanitize_number()

static char* switch_sanitize_number ( char * number )

inlinestatic

Definition at line 737 of file switch_utils.h.

References number, and switch_assert.

Referenced by switch_ivr_originate().

 {
         char *p = number, *q;
         char warp[] = "/:";
         int i;
 
         switch_assert(number);
 
         if (!(strchr(p, '/') || strchr(p, ':') || strchr(p, '@') || strchr(p, '%'))) {
                 return number;
         }
 
         while ((q = strrchr(p, '@')))
                 *q = '\0';
 
         while ((q = strrchr(p, '%')))
                 *q = '\0';
 
         for (i = 0; i < (int) strlen(warp); i++) {
                 while (p && (q = strchr(p, warp[i])))
                         p = q + 1;
         }
 
         return p;
 }

◆ switch_separate_file_params()

static void switch_separate_file_params	(	const char *	file,
		char **	file_portion,
		char **	params_portion
	)

inlinestatic

Definition at line 1252 of file switch_utils.h.

References switch_assert, and switch_find_end_paren().

 {
         char *e = NULL;
         char *space = strdup(file);
 
         switch_assert(space);
         file = space;
 
         *file_portion = NULL;
         *params_portion = NULL;
 
         while (*file == '{') {
                 e = switch_find_end_paren(file, '{', '}');
                 file = e + 1;
                 while(*file == ' ') file++;
         }
 
 
         if (e) {
                 *file_portion = strdup((char *)file);
                 *++e = '\0';
                 *params_portion = (char *)space;
         } else {
                 *file_portion = (char *)space;
         }
 
         return;
 }

◆ switch_separate_paren_args()

char* switch_separate_paren_args ( char * str )

Definition at line 1582 of file switch_utils.c.

Referenced by switch_ivr_phrase_macro_event().

 {
         char *e, *args;
         switch_size_t br;
 
         if ((args = strchr(str, '('))) {
                 e = args - 1;
                 *args++ = '\0';
                 while (*e == ' ') {
                         *e-- = '\0';
                 }
                 e = args;
                 br = 1;
                 while (e && *e) {
                         if (*e == '(') {
                                 br++;
                         } else if (br > 1 && *e == ')') {
                                 br--;
                         } else if (br == 1 && *e == ')') {
                                 *e = '\0';
                                 break;
                         }
                         e++;
                 }
         }
 
         return args;
 }

◆ switch_separate_string()

unsigned int switch_separate_string	(	_In_ char *	buf,
		char	delim,
		_Post_count_(return) char **	array,
		unsigned int	arraylen
	)

Separate a string into an array based on a character delimiter.

Parameters

buf	the string to parse
delim	the character delimiter
array	the array to split the values into
arraylen	the max number of elements in the array

Returns: the number of elements added to the array

Referenced by check_channel_status(), comp_callback(), limit_state_handler(), main(), parse_val(), switch_channel_caller_extension_masquerade(), switch_channel_handle_cause(), switch_channel_process_export(), switch_channel_queue_dtmf_string(), switch_check_network_list_ip_port_token(), switch_console_complete(), switch_console_set_alias(), switch_console_set_complete(), switch_core_asr_load_grammar(), switch_core_media_media_params(), switch_core_media_negotiate_sdp(), switch_core_media_prepare_codecs(), switch_core_media_recover_session(), switch_core_media_set_r_sdp_codec_string(), switch_core_mime_add_type(), switch_core_session_execute_exten(), switch_core_session_perform_receive_message(), switch_core_session_send_dtmf_string(), switch_core_speech_feed_tts(), switch_core_standard_on_routing(), switch_event_create_brackets(), switch_ivr_eavesdrop_session(), switch_ivr_originate(), switch_ivr_play_file(), switch_ivr_preprocess_session(), switch_load_network_lists(), switch_log_str2mask(), switch_play_and_get_digits(), switch_process_import(), switch_speex_fmtp_parse(), SWITCH_STANDARD_API(), switch_stream_spawn(), and transfer_after_bridge().

◆ switch_separate_string_cheap()

unsigned int switch_separate_string_cheap	(	_In_ const char *	buf,
		char	delim,
		_Post_count_(return) const char **	array,
		_Post_count_(return) unsigned int	larray[],
		unsigned int	arraylen
	)

Separate a string into an array based on a character delimiter, no memory corruption! DOESN'T support removing quotes like what's in switch_separate_string()!

Parameters

buf	the string to parse
delim	the character delimiter
array	the array to split the values into
larray	the array that hold the lenth of each element
arraylen	the max number of elements in the array

Returns: the number of elements added to the array

◆ switch_separate_string_string()

unsigned int switch_separate_string_string	(	char *	buf,
		char *	delim,
		_Post_count_(return) char **	array,
		unsigned int	arraylen
	)

Referenced by ecd_deliver(), switch_console_execute(), switch_event_add_array(), and switch_ivr_enterprise_originate().

◆ switch_simple_email()

switch_bool_t switch_simple_email	(	const char *	to,
		const char *	from,
		const char *	headers,
		const char *	body,
		const char *	file,
		const char *	convert_cmd,
		const char *	convert_ext
	)

Definition at line 1117 of file switch_utils.c.

References b, B64BUFFLEN, buf, filename, in, switch_runtime::mailer_app, switch_runtime::mailer_app_args, O_BINARY, runtime, switch_b64_table, SWITCH_CHANNEL_LOG, switch_core_mime_ext2type(), switch_cut_path(), switch_epoch_time_now(), SWITCH_FALSE, SWITCH_GLOBAL_dirs, SWITCH_LOG_DEBUG, SWITCH_LOG_ERROR, switch_log_printf(), SWITCH_LOG_WARNING, switch_mprintf(), SWITCH_PATH_SEPARATOR, switch_safe_free, switch_snprintf(), switch_stristr(), switch_system(), SWITCH_TRUE, switch_util_quote_shell_arg(), switch_directories::temp_dir, write_buf(), zstr, and zstr_buf.

Referenced by email(), and switch_needs_url_encode().

 {
         char *bound = "XXXX_boundary_XXXX";
         const char *mime_type = "audio/inline";
         char filename[80], buf[B64BUFFLEN];
         int fd = -1, ifd = -1;
         int x = 0, y = 0, bytes = 0, ilen = 0;
         unsigned int b = 0, l = 0;
         unsigned char in[B64BUFFLEN];
         unsigned char out[B64BUFFLEN + 512];
         char *dupfile = NULL, *ext = NULL;
         char *newfile = NULL;
         switch_bool_t rval = SWITCH_FALSE;
         const char *err = NULL;
 
         filename[0] = '\0';
 
         if (zstr(to)) {
                 err = "No to address specified";
                 goto end;
         }
 
         if (!zstr(file) && !zstr(convert_cmd) && !zstr(convert_ext)) {
                 if (strrchr(file, '.')) {
                         dupfile = strdup(file);
                         if ((ext = strrchr(dupfile, '.'))) {
                                 *ext++ = '\0';
                                 newfile = switch_mprintf("%s.%s", dupfile, convert_ext);
                         }
                 }
 
                 if (newfile) {
                         char cmd[1024] = "";
                         switch_snprintf(cmd, sizeof(cmd), "%s %s %s", convert_cmd, file, newfile);
                         switch_system(cmd, SWITCH_TRUE);
                         if (strcmp(file, newfile)) {
                                 file = newfile;
                         } else {
                                 switch_safe_free(newfile);
                         }
                 }
 
                 switch_safe_free(dupfile);
         }
 
         switch_snprintf(filename, 80, "%s%smail.%d%04x", SWITCH_GLOBAL_dirs.temp_dir, SWITCH_PATH_SEPARATOR, (int)(switch_time_t) switch_epoch_time_now(NULL), rand() & 0xffff);
 
         if ((fd = open(filename, O_WRONLY | O_CREAT | O_TRUNC, 0644)) > -1) {
                 if (file) {
                         if ((ifd = open(file, O_RDONLY | O_BINARY)) < 0) {
                                 rval = SWITCH_FALSE;
                                 err = "Cannot open tmp file\n";
                                 goto end;
                         }
                 }
 
                 if (!file && (!body || !switch_stristr("content-type", body))) {
                         bound = NULL;
                 }
 
                 if (bound) {
                         switch_snprintf(buf, B64BUFFLEN, "MIME-Version: 1.0\nContent-Type: multipart/mixed; boundary=\"%s\"\n", bound);
                         if (!write_buf(fd, buf)) {
                                 rval = SWITCH_FALSE;
                                 err = "write error.";
                                 goto end;
                         }
                 }
 
                 if (headers && !write_buf(fd, headers)) {
                         rval = SWITCH_FALSE;
                         err = "write error.";
                         goto end;
                 }
 
                 if (!write_buf(fd, "\n\n")) {
                         rval = SWITCH_FALSE;
                         err = "write error.";
                         goto end;
                 }
 
                 if (bound) {
                         if (body && switch_stristr("content-type", body)) {
                                 switch_snprintf(buf, B64BUFFLEN, "--%s\n", bound);
                         } else {
                                 switch_snprintf(buf, B64BUFFLEN, "--%s\nContent-Type: text/plain\n\n", bound);
                         }
                         if (!write_buf(fd, buf)) {
                                 rval = SWITCH_FALSE;
                                 err = "write error.";
                                 goto end;
                         }
                 }
 
                 if (body) {
                         if (!write_buf(fd, body)) {
                                 rval = SWITCH_FALSE;
                                 err = "write error.";
                                 goto end;
                         }
                 }
 
                 if (file && bound) {
                         const char *stipped_file = switch_cut_path(file);
                         const char *new_type;
                         char *ext;
 
                         if ((ext = strrchr(stipped_file, '.'))) {
                                 ext++;
                                 if ((new_type = switch_core_mime_ext2type(ext))) {
                                         mime_type = new_type;
                                 }
                         }
 
                         switch_snprintf(buf, B64BUFFLEN,
                                                         "\n\n--%s\nContent-Type: %s; name=\"%s\"\n"
                                                         "Content-ID: <ATTACHED@freeswitch.org>\n"
                                                         "Content-Transfer-Encoding: base64\n"
                                                         "Content-Description: Sound attachment.\n"
                                                         "Content-Disposition: attachment; filename=\"%s\"\n\n", bound, mime_type, stipped_file, stipped_file);
                         if (!write_buf(fd, buf)) {
                                 rval = SWITCH_FALSE;
                                 err = "write error.";
                                 goto end;
                         }
 
                         while ((ilen = read(ifd, in, B64BUFFLEN))) {
                                 for (x = 0; x < ilen; x++) {
                                         b = (b << 8) + in[x];
                                         l += 8;
                                         while (l >= 6) {
                                                 out[bytes++] = switch_b64_table[(b >> (l -= 6)) % 64];
                                                 if (++y != 72)
                                                         continue;
                                                 out[bytes++] = '\n';
                                                 y = 0;
                                         }
                                 }
                                 if (write(fd, &out, bytes) != bytes) {
                                         rval = -1;
                                         break;
                                 } else {
                                         bytes = 0;
                                 }
 
                         }
 
                         if (l > 0) {
                                 out[bytes++] = switch_b64_table[((b % 16) << (6 - l)) % 64];
                         }
                         if (l != 0)
                                 while (l < 6) {
                                         out[bytes++] = '=', l += 2;
                                 }
                         if (write(fd, &out, bytes) != bytes) {
                                 rval = -1;
                         }
 
                 }
 
                 if (bound) {
                         switch_snprintf(buf, B64BUFFLEN, "\n\n--%s--\n.\n", bound);
 
                         if (!write_buf(fd, buf)) {
                                 rval = SWITCH_FALSE;
                                 err = "write error.";
                                 goto end;
                         }
                 }
         }
 
         if (fd > -1) {
                 close(fd);
                 fd = -1;
         }
 
         if (zstr(from)) {
                 from = "freeswitch";
         }
 
         {
                 char *to_arg = switch_util_quote_shell_arg(to);
                 char *from_arg = switch_util_quote_shell_arg(from);
 #ifdef WIN32
                 switch_snprintf(buf, B64BUFFLEN, "\"\"%s\" -f %s %s %s < \"%s\"\"", runtime.mailer_app, from_arg, runtime.mailer_app_args, to_arg, filename);
 #else
                 switch_snprintf(buf, B64BUFFLEN, "/bin/cat %s | %s -f %s %s %s", filename, runtime.mailer_app, from_arg, runtime.mailer_app_args, to_arg);
 #endif
                 switch_safe_free(to_arg); switch_safe_free(from_arg);
         }
         if (switch_system(buf, SWITCH_TRUE) < 0) {
                 switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Unable to execute command: %s\n", buf);
                 err = "execute error";
                 rval = SWITCH_FALSE;
         }
 
         if (zstr(err)) {
                 if (file) {
                         switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Emailed file [%s] to [%s]\n", filename, to);
                 } else {
                         switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Emailed data to [%s]\n", to);
                 }
 
                 rval = SWITCH_TRUE;
         }
 
   end:
 
         if (fd > -1) {
                 close(fd);
         }
 
         if (!zstr_buf(filename) && unlink(filename) != 0) {
                 switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "Failed to delete file [%s]\n", filename);
         }
 
         if (ifd > -1) {
                 close(ifd);
         }
 
 
         if (newfile) {
                 unlink(newfile);
                 free(newfile);
         }
 
         if (rval != SWITCH_TRUE) {
                 if (zstr(err)) err = "Unknown Error";
 
                 switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "EMAIL NOT SENT, error [%s]\n", err);
         }
 
         return rval;
 }

◆ switch_socket_waitfor()

int switch_socket_waitfor	(	switch_pollfd_t *	poll,
		int	ms
	)

Wait for a socket.

Parameters

poll	the pollfd to wait on
ms	the number of milliseconds to wait

Returns: the requested condition

Definition at line 3541 of file switch_utils.c.

References switch_poll().

 {
         int nsds = 0;
 
         switch_poll(poll, 1, &nsds, ms);
 
         return nsds;
 }

◆ switch_split_date()

void switch_split_date	(	const char *	exp,
		int *	year,
		int *	month,
		int *	day
	)

Definition at line 3708 of file switch_utils.c.

References switch_assert, and switch_safe_free.

 {
         char *dup = strdup(exp);
         char *syear = NULL;
         char *smonth = NULL;
         char *sday = NULL;
 
         switch_assert(dup);
 
         syear = dup;
         if ((smonth=strchr(dup, '-'))) {
                 *smonth++ = '\0';
                 if ((sday=strchr(smonth, '-'))) {
                         *sday++ = '\0';
                         if (year) {
                                 *year = atol(syear);
                         }
                         if (month) {
                                 *month = atol(smonth);
                         }
                         if (day) {
                                 *day = atol(sday);
                         }
                 }
         }
         switch_safe_free(dup);
         return;
 
 }

◆ switch_split_time()

void switch_split_time	(	const char *	exp,
		int *	hour,
		int *	min,
		int *	sec
	)

Definition at line 3675 of file switch_utils.c.

References switch_assert, and switch_safe_free.

 {
         char *dup = strdup(exp);
         char *shour = NULL;
         char *smin = NULL;
         char *ssec = NULL;
 
         switch_assert(dup);
 
         shour = dup;
         if ((smin=strchr(dup, ':'))) {
                 *smin++ = '\0';
                 if ((ssec=strchr(smin, ':'))) {
                         *ssec++ = '\0';
                 } else {
                         ssec = "00";
                 }
                 if (hour) {
                         *hour = atol(shour);
                 }
                 if (min) {
                         *min = atol(smin);
                 }
                 if (sec) {
                         *sec = atol(ssec);
                 }
 
         }
         switch_safe_free(dup);
         return;
 
 }

◆ switch_split_user_domain()

int switch_split_user_domain	(	char *	in,
		char **	user,
		char **	domain
	)

Split a user string as user and domain.

Parameters

in	the input string
user	the string to put the user into
domain	the string to put the domain into

Returns: 1 if successfull

Note: Extended formats protocol:user:port (Example: sip:toto@.nosp@m.exam.nosp@m.ple.o.nosp@m.rg)

Definition at line 4216 of file switch_utils.c.

References in.

 {
         char *p = NULL, *h = NULL, *u = NULL;
 
         if (!in) return 0;
 
         /* Remove URL scheme */
         if (!strncasecmp(in, "sip:", 4)) in += 4;
         else if (!strncasecmp(in, "sips:", 5)) in += 5;
 
         /* Isolate the host part from the user part */
         if ((h = in, p = strchr(h, '@'))) *p = '\0', u = in, h = p+1;
 
         /* Clean out the host part of any suffix */
         for (p = h; *p; p++)
                 if (*p == ':' || *p == ';' || *p == ' ') {
                         *p = '\0'; break;
                 }
 
         if (user) *user = u;
         if (domain) *domain = h;
         return 1;
 }

◆ switch_str_time()

switch_time_t switch_str_time ( const char * in )

Converts a string representation of a date into a switch_time_t.

Parameters

in	the string

Returns: the epoch time in usec

Definition at line 2083 of file switch_utils.c.

References switch_micro_time_now(), switch_regex_copy_substring(), switch_regex_perform(), switch_regex_safe_free, switch_time_exp_get(), switch_time_exp_gmt_get(), switch_time_exp_lt(), switch_time_exp_t::tm_gmtoff, switch_time_exp_t::tm_hour, switch_time_exp_t::tm_isdst, switch_time_exp_t::tm_mday, switch_time_exp_t::tm_min, switch_time_exp_t::tm_mon, switch_time_exp_t::tm_sec, switch_time_exp_t::tm_usec, and switch_time_exp_t::tm_year.

Referenced by switch_fulldate_cmp().

 {
         switch_time_exp_t tm = { 0 }, local_tm = { 0 };
         int proceed = 0, ovector[30], time_only = 0;
         switch_regex_t *re = NULL;
         char replace[1024] = "";
         switch_time_t ret = 0, local_time = 0;
         char *pattern = "^(\\d+)-(\\d+)-(\\d+)\\s*(\\d*):{0,1}(\\d*):{0,1}(\\d*)";
         char *pattern2 = "^(\\d{4})(\\d{2})(\\d{2})(\\d{2})(\\d{2})(\\d{2})";
         char *pattern3 = "^(\\d*):{0,1}(\\d*):{0,1}(\\d*)$";
 
         switch_time_exp_lt(&tm, switch_micro_time_now());
 
 
         if ((time_only = switch_regex_perform(in, pattern3, &re, ovector, sizeof(ovector) / sizeof(ovector[0])))) {
                 tm.tm_hour = 0;
                 tm.tm_min = 0;
                 tm.tm_sec = 0;
         } else {
                 tm.tm_year = tm.tm_mon = tm.tm_mday = tm.tm_hour = tm.tm_min = tm.tm_sec = tm.tm_usec = 0;
 
                 if (!(proceed = switch_regex_perform(in, pattern, &re, ovector, sizeof(ovector) / sizeof(ovector[0])))) {
                         switch_regex_safe_free(re);
                         proceed = switch_regex_perform(in, pattern2, &re, ovector, sizeof(ovector) / sizeof(ovector[0]));
                 }
         }
 
         if (proceed || time_only) {
 
                 if (time_only > 1) {
                         switch_regex_copy_substring(in, ovector, time_only, 1, replace, sizeof(replace));
                         tm.tm_hour = atoi(replace);
                 }
 
                 if (time_only > 2) {
                         switch_regex_copy_substring(in, ovector, time_only, 2, replace, sizeof(replace));
                         tm.tm_min = atoi(replace);
                 }
 
                 if (time_only > 3) {
                         switch_regex_copy_substring(in, ovector, time_only, 3, replace, sizeof(replace));
                         tm.tm_sec = atoi(replace);
                 }
 
                 if (proceed > 1) {
                         switch_regex_copy_substring(in, ovector, proceed, 1, replace, sizeof(replace));
                         tm.tm_year = atoi(replace) - 1900;
                 }
 
                 if (proceed > 2) {
                         switch_regex_copy_substring(in, ovector, proceed, 2, replace, sizeof(replace));
                         tm.tm_mon = atoi(replace) - 1;
                 }
 
                 if (proceed > 3) {
                         switch_regex_copy_substring(in, ovector, proceed, 3, replace, sizeof(replace));
                         tm.tm_mday = atoi(replace);
                 }
 
                 if (proceed > 4) {
                         switch_regex_copy_substring(in, ovector, proceed, 4, replace, sizeof(replace));
                         tm.tm_hour = atoi(replace);
                 }
 
                 if (proceed > 5) {
                         switch_regex_copy_substring(in, ovector, proceed, 5, replace, sizeof(replace));
                         tm.tm_min = atoi(replace);
                 }
 
                 if (proceed > 6) {
                         switch_regex_copy_substring(in, ovector, proceed, 6, replace, sizeof(replace));
                         tm.tm_sec = atoi(replace);
                 }
                 
                 switch_regex_safe_free(re);
 
                 switch_time_exp_get(&local_time, &tm);
                 switch_time_exp_lt(&local_tm, local_time);
                 tm.tm_isdst = local_tm.tm_isdst;
                 tm.tm_gmtoff = local_tm.tm_gmtoff;
 
                 switch_time_exp_gmt_get(&ret, &tm);
                 return ret;
         }
 
         switch_regex_safe_free(re);
 
         return ret;
 }

◆ switch_strcasecmp_any()

int switch_strcasecmp_any	(	const char *	str,
			...
	)

Definition at line 394 of file switch_utils.c.

 {
         va_list ap;
         const char *next_str = 0;
         int r = 0;
 
         va_start(ap, str);
 
         while ((next_str = va_arg(ap, const char *))) {
                 if (!strcasecmp(str, next_str)) {
                         r = 1;
                         break;
                 }
         }
 
         va_end(ap);
 
         return r;
 }

◆ switch_strchr_strict()

static char* switch_strchr_strict	(	const char *	in,
		char	find,
		const char *	allowed
	)

inlinestatic

Definition at line 334 of file switch_utils.h.

References in, and switch_assert.

Referenced by switch_event_create_brackets().

 {
         const char *p;
 
         switch_assert(in);
 
         p = in;
 
         if (!*p) return NULL;
 
         while(p && *p) {
                 const char *a = allowed;
                 int acceptable = 0;
 
                 if (*p == find) break;
 
                 if (!a) {
                         acceptable = 1;
                 } else {
 
                         while(a && *a) {
 
                                 if (*p == *a) {
                                         acceptable = 1;
                                         break;
                                 }
 
                                 a++;
                         }
 
                 }
 
                 if (!acceptable) return NULL;
 
                 p++;
         }
 
         return (char *) p;
 }

◆ switch_strerror_r()

char* switch_strerror_r	(	int	errnum,
		char *	buf,
		switch_size_t	buflen
	)

Portable version of strerror_r(), work around for the incompatible return type of GNU and XSI variants.

Parameters

[in]	errnum	Error number

Definition at line 4308 of file switch_utils.c.

References buf, switch_copy_string(), and switch_snprintf().

Referenced by reincarnate_protect(), and rtp_common_read().

 {
 #ifdef HAVE_STRERROR_R
 #ifdef STRERROR_R_CHAR_P
         /* GNU variant returning char *, avoids warn-unused-result error */
         return strerror_r(errnum, buf, buflen);
 #else
         /*
          * XSI variant returning int, with GNU compatible error string,
          * if no message could be found
          */
         if (strerror_r(errnum, buf, buflen)) {
                 switch_snprintf(buf, buflen, "Unknown error %d", errnum);
         }
         return buf;
 #endif /* STRERROR_R_CHAR_P */
 #elif defined(WIN32)
         /* WIN32 variant */
         if (strerror_s(buf, buflen, errnum)) {
                 switch_snprintf(buf, buflen, "Unknown error %d", errnum);
         }
         return buf;
 #else
         /* Fallback, copy string into private buffer */
         switch_copy_string(buf, strerror(errnum), buflen);
         return buf;
 #endif
 }

◆ switch_string_has_escaped_data()

static int switch_string_has_escaped_data ( const char * in )

inlinestatic

Definition at line 384 of file switch_utils.h.

References buf, in, switch_amp_encode(), switch_assert, switch_b64_decode(), switch_b64_encode(), and SWITCH_DECLARE.

Referenced by switch_channel_expand_variables_check(), and switch_event_expand_headers_check().

 {
         const char *i;
 
         switch_assert(in);
 
         i = strchr(in, '\\');
 
         while (i && *i == '\\') {
                 i++;
                 if (*i == '\\' || *i == 'n' || *i == 's' || *i == 't' || *i == '\'') {
                         return 1;
                 }
                 i = strchr(i, '\\');
         }
 
         return 0;
 }

◆ switch_string_match()

switch_status_t switch_string_match	(	const char *	string,
		size_t	string_len,
		const char *	search,
		size_t	search_len
	)

Definition at line 3024 of file switch_utils.c.

References SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

Referenced by switch_string_replace().

 {
         size_t i;
 
         for (i = 0; (i < search_len) && (i < string_len); i++) {
                 if (string[i] != search[i]) {
                         return SWITCH_STATUS_FALSE;
                 }
         }
 
         if (i == search_len) {
                 return SWITCH_STATUS_SUCCESS;
         }
 
         return SWITCH_STATUS_FALSE;
 }

◆ switch_string_replace()

char* switch_string_replace	(	const char *	string,
		const char *	search,
		const char *	replace
	)

Definition at line 3041 of file switch_utils.c.

References switch_assert, SWITCH_STATUS_SUCCESS, and switch_string_match().

Referenced by switch_channel_set_timestamps(), switch_core_set_globals(), and switch_core_sqldb_start().

 {
         size_t string_len = strlen(string);
         size_t search_len = strlen(search);
         size_t replace_len = strlen(replace);
         size_t i, n;
         size_t dest_len = 0;
         char *dest, *tmp;
 
         dest = (char *) malloc(sizeof(char));
         switch_assert(dest);
 
         for (i = 0; i < string_len; i++) {
                 if (switch_string_match(string + i, string_len - i, search, search_len) == SWITCH_STATUS_SUCCESS) {
                         for (n = 0; n < replace_len; n++) {
                                 dest[dest_len] = replace[n];
                                 dest_len++;
                                 tmp = (char *) realloc(dest, sizeof(char) * (dest_len + 1));
                                 switch_assert(tmp);
                                 dest = tmp;
                         }
                         i += search_len - 1;
                 } else {
                         dest[dest_len] = string[i];
                         dest_len++;
                         tmp = (char *) realloc(dest, sizeof(char) * (dest_len + 1));
                         switch_assert(tmp);
                         dest = tmp;
                 }
         }
 
         dest[dest_len] = 0;
         return dest;
 }

◆ switch_string_var_check()

static switch_bool_t switch_string_var_check	(	char *	s,
		switch_bool_t	disable
	)

inlinestatic

Definition at line 763 of file switch_utils.h.

References SWITCH_FALSE, and SWITCH_TRUE.

Referenced by switch_core_set_var_conditional(), switch_core_set_variable(), and switch_var_clean_string().

 {
         char *p;
         char *dol = NULL;
 
         for (p = s; p && *p; p++) {
                 if (*p == '$') {
                         dol = p;
                 } else if (dol) {
                         if (*p == '{') {
                                 if (disable) {
                                         *dol = '%';
                                         dol = NULL;
                                 } else {
                                         return SWITCH_TRUE;
                                 }
                         } else if (*p != '\\') {
                                 dol = NULL;
                         }
                 }
         }
         return SWITCH_FALSE;
 }

◆ switch_string_var_check_const()

static switch_bool_t switch_string_var_check_const ( const char * s )

inlinestatic

Definition at line 788 of file switch_utils.h.

References SWITCH_FALSE, and SWITCH_TRUE.

Referenced by switch_channel_add_variable_var_check(), switch_channel_expand_variables_check(), switch_channel_set_variable_strip_quotes_var_check(), switch_channel_set_variable_var_check(), and switch_event_expand_headers_check().

 {
         const char *p;
         int dol = 0;
 
         for (p = s; p && *p; p++) {
                 if (*p == '$') {
                         dol = 1;
                 } else if (dol) {
                         if (*p == '{') {
                                 return SWITCH_TRUE;
                         } else if (*p != '\\') {
                                 dol = 0;
                         }
                 }
         }
         return SWITCH_FALSE;
 }

◆ switch_strip_commas()

char* switch_strip_commas	(	char *	in,
		char *	out,
		switch_size_t	len
	)

Definition at line 1539 of file switch_utils.c.

References in.

 {
         char *p = in, *q = out;
         char *ret = out;
         switch_size_t x = 0;
 
         for (; p && *p; p++) {
                 if ((*p > 47 && *p < 58)) {
                         *q++ = *p;
 
                         if (++x > len) {
                                 ret = NULL;
                                 break;
                         }
                 } else if (*p != ',') {
                         ret = NULL;
                         break;
                 }
         }
 
         return ret;
 }

◆ switch_strip_nonnumerics()

char* switch_strip_nonnumerics	(	char *	in,
		char *	out,
		switch_size_t	len
	)

Definition at line 1562 of file switch_utils.c.

References in.

 {
         char *p = in, *q = out;
         char *ret = out;
         switch_size_t x = 0;
         /* valid are 0 - 9, period (.), minus (-), and plus (+) - remove all others */
         for (; p && *p; p++) {
                 if ((*p > 47 && *p < 58) || *p == '.' || *p == '-' || *p == '+') {
                         *q++ = *p;
 
                         if (++x > len) {
                                 ret = NULL;
                                 break;
                         }
                 }
         }
 
         return ret;
 }

◆ switch_strip_spaces()

char* switch_strip_spaces	(	char *	str,
		switch_bool_t	dup
	)

Definition at line 1503 of file switch_utils.c.

References switch_network_node::str, switch_assert, SWITCH_BLANK_STRING, and zstr.

Referenced by switch_core_media_add_crypto().

 {
         char *sp = str;
         char *p, *s = NULL;
         size_t len;
 
         if (zstr(sp)) {
                 return dup ? strdup(SWITCH_BLANK_STRING) : sp;
         }
 
         while (*sp == ' ') {
                 sp++;
         }
 
         if (dup) {
                 s = strdup(sp);
                 switch_assert(s);
         } else {
                 s = sp;
         }
 
         if (zstr(s)) {
                 return s;
         }
 
         if ((len = strlen(s)) > 0) {
                 p = s + (len - 1);
 
                 while (p && *p && (p >= s) && *p == ' ') {
                         *p-- = '\0';
                 }
         }
 
         return s;
 }

◆ switch_strip_whitespace()

char* switch_strip_whitespace ( const char * str )

Definition at line 1471 of file switch_utils.c.

References switch_network_node::str, switch_assert, SWITCH_BLANK_STRING, and zstr.

Referenced by switch_api_execute().

 {
         const char *sp = str;
         char *p, *s = NULL;
         size_t len;
 
         if (zstr(sp)) {
                 return strdup(SWITCH_BLANK_STRING);
         }
 
         while ((*sp == 13 ) || (*sp == 10 ) || (*sp == 9 ) || (*sp == 32) || (*sp == 11) ) {
                 sp++;
         }
 
         if (zstr(sp)) {
                 return strdup(SWITCH_BLANK_STRING);
         }
 
         s = strdup(sp);
         switch_assert(s);
 
         if ((len = strlen(s)) > 0) {
                 p = s + (len - 1);
 
                 while ((p >= s) && ((*p == 13 ) || (*p == 10 ) || (*p == 9 ) || (*p == 32) || (*p == 11))) {
                         *p-- = '\0';
                 }
         }
 
         return s;
 }

◆ switch_stristr()

const char* switch_stristr	(	const char *	instr,
		const char *	str
	)

Definition at line 1673 of file switch_utils.c.

References get_netmask(), switch_network_node::mask, memset(), and switch_toupper().

Referenced by audio_bridge_thread(), check_ice(), core_event_handler(), do_chat_send(), find_pt(), inherit_codec(), init_upnp(), main(), msrp_parse_buffer(), msrp_worker(), preprocess(), speech_thread(), switch_cache_db_execute_sql_real(), switch_core_gen_certs(), switch_core_gen_encoded_silence(), switch_core_media_check_outgoing_proxy(), switch_core_media_media_params(), switch_core_media_negotiate_sdp(), switch_core_media_parse_rtp_bugs(), switch_core_media_patch_sdp(), switch_core_media_proxy_remote_addr(), switch_core_media_toggle_hold(), switch_core_perform_file_open(), switch_core_session_check_incoming_crypto(), switch_core_session_findall_matching_var(), switch_core_sqldb_start(), switch_core_video_parse_filter_string(), switch_ivr_originate(), switch_odbc_handle_exec(), and switch_simple_email().

 {
 /*
 ** Rev History:  16/07/97  Greg Thayer          Optimized
 **               07/04/95  Bob Stout            ANSI-fy
 **               02/03/94  Fred Cole            Original
 **               09/01/03  Bob Stout            Bug fix (lines 40-41) per Fred Bulback
 **
 ** Hereby donated to public domain.
 */
         const char *pptr, *sptr, *start;
 
         if (!str || !instr)
                 return NULL;
 
         for (start = str; *start; start++) {
                 /* find start of pattern in string */
                 for (; ((*start) && (switch_toupper(*start) != switch_toupper(*instr))); start++);
 
                 if (!*start)
                         return NULL;
 
                 pptr = instr;
                 sptr = start;
 
                 while (switch_toupper(*sptr) == switch_toupper(*pptr)) {
                         sptr++;
                         pptr++;
 
                         /* if end of pattern then pattern was found */
                         if (!*pptr)
                                 return (start);
 
                         if (!*sptr)
                                 return NULL;
                 }
         }
         return NULL;
 }

◆ switch_strstr()

static switch_bool_t switch_strstr	(	char *	s,
		char *	q
	)

inlinestatic

Test if one string is inside another with extra case checking.

Parameters

s	the inner string
q	the big string

Returns: SWITCH_TRUE or SWITCH_FALSE

Definition at line 937 of file switch_utils.h.

References switch_assert, SWITCH_FALSE, switch_safe_free, switch_toupper(), and SWITCH_TRUE.

 {
         char *p, *S = NULL, *Q = NULL;
         switch_bool_t tf = SWITCH_FALSE;
 
         if (!s || !q) {
                 return SWITCH_FALSE;
         }
 
         if (strstr(s, q)) {
                 return SWITCH_TRUE;
         }
 
         S = strdup(s);
 
         switch_assert(S != NULL);
 
         for (p = S; p && *p; p++) {
                 *p = (char) switch_toupper(*p);
         }
 
         if (strstr(S, q)) {
                 tf = SWITCH_TRUE;
                 goto done;
         }
 
         Q = strdup(q);
         switch_assert(Q != NULL);
 
         for (p = Q; p && *p; p++) {
                 *p = (char) switch_toupper(*p);
         }
 
         if (strstr(s, Q)) {
                 tf = SWITCH_TRUE;
                 goto done;
         }
 
         if (strstr(S, Q)) {
                 tf = SWITCH_TRUE;
                 goto done;
         }
 
   done:
         switch_safe_free(S);
         switch_safe_free(Q);
 
         return tf;
 }

◆ switch_testv6_subnet()

switch_bool_t switch_testv6_subnet	(	ip_t	_ip,
		ip_t	_net,
		ip_t	_mask
	)

Definition at line 483 of file switch_utils.c.

References IN6_AND_MASK, SWITCH_TRUE, and ip_t::v6.

Referenced by switch_check_network_list_ip_port_token(), and switch_network_list_validate_ip6_port_token().

                                                                                     {
                 if (!IN6_IS_ADDR_UNSPECIFIED(&_mask.v6)) {
                         struct in6_addr a, b;
                         IN6_AND_MASK(&a, &_net, &_mask);
                         IN6_AND_MASK(&b, &_ip, &_mask);
                         return !memcmp(&a,&b, sizeof(struct in6_addr));
                 } else {
                         if (!IN6_IS_ADDR_UNSPECIFIED(&_net.v6)) {
                                 return !memcmp(&_net,&_ip,sizeof(struct in6_addr));
                         }
                         else return SWITCH_TRUE;
                 }
 }

◆ switch_tod_cmp()

int switch_tod_cmp	(	const char *	exp,
		int	val
	)

Definition at line 4152 of file switch_utils.c.

References cur, switch_assert, and switch_safe_free.

Referenced by switch_xml_std_datetime_check().

 {
         char *dup = strdup(exp);
         char *minh;
         char *minm;
         char *mins;
         char *maxh;
         char *maxm;
         char *maxs;
         char *cur;
         char *p;
         int range_start, range_end;
 
         switch_assert(dup);
 
         cur = dup;
         if ((p = strchr(cur, ','))) {
                 *p++ = '\0';
         }
 
         while (cur) {
                 minh = cur;
                 if ((minm=strchr(cur, ':'))) {
                         *minm++ = '\0';
                         if ((maxh=strchr(minm, '-'))) {
                                 if ((maxm=strchr(maxh, ':'))) {
                                         *maxh++ = '\0';
                                         *maxm++ = '\0';
                                         /* Check if min/max seconds are present */
                                         if ((mins=strchr(minm, ':'))) {
                                                 *mins++ = '\0';
                                         } else {
                                                 mins = "00";
                                         }
                                         if ((maxs=strchr(maxm, ':'))) {
                                                 *maxs++ = '\0';
                                         } else {
                                                 maxs = "00";
                                         }
 
                                         range_start = (atol(minh) * 60 * 60) + (atol(minm) * 60) + atol(mins);
                                         range_end = (atol(maxh) * 60 * 60) + (atol(maxm) * 60) + atol(maxs);
                                         if (range_start <= range_end ? (val >= range_start && val <= range_end) : (val >= range_start || val <= range_end)) {
                                                 switch_safe_free(dup);
                                                 return 1;
                                         }
                                 }
                         }
                 }
 
                 cur = p;
                 if (p) {
                         if ((p = strchr(p, ','))) {
                                 *p++ = '\0';
                         }
                 }
 
         }
 
         switch_safe_free(dup);
         return 0;
 
 }

◆ switch_tolower()

static uint32_t switch_tolower ( uint32_t eax )

inlinestatic

Definition at line 112 of file switch_utils.h.

References b, switch_tolower_max(), switch_toupper(), and switch_toupper_max().

Referenced by switch_hash_default_ci(), and switch_tolower_max().

 {
         uint32_t ebx = (0x7f7f7f7ful & eax) + 0x25252525ul;
         ebx = (0x7f7f7f7ful & ebx) + 0x1a1a1a1aul;
         ebx = ((ebx & ~eax) >> 2)  & 0x20202020ul;
         return eax + ebx;
 }

◆ switch_tolower_max()

static void switch_tolower_max ( char * s )

inlinestatic

Definition at line 231 of file switch_utils.h.

References b, old_switch_tolower(), old_switch_toupper(), SWITCH_DECLARE, switch_isalnum(), switch_isalpha(), switch_iscntrl(), switch_isdigit(), switch_isgraph(), switch_islower(), switch_isprint(), switch_ispunct(), switch_isspace(), switch_isupper(), switch_isxdigit(), and switch_tolower().

Referenced by switch_lc_strdup(), and switch_tolower().

 {
         uint32_t *b,*p;
         char *c;
         size_t l;
 
         l = strlen(s);
 
         p = (uint32_t *) s;
 
         while (l > 4) {
                 b = p;
                 *b = (uint32_t) switch_tolower(*b);
                 b++;
                 p++;
                 l -= 4;
         }
 
         c = (char *)p;
 
         while(l > 0) {
                 *c = (char) switch_tolower(*c);
                 c++;
                 l--;
         }
 
 }

◆ switch_toupper()

static uint32_t switch_toupper ( uint32_t eax )

inlinestatic

Definition at line 101 of file switch_utils.h.

Referenced by switch_char_to_rfc2833(), switch_stristr(), switch_strstr(), switch_tolower(), and switch_toupper_max().

 {
 uint32_t ebx = (0x7f7f7f7ful & eax) + 0x05050505ul;
 ebx = (0x7f7f7f7ful & ebx) + 0x1a1a1a1aul;
  ebx = ((ebx & ~eax) >> 2 ) & 0x20202020ul;
  return eax - ebx;
 }

◆ switch_toupper_max()

static void switch_toupper_max ( char * s )

inlinestatic

Definition at line 203 of file switch_utils.h.

References b, and switch_toupper().

Referenced by switch_tolower(), and switch_uc_strdup().

 {
         uint32_t *b,*p;
         char *c;
         size_t l;
 
         l = strlen(s);
 
         p = (uint32_t *) s;
 
         while (l > 4) {
                 b = p;
                 *b = (uint32_t) switch_toupper(*b);
                 b++;
                 p++;
                 l -= 4;
         }
 
         c = (char *)p;
 
         while(l > 0) {
                 *c = (char) switch_toupper(*c);
                 c++;
                 l--;
         }
 
 }

◆ switch_true()

static switch_bool_t switch_true ( const char * expr )

inlinestatic

Evaluate the truthfullness of a string expression.

Parameters

expr	a string expression

Returns: true or false

Definition at line 519 of file switch_utils.h.

References SWITCH_FALSE, switch_is_number(), and SWITCH_TRUE.

 {
         return ((expr && ( !strcasecmp(expr, "yes") ||
                                            !strcasecmp(expr, "on") ||
                                            !strcasecmp(expr, "true") ||
                                            !strcasecmp(expr, "t") ||
                                            !strcasecmp(expr, "enabled") ||
                                            !strcasecmp(expr, "active") ||
                                            !strcasecmp(expr, "allow") ||
                                            (switch_is_number(expr) && atoi(expr)))) ? SWITCH_TRUE : SWITCH_FALSE);
 }

◆ switch_true_byte()

static switch_byte_t switch_true_byte ( const char * expr )

inlinestatic

Definition at line 531 of file switch_utils.h.

References switch_true().

 {
         return (switch_byte_t)switch_true(expr);
 }

◆ switch_uc_strdup()

static char* switch_uc_strdup ( const char * it )

inlinestatic

Definition at line 914 of file switch_utils.h.

References switch_toupper_max().

 {
         char *dup;
 
         if (it) {
                 dup = strdup(it);
                 switch_toupper_max(dup);
                 return dup;
         }
 
         return NULL;
 }

◆ switch_url_decode()

char* switch_url_decode ( char * s )

Definition at line 3654 of file switch_utils.c.

References zstr.

Referenced by switch_core_session_request_xml(), switch_http_parse_qs(), switch_img_write_text_img(), and switch_needs_url_encode().

 {
         char *o;
         unsigned int tmp;
 
         if (zstr(s) || !strchr(s, '%')) {
                 return s;
         }
 
         for (o = s; *s; s++, o++) {
                 if (*s == '%' && strlen(s) > 2 && sscanf(s + 1, "%2x", &tmp) == 1) {
                         *o = (char) tmp;
                         s += 2;
                 } else {
                         *o = *s;
                 }
         }
         *o = '\0';
         return s;
 }

◆ switch_url_encode()

char* switch_url_encode	(	const char *	url,
		char *	buf,
		size_t	len
	)

Definition at line 3649 of file switch_utils.c.

References SWITCH_FALSE, and switch_url_encode_opt().

Referenced by add_xml_header(), switch_channel_build_param_string(), switch_core_perform_file_open(), switch_event_build_param_string(), switch_event_serialize(), switch_ivr_set_json_chan_vars(), switch_ivr_set_xml_chan_var(), and switch_needs_url_encode().

 {
         return switch_url_encode_opt(url, buf, len, SWITCH_FALSE);
 }

◆ switch_url_encode_opt()

char* switch_url_encode_opt	(	const char *	url,
		char *	buf,
		size_t	len,
		switch_bool_t	double_encode
	)

Definition at line 3604 of file switch_utils.c.

References buf, end_of_p, switch_network_node::ok, and SWITCH_URL_UNSAFE.

Referenced by switch_core_url_encode_opt(), switch_needs_url_encode(), and switch_url_encode().

 {
         const char *p, *e = end_of_p(url);
         size_t x = 0;
         const char hex[] = "0123456789ABCDEF";
 
         if (!buf) {
                 return 0;
         }
 
         if (!url) {
                 return 0;
         }
 
         len--;
 
         for (p = url; *p; p++) {
                 int ok = 0;
 
                 if (x >= len) {
                         break;
                 }
 
                 if (!double_encode && *p == '%' && e-p > 1) {
                         if (strchr(hex, *(p+1)) && strchr(hex, *(p+2))) {
                                 ok = 1;
                         }
                 }
 
                 if (!ok && (*p < ' ' || *p > '~' || strchr(SWITCH_URL_UNSAFE, *p))) {
                         if ((x + 3) > len) {
                                 break;
                         }
                         buf[x++] = '%';
                         buf[x++] = hex[(*p >> 4) & 0x0f];
                         buf[x++] = hex[*p & 0x0f];
                 } else {
                         buf[x++] = *p;
                 }
         }
         buf[x] = '\0';
 
         return buf;
 }

◆ switch_util_quote_shell_arg()

char* switch_util_quote_shell_arg ( const char * string )

Quote shell argument.

Parameters

string the string to quote (example: a ' b"' c) \return the quoted string (gives: 'a '\'' b"'\'' c' for unices, "a ' b ' c" for MS Windows), should be freed

Definition at line 3076 of file switch_utils.c.

References switch_util_quote_shell_arg_pool().

Referenced by switch_simple_email().

 {
         return switch_util_quote_shell_arg_pool(string, NULL);
 }

◆ switch_util_quote_shell_arg_pool()

char* switch_util_quote_shell_arg_pool	(	const char *	string,
		switch_memory_pool_t *	pool
	)

Quote shell argument, allocating from pool if provided.

Parameters

string	the string to quote (example: a ' b"' c)
pool	a memory pool to use

Returns: the quoted string (gives: 'a '\'' b"'\'' c' for unices, "a ' b ' c" for MS Windows), if pool not provided, returned value should be freed

Definition at line 3081 of file switch_utils.c.

References switch_waitlist_s::revents, switch_waitlist_s::sock, switch_assert, switch_core_alloc, SWITCH_DECLARE, switch_errno, switch_errno_is_break(), SWITCH_POLL_ERROR, SWITCH_POLL_HUP, SWITCH_POLL_INVALID, SWITCH_POLL_PRI, SWITCH_POLL_RDBAND, SWITCH_POLL_RDNORM, SWITCH_POLL_READ, SWITCH_POLL_WRITE, SWITCH_SOCK_INVALID, switch_wait_sock(), and switch_wait_socklist().

Referenced by switch_util_quote_shell_arg().

 {
         size_t string_len = strlen(string);
         size_t i;
         size_t n = 0;
         size_t dest_len = 0;
         char *dest;
 
         /* first pass through, figure out how large to make the allocation */
         dest_len = strlen(string) + 1; /* string + null */
         dest_len += 1; /* opening quote */
         for (i = 0; i < string_len; i++) {
                 switch (string[i]) {
 #ifndef WIN32
                 case '\'':
                         /* We replace ' by sq backslace sq sq, so need 3 additional bytes */
                         dest_len += 3;
                         break;
 #endif
                 }
         }
         dest_len += 1; /* closing quote */
 
         /* if we're given a pool, allocate from it, otherwise use malloc */
         if (pool) {
                 dest = switch_core_alloc(pool, sizeof(char) * dest_len);
         } else {
                 dest = (char *) malloc(sizeof(char) * dest_len);
         }
         switch_assert(dest);
 
 #ifdef WIN32
         dest[n++] = '"';
 #else
         dest[n++] = '\'';
 #endif
 
         for (i = 0; i < string_len; i++) {
                 switch (string[i]) {
 #ifdef WIN32
                 case '"':
                 case '%':
                         dest[n++] = ' ';
                         break;
 #else
                 case '\'':
                         /* We replace ' by sq backslash sq sq */
                         dest[n++] = '\'';
                         dest[n++] = '\\';
                         dest[n++] = '\'';
                         dest[n++] = '\'';
                         break;
 #endif
                 default:
                         dest[n++] = string[i];
                 }
         }
 
 #ifdef WIN32
         dest[n++] = '"';
 #else
         dest[n++] = '\'';
 #endif
         dest[n++] = 0;
         switch_assert(n == dest_len);
         return dest;
 }

◆ switch_uuid_str()

char* switch_uuid_str	(	char *	buf,
		switch_size_t	len
	)

Definition at line 4241 of file switch_utils.c.

References buf, switch_snprintf(), switch_uuid_format(), SWITCH_UUID_FORMATTED_LENGTH, and switch_uuid_get().

Referenced by switch_caller_profile_dup(), switch_caller_profile_new(), switch_core_session_exec(), and switch_msrp_do_send().

 {
         switch_uuid_t uuid;
 
         if (len < (SWITCH_UUID_FORMATTED_LENGTH + 1)) {
                 switch_snprintf(buf, len, "INVALID");
         } else {
                 switch_uuid_get(&uuid);
                 switch_uuid_format(buf, &uuid);
         }
 
         return buf;
 }

◆ switch_var_clean_string()

static char* switch_var_clean_string ( char * s )

inlinestatic

Definition at line 807 of file switch_utils.h.

References switch_string_var_check(), and SWITCH_TRUE.

 {
         switch_string_var_check(s, SWITCH_TRUE);
         return s;
 }

◆ switch_wait_sock()

int switch_wait_sock	(	switch_os_socket_t	sock,
		uint32_t	ms,
		switch_poll_t	flags
	)

Definition at line 3333 of file switch_utils.c.

References switch_errno, switch_errno_is_break(), SWITCH_POLL_ERROR, SWITCH_POLL_READ, SWITCH_POLL_WRITE, and SWITCH_SOCK_INVALID.

Referenced by get_pmp_pubaddr(), and switch_util_quote_shell_arg_pool().

 {
         int s = 0, r = 0;
         fd_set *rfds;
         fd_set *wfds;
         fd_set *efds;
         struct timeval tv;
 
         if (sock == SWITCH_SOCK_INVALID) {
                 return SWITCH_SOCK_INVALID;
         }
 
         rfds = malloc(sizeof(fd_set));
         wfds = malloc(sizeof(fd_set));
         efds = malloc(sizeof(fd_set));
 
         FD_ZERO(rfds);
         FD_ZERO(wfds);
         FD_ZERO(efds);
 
 #ifndef WIN32
         /* Wouldn't you rather know?? */
         assert(sock <= FD_SETSIZE);
 #endif
 
         if ((flags & SWITCH_POLL_READ)) {
 
 #ifdef WIN32
 #pragma warning( push )
 #pragma warning( disable : 4127 )
         FD_SET(sock, rfds);
 #pragma warning( pop )
 #else
         FD_SET(sock, rfds);
 #endif
         }
 
         if ((flags & SWITCH_POLL_WRITE)) {
 
 #ifdef WIN32
 #pragma warning( push )
 #pragma warning( disable : 4127 )
         FD_SET(sock, wfds);
 #pragma warning( pop )
 #else
         FD_SET(sock, wfds);
 #endif
         }
 
         if ((flags & SWITCH_POLL_ERROR)) {
 
 #ifdef WIN32
 #pragma warning( push )
 #pragma warning( disable : 4127 )
         FD_SET(sock, efds);
 #pragma warning( pop )
 #else
         FD_SET(sock, efds);
 #endif
         }
 
         tv.tv_sec = ms / 1000;
         tv.tv_usec = (ms % 1000) * 1000;
 
         s = select(sock + 1, (flags & SWITCH_POLL_READ) ? rfds : NULL, (flags & SWITCH_POLL_WRITE) ? wfds : NULL, (flags & SWITCH_POLL_ERROR) ? efds : NULL, &tv);
 
         if (s < 0) {
                 if (switch_errno_is_break(switch_errno())) {
                         s = 0;
                 }
         }
 
         if (s < 0) {
                 r = s;
         } else if (s > 0) {
                 if ((flags & SWITCH_POLL_READ) && FD_ISSET(sock, rfds)) {
                         r |= SWITCH_POLL_READ;
                 }
 
                 if ((flags & SWITCH_POLL_WRITE) && FD_ISSET(sock, wfds)) {
                         r |= SWITCH_POLL_WRITE;
                 }
 
                 if ((flags & SWITCH_POLL_ERROR) && FD_ISSET(sock, efds)) {
                         r |= SWITCH_POLL_ERROR;
                 }
         }
 
         free(rfds);
         free(wfds);
         free(efds);
 
         return r;
 
 }

◆ switch_wait_socklist()

int switch_wait_socklist	(	switch_waitlist_t *	waitlist,
		uint32_t	len,
		uint32_t	ms
	)

Definition at line 3429 of file switch_utils.c.

References switch_waitlist_s::events, switch_waitlist_s::revents, switch_waitlist_s::sock, switch_errno, switch_errno_is_break(), SWITCH_POLL_ERROR, SWITCH_POLL_READ, SWITCH_POLL_WRITE, and SWITCH_SOCK_INVALID.

Referenced by switch_util_quote_shell_arg_pool().

 {
         int s = 0, r = 0;
         fd_set *rfds;
         fd_set *wfds;
         fd_set *efds;
         struct timeval tv;
         unsigned int i;
         switch_os_socket_t max_fd = 0;
         int flags = 0;
 
         rfds = malloc(sizeof(fd_set));
         wfds = malloc(sizeof(fd_set));
         efds = malloc(sizeof(fd_set));
 
         FD_ZERO(rfds);
         FD_ZERO(wfds);
         FD_ZERO(efds);
 
         for (i = 0; i < len; i++) {
                 if (waitlist[i].sock == SWITCH_SOCK_INVALID) {
                         break;
                 }
 
                 if (waitlist[i].sock > max_fd) {
                         max_fd = waitlist[i].sock;
                 }
 
 #ifndef WIN32
                 /* Wouldn't you rather know?? */
                 assert(waitlist[i].sock <= FD_SETSIZE);
 #endif
                 flags |= waitlist[i].events;
 
                 if ((waitlist[i].events & SWITCH_POLL_READ)) {
 
 #ifdef WIN32
 #pragma warning( push )
 #pragma warning( disable : 4127 )
                         FD_SET(waitlist[i].sock, rfds);
 #pragma warning( pop )
 #else
                         FD_SET(waitlist[i].sock, rfds);
 #endif
                 }
 
                 if ((waitlist[i].events & SWITCH_POLL_WRITE)) {
 
 #ifdef WIN32
 #pragma warning( push )
 #pragma warning( disable : 4127 )
                         FD_SET(waitlist[i].sock, wfds);
 #pragma warning( pop )
 #else
                         FD_SET(waitlist[i].sock, wfds);
 #endif
                 }
 
                 if ((waitlist[i].events & SWITCH_POLL_ERROR)) {
 
 #ifdef WIN32
 #pragma warning( push )
 #pragma warning( disable : 4127 )
                         FD_SET(waitlist[i].sock, efds);
 #pragma warning( pop )
 #else
                         FD_SET(waitlist[i].sock, efds);
 #endif
                 }
         }
 
         tv.tv_sec = ms / 1000;
         tv.tv_usec = (ms % 1000) * 1000;
 
         s = select(max_fd + 1, (flags & SWITCH_POLL_READ) ? rfds : NULL, (flags & SWITCH_POLL_WRITE) ? wfds : NULL, (flags & SWITCH_POLL_ERROR) ? efds : NULL, &tv);
 
         if (s < 0) {
                 if (switch_errno_is_break(switch_errno())) {
                         s = 0;
                 }
         }
 
         if (s < 0) {
                 r = s;
         } else if (s > 0) {
                 for (i = 0; i < len; i++) {
                         if ((waitlist[i].events & SWITCH_POLL_READ) && FD_ISSET(waitlist[i].sock, rfds)) {
                                 r |= SWITCH_POLL_READ;
                                 waitlist[i].revents |= SWITCH_POLL_READ;
                         }
 
                         if ((waitlist[i].events & SWITCH_POLL_WRITE) && FD_ISSET(waitlist[i].sock, wfds)) {
                                 r |= SWITCH_POLL_WRITE;
                                 waitlist[i].revents |= SWITCH_POLL_WRITE;
                         }
 
                         if ((waitlist[i].events & SWITCH_POLL_ERROR) && FD_ISSET(waitlist[i].sock, efds)) {
                                 r |= SWITCH_POLL_ERROR;
                                 waitlist[i].revents |= SWITCH_POLL_ERROR;
                         }
                 }
         }
 
         free(rfds);
         free(wfds);
         free(efds);
 
         return r;
 
 }

Data Structures

Macros

Typedefs

Enumerations

Functions

Detailed Description

Macro Definition Documentation

◆ DUMP_EVENT

◆ end_of

◆ end_of_p

◆ is_dtmf

◆ MAX_NETWORK_PORTS

◆ switch_arraylen

◆ switch_calc_video_fps

◆ switch_clear_flag

◆ switch_clear_flag_locked

◆ switch_codec2str

◆ switch_copy_flags

◆ SWITCH_DECLARE_GLOBAL_STRING_FUNC

◆ switch_errno

◆ switch_goto_int

◆ switch_goto_status

◆ switch_inet_ntop

◆ switch_is_valid_rate

◆ switch_malloc

◆ switch_network_list_add_cidr

◆ switch_network_list_validate_ip

◆ switch_normalize_to_16bit

◆ SWITCH_READ_ACCEPTABLE

◆ switch_safe_free

◆ switch_samples_per_packet

◆ switch_set_flag

◆ switch_set_flag_locked

◆ switch_set_string

◆ SWITCH_SMAX

◆ SWITCH_SMIN

◆ switch_split

◆ switch_split_cheap

◆ SWITCH_STATUS_IS_BREAK

◆ switch_str_nil

◆ switch_strdup

◆ switch_strlen_zero

◆ switch_strlen_zero_buf

◆ switch_test_flag

◆ switch_test_subnet

◆ switch_time_from_sec

◆ switch_true_buf

◆ SWITCH_URL_UNSAFE

◆ switch_yield

◆ switch_zmalloc

◆ zset

◆ zstr

◆ zstr_buf

Typedef Documentation

◆ switch_http_request_t

◆ switch_network_port_range_p

◆ switch_network_port_range_t

Enumeration Type Documentation

◆ switch_uri_flags

Function Documentation

◆ _zstr()

◆ get_addr()

◆ get_addr6()

◆ get_addr_int()

◆ get_port()

◆ old_switch_tolower()

◆ old_switch_toupper()

◆ switch_amp_encode()

◆ switch_ast2regex()

◆ switch_atoui()

◆ switch_atoul()

◆ switch_b64_decode()

◆ switch_b64_encode()

◆ switch_build_uri()

◆ switch_calc_bitrate()

◆ switch_calc_fps()

◆ switch_calloc()

◆ switch_char_to_rfc2833()

◆ switch_clean_name_string()

◆ switch_clean_string()