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