python: Removed threadpool handler again.
[ashd.git] / lib / cf.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 <unistd.h>
22 #include <string.h>
23 #include <ctype.h>
24 #include <glob.h>
25 #include <libgen.h>
26 #include <sys/socket.h>
27 #include <errno.h>
28
29 #ifdef HAVE_CONFIG_H
30 #include <config.h>
31 #endif
32 #include <utils.h>
33 #include <cf.h>
34 #include <mt.h>
35 #include <proc.h>
36 #include <log.h>
37
38 #define CH_SOCKET 0
39 #define CH_FORK 1
40
41 struct stdchild {
42     int type;
43     char **argv;
44     char **envp;
45     int fd;
46 };
47
48 static int parsefile(struct cfstate *s, FILE *in);
49 static void stdmerge(struct child *old, struct child *new);
50 static int stdhandle(struct child *ch, struct hthead *req, int fd, void (*chinit)(void *), void *idata);
51 static void stddestroy(struct child *ch);
52
53 static int doinclude(struct cfstate *s, char *spec)
54 {
55     int rv, i;
56     FILE *inc;
57     glob_t globm;
58     char *fbk, *dir, *fspec;
59
60     rv = 0;
61     fbk = s->file;
62     if(spec[0] == '/') {
63         fspec = spec;
64     } else {
65         dir = sstrdup(fbk);
66         fspec = sprintf3("%s/%s", dirname(dir), spec);
67         free(dir);
68     }
69     if(glob(fspec, 0, NULL, &globm))
70         return(0);
71     for(i = 0; i < globm.gl_pathc; i++) {
72         if((inc = fopen(globm.gl_pathv[i], "r")) != NULL) {
73             s->file = globm.gl_pathv[i];
74             if(parsefile(s, inc)) {
75                 fclose(inc);
76                 rv = 1;
77                 goto out;
78             }
79             fclose(inc);
80             inc = NULL;
81         }
82     }
83     
84 out:
85     globfree(&globm);
86     s->file = fbk;
87     return(rv);
88 }
89
90 static int parsefile(struct cfstate *s, FILE *in)
91 {
92     int i;
93     char line[1024];
94     int eof, argc;
95     int ind, indst[80], indl;
96     char *p, **w;
97     
98     s->lno = 0;
99     indst[indl = 0] = 0;
100     eof = 0;
101     while(1) {
102         if(fgets(line, sizeof(line), in) == NULL) {
103             eof = 1;
104             line[0] = 0;
105         }
106         s->lno++;
107         if(line[0]) {
108             for(p = line + strlen(line) - 1; p >= line; p--) {
109                 if(isspace(*p))
110                     *p = 0;
111                 else
112                     break;
113             }
114         }
115         for(ind = 0, p = line; *p; p++) {
116             if(*p == ' ') {
117                 ind++;
118             } else if(*p == '\t') {
119                 ind = ind - (ind % 8) + 8;
120             } else {
121                 break;
122             }
123         }
124         if(!eof && (!*p || (*p == '#')))
125             continue;
126         
127     reindent:
128         if(ind > indst[indl]) {
129             indst[++indl] = ind;
130             if(!s->expstart) {
131                 s->res = tokenize("start");
132                 if(yield())
133                     return(1);
134             } else {
135                 s->expstart = 0;
136             }
137         } else {
138             if(s->expstart) {
139                 s->res = tokenize("end");
140                 if(yield())
141                     return(1);
142                 s->expstart = 0;
143             }
144             while(ind < indst[indl]) {
145                 indl--;
146                 s->res = tokenize("end");
147                 if(yield())
148                     return(1);
149             }
150             if(ind > indst[indl]) {
151                 flog(LOG_WARNING, "%s:%i: unexpected indentation level", s->file, s->lno);
152                 goto reindent;
153             }
154         }
155         
156         if(eof)
157             return(0);
158         
159         argc = calen(w = tokenize(line));
160         if(argc < 1) {
161             /* Shouldn't happen, but... */
162             freeca(w);
163             continue;
164         }
165         
166         if(indl == 0) {
167             if(!strcmp(w[0], "include")) {
168                 for(i = 1; i < argc; i++) {
169                     if(doinclude(s, w[i])) {
170                         freeca(w);
171                         return(1);
172                     }
173                 }
174                 freeca(w);
175                 continue;
176             }
177         }
178         
179         if(!strcmp(w[0], "start") ||
180            !strcmp(w[0], "end") || 
181            !strcmp(w[0], "eof")) {
182             flog(LOG_WARNING, "%s:%i: illegal directive: %s", s->file, s->lno, w[0]);
183         } else {
184             s->res = w;
185             if(yield())
186                 return(1);
187         }
188     }
189 }
190
191 static void parsefn(struct muth *mt, va_list args)
192 {
193     vavar(struct cfstate *, s);
194     vavar(FILE *, in);
195     vavar(char *, file);
196     
197     s->file = sstrdup(file);
198     if(parsefile(s, in))
199         goto out;
200     do {
201         s->res = tokenize("eof");
202     } while(!yield());
203     
204 out:
205     free(s->file);
206 }
207
208 char **getcfline(struct cfstate *s)
209 {
210     freeca(s->argv);
211     if(s->res == NULL)
212         resume(s->pf, 0);
213     s->argc = calen(s->argv = s->res);
214     s->res = NULL;
215     return(s->argv);
216 }
217
218 struct cfstate *mkcfparser(FILE *in, char *name)
219 {
220     struct cfstate *s;
221     
222     omalloc(s);
223     s->pf = mustart(parsefn, s, in, name);
224     return(s);
225 }
226
227 void freecfparser(struct cfstate *s)
228 {
229     resume(s->pf, -1);
230     freeca(s->argv);
231     freeca(s->res);
232     free(s);
233 }
234
235 char *findstdconf(char *name)
236 {
237     char *home, *path, *p, *p2, *t;
238     
239     if((home = getenv("HOME")) != NULL) {
240         if(!access(t = sprintf2("%s/.ashd/etc/%s", home, name), R_OK))
241             return(t);
242         free(t);
243     }
244     if((path = getenv("PATH")) != NULL) {
245         path = sstrdup(path);
246         for(p = strtok(path, ":"); p != NULL; p = strtok(NULL, ":")) {
247             if((p2 = strrchr(p, '/')) == NULL)
248                 continue;
249             *p2 = 0;
250             if(!access(t = sprintf2("%s/etc/%s", p, name), R_OK)) {
251                 free(path);
252                 return(t);
253             }
254             free(t);
255         }
256         free(path);
257     }
258     return(NULL);
259 }
260
261 struct child *newchild(char *name, struct chandler *iface, void *pdata)
262 {
263     struct child *ch;
264     
265     omalloc(ch);
266     ch->name = sstrdup(name);
267     ch->iface = iface;
268     ch->pdata = pdata;
269     return(ch);
270 }
271
272 void freechild(struct child *ch)
273 {
274     if(ch->iface->destroy != NULL)
275         ch->iface->destroy(ch);
276     if(ch->name != NULL)
277         free(ch->name);
278     free(ch);
279 }
280
281 void mergechildren(struct child *dst, struct child *src)
282 {
283     struct child *ch1, *ch2;
284     
285     for(ch1 = dst; ch1 != NULL; ch1 = ch1->next) {
286         for(ch2 = src; ch2 != NULL; ch2 = ch2->next) {
287             if(ch1->iface->merge && !strcmp(ch1->name, ch2->name)) {
288                 ch1->iface->merge(ch1, ch2);
289                 break;
290             }
291         }
292     }
293 }
294
295 void skipcfblock(struct cfstate *s)
296 {
297     char **w;
298     
299     while(1) {
300         w = getcfline(s);
301         if(!strcmp(w[0], "end") || !strcmp(w[0], "eof"))
302             return;
303     }
304 }
305
306 static struct chandler stdhandler = {
307     .handle = stdhandle,
308     .merge = stdmerge,
309     .destroy = stddestroy,
310 };
311
312 static char **expandargs(struct stdchild *sd)
313 {
314     int i;
315     char **ret, *p, *p2, *p3, *np, *env;
316     struct charbuf exp;
317     
318     ret = szmalloc(sizeof(*ret) * (calen(sd->argv) + 1));
319     bufinit(exp);
320     for(i = 0; sd->argv[i] != NULL; i++) {
321         if((p = strchr(sd->argv[i], '$')) == NULL) {
322             ret[i] = sstrdup(sd->argv[i]);
323         } else {
324             exp.d = 0;
325             for(p2 = sd->argv[i]; p != NULL; p2 = np, p = strchr(np, '$')) {
326                 bufcat(exp, p2, p - p2);
327                 if(p[1] == '{') {
328                     if((p3 = strchr((p += 2), '}')) == NULL)
329                         break;
330                     np = p3 + 1;
331                 } else {
332                     for(p3 = ++p; *p3; p3++) {
333                         if(!(((*p3 >= 'a') && (*p3 <= 'z')) ||
334                              ((*p3 >= 'A') && (*p3 <= 'Z')) ||
335                              ((*p3 >= '0') && (*p3 <= '9')) ||
336                              (*p3 == '_'))) {
337                             break;
338                         }
339                     }
340                     np = p3;
341                 }
342                 char temp[(p3 - p) + 1];
343                 memcpy(temp, p, p3 - p);
344                 temp[p3 - p] = 0;
345                 if((env = getenv(temp)) != NULL)
346                     bufcatstr(exp, env);
347             }
348             bufcatstr2(exp, np);
349             ret[i] = sstrdup(exp.b);
350         }
351     }
352     ret[i] = NULL;
353     buffree(exp);
354     return(ret);
355 }
356
357 static int stdhandle(struct child *ch, struct hthead *req, int fd, void (*chinit)(void *), void *idata)
358 {
359     struct stdchild *sd = ch->pdata;
360     int serr;
361     char **args;
362     
363     void stdinit(void *data)
364     {
365         int i;
366         
367         for(i = 0; sd->envp[i]; i += 2)
368             putenv(sprintf2("%s=%s", sd->envp[i], sd->envp[i + 1]));
369         if(chinit != NULL)
370             chinit(data);
371     }
372     
373     if(sd->type == CH_SOCKET) {
374         if(sd->fd < 0) {
375             args = expandargs(sd);
376             sd->fd = stdmkchild(args, stdinit, idata);
377             freeca(args);
378         }
379         if(sendreq2(sd->fd, req, fd, MSG_NOSIGNAL | MSG_DONTWAIT)) {
380             serr = errno;
381             if((serr == EPIPE) || (serr == ECONNRESET)) {
382                 /* Assume that the child has crashed and restart it. */
383                 close(sd->fd);
384                 args = expandargs(sd);
385                 sd->fd = stdmkchild(args, stdinit, idata);
386                 freeca(args);
387                 if(!sendreq2(sd->fd, req, fd, MSG_NOSIGNAL | MSG_DONTWAIT))
388                     return(0);
389             }
390             flog(LOG_ERR, "could not pass on request to child %s: %s", ch->name, strerror(serr));
391             if(serr != EAGAIN) {
392                 close(sd->fd);
393                 sd->fd = -1;
394             }
395             return(-1);
396         }
397     } else if(sd->type == CH_FORK) {
398         args = expandargs(sd);
399         if(stdforkserve(args, req, fd, chinit, idata) < 0) {
400             freeca(args);
401             return(-1);
402         }
403         freeca(args);
404     }
405     return(0);
406 }
407
408 static void stdmerge(struct child *dst, struct child *src)
409 {
410     struct stdchild *od, *nd;
411     
412     if(src->iface == &stdhandler) {
413         nd = dst->pdata;
414         od = src->pdata;
415         nd->fd = od->fd;
416         od->fd = -1;
417     }
418 }
419
420 static void stddestroy(struct child *ch)
421 {
422     struct stdchild *d = ch->pdata;
423     
424     if(d->fd >= 0)
425         close(d->fd);
426     if(d->argv)
427         freeca(d->argv);
428     if(d->envp)
429         freeca(d->envp);
430     free(d);
431 }
432
433 struct child *parsechild(struct cfstate *s)
434 {
435     struct child *ch;
436     struct stdchild *d;
437     struct charvbuf envbuf;
438     int i;
439     int sl;
440     
441     sl = s->lno;
442     if(!strcmp(s->argv[0], "child")) {
443         s->expstart = 1;
444         if(s->argc < 2) {
445             flog(LOG_WARNING, "%s:%i: missing name in child declaration", s->file, s->lno);
446             skipcfblock(s);
447             return(NULL);
448         }
449         ch = newchild(s->argv[1], &stdhandler, omalloc(d));
450         d->type = CH_SOCKET;
451     } else if(!strcmp(s->argv[0], "fchild")) {
452         s->expstart = 1;
453         if(s->argc < 2) {
454             flog(LOG_WARNING, "%s:%i: missing name in child declaration", s->file, s->lno);
455             skipcfblock(s);
456             return(NULL);
457         }
458         ch = newchild(s->argv[1], &stdhandler, omalloc(d));
459         d->type = CH_FORK;
460     } else {
461         return(NULL);
462     }
463     d->fd = -1;
464     
465     bufinit(envbuf);
466     while(1) {
467         getcfline(s);
468         if(!strcmp(s->argv[0], "exec")) {
469             if(s->argc < 2) {
470                 flog(LOG_WARNING, "%s:%i: too few parameters to `exec'", s->file, s->lno);
471                 continue;
472             }
473             d->argv = szmalloc(sizeof(*d->argv) * s->argc);
474             for(i = 0; i < s->argc - 1; i++)
475                 d->argv[i] = sstrdup(s->argv[i + 1]);
476         } else if(!strcmp(s->argv[0], "env")) {
477             if(s->argc < 3) {
478                 flog(LOG_WARNING, "%s:%i: too few parameters to `env'", s->file, s->lno);
479                 continue;
480             }
481             bufadd(envbuf, sstrdup(s->argv[1]));
482             bufadd(envbuf, sstrdup(s->argv[2]));
483         } else if(!strcmp(s->argv[0], "end") || !strcmp(s->argv[0], "eof")) {
484             break;
485         } else {
486             flog(LOG_WARNING, "%s:%i: unknown directive `%s' in child declaration", s->file, s->lno, s->argv[0]);
487         }
488     }
489     bufadd(envbuf, NULL);
490     d->envp = envbuf.b;
491     if(d->argv == NULL) {
492         flog(LOG_WARNING, "%s:%i: missing `exec' in child declaration %s", s->file, sl, ch->name);
493         freechild(ch);
494         return(NULL);
495     }
496     return(ch);
497 }
498
499 int childhandle(struct child *ch, struct hthead *req, int fd, void (*chinit)(void *), void *idata)
500 {
501     return(ch->iface->handle(ch, req, fd, chinit, idata));
502 }