#include <switch.h>

#ifndef WIN32

#include <arpa/inet.h>

#if defined(HAVE_SYS_TIME_H) && defined(HAVE_SYS_RESOURCE_H)

#include <sys/time.h>

#include <sys/resource.h>

#include "private/switch_core_pvt.h"

#define ESCAPE_META '\\'

#ifdef SWITCH_HAVE_GUMBO

#include "gumbo.h"

struct switch_network_node {

};

typedef struct switch_network_node switch_network_node_t;

struct switch_network_list {

};

#ifndef WIN32

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

{

return inet_pton(af, src, dst);

}

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

{

switch_port_t port;

switch_get_addr(buf, len, addr);

port = switch_sockaddr_get_port(addr);

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

return buf;

}

SWITCH_DECLARE(switch_status_t) switch_frame_alloc(switch_frame_t **frame, switch_size_t size)

{

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;

}

typedef struct switch_frame_node_s {

} switch_frame_node_t;

struct switch_frame_buffer_s {

};

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

{

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 = orig->codec;

np->frame->pmap = orig->pmap;

np->frame->img = NULL;

np->frame->extra_data = np;

np->inuse = 1;

switch_set_flag(np->frame, SFF_DYNAMIC);

if (orig->packet) {

memcpy(np->frame->packet, orig->packet, orig->packetlen);

np->frame->packetlen = orig->packetlen;

np->frame->data = ((unsigned char *)np->frame->packet) + 12;

np->frame->datalen = orig->datalen;

} else {

np->frame->packet = NULL;

np->frame->packetlen = 0;

memcpy(np->frame->data, orig->data, orig->datalen);

np->frame->datalen = orig->datalen;

}

if (orig->img && !switch_test_flag(orig, SFF_ENCODED)) {

switch_img_copy(orig->img, &np->frame->img);

}

switch_mutex_unlock(fb->mutex);

return np->frame;

}

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

{

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

{

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_DECLARE(switch_status_t) switch_frame_buffer_push(switch_frame_buffer_t *fb, void *ptr)

{

return switch_queue_push(fb->queue, ptr);

}

SWITCH_DECLARE(switch_status_t) switch_frame_buffer_trypush(switch_frame_buffer_t *fb, void *ptr)

{

return switch_queue_trypush(fb->queue, ptr);

}

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

{

return switch_queue_pop(fb->queue, ptr);

}

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

{

return switch_queue_trypop(fb->queue, ptr);

}

SWITCH_DECLARE(int) switch_frame_buffer_size(switch_frame_buffer_t *fb)

{

return switch_queue_size(fb->queue);

}

SWITCH_DECLARE(switch_status_t) switch_frame_buffer_destroy(switch_frame_buffer_t **fbP)

{

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_DECLARE(switch_status_t) switch_frame_buffer_create(switch_frame_buffer_t **fbP, switch_size_t qlen)

{

switch_frame_buffer_t *fb;

switch_memory_pool_t *pool;

if (!qlen) qlen = 500;

switch_core_new_memory_pool(&pool);

fb = switch_core_alloc(pool, sizeof(*fb));

fb->pool = pool;

switch_queue_create(&fb->queue, qlen, fb->pool);

switch_mutex_init(&fb->mutex, SWITCH_MUTEX_NESTED, pool);

*fbP = fb;

return SWITCH_STATUS_SUCCESS;

}

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

{

switch_frame_t *new_frame;

if (!orig) {

return SWITCH_STATUS_FALSE;

}

switch_assert(orig->buflen);

new_frame = malloc(sizeof(*new_frame));

switch_assert(new_frame);

*new_frame = *orig;

switch_set_flag(new_frame, SFF_DYNAMIC);

if (orig->packet) {

new_frame->packet = malloc(SWITCH_RTP_MAX_BUF_LEN);

switch_assert(new_frame->packet);

memcpy(new_frame->packet, orig->packet, orig->packetlen);

new_frame->data = ((unsigned char *)new_frame->packet) + 12;

} else {

new_frame->packet = NULL;

new_frame->data = malloc(new_frame->buflen);

switch_assert(new_frame->data);

memcpy(new_frame->data, orig->data, orig->datalen);

}

new_frame->codec = orig->codec;

new_frame->pmap = orig->pmap;

new_frame->img = NULL;

if (orig->img && !switch_test_flag(orig, SFF_ENCODED)) {

switch_img_copy(orig->img, &new_frame->img);

}

*clone = new_frame;

return SWITCH_STATUS_SUCCESS;

}

SWITCH_DECLARE(switch_status_t) switch_frame_free(switch_frame_t **frame)

{

switch_frame_t * f;

if (!frame) {

return SWITCH_STATUS_FALSE;

}

f = *frame;

if (!f || !switch_test_flag(f, SFF_DYNAMIC)) {

return SWITCH_STATUS_FALSE;

}

*frame = NULL;

if (f->img) {

switch_img_free(&(f->img));

}

if (f->packet) {

switch_safe_free(f->packet);

} else {

switch_safe_free(f->data);

}

free(f);

return SWITCH_STATUS_SUCCESS;

}

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

{

va_list ap;

const char *next_str = 0;

int r = 0;

va_start(ap, str);

while ((next_str = va_arg(ap, const char *))) {

if (!strcasecmp(str, next_str)) {

r = 1;

break;

}

}

va_end(ap);

return r;

}

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

{

char *e, *r = NULL, *ptr = NULL, *next = NULL;

size_t len;

ptr = (char *) str;

while (ptr) {

len = strlen(param);

e = ptr+len;

next = strchr(ptr, ';');

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

size_t mlen;

ptr = ++e;

if (next) {

e = next;

} else {

e = ptr + strlen(ptr);

}

mlen = (e - ptr) + 1;

if (pool) {

r = switch_core_alloc(pool, mlen);

} else {

r = malloc(mlen);

}

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

break;

}

if (next) {

ptr = next + 1;

} else break;

}

return r;

}

SWITCH_DECLARE(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_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;

}

#define IN6_AND_MASK(result, ip, mask) \

((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];

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

if (!IN6_IS_ADDR_UNSPECIFIED(&_mask.v6)) {

struct in6_addr a, b;

IN6_AND_MASK(&a, &_net, &_mask);

IN6_AND_MASK(&b, &_ip, &_mask);

return !memcmp(&a,&b, sizeof(struct in6_addr));

} else {

if (!IN6_IS_ADDR_UNSPECIFIED(&_net.v6)) {

return !memcmp(&_net,&_ip,sizeof(struct in6_addr));

}

else return SWITCH_TRUE;

}

}

SWITCH_DECLARE(switch_bool_t) switch_network_list_validate_ip6_port_token(switch_network_list_t *list, ip_t ip, int port, const char **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_DECLARE(switch_bool_t) is_port_in_node(int port, switch_network_node_t *node)

{

if(port == 0)

return SWITCH_TRUE;

if(node->port_range.port != 0 && node->port_range.port != port)

return SWITCH_FALSE;

if(node->port_range.ports[0] != 0) {

int i;

for(i=0; i < MAX_NETWORK_PORTS && node->port_range.ports[i] != 0; i++) {

if(port == node->port_range.ports[i])

return SWITCH_TRUE;

}

return SWITCH_FALSE;

}

if(node->port_range.min_port != 0 || node->port_range.max_port != 0) {

if(port >= node->port_range.min_port && port <= node->port_range.max_port)

return SWITCH_TRUE;

return SWITCH_FALSE;

}

return SWITCH_TRUE;

}

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

{

switch_network_node_t *node;

switch_bool_t ok = list->default_type;

uint32_t bits = 0;

for (node = list->node_head; node; node = node->next) {

if (node->family == AF_INET6) continue; /* want AF_INET */

if (node->bits >= bits && switch_test_subnet(ip, node->ip.v4, node->mask.v4) && is_port_in_node(port, node)) {

if (node->ok) {

ok = SWITCH_TRUE;

} else {

ok = SWITCH_FALSE;

}

bits = node->bits;

if (token) {

*token = node->token;

}

}

}

return ok;

}

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

{

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

}

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

{

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

}

SWITCH_DECLARE(char *) switch_network_ipv4_mapped_ipv6_addr(const char* ip_str)

{

/* ipv4 mapped ipv6 address */

if (strncasecmp(ip_str, "::ffff:", 7)) {

return NULL;

}

return strdup(ip_str + 7);

}

SWITCH_DECLARE(char*) switch_network_port_range_to_string(switch_network_port_range_p port)

{

if (!port) {

return NULL;

}

if (port->port != 0) {

return switch_mprintf("port: %i ", port->port);

}

if (port->ports[0] != 0) {

int i, written = 0;

char buf[MAX_NETWORK_PORTS * 6];

for (i = 0; i < MAX_NETWORK_PORTS && port->ports[i] != 0; i++) {

written += snprintf(buf + written, sizeof(buf) - written, (i != 0 ? ", %u" : "%u"), port->ports[i]);

}

return switch_mprintf("ports: [%s] ", buf);

}

if (port->min_port != 0 || port->max_port != 0) {

return switch_mprintf("port range: [%i-%i] ", port->min_port, port->max_port);

}

return NULL;

}

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

const char *token, switch_network_port_range_p port)

{

ip_t ip, mask;

uint32_t bits;

switch_network_node_t *node;

char *ipv4 = NULL;

char *ports = NULL;

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

cidr_str = ipv4;

}

ports = switch_network_port_range_to_string(port);

if (switch_parse_cidr(cidr_str, &ip, &mask, &bits)) {

switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error Adding %s %s(%s) [%s] to list %s\n",

cidr_str, ports ? ports : "", ok ? "allow" : "deny", switch_str_nil(token), list->name);

switch_safe_free(ipv4);

switch_safe_free(ports);

return SWITCH_STATUS_GENERR;

}

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

node->ip = ip;

node->mask = mask;

node->ok = ok;

node->bits = bits;

node->str = switch_core_strdup(list->pool, cidr_str);

if(port) {

memcpy(&node->port_range, port, sizeof(switch_network_port_range_t));

}

if (strchr(cidr_str,':')) {

node->family = AF_INET6;

} else {

node->family = AF_INET;

}

if (!zstr(token)) {

node->token = switch_core_strdup(list->pool, token);

}

node->next = list->node_head;

list->node_head = node;

switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "Adding %s %s(%s) [%s] to list %s\n",

cidr_str, ports ? ports : "", ok ? "allow" : "deny", switch_str_nil(token), list->name);

switch_safe_free(ipv4);

switch_safe_free(ports);

return SWITCH_STATUS_SUCCESS;

}

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

{

char *cidr_str_dup = NULL;

switch_status_t status = SWITCH_STATUS_SUCCESS;

if (strchr(cidr_str, ',')) {

char *argv[32] = { 0 };

int i, argc;

cidr_str_dup = strdup(cidr_str);

switch_assert(cidr_str_dup);

if ((argc = switch_separate_string(cidr_str_dup, ',', argv, (sizeof(argv) / sizeof(argv[0]))))) {

for (i = 0; i < argc; i++) {

switch_status_t this_status;

if ((this_status = switch_network_list_perform_add_cidr_token(list, argv[i], ok, token, port)) != SWITCH_STATUS_SUCCESS) {

status = this_status;

}

}

}

} else {

status = switch_network_list_perform_add_cidr_token(list, cidr_str, ok, token, port);

}

switch_safe_free(cidr_str_dup);

return status;

}

SWITCH_DECLARE(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)

{

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

}

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

{

ip_t ip, mask;

switch_network_node_t *node;

switch_inet_pton(AF_INET, host, &ip);

switch_inet_pton(AF_INET, mask_str, &mask);

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

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

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

node->ok = ok;

if(port) {

memcpy(&node->port_range, port, sizeof(switch_network_port_range_t));

}

/* http://graphics.stanford.edu/~seander/bithacks.html */

mask.v4 = mask.v4 - ((mask.v4 >> 1) & 0x55555555);

mask.v4 = (mask.v4 & 0x33333333) + ((mask.v4 >> 2) & 0x33333333);

node->bits = (((mask.v4 + (mask.v4 >> 4)) & 0xF0F0F0F) * 0x1010101) >> 24;

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

node->next = list->node_head;

list->node_head = node;

return SWITCH_STATUS_SUCCESS;

}

SWITCH_DECLARE(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)

{

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

}

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

{

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;

}

SWITCH_DECLARE(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 && open != close) {

depth++;

} else if (*e == close) {

depth--;

if (!depth) {

break;

}

}

}

}

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

}

SWITCH_DECLARE(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;

}

#define DLINE_BLOCK_SIZE 1024

#define DLINE_MAX_SIZE 1048576

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

{

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_DECLARE(switch_size_t) switch_fp_read_dline(FILE *fd, char **buf, switch_size_t *len)

{

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_DECLARE(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 + 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: