[ashd.git] / src / dirplex / dirplex.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 <string.h>
#include <unistd.h>
#include <errno.h>
#include <sys/stat.h>
#include <ctype.h>
#include <dirent.h>
#include <time.h>
#include <fnmatch.h>
#include <sys/wait.h>
#include <sys/signal.h>

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

#include "dirplex.h"

time_t now;

static void chinit(void *idata)
{
    char *twd = idata;
    
    if(twd != NULL) {
	/* This should never be able to fail other than for critical
	 * I/O errors or some such, since the path has already been
	 * traversed. */
	if(chdir(twd))
	    exit(127);
    }
}

static void childerror(struct hthead *req, int fd)
{
    if(errno == EAGAIN)
	simpleerror(fd, 500, "Server Error", "The request handler is overloaded.");
    else
	simpleerror(fd, 500, "Server Error", "The request handler crashed.");
}

static void handle(struct hthead *req, int fd, char *path, struct pattern *pat)
{
    struct child *ch;
    struct config *ccf;
    struct headmod *head;
    char *twd;

    for(head = pat->headers; head != NULL; head = head->next) {
	headrmheader(req, head->name);
	headappheader(req, head->name, head->value);
    }
    if(!strncmp(path, "./", 2) && path[2])
	path += 2;
    if(pat->fchild) {
	headappheader(req, "X-Ash-File", path);
	stdforkserve(pat->fchild, req, fd, NULL, NULL);
    } else {
	if((ch = findchild(path, pat->childnm, &ccf)) == NULL) {
	    flog(LOG_ERR, "child %s requested, but was not declared", pat->childnm);
	    simpleerror(fd, 500, "Configuration Error", "The server is erroneously configured. Handler %s was requested, but not declared.", pat->childnm);
	    return;
	}
	if((twd = ccf?ccf->path:NULL) != NULL) {
	    if(!strcmp(twd, ".")) {
		twd = NULL;
	    } else if(strncmp(path, twd, strlen(twd)) || (path[strlen(twd)] != '/')) {
		/* Should be an impossible case under the current (and
		 * foreseeable) scheme. */
		simpleerror(fd, 500, "Server Error", "An internal server error occurred.");
		return;
	    } else {
		path = path + strlen(twd) + 1;
	    }
	}
	headappheader(req, "X-Ash-File", path);
	if(childhandle(ch, req, fd, chinit, twd))
	    childerror(req, fd);
    }
}

static void handle404(struct hthead *req, int fd, char *path)
{
    struct child *ch;
    struct config *ccf;
    struct pattern *pat;
    
    char tmp[strlen(path) + 1];
    strcpy(tmp, path);
    if((pat = findmatch(tmp, 0, PT_NOTFOUND)) != NULL) {
	handle(req, fd, tmp, pat);
    } else {
	ch = findchild(tmp, ".notfound", &ccf);
	if(childhandle(ch, req, fd, chinit, ccf?ccf->path:NULL))
	    childerror(req, fd);
    }
}

static void handlefile(struct hthead *req, int fd, char *path)
{
    struct pattern *pat;

    if((pat = findmatch(path, 0, PT_FILE)) == NULL) {
	handle404(req, fd, path);
	return;
    }
    handle(req, fd, path, pat);
}

static int checkaccess(char *path, char *name)
{
    int i, o;
    struct config **cfs;
    
    if(*name == '.') {
	cfs = getconfigs(sprintf3("%s/", path));
	for(i = 0; cfs[i] != NULL; i++) {
	    if(cfs[i]->dotallow != NULL) {
		for(o = 0; cfs[i]->dotallow[o] != NULL; o++) {
		    if(!fnmatch(cfs[i]->dotallow[o], name, 0))
			return(1);
		}
		break;
	    }
	}
	return(0);
    }
    return(1);
}

static char *findfile(char *path, char *name, struct stat *sb)
{
    DIR *dir;
    struct stat sbuf;
    struct dirent *dent;
    char *p, *fp, *ret;
    
    if(sb == NULL)
	sb = &sbuf;
    if((dir = opendir(path)) == NULL)
	return(NULL);
    ret = NULL;
    while((dent = readdir(dir)) != NULL) {
	/* Ignore backup files.
	 * XXX: There is probably a better and more extensible way to
	 * do this. */
	if(dent->d_name[strlen(dent->d_name) - 1] == '~')
	    continue;
	if((p = strchr(dent->d_name, '.')) == NULL)
	    continue;
	if(p - dent->d_name != strlen(name))
	    continue;
	if(strncmp(dent->d_name, name, strlen(name)))
	    continue;
	fp = sprintf2("%s/%s", path, dent->d_name);
	if(stat(fp, sb)) {
	    free(fp);
	    continue;
	}
	if(!S_ISREG(sb->st_mode)) {
	    free(fp);
	    continue;
	}
	if(!checkaccess(path, dent->d_name)) {
	    free(fp);
	    continue;
	}
	ret = fp;
	break;
    }
    closedir(dir);
    return(ret);
}

static void handledir(struct hthead *req, int fd, char *path)
{
    struct config **cfs;
    int i, o;
    struct stat sb;
    char *inm, *ipath, *cpath;
    struct pattern *pat;
    
    cpath = sprintf2("%s/", path);
    cfs = getconfigs(cpath);
    for(i = 0; cfs[i] != NULL; i++) {
	if(cfs[i]->index != NULL) {
	    for(o = 0; cfs[i]->index[o] != NULL; o++) {
		inm = cfs[i]->index[o];
		ipath = sprintf2("%s/%s", path, inm);
		if(!stat(ipath, &sb) && S_ISREG(sb.st_mode)) {
		    handlefile(req, fd, ipath);
		    free(ipath);
		    goto out;
		}
		free(ipath);
		
		if(!strchr(inm, '.') && ((ipath = findfile(path, inm, NULL)) != NULL)) {
		    handlefile(req, fd, ipath);
		    free(ipath);
		    goto out;
		}
	    }
	    break;
	}
    }
    if((pat = findmatch(cpath, 0, PT_DIR)) != NULL) {
	handle(req, fd, cpath, pat);
	goto out;
    }
    simpleerror(fd, 403, "Not Authorized", "Will not send listings for this directory.");
    
out:
    free(cpath);
}

static int checkpath(struct hthead *req, int fd, char *path, char *rest, int final);

static int checkentry(struct hthead *req, int fd, char *path, char *rest, char *el, int final)
{
    struct stat sb;
    char *newpath;
    int rv;
    
    if(!stat(sprintf3("%s/%s", path, el), &sb)) {
	if(!checkaccess(path, el))
	    return(0);
	if(S_ISDIR(sb.st_mode)) {
	    if(!*rest) {
		stdredir(req, fd, 301, sprintf3("%s/", el));
		return(1);
	    }
	    newpath = sprintf2("%s/%s", path, el);
	    rv = checkpath(req, fd, newpath, rest + 1, final);
	    free(newpath);
	    return(rv);
	} else if(S_ISREG(sb.st_mode)) {
	    newpath = sprintf2("%s/%s", path, el);
	    replrest(req, rest);
	    handlefile(req, fd, newpath);
	    free(newpath);
	    return(1);
	}
	handle404(req, fd, sprintf3("%s/", path));
	return(1);
    }
    if(!strchr(el, '.') && ((newpath = findfile(path, el, NULL)) != NULL)) {
	replrest(req, rest);
	handlefile(req, fd, newpath);
	free(newpath);
	return(1);
    }
    return(0);
}

static int checkdir(struct hthead *req, int fd, char *path, char *rest)
{
    char *cpath, *newpath;
    struct config *cf, *ccf;
    struct child *ch;
    struct stat sb;
    int rv;
    
    cf = getconfig(path);
    if((cf->capture != NULL) && (cf->caproot || !cf->path || strcmp(cf->path, "."))) {
	cpath = sprintf2("%s/", path);
	if((ch = findchild(cpath, cf->capture, &ccf)) == NULL) {
	    free(cpath);
	    flog(LOG_ERR, "child %s requested for capture, but was not declared", cf->capture);
	    simpleerror(fd, 500, "Configuration Error", "The server is erroneously configured. Handler %s was requested, but not declared.", cf->capture);
	    return(1);
	}
	free(cpath);
	if(*rest == '/')
	    rest++;
	replrest(req, rest);
	if(childhandle(ch, req, fd, chinit, ccf?ccf->path:NULL))
	    childerror(req, fd);
	return(1);
    }
    if(cf->reparse != NULL) {
	newpath = (cf->reparse[0] == '/')?sstrdup(cf->reparse):sprintf2("%s/%s", path, cf->reparse);
	rv = stat(newpath, &sb);
	if(!rv && S_ISDIR(sb.st_mode)) {
	    rv = checkpath(req, fd, newpath, rest, !cf->parsecomb);
	} else if(!rv && S_ISREG(sb.st_mode)) {
	    replrest(req, rest);
	    handlefile(req, fd, newpath);
	    rv = 1;
	} else {
	    rv = !cf->parsecomb;
	}
	free(newpath);
	if(rv)
	    return(rv);
    }
    return(0);
}

static int checkpath(struct hthead *req, int fd, char *path, char *rest, int final)
{
    char *p, *el;
    int rv;
    
    el = NULL;
    rv = 0;
    
    if(!strncmp(path, "./", 2))
	path += 2;
    if(checkdir(req, fd, path, rest))
	return(1);
    
    if((p = strchr(rest, '/')) == NULL) {
	el = unquoteurl(rest);
	rest = "";
    } else {
	char buf[p - rest + 1];
	memcpy(buf, rest, p - rest);
	buf[p - rest] = 0;
	el = unquoteurl(buf);
	rest = p;
    }
    if(el == NULL) {
	simpleerror(fd, 400, "Bad Request", "The requested URL contains an invalid escape sequence.");
	rv = 1;
	goto out;
    }
    if(strchr(el, '/') || (!*el && *rest)) {
	rv = 0;
	goto out;
    }
    if(!*el) {
	replrest(req, rest);
	handledir(req, fd, path);
	rv = 1;
	goto out;
    }
    rv = checkentry(req, fd, path, rest, el, final);
    
out:
    if(final && !rv) {
	handle404(req, fd, sprintf3("%s/", path));
	rv = 1;
    }
    if(el != NULL)
	free(el);
    return(rv);
}

static void serve(struct hthead *req, int fd)
{
    now = time(NULL);
    checkpath(req, fd, ".", req->rest, 1);
}

static void chldhandler(int sig)
{
    pid_t pid;
    int st;
    
    while((pid = waitpid(-1, &st, WNOHANG)) > 0) {
	if(WCOREDUMP(st))
	    flog(LOG_WARNING, "child process %i dumped core", pid);
    }
}

static void sighandler(int sig)
{
}

static void usage(FILE *out)
{
    fprintf(out, "usage: dirplex [-hN] [-c CONFIG] DIR\n");
}

int main(int argc, char **argv)
{
    int c;
    int nodef;
    char *gcf, *lcf, *clcf;
    struct hthead *req;
    int fd;
    
    nodef = 0;
    lcf = NULL;
    while((c = getopt(argc, argv, "hNc:")) >= 0) {
	switch(c) {
	case 'h':
	    usage(stdout);
	    exit(0);
	case 'N':
	    nodef = 1;
	    break;
	case 'c':
	    lcf = optarg;
	    break;
	default:
	    usage(stderr);
	    exit(1);
	}
    }
    if(argc - optind < 1) {
	usage(stderr);
	exit(1);
    }
    if(!nodef) {
	if((gcf = findstdconf("ashd/dirplex.rc")) != NULL) {
	    gconfig = readconfig(gcf);
	    free(gcf);
	}
    }
    if(lcf != NULL) {
	if(strchr(lcf, '/') == NULL) {
	    if((clcf = findstdconf(sprintf3("ashd/%s", lcf))) == NULL) {
		flog(LOG_ERR, "could not find requested configuration `%s'", lcf);
		exit(1);
	    }
	    if((lconfig = readconfig(clcf)) == NULL)
		exit(1);
	    free(clcf);
	} else {
	    if((lconfig = readconfig(lcf)) == NULL)
		exit(1);
	}
    }
    if(chdir(argv[optind])) {
	flog(LOG_ERR, "could not change directory to %s: %s", argv[optind], strerror(errno));
	exit(1);
    }
    signal(SIGCHLD, chldhandler);
    signal(SIGPIPE, sighandler);
    while(1) {
	if((fd = recvreq(0, &req)) < 0) {
	    if(errno != 0)
		flog(LOG_ERR, "recvreq: %s", strerror(errno));
	    break;
	}
	serve(req, fd);
	freehthead(req);
	close(fd);
    }
    return(0);
}
Commit	Line	Data
600a1ce7 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 <string.h>
	22	#include <unistd.h>
	23	#include <errno.h>
	24	#include <sys/stat.h>
	25	#include <ctype.h>
	26	#include <dirent.h>
	27	#include <time.h>
7aad7863	28	#include <fnmatch.h>
578ad6b1	29	#include <sys/wait.h>
600a1ce7 FT	30	#include <sys/signal.h>
	31
	32	#ifdef HAVE_CONFIG_H
	33	#include <config.h>
	34	#endif
	35	#include <utils.h>
	36	#include <log.h>
	37	#include <req.h>
	38	#include <proc.h>
	39	#include <resp.h>
	40	#include <cf.h>
	41
	42	#include "dirplex.h"
	43
	44	time_t now;
	45
da75c835 FT	46	static void chinit(void *idata)
	47	{
	48	char *twd = idata;
	49
	50	if(twd != NULL) {
	51	/* This should never be able to fail other than for critical
	52	* I/O errors or some such, since the path has already been
	53	* traversed. */
	54	if(chdir(twd))
	55	exit(127);
	56	}
	57	}
	58
f2f009c9 FT	59	static void childerror(struct hthead *req, int fd)
	60	{
	61	if(errno == EAGAIN)
	62	simpleerror(fd, 500, "Server Error", "The request handler is overloaded.");
	63	else
	64	simpleerror(fd, 500, "Server Error", "The request handler crashed.");
	65	}
	66
600a1ce7 FT	67	static void handle(struct hthead req, int fd, char path, struct pattern *pat)
	68	{
	69	struct child *ch;
da75c835	70	struct config *ccf;
acc2d159	71	struct headmod *head;
da75c835	72	char *twd;
600a1ce7	73
acc2d159 FT	74	for(head = pat->headers; head != NULL; head = head->next) {
	75	headrmheader(req, head->name);
	76	headappheader(req, head->name, head->value);
	77	}
2a249e82	78	if(!strncmp(path, "./", 2) && path[2])
cf6e7461	79	path += 2;
600a1ce7	80	if(pat->fchild) {
da75c835	81	headappheader(req, "X-Ash-File", path);
6a7a868e	82	stdforkserve(pat->fchild, req, fd, NULL, NULL);
600a1ce7	83	} else {
da75c835	84	if((ch = findchild(path, pat->childnm, &ccf)) == NULL) {
600a1ce7 FT	85	flog(LOG_ERR, "child %s requested, but was not declared", pat->childnm);
	86	simpleerror(fd, 500, "Configuration Error", "The server is erroneously configured. Handler %s was requested, but not declared.", pat->childnm);
	87	return;
	88	}
b70b2d4f	89	if((twd = ccf?ccf->path:NULL) != NULL) {
da75c835 FT	90	if(!strcmp(twd, ".")) {
	91	twd = NULL;
	92	} else if(strncmp(path, twd, strlen(twd)) \|\| (path[strlen(twd)] != '/')) {
	93	/* Should be an impossible case under the current (and
	94	* foreseeable) scheme. */
	95	simpleerror(fd, 500, "Server Error", "An internal server error occurred.");
	96	return;
	97	} else {
	98	path = path + strlen(twd) + 1;
	99	}
	100	}
	101	headappheader(req, "X-Ash-File", path);
	102	if(childhandle(ch, req, fd, chinit, twd))
f2f009c9	103	childerror(req, fd);
600a1ce7 FT	104	}
	105	}
	106
b70b2d4f FT	107	static void handle404(struct hthead req, int fd, char path)
	108	{
	109	struct child *ch;
	110	struct config *ccf;
a0b6c27c	111	struct pattern *pat;
b70b2d4f	112
a0b6c27c FT	113	char tmp[strlen(path) + 1];
	114	strcpy(tmp, path);
	115	if((pat = findmatch(tmp, 0, PT_NOTFOUND)) != NULL) {
	116	handle(req, fd, tmp, pat);
	117	} else {
	118	ch = findchild(tmp, ".notfound", &ccf);
	119	if(childhandle(ch, req, fd, chinit, ccf?ccf->path:NULL))
	120	childerror(req, fd);
	121	}
b70b2d4f FT	122	}
b70b2d4f FT	123
600a1ce7 FT	124	static void handlefile(struct hthead req, int fd, char path)
	125	{
	126	struct pattern *pat;
	127
a0b6c27c	128	if((pat = findmatch(path, 0, PT_FILE)) == NULL) {
b70b2d4f	129	handle404(req, fd, path);
600a1ce7 FT	130	return;
	131	}
	132	handle(req, fd, path, pat);
	133	}
	134
7aad7863 FT	135	static int checkaccess(char path, char name)
	136	{
	137	int i, o;
	138	struct config **cfs;
	139
	140	if(*name == '.') {
	141	cfs = getconfigs(sprintf3("%s/", path));
	142	for(i = 0; cfs[i] != NULL; i++) {
	143	if(cfs[i]->dotallow != NULL) {
	144	for(o = 0; cfs[i]->dotallow[o] != NULL; o++) {
	145	if(!fnmatch(cfs[i]->dotallow[o], name, 0))
	146	return(1);
	147	}
	148	break;
	149	}
	150	}
	151	return(0);
	152	}
	153	return(1);
	154	}
	155
600a1ce7 FT	156	static char findfile(char path, char name, struct stat sb)
	157	{
	158	DIR *dir;
	159	struct stat sbuf;
	160	struct dirent *dent;
	161	char p, fp, *ret;
	162
	163	if(sb == NULL)
	164	sb = &sbuf;
	165	if((dir = opendir(path)) == NULL)
	166	return(NULL);
	167	ret = NULL;
	168	while((dent = readdir(dir)) != NULL) {
	169	/* Ignore backup files.
	170	* XXX: There is probably a better and more extensible way to
	171	* do this. */
	172	if(dent->d_name[strlen(dent->d_name) - 1] == '~')
	173	continue;
	174	if((p = strchr(dent->d_name, '.')) == NULL)
	175	continue;
	176	if(p - dent->d_name != strlen(name))
	177	continue;
	178	if(strncmp(dent->d_name, name, strlen(name)))
	179	continue;
7aad7863 FT	180	fp = sprintf2("%s/%s", path, dent->d_name);
	181	if(stat(fp, sb)) {
	182	free(fp);
	183	continue;
	184	}
	185	if(!S_ISREG(sb->st_mode)) {
	186	free(fp);
600a1ce7	187	continue;
7aad7863 FT	188	}
	189	if(!checkaccess(path, dent->d_name)) {
	190	free(fp);
600a1ce7	191	continue;
7aad7863 FT	192	}
7aad7863 FT	193	ret = fp;
600a1ce7 FT	194	break;
	195	}
	196	closedir(dir);
	197	return(ret);
	198	}
	199
	200	static void handledir(struct hthead req, int fd, char path)
	201	{
	202	struct config **cfs;
	203	int i, o;
	204	struct stat sb;
	205	char inm, ipath, *cpath;
	206	struct pattern *pat;
	207
	208	cpath = sprintf2("%s/", path);
	209	cfs = getconfigs(cpath);
	210	for(i = 0; cfs[i] != NULL; i++) {
	211	if(cfs[i]->index != NULL) {
	212	for(o = 0; cfs[i]->index[o] != NULL; o++) {
	213	inm = cfs[i]->index[o];
	214	ipath = sprintf2("%s/%s", path, inm);
	215	if(!stat(ipath, &sb) && S_ISREG(sb.st_mode)) {
	216	handlefile(req, fd, ipath);
	217	free(ipath);
	218	goto out;
	219	}
	220	free(ipath);
	221
	222	if(!strchr(inm, '.') && ((ipath = findfile(path, inm, NULL)) != NULL)) {
	223	handlefile(req, fd, ipath);
	224	free(ipath);
	225	goto out;
	226	}
	227	}
	228	break;
	229	}
	230	}
a0b6c27c	231	if((pat = findmatch(cpath, 0, PT_DIR)) != NULL) {
600a1ce7 FT	232	handle(req, fd, cpath, pat);
	233	goto out;
	234	}
	235	simpleerror(fd, 403, "Not Authorized", "Will not send listings for this directory.");
	236
	237	out:
	238	free(cpath);
	239	}
	240
a0b6c27c	241	static int checkpath(struct hthead req, int fd, char path, char *rest, int final);
600a1ce7	242
a0b6c27c	243	static int checkentry(struct hthead req, int fd, char path, char rest, char el, int final)
600a1ce7 FT	244	{
	245	struct stat sb;
	246	char *newpath;
	247	int rv;
	248
600a1ce7	249	if(!stat(sprintf3("%s/%s", path, el), &sb)) {
7aad7863 FT	250	if(!checkaccess(path, el))
7aad7863 FT	251	return(0);
600a1ce7 FT	252	if(S_ISDIR(sb.st_mode)) {
	253	if(!*rest) {
	254	stdredir(req, fd, 301, sprintf3("%s/", el));
	255	return(1);
	256	}
	257	newpath = sprintf2("%s/%s", path, el);
a0b6c27c	258	rv = checkpath(req, fd, newpath, rest + 1, final);
600a1ce7 FT	259	free(newpath);
	260	return(rv);
	261	} else if(S_ISREG(sb.st_mode)) {
	262	newpath = sprintf2("%s/%s", path, el);
	263	replrest(req, rest);
	264	handlefile(req, fd, newpath);
	265	free(newpath);
	266	return(1);
	267	}
b70b2d4f	268	handle404(req, fd, sprintf3("%s/", path));
600a1ce7 FT	269	return(1);
	270	}
	271	if(!strchr(el, '.') && ((newpath = findfile(path, el, NULL)) != NULL)) {
	272	replrest(req, rest);
	273	handlefile(req, fd, newpath);
	274	free(newpath);
	275	return(1);
	276	}
	277	return(0);
	278	}
	279
300d73d9 FT	280	static int checkdir(struct hthead req, int fd, char path, char *rest)
300d73d9 FT	281	{
539c7b9f	282	char cpath, newpath;
300d73d9 FT	283	struct config cf, ccf;
300d73d9 FT	284	struct child *ch;
539c7b9f FT	285	struct stat sb;
539c7b9f FT	286	int rv;
300d73d9 FT	287
300d73d9 FT	288	cf = getconfig(path);
54490135	289	if((cf->capture != NULL) && (cf->caproot \|\| !cf->path \|\| strcmp(cf->path, "."))) {
300d73d9 FT	290	cpath = sprintf2("%s/", path);
	291	if((ch = findchild(cpath, cf->capture, &ccf)) == NULL) {
	292	free(cpath);
	293	flog(LOG_ERR, "child %s requested for capture, but was not declared", cf->capture);
	294	simpleerror(fd, 500, "Configuration Error", "The server is erroneously configured. Handler %s was requested, but not declared.", cf->capture);
	295	return(1);
	296	}
	297	free(cpath);
	298	if(*rest == '/')
	299	rest++;
	300	replrest(req, rest);
b70b2d4f	301	if(childhandle(ch, req, fd, chinit, ccf?ccf->path:NULL))
f2f009c9	302	childerror(req, fd);
300d73d9 FT	303	return(1);
300d73d9 FT	304	}
539c7b9f FT	305	if(cf->reparse != NULL) {
	306	newpath = (cf->reparse[0] == '/')?sstrdup(cf->reparse):sprintf2("%s/%s", path, cf->reparse);
	307	rv = stat(newpath, &sb);
	308	if(!rv && S_ISDIR(sb.st_mode)) {
	309	rv = checkpath(req, fd, newpath, rest, !cf->parsecomb);
	310	} else if(!rv && S_ISREG(sb.st_mode)) {
	311	replrest(req, rest);
	312	handlefile(req, fd, newpath);
	313	rv = 1;
	314	} else {
	315	rv = !cf->parsecomb;
	316	}
	317	free(newpath);
	318	if(rv)
	319	return(rv);
	320	}
300d73d9 FT	321	return(0);
	322	}
	323
a0b6c27c	324	static int checkpath(struct hthead req, int fd, char path, char *rest, int final)
600a1ce7	325	{
600a1ce7 FT	326	char p, el;
	327	int rv;
	328
	329	el = NULL;
	330	rv = 0;
	331
	332	if(!strncmp(path, "./", 2))
	333	path += 2;
300d73d9 FT	334	if(checkdir(req, fd, path, rest))
300d73d9 FT	335	return(1);
600a1ce7 FT	336
	337	if((p = strchr(rest, '/')) == NULL) {
	338	el = unquoteurl(rest);
	339	rest = "";
	340	} else {
	341	char buf[p - rest + 1];
	342	memcpy(buf, rest, p - rest);
	343	buf[p - rest] = 0;
	344	el = unquoteurl(buf);
	345	rest = p;
	346	}
	347	if(el == NULL) {
	348	simpleerror(fd, 400, "Bad Request", "The requested URL contains an invalid escape sequence.");
	349	rv = 1;
	350	goto out;
	351	}
	352	if(strchr(el, '/') \|\| (!el && rest)) {
a0b6c27c	353	rv = 0;
600a1ce7 FT	354	goto out;
	355	}
	356	if(!*el) {
	357	replrest(req, rest);
	358	handledir(req, fd, path);
240d9bcd FT	359	rv = 1;
240d9bcd FT	360	goto out;
600a1ce7	361	}
a0b6c27c	362	rv = checkentry(req, fd, path, rest, el, final);
600a1ce7 FT	363
600a1ce7 FT	364	out:
a0b6c27c FT	365	if(final && !rv) {
	366	handle404(req, fd, sprintf3("%s/", path));
	367	rv = 1;
	368	}
600a1ce7 FT	369	if(el != NULL)
	370	free(el);
	371	return(rv);
	372	}
	373
	374	static void serve(struct hthead *req, int fd)
	375	{
	376	now = time(NULL);
a0b6c27c	377	checkpath(req, fd, ".", req->rest, 1);
600a1ce7 FT	378	}
600a1ce7 FT	379
578ad6b1 FT	380	static void chldhandler(int sig)
	381	{
	382	pid_t pid;
3d6044ab	383	int st;
578ad6b1	384
3d6044ab FT	385	while((pid = waitpid(-1, &st, WNOHANG)) > 0) {
	386	if(WCOREDUMP(st))
	387	flog(LOG_WARNING, "child process %i dumped core", pid);
	388	}
578ad6b1 FT	389	}
578ad6b1 FT	390
fd735432 FT	391	static void sighandler(int sig)
	392	{
	393	}
	394
600a1ce7 FT	395	static void usage(FILE *out)
	396	{
	397	fprintf(out, "usage: dirplex [-hN] [-c CONFIG] DIR\n");
	398	}
	399
	400	int main(int argc, char **argv)
	401	{
	402	int c;
	403	int nodef;
	404	char gcf, lcf, *clcf;
	405	struct hthead *req;
	406	int fd;
	407
	408	nodef = 0;
	409	lcf = NULL;
	410	while((c = getopt(argc, argv, "hNc:")) >= 0) {
	411	switch(c) {
	412	case 'h':
	413	usage(stdout);
	414	exit(0);
	415	case 'N':
	416	nodef = 1;
	417	break;
	418	case 'c':
	419	lcf = optarg;
	420	break;
	421	default:
	422	usage(stderr);
	423	exit(1);
	424	}
	425	}
	426	if(argc - optind < 1) {
	427	usage(stderr);
	428	exit(1);
	429	}
	430	if(!nodef) {
	431	if((gcf = findstdconf("ashd/dirplex.rc")) != NULL) {
	432	gconfig = readconfig(gcf);
	433	free(gcf);
	434	}
	435	}
	436	if(lcf != NULL) {
	437	if(strchr(lcf, '/') == NULL) {
	438	if((clcf = findstdconf(sprintf3("ashd/%s", lcf))) == NULL) {
	439	flog(LOG_ERR, "could not find requested configuration `%s'", lcf);
	440	exit(1);
	441	}
	442	if((lconfig = readconfig(clcf)) == NULL)
	443	exit(1);
	444	free(clcf);
	445	} else {
	446	if((lconfig = readconfig(lcf)) == NULL)
	447	exit(1);
	448	}
	449	}
	450	if(chdir(argv[optind])) {
	451	flog(LOG_ERR, "could not change directory to %s: %s", argv[optind], strerror(errno));
	452	exit(1);
	453	}
578ad6b1	454	signal(SIGCHLD, chldhandler);
fd735432	455	signal(SIGPIPE, sighandler);
600a1ce7 FT	456	while(1) {
	457	if((fd = recvreq(0, &req)) < 0) {
	458	if(errno != 0)
	459	flog(LOG_ERR, "recvreq: %s", strerror(errno));
	460	break;
	461	}
	462	serve(req, fd);
	463	freehthead(req);
	464	close(fd);
	465	}
	466	return(0);
	467	}