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