[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 <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 handle(struct hthead *req, int fd, char *path, struct pattern *pat)
{
    struct child *ch;
    struct config *ccf;
    char *twd;

    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;
	}
	twd = NULL;
	if((twd = ccf->path) != 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))
	    simpleerror(fd, 500, "Server Error", "The request handler crashed.");
    }
}

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

    if((pat = findmatch(path, 0, 0)) == NULL) {
	simpleerror(fd, 404, "Not Found", "The requested URL has no corresponding resource.");
	return;
    }
    handle(req, fd, path, pat);
}

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 = sprintf3("%s/%s", path, dent->d_name);
	if(stat(fp, sb))
	    continue;
	if(!S_ISREG(sb->st_mode))
	    continue;
	ret = sstrdup(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, 1)) != 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);

static int checkentry(struct hthead *req, int fd, char *path, char *rest, char *el)
{
    struct stat sb;
    char *newpath;
    int rv;
    
    if(!el == '.') {
	simpleerror(fd, 404, "Not Found", "The requested URL has no corresponding resource.");
	return(1);
    }
    if(!stat(sprintf3("%s/%s", path, el), &sb)) {
	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);
	    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);
	}
	simpleerror(fd, 404, "Not Found", "The requested URL has no corresponding resource.");
	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 checkpath(struct hthead *req, int fd, char *path, char *rest)
{
    struct config *cf;
    char *p, *el;
    int rv;
    
    el = NULL;
    rv = 0;
    
    if(!strncmp(path, "./", 2))
	path += 2;
    cf = getconfig(path);
    
    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)) {
	simpleerror(fd, 404, "Not Found", "The requested URL has no corresponding resource.");
	rv = 1;
	goto out;
    }
    if(!*el) {
	replrest(req, rest);
	handledir(req, fd, path);
	return(1);
    }
    rv = checkentry(req, fd, path, rest, el);
    
out:
    if(el != NULL)
	free(el);
    return(rv);
}

static void serve(struct hthead *req, int fd)
{
    now = time(NULL);
    if(!checkpath(req, fd, ".", req->rest))
	simpleerror(fd, 404, "Not Found", "The requested URL has no corresponding resource.");
}

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, SIG_IGN);
    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>
	28	#include <sys/signal.h>
	29
	30	#ifdef HAVE_CONFIG_H
	31	#include <config.h>
	32	#endif
	33	#include <utils.h>
	34	#include <log.h>
	35	#include <req.h>
	36	#include <proc.h>
	37	#include <resp.h>
	38	#include <cf.h>
	39
	40	#include "dirplex.h"
	41
	42	time_t now;
	43
da75c835 FT	44	static void chinit(void *idata)
	45	{
	46	char *twd = idata;
	47
	48	if(twd != NULL) {
	49	/* This should never be able to fail other than for critical
	50	* I/O errors or some such, since the path has already been
	51	* traversed. */
	52	if(chdir(twd))
	53	exit(127);
	54	}
	55	}
	56
600a1ce7 FT	57	static void handle(struct hthead req, int fd, char path, struct pattern *pat)
	58	{
	59	struct child *ch;
da75c835 FT	60	struct config *ccf;
da75c835 FT	61	char *twd;
600a1ce7	62
600a1ce7	63	if(pat->fchild) {
da75c835	64	headappheader(req, "X-Ash-File", path);
6a7a868e	65	stdforkserve(pat->fchild, req, fd, NULL, NULL);
600a1ce7	66	} else {
da75c835	67	if((ch = findchild(path, pat->childnm, &ccf)) == NULL) {
600a1ce7 FT	68	flog(LOG_ERR, "child %s requested, but was not declared", pat->childnm);
	69	simpleerror(fd, 500, "Configuration Error", "The server is erroneously configured. Handler %s was requested, but not declared.", pat->childnm);
	70	return;
	71	}
da75c835 FT	72	twd = NULL;
	73	if((twd = ccf->path) != NULL) {
	74	if(!strcmp(twd, ".")) {
	75	twd = NULL;
	76	} else if(strncmp(path, twd, strlen(twd)) \|\| (path[strlen(twd)] != '/')) {
	77	/* Should be an impossible case under the current (and
	78	* foreseeable) scheme. */
	79	simpleerror(fd, 500, "Server Error", "An internal server error occurred.");
	80	return;
	81	} else {
	82	path = path + strlen(twd) + 1;
	83	}
	84	}
	85	headappheader(req, "X-Ash-File", path);
	86	if(childhandle(ch, req, fd, chinit, twd))
600a1ce7 FT	87	simpleerror(fd, 500, "Server Error", "The request handler crashed.");
	88	}
	89	}
	90
	91	static void handlefile(struct hthead req, int fd, char path)
	92	{
	93	struct pattern *pat;
	94
	95	if((pat = findmatch(path, 0, 0)) == NULL) {
	96	simpleerror(fd, 404, "Not Found", "The requested URL has no corresponding resource.");
	97	return;
	98	}
	99	handle(req, fd, path, pat);
	100	}
	101
	102	static char findfile(char path, char name, struct stat sb)
	103	{
	104	DIR *dir;
	105	struct stat sbuf;
	106	struct dirent *dent;
	107	char p, fp, *ret;
	108
	109	if(sb == NULL)
	110	sb = &sbuf;
	111	if((dir = opendir(path)) == NULL)
	112	return(NULL);
	113	ret = NULL;
	114	while((dent = readdir(dir)) != NULL) {
	115	/* Ignore backup files.
	116	* XXX: There is probably a better and more extensible way to
	117	* do this. */
	118	if(dent->d_name[strlen(dent->d_name) - 1] == '~')
	119	continue;
	120	if((p = strchr(dent->d_name, '.')) == NULL)
	121	continue;
	122	if(p - dent->d_name != strlen(name))
	123	continue;
	124	if(strncmp(dent->d_name, name, strlen(name)))
	125	continue;
	126	fp = sprintf3("%s/%s", path, dent->d_name);
	127	if(stat(fp, sb))
	128	continue;
	129	if(!S_ISREG(sb->st_mode))
	130	continue;
	131	ret = sstrdup(fp);
	132	break;
	133	}
	134	closedir(dir);
	135	return(ret);
	136	}
	137
	138	static void handledir(struct hthead req, int fd, char path)
	139	{
	140	struct config **cfs;
	141	int i, o;
	142	struct stat sb;
	143	char inm, ipath, *cpath;
	144	struct pattern *pat;
	145
	146	cpath = sprintf2("%s/", path);
	147	cfs = getconfigs(cpath);
	148	for(i = 0; cfs[i] != NULL; i++) {
	149	if(cfs[i]->index != NULL) {
	150	for(o = 0; cfs[i]->index[o] != NULL; o++) {
151	inm = cfs[i]->index[o];
152	ipath = sprintf2("%s/%s", path, inm);
153	if(!stat(ipath, &sb) && S_ISREG(sb.st_mode)) {
154	handlefile(req, fd, ipath);
155	free(ipath);
156	goto out;
157	}
158	free(ipath);
159
160	if(!strchr(inm, '.') && ((ipath = findfile(path, inm, NULL)) != NULL)) {
161	handlefile(req, fd, ipath);
162	free(ipath);
163	goto out;
164	}
165	}
166	break;
167	}
168	}
169	if((pat = findmatch(cpath, 0, 1)) != NULL) {
170	handle(req, fd, cpath, pat);
171	goto out;
172	}
173	simpleerror(fd, 403, "Not Authorized", "Will not send listings for this directory.");
174
175	out:
176	free(cpath);
177	}
178
179	static int checkpath(struct hthead req, int fd, char path, char *rest);
180
181	static int checkentry(struct hthead req, int fd, char path, char rest, char el)
182	{
183	struct stat sb;
184	char *newpath;
185	int rv;
186
187	if(!el == '.') {
188	simpleerror(fd, 404, "Not Found", "The requested URL has no corresponding resource.");
189	return(1);
190	}
191	if(!stat(sprintf3("%s/%s", path, el), &sb)) {
192	if(S_ISDIR(sb.st_mode)) {
193	if(!*rest) {
194	stdredir(req, fd, 301, sprintf3("%s/", el));
195	return(1);
196	}
197	newpath = sprintf2("%s/%s", path, el);
198	rv = checkpath(req, fd, newpath, rest + 1);
199	free(newpath);
200	return(rv);
201	} else if(S_ISREG(sb.st_mode)) {
202	newpath = sprintf2("%s/%s", path, el);
203	replrest(req, rest);
204	handlefile(req, fd, newpath);
205	free(newpath);
206	return(1);
207	}
208	simpleerror(fd, 404, "Not Found", "The requested URL has no corresponding resource.");
209	return(1);
210	}
211	if(!strchr(el, '.') && ((newpath = findfile(path, el, NULL)) != NULL)) {
212	replrest(req, rest);
213	handlefile(req, fd, newpath);
214	free(newpath);
215	return(1);
216	}
217	return(0);
218	}
219
220	static int checkpath(struct hthead req, int fd, char path, char *rest)
221	{
222	struct config *cf;
223	char p, el;
224	int rv;
225
226	el = NULL;
227	rv = 0;
228
229	if(!strncmp(path, "./", 2))
230	path += 2;
231	cf = getconfig(path);
232
233	if((p = strchr(rest, '/')) == NULL) {
234	el = unquoteurl(rest);
235	rest = "";
236	} else {
237	char buf[p - rest + 1];
238	memcpy(buf, rest, p - rest);
239	buf[p - rest] = 0;
240	el = unquoteurl(buf);
241	rest = p;
242	}
243	if(el == NULL) {
244	simpleerror(fd, 400, "Bad Request", "The requested URL contains an invalid escape sequence.");
245	rv = 1;
246	goto out;
247	}
248	if(strchr(el, '/') \|\| (!el && rest)) {
249	simpleerror(fd, 404, "Not Found", "The requested URL has no corresponding resource.");
250	rv = 1;
251	goto out;
252	}
253	if(!*el) {
254	replrest(req, rest);
255	handledir(req, fd, path);
256	return(1);
257	}
258	rv = checkentry(req, fd, path, rest, el);
259
260	out:
261	if(el != NULL)
262	free(el);
263	return(rv);
264	}
265
266	static void serve(struct hthead *req, int fd)
267	{
268	now = time(NULL);
269	if(!checkpath(req, fd, ".", req->rest))
270	simpleerror(fd, 404, "Not Found", "The requested URL has no corresponding resource.");
271	}
272
273	static void usage(FILE *out)
274	{
275	fprintf(out, "usage: dirplex [-hN] [-c CONFIG] DIR\n");
276	}
277
278	int main(int argc, char **argv)
279	{
280	int c;
281	int nodef;
282	char gcf, lcf, *clcf;
283	struct hthead *req;
284	int fd;
285
286	nodef = 0;
287	lcf = NULL;
288	while((c = getopt(argc, argv, "hNc:")) >= 0) {
289	switch(c) {
290	case 'h':
291	usage(stdout);
292	exit(0);
293	case 'N':
294	nodef = 1;
295	break;
296	case 'c':
297	lcf = optarg;
298	break;
299	default:
300	usage(stderr);
301	exit(1);
302	}
303	}
304	if(argc - optind < 1) {
305	usage(stderr);
306	exit(1);
307	}
308	if(!nodef) {
309	if((gcf = findstdconf("ashd/dirplex.rc")) != NULL) {
310	gconfig = readconfig(gcf);
311	free(gcf);
312	}
313	}
314	if(lcf != NULL) {
315	if(strchr(lcf, '/') == NULL) {
316	if((clcf = findstdconf(sprintf3("ashd/%s", lcf))) == NULL) {
317	flog(LOG_ERR, "could not find requested configuration `%s'", lcf);
318	exit(1);
319	}
320	if((lconfig = readconfig(clcf)) == NULL)
321	exit(1);
322	free(clcf);
323	} else {
324	if((lconfig = readconfig(lcf)) == NULL)
325	exit(1);
326	}
327	}
328	if(chdir(argv[optind])) {
329	flog(LOG_ERR, "could not change directory to %s: %s", argv[optind], strerror(errno));
330	exit(1);
331	}
332	signal(SIGCHLD, SIG_IGN);
333	while(1) {
334	if((fd = recvreq(0, &req)) < 0) {
335	if(errno != 0)
336	flog(LOG_ERR, "recvreq: %s", strerror(errno));
337	break;
338	}
339	serve(req, fd);
340	freehthead(req);
341	close(fd);
342	}
343	return(0);
344	}