1 /*
2  * Copyright (c) 2020, 2021 Tracey Emery <tracey@openbsd.org>
3  * Copyright (c) 2020 Stefan Sperling <stsp@openbsd.org>
4  * Copyright (c) 2004, 2005 Esben Norby <norby@openbsd.org>
5  * Copyright (c) 2004 Ryan McBride <mcbride@openbsd.org>
6  * Copyright (c) 2002, 2003, 2004 Henning Brauer <henning@openbsd.org>
7  * Copyright (c) 2001 Markus Friedl.  All rights reserved.
8  * Copyright (c) 2001 Daniel Hartmeier.  All rights reserved.
9  * Copyright (c) 2001 Theo de Raadt.  All rights reserved.
10  *
11  * Permission to use, copy, modify, and distribute this software for any
12  * purpose with or without fee is hereby granted, provided that the above
13  * copyright notice and this permission notice appear in all copies.
14  *
15  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
16  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
17  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
18  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
19  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
20  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
21  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
22  */
23 
24 %{
25 #include "got_compat.h"
26 
27 #include <sys/types.h>
28 #include <sys/queue.h>
29 
30 #include <netdb.h>
31 
32 #include <ctype.h>
33 #include <err.h>
34 #include <errno.h>
35 #include <limits.h>
36 #include <stdarg.h>
37 #include <stdio.h>
38 #include <stdlib.h>
39 #include <string.h>
40 
41 #include "got_error.h"
42 #include "gotconfig.h"
43 
44 static struct file {
45 	FILE			*stream;
46 	const char		*name;
47 	size_t	 		 ungetpos;
48 	size_t			 ungetsize;
49 	u_char			*ungetbuf;
50 	int			 eof_reached;
51 	int			 lineno;
52 } *file;
53 static const struct got_error*	newfile(struct file**, const char *, int *);
54 static void	closefile(struct file *);
55 int		 yyparse(void);
56 int		 yylex(void);
57 int		 yyerror(const char *, ...)
58     __attribute__((__format__ (printf, 1, 2)))
59     __attribute__((__nonnull__ (1)));
60 int		 kw_cmp(const void *, const void *);
61 int		 lookup(char *);
62 int		 igetc(void);
63 int		 lgetc(int);
64 void		 lungetc(int);
65 int		 findeol(void);
66 static int	 parseport(char *, long long *);
67 
68 TAILQ_HEAD(symhead, sym)	 symhead = TAILQ_HEAD_INITIALIZER(symhead);
69 struct sym {
70 	TAILQ_ENTRY(sym)	 entry;
71 	int			 used;
72 	int			 persist;
73 	char			*nam;
74 	char			*val;
75 };
76 
77 int	 symset(const char *, const char *, int);
78 int	 cmdline_symset(char *);
79 char	*symget(const char *);
80 
81 static int	 atoul(char *, u_long *);
82 
83 static const struct got_error* gerror;
84 static struct gotconfig_remote_repo *remote;
85 static struct gotconfig gotconfig;
86 static const struct got_error* new_remote(struct gotconfig_remote_repo **);
87 static const struct got_error* new_fetch_config(struct fetch_config **);
88 static const struct got_error* new_send_config(struct send_config **);
89 
90 typedef struct {
91 	union {
92 		long long	 number;
93 		char		*string;
94 		struct node_branch *branch;
95 		struct node_ref *ref;
96 	} v;
97 	int lineno;
98 } YYSTYPE;
99 
100 #if defined(__APPLE__) && !defined(YYSTYPE)
101 #warning "Setting YYSTYPE - is GNU Bison installed?"
102 #define YYSTYPE YYSTYPE
103 #endif
104 %}
105 
106 %token	ERROR
107 %token	REMOTE REPOSITORY SERVER PORT PROTOCOL MIRROR_REFERENCES BRANCH
108 %token	AUTHOR ALLOWED_SIGNERS REVOKED_SIGNERS SIGNER_ID FETCH_ALL_BRANCHES
109 %token	REFERENCE FETCH SEND
110 %token	<v.string>	STRING
111 %token	<v.number>	NUMBER
112 %type	<v.number>	boolean portplain
113 %type	<v.string>	numberstring
114 %type	<v.branch>	branch xbranch branch_list
115 %type	<v.ref>		ref xref ref_list
116 
117 %%
118 
119 grammar		: /* empty */
120 		| grammar '\n'
121 		| grammar author '\n'
122 		| grammar remote '\n'
123 		| grammar allowed_signers '\n'
124 		| grammar revoked_signers '\n'
125 		| grammar signer_id '\n'
126 		;
127 boolean		: STRING {
128 			if (strcasecmp($1, "true") == 0 ||
129 			    strcasecmp($1, "yes") == 0)
130 				$$ = 1;
131 			else if (strcasecmp($1, "false") == 0 ||
132 			    strcasecmp($1, "no") == 0)
133 				$$ = 0;
134 			else {
135 				yyerror("invalid boolean value '%s'", $1);
136 				free($1);
137 				YYERROR;
138 			}
139 			free($1);
140 		}
141 		;
142 numberstring	: NUMBER				{
143 			char	*s;
144 			if (asprintf(&s, "%lld", $1) == -1) {
145 				yyerror("string: asprintf");
146 				YYERROR;
147 			}
148 			$$ = s;
149 		}
150 		| STRING
151 		;
152 portplain	: numberstring	{
153 			if (parseport($1, &$$) == -1) {
154 				free($1);
155 				YYERROR;
156 			}
157 			free($1);
158 		}
159 		;
160 branch		: /* empty */				{ $$ = NULL; }
161 		| xbranch			{ $$ = $1; }
162 		| '{' optnl branch_list '}'	{ $$ = $3; }
163 		;
164 xbranch		: STRING {
165 			$$ = calloc(1, sizeof(struct node_branch));
166 			if ($$ == NULL) {
167 				yyerror("calloc");
168 				YYERROR;
169 			}
170 			$$->branch_name = $1;
171 			$$->tail = $$;
172 		}
173 		;
174 branch_list	: xbranch optnl			{ $$ = $1; }
175 		| branch_list comma xbranch optnl {
176 			$1->tail->next = $3;
177 			$1->tail = $3;
178 			$$ = $1;
179 		}
180 		;
181 ref		: /* empty */		{ $$ = NULL; }
182 		| xref			{ $$ = $1; }
183 		| '{' optnl ref_list '}'	{ $$ = $3; }
184 		;
185 xref		: STRING {
186 			$$ = calloc(1, sizeof(struct node_ref));
187 			if ($$ == NULL) {
188 				yyerror("calloc");
189 				YYERROR;
190 			}
191 			$$->ref_name = $1;
192 			$$->tail = $$;
193 		}
194 		;
195 ref_list	: xref optnl			{ $$ = $1; }
196 		| ref_list comma xref optnl {
197 			$1->tail->next = $3;
198 			$1->tail = $3;
199 			$$ = $1;
200 		}
201 		;
202 remoteopts2	: remoteopts2 remoteopts1 nl
203 		| remoteopts1 optnl
204 		;
205 remoteopts1	: REPOSITORY STRING {
206 			remote->repository = $2;
207 		}
208 		| SERVER STRING {
209 			remote->server = $2;
210 		}
211 		| PROTOCOL STRING {
212 			remote->protocol = $2;
213 		}
214 		| MIRROR_REFERENCES boolean {
215 			remote->mirror_references = $2;
216 		}
217 		| FETCH_ALL_BRANCHES boolean {
218 			remote->fetch_all_branches = $2;
219 		}
220 		| PORT portplain {
221 			remote->port = $2;
222 		}
223 		| BRANCH branch {
224 			remote->branch = $2;
225 		}
226 		| REFERENCE ref {
227 			remote->fetch_ref = $2;
228 		}
229 		| FETCH {
230 			static const struct got_error* error;
231 
232 			if (remote->fetch_config != NULL) {
233 				yyerror("fetch block already exists");
234 				YYERROR;
235 			}
236 			error = new_fetch_config(&remote->fetch_config);
237 			if (error) {
238 				yyerror("%s", error->msg);
239 				YYERROR;
240 			}
241 		} '{' optnl fetchempty '}'
242 		| SEND {
243 			static const struct got_error* error;
244 
245 			if (remote->send_config != NULL) {
246 				yyerror("send block already exists");
247 				YYERROR;
248 			}
249 			error = new_send_config(&remote->send_config);
250 			if (error) {
251 				yyerror("%s", error->msg);
252 				YYERROR;
253 			}
254 		} '{' optnl sendempty '}'
255 		;
256 fetchempty	: /* empty */
257 		| fetchopts2
258 		;
259 fetchopts2	: fetchopts2 fetchopts1 nl
260 		| fetchopts1 optnl
261 		;
262 fetchopts1	: REPOSITORY STRING {
263 			remote->fetch_config->repository = $2;
264 		}
265 		| SERVER STRING {
266 			remote->fetch_config->server = $2;
267 		}
268 		| PROTOCOL STRING {
269 			remote->fetch_config->protocol = $2;
270 		}
271 		| PORT portplain {
272 			remote->fetch_config->port = $2;
273 		}
274 		| BRANCH branch {
275 			remote->fetch_config->branch = $2;
276 		}
277 		;
278 sendempty	: /* empty */
279 		| sendopts2
280 		;
281 sendopts2	: sendopts2 sendopts1 nl
282 		| sendopts1 optnl
283 		;
284 sendopts1	: REPOSITORY STRING {
285 			remote->send_config->repository = $2;
286 		}
287 		| SERVER STRING {
288 			remote->send_config->server = $2;
289 		}
290 		| PROTOCOL STRING {
291 			remote->send_config->protocol = $2;
292 		}
293 		| PORT portplain {
294 			remote->send_config->port = $2;
295 		}
296 		| BRANCH branch {
297 			remote->send_config->branch = $2;
298 		}
299 		;
300 remote		: REMOTE STRING {
301 			static const struct got_error* error;
302 
303 			error = new_remote(&remote);
304 			if (error) {
305 				free($2);
306 				yyerror("%s", error->msg);
307 				YYERROR;
308 			}
309 			remote->name = $2;
310 		} '{' optnl remoteopts2 '}' {
311 			TAILQ_INSERT_TAIL(&gotconfig.remotes, remote, entry);
312 			gotconfig.nremotes++;
313 		}
314 		;
315 author		: AUTHOR STRING {
316 			gotconfig.author = $2;
317 		}
318 		;
319 allowed_signers	: ALLOWED_SIGNERS STRING {
320 			gotconfig.allowed_signers_file = $2;
321 		}
322 		;
323 revoked_signers	: REVOKED_SIGNERS STRING {
324 			gotconfig.revoked_signers_file = $2;
325 		}
326 		;
327 signer_id	: SIGNER_ID STRING {
328 			gotconfig.signer_id = $2;
329 		}
330 		;
331 optnl		: '\n' optnl
332 		| /* empty */
333 		;
334 nl		: '\n' optnl
335 		;
336 comma		: ','
337 		| /* empty */
338 		;
339 %%
340 
341 struct keywords {
342 	const char	*k_name;
343 	int		 k_val;
344 };
345 
346 int
347 yyerror(const char *fmt, ...)
348 {
349 	va_list		 ap;
350 	char		*msg;
351 	char		*err = NULL;
352 
353 	va_start(ap, fmt);
354 	if (vasprintf(&msg, fmt, ap) == -1) {
355 		gerror =  got_error_from_errno("vasprintf");
356 		return 0;
357 	}
358 	va_end(ap);
359 	if (asprintf(&err, "%s: line %d: %s", file->name, yylval.lineno,
360 	    msg) == -1) {
361 		gerror = got_error_from_errno("asprintf");
362 		return(0);
363 	}
364 	gerror = got_error_msg(GOT_ERR_PARSE_CONFIG, err);
365 	free(msg);
366 	return(0);
367 }
368 int
369 kw_cmp(const void *k, const void *e)
370 {
371 	return (strcmp(k, ((const struct keywords *)e)->k_name));
372 }
373 
374 int
375 lookup(char *s)
376 {
377 	/* This has to be sorted always. */
378 	static const struct keywords keywords[] = {
379 		{"allowed_signers",	ALLOWED_SIGNERS},
380 		{"author",		AUTHOR},
381 		{"branch",		BRANCH},
382 		{"fetch",		FETCH},
383 		{"fetch-all-branches",	FETCH_ALL_BRANCHES}, /* deprecated */
384 		{"fetch_all_branches",	FETCH_ALL_BRANCHES},
385 		{"mirror-references",	MIRROR_REFERENCES}, /* deprecated */
386 		{"mirror_references",	MIRROR_REFERENCES},
387 		{"port",		PORT},
388 		{"protocol",		PROTOCOL},
389 		{"reference",		REFERENCE},
390 		{"remote",		REMOTE},
391 		{"repository",		REPOSITORY},
392 		{"revoked_signers",	REVOKED_SIGNERS},
393 		{"send",		SEND},
394 		{"server",		SERVER},
395 		{"signer_id",		SIGNER_ID},
396 	};
397 	const struct keywords	*p;
398 
399 	p = bsearch(s, keywords, sizeof(keywords)/sizeof(keywords[0]),
400 	    sizeof(keywords[0]), kw_cmp);
401 
402 	if (p)
403 		return (p->k_val);
404 	else
405 		return (STRING);
406 }
407 
408 #define START_EXPAND	1
409 #define DONE_EXPAND	2
410 
411 static int	expanding;
412 
413 int
414 igetc(void)
415 {
416 	int	c;
417 
418 	while (1) {
419 		if (file->ungetpos > 0)
420 			c = file->ungetbuf[--file->ungetpos];
421 		else
422 			c = getc(file->stream);
423 
424 		if (c == START_EXPAND)
425 			expanding = 1;
426 		else if (c == DONE_EXPAND)
427 			expanding = 0;
428 		else
429 			break;
430 	}
431 	return (c);
432 }
433 
434 int
435 lgetc(int quotec)
436 {
437 	int		c, next;
438 
439 	if (quotec) {
440 		c = igetc();
441 		if (c == EOF) {
442 			yyerror("reached end of file while parsing "
443 			    "quoted string");
444 		}
445 		return (c);
446 	}
447 
448 	c = igetc();
449 	while (c == '\\') {
450 		next = igetc();
451 		if (next != '\n') {
452 			c = next;
453 			break;
454 		}
455 		yylval.lineno = file->lineno;
456 		file->lineno++;
457 	}
458 
459 	return (c);
460 }
461 
462 void
463 lungetc(int c)
464 {
465 	if (c == EOF)
466 		return;
467 
468 	if (file->ungetpos >= file->ungetsize) {
469 		void *p = reallocarray(file->ungetbuf, file->ungetsize, 2);
470 		if (p == NULL)
471 			err(1, "%s", __func__);
472 		file->ungetbuf = p;
473 		file->ungetsize *= 2;
474 	}
475 	file->ungetbuf[file->ungetpos++] = c;
476 }
477 
478 int
479 findeol(void)
480 {
481 	int	c;
482 
483 	/* Skip to either EOF or the first real EOL. */
484 	while (1) {
485 		c = lgetc(0);
486 		if (c == '\n') {
487 			file->lineno++;
488 			break;
489 		}
490 		if (c == EOF)
491 			break;
492 	}
493 	return (ERROR);
494 }
495 
496 static long long
497 getservice(char *n)
498 {
499 	struct servent	*s;
500 	u_long		 ulval;
501 
502 	if (atoul(n, &ulval) == 0) {
503 		if (ulval == 0 || ulval > 65535) {
504 			yyerror("illegal port value %lu", ulval);
505 			return (-1);
506 		}
507 		return ulval;
508 	} else {
509 		s = getservbyname(n, "tcp");
510 		if (s == NULL)
511 			s = getservbyname(n, "udp");
512 		if (s == NULL) {
513 			yyerror("unknown port %s", n);
514 			return (-1);
515 		}
516 		return (s->s_port);
517 	}
518 }
519 
520 static int
521 parseport(char *port, long long *pn)
522 {
523 	if ((*pn = getservice(port)) == -1) {
524 		*pn = 0LL;
525 		return (-1);
526 	}
527 	return (0);
528 }
529 
530 
531 int
532 yylex(void)
533 {
534 	char	 buf[8096];
535 	char	*p, *val;
536 	int	 quotec, next, c;
537 	int	 token;
538 
539 top:
540 	p = buf;
541 	c = lgetc(0);
542 	while (c == ' ' || c == '\t')
543 		c = lgetc(0); /* nothing */
544 
545 	yylval.lineno = file->lineno;
546 	if (c == '#') {
547 		c = lgetc(0);
548 		while (c != '\n' && c != EOF)
549 			c = lgetc(0); /* nothing */
550 	}
551 	if (c == '$' && !expanding) {
552 		while (1) {
553 			c = lgetc(0);
554 			if (c == EOF)
555 				return (0);
556 
557 			if (p + 1 >= buf + sizeof(buf) - 1) {
558 				yyerror("string too long");
559 				return (findeol());
560 			}
561 			if (isalnum(c) || c == '_') {
562 				*p++ = c;
563 				continue;
564 			}
565 			*p = '\0';
566 			lungetc(c);
567 			break;
568 		}
569 		val = symget(buf);
570 		if (val == NULL) {
571 			yyerror("macro '%s' not defined", buf);
572 			return (findeol());
573 		}
574 		p = val + strlen(val) - 1;
575 		lungetc(DONE_EXPAND);
576 		while (p >= val) {
577 			lungetc((unsigned char)*p);
578 			p--;
579 		}
580 		lungetc(START_EXPAND);
581 		goto top;
582 	}
583 
584 	switch (c) {
585 	case '\'':
586 	case '"':
587 		quotec = c;
588 		while (1) {
589 			c = lgetc(quotec);
590 			if (c == EOF)
591 				return (0);
592 			if (c == '\n') {
593 				file->lineno++;
594 				continue;
595 			} else if (c == '\\') {
596 				next = lgetc(quotec);
597 				if (next == EOF)
598 					return (0);
599 				if (next == quotec || c == ' ' || c == '\t')
600 					c = next;
601 				else if (next == '\n') {
602 					file->lineno++;
603 					continue;
604 				} else
605 					lungetc(next);
606 			} else if (c == quotec) {
607 				*p = '\0';
608 				break;
609 			} else if (c == '\0') {
610 				yyerror("syntax error");
611 				return (findeol());
612 			}
613 			if (p + 1 >= buf + sizeof(buf) - 1) {
614 				yyerror("string too long");
615 				return (findeol());
616 			}
617 			*p++ = c;
618 		}
619 		yylval.v.string = strdup(buf);
620 		if (yylval.v.string == NULL)
621 			err(1, "%s", __func__);
622 		return (STRING);
623 	}
624 
625 #define allowed_to_end_number(x) \
626 	(isspace(x) || x == ')' || x ==',' || x == '/' || x == '}' || x == '=')
627 
628 	if (c == '-' || isdigit(c)) {
629 		do {
630 			*p++ = c;
631 			if ((size_t)(p-buf) >= sizeof(buf)) {
632 				yyerror("string too long");
633 				return (findeol());
634 			}
635 			c = lgetc(0);
636 		} while (c != EOF && isdigit(c));
637 		lungetc(c);
638 		if (p == buf + 1 && buf[0] == '-')
639 			goto nodigits;
640 		if (c == EOF || allowed_to_end_number(c)) {
641 			const char *errstr = NULL;
642 
643 			*p = '\0';
644 			yylval.v.number = strtonum(buf, LLONG_MIN,
645 			    LLONG_MAX, &errstr);
646 			if (errstr) {
647 				yyerror("\"%s\" invalid number: %s",
648 				    buf, errstr);
649 				return (findeol());
650 			}
651 			return (NUMBER);
652 		} else {
653 nodigits:
654 			while (p > buf + 1)
655 				lungetc((unsigned char)*--p);
656 			c = (unsigned char)*--p;
657 			if (c == '-')
658 				return (c);
659 		}
660 	}
661 
662 #define allowed_in_string(x) \
663 	(isalnum(x) || (ispunct(x) && x != '(' && x != ')' && \
664 	x != '{' && x != '}' && \
665 	x != '!' && x != '=' && x != '#' && \
666 	x != ','))
667 
668 	if (isalnum(c) || c == ':' || c == '_') {
669 		do {
670 			*p++ = c;
671 			if ((size_t)(p-buf) >= sizeof(buf)) {
672 				yyerror("string too long");
673 				return (findeol());
674 			}
675 			c = lgetc(0);
676 		} while (c != EOF && (allowed_in_string(c)));
677 		lungetc(c);
678 		*p = '\0';
679 		token = lookup(buf);
680 		if (token == STRING) {
681 			yylval.v.string = strdup(buf);
682 			if (yylval.v.string == NULL)
683 				err(1, "%s", __func__);
684 		}
685 		return (token);
686 	}
687 	if (c == '\n') {
688 		yylval.lineno = file->lineno;
689 		file->lineno++;
690 	}
691 	if (c == EOF)
692 		return (0);
693 	return (c);
694 }
695 
696 static const struct got_error*
697 newfile(struct file **nfile, const char *filename, int *fd)
698 {
699 	const struct got_error* error = NULL;
700 
701 	(*nfile) = calloc(1, sizeof(struct file));
702 	if ((*nfile) == NULL)
703 		return got_error_from_errno("calloc");
704 	(*nfile)->stream = fdopen(*fd, "r");
705 	if ((*nfile)->stream == NULL) {
706 		error = got_error_from_errno("fdopen");
707 		free((*nfile));
708 		return error;
709 	}
710 	*fd = -1; /* Stream owns the file descriptor now. */
711 	(*nfile)->name = filename;
712 	(*nfile)->lineno = 1;
713 	(*nfile)->ungetsize = 16;
714 	(*nfile)->ungetbuf = malloc((*nfile)->ungetsize);
715 	if ((*nfile)->ungetbuf == NULL) {
716 		error = got_error_from_errno("malloc");
717 		fclose((*nfile)->stream);
718 		free((*nfile));
719 		return error;
720 	}
721 	return NULL;
722 }
723 
724 static const struct got_error*
725 new_remote(struct gotconfig_remote_repo **remote)
726 {
727 	const struct got_error *error = NULL;
728 
729 	*remote = calloc(1, sizeof(**remote));
730 	if (*remote == NULL)
731 		error = got_error_from_errno("calloc");
732 	return error;
733 }
734 
735 static const struct got_error*
736 new_fetch_config(struct fetch_config **fetch_config)
737 {
738 	const struct got_error *error = NULL;
739 
740 	*fetch_config = calloc(1, sizeof(**fetch_config));
741 	if (*fetch_config == NULL)
742 		error = got_error_from_errno("calloc");
743 	return error;
744 }
745 
746 static const struct got_error*
747 new_send_config(struct send_config **send_config)
748 {
749 	const struct got_error *error = NULL;
750 
751 	*send_config = calloc(1, sizeof(**send_config));
752 	if (*send_config == NULL)
753 		error = got_error_from_errno("calloc");
754 	return error;
755 }
756 
757 static void
758 closefile(struct file *file)
759 {
760 	fclose(file->stream);
761 	free(file->ungetbuf);
762 	free(file);
763 }
764 
765 const struct got_error *
766 gotconfig_parse(struct gotconfig **conf, const char *filename, int *fd)
767 {
768 	const struct got_error *err = NULL;
769 	struct sym	*sym, *next;
770 
771 	*conf = NULL;
772 
773 	err = newfile(&file, filename, fd);
774 	if (err)
775 		return err;
776 
777 	TAILQ_INIT(&gotconfig.remotes);
778 
779 	yyparse();
780 	closefile(file);
781 
782 	/* Free macros and check which have not been used. */
783 	TAILQ_FOREACH_SAFE(sym, &symhead, entry, next) {
784 		if (!sym->persist) {
785 			free(sym->nam);
786 			free(sym->val);
787 			TAILQ_REMOVE(&symhead, sym, entry);
788 			free(sym);
789 		}
790 	}
791 
792 	if (gerror == NULL)
793 		*conf = &gotconfig;
794 	return gerror;
795 }
796 
797 static void
798 free_fetch_config(struct fetch_config *fetch_config)
799 {
800 	free(remote->fetch_config->repository);
801 	free(remote->fetch_config->server);
802 	free(remote->fetch_config->protocol);
803 	free(remote->fetch_config);
804 }
805 
806 static void
807 free_send_config(struct send_config *send_config)
808 {
809 	free(remote->send_config->repository);
810 	free(remote->send_config->server);
811 	free(remote->send_config->protocol);
812 	free(remote->send_config);
813 }
814 
815 void
816 gotconfig_free(struct gotconfig *conf)
817 {
818 	struct gotconfig_remote_repo *remote;
819 
820 	free(conf->author);
821 	free(conf->allowed_signers_file);
822 	free(conf->revoked_signers_file);
823 	free(conf->signer_id);
824 	while (!TAILQ_EMPTY(&conf->remotes)) {
825 		remote = TAILQ_FIRST(&conf->remotes);
826 		TAILQ_REMOVE(&conf->remotes, remote, entry);
827 		if (remote->fetch_config != NULL)
828 			free_fetch_config(remote->fetch_config);
829 		if (remote->send_config != NULL)
830 			free_send_config(remote->send_config);
831 		free(remote->name);
832 		free(remote->repository);
833 		free(remote->server);
834 		free(remote->protocol);
835 		free(remote);
836 	}
837 }
838 
839 int
840 symset(const char *nam, const char *val, int persist)
841 {
842 	struct sym	*sym;
843 
844 	TAILQ_FOREACH(sym, &symhead, entry) {
845 		if (strcmp(nam, sym->nam) == 0)
846 			break;
847 	}
848 
849 	if (sym != NULL) {
850 		if (sym->persist == 1)
851 			return (0);
852 		else {
853 			free(sym->nam);
854 			free(sym->val);
855 			TAILQ_REMOVE(&symhead, sym, entry);
856 			free(sym);
857 		}
858 	}
859 	sym = calloc(1, sizeof(*sym));
860 	if (sym == NULL)
861 		return (-1);
862 
863 	sym->nam = strdup(nam);
864 	if (sym->nam == NULL) {
865 		free(sym);
866 		return (-1);
867 	}
868 	sym->val = strdup(val);
869 	if (sym->val == NULL) {
870 		free(sym->nam);
871 		free(sym);
872 		return (-1);
873 	}
874 	sym->used = 0;
875 	sym->persist = persist;
876 	TAILQ_INSERT_TAIL(&symhead, sym, entry);
877 	return (0);
878 }
879 
880 int
881 cmdline_symset(char *s)
882 {
883 	char	*sym, *val;
884 	int	ret;
885 	size_t	len;
886 
887 	val = strrchr(s, '=');
888 	if (val == NULL)
889 		return (-1);
890 
891 	len = strlen(s) - strlen(val) + 1;
892 	sym = malloc(len);
893 	if (sym == NULL)
894 		errx(1, "cmdline_symset: malloc");
895 
896 	strlcpy(sym, s, len);
897 
898 	ret = symset(sym, val + 1, 1);
899 	free(sym);
900 
901 	return (ret);
902 }
903 
904 char *
905 symget(const char *nam)
906 {
907 	struct sym	*sym;
908 
909 	TAILQ_FOREACH(sym, &symhead, entry) {
910 		if (strcmp(nam, sym->nam) == 0) {
911 			sym->used = 1;
912 			return (sym->val);
913 		}
914 	}
915 	return (NULL);
916 }
917 
918 static int
919 atoul(char *s, u_long *ulvalp)
920 {
921 	u_long	 ulval;
922 	char	*ep;
923 
924 	errno = 0;
925 	ulval = strtoul(s, &ep, 0);
926 	if (s[0] == '\0' || *ep != '\0')
927 		return (-1);
928 	if (errno == ERANGE && ulval == ULONG_MAX)
929 		return (-1);
930 	*ulvalp = ulval;
931 	return (0);
932 }