/** insert a roster item into this pkt, starting at elem */
static void _roster_insert_item(pkt_t pkt, item_t item, int elem)
{
int ns, i;
char *sub;
ns = nad_add_namespace(pkt->nad, uri_CLIENT, NULL);
elem = nad_insert_elem(pkt->nad, elem, ns, "item", NULL);
nad_set_attr(pkt->nad, elem, -1, "jid", jid_full(item->jid), 0);
if(item->to && item->from)
sub = "both";
else if(item->to)
sub = "to";
else if(item->from)
sub = "from";
else
sub = "none";
nad_set_attr(pkt->nad, elem, -1, "subscription", sub, 0);
if(item->ask == 1)
nad_set_attr(pkt->nad, elem, -1, "ask", "subscribe", 9);
else if(item->ask == 2)
nad_set_attr(pkt->nad, elem, -1, "ask", "unsubscribe", 11);
if(item->name != NULL)
nad_set_attr(pkt->nad, elem, -1, "name", item->name, 0);
for(i = 0; i < item->ngroups; i++)
nad_insert_elem(pkt->nad, elem, NAD_ENS(pkt->nad, elem), "group", item->groups[i]);
}
/** send a packet to the client for this session */
void sess_route(sess_t sess, pkt_t pkt) {
int ns;
log_debug(ZONE, "routing pkt 0x%X to %s (%s) for %s", pkt, sess->c2s, sess->c2s_id, jid_full(sess->jid));
if(pkt == NULL)
return;
/* wrap it up */
ns = nad_append_namespace(pkt->nad, 1, uri_SESSION, "sm");
nad_set_attr(pkt->nad, 1, ns, "c2s", sess->c2s_id, 0);
nad_set_attr(pkt->nad, 1, ns, "sm", sess->sm_id, 0);
nad_set_attr(pkt->nad, 0, -1, "to", sess->c2s, 0);
nad_set_attr(pkt->nad, 0, -1, "from", sess->user->jid->domain, 0);
/* remove error attribute */
nad_set_attr(pkt->nad, 0, -1, "error", NULL, 0);
/* and send it out */
sx_nad_write(sess->user->sm->router, pkt->nad);
/* free up the packet */
if(pkt->rto != NULL) jid_free(pkt->rto);
if(pkt->rfrom != NULL) jid_free(pkt->rfrom);
if(pkt->to != NULL) jid_free(pkt->to);
if(pkt->from != NULL) jid_free(pkt->from);
free(pkt);
}
/** 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;
}
/** tell a component about all the others */
static void _router_advertise_reverse(const char *key, int keylen, void *val, void *arg) {
component_t dest = (component_t) arg;
routes_t routes = (routes_t) val;
int el, ns, i;
nad_t nad;
assert((int) (routes->name != NULL));
assert((int) (routes->comp != NULL));
assert(routes->ncomp);
/* don't tell me about myself */
for(i = 0; i < routes->ncomp; i++)
if(routes->comp[i] == dest)
return;
log_debug(ZONE, "informing component about %.*s", keylen, key);
/* create a new packet */
nad = nad_new();
ns = nad_add_namespace(nad, uri_COMPONENT, NULL);
el = nad_append_elem(nad, ns, "presence", 0);
nad_set_attr(nad, el, -1, "from", key, keylen);
sx_nad_write(dest->s, nad);
}
void sm_packet(sess_t sess, bres_t res, nad_t nad) {
int ns;
ns = nad_add_namespace(nad, uri_COMPONENT, NULL);
nad_wrap_elem(nad, 0, ns, "route");
nad_set_attr(nad, 0, -1, "to", sess->smcomp?sess->smcomp:((char *) res->jid->domain), 0);
nad_set_attr(nad, 0, -1, "from", sess->c2s->id, 0);
ns = nad_append_namespace(nad, 1, uri_SESSION, "sc");
nad_set_attr(nad, 1, ns, "c2s", res->c2s_id, 0);
if(res->c2s_id[0] != '\0')
nad_set_attr(nad, 1, ns, "sm", res->sm_id, 0);
sx_nad_write(sess->c2s->router, nad);
}
/**
* Creates unique ID for every message.
*/
void set_mid(storage_t* st, os_object_t* o, nad_t nad, int arch) {
static char id[48];
static char* pos=id+47;
static char* rand=NULL;
static pthread_mutex_t mutex;
time_t tme;
long int rand_num;
int i;
// Lock everything to make sure we have unique IDs
pthread_mutex_lock(&mutex);
log_debug(ZONE, "Setting mid...");
// We had too many messages since boot
if(pos-id<2)
pos=id+47;
// First run of the function
if(pos-id==47) {
(*pos)=0;
pos--;
// Use current time as a start
for(tme=time(NULL); ((tme>0) && (pos>id+14)); tme=tme/26) {
(*pos)='a'+(tme%26);
pos--;
}
(*pos)='-';
rand=pos-(mid_rand_len);
pos=rand-1;
(*pos)='-';
pos--;
(*pos)='a';
}
// Make message ids unpredictable
rand_num=random();
for(i=0; i<mid_rand_len; i++) {
(*(rand+i)) = 'a' + (rand_num%26);
rand_num = rand_num / 26;
}
// Increment IDs and let it overflow
if((*pos)=='z') {
(*(--pos))='a';
} else {
(*pos)++;
}
// Store ID
os_object_put(*o, "mid", pos, os_type_STRING);
// Optionally put it into message
if(arch > 0)
nad_set_attr(nad,arch,-1,"id",pos, strlen(pos));
log_debug(ZONE, "mid set to %s.",pos);
// Unlock
pthread_mutex_unlock(&mutex);
}
static void _router_route_log_sink(const char *key, int keylen, void *val, void *arg) {
component_t comp = (component_t) val;
nad_t nad = (nad_t) arg;
log_debug(ZONE, "copying route to '%.*s' (%s, port %d)", keylen, key, comp->ip, comp->port);
nad = nad_copy(nad);
nad_set_attr(nad, 0, -1, "type", "log", 3);
_router_comp_write(comp, nad);
}
static void _router_process_unbind(component_t comp, nad_t nad) {
int attr;
jid_t name;
attr = nad_find_attr(nad, 0, -1, "name", NULL);
if(attr < 0 || (name = jid_new(NAD_AVAL(nad, attr), NAD_AVAL_L(nad, attr))) == NULL) {
log_debug(ZONE, "no or invalid 'name' on unbind packet, bouncing");
nad_set_attr(nad, 0, -1, "error", "400", 3);
sx_nad_write(comp->s, nad);
return;
}
if(xhash_get(comp->routes, name->domain) == NULL) {
log_write(comp->r->log, LOG_NOTICE, "[%s, port=%d] tried to unbind '%s', but it's not bound to this component", comp->ip, comp->port, name->domain);
nad_set_attr(nad, 0, -1, "name", NULL, 0);
nad_set_attr(nad, 0, -1, "error", "404", 3);
sx_nad_write(comp->s, nad);
jid_free(name);
return;
}
xhash_zap(comp->r->log_sinks, name->domain);
_route_remove(comp->r->routes, name->domain, comp);
xhash_zap(comp->routes, name->domain);
if(comp->r->default_route != NULL && strcmp(comp->r->default_route, name->domain) == 0) {
log_write(comp->r->log, LOG_NOTICE, "[%s] default route offline", name->domain);
free((void*)(comp->r->default_route));
comp->r->default_route = NULL;
}
log_write(comp->r->log, LOG_NOTICE, "[%s] offline", name->domain);
nad_set_attr(nad, 0, -1, "name", NULL, 0);
sx_nad_write(comp->s, nad);
/* deadvertise name */
if(xhash_get(comp->r->routes, name->domain) == NULL)
_router_advertise(comp->r, name->domain, comp, 1);
jid_free(name);
}
/** flip the to and from attributes on this elem */
nad_t stanza_tofrom(nad_t nad, int elem) {
int attr;
char to[3072], from[3072];
assert((int) (nad != NULL));
to[0] = '\0';
from[0] = '\0';
attr = nad_find_attr(nad, elem, -1, "to", NULL);
if(attr >= 0)
snprintf(to, 3072, "%.*s", NAD_AVAL_L(nad, attr), NAD_AVAL(nad, attr));
attr = nad_find_attr(nad, elem, -1, "from", NULL);
if(attr >= 0)
snprintf(from, 3072, "%.*s", NAD_AVAL_L(nad, attr), NAD_AVAL(nad, attr));
nad_set_attr(nad, elem, -1, "to", from[0] != '\0' ? from : NULL, 0);
nad_set_attr(nad, elem, -1, "from", to[0] != '\0' ? to : NULL, 0);
return nad;
}
int filter_packet(router_t r, nad_t nad) {
acl_t acl;
int ato, afrom, error = 0;
unsigned char *cur, *to = NULL, *from = NULL;
ato = nad_find_attr(nad, 1, -1, "to", NULL);
afrom = nad_find_attr(nad, 1, -1, "from", NULL);
if(ato >= 0 && NAD_AVAL_L(nad,ato) > 0) {
to = (char *) malloc(sizeof(char) * (NAD_AVAL_L(nad, ato) + 1));
sprintf(to, "%.*s", NAD_AVAL_L(nad, ato), NAD_AVAL(nad, ato));
cur = strstr(to, "@"); /* skip node part */
if(cur != NULL)
cur = strstr(cur, "/");
else
cur = strstr(to, "/");
if(cur != NULL) *cur = '\0'; /* remove the resource part */
}
if(afrom >= 0 && NAD_AVAL_L(nad,afrom) > 0) {
from = (char *) malloc(sizeof(char) * (NAD_AVAL_L(nad, afrom) + 1));
sprintf(from, "%.*s", NAD_AVAL_L(nad, afrom), NAD_AVAL(nad, afrom));
cur = strstr(from, "@");
if(cur != NULL)
cur = strstr(cur, "/");
else
cur = strstr(from, "/");
if(cur != NULL) *cur = '\0';
}
for(acl = r->filter; acl != NULL; acl = acl->next) {
if( from == NULL && acl->from != NULL) continue; /* no match if NULL matched vs not-NULL */
if( to == NULL && acl->to != NULL ) continue;
if( from != NULL && acl->from == NULL) continue; /* no match if not-NULL matched vs NULL */
if( to != NULL && acl->to == NULL ) continue;
if( from != NULL && acl->from != NULL && fnmatch(acl->from, from, 0) != 0 ) continue; /* do filename-like match */
if( to != NULL && acl->to != NULL && fnmatch(acl->to, to, 0) != 0 ) continue;
if( acl->what != NULL && nad_find_elem_path(nad, 0, -1, acl->what) < 0 ) continue; /* match packet type */
log_debug(ZONE, "matched packet %s->%s vs rule (%s %s->%s)", from, to, acl->what, acl->from, acl->to);
if (acl->log) {
if (acl->redirect) log_write(r->log, LOG_NOTICE, "filter: redirect packet from=%s to=%s - rule (from=%s to=%s what=%s), new to=%s", from, to, acl->from, acl->to, acl->what, acl->redirect);
else log_write(r->log, LOG_NOTICE, "filter: %s packet from=%s to=%s - rule (from=%s to=%s what=%s)",(acl->error?"deny":"allow"), from, to, acl->from, acl->to, acl->what);
}
if (acl->redirect) nad_set_attr(nad, 0, -1, "to", acl->redirect, acl->redirect_len);
error = acl->error;
break;
}
if(to != NULL) free(to);
if(from != NULL) free(from);
return error;
}
/** error the packet */
nad_t stanza_error(nad_t nad, int elem, int err) {
int ns;
assert((int) (nad != NULL));
assert((int) (elem >= 0));
assert((int) (err >= stanza_err_BAD_REQUEST && err < stanza_err_LAST));
err = err - stanza_err_BAD_REQUEST;
nad_set_attr(nad, elem, -1, "type", "error", 5);
elem = nad_insert_elem(nad, elem, NAD_ENS(nad, elem), "error", NULL);
if(_stanza_errors[err].code != NULL)
nad_set_attr(nad, elem, -1, "code", _stanza_errors[err].code, 0);
if(_stanza_errors[err].type != NULL)
nad_set_attr(nad, elem, -1, "type", _stanza_errors[err].type, 0);
if(_stanza_errors[err].name != NULL) {
ns = nad_add_namespace(nad, uri_STANZA_ERR, NULL);
nad_insert_elem(nad, elem, ns, _stanza_errors[err].name, NULL);
}
return nad;
}
/** presence from the session */
static mod_ret_t _presence_in_sess(mod_instance_t mi, sess_t sess, pkt_t pkt) {
/* only handle presence */
if(!(pkt->type & pkt_PRESENCE))
return mod_PASS;
/* reset from if necessary */
if(pkt->from == NULL || jid_compare_user(pkt->from, sess->jid) != 0) {
if(pkt->from != NULL)
jid_free(pkt->from);
pkt->from = jid_dup(sess->jid);
nad_set_attr(pkt->nad, 1, -1, "from", jid_full(pkt->from), 0);
}
/* presence broadcast (T1, T2, T3) */
if(pkt->to == NULL)
pres_update(sess, pkt);
/* directed presence (T7, T8) */
else
pres_deliver(sess, pkt);
return mod_HANDLED;
}
/** 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 _router_process_bind(component_t comp, nad_t nad) {
int attr, multi, n;
jid_t name;
alias_t alias;
char *user, *c;
attr = nad_find_attr(nad, 0, -1, "name", NULL);
if(attr < 0 || (name = jid_new(NAD_AVAL(nad, attr), NAD_AVAL_L(nad, attr))) == NULL) {
log_debug(ZONE, "no or invalid 'name' on bind packet, bouncing");
nad_set_attr(nad, 0, -1, "error", "400", 3);
sx_nad_write(comp->s, nad);
return;
}
user = strdup(comp->s->auth_id);
c = strchr(user, '@');
if(c != NULL) *c = '\0';
if(strcmp(user, name->domain) != 0 && !aci_check(comp->r->aci, "bind", user)) {
log_write(comp->r->log, LOG_NOTICE, "[%s, port=%d] tried to bind '%s', but their username (%s) is not permitted to bind other names", comp->ip, comp->port, name->domain, user);
nad_set_attr(nad, 0, -1, "name", NULL, 0);
nad_set_attr(nad, 0, -1, "error", "403", 3);
sx_nad_write(comp->s, nad);
jid_free(name);
free(user);
return;
}
multi = nad_find_attr(nad, 0, -1, "multi", NULL);
if(xhash_get(comp->r->routes, name->domain) != NULL && multi < 0) {
log_write(comp->r->log, LOG_NOTICE, "[%s, port=%d] tried to bind '%s', but it's already bound", comp->ip, comp->port, name->domain);
nad_set_attr(nad, 0, -1, "name", NULL, 0);
nad_set_attr(nad, 0, -1, "error", "409", 3);
sx_nad_write(comp->s, nad);
jid_free(name);
free(user);
return;
}
for(alias = comp->r->aliases; alias != NULL; alias = alias->next)
if(strcmp(alias->name, name->domain) == 0) {
log_write(comp->r->log, LOG_NOTICE, "[%s, port=%d] tried to bind '%s', but that name is aliased", comp->ip, comp->port);
nad_set_attr(nad, 0, -1, "name", NULL, 0);
nad_set_attr(nad, 0, -1, "error", "409", 3);
sx_nad_write(comp->s, nad);
jid_free(name);
free(user);
return;
}
/* default route */
if(nad_find_elem(nad, 0, NAD_ENS(nad, 0), "default", 1) >= 0) {
if(!aci_check(comp->r->aci, "default-route", user)) {
log_write(comp->r->log, LOG_NOTICE, "[%s, port=%d] tried to bind '%s' as the default route, but their username (%s) is not permitted to set a default route", comp->ip, comp->port, name->domain, user);
nad_set_attr(nad, 0, -1, "name", NULL, 0);
nad_set_attr(nad, 0, -1, "error", "403", 3);
sx_nad_write(comp->s, nad);
jid_free(name);
free(user);
return;
}
if(comp->r->default_route != NULL) {
log_write(comp->r->log, LOG_NOTICE, "[%s, port=%d] tried to bind '%s' as the default route, but one already exists", comp->ip, comp->port, name->domain);
nad_set_attr(nad, 0, -1, "name", NULL, 0);
nad_set_attr(nad, 0, -1, "error", "409", 3);
sx_nad_write(comp->s, nad);
jid_free(name);
return;
}
log_write(comp->r->log, LOG_NOTICE, "[%s] set as default route", name->domain);
comp->r->default_route = strdup(name->domain);
}
/* log sinks */
if(nad_find_elem(nad, 0, NAD_ENS(nad, 0), "log", 1) >= 0) {
if(!aci_check(comp->r->aci, "log", user)) {
log_write(comp->r->log, LOG_NOTICE, "[%s, port=%d] tried to bind '%s' as a log sink, but their username (%s) is not permitted to do this", comp->ip, comp->port, name->domain, user);
nad_set_attr(nad, 0, -1, "name", NULL, 0);
nad_set_attr(nad, 0, -1, "error", "403", 3);
sx_nad_write(comp->s, nad);
jid_free(name);
free(user);
return;
}
log_write(comp->r->log, LOG_NOTICE, "[%s] set as log sink", name->domain);
xhash_put(comp->r->log_sinks, pstrdup(xhash_pool(comp->r->log_sinks), name->domain), (void *) comp);
}
free(user);
n = _route_add(comp->r->routes, name->domain, comp, multi<0?route_SINGLE:route_MULTI_TO);
xhash_put(comp->routes, pstrdup(xhash_pool(comp->routes), name->domain), (void *) comp);
if(n>1)
log_write(comp->r->log, LOG_NOTICE, "[%s]:%d online (bound to %s, port %d)", name->domain, n, comp->ip, comp->port);
else
log_write(comp->r->log, LOG_NOTICE, "[%s] online (bound to %s, port %d)", name->domain, comp->ip, comp->port);
nad_set_attr(nad, 0, -1, "name", NULL, 0);
sx_nad_write(comp->s, nad);
/* advertise name */
_router_advertise(comp->r, name->domain, comp, 0);
/* tell the new component about everyone else */
xhash_walk(comp->r->routes, _router_advertise_reverse, (void *) comp);
/* bind aliases */
for(alias = comp->r->aliases; alias != NULL; alias = alias->next) {
if(strcmp(alias->target, name->domain) == 0) {
_route_add(comp->r->routes, name->domain, comp, route_MULTI_TO);
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, name->domain, comp->ip, comp->port);
/* advertise name */
_router_advertise(comp->r, alias->name, comp, 0);
}
}
/* done with this */
jid_free(name);
}
/** Send archiving preferences */
void send_arch_prefs(mod_instance_t mi, sess_t sess, pkt_t pkt) {
module_t mod = mi->mod;
int prefs;
int archive=default_mode;
int section;
int check;
char buff[2060]; // 2048 is jid_user maximum length
char* ret_str=buff;
os_t os = NULL;
os_object_t o = NULL;
pkt_t reply;
// Create a new packet
log_debug(ZONE, "Construction of reply with current settings");
reply = pkt_create(sess->user->sm, "iq", "result", NULL, NULL);
// Defaults
log_debug(ZONE, "Getting defaults");
prefs = nad_append_elem(reply->nad, nad_add_namespace(reply->nad, archive_uri, NULL), "prefs", 2);
// Load defaults
snprintf(buff, 2060, "(jid=%s)", jid_user(sess->jid));
if((storage_get(sess->user->sm->st, tbl_name "_settings", jid_user(sess->jid), buff, &os) == st_SUCCESS) &&
(os_iter_first(os)) && ((o=os_iter_object(os))!=NULL))
os_object_get_int(os, o, "setting", &archive);
// Set defaults
switch(archive) {
case A_ALWAYS:
nad_set_attr(reply->nad, prefs, -1,"default", "always", 6);
break;
case A_ROSTER:
nad_set_attr(reply->nad, prefs, -1,"default", "roster", 6);
break;
default:
nad_set_attr(reply->nad, prefs, -1,"default", "never", 5);
break;
}
// Cleanup
if(o != NULL) {
os_object_free(o);
o=NULL;
}
if(os != NULL) {
os_free(os);
os=NULL;
}
// Always archiving
log_debug(ZONE, "Getting what to archive always");
section = nad_append_elem(reply->nad, -1, "always", 3);
if(storage_get(sess->user->sm->st, tbl_name "_settings", jid_user(sess->jid), "(setting=1)", &os) == st_SUCCESS)
if(os_iter_first(os))
do {
o = os_iter_object(os);
if((o != NULL) && (os_object_get_str(os, o, "jid", &ret_str)) && (ret_str != NULL)) {
nad_append_elem(reply->nad, -1, "jid", 4);
nad_append_cdata(reply->nad, ret_str, strlen(ret_str), 5);
}
} while(os_iter_next(os));
// Cleanup
if(o != NULL) {
os_object_free(o);
o=NULL;
}
if(os != NULL) {
os_free(os);
os=NULL;
}
// Never archiving
log_debug(ZONE, "Getting what to never archive");
section = nad_append_elem(reply->nad, -1, "never", 3);
if(storage_get(sess->user->sm->st, tbl_name "_settings", jid_user(sess->jid), "(setting=0)", &os) == st_SUCCESS)
if(os_iter_first(os))
do {
o = os_iter_object(os);
if((o != NULL) && (os_object_get_str(os, o, "jid", &ret_str)) && (ret_str != NULL)) {
nad_append_elem(reply->nad, -1, "jid", 4);
nad_append_cdata(reply->nad, ret_str, strlen(ret_str), 5);
}
} while(os_iter_next(os));
// Cleanup
if(o != NULL) {
os_object_free(o);
o=NULL;
}
if(os != NULL) {
os_free(os);
os=NULL;
}
// Send packet
pkt_id(pkt, reply);
pkt_sess(reply, sess);
pkt_free(pkt);
}
/** auth set handler */
static void _authreg_auth_set(c2s_t c2s, sess_t sess, nad_t nad) {
int ns, elem, attr, authd = 0;
char username[1024], resource[1024], str[1024], hash[280];
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;
}
ns = nad_find_scoped_namespace(nad, uri_AUTH, NULL);
/* sort out the username */
elem = nad_find_elem(nad, 1, ns, "username", 1);
if(elem < 0)
{
log_debug(ZONE, "auth set 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 set username failed nodeprep, bouncing it");
sx_nad_write(sess->s, stanza_tofrom(stanza_error(nad, 0, stanza_err_JID_MALFORMED), 0));
return;
}
/* make sure we have the resource */
elem = nad_find_elem(nad, 1, ns, "resource", 1);
if(elem < 0)
{
log_debug(ZONE, "auth set with no resource, bouncing it");
sx_nad_write(sess->s, stanza_tofrom(stanza_error(nad, 0, stanza_err_BAD_REQUEST), 0));
return;
}
snprintf(resource, 1024, "%.*s", NAD_CDATA_L(nad, elem), NAD_CDATA(nad, elem));
if(stringprep_xmpp_resourceprep(resource, 1024) != 0) {
log_debug(ZONE, "auth set resource failed resourceprep, 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;
}
/* digest auth */
if(!authd && ar_mechs & AR_MECH_TRAD_DIGEST && c2s->ar->get_password != NULL)
{
elem = nad_find_elem(nad, 1, ns, "digest", 1);
if(elem >= 0)
{
if((c2s->ar->get_password)(c2s->ar, username, sess->host->realm, str) == 0)
{
snprintf(hash, 280, "%s%s", sess->s->id, str);
shahash_r(hash, hash);
if(strlen(hash) == NAD_CDATA_L(nad, elem) && strncmp(hash, NAD_CDATA(nad, elem), NAD_CDATA_L(nad, elem)) == 0)
{
log_debug(ZONE, "digest auth succeeded");
authd = 1;
_authreg_auth_log(c2s, sess, "traditional.digest", username, resource, TRUE);
}
}
}
}
/* plaintext auth (compare) */
if(!authd && ar_mechs & AR_MECH_TRAD_PLAIN && c2s->ar->get_password != NULL)
{
elem = nad_find_elem(nad, 1, ns, "password", 1);
if(elem >= 0)
{
if((c2s->ar->get_password)(c2s->ar, username, sess->host->realm, str) == 0 && strlen(str) == NAD_CDATA_L(nad, elem) && strncmp(str, NAD_CDATA(nad, elem), NAD_CDATA_L(nad, elem)) == 0)
{
log_debug(ZONE, "plaintext auth (compare) succeeded");
authd = 1;
_authreg_auth_log(c2s, sess, "traditional.plain(compare)", username, resource, TRUE);
}
}
}
/* plaintext auth (check) */
if(!authd && ar_mechs & AR_MECH_TRAD_PLAIN && c2s->ar->check_password != NULL)
{
elem = nad_find_elem(nad, 1, ns, "password", 1);
if(elem >= 0)
{
snprintf(str, 1024, "%.*s", NAD_CDATA_L(nad, elem), NAD_CDATA(nad, elem));
if((c2s->ar->check_password)(c2s->ar, username, sess->host->realm, str) == 0)
{
log_debug(ZONE, "plaintext auth (check) succeded");
authd = 1;
_authreg_auth_log(c2s, sess, "traditional.plain", username, resource, TRUE);
}
}
}
/* now, are they authenticated? */
if(authd)
{
/* create new bound jid holder */
if(sess->resources == NULL) {
sess->resources = (bres_t) calloc(1, sizeof(struct bres_st));
}
/* our local id */
sprintf(sess->resources->c2s_id, "%d", sess->s->tag);
/* the full user jid for this session */
sess->resources->jid = jid_new(sess->s->req_to, -1);
jid_reset_components(sess->resources->jid, username, sess->resources->jid->domain, resource);
log_write(sess->c2s->log, LOG_NOTICE, "[%d] requesting session: jid=%s", sess->s->tag, jid_full(sess->resources->jid));
/* build a result packet, we'll send this back to the client after we have a session for them */
sess->result = nad_new();
ns = nad_add_namespace(sess->result, uri_CLIENT, NULL);
nad_append_elem(sess->result, ns, "iq", 0);
nad_set_attr(sess->result, 0, -1, "type", "result", 6);
attr = nad_find_attr(nad, 0, -1, "id", NULL);
if(attr >= 0)
nad_set_attr(sess->result, 0, -1, "id", NAD_AVAL(nad, attr), NAD_AVAL_L(nad, attr));
/* start a session with the sm */
sm_start(sess, sess->resources);
/* finished with the nad */
nad_free(nad);
return;
}
_authreg_auth_log(c2s, sess, "traditional", username, resource, FALSE);
/* auth failed, so error */
sx_nad_write(sess->s, stanza_tofrom(stanza_error(nad, 0, stanza_err_OLD_UNAUTH), 0));
return;
}
/** they're trying to send us something */
static void _in_packet(conn_t in, nad_t nad) {
int attr, ns, sns;
jid_t from, to;
char *rkey;
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 incoming 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 incoming packet");
jid_free(from);
nad_free(nad);
return;
}
rkey = s2s_route_key(NULL, to->domain, from->domain);
log_debug(ZONE, "received packet from %s for %s", in->key, rkey);
/* drop packets received on routes not valid on that connection as per XMPP 8.3.10 */
if((conn_state_t) xhash_get(in->states, rkey) != conn_VALID) {
log_write(in->s2s->log, LOG_NOTICE, "[%d] [%s, port=%d] dropping packet on unvalidated route: '%s'", in->fd->fd, in->ip, in->port, rkey);
free(rkey);
nad_free(nad);
jid_free(from);
jid_free(to);
return;
}
free(rkey);
/* its good, off to the router with it */
log_debug(ZONE, "incoming packet on valid route, preparing it for the router");
/* rewrite server packets into client packets */
ns = nad_find_namespace(nad, 0, uri_SERVER, 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;
}
}
/*
* If stanza is not in any namespace (either because we removed the
* jabber:server namespace above or because it's in the default
* namespace for this stream) then this packet is intended to be
* handled by sm (and not just routed through the server), so set the
* jabber:client namespace.
*/
if(ns >= 0 || nad->elems[0].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 = nad->elems[0].ns;
/* wrap up the packet */
ns = nad_add_namespace(nad, uri_COMPONENT, "comp");
nad_wrap_elem(nad, 0, ns, "route");
nad_set_attr(nad, 0, -1, "to", to->domain, 0);
nad_set_attr(nad, 0, -1, "from", in->s2s->id, 0); /* route is from s2s, not packet source */
log_debug(ZONE, "sending packet to %s", to->domain);
/* go */
sx_nad_write(in->s2s->router, nad);
jid_free(from);
jid_free(to);
}
/** validate their key */
static void _in_verify(conn_t in, nad_t nad) {
int attr;
jid_t from, to;
char *id, *dbkey, *type;
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 verify 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 verify packet");
jid_free(from);
nad_free(nad);
return;
}
attr = nad_find_attr(nad, 0, -1, "id", NULL);
if(attr < 0) {
log_debug(ZONE, "missing id on db verify packet");
jid_free(from);
jid_free(to);
nad_free(nad);
return;
}
if(NAD_CDATA_L(nad, 0) <= 0) {
log_debug(ZONE, "no cdata on db verify packet");
jid_free(from);
jid_free(to);
nad_free(nad);
return;
}
/* extract the id */
id = (char *) malloc(sizeof(char) * (NAD_AVAL_L(nad, attr) + 1));
snprintf(id, NAD_AVAL_L(nad, attr) + 1, "%.*s", NAD_AVAL_L(nad, attr), NAD_AVAL(nad, attr));
/* generate a dialback key */
dbkey = s2s_db_key(NULL, in->s2s->local_secret, from->domain, id);
/* valid */
if(NAD_CDATA_L(nad, 0) == strlen(dbkey) && strncmp(dbkey, NAD_CDATA(nad, 0), NAD_CDATA_L(nad, 0)) == 0) {
log_debug(ZONE, "valid dialback key %s, verify succeeded", dbkey);
type = "valid";
} else {
log_debug(ZONE, "invalid dialback key %s, verify failed", dbkey);
type = "invalid";
}
log_write(in->s2s->log, LOG_NOTICE, "[%d] [%s, port=%d] checking dialback verification from %s: sending %s", in->fd->fd, in->ip, in->port, from->domain, type);
log_debug(ZONE, "letting them know");
/* now munge the packet and send it back to them */
stanza_tofrom(nad, 0);
nad_set_attr(nad, 0, -1, "type", type, 0);
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(dbkey);
free(id);
jid_free(from);
jid_free(to);
return;
}
/**
* Saves packet into database.
* @param direct Direction of the message - 2 = incomming, 1 = sent
*/
mod_ret_t savepkt(pkt_t pkt, int direct) {
int body=-1, sub=-1, type=-1, arch=-1;
char *mem=NULL;
const *owner = NULL, *other = NULL;
int sz = 0;
int archive=default_mode;
char filter[2060]; // 2048 is jid_user maximum length
time_t t=0;
jid_t own_jid, other_jid;
os_t os, set_os=NULL;
os_object_t o, set_o=NULL;
// Is it a message?
log_debug(ZONE, "Testing message...");
if ( (pkt->type & pkt_MESSAGE) == 0)
return mod_PASS;
log_debug(ZONE, "It is a message...");
// 0 element is route, 1st is message, we need subelement of message
body = nad_find_elem(pkt->nad, 1, -1, "body", 1);
log_debug(ZONE, "Body is at %d", body);
sub = nad_find_elem(pkt->nad, 1, -1, "subject", 1);
log_debug(ZONE, "Subject is at %d", sub);
type = nad_find_attr(pkt->nad, 1, -1, "type", NULL);
log_debug(ZONE, "Type %d", type);
// Are these parts really interesting?
if( ( (body < 0) || (NAD_CDATA_L(pkt->nad, body) < 1) ) &&
( (sub < 0) || (NAD_CDATA_L(pkt->nad, sub ) < 1) ) )
return mod_PASS;
log_debug(ZONE, "It's meaningful message!", pkt->from);
// What direction are we talking about?
if (direct == IN_D) {
own_jid = pkt->to;
other_jid = pkt->from;
} else {
own_jid = pkt->from;
other_jid = pkt->to;
}
// Get JIDs
if(own_jid != NULL) {
owner=jid_user(own_jid);
} else {
return mod_PASS;
}
if(other_jid != NULL) {
other=jid_user(other_jid);
} else {
return mod_PASS;
}
// Check settings
// Load defaults
snprintf(filter, 2060, "(jid=%s)", owner);
if((storage_get(pkt->sm->st, tbl_name "_settings", owner, filter, &set_os) == st_SUCCESS) &&
(os_iter_first(set_os)) && ((set_o=os_iter_object(set_os))!=NULL))
os_object_get_int(set_os, set_o, "setting", &archive);
// Cleanup
if(set_o != NULL) {
os_object_free(set_o);
set_o=NULL;
}
if(set_os != NULL) {
os_free(set_os);
set_os=NULL;
}
// Load contact specific
snprintf(filter, 2060, "(jid=%s)", other);
if((storage_get(pkt->sm->st, tbl_name "_settings", owner, filter, &set_os) == st_SUCCESS) &&
(os_iter_first(set_os)) && ((set_o=os_iter_object(set_os))!=NULL))
os_object_get_int(set_os, set_o, "setting", &archive);
// Cleanup
if(set_o != NULL) {
os_object_free(set_o);
set_o=NULL;
}
if(set_os != NULL) {
os_free(set_os);
set_os=NULL;
}
// Do we need to check roster?
if(archive==A_ROSTER) {
snprintf(filter, 2060, "(jid=%s)", other);
if(storage_get(pkt->sm->st, "roster-items", owner, filter, &set_os) == st_SUCCESS)
archive=A_ALWAYS;
else
archive=A_NEVER;
if(set_os != NULL) {
os_free(set_os);
set_os=NULL;
}
}
// Decide
if(archive==A_NEVER)
return mod_PASS;
// Prepare to store them
os = os_new();
if(os == NULL) return mod_PASS;
o = os_object_new(os);
if(o == NULL) return mod_PASS;
// Real storing
log_debug(ZONE, "Saving message for %s (other party is %s)", owner, other);
// Message
// Buffer allocation
if(body > 0) {
sz = NAD_CDATA_L(pkt->nad, body) / 1024;
log_debug(ZONE, "Body size %d", NAD_CDATA_L(pkt->nad, body));
}
if(sub > 0) {
sz = max(sz, NAD_CDATA_L(pkt->nad, sub) / 1024);
log_debug(ZONE, "Subj size %d", NAD_CDATA_L(pkt->nad, sub));
}
log_debug(ZONE, "Creating buffer of size %d", sz);
mem = (char*)malloc(1024 * (sz+1));
if(mem == NULL) return mod_PASS;
log_debug(ZONE, "We got past the buffer allocation.");
// JID
os_object_put(o, "other_jid", other, os_type_STRING);
// Body
mem[0]=0;
if ( (body > 0) && (NAD_CDATA_L(pkt->nad, body) > 0) ) {
strncpy(mem, NAD_CDATA(pkt->nad, body), NAD_CDATA_L(pkt->nad, body));
mem[NAD_CDATA_L(pkt->nad, body)] = 0;
}
os_object_put(o, "message", mem, os_type_STRING);
// Subject
mem[0]=0;
if ( (sub > 0) && (NAD_CDATA_L(pkt->nad, sub ) > 0) ) {
strncpy(mem, NAD_CDATA(pkt->nad, sub), NAD_CDATA_L(pkt->nad, sub));
mem[NAD_CDATA_L(pkt->nad, sub)] = 0;
}
os_object_put(o, "subject", mem, os_type_STRING);
// Type
mem[0]=0;
if ( (type > 0) && (NAD_AVAL_L(pkt->nad, type ) > 0) ) {
strncpy(mem, NAD_AVAL(pkt->nad, type), NAD_AVAL_L(pkt->nad, type));
mem[NAD_AVAL_L(pkt->nad, type)] = 0;
}
os_object_put(o, "type", mem, os_type_STRING);
// To and from resources
os_object_put(o, "my_resource", own_jid->resource, os_type_STRING);
os_object_put(o, "other_resource", other_jid->resource, os_type_STRING);
// Time and direction
t=time(NULL);
os_object_put(o, "direct", &direct, os_type_INTEGER);
os_object_put_time(o, "time", &t);
// Message ID
if (direct == IN_D) {
arch = nad_insert_elem(pkt->nad, 1, -1, "archived", "");
nad_set_attr(pkt->nad,arch,-1,"by",jid_user(own_jid), strlen(jid_user(own_jid)));
}
set_mid(&(pkt->sm->st), &o, pkt->nad, arch);
// Save itself
storage_put(pkt->sm->st, tbl_name, owner, os);
// Cleanup
os_object_free(o);
os_free(os);
free(mem);
log_debug(ZONE, "Saved.");
return mod_PASS;
}
/** register set handler */
static void _authreg_register_set(c2s_t c2s, sess_t sess, nad_t nad)
{
int ns = 0, elem, attr;
char username[1024], password[1024];
/* if we're not configured for registration (or pw changes), or we can't set passwords, fail outright */
if(!(sess->host->ar_register_enable || sess->host->ar_register_password) || c2s->ar->set_password == NULL) {
sx_nad_write(sess->s, stanza_tofrom(stanza_error(nad, 0, stanza_err_NOT_ALLOWED), 0));
return;
}
ns = nad_find_scoped_namespace(nad, uri_REGISTER, NULL);
/* removals */
if(sess->active && nad_find_elem(nad, 1, ns, "remove", 1) >= 0) {
/* only if full reg is enabled */
if(!sess->host->ar_register_enable) {
sx_nad_write(sess->s, stanza_tofrom(stanza_error(nad, 0, stanza_err_NOT_ALLOWED), 0));
return;
}
log_debug(ZONE, "user remove requested");
/* make sure we can delete them */
if(c2s->ar->delete_user == NULL) {
sx_nad_write(sess->s, stanza_tofrom(stanza_error(nad, 0, stanza_err_NOT_ALLOWED), 0));
return;
}
/* otherwise, delete them */
if((c2s->ar->delete_user)(c2s->ar, sess->resources->jid->node, sess->host->realm) != 0) {
log_debug(ZONE, "user delete failed");
sx_nad_write(sess->s, stanza_tofrom(stanza_error(nad, 0, stanza_err_INTERNAL_SERVER_ERROR), 0));
return;
}
log_write(c2s->log, LOG_NOTICE, "[%d] deleted user: user=%s; realm=%s", sess->s->tag, sess->resources->jid->node, sess->host->realm);
log_write(c2s->log, LOG_NOTICE, "[%d] registration remove succeeded, requesting user deletion: jid=%s", sess->s->tag, jid_user(sess->resources->jid));
/* make a result nad */
sess->result = nad_new();
ns = nad_add_namespace(sess->result, uri_CLIENT, NULL);
nad_append_elem(sess->result, ns, "iq", 0);
nad_set_attr(sess->result, 0, -1, "type", "result", 6);
/* extract the id */
attr = nad_find_attr(nad, 0, -1, "id", NULL);
if(attr >= 0)
nad_set_attr(sess->result, 0, -1, "id", NAD_AVAL(nad, attr), NAD_AVAL_L(nad, attr));
nad_free(nad);
sx_nad_write(sess->s, sess->result);
sess->result = NULL;
/* get the sm to delete them (it will force their sessions to end) */
sm_delete(sess, sess->resources);
return;
}
/* username is required */
elem = nad_find_elem(nad, 1, ns, "username", 1);
if(elem < 0)
{
log_debug(ZONE, "register set 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, "register set username failed nodeprep, bouncing it");
sx_nad_write(sess->s, stanza_tofrom(stanza_error(nad, 0, stanza_err_JID_MALFORMED), 0));
return;
}
elem = nad_find_elem(nad, 1, ns, "password", 1);
if(elem < 0)
{
log_debug(ZONE, "register set with no password, bouncing it");
sx_nad_write(sess->s, stanza_tofrom(stanza_error(nad, 0, stanza_err_BAD_REQUEST), 0));
return;
}
/* if they're already auth'd, its a password change */
if(sess->active)
{
/* confirm that the username matches their auth id */
if(strcmp(username, sess->resources->jid->node) != 0)
{
log_debug(ZONE, "%s is trying to change password for %s, bouncing it", jid_full(sess->resources->jid), username);
sx_nad_write(sess->s, stanza_tofrom(stanza_error(nad, 0, stanza_err_OLD_UNAUTH), 0));
return;
}
}
/* can't go on if we're not doing full reg */
else if(!sess->host->ar_register_enable) {
sx_nad_write(sess->s, stanza_tofrom(stanza_error(nad, 0, stanza_err_NOT_ALLOWED), 0));
return;
}
/* if they exist, bounce */
else if((c2s->ar->user_exists)(c2s->ar, username, sess->host->realm))
{
log_debug(ZONE, "attempt to register %s, but they already exist", username);
sx_nad_write(sess->s, stanza_tofrom(stanza_error(nad, 0, stanza_err_CONFLICT), 0));
return;
}
/* make sure we can create them */
else if(c2s->ar->create_user == NULL)
{
sx_nad_write(sess->s, stanza_tofrom(stanza_error(nad, 0, stanza_err_NOT_ALLOWED), 0));
return;
}
/* otherwise, create them */
else if((c2s->ar->create_user)(c2s->ar, username, sess->host->realm) != 0)
{
log_debug(ZONE, "user create failed");
sx_nad_write(sess->s, stanza_tofrom(stanza_error(nad, 0, stanza_err_INTERNAL_SERVER_ERROR), 0));
return;
}
else
log_write(c2s->log, LOG_NOTICE, "[%d] created user: user=%s; realm=%s", sess->s->tag, username, sess->host->realm);
/* extract the password */
snprintf(password, 257, "%.*s", NAD_CDATA_L(nad, elem), NAD_CDATA(nad, elem));
/* change it */
if((c2s->ar->set_password)(c2s->ar, username, sess->host->realm, password) != 0)
{
log_debug(ZONE, "password store failed");
sx_nad_write(sess->s, stanza_tofrom(stanza_error(nad, 0, stanza_err_INTERNAL_SERVER_ERROR), 0));
return;
}
log_debug(ZONE, "updated auth creds for %s", username);
/* make a result nad */
sess->result = nad_new();
ns = nad_add_namespace(sess->result, uri_CLIENT, NULL);
nad_append_elem(sess->result, ns, "iq", 0);
nad_set_attr(sess->result, 0, -1, "type", "result", 6);
/* extract the id */
attr = nad_find_attr(nad, 0, -1, "id", NULL);
if(attr >= 0)
nad_set_attr(sess->result, 0, -1, "id", NAD_AVAL(nad, attr), NAD_AVAL_L(nad, attr));
/* if they're active, then this was just a password change, and we're done */
if(sess->active) {
log_write(c2s->log, LOG_NOTICE, "[%d] password changed: jid=%s", sess->s->tag, jid_user(sess->resources->jid));
sx_nad_write(sess->s, sess->result);
sess->result = NULL;
return;
}
/* create new bound jid holder */
if(sess->resources == NULL) {
sess->resources = (bres_t) calloc(1, sizeof(struct bres_st));
}
/* our local id */
sprintf(sess->resources->c2s_id, "%d", sess->s->tag);
/* the user jid for this transaction */
sess->resources->jid = jid_new(sess->s->req_to, -1);
jid_reset_components(sess->resources->jid, username, sess->resources->jid->domain, sess->resources->jid->resource);
log_write(c2s->log, LOG_NOTICE, "[%d] registration succeeded, requesting user creation: jid=%s", sess->s->tag, jid_user(sess->resources->jid));
/* get the sm to create them */
sm_create(sess, sess->resources);
nad_free(nad);
return;
}
static void _router_process_route(component_t comp, nad_t nad) {
int atype, ato, afrom;
unsigned int dest;
struct jid_st sto, sfrom;
jid_static_buf sto_buf, sfrom_buf;
jid_t to = NULL, from = NULL;
routes_t targets;
component_t target;
union xhashv xhv;
/* init static jid */
jid_static(&sto,&sto_buf);
jid_static(&sfrom,&sfrom_buf);
if(nad_find_attr(nad, 0, -1, "error", NULL) >= 0) {
log_debug(ZONE, "dropping error packet, trying to avoid loops");
nad_free(nad);
return;
}
atype = nad_find_attr(nad, 0, -1, "type", NULL);
ato = nad_find_attr(nad, 0, -1, "to", NULL);
afrom = nad_find_attr(nad, 0, -1, "from", NULL);
if(ato >= 0) to = jid_reset(&sto, NAD_AVAL(nad, ato), NAD_AVAL_L(nad, ato));
if(afrom >= 0) from = jid_reset(&sfrom, NAD_AVAL(nad, afrom), NAD_AVAL_L(nad, afrom));
/* unicast */
if(atype < 0) {
if(to == NULL || from == NULL) {
log_debug(ZONE, "unicast route with missing or invalid to or from, bouncing");
nad_set_attr(nad, 0, -1, "error", "400", 3);
_router_comp_write(comp, nad);
return;
}
log_debug(ZONE, "unicast route from %s to %s", from->domain, to->domain);
/* check the from */
if(xhash_get(comp->routes, from->domain) == NULL) {
log_write(comp->r->log, LOG_NOTICE, "[%s, port=%d] tried to send a packet from '%s', but that name is not bound to this component", comp->ip, comp->port, from->domain);
nad_set_attr(nad, 0, -1, "error", "401", 3);
_router_comp_write(comp, nad);
return;
}
/* filter it */
if(comp->r->filter != NULL) {
int ret = filter_packet(comp->r, nad);
if(ret == stanza_err_REDIRECT) {
ato = nad_find_attr(nad, 0, -1, "to", NULL);
if(ato >= 0) to = jid_reset(&sto, NAD_AVAL(nad, ato), NAD_AVAL_L(nad, ato));
}
else if(ret > 0) {
log_debug(ZONE, "packet filtered out: %s (%s)", _stanza_errors[ret - stanza_err_BAD_REQUEST].name, _stanza_errors[ret - stanza_err_BAD_REQUEST].code);
nad_set_attr(nad, 0, -1, "error", _stanza_errors[ret - stanza_err_BAD_REQUEST].code, 3);
_router_comp_write(comp, nad);
return;
}
}
/* find a target */
targets = xhash_get(comp->r->routes, to->domain);
if(targets == NULL) {
if(comp->r->default_route != NULL && strcmp(from->domain, comp->r->default_route) == 0) {
log_debug(ZONE, "%s is unbound, bouncing", from->domain);
nad_set_attr(nad, 0, -1, "error", "404", 3);
_router_comp_write(comp, nad);
return;
}
targets = xhash_get(comp->r->routes, comp->r->default_route);
}
if(targets == NULL) {
log_debug(ZONE, "%s is unbound, and no default route, bouncing", to->domain);
nad_set_attr(nad, 0, -1, "error", "404", 3);
_router_comp_write(comp, nad);
return;
}
/* copy to any log sinks */
if(xhash_count(comp->r->log_sinks) > 0)
xhash_walk(comp->r->log_sinks, _router_route_log_sink, (void *) nad);
/* get route candidate */
if(targets->ncomp == 1) {
dest = 0;
}
else {
switch(targets->rtype) {
case route_MULTI_TO:
ato = nad_find_attr(nad, 1, -1, "to", NULL);
if(ato >= 0) to = jid_reset(&sto, NAD_AVAL(nad, ato), NAD_AVAL_L(nad, ato));
else {
ato = nad_find_attr(nad, 1, -1, "target", NULL);
if(ato >= 0) to = jid_reset(&sto, NAD_AVAL(nad, ato), NAD_AVAL_L(nad, ato));
else {
const char *out; int len;
nad_print(nad, 0, &out, &len);
log_write(comp->r->log, LOG_ERR, "Cannot get destination for multiple route: %.*s", len, out);
}
}
break;
case route_MULTI_FROM:
ato = nad_find_attr(nad, 1, -1, "from", NULL);
if(ato >= 0) to = jid_reset(&sto, NAD_AVAL(nad, ato), NAD_AVAL_L(nad, ato));
else {
const char *out; int len;
nad_print(nad, 0, &out, &len);
log_write(comp->r->log, LOG_ERR, "Cannot get source for multiple route: %.*s", len, out);
}
break;
default:
log_write(comp->r->log, LOG_ERR, "Multiple components bound to single component route '%s'", targets->name);
/* simulate no 'to' info in this case */
}
if(to->node == NULL || strlen(to->node) == 0) {
/* no node in destination JID - going random */
dest = rand();
log_debug(ZONE, "randomized to %u %% %d = %d", dest, targets->ncomp, dest % targets->ncomp);
}
else {
/* use JID hash */
unsigned char hashval[20];
unsigned int *val;
int i;
shahash_raw(jid_user(to), hashval);
val = (unsigned int *) hashval;
dest = *val;
for(i=1; i < 20 / (sizeof(unsigned int)/sizeof(unsigned char)); i++, val++) {
dest ^= *val;
}
dest >>= 2;
log_debug(ZONE, "JID %s hashed to %u %% %d = %d", jid_user(to), dest, targets->ncomp, dest % targets->ncomp);
/* jid_user() calls jid_expand() which may allocate some memory in _user and _full */
if (to->_user != NULL )
free(to->_user);
if (to->_full != NULL )
free(to->_full);
}
dest = dest % targets->ncomp;
}
target = targets->comp[dest];
/* push it out */
log_debug(ZONE, "writing route for '%s'*%u to %s, port %d", to->domain, dest+1, target->ip, target->port);
/* if logging enabled, log messages that match our criteria */
if (comp->r->message_logging_enabled && comp->r->message_logging_file != NULL) {
int attr_msg_to;
int attr_msg_from;
int attr_route_to;
int attr_route_from;
jid_t jid_msg_from = NULL;
jid_t jid_msg_to = NULL;
jid_t jid_route_from = NULL;
jid_t jid_route_to = NULL;
if ((NAD_ENAME_L(nad, 1) == 7 && strncmp("message", NAD_ENAME(nad, 1), 7) == 0) && // has a "message" element
((attr_route_from = nad_find_attr(nad, 0, -1, "from", NULL)) >= 0) &&
((attr_route_to = nad_find_attr(nad, 0, -1, "to", NULL)) >= 0) &&
((strncmp(NAD_AVAL(nad, attr_route_to), "c2s", 3)) != 0) && // ignore messages to "c2s" or we'd have dups
((jid_route_from = jid_new(NAD_AVAL(nad, attr_route_from), NAD_AVAL_L(nad, attr_route_from))) != NULL) && // has valid JID source in route
((jid_route_to = jid_new(NAD_AVAL(nad, attr_route_to), NAD_AVAL_L(nad, attr_route_to))) != NULL) && // has valid JID destination in route
((attr_msg_from = nad_find_attr(nad, 1, -1, "from", NULL)) >= 0) &&
((attr_msg_to = nad_find_attr(nad, 1, -1, "to", NULL)) >= 0) &&
((jid_msg_from = jid_new(NAD_AVAL(nad, attr_msg_from), NAD_AVAL_L(nad, attr_msg_from))) != NULL) && // has valid JID source in message
((jid_msg_to = jid_new(NAD_AVAL(nad, attr_msg_to), NAD_AVAL_L(nad, attr_msg_to))) != NULL)) // has valid JID dest in message
{
message_log(nad, comp->r, jid_full(jid_msg_from), jid_full(jid_msg_to));
}
if (jid_msg_from != NULL)
jid_free(jid_msg_from);
if (jid_msg_to != NULL)
jid_free(jid_msg_to);
if (jid_route_from != NULL)
jid_free(jid_route_from);
if (jid_route_to != NULL)
jid_free(jid_route_to);
}
_router_comp_write(target, nad);
return;
}
/* broadcast */
if(NAD_AVAL_L(nad, atype) == 9 && strncmp("broadcast", NAD_AVAL(nad, atype), 9) == 0) {
if(from == NULL) {
log_debug(ZONE, "broadcast route with missing or invalid from, bouncing");
nad_set_attr(nad, 0, -1, "error", "400", 3);
_router_comp_write(comp, nad);
return;
}
log_debug(ZONE, "broadcast route from %s", from->domain);
/* check the from */
if(xhash_get(comp->routes, from->domain) == NULL) {
log_write(comp->r->log, LOG_NOTICE, "[%s, port=%d] tried to send a packet from '%s', but that name is not bound to this component", comp->ip, comp->port, from->domain);
nad_set_attr(nad, 0, -1, "error", "401", 3);
_router_comp_write(comp, nad);
return;
}
/* loop the components and distribute */
if(xhash_iter_first(comp->r->components))
do {
xhv.comp_val = ⌖
xhash_iter_get(comp->r->components, NULL, NULL, xhv.val);
if(target != comp) {
log_debug(ZONE, "writing broadcast to %s, port %d", target->ip, target->port);
_router_comp_write(target, nad_copy(nad));
}
} while(xhash_iter_next(comp->r->components));
nad_free(nad);
return;
}
log_debug(ZONE, "unknown route type '%.*s', dropping", NAD_AVAL_L(nad, atype), NAD_AVAL(nad, atype));
nad_free(nad);
}
static mod_ret_t _session_in_router(mod_instance_t mi, pkt_t pkt) {
sm_t sm = mi->mod->mm->sm;
int ns, iq, elem, attr;
jid_t jid;
sess_t sess = (sess_t) NULL;
mod_ret_t ret;
/* if we've got this namespace, its from a c2s */
if(pkt->nad->ecur <= 1 || (ns = nad_find_namespace(pkt->nad, 1, uri_SESSION, NULL)) < 0)
return mod_PASS;
/* don't bother if its a failure */
if(pkt->type & pkt_SESS_FAILED) {
/* !!! check failed=1, handle */
pkt_free(pkt);
return mod_HANDLED;
}
/* session commands */
if(pkt->type & pkt_SESS) {
ns = nad_find_namespace(pkt->nad, 1, uri_SESSION, NULL);
/* only end can get away without a target */
attr = nad_find_attr(pkt->nad, 1, -1, "target", NULL);
if(attr < 0 && pkt->type != pkt_SESS_END) {
nad_set_attr(pkt->nad, 1, ns, "failed", "1", 1);
sx_nad_write(sm->router, stanza_tofrom(pkt->nad, 0));
pkt->nad = NULL;
pkt_free(pkt);
return mod_HANDLED;
}
/* session start */
if(pkt->type == pkt_SESS) {
jid = jid_new(NAD_AVAL(pkt->nad, attr), NAD_AVAL_L(pkt->nad, attr));
if(jid != NULL)
sess = sess_start(sm, jid);
if(jid == NULL || sess == NULL) {
nad_set_attr(pkt->nad, 1, ns, "failed", "1", 1);
sx_nad_write(sm->router, stanza_tofrom(pkt->nad, 0));
pkt->nad = NULL;
pkt_free(pkt);
if(jid != NULL)
jid_free(jid);
return mod_HANDLED;
}
/* c2s component that is handling this session */
strcpy(sess->c2s, pkt->rfrom->domain);
/* remember what c2s calls us */
attr = nad_find_attr(pkt->nad, 1, ns, "c2s", NULL);
snprintf(sess->c2s_id, sizeof(sess->c2s_id), "%.*s", NAD_AVAL_L(pkt->nad, attr), NAD_AVAL(pkt->nad, attr));
/* mark PBX session as fake */
if(!strncmp("PBX", sess->c2s_id, 3)) {
sess->fake = 1;
}
/* add our id */
nad_set_attr(pkt->nad, 1, ns, "sm", sess->sm_id, 0);
/* mark that it started OK */
nad_set_attr(pkt->nad, 1, -1, "action", "started", 7);
/* set this SM name */
nad_set_attr(pkt->nad, 0, -1, "to", sm->id, 0);
/* inform c2s */
sx_nad_write(sm->router, stanza_tofrom(pkt->nad, 0));
pkt->nad = NULL;
pkt_free(pkt);
jid_free(jid);
return mod_HANDLED;
}
/* user create */
if(pkt->type == pkt_SESS_CREATE) {
jid = jid_new(NAD_AVAL(pkt->nad, attr), NAD_AVAL_L(pkt->nad, attr));
if(jid == NULL || user_create(sm, jid) != 0) {
nad_set_attr(pkt->nad, 1, ns, "failed", "1", 1);
sx_nad_write(sm->router, stanza_tofrom(pkt->nad, 0));
pkt->nad = NULL;
pkt_free(pkt);
if(jid != NULL)
jid_free(jid);
return mod_HANDLED;
}
/* inform c2s */
nad_set_attr(pkt->nad, 1, -1, "action", "created", 7);
sx_nad_write(sm->router, stanza_tofrom(pkt->nad, 0));
pkt->nad = NULL;
pkt_free(pkt);
jid_free(jid);
return mod_HANDLED;
}
/* user delete */
if(pkt->type == pkt_SESS_DELETE) {
jid = jid_new(NAD_AVAL(pkt->nad, attr), NAD_AVAL_L(pkt->nad, attr));
if(jid == NULL) {
pkt_free(pkt);
return mod_HANDLED;
}
user_delete(sm, jid);
/* inform c2s */
nad_set_attr(pkt->nad, 1, -1, "action", "deleted", 7);
sx_nad_write(sm->router, stanza_tofrom(pkt->nad, 0));
pkt->nad = NULL;
pkt_free(pkt);
jid_free(jid);
return mod_HANDLED;
}
/* get the session id */
attr = nad_find_attr(pkt->nad, 1, ns, "sm", NULL);
if(attr < 0) {
log_debug(ZONE, "no session id, bouncing");
nad_set_attr(pkt->nad, 1, ns, "failed", "1", 1);
sx_nad_write(sm->router, stanza_tofrom(pkt->nad, 0));
pkt->nad = NULL;
pkt_free(pkt);
return mod_HANDLED;
}
/* find the corresponding session */
sess = xhash_getx(sm->sessions, NAD_AVAL(pkt->nad, attr), NAD_AVAL_L(pkt->nad, attr));
/* active check */
if(sess == NULL) {
log_debug(ZONE, "session %.*s doesn't exist, bouncing", NAD_AVAL_L(pkt->nad, attr), NAD_AVAL(pkt->nad, attr));
nad_set_attr(pkt->nad, 1, ns, "failed", "1", 1);
sx_nad_write(sm->router, stanza_tofrom(pkt->nad, 0));
pkt->nad = NULL;
pkt_free(pkt);
return mod_HANDLED;
}
/* make sure its from them */
attr = nad_find_attr(pkt->nad, 1, ns, "c2s", NULL);
if(attr >= 0 && (strlen(sess->c2s_id) != NAD_AVAL_L(pkt->nad, attr) || strncmp(sess->c2s_id, NAD_AVAL(pkt->nad, attr), NAD_AVAL_L(pkt->nad, attr)) != 0)) {
log_debug(ZONE, "invalid sender on route from %s for session %s (should be %s)", pkt->rfrom->domain, sess->sm_id, sess->c2s_id);
pkt_free(pkt);
return mod_HANDLED;
}
/* session end */
if(pkt->type == pkt_SESS_END) {
sm_c2s_action(sess, "ended", NULL);
sess_end(sess);
pkt_free(pkt);
return mod_HANDLED;
}
log_debug(ZONE, "unknown session packet, dropping");
pkt_free(pkt);
return mod_HANDLED;
}
/* otherwise, its a normal packet for the session */
/* #ifdef ENABLE_SUPERSEDED // FIXME XXX TODO clients are not yet ready for this */
/* check for RFC3920 session request *
* with RFC3920bis it is unneeded *
* session is activated by bind, so we just return back result */
if((ns = nad_find_scoped_namespace(pkt->nad, uri_XSESSION, NULL)) >= 0 &&
(iq = nad_find_elem(pkt->nad, 0, -1, "iq", 1)) >= 0 &&
(elem = nad_find_elem(pkt->nad, iq, ns, "session", 1)) >= 0) {
log_debug(ZONE, "session create request");
/* build a result packet */
nad_drop_elem(pkt->nad, elem);
nad_set_attr(pkt->nad, iq, -1, "type", "result", 6);
/* return the result */
sx_nad_write(sm->router, stanza_tofrom(pkt->nad, 0));
pkt->nad = NULL;
pkt_free(pkt);
return mod_HANDLED;
}
/* #endif */
/* get the session id */
attr = nad_find_attr(pkt->nad, 1, ns, "sm", NULL);
if(attr < 0) {
log_debug(ZONE, "no session id, bouncing");
nad_set_attr(pkt->nad, 1, ns, "failed", "1", 1);
sx_nad_write(sm->router, stanza_tofrom(pkt->nad, 0));
pkt->nad = NULL;
pkt_free(pkt);
return mod_HANDLED;
}
/* find the corresponding session */
sess = xhash_getx(sm->sessions, NAD_AVAL(pkt->nad, attr), NAD_AVAL_L(pkt->nad, attr));
/* active check */
if(sess == NULL) {
log_debug(ZONE, "session %.*s doesn't exist, bouncing", NAD_AVAL_L(pkt->nad, attr), NAD_AVAL(pkt->nad, attr));
nad_set_attr(pkt->nad, 1, ns, "failed", "1", 1);
sx_nad_write(sm->router, stanza_tofrom(pkt->nad, 0));
pkt->nad = NULL;
pkt_free(pkt);
return mod_HANDLED;
}
/* make sure its from them */
attr = nad_find_attr(pkt->nad, 1, ns, "c2s", NULL);
if(attr >= 0 && (strlen(sess->c2s_id) != NAD_AVAL_L(pkt->nad, attr) || strncmp(sess->c2s_id, NAD_AVAL(pkt->nad, attr), NAD_AVAL_L(pkt->nad, attr)) != 0)) {
log_debug(ZONE, "invalid sender on route from %s for session %s (should be %s)", jid_full(pkt->rfrom), sess->sm_id, sess->c2s_id);
pkt_free(pkt);
return mod_HANDLED;
}
/* where it came from */
pkt->source = sess;
/* hand it to the modules */
ret = mm_in_sess(pkt->sm->mm, sess, pkt);
switch(ret) {
case mod_HANDLED:
break;
case mod_PASS:
/* ignore IQ result packets that haven't been handled - XMPP 9.2.3.4 */
if(pkt->type == pkt_IQ_RESULT)
break;
else
ret = -stanza_err_FEATURE_NOT_IMPLEMENTED;
default:
pkt_sess(pkt_error(pkt, -ret), sess);
break;
}
return mod_HANDLED;
}
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 mod_ret_t _vacation_in_sess(mod_instance_t mi, sess_t sess, pkt_t pkt) {
module_t mod = mi->mod;
vacation_t v = sess->user->module_data[mod->index];
int ns, start, end, msg;
char dt[30];
pkt_t res;
os_t os;
os_object_t o;
/* we only want to play with vacation iq packets */
if((pkt->type != pkt_IQ && pkt->type != pkt_IQ_SET) || pkt->ns != ns_VACATION)
return mod_PASS;
/* if it has a to, throw it out */
if(pkt->to != NULL)
return -stanza_err_BAD_REQUEST;
/* get */
if(pkt->type == pkt_IQ) {
if(v->msg == NULL) {
res = pkt_create(mod->mm->sm, "iq", "result", NULL, NULL);
pkt_id(pkt, res);
pkt_free(pkt);
pkt_sess(res, sess);
return mod_HANDLED;
}
ns = nad_find_scoped_namespace(pkt->nad, uri_VACATION, NULL);
if(v->start != 0) {
datetime_out(v->start, dt_DATETIME, dt, 30);
nad_insert_elem(pkt->nad, 2, ns, "start", dt);
} else
nad_insert_elem(pkt->nad, 2, ns, "start", NULL);
if(v->end != 0) {
datetime_out(v->end, dt_DATETIME, dt, 30);
nad_insert_elem(pkt->nad, 2, ns, "end", dt);
} else
nad_insert_elem(pkt->nad, 2, ns, "end", NULL);
nad_insert_elem(pkt->nad, 2, ns, "message", v->msg);
pkt_tofrom(pkt);
nad_set_attr(pkt->nad, 1, -1, "type", "result", 6);
pkt_sess(pkt, sess);
return mod_HANDLED;
}
/* set */
ns = nad_find_scoped_namespace(pkt->nad, uri_VACATION, NULL);
start = nad_find_elem(pkt->nad, 2, ns, "start", 1);
end = nad_find_elem(pkt->nad, 2, ns, "end", 1);
msg = nad_find_elem(pkt->nad, 2, ns, "message", 1);
if(start < 0 || end < 0 || msg < 0) {
/* forget */
if(v->msg != NULL) {
free(v->msg);
v->msg = NULL;
}
v->start = 0;
v->end = 0;
storage_delete(mi->sm->st, "vacation-settings", jid_user(sess->jid), NULL);
res = pkt_create(mod->mm->sm, "iq", "result", NULL, NULL);
pkt_id(pkt, res);
pkt_free(pkt);
pkt_sess(res, sess);
return mod_HANDLED;
}
if(NAD_CDATA_L(pkt->nad, start) > 0) {
strncpy(dt, NAD_CDATA(pkt->nad, start), (30 < NAD_CDATA_L(pkt->nad, start) ? 30 : NAD_CDATA_L(pkt->nad, start)));
v->start = datetime_in(dt);
} else
v->start = 0;
if(NAD_CDATA_L(pkt->nad, end) > 0) {
strncpy(dt, NAD_CDATA(pkt->nad, end), (30 < NAD_CDATA_L(pkt->nad, end) ? 30 : NAD_CDATA_L(pkt->nad, end)));
v->end = datetime_in(dt);
} else
v->end = 0;
v->msg = (char *) malloc(sizeof(char) * (NAD_CDATA_L(pkt->nad, msg) + 1));
strncpy(v->msg, NAD_CDATA(pkt->nad, msg), NAD_CDATA_L(pkt->nad, msg));
v->msg[NAD_CDATA_L(pkt->nad, msg)] = '\0';
os = os_new();
o = os_object_new(os);
os_object_put(o, "start", &v->start, os_type_INTEGER);
os_object_put(o, "end", &v->end, os_type_INTEGER);
os_object_put(o, "message", v->msg, os_type_STRING);
if(storage_replace(mod->mm->sm->st, "vacation-settings", jid_user(sess->user->jid), NULL, os) != st_SUCCESS) {
free(v->msg);
v->msg = NULL;
v->start = 0;
v->end = 0;
return -stanza_err_INTERNAL_SERVER_ERROR;
}
res = pkt_create(mod->mm->sm, "iq", "result", NULL, NULL);
pkt_id(pkt, res);
pkt_free(pkt);
pkt_sess(res, sess);
return mod_HANDLED;
}
static mod_ret_t _iq_private_in_sess(mod_instance_t mi, sess_t sess, pkt_t pkt) {
module_t mod = mi->mod;
int ns, elem, target, targetns;
st_ret_t ret;
char filter[4096];
os_t os;
os_object_t o;
nad_t nad;
pkt_t result;
sess_t sscan;
/* only handle private sets and gets */
if((pkt->type != pkt_IQ && pkt->type != pkt_IQ_SET) || pkt->ns != ns_PRIVATE)
return mod_PASS;
/* we're only interested in no to, to our host, or to us */
if(pkt->to != NULL && jid_compare_user(sess->jid, pkt->to) != 0 && strcmp(sess->jid->domain, jid_user(pkt->to)) != 0)
return mod_PASS;
ns = nad_find_scoped_namespace(pkt->nad, uri_PRIVATE, NULL);
elem = nad_find_elem(pkt->nad, 1, ns, "query", 1);
/* find the first child */
target = elem + 1;
while(target < pkt->nad->ecur)
{
if(pkt->nad->elems[target].depth > pkt->nad->elems[elem].depth)
break;
target++;
}
/* not found, so we're done */
if(target == pkt->nad->ecur)
return -stanza_err_BAD_REQUEST;
/* find the target namespace */
targetns = NAD_ENS(pkt->nad, target);
/* gotta have a namespace */
if(targetns < 0)
{
log_debug(ZONE, "no namespace specified");
return -stanza_err_BAD_REQUEST;
}
log_debug(ZONE, "processing private request for %.*s", NAD_NURI_L(pkt->nad, targetns), NAD_NURI(pkt->nad, targetns));
/* get */
if(pkt->type == pkt_IQ) {
#ifdef ENABLE_EXPERIMENTAL
/* remember that this resource requested the namespace */
if(sess->module_data[mod->index] == NULL) {
/* create new hash if necesary */
sess->module_data[mod->index] = xhash_new(101);
pool_cleanup(sess->p, (void (*))(void *) xhash_free, sess->module_data[mod->index]);
}
xhash_put(sess->module_data[mod->index], pstrdupx(sess->p, NAD_NURI(pkt->nad, targetns), NAD_NURI_L(pkt->nad, targetns)), (void *) 1);
#endif
snprintf(filter, 4096, "(ns=%i:%.*s)", NAD_NURI_L(pkt->nad, targetns), NAD_NURI_L(pkt->nad, targetns), NAD_NURI(pkt->nad, targetns));
ret = storage_get(sess->user->sm->st, "private", jid_user(sess->jid), filter, &os);
switch(ret) {
case st_SUCCESS:
if(os_iter_first(os)) {
o = os_iter_object(os);
if(os_object_get_nad(os, o, "xml", &nad)) {
result = pkt_new(sess->user->sm, nad_copy(nad));
if(result != NULL) {
nad_set_attr(result->nad, 1, -1, "type", "result", 6);
pkt_id(pkt, result);
pkt_sess(result, sess);
pkt_free(pkt);
os_free(os);
return mod_HANDLED;
}
}
}
os_free(os);
/* drop through */
log_debug(ZONE, "storage_get succeeded, but couldn't make packet, faking st_NOTFOUND");
case st_NOTFOUND:
log_debug(ZONE, "namespace not found, returning");
/*
* !!! really, we should just return a 404. 1.4 just slaps a
* result on the packet and sends it back. hurrah for
* legacy namespaces.
*/
nad_set_attr(pkt->nad, 1, -1, "type", "result", 6);
pkt_sess(pkt_tofrom(pkt), sess);
return mod_HANDLED;
case st_FAILED:
return -stanza_err_INTERNAL_SERVER_ERROR;
case st_NOTIMPL:
return -stanza_err_FEATURE_NOT_IMPLEMENTED;
}
}
os = os_new();
o = os_object_new(os);
snprintf(filter, 4096, "%.*s", NAD_NURI_L(pkt->nad, targetns), NAD_NURI(pkt->nad, targetns));
os_object_put(o, "ns", filter, os_type_STRING);
os_object_put(o, "xml", pkt->nad, os_type_NAD);
snprintf(filter, 4096, "(ns=%i:%.*s)", NAD_NURI_L(pkt->nad, targetns), NAD_NURI_L(pkt->nad, targetns), NAD_NURI(pkt->nad, targetns));
ret = storage_replace(sess->user->sm->st, "private", jid_user(sess->jid), filter, os);
os_free(os);
switch(ret) {
case st_FAILED:
return -stanza_err_INTERNAL_SERVER_ERROR;
case st_NOTIMPL:
return -stanza_err_FEATURE_NOT_IMPLEMENTED;
default:
/* create result packet */
result = pkt_create(sess->user->sm, "iq", "result", NULL, NULL);
pkt_id(pkt, result);
/* and flush it to the session */
pkt_sess(result, sess);
#ifdef ENABLE_EXPERIMENTAL
/* push it to all resources that read this xmlns item */
snprintf(filter, 4096, "%.*s", NAD_NURI_L(pkt->nad, targetns), NAD_NURI(pkt->nad, targetns));
for(sscan = sess->user->sessions; sscan != NULL; sscan = sscan->next) {
/* skip our resource and those that didn't read any private-storage */
if(sscan == sess || sscan->module_data[mod->index] == NULL)
continue;
/* check whether namespace was read */
if(xhash_get(sscan->module_data[mod->index], filter)) {
result = pkt_dup(pkt, jid_full(sscan->jid), NULL);
if(result->from != NULL) {
jid_free(result->from);
nad_set_attr(result->nad, 1, -1, "from", NULL, 0);
}
pkt_id_new(result);
pkt_sess(result, sscan);
}
}
#endif
/* finally free the packet */
pkt_free(pkt);
return mod_HANDLED;
}
/* we never get here */
return 0;
}
/** 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);
}
