op public repos

Blob

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