[ashd.git] / src / htparser.c

/*
    ashd - A Sane HTTP Daemon
    Copyright (C) 2008  Fredrik Tolf <fredrik@dolda2000.com>

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

#include <stdlib.h>
#include <unistd.h>
#include <stdio.h>
#include <string.h>
#include <sys/select.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <errno.h>
#include <time.h>

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include <utils.h>
#include <mt.h>
#include <log.h>
#include <req.h>
#include <proc.h>

#define EV_READ 1
#define EV_WRITE 2

struct blocker {
    struct blocker *n, *p;
    int fd;
    int ev;
    time_t to;
    struct muth *th;
};

static struct blocker *blockers;
int plex;

static int block(int fd, int ev, time_t to)
{
    struct blocker *bl;
    int rv;
    
    omalloc(bl);
    bl->fd = fd;
    bl->ev = ev;
    if(to > 0)
	bl->to = time(NULL) + to;
    bl->th = current;
    bl->n = blockers;
    if(blockers)
	blockers->p = bl;
    blockers = bl;
    rv = yield();
    if(bl->n)
	bl->n->p = bl->p;
    if(bl->p)
	bl->p->n = bl->n;
    if(bl == blockers)
	blockers = bl->n;
    return(rv);
}

static int listensock4(int port)
{
    struct sockaddr_in name;
    int fd;
    int valbuf;
    
    memset(&name, 0, sizeof(name));
    name.sin_family = AF_INET;
    name.sin_port = htons(port);
    if((fd = socket(PF_INET, SOCK_STREAM, 0)) < 0)
	return(-1);
    valbuf = 1;
    setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &valbuf, sizeof(valbuf));
    if(bind(fd, (struct sockaddr *)&name, sizeof(name))) {
	close(fd);
	return(-1);
    }
    if(listen(fd, 16) < 0) {
	close(fd);
	return(-1);
    }
    return(fd);
}

static int listensock6(int port)
{
    struct sockaddr_in6 name;
    int fd;
    int valbuf;
    
    memset(&name, 0, sizeof(name));
    name.sin6_family = AF_INET6;
    name.sin6_port = htons(port);
    if((fd = socket(PF_INET6, SOCK_STREAM, 0)) < 0)
	return(-1);
    valbuf = 1;
    setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &valbuf, sizeof(valbuf));
    if(bind(fd, (struct sockaddr *)&name, sizeof(name))) {
	close(fd);
	return(-1);
    }
    if(listen(fd, 16) < 0) {
	close(fd);
	return(-1);
    }
    return(fd);
}

static size_t readhead(int fd, struct charbuf *buf)
{
    int nl;
    size_t off;
    
    int get1(void)
    {
	int ret;
	
	while(!(off < buf->d)) {
	    sizebuf(*buf, buf->d + 1024);
	    ret = recv(fd, buf->b + buf->d, buf->s - buf->d, MSG_DONTWAIT);
	    if(ret <= 0) {
		if((ret < 0) && (errno == EAGAIN)) {
		    if(block(fd, EV_READ, 60) <= 0)
			return(-1);
		    continue;
		}
		return(-1);
	    }
	    buf->d += ret;
	}
	return(buf->b[off++]);
    }

    nl = 0;
    off = 0;
    while(1) {
	switch(get1()) {
	case '\n':
	    if(nl)
		return(off);
	    nl = 1;
	    break;
	case '\r':
	    break;
	case -1:
	    return(-1);
	default:
	    nl = 0;
	    break;
	}
    }
}

#define SKIPNL(ptr) ({				\
	    int __buf__;			\
	    if(*(ptr) == '\r')			\
		*((ptr)++) = 0;			\
	    if(*(ptr) != '\n') {		\
		__buf__ = 0;			\
	    } else {				\
		*((ptr)++) = 0;			\
		__buf__ = 1;			\
	    }					\
	    __buf__;})
static struct hthead *parserawreq(char *buf)
{
    char *p, *p2, *nl;
    char *method, *url, *ver;
    struct hthead *req;
    
    if((nl = strchr(buf, '\n')) == NULL)
	return(NULL);
    if(((p = strchr(buf, ' ')) == NULL) || (p > nl))
	return(NULL);
    method = buf;
    *(p++) = 0;
    if(((p2 = strchr(p, ' ')) == NULL) || (p2 > nl))
	return(NULL);
    url = p;
    p = p2;
    *(p++) = 0;
    if(strncmp(p, "HTTP/", 5))
	return(NULL);
    ver = (p += 5);
    for(; ((*p >= '0') && (*p <= '9')) || (*p == '.'); p++);
    if(!SKIPNL(p))
	return(NULL);

    req = mkreq(method, url, ver);
    while(1) {
	if(SKIPNL(p)) {
	    if(*p)
		goto fail;
	    break;
	}
	if((nl = strchr(p, '\n')) == NULL)
	    goto fail;
	if(((p2 = strchr(p, ':')) == NULL) || (p2 > nl))
	    goto fail;
	*(p2++) = 0;
	for(; (*p2 == ' ') || (*p2 == '\t'); p2++);
	for(nl = p2; (*nl != '\r') && (*nl != '\n'); nl++);
	if(!SKIPNL(nl))
	    goto fail;
	if(strncasecmp(p, "x-ash-", 6))
	    headappheader(req, p, p2);
	p = nl;
    }
    return(req);
    
fail:
    freehthead(req);
    return(NULL);
}

static struct hthead *parserawresp(char *buf)
{
    char *p, *p2, *nl;
    char *msg, *ver;
    int code;
    struct hthead *resp;
    
    if((nl = strchr(buf, '\n')) == NULL)
	return(NULL);
    p = strchr(buf, '\r');
    if((p != NULL) && (p < nl))
	nl = p;
    if(strncmp(buf, "HTTP/", 5))
	return(NULL);
    ver = p = buf + 5;
    for(; ((*p >= '0') && (*p <= '9')) || (*p == '.'); p++);
    if(*p != ' ')
	return(NULL);
    *(p++) = 0;
    if(((p2 = strchr(p, ' ')) == NULL) || (p2 > nl))
	return(NULL);
    *(p2++) = 0;
    code = atoi(p);
    if((code < 100) || (code >= 600))
	return(NULL);
    if(p2 >= nl)
	return(NULL);
    msg = p2;
    p = nl;
    if(!SKIPNL(p))
	return(NULL);

    resp = mkresp(code, msg, ver);
    while(1) {
	if(SKIPNL(p)) {
	    if(*p)
		goto fail;
	    break;
	}
	if((nl = strchr(p, '\n')) == NULL)
	    goto fail;
	if(((p2 = strchr(p, ':')) == NULL) || (p2 > nl))
	    goto fail;
	*(p2++) = 0;
	for(; (*p2 == ' ') || (*p2 == '\t'); p2++);
	for(nl = p2; (*nl != '\r') && (*nl != '\n'); nl++);
	if(!SKIPNL(nl))
	    goto fail;
	headappheader(resp, p, p2);
	p = nl;
    }
    return(resp);
    
fail:
    freehthead(resp);
    return(NULL);
}

static off_t passdata(int src, int dst, struct charbuf *buf, off_t max)
{
    size_t dataoff, smax;
    off_t sent;
    int eof, ret;

    sent = 0;
    eof = 0;
    while((!eof || (buf->d > 0)) && ((max < 0) || (sent < max))) {
	if(!eof && (buf->d < buf->s) && ((max < 0) || (sent + buf->d < max))) {
	    while(1) {
		ret = recv(src, buf->b + buf->d, buf->s - buf->d, MSG_DONTWAIT);
		if((ret < 0) && (errno == EAGAIN)) {
		} else if(ret < 0) {
		    return(-1);
		} else if(ret == 0) {
		    eof = 1;
		    break;
		} else {
		    buf->d += ret;
		    break;
		}
		if(buf->d > 0)
		    break;
		if(block(src, EV_READ, 0) <= 0)
		    return(-1);
	    }
	}
	for(dataoff = 0; (dataoff < buf->d) && ((max < 0) || (sent < max));) {
	    if(block(dst, EV_WRITE, 120) <= 0)
		return(-1);
	    smax = buf->d - dataoff;
	    if(sent + smax > max)
		smax = max - sent;
	    ret = send(dst, buf->b + dataoff, smax, MSG_NOSIGNAL | MSG_DONTWAIT);
	    if(ret < 0)
		return(-1);
	    dataoff += ret;
	    sent += ret;
	}
	bufeat(*buf, dataoff);
    }
    return(sent);
}

static void serve(struct muth *muth, va_list args)
{
    vavar(int, fd);
    vavar(struct sockaddr_storage, name);
    int cfd;
    char old;
    char *hd;
    struct charbuf inbuf, outbuf;
    struct hthead *req, *resp;
    off_t dlen, sent;
    ssize_t headoff;
    char nmbuf[256];
    
    bufinit(inbuf);
    bufinit(outbuf);
    cfd = -1;
    req = NULL;
    while(1) {
	/*
	 * First, find and decode the header:
	 */
	if((headoff = readhead(fd, &inbuf)) < 0)
	    goto out;
	if(headoff > 65536) {
	    /* We cannot handle arbitrarily large headers, as they
	     * need to fit within a single Unix datagram. This is
	     * probably a safe limit, and larger packets than this are
	     * most likely erroneous (or malicious) anyway. */
	    goto out;
	}
	old = inbuf.b[headoff];
	inbuf.b[headoff] = 0;
	if((req = parserawreq(inbuf.b)) == NULL)
	    goto out;
	inbuf.b[headoff] = old;
	bufeat(inbuf, headoff);
	/* We strip off the leading slash from the rest string, so
	 * that multiplexers can parse coherently. */
	if(req->rest[0] == '/')
	    replrest(req, req->rest + 1);
	
	/*
	 * Add metainformation and then send the request to the root
	 * multiplexer:
	 */
	if(name.ss_family == AF_INET) {
	    headappheader(req, "X-Ash-Address", inet_ntop(AF_INET, &((struct sockaddr_in *)&name)->sin_addr, nmbuf, sizeof(nmbuf)));
	    headappheader(req, "X-Ash-Port", sprintf3("%i", ntohs(((struct sockaddr_in *)&name)->sin_port)));
	} else if(name.ss_family == AF_INET6) {
	    headappheader(req, "X-Ash-Address", inet_ntop(AF_INET6, &((struct sockaddr_in6 *)&name)->sin6_addr, nmbuf, sizeof(nmbuf)));
	    headappheader(req, "X-Ash-Port", sprintf3("%i", ntohs(((struct sockaddr_in6 *)&name)->sin6_port)));
	}
	cfd = sendreq(plex, req);

	/*
	 * If there is message data, pass it:
	 */
	if((hd = getheader(req, "content-length")) != NULL) {
	    dlen = atoo(hd);
	    if(dlen > 0)
		passdata(fd, cfd, &inbuf, dlen);
	}
	/* Make sure to send EOF */
	shutdown(cfd, SHUT_WR);
	
	/*
	 * Find and decode the response header:
	 */
	outbuf.d = 0;
	headoff = readhead(cfd, &outbuf);
	hd = memcpy(smalloc(headoff + 1), outbuf.b, headoff);
	hd[headoff] = 0;
	if((resp = parserawresp(hd)) == NULL)
	    goto out;
	
	/*
	 * Pass the actual output:
	 */
	sizebuf(outbuf, 65536);
	sent = passdata(cfd, fd, &outbuf, -1);
	sent -= headoff;
	
	/*
	 * Check for connection expiry
	 */
	if(strcasecmp(req->method, "head")) {
	    if((hd = getheader(resp, "content-length")) != NULL) {
		if(sent != atoo(hd)) {
		    /* Exit because of error */
		    goto out;
		}
	    } else {
		if(((hd = getheader(resp, "transfer-encoding")) == NULL) || !strcasecmp(hd, "identity"))
		    break;
	    }
	    if(((hd = getheader(req, "connection")) != NULL) && !strcasecmp(hd, "close"))
		break;
	    if(((hd = getheader(resp, "connection")) != NULL) && !strcasecmp(hd, "close"))
		break;
	}
	
	close(cfd);
	cfd = -1;
	freehthead(req);
	req = NULL;
	freehthead(resp);
	resp = NULL;
    }
    
out:
    if(cfd >= 0)
	close(cfd);
    if(req != NULL)
	freehthead(req);
    if(resp != NULL)
	freehthead(resp);
    buffree(inbuf);
    buffree(outbuf);
    close(fd);
}

static void listenloop(struct muth *muth, va_list args)
{
    vavar(int, ss);
    int ns;
    struct sockaddr_storage name;
    socklen_t namelen;
    
    while(1) {
	namelen = sizeof(name);
	block(ss, EV_READ, 0);
	ns = accept(ss, (struct sockaddr *)&name, &namelen);
	if(ns < 0) {
	    flog(LOG_ERR, "accept: %s", strerror(errno));
	    goto out;
	}
	mustart(serve, ns, name);
    }
    
out:
    close(ss);
}

static void ioloop(void)
{
    int ret;
    fd_set rfds, wfds, efds;
    struct blocker *bl, *nbl;
    struct timeval toval;
    time_t now, timeout;
    int maxfd;
    int ev;
    
    while(blockers != NULL) {
	FD_ZERO(&rfds);
	FD_ZERO(&wfds);
	FD_ZERO(&efds);
	maxfd = 0;
	now = time(NULL);
	timeout = 0;
	for(bl = blockers; bl; bl = bl->n) {
	    if(bl->ev & EV_READ)
		FD_SET(bl->fd, &rfds);
	    if(bl->ev & EV_WRITE)
		FD_SET(bl->fd, &wfds);
	    FD_SET(bl->fd, &efds);
	    if(bl->fd > maxfd)
		maxfd = bl->fd;
	    if((bl->to != 0) && ((timeout == 0) || (timeout > bl->to)))
		timeout = bl->to;
	}
	toval.tv_sec = timeout - now;
	toval.tv_usec = 0;
	ret = select(maxfd + 1, &rfds, &wfds, &efds, timeout?(&toval):NULL);
	if(ret < 0) {
	    if(errno != EINTR) {
		flog(LOG_CRIT, "ioloop: select errored out: %s", strerror(errno));
		/* To avoid CPU hogging in case it's bad, which it
		 * probably is. */
		sleep(1);
	    }
	}
	now = time(NULL);
	for(bl = blockers; bl; bl = nbl) {
	    nbl = bl->n;
	    ev = 0;
	    if(FD_ISSET(bl->fd, &rfds))
		ev |= EV_READ;
	    if(FD_ISSET(bl->fd, &wfds))
		ev |= EV_WRITE;
	    if(FD_ISSET(bl->fd, &efds))
		ev = -1;
	    if(ev != 0)
		resume(bl->th, ev);
	    else if((bl->to != 0) && (bl->to <= now))
		resume(bl->th, 0);
	}
    }
}

int main(int argc, char **argv)
{
    int fd;
    
    if(argc < 2) {
	fprintf(stderr, "usage: htparser ROOT [ARGS...]\n");
	exit(1);
    }
    if((plex = stdmkchild(argv + 1)) < 0) {
	flog(LOG_ERR, "could not spawn root multiplexer: %s", strerror(errno));
	return(1);
    }
    if((fd = listensock6(8080)) < 0) {
	flog(LOG_ERR, "could not listen on IPv6: %s", strerror(errno));
	return(1);
    }
    mustart(listenloop, fd);
    if((fd = listensock4(8080)) < 0) {
	if(errno != EADDRINUSE) {
	    flog(LOG_ERR, "could not listen on IPv4: %s", strerror(errno));
	    return(1);
	}
    } else {
	mustart(listenloop, fd);
    }
    ioloop();
    return(0);
}
Commit	Line	Data
f0bbedf7 FT	1	/*
	2	ashd - A Sane HTTP Daemon
	3	Copyright (C) 2008 Fredrik Tolf <fredrik@dolda2000.com>
	4
	5	This program is free software: you can redistribute it and/or modify
	6	it under the terms of the GNU General Public License as published by
	7	the Free Software Foundation, either version 3 of the License, or
	8	(at your option) any later version.
	9
	10	This program is distributed in the hope that it will be useful,
	11	but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	13	GNU General Public License for more details.
	14
	15	You should have received a copy of the GNU General Public License
	16	along with this program. If not, see <http://www.gnu.org/licenses/>.
	17	*/
	18
	19	#include <stdlib.h>
	20	#include <unistd.h>
	21	#include <stdio.h>
f4cdf919 FT	22	#include <string.h>
	23	#include <sys/select.h>
	24	#include <sys/socket.h>
	25	#include <netinet/in.h>
9d87a119	26	#include <arpa/inet.h>
f4cdf919	27	#include <errno.h>
9d87a119	28	#include <time.h>
f0bbedf7 FT	29
	30	#ifdef HAVE_CONFIG_H
	31	#include <config.h>
	32	#endif
	33	#include <utils.h>
f4cdf919 FT	34	#include <mt.h>
f4cdf919 FT	35	#include <log.h>
66987955	36	#include <req.h>
9d87a119	37	#include <proc.h>
f4cdf919 FT	38
	39	#define EV_READ 1
	40	#define EV_WRITE 2
	41
	42	struct blocker {
	43	struct blocker n, p;
	44	int fd;
	45	int ev;
9d87a119	46	time_t to;
f4cdf919 FT	47	struct muth *th;
	48	};
	49
	50	static struct blocker *blockers;
9d87a119	51	int plex;
f4cdf919	52
9d87a119	53	static int block(int fd, int ev, time_t to)
f4cdf919 FT	54	{
	55	struct blocker *bl;
	56	int rv;
	57
	58	omalloc(bl);
	59	bl->fd = fd;
	60	bl->ev = ev;
9d87a119 FT	61	if(to > 0)
9d87a119 FT	62	bl->to = time(NULL) + to;
f4cdf919 FT	63	bl->th = current;
	64	bl->n = blockers;
	65	if(blockers)
	66	blockers->p = bl;
	67	blockers = bl;
	68	rv = yield();
	69	if(bl->n)
	70	bl->n->p = bl->p;
	71	if(bl->p)
	72	bl->p->n = bl->n;
	73	if(bl == blockers)
	74	blockers = bl->n;
	75	return(rv);
	76	}
	77
	78	static int listensock4(int port)
	79	{
	80	struct sockaddr_in name;
	81	int fd;
	82	int valbuf;
	83
	84	memset(&name, 0, sizeof(name));
	85	name.sin_family = AF_INET;
	86	name.sin_port = htons(port);
	87	if((fd = socket(PF_INET, SOCK_STREAM, 0)) < 0)
	88	return(-1);
	89	valbuf = 1;
	90	setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &valbuf, sizeof(valbuf));
	91	if(bind(fd, (struct sockaddr *)&name, sizeof(name))) {
	92	close(fd);
	93	return(-1);
	94	}
	95	if(listen(fd, 16) < 0) {
	96	close(fd);
	97	return(-1);
	98	}
	99	return(fd);
	100	}
	101
	102	static int listensock6(int port)
	103	{
	104	struct sockaddr_in6 name;
	105	int fd;
	106	int valbuf;
	107
	108	memset(&name, 0, sizeof(name));
	109	name.sin6_family = AF_INET6;
	110	name.sin6_port = htons(port);
	111	if((fd = socket(PF_INET6, SOCK_STREAM, 0)) < 0)
	112	return(-1);
	113	valbuf = 1;
	114	setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &valbuf, sizeof(valbuf));
	115	if(bind(fd, (struct sockaddr *)&name, sizeof(name))) {
	116	close(fd);
	117	return(-1);
	118	}
	119	if(listen(fd, 16) < 0) {
	120	close(fd);
	121	return(-1);
	122	}
	123	return(fd);
	124	}
	125
c9955b14	126	static size_t readhead(int fd, struct charbuf *buf)
66987955	127	{
66987955	128	int nl;
c9955b14	129	size_t off;
66987955	130
c9955b14 FT	131	int get1(void)
	132	{
	133	int ret;
	134
	135	while(!(off < buf->d)) {
	136	sizebuf(*buf, buf->d + 1024);
	137	ret = recv(fd, buf->b + buf->d, buf->s - buf->d, MSG_DONTWAIT);
	138	if(ret <= 0) {
	139	if((ret < 0) && (errno == EAGAIN)) {
9d87a119 FT	140	if(block(fd, EV_READ, 60) <= 0)
9d87a119 FT	141	return(-1);
c9955b14 FT	142	continue;
	143	}
	144	return(-1);
66987955	145	}
c9955b14	146	buf->d += ret;
66987955	147	}
c9955b14 FT	148	return(buf->b[off++]);
	149	}
	150
	151	nl = 0;
	152	off = 0;
	153	while(1) {
	154	switch(get1()) {
	155	case '\n':
66987955	156	if(nl)
c9955b14	157	return(off);
66987955	158	nl = 1;
c9955b14 FT	159	break;
	160	case '\r':
	161	break;
	162	case -1:
	163	return(-1);
	164	default:
66987955	165	nl = 0;
c9955b14	166	break;
66987955 FT	167	}
66987955 FT	168	}
66987955 FT	169	}
	170
	171	#define SKIPNL(ptr) ({ \
	172	int __buf__; \
	173	if(*(ptr) == '\r') \
	174	*((ptr)++) = 0; \
	175	if(*(ptr) != '\n') { \
	176	__buf__ = 0; \
	177	} else { \
	178	*((ptr)++) = 0; \
	179	__buf__ = 1; \
	180	} \
	181	__buf__;})
9d87a119	182	static struct hthead parserawreq(char buf)
66987955 FT	183	{
	184	char p, p2, *nl;
	185	char method, url, *ver;
9d87a119	186	struct hthead *req;
66987955 FT	187
	188	if((nl = strchr(buf, '\n')) == NULL)
	189	return(NULL);
	190	if(((p = strchr(buf, ' ')) == NULL) \|\| (p > nl))
	191	return(NULL);
	192	method = buf;
	193	*(p++) = 0;
	194	if(((p2 = strchr(p, ' ')) == NULL) \|\| (p2 > nl))
	195	return(NULL);
	196	url = p;
	197	p = p2;
	198	*(p++) = 0;
	199	if(strncmp(p, "HTTP/", 5))
	200	return(NULL);
	201	ver = (p += 5);
	202	for(; ((p >= '0') && (p <= '9')) \|\| (*p == '.'); p++);
	203	if(!SKIPNL(p))
	204	return(NULL);
	205
	206	req = mkreq(method, url, ver);
	207	while(1) {
	208	if(SKIPNL(p)) {
	209	if(*p)
c9955b14	210	goto fail;
66987955 FT	211	break;
	212	}
	213	if((nl = strchr(p, '\n')) == NULL)
c9955b14	214	goto fail;
66987955	215	if(((p2 = strchr(p, ':')) == NULL) \|\| (p2 > nl))
c9955b14	216	goto fail;
66987955 FT	217	*(p2++) = 0;
	218	for(; (p2 == ' ') \|\| (p2 == '\t'); p2++);
	219	for(nl = p2; (nl != '\r') && (nl != '\n'); nl++);
	220	if(!SKIPNL(nl))
c9955b14	221	goto fail;
9d87a119 FT	222	if(strncasecmp(p, "x-ash-", 6))
9d87a119 FT	223	headappheader(req, p, p2);
66987955 FT	224	p = nl;
	225	}
	226	return(req);
c9955b14 FT	227
c9955b14 FT	228	fail:
9d87a119	229	freehthead(req);
c9955b14	230	return(NULL);
66987955 FT	231	}
66987955 FT	232
9d87a119 FT	233	static struct hthead parserawresp(char buf)
	234	{
	235	char p, p2, *nl;
	236	char msg, ver;
	237	int code;
	238	struct hthead *resp;
	239
	240	if((nl = strchr(buf, '\n')) == NULL)
	241	return(NULL);
	242	p = strchr(buf, '\r');
	243	if((p != NULL) && (p < nl))
	244	nl = p;
	245	if(strncmp(buf, "HTTP/", 5))
	246	return(NULL);
	247	ver = p = buf + 5;
	248	for(; ((p >= '0') && (p <= '9')) \|\| (*p == '.'); p++);
	249	if(*p != ' ')
	250	return(NULL);
	251	*(p++) = 0;
	252	if(((p2 = strchr(p, ' ')) == NULL) \|\| (p2 > nl))
	253	return(NULL);
	254	*(p2++) = 0;
	255	code = atoi(p);
	256	if((code < 100) \|\| (code >= 600))
	257	return(NULL);
	258	if(p2 >= nl)
	259	return(NULL);
	260	msg = p2;
	261	p = nl;
	262	if(!SKIPNL(p))
	263	return(NULL);
	264
	265	resp = mkresp(code, msg, ver);
	266	while(1) {
	267	if(SKIPNL(p)) {
	268	if(*p)
	269	goto fail;
	270	break;
	271	}
	272	if((nl = strchr(p, '\n')) == NULL)
	273	goto fail;
	274	if(((p2 = strchr(p, ':')) == NULL) \|\| (p2 > nl))
	275	goto fail;
	276	*(p2++) = 0;
	277	for(; (p2 == ' ') \|\| (p2 == '\t'); p2++);
	278	for(nl = p2; (nl != '\r') && (nl != '\n'); nl++);
	279	if(!SKIPNL(nl))
	280	goto fail;
	281	headappheader(resp, p, p2);
	282	p = nl;
	283	}
	284	return(resp);
	285
	286	fail:
	287	freehthead(resp);
	288	return(NULL);
	289	}
	290
	291	static off_t passdata(int src, int dst, struct charbuf *buf, off_t max)
	292	{
	293	size_t dataoff, smax;
	294	off_t sent;
	295	int eof, ret;
	296
297	sent = 0;
298	eof = 0;
d93d9a05	299	while((!eof \|\| (buf->d > 0)) && ((max < 0) \|\| (sent < max))) {
9d87a119 FT	300	if(!eof && (buf->d < buf->s) && ((max < 0) \|\| (sent + buf->d < max))) {
	301	while(1) {
	302	ret = recv(src, buf->b + buf->d, buf->s - buf->d, MSG_DONTWAIT);
	303	if((ret < 0) && (errno == EAGAIN)) {
	304	} else if(ret < 0) {
	305	return(-1);
	306	} else if(ret == 0) {
	307	eof = 1;
	308	break;
	309	} else {
	310	buf->d += ret;
	311	break;
	312	}
	313	if(buf->d > 0)
	314	break;
	315	if(block(src, EV_READ, 0) <= 0)
	316	return(-1);
	317	}
	318	}
	319	for(dataoff = 0; (dataoff < buf->d) && ((max < 0) \|\| (sent < max));) {
	320	if(block(dst, EV_WRITE, 120) <= 0)
	321	return(-1);
	322	smax = buf->d - dataoff;
	323	if(sent + smax > max)
	324	smax = max - sent;
	325	ret = send(dst, buf->b + dataoff, smax, MSG_NOSIGNAL \| MSG_DONTWAIT);
	326	if(ret < 0)
	327	return(-1);
	328	dataoff += ret;
	329	sent += ret;
	330	}
	331	bufeat(*buf, dataoff);
	332	}
	333	return(sent);
	334	}
	335
66987955 FT	336	static void serve(struct muth *muth, va_list args)
	337	{
	338	vavar(int, fd);
9d87a119 FT	339	vavar(struct sockaddr_storage, name);
	340	int cfd;
	341	char old;
	342	char *hd;
	343	struct charbuf inbuf, outbuf;
	344	struct hthead req, resp;
a0327573	345	off_t dlen, sent;
d93d9a05	346	ssize_t headoff;
9d87a119	347	char nmbuf[256];
66987955	348
9d87a119 FT	349	bufinit(inbuf);
	350	bufinit(outbuf);
	351	cfd = -1;
	352	req = NULL;
66987955	353	while(1) {
9d87a119 FT	354	/*
	355	* First, find and decode the header:
	356	*/
	357	if((headoff = readhead(fd, &inbuf)) < 0)
	358	goto out;
	359	if(headoff > 65536) {
	360	/* We cannot handle arbitrarily large headers, as they
	361	* need to fit within a single Unix datagram. This is
	362	* probably a safe limit, and larger packets than this are
	363	* most likely erroneous (or malicious) anyway. */
	364	goto out;
	365	}
	366	old = inbuf.b[headoff];
	367	inbuf.b[headoff] = 0;
	368	if((req = parserawreq(inbuf.b)) == NULL)
66987955	369	goto out;
9d87a119 FT	370	inbuf.b[headoff] = old;
9d87a119 FT	371	bufeat(inbuf, headoff);
9e9eca79 FT	372	/* We strip off the leading slash from the rest string, so
	373	* that multiplexers can parse coherently. */
	374	if(req->rest[0] == '/')
	375	replrest(req, req->rest + 1);
9d87a119 FT	376
	377	/*
	378	* Add metainformation and then send the request to the root
	379	* multiplexer:
	380	*/
	381	if(name.ss_family == AF_INET) {
	382	headappheader(req, "X-Ash-Address", inet_ntop(AF_INET, &((struct sockaddr_in *)&name)->sin_addr, nmbuf, sizeof(nmbuf)));
	383	headappheader(req, "X-Ash-Port", sprintf3("%i", ntohs(((struct sockaddr_in *)&name)->sin_port)));
	384	} else if(name.ss_family == AF_INET6) {
	385	headappheader(req, "X-Ash-Address", inet_ntop(AF_INET6, &((struct sockaddr_in6 *)&name)->sin6_addr, nmbuf, sizeof(nmbuf)));
	386	headappheader(req, "X-Ash-Port", sprintf3("%i", ntohs(((struct sockaddr_in6 *)&name)->sin6_port)));
	387	}
	388	cfd = sendreq(plex, req);
a0327573 FT	389
	390	/*
	391	* If there is message data, pass it:
	392	*/
	393	if((hd = getheader(req, "content-length")) != NULL) {
	394	dlen = atoo(hd);
	395	if(dlen > 0)
	396	passdata(fd, cfd, &inbuf, dlen);
	397	}
d93d9a05 FT	398	/* Make sure to send EOF */
d93d9a05 FT	399	shutdown(cfd, SHUT_WR);
9d87a119 FT	400
	401	/*
	402	* Find and decode the response header:
	403	*/
	404	outbuf.d = 0;
	405	headoff = readhead(cfd, &outbuf);
	406	hd = memcpy(smalloc(headoff + 1), outbuf.b, headoff);
	407	hd[headoff] = 0;
	408	if((resp = parserawresp(hd)) == NULL)
66987955	409	goto out;
9d87a119 FT	410
	411	/*
	412	* Pass the actual output:
	413	*/
	414	sizebuf(outbuf, 65536);
	415	sent = passdata(cfd, fd, &outbuf, -1);
	416	sent -= headoff;
	417
	418	/*
	419	* Check for connection expiry
	420	*/
	421	if(strcasecmp(req->method, "head")) {
	422	if((hd = getheader(resp, "content-length")) != NULL) {
	423	if(sent != atoo(hd)) {
	424	/* Exit because of error */
	425	goto out;
	426	}
	427	} else {
	428	if(((hd = getheader(resp, "transfer-encoding")) == NULL) \|\| !strcasecmp(hd, "identity"))
	429	break;
	430	}
	431	if(((hd = getheader(req, "connection")) != NULL) && !strcasecmp(hd, "close"))
	432	break;
	433	if(((hd = getheader(resp, "connection")) != NULL) && !strcasecmp(hd, "close"))
	434	break;
	435	}
	436
	437	close(cfd);
	438	cfd = -1;
	439	freehthead(req);
	440	req = NULL;
	441	freehthead(resp);
	442	resp = NULL;
66987955 FT	443	}
	444
	445	out:
9d87a119 FT	446	if(cfd >= 0)
	447	close(cfd);
	448	if(req != NULL)
	449	freehthead(req);
	450	if(resp != NULL)
	451	freehthead(resp);
	452	buffree(inbuf);
	453	buffree(outbuf);
66987955 FT	454	close(fd);
	455	}
	456
f4cdf919 FT	457	static void listenloop(struct muth *muth, va_list args)
	458	{
	459	vavar(int, ss);
	460	int ns;
	461	struct sockaddr_storage name;
	462	socklen_t namelen;
	463
	464	while(1) {
	465	namelen = sizeof(name);
9d87a119	466	block(ss, EV_READ, 0);
f4cdf919	467	ns = accept(ss, (struct sockaddr *)&name, &namelen);
66987955 FT	468	if(ns < 0) {
	469	flog(LOG_ERR, "accept: %s", strerror(errno));
	470	goto out;
	471	}
9d87a119	472	mustart(serve, ns, name);
f4cdf919	473	}
66987955 FT	474
	475	out:
	476	close(ss);
f4cdf919 FT	477	}
	478
	479	static void ioloop(void)
	480	{
	481	int ret;
	482	fd_set rfds, wfds, efds;
	483	struct blocker bl, nbl;
9d87a119 FT	484	struct timeval toval;
9d87a119 FT	485	time_t now, timeout;
f4cdf919 FT	486	int maxfd;
	487	int ev;
	488
66987955	489	while(blockers != NULL) {
f4cdf919 FT	490	FD_ZERO(&rfds);
	491	FD_ZERO(&wfds);
	492	FD_ZERO(&efds);
	493	maxfd = 0;
9d87a119 FT	494	now = time(NULL);
9d87a119 FT	495	timeout = 0;
f4cdf919 FT	496	for(bl = blockers; bl; bl = bl->n) {
	497	if(bl->ev & EV_READ)
	498	FD_SET(bl->fd, &rfds);
	499	if(bl->ev & EV_WRITE)
	500	FD_SET(bl->fd, &wfds);
	501	FD_SET(bl->fd, &efds);
	502	if(bl->fd > maxfd)
	503	maxfd = bl->fd;
9d87a119 FT	504	if((bl->to != 0) && ((timeout == 0) \|\| (timeout > bl->to)))
9d87a119 FT	505	timeout = bl->to;
f4cdf919	506	}
9d87a119 FT	507	toval.tv_sec = timeout - now;
	508	toval.tv_usec = 0;
	509	ret = select(maxfd + 1, &rfds, &wfds, &efds, timeout?(&toval):NULL);
f4cdf919 FT	510	if(ret < 0) {
	511	if(errno != EINTR) {
	512	flog(LOG_CRIT, "ioloop: select errored out: %s", strerror(errno));
	513	/* To avoid CPU hogging in case it's bad, which it
	514	* probably is. */
	515	sleep(1);
	516	}
	517	}
9d87a119	518	now = time(NULL);
f4cdf919 FT	519	for(bl = blockers; bl; bl = nbl) {
	520	nbl = bl->n;
	521	ev = 0;
	522	if(FD_ISSET(bl->fd, &rfds))
	523	ev \|= EV_READ;
	524	if(FD_ISSET(bl->fd, &wfds))
	525	ev \|= EV_WRITE;
	526	if(FD_ISSET(bl->fd, &efds))
	527	ev = -1;
66987955 FT	528	if(ev != 0)
66987955 FT	529	resume(bl->th, ev);
9d87a119 FT	530	else if((bl->to != 0) && (bl->to <= now))
9d87a119 FT	531	resume(bl->th, 0);
f4cdf919 FT	532	}
	533	}
	534	}
f0bbedf7 FT	535
	536	int main(int argc, char **argv)
	537	{
f4cdf919 FT	538	int fd;
f4cdf919 FT	539
9d87a119 FT	540	if(argc < 2) {
	541	fprintf(stderr, "usage: htparser ROOT [ARGS...]\n");
	542	exit(1);
	543	}
	544	if((plex = stdmkchild(argv + 1)) < 0) {
	545	flog(LOG_ERR, "could not spawn root multiplexer: %s", strerror(errno));
	546	return(1);
	547	}
f4cdf919 FT	548	if((fd = listensock6(8080)) < 0) {
	549	flog(LOG_ERR, "could not listen on IPv6: %s", strerror(errno));
	550	return(1);
	551	}
	552	mustart(listenloop, fd);
	553	if((fd = listensock4(8080)) < 0) {
	554	if(errno != EADDRINUSE) {
	555	flog(LOG_ERR, "could not listen on IPv4: %s", strerror(errno));
	556	return(1);
	557	}
	558	} else {
	559	mustart(listenloop, fd);
	560	}
	561	ioloop();
	562	return(0);
f0bbedf7	563	}