switch_utils.c File Reference

#include <switch.h>
#include <arpa/inet.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

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
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_destroy (switch_frame_buffer_t **fbP)
switch_status_t	switch_frame_buffer_create (switch_frame_buffer_t **fbP)
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_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)
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_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_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 (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_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_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)
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)
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_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)

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

#define _B   0x80

Definition at line 3568 of file switch_utils.c.

Referenced by switch_isprint().

#define _C   0x20

Definition at line 3566 of file switch_utils.c.

Referenced by switch_iscntrl().

#define _L   0x02

Definition at line 3562 of file switch_utils.c.

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

#define _N   0x04

Definition at line 3563 of file switch_utils.c.

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

#define _P   0x10

Definition at line 3565 of file switch_utils.c.

Referenced by switch_isgraph(), switch_isprint(), and switch_ispunct().

#define _S   0x08

Definition at line 3564 of file switch_utils.c.

Referenced by switch_isspace().

#define _U   0x01

Definition at line 3561 of file switch_utils.c.

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

#define _X   0x40

Definition at line 3567 of file switch_utils.c.

Referenced by switch_isxdigit().

#define B64BUFFLEN   1024

Definition at line 889 of file switch_utils.c.

Referenced by switch_simple_email().

#define DLINE_BLOCK_SIZE   1024

Definition at line 707 of file switch_utils.c.

Referenced by switch_fd_read_dline(), and switch_fp_read_dline().

#define DLINE_MAX_SIZE   1048576

Definition at line 708 of file switch_utils.c.

Referenced by switch_fd_read_dline(), and switch_fp_read_dline().

#define ESCAPE_META   '\\'

Definition at line 44 of file switch_utils.c.

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

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

Referenced by switch_testv6_subnet().

#define SWITCH_CTYPE_NUM_CHARS   256

Definition at line 3422 of file switch_utils.c.

Typedef Documentation

typedef struct switch_frame_node_s switch_frame_node_t

typedef struct switch_network_node switch_network_node_t

Definition at line 56 of file switch_utils.c.

Enumeration Type Documentation

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 3694 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

static dow_t _dow_read_token ( const char **  s )

inlinestatic

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

switch_status_t clean_uri

(

char *

uri

)

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

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

static

Definition at line 2468 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 || ((ptr+1) && 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;
}

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

static

Definition at line 114 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;
        int x = 0;

        switch_mutex_lock(fb->mutex);

        for (np = fb->head; np; np = np->next) {
                x++;
                
                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 = NULL;
        np->frame->pmap = NULL;
        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;
}

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

find the char representation of an ip adress

Parameters

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

Returns

the ip adress string

Definition at line 2273 of file switch_utils.c.

References buf, and switch_assert.

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

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

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

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

Definition at line 2257 of file switch_utils.c.

References buf, and switch_assert.

Referenced by switch_get_addr().

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

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

        return buf;
}

int get_addr_int

(

switch_sockaddr_t *

sa

)

Definition at line 2150 of file switch_utils.c.

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

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

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

static

Definition at line 1639 of file switch_utils.c.

Referenced by switch_find_local_ip().

{
        return -1;
}

unsigned short get_port

(

struct sockaddr *

sa

)

get the port number of an ip address

Parameters

sa	the struct sockaddr * to get the port from

Returns

the ip adress string

Definition at line 2284 of file switch_utils.c.

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

int old_switch_tolower

(

int

c

)

Definition at line 3509 of file switch_utils.c.

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

int old_switch_toupper

(

int

c

)

Definition at line 3462 of file switch_utils.c.

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

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

static

Definition at line 2577 of file switch_utils.c.

References buf, cleanup_separated_string(), 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;
}

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

static

Definition at line 2534 of file switch_utils.c.

References buf, cleanup_separated_string(), 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 || ((ptr+1) && 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;
}

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

Definition at line 804 of file switch_utils.c.

References buf, and switch_assert.

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

        q = buf;

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

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

  end:

        return buf;
}

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

Definition at line 1250 of file switch_utils.c.

References memset(), SWITCH_FALSE, and SWITCH_TRUE.

Referenced by switch_regex_perform().

{
        const char *p = pat;

        if (!pat) {
                return SWITCH_FALSE;
        }

        memset(rbuf, 0, len);

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

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

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

unsigned int switch_atoui

(

const char *

nptr

)

Definition at line 3925 of file switch_utils.c.

Referenced by switch_ivr_process_fh().

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

unsigned long switch_atoul

(

const char *

nptr

)

Definition at line 3932 of file switch_utils.c.

Referenced by switch_load_core_config().

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

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

Definition at line 929 of file switch_utils.c.

References switch_b64_table.

Referenced by switch_core_media_add_crypto().

{

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

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

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

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

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

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

  end:

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

        return ol;
}

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

Definition at line 890 of file switch_utils.c.

References switch_b64_table, and SWITCH_STATUS_SUCCESS.

Referenced by switch_core_media_build_crypto(), and switch_rtp_add_crypto_key().

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

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

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

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

  end:

        out[bytes] = '\0';

        return SWITCH_STATUS_SUCCESS;
}

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

build a URI string from components

Parameters

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

Returns

number of characters printed (not including the trailing null)

Definition at line 2300 of file switch_utils.c.

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

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

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

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

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

        colon = strchr(host, ':');

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

unsigned char switch_char_to_rfc2833

(

char

key

)

Return the RFC2833 event based on an key character.

Parameters

key	the charecter to encode

Returns

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

Definition at line 2335 of file switch_utils.c.

References switch_toupper().

Referenced by do_2833().

{
        char *c;
        unsigned char counter = 0;

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

int switch_cmp_addr	(	switch_sockaddr_t *	sa1,
		switch_sockaddr_t *	sa2
	)

Definition at line 2157 of file switch_utils.c.

Referenced by handle_ice(), and rtp_common_read().

{
        struct sockaddr_in *s1;
        struct sockaddr_in *s2;

        struct sockaddr_in6 *s16;
        struct sockaddr_in6 *s26;

        struct sockaddr *ss1;
        struct sockaddr *ss2;

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

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

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

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

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

        switch (ss1->sa_family) {
        case AF_INET:
                return (s1->sin_addr.s_addr == s2->sin_addr.s_addr && s1->sin_port == s2->sin_port);
        case AF_INET6:
                if (s16->sin6_addr.s6_addr && s26->sin6_addr.s6_addr) {
                        int i;

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

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

                        return 1;
                }
        }

        return 0;
}

int switch_cp_addr	(	switch_sockaddr_t *	sa1,
		switch_sockaddr_t *	sa2
	)

Definition at line 2206 of file switch_utils.c.

Referenced by read_rtp_packet(), and switch_rtp_set_remote_address().

{
        struct sockaddr_in *s1;
        struct sockaddr_in *s2;

        struct sockaddr_in6 *s16;
        struct sockaddr_in6 *s26;

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

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

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

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

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

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

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

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

                return 1;
        case AF_INET6:
                if (s16->sin6_addr.s6_addr && s26->sin6_addr.s6_addr) {
                        int i;

                        s16->sin6_port = s26->sin6_port;

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

                        return 1;
                }
        }

        return 0;
}

const char* switch_cut_path

(

const char *

in

)

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

Returns

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

Definition at line 2658 of file switch_utils.c.

References in.

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

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

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

switch_bool_t switch_dow_cmp	(	const char *	exp,
		int	val
	)

Definition at line 3732 of file switch_utils.c.

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

Referenced by switch_xml_std_datetime_check().

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

        return SWITCH_FALSE;
}

const char* switch_dow_int2str

(

int

val

)

Definition at line 3674 of file switch_utils.c.

References switch_arraylen.

Referenced by switch_xml_std_datetime_check().

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

int switch_dow_str2int

(

const char *

exp

)

Definition at line 3681 of file switch_utils.c.

References switch_arraylen.

Referenced by _dow_read_token().

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

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

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

Parameters

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

Returns

the escaped string

Definition at line 2350 of file switch_utils.c.

References in, and switch_core_alloc.

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

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

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

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

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

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

Definition at line 2421 of file switch_utils.c.

Referenced by switch_escape_string_pool().

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

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

        *o++ = '\0';

        return out;
}

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

Definition at line 2459 of file switch_utils.c.

References buf, switch_core_alloc, and switch_escape_string().

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

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

Definition at line 709 of file switch_utils.c.

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

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

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

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

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

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

                }

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

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

        *p++ = '\0';

        *len = ilen;
        *buf = data;

        return total;
}

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

Definition at line 687 of file switch_utils.c.

References buf, and cur.

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

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

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

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

Definition at line 661 of file switch_utils.c.

Referenced by expand_vars(), switch_core_asr_load_grammar(), switch_core_media_process_sdp_filter(), switch_core_speech_feed_tts(), switch_event_create_brackets(), switch_is_file_path(), switch_ivr_displace_session(), switch_ivr_originate(), switch_ivr_play_file(), switch_ivr_record_file(), switch_ivr_record_session(), and switch_separate_file_params().

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

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

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

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

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

Definition at line 1839 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_status_t switch_find_local_ip	(	char *	buf,
		int	len,
		int *	mask,
		int	family
	)

Definition at line 1665 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(iface_out)), 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;
}

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

Definition at line 360 of file switch_utils.c.

References switch_core_alloc, and switch_snprintf().

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

        ptr = (char *) str;

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

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

                        ptr = ++e;

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

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

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

                        break;
                }

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

        return r;
}

char* switch_format_number

(

const char *

num

)

Definition at line 3888 of file switch_utils.c.

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

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

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

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

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

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

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

        return r;
}

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

Definition at line 757 of file switch_utils.c.

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

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

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

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

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

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

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

                }

                total++;
                *p++ = c;

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

        *p++ = '\0';

        *len = ilen;
        *buf = data;

        return total;
}

switch_status_t switch_frame_alloc	(	switch_frame_t **	frame,
		switch_size_t	size
	)

Definition at line 83 of file switch_utils.c.

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

{
        switch_frame_t *new_frame;

        switch_zmalloc(new_frame, sizeof(*new_frame));

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

        *frame = new_frame;

        return SWITCH_STATUS_SUCCESS;
}

switch_status_t switch_frame_buffer_create

(

switch_frame_buffer_t **

fbP

)

Definition at line 254 of file switch_utils.c.

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

{
        switch_frame_buffer_t *fb;
        switch_memory_pool_t *pool;

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

        return SWITCH_STATUS_SUCCESS;
}

switch_status_t switch_frame_buffer_destroy

(

switch_frame_buffer_t **

fbP

)

Definition at line 243 of file switch_utils.c.

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

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

        return SWITCH_STATUS_SUCCESS;
}

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

Definition at line 226 of file switch_utils.c.

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

{
        switch_frame_t *new_frame;

        if (!orig) {
                return SWITCH_STATUS_FALSE;
        }

        switch_assert(orig->buflen);

        new_frame = find_free_frame(fb, orig);
                
        *clone = new_frame;

        return SWITCH_STATUS_SUCCESS;
}

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

Definition at line 193 of file switch_utils.c.

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

{
        switch_frame_t *old_frame;
        switch_frame_node_t *node;

        switch_mutex_lock(fb->mutex);

        old_frame = *frameP;
        *frameP = NULL;
        
        node = (switch_frame_node_t *) old_frame->extra_data;
        node->inuse = 0;
        switch_img_free(&node->frame->img);
        
        fb->total++;

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

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

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

        switch_mutex_unlock(fb->mutex);

        return SWITCH_STATUS_SUCCESS;
}

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

Definition at line 269 of file switch_utils.c.

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

{
        switch_frame_t *new_frame;

        if (!orig) {
                return SWITCH_STATUS_FALSE;
        }

        switch_assert(orig->buflen);

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

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

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


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

        return SWITCH_STATUS_SUCCESS;
}

switch_status_t switch_frame_free

(

switch_frame_t **

frame

)

Definition at line 308 of file switch_utils.c.

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

{
        switch_frame_t * f;

        if (!frame) {
                return SWITCH_STATUS_FALSE;
        }

        f = *frame;

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

        *frame = NULL;

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

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

        free(f);

        return SWITCH_STATUS_SUCCESS;
}

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

Definition at line 3337 of file switch_utils.c.

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

Referenced by switch_xml_std_datetime_check().

{
        char *dup = strdup(exp);
        char *sStart;
        char *sEnd;
        char *cur;
        char *p;

        switch_assert(dup);

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

        while (cur) {
                sStart = cur;
                if ((sEnd=strchr(cur, '~'))) {
                        char *sDate = sStart;
                        char *sTime;
                        *sEnd++ = '\0';
                        if ((sTime=strchr(sStart, ' '))) {
                                switch_time_t tsStart;
                                struct tm tmTmp;
                                int year = 1970, month = 1, day = 1;
                                int hour = 0, min = 0, sec = 0;
                                *sTime++ = '\0';

                                memset(&tmTmp, 0, sizeof(tmTmp));
                                switch_split_date(sDate, &year, &month, &day);
                                switch_split_time(sTime, &hour, &min, &sec);
                                tmTmp.tm_year = year-1900;
                                tmTmp.tm_mon = month-1;
                                tmTmp.tm_mday = day;

                                tmTmp.tm_hour = hour;
                                tmTmp.tm_min = min;
                                tmTmp.tm_sec = sec;
                                tmTmp.tm_isdst = 0;
                                tsStart = mktime(&tmTmp);

                                sDate = sEnd;
                                if ((sTime=strchr(sEnd, ' '))) {
                                        switch_time_t tsEnd;
                                        struct tm tmTmp;
                                        int year = 1970, month = 1, day = 1;
                                        int hour = 0, min = 0, sec = 0;
                                        *sTime++ = '\0';

                                        memset(&tmTmp, 0, sizeof(tmTmp));
                                        switch_split_date(sDate, &year, &month, &day);
                                        switch_split_time(sTime, &hour, &min, &sec);
                                        tmTmp.tm_year = year-1900;
                                        tmTmp.tm_mon = month-1;
                                        tmTmp.tm_mday = day;

                                        tmTmp.tm_hour = hour;
                                        tmTmp.tm_min = min;
                                        tmTmp.tm_sec = sec;
                                        tmTmp.tm_isdst = 0;
                                        tsEnd = mktime(&tmTmp);

                                        if (tsStart <= *ts/1000000 && tsEnd > *ts/1000000) {
                                                switch_safe_free(dup);
                                                return 1;
                                        }
                                }
                        }
                }

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

        }
        switch_safe_free(dup);
        return 0;

}

void switch_getcputime

(

switch_cputime *

t

)

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

Definition at line 4225 of file switch_utils.c.

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

void switch_http_dump_request

(

switch_http_request_t *

request

)

Definition at line 4195 of file switch_utils.c.

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

{
        switch_assert(request->method);

        printf("method: %s\n", request->method);

        if (request->uri) printf("uri: %s\n", request->uri);
        if (request->qs)  printf("qs: %s\n", request->qs);
        if (request->host) printf("host: %s\n", request->host);
        if (request->port) printf("port: %d\n", request->port);
        if (request->from) printf("from: %s\n", request->from);
        if (request->user_agent) printf("user_agent: %s\n", request->user_agent);
        if (request->referer) printf("referer: %s\n", request->referer);
        if (request->user) printf("user: %s\n", request->user);
        if (request->keepalive) printf("uri: %d\n", request->keepalive);
        if (request->content_type) printf("uri: %s\n", request->content_type);
        if (request->content_length) printf("uri: %" SWITCH_SIZE_T_FMT "\n", request->content_length);

        {
                switch_event_header_t *header = request->headers->headers;

                printf("headers:\n-------------------------\n");

                while(header) {
                        printf("%s: %s\n", header->name, header->value);
                        header = header->next;
                }
        }
}

void switch_http_free_request

(

switch_http_request_t *

request

)

Definition at line 4186 of file switch_utils.c.

References switch_event_destroy().

Referenced by switch_http_parse_header().

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

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

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

Parameters

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

Returns

SWITCH_STATUS_SUCCESS | SWITCH_STATUS_FALSE

Definition at line 4044 of file switch_utils.c.

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

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

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

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

        if (i == 0) return status;

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

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

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

        if (!p) goto err;

        *p++ = '\0';

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

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

        if (!p) goto err;

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

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

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

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

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

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

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

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

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

        if (header_count < 1) goto err;

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

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

                if (argc != 2) goto err;

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

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

                len = strlen(value);

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

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

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

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

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

noheader:

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

        return SWITCH_STATUS_SUCCESS;

err:
        switch_http_free_request(request);
        return status;
}

void switch_http_parse_qs	(	switch_http_request_t *	request,
		char *	qs
	)

parse http query string

Parameters

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

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

Definition at line 3969 of file switch_utils.c.

References switch_assert, switch_event_add_header_string(), switch_safe_free, SWITCH_STACK_BOTTOM, and switch_url_decode().

Referenced by switch_http_parse_header().

{
        char *q;
        char *next;
        char *name, *val;

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

        switch_assert(q);
        next = q;

        do {
                char *p;

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

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

                switch_url_decode(q);

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

        if (!qs) {
                switch_safe_free(q);
        }
}

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

Definition at line 66 of file switch_utils.c.

Referenced by switch_check_network_list_ip_token(), switch_find_local_ip(), switch_network_list_add_host_mask(), and switch_parse_cidr().

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

switch_bool_t switch_is_lan_addr

(

const char *

ip

)

Definition at line 1217 of file switch_utils.c.

References SWITCH_FALSE, SWITCH_TRUE, and zstr.

{
        if (zstr(ip))
                return SWITCH_FALSE;

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

switch_bool_t switch_is_leading_number

(

const char *

str

)

Definition at line 1460 of file switch_utils.c.

References SWITCH_FALSE, and SWITCH_TRUE.

Referenced by switch_core_media_filter_sdp().

{
        const char *p;
        switch_bool_t r = SWITCH_FALSE;

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

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

        return r;
}

switch_bool_t switch_is_number

(

const char *

str

)

Definition at line 1441 of file switch_utils.c.

References SWITCH_FALSE, and SWITCH_TRUE.

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

{
        const char *p;
        switch_bool_t r = SWITCH_TRUE;

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

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

        return r;
}

int switch_isalnum

(

int

c

)

Definition at line 3610 of file switch_utils.c.

References _L, _N, and _U.

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

int switch_isalpha

(

int

c

)

Definition at line 3615 of file switch_utils.c.

References _L, and _U.

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

int switch_iscntrl

(

int

c

)

Definition at line 3620 of file switch_utils.c.

References _C.

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

int switch_isdigit

(

int

c

)

Definition at line 3625 of file switch_utils.c.

References _N.

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

int switch_isgraph

(

int

c

)

Definition at line 3630 of file switch_utils.c.

References _L, _N, _P, and _U.

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

int switch_islower

(

int

c

)

Definition at line 3635 of file switch_utils.c.

References _L.

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

int switch_isprint

(

int

c

)

Definition at line 3640 of file switch_utils.c.

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

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

int switch_ispunct

(

int

c

)

Definition at line 3645 of file switch_utils.c.

References _P.

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

int switch_isspace

(

int

c

)

Definition at line 3650 of file switch_utils.c.

References _S.

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

int switch_isupper

(

int

c

)

Definition at line 3655 of file switch_utils.c.

References _U.

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

int switch_isxdigit

(

int

c

)

Definition at line 3660 of file switch_utils.c.

References _N, and _X.

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

char* switch_network_ipv4_mapped_ipv6_addr

(

const char *

ip_str

)

Definition at line 494 of file switch_utils.c.

Referenced by switch_check_network_list_ip_token(), and switch_network_list_perform_add_cidr_token().

{
        /* ipv4 mapped ipv6 address */

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

        return strdup(ip_str + 7);
}

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

Definition at line 552 of file switch_utils.c.

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

Referenced by switch_load_network_lists().

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

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

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

        switch_safe_free(cidr_str_dup);
        return status;
}

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

Definition at line 579 of file switch_utils.c.

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

Referenced by switch_load_network_lists().

{
        ip_t ip, mask;
        switch_network_node_t *node;

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

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

        node->ip.v4 = ntohl(ip.v4);
        node->mask.v4 = ntohl(mask.v4);
        node->ok = ok;

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

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

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

        return SWITCH_STATUS_SUCCESS;
}

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

Definition at line 404 of file switch_utils.c.

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

Referenced by switch_load_network_lists().

{
        switch_network_list_t *new_list;

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

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

        *list = new_list;

        return SWITCH_STATUS_SUCCESS;
}

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

Definition at line 505 of file switch_utils.c.

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

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

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

        if (switch_parse_cidr(cidr_str, &ip, &mask, &bits)) {
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error Adding %s (%s) [%s] to list %s\n",
                                                  cidr_str, ok ? "allow" : "deny", switch_str_nil(token), list->name);
                switch_safe_free(ipv4);
                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 (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] to list %s\n",
                                          cidr_str, ok ? "allow" : "deny", switch_str_nil(token), list->name);

        switch_safe_free(ipv4);
        return SWITCH_STATUS_SUCCESS;
}

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

Definition at line 441 of file switch_utils.c.

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

Referenced by switch_check_network_list_ip_token().

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

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

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

                        bits = node->bits;

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

        return ok;
}

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

Definition at line 468 of file switch_utils.c.

References switch_network_node::bits, switch_network_node::family, switch_network_node::ip, switch_network_node::mask, switch_network_node::next, switch_network_node::ok, SWITCH_FALSE, switch_test_subnet, SWITCH_TRUE, switch_network_node::token, and ip_t::v4.

Referenced by switch_check_network_list_ip_token().

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

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

                        bits = node->bits;

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

        return ok;
}

int switch_number_cmp	(	const char *	exp,
		int	val
	)

Definition at line 3765 of file switch_utils.c.

Referenced by switch_xml_std_datetime_check().

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

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

Definition at line 607 of file switch_utils.c.

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

Referenced by switch_check_network_list_ip_token(), and switch_network_list_perform_add_cidr_token().

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

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

        if (!bit_str) {
                return -1;
        }

        *bit_str++ = '\0';
        bits = atoi(bit_str);
        ipv6 = strchr(string, ':');
        if (ipv6) {
                int i,n;
                if (bits < 0 || bits > 128) {
                        return -2;
                }
                bits = atoi(bit_str);
                switch_inet_pton(AF_INET6, host, (unsigned char *)ip);
                for (n=bits,i=0 ;i < 16; i++){
                        if (n >= 8) {
                                maskv->v6.s6_addr[i] = 0xFF;
                                n -= 8;
                        } else if (n < 8) {
                                maskv->v6.s6_addr[i] = 0xFF & ~(0xFF >> n);
                                n -= n;
                        } else if (n == 0) {
                                maskv->v6.s6_addr[i] = 0x00;
                        }
                }
        } else {
                if (bits < 0 || bits > 32) {
                        return -2;
                }

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

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

        return 0;
}

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

Definition at line 72 of file switch_utils.c.

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

{
        switch_port_t port;

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

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

const char* switch_priority_name

(

switch_priority_t

priority

)

Return a printable name of a switch_priority_t.

Parameters

priority

the priority to get the name of

Returns

the printable form of the priority

Definition at line 1956 of file switch_utils.c.

References SWITCH_PRIORITY_HIGH, SWITCH_PRIORITY_LOW, and SWITCH_PRIORITY_NORMAL.

Referenced by switch_event_set_priority().

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

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

Definition at line 1281 of file switch_utils.c.

References switch_assert.

{
        char *p;

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

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

        return p;
}

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

Definition at line 1647 of file switch_utils.c.

References get_addr(), SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

{

        struct addrinfo *ai;
        int err;

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

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

        freeaddrinfo(ai);

        return SWITCH_STATUS_SUCCESS;
}

char switch_rfc2833_to_char

(

int

event

)

Return the RFC2833 character based on an event id.

Parameters

event

the event id to convert

Returns

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

Definition at line 2327 of file switch_utils.c.

Referenced by handle_rfc2833().

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

char* switch_separate_paren_args

(

char *

str

)

Definition at line 1412 of file switch_utils.c.

Referenced by switch_ivr_phrase_macro_event().

{
        char *e, *args;
        switch_size_t br;

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

        return args;
}

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

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

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


        if (*buf == '^' && *(buf+1) == '^') {
                char *p = buf + 2;
                
                if (p && *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));
}

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

Definition at line 2513 of file switch_utils.c.

References buf.

{
        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_bool_t switch_simple_email	(	const char *	to,
		const char *	from,
		const char *	headers,
		const char *	body,
		const char *	file,
		const char *	convert_cmd,
		const char *	convert_ext
	)

Definition at line 981 of file switch_utils.c.

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

Referenced by email().

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

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

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

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

                switch_safe_free(dupfile);
        }

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

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

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

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

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

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

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

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

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

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

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

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

                        }

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

                }

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

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

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

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

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

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

                rval = SWITCH_TRUE;
        }

  end:

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

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

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


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

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

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

        return rval;
}

int switch_socket_waitfor	(	switch_pollfd_t *	poll,
		int	ms
	)

Wait for a socket.

Parameters

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

Returns

the requested condition

Definition at line 3193 of file switch_utils.c.

References switch_poll().

{
        int nsds = 0;

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

        return nsds;
}

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

Definition at line 3306 of file switch_utils.c.

References switch_assert, and switch_safe_free.

Referenced by switch_fulldate_cmp().

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

        switch_assert(dup);

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

}

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

Definition at line 3273 of file switch_utils.c.

References switch_assert, and switch_safe_free.

Referenced by switch_fulldate_cmp().

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

        switch_assert(dup);

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

        }
        switch_safe_free(dup);
        return;

}

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

Split a user string as user and domain.

Parameters

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

Returns

1 if successfull

Note

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

Definition at line 3848 of file switch_utils.c.

References in.

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

        if (!in) return 0;

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

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

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

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

switch_time_t switch_str_time

(

const char *

in

)

Converts a string representation of a date into a switch_time_t.

Parameters

in	the string

Returns

the epoch time in usec

Definition at line 1890 of file switch_utils.c.

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

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

        switch_time_exp_lt(&tm, switch_micro_time_now());
        tm.tm_year = tm.tm_mon = tm.tm_mday = tm.tm_hour = tm.tm_min = tm.tm_sec = tm.tm_usec = 0;

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

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

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

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

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

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

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

                switch_regex_safe_free(re);

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

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

        switch_regex_safe_free(re);

        return ret;
}

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

Definition at line 339 of file switch_utils.c.

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

        va_start(ap, str);

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

        return r;
}

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

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

Parameters

[in]	errnum	Error number
	both]	buf Buffer for error message
[in]	buflen	Size of message buffer

Returns

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

Definition at line 3940 of file switch_utils.c.

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

Referenced by reincarnate_protect(), and rtp_common_read().

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

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

Definition at line 2677 of file switch_utils.c.

References SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

Referenced by switch_string_replace().

{
        size_t i;

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

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

        return SWITCH_STATUS_FALSE;
}

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

Definition at line 2694 of file switch_utils.c.

References switch_assert, SWITCH_STATUS_SUCCESS, and switch_string_match().

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

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

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

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

        dest[dest_len] = 0;
        return dest;
}

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

Definition at line 1369 of file switch_utils.c.

References in.

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

        for (; p && *p; p++) {
                if ((*p > 47 && *p < 58)) {
                        *q++ = *p;
                } else if (*p != ',') {
                        ret = NULL;
                        break;
                }

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

        return ret;
}

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

Definition at line 1392 of file switch_utils.c.

References in.

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

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

        return ret;
}

char* switch_strip_spaces	(	char *	str,
		switch_bool_t	dup
	)

Definition at line 1333 of file switch_utils.c.

References switch_assert, SWITCH_BLANK_STRING, and zstr.

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

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

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

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

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

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

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

        return s;
}

char* switch_strip_whitespace

(

const char *

str

)

Definition at line 1301 of file switch_utils.c.

References switch_assert, SWITCH_BLANK_STRING, and zstr.

Referenced by switch_api_execute().

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

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

        while ((*sp == 13 ) || (*sp == 10 ) || (*sp == 9 ) || (*sp == 32) || (*sp == 11) ) {
                sp++;
        }
        
        if (zstr(sp)) {
                return strdup(SWITCH_BLANK_STRING);
        }

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

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

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

        return s;
}

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

Definition at line 1479 of file switch_utils.c.

References switch_toupper().

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

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

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

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

                if (!*start)
                        return NULL;

                pptr = instr;
                sptr = start;

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

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

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

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

Definition at line 428 of file switch_utils.c.

References IN6_AND_MASK, and SWITCH_TRUE.

Referenced by switch_check_network_list_ip_token(), and switch_network_list_validate_ip6_token().

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

int switch_tod_cmp	(	const char *	exp,
		int	val
	)

Definition at line 3784 of file switch_utils.c.

References cur, switch_assert, and switch_safe_free.

Referenced by switch_xml_std_datetime_check().

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

        switch_assert(dup);

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

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

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

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

        }

        switch_safe_free(dup);
        return 0;

}

char* switch_url_decode

(

char *

s

)

Definition at line 3252 of file switch_utils.c.

References zstr.

Referenced by switch_core_session_request_xml(), and switch_http_parse_qs().

{
        char *o;
        unsigned int tmp;

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

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

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

Definition at line 3247 of file switch_utils.c.

References SWITCH_FALSE, and switch_url_encode_opt().

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

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

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

Definition at line 3202 of file switch_utils.c.

References buf, end_of_p, and SWITCH_URL_UNSAFE.

Referenced by switch_url_encode().

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

        if (!buf) {
                return 0;
        }

        if (!url) {
                return 0;
        }

        len--;

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

                if (x >= len) {
                        break;
                }

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

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

        return buf;
}

char* switch_util_quote_shell_arg

(

const char *

string

)

Quote shell argument.

Parameters

string

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

Definition at line 2729 of file switch_utils.c.

References switch_util_quote_shell_arg_pool().

Referenced by switch_simple_email().

{
        return switch_util_quote_shell_arg_pool(string, NULL);
}

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

Quote shell argument, allocating from pool if provided.

Parameters

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

Returns

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

Definition at line 2734 of file switch_utils.c.

References switch_assert, and switch_core_alloc.

Referenced by switch_util_quote_shell_arg().

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

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

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

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

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

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

char* switch_uuid_str	(	char *	buf,
		switch_size_t	len
	)

Definition at line 3873 of file switch_utils.c.

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

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

{
        switch_uuid_t uuid;

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

        return buf;
}

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

Definition at line 2985 of file switch_utils.c.

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

Referenced by get_pmp_pubaddr().

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

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

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

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

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

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

        if ((flags & SWITCH_POLL_WRITE)) {

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

        if ((flags & SWITCH_POLL_ERROR)) {

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

        tv.tv_sec = ms / 1000;
        tv.tv_usec = (ms % 1000) * ms;
        
        s = select(sock + 1, (flags & SWITCH_POLL_READ) ? rfds : NULL, (flags & SWITCH_POLL_WRITE) ? wfds : NULL, (flags & SWITCH_POLL_ERROR) ? efds : NULL, &tv);

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

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

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

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

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

        return r;

}

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

Definition at line 3081 of file switch_utils.c.

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

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

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

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

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

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

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

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

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

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

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

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

        tv.tv_sec = ms / 1000;
        tv.tv_usec = (ms % 1000) * ms;
        
        s = select(max_fd + 1, (flags & SWITCH_POLL_READ) ? rfds : NULL, (flags & SWITCH_POLL_WRITE) ? wfds : NULL, (flags & SWITCH_POLL_ERROR) ? efds : NULL, &tv);

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

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

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

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

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

        return r;

}

static char unescape_char ( char  escaped )

static

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

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

static

Definition at line 969 of file switch_utils.c.

Referenced by switch_ivr_record_file(), and switch_simple_email().

{

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

        return 1;
}

Variable Documentation

const int _switch_C_ctype_[1+SWITCH_CTYPE_NUM_CHARS]

Definition at line 3570 of file switch_utils.c.

const short _switch_C_tolower_[1+SWITCH_CTYPE_NUM_CHARS]

Definition at line 3471 of file switch_utils.c.

const short _switch_C_toupper_[1+SWITCH_CTYPE_NUM_CHARS]

Definition at line 3424 of file switch_utils.c.

const int* _switch_ctype_ = _switch_C_ctype_

Definition at line 3608 of file switch_utils.c.

const short* _switch_tolower_tab_ = _switch_C_tolower_

Definition at line 3507 of file switch_utils.c.

const short* _switch_toupper_tab_ = _switch_C_toupper_

Definition at line 3460 of file switch_utils.c.

const char* DOW[]

static

Initial value:

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

Definition at line 3664 of file switch_utils.c.

char RFC2833_CHARS[] = "0123456789*#ABCDF"

static

Definition at line 1970 of file switch_utils.c.

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

static

Definition at line 888 of file switch_utils.c.

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