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 <sys/ioctl.h>
25 #include <sys/types.h>
26 #include <sys/queue.h>
27 #include <sys/socket.h>
28 #include <sys/stat.h>
29 #include <sys/un.h>
30 
31 #include <net/if.h>
32 #include <netinet/in.h>
33 
34 #include <arpa/inet.h>
35 
36 #include <ctype.h>
37 #include <err.h>
38 #include <errno.h>
39 #include <event.h>
40 #include <ifaddrs.h>
41 #include <imsg.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_reference.h"
52 
53 #include "gotwebd.h"
54 
55 TAILQ_HEAD(files, file)		 files = TAILQ_HEAD_INITIALIZER(files);
56 static struct file {
57 	TAILQ_ENTRY(file)	 entry;
58 	FILE			*stream;
59 	char			*name;
60 	int			 lineno;
61 	int			 errors;
62 } *file;
63 struct file	*newfile(const char *, int);
64 static void	 closefile(struct file *);
65 int		 check_file_secrecy(int, const char *);
66 int		 yyparse(void);
67 int		 yylex(void);
68 int		 yyerror(const char *, ...)
69     __attribute__((__format__ (printf, 1, 2)))
70     __attribute__((__nonnull__ (1)));
71 int		 kw_cmp(const void *, const void *);
72 int		 lookup(char *);
73 int		 lgetc(int);
74 int		 lungetc(int);
75 int		 findeol(void);
76 
77 TAILQ_HEAD(symhead, sym)	 symhead = TAILQ_HEAD_INITIALIZER(symhead);
78 struct sym {
79 	TAILQ_ENTRY(sym)	 entry;
80 	int			 used;
81 	int			 persist;
82 	char			*nam;
83 	char			*val;
84 };
85 
86 int	 symset(const char *, const char *, int);
87 char	*symget(const char *);
88 
89 static int		 errors;
90 
91 static struct gotwebd		*gotwebd;
92 static struct server		*new_srv;
93 static struct server		*conf_new_server(const char *);
94 int				 getservice(const char *);
95 int				 n;
96 
97 int		 get_addrs(const char *, const char *);
98 int		 get_unix_addr(const char *);
99 int		 addr_dup_check(struct addresslist *, struct address *);
100 int		 add_addr(struct address *);
101 
102 typedef struct {
103 	union {
104 		long long	 number;
105 		char		*string;
106 	} v;
107 	int lineno;
108 } YYSTYPE;
109 
110 %}
111 
112 %token	LISTEN WWW_PATH SITE_NAME SITE_OWNER SITE_LINK LOGO
113 %token	LOGO_URL SHOW_REPO_OWNER SHOW_REPO_AGE SHOW_REPO_DESCRIPTION
114 %token	MAX_REPOS_DISPLAY REPOS_PATH MAX_COMMITS_DISPLAY ON ERROR
115 %token	SHOW_SITE_OWNER SHOW_REPO_CLONEURL PORT PREFORK RESPECT_EXPORTOK
116 %token	SERVER CHROOT CUSTOM_CSS SOCKET
117 %token	SUMMARY_COMMITS_DISPLAY SUMMARY_TAGS_DISPLAY
118 
119 %token	<v.string>	STRING
120 %token	<v.number>	NUMBER
121 %type	<v.number>	boolean
122 %type	<v.string>	listen_addr
123 
124 %%
125 
126 grammar		: /* empty */
127 		| grammar '\n'
128 		| grammar varset '\n'
129 		| grammar main '\n'
130 		| grammar server '\n'
131 		| grammar error '\n'		{ file->errors++; }
132 		;
133 
134 varset		: STRING '=' STRING	{
135 			char *s = $1;
136 			while (*s++) {
137 				if (isspace((unsigned char)*s)) {
138 					yyerror("macro name cannot contain "
139 					    "whitespace");
140 					free($1);
141 					free($3);
142 					YYERROR;
143 				}
144 			}
145 			if (symset($1, $3, 0) == -1)
146 				fatal("cannot store variable");
147 			free($1);
148 			free($3);
149 		}
150 		;
151 
152 boolean		: STRING {
153 			if (strcasecmp($1, "1") == 0 ||
154 			    strcasecmp($1, "on") == 0)
155 				$$ = 1;
156 			else if (strcasecmp($1, "0") == 0 ||
157 			    strcasecmp($1, "off") == 0)
158 				$$ = 0;
159 			else {
160 				yyerror("invalid boolean value '%s'", $1);
161 				free($1);
162 				YYERROR;
163 			}
164 			free($1);
165 		}
166 		| ON { $$ = 1; }
167 		| NUMBER {
168 			if ($1 != 0 && $1 != 1) {
169 				yyerror("invalid boolean value '%lld'", $1);
170 				YYERROR;
171 			}
172 			$$ = $1;
173 		}
174 		;
175 
176 listen_addr	: '*' { $$ = NULL; }
177 		| STRING
178 		;
179 
180 main		: PREFORK NUMBER {
181 			if ($2 <= 0 || $2 > PROC_MAX_INSTANCES) {
182 				yyerror("prefork is %s: %lld",
183 				    $2 <= 0 ? "too small" : "too large", $2);
184 				YYERROR;
185 			}
186 			gotwebd->prefork_gotwebd = $2;
187 		}
188 		| CHROOT STRING {
189 			if (*$2 == '\0') {
190 				yyerror("chroot path can't be an empty"
191 				    " string");
192 				free($2);
193 				YYERROR;
194 			}
195 
196 			n = strlcpy(gotwebd->httpd_chroot, $2,
197 			    sizeof(gotwebd->httpd_chroot));
198 			if (n >= sizeof(gotwebd->httpd_chroot)) {
199 				yyerror("%s: httpd_chroot truncated", __func__);
200 				free($2);
201 				YYERROR;
202 			}
203 			free($2);
204 		}
205 		| LISTEN ON listen_addr PORT STRING {
206 			if (get_addrs($3, $5) == -1) {
207 				yyerror("could not get addrs");
208 				YYERROR;
209 			}
210 			free($3);
211 			free($5);
212 		}
213 		| LISTEN ON listen_addr PORT NUMBER {
214 			char portno[32];
215 			int n;
216 
217 			n = snprintf(portno, sizeof(portno), "%lld",
218 			    (long long)$5);
219 			if (n < 0 || (size_t)n >= sizeof(portno))
220 				fatalx("port number too long: %lld",
221 				    (long long)$5);
222 
223 			if (get_addrs($3, portno) == -1) {
224 				yyerror("could not get addrs");
225 				YYERROR;
226 			}
227 			free($3);
228 		}
229 		| LISTEN ON SOCKET STRING {
230 			if (get_unix_addr($4) == -1) {
231 				yyerror("can't listen on %s", $4);
232 				free($4);
233 				YYERROR;
234 			}
235 			free($4);
236 		}
237 		;
238 
239 server		: SERVER STRING {
240 			struct server *srv;
241 
242 			TAILQ_FOREACH(srv, &gotwebd->servers, entry) {
243 				if (strcmp(srv->name, $2) == 0) {
244 					yyerror("server name exists '%s'", $2);
245 					free($2);
246 					YYERROR;
247 				}
248 			}
249 
250 			new_srv = conf_new_server($2);
251 			log_debug("adding server %s", $2);
252 			free($2);
253 		}
254 		| SERVER STRING {
255 			struct server *srv;
256 
257 			TAILQ_FOREACH(srv, &gotwebd->servers, entry) {
258 				if (strcmp(srv->name, $2) == 0) {
259 					yyerror("server name exists '%s'", $2);
260 					free($2);
261 					YYERROR;
262 				}
263 			}
264 
265 			new_srv = conf_new_server($2);
266 			log_debug("adding server %s", $2);
267 			free($2);
268 		} '{' optnl serveropts2 '}' {
269 		}
270 		;
271 
272 serveropts1	: REPOS_PATH STRING {
273 			n = strlcpy(new_srv->repos_path, $2,
274 			    sizeof(new_srv->repos_path));
275 			if (n >= sizeof(new_srv->repos_path)) {
276 				yyerror("%s: repos_path truncated", __func__);
277 				free($2);
278 				YYERROR;
279 			}
280 			free($2);
281 		}
282 		| SITE_NAME STRING {
283 			n = strlcpy(new_srv->site_name, $2,
284 			    sizeof(new_srv->site_name));
285 			if (n >= sizeof(new_srv->site_name)) {
286 				yyerror("%s: site_name truncated", __func__);
287 				free($2);
288 				YYERROR;
289 			}
290 			free($2);
291 		}
292 		| SITE_OWNER STRING {
293 			n = strlcpy(new_srv->site_owner, $2,
294 			    sizeof(new_srv->site_owner));
295 			if (n >= sizeof(new_srv->site_owner)) {
296 				yyerror("%s: site_owner truncated", __func__);
297 				free($2);
298 				YYERROR;
299 			}
300 			free($2);
301 		}
302 		| SITE_LINK STRING {
303 			n = strlcpy(new_srv->site_link, $2,
304 			    sizeof(new_srv->site_link));
305 			if (n >= sizeof(new_srv->site_link)) {
306 				yyerror("%s: site_link truncated", __func__);
307 				free($2);
308 				YYERROR;
309 			}
310 			free($2);
311 		}
312 		| LOGO STRING {
313 			n = strlcpy(new_srv->logo, $2, sizeof(new_srv->logo));
314 			if (n >= sizeof(new_srv->logo)) {
315 				yyerror("%s: logo truncated", __func__);
316 				free($2);
317 				YYERROR;
318 			}
319 			free($2);
320 		}
321 		| LOGO_URL STRING {
322 			n = strlcpy(new_srv->logo_url, $2,
323 			    sizeof(new_srv->logo_url));
324 			if (n >= sizeof(new_srv->logo_url)) {
325 				yyerror("%s: logo_url truncated", __func__);
326 				free($2);
327 				YYERROR;
328 			}
329 			free($2);
330 		}
331 		| CUSTOM_CSS STRING {
332 			n = strlcpy(new_srv->custom_css, $2,
333 			    sizeof(new_srv->custom_css));
334 			if (n >= sizeof(new_srv->custom_css)) {
335 				yyerror("%s: custom_css truncated", __func__);
336 				free($2);
337 				YYERROR;
338 			}
339 			free($2);
340 		}
341 		| SHOW_SITE_OWNER boolean {
342 			new_srv->show_site_owner = $2;
343 		}
344 		| SHOW_REPO_OWNER boolean {
345 			new_srv->show_repo_owner = $2;
346 		}
347 		| SHOW_REPO_AGE boolean {
348 			new_srv->show_repo_age = $2;
349 		}
350 		| SHOW_REPO_DESCRIPTION boolean {
351 			new_srv->show_repo_description = $2;
352 		}
353 		| SHOW_REPO_CLONEURL boolean {
354 			new_srv->show_repo_cloneurl = $2;
355 		}
356 		| RESPECT_EXPORTOK boolean {
357 			new_srv->respect_exportok = $2;
358 		}
359 		| MAX_REPOS_DISPLAY NUMBER {
360 			if ($2 < 0) {
361 				yyerror("max_repos_display is too small: %lld",
362 				    $2);
363 				YYERROR;
364 			}
365 			new_srv->max_repos_display = $2;
366 		}
367 		| MAX_COMMITS_DISPLAY NUMBER {
368 			if ($2 <= 1) {
369 				yyerror("max_commits_display is too small:"
370 				    " %lld", $2);
371 				YYERROR;
372 			}
373 			new_srv->max_commits_display = $2;
374 		}
375 		| SUMMARY_COMMITS_DISPLAY NUMBER {
376 			if ($2 < 1) {
377 				yyerror("summary_commits_display is too small:"
378 				    " %lld", $2);
379 				YYERROR;
380 			}
381 			new_srv->summary_commits_display = $2;
382 		}
383 		| SUMMARY_TAGS_DISPLAY NUMBER {
384 			if ($2 < 1) {
385 				yyerror("summary_tags_display is too small:"
386 				    " %lld", $2);
387 				YYERROR;
388 			}
389 			new_srv->summary_tags_display = $2;
390 		}
391 		;
392 
393 serveropts2	: serveropts2 serveropts1 nl
394 		| serveropts1 optnl
395 		;
396 
397 nl		: '\n' optnl
398 		;
399 
400 optnl		: '\n' optnl		/* zero or more newlines */
401 		| /* empty */
402 		;
403 
404 %%
405 
406 struct keywords {
407 	const char	*k_name;
408 	int		 k_val;
409 };
410 
411 int
412 yyerror(const char *fmt, ...)
413 {
414 	va_list ap;
415 	char *msg;
416 
417 	file->errors++;
418 	va_start(ap, fmt);
419 	if (vasprintf(&msg, fmt, ap) == -1)
420 		fatalx("yyerror vasprintf");
421 	va_end(ap);
422 	logit(LOG_CRIT, "%s:%d: %s", file->name, yylval.lineno, msg);
423 	free(msg);
424 	return (0);
425 }
426 
427 int
428 kw_cmp(const void *k, const void *e)
429 {
430 	return (strcmp(k, ((const struct keywords *)e)->k_name));
431 }
432 
433 int
434 lookup(char *s)
435 {
436 	/* This has to be sorted always. */
437 	static const struct keywords keywords[] = {
438 		{ "chroot",			CHROOT },
439 		{ "custom_css",			CUSTOM_CSS },
440 		{ "listen",			LISTEN },
441 		{ "logo",			LOGO },
442 		{ "logo_url",			LOGO_URL },
443 		{ "max_commits_display",	MAX_COMMITS_DISPLAY },
444 		{ "max_repos_display",		MAX_REPOS_DISPLAY },
445 		{ "on",				ON },
446 		{ "port",			PORT },
447 		{ "prefork",			PREFORK },
448 		{ "repos_path",			REPOS_PATH },
449 		{ "respect_exportok",		RESPECT_EXPORTOK },
450 		{ "server",			SERVER },
451 		{ "show_repo_age",		SHOW_REPO_AGE },
452 		{ "show_repo_cloneurl",		SHOW_REPO_CLONEURL },
453 		{ "show_repo_description",	SHOW_REPO_DESCRIPTION },
454 		{ "show_repo_owner",		SHOW_REPO_OWNER },
455 		{ "show_site_owner",		SHOW_SITE_OWNER },
456 		{ "site_link",			SITE_LINK },
457 		{ "site_name",			SITE_NAME },
458 		{ "site_owner",			SITE_OWNER },
459 		{ "socket",			SOCKET },
460 		{ "summary_commits_display",	SUMMARY_COMMITS_DISPLAY },
461 		{ "summary_tags_display",	SUMMARY_TAGS_DISPLAY },
462 	};
463 	const struct keywords *p;
464 
465 	p = bsearch(s, keywords, sizeof(keywords)/sizeof(keywords[0]),
466 	    sizeof(keywords[0]), kw_cmp);
467 
468 	if (p)
469 		return (p->k_val);
470 	else
471 		return (STRING);
472 }
473 
474 #define MAXPUSHBACK	128
475 
476 unsigned char *parsebuf;
477 int parseindex;
478 unsigned char pushback_buffer[MAXPUSHBACK];
479 int pushback_index = 0;
480 
481 int
482 lgetc(int quotec)
483 {
484 	int c, next;
485 
486 	if (parsebuf) {
487 		/* Read character from the parsebuffer instead of input. */
488 		if (parseindex >= 0) {
489 			c = parsebuf[parseindex++];
490 			if (c != '\0')
491 				return (c);
492 			parsebuf = NULL;
493 		} else
494 			parseindex++;
495 	}
496 
497 	if (pushback_index)
498 		return (pushback_buffer[--pushback_index]);
499 
500 	if (quotec) {
501 		c = getc(file->stream);
502 		if (c == EOF)
503 			yyerror("reached end of file while parsing "
504 			    "quoted string");
505 		return (c);
506 	}
507 
508 	c = getc(file->stream);
509 	while (c == '\\') {
510 		next = getc(file->stream);
511 		if (next != '\n') {
512 			c = next;
513 			break;
514 		}
515 		yylval.lineno = file->lineno;
516 		file->lineno++;
517 		c = getc(file->stream);
518 	}
519 
520 	return (c);
521 }
522 
523 int
524 lungetc(int c)
525 {
526 	if (c == EOF)
527 		return (EOF);
528 	if (parsebuf) {
529 		parseindex--;
530 		if (parseindex >= 0)
531 			return (c);
532 	}
533 	if (pushback_index < MAXPUSHBACK-1)
534 		return (pushback_buffer[pushback_index++] = c);
535 	else
536 		return (EOF);
537 }
538 
539 int
540 findeol(void)
541 {
542 	int c;
543 
544 	parsebuf = NULL;
545 
546 	/* Skip to either EOF or the first real EOL. */
547 	while (1) {
548 		if (pushback_index)
549 			c = pushback_buffer[--pushback_index];
550 		else
551 			c = lgetc(0);
552 		if (c == '\n') {
553 			file->lineno++;
554 			break;
555 		}
556 		if (c == EOF)
557 			break;
558 	}
559 	return (ERROR);
560 }
561 
562 int
563 yylex(void)
564 {
565 	unsigned char buf[8096];
566 	unsigned char *p, *val;
567 	int quotec, next, c;
568 	int token;
569 
570 top:
571 	p = buf;
572 	c = lgetc(0);
573 	while (c == ' ' || c == '\t')
574 		c = lgetc(0); /* nothing */
575 
576 	yylval.lineno = file->lineno;
577 	if (c == '#') {
578 		c = lgetc(0);
579 		while (c != '\n' && c != EOF)
580 			c = lgetc(0); /* nothing */
581 	}
582 	if (c == '$' && parsebuf == NULL) {
583 		while (1) {
584 			c = lgetc(0);
585 			if (c == EOF)
586 				return (0);
587 
588 			if (p + 1 >= buf + sizeof(buf) - 1) {
589 				yyerror("string too long");
590 				return (findeol());
591 			}
592 			if (isalnum(c) || c == '_') {
593 				*p++ = c;
594 				continue;
595 			}
596 			*p = '\0';
597 			lungetc(c);
598 			break;
599 		}
600 		val = symget(buf);
601 		if (val == NULL) {
602 			yyerror("macro '%s' not defined", buf);
603 			return (findeol());
604 		}
605 		parsebuf = val;
606 		parseindex = 0;
607 		goto top;
608 	}
609 
610 	switch (c) {
611 	case '\'':
612 	case '"':
613 		quotec = c;
614 		while (1) {
615 			c = lgetc(quotec);
616 			if (c == EOF)
617 				return (0);
618 			if (c == '\n') {
619 				file->lineno++;
620 				continue;
621 			} else if (c == '\\') {
622 				next = lgetc(quotec);
623 				if (next == EOF)
624 					return (0);
625 				if (next == quotec || c == ' ' || c == '\t')
626 					c = next;
627 				else if (next == '\n') {
628 					file->lineno++;
629 					continue;
630 				} else
631 					lungetc(next);
632 			} else if (c == quotec) {
633 				*p = '\0';
634 				break;
635 			} else if (c == '\0') {
636 				yyerror("syntax error");
637 				return (findeol());
638 			}
639 			if (p + 1 >= buf + sizeof(buf) - 1) {
640 				yyerror("string too long");
641 				return (findeol());
642 			}
643 			*p++ = c;
644 		}
645 		yylval.v.string = strdup(buf);
646 		if (yylval.v.string == NULL)
647 			err(1, "yylex: strdup");
648 		return (STRING);
649 	}
650 
651 #define allowed_to_end_number(x) \
652 	(isspace(x) || x == ')' || x ==',' || x == '/' || x == '}' || x == '=')
653 
654 	if (c == '-' || isdigit(c)) {
655 		do {
656 			*p++ = c;
657 			if ((unsigned)(p-buf) >= sizeof(buf)) {
658 				yyerror("string too long");
659 				return (findeol());
660 			}
661 			c = lgetc(0);
662 		} while (c != EOF && isdigit(c));
663 		lungetc(c);
664 		if (p == buf + 1 && buf[0] == '-')
665 			goto nodigits;
666 		if (c == EOF || allowed_to_end_number(c)) {
667 			const char *errstr = NULL;
668 
669 			*p = '\0';
670 			yylval.v.number = strtonum(buf, LLONG_MIN,
671 			    LLONG_MAX, &errstr);
672 			if (errstr) {
673 				yyerror("\"%s\" invalid number: %s",
674 				    buf, errstr);
675 				return (findeol());
676 			}
677 			return (NUMBER);
678 		} else {
679 nodigits:
680 			while (p > buf + 1)
681 				lungetc(*--p);
682 			c = *--p;
683 			if (c == '-')
684 				return (c);
685 		}
686 	}
687 
688 #define allowed_in_string(x) \
689 	(isalnum(x) || (ispunct(x) && x != '(' && x != ')' && \
690 	x != '{' && x != '}' && \
691 	x != '!' && x != '=' && x != '#' && \
692 	x != ','))
693 
694 	if (isalnum(c) || c == ':' || c == '_') {
695 		do {
696 			*p++ = c;
697 			if ((unsigned)(p-buf) >= sizeof(buf)) {
698 				yyerror("string too long");
699 				return (findeol());
700 			}
701 			c = lgetc(0);
702 		} while (c != EOF && (allowed_in_string(c)));
703 		lungetc(c);
704 		*p = '\0';
705 		token = lookup(buf);
706 		if (token == STRING) {
707 			yylval.v.string = strdup(buf);
708 			if (yylval.v.string == NULL)
709 				err(1, "yylex: strdup");
710 		}
711 		return (token);
712 	}
713 	if (c == '\n') {
714 		yylval.lineno = file->lineno;
715 		file->lineno++;
716 	}
717 	if (c == EOF)
718 		return (0);
719 	return (c);
720 }
721 
722 int
723 check_file_secrecy(int fd, const char *fname)
724 {
725 	struct stat st;
726 
727 	if (fstat(fd, &st)) {
728 		log_warn("cannot stat %s", fname);
729 		return (-1);
730 	}
731 	if (st.st_uid != 0 && st.st_uid != getuid()) {
732 		log_warnx("%s: owner not root or current user", fname);
733 		return (-1);
734 	}
735 	if (st.st_mode & (S_IWGRP | S_IXGRP | S_IRWXO)) {
736 		log_warnx("%s: group writable or world read/writable", fname);
737 		return (-1);
738 	}
739 	return (0);
740 }
741 
742 struct file *
743 newfile(const char *name, int secret)
744 {
745 	struct file *nfile;
746 
747 	nfile = calloc(1, sizeof(struct file));
748 	if (nfile == NULL) {
749 		log_warn("calloc");
750 		return (NULL);
751 	}
752 	nfile->name = strdup(name);
753 	if (nfile->name == NULL) {
754 		log_warn("strdup");
755 		free(nfile);
756 		return (NULL);
757 	}
758 	nfile->stream = fopen(nfile->name, "r");
759 	if (nfile->stream == NULL) {
760 		/* no warning, we don't require a conf file */
761 		free(nfile->name);
762 		free(nfile);
763 		return (NULL);
764 	} else if (secret &&
765 	    check_file_secrecy(fileno(nfile->stream), nfile->name)) {
766 		fclose(nfile->stream);
767 		free(nfile->name);
768 		free(nfile);
769 		return (NULL);
770 	}
771 	nfile->lineno = 1;
772 	return (nfile);
773 }
774 
775 static void
776 closefile(struct file *xfile)
777 {
778 	fclose(xfile->stream);
779 	free(xfile->name);
780 	free(xfile);
781 }
782 
783 static void
784 add_default_server(void)
785 {
786 	new_srv = conf_new_server(D_SITENAME);
787 	log_debug("%s: adding default server %s", __func__, D_SITENAME);
788 }
789 
790 int
791 parse_config(const char *filename, struct gotwebd *env)
792 {
793 	struct sym *sym, *next;
794 
795 	if (config_init(env) == -1)
796 		fatalx("failed to initialize configuration");
797 
798 	gotwebd = env;
799 
800 	file = newfile(filename, 0);
801 	if (file == NULL) {
802 		add_default_server();
803 		sockets_parse_sockets(env);
804 		/* just return, as we don't require a conf file */
805 		return (0);
806 	}
807 
808 	yyparse();
809 	errors = file->errors;
810 	closefile(file);
811 
812 	/* Free macros and check which have not been used. */
813 	TAILQ_FOREACH_SAFE(sym, &symhead, entry, next) {
814 		if ((gotwebd->gotwebd_verbose > 1) && !sym->used)
815 			fprintf(stderr, "warning: macro '%s' not used\n",
816 			    sym->nam);
817 		if (!sym->persist) {
818 			free(sym->nam);
819 			free(sym->val);
820 			TAILQ_REMOVE(&symhead, sym, entry);
821 			free(sym);
822 		}
823 	}
824 
825 	/* just add default server if no config specified */
826 	if (gotwebd->server_cnt == 0)
827 		add_default_server();
828 
829 	/* add the implicit listen on socket */
830 	if (TAILQ_EMPTY(&gotwebd->addresses)) {
831 		const char *path = D_HTTPD_CHROOT D_UNIX_SOCKET;
832 		if (get_unix_addr(path) == -1)
833 			yyerror("can't listen on %s", path);
834 	}
835 
836 	if (errors)
837 		return (-1);
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 = strlcpy(srv->repos_path, D_GOTPATH,
858 	    sizeof(srv->repos_path));
859 	if (n >= sizeof(srv->repos_path))
860 		fatalx("%s: strlcpy", __func__);
861 	n = strlcpy(srv->site_name, D_SITENAME,
862 	    sizeof(srv->site_name));
863 	if (n >= sizeof(srv->site_name))
864 		fatalx("%s: strlcpy", __func__);
865 	n = strlcpy(srv->site_owner, D_SITEOWNER,
866 	    sizeof(srv->site_owner));
867 	if (n >= sizeof(srv->site_owner))
868 		fatalx("%s: strlcpy", __func__);
869 	n = strlcpy(srv->site_link, D_SITELINK,
870 	    sizeof(srv->site_link));
871 	if (n >= sizeof(srv->site_link))
872 		fatalx("%s: strlcpy", __func__);
873 	n = strlcpy(srv->logo, D_GOTLOGO,
874 	    sizeof(srv->logo));
875 	if (n >= sizeof(srv->logo))
876 		fatalx("%s: strlcpy", __func__);
877 	n = strlcpy(srv->logo_url, D_GOTURL, sizeof(srv->logo_url));
878 	if (n >= sizeof(srv->logo_url))
879 		fatalx("%s: strlcpy", __func__);
880 	n = strlcpy(srv->custom_css, D_GOTWEBCSS, sizeof(srv->custom_css));
881 	if (n >= sizeof(srv->custom_css))
882 		fatalx("%s: strlcpy", __func__);
883 
884 	srv->show_site_owner = D_SHOWSOWNER;
885 	srv->show_repo_owner = D_SHOWROWNER;
886 	srv->show_repo_age = D_SHOWAGE;
887 	srv->show_repo_description = D_SHOWDESC;
888 	srv->show_repo_cloneurl = D_SHOWURL;
889 	srv->respect_exportok = D_RESPECTEXPORTOK;
890 
891 	srv->max_repos_display = D_MAXREPODISP;
892 	srv->max_commits_display = D_MAXCOMMITDISP;
893 	srv->summary_commits_display = D_MAXSLCOMMDISP;
894 	srv->summary_tags_display = D_MAXSLTAGDISP;
895 
896 	TAILQ_INSERT_TAIL(&gotwebd->servers, srv, entry);
897 	gotwebd->server_cnt++;
898 
899 	return srv;
900 };
901 
902 int
903 symset(const char *nam, const char *val, int persist)
904 {
905 	struct sym *sym;
906 
907 	TAILQ_FOREACH(sym, &symhead, entry) {
908 		if (strcmp(nam, sym->nam) == 0)
909 			break;
910 	}
911 
912 	if (sym != NULL) {
913 		if (sym->persist == 1)
914 			return (0);
915 		else {
916 			free(sym->nam);
917 			free(sym->val);
918 			TAILQ_REMOVE(&symhead, sym, entry);
919 			free(sym);
920 		}
921 	}
922 	sym = calloc(1, sizeof(*sym));
923 	if (sym == NULL)
924 		return (-1);
925 
926 	sym->nam = strdup(nam);
927 	if (sym->nam == NULL) {
928 		free(sym);
929 		return (-1);
930 	}
931 	sym->val = strdup(val);
932 	if (sym->val == NULL) {
933 		free(sym->nam);
934 		free(sym);
935 		return (-1);
936 	}
937 	sym->used = 0;
938 	sym->persist = persist;
939 	TAILQ_INSERT_TAIL(&symhead, sym, entry);
940 	return (0);
941 }
942 
943 int
944 cmdline_symset(char *s)
945 {
946 	char *sym, *val;
947 	int ret;
948 
949 	val = strrchr(s, '=');
950 	if (val == NULL)
951 		return (-1);
952 
953 	sym = strndup(s, val - s);
954 	if (sym == NULL)
955 		fatal("%s: strndup", __func__);
956 
957 	ret = symset(sym, val + 1, 1);
958 	free(sym);
959 
960 	return (ret);
961 }
962 
963 char *
964 symget(const char *nam)
965 {
966 	struct sym *sym;
967 
968 	TAILQ_FOREACH(sym, &symhead, entry) {
969 		if (strcmp(nam, sym->nam) == 0) {
970 			sym->used = 1;
971 			return (sym->val);
972 		}
973 	}
974 	return (NULL);
975 }
976 
977 int
978 get_addrs(const char *hostname, const char *servname)
979 {
980 	struct addrinfo hints, *res0, *res;
981 	int error;
982 	struct sockaddr_in *sin;
983 	struct sockaddr_in6 *sin6;
984 	struct address *h;
985 
986 	memset(&hints, 0, sizeof(hints));
987 	hints.ai_family = AF_UNSPEC;
988 	hints.ai_socktype = SOCK_STREAM;
989 	hints.ai_flags = AI_PASSIVE | AI_ADDRCONFIG;
990 	error = getaddrinfo(hostname, servname, &hints, &res0);
991 	if (error) {
992 		log_warnx("%s: could not parse \"%s:%s\": %s", __func__,
993 		    hostname, servname, gai_strerror(error));
994 		return (-1);
995 	}
996 
997 	for (res = res0; res; res = res->ai_next) {
998 		if ((h = calloc(1, sizeof(*h))) == NULL)
999 			fatal(__func__);
1000 
1001 		if (hostname == NULL) {
1002 			strlcpy(h->ifname, "*", sizeof(h->ifname));
1003 		} else {
1004 			if (strlcpy(h->ifname, hostname, sizeof(h->ifname)) >=
1005 			    sizeof(h->ifname)) {
1006 				log_warnx("%s: address truncated: %s",
1007 				    __func__, hostname);
1008 				freeaddrinfo(res0);
1009 				free(h);
1010 				return (-1);
1011 			}
1012 		}
1013 
1014 		h->ai_family = res->ai_family;
1015 		h->ai_socktype = res->ai_socktype;
1016 		h->ai_protocol = res->ai_protocol;
1017 		memcpy(&h->ss, res->ai_addr, res->ai_addrlen);
1018 		h->slen = res->ai_addrlen;
1019 
1020 		switch (res->ai_family) {
1021 		case AF_INET:
1022 			sin = (struct sockaddr_in *)res->ai_addr;
1023 			h->port = ntohs(sin->sin_port);
1024 			break;
1025 		case AF_INET6:
1026 			sin6 = (struct sockaddr_in6 *)res->ai_addr;
1027 			h->port = ntohs(sin6->sin6_port);
1028 			break;
1029 		default:
1030 			fatalx("unknown address family %d", res->ai_family);
1031 		}
1032 
1033 		if (add_addr(h) == -1) {
1034 			freeaddrinfo(res0);
1035 			return -1;
1036 		}
1037 	}
1038 	freeaddrinfo(res0);
1039 	return (0);
1040 }
1041 
1042 int
1043 get_unix_addr(const char *path)
1044 {
1045 	struct address *h;
1046 	struct sockaddr_un *sun;
1047 
1048 	if ((h = calloc(1, sizeof(*h))) == NULL)
1049 		fatal("%s: calloc", __func__);
1050 
1051 	h->ai_family = AF_UNIX;
1052 	h->ai_socktype = SOCK_STREAM;
1053 	h->ai_protocol = PF_UNSPEC;
1054 	h->slen = sizeof(*sun);
1055 
1056 	sun = (struct sockaddr_un *)&h->ss;
1057 	sun->sun_family = AF_UNIX;
1058 	if (strlcpy(sun->sun_path, path, sizeof(sun->sun_path)) >=
1059 	    sizeof(sun->sun_path)) {
1060 		log_warnx("socket path too long: %s", sun->sun_path);
1061 		return (-1);
1062 	}
1063 
1064 	return add_addr(h);
1065 }
1066 
1067 int
1068 addr_dup_check(struct addresslist *al, struct address *h)
1069 {
1070 	struct address *a;
1071 
1072 	TAILQ_FOREACH(a, al, entry) {
1073 		if (a->ai_family != h->ai_family ||
1074 		    a->ai_socktype != h->ai_socktype ||
1075 		    a->ai_protocol != h->ai_protocol ||
1076 		    a->slen != h->slen ||
1077 		    memcmp(&a->ss, &h->ss, a->slen) != 0)
1078 			continue;
1079 		return -1;
1080 	}
1081 
1082 	return 0;
1083 }
1084 
1085 int
1086 add_addr(struct address *h)
1087 {
1088 	if (addr_dup_check(&gotwebd->addresses, h) == 0) {
1089 		TAILQ_INSERT_TAIL(&gotwebd->addresses, h, entry);
1090 		return (0);
1091 	}
1092 
1093 	free(h);
1094 	return (0);
1095 }