/** process handshake packets from the client */
static int _sx_ack_process(sx_t s, sx_plugin_t p, nad_t nad) {
int attr;
/* not interested if we're not a server */
if(s->type != type_SERVER)
return 1;
/* only want ack packets */
if((NAD_ENS(nad, 0) < 0 || NAD_NURI_L(nad, NAD_ENS(nad, 0)) != strlen(uri_ACK) || strncmp(NAD_NURI(nad, NAD_ENS(nad, 0)), uri_ACK, strlen(uri_ACK)) != 0))
return 1;
/* pings */
if(NAD_ENAME_L(nad, 0) == 4 && strncmp(NAD_ENAME(nad, 0), "ping", 4) == 0) {
jqueue_push(s->wbufq, _sx_buffer_new("<ack:pong/>", 11, NULL, NULL), 0);
s->want_write = 1;
/* handled the packet */
nad_free(nad);
return 0;
}
/* enable only when authenticated */
if(s->state == state_OPEN && NAD_ENAME_L(nad, 0) == 6 && strncmp(NAD_ENAME(nad, 0), "enable", 6) == 0) {
jqueue_push(s->wbufq, _sx_buffer_new("<ack:enabled/>", 14, NULL, NULL), 254);
s->want_write = 1;
s->plugin_data[p->index] = (void *) 1;
/* handled the packet */
nad_free(nad);
return 0;
}
/* 'r' or 'a' when enabled */
if(s->plugin_data[p->index] != NULL && NAD_ENAME_L(nad, 0) == 1 && (strncmp(NAD_ENAME(nad, 0), "r", 1) == 0 || strncmp(NAD_ENAME(nad, 0), "a", 1) == 0) ) {
attr = nad_find_attr(nad, 0, -1, "c", NULL);
if(attr >= 0) {
char *buf = (char *) malloc(sizeof(char) * (NAD_AVAL_L(nad, attr) + 13 + 1));
snprintf(buf, NAD_AVAL_L(nad, attr) + 13 + 1, "<ack:a b='%.*s'/>", NAD_AVAL_L(nad, attr), NAD_AVAL(nad, attr));
jqueue_push(s->wbufq, _sx_buffer_new(buf, NAD_AVAL_L(nad, attr) + 13, NULL, NULL), 255);
free(buf);
s->want_write = 1;
}
/* handled the packet */
nad_free(nad);
return 0;
}
_sx_debug(ZONE, "unhandled ack namespace element '%.*s', dropping packet", NAD_ENAME_L(nad, 0), NAD_ENAME(nad, 0));
nad_free(nad);
return 0;
}
/** close a stream */
void _sx_close(sx_t s) {
/* close the stream if necessary */
if(s->state >= state_STREAM_SENT) {
if (s->flags & SX_WEBSOCKET_WRAPPER)
jqueue_push(s->wbufq, _sx_buffer_new("<close xmlns='" uri_XFRAMING "' />", sizeof(uri_XFRAMING) + 17, NULL, NULL), 0);
else
jqueue_push(s->wbufq, _sx_buffer_new("</stream:stream>", 16, NULL, NULL), 0);
s->want_write = 1;
}
_sx_state(s, state_CLOSING);
}
static void _router_comp_write(component_t comp, nad_t nad) {
int attr;
if(comp->tq != NULL) {
log_debug(ZONE, "%s port %d is throttled, jqueueing packet", comp->ip, comp->port);
jqueue_push(comp->tq, nad, 0);
return;
}
/* packets go raw to normal components */
if(!comp->legacy) {
sx_nad_write(comp->s, nad);
return;
}
log_debug(ZONE, "packet for legacy component, munging");
attr = nad_find_attr(nad, 0, -1, "error", NULL);
if(attr >= 0) {
if(NAD_AVAL_L(nad, attr) == 3 && strncmp("400", NAD_AVAL(nad, attr), 3) == 0)
stanza_error(nad, 1, stanza_err_BAD_REQUEST);
else
stanza_error(nad, 1, stanza_err_SERVICE_UNAVAILABLE);
}
sx_nad_write_elem(comp->s, nad, 1);
}
//** send an extended error with custom contents other than text */
// Ideally should be merged with sx_error. sx_error should permit additional content beneath the <stream:error> element, other than a <text> node.
void _sx_error_extended(sx_t s, int err, const char *content) {
int len = 0;
sx_buf_t buf;
/* build the string */
if(s->state < state_STREAM) len = strlen(uri_STREAMS) + 61;
len += strlen(uri_STREAMS) + strlen(uri_STREAM_ERR) + strlen(_stream_errors[err]) + 58;
if(content != NULL) len += strlen(content) + strlen(_stream_errors[err]) + 2;
buf = _sx_buffer_new(NULL, len, NULL, NULL);
len = 0;
if(s->state < state_STREAM)
len = sprintf(buf->data, "<stream:stream xmlns:stream='" uri_STREAMS "' version='1.0'>");
if(content == NULL)
len += sprintf(&(buf->data[len]), "<stream:error xmlns:stream='" uri_STREAMS "'><%s xmlns='" uri_STREAM_ERR "'/></stream:error>", _stream_errors[err]);
else
len += sprintf(&(buf->data[len]), "<stream:error xmlns:stream='" uri_STREAMS "'><%s xmlns='" uri_STREAM_ERR "'>%s</%s></stream:error>", _stream_errors[err], content, _stream_errors[err]);
if(s->state < state_STREAM)
len += sprintf(&(buf->data[len]), "</stream:stream>");
buf->len--;
assert(len == buf->len);
_sx_debug(ZONE, "prepared error: %.*s", buf->len, buf->data);
/* go */
jqueue_push(s->wbufq, buf, 0);
/* stuff to write */
s->want_write = 1;
}
/** send a new nad out */
int _sx_nad_write(sx_t s, nad_t nad, int elem) {
const char *out;
int len;
/* silently drop it if we're closing or closed */
if(s->state >= state_CLOSING) {
log_debug(ZONE, "stream closed, dropping outgoing packet");
nad_free(nad);
return 1;
}
/* run it through the plugins */
if(_sx_chain_nad_write(s, nad, elem) == 0)
return 1;
/* serialise it */
nad_print(nad, elem, &out, &len);
_sx_debug(ZONE, "queueing for write: %.*s", len, out);
/* ready to go */
jqueue_push(s->wbufq, _sx_buffer_new(out, len, NULL, NULL), 0);
nad_free(nad);
/* things to write */
s->want_write = 1;
return 0;
}
int sx_compress_client_compress(sx_plugin_t p, sx_t s, const char *pemfile) {
assert((int) (p != NULL));
assert((int) (s != NULL));
/* sanity */
if(s->type != type_CLIENT || s->state != state_STREAM) {
_sx_debug(ZONE, "wrong conn type or state for client compress");
return 1;
}
/* check if we're already compressed */
if((s->flags & SX_COMPRESS_WRAPPER) || s->compressed) {
_sx_debug(ZONE, "channel already compressed");
return 1;
}
_sx_debug(ZONE, "initiating compress sequence");
/* go */
jqueue_push(s->wbufq, _sx_buffer_new("<compress xmlns='" uri_COMPRESS "'><method>zlib</method></compress>", sizeof(uri_COMPRESS)-1 + 51, NULL, NULL), 0);
s->want_write = 1;
_sx_event(s, event_WANT_WRITE, NULL);
return 0;
}
/** we can write */
static int _sx_get_pending_write(sx_t s) {
sx_buf_t in, out;
int ret;
assert(s != NULL);
if (s->wbufpending != NULL) {
/* there's already a pending buffer ready to write */
return 0;
}
/* get the first buffer off the queue */
in = jqueue_pull(s->wbufq);
if(in == NULL) {
/* if there was a write event, and something is interested,
we still have to tell the plugins */
in = _sx_buffer_new(NULL, 0, NULL, NULL);
}
/* if there's more to write, we want to make sure we get it */
s->want_write = jqueue_size(s->wbufq);
/* make a copy for processing */
out = _sx_buffer_new(in->data, in->len, in->notify, in->notify_arg);
_sx_debug(ZONE, "encoding %d bytes for writing: %.*s", in->len, in->len, in->data);
/* run it by the plugins */
ret = _sx_chain_io_write(s, out);
if(ret <= 0) {
/* TODO/!!!: Are we leaking the 'out' buffer here? How about the 'in' buffer? */
if(ret == -1) {
/* temporary failure, push it back on the queue */
jqueue_push(s->wbufq, in, (s->wbufq->front != NULL) ? s->wbufq->front->priority : 0);
s->want_write = 1;
} else if(ret == -2) {
/* permanent failure, its all over */
/* !!! shut down */
s->want_read = s->want_write = 0;
return -1;
}
/* done */
return 0;
}
_sx_buffer_free(in);
if (out->len == 0)
/* if there's nothing to write, then we're done */
_sx_buffer_free(out);
else
s->wbufpending = out;
return 0;
}
/** send an error */
void _sx_error(sx_t s, int err, const char *text) {
int len = 0;
sx_buf_t buf;
/* open stream if not already */
if(s->state < state_STREAM) {
if (s->flags & SX_WEBSOCKET_WRAPPER)
jqueue_push(s->wbufq, _sx_buffer_new("<open xmlns='" uri_XFRAMING "' version='1.0' />", sizeof(uri_XFRAMING) + 30, NULL, NULL), 0);
else
jqueue_push(s->wbufq, _sx_buffer_new("<stream:stream xmlns:stream='" uri_STREAMS "' version='1.0'>", sizeof(uri_STREAMS) + 44, NULL, NULL), 0);
}
/* build the error */
len = strlen(uri_STREAMS) + strlen(uri_STREAM_ERR) + strlen(_stream_errors[err]) + 58;
if(text != NULL) len += strlen(uri_STREAM_ERR) + strlen(text) + 22;
buf = _sx_buffer_new(NULL, len, NULL, NULL);
if(text == NULL)
len = sprintf(buf->data, "<stream:error xmlns:stream='" uri_STREAMS "'><%s xmlns='" uri_STREAM_ERR "'/></stream:error>", _stream_errors[err]);
else
len = sprintf(buf->data, "<stream:error xmlns:stream='" uri_STREAMS "'><%s xmlns='" uri_STREAM_ERR "'/><text xmlns='" uri_STREAM_ERR "'>%s</text></stream:error>", _stream_errors[err], text);
buf->len--;
assert(len == buf->len);
_sx_debug(ZONE, "prepared error: %.*s", buf->len, buf->data);
jqueue_push(s->wbufq, buf, 0);
/* close the stream if needed */
if(s->state < state_STREAM) {
if (s->flags & SX_WEBSOCKET_WRAPPER)
jqueue_push(s->wbufq, _sx_buffer_new("<close xmlns='" uri_XFRAMING "' />", sizeof(uri_XFRAMING) + 17, NULL, NULL), 0);
else
jqueue_push(s->wbufq, _sx_buffer_new("</stream:stream>", 16, NULL, NULL), 0);
}
/* stuff to write */
s->want_write = 1;
}
/** send raw data out */
int _sx_raw_write(sx_t s, const char *buf, int len) {
/* siltently drop it if we're closing or closed */
if(s->state >= state_CLOSING) {
log_debug(ZONE, "stream closed, dropping outgoing raw data");
return 1;
}
_sx_debug(ZONE, "queuing for write: %.*s", len, buf);
/* ready to go */
jqueue_push(s->wbufq, _sx_buffer_new(buf, len, NULL, NULL), 0);
/* things to write */
s->want_write = 1;
return 0;
}
static void _route_remove(xht hroutes, const char *name, component_t comp) {
routes_t routes;
int i;
routes = xhash_get(hroutes, name);
if(routes == NULL) return;
if(routes->ncomp > 1) {
for(i = 0; i < routes->ncomp; i++) {
if(routes->comp[i] == comp) {
if(i != routes->ncomp - 1) {
routes->comp[i] = routes->comp[routes->ncomp - 1];
}
routes->ncomp--;
}
}
}
else {
jqueue_push(comp->r->deadroutes, (void *) routes, 0);
xhash_zap(hroutes, name);
}
}
/**
* process commandline
* @return: 0 to indicate that output needs to be written
*/
int _pbx_process_command(c2s_t c2s, char *cmd)
{
jid_t jid;
int action = 0, len;
sess_t sess;
unsigned char hashbuf[44] = "PBX";
unsigned char *sesshash;
sesshash = hashbuf+3;
/* get command */
if(!strncasecmp("START ", cmd, 6)) {
cmd += 6;
action = 1;
}
if(!strncasecmp("STOP ", cmd, 5)) {
cmd += 5;
action = 2;
}
if(action != 0) {
len = _pbx_command_part_len(cmd);
if(len > 0) {
jid = jid_new(cmd, len);
if(jid) {
cmd += len;
if(*cmd != '\0') cmd++;
shahash_r(jid_full(jid), sesshash);
sess = xhash_get(c2s->sessions, hashbuf);
switch(action) {
case 1:
log_debug(ZONE, "STARTing session for %s/%s (%s) with commandline: %s", jid_user(jid), jid->resource, hashbuf, cmd);
if(sess == NULL) {
/* create new session */
sess = (sess_t) calloc(1, sizeof(struct sess_st));
sess->c2s = c2s;
sess->last_activity = time(NULL);
/* put into sessions hash */
snprintf(sess->skey, sizeof(sess->skey), "%s", hashbuf);
xhash_put(c2s->sessions, sess->skey, (void *) sess);
/* generate bound resource */
sess->resources = (bres_t) calloc(1, sizeof(struct bres_st));
snprintf(sess->resources->c2s_id, sizeof(sess->resources->c2s_id), "%s", hashbuf);
sess->resources->jid = jid;
/* open SM session */
log_write(sess->c2s->log, LOG_NOTICE, "[PBX] requesting session: jid=%s", jid_full(jid));
sm_start(sess, sess->resources);
/* generate presence packet to get session online */
/* a bit hacky, but we need to emulate _some_ of the client behavior */
sess->result = _pbx_presence_nad(1, cmd);
}
else {
/* just send the presence */
sm_packet(sess, sess->resources, _pbx_presence_nad(1, cmd));
}
break;
case 2:
log_debug(ZONE, "STOPping session for %s/%s with commandline: %s", jid_user(jid), jid->resource, cmd);
if(sess != NULL) {
/* send unavailable presence */
sm_packet(sess, sess->resources, _pbx_presence_nad(0, cmd));
/* end the session */
sm_end(sess, sess->resources);
xhash_zap(c2s->sessions, sess->skey);
jqueue_push(c2s->dead_sess, (void *) sess, 0);
}
break;
}
/* TODO: respond with "OK", return 0 */
return -1;
}
}
/* TODO: generate "ERR" response, return 0 */
return -1;
}
if(!strncasecmp("STATUS", cmd, 6)) {
log_write(c2s->log, LOG_INFO, "STATUS PBX command not implemented yet");
return -1;
}
return -1;
}
static int _router_sx_callback(sx_t s, sx_event_t e, void *data, void *arg) {
component_t comp = (component_t) arg;
sx_buf_t buf = (sx_buf_t) data;
int rlen, len, attr, ns, sns, n;
sx_error_t *sxe;
nad_t nad;
struct jid_st sto, sfrom;
jid_static_buf sto_buf, sfrom_buf;
jid_t to, from;
alias_t alias;
/* init static jid */
jid_static(&sto,&sto_buf);
jid_static(&sfrom,&sfrom_buf);
switch(e) {
case event_WANT_READ:
log_debug(ZONE, "want read");
mio_read(comp->r->mio, comp->fd);
break;
case event_WANT_WRITE:
log_debug(ZONE, "want write");
mio_write(comp->r->mio, comp->fd);
break;
case event_READ:
log_debug(ZONE, "reading from %d", comp->fd->fd);
/* check rate limits */
if(comp->rate != NULL) {
if(rate_check(comp->rate) == 0) {
/* inform the app if we haven't already */
if(!comp->rate_log) {
log_write(comp->r->log, LOG_NOTICE, "[%s, port=%d] is being byte rate limited", comp->ip, comp->port);
comp->rate_log = 1;
}
log_debug(ZONE, "%d is throttled, delaying read", comp->fd->fd);
buf->len = 0;
return 0;
}
/* find out how much we can have */
rlen = rate_left(comp->rate);
if(rlen > buf->len)
rlen = buf->len;
}
/* no limit, just read as much as we can */
else
rlen = buf->len;
/* do the read */
len = recv(comp->fd->fd, buf->data, rlen, 0);
/* update rate limits */
if(comp->rate != NULL && len > 0) {
comp->rate_log = 0;
rate_add(comp->rate, len);
}
if(len < 0) {
if(MIO_WOULDBLOCK) {
buf->len = 0;
return 0;
}
log_debug(ZONE, "read failed: %s", strerror(errno));
sx_kill(comp->s);
return -1;
}
else if(len == 0) {
/* they went away */
sx_kill(comp->s);
return -1;
}
log_debug(ZONE, "read %d bytes", len);
buf->len = len;
return len;
case event_WRITE:
log_debug(ZONE, "writing to %d", comp->fd->fd);
len = send(comp->fd->fd, buf->data, buf->len, 0);
if(len >= 0) {
log_debug(ZONE, "%d bytes written", len);
return len;
}
if(MIO_WOULDBLOCK)
return 0;
log_debug(ZONE, "write failed: %s", strerror(errno));
sx_kill(comp->s);
return -1;
case event_ERROR:
sxe = (sx_error_t *) data;
log_write(comp->r->log, LOG_NOTICE, "[%s, port=%d] error: %s (%s)", comp->ip, comp->port, sxe->generic, sxe->specific);
break;
case event_STREAM:
/* legacy check */
if(s->ns == NULL || strcmp("jabber:component:accept", s->ns) != 0)
return 0;
/* component, old skool */
comp->legacy = 1;
/* enabled? */
if(comp->r->local_secret == NULL) {
sx_error(s, stream_err_INVALID_NAMESPACE, "support for legacy components not available"); /* !!! correct error? */
sx_close(s);
return 0;
}
/* sanity */
if(s->req_to == NULL) {
sx_error(s, stream_err_HOST_UNKNOWN, "no 'to' attribute on stream header");
sx_close(s);
return 0;
}
break;
case event_OPEN:
log_write(comp->r->log, LOG_NOTICE, "[%s, port=%d] authenticated as %s", comp->ip, comp->port, comp->s->auth_id);
/* make a route for legacy components */
if(comp->legacy) {
for(alias = comp->r->aliases; alias != NULL; alias = alias->next)
if(strcmp(alias->name, s->req_to) == 0) {
sx_error(s, stream_err_HOST_UNKNOWN, "requested name is aliased"); /* !!! correct error? */
sx_close(s);
return 0;
}
n = _route_add(comp->r->routes, s->req_to, comp, route_MULTI_FROM);
xhash_put(comp->routes, pstrdup(xhash_pool(comp->routes), s->req_to), (void *) comp);
if(n>1)
log_write(comp->r->log, LOG_NOTICE, "[%s]:%d online (bound to %s, port %d)", s->req_to, n, comp->ip, comp->port);
else
log_write(comp->r->log, LOG_NOTICE, "[%s] online (bound to %s, port %d)", s->req_to, comp->ip, comp->port);
/* advertise the name */
_router_advertise(comp->r, s->req_to, comp, 0);
/* this is a legacy component, so we don't tell it about other routes */
/* bind aliases */
for(alias = comp->r->aliases; alias != NULL; alias = alias->next) {
if(strcmp(alias->target, s->req_to) == 0) {
_route_add(comp->r->routes, alias->name, comp, route_MULTI_FROM);
xhash_put(comp->routes, pstrdup(xhash_pool(comp->routes), alias->name), (void *) comp);
log_write(comp->r->log, LOG_NOTICE, "[%s] online (alias of '%s', bound to %s, port %d)", alias->name, s->req_to, comp->ip, comp->port);
/* advertise name */
_router_advertise(comp->r, alias->name, comp, 0);
}
}
}
break;
case event_PACKET:
nad = (nad_t) data;
/* preauth */
if(comp->s->state == state_STREAM) {
/* non-legacy components can't do anything before auth */
if(!comp->legacy) {
log_debug(ZONE, "stream is preauth, dropping packet");
nad_free(nad);
return 0;
}
/* watch for handshake requests */
if(NAD_ENAME_L(nad, 0) != 9 || strncmp("handshake", NAD_ENAME(nad, 0), NAD_ENAME_L(nad, 0)) != 0) {
log_debug(ZONE, "unknown preauth packet %.*s, dropping", NAD_ENAME_L(nad, 0), NAD_ENAME(nad, 0));
nad_free(nad);
return 0;
}
/* process incoming handshakes */
_router_process_handshake(comp, nad);
return 0;
}
/* legacy processing */
if(comp->legacy) {
log_debug(ZONE, "packet from legacy component, munging it");
attr = nad_find_attr(nad, 0, -1, "to", NULL);
if(attr < 0 || (to = jid_reset(&sto, NAD_AVAL(nad, attr), NAD_AVAL_L(nad, attr))) == NULL) {
log_debug(ZONE, "invalid or missing 'to' address on legacy packet, dropping it");
nad_free(nad);
return 0;
}
attr = nad_find_attr(nad, 0, -1, "from", NULL);
if(attr < 0 || (from = jid_reset(&sfrom, NAD_AVAL(nad, attr), NAD_AVAL_L(nad, attr))) == NULL) {
log_debug(ZONE, "invalid or missing 'from' address on legacy packet, dropping it");
nad_free(nad);
return 0;
}
/* rewrite component packets into client packets */
ns = nad_find_namespace(nad, 0, "jabber:component:accept", NULL);
if(ns >= 0) {
if(nad->elems[0].ns == ns)
nad->elems[0].ns = nad->nss[nad->elems[0].ns].next;
else {
for(sns = nad->elems[0].ns; sns >= 0 && nad->nss[sns].next != ns; sns = nad->nss[sns].next);
nad->nss[sns].next = nad->nss[nad->nss[sns].next].next;
}
}
ns = nad_find_namespace(nad, 0, uri_CLIENT, NULL);
if(ns < 0) {
ns = nad_add_namespace(nad, uri_CLIENT, NULL);
nad->scope = -1;
nad->nss[ns].next = nad->elems[0].ns;
nad->elems[0].ns = ns;
}
nad->elems[0].my_ns = ns;
/* wrap up the packet */
ns = nad_add_namespace(nad, uri_COMPONENT, NULL);
nad_wrap_elem(nad, 0, ns, "route");
nad_set_attr(nad, 0, -1, "to", to->domain, 0);
nad_set_attr(nad, 0, -1, "from", from->domain, 0);
}
/* top element must be router scoped */
if(NAD_ENS(nad, 0) < 0 || NAD_NURI_L(nad, NAD_ENS(nad, 0)) != strlen(uri_COMPONENT) || strncmp(uri_COMPONENT, NAD_NURI(nad, NAD_ENS(nad, 0)), strlen(uri_COMPONENT)) != 0) {
log_debug(ZONE, "invalid packet namespace, dropping");
nad_free(nad);
return 0;
}
/* bind a name to this component */
if(NAD_ENAME_L(nad, 0) == 4 && strncmp("bind", NAD_ENAME(nad, 0), 4) == 0) {
_router_process_bind(comp, nad);
return 0;
}
/* unbind a name from this component */
if(NAD_ENAME_L(nad, 0) == 6 && strncmp("unbind", NAD_ENAME(nad, 0), 6) == 0) {
_router_process_unbind(comp, nad);
return 0;
}
/* route packets */
if(NAD_ENAME_L(nad, 0) == 5 && strncmp("route", NAD_ENAME(nad, 0), 5) == 0) {
_router_process_route(comp, nad);
return 0;
}
/* throttle packets */
if(NAD_ENAME_L(nad, 0) == 8 && strncmp("throttle", NAD_ENAME(nad, 0), 8) == 0) {
_router_process_throttle(comp, nad);
return 0;
}
log_debug(ZONE, "unknown packet, dropping");
nad_free(nad);
return 0;
case event_CLOSED:
{
/* close comp->fd by putting it in closefd ... unless it is already there */
_jqueue_node_t n;
for (n = comp->r->closefd->front; n != NULL; n = n->prev)
if (n->data == comp->fd) break;
if (!n) jqueue_push(comp->r->closefd, (void *) comp->fd, 0 /*priority*/);
return 0;
}
}
return 0;
}
int router_mio_callback(mio_t m, mio_action_t a, mio_fd_t fd, void *data, void *arg) {
component_t comp = (component_t) arg;
router_t r = (router_t) arg;
struct sockaddr_storage sa;
socklen_t namelen = sizeof(sa);
int port, nbytes;
switch(a) {
case action_READ:
log_debug(ZONE, "read action on fd %d", fd->fd);
/* they did something */
comp->last_activity = time(NULL);
ioctl(fd->fd, FIONREAD, &nbytes);
if(nbytes == 0) {
sx_kill(comp->s);
return 0;
}
return sx_can_read(comp->s);
case action_WRITE:
log_debug(ZONE, "write action on fd %d", fd->fd);
/* update activity timestamp */
comp->last_activity = time(NULL);
return sx_can_write(comp->s);
case action_CLOSE:
log_debug(ZONE, "close action on fd %d", fd->fd);
r = comp->r;
log_write(r->log, LOG_NOTICE, "[%s, port=%d] disconnect", comp->ip, comp->port);
/* unbind names */
xhash_walk(comp->routes, _router_route_unbind_walker, (void *) comp);
/* deregister component */
xhash_zap(r->components, comp->ipport);
xhash_free(comp->routes);
if(comp->tq != NULL)
/* !!! bounce packets */
jqueue_free(comp->tq);
rate_free(comp->rate);
jqueue_push(comp->r->dead, (void *) comp->s, 0);
free(comp);
break;
case action_ACCEPT:
log_debug(ZONE, "accept action on fd %d", fd->fd);
getpeername(fd->fd, (struct sockaddr *) &sa, &namelen);
port = j_inet_getport(&sa);
log_write(r->log, LOG_NOTICE, "[%s, port=%d] connect", (char *) data, port);
if(_router_accept_check(r, fd, (char *) data) != 0)
return 1;
comp = (component_t) calloc(1, sizeof(struct component_st));
comp->r = r;
comp->fd = fd;
snprintf(comp->ip, INET6_ADDRSTRLEN, "%s", (char *) data);
comp->port = port;
snprintf(comp->ipport, INET6_ADDRSTRLEN + 6, "%s:%d", comp->ip, comp->port);
comp->s = sx_new(r->sx_env, fd->fd, _router_sx_callback, (void *) comp);
mio_app(m, fd, router_mio_callback, (void *) comp);
if(r->byte_rate_total != 0)
comp->rate = rate_new(r->byte_rate_total, r->byte_rate_seconds, r->byte_rate_wait);
comp->routes = xhash_new(51);
/* register component */
log_debug(ZONE, "new component (%p) \"%s\"", comp, comp->ipport);
xhash_put(r->components, comp->ipport, (void *) comp);
#ifdef HAVE_SSL
sx_server_init(comp->s, SX_SSL_STARTTLS_OFFER | SX_SASL_OFFER);
#else
sx_server_init(comp->s, SX_SASL_OFFER);
#endif
break;
}
return 0;
}
int in_mio_callback(mio_t m, mio_action_t a, mio_fd_t fd, void *data, void *arg) {
conn_t in = (conn_t) arg;
s2s_t s2s = (s2s_t) arg;
struct sockaddr_storage sa;
int namelen = sizeof(sa), port, nbytes;
char ipport[INET6_ADDRSTRLEN + 17];
switch(a) {
case action_READ:
log_debug(ZONE, "read action on fd %d", fd->fd);
ioctl(fd->fd, FIONREAD, &nbytes);
if(nbytes == 0) {
sx_kill(in->s);
return 0;
}
return sx_can_read(in->s);
case action_WRITE:
log_debug(ZONE, "write action on fd %d", fd->fd);
return sx_can_write(in->s);
case action_CLOSE:
log_debug(ZONE, "close action on fd %d", fd->fd);
/* !!! logging */
log_write(in->s2s->log, LOG_NOTICE, "[%d] [%s, port=%d] disconnect, packets: %i", fd->fd, in->ip, in->port, in->packet_count);
jqueue_push(in->s2s->dead, (void *) in->s, 0);
/* remove from open streams hash if online, or open connections if not */
if (in->online)
xhash_zap(in->s2s->in, in->key);
else {
snprintf(ipport, INET6_ADDRSTRLEN + 16, "%s/%d", in->ip, in->port);
xhash_zap(in->s2s->in_accept, ipport);
}
jqueue_push(in->s2s->dead_conn, (void *) in, 0);
break;
case action_ACCEPT:
s2s = (s2s_t) arg;
log_debug(ZONE, "accept action on fd %d", fd->fd);
getpeername(fd->fd, (struct sockaddr *) &sa, &namelen);
port = j_inet_getport(&sa);
log_write(s2s->log, LOG_NOTICE, "[%d] [%s, port=%d] incoming connection", fd->fd, (char *) data, port);
/* new conn */
in = (conn_t) calloc(1, sizeof(struct conn_st));
in->s2s = s2s;
strncpy(in->ip, (char *) data, INET6_ADDRSTRLEN);
in->port = port;
in->states = xhash_new(101);
in->states_time = xhash_new(101);
in->fd = fd;
in->init_time = time(NULL);
in->s = sx_new(s2s->sx_env, in->fd->fd, _in_sx_callback, (void *) in);
mio_app(m, in->fd, in_mio_callback, (void *) in);
if(s2s->stanza_size_limit != 0)
in->s->rbytesmax = s2s->stanza_size_limit;
/* add to incoming connections hash */
snprintf(ipport, INET6_ADDRSTRLEN + 16, "%s/%d", in->ip, in->port);
xhash_put(s2s->in_accept, pstrdup(xhash_pool(s2s->in_accept),ipport), (void *) in);
#ifdef HAVE_SSL
sx_server_init(in->s, S2S_DB_HEADER | ((s2s->sx_ssl != NULL) ? SX_SSL_STARTTLS_OFFER : 0) );
#else
sx_server_init(in->s, S2S_DB_HEADER);
#endif
break;
}
return 0;
}
/** handler for read data */
void _sx_process_read(sx_t s, sx_buf_t buf) {
sx_error_t sxe;
nad_t nad;
char *errstring;
int i;
int ns, elem;
/* Note that buf->len can validly be 0 here, if we got data from
the socket but the plugin didn't return anything to us (e.g. a
SSL packet was split across a tcp segment boundary) */
/* count bytes parsed */
s->pbytes += buf->len;
/* parse it */
if(XML_Parse(s->expat, buf->data, buf->len, 0) == 0) {
/* only report error we haven't already */
if(!s->fail) {
/* parse error */
errstring = (char *) XML_ErrorString(XML_GetErrorCode(s->expat));
_sx_debug(ZONE, "XML parse error: %s, character %d: %.*s",
errstring, XML_GetCurrentByteIndex(s->expat) - s->tbytes, buf->len, buf->data);
_sx_gen_error(sxe, SX_ERR_XML_PARSE, "XML parse error", errstring);
_sx_event(s, event_ERROR, (void *) &sxe);
_sx_error(s, stream_err_XML_NOT_WELL_FORMED, errstring);
_sx_close(s);
_sx_buffer_free(buf);
return;
}
/* !!! is this the right thing to do? we should probably set
* s->fail and let the code further down handle it. */
_sx_buffer_free(buf);
return;
}
/* check if the stanza size limit is exceeded (it wasn't reset by parser) */
if(s->rbytesmax && s->pbytes > s->rbytesmax) {
/* parse error */
_sx_debug(ZONE, "maximum stanza size (%d) exceeded by reading %d bytes", s->rbytesmax, s->pbytes);
errstring = (char *) XML_ErrorString(XML_GetErrorCode(s->expat));
_sx_gen_error(sxe, SX_ERR_XML_PARSE, "stream read error", "Maximum stanza size exceeded");
_sx_event(s, event_ERROR, (void *) &sxe);
_sx_error(s, stream_err_POLICY_VIOLATION, errstring);
_sx_close(s);
_sx_buffer_free(buf);
return;
}
/* count bytes processed */
s->tbytes += buf->len;
/* done with the buffer */
_sx_buffer_free(buf);
/* process completed nads */
if(s->state >= state_STREAM)
while((nad = jqueue_pull(s->rnadq)) != NULL) {
int plugin_error;
#ifdef SX_DEBUG
const char *out; int len;
nad_print(nad, 0, &out, &len);
_sx_debug(ZONE, "completed nad: %.*s", len, out);
#endif
/* check for errors */
if(NAD_ENS(nad, 0) >= 0 && NAD_NURI_L(nad, NAD_ENS(nad, 0)) == strlen(uri_STREAMS) && strncmp(NAD_NURI(nad, NAD_ENS(nad, 0)), uri_STREAMS, strlen(uri_STREAMS)) == 0 && NAD_ENAME_L(nad, 0) == 5 && strncmp(NAD_ENAME(nad, 0), "error", 5) == 0) {
errstring = NULL;
/* get text error description if available - XMPP 4.7.2 */
if((ns = nad_find_scoped_namespace(nad, uri_STREAM_ERR, NULL)) >= 0)
if((elem = nad_find_elem(nad, 0, ns, "text", 1)) >= 0)
if(NAD_CDATA_L(nad, elem) > 0) {
errstring = (char *) malloc(sizeof(char) * (NAD_CDATA_L(nad, elem) + 1));
sprintf(errstring, "%.*s", NAD_CDATA_L(nad, elem), NAD_CDATA(nad, elem));
}
/* if not available, look for legacy error text as in <stream:error>description</stream:error> */
if (errstring == NULL && NAD_CDATA_L(nad, 0) > 0) {
errstring = (char *) malloc(sizeof(char) * (NAD_CDATA_L(nad, 0) + 1));
sprintf(errstring, "%.*s", NAD_CDATA_L(nad, 0), NAD_CDATA(nad, 0));
}
/* if not available, log the whole packet for debugging */
if (errstring == NULL) {
const char *xml;
int xlen;
nad_print(nad, 0, &xml, &xlen);
errstring = (char *) malloc(sizeof(char) * (xlen + 1));
sprintf(errstring, "%.*s", xlen, xml);
}
if(s->state < state_CLOSING) {
_sx_gen_error(sxe, SX_ERR_STREAM, "Stream error", errstring);
_sx_event(s, event_ERROR, (void *) &sxe);
_sx_state(s, state_CLOSING);
}
free(errstring);
nad_free(nad);
break;
}
/* check for close */
if ((s->flags & SX_WEBSOCKET_WRAPPER) && NAD_ENS(nad, 0) >= 0 && NAD_NURI_L(nad, NAD_ENS(nad, 0)) == strlen(uri_XFRAMING) && strncmp(NAD_NURI(nad, NAD_ENS(nad, 0)), uri_XFRAMING, strlen(uri_XFRAMING)) == 0 && NAD_ENAME_L(nad, 0) == 5 && strncmp(NAD_ENAME(nad, 0), "close", 5) == 0) {
_sx_debug(ZONE, "<close/> frame @ depth %d", s->depth);
s->fail = 1;
break;
}
/* run it by the plugins */
if(_sx_chain_nad_read(s, nad) == 0)
return;
/* now let the plugins process the completed nad */
plugin_error = 0;
if(s->env != NULL)
for(i = 0; i < s->env->nplugins; i++)
if(s->env->plugins[i]->process != NULL) {
int plugin_ret;
plugin_ret = (s->env->plugins[i]->process)(s, s->env->plugins[i], nad);
if(plugin_ret == 0) {
plugin_error ++;
break;
}
}
/* hand it to the app */
if ((plugin_error == 0) && (s->state < state_CLOSING))
_sx_event(s, event_PACKET, (void *) nad);
}
/* something went wrong, bail */
if(s->fail) {
_sx_close(s);
return;
}
/* stream was closed */
if(s->depth < 0 && s->state < state_CLOSING) {
/* close the stream if necessary */
if(s->state >= state_STREAM_SENT) {
if (s->flags & SX_WEBSOCKET_WRAPPER)
jqueue_push(s->wbufq, _sx_buffer_new("<close xmlns='" uri_XFRAMING "' />", sizeof(uri_XFRAMING) + 17, NULL, NULL), 0);
else
jqueue_push(s->wbufq, _sx_buffer_new("</stream:stream>", 16, NULL, NULL), 0);
s->want_write = 1;
}
_sx_state(s, state_CLOSING);
return;
}
}
static int _sx_compress_process(sx_t s, sx_plugin_t p, nad_t nad) {
int flags;
char *ns = NULL, *to = NULL, *from = NULL, *version = NULL;
sx_error_t sxe;
/* not interested if we're a server and we never offered it */
if(s->type == type_SERVER && !(s->flags & SX_COMPRESS_OFFER))
return 1;
/* only want compress packets */
if(NAD_ENS(nad, 0) < 0 || NAD_NURI_L(nad, NAD_ENS(nad, 0)) != sizeof(uri_COMPRESS)-1 || strncmp(NAD_NURI(nad, NAD_ENS(nad, 0)), uri_COMPRESS, sizeof(uri_COMPRESS)-1) != 0)
return 1;
/* compress from client */
if(s->type == type_SERVER) {
if(NAD_ENAME_L(nad, 0) == 8 && strncmp(NAD_ENAME(nad, 0), "compress", 8) == 0) {
nad_free(nad);
/* can't go on if we've been here before */
if(s->compressed) {
_sx_debug(ZONE, "compress requested on already compressed channel, dropping packet");
return 0;
}
_sx_debug(ZONE, "compress requested, setting up");
/* go ahead */
jqueue_push(s->wbufq, _sx_buffer_new("<compressed xmlns='" uri_COMPRESS "'/>", sizeof(uri_COMPRESS)-1 + 22, _sx_compress_notify_compress, NULL), 0);
s->want_write = 1;
/* handled the packet */
return 0;
}
}
else if(s->type == type_CLIENT) {
/* kick off the handshake */
if(NAD_ENAME_L(nad, 0) == 7 && strncmp(NAD_ENAME(nad, 0), "compressed", 7) == 0) {
nad_free(nad);
/* save interesting bits */
flags = s->flags;
if(s->ns != NULL) ns = strdup(s->ns);
if(s->req_to != NULL) to = strdup(s->req_to);
if(s->req_from != NULL) from = strdup(s->req_from);
if(s->req_version != NULL) version = strdup(s->req_version);
/* reset state */
_sx_reset(s);
_sx_debug(ZONE, "server ready for compression, starting");
/* second time round */
sx_client_init(s, flags | SX_COMPRESS_WRAPPER, ns, to, from, version);
/* free bits */
if(ns != NULL) free(ns);
if(to != NULL) free(to);
if(from != NULL) free(from);
if(version != NULL) free(version);
return 0;
}
/* busted server */
if(NAD_ENAME_L(nad, 0) == 7 && strncmp(NAD_ENAME(nad, 0), "failure", 7) == 0) {
nad_free(nad);
_sx_debug(ZONE, "server can't handle compression, business as usual");
_sx_gen_error(sxe, SX_ERR_COMPRESS_FAILURE, "compress failure", "Server was unable to establish compression");
_sx_event(s, event_ERROR, (void *) &sxe);
return 0;
}
}
_sx_debug(ZONE, "unknown compress namespace element '%.*s', dropping packet", NAD_ENAME_L(nad, 0), NAD_ENAME(nad, 0));
nad_free(nad);
return 0;
}