1 /* -*- mode: fundamental; indent-tabs-mode: t; -*- */
2 %{
3 
4 /*
5  * Copyright (c) 2021 Omar Polo <op@omarpolo.com>
6  *
7  * Permission to use, copy, modify, and distribute this software for any
8  * purpose with or without fee is hereby granted, provided that the above
9  * copyright notice and this permission notice appear in all copies.
10  *
11  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
12  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
13  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
14  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
15  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
16  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
17  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
18  */
19 
20 #include <errno.h>
21 #include <stdarg.h>
22 #include <stdio.h>
23 #include <string.h>
24 
25 #include "gmid.h"
26 
27 /*
28  * #define YYDEBUG 1
29  * int yydebug = 1;
30  */
31 
32 struct vhost *host;
33 struct location *loc;
34 
35 int goterror = 0;
36 
37 static struct vhost	*new_vhost(void);
38 static struct location	*new_location(void);
39 
40 void		 yyerror(const char*, ...);
41 int		 parse_portno(const char*);
42 void		 parse_conf(const char*);
43 char		*ensure_absolute_path(char*);
44 int		 check_block_code(int);
45 char		*check_block_fmt(char*);
46 int		 check_strip_no(int);
47 int		 check_prefork_num(int);
48 void		 advance_loc(void);
49 void		 only_once(const void*, const char*);
50 void		 only_oncei(int, const char*);
51 int		 fastcgi_conf(char *, char *, char *);
52 
53 %}
54 
55 /* for bison: */
56 /* %define parse.error verbose */
57 
58 %union {
59 	char		*str;
60 	int		 num;
61 }
62 
63 %token TIPV6 TPORT TPROTOCOLS TMIME TDEFAULT TTYPE TCHROOT TUSER TSERVER
64 %token TPREFORK TLOCATION TCERT TKEY TROOT TCGI TENV TLANG TLOG TINDEX TAUTO
65 %token TSTRIP TBLOCK TRETURN TENTRYPOINT TREQUIRE TCLIENT TCA TALIAS TTCP
66 %token TFASTCGI TSPAWN
67 
68 %token TERR
69 
70 %token <str>	TSTRING
71 %token <num>	TNUM
72 %token <num>	TBOOL
73 
74 %%
75 
76 conf		: options vhosts ;
77 
78 options		: /* empty */
79 		| options option
80 		;
81 
82 option		: TCHROOT TSTRING	{ conf.chroot = $2; }
83 		| TIPV6 TBOOL		{ conf.ipv6 = $2; }
84 		| TMIME TSTRING TSTRING	{ add_mime(&conf.mime, $2, $3); }
85 		| TPORT TNUM		{ conf.port = $2; }
86 		| TPREFORK TNUM		{ conf.prefork = check_prefork_num($2); }
87 		| TPROTOCOLS TSTRING {
88 			if (tls_config_parse_protocols(&conf.protos, $2) == -1)
89 				yyerror("invalid protocols string \"%s\"", $2);
90 		}
91 		| TUSER TSTRING		{ conf.user = $2; }
92 		;
93 
94 vhosts		: /* empty */
95 		| vhosts vhost
96 		;
97 
98 vhost		: TSERVER TSTRING {
99 			host = new_vhost();
100 			TAILQ_INSERT_HEAD(&hosts, host, vhosts);
101 
102 			loc = new_location();
103 			TAILQ_INSERT_HEAD(&host->locations, loc, locations);
104 
105 			loc->match = xstrdup("*");
106 			host->domain = $2;
107 
108 			if (strstr($2, "xn--") != NULL) {
109 				warnx("%s:%d \"%s\" looks like punycode: "
110 				    "you should use the decoded hostname.",
111 				    config_path, yylineno, $2);
112 			}
113 		} '{' servopts locations '}' {
114 
115 			if (host->cert == NULL || host->key == NULL)
116 				yyerror("invalid vhost definition: %s", $2);
117 		}
118 		| error '}'		{ yyerror("error in server directive"); }
119 		;
120 
121 servopts	: /* empty */
122 		| servopts servopt
123 		;
124 
125 servopt		: TALIAS TSTRING {
126 			struct alist *a;
127 
128 			a = xcalloc(1, sizeof(*a));
129 			a->alias = $2;
130 			if (TAILQ_EMPTY(&host->aliases))
131 				TAILQ_INSERT_HEAD(&host->aliases, a, aliases);
132 			else
133 				TAILQ_INSERT_TAIL(&host->aliases, a, aliases);
134 		}
135 		| TCERT TSTRING		{
136 			only_once(host->cert, "cert");
137 			host->cert = ensure_absolute_path($2);
138 		}
139 		| TCGI TSTRING		{
140 			only_once(host->cgi, "cgi");
141 			/* drop the starting '/', if any */
142 			if (*$2 == '/')
143 				memmove($2, $2+1, strlen($2));
144 			host->cgi = $2;
145 		}
146 		| TENTRYPOINT TSTRING {
147 			only_once(host->entrypoint, "entrypoint");
148 			while (*$2 == '/')
149 				memmove($2, $2+1, strlen($2));
150 			host->entrypoint = $2;
151 		}
152 		| TENV TSTRING TSTRING {
153 			struct envlist *e;
154 
155 			e = xcalloc(1, sizeof(*e));
156 			e->name = $2;
157 			e->value = $3;
158 			if (TAILQ_EMPTY(&host->env))
159 				TAILQ_INSERT_HEAD(&host->env, e, envs);
160 			else
161 				TAILQ_INSERT_TAIL(&host->env, e, envs);
162 		}
163 		| TKEY TSTRING		{
164 			only_once(host->key, "key");
165 			host->key  = ensure_absolute_path($2);
166 		}
167 		| locopt
168 		;
169 
170 locations	: /* empty */
171 		| locations location
172 		;
173 
174 location	: TLOCATION { advance_loc(); } TSTRING '{' locopts '}'	{
175 			/* drop the starting '/' if any */
176 			if (*$3 == '/')
177 				memmove($3, $3+1, strlen($3));
178 			loc->match = $3;
179 		}
180 		| error '}'
181 		;
182 
183 locopts		: /* empty */
184 		| locopts locopt
185 		;
186 
187 locopt		: TAUTO TINDEX TBOOL	{ loc->auto_index = $3 ? 1 : -1; }
188 		| TBLOCK TRETURN TNUM TSTRING {
189 			only_once(loc->block_fmt, "block");
190 			loc->block_fmt = check_block_fmt($4);
191 			loc->block_code = check_block_code($3);
192 		}
193 		| TBLOCK TRETURN TNUM {
194 			only_once(loc->block_fmt, "block");
195 			loc->block_fmt = xstrdup("temporary failure");
196 			loc->block_code = check_block_code($3);
197 			if ($3 >= 30 && $3 < 40)
198 				yyerror("missing `meta' for block return %d", $3);
199 		}
200 		| TBLOCK {
201 			only_once(loc->block_fmt, "block");
202 			loc->block_fmt = xstrdup("temporary failure");
203 			loc->block_code = 40;
204 		}
205 		| TDEFAULT TTYPE TSTRING {
206 			only_once(loc->default_mime, "default type");
207 			loc->default_mime = $3;
208 		}
209 		| TFASTCGI fastcgi
210 		| TINDEX TSTRING {
211 			only_once(loc->index, "index");
212 			loc->index = $2;
213 		}
214 		| TLANG TSTRING {
215 			only_once(loc->lang, "lang");
216 			loc->lang = $2;
217 		}
218 		| TLOG TBOOL	{ loc->disable_log = !$2; }
219 		| TREQUIRE TCLIENT TCA TSTRING {
220 			only_once(loc->reqca, "require client ca");
221 			ensure_absolute_path($4);
222 			if ((loc->reqca = load_ca($4)) == NULL)
223 				yyerror("couldn't load ca cert: %s", $4);
224 			free($4);
225 		}
226 		| TROOT TSTRING		{
227 			only_once(loc->dir, "root");
228 			loc->dir  = ensure_absolute_path($2);
229 		}
230 		| TSTRIP TNUM		{ loc->strip = check_strip_no($2); }
231 		;
232 
233 fastcgi		: TSPAWN TSTRING {
234 			only_oncei(loc->fcgi, "fastcgi");
235 			loc->fcgi = fastcgi_conf(NULL, NULL, $2);
236 		}
237 		| TSTRING {
238 			only_oncei(loc->fcgi, "fastcgi");
239 			loc->fcgi = fastcgi_conf($1, NULL, NULL);
240 		}
241 		| TTCP TSTRING TNUM {
242 			char *c;
243 			if (asprintf(&c, "%d", $3) == -1)
244 				err(1, "asprintf");
245 			only_oncei(loc->fcgi, "fastcgi");
246 			loc->fcgi = fastcgi_conf($2, c, NULL);
247 		}
248 		| TTCP TSTRING {
249 			only_oncei(loc->fcgi, "fastcgi");
250 			loc->fcgi = fastcgi_conf($2, xstrdup("9000"), NULL);
251 		}
252 		| TTCP TSTRING TSTRING {
253 			only_oncei(loc->fcgi, "fastcgi");
254 			loc->fcgi = fastcgi_conf($2, $3, NULL);
255 		}
256 		;
257 
258 %%
259 
260 static struct vhost *
261 new_vhost(void)
262 {
263 	return xcalloc(1, sizeof(struct vhost));
264 }
265 
266 static struct location *
267 new_location(void)
268 {
269 	struct location *l;
270 
271 	l = xcalloc(1, sizeof(*l));
272 	l->dirfd = -1;
273 	l->fcgi = -1;
274 	return l;
275 }
276 
277 void
278 yyerror(const char *msg, ...)
279 {
280 	va_list ap;
281 
282 	goterror = 1;
283 
284 	va_start(ap, msg);
285 	fprintf(stderr, "%s:%d: ", config_path, yylineno);
286 	vfprintf(stderr, msg, ap);
287 	fprintf(stderr, "\n");
288 	va_end(ap);
289 }
290 
291 int
292 parse_portno(const char *p)
293 {
294 	const char *errstr;
295 	int n;
296 
297 	n = strtonum(p, 0, UINT16_MAX, &errstr);
298 	if (errstr != NULL)
299 		yyerror("port number is %s: %s", errstr, p);
300 	return n;
301 }
302 
303 void
304 parse_conf(const char *path)
305 {
306 	config_path = path;
307 	if ((yyin = fopen(path, "r")) == NULL)
308 		err(1, "cannot open config: %s", path);
309 	yyparse();
310 	fclose(yyin);
311 
312 	if (goterror)
313 		exit(1);
314 
315 	if (TAILQ_FIRST(&hosts)->domain == NULL)
316 		errx(1, "no vhost defined in %s", path);
317 }
318 
319 char *
320 ensure_absolute_path(char *path)
321 {
322 	if (path == NULL || *path != '/')
323 		yyerror("not an absolute path: %s", path);
324 	return path;
325 }
326 
327 int
328 check_block_code(int n)
329 {
330 	if (n < 10 || n >= 70 || (n >= 20 && n <= 29))
331 		yyerror("invalid block code %d", n);
332 	return n;
333 }
334 
335 char *
336 check_block_fmt(char *fmt)
337 {
338 	char *s;
339 
340 	for (s = fmt; *s; ++s) {
341 		if (*s != '%')
342 			continue;
343 		switch (*++s) {
344 		case '%':
345 		case 'p':
346 		case 'q':
347 		case 'P':
348 		case 'N':
349 			break;
350 		default:
351 			yyerror("invalid format specifier %%%c", *s);
352 		}
353 	}
354 
355 	return fmt;
356 }
357 
358 int
359 check_strip_no(int n)
360 {
361 	if (n <= 0)
362 		yyerror("invalid strip number %d", n);
363 	return n;
364 }
365 
366 int
367 check_prefork_num(int n)
368 {
369 	if (n <= 0 || n >= PROC_MAX)
370 		yyerror("invalid prefork number %d", n);
371 	return n;
372 }
373 
374 void
375 advance_loc(void)
376 {
377 	loc = new_location();
378 	TAILQ_INSERT_TAIL(&host->locations, loc, locations);
379 }
380 
381 void
382 only_once(const void *ptr, const char *name)
383 {
384 	if (ptr != NULL)
385 		yyerror("`%s' specified more than once", name);
386 }
387 
388 void
389 only_oncei(int i, const char *name)
390 {
391 	if (i != -1)
392 		yyerror("`%s' specified more than once", name);
393 }
394 
395 int
396 fastcgi_conf(char *path, char *port, char *prog)
397 {
398 	struct fcgi	*f;
399 	int		i;
400 
401 	for (i = 0; i < FCGI_MAX; ++i) {
402 		f = &fcgi[i];
403 		
404 		if (f->path == NULL) {
405 			f->id = i;
406 			f->path = path;
407 			f->port = port;
408 			f->prog = prog;
409 			return i;
410 		}
411 
412 		/* XXX: what to do with prog? */
413 		if (!strcmp(f->path, path) &&
414 		    ((port == NULL && f->port == NULL) ||
415 		     !strcmp(f->port, port))) {
416 			free(path);
417 			free(port);
418 			return i;
419 		}
420 	}
421 
422 	yyerror("too much `fastcgi' rules defined.");
423 	return -1;
424 }