[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/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <errno.h>

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

static int plex;

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 struct hthead *parsereq(FILE *in)
{
    struct hthead *req;
    struct charbuf method, url, ver;
    int c;
    
    req = NULL;
    bufinit(method);
    bufinit(url);
    bufinit(ver);
    while(1) {
	c = getc(in);
	if(c == ' ') {
	    break;
	} else if((c == EOF) || (c < 32) || (c >= 128)) {
	    goto fail;
	} else {
	    bufadd(method, c);
	}
    }
    while(1) {
	c = getc(in);
	if(c == ' ') {
	    break;
	} else if((c == EOF) || (c < 32)) {
	    goto fail;
	} else {
	    bufadd(url, c);
	}
    }
    while(1) {
	c = getc(in);
	if(c == 10) {
	    break;
	} else if(c == 13) {
	} else if((c == EOF) || (c < 32) || (c >= 128)) {
	    goto fail;
	} else {
	    bufadd(ver, c);
	}
    }
    bufadd(method, 0);
    bufadd(url, 0);
    bufadd(ver, 0);
    req = mkreq(method.b, url.b, ver.b);
    if(parseheaders(req, in))
	goto fail;
    goto out;
    
fail:
    if(req != NULL) {
	freehthead(req);
	req = NULL;
    }
out:
    buffree(method);
    buffree(url);
    buffree(ver);
    return(req);
}

static struct hthead *parseresp(FILE *in)
{
    struct hthead *req;
    int code;
    struct charbuf ver, msg;
    int c;
    
    req = NULL;
    bufinit(ver);
    bufinit(msg);
    code = 0;
    while(1) {
	c = getc(in);
	if(c == ' ') {
	    break;
	} else if((c == EOF) || (c < 32) || (c >= 128)) {
	    goto fail;
	} else {
	    bufadd(ver, c);
	}
    }
    while(1) {
	c = getc(in);
	if(c == ' ') {
	    break;
	} else if((c == EOF) || (c < '0') || (c > '9')) {
	    goto fail;
	} else {
	    code = (code * 10) + (c - '0');
	}
    }
    while(1) {
	c = getc(in);
	if(c == 10) {
	    break;
	} else if(c == 13) {
	} else if((c == EOF) || (c < 32)) {
	    goto fail;
	} else {
	    bufadd(msg, c);
	}
    }
    bufadd(msg, 0);
    bufadd(ver, 0);
    req = mkresp(code, msg.b, ver.b);
    if(parseheaders(req, in))
	goto fail;
    goto out;
    
fail:
    if(req != NULL) {
	freehthead(req);
	req = NULL;
    }
out:
    buffree(msg);
    buffree(ver);
    return(req);
}

static off_t passdata(FILE *in, FILE *out, off_t max)
{
    size_t read;
    off_t total;
    char buf[8192];
    
    total = 0;
    while(!feof(in) && (total < max)) {
	read = sizeof(buf);
	if(max >= 0)
	    read = min(max - total, read);
	read = fread(buf, 1, read, in);
	if(ferror(in))
	    return(-1);
	if(fwrite(buf, 1, read, out) != read)
	    return(-1);
	total += read;
    }
    return(total);
}

static int passchunks(FILE *in, FILE *out)
{
    char buf[8192];
    size_t read;
    
    do {
	read = fread(buf, 1, sizeof(buf), in);
	if(ferror(in))
	    return(-1);
	fprintf(out, "%x\r\n", read);
	if(fwrite(buf, 1, read, out) != read)
	    return(-1);
	fprintf(out, "\r\n");
    } while(read > 0);
    return(0);
}

static int hasheader(struct hthead *head, char *name, char *val)
{
    char *hd;
    
    if((hd = getheader(head, name)) == NULL)
	return(0);
    return(!strcasecmp(hd, val));
}

static void serve(struct muth *muth, va_list args)
{
    vavar(int, fd);
    vavar(struct sockaddr_storage, name);
    int pfds[2];
    FILE *in, *out;
    struct hthead *req, *resp;
    char nmbuf[256];
    char *hd, *p;
    off_t dlen;
    
    in = mtstdopen(fd, 1, 60, "r+");
    out = NULL;
    req = resp = NULL;
    while(1) {
	if((req = parsereq(in)) == NULL)
	    break;
	replrest(req, req->url);
	if(req->rest[0] == '/')
	    replrest(req, req->rest + 1);
	if((p = strchr(req->rest, '?')) != NULL)
	    *p = 0;
	
	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)));
	}

	if(block(plex, EV_WRITE, 60) <= 0)
	    break;
	if(socketpair(PF_UNIX, SOCK_STREAM, 0, pfds))
	    break;
	if(sendreq(plex, req, pfds[0]))
	    break;
	close(pfds[0]);
	out = mtstdopen(pfds[1], 1, 600, "r+");

	if((hd = getheader(req, "content-length")) != NULL) {
	    dlen = atoo(hd);
	    if(dlen > 0) {
		if(passdata(in, out, dlen) != dlen)
		    break;
	    }
	}
	if(fflush(out))
	    break;
	/* Make sure to send EOF */
	shutdown(pfds[1], SHUT_WR);
	
	resp = parseresp(out);
	replstr(&resp->ver, req->ver);

	if(!strcmp(req->ver, "HTTP/1.0")) {
	    writeresp(in, resp);
	    fprintf(in, "\r\n");
	    if((hd = getheader(resp, "content-length")) != NULL) {
		dlen = passdata(out, in, -1);
		if(dlen != atoo(hd))
		    break;
		if(!hasheader(req, "connection", "keep-alive"))
		    break;
	    } else {
		passdata(out, in, -1);
		break;
	    }
	    if(hasheader(req, "connection", "close") || hasheader(resp, "connection", "close"))
		break;
	} else if(!strcmp(req->ver, "HTTP/1.1")) {
	    if((hd = getheader(resp, "content-length")) != NULL) {
		writeresp(in, resp);
		fprintf(in, "\r\n");
		dlen = passdata(out, in, -1);
		if(dlen != atoo(hd))
		    break;
	    } else if(!getheader(resp, "transfer-encoding")) {
		headappheader(resp, "Transfer-Encoding", "chunked");
		writeresp(in, resp);
		fprintf(in, "\r\n");
		if(passchunks(out, in))
		    break;
	    } else {
		writeresp(in, resp);
		fprintf(in, "\r\n");
		passdata(out, in, -1);
		break;
	    }
	    if(hasheader(req, "connection", "close") || hasheader(resp, "connection", "close"))
		break;
	} else {
	    break;
	}

	fclose(out);
	out = NULL;
	freehthead(req);
	freehthead(resp);
	req = resp = NULL;
    }
    
    if(out != NULL)
	fclose(out);
    if(req != NULL)
	freehthead(req);
    if(resp != NULL)
	freehthead(resp);
    fclose(in);
}

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 plexwatch(struct muth *muth, va_list args)
{
    vavar(int, fd);
    char *buf;
    int ret;
    
    while(1) {
	block(fd, EV_READ, 0);
	buf = smalloc(65536);
	ret = recv(fd, buf, 65536, 0);
	if(ret < 0) {
	    flog(LOG_WARNING, "received error on rootplex read channel: %s", strerror(errno));
	    exit(1);
	} else if(ret == 0) {
	    exit(0);
	}
	/* Maybe I'd like to implement some protocol in this direction
	 * some day... */
	free(buf);
    }
}

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);
    }
    mustart(plexwatch, plex);
    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	22	#include <string.h>
f4cdf919 FT	23	#include <sys/socket.h>
f4cdf919 FT	24	#include <netinet/in.h>
9d87a119	25	#include <arpa/inet.h>
f4cdf919	26	#include <errno.h>
f0bbedf7 FT	27
	28	#ifdef HAVE_CONFIG_H
	29	#include <config.h>
	30	#endif
	31	#include <utils.h>
f4cdf919	32	#include <mt.h>
83723896	33	#include <mtio.h>
f4cdf919	34	#include <log.h>
66987955	35	#include <req.h>
9d87a119	36	#include <proc.h>
f4cdf919	37
83723896	38	static int plex;
f4cdf919 FT	39
	40	static int listensock4(int port)
	41	{
	42	struct sockaddr_in name;
	43	int fd;
	44	int valbuf;
	45
	46	memset(&name, 0, sizeof(name));
	47	name.sin_family = AF_INET;
	48	name.sin_port = htons(port);
	49	if((fd = socket(PF_INET, SOCK_STREAM, 0)) < 0)
	50	return(-1);
	51	valbuf = 1;
	52	setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &valbuf, sizeof(valbuf));
	53	if(bind(fd, (struct sockaddr *)&name, sizeof(name))) {
	54	close(fd);
	55	return(-1);
	56	}
	57	if(listen(fd, 16) < 0) {
	58	close(fd);
	59	return(-1);
	60	}
	61	return(fd);
	62	}
	63
	64	static int listensock6(int port)
	65	{
	66	struct sockaddr_in6 name;
	67	int fd;
	68	int valbuf;
	69
	70	memset(&name, 0, sizeof(name));
	71	name.sin6_family = AF_INET6;
	72	name.sin6_port = htons(port);
	73	if((fd = socket(PF_INET6, SOCK_STREAM, 0)) < 0)
	74	return(-1);
	75	valbuf = 1;
	76	setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &valbuf, sizeof(valbuf));
	77	if(bind(fd, (struct sockaddr *)&name, sizeof(name))) {
	78	close(fd);
	79	return(-1);
	80	}
	81	if(listen(fd, 16) < 0) {
	82	close(fd);
	83	return(-1);
	84	}
	85	return(fd);
	86	}
	87
5fc1bf9f	88	static struct hthead parsereq(FILE in)
66987955	89	{
5fc1bf9f FT	90	struct hthead *req;
	91	struct charbuf method, url, ver;
	92	int c;
66987955	93
5fc1bf9f FT	94	req = NULL;
	95	bufinit(method);
	96	bufinit(url);
	97	bufinit(ver);
	98	while(1) {
	99	c = getc(in);
	100	if(c == ' ') {
	101	break;
	102	} else if((c == EOF) \|\| (c < 32) \|\| (c >= 128)) {
	103	goto fail;
	104	} else {
	105	bufadd(method, c);
66987955	106	}
c9955b14	107	}
c9955b14	108	while(1) {
5fc1bf9f FT	109	c = getc(in);
5fc1bf9f FT	110	if(c == ' ') {
c9955b14	111	break;
5fc1bf9f FT	112	} else if((c == EOF) \|\| (c < 32)) {
	113	goto fail;
	114	} else {
	115	bufadd(url, c);
66987955 FT	116	}
66987955 FT	117	}
66987955	118	while(1) {
5fc1bf9f FT	119	c = getc(in);
5fc1bf9f FT	120	if(c == 10) {
66987955	121	break;
5fc1bf9f FT	122	} else if(c == 13) {
5fc1bf9f FT	123	} else if((c == EOF) \|\| (c < 32) \|\| (c >= 128)) {
c9955b14	124	goto fail;
5fc1bf9f FT	125	} else {
	126	bufadd(ver, c);
	127	}
66987955	128	}
5fc1bf9f FT	129	bufadd(method, 0);
	130	bufadd(url, 0);
	131	bufadd(ver, 0);
	132	req = mkreq(method.b, url.b, ver.b);
	133	if(parseheaders(req, in))
	134	goto fail;
	135	goto out;
c9955b14 FT	136
c9955b14 FT	137	fail:
5fc1bf9f FT	138	if(req != NULL) {
	139	freehthead(req);
	140	req = NULL;
	141	}
	142	out:
	143	buffree(method);
	144	buffree(url);
	145	buffree(ver);
	146	return(req);
66987955 FT	147	}
66987955 FT	148
5fc1bf9f	149	static struct hthead parseresp(FILE in)
9d87a119	150	{
5fc1bf9f	151	struct hthead *req;
9d87a119	152	int code;
5fc1bf9f FT	153	struct charbuf ver, msg;
5fc1bf9f FT	154	int c;
9d87a119	155
5fc1bf9f FT	156	req = NULL;
	157	bufinit(ver);
	158	bufinit(msg);
	159	code = 0;
9d87a119	160	while(1) {
5fc1bf9f FT	161	c = getc(in);
5fc1bf9f FT	162	if(c == ' ') {
9d87a119	163	break;
5fc1bf9f	164	} else if((c == EOF) \|\| (c < 32) \|\| (c >= 128)) {
9d87a119	165	goto fail;
5fc1bf9f FT	166	} else {
	167	bufadd(ver, c);
	168	}
	169	}
	170	while(1) {
	171	c = getc(in);
	172	if(c == ' ') {
	173	break;
	174	} else if((c == EOF) \|\| (c < '0') \|\| (c > '9')) {
9d87a119	175	goto fail;
5fc1bf9f FT	176	} else {
	177	code = (code * 10) + (c - '0');
	178	}
	179	}
	180	while(1) {
	181	c = getc(in);
	182	if(c == 10) {
	183	break;
	184	} else if(c == 13) {
	185	} else if((c == EOF) \|\| (c < 32)) {
9d87a119	186	goto fail;
5fc1bf9f FT	187	} else {
	188	bufadd(msg, c);
	189	}
9d87a119	190	}
5fc1bf9f FT	191	bufadd(msg, 0);
	192	bufadd(ver, 0);
	193	req = mkresp(code, msg.b, ver.b);
	194	if(parseheaders(req, in))
	195	goto fail;
	196	goto out;
9d87a119 FT	197
9d87a119 FT	198	fail:
5fc1bf9f FT	199	if(req != NULL) {
	200	freehthead(req);
	201	req = NULL;
	202	}
	203	out:
	204	buffree(msg);
	205	buffree(ver);
	206	return(req);
9d87a119 FT	207	}
9d87a119 FT	208
5fc1bf9f	209	static off_t passdata(FILE in, FILE out, off_t max)
9d87a119	210	{
5fc1bf9f FT	211	size_t read;
	212	off_t total;
	213	char buf[8192];
	214
	215	total = 0;
a701d7b7	216	while(!feof(in) && (total < max)) {
5fc1bf9f FT	217	read = sizeof(buf);
5fc1bf9f FT	218	if(max >= 0)
a701d7b7	219	read = min(max - total, read);
5fc1bf9f FT	220	read = fread(buf, 1, read, in);
	221	if(ferror(in))
	222	return(-1);
	223	if(fwrite(buf, 1, read, out) != read)
	224	return(-1);
	225	total += read;
9d87a119	226	}
5fc1bf9f FT	227	return(total);
	228	}
	229
	230	static int passchunks(FILE in, FILE out)
	231	{
	232	char buf[8192];
	233	size_t read;
	234
	235	do {
	236	read = fread(buf, 1, sizeof(buf), in);
	237	if(ferror(in))
	238	return(-1);
	239	fprintf(out, "%x\r\n", read);
	240	if(fwrite(buf, 1, read, out) != read)
	241	return(-1);
	242	fprintf(out, "\r\n");
	243	} while(read > 0);
	244	return(0);
	245	}
	246
	247	static int hasheader(struct hthead head, char name, char *val)
	248	{
	249	char *hd;
	250
	251	if((hd = getheader(head, name)) == NULL)
	252	return(0);
	253	return(!strcasecmp(hd, val));
9d87a119 FT	254	}
9d87a119 FT	255
66987955 FT	256	static void serve(struct muth *muth, va_list args)
	257	{
	258	vavar(int, fd);
9d87a119	259	vavar(struct sockaddr_storage, name);
af34331c	260	int pfds[2];
5fc1bf9f	261	FILE in, out;
9d87a119	262	struct hthead req, resp;
9d87a119	263	char nmbuf[256];
5fc1bf9f FT	264	char hd, p;
5fc1bf9f FT	265	off_t dlen;
66987955	266
5fc1bf9f FT	267	in = mtstdopen(fd, 1, 60, "r+");
5fc1bf9f FT	268	out = NULL;
3c296bd4	269	req = resp = NULL;
66987955	270	while(1) {
5fc1bf9f FT	271	if((req = parsereq(in)) == NULL)
	272	break;
	273	replrest(req, req->url);
9e9eca79 FT	274	if(req->rest[0] == '/')
9e9eca79 FT	275	replrest(req, req->rest + 1);
edad3c6a FT	276	if((p = strchr(req->rest, '?')) != NULL)
edad3c6a FT	277	*p = 0;
9d87a119	278
9d87a119 FT	279	if(name.ss_family == AF_INET) {
	280	headappheader(req, "X-Ash-Address", inet_ntop(AF_INET, &((struct sockaddr_in *)&name)->sin_addr, nmbuf, sizeof(nmbuf)));
	281	headappheader(req, "X-Ash-Port", sprintf3("%i", ntohs(((struct sockaddr_in *)&name)->sin_port)));
	282	} else if(name.ss_family == AF_INET6) {
	283	headappheader(req, "X-Ash-Address", inet_ntop(AF_INET6, &((struct sockaddr_in6 *)&name)->sin6_addr, nmbuf, sizeof(nmbuf)));
	284	headappheader(req, "X-Ash-Port", sprintf3("%i", ntohs(((struct sockaddr_in6 *)&name)->sin6_port)));
	285	}
5fc1bf9f	286
46c3d430	287	if(block(plex, EV_WRITE, 60) <= 0)
5fc1bf9f	288	break;
af34331c	289	if(socketpair(PF_UNIX, SOCK_STREAM, 0, pfds))
5fc1bf9f	290	break;
af34331c	291	if(sendreq(plex, req, pfds[0]))
5fc1bf9f	292	break;
af34331c	293	close(pfds[0]);
5fc1bf9f	294	out = mtstdopen(pfds[1], 1, 600, "r+");
a0327573	295
a0327573 FT	296	if((hd = getheader(req, "content-length")) != NULL) {
a0327573 FT	297	dlen = atoo(hd);
a06a2fbd	298	if(dlen > 0) {
5fc1bf9f FT	299	if(passdata(in, out, dlen) != dlen)
5fc1bf9f FT	300	break;
a06a2fbd	301	}
a0327573	302	}
5fc1bf9f FT	303	if(fflush(out))
5fc1bf9f FT	304	break;
d93d9a05	305	/* Make sure to send EOF */
5fc1bf9f	306	shutdown(pfds[1], SHUT_WR);
9d87a119	307
5fc1bf9f FT	308	resp = parseresp(out);
	309	replstr(&resp->ver, req->ver);
	310
	311	if(!strcmp(req->ver, "HTTP/1.0")) {
	312	writeresp(in, resp);
	313	fprintf(in, "\r\n");
9d87a119	314	if((hd = getheader(resp, "content-length")) != NULL) {
5fc1bf9f FT	315	dlen = passdata(out, in, -1);
	316	if(dlen != atoo(hd))
	317	break;
	318	if(!hasheader(req, "connection", "keep-alive"))
9d87a119	319	break;
5fc1bf9f FT	320	} else {
	321	passdata(out, in, -1);
	322	break;
9d87a119	323	}
5fc1bf9f FT	324	if(hasheader(req, "connection", "close") \|\| hasheader(resp, "connection", "close"))
	325	break;
	326	} else if(!strcmp(req->ver, "HTTP/1.1")) {
	327	if((hd = getheader(resp, "content-length")) != NULL) {
	328	writeresp(in, resp);
	329	fprintf(in, "\r\n");
	330	dlen = passdata(out, in, -1);
	331	if(dlen != atoo(hd))
	332	break;
	333	} else if(!getheader(resp, "transfer-encoding")) {
	334	headappheader(resp, "Transfer-Encoding", "chunked");
	335	writeresp(in, resp);
	336	fprintf(in, "\r\n");
	337	if(passchunks(out, in))
	338	break;
	339	} else {
	340	writeresp(in, resp);
	341	fprintf(in, "\r\n");
	342	passdata(out, in, -1);
9d87a119	343	break;
5fc1bf9f FT	344	}
5fc1bf9f FT	345	if(hasheader(req, "connection", "close") \|\| hasheader(resp, "connection", "close"))
9d87a119	346	break;
5fc1bf9f FT	347	} else {
5fc1bf9f FT	348	break;
9d87a119	349	}
5fc1bf9f FT	350
	351	fclose(out);
	352	out = NULL;
9d87a119	353	freehthead(req);
9d87a119	354	freehthead(resp);
5fc1bf9f	355	req = resp = NULL;
66987955 FT	356	}
66987955 FT	357
5fc1bf9f FT	358	if(out != NULL)
5fc1bf9f FT	359	fclose(out);
9d87a119 FT	360	if(req != NULL)
	361	freehthead(req);
	362	if(resp != NULL)
	363	freehthead(resp);
5fc1bf9f	364	fclose(in);
66987955 FT	365	}
66987955 FT	366
f4cdf919 FT	367	static void listenloop(struct muth *muth, va_list args)
	368	{
	369	vavar(int, ss);
	370	int ns;
	371	struct sockaddr_storage name;
	372	socklen_t namelen;
	373
	374	while(1) {
	375	namelen = sizeof(name);
9d87a119	376	block(ss, EV_READ, 0);
f4cdf919	377	ns = accept(ss, (struct sockaddr *)&name, &namelen);
66987955 FT	378	if(ns < 0) {
	379	flog(LOG_ERR, "accept: %s", strerror(errno));
	380	goto out;
	381	}
9d87a119	382	mustart(serve, ns, name);
f4cdf919	383	}
66987955 FT	384
	385	out:
	386	close(ss);
f4cdf919 FT	387	}
f4cdf919 FT	388
32e24c19 FT	389	static void plexwatch(struct muth *muth, va_list args)
	390	{
	391	vavar(int, fd);
	392	char *buf;
	393	int ret;
	394
	395	while(1) {
	396	block(fd, EV_READ, 0);
	397	buf = smalloc(65536);
	398	ret = recv(fd, buf, 65536, 0);
	399	if(ret < 0) {
	400	flog(LOG_WARNING, "received error on rootplex read channel: %s", strerror(errno));
	401	exit(1);
	402	} else if(ret == 0) {
	403	exit(0);
	404	}
	405	/* Maybe I'd like to implement some protocol in this direction
	406	* some day... */
	407	free(buf);
	408	}
	409	}
	410
f0bbedf7 FT	411	int main(int argc, char **argv)
f0bbedf7 FT	412	{
f4cdf919 FT	413	int fd;
f4cdf919 FT	414
9d87a119 FT	415	if(argc < 2) {
	416	fprintf(stderr, "usage: htparser ROOT [ARGS...]\n");
	417	exit(1);
	418	}
	419	if((plex = stdmkchild(argv + 1)) < 0) {
	420	flog(LOG_ERR, "could not spawn root multiplexer: %s", strerror(errno));
	421	return(1);
	422	}
f4cdf919 FT	423	if((fd = listensock6(8080)) < 0) {
	424	flog(LOG_ERR, "could not listen on IPv6: %s", strerror(errno));
	425	return(1);
	426	}
	427	mustart(listenloop, fd);
	428	if((fd = listensock4(8080)) < 0) {
	429	if(errno != EADDRINUSE) {
	430	flog(LOG_ERR, "could not listen on IPv4: %s", strerror(errno));
	431	return(1);
	432	}
	433	} else {
	434	mustart(listenloop, fd);
	435	}
32e24c19	436	mustart(plexwatch, plex);
f4cdf919 FT	437	ioloop();
f4cdf919 FT	438	return(0);
f0bbedf7	439	}