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