1 /*
2  * Copyright (c) 2016-2019, 2020-2021 Tracey Emery <tracey@traceyemery.net>
3  * Copyright (c) 2004, 2005 Esben Norby <norby@openbsd.org>
4  * Copyright (c) 2004 Ryan McBride <mcbride@openbsd.org>
5  * Copyright (c) 2002, 2003, 2004 Henning Brauer <henning@openbsd.org>
6  * Copyright (c) 2001 Markus Friedl.  All rights reserved.
7  * Copyright (c) 2001 Daniel Hartmeier.  All rights reserved.
8  * Copyright (c) 2001 Theo de Raadt.  All rights reserved.
9  *
10  * Permission to use, copy, modify, and distribute this software for any
11  * purpose with or without fee is hereby granted, provided that the above
12  * copyright notice and this permission notice appear in all copies.
13  *
14  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
15  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
16  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
17  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
18  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
19  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
20  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
21  */
22 
23 %{
24 #include "got_compat.h"
25 
26 #include <sys/ioctl.h>
27 #include <sys/types.h>
28 #include <sys/queue.h>
29 #include <sys/socket.h>
30 #include <sys/stat.h>
31 
32 #include <net/if.h>
33 #include <netinet/in.h>
34 
35 #include <arpa/inet.h>
36 
37 #include <ctype.h>
38 #include <err.h>
39 #include <errno.h>
40 #include <event.h>
41 #include <ifaddrs.h>
42 #include <limits.h>
43 #include <netdb.h>
44 #include <stdarg.h>
45 #include <stdlib.h>
46 #include <stdio.h>
47 #include <string.h>
48 #include <syslog.h>
49 #include <unistd.h>
50 
51 #include "got_sockaddr.h"
52 #include "got_reference.h"
53 
54 #include "proc.h"
55 #include "gotwebd.h"
56 
57 TAILQ_HEAD(files, file)		 files = TAILQ_HEAD_INITIALIZER(files);
58 static struct file {
59 	TAILQ_ENTRY(file)	 entry;
60 	FILE			*stream;
61 	char			*name;
62 	int			 lineno;
63 	int			 errors;
64 } *file;
65 struct file	*newfile(const char *, int);
66 static void	 closefile(struct file *);
67 int		 check_file_secrecy(int, const char *);
68 int		 yyparse(void);
69 int		 yylex(void);
70 int		 yyerror(const char *, ...)
71     __attribute__((__format__ (printf, 1, 2)))
72     __attribute__((__nonnull__ (1)));
73 int		 kw_cmp(const void *, const void *);
74 int		 lookup(char *);
75 int		 lgetc(int);
76 int		 lungetc(int);
77 int		 findeol(void);
78 
79 TAILQ_HEAD(symhead, sym)	 symhead = TAILQ_HEAD_INITIALIZER(symhead);
80 struct sym {
81 	TAILQ_ENTRY(sym)	 entry;
82 	int			 used;
83 	int			 persist;
84 	char			*nam;
85 	char			*val;
86 };
87 
88 int	 symset(const char *, const char *, int);
89 char	*symget(const char *);
90 
91 static int		 errors;
92 
93 static struct gotwebd		*gotwebd;
94 static struct server		*new_srv;
95 static struct server		*conf_new_server(const char *);
96 int				 getservice(const char *);
97 int				 n;
98 
99 int		 get_addrs(const char *, struct server *, in_port_t);
100 int		 addr_dup_check(struct addresslist *, struct address *,
101 		    const char *, const char *);
102 int		 add_addr(struct server *, struct address *);
103 struct address	*host_v4(const char *);
104 struct address	*host_v6(const char *);
105 int		 host_dns(const char *, struct server *,
106 		    int, in_port_t, const char *, int);
107 int		 host_if(const char *, struct server *,
108 		    int, in_port_t, const char *, int);
109 int		 host(const char *, struct server *,
110 		    int, in_port_t, const char *, int);
111 int		 is_if_in_group(const char *, const char *);
112 
113 typedef struct {
114 	union {
115 		long long	 number;
116 		char		*string;
117 		in_port_t	 port;
118 	} v;
119 	int lineno;
120 } YYSTYPE;
121 
122 %}
123 
124 %token	LISTEN WWW_PATH MAX_REPOS SITE_NAME SITE_OWNER SITE_LINK LOGO
125 %token	LOGO_URL SHOW_REPO_OWNER SHOW_REPO_AGE SHOW_REPO_DESCRIPTION
126 %token	MAX_REPOS_DISPLAY REPOS_PATH MAX_COMMITS_DISPLAY ON ERROR
127 %token	SHOW_SITE_OWNER SHOW_REPO_CLONEURL PORT PREFORK RESPECT_EXPORTOK
128 %token	UNIX_SOCKET UNIX_SOCKET_NAME SERVER CHROOT CUSTOM_CSS SOCKET
129 
130 %token	<v.string>	STRING
131 %type	<v.port>	fcgiport
132 %token	<v.number>	NUMBER
133 %type	<v.number>	boolean
134 
135 %%
136 
137 grammar		: /* empty */
138 		| grammar '\n'
139 		| grammar varset '\n'
140 		| grammar main '\n'
141 		| grammar server '\n'
142 		| grammar error '\n'		{ file->errors++; }
143 		;
144 
145 varset		: STRING '=' STRING	{
146 			char *s = $1;
147 			while (*s++) {
148 				if (isspace((unsigned char)*s)) {
149 					yyerror("macro name cannot contain "
150 					    "whitespace");
151 					free($1);
152 					free($3);
153 					YYERROR;
154 				}
155 			}
156 			if (symset($1, $3, 0) == -1)
157 				fatal("cannot store variable");
158 			free($1);
159 			free($3);
160 		}
161 		;
162 
163 boolean		: STRING {
164 			if (strcasecmp($1, "1") == 0 ||
165 			    strcasecmp($1, "yes") == 0 ||
166 			    strcasecmp($1, "on") == 0)
167 				$$ = 1;
168 			else if (strcasecmp($1, "0") == 0 ||
169 			    strcasecmp($1, "off") == 0 ||
170 			    strcasecmp($1, "no") == 0)
171 				$$ = 0;
172 			else {
173 				yyerror("invalid boolean value '%s'", $1);
174 				free($1);
175 				YYERROR;
176 			}
177 			free($1);
178 		}
179 		| ON { $$ = 1; }
180 		| NUMBER { $$ = $1; }
181 		;
182 
183 fcgiport	: PORT NUMBER {
184 			if ($2 <= 0 || $2 > (int)USHRT_MAX) {
185 				yyerror("invalid port: %lld", $2);
186 				YYERROR;
187 			}
188 			$$ = $2;
189 		}
190 		| PORT STRING {
191 			int	 val;
192 
193 			if ((val = getservice($2)) == -1) {
194 				yyerror("invalid port: %s", $2);
195 				free($2);
196 				YYERROR;
197 			}
198 			free($2);
199 
200 			$$ = val;
201 		}
202 		;
203 
204 main		: PREFORK NUMBER {
205 			gotwebd->prefork_gotwebd = $2;
206 		}
207 		| CHROOT STRING {
208 			n = strlcpy(gotwebd->httpd_chroot, $2,
209 			    sizeof(gotwebd->httpd_chroot));
210 			if (n >= sizeof(gotwebd->httpd_chroot)) {
211 				yyerror("%s: httpd_chroot truncated", __func__);
212 				free($2);
213 				YYERROR;
214 			}
215 			free($2);
216 		}
217 		| UNIX_SOCKET boolean {
218 			gotwebd->unix_socket = $2;
219 		}
220 		| UNIX_SOCKET_NAME STRING {
221 			n = snprintf(gotwebd->unix_socket_name,
222 			    sizeof(gotwebd->unix_socket_name), "%s%s",
223 			    strlen(gotwebd->httpd_chroot) ?
224 			    gotwebd->httpd_chroot : D_HTTPD_CHROOT, $2);
225 			if (n < 0 ||
226 			    (size_t)n >= sizeof(gotwebd->unix_socket_name)) {
227 				yyerror("%s: unix_socket_name truncated",
228 				    __func__);
229 				free($2);
230 				YYERROR;
231 			}
232 			free($2);
233 		}
234 		;
235 
236 server		: SERVER STRING {
237 			struct server *srv;
238 
239 			TAILQ_FOREACH(srv, &gotwebd->servers, entry) {
240 				if (strcmp(srv->name, $2) == 0) {
241 					yyerror("server name exists '%s'", $2);
242 					free($2);
243 					YYERROR;
244 				}
245 			}
246 
247 			new_srv = conf_new_server($2);
248 			log_debug("adding server %s", $2);
249 			free($2);
250 		}
251 		| SERVER STRING {
252 			struct server *srv;
253 
254 			TAILQ_FOREACH(srv, &gotwebd->servers, entry) {
255 				if (strcmp(srv->name, $2) == 0) {
256 					yyerror("server name exists '%s'", $2);
257 					free($2);
258 					YYERROR;
259 				}
260 			}
261 
262 			new_srv = conf_new_server($2);
263 			log_debug("adding server %s", $2);
264 			free($2);
265 		} '{' optnl serveropts2 '}' {
266 		}
267 		;
268 
269 serveropts1	: REPOS_PATH STRING {
270 			n = strlcpy(new_srv->repos_path, $2,
271 			    sizeof(new_srv->repos_path));
272 			if (n >= sizeof(new_srv->repos_path)) {
273 				yyerror("%s: repos_path truncated", __func__);
274 				free($2);
275 				YYERROR;
276 			}
277 			free($2);
278 		}
279 		| SITE_NAME STRING {
280 			n = strlcpy(new_srv->site_name, $2,
281 			    sizeof(new_srv->site_name));
282 			if (n >= sizeof(new_srv->site_name)) {
283 				yyerror("%s: site_name truncated", __func__);
284 				free($2);
285 				YYERROR;
286 			}
287 			free($2);
288 		}
289 		| SITE_OWNER STRING {
290 			n = strlcpy(new_srv->site_owner, $2,
291 			    sizeof(new_srv->site_owner));
292 			if (n >= sizeof(new_srv->site_owner)) {
293 				yyerror("%s: site_owner truncated", __func__);
294 				free($2);
295 				YYERROR;
296 			}
297 			free($2);
298 		}
299 		| SITE_LINK STRING {
300 			n = strlcpy(new_srv->site_link, $2,
301 			    sizeof(new_srv->site_link));
302 			if (n >= sizeof(new_srv->site_link)) {
303 				yyerror("%s: site_link truncated", __func__);
304 				free($2);
305 				YYERROR;
306 			}
307 			free($2);
308 		}
309 		| LOGO STRING {
310 			n = strlcpy(new_srv->logo, $2, sizeof(new_srv->logo));
311 			if (n >= sizeof(new_srv->logo)) {
312 				yyerror("%s: logo truncated", __func__);
313 				free($2);
314 				YYERROR;
315 			}
316 			free($2);
317 		}
318 		| LOGO_URL STRING {
319 			n = strlcpy(new_srv->logo_url, $2,
320 			    sizeof(new_srv->logo_url));
321 			if (n >= sizeof(new_srv->logo_url)) {
322 				yyerror("%s: logo_url truncated", __func__);
323 				free($2);
324 				YYERROR;
325 			}
326 			free($2);
327 		}
328 		| CUSTOM_CSS STRING {
329 			n = strlcpy(new_srv->custom_css, $2,
330 			    sizeof(new_srv->custom_css));
331 			if (n >= sizeof(new_srv->custom_css)) {
332 				yyerror("%s: custom_css truncated", __func__);
333 				free($2);
334 				YYERROR;
335 			}
336 			free($2);
337 		}
338 		| LISTEN ON STRING fcgiport {
339 			if (get_addrs($3, new_srv, $4) == -1) {
340 				yyerror("could not get addrs");
341 				YYERROR;
342 			}
343 			new_srv->fcgi_socket = 1;
344 		}
345 		| LISTEN ON SOCKET STRING {
346 			if (!strcasecmp($4, "off") ||
347 			    !strcasecmp($4, "no")) {
348 				new_srv->unix_socket = 0;
349 				free($4);
350 				YYACCEPT;
351 			}
352 
353 			new_srv->unix_socket = 1;
354 
355 			n = snprintf(new_srv->unix_socket_name,
356 			    sizeof(new_srv->unix_socket_name), "%s%s",
357 			    strlen(gotwebd->httpd_chroot) ?
358 			    gotwebd->httpd_chroot : D_HTTPD_CHROOT, $4);
359 			if (n < 0 ||
360 			    (size_t)n >= sizeof(new_srv->unix_socket_name)) {
361 				yyerror("%s: unix_socket_name truncated",
362 				    __func__);
363 				free($4);
364 				YYERROR;
365 			}
366 			free($4);
367 		}
368 		| MAX_REPOS NUMBER {
369 			if ($2 > 0)
370 				new_srv->max_repos = $2;
371 		}
372 		| SHOW_SITE_OWNER boolean {
373 			new_srv->show_site_owner = $2;
374 		}
375 		| SHOW_REPO_OWNER boolean {
376 			new_srv->show_repo_owner = $2;
377 		}
378 		| SHOW_REPO_AGE boolean {
379 			new_srv->show_repo_age = $2;
380 		}
381 		| SHOW_REPO_DESCRIPTION boolean {
382 			new_srv->show_repo_description = $2;
383 		}
384 		| SHOW_REPO_CLONEURL boolean {
385 			new_srv->show_repo_cloneurl = $2;
386 		}
387 		| RESPECT_EXPORTOK boolean {
388 			new_srv->respect_exportok = $2;
389 		}
390 		| MAX_REPOS_DISPLAY NUMBER {
391 				new_srv->max_repos_display = $2;
392 		}
393 		| MAX_COMMITS_DISPLAY NUMBER {
394 			if ($2 > 0)
395 				new_srv->max_commits_display = $2;
396 		}
397 		;
398 
399 serveropts2	: serveropts2 serveropts1 nl
400 		| serveropts1 optnl
401 		;
402 
403 nl		: '\n' optnl
404 		;
405 
406 optnl		: '\n' optnl		/* zero or more newlines */
407 		| /* empty */
408 		;
409 
410 %%
411 
412 struct keywords {
413 	const char	*k_name;
414 	int		 k_val;
415 };
416 
417 int
418 yyerror(const char *fmt, ...)
419 {
420 	va_list ap;
421 	char *msg;
422 
423 	file->errors++;
424 	va_start(ap, fmt);
425 	if (vasprintf(&msg, fmt, ap) == -1)
426 		fatalx("yyerror vasprintf");
427 	va_end(ap);
428 	logit(LOG_CRIT, "%s:%d: %s", file->name, yylval.lineno, msg);
429 	free(msg);
430 	return (0);
431 }
432 
433 int
434 kw_cmp(const void *k, const void *e)
435 {
436 	return (strcmp(k, ((const struct keywords *)e)->k_name));
437 }
438 
439 int
440 lookup(char *s)
441 {
442 	/* This has to be sorted always. */
443 	static const struct keywords keywords[] = {
444 		{ "chroot",			CHROOT },
445 		{ "custom_css",			CUSTOM_CSS },
446 		{ "listen",			LISTEN },
447 		{ "logo",			LOGO },
448 		{ "logo_url",			LOGO_URL },
449 		{ "max_commits_display",	MAX_COMMITS_DISPLAY },
450 		{ "max_repos",			MAX_REPOS },
451 		{ "max_repos_display",		MAX_REPOS_DISPLAY },
452 		{ "on",				ON },
453 		{ "port",			PORT },
454 		{ "prefork",			PREFORK },
455 		{ "repos_path",			REPOS_PATH },
456 		{ "respect_exportok",		RESPECT_EXPORTOK },
457 		{ "server",			SERVER },
458 		{ "show_repo_age",		SHOW_REPO_AGE },
459 		{ "show_repo_cloneurl",		SHOW_REPO_CLONEURL },
460 		{ "show_repo_description",	SHOW_REPO_DESCRIPTION },
461 		{ "show_repo_owner",		SHOW_REPO_OWNER },
462 		{ "show_site_owner",		SHOW_SITE_OWNER },
463 		{ "site_link",			SITE_LINK },
464 		{ "site_name",			SITE_NAME },
465 		{ "site_owner",			SITE_OWNER },
466 		{ "socket",			SOCKET },
467 		{ "unix_socket",		UNIX_SOCKET },
468 		{ "unix_socket_name",		UNIX_SOCKET_NAME },
469 	};
470 	const struct keywords *p;
471 
472 	p = bsearch(s, keywords, sizeof(keywords)/sizeof(keywords[0]),
473 	    sizeof(keywords[0]), kw_cmp);
474 
475 	if (p)
476 		return (p->k_val);
477 	else
478 		return (STRING);
479 }
480 
481 #define MAXPUSHBACK	128
482 
483 unsigned char *parsebuf;
484 int parseindex;
485 unsigned char pushback_buffer[MAXPUSHBACK];
486 int pushback_index = 0;
487 
488 int
489 lgetc(int quotec)
490 {
491 	int c, next;
492 
493 	if (parsebuf) {
494 		/* Read character from the parsebuffer instead of input. */
495 		if (parseindex >= 0) {
496 			c = parsebuf[parseindex++];
497 			if (c != '\0')
498 				return (c);
499 			parsebuf = NULL;
500 		} else
501 			parseindex++;
502 	}
503 
504 	if (pushback_index)
505 		return (pushback_buffer[--pushback_index]);
506 
507 	if (quotec) {
508 		c = getc(file->stream);
509 		if (c == EOF)
510 			yyerror("reached end of file while parsing "
511 			    "quoted string");
512 		return (c);
513 	}
514 
515 	c = getc(file->stream);
516 	while (c == '\\') {
517 		next = getc(file->stream);
518 		if (next != '\n') {
519 			c = next;
520 			break;
521 		}
522 		yylval.lineno = file->lineno;
523 		file->lineno++;
524 		c = getc(file->stream);
525 	}
526 
527 	return (c);
528 }
529 
530 int
531 lungetc(int c)
532 {
533 	if (c == EOF)
534 		return (EOF);
535 	if (parsebuf) {
536 		parseindex--;
537 		if (parseindex >= 0)
538 			return (c);
539 	}
540 	if (pushback_index < MAXPUSHBACK-1)
541 		return (pushback_buffer[pushback_index++] = c);
542 	else
543 		return (EOF);
544 }
545 
546 int
547 findeol(void)
548 {
549 	int c;
550 
551 	parsebuf = NULL;
552 
553 	/* Skip to either EOF or the first real EOL. */
554 	while (1) {
555 		if (pushback_index)
556 			c = pushback_buffer[--pushback_index];
557 		else
558 			c = lgetc(0);
559 		if (c == '\n') {
560 			file->lineno++;
561 			break;
562 		}
563 		if (c == EOF)
564 			break;
565 	}
566 	return (ERROR);
567 }
568 
569 int
570 yylex(void)
571 {
572 	unsigned char buf[8096];
573 	unsigned char *p, *val;
574 	int quotec, next, c;
575 	int token;
576 
577 top:
578 	p = buf;
579 	c = lgetc(0);
580 	while (c == ' ' || c == '\t')
581 		c = lgetc(0); /* nothing */
582 
583 	yylval.lineno = file->lineno;
584 	if (c == '#') {
585 		c = lgetc(0);
586 		while (c != '\n' && c != EOF)
587 			c = lgetc(0); /* nothing */
588 	}
589 	if (c == '$' && parsebuf == NULL) {
590 		while (1) {
591 			c = lgetc(0);
592 			if (c == EOF)
593 				return (0);
594 
595 			if (p + 1 >= buf + sizeof(buf) - 1) {
596 				yyerror("string too long");
597 				return (findeol());
598 			}
599 			if (isalnum(c) || c == '_') {
600 				*p++ = c;
601 				continue;
602 			}
603 			*p = '\0';
604 			lungetc(c);
605 			break;
606 		}
607 		val = symget(buf);
608 		if (val == NULL) {
609 			yyerror("macro '%s' not defined", buf);
610 			return (findeol());
611 		}
612 		parsebuf = val;
613 		parseindex = 0;
614 		goto top;
615 	}
616 
617 	switch (c) {
618 	case '\'':
619 	case '"':
620 		quotec = c;
621 		while (1) {
622 			c = lgetc(quotec);
623 			if (c == EOF)
624 				return (0);
625 			if (c == '\n') {
626 				file->lineno++;
627 				continue;
628 			} else if (c == '\\') {
629 				next = lgetc(quotec);
630 				if (next == EOF)
631 					return (0);
632 				if (next == quotec || c == ' ' || c == '\t')
633 					c = next;
634 				else if (next == '\n') {
635 					file->lineno++;
636 					continue;
637 				} else
638 					lungetc(next);
639 			} else if (c == quotec) {
640 				*p = '\0';
641 				break;
642 			} else if (c == '\0') {
643 				yyerror("syntax error");
644 				return (findeol());
645 			}
646 			if (p + 1 >= buf + sizeof(buf) - 1) {
647 				yyerror("string too long");
648 				return (findeol());
649 			}
650 			*p++ = c;
651 		}
652 		yylval.v.string = strdup(buf);
653 		if (yylval.v.string == NULL)
654 			err(1, "yylex: strdup");
655 		return (STRING);
656 	}
657 
658 #define allowed_to_end_number(x) \
659 	(isspace(x) || x == ')' || x ==',' || x == '/' || x == '}' || x == '=')
660 
661 	if (c == '-' || isdigit(c)) {
662 		do {
663 			*p++ = c;
664 			if ((unsigned)(p-buf) >= sizeof(buf)) {
665 				yyerror("string too long");
666 				return (findeol());
667 			}
668 			c = lgetc(0);
669 		} while (c != EOF && isdigit(c));
670 		lungetc(c);
671 		if (p == buf + 1 && buf[0] == '-')
672 			goto nodigits;
673 		if (c == EOF || allowed_to_end_number(c)) {
674 			const char *errstr = NULL;
675 
676 			*p = '\0';
677 			yylval.v.number = strtonum(buf, LLONG_MIN,
678 			    LLONG_MAX, &errstr);
679 			if (errstr) {
680 				yyerror("\"%s\" invalid number: %s",
681 				    buf, errstr);
682 				return (findeol());
683 			}
684 			return (NUMBER);
685 		} else {
686 nodigits:
687 			while (p > buf + 1)
688 				lungetc(*--p);
689 			c = *--p;
690 			if (c == '-')
691 				return (c);
692 		}
693 	}
694 
695 #define allowed_in_string(x) \
696 	(isalnum(x) || (ispunct(x) && x != '(' && x != ')' && \
697 	x != '{' && x != '}' && \
698 	x != '!' && x != '=' && x != '#' && \
699 	x != ','))
700 
701 	if (isalnum(c) || c == ':' || c == '_') {
702 		do {
703 			*p++ = c;
704 			if ((unsigned)(p-buf) >= sizeof(buf)) {
705 				yyerror("string too long");
706 				return (findeol());
707 			}
708 			c = lgetc(0);
709 		} while (c != EOF && (allowed_in_string(c)));
710 		lungetc(c);
711 		*p = '\0';
712 		token = lookup(buf);
713 		if (token == STRING) {
714 			yylval.v.string = strdup(buf);
715 			if (yylval.v.string == NULL)
716 				err(1, "yylex: strdup");
717 		}
718 		return (token);
719 	}
720 	if (c == '\n') {
721 		yylval.lineno = file->lineno;
722 		file->lineno++;
723 	}
724 	if (c == EOF)
725 		return (0);
726 	return (c);
727 }
728 
729 int
730 check_file_secrecy(int fd, const char *fname)
731 {
732 	struct stat st;
733 
734 	if (fstat(fd, &st)) {
735 		log_warn("cannot stat %s", fname);
736 		return (-1);
737 	}
738 	if (st.st_uid != 0 && st.st_uid != getuid()) {
739 		log_warnx("%s: owner not root or current user", fname);
740 		return (-1);
741 	}
742 	if (st.st_mode & (S_IWGRP | S_IXGRP | S_IRWXO)) {
743 		log_warnx("%s: group writable or world read/writable", fname);
744 		return (-1);
745 	}
746 	return (0);
747 }
748 
749 struct file *
750 newfile(const char *name, int secret)
751 {
752 	struct file *nfile;
753 
754 	nfile = calloc(1, sizeof(struct file));
755 	if (nfile == NULL) {
756 		log_warn("calloc");
757 		return (NULL);
758 	}
759 	nfile->name = strdup(name);
760 	if (nfile->name == NULL) {
761 		log_warn("strdup");
762 		free(nfile);
763 		return (NULL);
764 	}
765 	nfile->stream = fopen(nfile->name, "r");
766 	if (nfile->stream == NULL) {
767 		/* no warning, we don't require a conf file */
768 		free(nfile->name);
769 		free(nfile);
770 		return (NULL);
771 	} else if (secret &&
772 	    check_file_secrecy(fileno(nfile->stream), nfile->name)) {
773 		fclose(nfile->stream);
774 		free(nfile->name);
775 		free(nfile);
776 		return (NULL);
777 	}
778 	nfile->lineno = 1;
779 	return (nfile);
780 }
781 
782 static void
783 closefile(struct file *xfile)
784 {
785 	fclose(xfile->stream);
786 	free(xfile->name);
787 	free(xfile);
788 }
789 
790 static void
791 add_default_server(void)
792 {
793 	new_srv = conf_new_server(D_SITENAME);
794 	log_debug("%s: adding default server %s", __func__, D_SITENAME);
795 }
796 
797 int
798 parse_config(const char *filename, struct gotwebd *env)
799 {
800 	struct sym *sym, *next;
801 
802 	if (config_init(env) == -1)
803 		fatalx("failed to initialize configuration");
804 
805 	gotwebd = env;
806 
807 	file = newfile(filename, 0);
808 	if (file == NULL) {
809 		add_default_server();
810 		sockets_parse_sockets(env);
811 		/* just return, as we don't require a conf file */
812 		return (0);
813 	}
814 
815 	yyparse();
816 	errors = file->errors;
817 	closefile(file);
818 
819 	/* Free macros and check which have not been used. */
820 	TAILQ_FOREACH_SAFE(sym, &symhead, entry, next) {
821 		if ((gotwebd->gotwebd_verbose > 1) && !sym->used)
822 			fprintf(stderr, "warning: macro '%s' not used\n",
823 			    sym->nam);
824 		if (!sym->persist) {
825 			free(sym->nam);
826 			free(sym->val);
827 			TAILQ_REMOVE(&symhead, sym, entry);
828 			free(sym);
829 		}
830 	}
831 
832 	if (errors)
833 		return (-1);
834 
835 	/* just add default server if no config specified */
836 	if (gotwebd->server_cnt == 0)
837 		add_default_server();
838 
839 	/* setup our listening sockets */
840 	sockets_parse_sockets(env);
841 
842 	return (0);
843 }
844 
845 struct server *
846 conf_new_server(const char *name)
847 {
848 	struct server *srv = NULL;
849 
850 	srv = calloc(1, sizeof(*srv));
851 	if (srv == NULL)
852 		fatalx("%s: calloc", __func__);
853 
854 	n = strlcpy(srv->name, name, sizeof(srv->name));
855 	if (n >= sizeof(srv->name))
856 		fatalx("%s: strlcpy", __func__);
857 	n = snprintf(srv->unix_socket_name,
858 	    sizeof(srv->unix_socket_name), "%s%s", D_HTTPD_CHROOT,
859 	    D_UNIX_SOCKET);
860 	if (n < 0 || (size_t)n >= sizeof(srv->unix_socket_name))
861 		fatalx("%s: snprintf", __func__);
862 	n = strlcpy(srv->repos_path, D_GOTPATH,
863 	    sizeof(srv->repos_path));
864 	if (n >= sizeof(srv->repos_path))
865 		fatalx("%s: strlcpy", __func__);
866 	n = strlcpy(srv->site_name, D_SITENAME,
867 	    sizeof(srv->site_name));
868 	if (n >= sizeof(srv->site_name))
869 		fatalx("%s: strlcpy", __func__);
870 	n = strlcpy(srv->site_owner, D_SITEOWNER,
871 	    sizeof(srv->site_owner));
872 	if (n >= sizeof(srv->site_owner))
873 		fatalx("%s: strlcpy", __func__);
874 	n = strlcpy(srv->site_link, D_SITELINK,
875 	    sizeof(srv->site_link));
876 	if (n >= sizeof(srv->site_link))
877 		fatalx("%s: strlcpy", __func__);
878 	n = strlcpy(srv->logo, D_GOTLOGO,
879 	    sizeof(srv->logo));
880 	if (n >= sizeof(srv->logo))
881 		fatalx("%s: strlcpy", __func__);
882 	n = strlcpy(srv->logo_url, D_GOTURL, sizeof(srv->logo_url));
883 	if (n >= sizeof(srv->logo_url))
884 		fatalx("%s: strlcpy", __func__);
885 	n = strlcpy(srv->custom_css, D_GOTWEBCSS, sizeof(srv->custom_css));
886 	if (n >= sizeof(srv->custom_css))
887 		fatalx("%s: strlcpy", __func__);
888 
889 	srv->show_site_owner = D_SHOWSOWNER;
890 	srv->show_repo_owner = D_SHOWROWNER;
891 	srv->show_repo_age = D_SHOWAGE;
892 	srv->show_repo_description = D_SHOWDESC;
893 	srv->show_repo_cloneurl = D_SHOWURL;
894 	srv->respect_exportok = D_RESPECTEXPORTOK;
895 
896 	srv->max_repos_display = D_MAXREPODISP;
897 	srv->max_commits_display = D_MAXCOMMITDISP;
898 	srv->max_repos = D_MAXREPO;
899 
900 	srv->unix_socket = 1;
901 	srv->fcgi_socket = 0;
902 
903 	TAILQ_INIT(&srv->al);
904 	TAILQ_INSERT_TAIL(&gotwebd->servers, srv, entry);
905 	gotwebd->server_cnt++;
906 
907 	return srv;
908 };
909 
910 int
911 symset(const char *nam, const char *val, int persist)
912 {
913 	struct sym *sym;
914 
915 	TAILQ_FOREACH(sym, &symhead, entry) {
916 		if (strcmp(nam, sym->nam) == 0)
917 			break;
918 	}
919 
920 	if (sym != NULL) {
921 		if (sym->persist == 1)
922 			return (0);
923 		else {
924 			free(sym->nam);
925 			free(sym->val);
926 			TAILQ_REMOVE(&symhead, sym, entry);
927 			free(sym);
928 		}
929 	}
930 	sym = calloc(1, sizeof(*sym));
931 	if (sym == NULL)
932 		return (-1);
933 
934 	sym->nam = strdup(nam);
935 	if (sym->nam == NULL) {
936 		free(sym);
937 		return (-1);
938 	}
939 	sym->val = strdup(val);
940 	if (sym->val == NULL) {
941 		free(sym->nam);
942 		free(sym);
943 		return (-1);
944 	}
945 	sym->used = 0;
946 	sym->persist = persist;
947 	TAILQ_INSERT_TAIL(&symhead, sym, entry);
948 	return (0);
949 }
950 
951 int
952 cmdline_symset(char *s)
953 {
954 	char *sym, *val;
955 	int ret;
956 
957 	val = strrchr(s, '=');
958 	if (val == NULL)
959 		return (-1);
960 
961 	sym = strndup(s, val - s);
962 	if (sym == NULL)
963 		fatal("%s: strndup", __func__);
964 
965 	ret = symset(sym, val + 1, 1);
966 	free(sym);
967 
968 	return (ret);
969 }
970 
971 char *
972 symget(const char *nam)
973 {
974 	struct sym *sym;
975 
976 	TAILQ_FOREACH(sym, &symhead, entry) {
977 		if (strcmp(nam, sym->nam) == 0) {
978 			sym->used = 1;
979 			return (sym->val);
980 		}
981 	}
982 	return (NULL);
983 }
984 
985 int
986 getservice(const char *n)
987 {
988 	struct servent *s;
989 	const char *errstr;
990 	long long llval;
991 
992 	llval = strtonum(n, 0, UINT16_MAX, &errstr);
993 	if (errstr) {
994 		s = getservbyname(n, "tcp");
995 		if (s == NULL)
996 			s = getservbyname(n, "udp");
997 		if (s == NULL)
998 			return (-1);
999 		return ntohs(s->s_port);
1000 	}
1001 
1002 	return (unsigned short)llval;
1003 }
1004 
1005 struct address *
1006 host_v4(const char *s)
1007 {
1008 	struct in_addr ina;
1009 	struct sockaddr_in *sain;
1010 	struct address *h;
1011 
1012 	memset(&ina, 0, sizeof(ina));
1013 	if (inet_pton(AF_INET, s, &ina) != 1)
1014 		return (NULL);
1015 
1016 	if ((h = calloc(1, sizeof(*h))) == NULL)
1017 		fatal(__func__);
1018 	sain = (struct sockaddr_in *)&h->ss;
1019 	got_sockaddr_inet_init(sain, &ina);
1020 	if (sain->sin_addr.s_addr == INADDR_ANY)
1021 		h->prefixlen = 0; /* 0.0.0.0 address */
1022 	else
1023 		h->prefixlen = -1; /* host address */
1024 	return (h);
1025 }
1026 
1027 struct address *
1028 host_v6(const char *s)
1029 {
1030 	struct addrinfo hints, *res;
1031 	struct sockaddr_in6 *sa_in6, *ra;
1032 	struct address *h = NULL;
1033 
1034 	memset(&hints, 0, sizeof(hints));
1035 	hints.ai_family = AF_INET6;
1036 	hints.ai_socktype = SOCK_DGRAM; /* dummy */
1037 	hints.ai_flags = AI_NUMERICHOST;
1038 	if (getaddrinfo(s, "0", &hints, &res) == 0) {
1039 		if ((h = calloc(1, sizeof(*h))) == NULL)
1040 			fatal(__func__);
1041 		sa_in6 = (struct sockaddr_in6 *)&h->ss;
1042 		ra = (struct sockaddr_in6 *)res->ai_addr;
1043 		got_sockaddr_inet6_init(sa_in6, &ra->sin6_addr,
1044 		    ra->sin6_scope_id);
1045 		if (memcmp(&sa_in6->sin6_addr, &in6addr_any,
1046 		    sizeof(sa_in6->sin6_addr)) == 0)
1047 			h->prefixlen = 0; /* any address */
1048 		else
1049 			h->prefixlen = -1; /* host address */
1050 		freeaddrinfo(res);
1051 	}
1052 
1053 	return (h);
1054 }
1055 
1056 int
1057 host_dns(const char *s, struct server *new_srv, int max,
1058     in_port_t port, const char *ifname, int ipproto)
1059 {
1060 	struct addrinfo hints, *res0, *res;
1061 	int error, cnt = 0;
1062 	struct sockaddr_in *sain;
1063 	struct sockaddr_in6 *sin6;
1064 	struct address *h;
1065 
1066 	if ((cnt = host_if(s, new_srv, max, port, ifname, ipproto)) != 0)
1067 		return (cnt);
1068 
1069 	memset(&hints, 0, sizeof(hints));
1070 	hints.ai_family = PF_UNSPEC;
1071 	hints.ai_socktype = SOCK_DGRAM; /* DUMMY */
1072 	hints.ai_flags = AI_ADDRCONFIG;
1073 	error = getaddrinfo(s, NULL, &hints, &res0);
1074 	if (error == EAI_AGAIN || error == EAI_NODATA || error == EAI_NONAME)
1075 		return (0);
1076 	if (error) {
1077 		log_warnx("%s: could not parse \"%s\": %s", __func__, s,
1078 		    gai_strerror(error));
1079 		return (-1);
1080 	}
1081 
1082 	for (res = res0; res && cnt < max; res = res->ai_next) {
1083 		if (res->ai_family != AF_INET &&
1084 		    res->ai_family != AF_INET6)
1085 			continue;
1086 		if ((h = calloc(1, sizeof(*h))) == NULL)
1087 			fatal(__func__);
1088 
1089 		if (port)
1090 			h->port = port;
1091 		if (ifname != NULL) {
1092 			if (strlcpy(h->ifname, ifname, sizeof(h->ifname)) >=
1093 			    sizeof(h->ifname)) {
1094 				log_warnx("%s: interface name truncated",
1095 				    __func__);
1096 				freeaddrinfo(res0);
1097 				free(h);
1098 				return (-1);
1099 			}
1100 		}
1101 		if (ipproto != -1)
1102 			h->ipproto = ipproto;
1103 		h->ss.ss_family = res->ai_family;
1104 		h->prefixlen = -1; /* host address */
1105 
1106 		if (res->ai_family == AF_INET) {
1107 			struct sockaddr_in *ra;
1108 			sain = (struct sockaddr_in *)&h->ss;
1109 			ra = (struct sockaddr_in *)res->ai_addr;
1110 			got_sockaddr_inet_init(sain, &ra->sin_addr);
1111 		} else {
1112 			struct sockaddr_in6 *ra;
1113 			sin6 = (struct sockaddr_in6 *)&h->ss;
1114 			ra = (struct sockaddr_in6 *)res->ai_addr;
1115 			got_sockaddr_inet6_init(sin6, &ra->sin6_addr, 0);
1116 		}
1117 
1118 		if (add_addr(new_srv, h))
1119 			return -1;
1120 		cnt++;
1121 	}
1122 	if (cnt == max && res) {
1123 		log_warnx("%s: %s resolves to more than %d hosts", __func__,
1124 		    s, max);
1125 	}
1126 	freeaddrinfo(res0);
1127 	return (cnt);
1128 }
1129 
1130 int
1131 host_if(const char *s, struct server *new_srv, int max,
1132     in_port_t port, const char *ifname, int ipproto)
1133 {
1134 	struct ifaddrs *ifap, *p;
1135 	struct sockaddr_in *sain;
1136 	struct sockaddr_in6 *sin6;
1137 	struct address *h;
1138 	int cnt = 0, af;
1139 
1140 	if (getifaddrs(&ifap) == -1)
1141 		fatal("getifaddrs");
1142 
1143 	/* First search for IPv4 addresses */
1144 	af = AF_INET;
1145 
1146  nextaf:
1147 	for (p = ifap; p != NULL && cnt < max; p = p->ifa_next) {
1148 		if (p->ifa_addr == NULL ||
1149 		    p->ifa_addr->sa_family != af ||
1150 		    (strcmp(s, p->ifa_name) != 0 &&
1151 		    !is_if_in_group(p->ifa_name, s)))
1152 			continue;
1153 		if ((h = calloc(1, sizeof(*h))) == NULL)
1154 			fatal("calloc");
1155 
1156 		if (port)
1157 			h->port = port;
1158 		if (ifname != NULL) {
1159 			if (strlcpy(h->ifname, ifname, sizeof(h->ifname)) >=
1160 			    sizeof(h->ifname)) {
1161 				log_warnx("%s: interface name truncated",
1162 				    __func__);
1163 				free(h);
1164 				freeifaddrs(ifap);
1165 				return (-1);
1166 			}
1167 		}
1168 		if (ipproto != -1)
1169 			h->ipproto = ipproto;
1170 		h->ss.ss_family = af;
1171 		h->prefixlen = -1; /* host address */
1172 
1173 		if (af == AF_INET) {
1174 			struct sockaddr_in *ra;
1175 			sain = (struct sockaddr_in *)&h->ss;
1176 			ra = (struct sockaddr_in *)p->ifa_addr;
1177 			got_sockaddr_inet_init(sain, &ra->sin_addr);
1178 		} else {
1179 			struct sockaddr_in6 *ra;
1180 			sin6 = (struct sockaddr_in6 *)&h->ss;
1181 			ra = (struct sockaddr_in6 *)p->ifa_addr;
1182 			got_sockaddr_inet6_init(sin6, &ra->sin6_addr,
1183 			    ra->sin6_scope_id);
1184 		}
1185 
1186 		if (add_addr(new_srv, h))
1187 			return -1;
1188 		cnt++;
1189 	}
1190 	if (af == AF_INET) {
1191 		/* Next search for IPv6 addresses */
1192 		af = AF_INET6;
1193 		goto nextaf;
1194 	}
1195 
1196 	if (cnt > max) {
1197 		log_warnx("%s: %s resolves to more than %d hosts", __func__,
1198 		    s, max);
1199 	}
1200 	freeifaddrs(ifap);
1201 	return (cnt);
1202 }
1203 
1204 int
1205 host(const char *s, struct server *new_srv, int max,
1206     in_port_t port, const char *ifname, int ipproto)
1207 {
1208 	struct address *h;
1209 
1210 	h = host_v4(s);
1211 
1212 	/* IPv6 address? */
1213 	if (h == NULL)
1214 		h = host_v6(s);
1215 
1216 	if (h != NULL) {
1217 		if (port)
1218 			h->port = port;
1219 		if (ifname != NULL) {
1220 			if (strlcpy(h->ifname, ifname, sizeof(h->ifname)) >=
1221 			    sizeof(h->ifname)) {
1222 				log_warnx("%s: interface name truncated",
1223 				    __func__);
1224 				free(h);
1225 				return (-1);
1226 			}
1227 		}
1228 		if (ipproto != -1)
1229 			h->ipproto = ipproto;
1230 
1231 		if (add_addr(new_srv, h))
1232 			return -1;
1233 		return (1);
1234 	}
1235 
1236 	return (host_dns(s, new_srv, max, port, ifname, ipproto));
1237 }
1238 
1239 int
1240 is_if_in_group(const char *ifname, const char *groupname)
1241 {
1242 /* TA: Check this... */
1243 #ifdef HAVE_STRUCT_IFGROUPREQ
1244 	unsigned int len;
1245 	struct ifgroupreq ifgr;
1246 	struct ifg_req *ifg;
1247 	int s;
1248 	int ret = 0;
1249 
1250 	if ((s = socket(AF_INET, SOCK_DGRAM, 0)) == -1)
1251 		err(1, "socket");
1252 
1253 	memset(&ifgr, 0, sizeof(ifgr));
1254 	if (strlcpy(ifgr.ifgr_name, ifname, IFNAMSIZ) >= IFNAMSIZ)
1255 		err(1, "IFNAMSIZ");
1256 	if (ioctl(s, SIOCGIFGROUP, (caddr_t)&ifgr) == -1) {
1257 		if (errno == EINVAL || errno == ENOTTY)
1258 			goto end;
1259 		err(1, "SIOCGIFGROUP");
1260 	}
1261 
1262 	len = ifgr.ifgr_len;
1263 	ifgr.ifgr_groups = calloc(len / sizeof(struct ifg_req),
1264 	    sizeof(struct ifg_req));
1265 	if (ifgr.ifgr_groups == NULL)
1266 		err(1, "getifgroups");
1267 	if (ioctl(s, SIOCGIFGROUP, (caddr_t)&ifgr) == -1)
1268 		err(1, "SIOCGIFGROUP");
1269 
1270 	ifg = ifgr.ifgr_groups;
1271 	for (; ifg && len >= sizeof(struct ifg_req); ifg++) {
1272 		len -= sizeof(struct ifg_req);
1273 		if (strcmp(ifg->ifgrq_group, groupname) == 0) {
1274 			ret = 1;
1275 			break;
1276 		}
1277 	}
1278 	free(ifgr.ifgr_groups);
1279 
1280 end:
1281 	close(s);
1282 	return (ret);
1283 #else
1284 	return (0);
1285 #endif
1286 }
1287 
1288 int
1289 get_addrs(const char *addr, struct server *new_srv, in_port_t port)
1290 {
1291 	if (strcmp("", addr) == 0) {
1292 		if (host("127.0.0.1", new_srv, 1, port, "127.0.0.1",
1293 		    -1) <= 0) {
1294 			yyerror("invalid listen ip: %s",
1295 			    "127.0.0.1");
1296 			return (-1);
1297 		}
1298 		if (host("::1", new_srv, 1, port, "::1", -1) <= 0) {
1299 			yyerror("invalid listen ip: %s", "::1");
1300 			return (-1);
1301 		}
1302 	} else {
1303 		if (host(addr, new_srv, GOTWEBD_MAXIFACE, port, addr,
1304 		    -1) <= 0) {
1305 			yyerror("invalid listen ip: %s", addr);
1306 			return (-1);
1307 		}
1308 	}
1309 	return (0);
1310 }
1311 
1312 int
1313 addr_dup_check(struct addresslist *al, struct address *h, const char *new_srv,
1314     const char *other_srv)
1315 {
1316 	struct address *a;
1317 	void *ia;
1318 	char buf[INET6_ADDRSTRLEN];
1319 	const char *addrstr;
1320 
1321 	TAILQ_FOREACH(a, al, entry) {
1322 		if (memcmp(&a->ss, &h->ss, sizeof(h->ss)) != 0 ||
1323 		    a->port != h->port)
1324 			continue;
1325 
1326 		switch (h->ss.ss_family) {
1327 		case AF_INET:
1328 			ia = &((struct sockaddr_in *)(&h->ss))->sin_addr;
1329 			break;
1330 		case AF_INET6:
1331 			ia = &((struct sockaddr_in6 *)(&h->ss))->sin6_addr;
1332 			break;
1333 		default:
1334 			yyerror("unknown address family: %d", h->ss.ss_family);
1335 			return -1;
1336 		}
1337 		addrstr = inet_ntop(h->ss.ss_family, ia, buf, sizeof(buf));
1338 		if (addrstr) {
1339 			if (other_srv) {
1340 				yyerror("server %s: duplicate fcgi listen "
1341 				    "address %s:%d, already used by server %s",
1342 				    new_srv, addrstr, h->port, other_srv);
1343 			} else {
1344 				log_warnx("server: %s: duplicate fcgi listen "
1345 				    "address %s:%d", new_srv, addrstr, h->port);
1346 			}
1347 		} else {
1348 			if (other_srv) {
1349 				yyerror("server: %s: duplicate fcgi listen "
1350 				    "address, already used by server %s",
1351 				    new_srv, other_srv);
1352 			} else {
1353 				log_warnx("server %s: duplicate fcgi listen "
1354 				    "address", new_srv);
1355 			}
1356 		}
1357 
1358 		return -1;
1359 	}
1360 
1361 	return 0;
1362 }
1363 
1364 int
1365 add_addr(struct server *new_srv, struct address *h)
1366 {
1367 	struct server *srv;
1368 
1369 	/* Address cannot be shared between different servers. */
1370 	TAILQ_FOREACH(srv, &gotwebd->servers, entry) {
1371 		if (srv == new_srv)
1372 			continue;
1373 		if (addr_dup_check(&srv->al, h, new_srv->name, srv->name))
1374 			return -1;
1375 	}
1376 
1377 	/* Tolerate duplicate address lines within the scope of a server. */
1378 	if (addr_dup_check(&new_srv->al, h, NULL, NULL) == 0)
1379 		TAILQ_INSERT_TAIL(&new_srv->al, h, entry);
1380 	else
1381 		free(h);
1382 
1383 	return 0;
1384 }