xref: /freebsd/contrib/bsnmp/snmpd/config.c (revision a03411e84728e9b267056fd31c7d1d9d1dc1b01e) 
1 /*
2  * Copyright (c) 2001-2003
3  *	Fraunhofer Institute for Open Communication Systems (FhG Fokus).
4  *	All rights reserved.
5  *
6  * Author: Harti Brandt <harti@freebsd.org>
7  *
8  * Redistribution and use in source and binary forms, with or without
9  * modification, are permitted provided that the following conditions
10  * are met:
11  * 1. Redistributions of source code must retain the above copyright
12  *    notice, this list of conditions and the following disclaimer.
13  * 2. Redistributions in binary form must reproduce the above copyright
14  *    notice, this list of conditions and the following disclaimer in the
15  *    documentation and/or other materials provided with the distribution.
16  *
17  * THIS SOFTWARE IS PROVIDED BY AUTHOR AND CONTRIBUTORS ``AS IS'' AND
18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20  * ARE DISCLAIMED.  IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
21  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27  * SUCH DAMAGE.
28  *
29  * $Begemot: bsnmp/snmpd/config.c,v 1.25 2006/02/14 09:04:20 brandt_h Exp $
30  *
31  * Parse configuration file.
32  */
33 #include <sys/types.h>
34 #include <sys/queue.h>
35 #include <sys/socket.h>
36 #include <sys/un.h>
37 #include <stdio.h>
38 #include <stdlib.h>
39 #include <string.h>
40 #include <stdarg.h>
41 #include <ctype.h>
42 #include <errno.h>
43 #include <syslog.h>
44 #include <unistd.h>
45 #include <limits.h>
46 #include <netdb.h>
47 #include <setjmp.h>
48 #include <inttypes.h>
49 
50 #include "snmpmod.h"
51 #include "snmpd.h"
52 #include "tree.h"
53 
54 /*
55 #define DEBUGGING
56 */
57 
58 /*
59  * config_file: EMPTY | config_file line
60  *
61  * line: oid '=' value
62  *     | '%' STRING
63  *     | STRING := REST_OF_LINE
64  *     | STRING ?= REST_OF_LINE
65  *     | . INCLUDE STRING
66  *
67  * oid: STRING suboid
68  *
69  * suboid: EMPTY | suboid '.' subid
70  *
71  * subid: NUM | STRING | '[' STRING ']'
72  *
73  * value: EMPTY | STRING | NUM
74  */
75 
76 /*
77  * Input context for macros and includes
78  */
79 enum input_type {
80 	INPUT_FILE	= 1,
81 	INPUT_STRING
82 };
83 struct input {
84 	enum input_type	type;
85 	union {
86 	    struct {
87 		FILE	*fp;
88 		char	*filename;
89 		u_int	lno;
90 	    }		file;
91 	    struct {
92 		char	*macro;
93 		char	*str;
94 		char	*ptr;
95 		size_t	left;
96 	    }		str;
97 	} u;
98 	LIST_ENTRY(input) link;
99 };
100 static LIST_HEAD(, input) inputs;
101 
102 #define input_fp	u.file.fp
103 #define input_filename	u.file.filename
104 #define input_lno	u.file.lno
105 #define input_macro	u.str.macro
106 #define input_str	u.str.str
107 #define input_ptr	u.str.ptr
108 #define input_left	u.str.left
109 
110 static int input_push;
111 static int input_buf[2];
112 
113 /*
114  * Configuration data. The configuration file is handled as one single
115  * SNMP transaction. So we need to keep the assignment data for the
116  * commit or rollback pass. Note, that dependencies and finish functions
117  * are NOT allowed here.
118  */
119 struct assign {
120 	struct snmp_value value;
121 	struct snmp_scratch scratch;
122 	const char *node_name;
123 
124 	TAILQ_ENTRY(assign) link;
125 };
126 static TAILQ_HEAD(assigns, assign) assigns = TAILQ_HEAD_INITIALIZER(assigns);
127 
128 
129 static struct snmp_context *snmp_ctx;
130 
131 struct macro {
132 	char	*name;
133 	char	*value;
134 	size_t	length;
135 	LIST_ENTRY(macro) link;
136 	int	perm;
137 };
138 static LIST_HEAD(, macro) macros = LIST_HEAD_INITIALIZER(macros);
139 
140 enum {
141 	TOK_EOF	= 0200,
142 	TOK_EOL,
143 	TOK_NUM,
144 	TOK_STR,
145 	TOK_HOST,
146 	TOK_ASSIGN,
147 	TOK_QASSIGN,
148 };
149 
150 /* lexer values and last token */
151 static uint64_t	numval;
152 static char	strval[_POSIX2_LINE_MAX];
153 static size_t	strvallen;
154 static int	token;
155 
156 /* error return */
157 static jmp_buf	errjmp[4];
158 static volatile int errstk;
159 
160 # define ERRPUSH()	(setjmp(errjmp[errstk++]))
161 # define ERRPOP()	((void)(errstk--))
162 # define ERRNEXT()	(longjmp(errjmp[--errstk], 1))
163 # define ERR()		(longjmp(errjmp[--errstk], 1))
164 
165 /* section context */
166 static int ignore;
167 
168 /*
169  * Report an error and jump to the error label
170  */
171 static void report(const char *fmt, ...) __dead2 __printflike(1, 2);
172 
173 static void
174 report(const char *fmt, ...)
175 {
176 	va_list ap;
177 	const struct input *input;
178 
179 	va_start(ap, fmt);
180 	vsyslog(LOG_ERR, fmt, ap);
181 	va_end(ap);
182 
183 	LIST_FOREACH(input, &inputs, link) {
184 		switch (input->type) {
185 
186 		  case INPUT_FILE:
187 			syslog(LOG_ERR, "  in file %s line %u",
188 			    input->input_filename, input->input_lno);
189 			break;
190 
191 		  case INPUT_STRING:
192 			syslog(LOG_ERR, "  in macro %s pos %td",
193 			    input->input_macro,
194 			    input->input_ptr - input->input_str);
195 			break;
196 		}
197 	}
198 	ERR();
199 }
200 
201 /*
202  * Open a file for input
203  */
204 static int
205 input_open_file(const char *fname, int sysdir)
206 {
207 	struct input *input;
208 	FILE *fp;
209 	char path[PATH_MAX + 1];
210 	const char *col;
211 	const char *ptr;
212 
213 	if (sysdir) {
214 		ptr = syspath;
215 		fp = NULL;
216 		while (*ptr != '\0') {
217 			if ((col = strchr(ptr, ':')) == NULL) {
218 				snprintf(path, sizeof(path), "%s/%s",
219 				    ptr, fname);
220 				col = ptr + strlen(ptr) - 1;
221 			} else if (col == ptr)
222 				snprintf(path, sizeof(path), "./%s", fname);
223 			else
224 				snprintf(path, sizeof(path), "%.*s/%s",
225 				    (int)(col - ptr), ptr, fname);
226 			if ((fp = fopen(path, "r")) != NULL)
227 				break;
228 			ptr = col + 1;
229 		}
230 	} else
231 		fp = fopen(fname, "r");
232 
233 	if (fp == NULL)
234 		report("%s: %m", fname);
235 
236 	if ((input = malloc(sizeof(*input))) == NULL) {
237 		fclose(fp);
238 		return (-1);
239 	}
240 	if ((input->input_filename = malloc(strlen(fname) + 1)) == NULL) {
241 		fclose(fp);
242 		free(input);
243 		return (-1);
244 	}
245 	strcpy(input->input_filename, fname);
246 	input->input_fp = fp;
247 	input->input_lno = 1;
248 	input->type = INPUT_FILE;
249 	LIST_INSERT_HEAD(&inputs, input, link);
250 	return (0);
251 }
252 
253 /*
254  * Make a macro the next input
255  */
256 static void
257 input_open_macro(struct macro *m)
258 {
259 	struct input *input;
260 
261 	if ((input = malloc(sizeof(*input))) == NULL)
262 		report("%m");
263 	input->type = INPUT_STRING;
264 	input->input_macro = m->name;
265 	if ((input->input_str = malloc(m->length)) == NULL) {
266 		free(input);
267 		report("%m");
268 	}
269 	memcpy(input->input_str, m->value, m->length);
270 	input->input_ptr = input->input_str;
271 	input->input_left = m->length;
272 	LIST_INSERT_HEAD(&inputs, input, link);
273 }
274 
275 /*
276  * Close top input source
277  */
278 static void
279 input_close(void)
280 {
281 	struct input *input;
282 
283 	if ((input = LIST_FIRST(&inputs)) == NULL)
284 		abort();
285 	switch (input->type) {
286 
287 	  case INPUT_FILE:
288 		fclose(input->input_fp);
289 		free(input->input_filename);
290 		break;
291 
292 	  case INPUT_STRING:
293 		free(input->input_str);
294 		break;
295 	}
296 	LIST_REMOVE(input, link);
297 	free(input);
298 }
299 
300 /*
301  * Close all inputs
302  */
303 static void
304 input_close_all(void)
305 {
306 	while (!LIST_EMPTY(&inputs))
307 		input_close();
308 }
309 
310 /*
311  * Push back one character
312  */
313 static void
314 input_ungetc(int c)
315 {
316 	if (c == EOF)
317 		report("pushing EOF");
318 	if (input_push == 2)
319 		report("pushing third char");
320 	input_buf[input_push++] = c;
321 }
322 
323 
324 /*
325  * Return next character from the input without preprocessing.
326  */
327 static int
328 input_getc_raw(void)
329 {
330 	int c;
331 	struct input *input;
332 
333 	if (input_push != 0) {
334 		c = input_buf[--input_push];
335 		goto ok;
336 	}
337 	while ((input = LIST_FIRST(&inputs)) != NULL) {
338 		switch (input->type) {
339 
340 		  case INPUT_FILE:
341 			if ((c = getc(input->input_fp)) == EOF) {
342 				if (ferror(input->input_fp))
343 					report("read error: %m");
344 				input_close();
345 				break;
346 			}
347 			if (c == '\n')
348 				input->input_lno++;
349 			goto ok;
350 
351 		  case INPUT_STRING:
352 			if (input->input_left-- == 0) {
353 				input_close();
354 				break;
355 			}
356 			c = *input->input_ptr++;
357 			goto ok;
358 		}
359 	}
360 # ifdef DEBUGGING
361 	fprintf(stderr, "EOF");
362 # endif
363 	return (EOF);
364 
365   ok:
366 # ifdef DEBUGGING
367 	if (!isascii(c) || !isprint(c))
368 		fprintf(stderr, "'%#2x'", c);
369 	else
370 		fprintf(stderr, "'%c'", c);
371 # endif
372 	return (c);
373 }
374 
375 /*
376  * Get character with and \\n -> processing.
377  */
378 static int
379 input_getc_plain(void)
380 {
381 	int c;
382 
383   again:
384 	if ((c = input_getc_raw()) == '\\') {
385 		if ((c = input_getc_raw()) == '\n')
386 			goto again;
387 		if (c != EOF)
388 			input_ungetc(c);
389 		return ('\\');
390 	}
391 	return (c);
392 }
393 
394 /*
395  * Get next character with substitution of macros
396  */
397 static int
398 input_getc(void)
399 {
400 	int c;
401 	struct macro *m;
402 	char	name[_POSIX2_LINE_MAX];
403 	size_t	namelen;
404 
405   again:
406 	if ((c = input_getc_plain()) != '$')
407 		return (c);
408 
409 	if ((c = input_getc()) == EOF)
410 		report("unexpected EOF");
411 	if (c != '(')
412 		report("expecting '(' after '$'");
413 
414 	namelen = 0;
415 	while ((c = input_getc()) != EOF && c != ')') {
416 		if (isalpha(c) || c == '_' || (namelen != 0 && isdigit(c)))
417 			name[namelen++] = c;
418 		else
419 			goto badchar;
420 	}
421 	if (c == EOF)
422 		report("unexpected EOF");
423 	name[namelen++] = '\0';
424 
425 	LIST_FOREACH(m, &macros, link)
426 		if (strcmp(m->name, name) == 0)
427 			break;
428 	if (m == NULL)
429 		report("undefined macro '%s'", name);
430 
431 	input_open_macro(m);
432 	goto again;
433 
434   badchar:
435 	if (!isascii(c) || !isprint(c))
436 		report("unexpected character %#2x", (u_int)c);
437 	else
438 		report("bad character '%c'", c);
439 }
440 
441 
442 static void
443 input_getnum(u_int base, u_int flen)
444 {
445 	int c;
446 	u_int cnt;
447 
448 	cnt = 0;
449 	numval = 0;
450 	while (flen == 0 || cnt < flen) {
451 		if ((c = input_getc()) == EOF) {
452 			if (cnt == 0)
453 				report("bad number");
454 			return;
455 		}
456 		if (isdigit(c)) {
457 			if (base == 8 && (c == '8' || c == '9')) {
458 				input_ungetc(c);
459 				if (cnt == 0)
460 					report("bad number");
461 				return;
462 			}
463 			numval = numval * base + (c - '0');
464 		} else if (base == 16 && isxdigit(c)) {
465 			if (islower(c))
466 				numval = numval * base + (c - 'a' + 10);
467 			else
468 				numval = numval * base + (c - 'A' + 10);
469 		} else {
470 			input_ungetc(c);
471 			if (cnt == 0)
472 				report("bad number");
473 			return;
474 		}
475 		cnt++;
476 	}
477 }
478 
479 static int
480 # ifdef DEBUGGING
481 _gettoken(void)
482 # else
483 gettoken(void)
484 # endif
485 {
486 	int c;
487 	char *end;
488 	static const char esc[] = "abfnrtv";
489 	static const char chr[] = "\a\b\f\n\r\t\v";
490 
491 	/*
492 	 * Skip any whitespace before the next token
493 	 */
494 	while ((c = input_getc()) != EOF) {
495 		if (!isspace(c) || c == '\n')
496 			break;
497 	}
498 	if (c == EOF)
499 		return (token = TOK_EOF);
500 	if (!isascii(c))
501 		goto badchar;
502 
503 	/*
504 	 * Skip comments
505 	 */
506 	if (c == '#') {
507 		while ((c = input_getc_plain()) != EOF) {
508 			if (c == '\n')
509 				return (token = TOK_EOL);
510 		}
511 		goto badeof;
512 	}
513 
514 	/*
515 	 * Single character tokens
516 	 */
517 	if (c == '\n')
518 		return (token = TOK_EOL);
519 	if (c == '.' || c == '%' || c == '=' || c == '<' || c == '>')
520 		return (token = c);
521 	if (c == ':') {
522 		if ((c = input_getc()) == '=')
523 			return (token = TOK_ASSIGN);
524 		input_ungetc(c);
525 		return (token = ':');
526 	}
527 	if (c == '?') {
528 		if ((c = input_getc()) == '=')
529 			return (token = TOK_QASSIGN);
530 		input_ungetc(c);
531 		goto badchar;
532 	}
533 
534 	/*
535 	 * Sort out numbers
536 	 */
537 	if (isdigit(c)) {
538 		if (c == '0') {
539 			if ((c = input_getc()) == 'x' || c == 'X') {
540 				input_getnum(16, 0);
541 			} else if (isdigit(c)) {
542 				input_ungetc(c);
543 				input_getnum(8, 0);
544 			} else {
545 				if (c != EOF)
546 					input_ungetc(c);
547 				numval = 0;
548 				c = 1;
549 			}
550 		} else {
551 			input_ungetc(c);
552 			input_getnum(10, 0);
553 		}
554 		return (token = TOK_NUM);
555 	}
556 
557 	/*
558 	 * Must be a string then
559 	 */
560 	strvallen = 0;
561 
562 # define GETC(C) do {							\
563 	if ((c = input_getc()) == EOF)					\
564 		goto badeof;						\
565 	if (!isascii(c) || (!isprint(c) && c != '\t')) 			\
566 		goto badchar;						\
567 } while(0)
568 
569 	if (c == '"') {
570 		for(;;) {
571 			GETC(c);
572 			if (c == '"') {
573 				strval[strvallen] = '\0';
574 				break;
575 			}
576 			if (c != '\\') {
577 				strval[strvallen++] = c;
578 				continue;
579 			}
580 			GETC(c);
581 			if ((end = strchr(esc, c)) != NULL) {
582 				strval[strvallen++] = chr[end - esc];
583 				continue;
584 			}
585 			if (c == 'x') {
586 				input_getnum(16, 2);
587 				c = numval;
588 			} else if (c >= '0' && c <= '7') {
589 				input_ungetc(c);
590 				input_getnum(8, 3);
591 				c = numval;
592 			}
593 			strval[strvallen++] = c;
594 		}
595 # undef GETC
596 
597 	} else if (c == '[') {
598 		/*
599 		 * Skip leading space
600 		 */
601 		while ((c = input_getc()) != EOF && isspace(c))
602 			;
603 		if (c == EOF)
604 			goto badeof;
605 		while (c != ']' && !isspace(c)) {
606 			if (!isalnum(c) && c != '.' && c != '-')
607 				goto badchar;
608 			strval[strvallen++] = c;
609 			if ((c = input_getc()) == EOF)
610 				goto badeof;
611 		}
612 		while (c != ']' && isspace(c)) {
613 			if ((c = input_getc()) == EOF)
614 				goto badeof;
615 		}
616 		if (c != ']')
617 			goto badchar;
618 		strval[strvallen] = '\0';
619 		return (token = TOK_HOST);
620 
621 	} else if (!isalpha(c) && c != '_') {
622 		goto badchar;
623 
624 	} else {
625 		for (;;) {
626 			strval[strvallen++] = c;
627 			if ((c = input_getc()) == EOF)
628 				goto badeof;
629 			if (!isalnum(c) && c != '_' && c != '-') {
630 				input_ungetc(c);
631 				strval[strvallen] = '\0';
632 				break;
633 			}
634 		}
635 	}
636 
637 	return (token = TOK_STR);
638 
639   badeof:
640 	report("unexpected EOF");
641 
642   badchar:
643 	if (!isascii(c) || !isprint(c))
644 		report("unexpected character %#2x", (u_int)c);
645 	else
646 		report("bad character '%c'", c);
647 }
648 
649 # ifdef DEBUGGING
650 static int
651 gettoken()
652 {
653 	_gettoken();
654 	if (isascii(token) && isprint(token))
655 		printf("(%c)", token);
656 	else {
657 		switch (token) {
658 
659 		  case TOK_EOF:
660 			printf("(EOF)");
661 			break;
662 		  case TOK_EOL:
663 			printf("(EOL)");
664 			break;
665 		  case TOK_NUM:
666 			printf("(NUM %ju)", (uintmax_t)numval);
667 			break;
668 		  case TOK_STR:
669 			printf("(STR %.*s)", (int)strvallen, strval);
670 			break;
671 		  case TOK_HOST:
672 			printf("(HOST %s)", strval);
673 			break;
674 		  default:
675 			printf("(%#2x)", token);
676 			break;
677 		}
678 	}
679 	return (token);
680 }
681 #endif
682 
683 
684 /*
685  * Try to execute the assignment.
686  */
687 static void
688 handle_assignment(const struct snmp_node *node, struct asn_oid *vindex,
689     const struct snmp_value *value)
690 {
691 	u_int i;
692 	int err;
693 	struct assign *tp;
694 	char nodename[100];
695 
696 	if (node->type == SNMP_NODE_LEAF) {
697 		/* index must be one single zero or no index at all */
698 		if (vindex->len > 1 || (vindex->len == 1 &&
699 		    vindex->subs[0] != 0))
700 			report("bad index on leaf node");
701 		vindex->len = 1;
702 		vindex->subs[0] = 0;
703 	} else {
704 		/* resulting oid must not be too long */
705 		if (node->oid.len + vindex->len > ASN_MAXOIDLEN)
706 			report("resulting OID too long");
707 	}
708 
709 	/*
710 	 * Get the next assignment entry for the transaction.
711 	 */
712 	if ((tp = malloc(sizeof(*tp))) == NULL)
713 		report("%m");
714 
715 	tp->value = *value;
716 	tp->node_name = node->name;
717 
718 	/*
719 	 * Build the OID
720 	 */
721 	tp->value.var = node->oid;
722 	for (i = 0; i < vindex->len; i++)
723 		tp->value.var.subs[tp->value.var.len++] = vindex->subs[i];
724 
725 	/*
726 	 * Puzzle together the variables for the call and call the
727 	 * set routine. The set routine may make our node pointer
728 	 * invalid (if we happend to call the module loader) so
729 	 * get a copy of the node name beforehands.
730 	 */
731 	snprintf(nodename, sizeof(nodename), "%s", node->name);
732 	snmp_ctx->scratch = &tp->scratch;
733 	snmp_ctx->var_index = 0;
734 	err = (*node->op)(snmp_ctx, &tp->value, node->oid.len, node->index,
735 	    SNMP_OP_SET);
736 	if (err != 0) {
737 		free(tp);
738 		report("assignment to %s.%s returns %d", nodename,
739 		    asn_oid2str(vindex), err);
740 	}
741 
742 	TAILQ_INSERT_TAIL(&assigns, tp, link);
743 }
744 
745 
746 /*
747  * Parse the section statement
748  */
749 static void
750 parse_section(const struct lmodule *mod)
751 {
752 	if (token != TOK_STR)
753 		report("expecting section name");
754 
755 	if (strcmp(strval, "snmpd") == 0) {
756 		if (mod != NULL)
757 			/* loading a module - ignore common stuff */
758 			ignore = 1;
759 		else
760 			/* global configuration - don't ignore */
761 			ignore = 0;
762 	} else {
763 		if (mod == NULL) {
764 			/* global configuration - ignore module stuff */
765 			ignore = 1;
766 		} else {
767 			/* loading module - check if it's our section */
768 			ignore = (strcmp(strval, mod->section) != 0);
769 		}
770 	}
771 	gettoken();
772 }
773 
774 /*
775  * Convert a hostname to four u_chars
776  */
777 static void
778 gethost(const char *host, u_char *ip)
779 {
780 	struct addrinfo hints, *res;
781 	int error;
782 	struct sockaddr_in *sain;
783 
784 	memset(&hints, 0, sizeof(hints));
785 	hints.ai_family = AF_INET;
786 	hints.ai_socktype = SOCK_DGRAM;
787 	hints.ai_protocol = IPPROTO_UDP;
788 	hints.ai_flags = AI_PASSIVE;
789 	error = getaddrinfo(host, NULL, &hints, &res);
790 	if (error != 0)
791 		report("%s: %s", host, gai_strerror(error));
792 	if (res == NULL)
793 		report("%s: unknown hostname", host);
794 
795 	sain = (struct sockaddr_in *)(void *)res->ai_addr;
796 	sain->sin_addr.s_addr = ntohl(sain->sin_addr.s_addr);
797 	ip[0] = sain->sin_addr.s_addr >> 24;
798 	ip[1] = sain->sin_addr.s_addr >> 16;
799 	ip[2] = sain->sin_addr.s_addr >>  8;
800 	ip[3] = sain->sin_addr.s_addr >>  0;
801 
802 	freeaddrinfo(res);
803 }
804 
805 /*
806  * Parse the left hand side of a config line.
807  */
808 static const struct snmp_node *
809 parse_oid(const char *varname, struct asn_oid *oid)
810 {
811 	struct snmp_node *node;
812 	u_int i;
813 	u_char ip[4];
814 	struct asn_oid str_oid;
815 
816 	for (node = tree; node < &tree[tree_size]; node++)
817 		if (strcmp(varname, node->name) == 0)
818 			break;
819 	if (node == &tree[tree_size])
820 		node = NULL;
821 
822 	oid->len = 0;
823 	while (token == '.') {
824 		if (gettoken() == TOK_NUM) {
825 			if (numval > ASN_MAXID)
826 				report("subid too large %#jx",
827 				    (uintmax_t)numval);
828 			if (oid->len == ASN_MAXOIDLEN)
829 				report("index too long");
830 			if (gettoken() != ':')
831 				oid->subs[oid->len++] = numval;
832 			else {
833 				str_oid.len = 0;
834 				str_oid.subs[str_oid.len++] = numval;
835 				while (gettoken() == TOK_NUM) {
836 					str_oid.subs[str_oid.len++] = numval;
837 					if (gettoken() != ':')
838 						break;
839 				}
840 				oid->subs[oid->len++] = str_oid.len;
841 				asn_append_oid(oid, &str_oid);
842 			}
843 
844 		} else if (token == TOK_STR) {
845 			if (strvallen + oid->len + 1 > ASN_MAXOIDLEN)
846 				report("oid too long");
847 			oid->subs[oid->len++] = strvallen;
848 			for (i = 0; i < strvallen; i++)
849 				oid->subs[oid->len++] = strval[i];
850 			gettoken();
851 
852 		} else if (token == TOK_HOST) {
853 			gethost(strval, ip);
854 			if (oid->len + 4 > ASN_MAXOIDLEN)
855 				report("index too long");
856 			for (i = 0; i < 4; i++)
857 				oid->subs[oid->len++] = ip[i];
858 			gettoken();
859 		} else
860 			report("bad token in index");
861 	}
862 
863 	return (node);
864 }
865 
866 /*
867  * Parse the value for an assignment.
868  */
869 static void
870 parse_syntax_null(struct snmp_value *value __unused)
871 {
872 	if (token != TOK_EOL)
873 		report("bad NULL syntax");
874 }
875 
876 static void
877 parse_syntax_integer(struct snmp_value *value)
878 {
879 	if (token != TOK_NUM)
880 		report("bad INTEGER syntax");
881 	if (numval > 0x7fffffff)
882 		report("INTEGER too large %ju", (uintmax_t)numval);
883 
884 	value->v.integer = numval;
885 	gettoken();
886 }
887 
888 static void
889 parse_syntax_counter64(struct snmp_value *value)
890 {
891 	if (token != TOK_NUM)
892 		report("bad COUNTER64 syntax");
893 
894 	value->v.counter64 = numval;
895 	gettoken();
896 }
897 
898 static void
899 parse_syntax_octetstring(struct snmp_value *value)
900 {
901 	u_long alloc;
902 	u_char *noct;
903 
904 	if (token == TOK_STR) {
905 		value->v.octetstring.len = strvallen;
906 		value->v.octetstring.octets = malloc(strvallen);
907 		(void)memcpy(value->v.octetstring.octets, strval, strvallen);
908 		gettoken();
909 		return;
910 	}
911 
912 	/* XX:XX:XX syntax */
913 	value->v.octetstring.octets = NULL;
914 	value->v.octetstring.len = 0;
915 
916 	if (token != TOK_NUM)
917 		/* empty string is allowed */
918 		return;
919 
920 	if (ERRPUSH()) {
921 		free(value->v.octetstring.octets);
922 		ERRNEXT();
923 	}
924 
925 	alloc = 0;
926 	for (;;) {
927 		if (token != TOK_NUM)
928 			report("bad OCTETSTRING syntax");
929 		if (numval > 0xff)
930 			report("byte value too large");
931 		if (alloc == value->v.octetstring.len) {
932 			alloc += 100;
933 			noct = realloc(value->v.octetstring.octets, alloc);
934 			if (noct == NULL)
935 				report("%m");
936 			value->v.octetstring.octets = noct;
937 		}
938 		value->v.octetstring.octets[value->v.octetstring.len++]
939 		    = numval;
940 		if (gettoken() != ':')
941 			break;
942 		gettoken();
943 	}
944 	ERRPOP();
945 }
946 
947 static void
948 parse_syntax_oid(struct snmp_value *value)
949 {
950 	value->v.oid.len = 0;
951 
952 	if (token != TOK_NUM)
953 		return;
954 
955 	for (;;) {
956 		if (token != TOK_NUM)
957 			report("bad OID syntax");
958 		if (numval > ASN_MAXID)
959 			report("subid too large");
960 		if (value->v.oid.len == ASN_MAXOIDLEN)
961 			report("OID too long");
962 		value->v.oid.subs[value->v.oid.len++] = numval;
963 		if (gettoken() != '.')
964 			break;
965 		gettoken();
966 	}
967 }
968 
969 static void
970 parse_syntax_ipaddress(struct snmp_value *value)
971 {
972 	int i;
973 	u_char ip[4];
974 
975 	if (token == TOK_NUM) {
976 		/* numerical address */
977 		i = 0;
978 		for (;;) {
979 			if (numval >= 256)
980 				report("ip address part too large");
981 			value->v.ipaddress[i++] = numval;
982 			if (i == 4)
983 				break;
984 			if (gettoken() != '.')
985 				report("expecting '.' in ip address");
986 		}
987 		gettoken();
988 
989 	} else if (token == TOK_HOST) {
990 		/* host name */
991 		gethost(strval, ip);
992 		for (i = 0; i < 4; i++)
993 			value->v.ipaddress[i] = ip[i];
994 		gettoken();
995 
996 	} else
997 		report("bad ip address syntax");
998 }
999 
1000 static void
1001 parse_syntax_uint32(struct snmp_value *value)
1002 {
1003 
1004 	if (token != TOK_NUM)
1005 		report("bad number syntax");
1006 	if (numval > 0xffffffff)
1007 		report("number too large");
1008 	value->v.uint32 = numval;
1009 	gettoken();
1010 }
1011 
1012 /*
1013  * Parse an assignement line
1014  */
1015 static void
1016 parse_assign(const char *varname)
1017 {
1018 	struct snmp_value value;
1019 	struct asn_oid vindex;
1020 	const struct snmp_node *node;
1021 
1022 	node = parse_oid(varname, &vindex);
1023 	if (token != '=')
1024 		report("'=' expected, got '%c'", token);
1025 	gettoken();
1026 
1027 	if (ignore) {
1028 		/* skip rest of line */
1029 		while (token != TOK_EOL && token != TOK_EOF)
1030 			gettoken();
1031 		return;
1032 	}
1033 	if (node == NULL)
1034 		report("unknown variable");
1035 
1036 	switch (value.syntax = node->syntax) {
1037 
1038 	  case SNMP_SYNTAX_NULL:
1039 		parse_syntax_null(&value);
1040 		break;
1041 
1042 	  case SNMP_SYNTAX_INTEGER:
1043 		parse_syntax_integer(&value);
1044 		break;
1045 
1046 	  case SNMP_SYNTAX_COUNTER64:
1047 		parse_syntax_counter64(&value);
1048 		break;
1049 
1050 	  case SNMP_SYNTAX_OCTETSTRING:
1051 		parse_syntax_octetstring(&value);
1052 		break;
1053 
1054 	  case SNMP_SYNTAX_OID:
1055 		parse_syntax_oid(&value);
1056 		break;
1057 
1058 	  case SNMP_SYNTAX_IPADDRESS:
1059 		parse_syntax_ipaddress(&value);
1060 		break;
1061 
1062 	  case SNMP_SYNTAX_COUNTER:
1063 	  case SNMP_SYNTAX_GAUGE:
1064 	  case SNMP_SYNTAX_TIMETICKS:
1065 		parse_syntax_uint32(&value);
1066 		break;
1067 
1068 	  case SNMP_SYNTAX_NOSUCHOBJECT:
1069 	  case SNMP_SYNTAX_NOSUCHINSTANCE:
1070 	  case SNMP_SYNTAX_ENDOFMIBVIEW:
1071 		abort();
1072 	}
1073 
1074 	if (ERRPUSH()) {
1075 		snmp_value_free(&value);
1076 		ERRNEXT();
1077 	}
1078 
1079 	handle_assignment(node, &vindex, &value);
1080 
1081 	ERRPOP();
1082 }
1083 
1084 /*
1085  * Handle macro definition line
1086  * We have already seen the := and the input now stands at the character
1087  * after the =. Skip whitespace and then call the input routine directly to
1088  * eat up characters.
1089  */
1090 static void
1091 parse_define(const char *varname)
1092 {
1093 	char *volatile string;
1094 	char *new;
1095 	volatile size_t alloc, length;
1096 	int c;
1097 	struct macro *m;
1098 	int t = token;
1099 
1100 	alloc = 100;
1101 	length = 0;
1102 	if ((string = malloc(alloc)) == NULL)
1103 		report("%m");
1104 
1105 	if (ERRPUSH()) {
1106 		free(string);
1107 		ERRNEXT();
1108 	}
1109 
1110 	while ((c = input_getc_plain()) != EOF) {
1111 		if (c == '\n' || !isspace(c))
1112 			break;
1113 	}
1114 
1115 	while (c != EOF && c != '#' && c != '\n') {
1116 		if (alloc == length) {
1117 			alloc *= 2;
1118 			if ((new = realloc(string, alloc)) == NULL)
1119 				report("%m");
1120 			string = new;
1121 		}
1122 		string[length++] = c;
1123 		c = input_getc_plain();
1124 	}
1125 	if (c == '#') {
1126 		while ((c = input_getc_plain()) != EOF && c != '\n')
1127 			;
1128 	}
1129 	if (c == EOF)
1130 		report("EOF in macro definition");
1131 
1132 	LIST_FOREACH(m, &macros, link)
1133 		if (strcmp(m->name, varname) == 0)
1134 			break;
1135 
1136 	if (m == NULL) {
1137 		if ((m = malloc(sizeof(*m))) == NULL)
1138 			report("%m");
1139 		if ((m->name = malloc(strlen(varname) + 1)) == NULL) {
1140 			free(m);
1141 			report("%m");
1142 		}
1143 		strcpy(m->name, varname);
1144 		m->perm = 0;
1145 		LIST_INSERT_HEAD(&macros, m, link);
1146 
1147 		m->value = string;
1148 		m->length = length;
1149 	} else {
1150 		if (t == TOK_ASSIGN) {
1151 			free(m->value);
1152 			m->value = string;
1153 			m->length = length;
1154 		} else
1155 			free(string);
1156 	}
1157 
1158 	token = TOK_EOL;
1159 
1160 	ERRPOP();
1161 }
1162 
1163 /*
1164  * Free all macros
1165  */
1166 static void
1167 macro_free_all(void)
1168 {
1169 	static struct macro *m, *m1;
1170 
1171 	m = LIST_FIRST(&macros);
1172 	while (m != NULL) {
1173 		m1 = LIST_NEXT(m, link);
1174 		if (!m->perm) {
1175 			free(m->name);
1176 			free(m->value);
1177 			LIST_REMOVE(m, link);
1178 			free(m);
1179 		}
1180 		m = m1;
1181 	}
1182 }
1183 
1184 /*
1185  * Parse an include directive and switch to the new file
1186  */
1187 static void
1188 parse_include(void)
1189 {
1190 	int sysdir = 0;
1191 	char fname[_POSIX2_LINE_MAX];
1192 
1193 	if (gettoken() == '<') {
1194 		sysdir = 1;
1195 		if (gettoken() != TOK_STR)
1196 			report("expecting filename after in .include");
1197 	} else if (token != TOK_STR)
1198 		report("expecting filename after in .include");
1199 
1200 	strcpy(fname, strval);
1201 	if (sysdir && gettoken() != '>')
1202 		report("expecting '>'");
1203 	gettoken();
1204 	if (input_open_file(fname, sysdir) == -1)
1205 		report("%s: %m", fname);
1206 }
1207 
1208 /*
1209  * Parse the configuration file
1210  */
1211 static void
1212 parse_file(const struct lmodule *mod)
1213 {
1214 	char varname[_POSIX2_LINE_MAX];
1215 
1216 	while (gettoken() != TOK_EOF) {
1217 		if (token == TOK_EOL)
1218 			/* empty line */
1219 			continue;
1220 		if (token == '%') {
1221 			gettoken();
1222 			parse_section(mod);
1223 		} else if (token == '.') {
1224 			if (gettoken() != TOK_STR)
1225 				report("keyword expected after '.'");
1226 			if (strcmp(strval, "include") == 0)
1227 				parse_include();
1228 			else
1229 				report("unknown keyword '%s'", strval);
1230 		} else if (token == TOK_STR) {
1231 			strcpy(varname, strval);
1232 			if (gettoken() == TOK_ASSIGN || token == TOK_QASSIGN)
1233 				parse_define(varname);
1234 			else
1235 				parse_assign(varname);
1236 		}
1237 		if (token != TOK_EOL)
1238 			report("eol expected");
1239 	}
1240 }
1241 
1242 /*
1243  * Do rollback on errors
1244  */
1245 static void
1246 do_rollback(void)
1247 {
1248 	struct assign *tp;
1249 	struct snmp_node *node;
1250 
1251 	while ((tp = TAILQ_LAST(&assigns, assigns)) != NULL) {
1252 		TAILQ_REMOVE(&assigns, tp, link);
1253 		for (node = tree; node < &tree[tree_size]; node++)
1254 			if (node->name == tp->node_name) {
1255 				snmp_ctx->scratch = &tp->scratch;
1256 				(void)(*node->op)(snmp_ctx, &tp->value,
1257 				    node->oid.len, node->index,
1258 				    SNMP_OP_ROLLBACK);
1259 				break;
1260 			}
1261 		if (node == &tree[tree_size])
1262 			syslog(LOG_ERR, "failed to find node for "
1263 			    "rollback");
1264 		snmp_value_free(&tp->value);
1265 		free(tp);
1266 	}
1267 }
1268 
1269 /*
1270  * Do commit
1271  */
1272 static void
1273 do_commit(void)
1274 {
1275 	struct assign *tp;
1276 	struct snmp_node *node;
1277 
1278 	while ((tp = TAILQ_FIRST(&assigns)) != NULL) {
1279 		TAILQ_REMOVE(&assigns, tp, link);
1280 		for (node = tree; node < &tree[tree_size]; node++)
1281 			if (node->name == tp->node_name) {
1282 				snmp_ctx->scratch = &tp->scratch;
1283 				(void)(*node->op)(snmp_ctx, &tp->value,
1284 				    node->oid.len, node->index, SNMP_OP_COMMIT);
1285 				break;
1286 			}
1287 		if (node == &tree[tree_size])
1288 			syslog(LOG_ERR, "failed to find node for commit");
1289 		snmp_value_free(&tp->value);
1290 		free(tp);
1291 	}
1292 }
1293 
1294 /*
1295  * Read the configuration file. Handle the entire file as one transaction.
1296  *
1297  * If lodmod is NULL, the sections for 'snmpd' and all loaded modules are
1298  * executed. If it is not NULL, only the sections for that module are handled.
1299  */
1300 int
1301 read_config(const char *fname, struct lmodule *lodmod)
1302 {
1303 	int err;
1304 	char objbuf[ASN_OIDSTRLEN];
1305 	char idxbuf[ASN_OIDSTRLEN];
1306 
1307 	ignore = 0;
1308 
1309 	input_push = 0;
1310 
1311 	if (ERRPUSH())
1312 		return (-1);
1313 	if (input_open_file(fname, 0) == -1) {
1314 		syslog(LOG_ERR, "%s: %m", fname);
1315 		return (-1);
1316 	}
1317 	ERRPOP();
1318 	community = COMM_INITIALIZE;
1319 
1320 	if ((snmp_ctx = snmp_init_context()) == NULL) {
1321 		input_close_all();
1322 		syslog(LOG_ERR, "%m");
1323 		return (-1);
1324 	}
1325 
1326 	if (ERRPUSH()) {
1327 		do_rollback();
1328 		input_close_all();
1329 		macro_free_all();
1330 		free(snmp_ctx);
1331 		return (-1);
1332 	}
1333 	parse_file(lodmod);
1334 	ERRPOP();
1335 
1336 	if ((err = snmp_dep_commit(snmp_ctx)) != SNMP_ERR_NOERROR) {
1337 		syslog(LOG_ERR, "init dep failed: %u %s %s", err,
1338 		    asn_oid2str_r(&snmp_ctx->dep->obj, objbuf),
1339 		    asn_oid2str_r(&snmp_ctx->dep->idx, idxbuf));
1340 		snmp_dep_rollback(snmp_ctx);
1341 		do_rollback();
1342 		input_close_all();
1343 		macro_free_all();
1344 		free(snmp_ctx);
1345 		return (-1);
1346 	}
1347 
1348 	do_commit();
1349 	snmp_dep_finish(snmp_ctx);
1350 
1351 	macro_free_all();
1352 
1353 	free(snmp_ctx);
1354 
1355 	return (0);
1356 }
1357 
1358 /*
1359  * Define a permanent macro
1360  */
1361 int
1362 define_macro(const char *name, const char *value)
1363 {
1364 	struct macro *m;
1365 
1366 	if ((m = malloc(sizeof(*m))) == NULL)
1367 		return (-1);
1368 	if ((m->name = malloc(strlen(name) + 1)) == NULL) {
1369 		free(m);
1370 		return (-1);
1371 	}
1372 	strcpy(m->name, name);
1373 	if ((m->value = malloc(strlen(value) + 1)) == NULL) {
1374 		free(m->name);
1375 		free(m);
1376 		return (-1);
1377 	}
1378 	strcpy(m->value, value);
1379 	m->length = strlen(value);
1380 	m->perm = 1;
1381 	LIST_INSERT_HEAD(&macros, m, link);
1382 	return (0);
1383 }
1384