Slightly more sensible argument parsing for htparser.
[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
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
37 #define CH_SOCKET 0
38 #define CH_FORK 1
39
40 #define PAT_REST 0
41 #define PAT_URL 1
42 #define PAT_METHOD 2
43 #define PAT_HEADER 3
44 #define PAT_ALL 4
45 #define PAT_DEFAULT 5
46
47 #define PATFL_MSS 1
48
49 struct config {
50     struct child *children;
51     struct pattern *patterns;
52 };
53
54 struct child {
55     struct child *next;
56     char *name;
57     int type;
58     char **argv;
59     int fd;
60 };
61
62 struct rule {
63     int type;
64     int fl;
65     char *header;
66     regex_t *pattern;
67 };
68
69 struct pattern {
70     struct pattern *next;
71     char *childnm;
72     struct rule **rules;
73     char *restpat;
74 };
75
76 static struct config *config;
77
78 static void freepattern(struct pattern *pat)
79 {
80     struct rule **rule;
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     if(pat->childnm != NULL)
92         free(pat->childnm);
93     free(pat);
94 }
95
96 static void freechild(struct child *ch)
97 {
98     if(ch->fd != -1)
99         close(ch->fd);
100     if(ch->name != NULL)
101         free(ch->name);
102     if(ch->argv != NULL)
103         freeca(ch->argv);
104     free(ch);
105 }
106
107 static struct child *newchild(char *name, int type)
108 {
109     struct child *ch;
110     
111     omalloc(ch);
112     ch->name = sstrdup(name);
113     ch->type = type;
114     ch->fd = -1;
115     return(ch);
116 }
117
118 static 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
129 static 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
141 static 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
150 static 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
166 static struct config *readconfig(char *filename)
167 {
168     int i;
169     struct config *cf;
170     FILE *s;
171     char line[1024];
172     char *p, **w;
173     int ind, eof;
174     int lno;
175     int state;
176     int rv;
177     int argc;
178     struct child *child;
179     struct pattern *pat;
180     struct rule *rule;
181     regex_t *regex;
182     int rxfl;
183     
184     if((s = fopen(filename, "r")) == NULL)
185         return(NULL);
186     omalloc(cf);
187     eof = 0;
188     state = 0;
189     w = NULL;
190     lno = 0;
191     do {
192         if(fgets(line, sizeof(line), s) == NULL) {
193             eof = 1;
194             line[0] = 0;
195         }
196         lno++;
197         for(p = line; *p; p++) {
198             if(*p == '#')
199                 continue;
200             if(!isspace(*p))
201                 break;
202         }
203         ind = isspace(line[0]);
204         w = tokenize(line);
205         argc = calen(w);
206         
207     retry:
208         if(state == 0) {
209             if(ind) {
210                 flog(LOG_WARNING, "%s%i: unexpected line indentation in global scope", filename, lno);
211                 goto next;
212             } else {
213                 if(!w[0]) {
214                 } else if(!strcmp(w[0], "child")) {
215                     if(argc < 2) {
216                         flog(LOG_WARNING, "%s:%i: missing name in child declaration", filename, lno);
217                         goto next;
218                     }
219                     child = newchild(w[1], CH_SOCKET);
220                     state = 1;
221                 } else if(!strcmp(w[0], "fchild")) {
222                     if(argc < 2) {
223                         flog(LOG_WARNING, "%s:%i: missing name in child declaration", filename, lno);
224                         goto next;
225                     }
226                     child = newchild(w[1], CH_FORK);
227                     state = 1;
228                 } else if(!strcmp(w[0], "match")) {
229                     pat = newpattern();
230                     state = 2;
231                 } else {
232                     flog(LOG_WARNING, "%s:%i: unknown directive %s", filename, lno, w[0]);
233                 }
234             }
235         } else if(state == 1) {
236             if(ind) {
237                 if(!w[0]) {
238                 } else if(!strcmp(w[0], "exec")) {
239                     if(argc < 2) {
240                         flog(LOG_WARNING, "%s:%i: too few parameters to `exec'", filename, lno);
241                         goto next;
242                     }
243                     child->argv = szmalloc(sizeof(*child->argv) * argc);
244                     for(i = 0; i < argc - 1; i++)
245                         child->argv[i] = sstrdup(w[i + 1]);
246                 } else {
247                     flog(LOG_WARNING, "%s:%i: unknown directive %s", filename, lno, w[0]);
248                 }
249             } else {
250                 state = 0;
251                 if(child->argv == NULL) {
252                     flog(LOG_WARNING, "%s:%i: missing `exec' in child declaration %s", filename, lno, child->name);
253                     freechild(child);
254                     goto retry;
255                 }
256                 child->next = cf->children;
257                 cf->children = child;
258                 goto retry;
259             }
260         } else if(state == 2) {
261             if(ind) {
262                 rxfl = 0;
263                 if(!w[0]) {
264                 } else if(!strcmp(w[0], "point") ||
265                           !strcmp(w[0], "url") ||
266                           !strcmp(w[0], "method")) {
267                     if(argc < 2) {
268                         flog(LOG_WARNING, "%s:%i: missing pattern for `%s' match", w[0], filename, lno);
269                         goto next;
270                     }
271                     if(argc >= 3) {
272                         if(strchr(w[2], 'i'))
273                             rxfl |= REG_ICASE;
274                     }
275                     if((regex = regalloc(w[1], rxfl)) == NULL) {
276                         flog(LOG_WARNING, "%s:%i: invalid regex for `%s' match", w[0], filename, lno);
277                         goto next;
278                     }
279                     rule = newrule(pat);
280                     if(!strcmp(w[0], "point"))
281                         rule->type = PAT_REST;
282                     else if(!strcmp(w[0], "url"))
283                         rule->type = PAT_URL;
284                     else if(!strcmp(w[0], "method"))
285                         rule->type = PAT_METHOD;
286                     rule->pattern = regex;
287                     if(argc >= 3) {
288                         if(strchr(w[2], 's'))
289                             rule->fl |= PATFL_MSS;
290                     }
291                 } else if(!strcmp(w[0], "header")) {
292                     if(argc < 3) {
293                         flog(LOG_WARNING, "%s:%i: missing header name or pattern for `header' match", filename, lno);
294                         goto next;
295                     }
296                     if(argc >= 4) {
297                         if(strchr(w[3], 'i'))
298                             rxfl |= REG_ICASE;
299                     }
300                     if((regex = regalloc(w[2], rxfl)) == NULL) {
301                         flog(LOG_WARNING, "%s:%i: invalid regex for `header' match", filename, lno);
302                         goto next;
303                     }
304                     rule = newrule(pat);
305                     rule->type = PAT_HEADER;
306                     rule->header = sstrdup(w[1]);
307                     rule->pattern = regex;
308                     if(argc >= 4) {
309                         if(strchr(w[3], 's'))
310                             rule->fl |= PATFL_MSS;
311                     }
312                 } else if(!strcmp(w[0], "all")) {
313                     newrule(pat)->type = PAT_ALL;
314                 } else if(!strcmp(w[0], "default")) {
315                     newrule(pat)->type = PAT_DEFAULT;
316                 } else if(!strcmp(w[0], "handler")) {
317                     if(argc < 2) {
318                         flog(LOG_WARNING, "%s:%i: missing child name for `handler' directive", filename, lno);
319                         goto next;
320                     }
321                     if(pat->childnm != NULL)
322                         free(pat->childnm);
323                     pat->childnm = sstrdup(w[1]);
324                 } else if(!strcmp(w[0], "restpat")) {
325                     if(argc < 2) {
326                         flog(LOG_WARNING, "%s:%i: missing pattern for `restpat' directive", filename, lno);
327                         goto next;
328                     }
329                     if(pat->restpat != NULL)
330                         free(pat->restpat);
331                     pat->restpat = sstrdup(w[1]);
332                 } else {
333                     flog(LOG_WARNING, "%s:%i: unknown directive %s", filename, lno, w[0]);
334                 }
335             } else {
336                 state = 0;
337                 if(pat->rules[0] == NULL) {
338                     flog(LOG_WARNING, "%s:%i: missing rules in match declaration", filename, lno);
339                     freepattern(pat);
340                     goto retry;
341                 }
342                 if(pat->childnm == NULL) {
343                     flog(LOG_WARNING, "%s:%i: missing handler in match declaration", filename, lno);
344                     freepattern(pat);
345                     goto retry;
346                 }
347                 pat->next = cf->patterns;
348                 cf->patterns = pat;
349                 goto retry;
350             }
351         }
352         
353     next:
354         freeca(w);
355         w = NULL;
356     } while(!eof);
357     rv = 0;
358     
359     if(w != NULL)
360         freeca(w);
361     fclose(s);
362     return(cf);
363 }
364
365 static void exprestpat(struct hthead *req, struct pattern *pat, char **mstr)
366 {
367     char *p, *p2, *hdr;
368     int mc;
369     struct charbuf buf;
370     
371     if(mstr == NULL)
372         mc = 0;
373     else
374         for(mc = 0; mstr[mc]; mc++);
375     bufinit(buf);
376     for(p = pat->restpat; *p; ) {
377         if(*p == '$') {
378             p++;
379             if((*p >= '0') && (*p <= '9')) {
380                 if(*p - '0' < mc)
381                     bufcatstr(buf, mstr[*p - '0']);
382                 p++;
383             } else if(*p == '_') {
384                 bufcatstr(buf, req->rest);
385                 p++;
386             } else if(*p == '$') {
387                 bufadd(buf, '$');
388                 p++;
389             } else if(*p == '{') {
390                 if((p2 = strchr(p, '{')) == NULL) {
391                     p++;
392                 } else {
393                     hdr = getheader(req, sprintf3("$.*s", p2 - p - 1, p + 1));
394                     if(hdr)
395                         bufcatstr(buf, hdr);
396                 }
397             } else if(!*p) {
398             }
399         } else {
400             bufadd(buf, *(p++));
401         }
402     }
403     bufadd(buf, 0);
404     replrest(req, buf.b);
405     buffree(buf);
406 }
407
408 static char *findmatch(struct config *cf, struct hthead *req, int trydefault)
409 {
410     int i, o;
411     struct pattern *pat;
412     struct rule *rule;
413     int rmo, matched;
414     char *pstr;
415     char **mstr;
416     regmatch_t gr[10];
417     
418     mstr = NULL;
419     for(pat = cf->patterns; pat != NULL; pat = pat->next) {
420         rmo = -1;
421         for(i = 0; (rule = pat->rules[i]) != NULL; i++) {
422             matched = 0;
423             if(rule->type == PAT_REST) {
424                 if((matched = !regexec(rule->pattern, pstr = req->rest, 10, gr, 0)))
425                     rmo = gr[0].rm_eo;
426                 else
427                     break;
428             } else if(rule->type == PAT_URL) {
429                 if(!(matched = !regexec(rule->pattern, pstr = req->url, 10, gr, 0)))
430                     break;
431             } else if(rule->type == PAT_METHOD) {
432                 if(!(matched = !regexec(rule->pattern, pstr = req->method, 10, gr, 0)))
433                     break;
434             } else if(rule->type == PAT_HEADER) {
435                 if(!(pstr = getheader(req, rule->header)))
436                     break;
437                 if(!(matched = !regexec(rule->pattern, pstr, 10, gr, 0)))
438                     break;
439             } else if(rule->type == PAT_ALL) {
440             } else if(rule->type == PAT_DEFAULT) {
441                 if(!trydefault)
442                     break;
443             }
444             if(matched && (rule->fl & PATFL_MSS)) {
445                 if(mstr) {
446                     flog(LOG_WARNING, "two pattern rules marked with `s' flag found (for handler %s)", pat->childnm);
447                     freeca(mstr);
448                 }
449                 for(o = 0; o < 10; o++) {
450                     if(gr[o].rm_so < 0)
451                         break;
452                 }
453                 mstr = szmalloc((o + 1) * sizeof(*mstr));
454                 for(o = 0; o < 10; o++) {
455                     if(gr[o].rm_so < 0)
456                         break;
457                     mstr[o] = smalloc(gr[o].rm_eo - gr[o].rm_so + 1);
458                     memcpy(mstr[o], pstr + gr[o].rm_so, gr[o].rm_eo - gr[o].rm_so);
459                     mstr[o][gr[o].rm_eo - gr[o].rm_so] = 0;
460                 }
461             }
462         }
463         if(!rule) {
464             if(pat->restpat) {
465                 exprestpat(req, pat, mstr);
466             } else if(rmo != -1) {
467                 replrest(req, req->rest + rmo);
468             }
469             if(mstr)
470                 freeca(mstr);
471             return(pat->childnm);
472         }
473         if(mstr) {
474             freeca(mstr);
475             mstr = NULL;
476         }
477     }
478     return(NULL);
479 }
480
481 static void forkchild(struct child *ch)
482 {
483     ch->fd = stdmkchild(ch->argv);
484 }
485
486 static void passreq(struct child *ch, struct hthead *req, int fd)
487 {
488     if(ch->fd < 0)
489         forkchild(ch);
490     if(sendreq(ch->fd, req, fd)) {
491         if(errno == EPIPE) {
492             /* Assume that the child has crashed and restart it. */
493             forkchild(ch);
494             if(!sendreq(ch->fd, req, fd))
495                 return;
496         }
497         flog(LOG_ERR, "could not pass on request to child %s: %s", ch->name, strerror(errno));
498         close(ch->fd);
499         ch->fd = -1;
500     }
501 }
502
503 static void serve(struct hthead *req, int fd)
504 {
505     char *chnm;
506     struct child *ch;
507     
508     if(((chnm = findmatch(config, req, 0)) == NULL) && ((chnm = findmatch(config, req, 1)) == NULL)) {
509         simpleerror(fd, 404, "Not Found", "The requested resource could not be found on this server.");
510         return;
511     }
512     if((ch = getchild(config, chnm)) == NULL) {
513         flog(LOG_ERR, "child %s requested, but was not declared", chnm);
514         simpleerror(fd, 500, "Configuration Error", "The server is erroneously configured. Handler %s was requested, but not declared.", chnm);
515         return;
516     }
517     
518     if(ch->type == CH_SOCKET) {
519         passreq(ch, req, fd);
520     } else if(ch->type == CH_FORK) {
521         stdforkserve(ch->argv, req, fd);
522     }
523 }
524
525 int main(int argc, char **argv)
526 {
527     struct hthead *req;
528     int fd;
529
530     if(argc < 2) {
531         flog(LOG_ERR, "usage: patplex CONFIGFILE");
532         exit(1);
533     }
534     config = readconfig(argv[1]);
535     signal(SIGCHLD, SIG_IGN);
536     while(1) {
537         if((fd = recvreq(0, &req)) < 0) {
538             if(errno != 0)
539                 flog(LOG_ERR, "recvreq: %s", strerror(errno));
540             break;
541         }
542         serve(req, fd);
543         freehthead(req);
544         close(fd);
545     }
546     return(0);
547 }