examples: Added some commentary.
[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 pattern {
61     struct pattern *next;
62     char *childnm;
63     struct rule **rules;
64     char *restpat;
65 };
66
67 static struct config *gconfig, *lconfig;
68 static volatile int reload = 0;
69
70 static 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
88 static 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
104 static 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
115 static 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
127 static 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
136 static 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
152 static 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
258 static 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
293 static 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
336 static 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
409 static 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
446 static 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
459 static void chldhandler(int sig)
460 {
461     pid_t pid;
462     
463     do {
464         pid = waitpid(-1, NULL, WNOHANG);
465     } while(pid > 0);
466 }
467
468 static void sighandler(int sig)
469 {
470     if(sig == SIGHUP)
471         reload = 1;
472 }
473
474 static void usage(FILE *out)
475 {
476     fprintf(out, "usage: patplex [-hN] CONFIGFILE\n");
477 }
478
479 int 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 }