[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 <pwd.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>

#include "htparser.h"

static int plex;

static void trimx(struct hthead *req)
{
    int i;
    
    i = 0;
    while(i < req->noheaders) {
	if(!strncasecmp(req->headers[i][0], "x-ash-", 6)) {
	    free(req->headers[i][0]);
	    free(req->headers[i][1]);
	    free(req->headers[i]);
	    memmove(req->headers + i, req->headers + i + 1, sizeof(*req->headers) * (--req->noheaders - i));
	} else {
	    i++;
	}
    }
}

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;
    trimx(req);
    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) && ((max < 0) || (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, "%zx\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));
}

void serve(FILE *in, struct conn *conn)
{
    int pfds[2];
    FILE *out;
    struct hthead *req, *resp;
    char *hd, *p;
    off_t dlen;
    
    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((conn->initreq != NULL) && conn->initreq(conn, req))
	    break;
	
	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);
	
	if((resp = parseresp(out)) == NULL)
	    break;
	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 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);
    }
}

static void usage(FILE *out)
{
    fprintf(out, "usage: htparser [-hSf] [-u USER] [-r ROOT] PORTSPEC... -- ROOT [ARGS...]\n");
    fprintf(out, "\twhere PORTSPEC is HANDLER[:PAR[=VAL][(,PAR[=VAL])...]] (try HANDLER:help)\n");
    fprintf(out, "\tavailable handlers are `plain'.\n");
}

static void addport(char *spec)
{
    char *nm, *p, *p2, *n;
    struct charvbuf pars, vals;
    
    bufinit(pars);
    bufinit(vals);
    if((p = strchr(spec, ':')) == NULL) {
	nm = spec;
    } else {
	nm = spec;
	*(p++) = 0;
	do {
	    if((n = strchr(p, ',')) != NULL)
		*(n++) = 0;
	    if((p2 = strchr(p, '=')) != NULL)
		*(p2++) = 0;
	    if(!*p) {
		usage(stderr);
		exit(1);
	    }
	    bufadd(pars, p);
	    if(p2)
		bufadd(vals, p2);
	    else
		bufadd(vals, "");
	} while((p = n) != NULL);
    }
    
    /* XXX: It would be nice to decentralize this, but, meh... */
    if(!strcmp(nm, "plain")) {
	handleplain(pars.d, pars.b, vals.b);
    } else {
	flog(LOG_ERR, "htparser: unknown port handler `%s'", nm);
	exit(1);
    }
    
    buffree(pars);
    buffree(vals);
}

int main(int argc, char **argv)
{
    int c;
    int i, s1;
    int daemonize, logsys;
    char *root;
    struct passwd *pwent;
    
    daemonize = logsys = 0;
    root = NULL;
    pwent = NULL;
    while((c = getopt(argc, argv, "+hSfu:r:")) >= 0) {
	switch(c) {
	case 'h':
	    usage(stdout);
	    exit(0);
	case 'f':
	    daemonize = 1;
	    break;
	case 'S':
	    logsys = 1;
	    break;
	case 'u':
	    if((pwent = getpwnam(optarg)) == NULL) {
		flog(LOG_ERR, "could not find user %s", optarg);
		exit(1);
	    }
	    break;
	case 'r':
	    root = optarg;
	    break;
	default:
	    usage(stderr);
	    exit(1);
	}
    }
    s1 = 0;
    for(i = optind; i < argc; i++) {
	if(!strcmp(argv[i], "--"))
	    break;
	s1 = 1;
	addport(argv[i]);
    }
    if(!s1 || (i == argc)) {
	usage(stderr);
	exit(1);
    }
    if((plex = stdmkchild(argv + ++i)) < 0) {
	flog(LOG_ERR, "could not spawn root multiplexer: %s", strerror(errno));
	return(1);
    }
    mustart(plexwatch, plex);
    if(logsys)
	opensyslog();
    if(root) {
	if(chroot(root)) {
	    flog(LOG_ERR, "could not chroot to %s: %s", root, strerror(errno));
	    exit(1);
	}
    }
    if(pwent) {
	if(setgid(pwent->pw_gid)) {
	    flog(LOG_ERR, "could not switch group to %i: %s", (int)pwent->pw_gid, strerror(errno));
	    exit(1);
	}
	if(setuid(pwent->pw_uid)) {
	    flog(LOG_ERR, "could not switch user to %i: %s", (int)pwent->pw_uid, strerror(errno));
	    exit(1);
	}
    }
    if(daemonize) {
	daemon(0, 0);
    }
    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	23	#include <sys/socket.h>
f0cbd8d7	24	#include <pwd.h>
f4cdf919	25	#include <errno.h>
f0bbedf7 FT	26
	27	#ifdef HAVE_CONFIG_H
	28	#include <config.h>
	29	#endif
	30	#include <utils.h>
f4cdf919	31	#include <mt.h>
83723896	32	#include <mtio.h>
f4cdf919	33	#include <log.h>
66987955	34	#include <req.h>
9d87a119	35	#include <proc.h>
f4cdf919	36
8774c31b	37	#include "htparser.h"
f4cdf919	38
8774c31b	39	static int plex;
f4cdf919	40
df431d1d FT	41	static void trimx(struct hthead *req)
	42	{
	43	int i;
	44
	45	i = 0;
	46	while(i < req->noheaders) {
	47	if(!strncasecmp(req->headers[i][0], "x-ash-", 6)) {
	48	free(req->headers[i][0]);
	49	free(req->headers[i][1]);
	50	free(req->headers[i]);
	51	memmove(req->headers + i, req->headers + i + 1, sizeof(req->headers) (--req->noheaders - i));
	52	} else {
	53	i++;
	54	}
	55	}
	56	}
	57
5fc1bf9f	58	static struct hthead parsereq(FILE in)
66987955	59	{
5fc1bf9f FT	60	struct hthead *req;
	61	struct charbuf method, url, ver;
	62	int c;
66987955	63
5fc1bf9f FT	64	req = NULL;
	65	bufinit(method);
	66	bufinit(url);
	67	bufinit(ver);
	68	while(1) {
	69	c = getc(in);
	70	if(c == ' ') {
	71	break;
	72	} else if((c == EOF) \|\| (c < 32) \|\| (c >= 128)) {
	73	goto fail;
	74	} else {
	75	bufadd(method, c);
66987955	76	}
c9955b14	77	}
c9955b14	78	while(1) {
5fc1bf9f FT	79	c = getc(in);
5fc1bf9f FT	80	if(c == ' ') {
c9955b14	81	break;
5fc1bf9f FT	82	} else if((c == EOF) \|\| (c < 32)) {
	83	goto fail;
	84	} else {
	85	bufadd(url, c);
66987955 FT	86	}
66987955 FT	87	}
66987955	88	while(1) {
5fc1bf9f FT	89	c = getc(in);
5fc1bf9f FT	90	if(c == 10) {
66987955	91	break;
5fc1bf9f FT	92	} else if(c == 13) {
5fc1bf9f FT	93	} else if((c == EOF) \|\| (c < 32) \|\| (c >= 128)) {
c9955b14	94	goto fail;
5fc1bf9f FT	95	} else {
	96	bufadd(ver, c);
	97	}
66987955	98	}
5fc1bf9f FT	99	bufadd(method, 0);
	100	bufadd(url, 0);
	101	bufadd(ver, 0);
	102	req = mkreq(method.b, url.b, ver.b);
	103	if(parseheaders(req, in))
	104	goto fail;
df431d1d	105	trimx(req);
5fc1bf9f	106	goto out;
c9955b14 FT	107
c9955b14 FT	108	fail:
5fc1bf9f FT	109	if(req != NULL) {
	110	freehthead(req);
	111	req = NULL;
	112	}
	113	out:
	114	buffree(method);
	115	buffree(url);
	116	buffree(ver);
	117	return(req);
66987955 FT	118	}
66987955 FT	119
5fc1bf9f	120	static struct hthead parseresp(FILE in)
9d87a119	121	{
5fc1bf9f	122	struct hthead *req;
9d87a119	123	int code;
5fc1bf9f FT	124	struct charbuf ver, msg;
5fc1bf9f FT	125	int c;
9d87a119	126
5fc1bf9f FT	127	req = NULL;
	128	bufinit(ver);
	129	bufinit(msg);
	130	code = 0;
9d87a119	131	while(1) {
5fc1bf9f FT	132	c = getc(in);
5fc1bf9f FT	133	if(c == ' ') {
9d87a119	134	break;
5fc1bf9f	135	} else if((c == EOF) \|\| (c < 32) \|\| (c >= 128)) {
9d87a119	136	goto fail;
5fc1bf9f FT	137	} else {
	138	bufadd(ver, c);
	139	}
	140	}
	141	while(1) {
	142	c = getc(in);
	143	if(c == ' ') {
	144	break;
	145	} else if((c == EOF) \|\| (c < '0') \|\| (c > '9')) {
9d87a119	146	goto fail;
5fc1bf9f FT	147	} else {
	148	code = (code * 10) + (c - '0');
	149	}
	150	}
	151	while(1) {
	152	c = getc(in);
	153	if(c == 10) {
	154	break;
	155	} else if(c == 13) {
	156	} else if((c == EOF) \|\| (c < 32)) {
9d87a119	157	goto fail;
5fc1bf9f FT	158	} else {
	159	bufadd(msg, c);
	160	}
9d87a119	161	}
5fc1bf9f FT	162	bufadd(msg, 0);
	163	bufadd(ver, 0);
	164	req = mkresp(code, msg.b, ver.b);
	165	if(parseheaders(req, in))
	166	goto fail;
	167	goto out;
9d87a119 FT	168
9d87a119 FT	169	fail:
5fc1bf9f FT	170	if(req != NULL) {
	171	freehthead(req);
	172	req = NULL;
	173	}
	174	out:
	175	buffree(msg);
	176	buffree(ver);
	177	return(req);
9d87a119 FT	178	}
9d87a119 FT	179
5fc1bf9f	180	static off_t passdata(FILE in, FILE out, off_t max)
9d87a119	181	{
5fc1bf9f FT	182	size_t read;
	183	off_t total;
	184	char buf[8192];
	185
	186	total = 0;
f9255ddd	187	while(!feof(in) && ((max < 0) \|\| (total < max))) {
5fc1bf9f FT	188	read = sizeof(buf);
5fc1bf9f FT	189	if(max >= 0)
a701d7b7	190	read = min(max - total, read);
5fc1bf9f FT	191	read = fread(buf, 1, read, in);
	192	if(ferror(in))
	193	return(-1);
	194	if(fwrite(buf, 1, read, out) != read)
	195	return(-1);
	196	total += read;
9d87a119	197	}
5fc1bf9f FT	198	return(total);
	199	}
	200
	201	static int passchunks(FILE in, FILE out)
	202	{
	203	char buf[8192];
	204	size_t read;
	205
	206	do {
	207	read = fread(buf, 1, sizeof(buf), in);
	208	if(ferror(in))
	209	return(-1);
f9255ddd	210	fprintf(out, "%zx\r\n", read);
5fc1bf9f FT	211	if(fwrite(buf, 1, read, out) != read)
	212	return(-1);
	213	fprintf(out, "\r\n");
	214	} while(read > 0);
	215	return(0);
	216	}
	217
	218	static int hasheader(struct hthead head, char name, char *val)
	219	{
	220	char *hd;
	221
	222	if((hd = getheader(head, name)) == NULL)
	223	return(0);
	224	return(!strcasecmp(hd, val));
9d87a119 FT	225	}
9d87a119 FT	226
8774c31b	227	void serve(FILE in, struct conn conn)
66987955	228	{
af34331c	229	int pfds[2];
8774c31b	230	FILE *out;
9d87a119	231	struct hthead req, resp;
5fc1bf9f FT	232	char hd, p;
5fc1bf9f FT	233	off_t dlen;
66987955	234
5fc1bf9f	235	out = NULL;
3c296bd4	236	req = resp = NULL;
66987955	237	while(1) {
5fc1bf9f FT	238	if((req = parsereq(in)) == NULL)
	239	break;
	240	replrest(req, req->url);
9e9eca79 FT	241	if(req->rest[0] == '/')
9e9eca79 FT	242	replrest(req, req->rest + 1);
edad3c6a FT	243	if((p = strchr(req->rest, '?')) != NULL)
edad3c6a FT	244	*p = 0;
9d87a119	245
8774c31b FT	246	if((conn->initreq != NULL) && conn->initreq(conn, req))
	247	break;
	248
46c3d430	249	if(block(plex, EV_WRITE, 60) <= 0)
5fc1bf9f	250	break;
af34331c	251	if(socketpair(PF_UNIX, SOCK_STREAM, 0, pfds))
5fc1bf9f	252	break;
af34331c	253	if(sendreq(plex, req, pfds[0]))
5fc1bf9f	254	break;
af34331c	255	close(pfds[0]);
5fc1bf9f	256	out = mtstdopen(pfds[1], 1, 600, "r+");
a0327573	257
a0327573 FT	258	if((hd = getheader(req, "content-length")) != NULL) {
a0327573 FT	259	dlen = atoo(hd);
a06a2fbd	260	if(dlen > 0) {
5fc1bf9f FT	261	if(passdata(in, out, dlen) != dlen)
5fc1bf9f FT	262	break;
a06a2fbd	263	}
a0327573	264	}
5fc1bf9f FT	265	if(fflush(out))
5fc1bf9f FT	266	break;
d93d9a05	267	/* Make sure to send EOF */
5fc1bf9f	268	shutdown(pfds[1], SHUT_WR);
9d87a119	269
f9255ddd FT	270	if((resp = parseresp(out)) == NULL)
f9255ddd FT	271	break;
5fc1bf9f FT	272	replstr(&resp->ver, req->ver);
	273
	274	if(!strcmp(req->ver, "HTTP/1.0")) {
	275	writeresp(in, resp);
	276	fprintf(in, "\r\n");
9d87a119	277	if((hd = getheader(resp, "content-length")) != NULL) {
5fc1bf9f FT	278	dlen = passdata(out, in, -1);
	279	if(dlen != atoo(hd))
	280	break;
	281	if(!hasheader(req, "connection", "keep-alive"))
9d87a119	282	break;
5fc1bf9f FT	283	} else {
	284	passdata(out, in, -1);
	285	break;
9d87a119	286	}
5fc1bf9f FT	287	if(hasheader(req, "connection", "close") \|\| hasheader(resp, "connection", "close"))
	288	break;
	289	} else if(!strcmp(req->ver, "HTTP/1.1")) {
	290	if((hd = getheader(resp, "content-length")) != NULL) {
	291	writeresp(in, resp);
	292	fprintf(in, "\r\n");
	293	dlen = passdata(out, in, -1);
	294	if(dlen != atoo(hd))
	295	break;
	296	} else if(!getheader(resp, "transfer-encoding")) {
	297	headappheader(resp, "Transfer-Encoding", "chunked");
	298	writeresp(in, resp);
	299	fprintf(in, "\r\n");
	300	if(passchunks(out, in))
	301	break;
	302	} else {
	303	writeresp(in, resp);
	304	fprintf(in, "\r\n");
	305	passdata(out, in, -1);
9d87a119	306	break;
5fc1bf9f FT	307	}
5fc1bf9f FT	308	if(hasheader(req, "connection", "close") \|\| hasheader(resp, "connection", "close"))
9d87a119	309	break;
5fc1bf9f FT	310	} else {
5fc1bf9f FT	311	break;
9d87a119	312	}
5fc1bf9f FT	313
	314	fclose(out);
	315	out = NULL;
9d87a119	316	freehthead(req);
9d87a119	317	freehthead(resp);
5fc1bf9f	318	req = resp = NULL;
66987955 FT	319	}
66987955 FT	320
5fc1bf9f FT	321	if(out != NULL)
5fc1bf9f FT	322	fclose(out);
9d87a119 FT	323	if(req != NULL)
	324	freehthead(req);
	325	if(resp != NULL)
	326	freehthead(resp);
5fc1bf9f	327	fclose(in);
66987955 FT	328	}
66987955 FT	329
32e24c19 FT	330	static void plexwatch(struct muth *muth, va_list args)
	331	{
	332	vavar(int, fd);
	333	char *buf;
	334	int ret;
	335
	336	while(1) {
	337	block(fd, EV_READ, 0);
	338	buf = smalloc(65536);
	339	ret = recv(fd, buf, 65536, 0);
	340	if(ret < 0) {
	341	flog(LOG_WARNING, "received error on rootplex read channel: %s", strerror(errno));
	342	exit(1);
	343	} else if(ret == 0) {
	344	exit(0);
	345	}
	346	/* Maybe I'd like to implement some protocol in this direction
	347	* some day... */
	348	free(buf);
	349	}
	350	}
	351
8774c31b FT	352	static void usage(FILE *out)
8774c31b FT	353	{
f0cbd8d7	354	fprintf(out, "usage: htparser [-hSf] [-u USER] [-r ROOT] PORTSPEC... -- ROOT [ARGS...]\n");
8774c31b FT	355	fprintf(out, "\twhere PORTSPEC is HANDLER[:PAR[=VAL][(,PAR[=VAL])...]] (try HANDLER:help)\n");
	356	fprintf(out, "\tavailable handlers are `plain'.\n");
	357	}
	358
	359	static void addport(char *spec)
	360	{
	361	char nm, p, p2, n;
	362	struct charvbuf pars, vals;
	363
	364	bufinit(pars);
	365	bufinit(vals);
	366	if((p = strchr(spec, ':')) == NULL) {
	367	nm = spec;
	368	} else {
	369	nm = spec;
	370	*(p++) = 0;
	371	do {
	372	if((n = strchr(p, ',')) != NULL)
	373	*(n++) = 0;
	374	if((p2 = strchr(p, '=')) != NULL)
	375	*(p2++) = 0;
	376	if(!*p) {
	377	usage(stderr);
	378	exit(1);
	379	}
	380	bufadd(pars, p);
	381	if(p2)
	382	bufadd(vals, p2);
	383	else
	384	bufadd(vals, "");
	385	} while((p = n) != NULL);
	386	}
	387
	388	/* XXX: It would be nice to decentralize this, but, meh... */
	389	if(!strcmp(nm, "plain")) {
	390	handleplain(pars.d, pars.b, vals.b);
	391	} else {
	392	flog(LOG_ERR, "htparser: unknown port handler `%s'", nm);
	393	exit(1);
	394	}
	395
	396	buffree(pars);
	397	buffree(vals);
	398	}
	399
f0bbedf7 FT	400	int main(int argc, char **argv)
f0bbedf7 FT	401	{
8774c31b FT	402	int c;
8774c31b FT	403	int i, s1;
f0cbd8d7 FT	404	int daemonize, logsys;
	405	char *root;
	406	struct passwd *pwent;
f4cdf919	407
f0cbd8d7 FT	408	daemonize = logsys = 0;
	409	root = NULL;
	410	pwent = NULL;
	411	while((c = getopt(argc, argv, "+hSfu:r:")) >= 0) {
8774c31b FT	412	switch(c) {
	413	case 'h':
	414	usage(stdout);
	415	exit(0);
f0cbd8d7 FT	416	case 'f':
	417	daemonize = 1;
	418	break;
	419	case 'S':
	420	logsys = 1;
	421	break;
	422	case 'u':
	423	if((pwent = getpwnam(optarg)) == NULL) {
	424	flog(LOG_ERR, "could not find user %s", optarg);
	425	exit(1);
	426	}
	427	break;
	428	case 'r':
	429	root = optarg;
	430	break;
8774c31b FT	431	default:
	432	usage(stderr);
	433	exit(1);
	434	}
	435	}
8774c31b FT	436	s1 = 0;
	437	for(i = optind; i < argc; i++) {
	438	if(!strcmp(argv[i], "--"))
	439	break;
	440	s1 = 1;
	441	addport(argv[i]);
9d87a119	442	}
8774c31b FT	443	if(!s1 \|\| (i == argc)) {
	444	usage(stderr);
	445	exit(1);
f4cdf919	446	}
8774c31b FT	447	if((plex = stdmkchild(argv + ++i)) < 0) {
	448	flog(LOG_ERR, "could not spawn root multiplexer: %s", strerror(errno));
	449	return(1);
f4cdf919	450	}
32e24c19	451	mustart(plexwatch, plex);
f0cbd8d7 FT	452	if(logsys)
	453	opensyslog();
	454	if(root) {
	455	if(chroot(root)) {
	456	flog(LOG_ERR, "could not chroot to %s: %s", root, strerror(errno));
	457	exit(1);
	458	}
	459	}
	460	if(pwent) {
	461	if(setgid(pwent->pw_gid)) {
	462	flog(LOG_ERR, "could not switch group to %i: %s", (int)pwent->pw_gid, strerror(errno));
	463	exit(1);
	464	}
	465	if(setuid(pwent->pw_uid)) {
	466	flog(LOG_ERR, "could not switch user to %i: %s", (int)pwent->pw_uid, strerror(errno));
	467	exit(1);
	468	}
	469	}
	470	if(daemonize) {
	471	daemon(0, 0);
	472	}
f4cdf919 FT	473	ioloop();
f4cdf919 FT	474	return(0);
f0bbedf7	475	}