/** 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;
}
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;
}
