[ashd.git] / lib / cf.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 <stdio.h>
#include <unistd.h>
#include <string.h>
#include <ctype.h>
#include <glob.h>
#include <libgen.h>
#include <sys/socket.h>
#include <errno.h>

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

#define CH_SOCKET 0
#define CH_FORK 1

struct stdchild {
    int type;
    char **argv;
    int fd;
};

static int parsefile(struct cfstate *s, FILE *in);
static void stdmerge(struct child *old, struct child *new);
static int stdhandle(struct child *ch, struct hthead *req, int fd, void (*chinit)(void *), void *idata);
static void stddestroy(struct child *ch);

static int doinclude(struct cfstate *s, char *spec)
{
    int rv, i;
    FILE *inc;
    glob_t globm;
    char *fbk, *dir, *fspec;

    rv = 0;
    fbk = s->file;
    if(spec[0] == '/') {
	fspec = spec;
    } else {
	dir = sstrdup(fbk);
	fspec = sprintf3("%s/%s", dirname(dir), spec);
	free(dir);
    }
    if(glob(fspec, 0, NULL, &globm))
	return(0);
    for(i = 0; i < globm.gl_pathc; i++) {
	if((inc = fopen(globm.gl_pathv[i], "r")) != NULL) {
	    s->file = globm.gl_pathv[i];
	    if(parsefile(s, inc)) {
		fclose(inc);
		rv = 1;
		goto out;
	    }
	    fclose(inc);
	    inc = NULL;
	}
    }
    
out:
    globfree(&globm);
    s->file = fbk;
    return(rv);
}

static int parsefile(struct cfstate *s, FILE *in)
{
    int i;
    char line[1024];
    int eof, argc;
    int ind, indst[80], indl;
    char *p, **w;
    
    s->lno = 0;
    indst[indl = 0] = 0;
    eof = 0;
    while(1) {
	if(fgets(line, sizeof(line), in) == NULL) {
	    eof = 1;
	    line[0] = 0;
	}
	s->lno++;
	if(line[0]) {
	    for(p = line + strlen(line) - 1; p >= line; p--) {
		if(isspace(*p))
		    *p = 0;
		else
		    break;
	    }
	}
	for(ind = 0, p = line; *p; p++) {
	    if(*p == ' ') {
		ind++;
	    } else if(*p == '\t') {
		ind = ind - (ind % 8) + 8;
	    } else {
		break;
	    }
	}
	if(!eof && (!*p || (*p == '#')))
	    continue;
	
    reindent:
	if(ind > indst[indl]) {
	    indst[++indl] = ind;
	    if(!s->expstart) {
		s->res = tokenize("start");
		if(yield())
		    return(1);
	    } else {
		s->expstart = 0;
	    }
	} else {
	    if(s->expstart) {
		s->res = tokenize("end");
		if(yield())
		    return(1);
		s->expstart = 0;
	    }
	    while(ind < indst[indl]) {
		indl--;
		s->res = tokenize("end");
		if(yield())
		    return(1);
	    }
	    if(ind > indst[indl]) {
		flog(LOG_WARNING, "%s:%i: unexpected indentation level", s->file, s->lno);
		goto reindent;
	    }
	}
	
	if(eof)
	    return(0);
	
	argc = calen(w = tokenize(line));
	if(argc < 1) {
	    /* Shouldn't happen, but... */
	    freeca(w);
	    continue;
	}
	
	if(indl == 0) {
	    if(!strcmp(w[0], "include")) {
		for(i = 1; i < argc; i++) {
		    if(doinclude(s, w[i])) {
			freeca(w);
			return(1);
		    }
		}
		freeca(w);
		continue;
	    }
	}
	
	if(!strcmp(w[0], "start") ||
	   !strcmp(w[0], "end") || 
	   !strcmp(w[0], "eof")) {
	    flog(LOG_WARNING, "%s:%i: illegal directive: %s", s->file, s->lno, w[0]);
	} else {
	    s->res = w;
	    if(yield())
		return(1);
	}
    }
}

static void parsefn(struct muth *mt, va_list args)
{
    vavar(struct cfstate *, s);
    vavar(FILE *, in);
    vavar(char *, file);
    
    s->file = sstrdup(file);
    if(parsefile(s, in))
	goto out;
    do {
	s->res = tokenize("eof");
    } while(!yield());
    
out:
    free(s->file);
}

char **getcfline(struct cfstate *s)
{
    freeca(s->argv);
    if(s->res == NULL)
	resume(s->pf, 0);
    s->argc = calen(s->argv = s->res);
    s->res = NULL;
    return(s->argv);
}

struct cfstate *mkcfparser(FILE *in, char *name)
{
    struct cfstate *s;
    
    omalloc(s);
    s->pf = mustart(parsefn, s, in, name);
    return(s);
}

void freecfparser(struct cfstate *s)
{
    resume(s->pf, -1);
    freeca(s->argv);
    freeca(s->res);
    free(s);
}

char *findstdconf(char *name)
{
    char *path, *p, *p2, *t;
    
    if((path = getenv("PATH")) == NULL)
	return(NULL);
    path = sstrdup(path);
    for(p = strtok(path, ":"); p != NULL; p = strtok(NULL, ":")) {
	if((p2 = strrchr(p, '/')) == NULL)
	    continue;
	*p2 = 0;
	if(!access(t = sprintf2("%s/etc/%s", p, name), R_OK)) {
	    free(path);
	    return(t);
	}
	free(t);
    }
    free(path);
    return(NULL);
}

struct child *newchild(char *name, struct chandler *iface, void *pdata)
{
    struct child *ch;
    
    omalloc(ch);
    ch->name = sstrdup(name);
    ch->iface = iface;
    ch->pdata = pdata;
    return(ch);
}

void freechild(struct child *ch)
{
    if(ch->iface->destroy != NULL)
	ch->iface->destroy(ch);
    if(ch->name != NULL)
	free(ch->name);
    free(ch);
}

void mergechildren(struct child *dst, struct child *src)
{
    struct child *ch1, *ch2;
    
    for(ch1 = dst; ch1 != NULL; ch1 = ch1->next) {
	for(ch2 = src; ch2 != NULL; ch2 = ch2->next) {
	    if(ch1->iface->merge && !strcmp(ch1->name, ch2->name)) {
		ch1->iface->merge(ch1, ch2);
		break;
	    }
	}
    }
}

void skipcfblock(struct cfstate *s)
{
    char **w;
    
    while(1) {
	w = getcfline(s);
	if(!strcmp(w[0], "end") || !strcmp(w[0], "eof"))
	    return;
    }
}

static struct chandler stdhandler = {
    .handle = stdhandle,
    .merge = stdmerge,
    .destroy = stddestroy,
};

static int stdhandle(struct child *ch, struct hthead *req, int fd, void (*chinit)(void *), void *idata)
{
    struct stdchild *i = ch->pdata;
    int serr;
    
    if(i->type == CH_SOCKET) {
	if(i->fd < 0)
	    i->fd = stdmkchild(i->argv, chinit, idata);
	if(sendreq2(i->fd, req, fd, MSG_NOSIGNAL | MSG_DONTWAIT)) {
	    serr = errno;
	    if((serr == EPIPE) || (serr == ECONNRESET)) {
		/* Assume that the child has crashed and restart it. */
		close(i->fd);
		i->fd = stdmkchild(i->argv, chinit, idata);
		if(!sendreq2(i->fd, req, fd, MSG_NOSIGNAL | MSG_DONTWAIT))
		    return(0);
	    }
	    flog(LOG_ERR, "could not pass on request to child %s: %s", ch->name, strerror(serr));
	    if(serr != EAGAIN) {
		close(i->fd);
		i->fd = -1;
	    }
	    return(-1);
	}
    } else if(i->type == CH_FORK) {
	if(stdforkserve(i->argv, req, fd, chinit, idata) < 0)
	    return(-1);
    }
    return(0);
}

static void stdmerge(struct child *dst, struct child *src)
{
    struct stdchild *od, *nd;
    
    if(src->iface == &stdhandler) {
	nd = dst->pdata;
	od = src->pdata;
	nd->fd = od->fd;
	od->fd = -1;
    }
}

static void stddestroy(struct child *ch)
{
    struct stdchild *d = ch->pdata;
    
    if(d->fd >= 0)
	close(d->fd);
    if(d->argv)
	freeca(d->argv);
    free(d);
}

struct child *parsechild(struct cfstate *s)
{
    struct child *ch;
    struct stdchild *d;
    int i;
    int sl;
    
    sl = s->lno;
    if(!strcmp(s->argv[0], "child")) {
	s->expstart = 1;
	if(s->argc < 2) {
	    flog(LOG_WARNING, "%s:%i: missing name in child declaration", s->file, s->lno);
	    skipcfblock(s);
	    return(NULL);
	}
	ch = newchild(s->argv[1], &stdhandler, omalloc(d));
	d->type = CH_SOCKET;
    } else if(!strcmp(s->argv[0], "fchild")) {
	s->expstart = 1;
	if(s->argc < 2) {
	    flog(LOG_WARNING, "%s:%i: missing name in child declaration", s->file, s->lno);
	    skipcfblock(s);
	    return(NULL);
	}
	ch = newchild(s->argv[1], &stdhandler, omalloc(d));
	d->type = CH_FORK;
    } else {
	return(NULL);
    }
    d->fd = -1;
    
    while(1) {
	getcfline(s);
	if(!strcmp(s->argv[0], "exec")) {
	    if(s->argc < 2) {
		flog(LOG_WARNING, "%s:%i: too few parameters to `exec'", s->file, s->lno);
		continue;
	    }
	    d->argv = szmalloc(sizeof(*d->argv) * s->argc);
	    for(i = 0; i < s->argc - 1; i++)
		d->argv[i] = sstrdup(s->argv[i + 1]);
	} else if(!strcmp(s->argv[0], "end") || !strcmp(s->argv[0], "eof")) {
	    break;
	} else {
	    flog(LOG_WARNING, "%s:%i: unknown directive `%s' in child declaration", s->file, s->lno, s->argv[0]);
	}
    }
    if(d->argv == NULL) {
	flog(LOG_WARNING, "%s:%i: missing `exec' in child declaration %s", s->file, sl, ch->name);
	freechild(ch);
	return(NULL);
    }
    return(ch);
}

int childhandle(struct child *ch, struct hthead *req, int fd, void (*chinit)(void *), void *idata)
{
    return(ch->iface->handle(ch, req, fd, chinit, idata));
}
Commit	Line	Data
06c1a718 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 <stdio.h>
	21	#include <unistd.h>
	22	#include <string.h>
	23	#include <ctype.h>
	24	#include <glob.h>
dd281054	25	#include <libgen.h>
3d74fc07	26	#include <sys/socket.h>
06c1a718 FT	27	#include <errno.h>
	28
	29	#ifdef HAVE_CONFIG_H
	30	#include <config.h>
	31	#endif
	32	#include <utils.h>
	33	#include <cf.h>
	34	#include <mt.h>
	35	#include <proc.h>
	36	#include <log.h>
	37
	38	#define CH_SOCKET 0
	39	#define CH_FORK 1
	40
1924fe8c FT	41	struct stdchild {
	42	int type;
	43	char **argv;
	44	int fd;
	45	};
	46
dd281054	47	static int parsefile(struct cfstate s, FILE in);
1924fe8c FT	48	static void stdmerge(struct child old, struct child new);
	49	static int stdhandle(struct child ch, struct hthead req, int fd, void (chinit)(void ), void *idata);
	50	static void stddestroy(struct child *ch);
dd281054 FT	51
dd281054 FT	52	static int doinclude(struct cfstate s, char spec)
06c1a718	53	{
dd281054 FT	54	int rv, i;
dd281054 FT	55	FILE *inc;
06c1a718	56	glob_t globm;
dd281054 FT	57	char fbk, dir, *fspec;
	58
	59	rv = 0;
	60	fbk = s->file;
	61	if(spec[0] == '/') {
	62	fspec = spec;
	63	} else {
	64	dir = sstrdup(fbk);
	65	fspec = sprintf3("%s/%s", dirname(dir), spec);
	66	free(dir);
	67	}
	68	if(glob(fspec, 0, NULL, &globm))
	69	return(0);
	70	for(i = 0; i < globm.gl_pathc; i++) {
	71	if((inc = fopen(globm.gl_pathv[i], "r")) != NULL) {
	72	s->file = globm.gl_pathv[i];
	73	if(parsefile(s, inc)) {
	74	fclose(inc);
	75	rv = 1;
	76	goto out;
	77	}
	78	fclose(inc);
	79	inc = NULL;
	80	}
	81	}
	82
	83	out:
	84	globfree(&globm);
	85	s->file = fbk;
	86	return(rv);
	87	}
	88
	89	static int parsefile(struct cfstate s, FILE in)
	90	{
	91	int i;
06c1a718 FT	92	char line[1024];
	93	int eof, argc;
	94	int ind, indst[80], indl;
dd281054	95	char p, *w;
06c1a718 FT	96
	97	s->lno = 0;
	98	indst[indl = 0] = 0;
	99	eof = 0;
	100	while(1) {
	101	if(fgets(line, sizeof(line), in) == NULL) {
	102	eof = 1;
	103	line[0] = 0;
	104	}
	105	s->lno++;
c3b91092 FT	106	if(line[0]) {
	107	for(p = line + strlen(line) - 1; p >= line; p--) {
	108	if(isspace(*p))
	109	*p = 0;
	110	else
	111	break;
	112	}
06c1a718 FT	113	}
	114	for(ind = 0, p = line; *p; p++) {
	115	if(*p == ' ') {
	116	ind++;
	117	} else if(*p == '\t') {
	118	ind = ind - (ind % 8) + 8;
	119	} else {
	120	break;
	121	}
	122	}
	123	if(!eof && (!p \|\| (p == '#')))
	124	continue;
	125
	126	reindent:
	127	if(ind > indst[indl]) {
	128	indst[++indl] = ind;
	129	if(!s->expstart) {
	130	s->res = tokenize("start");
	131	if(yield())
	132	return(1);
	133	} else {
	134	s->expstart = 0;
	135	}
	136	} else {
	137	if(s->expstart) {
	138	s->res = tokenize("end");
	139	if(yield())
	140	return(1);
	141	s->expstart = 0;
	142	}
	143	while(ind < indst[indl]) {
	144	indl--;
	145	s->res = tokenize("end");
	146	if(yield())
	147	return(1);
	148	}
	149	if(ind > indst[indl]) {
	150	flog(LOG_WARNING, "%s:%i: unexpected indentation level", s->file, s->lno);
	151	goto reindent;
	152	}
	153	}
	154
	155	if(eof)
	156	return(0);
	157
	158	argc = calen(w = tokenize(line));
	159	if(argc < 1) {
	160	/* Shouldn't happen, but... */
	161	freeca(w);
	162	continue;
	163	}
	164
	165	if(indl == 0) {
	166	if(!strcmp(w[0], "include")) {
06c1a718	167	for(i = 1; i < argc; i++) {
dd281054 FT	168	if(doinclude(s, w[i])) {
	169	freeca(w);
	170	return(1);
06c1a718 FT	171	}
	172	}
	173	freeca(w);
06c1a718 FT	174	continue;
	175	}
	176	}
	177
	178	if(!strcmp(w[0], "start") \|\|
	179	!strcmp(w[0], "end") \|\|
	180	!strcmp(w[0], "eof")) {
	181	flog(LOG_WARNING, "%s:%i: illegal directive: %s", s->file, s->lno, w[0]);
	182	} else {
	183	s->res = w;
	184	if(yield())
	185	return(1);
	186	}
	187	}
	188	}
	189
	190	static void parsefn(struct muth *mt, va_list args)
	191	{
	192	vavar(struct cfstate *, s);
	193	vavar(FILE *, in);
	194	vavar(char *, file);
	195
	196	s->file = sstrdup(file);
	197	if(parsefile(s, in))
	198	goto out;
	199	do {
	200	s->res = tokenize("eof");
	201	} while(!yield());
	202
	203	out:
	204	free(s->file);
	205	}
	206
	207	char *getcfline(struct cfstate s)
	208	{
	209	freeca(s->argv);
	210	if(s->res == NULL)
	211	resume(s->pf, 0);
	212	s->argc = calen(s->argv = s->res);
	213	s->res = NULL;
	214	return(s->argv);
	215	}
	216
	217	struct cfstate mkcfparser(FILE in, char *name)
	218	{
	219	struct cfstate *s;
	220
	221	omalloc(s);
	222	s->pf = mustart(parsefn, s, in, name);
	223	return(s);
	224	}
	225
	226	void freecfparser(struct cfstate *s)
	227	{
	228	resume(s->pf, -1);
	229	freeca(s->argv);
	230	freeca(s->res);
	231	free(s);
	232	}
	233
0fc6fd13 FT	234	char findstdconf(char name)
	235	{
	236	char path, p, p2, t;
	237
	238	if((path = getenv("PATH")) == NULL)
	239	return(NULL);
	240	path = sstrdup(path);
	241	for(p = strtok(path, ":"); p != NULL; p = strtok(NULL, ":")) {
	242	if((p2 = strrchr(p, '/')) == NULL)
	243	continue;
	244	*p2 = 0;
13975be5	245	if(!access(t = sprintf2("%s/etc/%s", p, name), R_OK)) {
0fc6fd13	246	free(path);
13975be5	247	return(t);
0fc6fd13	248	}
13975be5	249	free(t);
0fc6fd13 FT	250	}
	251	free(path);
	252	return(NULL);
	253	}
	254
1924fe8c	255	struct child newchild(char name, struct chandler iface, void pdata)
06c1a718 FT	256	{
	257	struct child *ch;
	258
	259	omalloc(ch);
	260	ch->name = sstrdup(name);
1924fe8c FT	261	ch->iface = iface;
1924fe8c FT	262	ch->pdata = pdata;
06c1a718 FT	263	return(ch);
	264	}
	265
	266	void freechild(struct child *ch)
	267	{
1924fe8c FT	268	if(ch->iface->destroy != NULL)
1924fe8c FT	269	ch->iface->destroy(ch);
06c1a718 FT	270	if(ch->name != NULL)
06c1a718 FT	271	free(ch->name);
06c1a718 FT	272	free(ch);
	273	}
	274
1924fe8c FT	275	void mergechildren(struct child dst, struct child src)
	276	{
	277	struct child ch1, ch2;
	278
	279	for(ch1 = dst; ch1 != NULL; ch1 = ch1->next) {
	280	for(ch2 = src; ch2 != NULL; ch2 = ch2->next) {
	281	if(ch1->iface->merge && !strcmp(ch1->name, ch2->name)) {
	282	ch1->iface->merge(ch1, ch2);
	283	break;
	284	}
	285	}
	286	}
	287	}
	288
06c1a718 FT	289	void skipcfblock(struct cfstate *s)
	290	{
	291	char **w;
	292
	293	while(1) {
	294	w = getcfline(s);
	295	if(!strcmp(w[0], "end") \|\| !strcmp(w[0], "eof"))
	296	return;
	297	}
	298	}
	299
1924fe8c FT	300	static struct chandler stdhandler = {
	301	.handle = stdhandle,
	302	.merge = stdmerge,
	303	.destroy = stddestroy,
	304	};
	305
	306	static int stdhandle(struct child ch, struct hthead req, int fd, void (chinit)(void ), void *idata)
	307	{
	308	struct stdchild *i = ch->pdata;
45b19d96	309	int serr;
1924fe8c FT	310
	311	if(i->type == CH_SOCKET) {
	312	if(i->fd < 0)
	313	i->fd = stdmkchild(i->argv, chinit, idata);
3d74fc07	314	if(sendreq2(i->fd, req, fd, MSG_NOSIGNAL \| MSG_DONTWAIT)) {
45b19d96 FT	315	serr = errno;
45b19d96 FT	316	if((serr == EPIPE) \|\| (serr == ECONNRESET)) {
1924fe8c FT	317	/* Assume that the child has crashed and restart it. */
	318	close(i->fd);
	319	i->fd = stdmkchild(i->argv, chinit, idata);
3d74fc07	320	if(!sendreq2(i->fd, req, fd, MSG_NOSIGNAL \| MSG_DONTWAIT))
1924fe8c FT	321	return(0);
1924fe8c FT	322	}
45b19d96 FT	323	flog(LOG_ERR, "could not pass on request to child %s: %s", ch->name, strerror(serr));
45b19d96 FT	324	if(serr != EAGAIN) {
fc35a3ef FT	325	close(i->fd);
	326	i->fd = -1;
	327	}
1924fe8c FT	328	return(-1);
	329	}
	330	} else if(i->type == CH_FORK) {
	331	if(stdforkserve(i->argv, req, fd, chinit, idata) < 0)
	332	return(-1);
	333	}
	334	return(0);
	335	}
	336
	337	static void stdmerge(struct child dst, struct child src)
	338	{
	339	struct stdchild od, nd;
	340
	341	if(src->iface == &stdhandler) {
	342	nd = dst->pdata;
	343	od = src->pdata;
	344	nd->fd = od->fd;
	345	od->fd = -1;
	346	}
	347	}
	348
	349	static void stddestroy(struct child *ch)
	350	{
	351	struct stdchild *d = ch->pdata;
	352
	353	if(d->fd >= 0)
	354	close(d->fd);
	355	if(d->argv)
	356	freeca(d->argv);
	357	free(d);
	358	}
	359
06c1a718 FT	360	struct child parsechild(struct cfstate s)
	361	{
	362	struct child *ch;
1924fe8c	363	struct stdchild *d;
06c1a718 FT	364	int i;
	365	int sl;
	366
	367	sl = s->lno;
	368	if(!strcmp(s->argv[0], "child")) {
	369	s->expstart = 1;
	370	if(s->argc < 2) {
	371	flog(LOG_WARNING, "%s:%i: missing name in child declaration", s->file, s->lno);
	372	skipcfblock(s);
	373	return(NULL);
	374	}
1924fe8c FT	375	ch = newchild(s->argv[1], &stdhandler, omalloc(d));
1924fe8c FT	376	d->type = CH_SOCKET;
06c1a718 FT	377	} else if(!strcmp(s->argv[0], "fchild")) {
	378	s->expstart = 1;
	379	if(s->argc < 2) {
	380	flog(LOG_WARNING, "%s:%i: missing name in child declaration", s->file, s->lno);
	381	skipcfblock(s);
	382	return(NULL);
	383	}
1924fe8c FT	384	ch = newchild(s->argv[1], &stdhandler, omalloc(d));
1924fe8c FT	385	d->type = CH_FORK;
06c1a718 FT	386	} else {
	387	return(NULL);
	388	}
1924fe8c	389	d->fd = -1;
06c1a718 FT	390
	391	while(1) {
	392	getcfline(s);
	393	if(!strcmp(s->argv[0], "exec")) {
	394	if(s->argc < 2) {
	395	flog(LOG_WARNING, "%s:%i: too few parameters to `exec'", s->file, s->lno);
	396	continue;
	397	}
1924fe8c	398	d->argv = szmalloc(sizeof(d->argv) s->argc);
06c1a718	399	for(i = 0; i < s->argc - 1; i++)
1924fe8c	400	d->argv[i] = sstrdup(s->argv[i + 1]);
06c1a718 FT	401	} else if(!strcmp(s->argv[0], "end") \|\| !strcmp(s->argv[0], "eof")) {
	402	break;
	403	} else {
	404	flog(LOG_WARNING, "%s:%i: unknown directive `%s' in child declaration", s->file, s->lno, s->argv[0]);
	405	}
	406	}
1924fe8c	407	if(d->argv == NULL) {
06c1a718 FT	408	flog(LOG_WARNING, "%s:%i: missing `exec' in child declaration %s", s->file, sl, ch->name);
	409	freechild(ch);
	410	return(NULL);
	411	}
	412	return(ch);
	413	}
	414
6a7a868e	415	int childhandle(struct child ch, struct hthead req, int fd, void (chinit)(void ), void *idata)
06c1a718	416	{
1924fe8c	417	return(ch->iface->handle(ch, req, fd, chinit, idata));
06c1a718	418	}