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