call[fs]cgi: Call killcuraddr explicitly instead of as an exit handler.
[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#define PATFL_UNQ 2
48
49struct config {
50 struct child *children;
51 struct pattern *patterns;
52};
53
54struct rule {
55 int type;
56 int fl;
57 char *header;
58 regex_t *pattern;
59};
60
61struct headmod {
62 struct headmod *next;
63 char *name, *value;
64};
65
66struct pattern {
67 struct pattern *next;
68 struct headmod *headers;
69 char *childnm;
70 struct rule **rules;
71 char *restpat;
72};
73
74static struct config *gconfig, *lconfig;
75static volatile int reload = 0;
76
77static void freepattern(struct pattern *pat)
78{
79 struct rule **rule;
80 struct headmod *head;
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 while((head = pat->headers) != NULL) {
92 pat->headers = head->next;
93 free(head->name);
94 free(head->value);
95 free(head);
96 }
97 if(pat->childnm != NULL)
98 free(pat->childnm);
99 free(pat);
100}
101
102static void freeconfig(struct config *cf)
103{
104 struct child *ch, *nch;
105 struct pattern *pat, *npat;
106
107 for(ch = cf->children; ch != NULL; ch = nch) {
108 nch = ch->next;
109 freechild(ch);
110 }
111 for(pat = cf->patterns; pat != NULL; pat = npat) {
112 npat = pat->next;
113 freepattern(pat);
114 }
115 free(cf);
116}
117
118static 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
129static 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
141static 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
150static 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
166static struct pattern *parsepattern(struct cfstate *s)
167{
168 struct pattern *pat;
169 int sl;
170 struct rule *rule;
171 struct headmod *head;
172 regex_t *regex;
173 int rxfl;
174
175 if(!strcmp(s->argv[0], "match")) {
176 s->expstart = 1;
177 pat = newpattern();
178 } else {
179 return(NULL);
180 }
181
182 sl = s->lno;
183 while(1) {
184 getcfline(s);
185 if(!strcmp(s->argv[0], "point") ||
186 !strcmp(s->argv[0], "url") ||
187 !strcmp(s->argv[0], "method")) {
188 if(s->argc < 2) {
189 flog(LOG_WARNING, "%s:%i: missing pattern for `%s' match", s->file, s->lno, s->argv[0]);
190 continue;
191 }
192 rxfl = 0;
193 if(s->argc >= 3) {
194 if(strchr(s->argv[2], 'i'))
195 rxfl |= REG_ICASE;
196 }
197 if((regex = regalloc(s->argv[1], rxfl)) == NULL) {
198 flog(LOG_WARNING, "%s:%i: invalid regex for `%s' match", s->file, s->lno, s->argv[0]);
199 continue;
200 }
201 rule = newrule(pat);
202 if(!strcmp(s->argv[0], "point"))
203 rule->type = PAT_REST;
204 else if(!strcmp(s->argv[0], "url"))
205 rule->type = PAT_URL;
206 else if(!strcmp(s->argv[0], "method"))
207 rule->type = PAT_METHOD;
208 rule->pattern = regex;
209 if(s->argc >= 3) {
210 if(strchr(s->argv[2], 's'))
211 rule->fl |= PATFL_MSS;
212 if(strchr(s->argv[2], 'q'))
213 rule->fl |= PATFL_UNQ;
214 }
215 } else if(!strcmp(s->argv[0], "header")) {
216 if(s->argc < 3) {
217 flog(LOG_WARNING, "%s:%i: missing header name or pattern for `header' match", s->file, s->lno);
218 continue;
219 }
220 rxfl = 0;
221 if(s->argc >= 4) {
222 if(strchr(s->argv[3], 'i'))
223 rxfl |= REG_ICASE;
224 }
225 if((regex = regalloc(s->argv[2], rxfl)) == NULL) {
226 flog(LOG_WARNING, "%s:%i: invalid regex for `header' match", s->file, s->lno);
227 continue;
228 }
229 rule = newrule(pat);
230 rule->type = PAT_HEADER;
231 rule->header = sstrdup(s->argv[1]);
232 rule->pattern = regex;
233 if(s->argc >= 4) {
234 if(strchr(s->argv[3], 's'))
235 rule->fl |= PATFL_MSS;
236 }
237 } else if(!strcmp(s->argv[0], "all")) {
238 newrule(pat)->type = PAT_ALL;
239 } else if(!strcmp(s->argv[0], "default")) {
240 newrule(pat)->type = PAT_DEFAULT;
241 } else if(!strcmp(s->argv[0], "handler")) {
242 if(s->argc < 2) {
243 flog(LOG_WARNING, "%s:%i: missing child name for `handler' directive", s->file, s->lno);
244 continue;
245 }
246 if(pat->childnm != NULL)
247 free(pat->childnm);
248 pat->childnm = sstrdup(s->argv[1]);
249 } else if(!strcmp(s->argv[0], "restpat")) {
250 if(s->argc < 2) {
251 flog(LOG_WARNING, "%s:%i: missing pattern for `restpat' directive", s->file, s->lno);
252 continue;
253 }
254 if(pat->restpat != NULL)
255 free(pat->restpat);
256 pat->restpat = sstrdup(s->argv[1]);
257 } else if(!strcmp(s->argv[0], "set") || !strcmp(s->argv[0], "xset")) {
258 if(s->argc < 3) {
259 flog(LOG_WARNING, "%s:%i: missing header name or pattern for `%s' directive", s->file, s->lno, s->argv[0]);
260 continue;
261 }
262 omalloc(head);
263 if(!strcmp(s->argv[0], "xset"))
264 head->name = sprintf2("X-Ash-%s", s->argv[1]);
265 else
266 head->name = sstrdup(s->argv[1]);
267 head->value = sstrdup(s->argv[2]);
268 head->next = pat->headers;
269 pat->headers = head;
270 } else if(!strcmp(s->argv[0], "end") || !strcmp(s->argv[0], "eof")) {
271 break;
272 } else {
273 flog(LOG_WARNING, "%s:%i: unknown directive `%s' in pattern declaration", s->file, s->lno, s->argv[0]);
274 }
275 }
276
277 if(pat->rules[0] == NULL) {
278 flog(LOG_WARNING, "%s:%i: missing rules in match declaration", s->file, sl);
279 freepattern(pat);
280 return(NULL);
281 }
282 if(pat->childnm == NULL) {
283 flog(LOG_WARNING, "%s:%i: missing handler in match declaration", s->file, sl);
284 freepattern(pat);
285 return(NULL);
286 }
287 return(pat);
288}
289
290static struct config *readconfig(char *filename)
291{
292 struct cfstate *s;
293 struct config *cf;
294 struct child *ch;
295 struct pattern *pat;
296 FILE *in;
297
298 if((in = fopen(filename, "r")) == NULL) {
299 flog(LOG_WARNING, "%s: %s", filename, strerror(errno));
300 return(NULL);
301 }
302 s = mkcfparser(in, filename);
303 omalloc(cf);
304
305 while(1) {
306 getcfline(s);
307 if((ch = parsechild(s)) != NULL) {
308 ch->next = cf->children;
309 cf->children = ch;
310 } else if((pat = parsepattern(s)) != NULL) {
311 pat->next = cf->patterns;
312 cf->patterns = pat;
313 } else if(!strcmp(s->argv[0], "eof")) {
314 break;
315 } else {
316 flog(LOG_WARNING, "%s:%i: unknown directive `%s'", s->file, s->lno, s->argv[0]);
317 }
318 }
319
320 freecfparser(s);
321 fclose(in);
322 return(cf);
323}
324
325static void exprestpat(struct hthead *req, struct pattern *pat, char **mstr)
326{
327 char *p, *p2, *hdr;
328 int mc;
329 struct charbuf buf;
330
331 if(mstr == NULL)
332 mc = 0;
333 else
334 for(mc = 0; mstr[mc]; mc++);
335 bufinit(buf);
336 for(p = pat->restpat; *p; ) {
337 if(*p == '$') {
338 p++;
339 if((*p >= '0') && (*p <= '9')) {
340 if(*p - '0' < mc)
341 bufcatstr(buf, mstr[*p - '0']);
342 p++;
343 } else if(*p == '_') {
344 bufcatstr(buf, req->rest);
345 p++;
346 } else if(*p == '$') {
347 bufadd(buf, '$');
348 p++;
349 } else if(*p == '{') {
350 if((p2 = strchr(p, '}')) == NULL) {
351 p++;
352 } else {
353 hdr = getheader(req, sprintf3("%.*s", p2 - p - 1, p + 1));
354 if(hdr)
355 bufcatstr(buf, hdr);
356 }
357 } else if(!*p) {
358 }
359 } else {
360 bufadd(buf, *(p++));
361 }
362 }
363 bufadd(buf, 0);
364 replrest(req, buf.b);
365 buffree(buf);
366}
367
368static void qoffsets(char *buf, int *obuf, char *pstr, int unquote)
369{
370 int i, o, d1, d2;
371
372 if(unquote) {
373 i = o = 0;
374 while(pstr[i]) {
375 obuf[o] = i;
376 if((pstr[i] == '%') && ((d1 = hexdigit(pstr[i + 1])) >= 0) && ((d2 = hexdigit(pstr[i + 2])) >= 0)) {
377 buf[o] = (d1 << 4) | d2;
378 i += 3;
379 } else {
380 buf[o] = pstr[i];
381 i++;
382 }
383 o++;
384 }
385 buf[o] = 0;
386 } else {
387 for(i = 0; pstr[i]; i++) {
388 buf[i] = pstr[i];
389 obuf[i] = i;
390 }
391 buf[i] = 0;
392 }
393}
394
395static struct pattern *findmatch(struct config *cf, struct hthead *req, int trydefault)
396{
397 int i, o;
398 struct pattern *pat;
399 struct rule *rule;
400 int rmo;
401 regex_t *rx;
402 char *pstr;
403 char **mstr;
404 regmatch_t gr[10];
405
406 mstr = NULL;
407 for(pat = cf->patterns; pat != NULL; pat = pat->next) {
408 rmo = -1;
409 for(i = 0; (rule = pat->rules[i]) != NULL; i++) {
410 rx = NULL;
411 if(rule->type == PAT_REST) {
412 rx = rule->pattern;
413 pstr = req->rest;
414 } else if(rule->type == PAT_URL) {
415 rx = rule->pattern;
416 pstr = req->url;
417 } else if(rule->type == PAT_METHOD) {
418 rx = rule->pattern;
419 pstr = req->method;
420 } else if(rule->type == PAT_HEADER) {
421 rx = rule->pattern;
422 if(!(pstr = getheader(req, rule->header)))
423 break;
424 }
425 if(rx != NULL) {
426 char pbuf[strlen(pstr) + 1];
427 int obuf[strlen(pstr) + 1];
428 qoffsets(pbuf, obuf, pstr, !!(rule->fl & PATFL_UNQ));
429 if(regexec(rx, pbuf, 10, gr, 0))
430 break;
431 else if(rule->type == PAT_REST)
432 rmo = obuf[gr[0].rm_eo];
433 if(rule->fl & PATFL_MSS) {
434 if(mstr) {
435 flog(LOG_WARNING, "two pattern rules marked with `s' flag found (for handler %s)", pat->childnm);
436 freeca(mstr);
437 }
438 for(o = 0; o < 10; o++) {
439 if(gr[o].rm_so < 0)
440 break;
441 }
442 mstr = szmalloc((o + 1) * sizeof(*mstr));
443 for(o = 0; o < 10; o++) {
444 if(gr[o].rm_so < 0)
445 break;
446 mstr[o] = smalloc(obuf[gr[o].rm_eo] - obuf[gr[o].rm_so] + 1);
447 memcpy(mstr[o], pstr + obuf[gr[o].rm_so], obuf[gr[o].rm_eo] - obuf[gr[o].rm_so]);
448 mstr[o][obuf[gr[o].rm_eo] - obuf[gr[o].rm_so]] = 0;
449 }
450 }
451 } else if(rule->type == PAT_ALL) {
452 } else if(rule->type == PAT_DEFAULT) {
453 if(!trydefault)
454 break;
455 }
456 }
457 if(!rule) {
458 if(pat->restpat) {
459 exprestpat(req, pat, mstr);
460 } else if(rmo != -1) {
461 replrest(req, req->rest + rmo);
462 }
463 if(mstr)
464 freeca(mstr);
465 return(pat);
466 }
467 if(mstr) {
468 freeca(mstr);
469 mstr = NULL;
470 }
471 }
472 return(NULL);
473}
474
475static void childerror(struct hthead *req, int fd)
476{
477 if(errno == EAGAIN)
478 simpleerror(fd, 500, "Server Error", "The request handler is overloaded.");
479 else
480 simpleerror(fd, 500, "Server Error", "The request handler crashed.");
481}
482
483static void serve(struct hthead *req, int fd)
484{
485 struct pattern *pat;
486 struct headmod *head;
487 struct child *ch;
488
489 pat = NULL;
490 if(pat == NULL)
491 pat = findmatch(lconfig, req, 0);
492 if(pat == NULL)
493 pat = findmatch(lconfig, req, 1);
494 if(gconfig != NULL) {
495 if(pat == NULL)
496 pat = findmatch(gconfig, req, 0);
497 if(pat == NULL)
498 pat = findmatch(gconfig, req, 1);
499 }
500 if(pat == NULL) {
501 simpleerror(fd, 404, "Not Found", "The requested resource could not be found on this server.");
502 return;
503 }
504 ch = NULL;
505 if(ch == NULL)
506 ch = getchild(lconfig, pat->childnm);
507 if(gconfig != NULL) {
508 if(ch == NULL)
509 ch = getchild(gconfig, pat->childnm);
510 }
511 if(ch == NULL) {
512 flog(LOG_ERR, "child %s requested, but was not declared", pat->childnm);
513 simpleerror(fd, 500, "Configuration Error", "The server is erroneously configured. Handler %s was requested, but not declared.", pat->childnm);
514 return;
515 }
516
517 for(head = pat->headers; head != NULL; head = head->next) {
518 headrmheader(req, head->name);
519 headappheader(req, head->name, head->value);
520 }
521 if(childhandle(ch, req, fd, NULL, NULL))
522 childerror(req, fd);
523}
524
525static void reloadconf(char *nm)
526{
527 struct config *cf;
528
529 if((cf = readconfig(nm)) == NULL) {
530 flog(LOG_WARNING, "could not reload configuration file `%s'", nm);
531 return;
532 }
533 mergechildren(cf->children, lconfig->children);
534 freeconfig(lconfig);
535 lconfig = cf;
536}
537
538static void chldhandler(int sig)
539{
540 pid_t pid;
541 int st;
542
543 while((pid = waitpid(-1, &st, WNOHANG)) > 0) {
544 if(WCOREDUMP(st))
545 flog(LOG_WARNING, "child process %i dumped core", pid);
546 }
547}
548
549static void sighandler(int sig)
550{
551 if(sig == SIGHUP)
552 reload = 1;
553}
554
555static void usage(FILE *out)
556{
557 fprintf(out, "usage: patplex [-hN] CONFIGFILE\n");
558}
559
560int main(int argc, char **argv)
561{
562 int c;
563 int nodef;
564 char *gcf, *lcf;
565 struct hthead *req;
566 int fd;
567
568 nodef = 0;
569 while((c = getopt(argc, argv, "hN")) >= 0) {
570 switch(c) {
571 case 'h':
572 usage(stdout);
573 exit(0);
574 case 'N':
575 nodef = 1;
576 break;
577 default:
578 usage(stderr);
579 exit(1);
580 }
581 }
582 if(argc - optind < 1) {
583 usage(stderr);
584 exit(1);
585 }
586 if(!nodef) {
587 if((gcf = findstdconf("ashd/patplex.rc")) != NULL) {
588 gconfig = readconfig(gcf);
589 free(gcf);
590 }
591 }
592 if((strchr(lcf = argv[optind], '/')) == NULL) {
593 if((lcf = findstdconf(sprintf3("ashd/%s", lcf))) == NULL) {
594 flog(LOG_ERR, "could not find requested configuration file `%s'", argv[optind]);
595 exit(1);
596 }
597 }
598 if((lconfig = readconfig(lcf)) == NULL) {
599 flog(LOG_ERR, "could not read `%s'", lcf);
600 exit(1);
601 }
602 signal(SIGCHLD, chldhandler);
603 signal(SIGHUP, sighandler);
604 signal(SIGPIPE, sighandler);
605 while(1) {
606 if(reload) {
607 reloadconf(lcf);
608 reload = 0;
609 }
610 if((fd = recvreq(0, &req)) < 0) {
611 if(errno == EINTR)
612 continue;
613 if(errno != 0)
614 flog(LOG_ERR, "recvreq: %s", strerror(errno));
615 break;
616 }
617 serve(req, fd);
618 freehthead(req);
619 close(fd);
620 }
621 return(0);
622}