switch_utils.h File Reference

---

Detailed Description

Compatability and Helper Code.

Just a miscelaneaous set of general utility/helper functions.

Defines
#define	switch_samples_per_frame(rate, interval)   ((uint32_t)((float)rate / (1000.0f / (float)interval)))
#define	SWITCH_SMAX   32767
#define	SWITCH_SMIN   -32768
#define	switch_normalize_to_16bit(n)   if (n > SWITCH_SMAX) n = SWITCH_SMAX / 2; else if (n < SWITCH_SMIN) n = SWITCH_SMIN / 2;
#define	switch_codec2str(codec, buf, len)
#define	switch_is_file_path(file)   (file && ((*file == '/') || strstr(file, SWITCH_URL_SEPARATOR)))
#define	switch_strlen_zero(s)   (!s || *s == '\0')
	Test for NULL or zero length string.
#define	switch_true(expr)
	Evaluate the truthfullness of a string expression.
#define	SWITCH_STATUS_IS_BREAK(x)   (x == SWITCH_STATUS_BREAK || x == 730035 || x == 35)
#define	is_dtmf(key)   ((key > 47 && key < 58) || (key > 64 && key < 69) || (key > 96 && key < 101) || key == 35 || key == 42 || key == 87 || key == 119)
	determine if a character is a valid DTMF key
#define	end_of(_s)   *(*_s == '\0' ? _s : _s + strlen(_s) - 1)
#define	end_of_p(_s)   (*_s == '\0' ? _s : _s + strlen(_s) - 1)
#define	switch_test_flag(obj, flag)   ((obj)->flags & flag)
	Test for the existance of a flag on an arbitary object.
#define	switch_set_flag(obj, flag)   (obj)->flags |= (flag)
	Set a flag on an arbitrary object.
#define	switch_set_flag_locked(obj, flag)
	Set a flag on an arbitrary object while locked.
#define	switch_clear_flag_locked(obj, flag)   switch_mutex_lock(obj->flag_mutex); (obj)->flags &= ~(flag); switch_mutex_unlock(obj->flag_mutex);
	Clear a flag on an arbitrary object.
#define	switch_clear_flag(obj, flag)   (obj)->flags &= ~(flag)
	Clear a flag on an arbitrary object while locked.
#define	switch_copy_flags(dest, src, flags)   (dest)->flags &= ~(flags); (dest)->flags |= ((src)->flags & (flags))
	Copy flags from one arbitrary object to another.
#define	switch_set_string(_dst, _src)   switch_copy_string(_dst, _src, sizeof(_dst))
#define	switch_safe_free(it)   if (it) {free(it);it=NULL;}
	Free a pointer and set it to NULL unless it already is NULL.
#define	switch_str_nil(s)   (s ? s : "")
	Make a null string a blank string instead.
#define	switch_yield(ms)   switch_sleep(ms);
	Wait a desired number of microseconds and yield the CPU.
#define	SWITCH_DECLARE_GLOBAL_STRING_FUNC(fname, vname)
	Declares a function designed to set a dymaic global string.
#define	SWITCH_READ_ACCEPTABLE(status)   (status == SWITCH_STATUS_SUCCESS || status == SWITCH_STATUS_BREAK)
#define	switch_test_subnet(_ip, _net, _mask)   (_mask ? ((_net & _mask) == (_ip & _mask)) : _net ? _net == _ip : 1)
#define	switch_malloc(ptr, len)   (void)(assert(((ptr) = malloc((len)))),ptr)
#define	switch_zmalloc(ptr, len)   (void)(assert((ptr = malloc(len))),memset(ptr, 0, len))
Functions
switch_status_t	switch_b64_encode (unsigned char *in, switch_size_t ilen, unsigned char *out, switch_size_t olen)
switch_size_t	switch_b64_decode (char *in, char *out, switch_size_t olen)
char *	switch_amp_encode (char *s, char *buf, switch_size_t len)
switch_size_t	switch_fd_read_line (int fd, char *buf, switch_size_t len)
switch_status_t	switch_find_local_ip (_Out_opt_bytecapcount_(len) char *buf, _In_ int len, _In_ int family)
	find local ip of the box
char *	get_addr (char *buf, switch_size_t len, struct in_addr *in)
	find the char representation of an ip adress
const char *	switch_priority_name (switch_priority_t priority)
	Return a printable name of a switch_priority_t.
char	switch_rfc2833_to_char (int event)
	Return the RFC2833 character based on an event id.
unsigned char	switch_char_to_rfc2833 (char key)
	Return the RFC2833 event based on an key character.
switch_time_t	switch_str_time (const char *in)
	Converts a string representation of a date into a switch_time_t.
unsigned int	switch_separate_string (char *buf, char delim, char **array, unsigned int arraylen)
	Separate a string into an array based on a character delimeter.
switch_bool_t	switch_is_number (const char *str)
char *	switch_strip_spaces (const char *str)
char *	switch_separate_paren_args (char *str)
const char *	switch_stristr (const char *instr, const char *str)
switch_bool_t	switch_is_lan_addr (const char *ip)
char *	switch_replace_char (char *str, char from, char to, switch_bool_t dup)
switch_bool_t	switch_ast2regex (char *pat, char *rbuf, size_t len)
char *	switch_escape_char (switch_memory_pool_t *pool, char *in, const char *delim, char esc)
	Escape a string by prefixing a list of characters with an escape character.
int	switch_socket_waitfor (switch_pollfd_t *poll, int ms)
	Wait for a socket.
const char *	switch_cut_path (const char *in)
	Create a pointer to the file name in a given file path eliminating the directory name.
char *	switch_string_replace (const char *string, const char *search, const char *replace)
switch_status_t	switch_string_match (const char *string, size_t string_len, const char *search, size_t search_len)
size_t	switch_url_encode (const char *url, char *buf, size_t len)
char *	switch_url_decode (char *s)
switch_bool_t	switch_simple_email (const char *to, const char *from, const char *headers, const char *body, const char *file)
char *	switch_find_end_paren (const char *s, char open, char close)
int	switch_parse_cidr (const char *string, uint32_t *ip, uint32_t *mask, uint32_t *bitp)
switch_status_t	switch_network_list_create (switch_network_list_t **list, switch_bool_t default_type, switch_memory_pool_t *pool)
switch_status_t	switch_network_list_add_cidr (switch_network_list_t *list, const char *cidr_str, switch_bool_t ok)
switch_status_t	switch_network_list_add_host_mask (switch_network_list_t *list, const char *host, const char *mask_str, switch_bool_t ok)
switch_bool_t	switch_network_list_validate_ip (switch_network_list_t *list, uint32_t ip)
int	switch_inet_pton (int af, const char *src, void *dst)

---

Define Documentation

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

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

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

determine if a character is a valid DTMF key Parameters: key  the key to test Returns: TRUE or FALSE

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

Clear a flag on an arbitrary object while locked. Parameters: obj  the object to test flag  the or'd list of flags to clear

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

Clear a flag on an arbitrary object. Parameters: obj  the object to test flag  the or'd list of flags to clear

#define switch_codec2str (  codec, buf, len   )

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

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

Copy flags from one arbitrary object to another. Parameters: dest  the object to copy the flags to src  the object to copy the flags from flags  the flags to copy

#define SWITCH_DECLARE_GLOBAL_STRING_FUNC (  fname, vname   )

Value: static void fname(char *string) { if (!string) return;\ if (vname) {free(vname); vname = NULL;}vname = strdup(string);} static void fname(char *string) Declares a function designed to set a dymaic global string. Parameters: fname  the function name to declare vname  the name of the global pointer to modify with the new function

#define switch_is_file_path (  file   )     (file && ((*file == '/') || strstr(file, SWITCH_URL_SEPARATOR)))

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

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

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

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

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

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

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

Set a flag on an arbitrary object. Parameters: obj  the object to set the flags on flag  the or'd list of flags to set

#define switch_set_flag_locked (  obj, flag   )

Value: assert(obj->flag_mutex != NULL);\ switch_mutex_lock(obj->flag_mutex);\ (obj)->flags |= (flag);\ switch_mutex_unlock(obj->flag_mutex); Set a flag on an arbitrary object while locked. Parameters: obj  the object to set the flags on flag  the or'd list of flags to set

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

#define SWITCH_SMAX   32767

#define SWITCH_SMIN   -32768

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

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

Make a null string a blank string instead. Parameters: s  the string to test Returns: the original string or blank string.

#define switch_strlen_zero (  s   )     (!s || *s == '\0')

Test for NULL or zero length string. Parameters: s  the string to test Returns: true value if the string is NULL or zero length

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

Test for the existance of a flag on an arbitary object. Parameters: obj  the object to test flag  the or'd list of flags to test Returns: true value if the object has the flags defined

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

#define switch_true (  expr   )

Value: (expr && ( !strcasecmp(expr, "yes") ||\ !strcasecmp(expr, "on") ||\ !strcasecmp(expr, "true") ||\ !strcasecmp(expr, "enabled") ||\ !strcasecmp(expr, "active") ||\ !strcasecmp(expr, "allow") ||\ atoi(expr))) ? SWITCH_TRUE : SWITCH_FALSE Evaluate the truthfullness of a string expression. Parameters: expr  a string expression Returns: true or false

#define switch_yield (  ms   )     switch_sleep(ms);

Wait a desired number of microseconds and yield the CPU.

#define switch_zmalloc (  ptr, len   )     (void)(assert((ptr = malloc(len))),memset(ptr, 0, len))

---

Function Documentation

char* get_addr (  char *  buf, switch_size_t  len, struct in_addr *  in )

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 in  the struct in_addr * to get the adress from Returns: the ip adress string { switch_assert(buf); *buf = '\0'; if (in) { switch_inet_ntop(AF_INET, in, buf, len); } return buf; }

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

{ char *p, *q; switch_size_t x = 0; switch_assert(s); q = buf; for(p = s; x < len; p++) { switch(*p) { 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 (  char *  pat, char *  rbuf, size_t  len )

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

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

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

{ 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 (++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) { out[bytes++] = '=', l += 2; } } return SWITCH_STATUS_SUCCESS; }

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 { char *c; unsigned char counter = 0; key = (char) toupper(key); for (c = RFC2833_CHARS; *c; c++) { if (*c == key) { return counter; } counter++; } 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 { 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; } }

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 { char *data; const char *p, *d; int count = 1, i = 0; p = in; while (*p) { d = delim; while (*d) { if (*p == *d) { count++; } d++; } p++; } if (count == 1) { return in; } data = switch_core_alloc(pool, strlen(in) + count); p = in; while (*p) { d = delim; while (*d) { if (*p == *d) { data[i++] = esc; } d++; } data[i++] = *p; p++; } return data; }

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

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

{ 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) { depth++; } else if (*e == close) { depth--; if (!depth) { break; } } } } return (char *)e; }

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

find local ip of the box Parameters: buf  the buffer to write the ip adress found into len  the length of the buf family  the address family to return (AF_INET or AF_INET6) Returns: SWITCH_STATUS_SUCCESSS for success, otherwise failure

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

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

switch_bool_t switch_is_lan_addr (  const char *  ip  )

{ if (switch_strlen_zero(ip)) return SWITCH_FALSE; return ( strncmp(ip, "10.", 3) && strncmp(ip, "192.168.", 8) && strncmp(ip, "127.", 4) && strncmp(ip, "255.", 4) && strncmp(ip, "0.", 2) && strncmp(ip, "1.", 2) && strncmp(ip, "2.", 2) && strncmp(ip, "172.16.", 7) && strncmp(ip, "172.17.", 7) && strncmp(ip, "172.18.", 7) && strncmp(ip, "172.19.", 7) && strncmp(ip, "172.2", 5) && strncmp(ip, "172.30.", 7) && strncmp(ip, "172.31.", 7) && strncmp(ip, "192.0.2.", 8) && strncmp(ip, "169.254.", 8) ) ? SWITCH_FALSE : SWITCH_TRUE; }

switch_bool_t switch_is_number (  const char *  str  )

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

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

{ uint32_t ip, mask, bits; switch_network_node_t *node; if (switch_parse_cidr(cidr_str, &ip, &mask, &bits)) { 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->next = list->node_head; list->node_head = node; return SWITCH_STATUS_SUCCESS; }

Here is the call graph for this function:

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 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 = ip; node->mask = mask; node->ok = ok; /* http://graphics.stanford.edu/~seander/bithacks.html */ mask = mask - ((mask >> 1) & 0x55555555); mask = (mask & 0x33333333) + ((mask >> 2) & 0x33333333); node->bits = (((mask + (mask >> 4)) & 0xF0F0F0F) * 0x1010101) >> 24; node->next = list->node_head; list->node_head = node; return SWITCH_STATUS_SUCCESS; }

Here is the call graph for this function:

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

{ 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; *list = new_list; return SWITCH_STATUS_SUCCESS; }

switch_bool_t switch_network_list_validate_ip (  switch_network_list_t *  list, uint32_t  ip )

{ 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->bits > bits && switch_test_subnet(ip, node->ip, node->mask)) { if (node->ok) { ok = SWITCH_TRUE; } else { ok = SWITCH_FALSE; } bits = node->bits; } } return ok; }

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

{ char host[128]; char *bit_str; int32_t bits; switch_copy_string(host, string, sizeof(host)); bit_str = strchr(host, '/'); if (!bit_str) { return -1; } *bit_str++ = '\0'; bits = atoi(bit_str); if (bits < 0 || bits > 32) { return -2; } bits = atoi(bit_str); switch_inet_pton(AF_INET, host, ip); *mask = 0xFFFFFFFF & ~(0xFFFFFFFF << bits); *bitp = bits; return 0; }

Here is the call graph for this function:

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

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

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

char* switch_separate_paren_args (  char *  str  )

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

Separate a string into an array based on a character delimeter. Parameters: buf  the string to parse delim  the character delimeter array  the array to split the values into arraylen  the max number of elements in the array Returns: the number of elements added to the array { if (!buf || !array || !arraylen) { return 0; } memset(array, 0, arraylen * sizeof (*array)); return (delim == ' ' ? separate_string_blank_delim(buf, array, arraylen) : separate_string_char_delim(buf, delim, array, arraylen)); }

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

{ char *bound = "XXXX_boundary_XXXX"; const char *mime_type = "audio/inline"; char filename[80], buf[B64BUFFLEN]; int fd = 0, ifd = 0; int x = 0, y = 0, bytes = 0, ilen = 0; unsigned int b = 0, l = 0; unsigned char in[B64BUFFLEN]; unsigned char out[B64BUFFLEN + 512]; switch_snprintf(filename, 80, "%smail.%d%04x", SWITCH_GLOBAL_dirs.temp_dir, (int)switch_timestamp(NULL), rand() & 0xffff); if ((fd = open(filename, O_WRONLY | O_CREAT | O_TRUNC, 0644))) { if (file) { if ((ifd = open(file, O_RDONLY)) < 1) { return SWITCH_FALSE; } } switch_snprintf(buf, B64BUFFLEN, "MIME-Version: 1.0\nContent-Type: multipart/mixed; boundary=\"%s\"\n", bound); if (!write_buf(fd, buf)) { return SWITCH_FALSE; } if (headers && !write_buf(fd, headers)) return SWITCH_FALSE; if (!write_buf(fd, "\n\n")) return SWITCH_FALSE; 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)) return SWITCH_FALSE; if (body) { if (!write_buf(fd, body)) { return SWITCH_FALSE; } } if (file) { 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)) return SWITCH_FALSE; 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) { return -1; } 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) { return -1; } } switch_snprintf(buf, B64BUFFLEN, "\n\n--%s--\n.\n", bound); if (!write_buf(fd, buf)) return SWITCH_FALSE; } if (fd) { close(fd); } if (ifd) { close(ifd); } switch_snprintf(buf, B64BUFFLEN, "/bin/cat %s | %s %s %s", filename, runtime.mailer_app, runtime.mailer_app_args, to); if (system(buf)) { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Unable to execute command: %s\n", buf); } if (unlink(filename) != 0) { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "failed to delete file [%s]\n", filename); } 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); } return SWITCH_TRUE; }

Here is the call graph for this function: