/** register get handler */
static void _authreg_register_get(c2s_t c2s, sess_t sess, nad_t nad) {
int attr, ns;
char id[128];
/* registrations can happen if reg is enabled and we can create users and set passwords */
if(sess->active || !(sess->host->ar->set_password != NULL && sess->host->ar->create_user != NULL &&
(sess->host->ar_register_enable || sess->host->ar_register_oob))) {
sx_nad_write(sess->s, stanza_tofrom(stanza_error(nad, 0, stanza_err_NOT_ALLOWED), 0));
return;
}
/* extract the id */
attr = nad_find_attr(nad, 0, -1, "id", NULL);
if(attr >= 0)
snprintf(id, 128, "%.*s", NAD_AVAL_L(nad, attr), NAD_AVAL(nad, attr));
nad_free(nad);
/* build a result packet */
nad = nad_new();
ns = nad_add_namespace(nad, uri_CLIENT, NULL);
nad_append_elem(nad, ns, "iq", 0);
nad_append_attr(nad, -1, "type", "result");
if(attr >= 0)
nad_append_attr(nad, -1, "id", id);
ns = nad_add_namespace(nad, uri_REGISTER, NULL);
nad_append_elem(nad, ns, "query", 1);
nad_append_elem(nad, ns, "instructions", 2);
nad_append_cdata(nad, sess->host->ar_register_instructions, strlen(sess->host->ar_register_instructions), 3);
if(sess->host->ar_register_enable) {
nad_append_elem(nad, ns, "username", 2);
nad_append_elem(nad, ns, "password", 2);
}
if(sess->host->ar_register_oob) {
int ns = nad_add_namespace(nad, uri_OOB, NULL);
nad_append_elem(nad, ns, "x", 2);
nad_append_elem(nad, ns, "url", 3);
nad_append_cdata(nad, sess->host->ar_register_oob, strlen(sess->host->ar_register_oob), 4);
}
/* give it back to the client */
sx_nad_write(sess->s, nad);
}
/** make a new action route */
static nad_t _sm_build_route(sess_t sess, bres_t res, const char *action, const char *target, const char *id) {
nad_t nad;
int ns, ans;
nad = nad_new();
ns = nad_add_namespace(nad, uri_COMPONENT, NULL);
nad_append_elem(nad, ns, "route", 0);
nad_append_attr(nad, -1, "to", sess->smcomp?sess->smcomp:((char *) res->jid->domain));
nad_append_attr(nad, -1, "from", sess->c2s->id);
ans = nad_add_namespace(nad, uri_SESSION, "sc");
nad_append_elem(nad, ans, "session", 1);
if(res->c2s_id[0] != '\0')
nad_append_attr(nad, ans, "c2s", res->c2s_id);
if(res->sm_id[0] != '\0')
nad_append_attr(nad, ans, "sm", res->sm_id);
nad_append_attr(nad, -1, "action", action);
if(target != NULL) {
nad_set_attr(nad, 0, -1, "target", target, NULL);
nad_append_attr(nad, -1, "target", target);
}
if(id != NULL)
nad_append_attr(nad, -1, "id", id);
log_debug(ZONE, "built new route nad for %s action %s target %s id %s", jid_full(res->jid), action, target, id);
return nad;
}
/** domain advertisement */
static void _router_advertise(router_t r, const char *domain, component_t src, int unavail) {
struct broadcast_st bc;
int ns;
log_debug(ZONE, "advertising %s to all routes (unavail=%d)", domain, unavail);
bc.r = r;
bc.src = src;
/* create a new packet */
bc.nad = nad_new();
ns = nad_add_namespace(bc.nad, uri_COMPONENT, NULL);
nad_append_elem(bc.nad, ns, "presence", 0);
nad_append_attr(bc.nad, -1, "from", domain);
if(unavail)
nad_append_attr(bc.nad, -1, "type", "unavailable");
xhash_walk(r->routes, _router_broadcast, (void *) &bc);
nad_free(bc.nad);
}
/** send a new action route */
void sm_c2s_action(sess_t dest, const char *action, const char *target) {
nad_t nad;
int rns, sns;
nad = nad_new();
rns = nad_add_namespace(nad, uri_COMPONENT, NULL);
nad_append_elem(nad, rns, "route", 0);
nad_append_attr(nad, -1, "to", dest->c2s);
nad_append_attr(nad, -1, "from", dest->user->sm->id);
sns = nad_add_namespace(nad, uri_SESSION, "sc");
nad_append_elem(nad, sns, "session", 1);
if (dest->c2s_id[0] != '\0')
nad_append_attr(nad, sns, "c2s", dest->c2s_id);
if (dest->sm_id[0] != '\0')
nad_append_attr(nad, sns, "sm", dest->sm_id);
nad_append_attr(nad, -1, "action", action);
if (target != NULL)
nad_append_attr(nad, -1, "target", target);
log_debug(ZONE,
"routing nad to %s from %s c2s %s s2s %s action %s target %s",
dest->c2s, dest->user->sm->id, dest->c2s_id, dest->sm_id,
action, target);
sx_nad_write(dest->user->sm->router, nad);
}
static void _config_startElement(void *arg, const char *name, const char **atts)
{
struct build_data *bd = (struct build_data *) arg;
int i = 0;
nad_append_elem(bd->nad, -1, (char *) name, bd->depth);
while(atts[i] != NULL)
{
nad_append_attr(bd->nad, -1, (char *) atts[i], (char *) atts[i + 1]);
i += 2;
}
bd->depth++;
}
static mod_ret_t _pep_out_sess(mod_instance_t mi, sess_t sess, pkt_t pkt) {
/* add pep identity to disco results from bare JID */
if(!(pkt->type & pkt_IQ) || pkt->ns != ns_DISCO_INFO || (pkt->from != NULL && strcmp(jid_user(sess->jid), jid_full(pkt->from))))
return mod_PASS;
/* add PEP identity */
nad_append_elem(pkt->nad, -1, "identity", 3);
nad_append_attr(pkt->nad, -1, "category", "pubsub");
nad_append_attr(pkt->nad, -1, "type", "pep");
nad_append_elem(pkt->nad, -1, "feature", 3);
nad_append_attr(pkt->nad, -1, "var", uri_PUBSUB "#access-presence");
nad_append_elem(pkt->nad, -1, "feature", 3);
nad_append_attr(pkt->nad, -1, "var", uri_PUBSUB "#auto-create");
nad_append_elem(pkt->nad, -1, "feature", 3);
nad_append_attr(pkt->nad, -1, "var", uri_PUBSUB "#auto-subscribe");
nad_append_elem(pkt->nad, -1, "feature", 3);
nad_append_attr(pkt->nad, -1, "var", uri_PUBSUB "#filtered-notifications");
nad_append_elem(pkt->nad, -1, "feature", 3);
nad_append_attr(pkt->nad, -1, "var", uri_PUBSUB "#publish");
return mod_PASS;
}
pkt_t amp_build_response_pkt(pkt_t pkt, amp_rule_t rule) {
if (!pkt || !rule) return NULL;
if (rule->result == AMP_TRIGGERED) {
int ns;
pkt_t res = pkt_create(pkt->sm, "message", NULL, jid_full(pkt->from), jid_full(pkt->to));
pkt_id(pkt, res);
ns = nad_add_namespace(res->nad, uri_AMP, NULL);
nad_append_elem(res->nad, ns, "amp", 2);
nad_append_attr(res->nad, -1, "status", rule->action);
nad_append_attr(res->nad, -1, "from", jid_full(pkt->from));
nad_append_attr(res->nad, -1, "to", jid_full(pkt->to));
nad_append_elem(res->nad, ns, "rule", 3);
nad_append_attr(res->nad, -1, "condition", rule->condition);
nad_append_attr(res->nad, -1, "value", rule->value);
nad_append_attr(res->nad, -1, "action", rule->action);
return res;
}
return NULL;
}
static nad_t _pbx_presence_nad(int available, char *cmd)
{
nad_t nad;
int ns;
char *show = NULL;
nad = nad_new();
ns = nad_add_namespace(nad, uri_CLIENT, NULL);
nad_append_elem(nad, ns, "presence", 0);
if(!available) {
nad_append_attr(nad, -1, "type", "unavailable");
}
else {
char *cont;
long int priority;
char prioritystr[5]; // -128 to +127 + \0
priority = strtol(cmd, &cont, 10);
log_debug(ZONE, "Read %ld priority", priority);
if(cmd == cont) priority = -1; // use -1 priority if not given
if(priority < -128) priority = -128;
if(priority > 127) priority = 127;
nad_append_elem(nad, -1, "priority", 1);
snprintf(prioritystr, 5, "%ld", priority);
nad_append_cdata(nad, prioritystr, strlen(prioritystr), 2);
if(cmd != cont) {
cmd = cont;
while(*cmd == ' ') { cmd++; }
}
if(!strncmp("CHAT", cmd, 4)) {
cmd += 4;
show = "chat";
}
if(!strncmp("ONLINE", cmd, 6)) {
cmd += 6;
}
if(!strncmp("DND", cmd, 3)) {
cmd += 3;
show = "dnd";
}
if(!strncmp("AWAY", cmd, 4)) {
cmd += 4;
show = "away";
}
if(!strncmp("XA", cmd, 2)) {
cmd += 2;
show = "xa";
}
if(show) {
nad_append_elem(nad, -1, "show", 1);
nad_append_cdata(nad, show, strlen(show), 2);
}
}
while(*cmd == ' ') { cmd++; }
if(*cmd != '\0' && *cmd != '\n') {
int len = strlen(cmd);
nad_append_elem(nad, -1, "status", 1);
nad_append_cdata(nad, cmd, len - (cmd[len-1] == '\n' ? 1 : 0), 2);
}
return nad;
}
/** auth requests */
static void _in_result(conn_t in, nad_t nad) {
int attr, ns;
jid_t from, to;
char *rkey;
nad_t verify;
pkt_t pkt;
time_t now;
attr = nad_find_attr(nad, 0, -1, "from", NULL);
if(attr < 0 || (from = jid_new(NAD_AVAL(nad, attr), NAD_AVAL_L(nad, attr))) == NULL) {
log_debug(ZONE, "missing or invalid from on db result packet");
nad_free(nad);
return;
}
attr = nad_find_attr(nad, 0, -1, "to", NULL);
if(attr < 0 || (to = jid_new(NAD_AVAL(nad, attr), NAD_AVAL_L(nad, attr))) == NULL) {
log_debug(ZONE, "missing or invalid to on db result packet");
jid_free(from);
nad_free(nad);
return;
}
rkey = s2s_route_key(NULL, to->domain, from->domain);
log_write(in->s2s->log, LOG_NOTICE, "[%d] [%s, port=%d] received dialback auth request for route '%s'", in->fd->fd, in->ip, in->port, rkey);
/* get current state */
if((conn_state_t) xhash_get(in->states, rkey) == conn_VALID) {
log_write(in->s2s->log, LOG_NOTICE, "[%d] [%s, port=%d] route '%s' is already valid: sending valid", in->fd->fd, in->ip, in->port, rkey);
/* its already valid, just reply right now */
stanza_tofrom(nad, 0);
nad_set_attr(nad, 0, -1, "type", "valid", 5);
nad->elems[0].icdata = nad->elems[0].itail = -1;
nad->elems[0].lcdata = nad->elems[0].ltail = 0;
sx_nad_write(in->s, nad);
free(rkey);
jid_free(from);
jid_free(to);
return;
}
/* not valid, so we need to verify */
/* need the key */
if(NAD_CDATA_L(nad, 0) <= 0) {
log_write(in->s2s->log, LOG_NOTICE, "[%d] [%s, port=%d] no dialback key given with db result packet", in->fd->fd, in->ip, in->port, rkey);
free(rkey);
nad_free(nad);
jid_free(from);
jid_free(to);
return;
}
log_debug(ZONE, "requesting verification for route %s", rkey);
/* set the route status to INPROGRESS and set timestamp */
xhash_put(in->states, pstrdup(xhash_pool(in->states), rkey), (void *) conn_INPROGRESS);
/* record the time that we set conn_INPROGRESS state */
now = time(NULL);
xhash_put(in->states_time, pstrdup(xhash_pool(in->states_time), rkey), (void *) now);
free(rkey);
/* new packet */
verify = nad_new();
ns = nad_add_namespace(verify, uri_DIALBACK, "db");
nad_append_elem(verify, ns, "verify", 0);
nad_append_attr(verify, -1, "to", from->domain);
nad_append_attr(verify, -1, "from", to->domain);
nad_append_attr(verify, -1, "id", in->s->id);
nad_append_cdata(verify, NAD_CDATA(nad, 0), NAD_CDATA_L(nad, 0), 1);
/* new packet */
pkt = (pkt_t) calloc(1, sizeof(struct pkt_st));
pkt->nad = verify;
pkt->to = from;
pkt->from = to;
pkt->db = 1;
/* its away */
out_packet(in->s2s, pkt);
nad_free(nad);
}
/** our master callback */
int sm_sx_callback(sx_t s, sx_event_t e, void *data, void *arg) {
sm_t sm = (sm_t) arg;
sx_buf_t buf = (sx_buf_t) data;
sx_error_t *sxe;
nad_t nad;
pkt_t pkt;
int len, ns, elem, attr;
char *domain;
switch(e) {
case event_WANT_READ:
log_debug(ZONE, "want read");
mio_read(sm->mio, sm->fd);
break;
case event_WANT_WRITE:
log_debug(ZONE, "want write");
mio_write(sm->mio, sm->fd);
break;
case event_READ:
log_debug(ZONE, "reading from %d", sm->fd->fd);
/* do the read */
len = recv(sm->fd->fd, buf->data, buf->len, 0);
if (len < 0) {
if (MIO_WOULDBLOCK) {
buf->len = 0;
return 0;
}
log_write(sm->log, LOG_NOTICE, "[%d] [router] read error: %s (%d)", sm->fd->fd, MIO_STRERROR(MIO_ERROR), MIO_ERROR);
sx_kill(s);
return -1;
}
else if (len == 0) {
/* they went away */
sx_kill(s);
return -1;
}
log_debug(ZONE, "read %d bytes", len);
buf->len = len;
return len;
case event_WRITE:
log_debug(ZONE, "writing to %d", sm->fd->fd);
len = send(sm->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_write(sm->log, LOG_NOTICE, "[%d] [router] write error: %s (%d)", sm->fd->fd, MIO_STRERROR(MIO_ERROR), MIO_ERROR);
sx_kill(s);
return -1;
case event_ERROR:
sxe = (sx_error_t *) data;
log_write(sm->log, LOG_NOTICE, "error from router: %s (%s)", sxe->generic, sxe->specific);
if(sxe->code == SX_ERR_AUTH)
sx_close(s);
break;
case event_STREAM:
break;
case event_OPEN:
log_write(sm->log, LOG_NOTICE, "connection to router established");
/* set connection attempts counter */
sm->retry_left = sm->retry_lost;
nad = nad_new();
ns = nad_add_namespace(nad, uri_COMPONENT, NULL);
nad_append_elem(nad, ns, "bind", 0);
nad_append_attr(nad, -1, "name", sm->id);
log_debug(ZONE, "requesting component bind for '%s'", sm->id);
sx_nad_write(sm->router, nad);
if(xhash_iter_first(sm->hosts))
do {
xhash_iter_get(sm->hosts, (void *) &domain, &len, NULL);
/* skip already requested SM id */
if (strlen(sm->id) == len && strncmp(sm->id, domain, len) == 0)
continue;
nad = nad_new();
ns = nad_add_namespace(nad, uri_COMPONENT, NULL);
elem = nad_append_elem(nad, ns, "bind", 0);
nad_set_attr(nad, elem, -1, "name", domain, len);
nad_append_attr(nad, -1, "multi", "to");
log_debug(ZONE, "requesting domain bind for '%.*s'", len, domain);
sx_nad_write(sm->router, nad);
} while(xhash_iter_next(sm->hosts));
sm_update_host = 1;
break;
case event_PACKET:
nad = (nad_t) data;
/* drop unqualified packets */
if (NAD_ENS(nad, 0) < 0) {
nad_free(nad);
return 0;
}
/* watch for the features packet */
if (s->state == state_STREAM) {
if (NAD_NURI_L(nad, NAD_ENS(nad, 0)) != strlen(uri_STREAMS)
|| strncmp(uri_STREAMS, NAD_NURI(nad, NAD_ENS(nad, 0)), strlen(uri_STREAMS)) != 0
|| NAD_ENAME_L(nad, 0) != 8 || strncmp("features", NAD_ENAME(nad, 0), 8) != 0) {
log_debug(ZONE, "got a non-features packet on an unauth'd stream, dropping");
nad_free(nad);
return 0;
}
#ifdef HAVE_SSL
/* starttls if we can */
if (sm->sx_ssl != NULL && s->ssf == 0) {
ns = nad_find_scoped_namespace(nad, uri_TLS, NULL);
if (ns >= 0) {
elem = nad_find_elem(nad, 0, ns, "starttls", 1);
if (elem >= 0) {
if (sx_ssl_client_starttls(sm->sx_ssl, s, NULL, NULL) == 0) {
nad_free(nad);
return 0;
}
log_write(sm->log, LOG_NOTICE, "unable to establish encrypted session with router");
}
}
}
#endif
/* !!! pull the list of mechanisms, and choose the best one.
* if there isn't an appropriate one, error and bail */
/* authenticate */
sx_sasl_auth(sm->sx_sasl, s, "jabberd-router", "DIGEST-MD5", sm->router_user, sm->router_pass);
nad_free(nad);
return 0;
}
/* watch for the bind response */
if (s->state == state_OPEN && !sm->online) {
if (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
|| NAD_ENAME_L(nad, 0) != 4 || strncmp("bind", NAD_ENAME(nad, 0), 4)) {
log_debug(ZONE, "got a packet from router, but we're not online, dropping");
nad_free(nad);
return 0;
}
/* catch errors */
attr = nad_find_attr(nad, 0, -1, "error", NULL);
if(attr >= 0) {
log_write(sm->log, LOG_NOTICE, "router refused bind request (%.*s)", NAD_AVAL_L(nad, attr), NAD_AVAL(nad, attr));
exit(1);
}
log_debug(ZONE, "coming online");
/* we're online */
sm->online = sm->started = 1;
log_write(sm->log, LOG_NOTICE, "%s ready for sessions", sm->id);
nad_free(nad);
return 0;
}
log_debug(ZONE, "got a packet");
pkt = pkt_new(sm, nad);
if (pkt == NULL) {
log_debug(ZONE, "invalid packet, dropping");
return 0;
}
/* go */
dispatch(sm, pkt);
return 0;
case event_CLOSED:
mio_close(sm->mio, sm->fd);
sm->fd = NULL;
return -1;
}
return 0;
}
static void _nad_parse_element_start(void *arg, const char *name, const char **atts) {
struct build_data *bd = (struct build_data *) arg;
char buf[1024];
char *uri, *elem, *prefix;
const char **attr;
int el, ns;
/* make a copy */
strncpy(buf, name, 1024);
buf[1023] = '\0';
/* expat gives us:
prefixed namespaced elem: uri|elem|prefix
default namespaced elem: uri|elem
un-namespaced elem: elem
*/
/* extract all the bits */
uri = buf;
elem = strchr(uri, '|');
if(elem != NULL) {
*elem = '\0';
elem++;
prefix = strchr(elem, '|');
if(prefix != NULL) {
*prefix = '\0';
prefix++;
}
ns = nad_add_namespace(bd->nad, uri, prefix);
} else {
/* un-namespaced, just take it as-is */
uri = NULL;
elem = buf;
prefix = NULL;
ns = -1;
}
/* add it */
el = nad_append_elem(bd->nad, ns, elem, bd->depth);
/* now the attributes, one at a time */
attr = atts;
while(attr[0] != NULL) {
/* make a copy */
strncpy(buf, attr[0], 1024);
buf[1023] = '\0';
/* extract all the bits */
uri = buf;
elem = strchr(uri, '|');
if(elem != NULL) {
*elem = '\0';
elem++;
prefix = strchr(elem, '|');
if(prefix != NULL) {
*prefix = '\0';
prefix++;
}
ns = nad_append_namespace(bd->nad, el, uri, prefix);
} else {
/* un-namespaced, just take it as-is */
uri = NULL;
elem = buf;
prefix = NULL;
ns = -1;
}
/* add it */
nad_append_attr(bd->nad, ns, elem, (char *) attr[1]);
attr += 2;
}
bd->depth++;
}
/** auth get handler */
static void _authreg_auth_get(c2s_t c2s, sess_t sess, nad_t nad) {
int ns, elem, attr;
char username[1024], id[128];
int ar_mechs;
/* can't auth if they're active */
if(sess->active) {
sx_nad_write(sess->s, stanza_tofrom(stanza_error(nad, 0, stanza_err_NOT_ALLOWED), 0));
return;
}
/* sort out the username */
ns = nad_find_scoped_namespace(nad, uri_AUTH, NULL);
elem = nad_find_elem(nad, 1, ns, "username", 1);
if(elem < 0)
{
log_debug(ZONE, "auth get with no username, bouncing it");
sx_nad_write(sess->s, stanza_tofrom(stanza_error(nad, 0, stanza_err_BAD_REQUEST), 0));
return;
}
snprintf(username, 1024, "%.*s", NAD_CDATA_L(nad, elem), NAD_CDATA(nad, elem));
if(stringprep_xmpp_nodeprep(username, 1024) != 0) {
log_debug(ZONE, "auth get username failed nodeprep, bouncing it");
sx_nad_write(sess->s, stanza_tofrom(stanza_error(nad, 0, stanza_err_JID_MALFORMED), 0));
return;
}
ar_mechs = c2s->ar_mechanisms;
if (sess->s->ssf>0)
ar_mechs = ar_mechs | c2s->ar_ssl_mechanisms;
/* no point going on if we have no mechanisms */
if(!(ar_mechs & (AR_MECH_TRAD_PLAIN | AR_MECH_TRAD_DIGEST))) {
sx_nad_write(sess->s, stanza_tofrom(stanza_error(nad, 0, stanza_err_FORBIDDEN), 0));
return;
}
/* do we have the user? */
if((c2s->ar->user_exists)(c2s->ar, username, sess->host->realm) == 0) {
sx_nad_write(sess->s, stanza_tofrom(stanza_error(nad, 0, stanza_err_OLD_UNAUTH), 0));
return;
}
/* extract the id */
attr = nad_find_attr(nad, 0, -1, "id", NULL);
if(attr >= 0)
snprintf(id, 128, "%.*s", NAD_AVAL_L(nad, attr), NAD_AVAL(nad, attr));
nad_free(nad);
/* build a result packet */
nad = nad_new();
ns = nad_add_namespace(nad, uri_CLIENT, NULL);
nad_append_elem(nad, ns, "iq", 0);
nad_append_attr(nad, -1, "type", "result");
if(attr >= 0)
nad_append_attr(nad, -1, "id", id);
ns = nad_add_namespace(nad, uri_AUTH, NULL);
nad_append_elem(nad, ns, "query", 1);
nad_append_elem(nad, ns, "username", 2);
nad_append_cdata(nad, username, strlen(username), 3);
nad_append_elem(nad, ns, "resource", 2);
/* fill out the packet with available auth mechanisms */
if(ar_mechs & AR_MECH_TRAD_PLAIN && (c2s->ar->get_password != NULL || c2s->ar->check_password != NULL))
nad_append_elem(nad, ns, "password", 2);
if(ar_mechs & AR_MECH_TRAD_DIGEST && c2s->ar->get_password != NULL)
nad_append_elem(nad, ns, "digest", 2);
/* give it back to the client */
sx_nad_write(sess->s, nad);
return;
}
