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
union	ip_t

struct	switch_http_request_s

struct	switch_cputime

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

#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_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_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)(assert(((ptr) = malloc((len)))),ptr)

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

#define	switch_strdup(ptr, s) (void)(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_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 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 (char in, char out, switch_size_t olen)

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

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_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 int	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)

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 a number (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)

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_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, int quality, double fps)

static int32_t	switch_parse_bandwidth_string (const char *bwv)

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)

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

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)

void	switch_getcputime (switch_cputime *t)

Detailed Description

Compatability and Helper Code.

Just a miscelaneaous set of general utility/helper functions.

Definition in file switch_utils.h.

Macro Definition Documentation

#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 1211 of file switch_utils.h.

Referenced by switch_ivr_uuid_bridge().

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

Definition at line 616 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_core_media_gen_local_sdp(), and switch_img_write_text_img().

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

Definition at line 617 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_event_expand_headers_check(), switch_needs_url_encode(), and switch_url_encode_opt().

#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 614 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().

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

Definition at line 341 of file switch_utils.h.

Referenced by switch_dow_int2str(), and switch_dow_str2int().

#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 655 of file switch_utils.h.

#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 648 of file switch_utils.h.

Referenced by switch_core_file_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(), and unicast_thread_run().

#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 262 of file switch_utils.h.

Referenced by switch_core_session_outgoing_channel().

#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 663 of file switch_utils.h.

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

if

if((uint32_t)(unpack->cur-unpack->buf) > unpack->buflen)

Definition: switch_bitpack.h:157

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 923 of file switch_utils.h.

#define switch_errno ( ) errno

Definition at line 578 of file switch_utils.h.

Referenced by switch_wait_sock(), and switch_wait_socklist().

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

Definition at line 257 of file switch_utils.h.

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

#define switch_inet_ntop inet_ntop

Definition at line 1214 of file switch_utils.h.

#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 344 of file switch_utils.h.

Referenced by switch_ivr_record_file(), and switch_ivr_record_session().

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

Definition at line 1205 of file switch_utils.h.

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

Definition at line 1158 of file switch_utils.h.

Referenced by switch_load_network_lists().

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

Definition at line 1164 of file switch_utils.h.

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

Definition at line 261 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().

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

#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 789 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(), API::executeString(), fs_encode_cleanup(), CoreSession::getXMLCDR(), hashtable_expand(), load_mime_types(), CoreSession::originate(), parse_presence_data_cols(), play_and_collect(), preprocess(), preprocess_exec_set(), preprocess_glob(), record_callback(), Event::serialize(), CoreSession::set_tts_params(), CoreSession::set_tts_parms(), setup_ringback(), speech_thread(), sql_in_thread(), 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_uninit(), switch_check_network_list_ip_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_load_grammar(), switch_core_destroy(), switch_core_file_close(), switch_core_gen_certs(), switch_core_hash_empty(), switch_core_media_ext_address_lookup(), switch_core_media_gen_local_sdp(), switch_core_media_process_sdp_filter(), switch_core_media_set_r_sdp_codec_string(), 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_reporting_state(), switch_core_session_reset(), switch_core_speech_feed_tts(), switch_core_sqldb_start(), 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(), switch_ivr_set_json_chan_vars(), switch_ivr_sleep(), switch_ivr_speak_text_handle(), switch_ivr_wait_for_answer(), switch_json_add_presence_data_cols(), switch_loadable_module_enumerate_available(), switch_loadable_module_get_codecs(), switch_loadable_module_load_file(), switch_log_node_free(), switch_log_vprintf(), switch_nat_init(), switch_nat_multicast_runtime(), switch_nat_republish(), switch_nat_shutdown(), switch_network_list_add_cidr_token(), switch_network_list_perform_add_cidr_token(), switch_odbc_handle_destroy(), switch_odbc_handle_new(), switch_pgsql_handle_callback_exec_detailed(), switch_pgsql_handle_connect(), switch_pgsql_handle_destroy(), switch_pgsql_handle_disconnect(), switch_pgsql_handle_new(), switch_pgsql_next_result_timed(), switch_pgsql_send_query(), switch_pgsql_SQLEndTran(), 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_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_user_merged(), switch_xml_parse_file(), switch_xml_tohtml(), switch_xml_user_cache(), task_thread_loop(), tone_detect_set_total_time(), and Stream::~Stream().

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

Definition at line 258 of file switch_utils.h.

Referenced by switch_core_speech_open().

#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 631 of file switch_utils.h.

#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 638 of file switch_utils.h.

Referenced by 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().

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

Definition at line 665 of file switch_utils.h.

Referenced by _switch_cache_db_get_db_handle_dsn(), add_handle(), check_ice(), check_ip(), get_handle(), switch_config_open_file(), switch_core_asr_open(), 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_log_vprintf(), and switch_nat_multicast_runtime().

#define SWITCH_SMAX 32767

Definition at line 259 of file switch_utils.h.

Referenced by switch_core_media_bug_read().

#define SWITCH_SMIN -32768

Definition at line 260 of file switch_utils.h.

Referenced by switch_core_media_bug_read().

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

Definition at line 342 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().

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

Definition at line 564 of file switch_utils.h.

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

#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 903 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(), 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_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(), switch_ivr_record_session(), switch_loadable_module_process(), switch_loadable_module_unprocess(), switch_network_list_perform_add_cidr_token(), switch_odbc_handle_callback_exec_detailed(), switch_odbc_handle_exec(), switch_pgsql_handle_callback_exec_detailed(), switch_pgsql_handle_exec_base_detailed(), switch_scheduler_add_task(), switch_scheduler_execute(), switch_stun_host_lookup(), and task_thread_loop().

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

Definition at line 1207 of file switch_utils.h.

Referenced by switch_cache_db_execute_sql_real(), and switch_pgsql_handle_get_error().

#define switch_strlen_zero ( x ) zstr(x)

Definition at line 283 of file switch_utils.h.

Referenced by main().

#define switch_strlen_zero_buf ( x ) zstr_buf(x)

Definition at line 284 of file switch_utils.h.

#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 624 of file switch_utils.h.

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

Definition at line 1166 of file switch_utils.h.

Referenced by switch_check_network_list_ip_token(), and switch_network_list_validate_ip_token().

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

Definition at line 916 of file switch_utils.h.

#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 467 of file switch_utils.h.

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

Definition at line 47 of file switch_utils.h.

Referenced by switch_needs_url_encode(), and switch_url_encode_opt().

#define switch_yield ( ms ) switch_sleep(ms);

Wait a desired number of microseconds and yield the CPU.

Definition at line 908 of file switch_utils.h.

Referenced by _switch_cache_db_get_db_handle(), audio_bridge_thread(), media_thread_run(), originate_on_consume_media_transmit(), pool_thread(), record_callback(), recording_thread(), 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_core_db_exec(), switch_core_db_persistant_execute(), switch_core_db_persistant_execute_trans(), switch_core_media_end_video_function(), switch_core_media_ext_address_lookup(), 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_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_nat_multicast_runtime(), switch_nat_thread_stop(), 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_thread_rwlock_trywrlock_timeout(), switch_user_sql_thread(), uuid_bridge_on_soft_execute(), video_helper_thread(), and wait_for_cause().

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

Definition at line 1206 of file switch_utils.h.

Referenced by generate_on_dtmf(), switch_channel_queue_dtmf(), switch_console_push_match(), switch_core_inthash_insert(), switch_core_media_gen_local_sdp(), switch_event_bind_removable(), switch_event_channel_broadcast(), switch_event_channel_sub_channel(), switch_event_reserve_subclass_detailed(), switch_frame_alloc(), switch_hashtable_first_iter(), switch_ivr_collect_digits_count(), 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(), and switch_scheduler_add_task().

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

Definition at line 295 of file switch_utils.h.

#define zstr ( x ) _zstr(x)

Definition at line 281 of file switch_utils.h.

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

Definition at line 285 of file switch_utils.h.

Referenced by get_upnp_pubaddr(), and switch_strftime_tz().

Typedef Documentation

typedef struct switch_http_request_s switch_http_request_t

Enumeration Type Documentation

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 546 of file switch_utils.h.

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

Function Documentation

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 274 of file switch_utils.h.

 {
         return !s || *s == '\0';
 }

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 2273 of file switch_utils.c.

References buf, and switch_assert.

Referenced by 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;
 }

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

Definition at line 2257 of file switch_utils.c.

References buf, and switch_assert.

Referenced by 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;
 }

int get_addr_int ( switch_sockaddr_t * sa )

Definition at line 2150 of file switch_utils.c.

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

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 2284 of file switch_utils.c.

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

int old_switch_tolower ( int c )

Definition at line 3509 of file switch_utils.c.

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

int old_switch_toupper ( int c )

Definition at line 3462 of file switch_utils.c.

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

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

Definition at line 804 of file switch_utils.c.

References buf, and switch_assert.

 {
         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_bool_t switch_ast2regex	(	const char *	pat,
		char *	rbuf,
		size_t	len
	)

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

unsigned int switch_atoui ( const char * nptr )

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

unsigned long switch_atoul ( const char * nptr )

Definition at line 3932 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_size_t switch_b64_decode	(	char *	in,
		char *	out,
		switch_size_t	olen
	)

Definition at line 929 of file switch_utils.c.

References switch_b64_table.

Referenced by switch_core_media_add_crypto().

 {
 
         char l64[256];
         int b = 0, c, l = 0, i;
         char *ip, *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 - 2) {
                                 goto end;
                         }
                 }
         }
 
   end:
 
         op[ol++] = '\0';
 
         return ol;
 }

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

Definition at line 890 of file switch_utils.c.

References switch_b64_table, and SWITCH_STATUS_SUCCESS.

Referenced by switch_core_media_build_crypto(), and switch_rtp_add_crypto_key().

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

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 2300 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 : "");
 }

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

inlinestatic

Definition at line 998 of file switch_utils.h.

 {
         int r;
 
         /* KUSH GAUGE*/
 
         if (!fps) fps = 15;
         
         r = (int32_t)((double)(w * h * fps * (quality ? quality : 1)) * 0.07) / 1000;
 
         if (!quality) r /= 2;
 
         return r;
 
 }

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 2335 of file switch_utils.c.

References switch_toupper().

Referenced by do_2833().

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

static char* switch_clean_name_string ( char * s )

inlinestatic

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

static char* switch_clean_string ( char * s )

inlinestatic

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

int switch_cmp_addr	(	switch_sockaddr_t *	sa1,
		switch_sockaddr_t *	sa2
	)

Definition at line 2157 of file switch_utils.c.

Referenced by handle_ice(), and rtp_common_read().

 {
         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:
                 return (s1->sin_addr.s_addr == s2->sin_addr.s_addr && s1->sin_port == s2->sin_port);
         case AF_INET6:
                 if (s16->sin6_addr.s6_addr && s26->sin6_addr.s6_addr) {
                         int i;
 
                         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;
 }

int switch_cp_addr	(	switch_sockaddr_t *	sa1,
		switch_sockaddr_t *	sa2
	)

Definition at line 2206 of file switch_utils.c.

Referenced by read_rtp_packet(), and switch_rtp_set_remote_address().

 {
         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:
                 if (s16->sin6_addr.s6_addr && s26->sin6_addr.s6_addr) {
                         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;
 }

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 2658 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_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_bool_t switch_dow_cmp	(	const char *	exp,
		int	val
	)

Definition at line 3732 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 = prev = 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;
 }

const char* switch_dow_int2str ( int val )

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

int switch_dow_str2int ( const char * exp )

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

static int switch_dtmftoi ( char * s )

inlinestatic

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

static int switch_errno_is_break ( int errcode )

inlinestatic

Definition at line 580 of file switch_utils.h.

Referenced by switch_wait_sock(), and switch_wait_socklist().

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

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 2350 of file switch_utils.c.

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

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

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

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

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

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 482 of file switch_utils.h.

References SWITCH_FALSE, switch_is_number(), and SWITCH_TRUE.

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

 {
         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_size_t switch_fd_read_dline	(	int	fd,
		char **	buf,
		switch_size_t *	len
	)

Definition at line 709 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().

 {
         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_size_t switch_fd_read_line	(	int	fd,
		char *	buf,
		switch_size_t	len
	)

Definition at line 687 of file switch_utils.c.

References buf, and cur.

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

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

Definition at line 661 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_is_file_path(), switch_ivr_displace_session(), switch_ivr_originate(), switch_ivr_play_file(), switch_ivr_record_file(), switch_ivr_record_session(), 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_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

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_load_network_lists(), and switch_nat_init().

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

Definition at line 360 of file switch_utils.c.

References switch_core_alloc, and switch_snprintf().

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

char* switch_format_number ( const char * num )

Definition at line 3888 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_size_t switch_fp_read_dline	(	FILE *	fd,
		char **	buf,
		switch_size_t *	len
	)

Definition at line 757 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(), 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_status_t switch_frame_alloc	(	switch_frame_t **	frame,
		switch_size_t	size
	)

Definition at line 83 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.

 {
         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_status_t switch_frame_buffer_create ( switch_frame_buffer_t ** fbP )

Definition at line 254 of file switch_utils.c.

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

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

switch_status_t switch_frame_buffer_destroy ( switch_frame_buffer_t ** fbP )

Definition at line 243 of file switch_utils.c.

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

 {
         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_status_t switch_frame_buffer_dup	(	switch_frame_buffer_t *	fb,
		switch_frame_t *	orig,
		switch_frame_t **	clone
	)

Definition at line 226 of file switch_utils.c.

References find_free_frame(), switch_assert, SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

 {
         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_status_t switch_frame_buffer_free	(	switch_frame_buffer_t *	fb,
		switch_frame_t **	frameP
	)

Definition at line 193 of file switch_utils.c.

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

 {
         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_status_t switch_frame_dup	(	switch_frame_t *	orig,
		switch_frame_t **	clone
	)

Definition at line 269 of file switch_utils.c.

References switch_frame::buflen, switch_frame::codec, switch_frame::data, switch_frame::img, switch_frame::packet, 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.

 {
         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);
                 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 = NULL;
         new_frame->pmap = NULL;
         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_status_t switch_frame_free ( switch_frame_t ** frame )

Definition at line 308 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.

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

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

Definition at line 3337 of file switch_utils.c.

References cur, memset(), switch_assert, switch_safe_free, switch_split_date(), and switch_split_time().

Referenced by switch_xml_std_datetime_check().

 {
         char *dup = strdup(exp);
         char *sStart;
         char *sEnd;
         char *cur;
         char *p;
 
         switch_assert(dup);
 
         cur = dup;
         if ((p = strchr(cur, ','))) {
                 *p++ = '\0';
         }
 
         while (cur) {
                 sStart = cur;
                 if ((sEnd=strchr(cur, '~'))) {
                         char *sDate = sStart;
                         char *sTime;
                         *sEnd++ = '\0';
                         if ((sTime=strchr(sStart, ' '))) {
                                 switch_time_t tsStart;
                                 struct tm tmTmp;
                                 int year = 1970, month = 1, day = 1;
                                 int hour = 0, min = 0, sec = 0;
                                 *sTime++ = '\0';
 
                                 memset(&tmTmp, 0, sizeof(tmTmp));
                                 switch_split_date(sDate, &year, &month, &day);
                                 switch_split_time(sTime, &hour, &min, &sec);
                                 tmTmp.tm_year = year-1900;
                                 tmTmp.tm_mon = month-1;
                                 tmTmp.tm_mday = day;
 
                                 tmTmp.tm_hour = hour;
                                 tmTmp.tm_min = min;
                                 tmTmp.tm_sec = sec;
                                 tmTmp.tm_isdst = 0;
                                 tsStart = mktime(&tmTmp);
 
                                 sDate = sEnd;
                                 if ((sTime=strchr(sEnd, ' '))) {
                                         switch_time_t tsEnd;
                                         struct tm tmTmp;
                                         int year = 1970, month = 1, day = 1;
                                         int hour = 0, min = 0, sec = 0;
                                         *sTime++ = '\0';
 
                                         memset(&tmTmp, 0, sizeof(tmTmp));
                                         switch_split_date(sDate, &year, &month, &day);
                                         switch_split_time(sTime, &hour, &min, &sec);
                                         tmTmp.tm_year = year-1900;
                                         tmTmp.tm_mon = month-1;
                                         tmTmp.tm_mday = day;
 
                                         tmTmp.tm_hour = hour;
                                         tmTmp.tm_min = min;
                                         tmTmp.tm_sec = sec;
                                         tmTmp.tm_isdst = 0;
                                         tsEnd = mktime(&tmTmp);
 
                                         if (tsStart <= *ts/1000000 && tsEnd > *ts/1000000) {
                                                 switch_safe_free(dup);
                                                 return 1;
                                         }
                                 }
                         }
                 }
 
                 cur = p;
                 if (p) {
                         if ((p = strchr(p, ','))) {
                                 *p++ = '\0';
                         }
                 }
 
         }
         switch_safe_free(dup);
         return 0;
 
 }

void switch_getcputime ( switch_cputime * t )

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

Definition at line 4225 of file switch_utils.c.

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

void switch_http_dump_request ( switch_http_request_t * request )

Definition at line 4195 of file switch_utils.c.

References switch_event_header::name, switch_event_header::next, switch_assert, SWITCH_SIZE_T_FMT, and switch_event_header::value.

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

void switch_http_free_request ( switch_http_request_t * request )

Definition at line 4186 of file switch_utils.c.

References 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_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 4044 of file switch_utils.c.

References clean_uri(), switch_event_add_header_string(), SWITCH_EVENT_CHANNEL_DATA, switch_event_create, switch_http_free_request(), switch_http_parse_qs(), switch_separate_string(), SWITCH_STACK_BOTTOM, SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, and SWITCH_TRUE.

 {
         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);
         request->method = request->_buffer;
         request->bytes_buffered = datalen;
         if (body) {
                 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;
 }

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 3969 of file switch_utils.c.

References 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;
 
         if (qs) {
                 q = qs;
         } else { /*parse our own qs, dup to avoid modify the original string */
                 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);
 
         if (!qs) {
                 switch_safe_free(q);
         }
 }

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 switch_check_network_list_ip_token(), switch_find_local_ip(), switch_network_list_add_host_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 */
 }

static switch_bool_t switch_is_digit_string ( const char * s )

inlinestatic

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

static switch_bool_t switch_is_file_path ( const char * file )

inlinestatic

Definition at line 1098 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_gen_certs(), switch_img_txt_handle_create(), switch_ivr_displace_session(), switch_ivr_play_file(), switch_ivr_record_file(), switch_ivr_record_session(), 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_bool_t switch_is_lan_addr ( const char * ip )

Definition at line 1217 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_bool_t switch_is_leading_number ( const char * str )

Definition at line 1460 of file switch_utils.c.

References SWITCH_FALSE, and SWITCH_TRUE.

Referenced by switch_core_media_filter_sdp().

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

static switch_bool_t switch_is_moh ( const char * s )

inlinestatic

Definition at line 286 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_bool_t switch_is_number ( const char * str )

Definition at line 1441 of file switch_utils.c.

References SWITCH_FALSE, and SWITCH_TRUE.

Referenced by load_configuration(), switch_channel_perform_mark_answered(), switch_false(), switch_format_number(), 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;
 }

int switch_isalnum ( int c )

Definition at line 3610 of file switch_utils.c.

References _L, _N, and _U.

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

int switch_isalpha ( int c )

Definition at line 3615 of file switch_utils.c.

References _L, and _U.

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

int switch_iscntrl ( int c )

Definition at line 3620 of file switch_utils.c.

References _C.

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

int switch_isdigit ( int c )

Definition at line 3625 of file switch_utils.c.

References _N.

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

int switch_isgraph ( int c )

Definition at line 3630 of file switch_utils.c.

References _L, _N, _P, and _U.

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

int switch_islower ( int c )

Definition at line 3635 of file switch_utils.c.

References _L.

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

int switch_isprint ( int c )

Definition at line 3640 of file switch_utils.c.

References _B, _L, _N, _P, and _U.

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

int switch_ispunct ( int c )

Definition at line 3645 of file switch_utils.c.

References _P.

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

int switch_isspace ( int c )

Definition at line 3650 of file switch_utils.c.

References _S.

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

int switch_isupper ( int c )

Definition at line 3655 of file switch_utils.c.

References _U.

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

int switch_isxdigit ( int c )

Definition at line 3660 of file switch_utils.c.

References _N, and _X.

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

static char switch_itodtmf ( char i )

inlinestatic

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

static uint32_t switch_known_bitrate ( switch_payload_t payload )

inlinestatic

Definition at line 418 of file switch_utils.h.

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

static char* switch_lc_strdup ( const char * it )

inlinestatic

Definition at line 804 of file switch_utils.h.

References switch_tolower().

 {
         char *dup;
         char *p;
 
         if (it) {
                 dup = strdup(it);
                 for (p = dup; p && *p; p++) {
                         *p = (char) switch_tolower(*p);
                 }
                 return dup;
         }
 
         return NULL;
 }

static int switch_needs_url_encode ( const char * s )

inlinestatic

Definition at line 1039 of file switch_utils.h.

References end_of_p, and SWITCH_URL_UNSAFE.

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

char* switch_network_ipv4_mapped_ipv6_addr ( const char * ip_str )

Definition at line 494 of file switch_utils.c.

Referenced by switch_check_network_list_ip_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_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 552 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().

 {
         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)) != SWITCH_STATUS_SUCCESS) {
                                         status = this_status;
                                 }
                         }
                 }
         } else {
                 status = switch_network_list_perform_add_cidr_token(list, cidr_str, ok, token);
         }
 
         switch_safe_free(cidr_str_dup);
         return status;
 }

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 579 of file switch_utils.c.

References switch_network_node::bits, switch_network_node::ip, switch_network_node::mask, switch_network_node::next, switch_network_node::ok, 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().

 {
         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;
 
         /* 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_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 404 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().

 {
         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_bool_t switch_network_list_validate_ip6_token	(	switch_network_list_t *	list,
		ip_t	ip,
		const char **	token
	)

Definition at line 441 of file switch_utils.c.

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

Referenced by switch_check_network_list_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_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_bool_t switch_network_list_validate_ip_token	(	switch_network_list_t *	list,
		uint32_t	ip,
		const char **	token
	)

Definition at line 468 of file switch_utils.c.

References switch_network_node::bits, switch_network_node::family, switch_network_node::ip, switch_network_node::mask, switch_network_node::next, 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_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)) {
                         if (node->ok) {
                                 ok = SWITCH_TRUE;
                         } else {
                                 ok = SWITCH_FALSE;
                         }
 
                         bits = node->bits;
 
                         if (token) {
                                 *token = node->token;
                         }
                 }
         }
 
         return ok;
 }

int switch_number_cmp	(	const char *	exp,
		int	val
	)

Definition at line 3765 of file switch_utils.c.

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

static const char* switch_parse_audio_col ( switch_audio_col_t col )

inlinestatic

Definition at line 1124 of file switch_utils.h.

References 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, and SWITCH_AUDIO_COL_STR_TITLE.

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

static int32_t switch_parse_bandwidth_string ( const char * bwv )

inlinestatic

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

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

Definition at line 607 of file switch_utils.c.

References switch_copy_string(), switch_inet_pton(), ip_t::v4, and ip_t::v6.

Referenced by switch_check_network_list_ip_token(), and switch_network_list_perform_add_cidr_token().

 {
         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) {
                 int i,n;
                 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++){
                         if (n >= 8) {
                                 maskv->v6.s6_addr[i] = 0xFF;
                                 n -= 8;
                         } else if (n < 8) {
                                 maskv->v6.s6_addr[i] = 0xFF & ~(0xFF >> n);
                                 n -= n;
                         } else if (n == 0) {
                                 maskv->v6.s6_addr[i] = 0x00;
                         }
                 }
         } 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;
 }

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

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

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 1956 of file switch_utils.c.

References SWITCH_PRIORITY_HIGH, SWITCH_PRIORITY_LOW, and SWITCH_PRIORITY_NORMAL.

Referenced by 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";
         }
 }

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

Definition at line 1281 of file switch_utils.c.

References switch_assert.

 {
         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_status_t switch_resolve_host	(	const char *	host,
		char *	buf,
		size_t	buflen
	)

Definition at line 1647 of file switch_utils.c.

References get_addr(), SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

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

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 2327 of file switch_utils.c.

Referenced by handle_rfc2833().

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

static uint32_t switch_round_to_step	(	uint32_t	num,
		uint32_t	step
	)

inlinestatic

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

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

inlinestatic

Turn a string into a number (default if NULL)

Parameters

nptr	the string
dft	the default

Returns: the number version of the string or the default

Definition at line 779 of file switch_utils.h.

Referenced by switch_core_media_process_udptl().

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

static char* switch_safe_strdup ( const char * it )

inlinestatic

Definition at line 791 of file switch_utils.h.

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

static char* switch_sanitize_number ( char * number )

inlinestatic

Definition at line 668 of file switch_utils.h.

References 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, '@'))) {
                 return number;
         }
 
         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;
 }

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

inlinestatic

Definition at line 1070 of file switch_utils.h.

References switch_find_end_paren().

 {
         char *e = NULL;
         char *space = strdup(file);
 
         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;
 }

char* switch_separate_paren_args ( char * str )

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

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(), switch_channel_caller_extension_masquerade(), switch_channel_handle_cause(), switch_channel_process_export(), switch_channel_queue_dtmf_string(), switch_check_network_list_ip_token(), switch_console_complete(), switch_console_set_alias(), switch_console_set_complete(), switch_core_asr_load_grammar(), 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_log_str2mask(), switch_play_and_get_digits(), switch_process_import(), switch_speex_fmtp_parse(), and transfer_after_bridge().

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

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

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 981 of file switch_utils.c.

References 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(), and zstr.

Referenced by email().

 {
         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;
 
         if (zstr(to)) {
                 err = "No to address specified";
                 goto end;
         }
 
         if (!zstr(file) && !zstr(convert_cmd) && !zstr(convert_ext)) {
                 if ((ext = 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_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 (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;
 }

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 3193 of file switch_utils.c.

References switch_poll().

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

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

Definition at line 3306 of file switch_utils.c.

References switch_assert, and switch_safe_free.

Referenced by switch_fulldate_cmp().

 {
         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 && syear) {
                                 *year = atol(syear);
                         }
                         if (month && smonth) {
                                 *month = atol(smonth);
                         }
                         if (day && sday) {
                                 *day = atol(sday);
                         }
                 }
         }
         switch_safe_free(dup);
         return;
 
 }

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

Definition at line 3273 of file switch_utils.c.

References switch_assert, and switch_safe_free.

Referenced by switch_fulldate_cmp().

 {
         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 && shour) {
                         *hour = atol(shour);
                 }
                 if (min && smin) {
                         *min = atol(smin);
                 }
                 if (sec && ssec) {
                         *sec = atol(ssec);
                 }
 
         }
         switch_safe_free(dup);
         return;
 
 }

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 3848 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_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 1890 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.

 {
         switch_time_exp_t tm = { 0 }, local_tm = { 0 };
         int proceed = 0, ovector[30];
         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})";
 
         switch_time_exp_lt(&tm, switch_micro_time_now());
         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) {
 
                 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;
 }

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

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

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

inlinestatic

Definition at line 301 of file switch_utils.h.

References in, and switch_assert.

Referenced by switch_event_create_brackets(), and switch_ivr_originate().

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

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
	both]	buf Buffer for error message
[in]	buflen	Size of message buffer

Returns: Pointer to message buffer, returning error message or "Unknown error xxx" if none found

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

static int switch_string_has_escaped_data ( const char * in )

inlinestatic

Definition at line 350 of file switch_utils.h.

References switch_assert.

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_status_t switch_string_match	(	const char *	string,
		size_t	string_len,
		const char *	search,
		size_t	search_len
	)

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

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

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

static switch_bool_t switch_string_var_check	(	char *	s,
		switch_bool_t	disable
	)

inlinestatic

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

static switch_bool_t switch_string_var_check_const ( const char * s )

inlinestatic

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

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

Definition at line 1369 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;
                 } else if (*p != ',') {
                         ret = NULL;
                         break;
                 }
 
                 if (++x > len) {
                         ret = NULL;
                         break;
                 }
         }
 
         return ret;
 }

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

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

char* switch_strip_spaces	(	char *	str,
		switch_bool_t	dup
	)

Definition at line 1333 of file switch_utils.c.

References switch_assert, SWITCH_BLANK_STRING, and zstr.

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

char* switch_strip_whitespace ( const char * str )

Definition at line 1301 of file switch_utils.c.

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

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

Definition at line 1479 of file switch_utils.c.

References switch_toupper().

Referenced by audio_bridge_thread(), check_ice(), core_event_handler(), do_chat_send(), find_pt(), inherit_codec(), init_upnp(), main(), 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_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_session_check_incoming_crypto(), switch_core_session_findall_matching_var(), switch_core_sqldb_start(), switch_ivr_originate(), switch_odbc_handle_exec(), switch_pgsql_finish_results_real(), switch_pgsql_handle_exec_base_detailed(), 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;
 }

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 847 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_bool_t switch_testv6_subnet	(	ip_t	_ip,
		ip_t	_net,
		ip_t	_mask
	)

Definition at line 428 of file switch_utils.c.

References IN6_AND_MASK, and SWITCH_TRUE.

Referenced by switch_check_network_list_ip_token(), and switch_network_list_validate_ip6_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;
                 }
 }

int switch_tod_cmp	(	const char *	exp,
		int	val
	)

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

static uint32_t switch_tolower ( uint32_t eax )

inlinestatic

Definition at line 81 of file switch_utils.h.

Referenced by switch_hash_default_ci(), switch_lc_strdup(), and switch_tolower_max().

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

static void switch_tolower_max ( char * s )

inlinestatic

Definition at line 200 of file switch_utils.h.

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

static uint32_t switch_toupper ( uint32_t eax )

inlinestatic

Definition at line 70 of file switch_utils.h.

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

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

static void switch_toupper_max ( char * s )

inlinestatic

Definition at line 172 of file switch_utils.h.

References switch_toupper().

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

static int 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 450 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);
 }

static switch_byte_t switch_true_byte ( const char * expr )

inlinestatic

Definition at line 462 of file switch_utils.h.

References switch_true().

 {
         return (switch_byte_t)switch_true(expr);
 }

static char* switch_uc_strdup ( const char * it )

inlinestatic

Definition at line 821 of file switch_utils.h.

References switch_toupper().

 {
         char *dup;
         char *p;
 
         if (it) {
                 dup = strdup(it);
                 for (p = dup; p && *p; p++) {
                         *p = (char) switch_toupper(*p);
                 }
                 return dup;
         }
 
         return NULL;
 }

char* switch_url_decode ( char * s )

Definition at line 3252 of file switch_utils.c.

References zstr.

Referenced by switch_core_session_request_xml(), and switch_http_parse_qs().

 {
         char *o;
         unsigned int tmp;
 
         if (zstr(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;
 }

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

Definition at line 3247 of file switch_utils.c.

References SWITCH_FALSE, and switch_url_encode_opt().

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

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

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

Definition at line 3202 of file switch_utils.c.

References buf, end_of_p, and SWITCH_URL_UNSAFE.

Referenced by 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;
 }

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

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 2734 of file switch_utils.c.

References switch_assert, and switch_core_alloc.

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

char* switch_uuid_str	(	char *	buf,
		switch_size_t	len
	)

Definition at line 3873 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(), and switch_core_session_exec().

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

static char* switch_var_clean_string ( char * s )

inlinestatic

Definition at line 735 of file switch_utils.h.

References switch_string_var_check(), and SWITCH_TRUE.

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

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

Definition at line 2985 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().

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

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

Definition at line 3081 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.

 {
         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) * ms;
         
         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

Typedef Documentation

Enumeration Type Documentation

Function Documentation