[ashd.git] / lib / cf.c

/*
    ashd - A Sane HTTP Daemon
    Copyright (C) 2008  Fredrik Tolf <fredrik@dolda2000.com>

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <ctype.h>
#include <glob.h>
#include <errno.h>

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include <utils.h>
#include <cf.h>
#include <mt.h>
#include <proc.h>
#include <log.h>

#define CH_SOCKET 0
#define CH_FORK 1

static int parsefile(struct cfstate *s, FILE *in)
{
    int i, o, ret;
    glob_t globm;
    char line[1024];
    int eof, argc;
    int ind, indst[80], indl;
    char *p, **w, *fbk;
    FILE *inc;
    
    s->lno = 0;
    indst[indl = 0] = 0;
    eof = 0;
    while(1) {
	if(fgets(line, sizeof(line), in) == NULL) {
	    eof = 1;
	    line[0] = 0;
	}
	s->lno++;
	for(p = line + strlen(line) - 1; p >= line; p--) {
	    if(isspace(*p))
		*p = 0;
	    else
		break;
	}
	for(ind = 0, p = line; *p; p++) {
	    if(*p == ' ') {
		ind++;
	    } else if(*p == '\t') {
		ind = ind - (ind % 8) + 8;
	    } else {
		break;
	    }
	}
	if(!eof && (!*p || (*p == '#')))
	    continue;
	
    reindent:
	if(ind > indst[indl]) {
	    indst[++indl] = ind;
	    if(!s->expstart) {
		s->res = tokenize("start");
		if(yield())
		    return(1);
	    } else {
		s->expstart = 0;
	    }
	} else {
	    if(s->expstart) {
		s->res = tokenize("end");
		if(yield())
		    return(1);
		s->expstart = 0;
	    }
	    while(ind < indst[indl]) {
		indl--;
		s->res = tokenize("end");
		if(yield())
		    return(1);
	    }
	    if(ind > indst[indl]) {
		flog(LOG_WARNING, "%s:%i: unexpected indentation level", s->file, s->lno);
		goto reindent;
	    }
	}
	
	if(eof)
	    return(0);
	
	argc = calen(w = tokenize(line));
	if(argc < 1) {
	    /* Shouldn't happen, but... */
	    freeca(w);
	    continue;
	}
	
	if(indl == 0) {
	    if(!strcmp(w[0], "include")) {
		fbk = s->file;
		for(i = 1; i < argc; i++) {
		    if((ret = glob(w[i], 0, NULL, &globm)) == 0) {
			for(o = 0; o < globm.gl_pathc; o++) {
			    if((inc = fopen(globm.gl_pathv[o], "r")) != NULL) {
				s->file = globm.gl_pathv[o];
				if(parsefile(s, inc)) {
				    fclose(inc);
				    globfree(&globm);
				    freeca(w);
				    return(1);
				}
				fclose(inc);
			    }
			}
			globfree(&globm);
		    }
		}
		freeca(w);
		s->file = fbk;
		continue;
	    }
	}
	
	if(!strcmp(w[0], "start") ||
	   !strcmp(w[0], "end") || 
	   !strcmp(w[0], "eof")) {
	    flog(LOG_WARNING, "%s:%i: illegal directive: %s", s->file, s->lno, w[0]);
	} else {
	    s->res = w;
	    if(yield())
		return(1);
	}
    }
}

static void parsefn(struct muth *mt, va_list args)
{
    vavar(struct cfstate *, s);
    vavar(FILE *, in);
    vavar(char *, file);
    
    s->file = sstrdup(file);
    if(parsefile(s, in))
	goto out;
    do {
	s->res = tokenize("eof");
    } while(!yield());
    
out:
    free(s->file);
}

char **getcfline(struct cfstate *s)
{
    freeca(s->argv);
    if(s->res == NULL)
	resume(s->pf, 0);
    s->argc = calen(s->argv = s->res);
    s->res = NULL;
    return(s->argv);
}

struct cfstate *mkcfparser(FILE *in, char *name)
{
    struct cfstate *s;
    
    omalloc(s);
    s->pf = mustart(parsefn, s, in, name);
    return(s);
}

void freecfparser(struct cfstate *s)
{
    resume(s->pf, -1);
    freeca(s->argv);
    freeca(s->res);
    free(s);
}

static struct child *newchild(char *name, int type)
{
    struct child *ch;
    
    omalloc(ch);
    ch->name = sstrdup(name);
    ch->type = type;
    ch->fd = -1;
    return(ch);
}

void freechild(struct child *ch)
{
    if(ch->fd != -1)
	close(ch->fd);
    if(ch->name != NULL)
	free(ch->name);
    if(ch->argv != NULL)
	freeca(ch->argv);
    free(ch);
}

void skipcfblock(struct cfstate *s)
{
    char **w;
    
    while(1) {
	w = getcfline(s);
	if(!strcmp(w[0], "end") || !strcmp(w[0], "eof"))
	    return;
    }
}

struct child *parsechild(struct cfstate *s)
{
    struct child *ch;
    int i;
    int sl;
    
    sl = s->lno;
    if(!strcmp(s->argv[0], "child")) {
	s->expstart = 1;
	if(s->argc < 2) {
	    flog(LOG_WARNING, "%s:%i: missing name in child declaration", s->file, s->lno);
	    skipcfblock(s);
	    return(NULL);
	}
	ch = newchild(s->argv[1], CH_SOCKET);
    } else if(!strcmp(s->argv[0], "fchild")) {
	s->expstart = 1;
	if(s->argc < 2) {
	    flog(LOG_WARNING, "%s:%i: missing name in child declaration", s->file, s->lno);
	    skipcfblock(s);
	    return(NULL);
	}
	ch = newchild(s->argv[1], CH_FORK);
    } else {
	return(NULL);
    }
    
    while(1) {
	getcfline(s);
	if(!strcmp(s->argv[0], "exec")) {
	    if(s->argc < 2) {
		flog(LOG_WARNING, "%s:%i: too few parameters to `exec'", s->file, s->lno);
		continue;
	    }
	    ch->argv = szmalloc(sizeof(*ch->argv) * s->argc);
	    for(i = 0; i < s->argc - 1; i++)
		ch->argv[i] = sstrdup(s->argv[i + 1]);
	} else if(!strcmp(s->argv[0], "end") || !strcmp(s->argv[0], "eof")) {
	    break;
	} else {
	    flog(LOG_WARNING, "%s:%i: unknown directive `%s' in child declaration", s->file, s->lno, s->argv[0]);
	}
    }
    if(ch->argv == NULL) {
	flog(LOG_WARNING, "%s:%i: missing `exec' in child declaration %s", s->file, sl, ch->name);
	freechild(ch);
	return(NULL);
    }
    return(ch);
}

int childhandle(struct child *ch, struct hthead *req, int fd)
{
    if(ch->type == CH_SOCKET) {
	if(ch->fd < 0)
	    ch->fd = stdmkchild(ch->argv);
	if(sendreq(ch->fd, req, fd)) {
	    if(errno == EPIPE) {
		/* Assume that the child has crashed and restart it. */
		close(ch->fd);
		ch->fd = stdmkchild(ch->argv);
		if(!sendreq(ch->fd, req, fd))
		    return(-1);
	    }
	    flog(LOG_ERR, "could not pass on request to child %s: %s", ch->name, strerror(errno));
	    close(ch->fd);
	    ch->fd = -1;
	    return(-1);
	}
    } else if(ch->type == CH_FORK) {
	if(stdforkserve(ch->argv, req, fd) < 0)
	    return(-1);
    }
    return(0);
}
Commit	Line	Data
06c1a718 FT	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 <errno.h>
	26
	27	#ifdef HAVE_CONFIG_H
	28	#include <config.h>
	29	#endif
	30	#include <utils.h>
	31	#include <cf.h>
	32	#include <mt.h>
	33	#include <proc.h>
	34	#include <log.h>
	35
	36	#define CH_SOCKET 0
	37	#define CH_FORK 1
	38
	39	static int parsefile(struct cfstate s, FILE in)
	40	{
	41	int i, o, ret;
	42	glob_t globm;
	43	char line[1024];
	44	int eof, argc;
	45	int ind, indst[80], indl;
	46	char p, w, fbk;
	47	FILE *inc;
	48
	49	s->lno = 0;
	50	indst[indl = 0] = 0;
	51	eof = 0;
	52	while(1) {
	53	if(fgets(line, sizeof(line), in) == NULL) {
	54	eof = 1;
	55	line[0] = 0;
	56	}
	57	s->lno++;
	58	for(p = line + strlen(line) - 1; p >= line; p--) {
	59	if(isspace(*p))
	60	*p = 0;
	61	else
	62	break;
	63	}
	64	for(ind = 0, p = line; *p; p++) {
65	if(*p == ' ') {
66	ind++;
67	} else if(*p == '\t') {
68	ind = ind - (ind % 8) + 8;
69	} else {
70	break;
71	}
72	}
73	if(!eof && (!p \|\| (p == '#')))
74	continue;
75
76	reindent:
77	if(ind > indst[indl]) {
78	indst[++indl] = ind;
79	if(!s->expstart) {
80	s->res = tokenize("start");
81	if(yield())
82	return(1);
83	} else {
84	s->expstart = 0;
85	}
86	} else {
87	if(s->expstart) {
88	s->res = tokenize("end");
89	if(yield())
90	return(1);
91	s->expstart = 0;
92	}
93	while(ind < indst[indl]) {
94	indl--;
95	s->res = tokenize("end");
96	if(yield())
97	return(1);
98	}
99	if(ind > indst[indl]) {
100	flog(LOG_WARNING, "%s:%i: unexpected indentation level", s->file, s->lno);
101	goto reindent;
102	}
103	}
104
105	if(eof)
106	return(0);
107
108	argc = calen(w = tokenize(line));
109	if(argc < 1) {
110	/* Shouldn't happen, but... */
111	freeca(w);
112	continue;
113	}
114
115	if(indl == 0) {
116	if(!strcmp(w[0], "include")) {
117	fbk = s->file;
118	for(i = 1; i < argc; i++) {
119	if((ret = glob(w[i], 0, NULL, &globm)) == 0) {
120	for(o = 0; o < globm.gl_pathc; o++) {
121	if((inc = fopen(globm.gl_pathv[o], "r")) != NULL) {
122	s->file = globm.gl_pathv[o];
123	if(parsefile(s, inc)) {
124	fclose(inc);
125	globfree(&globm);
126	freeca(w);
127	return(1);
128	}
129	fclose(inc);
130	}
131	}
132	globfree(&globm);
133	}
134	}
135	freeca(w);
136	s->file = fbk;
137	continue;
138	}
139	}
140
141	if(!strcmp(w[0], "start") \|\|
142	!strcmp(w[0], "end") \|\|
143	!strcmp(w[0], "eof")) {
144	flog(LOG_WARNING, "%s:%i: illegal directive: %s", s->file, s->lno, w[0]);
145	} else {
146	s->res = w;
147	if(yield())
148	return(1);
149	}
150	}
151	}
152
153	static void parsefn(struct muth *mt, va_list args)
154	{
155	vavar(struct cfstate *, s);
156	vavar(FILE *, in);
157	vavar(char *, file);
158
159	s->file = sstrdup(file);
160	if(parsefile(s, in))
161	goto out;
162	do {
163	s->res = tokenize("eof");
164	} while(!yield());
165
166	out:
167	free(s->file);
168	}
169
170	char *getcfline(struct cfstate s)
171	{
172	freeca(s->argv);
173	if(s->res == NULL)
174	resume(s->pf, 0);
175	s->argc = calen(s->argv = s->res);
176	s->res = NULL;
177	return(s->argv);
178	}
179
180	struct cfstate mkcfparser(FILE in, char *name)
181	{
182	struct cfstate *s;
183
184	omalloc(s);
185	s->pf = mustart(parsefn, s, in, name);
186	return(s);
187	}
188
189	void freecfparser(struct cfstate *s)
190	{
191	resume(s->pf, -1);
192	freeca(s->argv);
193	freeca(s->res);
194	free(s);
195	}
196
197	static struct child newchild(char name, int type)
198	{
199	struct child *ch;
200
201	omalloc(ch);
202	ch->name = sstrdup(name);
203	ch->type = type;
204	ch->fd = -1;
205	return(ch);
206	}
207
208	void freechild(struct child *ch)
209	{
210	if(ch->fd != -1)
211	close(ch->fd);
212	if(ch->name != NULL)
213	free(ch->name);
214	if(ch->argv != NULL)
215	freeca(ch->argv);
216	free(ch);
217	}
218
219	void skipcfblock(struct cfstate *s)
220	{
221	char **w;
222
223	while(1) {
224	w = getcfline(s);
225	if(!strcmp(w[0], "end") \|\| !strcmp(w[0], "eof"))
226	return;
227	}
228	}
229
230	struct child parsechild(struct cfstate s)
231	{
232	struct child *ch;
233	int i;
234	int sl;
235
236	sl = s->lno;
237	if(!strcmp(s->argv[0], "child")) {
238	s->expstart = 1;
239	if(s->argc < 2) {
240	flog(LOG_WARNING, "%s:%i: missing name in child declaration", s->file, s->lno);
241	skipcfblock(s);
242	return(NULL);
243	}
244	ch = newchild(s->argv[1], CH_SOCKET);
245	} else if(!strcmp(s->argv[0], "fchild")) {
246	s->expstart = 1;
247	if(s->argc < 2) {
248	flog(LOG_WARNING, "%s:%i: missing name in child declaration", s->file, s->lno);
249	skipcfblock(s);
250	return(NULL);
251	}
252	ch = newchild(s->argv[1], CH_FORK);
253	} else {
254	return(NULL);
255	}
256
257	while(1) {
258	getcfline(s);
259	if(!strcmp(s->argv[0], "exec")) {
260	if(s->argc < 2) {
261	flog(LOG_WARNING, "%s:%i: too few parameters to `exec'", s->file, s->lno);
262	continue;
263	}
264	ch->argv = szmalloc(sizeof(ch->argv) s->argc);
265	for(i = 0; i < s->argc - 1; i++)
266	ch->argv[i] = sstrdup(s->argv[i + 1]);
267	} else if(!strcmp(s->argv[0], "end") \|\| !strcmp(s->argv[0], "eof")) {
268	break;
269	} else {
270	flog(LOG_WARNING, "%s:%i: unknown directive `%s' in child declaration", s->file, s->lno, s->argv[0]);
271	}
272	}
273	if(ch->argv == NULL) {
274	flog(LOG_WARNING, "%s:%i: missing `exec' in child declaration %s", s->file, sl, ch->name);
275	freechild(ch);
276	return(NULL);
277	}
278	return(ch);
279	}
280
281	int childhandle(struct child ch, struct hthead req, int fd)
282	{
283	if(ch->type == CH_SOCKET) {
284	if(ch->fd < 0)
285	ch->fd = stdmkchild(ch->argv);
286	if(sendreq(ch->fd, req, fd)) {
287	if(errno == EPIPE) {
288	/* Assume that the child has crashed and restart it. */
289	close(ch->fd);
290	ch->fd = stdmkchild(ch->argv);
291	if(!sendreq(ch->fd, req, fd))
292	return(-1);
293	}
294	flog(LOG_ERR, "could not pass on request to child %s: %s", ch->name, strerror(errno));
295	close(ch->fd);
296	ch->fd = -1;
297	return(-1);
298	}
299	} else if(ch->type == CH_FORK) {
300	if(stdforkserve(ch->argv, req, fd) < 0)
301	return(-1);
302	}
303	return(0);
304	}