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