static void _router_process_handshake(component_t comp, nad_t nad) {
char *hash;
int hashlen;
/* must have a hash as cdata */
if(NAD_CDATA_L(nad, 0) != 40) {
log_debug(ZONE, "handshake isn't long enough to be a sha1 hash");
sx_error(comp->s, stream_err_NOT_AUTHORIZED, "handshake isn't long enough to be a sha1 hash");
sx_close(comp->s);
nad_free(nad);
return;
}
/* make room for shahash_r to work .. needs at least 41 chars */
hashlen = strlen(comp->s->id) + strlen(comp->r->local_secret) + 1;
if(hashlen < 41)
hashlen = 41;
/* build the creds and hash them */
hash = (char *) malloc(sizeof(char) * hashlen);
sprintf(hash, "%s%s", comp->s->id, comp->r->local_secret);
shahash_r(hash, hash);
/* check */
log_debug(ZONE, "checking their hash %.*s against our hash %s", 40, NAD_CDATA(nad, 0), hash);
if(strncmp(hash, NAD_CDATA(nad, 0), 40) == 0) {
log_debug(ZONE, "handshake succeeded");
free(hash);
/* respond */
nad->elems[0].icdata = nad->elems[0].itail = -1;
nad->elems[0].lcdata = nad->elems[0].ltail = 0;
sx_nad_write(comp->s, nad);
sx_auth(comp->s, "handshake", comp->s->req_to);
return;
}
log_debug(ZONE, "auth failed");
free(hash);
/* failed, let them know */
sx_error(comp->s, stream_err_NOT_AUTHORIZED, "hash didn't match, auth failed");
sx_close(comp->s);
nad_free(nad);
}
static int _sx_compress_wio(sx_t s, sx_plugin_t p, sx_buf_t buf) {
_sx_compress_conn_t sc = (_sx_compress_conn_t) s->plugin_data[p->index];
int ret;
sx_error_t sxe;
/* only bothering if they asked for wrappermode */
if(!(s->flags & SX_COMPRESS_WRAPPER) || !s->compressed)
return 1;
_sx_debug(ZONE, "in _sx_compress_wio");
/* move the data into the zlib write buffer */
if(buf->len > 0) {
_sx_debug(ZONE, "loading %d bytes into zlib write buffer", buf->len);
_sx_buffer_alloc_margin(sc->wbuf, 0, buf->len);
memcpy(sc->wbuf->data + sc->wbuf->len, buf->data, buf->len);
sc->wbuf->len += buf->len;
_sx_buffer_clear(buf);
}
/* compress the data */
if(sc->wbuf->len > 0) {
sc->wstrm.avail_in = sc->wbuf->len;
sc->wstrm.next_in = sc->wbuf->data;
/* deflate() on write buffer until there is data to compress */
do {
/* make place for deflated data */
_sx_buffer_alloc_margin(buf, 0, sc->wbuf->len + SX_COMPRESS_CHUNK);
sc->wstrm.avail_out = sc->wbuf->len + SX_COMPRESS_CHUNK;
sc->wstrm.next_out = buf->data + buf->len;
ret = deflate(&(sc->wstrm), Z_SYNC_FLUSH);
assert(ret != Z_STREAM_ERROR);
buf->len += sc->wbuf->len + SX_COMPRESS_CHUNK - sc->wstrm.avail_out;
} while (sc->wstrm.avail_out == 0);
if(ret != Z_OK || sc->wstrm.avail_in != 0) {
/* throw an error */
_sx_gen_error(sxe, SX_ERR_COMPRESS, "compression error", "Error during compression");
_sx_event(s, event_ERROR, (void *) &sxe);
sx_error(s, stream_err_INTERNAL_SERVER_ERROR, "Error during compression");
sx_close(s);
return -2; /* fatal */
}
sc->wbuf->len = sc->wstrm.avail_in;
sc->wbuf->data = sc->wstrm.next_in;
}
_sx_debug(ZONE, "passing %d bytes from zlib write buffer", buf->len);
return 1;
}
int _s2s_check_conn_routes(s2s_t s2s, conn_t conn, const char *direction)
{
char *rkey;
int rkeylen;
conn_state_t state;
time_t now, dialback_time;
now = time(NULL);
if(xhash_iter_first(conn->states))
do {
/* retrieve state in a separate operation, as sizeof(int) != sizeof(void *) on 64-bit platforms,
so passing a pointer to state in xhash_iter_get is unsafe */
xhash_iter_get(conn->states, (const char **) &rkey, &rkeylen, NULL);
state = (conn_state_t) xhash_getx(conn->states, rkey, rkeylen);
if (state == conn_INPROGRESS) {
dialback_time = (time_t) xhash_getx(conn->states_time, rkey, rkeylen);
if(now > dialback_time + s2s->check_queue) {
log_write(s2s->log, LOG_NOTICE, "[%d] [%s, port=%d] dialback for %s route '%.*s' timed out", conn->fd->fd, conn->ip, conn->port, direction, rkeylen, rkey);
xhash_zapx(conn->states, rkey, rkeylen);
xhash_zapx(conn->states_time, rkey, rkeylen);
/* stream error */
sx_error(conn->s, stream_err_CONNECTION_TIMEOUT, "dialback timed out");
/* close connection as per XMPP/RFC3920 */
sx_close(conn->s);
/* indicate that we closed the connection */
return 0;
}
}
} while(xhash_iter_next(conn->states));
/* all ok */
return 1;
}
static void _c2s_time_checks(c2s_t c2s) {
sess_t sess;
time_t now;
union xhashv xhv;
now = time(NULL);
if(xhash_iter_first(c2s->sessions))
do {
xhv.sess_val = &sess;
xhash_iter_get(c2s->sessions, NULL, NULL, xhv.val);
if(!sess->s) continue;
if(c2s->io_check_idle > 0 && now > sess->last_activity + c2s->io_check_idle) {
log_write(c2s->log, LOG_NOTICE, "[%d] [%s, port=%d] timed out", sess->fd->fd, sess->ip, sess->port);
sx_error(sess->s, stream_err_HOST_GONE, "connection timed out");
sx_close(sess->s);
continue;
}
if(c2s->io_check_keepalive > 0 && now > sess->last_activity + c2s->io_check_keepalive && sess->s->state >= state_STREAM) {
log_debug(ZONE, "sending keepalive for %d", sess->fd->fd);
sx_raw_write(sess->s, " ", 1);
}
if(sess->rate != NULL && sess->rate->bad != 0 && rate_check(sess->rate) != 0) {
/* read the pending bytes when rate limit is no longer in effect */
log_debug(ZONE, "reading throttled %d", sess->fd->fd);
sess->s->want_read = 1;
sx_can_read(sess->s);
}
} while(xhash_iter_next(c2s->sessions));
}
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;
}
static void _s2s_time_checks(s2s_t s2s) {
conn_t conn;
time_t now;
char *rkey, *key;
int keylen;
jqueue_t q;
dnscache_t dns;
char *c;
int c_len;
union xhashv xhv;
now = time(NULL);
/* queue expiry */
if(s2s->check_queue > 0) {
if(xhash_iter_first(s2s->outq))
do {
xhv.jq_val = &q;
xhash_iter_get(s2s->outq, (const char **) &rkey, &keylen, xhv.val);
log_debug(ZONE, "running time checks for %.*s", keylen, rkey);
c = memchr(rkey, '/', keylen);
c++;
c_len = keylen - (c - rkey);
/* dns lookup timeout check first */
dns = xhash_getx(s2s->dnscache, c, c_len);
if(dns != NULL && dns->pending) {
log_debug(ZONE, "dns lookup pending for %.*s", c_len, c);
if(now > dns->init_time + s2s->check_queue) {
log_write(s2s->log, LOG_NOTICE, "dns lookup for %.*s timed out", c_len, c);
/* bounce queue */
out_bounce_route_queue(s2s, rkey, keylen, stanza_err_REMOTE_SERVER_NOT_FOUND);
/* expire pending dns entry */
xhash_zap(s2s->dnscache, dns->name);
xhash_free(dns->results);
if (dns->query != NULL) {
if (dns->query->query != NULL)
dns_cancel(NULL, dns->query->query);
xhash_free(dns->query->hosts);
xhash_free(dns->query->results);
free(dns->query->name);
free(dns->query);
}
free(dns);
}
continue;
}
/* get the conn */
conn = xhash_getx(s2s->out_dest, c, c_len);
if(conn == NULL) {
if(jqueue_size(q) > 0) {
/* no pending conn? perhaps it failed? */
log_debug(ZONE, "no pending connection for %.*s, bouncing %i packets in queue", c_len, c, jqueue_size(q));
/* bounce queue */
out_bounce_route_queue(s2s, rkey, keylen, stanza_err_REMOTE_SERVER_TIMEOUT);
}
continue;
}
/* connect timeout check */
if(!conn->online && now > conn->init_time + s2s->check_queue) {
dnsres_t bad;
char *ipport;
log_write(s2s->log, LOG_NOTICE, "[%d] [%s, port=%d] connection to %s timed out", conn->fd->fd, conn->ip, conn->port, c);
if (s2s->dns_bad_timeout > 0) {
/* mark this host as bad */
ipport = dns_make_ipport(conn->ip, conn->port);
bad = xhash_get(s2s->dns_bad, ipport);
if (bad == NULL) {
bad = (dnsres_t) calloc(1, sizeof(struct dnsres_st));
bad->key = ipport;
xhash_put(s2s->dns_bad, ipport, bad);
} else {
free(ipport);
}
bad->expiry = time(NULL) + s2s->dns_bad_timeout;
}
/* close connection as per XMPP/RFC3920 */
/* the close function will retry or bounce the queue */
sx_close(conn->s);
}
} while(xhash_iter_next(s2s->outq));
}
/* expiry of connected routes in conn_INPROGRESS state */
if(s2s->check_queue > 0) {
/* outgoing connections */
if(s2s->out_reuse) {
if(xhash_iter_first(s2s->out_host))
do {
xhv.conn_val = &conn;
xhash_iter_get(s2s->out_host, (const char **) &key, &keylen, xhv.val);
log_debug(ZONE, "checking dialback state for outgoing conn %.*s", keylen, key);
if (_s2s_check_conn_routes(s2s, conn, "outgoing")) {
log_debug(ZONE, "checking pending verify requests for outgoing conn %.*s", keylen, key);
if (conn->verify > 0 && now > conn->last_verify + s2s->check_queue) {
log_write(s2s->log, LOG_NOTICE, "[%d] [%s, port=%d] dialback verify request timed out", conn->fd->fd, conn->ip, conn->port);
sx_error(conn->s, stream_err_CONNECTION_TIMEOUT, "dialback verify request timed out");
sx_close(conn->s);
}
}
} while(xhash_iter_next(s2s->out_host));
} else {
if(xhash_iter_first(s2s->out_dest))
do {
xhv.conn_val = &conn;
xhash_iter_get(s2s->out_dest, (const char **) &key, &keylen, xhv.val);
log_debug(ZONE, "checking dialback state for outgoing conn %s (%s)", conn->dkey, conn->key);
if (_s2s_check_conn_routes(s2s, conn, "outgoing")) {
log_debug(ZONE, "checking pending verify requests for outgoing conn %s (%s)", conn->dkey, conn->key);
if (conn->verify > 0 && now > conn->last_verify + s2s->check_queue) {
log_write(s2s->log, LOG_NOTICE, "[%d] [%s, port=%d] dialback verify request timed out", conn->fd->fd, conn->ip, conn->port);
sx_error(conn->s, stream_err_CONNECTION_TIMEOUT, "dialback verify request timed out");
sx_close(conn->s);
}
}
} while(xhash_iter_next(s2s->out_dest));
}
/* incoming open streams */
if(xhash_iter_first(s2s->in))
do {
xhv.conn_val = &conn;
xhash_iter_get(s2s->in, (const char **) &key, &keylen, xhv.val);
log_debug(ZONE, "checking dialback state for incoming conn %.*s", keylen, key);
if (_s2s_check_conn_routes(s2s, conn, "incoming"))
/* if the connection is still valid, check that dialbacks have been initiated */
if(!xhash_count(conn->states) && now > conn->init_time + s2s->check_queue) {
log_write(s2s->log, LOG_NOTICE, "[%d] [%s, port=%d] no dialback started", conn->fd->fd, conn->ip, conn->port);
sx_error(conn->s, stream_err_CONNECTION_TIMEOUT, "no dialback initiated");
sx_close(conn->s);
}
} while(xhash_iter_next(s2s->in));
/* incoming open connections (not yet streams) */
if(xhash_iter_first(s2s->in_accept))
do {
xhv.conn_val = &conn;
xhash_iter_get(s2s->in_accept, (const char **) &key, &keylen, xhv.val);
log_debug(ZONE, "checking stream connection state for incoming conn %i", conn->fd->fd);
if(!conn->online && now > conn->init_time + s2s->check_queue) {
log_write(s2s->log, LOG_NOTICE, "[%d] [%s, port=%d] stream initiation timed out", conn->fd->fd, conn->ip, conn->port);
sx_close(conn->s);
}
} while(xhash_iter_next(s2s->in_accept));
}
/* keepalives */
if(s2s->out_reuse) {
if(xhash_iter_first(s2s->out_host))
do {
xhv.conn_val = &conn;
xhash_iter_get(s2s->out_host, NULL, NULL, xhv.val);
if(s2s->check_keepalive > 0 && conn->last_activity > 0 && now > conn->last_activity + s2s->check_keepalive && conn->s->state >= state_STREAM) {
log_debug(ZONE, "sending keepalive for %d", conn->fd->fd);
sx_raw_write(conn->s, " ", 1);
}
} while(xhash_iter_next(s2s->out_host));
} else {
if(xhash_iter_first(s2s->out_dest))
do {
xhv.conn_val = &conn;
xhash_iter_get(s2s->out_dest, NULL, NULL, xhv.val);
if(s2s->check_keepalive > 0 && conn->last_activity > 0 && now > conn->last_activity + s2s->check_keepalive && conn->s->state >= state_STREAM) {
log_debug(ZONE, "sending keepalive for %d", conn->fd->fd);
sx_raw_write(conn->s, " ", 1);
}
} while(xhash_iter_next(s2s->out_dest));
}
/* idle timeouts - disconnect connections through which no packets have been sent for <idle> seconds */
if(s2s->check_idle > 0) {
/* outgoing connections */
if(s2s->out_reuse) {
if(xhash_iter_first(s2s->out_host))
do {
xhv.conn_val = &conn;
xhash_iter_get(s2s->out_host, (const char **) &key, &keylen, xhv.val);
log_debug(ZONE, "checking idle state for %.*s", keylen, key);
if (conn->last_packet > 0 && now > conn->last_packet + s2s->check_idle && conn->s->state >= state_STREAM) {
log_write(s2s->log, LOG_NOTICE, "[%d] [%s, port=%d] idle timeout", conn->fd->fd, conn->ip, conn->port);
sx_close(conn->s);
}
} while(xhash_iter_next(s2s->out_host));
} else {
if(xhash_iter_first(s2s->out_dest))
do {
xhv.conn_val = &conn;
xhash_iter_get(s2s->out_dest, (const char **) &key, &keylen, xhv.val);
log_debug(ZONE, "checking idle state for %s (%s)", conn->dkey, conn->key);
if (conn->last_packet > 0 && now > conn->last_packet + s2s->check_idle && conn->s->state >= state_STREAM) {
log_write(s2s->log, LOG_NOTICE, "[%d] [%s, port=%d] idle timeout", conn->fd->fd, conn->ip, conn->port);
sx_close(conn->s);
}
} while(xhash_iter_next(s2s->out_dest));
}
/* incoming connections */
if(xhash_iter_first(s2s->in))
do {
xhv.conn_val = &conn;
xhash_iter_get(s2s->in, (const char **) &key, &keylen, xhv.val);
log_debug(ZONE, "checking idle state for %.*s", keylen, key);
if (conn->last_packet > 0 && now > conn->last_packet + s2s->check_idle && conn->s->state >= state_STREAM) {
log_write(s2s->log, LOG_NOTICE, "[%d] [%s, port=%d] idle timeout", conn->fd->fd, conn->ip, conn->port);
sx_close(conn->s);
}
} while(xhash_iter_next(s2s->in));
}
return;
}
static int _sx_compress_rio(sx_t s, sx_plugin_t p, sx_buf_t buf) {
_sx_compress_conn_t sc = (_sx_compress_conn_t) s->plugin_data[p->index];
int ret;
sx_error_t sxe;
/* only bothering if they asked for wrappermode */
if(!(s->flags & SX_COMPRESS_WRAPPER) || !s->compressed)
return 1;
_sx_debug(ZONE, "in _sx_compress_rio");
/* move the data into the zlib read buffer */
if(buf->len > 0) {
_sx_debug(ZONE, "loading %d bytes into zlib read buffer", buf->len);
_sx_buffer_alloc_margin(sc->rbuf, 0, buf->len);
memcpy(sc->rbuf->data + sc->rbuf->len, buf->data, buf->len);
sc->rbuf->len += buf->len;
_sx_buffer_clear(buf);
}
/* decompress the data */
if(sc->rbuf->len > 0) {
sc->rstrm.avail_in = sc->rbuf->len;
sc->rstrm.next_in = sc->rbuf->data;
/* run inflate() on read buffer while able to fill the output buffer */
do {
/* make place for inflated data */
_sx_buffer_alloc_margin(buf, 0, SX_COMPRESS_CHUNK);
sc->rstrm.avail_out = SX_COMPRESS_CHUNK;
sc->rstrm.next_out = buf->data + buf->len;
ret = inflate(&(sc->rstrm), Z_SYNC_FLUSH);
assert(ret != Z_STREAM_ERROR);
switch (ret) {
case Z_NEED_DICT:
case Z_DATA_ERROR:
case Z_MEM_ERROR:
/* throw an error */
_sx_gen_error(sxe, SX_ERR_COMPRESS, "compression error", "Error during decompression");
_sx_event(s, event_ERROR, (void *) &sxe);
sx_error(s, stream_err_INVALID_XML, "Error during decompression");
sx_close(s);
return -2;
}
buf->len += SX_COMPRESS_CHUNK - sc->rstrm.avail_out;
} while (sc->rstrm.avail_out == 0);
sc->rbuf->len = sc->rstrm.avail_in;
sc->rbuf->data = sc->rstrm.next_in;
}
_sx_debug(ZONE, "passing %d bytes from zlib read buffer", buf->len);
/* flag if we want to read */
if(sc->rbuf->len > 0)
s->want_read = 1;
if(buf->len == 0)
return 0;
return 1;
}