int
noit_http_rest_raw_handler(eventer_t e, int mask, void *closure,
struct timeval *now) {
int newmask = EVENTER_READ | EVENTER_EXCEPTION, rv, done = 0;
acceptor_closure_t *ac = closure;
noit_http_rest_closure_t *restc = ac->service_ctx;
if(mask & EVENTER_EXCEPTION || (restc && restc->wants_shutdown)) {
/* Exceptions cause us to simply snip the connection */
eventer_remove_fd(e->fd);
e->opset->close(e->fd, &newmask, e);
acceptor_closure_free(ac);
return 0;
}
if(!ac->service_ctx) {
ac->service_ctx = restc = noit_http_rest_closure_alloc();
ac->service_ctx_free = noit_http_rest_closure_free;
restc->ac = ac;
restc->http_ctx =
noit_http_session_ctx_new(noit_rest_request_dispatcher,
restc, e, ac);
}
rv = noit_http_session_drive(e, mask, restc->http_ctx, now, &done);
if(done) {
acceptor_closure_free(ac);
}
return rv;
}
int
noit_http_rest_handler(eventer_t e, int mask, void *closure,
struct timeval *now) {
int newmask = EVENTER_READ | EVENTER_EXCEPTION, rv, done = 0;
acceptor_closure_t *ac = closure;
noit_http_rest_closure_t *restc = ac->service_ctx;
if(mask & EVENTER_EXCEPTION || (restc && restc->wants_shutdown)) {
socket_error:
/* Exceptions cause us to simply snip the connection */
eventer_remove_fd(e->fd);
e->opset->close(e->fd, &newmask, e);
acceptor_closure_free(ac);
return 0;
}
if(!ac->service_ctx) {
const char *primer = "";
ac->service_ctx = restc = noit_http_rest_closure_alloc();
ac->service_ctx_free = noit_http_rest_closure_free;
restc->ac = ac;
restc->remote_cn = strdup(ac->remote_cn ? ac->remote_cn : "");
restc->http_ctx =
noit_http_session_ctx_new(noit_rest_request_dispatcher,
restc, e, ac);
switch(ac->cmd) {
case NOIT_CONTROL_DELETE:
primer = "DELE";
break;
case NOIT_CONTROL_GET:
primer = "GET ";
break;
case NOIT_CONTROL_HEAD:
primer = "HEAD";
break;
case NOIT_CONTROL_POST:
primer = "POST";
break;
case NOIT_CONTROL_PUT:
primer = "PUT ";
break;
case NOIT_CONTROL_MERGE:
primer = "MERG";
break;
default:
goto socket_error;
}
noit_http_session_prime_input(restc->http_ctx, primer, 4);
}
rv = noit_http_session_drive(e, mask, restc->http_ctx, now, &done);
if(done) {
acceptor_closure_free(ac);
}
return rv;
}
int
noit_control_dispatch(eventer_t e, int mask, void *closure,
struct timeval *now) {
u_int32_t cmd;
int len = 0, callmask = mask;
void *vdelegation_table;
noit_hash_table *delegation_table = NULL;
acceptor_closure_t *ac = closure;
assert(ac->rlen >= 0);
while(len >= 0 && ac->rlen < sizeof(cmd)) {
len = e->opset->read(e->fd, ((char *)&cmd) + ac->rlen,
sizeof(cmd) - ac->rlen, &mask, e);
if(len == -1 && errno == EAGAIN)
return EVENTER_READ | EVENTER_EXCEPTION;
if(len > 0) ac->rlen += len;
}
assert(ac->rlen >= 0 && ac->rlen <= sizeof(cmd));
if(callmask & EVENTER_EXCEPTION || ac->rlen != sizeof(cmd)) {
int newmask;
socket_error:
/* Exceptions cause us to simply snip the connection */
eventer_remove_fd(e->fd);
e->opset->close(e->fd, &newmask, e);
acceptor_closure_free(ac);
return 0;
}
ac->cmd = ntohl(cmd);
/* Lookup cmd and dispatch */
if(noit_hash_retrieve(&listener_commands,
(char *)&ac->dispatch, sizeof(ac->dispatch),
(void **)&vdelegation_table)) {
void *vfunc;
delegation_table = (noit_hash_table *)vdelegation_table;
if(noit_hash_retrieve(delegation_table,
(char *)&ac->cmd, sizeof(ac->cmd), &vfunc)) {
e->callback = *((eventer_func_t *)vfunc);
return e->callback(e, callmask, closure, now);
}
else {
const char *event_name;
noitL(noit_error, "listener (%s %p) has no command: 0x%08x\n",
(event_name = eventer_name_for_callback(ac->dispatch))?event_name:"???",
delegation_table, cmd);
}
}
else {
const char *event_name;
noitL(noit_error, "No delegation table for listener (%s %p)\n",
(event_name = eventer_name_for_callback(ac->dispatch))?event_name:"???",
delegation_table);
}
goto socket_error;
}
int
stratcon_realtime_http_handler(eventer_t e, int mask, void *closure,
struct timeval *now) {
int done = 0, rv;
acceptor_closure_t *ac = closure;
noit_http_session_ctx *http_ctx = ac->service_ctx;
rv = noit_http_session_drive(e, mask, http_ctx, now, &done);
if(done) acceptor_closure_free(ac);
return rv;
}
static int
handoff_http_handler(eventer_t e, int mask, void *closure,
struct timeval *now) {
int done = 0, rv;
acceptor_closure_t *ac = closure;
noit_http_session_ctx *http_ctx = ac->service_ctx;
rv = noit_http_session_drive(e, mask, http_ctx, now, &done);
if(done) {
the_one_and_only = NULL;
acceptor_closure_free(ac);
}
return rv;
}
void *
noit_livestream_thread_main(void *e_vptr) {
int mask;
eventer_t e = e_vptr;
acceptor_closure_t *ac = e->closure;
noit_livestream_closure_t *jcl = ac->service_ctx;
/* Go into blocking mode */
if(eventer_set_fd_blocking(e->fd) == -1) {
noitL(noit_error, "failed setting livestream to blocking: [%d] [%s]\n",
errno, strerror(errno));
goto alldone;
}
while(1) {
u_int32_t netlen;
struct log_entry *le = NULL;
int rv;
sem_wait(&jcl->lqueue_sem);
pthread_mutex_lock(&jcl->lqueue_lock);
if(jcl->lqueue) {
/* If there are items, pop and advance the header pointer */
le = jcl->lqueue;
jcl->lqueue = jcl->lqueue->next;
if(!jcl->lqueue) jcl->lqueue_end = NULL;
}
pthread_mutex_unlock(&jcl->lqueue_lock);
if(!le) continue;
/* Here we actually push the message */
netlen = htonl(le->len);
if((rv = Ewrite(&netlen, sizeof(netlen))) != sizeof(netlen)) {
noitL(noit_error, "Error writing le header over SSL %d != %d\n",
rv, (int)sizeof(netlen));
goto alldone;
}
if((rv = Ewrite(le->buff, le->len)) != le->len) {
noitL(noit_error, "Error writing livestream message over SSL %d != %d\n",
rv, le->len);
goto alldone;
}
}
alldone:
e->opset->close(e->fd, &mask, e);
jcl->wants_shutdown = 1;
if(ac) acceptor_closure_free(ac);
return NULL;
}
static int
noit_listener_accept_ssl(eventer_t e, int mask,
void *closure, struct timeval *tv) {
int rv;
listener_closure_t listener_closure = (listener_closure_t)closure;
acceptor_closure_t *ac = NULL;
if(!closure) goto socketfail;
ac = listener_closure->dispatch_closure;
rv = eventer_SSL_accept(e, &mask);
if(rv > 0) {
eventer_ssl_ctx_t *sslctx;
e->callback = listener_closure->dispatch_callback;
/* We must make a copy of the acceptor_closure_t for each new
* connection.
*/
if((sslctx = eventer_get_eventer_ssl_ctx(e)) != NULL) {
const char *cn, *end;
cn = eventer_ssl_get_peer_subject(sslctx);
if(cn && (cn = strstr(cn, "CN=")) != NULL) {
cn += 3;
end = cn;
while(*end && *end != '/') end++;
ac->remote_cn = malloc(end - cn + 1);
memcpy(ac->remote_cn, cn, end - cn);
ac->remote_cn[end-cn] = '\0';
}
}
e->closure = ac;
noitL(nldeb, "noit_listener[%s] SSL_accept on fd %d [%s]\n",
eventer_name_for_callback_e(e->callback, e),
e->fd, ac->remote_cn ? ac->remote_cn : "anonymous");
if(listener_closure) free(listener_closure);
return e->callback(e, mask, e->closure, tv);
}
if(errno == EAGAIN) return mask|EVENTER_EXCEPTION;
socketfail:
if(listener_closure) free(listener_closure);
if(ac) acceptor_closure_free(ac);
eventer_remove_fd(e->fd);
e->opset->close(e->fd, &mask, e);
return 0;
}
int
mtev_capabilities_handler(eventer_t e, int mask, void *closure,
struct timeval *now) {
int newmask = EVENTER_WRITE | EVENTER_EXCEPTION;
acceptor_closure_t *ac = closure;
mtev_capsvc_closure_t *cl = ac->service_ctx;
if(mask & EVENTER_EXCEPTION) {
socket_error:
/* Exceptions cause us to simply snip the connection */
cleanup_shutdown:
eventer_remove_fd(e->fd);
e->opset->close(e->fd, &newmask, e);
if(cl) {
if(cl->buff) free(cl->buff);
free(cl);
}
acceptor_closure_free(ac);
return 0;
}
if(!ac->service_ctx) {
cl = ac->service_ctx = calloc(1, sizeof(*cl));
mtev_capabilities_tobuff(cl, ac->dispatch);
}
while(cl->towrite > cl->written) {
int len;
while((len = e->opset->write(e->fd, cl->buff + cl->written,
cl->towrite - cl->written,
&newmask, e)) == -1 && errno == EINTR);
if(len < 0) {
if(errno == EAGAIN) return newmask | EVENTER_EXCEPTION;
goto socket_error;
}
cl->written += len;
}
goto cleanup_shutdown;
}
int
noit_console_handler(eventer_t e, int mask, void *closure,
struct timeval *now) {
int newmask = EVENTER_READ | EVENTER_EXCEPTION;
int keep_going;
acceptor_closure_t *ac = closure;
noit_console_closure_t ncct = ac->service_ctx;
if(mask & EVENTER_EXCEPTION || (ncct && ncct->wants_shutdown)) {
socket_error:
/* Exceptions cause us to simply snip the connection */
/* This removes the log feed which is important to do before calling close */
eventer_remove_fd(e->fd);
if(ncct) noit_console_closure_free(ncct);
if(ac) acceptor_closure_free(ac);
e->opset->close(e->fd, &newmask, e);
return 0;
}
if(!ac->service_ctx) {
ncct = ac->service_ctx = noit_console_closure_alloc();
}
if(!ncct->initialized) {
ncct->e = e;
if(allocate_pty(&ncct->pty_master, &ncct->pty_slave)) {
nc_printf(ncct, "Failed to open pty: %s\n", strerror(errno));
ncct->wants_shutdown = 1;
goto socket_error;
}
else {
int i;
const char *line_protocol;
HistEvent ev;
ncct->hist = history_init();
history(ncct->hist, &ev, H_SETSIZE, 500);
ncct->el = el_init("noitd", ncct->pty_master, NULL,
e->fd, e, e->fd, e);
if(!ncct->el) goto socket_error;
if(el_set(ncct->el, EL_USERDATA, ncct)) {
noitL(noit_error, "Cannot set userdata on noitedit session\n");
goto socket_error;
}
if(el_set(ncct->el, EL_EDITOR, "emacs"))
noitL(noit_error, "Cannot set emacs mode on console\n");
if(el_set(ncct->el, EL_HIST, history, ncct->hist))
noitL(noit_error, "Cannot set history on console\n");
el_set(ncct->el, EL_ADDFN, "noit_complete",
"auto completion functions for noit", noit_edit_complete);
el_set(ncct->el, EL_BIND, "^I", "noit_complete", NULL);
for(i=EL_NUM_FCNS; i < ncct->el->el_map.nfunc; i++) {
if(ncct->el->el_map.func[i] == noit_edit_complete) {
ncct->noit_edit_complete_cmdnum = i;
break;
}
}
if(!noit_hash_retr_str(ac->config,
"line_protocol", strlen("line_protocol"),
&line_protocol)) {
line_protocol = NULL;
}
if(line_protocol && !strcasecmp(line_protocol, "telnet")) {
ncct->telnet = noit_console_telnet_alloc(ncct);
ncct->output_cooker = nc_telnet_cooker;
}
noit_console_state_init(ncct);
}
snprintf(ncct->feed_path, sizeof(ncct->feed_path), "console/%d", e->fd);
noit_log_stream_new(ncct->feed_path, "noit_console", ncct->feed_path,
ncct, NULL);
noit_console_motd(e, ac, ncct);
ncct->initialized = 1;
}
/* If we still have data to send back to the client, this will take
* care of that
*/
if(noit_console_continue_sending(ncct, &newmask) < 0) {
if(ncct->wants_shutdown || errno != EAGAIN) goto socket_error;
return newmask | EVENTER_EXCEPTION;
}
for(keep_going=1 ; keep_going ; ) {
int len, plen;
char sbuf[4096];
const char *buffer;
keep_going = 0;
buffer = el_gets(ncct->el, &plen);
if(!el_eagain(ncct->el)) {
if(!buffer) {
buffer = "exit";
plen = 4;
nc_write(ncct, "\n", 1);
}
keep_going++;
}
len = e->opset->read(e->fd, sbuf, sizeof(sbuf)-1, &newmask, e);
if(len == 0 || (len < 0 && errno != EAGAIN)) {
eventer_remove_fd(e->fd);
if(ncct) noit_console_closure_free(ncct);
if(ac) acceptor_closure_free(ac);
e->opset->close(e->fd, &newmask, e);
return 0;
}
if(len > 0) {
keep_going++;
sbuf[len] = '\0';
if(ncct->telnet) {
noit_console_telnet_telrcv(ncct, sbuf, len);
ptyflush(ncct);
}
else {
int written;
written = write(ncct->pty_slave, sbuf, len);
if(written <= 0) goto socket_error;
assert(written == len);
}
}
if(buffer) {
char *cmd_buffer;
cmd_buffer = malloc(plen+1);
memcpy(cmd_buffer, buffer, plen);
/* chomp */
cmd_buffer[plen] = '\0';
if(cmd_buffer[plen-1] == '\n') cmd_buffer[plen-1] = '\0';
noitL(noit_debug, "IN[%d]: '%s'\n", plen, cmd_buffer);
noit_console_dispatch(e, cmd_buffer, ncct);
free(cmd_buffer);
}
if(noit_console_continue_sending(ncct, &newmask) == -1) {
if(ncct->wants_shutdown || errno != EAGAIN) goto socket_error;
return newmask | EVENTER_EXCEPTION;
}
if(ncct->wants_shutdown) goto socket_error;
}
return newmask | EVENTER_EXCEPTION;
}
int
noit_jlog_handler(eventer_t e, int mask, void *closure,
struct timeval *now) {
eventer_t newe;
pthread_t tid;
pthread_attr_t tattr;
int newmask = EVENTER_READ | EVENTER_EXCEPTION;
acceptor_closure_t *ac = closure;
noit_jlog_closure_t *jcl = ac->service_ctx;
char errbuff[256];
const char *errstr = "unknown error";
if(mask & EVENTER_EXCEPTION || (jcl && jcl->wants_shutdown)) {
int len, nlen;
socket_error:
/* Exceptions cause us to simply snip the connection */
len = strlen(errstr);
nlen = htonl(0 - len);
e->opset->write(e->fd, &nlen, sizeof(nlen), &newmask, e);
e->opset->write(e->fd, errstr, strlen(errstr), &newmask, e);
eventer_remove_fd(e->fd);
e->opset->close(e->fd, &newmask, e);
if(jcl) noit_jlog_closure_free(jcl);
acceptor_closure_free(ac);
return 0;
}
if(!ac->service_ctx) {
noit_log_stream_t ls;
const char *logname, *type;
int first_attempt = 1;
char path[PATH_MAX], subscriber[256], *sub;
jcl = ac->service_ctx = noit_jlog_closure_alloc();
if(!noit_hash_retr_str(ac->config,
"log_transit_feed_name",
strlen("log_transit_feed_name"),
&logname)) {
errstr = "No 'log_transit_feed_name' specified in log_transit.";
noitL(noit_error, "%s\n", errstr);
goto socket_error;
}
ls = noit_log_stream_find(logname);
if(!ls) {
snprintf(errbuff, sizeof(errbuff),
"Could not find log '%s' for log_transit.", logname);
errstr = errbuff;
noitL(noit_error, "%s\n", errstr);
goto socket_error;
}
type = noit_log_stream_get_type(ls);
if(!type || strcmp(type, "jlog")) {
snprintf(errbuff, sizeof(errbuff),
"Log '%s' for log_transit is not a jlog.", logname);
errstr = errbuff;
noitL(noit_error, "%s\n", errstr);
goto socket_error;
}
if(ac->cmd == NOIT_JLOG_DATA_FEED) {
if(!ac->remote_cn) {
errstr = "jlog transit started to unidentified party.";
noitL(noit_error, "%s\n", errstr);
goto socket_error;
}
strlcpy(subscriber, ac->remote_cn, sizeof(subscriber));
jcl->feed_stats = noit_jlog_feed_stats(subscriber);
}
else {
jcl->feed_stats = noit_jlog_feed_stats("~");
snprintf(subscriber, sizeof(subscriber),
"~%07d", noit_atomic_inc32(&tmpfeedcounter));
}
jcl->subscriber = strdup(subscriber);
strlcpy(path, noit_log_stream_get_path(ls), sizeof(path));
sub = strchr(path, '(');
if(sub) {
char *esub = strchr(sub, ')');
if(esub) {
*esub = '\0';
*sub++ = '\0';
}
}
jcl->jlog = jlog_new(path);
if(ac->cmd == NOIT_JLOG_DATA_TEMP_FEED) {
add_sub:
if(jlog_ctx_add_subscriber(jcl->jlog, jcl->subscriber, JLOG_END) == -1) {
snprintf(errbuff, sizeof(errbuff),
"jlog reader[%s] error: %s", jcl->subscriber,
jlog_ctx_err_string(jcl->jlog));
errstr = errbuff;
noitL(noit_error, "%s\n", errstr);
}
}
if(jlog_ctx_open_reader(jcl->jlog, jcl->subscriber) == -1) {
if(sub && !strcmp(sub, "*")) {
if(first_attempt) {
jlog_ctx_close(jcl->jlog);
jcl->jlog = jlog_new(path);
first_attempt = 0;
goto add_sub;
}
}
snprintf(errbuff, sizeof(errbuff),
"jlog reader[%s] error: %s", jcl->subscriber,
jlog_ctx_err_string(jcl->jlog));
errstr = errbuff;
noitL(noit_error, "%s\n", errstr);
goto socket_error;
}
}
/* The jlog stuff is disk I/O and can block us.
* We'll create a new thread to just handle this connection.
*/
eventer_remove_fd(e->fd);
newe = eventer_alloc();
memcpy(newe, e, sizeof(*e));
pthread_attr_init(&tattr);
pthread_attr_setdetachstate(&tattr, PTHREAD_CREATE_DETACHED);
gettimeofday(&jcl->feed_stats->last_connection, NULL);
noit_atomic_inc32(&jcl->feed_stats->connections);
if(pthread_create(&tid, &tattr, noit_jlog_thread_main, newe) == 0) {
return 0;
}
/* Undo our dup */
eventer_free(newe);
/* Creating the thread failed, close it down and deschedule. */
e->opset->close(e->fd, &newmask, e);
return 0;
}
void *
noit_jlog_thread_main(void *e_vptr) {
int mask, bytes_read;
eventer_t e = e_vptr;
acceptor_closure_t *ac = e->closure;
noit_jlog_closure_t *jcl = ac->service_ctx;
char inbuff[sizeof(jlog_id)];
eventer_set_fd_blocking(e->fd);
while(1) {
jlog_id client_chkpt;
int sleeptime = (ac->cmd == NOIT_JLOG_DATA_TEMP_FEED) ?
1 : DEFAULT_SECONDS_BETWEEN_BATCHES;
jlog_get_checkpoint(jcl->jlog, ac->remote_cn, &jcl->chkpt);
jcl->count = jlog_ctx_read_interval(jcl->jlog, &jcl->start, &jcl->finish);
if(jcl->count < 0) {
char idxfile[PATH_MAX];
noitL(noit_error, "jlog_ctx_read_interval: %s\n",
jlog_ctx_err_string(jcl->jlog));
switch (jlog_ctx_err(jcl->jlog)) {
case JLOG_ERR_FILE_CORRUPT:
case JLOG_ERR_IDX_CORRUPT:
jlog_repair_datafile(jcl->jlog, jcl->start.log);
jlog_repair_datafile(jcl->jlog, jcl->start.log + 1);
noitL(noit_error,
"jlog reconstructed, deleting corresponding index.\n");
STRSETDATAFILE(jcl->jlog, idxfile, jcl->start.log);
strlcat(idxfile, INDEX_EXT, sizeof(idxfile));
unlink(idxfile);
STRSETDATAFILE(jcl->jlog, idxfile, jcl->start.log + 1);
strlcat(idxfile, INDEX_EXT, sizeof(idxfile));
unlink(idxfile);
goto alldone;
break;
default:
goto alldone;
}
}
if(jcl->count > MAX_ROWS_AT_ONCE) {
/* Artificially set down the range to make the batches a bit easier
* to handle on the stratcond/postgres end.
* However, we must have more data, so drop the sleeptime to 0
*/
jcl->count = MAX_ROWS_AT_ONCE;
jcl->finish.marker = jcl->start.marker + jcl->count;
sleeptime = 0;
}
if(jcl->count > 0) {
if(noit_jlog_push(e, jcl)) {
goto alldone;
}
/* Read our jlog_id accounting for possibly short reads */
bytes_read = 0;
while(bytes_read < sizeof(jlog_id)) {
int len;
if((len = e->opset->read(e->fd, inbuff + bytes_read,
sizeof(jlog_id) - bytes_read,
&mask, e)) <= 0)
goto alldone;
bytes_read += len;
}
memcpy(&client_chkpt, inbuff, sizeof(jlog_id));
/* Fix the endian */
client_chkpt.log = ntohl(client_chkpt.log);
client_chkpt.marker = ntohl(client_chkpt.marker);
if(memcmp(&jcl->chkpt, &client_chkpt, sizeof(jlog_id))) {
noitL(noit_error,
"client %s submitted invalid checkpoint %u:%u expected %u:%u\n",
ac->remote_cn, client_chkpt.log, client_chkpt.marker,
jcl->chkpt.log, jcl->chkpt.marker);
goto alldone;
}
gettimeofday(&jcl->feed_stats->last_checkpoint, NULL);
jlog_ctx_read_checkpoint(jcl->jlog, &jcl->chkpt);
}
else {
/* we have nothing to write -- maybe we have no checks configured...
* If this is the case "forever", the remote might disconnect and
* we would never know. Do the painful work of detecting a
* disconnected client.
*/
struct pollfd pfd;
pfd.fd = e->fd;
pfd.events = POLLIN | POLLHUP | POLLRDNORM;
pfd.revents = 0;
if(poll(&pfd, 1, 0) != 0) {
/* normally, we'd recv PEEK|DONTWAIT. However, the client should
* not be writing to us. So, we know we can't have any legitimate
* data on this socket (true even though this is SSL). So, if we're
* here then "shit went wrong"
*/
noitL(noit_error, "jlog client %s disconnected while idle\n",
ac->remote_cn);
goto alldone;
}
}
if(sleeptime) sleep(sleeptime);
}
alldone:
e->opset->close(e->fd, &mask, e);
noit_atomic_dec32(&jcl->feed_stats->connections);
noit_jlog_closure_free(jcl);
acceptor_closure_free(ac);
return NULL;
}
int
noit_capabilities_handler(eventer_t e, int mask, void *closure,
struct timeval *now) {
int newmask = EVENTER_WRITE | EVENTER_EXCEPTION;
acceptor_closure_t *ac = closure;
noit_capsvc_closure_t *cl = ac->service_ctx;
if(mask & EVENTER_EXCEPTION) {
socket_error:
/* Exceptions cause us to simply snip the connection */
cleanup_shutdown:
eventer_remove_fd(e->fd);
e->opset->close(e->fd, &newmask, e);
if(cl) {
if(cl->buff) free(cl->buff);
free(cl);
}
if(ac) acceptor_closure_free(ac);
return 0;
}
if(!ac->service_ctx) {
char vbuff[128];
noit_hash_table *lc;
noit_hash_iter iter = NOIT_HASH_ITER_ZERO;
const char *k;
int klen;
void *data;
xmlDocPtr xmldoc;
xmlNodePtr root, cmds;
cl = ac->service_ctx = calloc(1, sizeof(*cl));
/* fill out capabilities */
noit_build_version(vbuff, sizeof(vbuff));
/* Create an XML Document */
xmldoc = xmlNewDoc((xmlChar *)"1.0");
root = xmlNewDocNode(xmldoc, NULL, (xmlChar *)"noit_capabilities", NULL);
xmlDocSetRootElement(xmldoc, root);
/* Fill in the document */
xmlNewTextChild(root, NULL, (xmlChar *)"version", (xmlChar *)vbuff);
cmds = xmlNewNode(NULL, (xmlChar *)"services");
xmlAddChild(root, cmds);
lc = noit_listener_commands();
while(noit_hash_next(lc, &iter, &k, &klen, &data)) {
xmlNodePtr cnode;
char hexcode[11];
const char *name;
eventer_func_t *f = (eventer_func_t *)k;
noit_hash_table *sc = (noit_hash_table *)data;
noit_hash_iter sc_iter = NOIT_HASH_ITER_ZERO;
const char *sc_k;
int sc_klen;
void *sc_data;
name = eventer_name_for_callback(*f);
cnode = xmlNewNode(NULL, (xmlChar *)"service");
xmlSetProp(cnode, (xmlChar *)"name", name ? (xmlChar *)name : NULL);
if(*f == ac->dispatch)
xmlSetProp(cnode, (xmlChar *)"connected", (xmlChar *)"true");
xmlAddChild(cmds, cnode);
while(noit_hash_next(sc, &sc_iter, &sc_k, &sc_klen, &sc_data)) {
xmlNodePtr scnode;
char *name_copy, *version = NULL;
eventer_func_t *f = (eventer_func_t *)sc_data;
snprintf(hexcode, sizeof(hexcode), "0x%08x", *((u_int32_t *)sc_k));
name = eventer_name_for_callback(*f);
name_copy = strdup(name ? name : "[[unknown]]");
version = strchr(name_copy, '/');
if(version) *version++ = '\0';
scnode = xmlNewNode(NULL, (xmlChar *)"command");
xmlSetProp(scnode, (xmlChar *)"name", (xmlChar *)name_copy);
if(version)
xmlSetProp(scnode, (xmlChar *)"version", (xmlChar *)version);
xmlSetProp(scnode, (xmlChar *)"code", (xmlChar *)hexcode);
xmlAddChild(cnode, scnode);
free(name_copy);
}
}
/* Write it out to a buffer and copy it for writing */
cl->buff = noit_xmlSaveToBuffer(xmldoc);
cl->towrite = strlen(cl->buff);
/* Clean up after ourselves */
xmlFreeDoc(xmldoc);
}
while(cl->towrite > cl->written) {
int len;
while((len = e->opset->write(e->fd, cl->buff + cl->written,
cl->towrite - cl->written,
&newmask, e)) == -1 && errno == EINTR);
if(len < 0) {
if(errno == EAGAIN) return newmask | EVENTER_EXCEPTION;
goto socket_error;
}
cl->written += len;
}
goto cleanup_shutdown;
}
int
noit_livestream_handler(eventer_t e, int mask, void *closure,
struct timeval *now) {
eventer_t newe;
pthread_t tid;
int newmask = EVENTER_READ | EVENTER_EXCEPTION;
acceptor_closure_t *ac = closure;
noit_livestream_closure_t *jcl = ac->service_ctx;
if(mask & EVENTER_EXCEPTION || (jcl && jcl->wants_shutdown)) {
socket_error:
/* Exceptions cause us to simply snip the connection */
eventer_remove_fd(e->fd);
e->opset->close(e->fd, &newmask, e);
if(jcl) noit_livestream_closure_free(jcl);
if(ac) acceptor_closure_free(ac);
return 0;
}
if(!ac->service_ctx || !jcl->feed) {
int len;
jcl = ac->service_ctx = noit_livestream_closure_alloc();
/* Setup logger to this channel */
if(!jcl->period) {
u_int32_t nperiod;
len = e->opset->read(e->fd, &nperiod, sizeof(nperiod), &mask, e);
if(len == -1 && errno == EAGAIN) return mask | EVENTER_EXCEPTION;
if(len != sizeof(nperiod)) goto socket_error;
jcl->period = ntohl(nperiod);
if(!jcl->period) {
noitL(noit_error, "period of 0 specified in livestream. not allowed.\n");
goto socket_error;
}
}
while(jcl->uuid_read < 36) {
len = e->opset->read(e->fd, jcl->uuid_str + jcl->uuid_read, 36 - jcl->uuid_read, &mask, e);
if(len == -1 && errno == EAGAIN) return mask | EVENTER_EXCEPTION;
if(len == 0) goto socket_error;
jcl->uuid_read += len;
}
jcl->uuid_str[36] = '\0';
if(uuid_parse(jcl->uuid_str, jcl->uuid)) {
noitL(noit_error, "bad uuid received in livestream handler '%s'\n", jcl->uuid_str);
goto socket_error;
}
jcl->feed = malloc(32);
snprintf(jcl->feed, 32, "livestream/%d", noit_atomic_inc32(&ls_counter));
noit_log_stream_new(jcl->feed, "noit_livestream", jcl->feed,
jcl, NULL);
jcl->check = noit_check_watch(jcl->uuid, jcl->period);
if(!jcl->check) {
e->opset->close(e->fd, &newmask, e);
return 0;
}
/* This check must be watched from the livestream */
noit_check_transient_add_feed(jcl->check, jcl->feed);
/* Note the check */
noit_check_log_check(jcl->check);
/* kick it off, if it isn't running already */
if(!NOIT_CHECK_LIVE(jcl->check)) noit_check_activate(jcl->check);
}
eventer_remove_fd(e->fd);
newe = eventer_alloc();
memcpy(newe, e, sizeof(*e));
if(pthread_create(&tid, NULL, noit_livestream_thread_main, newe) == 0) {
return 0;
}
noit_check_transient_remove_feed(jcl->check, jcl->feed);
noit_livestream_closure_free(jcl);
/* Undo our dup */
eventer_free(newe);
/* Creating the thread failed, close it down and deschedule. */
e->opset->close(e->fd, &newmask, e);
return 0;
}
static int
noit_listener_acceptor(eventer_t e, int mask,
void *closure, struct timeval *tv) {
int conn, newmask = EVENTER_READ;
socklen_t salen;
listener_closure_t listener_closure = (listener_closure_t)closure;
acceptor_closure_t *ac = NULL;
if(mask & EVENTER_EXCEPTION) {
socketfail:
if(ac) acceptor_closure_free(ac);
/* We don't shut down the socket, it's out listener! */
return EVENTER_READ | EVENTER_WRITE | EVENTER_EXCEPTION;
}
do {
ac = malloc(sizeof(*ac));
memcpy(ac, listener_closure->dispatch_closure, sizeof(*ac));
salen = sizeof(ac->remote);
conn = e->opset->accept(e->fd, &ac->remote.remote_addr, &salen, &newmask, e);
if(conn >= 0) {
eventer_t newe;
noitL(nldeb, "noit_listener[%s] accepted fd %d\n",
eventer_name_for_callback(listener_closure->dispatch_callback),
conn);
if(eventer_set_fd_nonblocking(conn)) {
close(conn);
free(ac);
goto accept_bail;
}
newe = eventer_alloc();
newe->fd = conn;
newe->mask = EVENTER_READ | EVENTER_WRITE | EVENTER_EXCEPTION;
if(listener_closure->sslconfig->size) {
const char *layer, *cert, *key, *ca, *ciphers, *crl;
eventer_ssl_ctx_t *ctx;
/* We have an SSL configuration. While our socket accept is
* complete, we now have to SSL_accept, which could require
* several reads and writes and needs its own event callback.
*/
#define SSLCONFGET(var,name) do { \
if(!noit_hash_retr_str(listener_closure->sslconfig, name, strlen(name), \
&var)) var = NULL; } while(0)
SSLCONFGET(layer, "layer");
SSLCONFGET(cert, "certificate_file");
SSLCONFGET(key, "key_file");
SSLCONFGET(ca, "ca_chain");
SSLCONFGET(ciphers, "ciphers");
ctx = eventer_ssl_ctx_new(SSL_SERVER, layer, cert, key, ca, ciphers);
if(!ctx) {
newe->opset->close(newe->fd, &newmask, e);
eventer_free(newe);
goto socketfail;
}
SSLCONFGET(crl, "crl");
if(crl) {
if(!eventer_ssl_use_crl(ctx, crl)) {
noitL(noit_error, "Failed to load CRL from %s\n", crl);
eventer_ssl_ctx_free(ctx);
newe->opset->close(newe->fd, &newmask, e);
eventer_free(newe);
goto socketfail;
}
}
eventer_ssl_ctx_set_verify(ctx, eventer_ssl_verify_cert,
listener_closure->sslconfig);
EVENTER_ATTACH_SSL(newe, ctx);
newe->callback = noit_listener_accept_ssl;
newe->closure = malloc(sizeof(*listener_closure));
memcpy(newe->closure, listener_closure, sizeof(*listener_closure));
((listener_closure_t)newe->closure)->dispatch_closure = ac;
}
else {
newe->callback = listener_closure->dispatch_callback;
/* We must make a copy of the acceptor_closure_t for each new
* connection.
*/
newe->closure = ac;
}
eventer_add(newe);
}
else {
if(errno == EAGAIN) {
if(ac) acceptor_closure_free(ac);
}
else if(errno != EINTR) {
noitL(noit_error, "accept socket error: %s\n", strerror(errno));
goto socketfail;
}
}
} while(conn >= 0);
accept_bail:
return newmask | EVENTER_EXCEPTION;
}
