Head

GCC Code Coverage Report

Directory:	./		Exec	Total	Coverage
File:	usr.sbin/snmpctl/parser.c	Lines:	32	145	22.1 %
Date:	2017-11-07	Branches:	25	150	16.7 %


/*	$OpenBSD: parser.c,v 1.15 2014/04/14 12:56:21 blambert Exp $	*/

/*
 * Copyright (c) 2008 Reyk Floeter <reyk@openbsd.org>
 * Copyright (c) 2004 Esben Norby <norby@openbsd.org>
 * Copyright (c) 2003, 2004 Henning Brauer <henning@openbsd.org>
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

#include <sys/types.h>
#include <sys/socket.h>
#include <sys/queue.h>
#include <sys/tree.h>
#include <sys/uio.h>

#include <netinet/in.h>
#include <net/if.h>
#include <arpa/inet.h>

#include <err.h>
#include <errno.h>
#include <limits.h>
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <string.h>
#include <event.h>

#include "snmpd.h"
#include "snmp.h"
#include "parser.h"

enum token_type {
	NOTOKEN,
	ENDTOKEN,
	KEYWORD,
	TRAPOID,
	ELEMENTOBJECT,
	VALTYPE,
	IPADDRVAL,
	INT32VAL,
	UINT32VAL,
	INT64VAL,
	STRINGVAL,
	SNMPOID,
	SNMPHOST,
	SNMPCOMMUNITY,
	SNMPVERSION
};

struct token {
	enum token_type		 type;
	const char		*keyword;
	int			 value;
	const struct token	*next;
};

static const struct token t_main[];
static const struct token t_show[];
static const struct token t_trap[];
static const struct token t_trapoid[];
static const struct token t_element[];
static const struct token t_oid[];
static const struct token t_type[];
static const struct token t_ipaddr[];
static const struct token t_int32[];
static const struct token t_uint32[];
static const struct token t_int64[];
static const struct token t_string[];
static const struct token t_snmp[];
static const struct token t_snmpclient[];
static const struct token t_snmphost[];
static const struct token t_snmpoid[];
static const struct token t_snmpcommunity[];
static const struct token t_snmpversion[];

static const struct token t_main[] = {
	{KEYWORD,	"monitor",	MONITOR,	NULL},
	{KEYWORD,	"show",		NONE,		t_show},
	{KEYWORD,	"snmp",		NONE,		t_snmp},
	{KEYWORD,	"trap",		NONE,		t_trap},
	{KEYWORD,	"walk",		WALK,		t_snmphost},
	{ENDTOKEN,	"",		NONE,		NULL}
};

static const struct token t_show[] = {
	{KEYWORD,	"mib",		SHOW_MIB,	NULL},
	{ENDTOKEN,	"",		NONE,		NULL}
};

static const struct token t_snmp[] = {
	{KEYWORD,	"bulkwalk",	BULKWALK,	t_snmphost},
	{KEYWORD,	"get",		GET,		t_snmphost},
	{KEYWORD,	"walk",		WALK,		t_snmphost},
	{ENDTOKEN,	"",		NONE,		NULL}
};

static const struct token t_snmphost[] = {
	{SNMPHOST,	"",		NONE,		t_snmpclient},
	{ENDTOKEN,	"",		NONE,		NULL}
};

static const struct token t_snmpclient[] = {
	{NOTOKEN,	"",		NONE,		NULL},
	{KEYWORD,	"oid",		NONE,		t_snmpoid},
	{KEYWORD,	"community",	NONE,		t_snmpcommunity},
	{KEYWORD,	"version",	NONE,		t_snmpversion},
	{ENDTOKEN,	"",		NONE,		NULL}
};

static const struct token t_snmpoid[] = {
	{SNMPOID,	"",		NONE,		t_snmpclient},
	{ENDTOKEN,	"",		NONE,		NULL}
};

static const struct token t_snmpcommunity[] = {
	{SNMPCOMMUNITY,	"",		NONE,		t_snmpclient},
	{ENDTOKEN,	"",		NONE,		NULL}
};

static const struct token t_snmpversion[] = {
	{SNMPVERSION,	"",		NONE,		t_snmpclient},
	{ENDTOKEN,	"",		NONE,		NULL}
};

static const struct token t_trap[] = {
	{KEYWORD,	"send",		TRAP,		t_trapoid},
	{ENDTOKEN,	"",		NONE,		NULL}
};

static const struct token t_trapoid[] = {
	{TRAPOID,	"",		NONE,		t_element},
	{ENDTOKEN,	"",		NONE,		NULL}
};

static const struct token t_element[] = {
	{NOTOKEN,	"",		NONE,		NULL},
	{KEYWORD,	"oid",		NONE,		t_oid},
	{ENDTOKEN,	"",		NONE,		NULL}
};

static const struct token t_oid[] = {
	{ELEMENTOBJECT,	"",		NONE,		t_type},
	{ENDTOKEN,	"",		NONE,		NULL}
};

static const struct token t_type[] = {
	{VALTYPE,	"ip",		SNMP_IPADDR,	t_ipaddr },
	{VALTYPE,	"counter",	SNMP_COUNTER32,	t_int32 },
	{VALTYPE,	"gauge",	SNMP_GAUGE32,	t_int32 },
	{VALTYPE,	"unsigned",	SNMP_GAUGE32,	t_uint32 },
	{VALTYPE,	"ticks",	SNMP_TIMETICKS,	t_int32 },
	{VALTYPE,	"opaque",	SNMP_OPAQUE,	t_int32 },
	{VALTYPE,	"nsap",		SNMP_NSAPADDR,	t_int32 },
	{VALTYPE,	"counter64",	SNMP_COUNTER64,	t_int64 },
	{VALTYPE,	"uint",		SNMP_UINTEGER32, t_uint32 },
	{VALTYPE,	"int",		SNMP_INTEGER32,	t_int32 },
	{VALTYPE,	"bitstring",	SNMP_BITSTRING,	t_string },
	{VALTYPE,	"string",	SNMP_OCTETSTRING, t_string },
	{VALTYPE,	"null",		SNMP_NULL,	t_element },
	{VALTYPE,	"oid",		SNMP_OBJECT,	t_string },
	{ENDTOKEN,	"",		NONE,		NULL}
};

static const struct token t_ipaddr[] = {
	{IPADDRVAL,	"",		NONE,		t_element},
	{ENDTOKEN,	"",		NONE,		NULL}
};

static const struct token t_int32[] = {
	{INT32VAL,	"",		NONE,		t_element},
	{ENDTOKEN,	"",		NONE,		NULL}
};

static const struct token t_uint32[] = {
	{UINT32VAL,	"",		NONE,		t_element},
	{ENDTOKEN,	"",		NONE,		NULL}
};

static const struct token t_int64[] = {
	{INT64VAL,	"",		NONE,		t_element},
	{ENDTOKEN,	"",		NONE,		NULL}
};

static const struct token t_string[] = {
	{STRINGVAL,	"",		NONE,		t_element},
	{ENDTOKEN,	"",		NONE,		NULL}
};

static struct parse_result	 res;

const struct token		*match_token(char *, const struct token []);
void				 show_valid_args(const struct token []);

struct parse_result *
parse(int argc, char *argv[])
{
	const struct token	*table = t_main;
	const struct token	*match;

	bzero(&res, sizeof(res));
	res.version = -1;
	TAILQ_INIT(&res.oids);
	TAILQ_INIT(&res.varbinds);

	while (argc >= 0) {
		if ((match = match_token(argv[0], table)) == NULL) {
			fprintf(stderr, "valid commands/args:\n");
			show_valid_args(table);
			return (NULL);
		}

		argc--;
		argv++;

		if (match->type == NOTOKEN || match->next == NULL)
			break;

		table = match->next;
	}

	if (argc > 0) {
		fprintf(stderr, "superfluous argument: %s\n", argv[0]);
		return (NULL);
	}

	return (&res);
}

const struct token *
match_token(char *word, const struct token table[])
{
	u_int			 i, match = 0;
	const struct token	*t = NULL;
	const char		*errs = NULL;
	int			 terminal = 0;
	struct parse_val	*val;
	struct parse_varbind	*vb = NULL;

	for (i = 0; table[i].type != ENDTOKEN; i++) {
		switch (table[i].type) {
		case NOTOKEN:
			if (word == NULL || strlen(word) == 0) {
				match++;
				t = &table[i];
			}
			break;
		case KEYWORD:
			if (word != NULL && strncmp(word, table[i].keyword,
			    strlen(word)) == 0) {
				match++;
				t = &table[i];
				if (t->value)
					res.action = t->value;
			}
			break;
		case SNMPHOST:
			if (!match && word != NULL && strlen(word) > 0 &&
			    res.host == NULL) {
				if ((res.host = strdup(word)) == NULL)
					err(1, "strdup");
				match++;
				t = &table[i];
			}
			break;
		case SNMPOID:
			if (!match && word != NULL && strlen(word) > 0) {
				if ((val = calloc(1, sizeof(*val))) == NULL ||
				    (val->val = strdup(word)) == NULL)
					err(1, "strdup");
				TAILQ_INSERT_TAIL(&res.oids, val, val_entry);
				match++;
				t = &table[i];
			}
			break;
		case SNMPCOMMUNITY:
			if (!match && word != NULL && strlen(word) > 0 &&
			    res.community == NULL) {
				if ((res.community = strdup(word)) == NULL)
					err(1, "strdup");
				match++;
				t = &table[i];
			}
			break;
		case SNMPVERSION:
			if (!match && word != NULL && strlen(word) > 0 &&
			    res.version == -1) {
				if (strcmp("1", word) == 0)
					res.version = SNMP_V1;
				else if (strcmp("2c", word) == 0)
					res.version = SNMP_V2;
				else
					break;
				match++;
				t = &table[i];
			}
			break;
		case VALTYPE:
			if (word != NULL && strncmp(word, table[i].keyword,
			    strlen(word)) == 0) {
				match++;
				t = &table[i];
				vb = TAILQ_LAST(&res.varbinds, parse_varbinds);
				if (vb == NULL)
					errx(1, "inconsistent varbind list");
				vb->sm.snmp_type = t->value;
				if (t->value == SNMP_NULL)
					terminal = 1;
			}
			break;
		case TRAPOID:
			if (word == NULL || strlen(word) == 0)
				break;
			if ((res.trapoid = strdup(word)) == NULL)
				err(1, "malloc");
			match++;
			t = &table[i];
			break;
		case ELEMENTOBJECT:
			if (word == NULL || strlen(word) == 0)
				break;
			if ((vb = calloc(1, sizeof(*vb))) == NULL)
				errx(1, "calloc");
			if (strlcpy(vb->sm.snmp_oid, word,
			    sizeof(vb->sm.snmp_oid)) >= sizeof(vb->sm.snmp_oid))
				errx(1, "oid too long");

			TAILQ_INSERT_TAIL(&res.varbinds, vb, vb_entry);
			match++;
			t = &table[i];
			break;
		case IPADDRVAL:
			if (word == NULL || strlen(word) == 0)
				break;
			vb = TAILQ_LAST(&res.varbinds, parse_varbinds);
			if (vb == NULL)
				errx(1, "inconsistent varbind list");
			if (inet_pton(AF_INET, word, &vb->u.in4) == -1) {
				/* XXX the SNMP_IPADDR type is IPv4-only? */
				if (inet_pton(AF_INET6, word, &vb->u.in6) == -1)
					errx(1, "invalid IP address");
				vb->sm.snmp_len = sizeof(vb->u.in6);
			} else {
				vb->sm.snmp_len = sizeof(vb->u.in4);
			}
			terminal = 1;
			break;
		case INT32VAL:
			if (word == NULL || strlen(word) == 0)
				break;
			vb = TAILQ_LAST(&res.varbinds, parse_varbinds);
			if (vb == NULL)
				errx(1, "inconsistent varbind list");
			vb->u.d = strtonum(word, INT_MIN, INT_MAX, &errs);
			vb->sm.snmp_len = sizeof(vb->u.d);
			terminal = 1;
			break;
		case UINT32VAL:
			if (word == NULL || strlen(word) == 0)
				break;
			vb = TAILQ_LAST(&res.varbinds, parse_varbinds);
			if (vb == NULL)
				errx(1, "inconsistent varbind list");
			vb->u.u = strtonum(word, 0, UINT_MAX, &errs);
			vb->sm.snmp_len = sizeof(vb->u.u);
			terminal = 1;
			break;
		case INT64VAL:
			if (word == NULL || strlen(word) == 0)
				break;
			vb = TAILQ_LAST(&res.varbinds, parse_varbinds);
			if (vb == NULL)
				errx(1, "inconsistent varbind list");
			vb->u.l = strtonum(word, INT64_MIN, INT64_MAX, &errs);
			vb->sm.snmp_len = sizeof(vb->u.l);
			terminal = 1;
			break;
		case STRINGVAL:
			if (word == NULL || strlen(word) == 0)
				break;
			vb = TAILQ_LAST(&res.varbinds, parse_varbinds);
			if (vb == NULL)
				errx(1, "inconsistent varbind list");
			vb->u.str = word;
			vb->sm.snmp_len = strlen(word);
			terminal = 1;
			break;
		case ENDTOKEN:
			break;
		}
		if (terminal)
			break;
	}

	if (terminal) {
		t = &table[i];
	} else if (match != 1) {
		if (word == NULL)
			fprintf(stderr, "missing argument:\n");
		else if (match > 1)
			fprintf(stderr, "ambiguous argument: %s\n", word);
		else if (match < 1)
			fprintf(stderr, "unknown argument: %s\n", word);
		return (NULL);
	}

	return (t);
}

void
show_valid_args(const struct token table[])
{
	int	i;

	for (i = 0; table[i].type != ENDTOKEN; i++) {
		switch (table[i].type) {
		case NOTOKEN:
			fprintf(stderr, "  <cr>\n");
			break;
		case KEYWORD:
			fprintf(stderr, "  %s\n", table[i].keyword);
			break;
		case VALTYPE:
			fprintf(stderr, "  %s <value>\n", table[i].keyword);
			break;
		case SNMPHOST:
			fprintf(stderr, "  <hostname>\n");
			break;
		case SNMPOID:
		case TRAPOID:
		case ELEMENTOBJECT:
			fprintf(stderr, "  <oid-string>\n");
			break;
		case IPADDRVAL:
			fprintf(stderr, "  <ip-address>\n");
			break;
		case INT32VAL:
			fprintf(stderr, "  <int32>\n");
			break;
		case UINT32VAL:
			fprintf(stderr, "  <uint32>\n");
			break;
		case INT64VAL:
			fprintf(stderr, "  <int64>\n");
			break;
		case STRINGVAL:
		case SNMPCOMMUNITY:
			fprintf(stderr, "  <string>\n");
			break;
		case SNMPVERSION:
			fprintf(stderr, "  [1|2c]\n");
			break;
		case ENDTOKEN:
			break;
		}
	}
}


Generated by: GCOVR (Version 3.3)

Line	Branch	Exec	Source
1			/* $OpenBSD: parser.c,v 1.15 2014/04/14 12:56:21 blambert Exp $ */
2
3			/*
4			* Copyright (c) 2008 Reyk Floeter <reyk@openbsd.org>
5			* Copyright (c) 2004 Esben Norby <norby@openbsd.org>
6			* Copyright (c) 2003, 2004 Henning Brauer <henning@openbsd.org>
7			*
8			* Permission to use, copy, modify, and distribute this software for any
9			* purpose with or without fee is hereby granted, provided that the above
10			* copyright notice and this permission notice appear in all copies.
11			*
12			* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
13			* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
14			* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
15			* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
16			* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
17			* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
18			* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
19			*/
20
21			#include <sys/types.h>
22			#include <sys/socket.h>
23			#include <sys/queue.h>
24			#include <sys/tree.h>
25			#include <sys/uio.h>
26
27			#include <netinet/in.h>
28			#include <net/if.h>
29			#include <arpa/inet.h>
30
31			#include <err.h>
32			#include <errno.h>
33			#include <limits.h>
34			#include <stdio.h>
35			#include <stdlib.h>
36			#include <stdint.h>
37			#include <string.h>
38			#include <event.h>
39
40			#include "snmpd.h"
41			#include "snmp.h"
42			#include "parser.h"
43
44			enum token_type {
45			NOTOKEN,
46			ENDTOKEN,
47			KEYWORD,
48			TRAPOID,
49			ELEMENTOBJECT,
50			VALTYPE,
51			IPADDRVAL,
52			INT32VAL,
53			UINT32VAL,
54			INT64VAL,
55			STRINGVAL,
56			SNMPOID,
57			SNMPHOST,
58			SNMPCOMMUNITY,
59			SNMPVERSION
60			};
61
62			struct token {
63			enum token_type type;
64			const char *keyword;
65			int value;
66			const struct token *next;
67			};
68
69			static const struct token t_main[];
70			static const struct token t_show[];
71			static const struct token t_trap[];
72			static const struct token t_trapoid[];
73			static const struct token t_element[];
74			static const struct token t_oid[];
75			static const struct token t_type[];
76			static const struct token t_ipaddr[];
77			static const struct token t_int32[];
78			static const struct token t_uint32[];
79			static const struct token t_int64[];
80			static const struct token t_string[];
81			static const struct token t_snmp[];
82			static const struct token t_snmpclient[];
83			static const struct token t_snmphost[];
84			static const struct token t_snmpoid[];
85			static const struct token t_snmpcommunity[];
86			static const struct token t_snmpversion[];
87
88			static const struct token t_main[] = {
89			{KEYWORD, "monitor", MONITOR, NULL},
90			{KEYWORD, "show", NONE, t_show},
91			{KEYWORD, "snmp", NONE, t_snmp},
92			{KEYWORD, "trap", NONE, t_trap},
93			{KEYWORD, "walk", WALK, t_snmphost},
94			{ENDTOKEN, "", NONE, NULL}
95			};
96
97			static const struct token t_show[] = {
98			{KEYWORD, "mib", SHOW_MIB, NULL},
99			{ENDTOKEN, "", NONE, NULL}
100			};
101
102			static const struct token t_snmp[] = {
103			{KEYWORD, "bulkwalk", BULKWALK, t_snmphost},
104			{KEYWORD, "get", GET, t_snmphost},
105			{KEYWORD, "walk", WALK, t_snmphost},
106			{ENDTOKEN, "", NONE, NULL}
107			};
108
109			static const struct token t_snmphost[] = {
110			{SNMPHOST, "", NONE, t_snmpclient},
111			{ENDTOKEN, "", NONE, NULL}
112			};
113
114			static const struct token t_snmpclient[] = {
115			{NOTOKEN, "", NONE, NULL},
116			{KEYWORD, "oid", NONE, t_snmpoid},
117			{KEYWORD, "community", NONE, t_snmpcommunity},
118			{KEYWORD, "version", NONE, t_snmpversion},
119			{ENDTOKEN, "", NONE, NULL}
120			};
121
122			static const struct token t_snmpoid[] = {
123			{SNMPOID, "", NONE, t_snmpclient},
124			{ENDTOKEN, "", NONE, NULL}
125			};
126
127			static const struct token t_snmpcommunity[] = {
128			{SNMPCOMMUNITY, "", NONE, t_snmpclient},
129			{ENDTOKEN, "", NONE, NULL}
130			};
131
132			static const struct token t_snmpversion[] = {
133			{SNMPVERSION, "", NONE, t_snmpclient},
134			{ENDTOKEN, "", NONE, NULL}
135			};
136
137			static const struct token t_trap[] = {
138			{KEYWORD, "send", TRAP, t_trapoid},
139			{ENDTOKEN, "", NONE, NULL}
140			};
141
142			static const struct token t_trapoid[] = {
143			{TRAPOID, "", NONE, t_element},
144			{ENDTOKEN, "", NONE, NULL}
145			};
146
147			static const struct token t_element[] = {
148			{NOTOKEN, "", NONE, NULL},
149			{KEYWORD, "oid", NONE, t_oid},
150			{ENDTOKEN, "", NONE, NULL}
151			};
152
153			static const struct token t_oid[] = {
154			{ELEMENTOBJECT, "", NONE, t_type},
155			{ENDTOKEN, "", NONE, NULL}
156			};
157
158			static const struct token t_type[] = {
159			{VALTYPE, "ip", SNMP_IPADDR, t_ipaddr },
160			{VALTYPE, "counter", SNMP_COUNTER32, t_int32 },
161			{VALTYPE, "gauge", SNMP_GAUGE32, t_int32 },
162			{VALTYPE, "unsigned", SNMP_GAUGE32, t_uint32 },
163			{VALTYPE, "ticks", SNMP_TIMETICKS, t_int32 },
164			{VALTYPE, "opaque", SNMP_OPAQUE, t_int32 },
165			{VALTYPE, "nsap", SNMP_NSAPADDR, t_int32 },
166			{VALTYPE, "counter64", SNMP_COUNTER64, t_int64 },
167			{VALTYPE, "uint", SNMP_UINTEGER32, t_uint32 },
168			{VALTYPE, "int", SNMP_INTEGER32, t_int32 },
169			{VALTYPE, "bitstring", SNMP_BITSTRING, t_string },
170			{VALTYPE, "string", SNMP_OCTETSTRING, t_string },
171			{VALTYPE, "null", SNMP_NULL, t_element },
172			{VALTYPE, "oid", SNMP_OBJECT, t_string },
173			{ENDTOKEN, "", NONE, NULL}
174			};
175
176			static const struct token t_ipaddr[] = {
177			{IPADDRVAL, "", NONE, t_element},
178			{ENDTOKEN, "", NONE, NULL}
179			};
180
181			static const struct token t_int32[] = {
182			{INT32VAL, "", NONE, t_element},
183			{ENDTOKEN, "", NONE, NULL}
184			};
185
186			static const struct token t_uint32[] = {
187			{UINT32VAL, "", NONE, t_element},
188			{ENDTOKEN, "", NONE, NULL}
189			};
190
191			static const struct token t_int64[] = {
192			{INT64VAL, "", NONE, t_element},
193			{ENDTOKEN, "", NONE, NULL}
194			};
195
196			static const struct token t_string[] = {
197			{STRINGVAL, "", NONE, t_element},
198			{ENDTOKEN, "", NONE, NULL}
199			};
200
201			static struct parse_result res;
202
203			const struct token match_token(char , const struct token []);
204			void show_valid_args(const struct token []);
205
206			struct parse_result *
207			parse(int argc, char *argv[])
208			{
209			const struct token *table = t_main;
210			const struct token *match;
211
212		8	bzero(&res, sizeof(res));
213		4	res.version = -1;
214		4	TAILQ_INIT(&res.oids);
215		4	TAILQ_INIT(&res.varbinds);
216
217	✓✗	32	while (argc >= 0) {
218	✗✓	16	if ((match = match_token(argv[0], table)) == NULL) {
219			fprintf(stderr, "valid commands/args:\n");
220			show_valid_args(table);
221			return (NULL);
222			}
223
224		16	argc--;
225		16	argv++;
226
227	✓✓✓✗	28	if (match->type == NOTOKEN \|\| match->next == NULL)
228			break;
229
230			table = match->next;
231			}
232
233	✗✓	4	if (argc > 0) {
234			fprintf(stderr, "superfluous argument: %s\n", argv[0]);
235			return (NULL);
236			}
237
238		4	return (&res);
239		4	}
240
241			const struct token *
242			match_token(char *word, const struct token table[])
243			{
244			u_int i, match = 0;
245			const struct token *t = NULL;
246		32	const char *errs = NULL;
247			int terminal = 0;
248			struct parse_val *val;
249			struct parse_varbind *vb = NULL;
250
251	✓✓	104	for (i = 0; table[i].type != ENDTOKEN; i++) {
252	✓✓✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✓	72	switch (table[i].type) {
253			case NOTOKEN:
254	✗✓✗✗	4	if (word == NULL \|\| strlen(word) == 0) {
255		4	match++;
256			t = &table[i];
257		4	}
258			break;
259			case KEYWORD:
260	✓✓✓✓	100	if (word != NULL && strncmp(word, table[i].keyword,
261		48	strlen(word)) == 0) {
262		8	match++;
263			t = &table[i];
264	✓✓	8	if (t->value)
265		4	res.action = t->value;
266			}
267			break;
268			case SNMPHOST:
269			if (!match && word != NULL && strlen(word) > 0 &&
270			res.host == NULL) {
271			if ((res.host = strdup(word)) == NULL)
272			err(1, "strdup");
273			match++;
274			t = &table[i];
275			}
276			break;
277			case SNMPOID:
278			if (!match && word != NULL && strlen(word) > 0) {
279			if ((val = calloc(1, sizeof(*val))) == NULL \|\|
280			(val->val = strdup(word)) == NULL)
281			err(1, "strdup");
282			TAILQ_INSERT_TAIL(&res.oids, val, val_entry);
283			match++;
284			t = &table[i];
285			}
286			break;
287			case SNMPCOMMUNITY:
288			if (!match && word != NULL && strlen(word) > 0 &&
289			res.community == NULL) {
290			if ((res.community = strdup(word)) == NULL)
291			err(1, "strdup");
292			match++;
293			t = &table[i];
294			}
295			break;
296			case SNMPVERSION:
297			if (!match && word != NULL && strlen(word) > 0 &&
298			res.version == -1) {
299			if (strcmp("1", word) == 0)
300			res.version = SNMP_V1;
301			else if (strcmp("2c", word) == 0)
302			res.version = SNMP_V2;
303			else
304			break;
305			match++;
306			t = &table[i];
307			}
308			break;
309			case VALTYPE:
310			if (word != NULL && strncmp(word, table[i].keyword,
311			strlen(word)) == 0) {
312			match++;
313			t = &table[i];
314			vb = TAILQ_LAST(&res.varbinds, parse_varbinds);
315			if (vb == NULL)
316			errx(1, "inconsistent varbind list");
317			vb->sm.snmp_type = t->value;
318			if (t->value == SNMP_NULL)
319			terminal = 1;
320			}
321			break;
322			case TRAPOID:
323	✓✗✓✗	8	if (word == NULL \|\| strlen(word) == 0)
324			break;
325	✗✓	4	if ((res.trapoid = strdup(word)) == NULL)
326			err(1, "malloc");
327		4	match++;
328			t = &table[i];
329		4	break;
330			case ELEMENTOBJECT:
331			if (word == NULL \|\| strlen(word) == 0)
332			break;
333			if ((vb = calloc(1, sizeof(*vb))) == NULL)
334			errx(1, "calloc");
335			if (strlcpy(vb->sm.snmp_oid, word,
336			sizeof(vb->sm.snmp_oid)) >= sizeof(vb->sm.snmp_oid))
337			errx(1, "oid too long");
338
339			TAILQ_INSERT_TAIL(&res.varbinds, vb, vb_entry);
340			match++;
341			t = &table[i];
342			break;
343			case IPADDRVAL:
344			if (word == NULL \|\| strlen(word) == 0)
345			break;
346			vb = TAILQ_LAST(&res.varbinds, parse_varbinds);
347			if (vb == NULL)
348			errx(1, "inconsistent varbind list");
349			if (inet_pton(AF_INET, word, &vb->u.in4) == -1) {
350			/* XXX the SNMP_IPADDR type is IPv4-only? */
351			if (inet_pton(AF_INET6, word, &vb->u.in6) == -1)
352			errx(1, "invalid IP address");
353			vb->sm.snmp_len = sizeof(vb->u.in6);
354			} else {
355			vb->sm.snmp_len = sizeof(vb->u.in4);
356			}
357			terminal = 1;
358			break;
359			case INT32VAL:
360			if (word == NULL \|\| strlen(word) == 0)
361			break;
362			vb = TAILQ_LAST(&res.varbinds, parse_varbinds);
363			if (vb == NULL)
364			errx(1, "inconsistent varbind list");
365			vb->u.d = strtonum(word, INT_MIN, INT_MAX, &errs);
366			vb->sm.snmp_len = sizeof(vb->u.d);
367			terminal = 1;
368			break;
369			case UINT32VAL:
370			if (word == NULL \|\| strlen(word) == 0)
371			break;
372			vb = TAILQ_LAST(&res.varbinds, parse_varbinds);
373			if (vb == NULL)
374			errx(1, "inconsistent varbind list");
375			vb->u.u = strtonum(word, 0, UINT_MAX, &errs);
376			vb->sm.snmp_len = sizeof(vb->u.u);
377			terminal = 1;
378			break;
379			case INT64VAL:
380			if (word == NULL \|\| strlen(word) == 0)
381			break;
382			vb = TAILQ_LAST(&res.varbinds, parse_varbinds);
383			if (vb == NULL)
384			errx(1, "inconsistent varbind list");
385			vb->u.l = strtonum(word, INT64_MIN, INT64_MAX, &errs);
386			vb->sm.snmp_len = sizeof(vb->u.l);
387			terminal = 1;
388			break;
389			case STRINGVAL:
390			if (word == NULL \|\| strlen(word) == 0)
391			break;
392			vb = TAILQ_LAST(&res.varbinds, parse_varbinds);
393			if (vb == NULL)
394			errx(1, "inconsistent varbind list");
395			vb->u.str = word;
396			vb->sm.snmp_len = strlen(word);
397			terminal = 1;
398			break;
399			case ENDTOKEN:
400			break;
401			}
402	✓✗	36	if (terminal)
403			break;
404			}
405
406	✗✓	16	if (terminal) {
407			t = &table[i];
408	✗✓	16	} else if (match != 1) {
409			if (word == NULL)
410			fprintf(stderr, "missing argument:\n");
411			else if (match > 1)
412			fprintf(stderr, "ambiguous argument: %s\n", word);
413			else if (match < 1)
414			fprintf(stderr, "unknown argument: %s\n", word);
415			return (NULL);
416			}
417
418		16	return (t);
419		16	}
420
421			void
422			show_valid_args(const struct token table[])
423			{
424			int i;
425
426			for (i = 0; table[i].type != ENDTOKEN; i++) {
427			switch (table[i].type) {
428			case NOTOKEN:
429			fprintf(stderr, " <cr>\n");
430			break;
431			case KEYWORD:
432			fprintf(stderr, " %s\n", table[i].keyword);
433			break;
434			case VALTYPE:
435			fprintf(stderr, " %s <value>\n", table[i].keyword);
436			break;
437			case SNMPHOST:
438			fprintf(stderr, " <hostname>\n");
439			break;
440			case SNMPOID:
441			case TRAPOID:
442			case ELEMENTOBJECT:
443			fprintf(stderr, " <oid-string>\n");
444			break;
445			case IPADDRVAL:
446			fprintf(stderr, " <ip-address>\n");
447			break;
448			case INT32VAL:
449			fprintf(stderr, " <int32>\n");
450			break;
451			case UINT32VAL:
452			fprintf(stderr, " <uint32>\n");
453			break;
454			case INT64VAL:
455			fprintf(stderr, " <int64>\n");
456			break;
457			case STRINGVAL:
458			case SNMPCOMMUNITY:
459			fprintf(stderr, " <string>\n");
460			break;
461			case SNMPVERSION:
462			fprintf(stderr, " [1\|2c]\n");
463			break;
464			case ENDTOKEN:
465			break;
466			}
467			}
468			}