switch_utils.c File Reference

#include <switch.h>
#include "private/switch_apr_pvt.h"
#include <arpa/inet.h>
#include <sys/types.h>
#include <unistd.h>
#include "private/switch_core_pvt.h"

Include dependency graph for switch_utils.c:

Go to the source code of this file.

Data Structures
struct	switch_network_node
struct	switch_network_list
struct	switch_frame_node_s
struct	switch_frame_buffer_s

Macros
#define	ESCAPE_META   '\\'
#define	IN6_AND_MASK(result, ip, mask)
#define	DLINE_BLOCK_SIZE   1024
#define	DLINE_MAX_SIZE   1048576
#define	B64BUFFLEN   1024
#define	SWITCH_CTYPE_NUM_CHARS   256
#define	_U   0x01
#define	_L   0x02
#define	_N   0x04
#define	_S   0x08
#define	_P   0x10
#define	_C   0x20
#define	_X   0x40
#define	_B   0x80
#define	SHA256_LENGTH   32

Typedefs
typedef struct switch_network_node	switch_network_node_t
typedef struct switch_frame_node_s	switch_frame_node_t

Enumerations
enum	dow_t {   DOW_ERR = -2, DOW_EOF = -1, DOW_SUN = 1, DOW_MON,   DOW_TUE, DOW_WED, DOW_THU, DOW_FRI,   DOW_SAT, DOW_HYPHEN = '-', DOW_COMA = ',' }

Functions
void *	switch_calloc (size_t nmemb, size_t size)
int	switch_inet_pton (int af, const char *src, void *dst)
char *	switch_print_host (switch_sockaddr_t *addr, char *buf, switch_size_t len)
switch_status_t	switch_frame_alloc (switch_frame_t **frame, switch_size_t size)
static switch_frame_t *	find_free_frame (switch_frame_buffer_t *fb, switch_frame_t *orig)
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_push (switch_frame_buffer_t *fb, void *ptr)
switch_status_t	switch_frame_buffer_trypush (switch_frame_buffer_t *fb, void *ptr)
switch_status_t	switch_frame_buffer_pop (switch_frame_buffer_t *fb, void **ptr)
switch_status_t	switch_frame_buffer_trypop (switch_frame_buffer_t *fb, void **ptr)
int	switch_frame_buffer_size (switch_frame_buffer_t *fb)
switch_status_t	switch_frame_buffer_destroy (switch_frame_buffer_t **fbP)
switch_status_t	switch_frame_buffer_create (switch_frame_buffer_t **fbP, switch_size_t qlen)
switch_status_t	switch_frame_dup (switch_frame_t *orig, switch_frame_t **clone)
switch_status_t	switch_frame_free (switch_frame_t **frame)
int	switch_strcasecmp_any (const char *str,...)
char *	switch_find_parameter (const char *str, const char *param, switch_memory_pool_t *pool)
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_bool_t	switch_testv6_subnet (ip_t _ip, ip_t _net, ip_t _mask)
switch_bool_t	switch_network_list_validate_ip6_port_token (switch_network_list_t *list, ip_t ip, int port, const char **token)
switch_bool_t	is_port_in_node (int port, switch_network_node_t *node)
switch_bool_t	switch_network_list_validate_ip_port_token (switch_network_list_t *list, uint32_t ip, int port, const char **token)
switch_bool_t	switch_network_list_validate_ip6_token (switch_network_list_t *list, ip_t ip, const char **token)
switch_bool_t	switch_network_list_validate_ip_token (switch_network_list_t *list, uint32_t ip, const char **token)
char *	switch_network_ipv4_mapped_ipv6_addr (const char *ip_str)
char *	switch_network_port_range_to_string (switch_network_port_range_p port)
switch_status_t	switch_network_list_perform_add_cidr_token (switch_network_list_t *list, const char *cidr_str, switch_bool_t ok, const char *token, switch_network_port_range_p port)
switch_status_t	switch_network_list_add_cidr_port_token (switch_network_list_t *list, const char *cidr_str, switch_bool_t ok, const char *token, switch_network_port_range_p port)
switch_status_t	switch_network_list_add_cidr_token (switch_network_list_t *list, const char *cidr_str, switch_bool_t ok, const char *token)
switch_status_t	switch_network_list_add_host_port_mask (switch_network_list_t *list, const char *host, const char *mask_str, switch_bool_t ok, switch_network_port_range_p port)
switch_status_t	switch_network_list_add_host_mask (switch_network_list_t *list, const char *host, const char *mask_str, switch_bool_t ok)
int	switch_parse_cidr (const char *string, ip_t *ip, ip_t *mask, uint32_t *bitp)
char *	switch_find_end_paren (const char *s, char open, char close)
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)
char *	switch_amp_encode (char *s, char *buf, switch_size_t len)
switch_status_t	switch_b64_encode (unsigned char *in, switch_size_t ilen, unsigned char *out, switch_size_t olen)
switch_size_t	switch_b64_decode (const char *in, char *out, switch_size_t olen)
static int	write_buf (int fd, const char *buf)
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)
switch_bool_t	switch_is_lan_addr (const char *ip)
switch_bool_t	switch_ast2regex (const char *pat, char *rbuf, size_t len)
char *	switch_replace_char (char *str, char from, char to, switch_bool_t dup)
char *	switch_pool_strip_whitespace (switch_memory_pool_t *pool, const char *str)
char *	switch_strip_whitespace (const char *str)
char *	switch_strip_spaces (char *str, switch_bool_t dup)
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)
switch_bool_t	switch_is_uint_in_range (const char *str, unsigned int from, unsigned int to)
	Check if a 32 bit unsigned number is in a range. More...
switch_bool_t	switch_is_number (const char *str)
switch_bool_t	switch_is_leading_number (const char *str)
const char *	switch_stristr (const char *instr, const char *str)
static int	get_netmask (struct sockaddr_in *me, int *mask)
switch_status_t	switch_resolve_host (const char *host, char *buf, size_t buflen)
switch_status_t	switch_find_local_ip (char *buf, int len, int *mask, int family)
switch_status_t	switch_find_interface_ip (char *buf, int len, int *mask, const char *ifname, int family)
switch_time_t	switch_str_time (const char *in)
	Converts a string representation of a date into a switch_time_t. More...
const char *	switch_priority_name (switch_priority_t priority)
	Return a printable name of a switch_priority_t. More...
int	get_addr_int (switch_sockaddr_t *sa)
int	switch_cmp_addr (switch_sockaddr_t *sa1, switch_sockaddr_t *sa2, switch_bool_t ip_only)
int	switch_cp_addr (switch_sockaddr_t *sa1, switch_sockaddr_t *sa2)
char *	get_addr6 (char *buf, switch_size_t len, struct sockaddr_in6 *sa, socklen_t salen)
char *	get_addr (char *buf, switch_size_t len, struct sockaddr *sa, socklen_t salen)
	find the char representation of an ip adress More...
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...
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...
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...
static char	unescape_char (char escaped)
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)
static char *	cleanup_separated_string (char *str, char delim)
unsigned int	switch_separate_string_string (char *buf, char *delim, char **array, unsigned int arraylen)
static unsigned int	separate_string_char_delim (char *buf, char delim, char **array, unsigned int arraylen)
static unsigned int	separate_string_blank_delim (char *buf, char **array, unsigned int arraylen)
unsigned int	switch_separate_string (char *buf, char delim, char **array, unsigned int arraylen)
static unsigned int	separate_string_char_delim_cheap (const char *buf, char delim, const char **array, unsigned int larray[], unsigned int arraylen)
static unsigned int	separate_string_blank_delim_cheap (const char *buf, const char **array, unsigned int larray[], unsigned int arraylen)
unsigned int	switch_separate_string_cheap (const char *buf, char delim, const char **array, unsigned int larray[], unsigned int arraylen)
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...
switch_status_t	switch_string_match (const char *string, size_t string_len, const char *search, size_t search_len)
char *	switch_string_replace (const char *string, const char *search, const char *replace)
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...
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)
int	switch_socket_waitfor (switch_pollfd_t *poll, int ms)
	Wait for a socket. More...
char *	switch_core_session_url_encode (switch_core_session_t *session, const char *url)
char *	switch_core_session_url_encode_opt (switch_core_session_t *session, const char *url, switch_bool_t double_encode)
char *	switch_core_url_encode (switch_memory_pool_t *pool, const char *url)
char *	switch_core_url_encode_opt (switch_memory_pool_t *pool, const char *url, switch_bool_t double_encode)
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)
void	switch_split_time (const char *exp, int *hour, int *min, int *sec)
void	switch_split_date (const char *exp, int *year, int *month, int *day)
int	switch_fulldate_cmp (const char *exp, switch_time_t *ts)
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)
const char *	switch_dow_int2str (int val)
int	switch_dow_str2int (const char *exp)
static dow_t	_dow_read_token (const char **s)
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_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)
void	switch_http_parse_qs (switch_http_request_t *request, char *qs)
switch_status_t	clean_uri (char *uri)
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_getcputime (switch_cputime *t)
char *	switch_html_strip (const char *str)
unsigned long	switch_getpid (void)
switch_status_t	switch_digest (const char *digest_name, unsigned char **digest, const void *input, switch_size_t inputLen, unsigned int *outputlen)
switch_status_t	switch_digest_string (const char *digest_name, char **digest_str, const void *input, switch_size_t inputLen, unsigned int *outputlen)
char *	switch_must_strdup (const char *_s)
const char *	switch_memory_usage_stream (switch_stream_handle_t *stream)
cJSON *	switch_jwt_verify (const char *secret, const char *token)
char *	switch_jwt_sign (const char *secret, const uint8_t *payload, switch_size_t size)

Variables
static const char	switch_b64_table [65] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
static char	RFC2833_CHARS [] = "0123456789*#ABCDF"
const short	_switch_C_toupper_ [1+SWITCH_CTYPE_NUM_CHARS]
const short *	_switch_toupper_tab_ = _switch_C_toupper_
const short	_switch_C_tolower_ [1+SWITCH_CTYPE_NUM_CHARS]
const short *	_switch_tolower_tab_ = _switch_C_tolower_
const int	_switch_C_ctype_ [1+SWITCH_CTYPE_NUM_CHARS]
const int *	_switch_ctype_ = _switch_C_ctype_
static const char *	DOW []

Macro Definition Documentation

_B

#define _B   0x80

Definition at line 3936 of file switch_utils.c.

Referenced by switch_isprint().

_C

#define _C   0x20

Definition at line 3934 of file switch_utils.c.

Referenced by switch_iscntrl().

_L

#define _L   0x02

Definition at line 3930 of file switch_utils.c.

Referenced by switch_isalnum(), switch_isalpha(), switch_isgraph(), switch_islower(), and switch_isprint().

_N

#define _N   0x04

Definition at line 3931 of file switch_utils.c.

Referenced by switch_isalnum(), switch_isdigit(), switch_isgraph(), switch_isprint(), and switch_isxdigit().

_P

#define _P   0x10

Definition at line 3933 of file switch_utils.c.

_S

#define _S   0x08

Definition at line 3932 of file switch_utils.c.

Referenced by switch_isspace().

_U

#define _U   0x01

Definition at line 3929 of file switch_utils.c.

Referenced by switch_isalnum(), switch_isalpha(), switch_isgraph(), switch_isprint(), and switch_isupper().

_X

#define _X   0x40

Definition at line 3935 of file switch_utils.c.

Referenced by switch_isxdigit().

B64BUFFLEN

#define B64BUFFLEN   1024

Definition at line 1024 of file switch_utils.c.

Referenced by switch_simple_email().

DLINE_BLOCK_SIZE

#define DLINE_BLOCK_SIZE   1024

Definition at line 842 of file switch_utils.c.

Referenced by switch_fd_read_dline(), and switch_fp_read_dline().

DLINE_MAX_SIZE

#define DLINE_MAX_SIZE   1048576

Definition at line 843 of file switch_utils.c.

Referenced by switch_fd_read_dline(), and switch_fp_read_dline().

ESCAPE_META

#define ESCAPE_META   '\\'

Definition at line 51 of file switch_utils.c.

Referenced by cleanup_separated_string(), separate_string_blank_delim(), and separate_string_char_delim().

IN6_AND_MASK

#define IN6_AND_MASK	(		result,
			ip,
			mask
	)

Value:

((uint32_t *) (result))[0] =((const uint32_t *) (ip))[0] & ((const uint32_t *)(mask))[0]; \
        ((uint32_t *) (result))[1] =((const uint32_t *) (ip))[1] & ((const uint32_t *)(mask))[1]; \
        ((uint32_t *) (result))[2] =((const uint32_t *) (ip))[2] & ((const uint32_t *)(mask))[2]; \
        ((uint32_t *) (result))[3] =((const uint32_t *) (ip))[3] & ((const uint32_t *)(mask))[3];

Definition at line 478 of file switch_utils.c.

Referenced by switch_testv6_subnet().

SHA256_LENGTH

#define SHA256_LENGTH   32

Definition at line 4942 of file switch_utils.c.

Referenced by switch_jwt_sign(), and switch_jwt_verify().

SWITCH_CTYPE_NUM_CHARS

#define SWITCH_CTYPE_NUM_CHARS   256

Definition at line 3790 of file switch_utils.c.

Typedef Documentation

switch_frame_node_t

typedef struct switch_frame_node_s switch_frame_node_t

switch_network_node_t

typedef struct switch_network_node switch_network_node_t

Definition at line 77 of file switch_utils.c.

Enumeration Type Documentation

dow_t

enum dow_t

Enumerator
DOW_ERR
DOW_EOF
DOW_SUN
DOW_MON
DOW_TUE
DOW_WED
DOW_THU
DOW_FRI
DOW_SAT
DOW_HYPHEN
DOW_COMA

Definition at line 4062 of file switch_utils.c.

             {
        DOW_ERR = -2,
        DOW_EOF = -1,
        DOW_SUN = 1,
        DOW_MON,
        DOW_TUE,
        DOW_WED,
        DOW_THU,
        DOW_FRI,
        DOW_SAT,
        DOW_HYPHEN = '-',
        DOW_COMA = ','
} dow_t;

Function Documentation

_dow_read_token()

static dow_t _dow_read_token ( const char **  s )

inlinestatic

Definition at line 4076 of file switch_utils.c.

References DOW_COMA, DOW_EOF, DOW_ERR, DOW_HYPHEN, and switch_dow_str2int().

Referenced by switch_dow_cmp().

{
        int i;

        if (**s == '-') {
                (*s)++;
                return DOW_HYPHEN;
        } else if (**s == ',') {
                (*s)++;
                return DOW_COMA;
        } else if (**s >= '1' && **s <= '7') {
                dow_t r = **s - '0';
                (*s)++;
                return r;
        } else if ((i = switch_dow_str2int(*s)) && i != -1) {
                (*s) += 3;
                return i;
        } else if (!**s) {
                return DOW_EOF;
        } else {
                return DOW_ERR;
        }
}

clean_uri()

switch_status_t clean_uri

(

char *

uri

)

Definition at line 4378 of file switch_utils.c.

References switch_separate_string(), SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

Referenced by switch_http_parse_header().

{
        int argc;
        char *argv[64];
        int last, i, len, uri_len = 0;

        argc = switch_separate_string(uri, '/', argv, sizeof(argv) / sizeof(argv[0]));

        if (argc == sizeof(argv)) { /* too deep */
                return SWITCH_STATUS_FALSE;
        }

        last = 1;
        for(i = 1; i < argc; i++) {
                if (*argv[i] == '\0' || !strcmp(argv[i], ".")) {
                        /* ignore //// or /././././ */
                } else if (!strcmp(argv[i], "..")) {
                        /* got /../, go up one level */
                        if (last > 1) last--;
                } else {
                        argv[last++] = argv[i];
                }
        }

        for(i = 1; i < last; i++) {
                len = strlen(argv[i]);
                sprintf(uri + uri_len, "/%s", argv[i]);
                uri_len += (len + 1);
        }

        return SWITCH_STATUS_SUCCESS;
}

cleanup_separated_string()

static char* cleanup_separated_string ( char *  str, char  delim  )

static

Definition at line 2689 of file switch_utils.c.

References ESCAPE_META, and unescape_char().

Referenced by separate_string_blank_delim(), and separate_string_char_delim().

{
        char *ptr;
        char *dest;
        char *start;
        char *end = NULL;
        int inside_quotes = 0;

        /* Skip initial whitespace */
        for (ptr = str; *ptr == ' '; ++ptr) {
        }

        for (start = dest = ptr; *ptr; ++ptr) {
                char e;
                int esc = 0;

                if (*ptr == ESCAPE_META) {
                        e = *(ptr + 1);
                        if (e == '\'' || e == '"' || (delim && e == delim) || e == ESCAPE_META || (e = unescape_char(*(ptr + 1))) != *(ptr + 1)) {
                                ++ptr;
                                *dest++ = e;
                                end = dest;
                                esc++;
                        }
                }
                if (!esc) {
                        if (*ptr == '\'' && (inside_quotes || strchr(ptr+1, '\''))) {
                                if ((inside_quotes = (1 - inside_quotes))) {
                                        end = dest;
                                }
                        } else {
                                *dest++ = *ptr;
                                if (*ptr != ' ' || inside_quotes) {
                                        end = dest;
                                }
                        }
                }
        }
        if (end) {
                *end = '\0';
        }

        return start;
}

find_free_frame()

static switch_frame_t* find_free_frame ( switch_frame_buffer_t *  fb, switch_frame_t *  orig  )

static

Definition at line 141 of file switch_utils.c.

References switch_frame::buflen, switch_frame::channels, switch_frame::codec, switch_frame::data, switch_frame::datalen, switch_frame::extra_data, switch_frame::flags, switch_frame_node_s::frame, switch_frame_buffer_s::head, switch_frame::img, switch_frame_node_s::inuse, switch_frame::m, switch_frame_buffer_s::mutex, switch_frame_node_s::next, switch_frame::packet, switch_frame::packetlen, switch_frame::payload, switch_frame::pmap, switch_frame_buffer_s::pool, switch_frame_node_s::prev, switch_frame::rate, switch_frame::samples, switch_frame::seq, SFF_DYNAMIC, SFF_ENCODED, switch_frame::ssrc, switch_core_alloc, switch_img_copy(), switch_mutex_lock(), switch_mutex_unlock(), SWITCH_RTP_MAX_BUF_LEN, switch_set_flag, switch_test_flag, switch_frame::timestamp, and switch_frame_buffer_s::total.

Referenced by switch_frame_buffer_dup().

{
        switch_frame_node_t *np;

        switch_mutex_lock(fb->mutex);

        for (np = fb->head; np; np = np->next) {
                if (!np->inuse && ((orig->packet && np->frame->packet) || (!orig->packet && !np->frame->packet))) {

                        if (np == fb->head) {
                                fb->head = np->next;
                        } else if (np->prev) {
                                np->prev->next = np->next;
                        }

                        if (np->next) {
                                np->next->prev = np->prev;
                        }

                        fb->total--;
                        np->prev = np->next = NULL;
                        break;
                }
        }

        if (!np) {
                np = switch_core_alloc(fb->pool, sizeof(*np));
                np->frame = switch_core_alloc(fb->pool, sizeof(*np->frame));

                if (orig->packet) {
                        np->frame->packet = switch_core_alloc(fb->pool, SWITCH_RTP_MAX_BUF_LEN);
                } else {
                        np->frame->packet = NULL;
                        np->frame->data = switch_core_alloc(fb->pool, SWITCH_RTP_MAX_BUF_LEN);
                        np->frame->buflen = SWITCH_RTP_MAX_BUF_LEN;
                }
        }

        np->frame->samples = orig->samples;
        np->frame->rate = orig->rate;
        np->frame->channels = orig->channels;
        np->frame->payload = orig->payload;
        np->frame->timestamp = orig->timestamp;
        np->frame->seq = orig->seq;
        np->frame->ssrc = orig->ssrc;
        np->frame->m = orig->m;
        np->frame->flags = orig->flags;
        np->frame->codec = orig->codec;
        np->frame->pmap = orig->pmap;
        np->frame->img = NULL;
        np->frame->extra_data = np;
        np->inuse = 1;

        switch_set_flag(np->frame, SFF_DYNAMIC);

        if (orig->packet) {
                memcpy(np->frame->packet, orig->packet, orig->packetlen);
                np->frame->packetlen = orig->packetlen;
                np->frame->data = ((unsigned char *)np->frame->packet) + 12;
                np->frame->datalen = orig->datalen;
        } else {
                np->frame->packet = NULL;
                np->frame->packetlen = 0;
                memcpy(np->frame->data, orig->data, orig->datalen);
                np->frame->datalen = orig->datalen;
        }

        if (orig->img && !switch_test_flag(orig, SFF_ENCODED)) {
                switch_img_copy(orig->img, &np->frame->img);
        }

        switch_mutex_unlock(fb->mutex);

        return np->frame;
}

get_addr()

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

find the char representation of an ip adress

Parameters

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

Returns

the ip adress string

Definition at line 2494 of file switch_utils.c.

References buf, and switch_assert.

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

{
        switch_assert(buf);
        *buf = '\0';

        if (sa) {
                getnameinfo(sa, salen, buf, (socklen_t) len, NULL, 0, NI_NUMERICHOST);
        }
        return buf;
}

get_addr6()

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

Definition at line 2478 of file switch_utils.c.

References buf, and switch_assert.

Referenced by switch_false(), and switch_get_addr().

{
        switch_assert(buf);
        *buf = '\0';

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

        return buf;
}

get_addr_int()

int get_addr_int

(

switch_sockaddr_t *

sa

)

Definition at line 2367 of file switch_utils.c.

Referenced by switch_false().

{
        struct sockaddr_in *s = (struct sockaddr_in *) &sa->sa;

        return ntohs((unsigned short) s->sin_addr.s_addr);
}

get_netmask()

static int get_netmask ( struct sockaddr_in *  me, int *  mask  )

static

Definition at line 1833 of file switch_utils.c.

Referenced by switch_find_local_ip(), and switch_stristr().

{
        return -1;
}

get_port()

unsigned short get_port

(

struct sockaddr *

sa

)

get the port number of an ip address

Parameters

sa	the struct sockaddr * to get the port from

Returns

the ip adress string

Definition at line 2505 of file switch_utils.c.

Referenced by switch_false().

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

is_port_in_node()

switch_bool_t is_port_in_node	(	int	port,
		switch_network_node_t *	node
	)

Definition at line 524 of file switch_utils.c.

References MAX_NETWORK_PORTS, switch_network_port_range::max_port, switch_network_port_range::min_port, switch_network_port_range::port, switch_network_node::port_range, switch_network_port_range::ports, SWITCH_FALSE, and SWITCH_TRUE.

Referenced by switch_network_list_validate_ip_port_token().

{
        if(port == 0)
                return SWITCH_TRUE;
        if(node->port_range.port != 0 && node->port_range.port != port)
                return SWITCH_FALSE;
        if(node->port_range.ports[0] != 0) {
                int i;
                for(i=0; i < MAX_NETWORK_PORTS && node->port_range.ports[i] != 0; i++) {
                        if(port == node->port_range.ports[i])
                                return SWITCH_TRUE;
                }
                return SWITCH_FALSE;
        }
        if(node->port_range.min_port != 0 || node->port_range.max_port != 0) {
                if(port >= node->port_range.min_port && port <= node->port_range.max_port)
                        return SWITCH_TRUE;
                return SWITCH_FALSE;
        }
        return SWITCH_TRUE;
}

old_switch_tolower()

int old_switch_tolower

(

int

c

)

Definition at line 3877 of file switch_utils.c.

Referenced by switch_tolower_max().

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

old_switch_toupper()

int old_switch_toupper

(

int

c

)

Definition at line 3830 of file switch_utils.c.

Referenced by switch_tolower_max().

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

separate_string_blank_delim()

static unsigned int separate_string_blank_delim ( char *  buf, char **  array, unsigned int  arraylen  )

static

Definition at line 2798 of file switch_utils.c.

References buf, cleanup_separated_string(), count, and ESCAPE_META.

Referenced by switch_separate_string().

{
        enum tokenizer_state {
                START,
                SKIP_INITIAL_SPACE,
                FIND_DELIM,
                SKIP_ENDING_SPACE
        } state = START;

        unsigned int count = 0;
        char *ptr = buf;
        int inside_quotes = 0;
        unsigned int i;

        while (*ptr && count < arraylen) {
                switch (state) {
                case START:
                        array[count++] = ptr;
                        state = SKIP_INITIAL_SPACE;
                        break;

                case SKIP_INITIAL_SPACE:
                        if (*ptr == ' ') {
                                ++ptr;
                        } else {
                                state = FIND_DELIM;
                        }
                        break;

                case FIND_DELIM:
                        if (*ptr == ESCAPE_META) {
                                ++ptr;
                        } else if (*ptr == '\'') {
                                inside_quotes = (1 - inside_quotes);
                        } else if (*ptr == ' ' && !inside_quotes) {
                                *ptr = '\0';
                                state = SKIP_ENDING_SPACE;
                        }
                        ++ptr;
                        break;

                case SKIP_ENDING_SPACE:
                        if (*ptr == ' ') {
                                ++ptr;
                        } else {
                                state = START;
                        }
                        break;
                }
        }
        /* strip quotes, escaped chars and leading / trailing spaces */

        for (i = 0; i < count; ++i) {
                array[i] = cleanup_separated_string(array[i], 0);
        }

        return count;
}

separate_string_blank_delim_cheap()

static unsigned int separate_string_blank_delim_cheap ( const char *  buf, const char **  array, unsigned int  larray[], unsigned int  arraylen  )

static

Definition at line 2923 of file switch_utils.c.

References buf, and count.

Referenced by switch_separate_string_cheap().

{
        enum tokenizer_state {
                START,
                SKIP_INITIAL_SPACE,
                FIND_DELIM,
                SKIP_ENDING_SPACE
        } state = START, dstate = START;

        unsigned int count = 0;
        const char *ptr = buf;

        while (*ptr && count < arraylen) {
                switch (state) {
                case START:
                        array[count++] = ptr;
                        dstate = START;
                        state = SKIP_INITIAL_SPACE;
                        break;

                case SKIP_INITIAL_SPACE:
                        if (*ptr == ' ') {
                                ++ptr;
                        } else {
                                state = FIND_DELIM;
                        }
                        break;

                case FIND_DELIM:
                        if (*ptr == ' ') {
                                larray[count - 1] = (unsigned int)(ptr - array[count - 1]);
                                dstate = state;
                                state = SKIP_ENDING_SPACE;
                        }
                        ++ptr;
                        break;

                case SKIP_ENDING_SPACE:
                        if (*ptr == ' ') {
                                ++ptr;
                        } else {
                                dstate = state;
                                state = START;
                        }
                        break;
                }
        }
        if (dstate == START) larray[count - 1] = strlen(array[count - 1]);

        /* strip quotes, escaped chars and leading / trailing spaces */

        // for (i = 0; i < count; ++i) {
        //      array[i] = cleanup_separated_string(array[i], 0);
        // }

        return count;
}

separate_string_char_delim()

static unsigned int separate_string_char_delim ( char *  buf, char  delim, char **  array, unsigned int  arraylen  )

static

Definition at line 2755 of file switch_utils.c.

References buf, cleanup_separated_string(), count, and ESCAPE_META.

Referenced by switch_separate_string().

{
        enum tokenizer_state {
                START,
                FIND_DELIM
        } state = START;

        unsigned int count = 0;
        char *ptr = buf;
        int inside_quotes = 0;
        unsigned int i;

        while (*ptr && count < arraylen) {
                switch (state) {
                case START:
                        array[count++] = ptr;
                        state = FIND_DELIM;
                        break;

                case FIND_DELIM:
                        /* escaped characters are copied verbatim to the destination string */
                        if (*ptr == ESCAPE_META) {
                                ++ptr;
                        } else if (*ptr == '\'' && (inside_quotes || strchr(ptr+1, '\''))) {
                                inside_quotes = (1 - inside_quotes);
                        } else if (*ptr == delim && !inside_quotes) {
                                *ptr = '\0';
                                state = START;
                        }
                        ++ptr;
                        break;
                }
        }
        /* strip quotes, escaped chars and leading / trailing spaces */

        for (i = 0; i < count; ++i) {
                array[i] = cleanup_separated_string(array[i], delim);
        }

        return count;
}

separate_string_char_delim_cheap()

static unsigned int separate_string_char_delim_cheap ( const char *  buf, char  delim, const char **  array, unsigned int  larray[], unsigned int  arraylen  )

static

Definition at line 2880 of file switch_utils.c.

References buf, and count.

Referenced by switch_separate_string_cheap().

{
        enum tokenizer_state {
                START,
                FIND_DELIM
        } state = START, dstate = START;

        unsigned int count = 0;
        const char *ptr = buf;

        while (*ptr && count < arraylen) {
                switch (state) {
                case START:
                        array[count] = ptr;
                        state = FIND_DELIM;
                        dstate = START;
                        count++;
                        ptr++;
                        break;

                case FIND_DELIM:
                        if (*ptr == delim) {
                                larray[count - 1] = (unsigned int)(ptr - array[count - 1]);
                                dstate = state;
                                state = START;
                        }
                        ++ptr;
                        break;
                }
        }

        if (dstate == START) larray[count - 1] = strlen(array[count - 1]);

        /* strip quotes, escaped chars and leading / trailing spaces */

        // for (i = 0; i < count; ++i) {
        //      array[i] = cleanup_separated_string(array[i], delim);
        // }

        return count;
}

switch_amp_encode()

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

Definition at line 939 of file switch_utils.c.

References buf, and switch_assert.

Referenced by switch_string_has_escaped_data().

{
        char *p, *q;
        switch_size_t x = 0;
        switch_assert(s);

        q = buf;

        for (p = s; x < len; p++) {
                switch (*p) {

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

  end:

        return buf;
}

switch_ast2regex()

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

Definition at line 1388 of file switch_utils.c.

References memset(), SWITCH_FALSE, and SWITCH_TRUE.

Referenced by switch_regex_perform().

{
        const char *p = pat;

        if (!pat) {
                return SWITCH_FALSE;
        }

        memset(rbuf, 0, len);

        *(rbuf + strlen(rbuf)) = '^';

        while (p && *p) {
                if (*p == 'N') {
                        strncat(rbuf, "[2-9]", len - strlen(rbuf));
                } else if (*p == 'X') {
                        strncat(rbuf, "[0-9]", len - strlen(rbuf));
                } else if (*p == 'Z') {
                        strncat(rbuf, "[1-9]", len - strlen(rbuf));
                } else if (*p == '.') {
                        strncat(rbuf, ".*", len - strlen(rbuf));
                } else if (strlen(rbuf) < len - 1) {
                        *(rbuf + strlen(rbuf)) = *p;
                }
                p++;
        }
        *(rbuf + strlen(rbuf)) = '$';

        return strcmp(pat, rbuf) ? SWITCH_TRUE : SWITCH_FALSE;
}

switch_atoui()

unsigned int switch_atoui

(

const char *

nptr

)

Definition at line 4293 of file switch_utils.c.

Referenced by switch_ivr_process_fh().

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

switch_atoul()

unsigned long switch_atoul

(

const char *

nptr

)

Definition at line 4300 of file switch_utils.c.

Referenced by switch_load_core_config().

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

switch_b64_decode()

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

Definition at line 1064 of file switch_utils.c.

References b, switch_network_node::ip, and switch_b64_table.

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

{

        char l64[256];
        int b = 0, c, l = 0, i;
        const char *ip;
        char *op = out;
        size_t ol = 0;

        for (i = 0; i < 256; i++) {
                l64[i] = -1;
        }

        for (i = 0; i < 64; i++) {
                l64[(int) switch_b64_table[i]] = (char) i;
        }

        for (ip = in; ip && *ip; ip++) {
                c = l64[(int) *ip];
                if (c == -1) {
                        continue;
                }

                b = (b << 6) + c;
                l += 6;

                while (l >= 8) {
                        op[ol++] = (char) ((b >> (l -= 8)) % 256);
                        if (ol >= olen - 1) {
                                goto end;
                        }
                }
        }

  end:

        op[ol+1] = '\0';

        return ol;
}

switch_b64_encode()

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

Definition at line 1025 of file switch_utils.c.

References b, switch_b64_table, and SWITCH_STATUS_SUCCESS.

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

{
        int y = 0, bytes = 0;
        size_t x = 0;
        unsigned int b = 0, l = 0;

        for (x = 0; x < ilen; x++) {
                b = (b << 8) + in[x];
                l += 8;

                while (l >= 6) {
                        out[bytes++] = switch_b64_table[(b >> (l -= 6)) % 64];
                        if (bytes >= (int)olen - 1) {
                                goto end;
                        }
                        if (++y != 72) {
                                continue;
                        }
                        /* out[bytes++] = '\n'; */
                        y = 0;
                }
        }

        if (l > 0) {
                out[bytes++] = switch_b64_table[((b % 16) << (6 - l)) % 64];
        }
        if (l != 0) {
                while (l < 6 && bytes < (int)olen - 1) {
                        out[bytes++] = '=', l += 2;
                }
        }

  end:

        out[bytes] = '\0';

        return SWITCH_STATUS_SUCCESS;
}

switch_build_uri()

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

build a URI string from components

Parameters

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

Returns

number of characters printed (not including the trailing null)

Definition at line 2521 of file switch_utils.c.

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

{
        char host[NI_MAXHOST], serv[NI_MAXSERV];
        struct sockaddr_in6 si6;
        const struct sockaddr *addr;
        const char *colon;

        if (flags & SWITCH_URI_NO_SCOPE && sa->family == AF_INET6) {
                memcpy(&si6, &sa->sa, sa->salen);
                si6.sin6_scope_id = 0;

                addr = (const struct sockaddr *) &si6;
        } else {
                addr = (const struct sockaddr *) (intptr_t) & sa->sa;
        }

        if (getnameinfo(addr, sa->salen, host, sizeof(host), serv, sizeof(serv),
                                        ((flags & SWITCH_URI_NUMERIC_HOST) ? NI_NUMERICHOST : 0) | ((flags & SWITCH_URI_NUMERIC_PORT) ? NI_NUMERICSERV : 0)) != 0) {
                return 0;
        }

        colon = strchr(host, ':');

        return switch_snprintf(uri, size, "%s:%s%s%s%s%s%s%s", scheme,
                                                   user ? user : "", user ? "@" : "", colon ? "[" : "", host, colon ? "]" : "", serv[0] ? ":" : "", serv[0] ? serv : "");
}

switch_calloc()

void* switch_calloc	(	size_t	nmemb,
		size_t	size
	)

Definition at line 86 of file switch_utils.c.

{
        return calloc(nmemb, size);
}

switch_char_to_rfc2833()

unsigned char switch_char_to_rfc2833

(

char

key

)

Return the RFC2833 event based on an key character.

Parameters

key	the charecter to encode

Returns

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

Definition at line 2556 of file switch_utils.c.

References RFC2833_CHARS, and switch_toupper().

Referenced by do_2833(), and switch_errno_is_break().

{
        char *c;
        unsigned char counter = 0;

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

switch_cmp_addr()

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

Definition at line 2374 of file switch_utils.c.

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

{
        struct sockaddr_in *s1;
        struct sockaddr_in *s2;

        struct sockaddr_in6 *s16;
        struct sockaddr_in6 *s26;

        struct sockaddr *ss1;
        struct sockaddr *ss2;

        if (!(sa1 && sa2))
                return 0;

        s1 = (struct sockaddr_in *) &sa1->sa;
        s2 = (struct sockaddr_in *) &sa2->sa;

        s16 = (struct sockaddr_in6 *) &sa1->sa;
        s26 = (struct sockaddr_in6 *) &sa2->sa;

        ss1 = (struct sockaddr *) &sa1->sa;
        ss2 = (struct sockaddr *) &sa2->sa;

        if (ss1->sa_family != ss2->sa_family)
                return 0;

        switch (ss1->sa_family) {
        case AF_INET:
                if (ip_only) {
                        return (s1->sin_addr.s_addr == s2->sin_addr.s_addr);
                } else {
                        return (s1->sin_addr.s_addr == s2->sin_addr.s_addr && s1->sin_port == s2->sin_port);
                }
        case AF_INET6:
                {
                        int i;

                        if (!ip_only) {
                                if (s16->sin6_port != s26->sin6_port) return 0;
                        }

                        for (i = 0; i < 4; i++) {
                                if (*((int32_t *) s16->sin6_addr.s6_addr + i) != *((int32_t *) s26->sin6_addr.s6_addr + i)) return 0;
                        }

                        return 1;
                }
        }

        return 0;
}

switch_core_session_url_encode()

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

Definition at line 3550 of file switch_utils.c.

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

Referenced by switch_needs_url_encode().

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

switch_core_session_url_encode_opt()

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

Definition at line 3555 of file switch_utils.c.

References switch_core_session_get_pool(), and switch_core_url_encode_opt().

Referenced by switch_needs_url_encode().

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

switch_core_url_encode()

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

Definition at line 3560 of file switch_utils.c.

References switch_core_url_encode_opt(), and SWITCH_FALSE.

Referenced by switch_needs_url_encode().

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

switch_core_url_encode_opt()

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

Definition at line 3565 of file switch_utils.c.

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

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

{
        const char hex[] = "0123456789ABCDEF";
        switch_size_t len = 0;
        switch_size_t slen = 0;
        const char *p, *e;

        if (!url) return NULL;
        if (!pool) return NULL;

        e = end_of_p(url);

        for (p = url; *p; p++) {
                int ok = 0;

                len++;
                slen++;

                if (!double_encode && *p == '%' && e-p > 1) {
                        if (strchr(hex, *(p+1)) && strchr(hex, *(p+2))) {
                                ok = 1;
                        }
                }

                if (!ok && (*p < ' ' || *p > '~' || strchr(SWITCH_URL_UNSAFE, *p))) {
                        len += 2;
                }
        }

        slen++;
        len++; /* NULL Terminatior */

        if (slen == len) {
                return switch_core_strdup(pool, url);
        } else {
                return switch_url_encode_opt(url, switch_core_alloc(pool, sizeof(char) * len), len, double_encode);
        }
}

switch_cp_addr()

int switch_cp_addr	(	switch_sockaddr_t *	sa1,
		switch_sockaddr_t *	sa2
	)

Definition at line 2427 of file switch_utils.c.

Referenced by read_rtp_packet(), and switch_false().

{
        struct sockaddr_in *s1;
        struct sockaddr_in *s2;

        struct sockaddr_in6 *s16;
        struct sockaddr_in6 *s26;

        struct sockaddr *ss1;
        //struct sockaddr *ss2;

        if (!(sa1 && sa2))
                return 0;

        s1 = (struct sockaddr_in *) &sa1->sa;
        s2 = (struct sockaddr_in *) &sa2->sa;

        s16 = (struct sockaddr_in6 *) &sa1->sa;
        s26 = (struct sockaddr_in6 *) &sa2->sa;

        ss1 = (struct sockaddr *) &sa1->sa;
        //ss2 = (struct sockaddr *) &sa2->sa;

        sa1->port = sa2->port;
        sa1->family = sa2->family;

        sa1->sa.sin.sin_family = sa2->family;

        switch (ss1->sa_family) {
        case AF_INET:
                s1->sin_addr.s_addr = s2->sin_addr.s_addr;
                s1->sin_port = s2->sin_port;

                return 1;
        case AF_INET6:
                {
                        int i;

                        s16->sin6_port = s26->sin6_port;

                        for (i = 0; i < 4; i++) {
                                *((int32_t *) s16->sin6_addr.s6_addr + i) = *((int32_t *) s26->sin6_addr.s6_addr + i);
                        }

                        return 1;
                }
        }

        return 0;
}

switch_cut_path()

const char* switch_cut_path

(

const char *

in

)

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

Returns

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

Definition at line 3005 of file switch_utils.c.

References in.

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

{
        const char *p, *ret = in;
        const char delims[] = "/\\";
        const char *i;

        if (in) {
                for (i = delims; *i; i++) {
                        p = in;
                        while ((p = strchr(p, *i)) != 0) {
                                ret = ++p;
                        }
                }
                return ret;
        } else {
                return NULL;
        }
}

switch_digest()

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

Definition at line 4715 of file switch_utils.c.

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

Referenced by switch_digest_string().

{
#if defined(HAVE_OPENSSL)
        EVP_MD_CTX *mdctx;
        const EVP_MD *md;
        int size;

        switch_assert(digest);

        if (!digest_name) {
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Message digest is not set\n");
                return SWITCH_STATUS_FALSE;
        }

        md = EVP_get_digestbyname(digest_name);

        if (!md) {
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Unknown message digest %s\n", digest_name);                    
                return SWITCH_STATUS_FALSE;
        }

        size = EVP_MD_size(md);
        if (!size || !(*digest = malloc(size))) {
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Zero digest size or can't allocate memory to store results %s\n", digest_name);
                return SWITCH_STATUS_FALSE;
        }

#if OPENSSL_VERSION_NUMBER >= 0x10100000L
        mdctx = EVP_MD_CTX_new();
#else
        mdctx = EVP_MD_CTX_create();
#endif

        if (!mdctx) {
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "EVP_MD_CTX_new error\n");
                switch_safe_free(*digest);
                return SWITCH_STATUS_FALSE;
        }

        EVP_MD_CTX_init(mdctx);
        EVP_DigestInit_ex(mdctx, md, NULL);
        EVP_DigestUpdate(mdctx, input, inputLen);
        EVP_DigestFinal_ex(mdctx, *digest, outputlen);

#if OPENSSL_VERSION_NUMBER >= 0x10100000L
        EVP_MD_CTX_free(mdctx);
#else
        EVP_MD_CTX_destroy(mdctx);
#endif

        return SWITCH_STATUS_SUCCESS;
#else
        return SWITCH_STATUS_FALSE;
#endif
}

switch_digest_string()

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

Definition at line 4771 of file switch_utils.c.

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

{
        unsigned char *digest = NULL;
        switch_status_t status;
        short i = 0, x;
        uint8_t b;

        status = switch_digest(digest_name, &digest, input, inputLen, outputlen);

        if (status == SWITCH_STATUS_SUCCESS) {
                if ((*digest_str = malloc(*outputlen * 2 + 1))) {
                        for (x = i = 0; x < *outputlen; x++) {
                                b = (digest[x] >> 4) & 15;
                                (*digest_str)[i++] = b + (b > 9 ? 'a' - 10 : '0');
                                b = digest[x] & 15;
                                (*digest_str)[i++] = b + (b > 9 ? 'a' - 10 : '0');
                        }

                        (*digest_str)[i] = '\0';
                } else {
                        switch_safe_free(digest);
                        *outputlen = 0;
                        return SWITCH_STATUS_FALSE;
                }
        }

        switch_safe_free(digest);
        *outputlen = i;

        return status;
}

switch_dow_cmp()

switch_bool_t switch_dow_cmp	(	const char *	exp,
		int	val
	)

Definition at line 4100 of file switch_utils.c.

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

Referenced by switch_xml_std_datetime_check().

{
        dow_t cur, prev = DOW_EOF, range_start = DOW_EOF;
        const char *p = exp;

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

                prev = cur;
        }

        return SWITCH_FALSE;
}

switch_dow_int2str()

const char* switch_dow_int2str

(

int

val

)

Definition at line 4042 of file switch_utils.c.

References switch_arraylen.

Referenced by switch_xml_std_datetime_check().

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

switch_dow_str2int()

int switch_dow_str2int

(

const char *

exp

)

Definition at line 4049 of file switch_utils.c.

References switch_arraylen.

Referenced by _dow_read_token().

                                                        {
        int ret = -1;
        int x;

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

switch_escape_char()

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

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

Parameters

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

Returns

the escaped string

Definition at line 2571 of file switch_utils.c.

References count, in, and switch_core_alloc.

{
        char *data;
        const char *p, *d;
        int count = 1, i = 0;

        p = in;
        while (*p) {
                d = delim;
                while (*d) {
                        if (*p == *d) {
                                count++;
                        }
                        d++;
                }
                p++;
        }

        if (count == 1) {
                return in;
        }

        data = switch_core_alloc(pool, strlen(in) + count);

        p = in;
        while (*p) {
                d = delim;
                while (*d) {
                        if (*p == *d) {
                                data[i++] = esc;
                        }
                        d++;
                }
                data[i++] = *p;
                p++;
        }
        return data;
}

switch_escape_string()

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

Definition at line 2642 of file switch_utils.c.

Referenced by switch_escape_string_pool().

{
        const char *p;
        char *o = out;

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

        *o++ = '\0';

        return out;
}

switch_escape_string_pool()

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

Definition at line 2680 of file switch_utils.c.

References buf, switch_core_alloc, and switch_escape_string().

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

switch_fd_read_dline()

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

Definition at line 844 of file switch_utils.c.

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

Referenced by switch_known_bitrate().

{
        char c, *p;
        int cur;
        switch_size_t total = 0;
        char *data = *buf;
        switch_size_t ilen = *len;

        if (!data) {
                *len = ilen = DLINE_BLOCK_SIZE;
                data = malloc(ilen);
                memset(data, 0, ilen);
        }

        p = data;
        while ((cur = read(fd, &c, 1)) == 1) {

                if (total + 2 >= ilen) {
                        if (ilen + DLINE_BLOCK_SIZE > DLINE_MAX_SIZE) {
                                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Single line limit reached!\n");
                                break;
                        }

                        ilen += DLINE_BLOCK_SIZE;
                        data = realloc(data, ilen);
                        switch_assert(data);
                        p = data + total;

                }

                total += cur;
                *p++ = c;

                if (c == '\r' || c == '\n') {
                        break;
                }
        }

        *p++ = '\0';

        *len = ilen;
        *buf = data;

        return total;
}

switch_fd_read_line()

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

Definition at line 822 of file switch_utils.c.

References buf, and cur.

Referenced by switch_known_bitrate().

{
        char c, *p;
        int cur;
        switch_size_t total = 0;

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

        *p++ = '\0';
        assert(total < len);
        return total;
}

switch_find_end_paren()

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

Definition at line 796 of file switch_utils.c.

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

{
        const char *e = NULL;
        int depth = 0;

        while (s && *s && *s == ' ') {
                s++;
        }

        if (s && *s == open) {
                depth++;
                for (e = s + 1; e && *e; e++) {
                        if (*e == open && open != close) {
                                depth++;
                        } else if (*e == close) {
                                depth--;
                                if (!depth) {
                                        break;
                                }
                        }
                }
        }

        return (e && *e == close) ? (char *) e : NULL;
}

switch_find_interface_ip()

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

Definition at line 2032 of file switch_utils.c.

References SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

{
        switch_status_t status = SWITCH_STATUS_FALSE;

#ifdef HAVE_GETIFADDRS

        struct ifaddrs *addrs, *addr;

        getifaddrs(&addrs);
        for(addr = addrs; addr; addr = addr->ifa_next)
        {
                if (!(addr->ifa_flags & IFF_UP)) continue; // Address is not UP
                if (!addr->ifa_addr) continue; // No address set
                if (!addr->ifa_netmask) continue; // No netmask set
                if (family != AF_UNSPEC && addr->ifa_addr->sa_family != family) continue; // Not the address family we're looking for
                if (strcmp(addr->ifa_name, ifname)) continue; // Not the interface we're looking for

                switch(addr->ifa_addr->sa_family) {
                case AF_INET:
                        inet_ntop(AF_INET, &( ((struct sockaddr_in*)(addr->ifa_addr))->sin_addr ), buf, len - 1);
                        break;
                case AF_INET6:
                        inet_ntop(AF_INET6, &( ((struct sockaddr_in6*)(addr->ifa_addr))->sin6_addr ), buf, len - 1);
                        break;
                default:
                        continue;
                }

                if (mask && addr->ifa_netmask->sa_family == AF_INET) {
                        *mask = ((struct sockaddr_in*)(addr->ifa_addr))->sin_addr.s_addr;
                }

                status = SWITCH_STATUS_SUCCESS;
                break;
        }
        freeifaddrs(addrs);

#elif defined(__linux__)

        // TODO Not implemented, contributions welcome.

#elif defined(WIN32)

        // TODO Not implemented, contributions welcome.

#endif

        return status;
}

switch_find_local_ip()

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

Definition at line 1858 of file switch_utils.c.

References get_addr(), get_netmask(), memset(), switch_copy_string(), switch_core_get_variable_dup(), switch_inet_pton(), switch_safe_free, SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

{
        switch_status_t status = SWITCH_STATUS_FALSE;
        char *base;
        char *force_local_ip_v4 = switch_core_get_variable_dup("force_local_ip_v4");
        char *force_local_ip_v6 = switch_core_get_variable_dup("force_local_ip_v6");

#ifdef WIN32
        SOCKET tmp_socket;
        SOCKADDR_STORAGE l_address;
        int l_address_len;
        struct addrinfo *address_info;
#else
#ifdef __Darwin__
        int ilen;
#else
        unsigned int ilen;
#endif
        int tmp_socket = -1, on = 1;
        char abuf[25] = "";
#endif

        switch (family) {
        case AF_INET:
                if (force_local_ip_v4) {
                        switch_copy_string(buf, force_local_ip_v4, len);
                        switch_safe_free(force_local_ip_v4);
                        switch_safe_free(force_local_ip_v6);
                        return SWITCH_STATUS_SUCCESS;
                }
        case AF_INET6:
                if (force_local_ip_v6) {
                        switch_copy_string(buf, force_local_ip_v6, len);
                        switch_safe_free(force_local_ip_v4);
                        switch_safe_free(force_local_ip_v6);
                        return SWITCH_STATUS_SUCCESS;
                }
        default:
                switch_safe_free(force_local_ip_v4);
                switch_safe_free(force_local_ip_v6);
                break;
        }


        if (len < 16) {
                return status;
        }

        switch (family) {
        case AF_INET:
                switch_copy_string(buf, "127.0.0.1", len);
                base = "82.45.148.209";
                break;
        case AF_INET6:
                switch_copy_string(buf, "::1", len);
                base = "2001:503:BA3E::2:30";   /* DNS Root server A */
                break;
        default:
                base = "127.0.0.1";
                break;
        }

#ifdef WIN32
        tmp_socket = socket(family, SOCK_DGRAM, 0);

        getaddrinfo(base, NULL, NULL, &address_info);

        if (!address_info || WSAIoctl(tmp_socket,
                                                                  SIO_ROUTING_INTERFACE_QUERY,
                                                                  address_info->ai_addr, (DWORD) address_info->ai_addrlen, &l_address, sizeof(l_address), (LPDWORD) & l_address_len, NULL,
                                                                  NULL)) {

                closesocket(tmp_socket);
                if (address_info)
                        freeaddrinfo(address_info);
                return status;
        }


        closesocket(tmp_socket);
        freeaddrinfo(address_info);

        if (!getnameinfo((const struct sockaddr *) &l_address, l_address_len, buf, len, NULL, 0, NI_NUMERICHOST)) {
                status = SWITCH_STATUS_SUCCESS;
                if (mask) {
                        get_netmask((struct sockaddr_in *) &l_address, mask);
                }
        }
#else

        switch (family) {
        case AF_INET:
                {
                        struct sockaddr_in iface_out;
                        struct sockaddr_in remote;
                        memset(&remote, 0, sizeof(struct sockaddr_in));

                        remote.sin_family = AF_INET;
                        remote.sin_addr.s_addr = inet_addr(base);
                        remote.sin_port = htons(4242);

                        memset(&iface_out, 0, sizeof(iface_out));
                        if ( (tmp_socket = socket(AF_INET, SOCK_DGRAM, 0)) == -1 ) {
                                goto doh;
                        }

                        if (setsockopt(tmp_socket, SOL_SOCKET, SO_BROADCAST, &on, sizeof(on)) == -1) {
                                goto doh;
                        }

                        if (connect(tmp_socket, (struct sockaddr *) &remote, sizeof(struct sockaddr_in)) == -1) {
                                goto doh;
                        }

                        ilen = sizeof(iface_out);
                        if (getsockname(tmp_socket, (struct sockaddr *) &iface_out, &ilen) == -1) {
                                goto doh;
                        }

                        if (iface_out.sin_addr.s_addr == 0) {
                                goto doh;
                        }

                        switch_copy_string(buf, get_addr(abuf, sizeof(abuf), (struct sockaddr *) &iface_out, sizeof(struct sockaddr_storage)), len);
                        if (mask) {
                                get_netmask((struct sockaddr_in *) &iface_out, mask);
                        }

                        status = SWITCH_STATUS_SUCCESS;
                }
                break;
        case AF_INET6:
                {
                        struct sockaddr_in6 iface_out;
                        struct sockaddr_in6 remote;
                        memset(&remote, 0, sizeof(struct sockaddr_in6));

                        remote.sin6_family = AF_INET6;
                        switch_inet_pton(AF_INET6, base, &remote.sin6_addr);
                        remote.sin6_port = htons(4242);

                        memset(&iface_out, 0, sizeof(iface_out));
                        if ( (tmp_socket = socket(AF_INET6, SOCK_DGRAM, 0)) == -1 ) {
                                goto doh;
                        }

                        if (connect(tmp_socket, (struct sockaddr *) &remote, sizeof(remote)) == -1) {
                                goto doh;
                        }

                        ilen = sizeof(iface_out);
                        if (getsockname(tmp_socket, (struct sockaddr *) &iface_out, &ilen) == -1) {
                                goto doh;
                        }

                        inet_ntop(AF_INET6, (const void *) &iface_out.sin6_addr, buf, len - 1);
                        status = SWITCH_STATUS_SUCCESS;
                }
                break;
        }

  doh:
        if (tmp_socket > 0) {
                close(tmp_socket);
        }
#endif

        return status;
}

switch_find_parameter()

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

Definition at line 415 of file switch_utils.c.

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

Referenced by switch_known_bitrate().

{
        char *e, *r = NULL, *ptr = NULL, *next = NULL;
        size_t len;

        ptr = (char *) str;

        while (ptr) {
                len = strlen(param);
                e = ptr+len;
                next = strchr(ptr, ';');

                if (!strncasecmp(ptr, param, len) && *e == '=') {
                        size_t mlen;

                        ptr = ++e;

                        if (next) {
                                e = next;
                        } else {
                                e = ptr + strlen(ptr);
                        }

                        mlen = (e - ptr) + 1;

                        if (pool) {
                                r = switch_core_alloc(pool, mlen);
                        } else {
                                r = malloc(mlen);
                        }

                        switch_snprintf(r, mlen, "%s", ptr);

                        break;
                }

                if (next) {
                        ptr = next + 1;
                } else break;
        }

        return r;
}

switch_format_number()

char* switch_format_number

(

const char *

num

)

Definition at line 4256 of file switch_utils.c.

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

{
        char *r;
        size_t len;
        const char *p = num;

        if (!p) {
                return (char*)p;
        }

        if (zstr(p)) {
                return strdup(p);
        }

        if (*p == '+') {
                p++;
        }

        if (!switch_is_number(p)) {
                return strdup(p);
        }

        len = strlen(p);

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

        return r;
}

switch_fp_read_dline()

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

Definition at line 892 of file switch_utils.c.

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

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

{
        char c, *p;
        switch_size_t total = 0;
        char *data = *buf;
        switch_size_t ilen = *len;

        if (!data) {
                *len = ilen = DLINE_BLOCK_SIZE;
                data = malloc(ilen);
                memset(data, 0, ilen);
        }

        p = data;
        //while ((c = fgetc(fd)) != EOF) {

        while (fread(&c, 1, 1, fd) == 1) {

                if (total + 2 >= ilen) {
                        if (ilen + DLINE_BLOCK_SIZE > DLINE_MAX_SIZE) {
                                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Single line limit reached!\n");
                                break;
                        }

                        ilen += DLINE_BLOCK_SIZE;
                        data = realloc(data, ilen);
                        switch_assert(data);
                        p = data + total;

                }

                total++;
                *p++ = c;

                if (c == '\r' || c == '\n') {
                        break;
                }
        }

        *p++ = '\0';

        *len = ilen;
        *buf = data;

        return total;
}

switch_frame_alloc()

switch_status_t switch_frame_alloc	(	switch_frame_t **	frame,
		switch_size_t	size
	)

Definition at line 109 of file switch_utils.c.

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

Referenced by switch_known_bitrate().

{
        switch_frame_t *new_frame;

        switch_zmalloc(new_frame, sizeof(*new_frame));

        switch_set_flag(new_frame, SFF_DYNAMIC);
        new_frame->buflen = (uint32_t)size;
        new_frame->data = malloc(size);
        switch_assert(new_frame->data);

        *frame = new_frame;

        return SWITCH_STATUS_SUCCESS;
}

switch_frame_buffer_create()

switch_status_t switch_frame_buffer_create	(	switch_frame_buffer_t **	fbP,
		switch_size_t	qlen
	)

Definition at line 303 of file switch_utils.c.

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

Referenced by audio_write_thread().

{
        switch_frame_buffer_t *fb;
        switch_memory_pool_t *pool;

        if (!qlen) qlen = 500;

        switch_core_new_memory_pool(&pool);
        fb = switch_core_alloc(pool, sizeof(*fb));
        fb->pool = pool;
        switch_queue_create(&fb->queue, qlen, fb->pool);
        switch_mutex_init(&fb->mutex, SWITCH_MUTEX_NESTED, pool);
        *fbP = fb;

        return SWITCH_STATUS_SUCCESS;
}

switch_frame_buffer_destroy()

switch_status_t switch_frame_buffer_destroy

(

switch_frame_buffer_t **

fbP

)

Definition at line 292 of file switch_utils.c.

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

Referenced by switch_media_handle_destroy().

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

        return SWITCH_STATUS_SUCCESS;
}

switch_frame_buffer_dup()

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

Definition at line 250 of file switch_utils.c.

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

Referenced by perform_write().

{
        switch_frame_t *new_frame;

        if (!orig) {
                return SWITCH_STATUS_FALSE;
        }

        switch_assert(orig->buflen);

        new_frame = find_free_frame(fb, orig);

        *clone = new_frame;

        return SWITCH_STATUS_SUCCESS;
}

switch_frame_buffer_free()

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

Definition at line 217 of file switch_utils.c.

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

Referenced by audio_write_thread().

{
        switch_frame_t *old_frame;
        switch_frame_node_t *node;

        switch_mutex_lock(fb->mutex);

        old_frame = *frameP;
        *frameP = NULL;

        node = (switch_frame_node_t *) old_frame->extra_data;
        node->inuse = 0;
        switch_img_free(&node->frame->img);

        fb->total++;

        if (fb->head) {
                fb->head->prev = node;
        }

        node->next = fb->head;
        node->prev = NULL;
        fb->head = node;

        switch_assert(node->next != node);
        switch_assert(node->prev != node);


        switch_mutex_unlock(fb->mutex);

        return SWITCH_STATUS_SUCCESS;
}

switch_frame_buffer_pop()

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

Definition at line 277 of file switch_utils.c.

References switch_frame_buffer_s::queue, and switch_queue_pop().

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

switch_frame_buffer_push()

switch_status_t switch_frame_buffer_push	(	switch_frame_buffer_t *	fb,
		void *	ptr
	)

Definition at line 267 of file switch_utils.c.

References switch_frame_buffer_s::queue, and switch_queue_push().

Referenced by perform_write(), and switch_core_media_deactivate_rtp().

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

switch_frame_buffer_size()

int switch_frame_buffer_size

(

switch_frame_buffer_t *

fb

)

Definition at line 287 of file switch_utils.c.

References switch_frame_buffer_s::queue, and switch_queue_size().

{
        return switch_queue_size(fb->queue);
}

switch_frame_buffer_trypop()

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

Definition at line 282 of file switch_utils.c.

References switch_frame_buffer_s::queue, and switch_queue_trypop().

Referenced by audio_write_thread().

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

switch_frame_buffer_trypush()

switch_status_t switch_frame_buffer_trypush	(	switch_frame_buffer_t *	fb,
		void *	ptr
	)

Definition at line 272 of file switch_utils.c.

References switch_frame_buffer_s::queue, and switch_queue_trypush().

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

switch_frame_dup()

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

Definition at line 321 of file switch_utils.c.

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

Referenced by switch_known_bitrate().

{
        switch_frame_t *new_frame;

        if (!orig) {
                return SWITCH_STATUS_FALSE;
        }

        switch_assert(orig->buflen);

        new_frame = malloc(sizeof(*new_frame));
        switch_assert(new_frame);

        *new_frame = *orig;
        switch_set_flag(new_frame, SFF_DYNAMIC);

        if (orig->packet) {
                new_frame->packet = malloc(SWITCH_RTP_MAX_BUF_LEN);
                switch_assert(new_frame->packet);
                memcpy(new_frame->packet, orig->packet, orig->packetlen);
                new_frame->data = ((unsigned char *)new_frame->packet) + 12;
        } else {
                new_frame->packet = NULL;
                new_frame->data = malloc(new_frame->buflen);
                switch_assert(new_frame->data);
                memcpy(new_frame->data, orig->data, orig->datalen);
        }


        new_frame->codec = orig->codec;
        new_frame->pmap = orig->pmap;
        new_frame->img = NULL;


        if (orig->img && !switch_test_flag(orig, SFF_ENCODED)) {
                switch_img_copy(orig->img, &new_frame->img);
        }
        *clone = new_frame;

        return SWITCH_STATUS_SUCCESS;
}

switch_frame_free()

switch_status_t switch_frame_free

(

switch_frame_t **

frame

)

Definition at line 363 of file switch_utils.c.

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

Referenced by switch_known_bitrate().

{
        switch_frame_t * f;

        if (!frame) {
                return SWITCH_STATUS_FALSE;
        }

        f = *frame;

        if (!f || !switch_test_flag(f, SFF_DYNAMIC)) {
                return SWITCH_STATUS_FALSE;
        }

        *frame = NULL;

        if (f->img) {
                switch_img_free(&(f->img));
        }

        if (f->packet) {
                switch_safe_free(f->packet);
        } else {
                switch_safe_free(f->data);
        }

        free(f);

        return SWITCH_STATUS_SUCCESS;
}

switch_fulldate_cmp()

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

Definition at line 3739 of file switch_utils.c.

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

Referenced by switch_xml_std_datetime_check().

{
        char *dup = strdup(exp);
        char *sStart;
        char *sEnd;
        char *cur;
        char *p;
        switch_time_t tsStart = 0;
        switch_time_t tsEnd = 0;
        int ret = 0;

        switch_assert(dup);

        cur = dup;
        if ((p = strchr(cur, ','))) {
                *p++ = '\0';
        }

        while (cur) {
                sStart = cur;
                if ((sEnd = strchr(cur, '~'))) {
                        *sEnd++ = '\0';

                        tsStart = switch_str_time(sStart);
                        tsEnd = switch_str_time(sEnd);


                        if (tsStart == 0 || tsEnd == 0) {
                                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Parse error for date time range (%s~%s)\n", sStart, sEnd);
                                break;
                        }

                        if (tsStart <= *ts && tsEnd > *ts) {
                                ret = 1;
                                break;
                        }
                }

                if ((cur = p)) {
                        if ((p = strchr(p, ','))) {
                                *p++ = '\0';
                        }
                }
        }

        switch_safe_free(dup);
        return ret;
}

switch_getcputime()

void switch_getcputime

(

switch_cputime *

t

)

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

Definition at line 4591 of file switch_utils.c.

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

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

switch_getpid()

unsigned long switch_getpid

(

void

)

Definition at line 4704 of file switch_utils.c.

Referenced by fst_init_core_and_modload().

{
#ifndef WIN32
        pid_t pid = getpid();
#else
        int pid = _getpid();
#endif

        return (unsigned long)pid;
}

switch_html_strip()

char* switch_html_strip

(

const char *

str

)

Definition at line 4658 of file switch_utils.c.

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

{
        char *p, *html = NULL, *text = NULL;
        int x = 0, got_ct = 0;
#ifdef SWITCH_HAVE_GUMBO
        GumboOutput *output;
        switch_stream_handle_t stream;

        SWITCH_STANDARD_STREAM(stream);
#endif

        for(p = (char *)str; p && *p; p++) {

                if (!strncasecmp(p, "Content-Type:", 13)) {
                        got_ct++;
                }

                if (!got_ct) continue;

                if (*p == '\n') {
                        x++;
                        if (x == 2) {
                                break;
                        }
                } else if (x && (*p != '\r')) {
                        x = 0;
                }
        }

        html = p;

#ifdef SWITCH_HAVE_GUMBO
        if ((output = gumbo_parse_with_options(&kGumboDefaultOptions, html, strlen(html)))) {
                process(output->root, &stream);
                gumbo_destroy_output(&kGumboDefaultOptions, output);
        }

        text = (char *)stream.data;
#else
        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "Support for html parser is not compiled.\n");
        text = switch_safe_strdup(html);
#endif

        return text;
}

switch_http_dump_request()

void switch_http_dump_request

(

switch_http_request_t *

request

)

Definition at line 4561 of file switch_utils.c.

References switch_http_request_s::content_length, switch_http_request_s::content_type, switch_http_request_s::from, switch_event::headers, switch_http_request_s::headers, switch_http_request_s::host, switch_http_request_s::keepalive, switch_http_request_s::method, switch_event_header::name, switch_event_header::next, switch_http_request_s::port, switch_http_request_s::qs, switch_http_request_s::referer, switch_assert, SWITCH_SIZE_T_FMT, switch_http_request_s::uri, switch_http_request_s::user, switch_http_request_s::user_agent, 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;
                }
        }
}

switch_http_free_request()

void switch_http_free_request

(

switch_http_request_t *

request

)

Definition at line 4552 of file switch_utils.c.

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

Referenced by switch_http_parse_header().

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

switch_http_parse_header()

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

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

Parameters

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

Returns

SWITCH_STATUS_SUCCESS | SWITCH_STATUS_FALSE

Definition at line 4411 of file switch_utils.c.

References switch_http_request_s::_buffer, switch_http_request_s::_destroy_headers, buffer, switch_http_request_s::bytes_buffered, switch_http_request_s::bytes_header, switch_http_request_s::bytes_read, clean_uri(), switch_http_request_s::content_length, switch_http_request_s::content_type, switch_http_request_s::headers, switch_http_request_s::host, switch_http_request_s::keepalive, switch_http_request_s::method, switch_http_request_s::port, switch_http_request_s::qs, switch_http_request_s::referer, switch_assert, 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, SWITCH_TRUE, switch_http_request_s::uri, switch_http_request_s::user_agent, and value.

{
        switch_status_t status = SWITCH_STATUS_FALSE;
        char *p = buffer;
        int i = 10;
        char *http = NULL;
        int header_count;
        char *headers[64] = { 0 };
        int argc;
        char *argv[2] = { 0 };
        char *body = NULL;

        if (datalen < 16)       return status; /* minimum GET / HTTP/1.1\r\n */

        while(i--) { // sanity check
                if (*p++ == ' ') break;
        }

        if (i == 0) return status;

        if ((body = strstr(buffer, "\r\n\r\n"))) {
                *body = '\0';
                body += 4;
        } else if (( body = strstr(buffer, "\n\n"))) {
                *body = '\0';
                body += 2;
        } else {
                return status;
        }

        request->_buffer = strdup(buffer);
        switch_assert(request->_buffer);
        request->method = request->_buffer;
        request->bytes_buffered = datalen;
        request->bytes_header = body - buffer;
        request->bytes_read = body - buffer;

        p = strchr(request->method, ' ');

        if (!p) goto err;

        *p++ = '\0';

        if (*p != '/') goto err; /* must start from '/' */

        request->uri = p;
        p = strchr(request->uri, ' ');

        if (!p) goto err;

        *p++ = '\0';
        http = p;

        p = strchr(request->uri, '?');

        if (p) {
                *p++ = '\0';
                request->qs = p;
        }

        if (clean_uri((char *)request->uri) != SWITCH_STATUS_SUCCESS) {
                goto err;
        }

        if (!strncmp(http, "HTTP/1.1", 8)) {
                request->keepalive = SWITCH_TRUE;
        } else if (strncmp(http, "HTTP/1.0", 8)) {
                goto err;
        }

        if (!request->headers) {
                if (switch_event_create(&request->headers, SWITCH_EVENT_CHANNEL_DATA) != SWITCH_STATUS_SUCCESS) {
                        goto err;
                }
                request->_destroy_headers = SWITCH_TRUE;
        }

        p = strchr(http, '\n');

        if (p) {
                *p++ = '\0'; // now the first header
        } else {
                goto noheader;
        }

        header_count = switch_separate_string(p, '\n', headers, sizeof(headers)/ sizeof(headers[0]));

        if (header_count < 1) goto err;

        for (i = 0; i < header_count; i++) {
                char *header, *value;
                int len;

                argc = switch_separate_string(headers[i], ':', argv, 2);

                if (argc != 2) goto err;

                header = argv[0];
                value = argv[1];

                if (*value == ' ') value++;

                len = strlen(value);

                if (len && *(value + len - 1) == '\r') *(value + len - 1) = '\0';

                switch_event_add_header_string(request->headers, SWITCH_STACK_BOTTOM, header, value);

                if (!strncasecmp(header, "User-Agent", 10)) {
                        request->user_agent = value;
                } else if (!strncasecmp(header, "Host", 4)) {
                        request->host = value;
                        p = strchr(value, ':');

                        if (p) {
                                *p++ = '\0';

                                if (*p) request->port = (switch_port_t)atoi(p);
                        }
                } else if (!strncasecmp(header, "Content-Type", 12)) {
                        request->content_type = value;
                } else if (!strncasecmp(header, "Content-Length", 14)) {
                        request->content_length = atoi(value);
                } else if (!strncasecmp(header, "Referer", 7)) {
                        request->referer = value;
                }
        }

noheader:

        if (request->qs) {
                switch_http_parse_qs(request, NULL);
        }

        return SWITCH_STATUS_SUCCESS;

err:
        switch_http_free_request(request);
        return status;
}

switch_http_parse_qs()

void switch_http_parse_qs	(	switch_http_request_t *	request,
		char *	qs
	)

parse http query string

Parameters

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

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

Definition at line 4337 of file switch_utils.c.

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

Referenced by switch_http_parse_header().

{
        char *q;
        char *next;
        char *name, *val;
        char *dup = NULL;

        if (qs) {
                q = qs;
        } else { /*parse our own qs, dup to avoid modify the original string */
                dup = q = strdup(request->qs);
        }

        switch_assert(q);
        next = q;

        do {
                char *p;

                if ((next = strchr(next, '&'))) {
                        *next++ = '\0';
                }

                for (p = q; p && *p; p++) {
                        if (*p == '+') *p = ' ';
                }

                switch_url_decode(q);

                name = q;
                if ((val = strchr(name, '='))) {
                        *val++ = '\0';
                        switch_event_add_header_string(request->headers, SWITCH_STACK_BOTTOM, name, val);
                }
                q = next;
        } while (q);

        switch_safe_free(dup);
}

switch_inet_pton()

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

Definition at line 92 of file switch_utils.c.

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

{
        return inet_pton(af, src, dst);
}

switch_is_lan_addr()

switch_bool_t switch_is_lan_addr

(

const char *

ip

)

Definition at line 1355 of file switch_utils.c.

References SWITCH_FALSE, SWITCH_TRUE, and zstr.

{
        if (zstr(ip))
                return SWITCH_FALSE;

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

switch_is_leading_number()

switch_bool_t switch_is_leading_number

(

const char *

str

)

Definition at line 1654 of file switch_utils.c.

References SWITCH_FALSE, and SWITCH_TRUE.

Referenced by switch_core_media_filter_sdp(), and switch_known_bitrate().

{
        const char *p;
        switch_bool_t r = SWITCH_FALSE;

        if (*str == '-' || *str == '+') {
                str++;
        }

        for (p = str; p && *p; p++) {
                if ((*p == '.' || (*p > 47 && *p < 58))) {
                        r = SWITCH_TRUE;
                        break;
                }
        }

        return r;
}

switch_is_number()

switch_bool_t switch_is_number

(

const char *

str

)

Definition at line 1635 of file switch_utils.c.

References SWITCH_FALSE, and SWITCH_TRUE.

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

{
        const char *p;
        switch_bool_t r = SWITCH_TRUE;

        if (*str == '-' || *str == '+') {
                str++;
        }

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

        return r;
}

switch_is_uint_in_range()

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

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

Parameters

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

Returns

true or false

Definition at line 1611 of file switch_utils.c.

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

Referenced by check_ice(), and switch_known_bitrate().

{
        unsigned int number;
        const char *original_str = str;

        if (str == NULL || *str == '\0' || from > to) {
                return SWITCH_FALSE;
        }

        for (; *str != '\0'; str++) {
                if (!isdigit(*str)) {
                        return SWITCH_FALSE;
                }
        }

        number = atoi(original_str);

        if (number < from || number > to) {
                return SWITCH_FALSE;
        }

        return SWITCH_TRUE;
}

switch_isalnum()

int switch_isalnum

(

int

c

)

Definition at line 3978 of file switch_utils.c.

References _L, _N, and _U.

Referenced by switch_tolower_max().

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

switch_isalpha()

int switch_isalpha

(

int

c

)

Definition at line 3983 of file switch_utils.c.

References _L, and _U.

Referenced by switch_tolower_max().

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

switch_iscntrl()

int switch_iscntrl

(

int

c

)

Definition at line 3988 of file switch_utils.c.

References _C.

Referenced by switch_tolower_max().

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

switch_isdigit()

int switch_isdigit

(

int

c

)

Definition at line 3993 of file switch_utils.c.

References _N.

Referenced by switch_tolower_max().

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

switch_isgraph()

int switch_isgraph

(

int

c

)

Definition at line 3998 of file switch_utils.c.

References _L, _N, and _U.

Referenced by switch_tolower_max().

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

switch_islower()

int switch_islower

(

int

c

)

Definition at line 4003 of file switch_utils.c.

References _L.

Referenced by switch_tolower_max().

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

switch_isprint()

int switch_isprint

(

int

c

)

Definition at line 4008 of file switch_utils.c.

References _B, _L, _N, and _U.

Referenced by switch_tolower_max().

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

switch_ispunct()

int switch_ispunct

(

int

c

)

Definition at line 4013 of file switch_utils.c.

Referenced by switch_tolower_max().

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

switch_isspace()

int switch_isspace

(

int

c

)

Definition at line 4018 of file switch_utils.c.

References _S.

Referenced by switch_tolower_max().

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

switch_isupper()

int switch_isupper

(

int

c

)

Definition at line 4023 of file switch_utils.c.

References _U.

Referenced by switch_tolower_max().

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

switch_isxdigit()

int switch_isxdigit

(

int

c

)

Definition at line 4028 of file switch_utils.c.

References _N, and _X.

Referenced by switch_tolower_max().

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

switch_jwt_sign()

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

Parameters

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

Returns

NULL or signed token

Definition at line 5007 of file switch_utils.c.

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

{
        cJSON *json;
        switch_size_t need;
        char *header;
        uint8_t *bheader;
        uint8_t *bpayload;
        char *to_sign;
        unsigned int len = 0;
        unsigned char signature[SHA256_LENGTH];
        unsigned char *bsignature;
        char *result = NULL;

        if (!secret || !payload) return NULL;

        json = cJSON_CreateObject();
        switch_assert(json);
        cJSON_AddStringToObject(json, "alg", "HS256");
        cJSON_AddStringToObject(json, "typ", "JWT");
        header = cJSON_Print(json);
        cJSON_Delete(json);
        if (!header) return NULL;

        need = ((strlen(header) + 3 - 1) / 3) * 4 + 1; // with extra NULL
        bheader = (uint8_t *)switch_must_malloc(need);
        switch_b64_encode((unsigned char *)header, strlen(header), bheader, need);
        free(header);
        header = NULL;

        need = ((size + 3 - 1) / 3) * 4 + 1; // with extra NULL
        bpayload = (uint8_t *)switch_must_malloc(need);
        switch_b64_encode((unsigned char *)payload, size, bpayload, need);

        to_sign = switch_mprintf("%s.%s", (char *)bheader, (char *)bpayload);
        switch_assert(to_sign);

        HMAC(EVP_sha256(), secret, strlen(secret), (unsigned char *)to_sign, strlen(to_sign), signature, &len);
        switch_assert(len == SHA256_LENGTH);
        free(to_sign);
        to_sign = NULL;

        need = ((len + 3 - 1) / 3) * 4 + 1; // with extra NULL
        bsignature = (uint8_t *)switch_must_malloc(need);
        switch_b64_encode((unsigned char *)signature, len, bsignature, need);
        result = switch_mprintf("%s.%s.%s", bheader, bpayload, bsignature);

        free(bheader);
        free(bpayload);
        free(bsignature);

        return result;
}

switch_jwt_verify()

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

Parameters

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

Returns

NULL or payload in cJSON

Definition at line 4943 of file switch_utils.c.

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

{
        int ok = 0;
        cJSON *json = NULL;
        cJSON *payload = NULL;
        char *out = NULL;
        unsigned int len = 0;
        unsigned char signature[SHA256_LENGTH];
        const char *alg = NULL;
        const char *typ = NULL;
        char *header = strdup(token);
        char *dot;

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

        if (ok) {
                char *p = strchr(token, '.');

                if (p) {
                        p++;
                        out = (char *)switch_must_malloc(strlen(p));
                        len = switch_b64_decode((const char *)p, out, strlen(p));
                        payload = cJSON_Parse(out);
                        free(out);
                        out = NULL;
                }
        }

end:
        switch_safe_free(header);
        switch_safe_free(out);
        if (json) cJSON_Delete(json);

        return payload;
}

switch_memory_usage_stream()

const char* switch_memory_usage_stream

(

switch_stream_handle_t *

stream

)

Definition at line 4810 of file switch_utils.c.

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

{
        const char *status = NULL;
#ifdef __GLIBC__
/*
 *  The mallinfo2() function was added in glibc 2.33.
 *  https://man7.org/linux/man-pages/man3/mallinfo.3.html
 */
#if defined(__GLIBC_PREREQ) && __GLIBC_PREREQ(2, 33)
        struct mallinfo2 mi;

        mi = mallinfo2();

        stream->write_function(stream, "Total non-mmapped bytes (arena):       %" SWITCH_SIZE_T_FMT "\n", mi.arena);
        stream->write_function(stream, "# of free chunks (ordblks):            %" SWITCH_SIZE_T_FMT "\n", mi.ordblks);
        stream->write_function(stream, "# of free fastbin blocks (smblks):     %" SWITCH_SIZE_T_FMT "\n", mi.smblks);
        stream->write_function(stream, "# of mapped regions (hblks):           %" SWITCH_SIZE_T_FMT "\n", mi.hblks);
        stream->write_function(stream, "Bytes in mapped regions (hblkhd):      %" SWITCH_SIZE_T_FMT "\n", mi.hblkhd);
        stream->write_function(stream, "Max. total allocated space (usmblks):  %" SWITCH_SIZE_T_FMT "\n", mi.usmblks);
        stream->write_function(stream, "Free bytes held in fastbins (fsmblks): %" SWITCH_SIZE_T_FMT "\n", mi.fsmblks);
        stream->write_function(stream, "Total allocated space (uordblks):      %" SWITCH_SIZE_T_FMT "\n", mi.uordblks);
        stream->write_function(stream, "Total free space (fordblks):           %" SWITCH_SIZE_T_FMT "\n", mi.fordblks);
        stream->write_function(stream, "Topmost releasable block (keepcost):   %" SWITCH_SIZE_T_FMT "\n", mi.keepcost);
#else
        struct mallinfo mi;

        mi = mallinfo();

        stream->write_function(stream, "Total non-mmapped bytes (arena):       %u\n", mi.arena);
        stream->write_function(stream, "# of free chunks (ordblks):            %u\n", mi.ordblks);
        stream->write_function(stream, "# of free fastbin blocks (smblks):     %u\n", mi.smblks);
        stream->write_function(stream, "# of mapped regions (hblks):           %u\n", mi.hblks);
        stream->write_function(stream, "Bytes in mapped regions (hblkhd):      %u\n", mi.hblkhd);
        stream->write_function(stream, "Max. total allocated space (usmblks):  %u\n", mi.usmblks);
        stream->write_function(stream, "Free bytes held in fastbins (fsmblks): %u\n", mi.fsmblks);
        stream->write_function(stream, "Total allocated space (uordblks):      %u\n", mi.uordblks);
        stream->write_function(stream, "Total free space (fordblks):           %u\n", mi.fordblks);
        stream->write_function(stream, "Topmost releasable block (keepcost):   %u\n", mi.keepcost);

#endif

        switch_goto_status(NULL, done);
#else
#ifdef WIN32
        /* Based on: https://docs.microsoft.com/en-us/windows/win32/memory/enumerating-a-heap and https://docs.microsoft.com/en-us/windows/win32/memory/getting-process-heaps */
        PHANDLE aHeaps;
        SIZE_T BytesToAllocate;
        DWORD HeapsIndex;
        DWORD HeapsLength;
        DWORD NumberOfHeaps;
        HRESULT Result;
        HANDLE hDefaultProcessHeap;
        size_t CommittedSizeTotal = 0;
        size_t UnCommittedSizeTotal = 0;
        size_t SizeTotal = 0;
        size_t OverheadTotal = 0;

        NumberOfHeaps = GetProcessHeaps(0, NULL);
        Result = SIZETMult(NumberOfHeaps, sizeof(*aHeaps), &BytesToAllocate);
        if (Result != S_OK) {
                switch_goto_status("SIZETMult failed.", done);
        }

        hDefaultProcessHeap = GetProcessHeap();
        if (hDefaultProcessHeap == NULL) {
                switch_goto_status("Failed to retrieve the default process heap", done);
        }

        aHeaps = (PHANDLE)HeapAlloc(hDefaultProcessHeap, 0, BytesToAllocate);
        if (aHeaps == NULL) {
                switch_goto_status("HeapAlloc failed to allocate space for heaps", done);
        }

        HeapsLength = NumberOfHeaps;
        NumberOfHeaps = GetProcessHeaps(HeapsLength, aHeaps);

        if (NumberOfHeaps == 0) {
                switch_goto_status("Failed to retrieve heaps", cleanup);
        } else if (NumberOfHeaps > HeapsLength) {
                /*
                 * Compare the latest number of heaps with the original number of heaps.
                 * If the latest number is larger than the original number, another
                 * component has created a new heap and the buffer is too small.
                 */
                switch_goto_status("Another component created a heap between calls.", cleanup);
        }

        stream->write_function(stream, "Process has %d heaps.\n", HeapsLength);
        for (HeapsIndex = 0; HeapsIndex < HeapsLength; ++HeapsIndex) {
                PROCESS_HEAP_ENTRY Entry;
                HANDLE hHeap = aHeaps[HeapsIndex];

                stream->write_function(stream, "Heap %d at address: %#p.\n", HeapsIndex, aHeaps[HeapsIndex]);

                /* Lock the heap to prevent other threads from accessing the heap during enumeration. */
                if (HeapLock(hHeap) == FALSE) {
                        switch_goto_status("Failed to lock heap.", cleanup);
                }

                Entry.lpData = NULL;
                while (HeapWalk(hHeap, &Entry) != FALSE) {
                        if ((Entry.wFlags & PROCESS_HEAP_ENTRY_BUSY) != 0) {
                        } else if ((Entry.wFlags & PROCESS_HEAP_REGION) != 0) {
                                CommittedSizeTotal += Entry.Region.dwCommittedSize;
                                UnCommittedSizeTotal += Entry.Region.dwUnCommittedSize;
                        }

                        SizeTotal += Entry.cbData;
                        OverheadTotal += Entry.cbOverhead;
                }

                /* Unlock the heap to allow other threads to access the heap after enumeration has completed. */
                if (HeapUnlock(hHeap) == FALSE) {
                        abort();
                }
        }

        stream->write_function(stream, "Committed bytes:   %" SWITCH_SIZE_T_FMT "\n", CommittedSizeTotal);
        stream->write_function(stream, "Uncommited bytes:  %" SWITCH_SIZE_T_FMT "\n", UnCommittedSizeTotal);
        stream->write_function(stream, "Size:              %" SWITCH_SIZE_T_FMT "\n", SizeTotal);
        stream->write_function(stream, "Overhead:          %" SWITCH_SIZE_T_FMT"\n", OverheadTotal);

cleanup:
        HeapFree(hDefaultProcessHeap, 0, aHeaps);
#else
        switch_goto_status("Memory usage statistics is not implemented on the current platform.", done);
#endif
#endif
done:
        return status;
}

switch_must_strdup()

char* switch_must_strdup

(

const char *

_s

)

Definition at line 4803 of file switch_utils.c.

References switch_assert.

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

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

switch_network_ipv4_mapped_ipv6_addr()

char* switch_network_ipv4_mapped_ipv6_addr

(

const char *

ip_str

)

Definition at line 582 of file switch_utils.c.

Referenced by switch_check_network_list_ip_port_token(), and switch_network_list_perform_add_cidr_token().

{
        /* ipv4 mapped ipv6 address */

        if (strncasecmp(ip_str, "::ffff:", 7)) {
                return NULL;
        }

        return strdup(ip_str + 7);
}

switch_network_list_add_cidr_port_token()

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

Definition at line 675 of file switch_utils.c.

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

Referenced by switch_load_network_lists(), and switch_network_list_add_cidr_token().

{
        char *cidr_str_dup = NULL;
        switch_status_t status = SWITCH_STATUS_SUCCESS;

        if (strchr(cidr_str, ',')) {
                char *argv[32] = { 0 };
                int i, argc;
                cidr_str_dup = strdup(cidr_str);

                switch_assert(cidr_str_dup);
                if ((argc = switch_separate_string(cidr_str_dup, ',', argv, (sizeof(argv) / sizeof(argv[0]))))) {
                        for (i = 0; i < argc; i++) {
                                switch_status_t this_status;
                                if ((this_status = switch_network_list_perform_add_cidr_token(list, argv[i], ok, token, port)) != SWITCH_STATUS_SUCCESS) {
                                        status = this_status;
                                }
                        }
                }
        } else {
                status = switch_network_list_perform_add_cidr_token(list, cidr_str, ok, token, port);
        }

        switch_safe_free(cidr_str_dup);
        return status;
}

switch_network_list_add_cidr_token()

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

Definition at line 702 of file switch_utils.c.

References switch_network_list_add_cidr_port_token().

Referenced by switch_load_network_lists(), and switch_parse_audio_col().

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

switch_network_list_add_host_mask()

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

Definition at line 737 of file switch_utils.c.

References switch_network_list_add_host_port_mask().

Referenced by switch_load_network_lists().

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

switch_network_list_add_host_port_mask()

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

Definition at line 707 of file switch_utils.c.

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

Referenced by switch_load_network_lists(), and switch_network_list_add_host_mask().

{
        ip_t ip, mask;
        switch_network_node_t *node;

        switch_inet_pton(AF_INET, host, &ip);
        switch_inet_pton(AF_INET, mask_str, &mask);

        node = switch_core_alloc(list->pool, sizeof(*node));

        node->ip.v4 = ntohl(ip.v4);
        node->mask.v4 = ntohl(mask.v4);
        node->ok = ok;
        if(port) {
                memcpy(&node->port_range, port, sizeof(switch_network_port_range_t));
        }

        /* http://graphics.stanford.edu/~seander/bithacks.html */
        mask.v4 = mask.v4 - ((mask.v4 >> 1) & 0x55555555);
        mask.v4 = (mask.v4 & 0x33333333) + ((mask.v4 >> 2) & 0x33333333);
        node->bits = (((mask.v4 + (mask.v4 >> 4)) & 0xF0F0F0F) * 0x1010101) >> 24;

        node->str = switch_core_sprintf(list->pool, "%s:%s", host, mask_str);

        node->next = list->node_head;
        list->node_head = node;

        return SWITCH_STATUS_SUCCESS;
}

switch_network_list_create()

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

Definition at line 459 of file switch_utils.c.

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

Referenced by switch_load_network_lists(), and switch_parse_audio_col().

{
        switch_network_list_t *new_list;

        if (!pool) {
                switch_core_new_memory_pool(&pool);
        }

        new_list = switch_core_alloc(pool, sizeof(**list));
        new_list->pool = pool;
        new_list->default_type = default_type;
        new_list->name = switch_core_strdup(new_list->pool, name);

        *list = new_list;

        return SWITCH_STATUS_SUCCESS;
}

switch_network_list_perform_add_cidr_token()

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

Definition at line 619 of file switch_utils.c.

References switch_network_node::bits, switch_network_node::family, switch_network_node::ip, switch_network_node::mask, switch_network_list::name, switch_network_node::next, switch_network_list::node_head, switch_network_node::ok, switch_network_list::pool, switch_network_node::port_range, switch_network_node::str, SWITCH_CHANNEL_LOG, switch_core_alloc, switch_core_strdup, SWITCH_LOG_ERROR, SWITCH_LOG_NOTICE, switch_log_printf(), switch_network_ipv4_mapped_ipv6_addr(), switch_network_port_range_to_string(), switch_parse_cidr(), switch_safe_free, SWITCH_STATUS_GENERR, SWITCH_STATUS_SUCCESS, switch_str_nil, switch_network_node::token, and zstr.

Referenced by switch_network_list_add_cidr_port_token().

{
        ip_t ip, mask;
        uint32_t bits;
        switch_network_node_t *node;
        char *ipv4 = NULL;
        char *ports = NULL;

        if ((ipv4 = switch_network_ipv4_mapped_ipv6_addr(cidr_str))) {
                cidr_str = ipv4;
        }

        ports = switch_network_port_range_to_string(port);

        if (switch_parse_cidr(cidr_str, &ip, &mask, &bits)) {
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error Adding %s %s(%s) [%s] to list %s\n",
                                                  cidr_str, ports ? ports : "", ok ? "allow" : "deny", switch_str_nil(token), list->name);
                switch_safe_free(ipv4);
                switch_safe_free(ports);
                return SWITCH_STATUS_GENERR;
        }

        node = switch_core_alloc(list->pool, sizeof(*node));

        node->ip = ip;
        node->mask = mask;
        node->ok = ok;
        node->bits = bits;
        node->str = switch_core_strdup(list->pool, cidr_str);
        if(port) {
                memcpy(&node->port_range, port, sizeof(switch_network_port_range_t));
        }


        if (strchr(cidr_str,':')) {
                node->family = AF_INET6;
        } else {
                node->family = AF_INET;
        }

        if (!zstr(token)) {
                node->token = switch_core_strdup(list->pool, token);
        }

        node->next = list->node_head;
        list->node_head = node;

        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "Adding %s %s(%s) [%s] to list %s\n",
                                          cidr_str, ports ? ports : "", ok ? "allow" : "deny", switch_str_nil(token), list->name);

        switch_safe_free(ipv4);
        switch_safe_free(ports);
        return SWITCH_STATUS_SUCCESS;
}

switch_network_list_validate_ip6_port_token()

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

Definition at line 497 of file switch_utils.c.

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

Referenced by switch_check_network_list_ip_port_token(), and switch_network_list_validate_ip6_token().

{
        switch_network_node_t *node;
        switch_bool_t ok = list->default_type;
        uint32_t bits = 0;

        for (node = list->node_head; node; node = node->next) {
                if (node->family == AF_INET) continue;

                if (node->bits >= bits && switch_testv6_subnet(ip, node->ip, node->mask)) {
                        if (node->ok) {
                                ok = SWITCH_TRUE;
                        } else {
                                ok = SWITCH_FALSE;
                        }

                        bits = node->bits;

                        if (token) {
                                *token = node->token;
                        }
                }
        }

        return ok;
}

switch_network_list_validate_ip6_token()

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

Definition at line 572 of file switch_utils.c.

References switch_network_list_validate_ip6_port_token().

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

switch_network_list_validate_ip_port_token()

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

Definition at line 546 of file switch_utils.c.

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

Referenced by switch_check_network_list_ip_port_token(), and switch_network_list_validate_ip_token().

{
        switch_network_node_t *node;
        switch_bool_t ok = list->default_type;
        uint32_t bits = 0;

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

                        bits = node->bits;

                        if (token) {
                                *token = node->token;
                        }
                }
        }

        return ok;
}

switch_network_list_validate_ip_token()

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

Definition at line 577 of file switch_utils.c.

References switch_network_list_validate_ip_port_token().

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

switch_network_port_range_to_string()

char* switch_network_port_range_to_string

(

switch_network_port_range_p

port

)

Definition at line 593 of file switch_utils.c.

References buf, MAX_NETWORK_PORTS, switch_network_port_range::max_port, switch_network_port_range::min_port, switch_network_port_range::port, switch_network_port_range::ports, and switch_mprintf().

Referenced by switch_network_list_perform_add_cidr_token().

{
        if (!port) {
                return NULL;
        }

        if (port->port != 0) {
                return switch_mprintf("port: %i ", port->port);
        }

        if (port->ports[0] != 0) {
                int i, written = 0;
                char buf[MAX_NETWORK_PORTS * 6];
            for (i = 0; i < MAX_NETWORK_PORTS && port->ports[i] != 0; i++) {
                written += snprintf(buf + written, sizeof(buf) - written, (i != 0 ? ", %u" : "%u"), port->ports[i]);
            }
                return switch_mprintf("ports: [%s] ", buf);
        }

        if (port->min_port != 0 || port->max_port != 0) {
                return switch_mprintf("port range: [%i-%i] ", port->min_port, port->max_port);
        }

        return NULL;
}

switch_number_cmp()

int switch_number_cmp	(	const char *	exp,
		int	val
	)

Definition at line 4133 of file switch_utils.c.

References b.

Referenced by switch_xml_std_datetime_check().

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

switch_parse_cidr()

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

Definition at line 743 of file switch_utils.c.

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

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

{
        char host[128];
        char *bit_str;
        int32_t bits;
        const char *ipv6;
        ip_t *maskv = mask;
        ip_t *ipv = ip;

        switch_copy_string(host, string, sizeof(host) - 1);
        bit_str = strchr(host, '/');

        if (!bit_str) {
                return -1;
        }

        *bit_str++ = '\0';
        bits = atoi(bit_str);
        ipv6 = strchr(string, ':');
        if (ipv6) {
                int32_t i, n;
                uint32_t k;

                if (bits < 0 || bits > 128) {
                        return -2;
                }

                bits = atoi(bit_str);
                switch_inet_pton(AF_INET6, host, (unsigned char *)ip);

                for (n = bits, i = 0; i < 16; i++) {
                        k = (n > 8) ? 8 : n;
                        maskv->v6.s6_addr[i] = 0xFF & ~(0xFF >> k);     /* k = 0 gives 0x00, k = 8 gives 0xFF */
                        n -= k;
                }
        } else {
                if (bits < 0 || bits > 32) {
                        return -2;
                }

                bits = atoi(bit_str);
                switch_inet_pton(AF_INET, host, (unsigned char *)ip);
                ipv->v4 = htonl(ipv->v4);

                maskv->v4 = 0xFFFFFFFF & ~(0xFFFFFFFF >> bits);
        }

        *bitp = bits;

        return 0;
}

switch_pool_strip_whitespace()

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

Definition at line 1439 of file switch_utils.c.

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

{
        const char *sp = str;
        char *p, *s = NULL;
        size_t len;

        if (zstr(sp)) {
                return switch_core_strdup(pool, SWITCH_BLANK_STRING);
        }

        while ((*sp == 13 ) || (*sp == 10 ) || (*sp == 9 ) || (*sp == 32) || (*sp == 11) ) {
                sp++;
        }

        if (zstr(sp)) {
                return switch_core_strdup(pool, SWITCH_BLANK_STRING);
        }

        s = switch_core_strdup(pool, sp);
        switch_assert(s);

        if ((len = strlen(s)) > 0) {
                p = s + (len - 1);

                while ((p >= s) && ((*p == 13 ) || (*p == 10 ) || (*p == 9 ) || (*p == 32) || (*p == 11))) {
                        *p-- = '\0';
                }
        }

        return s;
}

switch_print_host()

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

Definition at line 98 of file switch_utils.c.

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

{
        switch_port_t port;

        switch_get_addr(buf, len, addr);
        port = switch_sockaddr_get_port(addr);

        snprintf(buf + strlen(buf), len - strlen(buf), ":%d", port);
        return buf;
}

switch_priority_name()

const char* switch_priority_name

(

switch_priority_t

priority

)

Return a printable name of a switch_priority_t.

Parameters

priority

the priority to get the name of

Returns

the printable form of the priority

Definition at line 2173 of file switch_utils.c.

References SWITCH_PRIORITY_HIGH, SWITCH_PRIORITY_LOW, and SWITCH_PRIORITY_NORMAL.

Referenced by switch_errno_is_break(), and switch_event_set_priority().

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

switch_replace_char()

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

Definition at line 1419 of file switch_utils.c.

References switch_network_node::str, switch_assert, and to.

{
        char *p;

        if (dup) {
                p = strdup(str);
                switch_assert(p);
        } else {
                p = str;
        }

        for (; p && *p; p++) {
                if (*p == from) {
                        *p = to;
                }
        }

        return p;
}

switch_resolve_host()

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

Definition at line 1841 of file switch_utils.c.

References get_addr(), SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

Referenced by check_ice(), and switch_false().

{

        struct addrinfo *ai;

        if (getaddrinfo(host, 0, 0, &ai)) {
                return SWITCH_STATUS_FALSE;
        }

        get_addr(buf, buflen, ai->ai_addr, sizeof(struct sockaddr_storage));

        freeaddrinfo(ai);

        return SWITCH_STATUS_SUCCESS;
}

switch_rfc2833_to_char()

char switch_rfc2833_to_char

(

int

event

)

Return the RFC2833 character based on an event id.

Parameters

event

the event id to convert

Returns

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

Definition at line 2548 of file switch_utils.c.

References RFC2833_CHARS.

Referenced by handle_rfc2833(), and switch_errno_is_break().

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

switch_separate_paren_args()

char* switch_separate_paren_args

(

char *

str

)

Definition at line 1582 of file switch_utils.c.

Referenced by switch_ivr_phrase_macro_event().

{
        char *e, *args;
        switch_size_t br;

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

        return args;
}

switch_separate_string()

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

Definition at line 2857 of file switch_utils.c.

References memset(), separate_string_blank_delim(), and separate_string_char_delim().

Referenced by clean_uri(), switch_http_parse_header(), and switch_network_list_add_cidr_port_token().

{
        if (!buf || !array || !arraylen) {
                return 0;
        }


        if (*buf == '^' && *(buf+1) == '^') {
                char *p = buf + 2;

                if (*p && *(p+1)) {
                        buf = p;
                        delim = *buf++;
                }
        }


        memset(array, 0, arraylen * sizeof(*array));

        return (delim == ' ' ? separate_string_blank_delim(buf, array, arraylen) : separate_string_char_delim(buf, delim, array, arraylen));
}

switch_separate_string_cheap()

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

Definition at line 2982 of file switch_utils.c.

References memset(), separate_string_blank_delim_cheap(), and separate_string_char_delim_cheap().

{
        if (!buf || !array || !arraylen) {
                return 0;
        }


        if (*buf == '^' && *(buf+1) == '^') {
                const char *p = buf + 2;

                if (*p && *(p+1)) {
                        buf = p;
                        delim = *buf++;
                }
        }


        memset(array, 0, arraylen * sizeof(*array));

        return (delim == ' ' ? separate_string_blank_delim_cheap(buf, array, larray, arraylen) : separate_string_char_delim_cheap(buf, delim, array, larray, arraylen));
}

switch_separate_string_string()

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

Definition at line 2734 of file switch_utils.c.

References buf, and count.

{
        unsigned int count = 0;
        char *d;
        size_t dlen = strlen(delim);

        array[count++] = buf;

        while (count < arraylen && array[count - 1]) {
                if ((d = strstr(array[count - 1], delim))) {
                        *d = '\0';
                        d += dlen;
                        array[count++] = d;
                } else
                        break;
        }

        return count;
}

switch_simple_email()

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

Definition at line 1117 of file switch_utils.c.

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

Referenced by email(), and switch_needs_url_encode().

{
        char *bound = "XXXX_boundary_XXXX";
        const char *mime_type = "audio/inline";
        char filename[80], buf[B64BUFFLEN];
        int fd = -1, ifd = -1;
        int x = 0, y = 0, bytes = 0, ilen = 0;
        unsigned int b = 0, l = 0;
        unsigned char in[B64BUFFLEN];
        unsigned char out[B64BUFFLEN + 512];
        char *dupfile = NULL, *ext = NULL;
        char *newfile = NULL;
        switch_bool_t rval = SWITCH_FALSE;
        const char *err = NULL;

        filename[0] = '\0';

        if (zstr(to)) {
                err = "No to address specified";
                goto end;
        }

        if (!zstr(file) && !zstr(convert_cmd) && !zstr(convert_ext)) {
                if (strrchr(file, '.')) {
                        dupfile = strdup(file);
                        if ((ext = strrchr(dupfile, '.'))) {
                                *ext++ = '\0';
                                newfile = switch_mprintf("%s.%s", dupfile, convert_ext);
                        }
                }

                if (newfile) {
                        char cmd[1024] = "";
                        switch_snprintf(cmd, sizeof(cmd), "%s %s %s", convert_cmd, file, newfile);
                        switch_system(cmd, SWITCH_TRUE);
                        if (strcmp(file, newfile)) {
                                file = newfile;
                        } else {
                                switch_safe_free(newfile);
                        }
                }

                switch_safe_free(dupfile);
        }

        switch_snprintf(filename, 80, "%s%smail.%d%04x", SWITCH_GLOBAL_dirs.temp_dir, SWITCH_PATH_SEPARATOR, (int)(switch_time_t) switch_epoch_time_now(NULL), rand() & 0xffff);

        if ((fd = open(filename, O_WRONLY | O_CREAT | O_TRUNC, 0644)) > -1) {
                if (file) {
                        if ((ifd = open(file, O_RDONLY | O_BINARY)) < 0) {
                                rval = SWITCH_FALSE;
                                err = "Cannot open tmp file\n";
                                goto end;
                        }
                }

                if (!file && (!body || !switch_stristr("content-type", body))) {
                        bound = NULL;
                }

                if (bound) {
                        switch_snprintf(buf, B64BUFFLEN, "MIME-Version: 1.0\nContent-Type: multipart/mixed; boundary=\"%s\"\n", bound);
                        if (!write_buf(fd, buf)) {
                                rval = SWITCH_FALSE;
                                err = "write error.";
                                goto end;
                        }
                }

                if (headers && !write_buf(fd, headers)) {
                        rval = SWITCH_FALSE;
                        err = "write error.";
                        goto end;
                }

                if (!write_buf(fd, "\n\n")) {
                        rval = SWITCH_FALSE;
                        err = "write error.";
                        goto end;
                }

                if (bound) {
                        if (body && switch_stristr("content-type", body)) {
                                switch_snprintf(buf, B64BUFFLEN, "--%s\n", bound);
                        } else {
                                switch_snprintf(buf, B64BUFFLEN, "--%s\nContent-Type: text/plain\n\n", bound);
                        }
                        if (!write_buf(fd, buf)) {
                                rval = SWITCH_FALSE;
                                err = "write error.";
                                goto end;
                        }
                }

                if (body) {
                        if (!write_buf(fd, body)) {
                                rval = SWITCH_FALSE;
                                err = "write error.";
                                goto end;
                        }
                }

                if (file && bound) {
                        const char *stipped_file = switch_cut_path(file);
                        const char *new_type;
                        char *ext;

                        if ((ext = strrchr(stipped_file, '.'))) {
                                ext++;
                                if ((new_type = switch_core_mime_ext2type(ext))) {
                                        mime_type = new_type;
                                }
                        }

                        switch_snprintf(buf, B64BUFFLEN,
                                                        "\n\n--%s\nContent-Type: %s; name=\"%s\"\n"
                                                        "Content-ID: <ATTACHED@freeswitch.org>\n"
                                                        "Content-Transfer-Encoding: base64\n"
                                                        "Content-Description: Sound attachment.\n"
                                                        "Content-Disposition: attachment; filename=\"%s\"\n\n", bound, mime_type, stipped_file, stipped_file);
                        if (!write_buf(fd, buf)) {
                                rval = SWITCH_FALSE;
                                err = "write error.";
                                goto end;
                        }

                        while ((ilen = read(ifd, in, B64BUFFLEN))) {
                                for (x = 0; x < ilen; x++) {
                                        b = (b << 8) + in[x];
                                        l += 8;
                                        while (l >= 6) {
                                                out[bytes++] = switch_b64_table[(b >> (l -= 6)) % 64];
                                                if (++y != 72)
                                                        continue;
                                                out[bytes++] = '\n';
                                                y = 0;
                                        }
                                }
                                if (write(fd, &out, bytes) != bytes) {
                                        rval = -1;
                                        break;
                                } else {
                                        bytes = 0;
                                }

                        }

                        if (l > 0) {
                                out[bytes++] = switch_b64_table[((b % 16) << (6 - l)) % 64];
                        }
                        if (l != 0)
                                while (l < 6) {
                                        out[bytes++] = '=', l += 2;
                                }
                        if (write(fd, &out, bytes) != bytes) {
                                rval = -1;
                        }

                }

                if (bound) {
                        switch_snprintf(buf, B64BUFFLEN, "\n\n--%s--\n.\n", bound);

                        if (!write_buf(fd, buf)) {
                                rval = SWITCH_FALSE;
                                err = "write error.";
                                goto end;
                        }
                }
        }

        if (fd > -1) {
                close(fd);
                fd = -1;
        }

        if (zstr(from)) {
                from = "freeswitch";
        }

        {
                char *to_arg = switch_util_quote_shell_arg(to);
                char *from_arg = switch_util_quote_shell_arg(from);
#ifdef WIN32
                switch_snprintf(buf, B64BUFFLEN, "\"\"%s\" -f %s %s %s < \"%s\"\"", runtime.mailer_app, from_arg, runtime.mailer_app_args, to_arg, filename);
#else
                switch_snprintf(buf, B64BUFFLEN, "/bin/cat %s | %s -f %s %s %s", filename, runtime.mailer_app, from_arg, runtime.mailer_app_args, to_arg);
#endif
                switch_safe_free(to_arg); switch_safe_free(from_arg);
        }
        if (switch_system(buf, SWITCH_TRUE) < 0) {
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Unable to execute command: %s\n", buf);
                err = "execute error";
                rval = SWITCH_FALSE;
        }

        if (zstr(err)) {
                if (file) {
                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Emailed file [%s] to [%s]\n", filename, to);
                } else {
                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Emailed data to [%s]\n", to);
                }

                rval = SWITCH_TRUE;
        }

  end:

        if (fd > -1) {
                close(fd);
        }

        if (!zstr_buf(filename) && unlink(filename) != 0) {
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "Failed to delete file [%s]\n", filename);
        }

        if (ifd > -1) {
                close(ifd);
        }


        if (newfile) {
                unlink(newfile);
                free(newfile);
        }

        if (rval != SWITCH_TRUE) {
                if (zstr(err)) err = "Unknown Error";

                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "EMAIL NOT SENT, error [%s]\n", err);
        }

        return rval;
}

switch_socket_waitfor()

int switch_socket_waitfor	(	switch_pollfd_t *	poll,
		int	ms
	)

Wait for a socket.

Parameters

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

Returns

the requested condition

Definition at line 3541 of file switch_utils.c.

References switch_poll().

{
        int nsds = 0;

        switch_poll(poll, 1, &nsds, ms);

        return nsds;
}

switch_split_date()

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

Definition at line 3708 of file switch_utils.c.

References switch_assert, and switch_safe_free.

{
        char *dup = strdup(exp);
        char *syear = NULL;
        char *smonth = NULL;
        char *sday = NULL;

        switch_assert(dup);

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

}

switch_split_time()

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

Definition at line 3675 of file switch_utils.c.

References switch_assert, and switch_safe_free.

{
        char *dup = strdup(exp);
        char *shour = NULL;
        char *smin = NULL;
        char *ssec = NULL;

        switch_assert(dup);

        shour = dup;
        if ((smin=strchr(dup, ':'))) {
                *smin++ = '\0';
                if ((ssec=strchr(smin, ':'))) {
                        *ssec++ = '\0';
                } else {
                        ssec = "00";
                }
                if (hour) {
                        *hour = atol(shour);
                }
                if (min) {
                        *min = atol(smin);
                }
                if (sec) {
                        *sec = atol(ssec);
                }

        }
        switch_safe_free(dup);
        return;

}

switch_split_user_domain()

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

Split a user string as user and domain.

Parameters

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

Returns

1 if successfull

Note

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

Definition at line 4216 of file switch_utils.c.

References in.

{
        char *p = NULL, *h = NULL, *u = NULL;

        if (!in) return 0;

        /* Remove URL scheme */
        if (!strncasecmp(in, "sip:", 4)) in += 4;
        else if (!strncasecmp(in, "sips:", 5)) in += 5;

        /* Isolate the host part from the user part */
        if ((h = in, p = strchr(h, '@'))) *p = '\0', u = in, h = p+1;

        /* Clean out the host part of any suffix */
        for (p = h; *p; p++)
                if (*p == ':' || *p == ';' || *p == ' ') {
                        *p = '\0'; break;
                }

        if (user) *user = u;
        if (domain) *domain = h;
        return 1;
}

switch_str_time()

switch_time_t switch_str_time

(

const char *

in

)

Converts a string representation of a date into a switch_time_t.

Parameters

in	the string

Returns

the epoch time in usec

Definition at line 2083 of file switch_utils.c.

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

Referenced by switch_fulldate_cmp().

{
        switch_time_exp_t tm = { 0 }, local_tm = { 0 };
        int proceed = 0, ovector[30], time_only = 0;
        switch_regex_t *re = NULL;
        char replace[1024] = "";
        switch_time_t ret = 0, local_time = 0;
        char *pattern = "^(\\d+)-(\\d+)-(\\d+)\\s*(\\d*):{0,1}(\\d*):{0,1}(\\d*)";
        char *pattern2 = "^(\\d{4})(\\d{2})(\\d{2})(\\d{2})(\\d{2})(\\d{2})";
        char *pattern3 = "^(\\d*):{0,1}(\\d*):{0,1}(\\d*)$";

        switch_time_exp_lt(&tm, switch_micro_time_now());


        if ((time_only = switch_regex_perform(in, pattern3, &re, ovector, sizeof(ovector) / sizeof(ovector[0])))) {
                tm.tm_hour = 0;
                tm.tm_min = 0;
                tm.tm_sec = 0;
        } else {
                tm.tm_year = tm.tm_mon = tm.tm_mday = tm.tm_hour = tm.tm_min = tm.tm_sec = tm.tm_usec = 0;

                if (!(proceed = switch_regex_perform(in, pattern, &re, ovector, sizeof(ovector) / sizeof(ovector[0])))) {
                        switch_regex_safe_free(re);
                        proceed = switch_regex_perform(in, pattern2, &re, ovector, sizeof(ovector) / sizeof(ovector[0]));
                }
        }

        if (proceed || time_only) {

                if (time_only > 1) {
                        switch_regex_copy_substring(in, ovector, time_only, 1, replace, sizeof(replace));
                        tm.tm_hour = atoi(replace);
                }

                if (time_only > 2) {
                        switch_regex_copy_substring(in, ovector, time_only, 2, replace, sizeof(replace));
                        tm.tm_min = atoi(replace);
                }

                if (time_only > 3) {
                        switch_regex_copy_substring(in, ovector, time_only, 3, replace, sizeof(replace));
                        tm.tm_sec = atoi(replace);
                }

                if (proceed > 1) {
                        switch_regex_copy_substring(in, ovector, proceed, 1, replace, sizeof(replace));
                        tm.tm_year = atoi(replace) - 1900;
                }

                if (proceed > 2) {
                        switch_regex_copy_substring(in, ovector, proceed, 2, replace, sizeof(replace));
                        tm.tm_mon = atoi(replace) - 1;
                }

                if (proceed > 3) {
                        switch_regex_copy_substring(in, ovector, proceed, 3, replace, sizeof(replace));
                        tm.tm_mday = atoi(replace);
                }

                if (proceed > 4) {
                        switch_regex_copy_substring(in, ovector, proceed, 4, replace, sizeof(replace));
                        tm.tm_hour = atoi(replace);
                }

                if (proceed > 5) {
                        switch_regex_copy_substring(in, ovector, proceed, 5, replace, sizeof(replace));
                        tm.tm_min = atoi(replace);
                }

                if (proceed > 6) {
                        switch_regex_copy_substring(in, ovector, proceed, 6, replace, sizeof(replace));
                        tm.tm_sec = atoi(replace);
                }
                
                switch_regex_safe_free(re);

                switch_time_exp_get(&local_time, &tm);
                switch_time_exp_lt(&local_tm, local_time);
                tm.tm_isdst = local_tm.tm_isdst;
                tm.tm_gmtoff = local_tm.tm_gmtoff;

                switch_time_exp_gmt_get(&ret, &tm);
                return ret;
        }

        switch_regex_safe_free(re);

        return ret;
}

switch_strcasecmp_any()

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

Definition at line 394 of file switch_utils.c.

{
        va_list ap;
        const char *next_str = 0;
        int r = 0;

        va_start(ap, str);

        while ((next_str = va_arg(ap, const char *))) {
                if (!strcasecmp(str, next_str)) {
                        r = 1;
                        break;
                }
        }

        va_end(ap);

        return r;
}

switch_strerror_r()

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

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

Parameters

[in]	errnum	Error number

Definition at line 4308 of file switch_utils.c.

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

Referenced by reincarnate_protect(), and rtp_common_read().

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

switch_string_match()

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

Definition at line 3024 of file switch_utils.c.

References SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

Referenced by switch_string_replace().

{
        size_t i;

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

        if (i == search_len) {
                return SWITCH_STATUS_SUCCESS;
        }

        return SWITCH_STATUS_FALSE;
}

switch_string_replace()

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

Definition at line 3041 of file switch_utils.c.

References switch_assert, SWITCH_STATUS_SUCCESS, and switch_string_match().

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

{
        size_t string_len = strlen(string);
        size_t search_len = strlen(search);
        size_t replace_len = strlen(replace);
        size_t i, n;
        size_t dest_len = 0;
        char *dest, *tmp;

        dest = (char *) malloc(sizeof(char));
        switch_assert(dest);

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

        dest[dest_len] = 0;
        return dest;
}

switch_strip_commas()

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

Definition at line 1539 of file switch_utils.c.

References in.

{
        char *p = in, *q = out;
        char *ret = out;
        switch_size_t x = 0;

        for (; p && *p; p++) {
                if ((*p > 47 && *p < 58)) {
                        *q++ = *p;

                        if (++x > len) {
                                ret = NULL;
                                break;
                        }
                } else if (*p != ',') {
                        ret = NULL;
                        break;
                }
        }

        return ret;
}

switch_strip_nonnumerics()

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

Definition at line 1562 of file switch_utils.c.

References in.

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

                        if (++x > len) {
                                ret = NULL;
                                break;
                        }
                }
        }

        return ret;
}

switch_strip_spaces()

char* switch_strip_spaces	(	char *	str,
		switch_bool_t	dup
	)

Definition at line 1503 of file switch_utils.c.

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

Referenced by switch_core_media_add_crypto().

{
        char *sp = str;
        char *p, *s = NULL;
        size_t len;

        if (zstr(sp)) {
                return dup ? strdup(SWITCH_BLANK_STRING) : sp;
        }

        while (*sp == ' ') {
                sp++;
        }

        if (dup) {
                s = strdup(sp);
                switch_assert(s);
        } else {
                s = sp;
        }

        if (zstr(s)) {
                return s;
        }

        if ((len = strlen(s)) > 0) {
                p = s + (len - 1);

                while (p && *p && (p >= s) && *p == ' ') {
                        *p-- = '\0';
                }
        }

        return s;
}

switch_strip_whitespace()

char* switch_strip_whitespace

(

const char *

str

)

Definition at line 1471 of file switch_utils.c.

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

Referenced by switch_api_execute().

{
        const char *sp = str;
        char *p, *s = NULL;
        size_t len;

        if (zstr(sp)) {
                return strdup(SWITCH_BLANK_STRING);
        }

        while ((*sp == 13 ) || (*sp == 10 ) || (*sp == 9 ) || (*sp == 32) || (*sp == 11) ) {
                sp++;
        }

        if (zstr(sp)) {
                return strdup(SWITCH_BLANK_STRING);
        }

        s = strdup(sp);
        switch_assert(s);

        if ((len = strlen(s)) > 0) {
                p = s + (len - 1);

                while ((p >= s) && ((*p == 13 ) || (*p == 10 ) || (*p == 9 ) || (*p == 32) || (*p == 11))) {
                        *p-- = '\0';
                }
        }

        return s;
}

switch_stristr()

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

Definition at line 1673 of file switch_utils.c.

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

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

{
/*
** Rev History:  16/07/97  Greg Thayer          Optimized
**               07/04/95  Bob Stout            ANSI-fy
**               02/03/94  Fred Cole            Original
**               09/01/03  Bob Stout            Bug fix (lines 40-41) per Fred Bulback
**
** Hereby donated to public domain.
*/
        const char *pptr, *sptr, *start;

        if (!str || !instr)
                return NULL;

        for (start = str; *start; start++) {
                /* find start of pattern in string */
                for (; ((*start) && (switch_toupper(*start) != switch_toupper(*instr))); start++);

                if (!*start)
                        return NULL;

                pptr = instr;
                sptr = start;

                while (switch_toupper(*sptr) == switch_toupper(*pptr)) {
                        sptr++;
                        pptr++;

                        /* if end of pattern then pattern was found */
                        if (!*pptr)
                                return (start);

                        if (!*sptr)
                                return NULL;
                }
        }
        return NULL;
}

switch_testv6_subnet()

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

Definition at line 483 of file switch_utils.c.

References IN6_AND_MASK, SWITCH_TRUE, and ip_t::v6.

Referenced by switch_check_network_list_ip_port_token(), and switch_network_list_validate_ip6_port_token().

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

switch_tod_cmp()

int switch_tod_cmp	(	const char *	exp,
		int	val
	)

Definition at line 4152 of file switch_utils.c.

References cur, switch_assert, and switch_safe_free.

Referenced by switch_xml_std_datetime_check().

{
        char *dup = strdup(exp);
        char *minh;
        char *minm;
        char *mins;
        char *maxh;
        char *maxm;
        char *maxs;
        char *cur;
        char *p;
        int range_start, range_end;

        switch_assert(dup);

        cur = dup;
        if ((p = strchr(cur, ','))) {
                *p++ = '\0';
        }

        while (cur) {
                minh = cur;
                if ((minm=strchr(cur, ':'))) {
                        *minm++ = '\0';
                        if ((maxh=strchr(minm, '-'))) {
                                if ((maxm=strchr(maxh, ':'))) {
                                        *maxh++ = '\0';
                                        *maxm++ = '\0';
                                        /* Check if min/max seconds are present */
                                        if ((mins=strchr(minm, ':'))) {
                                                *mins++ = '\0';
                                        } else {
                                                mins = "00";
                                        }
                                        if ((maxs=strchr(maxm, ':'))) {
                                                *maxs++ = '\0';
                                        } else {
                                                maxs = "00";
                                        }

                                        range_start = (atol(minh) * 60 * 60) + (atol(minm) * 60) + atol(mins);
                                        range_end = (atol(maxh) * 60 * 60) + (atol(maxm) * 60) + atol(maxs);
                                        if (range_start <= range_end ? (val >= range_start && val <= range_end) : (val >= range_start || val <= range_end)) {
                                                switch_safe_free(dup);
                                                return 1;
                                        }
                                }
                        }
                }

                cur = p;
                if (p) {
                        if ((p = strchr(p, ','))) {
                                *p++ = '\0';
                        }
                }

        }

        switch_safe_free(dup);
        return 0;

}

switch_url_decode()

char* switch_url_decode

(

char *

s

)

Definition at line 3654 of file switch_utils.c.

References zstr.

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

{
        char *o;
        unsigned int tmp;

        if (zstr(s) || !strchr(s, '%')) {
                return s;
        }

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

switch_url_encode()

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

Definition at line 3649 of file switch_utils.c.

References SWITCH_FALSE, and switch_url_encode_opt().

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

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

switch_url_encode_opt()

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

Definition at line 3604 of file switch_utils.c.

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

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

{
        const char *p, *e = end_of_p(url);
        size_t x = 0;
        const char hex[] = "0123456789ABCDEF";

        if (!buf) {
                return 0;
        }

        if (!url) {
                return 0;
        }

        len--;

        for (p = url; *p; p++) {
                int ok = 0;

                if (x >= len) {
                        break;
                }

                if (!double_encode && *p == '%' && e-p > 1) {
                        if (strchr(hex, *(p+1)) && strchr(hex, *(p+2))) {
                                ok = 1;
                        }
                }

                if (!ok && (*p < ' ' || *p > '~' || strchr(SWITCH_URL_UNSAFE, *p))) {
                        if ((x + 3) > len) {
                                break;
                        }
                        buf[x++] = '%';
                        buf[x++] = hex[(*p >> 4) & 0x0f];
                        buf[x++] = hex[*p & 0x0f];
                } else {
                        buf[x++] = *p;
                }
        }
        buf[x] = '\0';

        return buf;
}

switch_util_quote_shell_arg()

char* switch_util_quote_shell_arg

(

const char *

string

)

Quote shell argument.

Parameters

string

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

Definition at line 3076 of file switch_utils.c.

References switch_util_quote_shell_arg_pool().

Referenced by switch_simple_email().

{
        return switch_util_quote_shell_arg_pool(string, NULL);
}

switch_util_quote_shell_arg_pool()

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

Quote shell argument, allocating from pool if provided.

Parameters

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

Returns

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

Definition at line 3081 of file switch_utils.c.

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

Referenced by switch_util_quote_shell_arg().

{
        size_t string_len = strlen(string);
        size_t i;
        size_t n = 0;
        size_t dest_len = 0;
        char *dest;

        /* first pass through, figure out how large to make the allocation */
        dest_len = strlen(string) + 1; /* string + null */
        dest_len += 1; /* opening quote */
        for (i = 0; i < string_len; i++) {
                switch (string[i]) {
#ifndef WIN32
                case '\'':
                        /* We replace ' by sq backslace sq sq, so need 3 additional bytes */
                        dest_len += 3;
                        break;
#endif
                }
        }
        dest_len += 1; /* closing quote */

        /* if we're given a pool, allocate from it, otherwise use malloc */
        if (pool) {
                dest = switch_core_alloc(pool, sizeof(char) * dest_len);
        } else {
                dest = (char *) malloc(sizeof(char) * dest_len);
        }
        switch_assert(dest);

#ifdef WIN32
        dest[n++] = '"';
#else
        dest[n++] = '\'';
#endif

        for (i = 0; i < string_len; i++) {
                switch (string[i]) {
#ifdef WIN32
                case '"':
                case '%':
                        dest[n++] = ' ';
                        break;
#else
                case '\'':
                        /* We replace ' by sq backslash sq sq */
                        dest[n++] = '\'';
                        dest[n++] = '\\';
                        dest[n++] = '\'';
                        dest[n++] = '\'';
                        break;
#endif
                default:
                        dest[n++] = string[i];
                }
        }

#ifdef WIN32
        dest[n++] = '"';
#else
        dest[n++] = '\'';
#endif
        dest[n++] = 0;
        switch_assert(n == dest_len);
        return dest;
}

switch_uuid_str()

char* switch_uuid_str	(	char *	buf,
		switch_size_t	len
	)

Definition at line 4241 of file switch_utils.c.

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

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

{
        switch_uuid_t uuid;

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

        return buf;
}

switch_wait_sock()

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

Definition at line 3333 of file switch_utils.c.

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

Referenced by get_pmp_pubaddr(), and switch_util_quote_shell_arg_pool().

{
        int s = 0, r = 0;
        fd_set *rfds;
        fd_set *wfds;
        fd_set *efds;
        struct timeval tv;

        if (sock == SWITCH_SOCK_INVALID) {
                return SWITCH_SOCK_INVALID;
        }

        rfds = malloc(sizeof(fd_set));
        wfds = malloc(sizeof(fd_set));
        efds = malloc(sizeof(fd_set));

        FD_ZERO(rfds);
        FD_ZERO(wfds);
        FD_ZERO(efds);

#ifndef WIN32
        /* Wouldn't you rather know?? */
        assert(sock <= FD_SETSIZE);
#endif

        if ((flags & SWITCH_POLL_READ)) {

#ifdef WIN32
#pragma warning( push )
#pragma warning( disable : 4127 )
        FD_SET(sock, rfds);
#pragma warning( pop )
#else
        FD_SET(sock, rfds);
#endif
        }

        if ((flags & SWITCH_POLL_WRITE)) {

#ifdef WIN32
#pragma warning( push )
#pragma warning( disable : 4127 )
        FD_SET(sock, wfds);
#pragma warning( pop )
#else
        FD_SET(sock, wfds);
#endif
        }

        if ((flags & SWITCH_POLL_ERROR)) {

#ifdef WIN32
#pragma warning( push )
#pragma warning( disable : 4127 )
        FD_SET(sock, efds);
#pragma warning( pop )
#else
        FD_SET(sock, efds);
#endif
        }

        tv.tv_sec = ms / 1000;
        tv.tv_usec = (ms % 1000) * 1000;

        s = select(sock + 1, (flags & SWITCH_POLL_READ) ? rfds : NULL, (flags & SWITCH_POLL_WRITE) ? wfds : NULL, (flags & SWITCH_POLL_ERROR) ? efds : NULL, &tv);

        if (s < 0) {
                if (switch_errno_is_break(switch_errno())) {
                        s = 0;
                }
        }

        if (s < 0) {
                r = s;
        } else if (s > 0) {
                if ((flags & SWITCH_POLL_READ) && FD_ISSET(sock, rfds)) {
                        r |= SWITCH_POLL_READ;
                }

                if ((flags & SWITCH_POLL_WRITE) && FD_ISSET(sock, wfds)) {
                        r |= SWITCH_POLL_WRITE;
                }

                if ((flags & SWITCH_POLL_ERROR) && FD_ISSET(sock, efds)) {
                        r |= SWITCH_POLL_ERROR;
                }
        }

        free(rfds);
        free(wfds);
        free(efds);

        return r;

}

switch_wait_socklist()

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

Definition at line 3429 of file switch_utils.c.

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

Referenced by switch_util_quote_shell_arg_pool().

{
        int s = 0, r = 0;
        fd_set *rfds;
        fd_set *wfds;
        fd_set *efds;
        struct timeval tv;
        unsigned int i;
        switch_os_socket_t max_fd = 0;
        int flags = 0;

        rfds = malloc(sizeof(fd_set));
        wfds = malloc(sizeof(fd_set));
        efds = malloc(sizeof(fd_set));

        FD_ZERO(rfds);
        FD_ZERO(wfds);
        FD_ZERO(efds);

        for (i = 0; i < len; i++) {
                if (waitlist[i].sock == SWITCH_SOCK_INVALID) {
                        break;
                }

                if (waitlist[i].sock > max_fd) {
                        max_fd = waitlist[i].sock;
                }

#ifndef WIN32
                /* Wouldn't you rather know?? */
                assert(waitlist[i].sock <= FD_SETSIZE);
#endif
                flags |= waitlist[i].events;

                if ((waitlist[i].events & SWITCH_POLL_READ)) {

#ifdef WIN32
#pragma warning( push )
#pragma warning( disable : 4127 )
                        FD_SET(waitlist[i].sock, rfds);
#pragma warning( pop )
#else
                        FD_SET(waitlist[i].sock, rfds);
#endif
                }

                if ((waitlist[i].events & SWITCH_POLL_WRITE)) {

#ifdef WIN32
#pragma warning( push )
#pragma warning( disable : 4127 )
                        FD_SET(waitlist[i].sock, wfds);
#pragma warning( pop )
#else
                        FD_SET(waitlist[i].sock, wfds);
#endif
                }

                if ((waitlist[i].events & SWITCH_POLL_ERROR)) {

#ifdef WIN32
#pragma warning( push )
#pragma warning( disable : 4127 )
                        FD_SET(waitlist[i].sock, efds);
#pragma warning( pop )
#else
                        FD_SET(waitlist[i].sock, efds);
#endif
                }
        }

        tv.tv_sec = ms / 1000;
        tv.tv_usec = (ms % 1000) * 1000;

        s = select(max_fd + 1, (flags & SWITCH_POLL_READ) ? rfds : NULL, (flags & SWITCH_POLL_WRITE) ? wfds : NULL, (flags & SWITCH_POLL_ERROR) ? efds : NULL, &tv);

        if (s < 0) {
                if (switch_errno_is_break(switch_errno())) {
                        s = 0;
                }
        }

        if (s < 0) {
                r = s;
        } else if (s > 0) {
                for (i = 0; i < len; i++) {
                        if ((waitlist[i].events & SWITCH_POLL_READ) && FD_ISSET(waitlist[i].sock, rfds)) {
                                r |= SWITCH_POLL_READ;
                                waitlist[i].revents |= SWITCH_POLL_READ;
                        }

                        if ((waitlist[i].events & SWITCH_POLL_WRITE) && FD_ISSET(waitlist[i].sock, wfds)) {
                                r |= SWITCH_POLL_WRITE;
                                waitlist[i].revents |= SWITCH_POLL_WRITE;
                        }

                        if ((waitlist[i].events & SWITCH_POLL_ERROR) && FD_ISSET(waitlist[i].sock, efds)) {
                                r |= SWITCH_POLL_ERROR;
                                waitlist[i].revents |= SWITCH_POLL_ERROR;
                        }
                }
        }

        free(rfds);
        free(wfds);
        free(efds);

        return r;

}

unescape_char()

static char unescape_char ( char  escaped )

static

Definition at line 2619 of file switch_utils.c.

Referenced by cleanup_separated_string().

{
        char unescaped;

        switch (escaped) {
        case 'n':
                unescaped = '\n';
                break;
        case 'r':
                unescaped = '\r';
                break;
        case 't':
                unescaped = '\t';
                break;
        case 's':
                unescaped = ' ';
                break;
        default:
                unescaped = escaped;
        }
        return unescaped;
}

write_buf()

static int write_buf ( int  fd, const char *  buf  )

static

Definition at line 1105 of file switch_utils.c.

Referenced by switch_ivr_record_file_event(), and switch_simple_email().

{

        int len = (int) strlen(buf);
        if (fd && write(fd, buf, len) != len) {
                close(fd);
                return 0;
        }

        return 1;
}

Variable Documentation

_switch_C_ctype_

const int _switch_C_ctype_[1+SWITCH_CTYPE_NUM_CHARS]

Definition at line 3938 of file switch_utils.c.

_switch_C_tolower_

const short _switch_C_tolower_[1+SWITCH_CTYPE_NUM_CHARS]

Definition at line 3839 of file switch_utils.c.

_switch_C_toupper_

const short _switch_C_toupper_[1+SWITCH_CTYPE_NUM_CHARS]

Definition at line 3792 of file switch_utils.c.

_switch_ctype_

const int* _switch_ctype_ = _switch_C_ctype_

Definition at line 3976 of file switch_utils.c.

_switch_tolower_tab_

const short* _switch_tolower_tab_ = _switch_C_tolower_

Definition at line 3875 of file switch_utils.c.

_switch_toupper_tab_

const short* _switch_toupper_tab_ = _switch_C_toupper_

Definition at line 3828 of file switch_utils.c.

DOW

const char* DOW[]

static

Initial value:

= {
        "sun",
        "mon",
        "tue",
        "wed",
        "thu",
        "fri",
        "sat"
}

Definition at line 4032 of file switch_utils.c.

RFC2833_CHARS

char RFC2833_CHARS[] = "0123456789*#ABCDF"

static

Definition at line 2187 of file switch_utils.c.

Referenced by switch_char_to_rfc2833(), and switch_rfc2833_to_char().

switch_b64_table

const char switch_b64_table[65] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"

static

Definition at line 1023 of file switch_utils.c.

Referenced by switch_b64_decode(), switch_b64_encode(), and switch_simple_email().