[ashd.git] / src / patplex.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 <signal.h>
#include <errno.h>
#include <ctype.h>
#include <regex.h>

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

#define CH_SOCKET 0
#define CH_FORK 1

#define PAT_REST 0
#define PAT_URL 1
#define PAT_METHOD 2
#define PAT_HEADER 3
#define PAT_ALL 4
#define PAT_DEFAULT 5

#define PATFL_MSS 1

struct config {
    struct child *children;
    struct pattern *patterns;
};

struct child {
    struct child *next;
    char *name;
    int type;
    char **argv;
    int fd;
};

struct rule {
    int type;
    int fl;
    char *header;
    regex_t *pattern;
};

struct pattern {
    struct pattern *next;
    char *childnm;
    struct rule **rules;
    char *restpat;
};

static struct config *config;

static void freepattern(struct pattern *pat)
{
    struct rule **rule;
    
    for(rule = pat->rules; *rule; rule++) {
	if((*rule)->header != NULL)
	    free((*rule)->header);
	if((*rule)->pattern != NULL) {
	    regfree((*rule)->pattern);
	    free((*rule)->pattern);
	}
	free(*rule);
    }
    if(pat->childnm != NULL)
	free(pat->childnm);
    free(pat);
}

static void freechild(struct child *ch)
{
    if(ch->fd != -1)
	close(ch->fd);
    if(ch->name != NULL)
	free(ch->name);
    if(ch->argv != NULL)
	freeca(ch->argv);
    free(ch);
}

static struct child *newchild(char *name, int type)
{
    struct child *ch;
    
    omalloc(ch);
    ch->name = sstrdup(name);
    ch->type = type;
    ch->fd = -1;
    return(ch);
}

static struct child *getchild(struct config *cf, char *name)
{
    struct child *ch;
    
    for(ch = cf->children; ch; ch = ch->next) {
	if(!strcmp(ch->name, name))
	    break;
    }
    return(ch);
}

static struct rule *newrule(struct pattern *pat)
{
    int i;
    struct rule *rule;
    
    for(i = 0; pat->rules[i]; i++);
    pat->rules = srealloc(pat->rules, sizeof(*pat->rules) * (i + 2));
    rule = pat->rules[i] = szmalloc(sizeof(*rule));
    pat->rules[i + 1] = NULL;
    return(rule);
}

static struct pattern *newpattern(void)
{
    struct pattern *pat;
    
    omalloc(pat);
    pat->rules = szmalloc(sizeof(*pat->rules));
    return(pat);
}

static regex_t *regalloc(char *regex, int flags)
{
    regex_t *ret;
    int res;
    char errbuf[256];
    
    omalloc(ret);
    if((res = regcomp(ret, regex, flags | REG_EXTENDED)) != 0) {
	regerror(res, ret, errbuf, sizeof(errbuf));
	flog(LOG_WARNING, "%s: %s", regex, errbuf);
	free(ret);
	return(NULL);
    }
    return(ret);
}

static struct config *readconfig(char *filename)
{
    int i;
    struct config *cf;
    FILE *s;
    char line[1024];
    char *p, **w;
    int ind, eof;
    int lno;
    int state;
    int rv;
    int argc;
    struct child *child;
    struct pattern *pat;
    struct rule *rule;
    regex_t *regex;
    int rxfl;
    
    if((s = fopen(filename, "r")) == NULL)
	return(NULL);
    omalloc(cf);
    eof = 0;
    state = 0;
    w = NULL;
    lno = 0;
    do {
	if(fgets(line, sizeof(line), s) == NULL) {
	    eof = 1;
	    line[0] = 0;
	}
	lno++;
	for(p = line; *p; p++) {
	    if(*p == '#')
		continue;
	    if(!isspace(*p))
		break;
	}
	ind = isspace(line[0]);
	w = tokenize(line);
	argc = calen(w);
	
    retry:
	if(state == 0) {
	    if(ind) {
		flog(LOG_WARNING, "%s%i: unexpected line indentation in global scope", filename, lno);
		goto next;
	    } else {
		if(!w[0]) {
		} else if(!strcmp(w[0], "child")) {
		    if(argc < 2) {
			flog(LOG_WARNING, "%s:%i: missing name in child declaration", filename, lno);
			goto next;
		    }
		    child = newchild(w[1], CH_SOCKET);
		    state = 1;
		} else if(!strcmp(w[0], "fchild")) {
		    if(argc < 2) {
			flog(LOG_WARNING, "%s:%i: missing name in child declaration", filename, lno);
			goto next;
		    }
		    child = newchild(w[1], CH_FORK);
		    state = 1;
		} else if(!strcmp(w[0], "match")) {
		    pat = newpattern();
		    state = 2;
		} else {
		    flog(LOG_WARNING, "%s:%i: unknown directive %s", filename, lno, w[0]);
		}
	    }
	} else if(state == 1) {
	    if(ind) {
		if(!w[0]) {
		} else if(!strcmp(w[0], "exec")) {
		    if(argc < 2) {
			flog(LOG_WARNING, "%s:%i: too few parameters to `exec'", filename, lno);
			goto next;
		    }
		    child->argv = szmalloc(sizeof(*child->argv) * argc);
		    for(i = 0; i < argc - 1; i++)
			child->argv[i] = sstrdup(w[i + 1]);
		} else {
		    flog(LOG_WARNING, "%s:%i: unknown directive %s", filename, lno, w[0]);
		}
	    } else {
		state = 0;
		if(child->argv == NULL) {
		    flog(LOG_WARNING, "%s:%i: missing `exec' in child declaration %s", filename, lno, child->name);
		    freechild(child);
		    goto retry;
		}
		child->next = cf->children;
		cf->children = child;
		goto retry;
	    }
	} else if(state == 2) {
	    if(ind) {
		rxfl = 0;
		if(!w[0]) {
		} else if(!strcmp(w[0], "point") ||
			  !strcmp(w[0], "url") ||
			  !strcmp(w[0], "method")) {
		    if(argc < 2) {
			flog(LOG_WARNING, "%s:%i: missing pattern for `%s' match", w[0], filename, lno);
			goto next;
		    }
		    if(argc >= 3) {
			if(strchr(w[2], 'i'))
			    rxfl |= REG_ICASE;
		    }
		    if((regex = regalloc(w[1], rxfl)) == NULL) {
			flog(LOG_WARNING, "%s:%i: invalid regex for `%s' match", w[0], filename, lno);
			goto next;
		    }
		    rule = newrule(pat);
		    if(!strcmp(w[0], "point"))
			rule->type = PAT_REST;
		    else if(!strcmp(w[0], "url"))
			rule->type = PAT_URL;
		    else if(!strcmp(w[0], "method"))
			rule->type = PAT_METHOD;
		    rule->pattern = regex;
		    if(argc >= 3) {
			if(strchr(w[2], 's'))
			    rule->fl |= PATFL_MSS;
		    }
		} else if(!strcmp(w[0], "header")) {
		    if(argc < 3) {
			flog(LOG_WARNING, "%s:%i: missing header name or pattern for `header' match", filename, lno);
			goto next;
		    }
		    if(argc >= 4) {
			if(strchr(w[3], 'i'))
			    rxfl |= REG_ICASE;
		    }
		    if((regex = regalloc(w[2], rxfl)) == NULL) {
			flog(LOG_WARNING, "%s:%i: invalid regex for `header' match", filename, lno);
			goto next;
		    }
		    rule = newrule(pat);
		    rule->type = PAT_HEADER;
		    rule->header = sstrdup(w[1]);
		    rule->pattern = regex;
		    if(argc >= 4) {
			if(strchr(w[3], 's'))
			    rule->fl |= PATFL_MSS;
		    }
		} else if(!strcmp(w[0], "all")) {
		    newrule(pat)->type = PAT_ALL;
		} else if(!strcmp(w[0], "default")) {
		    newrule(pat)->type = PAT_DEFAULT;
		} else if(!strcmp(w[0], "handler")) {
		    if(argc < 2) {
			flog(LOG_WARNING, "%s:%i: missing child name for `handler' directive", filename, lno);
			goto next;
		    }
		    if(pat->childnm != NULL)
			free(pat->childnm);
		    pat->childnm = sstrdup(w[1]);
		} else if(!strcmp(w[0], "restpat")) {
		    if(argc < 2) {
			flog(LOG_WARNING, "%s:%i: missing pattern for `restpat' directive", filename, lno);
			goto next;
		    }
		    if(pat->restpat != NULL)
			free(pat->restpat);
		    pat->restpat = sstrdup(w[1]);
		} else {
		    flog(LOG_WARNING, "%s:%i: unknown directive %s", filename, lno, w[0]);
		}
	    } else {
		state = 0;
		if(pat->rules[0] == NULL) {
		    flog(LOG_WARNING, "%s:%i: missing rules in match declaration", filename, lno);
		    freepattern(pat);
		    goto retry;
		}
		if(pat->childnm == NULL) {
		    flog(LOG_WARNING, "%s:%i: missing handler in match declaration", filename, lno);
		    freepattern(pat);
		    goto retry;
		}
		pat->next = cf->patterns;
		cf->patterns = pat;
		goto retry;
	    }
	}
	
    next:
	freeca(w);
	w = NULL;
    } while(!eof);
    rv = 0;
    
    if(w != NULL)
	freeca(w);
    fclose(s);
    return(cf);
}

static void exprestpat(struct hthead *req, struct pattern *pat, char **mstr)
{
    char *p, *p2, *hdr;
    int mc;
    struct charbuf buf;
    
    if(mstr == NULL)
	mc = 0;
    else
	for(mc = 0; mstr[mc]; mc++);
    bufinit(buf);
    for(p = pat->restpat; *p; ) {
	if(*p == '$') {
	    p++;
	    if((*p >= '0') && (*p <= '9')) {
		if(*p - '0' < mc)
		    bufcatstr(buf, mstr[*p - '0']);
		p++;
	    } else if(*p == '_') {
		bufcatstr(buf, req->rest);
		p++;
	    } else if(*p == '$') {
		bufadd(buf, '$');
		p++;
	    } else if(*p == '{') {
		if((p2 = strchr(p, '{')) == NULL) {
		    p++;
		} else {
		    hdr = getheader(req, sprintf3("$.*s", p2 - p - 1, p + 1));
		    if(hdr)
			bufcatstr(buf, hdr);
		}
	    } else if(!*p) {
	    }
	} else {
	    bufadd(buf, *(p++));
	}
    }
    bufadd(buf, 0);
    replrest(req, buf.b);
    buffree(buf);
}

static char *findmatch(struct config *cf, struct hthead *req, int trydefault)
{
    int i, o;
    struct pattern *pat;
    struct rule *rule;
    int rmo, matched;
    char *pstr;
    char **mstr;
    regmatch_t gr[10];
    
    mstr = NULL;
    for(pat = cf->patterns; pat != NULL; pat = pat->next) {
	rmo = -1;
	for(i = 0; (rule = pat->rules[i]) != NULL; i++) {
	    matched = 0;
	    if(rule->type == PAT_REST) {
		if((matched = !regexec(rule->pattern, pstr = req->rest, 10, gr, 0)))
		    rmo = gr[0].rm_eo;
		else
		    break;
	    } else if(rule->type == PAT_URL) {
		if(!(matched = !regexec(rule->pattern, pstr = req->url, 10, gr, 0)))
		    break;
	    } else if(rule->type == PAT_METHOD) {
		if(!(matched = !regexec(rule->pattern, pstr = req->method, 10, gr, 0)))
		    break;
	    } else if(rule->type == PAT_HEADER) {
		if(!(pstr = getheader(req, rule->header)))
		    break;
		if(!(matched = !regexec(rule->pattern, pstr, 10, gr, 0)))
		    break;
	    } else if(rule->type == PAT_ALL) {
	    } else if(rule->type == PAT_DEFAULT) {
		if(!trydefault)
		    break;
	    }
	    if(matched && (rule->fl & PATFL_MSS)) {
		if(mstr) {
		    flog(LOG_WARNING, "two pattern rules marked with `s' flag found (for handler %s)", pat->childnm);
		    freeca(mstr);
		}
		for(o = 0; o < 10; o++) {
		    if(gr[o].rm_so < 0)
			break;
		}
		mstr = szmalloc((o + 1) * sizeof(*mstr));
		for(o = 0; o < 10; o++) {
		    if(gr[o].rm_so < 0)
			break;
		    mstr[o] = smalloc(gr[o].rm_eo - gr[o].rm_so + 1);
		    memcpy(mstr[o], pstr + gr[o].rm_so, gr[o].rm_eo - gr[o].rm_so);
		    mstr[o][gr[o].rm_eo - gr[o].rm_so] = 0;
		}
	    }
	}
	if(!rule) {
	    if(pat->restpat) {
		exprestpat(req, pat, mstr);
	    } else if(rmo != -1) {
		replrest(req, req->rest + rmo);
	    }
	    if(mstr)
		freeca(mstr);
	    return(pat->childnm);
	}
	if(mstr) {
	    freeca(mstr);
	    mstr = NULL;
	}
    }
    return(NULL);
}

static void forkchild(struct child *ch)
{
    ch->fd = stdmkchild(ch->argv);
}

static void passreq(struct child *ch, struct hthead *req, int fd)
{
    if(ch->fd < 0)
	forkchild(ch);
    if(sendreq(ch->fd, req, fd)) {
	if(errno == EPIPE) {
	    /* Assume that the child has crashed and restart it. */
	    forkchild(ch);
	    if(!sendreq(ch->fd, req, fd))
		return;
	}
	flog(LOG_ERR, "could not pass on request to child %s: %s", ch->name, strerror(errno));
	close(ch->fd);
	ch->fd = -1;
    }
}

static void serve(struct hthead *req, int fd)
{
    char *chnm;
    struct child *ch;
    
    if(((chnm = findmatch(config, req, 0)) == NULL) && ((chnm = findmatch(config, req, 1)) == NULL)) {
	simpleerror(fd, 404, "Not Found", "The requested resource could not be found on this server.");
	return;
    }
    if((ch = getchild(config, chnm)) == NULL) {
	flog(LOG_ERR, "child %s requested, but was not declared", chnm);
	simpleerror(fd, 500, "Configuration Error", "The server is erroneously configured. Handler %s was requested, but not declared.", chnm);
	return;
    }
    
    if(ch->type == CH_SOCKET) {
	passreq(ch, req, fd);
    } else if(ch->type == CH_FORK) {
	stdforkserve(ch->argv, req, fd);
    }
}

int main(int argc, char **argv)
{
    struct hthead *req;
    int fd;

    if(argc < 2) {
	flog(LOG_ERR, "usage: patplex CONFIGFILE");
	exit(1);
    }
    config = readconfig(argv[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
326e08fc 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 <signal.h>
	24	#include <errno.h>
	25	#include <ctype.h>
	26	#include <regex.h>
	27
	28	#ifdef HAVE_CONFIG_H
	29	#include <config.h>
	30	#endif
	31	#include <utils.h>
	32	#include <log.h>
	33	#include <req.h>
	34	#include <proc.h>
	35	#include <resp.h>
	36
	37	#define CH_SOCKET 0
	38	#define CH_FORK 1
	39
	40	#define PAT_REST 0
	41	#define PAT_URL 1
	42	#define PAT_METHOD 2
	43	#define PAT_HEADER 3
	44	#define PAT_ALL 4
	45	#define PAT_DEFAULT 5
	46
	47	#define PATFL_MSS 1
	48
	49	struct config {
	50	struct child *children;
	51	struct pattern *patterns;
	52	};
	53
	54	struct child {
	55	struct child *next;
	56	char *name;
	57	int type;
	58	char **argv;
	59	int fd;
	60	};
	61
	62	struct rule {
	63	int type;
	64	int fl;
65	char *header;
66	regex_t *pattern;
67	};
68
69	struct pattern {
70	struct pattern *next;
71	char *childnm;
72	struct rule **rules;
73	char *restpat;
74	};
75
76	static struct config *config;
77
78	static void freepattern(struct pattern *pat)
79	{
80	struct rule **rule;
81
82	for(rule = pat->rules; *rule; rule++) {
83	if((*rule)->header != NULL)
84	free((*rule)->header);
85	if((*rule)->pattern != NULL) {
86	regfree((*rule)->pattern);
87	free((*rule)->pattern);
88	}
89	free(*rule);
90	}
91	if(pat->childnm != NULL)
92	free(pat->childnm);
93	free(pat);
94	}
95
96	static void freechild(struct child *ch)
97	{
98	if(ch->fd != -1)
99	close(ch->fd);
100	if(ch->name != NULL)
101	free(ch->name);
102	if(ch->argv != NULL)
103	freeca(ch->argv);
104	free(ch);
105	}
106
107	static struct child newchild(char name, int type)
108	{
109	struct child *ch;
110
111	omalloc(ch);
112	ch->name = sstrdup(name);
113	ch->type = type;
114	ch->fd = -1;
115	return(ch);
116	}
117
118	static struct child getchild(struct config cf, char *name)
119	{
120	struct child *ch;
121
122	for(ch = cf->children; ch; ch = ch->next) {
123	if(!strcmp(ch->name, name))
124	break;
125	}
126	return(ch);
127	}
128
129	static struct rule newrule(struct pattern pat)
130	{
131	int i;
132	struct rule *rule;
133
134	for(i = 0; pat->rules[i]; i++);
135	pat->rules = srealloc(pat->rules, sizeof(pat->rules) (i + 2));
136	rule = pat->rules[i] = szmalloc(sizeof(*rule));
137	pat->rules[i + 1] = NULL;
138	return(rule);
139	}
140
141	static struct pattern *newpattern(void)
142	{
143	struct pattern *pat;
144
145	omalloc(pat);
146	pat->rules = szmalloc(sizeof(*pat->rules));
147	return(pat);
148	}
149
150	static regex_t regalloc(char regex, int flags)
151	{
152	regex_t *ret;
153	int res;
154	char errbuf[256];
155
156	omalloc(ret);
157	if((res = regcomp(ret, regex, flags \| REG_EXTENDED)) != 0) {
158	regerror(res, ret, errbuf, sizeof(errbuf));
159	flog(LOG_WARNING, "%s: %s", regex, errbuf);
160	free(ret);
161	return(NULL);
162	}
163	return(ret);
164	}
165
166	static struct config readconfig(char filename)
167	{
168	int i;
169	struct config *cf;
170	FILE *s;
171	char line[1024];
172	char p, *w;
173	int ind, eof;
174	int lno;
175	int state;
176	int rv;
177	int argc;
178	struct child *child;
179	struct pattern *pat;
180	struct rule *rule;
181	regex_t *regex;
182	int rxfl;
183
184	if((s = fopen(filename, "r")) == NULL)
185	return(NULL);
186	omalloc(cf);
187	eof = 0;
188	state = 0;
189	w = NULL;
190	lno = 0;
191	do {
192	if(fgets(line, sizeof(line), s) == NULL) {
193	eof = 1;
194	line[0] = 0;
195	}
196	lno++;
197	for(p = line; *p; p++) {
198	if(*p == '#')
199	continue;
200	if(!isspace(*p))
201	break;
202	}
203	ind = isspace(line[0]);
204	w = tokenize(line);
205	argc = calen(w);
206
207	retry:
208	if(state == 0) {
209	if(ind) {
210	flog(LOG_WARNING, "%s%i: unexpected line indentation in global scope", filename, lno);
211	goto next;
212	} else {
213	if(!w[0]) {
214	} else if(!strcmp(w[0], "child")) {
215	if(argc < 2) {
216	flog(LOG_WARNING, "%s:%i: missing name in child declaration", filename, lno);
217	goto next;
218	}
219	child = newchild(w[1], CH_SOCKET);
220	state = 1;
221	} else if(!strcmp(w[0], "fchild")) {
222	if(argc < 2) {
223	flog(LOG_WARNING, "%s:%i: missing name in child declaration", filename, lno);
224	goto next;
225	}
226	child = newchild(w[1], CH_FORK);
227	state = 1;
228	} else if(!strcmp(w[0], "match")) {
229	pat = newpattern();
230	state = 2;
231	} else {
232	flog(LOG_WARNING, "%s:%i: unknown directive %s", filename, lno, w[0]);
233	}
234	}
235	} else if(state == 1) {
236	if(ind) {
237	if(!w[0]) {
238	} else if(!strcmp(w[0], "exec")) {
239	if(argc < 2) {
240	flog(LOG_WARNING, "%s:%i: too few parameters to `exec'", filename, lno);
241	goto next;
242	}
243	child->argv = szmalloc(sizeof(child->argv) argc);
244	for(i = 0; i < argc - 1; i++)
245	child->argv[i] = sstrdup(w[i + 1]);
246	} else {
247	flog(LOG_WARNING, "%s:%i: unknown directive %s", filename, lno, w[0]);
248	}
249	} else {
250	state = 0;
251	if(child->argv == NULL) {
252	flog(LOG_WARNING, "%s:%i: missing `exec' in child declaration %s", filename, lno, child->name);
253	freechild(child);
254	goto retry;
255	}
256	child->next = cf->children;
257	cf->children = child;
258	goto retry;
259	}
260	} else if(state == 2) {
261	if(ind) {
262	rxfl = 0;
263	if(!w[0]) {
264	} else if(!strcmp(w[0], "point") \|\|
265	!strcmp(w[0], "url") \|\|
266	!strcmp(w[0], "method")) {
267	if(argc < 2) {
268	flog(LOG_WARNING, "%s:%i: missing pattern for `%s' match", w[0], filename, lno);
269	goto next;
270	}
271	if(argc >= 3) {
272	if(strchr(w[2], 'i'))
273	rxfl \|= REG_ICASE;
274	}
275	if((regex = regalloc(w[1], rxfl)) == NULL) {
276	flog(LOG_WARNING, "%s:%i: invalid regex for `%s' match", w[0], filename, lno);
277	goto next;
278	}
279	rule = newrule(pat);
280	if(!strcmp(w[0], "point"))
281	rule->type = PAT_REST;
282	else if(!strcmp(w[0], "url"))
283	rule->type = PAT_URL;
284	else if(!strcmp(w[0], "method"))
285	rule->type = PAT_METHOD;
286	rule->pattern = regex;
287	if(argc >= 3) {
288	if(strchr(w[2], 's'))
289	rule->fl \|= PATFL_MSS;
290	}
291	} else if(!strcmp(w[0], "header")) {
292	if(argc < 3) {
293	flog(LOG_WARNING, "%s:%i: missing header name or pattern for `header' match", filename, lno);
294	goto next;
295	}
296	if(argc >= 4) {
297	if(strchr(w[3], 'i'))
298	rxfl \|= REG_ICASE;
299	}
300	if((regex = regalloc(w[2], rxfl)) == NULL) {
301	flog(LOG_WARNING, "%s:%i: invalid regex for `header' match", filename, lno);
302	goto next;
303	}
304	rule = newrule(pat);
305	rule->type = PAT_HEADER;
306	rule->header = sstrdup(w[1]);
307	rule->pattern = regex;
308	if(argc >= 4) {
309	if(strchr(w[3], 's'))
310	rule->fl \|= PATFL_MSS;
311	}
312	} else if(!strcmp(w[0], "all")) {
313	newrule(pat)->type = PAT_ALL;
314	} else if(!strcmp(w[0], "default")) {
315	newrule(pat)->type = PAT_DEFAULT;
316	} else if(!strcmp(w[0], "handler")) {
317	if(argc < 2) {
318	flog(LOG_WARNING, "%s:%i: missing child name for `handler' directive", filename, lno);
319	goto next;
320	}
321	if(pat->childnm != NULL)
322	free(pat->childnm);
323	pat->childnm = sstrdup(w[1]);
324	} else if(!strcmp(w[0], "restpat")) {
325	if(argc < 2) {
326	flog(LOG_WARNING, "%s:%i: missing pattern for `restpat' directive", filename, lno);
327	goto next;
328	}
329	if(pat->restpat != NULL)
330	free(pat->restpat);
331	pat->restpat = sstrdup(w[1]);
332	} else {
333	flog(LOG_WARNING, "%s:%i: unknown directive %s", filename, lno, w[0]);
334	}
335	} else {
336	state = 0;
337	if(pat->rules[0] == NULL) {
338	flog(LOG_WARNING, "%s:%i: missing rules in match declaration", filename, lno);
339	freepattern(pat);
340	goto retry;
341	}
342	if(pat->childnm == NULL) {
343	flog(LOG_WARNING, "%s:%i: missing handler in match declaration", filename, lno);
344	freepattern(pat);
345	goto retry;
346	}
347	pat->next = cf->patterns;
348	cf->patterns = pat;
349	goto retry;
350	}
351	}
352
353	next:
354	freeca(w);
355	w = NULL;
356	} while(!eof);
357	rv = 0;
358
359	if(w != NULL)
360	freeca(w);
361	fclose(s);
362	return(cf);
363	}
364
365	static void exprestpat(struct hthead req, struct pattern pat, char **mstr)
366	{
367	char p, p2, *hdr;
368	int mc;
369	struct charbuf buf;
370
371	if(mstr == NULL)
372	mc = 0;
373	else
374	for(mc = 0; mstr[mc]; mc++);
375	bufinit(buf);
376	for(p = pat->restpat; *p; ) {
377	if(*p == '$') {
378	p++;
379	if((p >= '0') && (p <= '9')) {
380	if(*p - '0' < mc)
381	bufcatstr(buf, mstr[*p - '0']);
382	p++;
383	} else if(*p == '_') {
384	bufcatstr(buf, req->rest);
385	p++;
386	} else if(*p == '$') {
387	bufadd(buf, '$');
388	p++;
389	} else if(*p == '{') {
390	if((p2 = strchr(p, '{')) == NULL) {
391	p++;
392	} else {
393	hdr = getheader(req, sprintf3("$.*s", p2 - p - 1, p + 1));
394	if(hdr)
395	bufcatstr(buf, hdr);
396	}
397	} else if(!*p) {
398	}
399	} else {
400	bufadd(buf, *(p++));
401	}
402	}
403	bufadd(buf, 0);
404	replrest(req, buf.b);
405	buffree(buf);
406	}
407
408	static char findmatch(struct config cf, struct hthead *req, int trydefault)
409	{
410	int i, o;
411	struct pattern *pat;
412	struct rule *rule;
413	int rmo, matched;
414	char *pstr;
415	char **mstr;
416	regmatch_t gr[10];
417
418	mstr = NULL;
419	for(pat = cf->patterns; pat != NULL; pat = pat->next) {
420	rmo = -1;
421	for(i = 0; (rule = pat->rules[i]) != NULL; i++) {
422	matched = 0;
423	if(rule->type == PAT_REST) {
424	if((matched = !regexec(rule->pattern, pstr = req->rest, 10, gr, 0)))
425	rmo = gr[0].rm_eo;
426	else
427	break;
428	} else if(rule->type == PAT_URL) {
429	if(!(matched = !regexec(rule->pattern, pstr = req->url, 10, gr, 0)))
430	break;
431	} else if(rule->type == PAT_METHOD) {
432	if(!(matched = !regexec(rule->pattern, pstr = req->method, 10, gr, 0)))
433	break;
434	} else if(rule->type == PAT_HEADER) {
435	if(!(pstr = getheader(req, rule->header)))
436	break;
437	if(!(matched = !regexec(rule->pattern, pstr, 10, gr, 0)))
438	break;
439	} else if(rule->type == PAT_ALL) {
440	} else if(rule->type == PAT_DEFAULT) {
441	if(!trydefault)
442	break;
443	}
444	if(matched && (rule->fl & PATFL_MSS)) {
445	if(mstr) {
446	flog(LOG_WARNING, "two pattern rules marked with `s' flag found (for handler %s)", pat->childnm);
447	freeca(mstr);
448	}
449	for(o = 0; o < 10; o++) {
450	if(gr[o].rm_so < 0)
451	break;
452	}
453	mstr = szmalloc((o + 1) * sizeof(*mstr));
454	for(o = 0; o < 10; o++) {
455	if(gr[o].rm_so < 0)
456	break;
457	mstr[o] = smalloc(gr[o].rm_eo - gr[o].rm_so + 1);
458	memcpy(mstr[o], pstr + gr[o].rm_so, gr[o].rm_eo - gr[o].rm_so);
459	mstr[o][gr[o].rm_eo - gr[o].rm_so] = 0;
460	}
461	}
462	}
463	if(!rule) {
464	if(pat->restpat) {
465	exprestpat(req, pat, mstr);
466	} else if(rmo != -1) {
467	replrest(req, req->rest + rmo);
468	}
469	if(mstr)
470	freeca(mstr);
471	return(pat->childnm);
472	}
473	if(mstr) {
474	freeca(mstr);
475	mstr = NULL;
476	}
477	}
478	return(NULL);
479	}
480
481	static void forkchild(struct child *ch)
482	{
483	ch->fd = stdmkchild(ch->argv);
484	}
485
486	static void passreq(struct child ch, struct hthead req, int fd)
487	{
488	if(ch->fd < 0)
489	forkchild(ch);
490	if(sendreq(ch->fd, req, fd)) {
491	if(errno == EPIPE) {
492	/* Assume that the child has crashed and restart it. */
493	forkchild(ch);
494	if(!sendreq(ch->fd, req, fd))
495	return;
496	}
497	flog(LOG_ERR, "could not pass on request to child %s: %s", ch->name, strerror(errno));
498	close(ch->fd);
499	ch->fd = -1;
500	}
501	}
502
503	static void serve(struct hthead *req, int fd)
504	{
505	char *chnm;
506	struct child *ch;
507
508	if(((chnm = findmatch(config, req, 0)) == NULL) && ((chnm = findmatch(config, req, 1)) == NULL)) {
509	simpleerror(fd, 404, "Not Found", "The requested resource could not be found on this server.");
510	return;
511	}
512	if((ch = getchild(config, chnm)) == NULL) {
513	flog(LOG_ERR, "child %s requested, but was not declared", chnm);
514	simpleerror(fd, 500, "Configuration Error", "The server is erroneously configured. Handler %s was requested, but not declared.", chnm);
515	return;
516	}
517
518	if(ch->type == CH_SOCKET) {
519	passreq(ch, req, fd);
520	} else if(ch->type == CH_FORK) {
521	stdforkserve(ch->argv, req, fd);
522	}
523	}
524
525	int main(int argc, char **argv)
526	{
527	struct hthead *req;
528	int fd;
529
530	if(argc < 2) {
531	flog(LOG_ERR, "usage: patplex CONFIGFILE");
532	exit(1);
533	}
534	config = readconfig(argv[1]);
535	signal(SIGCHLD, SIG_IGN);
536	while(1) {
537	if((fd = recvreq(0, &req)) < 0) {
538	if(errno != 0)
539	flog(LOG_ERR, "recvreq: %s", strerror(errno));
540	break;
541	}
542	serve(req, fd);
543	freehthead(req);
544	close(fd);
545	}
546	return(0);
547	}