xref: /freebsd/usr.sbin/bsnmpd/tools/libbsnmptools/bsnmptools.c (revision 777123969db5ee8eceee28d7df72b7fd7352cb85)
1 /*-
2  * Copyright (c) 2005-2006 The FreeBSD Project
3  * All rights reserved.
4  *
5  * Author: Shteryana Shopova <syrinx@FreeBSD.org>
6  *
7  * Redistribution of this software and documentation and use in source and
8  * binary forms, with or without modification, are permitted provided that
9  * the following conditions are met:
10  *
11  * 1. Redistributions of source code or documentation must retain the above
12  *    copyright 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 THE 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 THE 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  * Helper functions for snmp client tools
30  */
31 
32 #include <sys/param.h>
33 #include <sys/queue.h>
34 #include <sys/uio.h>
35 
36 #include <assert.h>
37 #include <ctype.h>
38 #include <err.h>
39 #include <errno.h>
40 #include <fcntl.h>
41 #include <stdio.h>
42 #include <stdlib.h>
43 #include <string.h>
44 #include <syslog.h>
45 #include <unistd.h>
46 
47 #include <bsnmp/asn1.h>
48 #include <bsnmp/snmp.h>
49 #include <bsnmp/snmpclient.h>
50 #include "bsnmptc.h"
51 #include "bsnmptools.h"
52 
53 /* Internal variable to turn on library debugging for testing and to
54  * find bugs. It is not exported via the header file.
55  * XXX should we cover it by some #ifdef BSNMPTOOLS_DEBUG? */
56 int _bsnmptools_debug = 0;
57 
58 /* Default files to import mapping from if none explicitly provided. */
59 #define	bsnmpd_defs		"/usr/share/snmp/defs/tree.def"
60 #define	mibII_defs		"/usr/share/snmp/defs/mibII_tree.def"
61 
62 /*
63  * The .iso.org.dod oid that has to be prepended to every OID when requesting
64  * a value.
65  */
66 const struct asn_oid IsoOrgDod_OID = {
67 	3, { 1, 3, 6 }
68 };
69 
70 
71 #define	SNMP_ERR_UNKNOWN	0
72 
73 /*
74  * An array of error strings corresponding to error definitions from libbsnmp.
75  */
76 static const struct {
77 	const char *str;
78 	int32_t error;
79 } error_strings[] = {
80 	{ "Unknown", SNMP_ERR_UNKNOWN },
81 	{ "Too big ", SNMP_ERR_TOOBIG },
82 	{ "No such Name", SNMP_ERR_NOSUCHNAME },
83 	{ "Bad Value", SNMP_ERR_BADVALUE },
84 	{ "Readonly", SNMP_ERR_READONLY },
85 	{ "General error", SNMP_ERR_GENERR },
86 	{ "No access", SNMP_ERR_NO_ACCESS },
87 	{ "Wrong type", SNMP_ERR_WRONG_TYPE },
88 	{ "Wrong length", SNMP_ERR_WRONG_LENGTH },
89 	{ "Wrong encoding", SNMP_ERR_WRONG_ENCODING },
90 	{ "Wrong value", SNMP_ERR_WRONG_VALUE },
91 	{ "No creation", SNMP_ERR_NO_CREATION },
92 	{ "Inconsistent value", SNMP_ERR_INCONS_VALUE },
93 	{ "Resource unavailable", SNMP_ERR_RES_UNAVAIL },
94 	{ "Commit failed", SNMP_ERR_COMMIT_FAILED },
95 	{ "Undo failed", SNMP_ERR_UNDO_FAILED },
96 	{ "Authorization error", SNMP_ERR_AUTH_ERR },
97 	{ "Not writable", SNMP_ERR_NOT_WRITEABLE },
98 	{ "Inconsistent name", SNMP_ERR_INCONS_NAME },
99 	{ NULL, 0 }
100 };
101 
102 /* This one and any following are exceptions. */
103 #define	SNMP_SYNTAX_UNKNOWN	SNMP_SYNTAX_NOSUCHOBJECT
104 
105 static const struct {
106 	const char *str;
107 	enum snmp_syntax stx;
108 } syntax_strings[] = {
109 	{ "Null", SNMP_SYNTAX_NULL },
110 	{ "Integer", SNMP_SYNTAX_INTEGER },
111 	{ "OctetString", SNMP_SYNTAX_OCTETSTRING },
112 	{ "OID", SNMP_SYNTAX_OID },
113 	{ "IpAddress", SNMP_SYNTAX_IPADDRESS },
114 	{ "Counter32", SNMP_SYNTAX_COUNTER },
115 	{ "Gauge", SNMP_SYNTAX_GAUGE },
116 	{ "TimeTicks", SNMP_SYNTAX_TIMETICKS },
117 	{ "Counter64", SNMP_SYNTAX_COUNTER64 },
118 	{ "Unknown", SNMP_SYNTAX_UNKNOWN },
119 };
120 
121 int
snmptool_init(struct snmp_toolinfo * snmptoolctx)122 snmptool_init(struct snmp_toolinfo *snmptoolctx)
123 {
124 	char *str;
125 	size_t slen;
126 
127 	memset(snmptoolctx, 0, sizeof(struct snmp_toolinfo));
128 	snmptoolctx->objects = 0;
129 	snmptoolctx->mappings = NULL;
130 	snmptoolctx->flags = SNMP_PDU_GET;	/* XXX */
131 	SLIST_INIT(&snmptoolctx->filelist);
132 	snmp_client_init(&snmp_client);
133 	SET_MAXREP(snmptoolctx, SNMP_MAX_REPETITIONS);
134 
135 	if (add_filename(snmptoolctx, bsnmpd_defs, &IsoOrgDod_OID, 0) < 0)
136 		warnx("Error adding file %s to list", bsnmpd_defs);
137 
138 	if (add_filename(snmptoolctx, mibII_defs, &IsoOrgDod_OID, 0) < 0)
139 		warnx("Error adding file %s to list", mibII_defs);
140 
141 	/* Read the environment */
142 	if ((str = getenv("SNMPAUTH")) != NULL) {
143 		slen = strlen(str);
144 		if (slen == strlen("md5") && strcasecmp(str, "md5") == 0)
145 			snmp_client.user.auth_proto = SNMP_AUTH_HMAC_MD5;
146 		else if (slen == strlen("sha")&& strcasecmp(str, "sha") == 0)
147 			snmp_client.user.auth_proto = SNMP_AUTH_HMAC_SHA;
148 		else if (slen != 0)
149 			warnx("Bad authentication type - %s in SNMPAUTH", str);
150 	}
151 
152 	if ((str = getenv("SNMPPRIV")) != NULL) {
153 		slen = strlen(str);
154 		if (slen == strlen("des") && strcasecmp(str, "des") == 0)
155 			snmp_client.user.priv_proto = SNMP_PRIV_DES;
156 		else if (slen == strlen("aes")&& strcasecmp(str, "aes") == 0)
157 			snmp_client.user.priv_proto = SNMP_PRIV_AES;
158 		else if (slen != 0)
159 			warnx("Bad privacy type - %s in SNMPPRIV", str);
160 	}
161 
162 	if ((str = getenv("SNMPUSER")) != NULL) {
163 		if ((slen = strlen(str)) > sizeof(snmp_client.user.sec_name)) {
164 			warnx("Username too long - %s in SNMPUSER", str);
165 			return (-1);
166 		}
167 		if (slen > 0) {
168 			strlcpy(snmp_client.user.sec_name, str,
169 			    sizeof(snmp_client.user.sec_name));
170 			snmp_client.version = SNMP_V3;
171 		}
172 	}
173 
174 	if ((str = getenv("SNMPPASSWD")) != NULL) {
175 		if ((slen = strlen(str)) > MAXSTR)
176 			slen = MAXSTR - 1;
177 		if ((snmptoolctx->passwd = malloc(slen + 1)) == NULL) {
178 			warn("malloc() failed");
179 			return (-1);
180 		}
181 		strlcpy(snmptoolctx->passwd, str, slen + 1);
182 	}
183 
184 	return (0);
185 }
186 
187 #define	OBJECT_IDX_LIST(o)	o->info->table_idx->index_list
188 
189 /*
190  * Walk through the file list and import string<->oid mappings from each file.
191  */
192 int32_t
snmp_import_all(struct snmp_toolinfo * snmptoolctx)193 snmp_import_all(struct snmp_toolinfo *snmptoolctx)
194 {
195 	int32_t fc;
196 	struct fname *tmp;
197 
198 	if (snmptoolctx == NULL)
199 		return (-1);
200 
201 	if (ISSET_NUMERIC(snmptoolctx))
202 		return (0);
203 
204 	if ((snmptoolctx->mappings = snmp_mapping_init()) == NULL)
205 		return (-1);
206 
207 	fc = 0;
208 	if (SLIST_EMPTY(&snmptoolctx->filelist)) {
209 		warnx("No files to read OID <-> string conversions from");
210 		return (-1);
211 	} else {
212 		SLIST_FOREACH(tmp, &snmptoolctx->filelist, link) {
213 			if (tmp->done)
214 				continue;
215 			if (snmp_import_file(snmptoolctx, tmp) < 0) {
216 				fc = -1;
217 				break;
218 			}
219 			fc++;
220 		}
221 	}
222 
223 	snmp_mapping_dump(snmptoolctx);
224 	return (fc);
225 }
226 
227 /*
228  * Add a filename to the file list - the initial idea of keeping a list with all
229  * files to read OIDs from was that an application might want to have loaded in
230  * memory the OIDs from a single file only and when done with them read the OIDs
231  * from another file. This is not used yet but might be a good idea at some
232  * point. Size argument is number of bytes in string including trailing '\0',
233  * not string length.
234  */
235 int32_t
add_filename(struct snmp_toolinfo * snmptoolctx,const char * filename,const struct asn_oid * cut,int32_t done)236 add_filename(struct snmp_toolinfo *snmptoolctx, const char *filename,
237     const struct asn_oid *cut, int32_t done)
238 {
239 	char *fstring;
240 	struct fname *entry;
241 
242 	if (snmptoolctx == NULL)
243 		return (-1);
244 
245 	/* Make sure file was not in list. */
246 	SLIST_FOREACH(entry, &snmptoolctx->filelist, link) {
247 		if (strncmp(entry->name, filename, strlen(entry->name)) == 0)
248 			return (0);
249 	}
250 
251 	if ((fstring = strdup(filename)) == NULL) {
252 		warn("strdup() failed");
253 		return (-1);
254 	}
255 
256 	if ((entry = calloc(1, sizeof(struct fname))) == NULL) {
257 		warn("calloc() failed");
258 		free(fstring);
259 		return (-1);
260 	}
261 
262 	if (cut != NULL)
263 		asn_append_oid(&(entry->cut), cut);
264 	entry->name = fstring;
265 	entry->done = done;
266 	SLIST_INSERT_HEAD(&snmptoolctx->filelist, entry, link);
267 
268 	return (1);
269 }
270 
271 void
free_filelist(struct snmp_toolinfo * snmptoolctx)272 free_filelist(struct snmp_toolinfo *snmptoolctx)
273 {
274 	struct fname *f;
275 
276 	if (snmptoolctx == NULL)
277 		return; /* XXX error handling */
278 
279 	while ((f = SLIST_FIRST(&snmptoolctx->filelist)) != NULL) {
280 		SLIST_REMOVE_HEAD(&snmptoolctx->filelist, link);
281 		if (f->name)
282 			free(f->name);
283 		free(f);
284 	}
285 }
286 
287 static char
isvalid_fchar(char c,int pos)288 isvalid_fchar(char c, int pos)
289 {
290 	if (isalpha(c)|| c == '/'|| c == '_' || c == '.' || c == '~' ||
291 	    (pos != 0 && isdigit(c))){
292 		return (c);
293 	}
294 
295 	if (c == '\0')
296 		return (0);
297 
298 	if (!isascii(c) || !isprint(c))
299 		warnx("Unexpected character %#2x", (u_int) c);
300 	else
301 		warnx("Illegal character '%c'", c);
302 
303 	return (-1);
304 }
305 
306 /*
307  * Re-implement getsubopt from scratch, because the second argument is broken
308  * and will not compile with WARNS=5.
309  * Copied from src/contrib/bsnmp/snmpd/main.c.
310  */
311 static int
getsubopt1(char ** arg,const char * const * options,char ** valp,char ** optp)312 getsubopt1(char **arg, const char *const *options, char **valp, char **optp)
313 {
314 	static const char *const delim = ",\t ";
315 	u_int i;
316 	char *ptr;
317 
318 	*optp = NULL;
319 
320 	/* Skip leading junk. */
321 	for (ptr = *arg; *ptr != '\0'; ptr++)
322 		if (strchr(delim, *ptr) == NULL)
323 			break;
324 	if (*ptr == '\0') {
325 		*arg = ptr;
326 		return (-1);
327 	}
328 	*optp = ptr;
329 
330 	/* Find the end of the option. */
331 	while (*++ptr != '\0')
332 		if (strchr(delim, *ptr) != NULL || *ptr == '=')
333 			break;
334 
335 	if (*ptr != '\0') {
336 		if (*ptr == '=') {
337 			*ptr++ = '\0';
338 			*valp = ptr;
339 			while (*ptr != '\0' && strchr(delim, *ptr) == NULL)
340 				ptr++;
341 			if (*ptr != '\0')
342 				*ptr++ = '\0';
343 		} else
344 			*ptr++ = '\0';
345 	}
346 
347 	*arg = ptr;
348 
349 	for (i = 0; *options != NULL; options++, i++)
350 		if (strcmp(*optp, *options) == 0)
351 			return (i);
352 	return (-1);
353 }
354 
355 static int32_t
parse_path(char * value)356 parse_path(char *value)
357 {
358 	int32_t i, len;
359 
360 	if (value == NULL)
361 		return (-1);
362 
363 	for (len = 0; len < MAXPATHLEN; len++) {
364 		i = isvalid_fchar(*(value + len), len) ;
365 
366 		if (i == 0)
367 			break;
368 		else if (i < 0)
369 			return (-1);
370 	}
371 
372 	if (len >= MAXPATHLEN || value[len] != '\0') {
373 		warnx("Bad pathname - '%s'", value);
374 		return (-1);
375 	}
376 
377 	return (len);
378 }
379 
380 static int32_t
parse_flist(struct snmp_toolinfo * snmptoolctx,char * value,char * path,const struct asn_oid * cut)381 parse_flist(struct snmp_toolinfo *snmptoolctx, char *value, char *path,
382     const struct asn_oid *cut)
383 {
384 	int32_t namelen;
385 	char filename[MAXPATHLEN + 1];
386 
387 	if (value == NULL)
388 		return (-1);
389 
390 	do {
391 		memset(filename, 0, MAXPATHLEN + 1);
392 
393 		if (isalpha(*value) && (path == NULL || path[0] == '\0')) {
394 			strlcpy(filename, SNMP_DEFS_DIR, MAXPATHLEN + 1);
395 			namelen = strlen(SNMP_DEFS_DIR);
396 		} else if (path != NULL){
397 			strlcpy(filename, path, MAXPATHLEN + 1);
398 			namelen = strlen(path);
399 		} else
400 			namelen = 0;
401 
402 		for ( ; namelen < MAXPATHLEN; value++) {
403 			if (isvalid_fchar(*value, namelen) > 0) {
404 				filename[namelen++] = *value;
405 				continue;
406 			}
407 
408 			if (*value == ',' )
409 				value++;
410 			else if (*value == '\0')
411 				;
412 			else {
413 				if (!isascii(*value) || !isprint(*value))
414 					warnx("Unexpected character %#2x in"
415 					    " filename", (u_int) *value);
416 				else
417 					warnx("Illegal character '%c' in"
418 					    " filename", *value);
419 				return (-1);
420 			}
421 
422 			filename[namelen]='\0';
423 			break;
424 		}
425 
426 		if ((namelen == MAXPATHLEN) && (filename[MAXPATHLEN] != '\0')) {
427 			warnx("Filename %s too long", filename);
428 			return (-1);
429 		}
430 
431 		if (add_filename(snmptoolctx, filename, cut, 0) < 0) {
432 			warnx("Error adding file %s to list", filename);
433 			return (-1);
434 		}
435 	} while (*value != '\0');
436 
437 	return(1);
438 }
439 
440 static int32_t
parse_ascii(char * ascii,uint8_t * binstr,size_t binlen)441 parse_ascii(char *ascii, uint8_t *binstr, size_t binlen)
442 {
443 	char dptr[3];
444 	size_t count;
445 	int32_t alen, i, saved_errno;
446 	uint32_t val;
447 
448 	/* Filter 0x at the beginning */
449 	if ((alen = strlen(ascii)) > 2 && ascii[0] == '0' && ascii[1] == 'x')
450 		i = 2;
451 	else
452 		i = 0;
453 
454 	saved_errno = errno;
455 	errno = 0;
456 	for (count = 0; i < alen; i += 2) {
457 		/* XXX: consider strlen(ascii) % 2 != 0 */
458 		dptr[0] = ascii[i];
459 		dptr[1] = ascii[i + 1];
460 		dptr[2] = '\0';
461 		if ((val = strtoul(dptr, NULL, 16)) > 0xFF || errno != 0) {
462 			errno = saved_errno;
463 			return (-1);
464 		}
465 		binstr[count] = (uint8_t) val;
466 		if (++count >= binlen) {
467 			warnx("Key %s too long - truncating to %zu octets",
468 			    ascii, binlen);
469 			break;
470 		}
471 	}
472 
473 	return (count);
474 }
475 
476 /*
477  * Functions to parse common input options for client tools and fill in the
478  * snmp_client structure.
479  */
480 int32_t
parse_authentication(struct snmp_toolinfo * snmptoolctx __unused,char * opt_arg)481 parse_authentication(struct snmp_toolinfo *snmptoolctx __unused, char *opt_arg)
482 {
483 	int32_t /* count, */ subopt;
484 	char *val, *option;
485 	const char *const subopts[] = {
486 		"proto",
487 		"key",
488 		NULL
489 	};
490 
491 	assert(opt_arg != NULL);
492 	/* count = 1; */
493 	while ((subopt = getsubopt1(&opt_arg, subopts, &val, &option)) != EOF) {
494 		switch (subopt) {
495 		case 0:
496 			if (val == NULL) {
497 				warnx("Suboption 'proto' requires an argument");
498 				return (-1);
499 			}
500 			if (strlen(val) != 3) {
501 				warnx("Unknown auth protocol - %s", val);
502 				return (-1);
503 			}
504 			if (strncasecmp("md5", val, strlen("md5")) == 0)
505 				snmp_client.user.auth_proto =
506 				    SNMP_AUTH_HMAC_MD5;
507 			else if (strncasecmp("sha", val, strlen("sha")) == 0)
508 				snmp_client.user.auth_proto =
509 				    SNMP_AUTH_HMAC_SHA;
510 			else {
511 				warnx("Unknown auth protocol - %s", val);
512 				return (-1);
513 			}
514 			break;
515 		case 1:
516 			if (val == NULL) {
517 				warnx("Suboption 'key' requires an argument");
518 				return (-1);
519 			}
520 			if (parse_ascii(val, snmp_client.user.auth_key,
521 			    SNMP_AUTH_KEY_SIZ) < 0) {
522 				warnx("Bad authentication key- %s", val);
523 				return (-1);
524 			}
525 			break;
526 		default:
527 			warnx("Unknown suboption - '%s'", suboptarg);
528 			return (-1);
529 		}
530 		/* count += 1; */
531 	}
532 	return (2/* count */);
533 }
534 
535 int32_t
parse_privacy(struct snmp_toolinfo * snmptoolctx __unused,char * opt_arg)536 parse_privacy(struct snmp_toolinfo *snmptoolctx __unused, char *opt_arg)
537 {
538 	int32_t /* count, */ subopt;
539 	char *val, *option;
540 	const char *const subopts[] = {
541 		"proto",
542 		"key",
543 		NULL
544 	};
545 
546 	assert(opt_arg != NULL);
547 	/* count = 1; */
548 	while ((subopt = getsubopt1(&opt_arg, subopts, &val, &option)) != EOF) {
549 		switch (subopt) {
550 		case 0:
551 			if (val == NULL) {
552 				warnx("Suboption 'proto' requires an argument");
553 				return (-1);
554 			}
555 			if (strlen(val) != 3) {
556 				warnx("Unknown privacy protocol - %s", val);
557 				return (-1);
558 			}
559 			if (strncasecmp("aes", val, strlen("aes")) == 0)
560 				snmp_client.user.priv_proto = SNMP_PRIV_AES;
561 			else if (strncasecmp("des", val, strlen("des")) == 0)
562 				snmp_client.user.priv_proto = SNMP_PRIV_DES;
563 			else {
564 				warnx("Unknown privacy protocol - %s", val);
565 				return (-1);
566 			}
567 			break;
568 		case 1:
569 			if (val == NULL) {
570 				warnx("Suboption 'key' requires an argument");
571 				return (-1);
572 			}
573 			if (parse_ascii(val, snmp_client.user.priv_key,
574 			    SNMP_PRIV_KEY_SIZ) < 0) {
575 				warnx("Bad privacy key- %s", val);
576 				return (-1);
577 			}
578 			break;
579 		default:
580 			warnx("Unknown suboption - '%s'", suboptarg);
581 			return (-1);
582 		}
583 		/* count += 1; */
584 	}
585 	return (2/* count */);
586 }
587 
588 int32_t
parse_context(struct snmp_toolinfo * snmptoolctx __unused,char * opt_arg)589 parse_context(struct snmp_toolinfo *snmptoolctx __unused, char *opt_arg)
590 {
591 	int32_t /* count, */ subopt;
592 	char *val, *option;
593 	const char *const subopts[] = {
594 		"context",
595 		"context-engine",
596 		NULL
597 	};
598 
599 	assert(opt_arg != NULL);
600 	/* count = 1; */
601 	while ((subopt = getsubopt1(&opt_arg, subopts, &val, &option)) != EOF) {
602 		switch (subopt) {
603 		case 0:
604 			if (val == NULL) {
605 				warnx("Suboption 'context' - no argument");
606 				return (-1);
607 			}
608 			strlcpy(snmp_client.cname, val, SNMP_CONTEXT_NAME_SIZ);
609 			break;
610 		case 1:
611 			if (val == NULL) {
612 				warnx("Suboption 'context-engine' - no argument");
613 				return (-1);
614 			}
615 			if ((int32_t)(snmp_client.clen = parse_ascii(val,
616 			    snmp_client.cengine, SNMP_ENGINE_ID_SIZ)) == -1) {
617 				warnx("Bad EngineID - %s", val);
618 				return (-1);
619 			}
620 			break;
621 		default:
622 			warnx("Unknown suboption - '%s'", suboptarg);
623 			return (-1);
624 		}
625 		/* count += 1; */
626 	}
627 	return (2/* count */);
628 }
629 
630 int32_t
parse_user_security(struct snmp_toolinfo * snmptoolctx __unused,char * opt_arg)631 parse_user_security(struct snmp_toolinfo *snmptoolctx __unused, char *opt_arg)
632 {
633 	int32_t /* count, */ subopt, saved_errno;
634 	char *val, *option;
635 	const char *const subopts[] = {
636 		"engine",
637 		"engine-boots",
638 		"engine-time",
639 		"name",
640 		NULL
641 	};
642 
643 	assert(opt_arg != NULL);
644 	/* count = 1; */
645 	while ((subopt = getsubopt1(&opt_arg, subopts, &val, &option)) != EOF) {
646 		switch (subopt) {
647 		case 0:
648 			if (val == NULL) {
649 				warnx("Suboption 'engine' - no argument");
650 				return (-1);
651 			}
652 			snmp_client.engine.engine_len = parse_ascii(val,
653 			    snmp_client.engine.engine_id, SNMP_ENGINE_ID_SIZ);
654 			if ((int32_t)snmp_client.engine.engine_len == -1) {
655 				warnx("Bad EngineID - %s", val);
656 				return (-1);
657 			}
658 			break;
659 		case 1:
660 			if (val == NULL) {
661 				warnx("Suboption 'engine-boots' - no argument");
662 				return (-1);
663 			}
664 			saved_errno = errno;
665 			errno = 0;
666 			snmp_client.engine.engine_boots = strtoul(val, NULL, 10);
667 			if (errno != 0) {
668 				warn("Bad 'engine-boots' value %s", val);
669 				errno = saved_errno;
670 				return (-1);
671 			}
672 			errno = saved_errno;
673 			break;
674 		case 2:
675 			if (val == NULL) {
676 				warnx("Suboption 'engine-time' - no argument");
677 				return (-1);
678 			}
679 			saved_errno = errno;
680 			errno = 0;
681 			snmp_client.engine.engine_time = strtoul(val, NULL, 10);
682 			if (errno != 0) {
683 				warn("Bad 'engine-time' value %s", val);
684 				errno = saved_errno;
685 				return (-1);
686 			}
687 			errno = saved_errno;
688 			break;
689 		case 3:
690 			strlcpy(snmp_client.user.sec_name, val,
691 			    SNMP_ADM_STR32_SIZ);
692 			break;
693 		default:
694 			warnx("Unknown suboption - '%s'", suboptarg);
695 			return (-1);
696 		}
697 		/* count += 1; */
698 	}
699 	return (2/* count */);
700 }
701 
702 int32_t
parse_file(struct snmp_toolinfo * snmptoolctx,char * opt_arg)703 parse_file(struct snmp_toolinfo *snmptoolctx, char *opt_arg)
704 {
705 	assert(opt_arg != NULL);
706 
707 	if (parse_flist(snmptoolctx, opt_arg, NULL, &IsoOrgDod_OID) < 0)
708 		return (-1);
709 
710 	return (2);
711 }
712 
713 int32_t
parse_include(struct snmp_toolinfo * snmptoolctx,char * opt_arg)714 parse_include(struct snmp_toolinfo *snmptoolctx, char *opt_arg)
715 {
716 	char path[MAXPATHLEN + 1];
717 	int32_t cut_dflt, len, subopt;
718 	struct asn_oid cut;
719 	char *val, *option;
720 	const char *const subopts[] = {
721 		"cut",
722 		"path",
723 		"file",
724 		NULL
725 	};
726 
727 #define	INC_CUT		0
728 #define	INC_PATH	1
729 #define	INC_LIST	2
730 
731 	assert(opt_arg != NULL);
732 
733 	/* if (opt == 'i')
734 		free_filelist(snmptoolctx, ); */
735 	/*
736 	 * This function should be called only after getopt(3) - otherwise if
737 	 * no previous validation of opt_arg strlen() may not return what is
738 	 * expected.
739 	 */
740 
741 	path[0] = '\0';
742 	memset(&cut, 0, sizeof(struct asn_oid));
743 	cut_dflt = -1;
744 
745 	while ((subopt = getsubopt1(&opt_arg, subopts, &val, &option)) != EOF) {
746 		switch (subopt) {
747 		    case INC_CUT:
748 			if (val == NULL) {
749 				warnx("Suboption 'cut' requires an argument");
750 				return (-1);
751 			} else {
752 				if (snmp_parse_numoid(val, &cut) < 0)
753 					return (-1);
754 			}
755 			cut_dflt = 1;
756 			break;
757 
758 		    case INC_PATH:
759 			if ((len = parse_path(val)) < 0)
760 				return (-1);
761 			strlcpy(path, val, len + 1);
762 			break;
763 
764 		    case INC_LIST:
765 			if (val == NULL)
766 				return (-1);
767 			if (cut_dflt == -1)
768 				len = parse_flist(snmptoolctx, val, path, &IsoOrgDod_OID);
769 			else
770 				len = parse_flist(snmptoolctx, val, path, &cut);
771 			if (len < 0)
772 				return (-1);
773 			break;
774 
775 		    default:
776 			warnx("Unknown suboption - '%s'", suboptarg);
777 			return (-1);
778 		}
779 	}
780 
781 	/* XXX: Fix me - returning two is wrong here */
782 	return (2);
783 }
784 
785 int32_t
parse_server(char * opt_arg)786 parse_server(char *opt_arg)
787 {
788 	assert(opt_arg != NULL);
789 
790 	if (snmp_parse_server(&snmp_client, opt_arg) < 0)
791 		return (-1);
792 
793 	return (2);
794 }
795 
796 int32_t
parse_timeout(char * opt_arg)797 parse_timeout(char *opt_arg)
798 {
799 	int32_t v, saved_errno;
800 
801 	assert(opt_arg != NULL);
802 
803 	saved_errno = errno;
804 	errno = 0;
805 
806 	v = strtol(opt_arg, NULL, 10);
807 	if (errno != 0) {
808 		warn("Error parsing timeout value");
809 		errno = saved_errno;
810 		return (-1);
811 	}
812 
813 	snmp_client.timeout.tv_sec = v;
814 	errno = saved_errno;
815 	return (2);
816 }
817 
818 int32_t
parse_retry(char * opt_arg)819 parse_retry(char *opt_arg)
820 {
821 	uint32_t v;
822 	int32_t saved_errno;
823 
824 	assert(opt_arg != NULL);
825 
826 	saved_errno = errno;
827 	errno = 0;
828 
829 	v = strtoul(opt_arg, NULL, 10);
830 	if (errno != 0) {
831 		warn("Error parsing retries count");
832 		errno = saved_errno;
833 		return (-1);
834 	}
835 
836 	snmp_client.retries = v;
837 	errno = saved_errno;
838 	return (2);
839 }
840 
841 int32_t
parse_version(char * opt_arg)842 parse_version(char *opt_arg)
843 {
844 	uint32_t v;
845 	int32_t saved_errno;
846 
847 	assert(opt_arg != NULL);
848 
849 	saved_errno = errno;
850 	errno = 0;
851 
852 	v = strtoul(opt_arg, NULL, 10);
853 	if (errno != 0) {
854 		warn("Error parsing version");
855 		errno = saved_errno;
856 		return (-1);
857 	}
858 
859 	switch (v) {
860 		case 1:
861 			snmp_client.version = SNMP_V1;
862 			break;
863 		case 2:
864 			snmp_client.version = SNMP_V2c;
865 			break;
866 		case 3:
867 			snmp_client.version = SNMP_V3;
868 			break;
869 		default:
870 			warnx("Unsupported SNMP version - %u", v);
871 			errno = saved_errno;
872 			return (-1);
873 	}
874 
875 	errno = saved_errno;
876 	return (2);
877 }
878 
879 int32_t
parse_local_path(char * opt_arg)880 parse_local_path(char *opt_arg)
881 {
882 	assert(opt_arg != NULL);
883 
884 	if (strlcpy(snmp_client.local_path, opt_arg,
885 	    sizeof(snmp_client.local_path)) >= sizeof(snmp_client.local_path)) {
886 		warnx("Filename too long - %s", opt_arg);
887 		return (-1);
888 	}
889 	return (2);
890 }
891 
892 int32_t
parse_buflen(char * opt_arg)893 parse_buflen(char *opt_arg)
894 {
895 	uint32_t size;
896 	int32_t saved_errno;
897 
898 	assert(opt_arg != NULL);
899 
900 	saved_errno = errno;
901 	errno = 0;
902 
903 	size = strtoul(opt_arg, NULL, 10);
904 	if (errno != 0) {
905 		warn("Error parsing buffer size");
906 		errno = saved_errno;
907 		return (-1);
908 	}
909 
910 	if (size > MAX_BUFF_SIZE) {
911 		warnx("Buffer size too big - %d max allowed", MAX_BUFF_SIZE);
912 		errno = saved_errno;
913 		return (-1);
914 	}
915 
916 	snmp_client.txbuflen = snmp_client.rxbuflen = size;
917 	errno = saved_errno;
918 	return (2);
919 }
920 
921 int32_t
parse_debug(void)922 parse_debug(void)
923 {
924 	snmp_client.dump_pdus = 1;
925 	return (1);
926 }
927 
928 int32_t
parse_discovery(struct snmp_toolinfo * snmptoolctx)929 parse_discovery(struct snmp_toolinfo *snmptoolctx)
930 {
931 	SET_EDISCOVER(snmptoolctx);
932 	snmp_client.version = SNMP_V3;
933 	return (1);
934 }
935 
936 int32_t
parse_local_key(struct snmp_toolinfo * snmptoolctx)937 parse_local_key(struct snmp_toolinfo *snmptoolctx)
938 {
939 	SET_LOCALKEY(snmptoolctx);
940 	snmp_client.version = SNMP_V3;
941 	return (1);
942 }
943 
944 int32_t
parse_num_oids(struct snmp_toolinfo * snmptoolctx)945 parse_num_oids(struct snmp_toolinfo *snmptoolctx)
946 {
947 	SET_NUMERIC(snmptoolctx);
948 	return (1);
949 }
950 
951 int32_t
parse_output(struct snmp_toolinfo * snmptoolctx,char * opt_arg)952 parse_output(struct snmp_toolinfo *snmptoolctx, char *opt_arg)
953 {
954 	assert(opt_arg != NULL);
955 
956 	if (strlen(opt_arg) > strlen("verbose")) {
957 		warnx( "Invalid output option - %s",opt_arg);
958 		return (-1);
959 	}
960 
961 	if (strncasecmp(opt_arg, "short", strlen(opt_arg)) == 0)
962 		SET_OUTPUT(snmptoolctx, OUTPUT_SHORT);
963 	else if (strncasecmp(opt_arg, "verbose", strlen(opt_arg)) == 0)
964 		SET_OUTPUT(snmptoolctx, OUTPUT_VERBOSE);
965 	else if (strncasecmp(opt_arg,"tabular", strlen(opt_arg)) == 0)
966 		SET_OUTPUT(snmptoolctx, OUTPUT_TABULAR);
967 	else if (strncasecmp(opt_arg, "quiet", strlen(opt_arg)) == 0)
968 		SET_OUTPUT(snmptoolctx, OUTPUT_QUIET);
969 	else {
970 		warnx( "Invalid output option - %s", opt_arg);
971 		return (-1);
972 	}
973 
974 	return (2);
975 }
976 
977 int32_t
parse_errors(struct snmp_toolinfo * snmptoolctx)978 parse_errors(struct snmp_toolinfo *snmptoolctx)
979 {
980 	SET_RETRY(snmptoolctx);
981 	return (1);
982 }
983 
984 int32_t
parse_skip_access(struct snmp_toolinfo * snmptoolctx)985 parse_skip_access(struct snmp_toolinfo *snmptoolctx)
986 {
987 	SET_ERRIGNORE(snmptoolctx);
988 	return (1);
989 }
990 
991 char *
snmp_parse_suboid(char * str,struct asn_oid * oid)992 snmp_parse_suboid(char *str, struct asn_oid *oid)
993 {
994 	char *endptr;
995 	asn_subid_t suboid;
996 
997 	if (*str == '.')
998 		str++;
999 
1000 	if (*str < '0' || *str > '9')
1001 		return (str);
1002 
1003 	do {
1004 		suboid = strtoul(str, &endptr, 10);
1005 		if ((asn_subid_t) suboid > ASN_MAXID) {
1006 			warnx("Suboid %u > ASN_MAXID", suboid);
1007 			return (NULL);
1008 		}
1009 		if (snmp_suboid_append(oid, suboid) < 0)
1010 			return (NULL);
1011 		str = endptr + 1;
1012 	} while (*endptr == '.');
1013 
1014 	return (endptr);
1015 }
1016 
1017 static char *
snmp_int2asn_oid(char * str,struct asn_oid * oid)1018 snmp_int2asn_oid(char *str, struct asn_oid *oid)
1019 {
1020 	char *endptr;
1021 	int32_t v, saved_errno;
1022 
1023 	saved_errno = errno;
1024 	errno = 0;
1025 
1026 	v = strtol(str, &endptr, 10);
1027 	if (errno != 0) {
1028 		warn("Integer value %s not supported", str);
1029 		errno = saved_errno;
1030 		return (NULL);
1031 	}
1032 	errno = saved_errno;
1033 
1034 	if (snmp_suboid_append(oid, (asn_subid_t) v) < 0)
1035 		return (NULL);
1036 
1037 	return (endptr);
1038 }
1039 
1040 /* It is a bit weird to have a table indexed by OID but still... */
1041 static char *
snmp_oid2asn_oid(struct snmp_toolinfo * snmptoolctx,char * str,struct asn_oid * oid)1042 snmp_oid2asn_oid(struct snmp_toolinfo *snmptoolctx, char *str,
1043     struct asn_oid *oid)
1044 {
1045 	int32_t i;
1046 	char string[MAXSTR + 1], *endptr;
1047 	struct snmp_object obj;
1048 
1049 	for (i = 0; i < MAXSTR; i++)
1050 		if (isalpha (*(str + i)) == 0)
1051 			break;
1052 
1053 	endptr = str + i;
1054 	memset(&obj, 0, sizeof(struct snmp_object));
1055 	if (i == 0) {
1056 		if ((endptr = snmp_parse_suboid(str, &(obj.val.var))) == NULL)
1057 			return (NULL);
1058 		if (snmp_suboid_append(oid, (asn_subid_t) obj.val.var.len) < 0)
1059 			return (NULL);
1060 	} else {
1061 		strlcpy(string, str, i + 1);
1062 		if (snmp_lookup_enumoid(snmptoolctx, &obj, string) < 0) {
1063 			warnx("Unknown string - %s", string);
1064 			return (NULL);
1065 		}
1066 	}
1067 
1068 	asn_append_oid(oid, &(obj.val.var));
1069 	return (endptr);
1070 }
1071 
1072 static char *
snmp_ip2asn_oid(char * str,struct asn_oid * oid)1073 snmp_ip2asn_oid(char *str, struct asn_oid *oid)
1074 {
1075 	uint32_t v;
1076 	int32_t i;
1077 	char *endptr, *ptr;
1078 
1079 	ptr = str;
1080 
1081 	for (i = 0; i < 4; i++) {
1082 		v = strtoul(ptr, &endptr, 10);
1083 		if (v > 0xff)
1084 			return (NULL);
1085 		if (*endptr != '.' && strchr("],\0", *endptr) == NULL && i != 3)
1086 			return (NULL);
1087 		if (snmp_suboid_append(oid, (asn_subid_t) v) < 0)
1088 			return (NULL);
1089 		ptr = endptr + 1;
1090 	}
1091 
1092 	return (endptr);
1093 }
1094 
1095 /* 32-bit counter, gauge, timeticks. */
1096 static char *
snmp_uint2asn_oid(char * str,struct asn_oid * oid)1097 snmp_uint2asn_oid(char *str, struct asn_oid *oid)
1098 {
1099 	char *endptr;
1100 	uint32_t v;
1101 	int32_t saved_errno;
1102 
1103 	saved_errno = errno;
1104 	errno = 0;
1105 
1106 	v = strtoul(str, &endptr, 10);
1107 	if (errno != 0) {
1108 		warn("Integer value %s not supported", str);
1109 		errno = saved_errno;
1110 		return (NULL);
1111 	}
1112 	errno = saved_errno;
1113 	if (snmp_suboid_append(oid, (asn_subid_t) v) < 0)
1114 		return (NULL);
1115 
1116 	return (endptr);
1117 }
1118 
1119 static char *
snmp_cnt64_2asn_oid(char * str,struct asn_oid * oid)1120 snmp_cnt64_2asn_oid(char *str, struct asn_oid *oid)
1121 {
1122 	char *endptr;
1123 	uint64_t v;
1124 	int32_t saved_errno;
1125 
1126 	saved_errno = errno;
1127 	errno = 0;
1128 
1129 	v = strtoull(str, &endptr, 10);
1130 
1131 	if (errno != 0) {
1132 		warn("Integer value %s not supported", str);
1133 		errno = saved_errno;
1134 		return (NULL);
1135 	}
1136 	errno = saved_errno;
1137 	if (snmp_suboid_append(oid, (asn_subid_t) (v & 0xffffffff)) < 0)
1138 		return (NULL);
1139 
1140 	if (snmp_suboid_append(oid, (asn_subid_t) (v >> 32)) < 0)
1141 		return (NULL);
1142 
1143 	return (endptr);
1144 }
1145 
1146 enum snmp_syntax
parse_syntax(char * str)1147 parse_syntax(char *str)
1148 {
1149 	int32_t i;
1150 
1151 	for (i = 0; i < SNMP_SYNTAX_UNKNOWN; i++) {
1152 		if (strncmp(syntax_strings[i].str, str,
1153 		    strlen(syntax_strings[i].str)) == 0)
1154 			return (syntax_strings[i].stx);
1155 	}
1156 
1157 	return (SNMP_SYNTAX_NULL);
1158 }
1159 
1160 static char *
snmp_parse_subindex(struct snmp_toolinfo * snmptoolctx,char * str,struct index * idx,struct snmp_object * object)1161 snmp_parse_subindex(struct snmp_toolinfo *snmptoolctx, char *str,
1162     struct index *idx, struct snmp_object *object)
1163 {
1164 	char *ptr;
1165 	int32_t i;
1166 	enum snmp_syntax stx;
1167 	char syntax[MAX_CMD_SYNTAX_LEN];
1168 
1169 	ptr = str;
1170 	if (GET_OUTPUT(snmptoolctx) == OUTPUT_VERBOSE) {
1171 		for (i = 0; i < MAX_CMD_SYNTAX_LEN ; i++) {
1172 			if (*(ptr + i) == ':')
1173 				break;
1174 		}
1175 
1176 		if (i >= MAX_CMD_SYNTAX_LEN) {
1177 			warnx("Unknown syntax in OID - %s", str);
1178 			return (NULL);
1179 		}
1180 		/* Expect a syntax string here. */
1181 		if ((stx = parse_syntax(str)) <= SNMP_SYNTAX_NULL) {
1182 			warnx("Invalid  syntax - %s",syntax);
1183 			return (NULL);
1184 		}
1185 
1186 		if (stx != idx->syntax && !ISSET_ERRIGNORE(snmptoolctx)) {
1187 			warnx("Syntax mismatch - %d expected, %d given",
1188 			    idx->syntax, stx);
1189 			return (NULL);
1190 		}
1191 		/*
1192 		 * That is where the suboid started + the syntax length + one
1193 		 * character for ':'.
1194 		 */
1195 		ptr = str + i + 1;
1196 	} else
1197 		stx = idx->syntax;
1198 
1199 	switch (stx) {
1200 		case SNMP_SYNTAX_INTEGER:
1201 			return (snmp_int2asn_oid(ptr, &(object->val.var)));
1202 		case SNMP_SYNTAX_OID:
1203 			return (snmp_oid2asn_oid(snmptoolctx, ptr,
1204 			    &(object->val.var)));
1205 		case SNMP_SYNTAX_IPADDRESS:
1206 			return (snmp_ip2asn_oid(ptr, &(object->val.var)));
1207 		case SNMP_SYNTAX_COUNTER:
1208 			/* FALLTHROUGH */
1209 		case SNMP_SYNTAX_GAUGE:
1210 			/* FALLTHROUGH */
1211 		case SNMP_SYNTAX_TIMETICKS:
1212 			return (snmp_uint2asn_oid(ptr, &(object->val.var)));
1213 		case SNMP_SYNTAX_COUNTER64:
1214 			return (snmp_cnt64_2asn_oid(ptr, &(object->val.var)));
1215 		case SNMP_SYNTAX_OCTETSTRING:
1216 			return (snmp_tc2oid(idx->tc, ptr, &(object->val.var)));
1217 		default:
1218 			/* NOTREACHED */
1219 			break;
1220 	}
1221 
1222 	return (NULL);
1223 }
1224 
1225 char *
snmp_parse_index(struct snmp_toolinfo * snmptoolctx,char * str,struct snmp_object * object)1226 snmp_parse_index(struct snmp_toolinfo *snmptoolctx, char *str,
1227     struct snmp_object *object)
1228 {
1229 	char *ptr;
1230 	struct index *temp;
1231 
1232 	if (object->info->table_idx == NULL)
1233 		return (NULL);
1234 
1235 	ptr = NULL;
1236 	STAILQ_FOREACH(temp, &(OBJECT_IDX_LIST(object)), link) {
1237 		if ((ptr = snmp_parse_subindex(snmptoolctx, str, temp, object))
1238 		    == NULL)
1239 			return (NULL);
1240 
1241 		if (*ptr != ',' && *ptr != ']')
1242 			return (NULL);
1243 		str = ptr + 1;
1244 	}
1245 
1246 	if (ptr == NULL || *ptr != ']') {
1247 		warnx("Mismatching index - %s", str);
1248 		return (NULL);
1249 	}
1250 
1251 	return (ptr + 1);
1252 }
1253 
1254 /*
1255  * Fill in the struct asn_oid member of snmp_value with suboids from input.
1256  * If an error occurs - print message on stderr and return (-1).
1257  * If all is ok - return the length of the oid.
1258  */
1259 int32_t
snmp_parse_numoid(char * argv,struct asn_oid * var)1260 snmp_parse_numoid(char *argv, struct asn_oid *var)
1261 {
1262 	char *endptr, *str;
1263 	asn_subid_t suboid;
1264 
1265 	str = argv;
1266 
1267 	if (*str == '.')
1268 		str++;
1269 
1270 	do {
1271 		if (var->len == ASN_MAXOIDLEN) {
1272 			warnx("Oid too long - %u", var->len);
1273 			return (-1);
1274 		}
1275 
1276 		suboid = strtoul(str, &endptr, 10);
1277 		if (suboid > ASN_MAXID) {
1278 			warnx("Oid too long - %u", var->len);
1279 			return (-1);
1280 		}
1281 
1282 		var->subs[var->len++] = suboid;
1283 		str = endptr + 1;
1284 	} while ( *endptr == '.');
1285 
1286 	if (*endptr != '\0') {
1287 		warnx("Invalid oid string - %s", argv);
1288 		return (-1);
1289 	}
1290 
1291 	return (var->len);
1292 }
1293 
1294 /* Append a length 1 suboid to an asn_oid structure. */
1295 int32_t
snmp_suboid_append(struct asn_oid * var,asn_subid_t suboid)1296 snmp_suboid_append(struct asn_oid *var, asn_subid_t suboid)
1297 {
1298 	if (var == NULL)
1299 		return (-1);
1300 
1301 	if (var->len >= ASN_MAXOIDLEN) {
1302 		warnx("Oid too long - %u", var->len);
1303 		return (-1);
1304 	}
1305 
1306 	var->subs[var->len++] = suboid;
1307 
1308 	return (1);
1309 }
1310 
1311 /* Pop the last suboid from an asn_oid structure. */
1312 int32_t
snmp_suboid_pop(struct asn_oid * var)1313 snmp_suboid_pop(struct asn_oid *var)
1314 {
1315 	asn_subid_t suboid;
1316 
1317 	if (var == NULL)
1318 		return (-1);
1319 
1320 	if (var->len < 1)
1321 		return (-1);
1322 
1323 	suboid = var->subs[--(var->len)];
1324 	var->subs[var->len] = 0;
1325 
1326 	return (suboid);
1327 }
1328 
1329 /*
1330  * Parse the command-line provided string into an OID - allocate memory for a new
1331  * snmp object, fill in its fields and insert it in the object list. A
1332  * (snmp_verify_inoid_f) function must be provided to validate the input string.
1333  */
1334 int32_t
snmp_object_add(struct snmp_toolinfo * snmptoolctx,snmp_verify_inoid_f func,char * string)1335 snmp_object_add(struct snmp_toolinfo *snmptoolctx, snmp_verify_inoid_f func,
1336     char *string)
1337 {
1338 	struct snmp_object *obj;
1339 
1340 	if (snmptoolctx == NULL)
1341 		return (-1);
1342 
1343 	/* XXX-BZ does that chack make sense? */
1344 	if (snmptoolctx->objects >= SNMP_MAX_BINDINGS) {
1345 		warnx("Too many bindings in PDU - %u", snmptoolctx->objects + 1);
1346 		return (-1);
1347 	}
1348 
1349 	if ((obj = calloc(1, sizeof(struct snmp_object))) == NULL) {
1350 		syslog(LOG_ERR, "malloc() failed: %s", strerror(errno));
1351 		return (-1);
1352 	}
1353 
1354 	if (func(snmptoolctx, obj, string) < 0) {
1355 		warnx("Invalid OID - %s", string);
1356 		free(obj);
1357 		return (-1);
1358 	}
1359 
1360 	snmptoolctx->objects++;
1361 	SLIST_INSERT_HEAD(&snmptoolctx->snmp_objectlist, obj, link);
1362 
1363 	return (1);
1364 }
1365 
1366 /* Given an OID, find it in the object list and remove it. */
1367 int32_t
snmp_object_remove(struct snmp_toolinfo * snmptoolctx,struct asn_oid * oid)1368 snmp_object_remove(struct snmp_toolinfo *snmptoolctx, struct asn_oid *oid)
1369 {
1370 	struct snmp_object *temp;
1371 
1372 	if (SLIST_EMPTY(&snmptoolctx->snmp_objectlist)) {
1373 		warnx("Object list already empty");
1374 		return (-1);
1375 	}
1376 
1377 
1378 	SLIST_FOREACH(temp, &snmptoolctx->snmp_objectlist, link)
1379 		if (asn_compare_oid(&(temp->val.var), oid) == 0)
1380 			break;
1381 
1382 	if (temp == NULL) {
1383 		warnx("No such object in list");
1384 		return (-1);
1385 	}
1386 
1387 	SLIST_REMOVE(&snmptoolctx->snmp_objectlist, temp, snmp_object, link);
1388 	if (temp->val.syntax == SNMP_SYNTAX_OCTETSTRING &&
1389 	    temp->val.v.octetstring.octets != NULL)
1390 		free(temp->val.v.octetstring.octets);
1391 	free(temp);
1392 
1393 	return (1);
1394 }
1395 
1396 static void
snmp_object_freeall(struct snmp_toolinfo * snmptoolctx)1397 snmp_object_freeall(struct snmp_toolinfo *snmptoolctx)
1398 {
1399 	struct snmp_object *o;
1400 
1401 	while ((o = SLIST_FIRST(&snmptoolctx->snmp_objectlist)) != NULL) {
1402 		SLIST_REMOVE_HEAD(&snmptoolctx->snmp_objectlist, link);
1403 
1404 		if (o->val.syntax == SNMP_SYNTAX_OCTETSTRING &&
1405 		    o->val.v.octetstring.octets != NULL)
1406 			free(o->val.v.octetstring.octets);
1407 		free(o);
1408 	}
1409 }
1410 
1411 /* Do all possible memory release before exit. */
1412 void
snmp_tool_freeall(struct snmp_toolinfo * snmptoolctx)1413 snmp_tool_freeall(struct snmp_toolinfo *snmptoolctx)
1414 {
1415 	if (snmp_client.chost != NULL) {
1416 		free(snmp_client.chost);
1417 		snmp_client.chost = NULL;
1418 	}
1419 
1420 	if (snmp_client.cport != NULL) {
1421 		free(snmp_client.cport);
1422 		snmp_client.cport = NULL;
1423 	}
1424 
1425 	snmp_mapping_free(snmptoolctx);
1426 	free_filelist(snmptoolctx);
1427 	snmp_object_freeall(snmptoolctx);
1428 
1429 	if (snmptoolctx->passwd != NULL) {
1430 		free(snmptoolctx->passwd);
1431 		snmptoolctx->passwd = NULL;
1432 	}
1433 }
1434 
1435 /*
1436  * Fill all variables from the object list into a PDU. (snmp_verify_vbind_f)
1437  * function should check whether the variable is consistent in this PDU
1438  * (e.g do not add non-leaf OIDs to a GET PDU, or OIDs with read access only to
1439  * a SET PDU) - might be NULL though. (snmp_add_vbind_f) function is the
1440  * function actually adds the variable to the PDU and must not be NULL.
1441  */
1442 int32_t
snmp_pdu_add_bindings(struct snmp_toolinfo * snmptoolctx,snmp_verify_vbind_f vfunc,snmp_add_vbind_f afunc,struct snmp_pdu * pdu,int32_t maxcount)1443 snmp_pdu_add_bindings(struct snmp_toolinfo *snmptoolctx,
1444     snmp_verify_vbind_f vfunc, snmp_add_vbind_f afunc,
1445     struct snmp_pdu *pdu, int32_t maxcount)
1446 {
1447 	int32_t nbindings, abind;
1448 	struct snmp_object *obj;
1449 
1450 	if (pdu == NULL || afunc == NULL)
1451 		return (-1);
1452 
1453 	/* Return 0 in case of no more work todo. */
1454 	if (SLIST_EMPTY(&snmptoolctx->snmp_objectlist))
1455 		return (0);
1456 
1457 	if (maxcount < 0 || maxcount > SNMP_MAX_BINDINGS) {
1458 		warnx("maxcount out of range: <0 || >SNMP_MAX_BINDINGS");
1459 		return (-1);
1460 	}
1461 
1462 	nbindings = 0;
1463 	SLIST_FOREACH(obj, &snmptoolctx->snmp_objectlist, link) {
1464 		if ((vfunc != NULL) && (vfunc(snmptoolctx, pdu, obj) < 0)) {
1465 			nbindings = -1;
1466 			break;
1467 		}
1468 		if ((abind = afunc(pdu, obj)) < 0) {
1469 			nbindings = -1;
1470 			break;
1471 		}
1472 
1473 		if (abind > 0) {
1474 			/* Do not put more varbindings than requested. */
1475 			if (++nbindings >= maxcount)
1476 				break;
1477 		}
1478 	}
1479 
1480 	return (nbindings);
1481 }
1482 
1483 /*
1484  * Locate an object in the object list and set a corresponding error status.
1485  */
1486 int32_t
snmp_object_seterror(struct snmp_toolinfo * snmptoolctx,struct snmp_value * err_value,int32_t error_status)1487 snmp_object_seterror(struct snmp_toolinfo *snmptoolctx,
1488     struct snmp_value *err_value, int32_t error_status)
1489 {
1490 	struct snmp_object *obj;
1491 
1492 	if (SLIST_EMPTY(&snmptoolctx->snmp_objectlist) || err_value == NULL)
1493 		return (-1);
1494 
1495 	SLIST_FOREACH(obj, &snmptoolctx->snmp_objectlist, link)
1496 		if (asn_compare_oid(&(err_value->var), &(obj->val.var)) == 0) {
1497 			obj->error = error_status;
1498 			return (1);
1499 		}
1500 
1501 	return (0);
1502 }
1503 
1504 /*
1505  * Check a PDU received in response to a SNMP_PDU_GET/SNMP_PDU_GETBULK request
1506  * but don't compare syntaxes - when sending a request PDU they must be null.
1507  * This is a (almost) complete copy of snmp_pdu_check() - with matching syntaxes
1508  * checks and some other checks skipped.
1509  */
1510 int32_t
snmp_parse_get_resp(struct snmp_pdu * resp,struct snmp_pdu * req)1511 snmp_parse_get_resp(struct snmp_pdu *resp, struct snmp_pdu *req)
1512 {
1513 	uint32_t i;
1514 
1515 	for (i = 0; i < req->nbindings; i++) {
1516 		if (asn_compare_oid(&req->bindings[i].var,
1517 		    &resp->bindings[i].var) != 0) {
1518 			warnx("Bad OID in response");
1519 			return (-1);
1520 		}
1521 
1522 		if (snmp_client.version != SNMP_V1 && (resp->bindings[i].syntax
1523 		    == SNMP_SYNTAX_NOSUCHOBJECT || resp->bindings[i].syntax ==
1524 		    SNMP_SYNTAX_NOSUCHINSTANCE))
1525 			return (0);
1526 	}
1527 
1528 	return (1);
1529 }
1530 
1531 int32_t
snmp_parse_getbulk_resp(struct snmp_pdu * resp,struct snmp_pdu * req)1532 snmp_parse_getbulk_resp(struct snmp_pdu *resp, struct snmp_pdu *req)
1533 {
1534 	int32_t N, R, M, r;
1535 
1536 	if (req->error_status > (int32_t) resp->nbindings) {
1537 		warnx("Bad number of bindings in response");
1538 		return (-1);
1539 	}
1540 
1541 	for (N = 0; N < req->error_status; N++) {
1542 		if (asn_is_suboid(&req->bindings[N].var,
1543 		    &resp->bindings[N].var) == 0)
1544 			return (0);
1545 		if (resp->bindings[N].syntax == SNMP_SYNTAX_ENDOFMIBVIEW)
1546 			return (0);
1547 	}
1548 
1549 	for (R = N , r = N; R  < (int32_t) req->nbindings; R++) {
1550 		for (M = 0; M < req->error_index && (r + M) <
1551 		    (int32_t) resp->nbindings; M++) {
1552 			if (asn_is_suboid(&req->bindings[R].var,
1553 			    &resp->bindings[r + M].var) == 0)
1554 				return (0);
1555 
1556 			if (resp->bindings[r + M].syntax ==
1557 			    SNMP_SYNTAX_ENDOFMIBVIEW) {
1558 				M++;
1559 				break;
1560 			}
1561 		}
1562 		r += M;
1563 	}
1564 
1565 	return (0);
1566 }
1567 
1568 int32_t
snmp_parse_getnext_resp(struct snmp_pdu * resp,struct snmp_pdu * req)1569 snmp_parse_getnext_resp(struct snmp_pdu *resp, struct snmp_pdu *req)
1570 {
1571 	uint32_t i;
1572 
1573 	for (i = 0; i < req->nbindings; i++) {
1574 		if (asn_is_suboid(&req->bindings[i].var, &resp->bindings[i].var)
1575 		    == 0)
1576 			return (0);
1577 
1578 		if (resp->version != SNMP_V1 && resp->bindings[i].syntax ==
1579 		    SNMP_SYNTAX_ENDOFMIBVIEW)
1580 			return (0);
1581 	}
1582 
1583 	return (1);
1584 }
1585 
1586 /*
1587  * Should be called to check a response to get/getnext/getbulk.
1588  */
1589 int32_t
snmp_parse_resp(struct snmp_pdu * resp,struct snmp_pdu * req)1590 snmp_parse_resp(struct snmp_pdu *resp, struct snmp_pdu *req)
1591 {
1592 	if (resp == NULL || req == NULL)
1593 		return (-2);
1594 
1595 	if (resp->version != req->version) {
1596 		warnx("Response has wrong version");
1597 		return (-1);
1598 	}
1599 
1600 	if (resp->error_status == SNMP_ERR_NOSUCHNAME) {
1601 		warnx("Error - No Such Name");
1602 		return (0);
1603 	}
1604 
1605 	if (resp->error_status != SNMP_ERR_NOERROR) {
1606 		warnx("Error %d in response", resp->error_status);
1607 		return (-1);
1608 	}
1609 
1610 	if (resp->nbindings != req->nbindings && req->type != SNMP_PDU_GETBULK){
1611 		warnx("Bad number of bindings in response");
1612 		return (-1);
1613 	}
1614 
1615 	switch (req->type) {
1616 		case SNMP_PDU_GET:
1617 			return (snmp_parse_get_resp(resp,req));
1618 		case SNMP_PDU_GETBULK:
1619 			return (snmp_parse_getbulk_resp(resp,req));
1620 		case SNMP_PDU_GETNEXT:
1621 			return (snmp_parse_getnext_resp(resp,req));
1622 		default:
1623 			/* NOTREACHED */
1624 			break;
1625 	}
1626 
1627 	return (-2);
1628 }
1629 
1630 static void
snmp_output_octetstring(struct snmp_toolinfo * snmptoolctx,enum snmp_tc tc,uint32_t len,uint8_t * octets)1631 snmp_output_octetstring(struct snmp_toolinfo *snmptoolctx, enum snmp_tc tc,
1632     uint32_t len, uint8_t *octets)
1633 {
1634 	char *buf;
1635 
1636 	if (len == 0 || octets == NULL)
1637 		return;
1638 
1639 	if (GET_OUTPUT(snmptoolctx) == OUTPUT_VERBOSE)
1640 		fprintf(stdout, "%s : ",
1641 		    syntax_strings[SNMP_SYNTAX_OCTETSTRING].str);
1642 
1643 	if ((buf = snmp_oct2tc(tc, len, (char *) octets)) != NULL) {
1644 		fprintf(stdout, "%s", buf);
1645 		free(buf);
1646 	}
1647 }
1648 
1649 static void
snmp_output_octetindex(struct snmp_toolinfo * snmptoolctx,enum snmp_tc tc,struct asn_oid * oid)1650 snmp_output_octetindex(struct snmp_toolinfo *snmptoolctx, enum snmp_tc tc,
1651     struct asn_oid *oid)
1652 {
1653 	uint32_t i;
1654 	uint8_t *s;
1655 
1656 	if ((s = malloc(oid->subs[0] + 1)) == NULL)
1657 		syslog(LOG_ERR, "malloc failed - %s", strerror(errno));
1658 	else {
1659 		for (i = 0; i < oid->subs[0]; i++)
1660 			s[i] = (u_char) (oid->subs[i + 1]);
1661 
1662 		snmp_output_octetstring(snmptoolctx, tc, oid->subs[0], s);
1663 		free(s);
1664 	}
1665 }
1666 
1667 /*
1668  * Check and output syntax type and value.
1669  */
1670 static void
snmp_output_oid_value(struct snmp_toolinfo * snmptoolctx,struct asn_oid * oid)1671 snmp_output_oid_value(struct snmp_toolinfo *snmptoolctx, struct asn_oid *oid)
1672 {
1673 	char oid_string[ASN_OIDSTRLEN];
1674 	struct snmp_object obj;
1675 
1676 	if (GET_OUTPUT(snmptoolctx) == OUTPUT_VERBOSE)
1677 		fprintf(stdout, "%s : ", syntax_strings[SNMP_SYNTAX_OID].str);
1678 
1679 	if(!ISSET_NUMERIC(snmptoolctx)) {
1680 		memset(&obj, 0, sizeof(struct snmp_object));
1681 		asn_append_oid(&(obj.val.var), oid);
1682 
1683 		if (snmp_lookup_enumstring(snmptoolctx, &obj) > 0)
1684 			fprintf(stdout, "%s" , obj.info->string);
1685 		else if (snmp_lookup_oidstring(snmptoolctx, &obj) > 0)
1686 			fprintf(stdout, "%s" , obj.info->string);
1687 		else if (snmp_lookup_nodestring(snmptoolctx, &obj) > 0)
1688 			fprintf(stdout, "%s" , obj.info->string);
1689 		else {
1690 			(void) asn_oid2str_r(oid, oid_string);
1691 			fprintf(stdout, "%s", oid_string);
1692 		}
1693 	} else {
1694 		(void) asn_oid2str_r(oid, oid_string);
1695 		fprintf(stdout, "%s", oid_string);
1696 	}
1697 }
1698 
1699 static void
snmp_output_int(struct snmp_toolinfo * snmptoolctx,struct enum_pairs * enums,int32_t int_val)1700 snmp_output_int(struct snmp_toolinfo *snmptoolctx, struct enum_pairs *enums,
1701     int32_t int_val)
1702 {
1703 	char *string;
1704 
1705 	if (GET_OUTPUT(snmptoolctx) == OUTPUT_VERBOSE)
1706 		fprintf(stdout, "%s : ",
1707 		    syntax_strings[SNMP_SYNTAX_INTEGER].str);
1708 
1709 	if (enums != NULL && (string = enum_string_lookup(enums, int_val))
1710 	    != NULL)
1711 		fprintf(stdout, "%s", string);
1712 	else
1713 		fprintf(stdout, "%d", int_val);
1714 }
1715 
1716 static void
snmp_output_ipaddress(struct snmp_toolinfo * snmptoolctx,uint8_t * ip)1717 snmp_output_ipaddress(struct snmp_toolinfo *snmptoolctx, uint8_t *ip)
1718 {
1719 	if (GET_OUTPUT(snmptoolctx) == OUTPUT_VERBOSE)
1720 		fprintf(stdout, "%s : ",
1721 		    syntax_strings[SNMP_SYNTAX_IPADDRESS].str);
1722 
1723 	fprintf(stdout, "%u.%u.%u.%u", ip[0], ip[1], ip[2], ip[3]);
1724 }
1725 
1726 static void
snmp_output_counter(struct snmp_toolinfo * snmptoolctx,uint32_t counter)1727 snmp_output_counter(struct snmp_toolinfo *snmptoolctx, uint32_t counter)
1728 {
1729 	if (GET_OUTPUT(snmptoolctx) == OUTPUT_VERBOSE)
1730 		fprintf(stdout, "%s : ",
1731 		    syntax_strings[SNMP_SYNTAX_COUNTER].str);
1732 
1733 	fprintf(stdout, "%u", counter);
1734 }
1735 
1736 static void
snmp_output_gauge(struct snmp_toolinfo * snmptoolctx,uint32_t gauge)1737 snmp_output_gauge(struct snmp_toolinfo *snmptoolctx, uint32_t gauge)
1738 {
1739 	if (GET_OUTPUT(snmptoolctx) == OUTPUT_VERBOSE)
1740 		fprintf(stdout, "%s : ", syntax_strings[SNMP_SYNTAX_GAUGE].str);
1741 
1742 	fprintf(stdout, "%u", gauge);
1743 }
1744 
1745 static void
snmp_output_ticks(struct snmp_toolinfo * snmptoolctx,uint32_t ticks)1746 snmp_output_ticks(struct snmp_toolinfo *snmptoolctx, uint32_t ticks)
1747 {
1748 	if (GET_OUTPUT(snmptoolctx) == OUTPUT_VERBOSE)
1749 		fprintf(stdout, "%s : ",
1750 		    syntax_strings[SNMP_SYNTAX_TIMETICKS].str);
1751 
1752 	fprintf(stdout, "%u", ticks);
1753 }
1754 
1755 static void
snmp_output_counter64(struct snmp_toolinfo * snmptoolctx,uint64_t counter64)1756 snmp_output_counter64(struct snmp_toolinfo *snmptoolctx, uint64_t counter64)
1757 {
1758 	if (GET_OUTPUT(snmptoolctx) == OUTPUT_VERBOSE)
1759 		fprintf(stdout, "%s : ",
1760 		    syntax_strings[SNMP_SYNTAX_COUNTER64].str);
1761 
1762 	fprintf(stdout,"%ju", counter64);
1763 }
1764 
1765 int32_t
snmp_output_numval(struct snmp_toolinfo * snmptoolctx,struct snmp_value * val,struct snmp_oid2str * entry)1766 snmp_output_numval(struct snmp_toolinfo *snmptoolctx, struct snmp_value *val,
1767     struct snmp_oid2str *entry)
1768 {
1769 	if (val == NULL)
1770 		return (-1);
1771 
1772 	if (GET_OUTPUT(snmptoolctx) != OUTPUT_QUIET)
1773 		fprintf(stdout, " = ");
1774 
1775 	switch (val->syntax) {
1776 	    case SNMP_SYNTAX_INTEGER:
1777 		if (entry != NULL)
1778 			snmp_output_int(snmptoolctx, entry->snmp_enum,
1779 			    val->v.integer);
1780 		else
1781 			snmp_output_int(snmptoolctx, NULL, val->v.integer);
1782 		break;
1783 
1784 	    case SNMP_SYNTAX_OCTETSTRING:
1785 		if (entry != NULL)
1786 			snmp_output_octetstring(snmptoolctx, entry->tc,
1787 			    val->v.octetstring.len, val->v.octetstring.octets);
1788 		else
1789 			snmp_output_octetstring(snmptoolctx, SNMP_STRING,
1790 			    val->v.octetstring.len, val->v.octetstring.octets);
1791 		break;
1792 
1793 	    case SNMP_SYNTAX_OID:
1794 		snmp_output_oid_value(snmptoolctx, &(val->v.oid));
1795 		break;
1796 
1797 	    case SNMP_SYNTAX_IPADDRESS:
1798 		snmp_output_ipaddress(snmptoolctx, val->v.ipaddress);
1799 		break;
1800 
1801 	    case SNMP_SYNTAX_COUNTER:
1802 		snmp_output_counter(snmptoolctx, val->v.uint32);
1803 		break;
1804 
1805 	    case SNMP_SYNTAX_GAUGE:
1806 		snmp_output_gauge(snmptoolctx, val->v.uint32);
1807 		break;
1808 
1809 	    case SNMP_SYNTAX_TIMETICKS:
1810 		snmp_output_ticks(snmptoolctx, val->v.uint32);
1811 		break;
1812 
1813 	    case SNMP_SYNTAX_COUNTER64:
1814 		snmp_output_counter64(snmptoolctx, val->v.counter64);
1815 		break;
1816 
1817 	    case SNMP_SYNTAX_NOSUCHOBJECT:
1818 		fprintf(stderr, "No Such Object\n");
1819 		return (val->syntax);
1820 
1821 	    case SNMP_SYNTAX_NOSUCHINSTANCE:
1822 		fprintf(stderr, "No Such Instance\n");
1823 		return (val->syntax);
1824 
1825 	    case SNMP_SYNTAX_ENDOFMIBVIEW:
1826 		fprintf(stdout, "End of Mib View\n");
1827 		return (val->syntax);
1828 
1829 	    case SNMP_SYNTAX_NULL:
1830 		/* NOTREACHED */
1831 		fprintf(stderr, "agent returned NULL Syntax\n");
1832 		return (val->syntax);
1833 
1834 	    default:
1835 		/* NOTREACHED - If here - then all went completely wrong. */
1836 		fprintf(stderr, "agent returned unknown syntax\n");
1837 		return (-1);
1838 	}
1839 
1840 	fprintf(stdout, "\n");
1841 
1842 	return (0);
1843 }
1844 
1845 static int32_t
snmp_fill_object(struct snmp_toolinfo * snmptoolctx,struct snmp_object * obj,struct snmp_value * val)1846 snmp_fill_object(struct snmp_toolinfo *snmptoolctx, struct snmp_object *obj,
1847     struct snmp_value *val)
1848 {
1849 	int32_t rc;
1850 	asn_subid_t suboid;
1851 
1852 	if (obj == NULL || val == NULL)
1853 		return (-1);
1854 
1855 	if ((suboid = snmp_suboid_pop(&(val->var))) > ASN_MAXID)
1856 		return (-1);
1857 
1858 	memset(obj, 0, sizeof(struct snmp_object));
1859 	asn_append_oid(&(obj->val.var), &(val->var));
1860 	obj->val.syntax = val->syntax;
1861 
1862 	if (obj->val.syntax > 0)
1863 		rc = snmp_lookup_leafstring(snmptoolctx, obj);
1864 	else
1865 		rc = snmp_lookup_nonleaf_string(snmptoolctx, obj);
1866 
1867 	(void) snmp_suboid_append(&(val->var), suboid);
1868 	(void) snmp_suboid_append(&(obj->val.var), suboid);
1869 
1870 	return (rc);
1871 }
1872 
1873 static int32_t
snmp_output_index(struct snmp_toolinfo * snmptoolctx,struct index * stx,struct asn_oid * oid)1874 snmp_output_index(struct snmp_toolinfo *snmptoolctx, struct index *stx,
1875     struct asn_oid *oid)
1876 {
1877 	uint8_t ip[4];
1878 	uint32_t bytes = 1;
1879 	uint64_t cnt64;
1880 	struct asn_oid temp, out;
1881 
1882 	if (oid->len < bytes)
1883 		return (-1);
1884 
1885 	memset(&temp, 0, sizeof(struct asn_oid));
1886 	asn_append_oid(&temp, oid);
1887 
1888 	switch (stx->syntax) {
1889 	    case SNMP_SYNTAX_INTEGER:
1890 		snmp_output_int(snmptoolctx, stx->snmp_enum, temp.subs[0]);
1891 		break;
1892 
1893 	    case SNMP_SYNTAX_OCTETSTRING:
1894 		if ((temp.subs[0] > temp.len -1 ) || (temp.subs[0] >
1895 		    ASN_MAXOCTETSTRING))
1896 			return (-1);
1897 		snmp_output_octetindex(snmptoolctx, stx->tc, &temp);
1898 		bytes += temp.subs[0];
1899 		break;
1900 
1901 	    case SNMP_SYNTAX_OID:
1902 		if ((temp.subs[0] > temp.len -1) || (temp.subs[0] >
1903 		    ASN_MAXOIDLEN))
1904 			return (-1);
1905 
1906 		bytes += temp.subs[0];
1907 		memset(&out, 0, sizeof(struct asn_oid));
1908 		asn_slice_oid(&out, &temp, 1, bytes);
1909 		snmp_output_oid_value(snmptoolctx, &out);
1910 		break;
1911 
1912 	    case SNMP_SYNTAX_IPADDRESS:
1913 		if (temp.len < 4)
1914 			return (-1);
1915 		for (bytes = 0; bytes < 4; bytes++)
1916 			ip[bytes] = temp.subs[bytes];
1917 
1918 		snmp_output_ipaddress(snmptoolctx, ip);
1919 		bytes = 4;
1920 		break;
1921 
1922 	    case SNMP_SYNTAX_COUNTER:
1923 		snmp_output_counter(snmptoolctx, temp.subs[0]);
1924 		break;
1925 
1926 	    case SNMP_SYNTAX_GAUGE:
1927 		snmp_output_gauge(snmptoolctx, temp.subs[0]);
1928 		break;
1929 
1930 	    case SNMP_SYNTAX_TIMETICKS:
1931 		snmp_output_ticks(snmptoolctx, temp.subs[0]);
1932 		break;
1933 
1934 	    case SNMP_SYNTAX_COUNTER64:
1935 		if (oid->len < 2)
1936 			return (-1);
1937 		bytes = 2;
1938 		memcpy(&cnt64, temp.subs, bytes);
1939 		snmp_output_counter64(snmptoolctx, cnt64);
1940 		break;
1941 
1942 	    default:
1943 		return (-1);
1944 	}
1945 
1946 	return (bytes);
1947 }
1948 
1949 static int32_t
snmp_output_object(struct snmp_toolinfo * snmptoolctx,struct snmp_object * o)1950 snmp_output_object(struct snmp_toolinfo *snmptoolctx, struct snmp_object *o)
1951 {
1952 	int32_t i, first, len;
1953 	struct asn_oid oid;
1954 	struct index *temp;
1955 
1956 	if (ISSET_NUMERIC(snmptoolctx))
1957 		return (-1);
1958 
1959 	if (o->info->table_idx == NULL) {
1960 		fprintf(stdout,"%s.%d", o->info->string,
1961 		    o->val.var.subs[o->val.var.len - 1]);
1962 		return (1);
1963 	}
1964 
1965 	fprintf(stdout,"%s[", o->info->string);
1966 	memset(&oid, 0, sizeof(struct asn_oid));
1967 
1968 	len = 1;
1969 	asn_slice_oid(&oid, &(o->val.var), (o->info->table_idx->var.len + len),
1970 	    o->val.var.len);
1971 
1972 	first = 1;
1973 	STAILQ_FOREACH(temp, &(OBJECT_IDX_LIST(o)), link) {
1974 		if(first)
1975 			first = 0;
1976 		else
1977 			fprintf(stdout, ", ");
1978 		if ((i = snmp_output_index(snmptoolctx, temp, &oid)) < 0)
1979 			break;
1980 		len += i;
1981 		memset(&oid, 0, sizeof(struct asn_oid));
1982 		asn_slice_oid(&oid, &(o->val.var),
1983 		    (o->info->table_idx->var.len + len), o->val.var.len + 1);
1984 	}
1985 
1986 	fprintf(stdout,"]");
1987 	return (1);
1988 }
1989 
1990 void
snmp_output_err_resp(struct snmp_toolinfo * snmptoolctx,struct snmp_pdu * pdu)1991 snmp_output_err_resp(struct snmp_toolinfo *snmptoolctx, struct snmp_pdu *pdu)
1992 {
1993 	struct snmp_object *object;
1994 	char buf[ASN_OIDSTRLEN];
1995 
1996 	if (pdu == NULL || (pdu->error_index > (int32_t) pdu->nbindings)) {
1997 		fprintf(stdout, "Invalid error index in PDU\n");
1998 		return;
1999 	}
2000 
2001 	if ((object = calloc(1, sizeof(struct snmp_object))) == NULL) {
2002 		fprintf(stdout, "calloc: %s", strerror(errno));
2003 		return;
2004 	}
2005 
2006 	fprintf(stdout, "Agent %s:%s returned error \n", snmp_client.chost,
2007 	    snmp_client.cport);
2008 
2009 	if (!ISSET_NUMERIC(snmptoolctx) && (snmp_fill_object(snmptoolctx, object,
2010 	    &(pdu->bindings[pdu->error_index - 1])) > 0))
2011 		snmp_output_object(snmptoolctx, object);
2012 	else {
2013 		asn_oid2str_r(&(pdu->bindings[pdu->error_index - 1].var), buf);
2014 		fprintf(stdout,"%s", buf);
2015 	}
2016 
2017 	fprintf(stdout," caused error - ");
2018 	if ((pdu->error_status > 0) && (pdu->error_status <=
2019 	    SNMP_ERR_INCONS_NAME))
2020 		fprintf(stdout, "%s\n", error_strings[pdu->error_status].str);
2021 	else
2022 		fprintf(stdout,"%s\n", error_strings[SNMP_ERR_UNKNOWN].str);
2023 
2024 	free(object);
2025 	object = NULL;
2026 }
2027 
2028 int32_t
snmp_output_resp(struct snmp_toolinfo * snmptoolctx,struct snmp_pdu * pdu,struct asn_oid * root)2029 snmp_output_resp(struct snmp_toolinfo *snmptoolctx, struct snmp_pdu *pdu,
2030     struct asn_oid *root)
2031 {
2032 	struct snmp_object *object;
2033 	char p[ASN_OIDSTRLEN];
2034 	int32_t error;
2035 	uint32_t i;
2036 
2037 	if ((object = calloc(1, sizeof(struct snmp_object))) == NULL)
2038 		return (-1);
2039 
2040 	i = error = 0;
2041 	while (i < pdu->nbindings) {
2042 		if (root != NULL && !(asn_is_suboid(root,
2043 		    &(pdu->bindings[i].var))))
2044 			break;
2045 
2046 		if (GET_OUTPUT(snmptoolctx) != OUTPUT_QUIET) {
2047 			if (!ISSET_NUMERIC(snmptoolctx) &&
2048 			    (snmp_fill_object(snmptoolctx, object,
2049 			    &(pdu->bindings[i])) > 0))
2050 				snmp_output_object(snmptoolctx, object);
2051 			else {
2052 				asn_oid2str_r(&(pdu->bindings[i].var), p);
2053 				fprintf(stdout, "%s", p);
2054 			}
2055 		}
2056 		error |= snmp_output_numval(snmptoolctx, &(pdu->bindings[i]),
2057 		    object->info);
2058 		i++;
2059 	}
2060 
2061 	free(object);
2062 	object = NULL;
2063 
2064 	if (error)
2065 		return (-1);
2066 
2067 	return (i);
2068 }
2069 
2070 void
snmp_output_engine(void)2071 snmp_output_engine(void)
2072 {
2073 	uint32_t i;
2074 	char *cptr, engine[2 * SNMP_ENGINE_ID_SIZ + 2];
2075 
2076 	cptr = engine;
2077 	for (i = 0; i < snmp_client.engine.engine_len; i++)
2078 		cptr += sprintf(cptr, "%.2x", snmp_client.engine.engine_id[i]);
2079 	*cptr++ = '\0';
2080 
2081 	fprintf(stdout, "Engine ID 0x%s\n", engine);
2082 	fprintf(stdout, "Boots : %u\t\tTime : %d\n",
2083 	    snmp_client.engine.engine_boots,
2084 	    snmp_client.engine.engine_time);
2085 }
2086 
2087 void
snmp_output_keys(void)2088 snmp_output_keys(void)
2089 {
2090 	uint32_t i, keylen = 0;
2091 	char *cptr, extkey[2 * SNMP_AUTH_KEY_SIZ + 2];
2092 
2093 	fprintf(stdout, "Localized keys for %s\n", snmp_client.user.sec_name);
2094 	if (snmp_client.user.auth_proto == SNMP_AUTH_HMAC_MD5) {
2095 		fprintf(stdout, "MD5 : 0x");
2096 		keylen = SNMP_AUTH_HMACMD5_KEY_SIZ;
2097 	} else if (snmp_client.user.auth_proto == SNMP_AUTH_HMAC_SHA) {
2098 		fprintf(stdout, "SHA : 0x");
2099 		keylen = SNMP_AUTH_HMACSHA_KEY_SIZ;
2100 	}
2101 	if (snmp_client.user.auth_proto != SNMP_AUTH_NOAUTH) {
2102 		cptr = extkey;
2103 		for (i = 0; i < keylen; i++)
2104 			cptr += sprintf(cptr, "%.2x",
2105 			    snmp_client.user.auth_key[i]);
2106 		*cptr++ = '\0';
2107 		fprintf(stdout, "%s\n", extkey);
2108 	}
2109 
2110 	if (snmp_client.user.priv_proto == SNMP_PRIV_DES) {
2111 		fprintf(stdout, "DES : 0x");
2112 		keylen = SNMP_PRIV_DES_KEY_SIZ;
2113 	} else if (snmp_client.user.priv_proto == SNMP_PRIV_AES) {
2114 		fprintf(stdout, "AES : 0x");
2115 		keylen = SNMP_PRIV_AES_KEY_SIZ;
2116 	}
2117 	if (snmp_client.user.priv_proto != SNMP_PRIV_NOPRIV) {
2118 		cptr = extkey;
2119 		for (i = 0; i < keylen; i++)
2120 			cptr += sprintf(cptr, "%.2x",
2121 			    snmp_client.user.priv_key[i]);
2122 		*cptr++ = '\0';
2123 		fprintf(stdout, "%s\n", extkey);
2124 	}
2125 }
2126