X-Git-Url: https://git.tcpdump.org/tcpdump/blobdiff_plain/410956bc363e11845ef9ed695dfbcbfef84e537f..HEAD:/print-snmp.c

diff --git a/print-snmp.c b/print-snmp.c
index d329f867..e1cc9771 100644
--- a/print-snmp.c
+++ b/print-snmp.c
@@ -58,24 +58,26 @@
 
 /* \summary: Simple Network Management Protocol (SNMP) printer */
 
-#ifdef HAVE_CONFIG_H
-#include "config.h"
-#endif
+#include <config.h>
 
-#include <netdissect-stdinc.h>
+#include "netdissect-stdinc.h"
 
 #include <stdio.h>
 #include <string.h>
+#include <limits.h>
 
 #ifdef USE_LIBSMI
 #include <smi.h>
 #endif
 
+#include "netdissect-ctype.h"
+
+#define ND_LONGJMP_FROM_TCHECK
 #include "netdissect.h"
+#include "extract.h"
 
 #undef OPAQUE  /* defined in <wingdi.h> */
 
-static const char tstr[] = "[|snmp]";
 
 /*
  * Universal ASN.1 types
@@ -331,10 +333,10 @@ static const struct obj_abrev {
 		} while ((objp = objp->next) != NULL); \
 	} \
 	if (objp) { \
-		ND_PRINT((ndo, suppressdot?"%s":".%s", objp->desc)); \
+		ND_PRINT(suppressdot?"%s":".%s", objp->desc); \
 		objp = objp->child; \
 	} else \
-		ND_PRINT((ndo, suppressdot?"%u":".%u", (o))); \
+		ND_PRINT(suppressdot?"%u":".%u", (o)); \
 }
 
 /*
@@ -417,18 +419,17 @@ static const char *SnmpVersion[] = {
  */
 static int
 asn1_parse(netdissect_options *ndo,
-           register const u_char *p, u_int len, struct be *elem)
+           const u_char *p, u_int len, struct be *elem)
 {
 	u_char form, class, id;
-	int i, hdr;
+	u_int i, hdr;
 
 	elem->asnlen = 0;
 	elem->type = BE_ANY;
 	if (len < 1) {
-		ND_PRINT((ndo, "[nothing to parse]"));
-		return -1;
+		ND_PRINT("[nothing to parse]");
+		goto invalid;
 	}
-	ND_TCHECK(*p);
 
 	/*
 	 * it would be nice to use a bit field, but you can't depend on them.
@@ -437,14 +438,14 @@ asn1_parse(netdissect_options *ndo,
 	 *  +---+---+---+---+---+---+---+---+
 	 *    7   6   5   4   3   2   1   0
 	 */
-	id = *p & ASN_ID_BITS;		/* lower 5 bits, range 00-1f */
+	id = GET_U_1(p) & ASN_ID_BITS;		/* lower 5 bits, range 00-1f */
 #ifdef notdef
-	form = (*p & 0xe0) >> 5;	/* move upper 3 bits to lower 3 */
+	form = (GET_U_1(p) & 0xe0) >> 5;	/* move upper 3 bits to lower 3 */
 	class = form >> 1;		/* bits 7&6 -> bits 1&0, range 0-3 */
 	form &= 0x1;			/* bit 5 -> bit 0, range 0-1 */
 #else
-	form = (u_char)(*p & ASN_FORM_BITS) >> ASN_FORM_SHIFT;
-	class = (u_char)(*p & ASN_CLASS_BITS) >> ASN_CLASS_SHIFT;
+	form = (u_char)(GET_U_1(p) & ASN_FORM_BITS) >> ASN_FORM_SHIFT;
+	class = (u_char)(GET_U_1(p) & ASN_CLASS_BITS) >> ASN_CLASS_SHIFT;
 #endif
 	elem->form = form;
 	elem->class = class;
@@ -463,62 +464,60 @@ asn1_parse(netdissect_options *ndo,
 		 * that won't fit in 32 bits.
 		 */
 		id = 0;
-		ND_TCHECK(*p);
-		while (*p & ASN_BIT8) {
+		while (GET_U_1(p) & ASN_BIT8) {
 			if (len < 1) {
-				ND_PRINT((ndo, "[Xtagfield?]"));
-				return -1;
+				ND_PRINT("[Xtagfield?]");
+				goto invalid;
 			}
-			id = (id << 7) | (*p & ~ASN_BIT8);
+			id = (id << 7) | (GET_U_1(p) & ~ASN_BIT8);
 			len--;
 			hdr++;
 			p++;
-			ND_TCHECK(*p);
 		}
 		if (len < 1) {
-			ND_PRINT((ndo, "[Xtagfield?]"));
-			return -1;
+			ND_PRINT("[Xtagfield?]");
+			goto invalid;
 		}
-		ND_TCHECK(*p);
-		elem->id = id = (id << 7) | *p;
+		elem->id = id = (id << 7) | GET_U_1(p);
 		--len;
 		++hdr;
 		++p;
 	}
 	if (len < 1) {
-		ND_PRINT((ndo, "[no asnlen]"));
-		return -1;
+		ND_PRINT("[no asnlen]");
+		goto invalid;
 	}
-	ND_TCHECK(*p);
-	elem->asnlen = *p;
+	elem->asnlen = GET_U_1(p);
 	p++; len--; hdr++;
 	if (elem->asnlen & ASN_BIT8) {
 		uint32_t noct = elem->asnlen % ASN_BIT8;
 		elem->asnlen = 0;
 		if (len < noct) {
-			ND_PRINT((ndo, "[asnlen? %d<%d]", len, noct));
-			return -1;
+			ND_PRINT("[asnlen? %d<%d]", len, noct);
+			goto invalid;
+		}
+		for (; noct != 0; len--, hdr++, noct--) {
+			elem->asnlen = (elem->asnlen << ASN_SHIFT8) | GET_U_1(p);
+			p++;
 		}
-		ND_TCHECK2(*p, noct);
-		for (; noct-- > 0; len--, hdr++)
-			elem->asnlen = (elem->asnlen << ASN_SHIFT8) | *p++;
 	}
 	if (len < elem->asnlen) {
-		ND_PRINT((ndo, "[len%d<asnlen%u]", len, elem->asnlen));
-		return -1;
+		ND_PRINT("[len%d<asnlen%u]", len, elem->asnlen);
+		goto invalid;
 	}
 	if (form >= sizeof(Form)/sizeof(Form[0])) {
-		ND_PRINT((ndo, "[form?%d]", form));
-		return -1;
+		ND_PRINT("[form?%d]", form);
+		goto invalid;
 	}
 	if (class >= sizeof(Class)/sizeof(Class[0])) {
-		ND_PRINT((ndo, "[class?%c/%d]", *Form[form], class));
-		return -1;
+		ND_PRINT("[class?%c/%d]", *Form[form], class);
+		goto invalid;
 	}
 	if ((int)id >= Class[class].numIDs) {
-		ND_PRINT((ndo, "[id?%c/%s/%d]", *Form[form], Class[class].name, id));
-		return -1;
+		ND_PRINT("[id?%c/%s/%d]", *Form[form], Class[class].name, id);
+		goto invalid;
 	}
+	ND_TCHECK_LEN(p, elem->asnlen);
 
 	switch (form) {
 	case PRIMITIVE:
@@ -531,19 +530,18 @@ asn1_parse(netdissect_options *ndo,
 				break;
 
 			case INTEGER: {
-				register int32_t data;
+				uint32_t data;
 				elem->type = BE_INT;
 				data = 0;
 
 				if (elem->asnlen == 0) {
-					ND_PRINT((ndo, "[asnlen=0]"));
-					return -1;
+					ND_PRINT("[asnlen=0]");
+					goto invalid;
 				}
-				ND_TCHECK2(*p, elem->asnlen);
-				if (*p & ASN_BIT8)	/* negative */
-					data = -1;
-				for (i = elem->asnlen; i-- > 0; p++)
-					data = (data << ASN_SHIFT8) | *p;
+				if (GET_U_1(p) & ASN_BIT8)	/* negative */
+					data = UINT_MAX;
+				for (i = elem->asnlen; i != 0; p++, i--)
+					data = (data << ASN_SHIFT8) | GET_U_1(p);
 				elem->data.integer = data;
 				break;
 			}
@@ -561,7 +559,7 @@ asn1_parse(netdissect_options *ndo,
 			default:
 				elem->type = BE_OCTET;
 				elem->data.raw = (const uint8_t *)p;
-				ND_PRINT((ndo, "[P/U/%s]", Class[class].Id[id]));
+				ND_PRINT("[P/U/%s]", Class[class].Id[id]);
 				break;
 			}
 			break;
@@ -576,23 +574,21 @@ asn1_parse(netdissect_options *ndo,
 			case COUNTER:
 			case GAUGE:
 			case TIMETICKS: {
-				register uint32_t data;
-				ND_TCHECK2(*p, elem->asnlen);
+				uint32_t data;
 				elem->type = BE_UNS;
 				data = 0;
-				for (i = elem->asnlen; i-- > 0; p++)
-					data = (data << 8) + *p;
+				for (i = elem->asnlen; i != 0; p++, i--)
+					data = (data << 8) + GET_U_1(p);
 				elem->data.uns = data;
 				break;
 			}
 
 			case COUNTER64: {
-				register uint64_t data64;
-				ND_TCHECK2(*p, elem->asnlen);
+				uint64_t data64;
 			        elem->type = BE_UNS64;
 				data64 = 0;
-				for (i = elem->asnlen; i-- > 0; p++)
-					data64 = (data64 << 8) + *p;
+				for (i = elem->asnlen; i != 0; p++, i--)
+					data64 = (data64 << 8) + GET_U_1(p);
 				elem->data.uns64 = data64;
 				break;
 			}
@@ -600,8 +596,8 @@ asn1_parse(netdissect_options *ndo,
 			default:
 				elem->type = BE_OCTET;
 				elem->data.raw = (const uint8_t *)p;
-				ND_PRINT((ndo, "[P/A/%s]",
-					Class[class].Id[id]));
+				ND_PRINT("[P/A/%s]",
+					Class[class].Id[id]);
 				break;
 			}
 			break;
@@ -626,8 +622,7 @@ asn1_parse(netdissect_options *ndo,
 			break;
 
 		default:
-			ND_PRINT((ndo, "[P/%s/%s]", Class[class].name, Class[class].Id[id]));
-			ND_TCHECK2(*p, elem->asnlen);
+			ND_PRINT("[P/%s/%s]", Class[class].name, Class[class].Id[id]);
 			elem->type = BE_OCTET;
 			elem->data.raw = (const uint8_t *)p;
 			break;
@@ -646,7 +641,7 @@ asn1_parse(netdissect_options *ndo,
 			default:
 				elem->type = BE_OCTET;
 				elem->data.raw = (const uint8_t *)p;
-				ND_PRINT((ndo, "C/U/%s", Class[class].Id[id]));
+				ND_PRINT("C/U/%s", Class[class].Id[id]);
 				break;
 			}
 			break;
@@ -659,7 +654,7 @@ asn1_parse(netdissect_options *ndo,
 		default:
 			elem->type = BE_OCTET;
 			elem->data.raw = (const uint8_t *)p;
-			ND_PRINT((ndo, "C/%s/%s", Class[class].name, Class[class].Id[id]));
+			ND_PRINT("C/%s/%s", Class[class].name, Class[class].Id[id]);
 			break;
 		}
 		break;
@@ -668,59 +663,43 @@ asn1_parse(netdissect_options *ndo,
 	len -= elem->asnlen;
 	return elem->asnlen + hdr;
 
-trunc:
-	ND_PRINT((ndo, "%s", tstr));
+invalid:
 	return -1;
 }
 
-static int
+static void
 asn1_print_octets(netdissect_options *ndo, struct be *elem)
 {
 	const u_char *p = (const u_char *)elem->data.raw;
 	uint32_t asnlen = elem->asnlen;
 	uint32_t i;
 
-	ND_TCHECK2(*p, asnlen);
-	for (i = asnlen; i-- > 0; p++)
-		ND_PRINT((ndo, "_%.2x", *p));
-	return 0;
-
-trunc:
-	ND_PRINT((ndo, "%s", tstr));
-	return -1;
+	for (i = asnlen; i != 0; p++, i--)
+		ND_PRINT("_%.2x", GET_U_1(p));
 }
 
-static int
+static void
 asn1_print_string(netdissect_options *ndo, struct be *elem)
 {
-	register int printable = 1, first = 1;
+	int printable = 1, first = 1;
 	const u_char *p;
 	uint32_t asnlen = elem->asnlen;
 	uint32_t i;
 
 	p = elem->data.str;
-	ND_TCHECK2(*p, asnlen);
-	for (i = asnlen; printable && i-- > 0; p++)
-		printable = ND_ISPRINT(*p);
+	for (i = asnlen; printable && i != 0; p++, i--)
+		printable = ND_ASCII_ISPRINT(GET_U_1(p));
 	p = elem->data.str;
 	if (printable) {
-		ND_PRINT((ndo, "\""));
-		if (fn_printn(ndo, p, asnlen, ndo->ndo_snapend)) {
-			ND_PRINT((ndo, "\""));
-			goto trunc;
-		}
-		ND_PRINT((ndo, "\""));
+		ND_PRINT("\"");
+		nd_printjn(ndo, p, asnlen);
+		ND_PRINT("\"");
 	} else {
-		for (i = asnlen; i-- > 0; p++) {
-			ND_PRINT((ndo, first ? "%.2x" : "_%.2x", *p));
+		for (i = asnlen; i != 0; p++, i--) {
+			ND_PRINT(first ? "%.2x" : "_%.2x", GET_U_1(p));
 			first = 0;
 		}
 	}
-	return 0;
-
-trunc:
-	ND_PRINT((ndo, "%s", tstr));
-	return -1;
 }
 
 /*
@@ -739,121 +718,115 @@ asn1_print(netdissect_options *ndo,
 	switch (elem->type) {
 
 	case BE_OCTET:
-		if (asn1_print_octets(ndo, elem) == -1)
-			return -1;
+		asn1_print_octets(ndo, elem);
 		break;
 
 	case BE_NULL:
 		break;
 
 	case BE_OID: {
-		int o = 0, first = -1;
+		int first = -1;
+		uint32_t o = 0;
 
 		p = (const u_char *)elem->data.raw;
 		i = asnlen;
-		if (!nd_smi_module_loaded) {
-			if (!ndo->ndo_nflag && asnlen > 2) {
-				const struct obj_abrev *a = &obj_abrev_list[0];
-				for (; a->node; a++) {
-					if (i < a->oid_len)
-						continue;
-					if (!ND_TTEST2(*p, a->oid_len))
-						continue;
-					if (memcmp(a->oid, p, a->oid_len) == 0) {
-						objp = a->node->child;
-						i -= a->oid_len;
-						p += a->oid_len;
-						ND_PRINT((ndo, "%s", a->prefix));
-						first = 1;
-						break;
-					}
+		if (!ndo->ndo_nflag && asnlen > 2) {
+			const struct obj_abrev *a = &obj_abrev_list[0];
+			for (; a->node; a++) {
+				if (i < a->oid_len)
+					continue;
+				ND_TCHECK_LEN(p, a->oid_len);
+				if (memcmp(a->oid, p, a->oid_len) == 0) {
+					objp = a->node->child;
+					i -= a->oid_len;
+					p += a->oid_len;
+					ND_PRINT("%s", a->prefix);
+					first = 1;
+					break;
 				}
 			}
+		}
 
-			for (; i-- > 0; p++) {
-				ND_TCHECK(*p);
-				o = (o << ASN_SHIFT7) + (*p & ~ASN_BIT8);
-				if (*p & ASN_LONGLEN)
-				        continue;
-
-				/*
-				 * first subitem encodes two items with
-				 * 1st*OIDMUX+2nd
-				 * (see X.690:1997 clause 8.19 for the details)
-				 */
-				if (first < 0) {
-				        int s;
-					if (!ndo->ndo_nflag)
-						objp = mibroot;
-					first = 0;
-					s = o / OIDMUX;
-					if (s > 2) s = 2;
-					OBJ_PRINT(s, first);
-					o -= s * OIDMUX;
-				}
-				OBJ_PRINT(o, first);
-				if (--first < 0)
-					first = 0;
-				o = 0;
+		for (; i != 0; p++, i--) {
+			o = (o << ASN_SHIFT7) + (GET_U_1(p) & ~ASN_BIT8);
+			if (GET_U_1(p) & ASN_LONGLEN)
+			        continue;
+
+			/*
+			 * first subitem encodes two items with
+			 * 1st*OIDMUX+2nd
+			 * (see X.690:1997 clause 8.19 for the details)
+			 */
+			if (first < 0) {
+			        int s;
+				if (!ndo->ndo_nflag)
+					objp = mibroot;
+				first = 0;
+				s = o / OIDMUX;
+				if (s > 2) s = 2;
+				OBJ_PRINT(s, first);
+				o -= s * OIDMUX;
 			}
+			OBJ_PRINT(o, first);
+			if (--first < 0)
+				first = 0;
+			o = 0;
 		}
 		break;
 	}
 
 	case BE_INT:
-		ND_PRINT((ndo, "%d", elem->data.integer));
+		ND_PRINT("%d", elem->data.integer);
 		break;
 
 	case BE_UNS:
-		ND_PRINT((ndo, "%u", elem->data.uns));
+		ND_PRINT("%u", elem->data.uns);
 		break;
 
 	case BE_UNS64:
-		ND_PRINT((ndo, "%" PRIu64, elem->data.uns64));
+		ND_PRINT("%" PRIu64, elem->data.uns64);
 		break;
 
 	case BE_STR:
-		if (asn1_print_string(ndo, elem) == -1)
-			return -1;
+		asn1_print_string(ndo, elem);
 		break;
 
 	case BE_SEQ:
-		ND_PRINT((ndo, "Seq(%u)", elem->asnlen));
+		ND_PRINT("Seq(%u)", elem->asnlen);
 		break;
 
 	case BE_INETADDR:
 		if (asnlen != ASNLEN_INETADDR)
-			ND_PRINT((ndo, "[inetaddr len!=%d]", ASNLEN_INETADDR));
+			ND_PRINT("[inetaddr len!=%d]", ASNLEN_INETADDR);
 		p = (const u_char *)elem->data.raw;
-		ND_TCHECK2(*p, asnlen);
-		for (i = asnlen; i-- != 0; p++) {
-			ND_PRINT((ndo, (i == asnlen-1) ? "%u" : ".%u", *p));
+		for (i = asnlen; i != 0; p++, i--) {
+			ND_PRINT((i == asnlen) ? "%u" : ".%u", GET_U_1(p));
 		}
 		break;
 
 	case BE_NOSUCHOBJECT:
 	case BE_NOSUCHINST:
 	case BE_ENDOFMIBVIEW:
-		ND_PRINT((ndo, "[%s]", Class[EXCEPTIONS].Id[elem->id]));
+		ND_PRINT("[%s]", Class[EXCEPTIONS].Id[elem->id]);
 		break;
 
 	case BE_PDU:
-		ND_PRINT((ndo, "%s(%u)", Class[CONTEXT].Id[elem->id], elem->asnlen));
+		ND_PRINT("%s(%u)", Class[CONTEXT].Id[elem->id], elem->asnlen);
 		break;
 
 	case BE_ANY:
-		ND_PRINT((ndo, "[BE_ANY!?]"));
+		ND_PRINT("[BE_ANY!?]");
 		break;
 
 	default:
-		ND_PRINT((ndo, "[be!?]"));
+		ND_PRINT("[be!?]");
 		break;
 	}
+	/* This function now always returns 0. Don't make it void yet, as other
+	 * code checks for negative result and this function might need to signal
+	 * invalid data later.
+	 */
 	return 0;
-
-trunc:
-	ND_PRINT((ndo, "%s", tstr));
-	return -1;
 }
 
 #ifdef notdef
@@ -872,16 +845,16 @@ asn1_decode(u_char *p, u_int length)
 	struct be elem;
 	int i = 0;
 
-	while (i >= 0 && length > 0) {
+	while (i >= 0 && length != 0) {
 		i = asn1_parse(ndo, p, length, &elem);
 		if (i >= 0) {
-			ND_PRINT((ndo, " "));
+			ND_PRINT(" ");
 			if (asn1_print(ndo, &elem) < 0)
 				return;
 			if (elem.type == BE_SEQ || elem.type == BE_PDU) {
-				ND_PRINT((ndo, " {"));
+				ND_PRINT(" {");
 				asn1_decode(elem.data.raw, elem.asnlen);
-				ND_PRINT((ndo, " }"));
+				ND_PRINT(" }");
 			}
 			length -= i;
 			p += i;
@@ -920,40 +893,34 @@ smi_decode_oid(netdissect_options *ndo,
 {
 	const u_char *p = (const u_char *)elem->data.raw;
 	uint32_t asnlen = elem->asnlen;
-	int o = 0, first = -1, i = asnlen;
+	uint32_t i = asnlen;
+	int o = 0, first = -1;
 	unsigned int firstval;
 
-	if (nd_smi_module_loaded) {
-		for (*oidlen = 0; i-- > 0; p++) {
-			ND_TCHECK(*p);
-		        o = (o << ASN_SHIFT7) + (*p & ~ASN_BIT8);
-			if (*p & ASN_LONGLEN)
-			    continue;
+	for (*oidlen = 0; i != 0; p++, i--) {
+	        o = (o << ASN_SHIFT7) + (GET_U_1(p) & ~ASN_BIT8);
+		if (GET_U_1(p) & ASN_LONGLEN)
+		    continue;
 
-			/*
-			 * first subitem encodes two items with 1st*OIDMUX+2nd
-			 * (see X.690:1997 clause 8.19 for the details)
-			 */
-			if (first < 0) {
-		        	first = 0;
-				firstval = o / OIDMUX;
-				if (firstval > 2) firstval = 2;
-				o -= firstval * OIDMUX;
-				if (*oidlen < oidsize) {
-				    oid[(*oidlen)++] = firstval;
-				}
-			}
+		/*
+		 * first subitem encodes two items with 1st*OIDMUX+2nd
+		 * (see X.690:1997 clause 8.19 for the details)
+		 */
+		if (first < 0) {
+			first = 0;
+			firstval = o / OIDMUX;
+			if (firstval > 2) firstval = 2;
+			o -= firstval * OIDMUX;
 			if (*oidlen < oidsize) {
-				oid[(*oidlen)++] = o;
+			    oid[(*oidlen)++] = firstval;
 			}
-			o = 0;
 		}
+		if (*oidlen < oidsize) {
+			oid[(*oidlen)++] = o;
+		}
+		o = 0;
 	}
 	return 0;
-
-trunc:
-	ND_PRINT((ndo, "%s", tstr));
-	return -1;
 }
 
 static int smi_check_type(SmiBasetype basetype, int be)
@@ -1054,6 +1021,10 @@ smi_print_variable(netdissect_options *ndo,
 	SmiNode *smiNode = NULL;
 	unsigned int i;
 
+	if (!nd_smi_module_loaded) {
+		*status = asn1_print(ndo, elem);
+		return NULL;
+	}
 	*status = smi_decode_oid(ndo, elem, oid, sizeof(oid) / sizeof(unsigned int),
 	    &oidlen);
 	if (*status < 0)
@@ -1064,12 +1035,12 @@ smi_print_variable(netdissect_options *ndo,
 		return NULL;
 	}
 	if (ndo->ndo_vflag) {
-		ND_PRINT((ndo, "%s::", smiGetNodeModule(smiNode)->name));
+		ND_PRINT("%s::", smiGetNodeModule(smiNode)->name);
 	}
-	ND_PRINT((ndo, "%s", smiNode->name));
+	ND_PRINT("%s", smiNode->name);
 	if (smiNode->oidlen < oidlen) {
 		for (i = smiNode->oidlen; i < oidlen; i++) {
-			ND_PRINT((ndo, ".%u", oid[i]));
+			ND_PRINT(".%u", oid[i]);
 		}
 	}
 	*status = 0;
@@ -1097,20 +1068,20 @@ smi_print_value(netdissect_options *ndo,
 	}
 
 	if (NOTIFY_CLASS(pduid) && smiNode->access < SMI_ACCESS_NOTIFY) {
-	    ND_PRINT((ndo, "[notNotifyable]"));
+	    ND_PRINT("[notNotifiable]");
 	}
 
 	if (READ_CLASS(pduid) && smiNode->access < SMI_ACCESS_READ_ONLY) {
-	    ND_PRINT((ndo, "[notReadable]"));
+	    ND_PRINT("[notReadable]");
 	}
 
 	if (WRITE_CLASS(pduid) && smiNode->access < SMI_ACCESS_READ_WRITE) {
-	    ND_PRINT((ndo, "[notWritable]"));
+	    ND_PRINT("[notWritable]");
 	}
 
 	if (RESPONSE_CLASS(pduid)
 	    && smiNode->access == SMI_ACCESS_NOT_ACCESSIBLE) {
-	    ND_PRINT((ndo, "[noAccess]"));
+	    ND_PRINT("[noAccess]");
 	}
 
 	smiType = smiGetNodeType(smiNode);
@@ -1119,11 +1090,11 @@ smi_print_value(netdissect_options *ndo,
 	}
 
 	if (! smi_check_type(smiType->basetype, elem->type)) {
-	    ND_PRINT((ndo, "[wrongType]"));
+	    ND_PRINT("[wrongType]");
 	}
 
 	if (! smi_check_range(smiType, elem)) {
-	    ND_PRINT((ndo, "[outOfRange]"));
+	    ND_PRINT("[outOfRange]");
 	}
 
 	/* resolve bits to named bits */
@@ -1139,22 +1110,24 @@ smi_print_value(netdissect_options *ndo,
 	        if (smiType->basetype == SMI_BASETYPE_BITS) {
 		        /* print bit labels */
 		} else {
-		        smi_decode_oid(ndo, elem, oid,
-				       sizeof(oid)/sizeof(unsigned int),
-				       &oidlen);
-			smiNode = smiGetNodeByOID(oidlen, oid);
-			if (smiNode) {
-			        if (ndo->ndo_vflag) {
-					ND_PRINT((ndo, "%s::", smiGetNodeModule(smiNode)->name));
-				}
-				ND_PRINT((ndo, "%s", smiNode->name));
-				if (smiNode->oidlen < oidlen) {
-				        for (i = smiNode->oidlen;
-					     i < oidlen; i++) {
-					        ND_PRINT((ndo, ".%u", oid[i]));
+			if (nd_smi_module_loaded &&
+			    smi_decode_oid(ndo, elem, oid,
+					   sizeof(oid)/sizeof(unsigned int),
+					   &oidlen) == 0) {
+				smiNode = smiGetNodeByOID(oidlen, oid);
+				if (smiNode) {
+				        if (ndo->ndo_vflag) {
+						ND_PRINT("%s::", smiGetNodeModule(smiNode)->name);
 					}
+					ND_PRINT("%s", smiNode->name);
+					if (smiNode->oidlen < oidlen) {
+					        for (i = smiNode->oidlen;
+						     i < oidlen; i++) {
+						        ND_PRINT(".%u", oid[i]);
+						}
+					}
+					done++;
 				}
-				done++;
 			}
 		}
 		break;
@@ -1166,8 +1139,8 @@ smi_print_value(netdissect_options *ndo,
 			     nn = smiGetNextNamedNumber(nn)) {
 			         if (nn->value.value.integer32
 				     == elem->data.integer) {
-				         ND_PRINT((ndo, "%s", nn->name));
-					 ND_PRINT((ndo, "(%d)", elem->data.integer));
+				         ND_PRINT("%s", nn->name);
+					 ND_PRINT("(%d)", elem->data.integer);
 					 done++;
 					 break;
 				}
@@ -1224,7 +1197,7 @@ varbind_print(netdissect_options *ndo,
               u_short pduid, const u_char *np, u_int length)
 {
 	struct be elem;
-	int count = 0, ind;
+	int count = 0;
 #ifdef USE_LIBSMI
 	SmiNode *smiNode = NULL;
 #endif
@@ -1234,27 +1207,27 @@ varbind_print(netdissect_options *ndo,
 	if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
 		return;
 	if (elem.type != BE_SEQ) {
-		ND_PRINT((ndo, "[!SEQ of varbind]"));
+		ND_PRINT("[!SEQ of varbind]");
 		asn1_print(ndo, &elem);
 		return;
 	}
 	if ((u_int)count < length)
-		ND_PRINT((ndo, "[%d extra after SEQ of varbind]", length - count));
+		ND_PRINT("[%d extra after SEQ of varbind]", length - count);
 	/* descend */
 	length = elem.asnlen;
 	np = (const u_char *)elem.data.raw;
 
-	for (ind = 1; length > 0; ind++) {
+	while (length) {
 		const u_char *vbend;
 		u_int vblength;
 
-		ND_PRINT((ndo, " "));
+		ND_PRINT(" ");
 
 		/* Sequence */
 		if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
 			return;
 		if (elem.type != BE_SEQ) {
-			ND_PRINT((ndo, "[!varbind]"));
+			ND_PRINT("[!varbind]");
 			asn1_print(ndo, &elem);
 			return;
 		}
@@ -1268,7 +1241,7 @@ varbind_print(netdissect_options *ndo,
 		if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
 			return;
 		if (elem.type != BE_OID) {
-			ND_PRINT((ndo, "[objName!=OID]"));
+			ND_PRINT("[objName!=OID]");
 			asn1_print(ndo, &elem);
 			return;
 		}
@@ -1284,7 +1257,7 @@ varbind_print(netdissect_options *ndo,
 
 		if (pduid != GETREQ && pduid != GETNEXTREQ
 		    && pduid != GETBULKREQ)
-			ND_PRINT((ndo, "="));
+			ND_PRINT("=");
 
 		/* objVal (ANY) */
 		if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
@@ -1292,7 +1265,7 @@ varbind_print(netdissect_options *ndo,
 		if (pduid == GETREQ || pduid == GETNEXTREQ
 		    || pduid == GETBULKREQ) {
 			if (elem.type != BE_NULL) {
-				ND_PRINT((ndo, "[objVal!=NULL]"));
+				ND_PRINT("[objVal!=NULL]");
 				if (asn1_print(ndo, &elem) < 0)
 					return;
 			}
@@ -1327,12 +1300,12 @@ snmppdu_print(netdissect_options *ndo,
 	if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
 		return;
 	if (elem.type != BE_INT) {
-		ND_PRINT((ndo, "[reqId!=INT]"));
+		ND_PRINT("[reqId!=INT]");
 		asn1_print(ndo, &elem);
 		return;
 	}
 	if (ndo->ndo_vflag)
-		ND_PRINT((ndo, "R=%d ", elem.data.integer));
+		ND_PRINT("R=%d ", elem.data.integer);
 	length -= count;
 	np += count;
 
@@ -1340,7 +1313,7 @@ snmppdu_print(netdissect_options *ndo,
 	if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
 		return;
 	if (elem.type != BE_INT) {
-		ND_PRINT((ndo, "[errorStatus!=INT]"));
+		ND_PRINT("[errorStatus!=INT]");
 		asn1_print(ndo, &elem);
 		return;
 	}
@@ -1349,13 +1322,13 @@ snmppdu_print(netdissect_options *ndo,
 	    || pduid == INFORMREQ || pduid == V2TRAP || pduid == REPORT)
 	    && elem.data.integer != 0) {
 		char errbuf[20];
-		ND_PRINT((ndo, "[errorStatus(%s)!=0]",
-			DECODE_ErrorStatus(elem.data.integer)));
+		ND_PRINT("[errorStatus(%s)!=0]",
+			DECODE_ErrorStatus(elem.data.integer));
 	} else if (pduid == GETBULKREQ) {
-		ND_PRINT((ndo, " N=%d", elem.data.integer));
+		ND_PRINT(" N=%d", elem.data.integer);
 	} else if (elem.data.integer != 0) {
 		char errbuf[20];
-		ND_PRINT((ndo, " %s", DECODE_ErrorStatus(elem.data.integer)));
+		ND_PRINT(" %s", DECODE_ErrorStatus(elem.data.integer));
 		error_status = elem.data.integer;
 	}
 	length -= count;
@@ -1365,29 +1338,28 @@ snmppdu_print(netdissect_options *ndo,
 	if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
 		return;
 	if (elem.type != BE_INT) {
-		ND_PRINT((ndo, "[errorIndex!=INT]"));
+		ND_PRINT("[errorIndex!=INT]");
 		asn1_print(ndo, &elem);
 		return;
 	}
 	if ((pduid == GETREQ || pduid == GETNEXTREQ || pduid == SETREQ
 	    || pduid == INFORMREQ || pduid == V2TRAP || pduid == REPORT)
 	    && elem.data.integer != 0)
-		ND_PRINT((ndo, "[errorIndex(%d)!=0]", elem.data.integer));
+		ND_PRINT("[errorIndex(%d)!=0]", elem.data.integer);
 	else if (pduid == GETBULKREQ)
-		ND_PRINT((ndo, " M=%d", elem.data.integer));
+		ND_PRINT(" M=%d", elem.data.integer);
 	else if (elem.data.integer != 0) {
 		if (!error_status)
-			ND_PRINT((ndo, "[errorIndex(%d) w/o errorStatus]", elem.data.integer));
+			ND_PRINT("[errorIndex(%d) w/o errorStatus]", elem.data.integer);
 		else
-			ND_PRINT((ndo, "@%d", elem.data.integer));
+			ND_PRINT("@%d", elem.data.integer);
 	} else if (error_status) {
-		ND_PRINT((ndo, "[errorIndex==0]"));
+		ND_PRINT("[errorIndex==0]");
 	}
 	length -= count;
 	np += count;
 
 	varbind_print(ndo, pduid, np, length);
-	return;
 }
 
 /*
@@ -1400,13 +1372,13 @@ trappdu_print(netdissect_options *ndo,
 	struct be elem;
 	int count = 0, generic;
 
-	ND_PRINT((ndo, " "));
+	ND_PRINT(" ");
 
 	/* enterprise (oid) */
 	if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
 		return;
 	if (elem.type != BE_OID) {
-		ND_PRINT((ndo, "[enterprise!=OID]"));
+		ND_PRINT("[enterprise!=OID]");
 		asn1_print(ndo, &elem);
 		return;
 	}
@@ -1415,13 +1387,13 @@ trappdu_print(netdissect_options *ndo,
 	length -= count;
 	np += count;
 
-	ND_PRINT((ndo, " "));
+	ND_PRINT(" ");
 
 	/* agent-addr (inetaddr) */
 	if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
 		return;
 	if (elem.type != BE_INETADDR) {
-		ND_PRINT((ndo, "[agent-addr!=INETADDR]"));
+		ND_PRINT("[agent-addr!=INETADDR]");
 		asn1_print(ndo, &elem);
 		return;
 	}
@@ -1434,14 +1406,14 @@ trappdu_print(netdissect_options *ndo,
 	if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
 		return;
 	if (elem.type != BE_INT) {
-		ND_PRINT((ndo, "[generic-trap!=INT]"));
+		ND_PRINT("[generic-trap!=INT]");
 		asn1_print(ndo, &elem);
 		return;
 	}
 	generic = elem.data.integer;
 	{
 		char buf[20];
-		ND_PRINT((ndo, " %s", DECODE_GenericTrap(generic)));
+		ND_PRINT(" %s", DECODE_GenericTrap(generic));
 	}
 	length -= count;
 	np += count;
@@ -1450,25 +1422,25 @@ trappdu_print(netdissect_options *ndo,
 	if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
 		return;
 	if (elem.type != BE_INT) {
-		ND_PRINT((ndo, "[specific-trap!=INT]"));
+		ND_PRINT("[specific-trap!=INT]");
 		asn1_print(ndo, &elem);
 		return;
 	}
 	if (generic != GT_ENTERPRISE) {
 		if (elem.data.integer != 0)
-			ND_PRINT((ndo, "[specific-trap(%d)!=0]", elem.data.integer));
+			ND_PRINT("[specific-trap(%d)!=0]", elem.data.integer);
 	} else
-		ND_PRINT((ndo, " s=%d", elem.data.integer));
+		ND_PRINT(" s=%d", elem.data.integer);
 	length -= count;
 	np += count;
 
-	ND_PRINT((ndo, " "));
+	ND_PRINT(" ");
 
 	/* time-stamp (TimeTicks) */
 	if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
 		return;
 	if (elem.type != BE_UNS) {			/* XXX */
-		ND_PRINT((ndo, "[time-stamp!=TIMETICKS]"));
+		ND_PRINT("[time-stamp!=TIMETICKS]");
 		asn1_print(ndo, &elem);
 		return;
 	}
@@ -1478,7 +1450,6 @@ trappdu_print(netdissect_options *ndo,
 	np += count;
 
 	varbind_print(ndo, TRAP, np, length);
-	return;
 }
 
 /*
@@ -1495,17 +1466,17 @@ pdu_print(netdissect_options *ndo,
 	if ((count = asn1_parse(ndo, np, length, &pdu)) < 0)
 		return;
 	if (pdu.type != BE_PDU) {
-		ND_PRINT((ndo, "[no PDU]"));
+		ND_PRINT("[no PDU]");
 		return;
 	}
 	if ((u_int)count < length)
-		ND_PRINT((ndo, "[%d extra after PDU]", length - count));
+		ND_PRINT("[%d extra after PDU]", length - count);
 	if (ndo->ndo_vflag) {
-		ND_PRINT((ndo, "{ "));
+		ND_PRINT("{ ");
 	}
 	if (asn1_print(ndo, &pdu) < 0)
 		return;
-	ND_PRINT((ndo, " "));
+	ND_PRINT(" ");
 	/* descend into PDU */
 	length = pdu.asnlen;
 	np = (const u_char *)pdu.data.raw;
@@ -1513,12 +1484,12 @@ pdu_print(netdissect_options *ndo,
 	if (version == SNMP_VERSION_1 &&
 	    (pdu.id == GETBULKREQ || pdu.id == INFORMREQ ||
 	     pdu.id == V2TRAP || pdu.id == REPORT)) {
-	        ND_PRINT((ndo, "[v2 PDU in v1 message]"));
+	        ND_PRINT("[v2 PDU in v1 message]");
 		return;
 	}
 
 	if (version == SNMP_VERSION_2 && pdu.id == TRAP) {
-		ND_PRINT((ndo, "[v1 PDU in v2 message]"));
+		ND_PRINT("[v1 PDU in v2 message]");
 		return;
 	}
 
@@ -1539,7 +1510,7 @@ pdu_print(netdissect_options *ndo,
 	}
 
 	if (ndo->ndo_vflag) {
-		ND_PRINT((ndo, " } "));
+		ND_PRINT(" } ");
 	}
 }
 
@@ -1557,7 +1528,7 @@ scopedpdu_print(netdissect_options *ndo,
 	if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
 		return;
 	if (elem.type != BE_SEQ) {
-		ND_PRINT((ndo, "[!scoped PDU]"));
+		ND_PRINT("[!scoped PDU]");
 		asn1_print(ndo, &elem);
 		return;
 	}
@@ -1568,33 +1539,31 @@ scopedpdu_print(netdissect_options *ndo,
 	if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
 		return;
 	if (elem.type != BE_STR) {
-		ND_PRINT((ndo, "[contextEngineID!=STR]"));
+		ND_PRINT("[contextEngineID!=STR]");
 		asn1_print(ndo, &elem);
 		return;
 	}
 	length -= count;
 	np += count;
 
-	ND_PRINT((ndo, "E="));
-	if (asn1_print_octets(ndo, &elem) == -1)
-		return;
-	ND_PRINT((ndo, " "));
+	ND_PRINT("E=");
+	asn1_print_octets(ndo, &elem);
+	ND_PRINT(" ");
 
 	/* contextName (OCTET STRING) */
 	if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
 		return;
 	if (elem.type != BE_STR) {
-		ND_PRINT((ndo, "[contextName!=STR]"));
+		ND_PRINT("[contextName!=STR]");
 		asn1_print(ndo, &elem);
 		return;
 	}
 	length -= count;
 	np += count;
 
-	ND_PRINT((ndo, "C="));
-	if (asn1_print_string(ndo, &elem) == -1)
-		return;
-	ND_PRINT((ndo, " "));
+	ND_PRINT("C=");
+	asn1_print_string(ndo, &elem);
+	ND_PRINT(" ");
 
 	pdu_print(ndo, np, length, version);
 }
@@ -1613,7 +1582,7 @@ community_print(netdissect_options *ndo,
 	if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
 		return;
 	if (elem.type != BE_STR) {
-		ND_PRINT((ndo, "[comm!=STR]"));
+		ND_PRINT("[comm!=STR]");
 		asn1_print(ndo, &elem);
 		return;
 	}
@@ -1622,10 +1591,9 @@ community_print(netdissect_options *ndo,
 	    strncmp((const char *)elem.data.str, DEF_COMMUNITY,
 	            sizeof(DEF_COMMUNITY) - 1) == 0)) {
 		/* ! "public" */
-		ND_PRINT((ndo, "C="));
-		if (asn1_print_string(ndo, &elem) == -1)
-			return;
-		ND_PRINT((ndo, " "));
+		ND_PRINT("C=");
+		asn1_print_string(ndo, &elem);
+		ND_PRINT(" ");
 	}
 	length -= count;
 	np += count;
@@ -1647,7 +1615,7 @@ usm_print(netdissect_options *ndo,
 	if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
 		return;
 	if (elem.type != BE_SEQ) {
-		ND_PRINT((ndo, "[!usm]"));
+		ND_PRINT("[!usm]");
 		asn1_print(ndo, &elem);
 		return;
 	}
@@ -1658,7 +1626,7 @@ usm_print(netdissect_options *ndo,
 	if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
 		return;
 	if (elem.type != BE_STR) {
-		ND_PRINT((ndo, "[msgAuthoritativeEngineID!=STR]"));
+		ND_PRINT("[msgAuthoritativeEngineID!=STR]");
 		asn1_print(ndo, &elem);
 		return;
 	}
@@ -1669,12 +1637,12 @@ usm_print(netdissect_options *ndo,
 	if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
 		return;
 	if (elem.type != BE_INT) {
-		ND_PRINT((ndo, "[msgAuthoritativeEngineBoots!=INT]"));
+		ND_PRINT("[msgAuthoritativeEngineBoots!=INT]");
 		asn1_print(ndo, &elem);
 		return;
 	}
 	if (ndo->ndo_vflag)
-		ND_PRINT((ndo, "B=%d ", elem.data.integer));
+		ND_PRINT("B=%d ", elem.data.integer);
 	length -= count;
 	np += count;
 
@@ -1682,12 +1650,12 @@ usm_print(netdissect_options *ndo,
 	if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
 		return;
 	if (elem.type != BE_INT) {
-		ND_PRINT((ndo, "[msgAuthoritativeEngineTime!=INT]"));
+		ND_PRINT("[msgAuthoritativeEngineTime!=INT]");
 		asn1_print(ndo, &elem);
 		return;
 	}
 	if (ndo->ndo_vflag)
-		ND_PRINT((ndo, "T=%d ", elem.data.integer));
+		ND_PRINT("T=%d ", elem.data.integer);
 	length -= count;
 	np += count;
 
@@ -1695,23 +1663,22 @@ usm_print(netdissect_options *ndo,
 	if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
 		return;
 	if (elem.type != BE_STR) {
-		ND_PRINT((ndo, "[msgUserName!=STR]"));
+		ND_PRINT("[msgUserName!=STR]");
 		asn1_print(ndo, &elem);
 		return;
 	}
 	length -= count;
         np += count;
 
-	ND_PRINT((ndo, "U="));
-	if (asn1_print_string(ndo, &elem) == -1)
-		return;
-	ND_PRINT((ndo, " "));
+	ND_PRINT("U=");
+	asn1_print_string(ndo, &elem);
+	ND_PRINT(" ");
 
 	/* msgAuthenticationParameters (OCTET STRING) */
 	if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
 		return;
 	if (elem.type != BE_STR) {
-		ND_PRINT((ndo, "[msgAuthenticationParameters!=STR]"));
+		ND_PRINT("[msgAuthenticationParameters!=STR]");
 		asn1_print(ndo, &elem);
 		return;
 	}
@@ -1722,7 +1689,7 @@ usm_print(netdissect_options *ndo,
 	if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
 		return;
 	if (elem.type != BE_STR) {
-		ND_PRINT((ndo, "[msgPrivacyParameters!=STR]"));
+		ND_PRINT("[msgPrivacyParameters!=STR]");
 		asn1_print(ndo, &elem);
 		return;
 	}
@@ -1730,7 +1697,7 @@ usm_print(netdissect_options *ndo,
         np += count;
 
 	if ((u_int)count < length)
-		ND_PRINT((ndo, "[%d extra after usm SEQ]", length - count));
+		ND_PRINT("[%d extra after usm SEQ]", length - count);
 }
 
 /*
@@ -1751,7 +1718,7 @@ v3msg_print(netdissect_options *ndo,
 	if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
 		return;
 	if (elem.type != BE_SEQ) {
-		ND_PRINT((ndo, "[!message]"));
+		ND_PRINT("[!message]");
 		asn1_print(ndo, &elem);
 		return;
 	}
@@ -1759,14 +1726,14 @@ v3msg_print(netdissect_options *ndo,
 	np = (const u_char *)elem.data.raw;
 
 	if (ndo->ndo_vflag) {
-		ND_PRINT((ndo, "{ "));
+		ND_PRINT("{ ");
 	}
 
 	/* msgID (INTEGER) */
 	if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
 		return;
 	if (elem.type != BE_INT) {
-		ND_PRINT((ndo, "[msgID!=INT]"));
+		ND_PRINT("[msgID!=INT]");
 		asn1_print(ndo, &elem);
 		return;
 	}
@@ -1777,7 +1744,7 @@ v3msg_print(netdissect_options *ndo,
 	if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
 		return;
 	if (elem.type != BE_INT) {
-		ND_PRINT((ndo, "[msgMaxSize!=INT]"));
+		ND_PRINT("[msgMaxSize!=INT]");
 		asn1_print(ndo, &elem);
 		return;
 	}
@@ -1788,33 +1755,33 @@ v3msg_print(netdissect_options *ndo,
 	if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
 		return;
 	if (elem.type != BE_STR) {
-		ND_PRINT((ndo, "[msgFlags!=STR]"));
+		ND_PRINT("[msgFlags!=STR]");
 		asn1_print(ndo, &elem);
 		return;
 	}
 	if (elem.asnlen != 1) {
-		ND_PRINT((ndo, "[msgFlags size %d]", elem.asnlen));
+		ND_PRINT("[msgFlags size %d]", elem.asnlen);
 		return;
 	}
-	flags = elem.data.str[0];
+	flags = GET_U_1(elem.data.str);
 	if (flags != 0x00 && flags != 0x01 && flags != 0x03
 	    && flags != 0x04 && flags != 0x05 && flags != 0x07) {
-		ND_PRINT((ndo, "[msgFlags=0x%02X]", flags));
+		ND_PRINT("[msgFlags=0x%02X]", flags);
 		return;
 	}
 	length -= count;
 	np += count;
 
-	ND_PRINT((ndo, "F=%s%s%s ",
+	ND_PRINT("F=%s%s%s ",
 	          flags & 0x01 ? "a" : "",
 	          flags & 0x02 ? "p" : "",
-	          flags & 0x04 ? "r" : ""));
+	          flags & 0x04 ? "r" : "");
 
 	/* msgSecurityModel (INTEGER) */
 	if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
 		return;
 	if (elem.type != BE_INT) {
-		ND_PRINT((ndo, "[msgSecurityModel!=INT]"));
+		ND_PRINT("[msgSecurityModel!=INT]");
 		asn1_print(ndo, &elem);
 		return;
 	}
@@ -1823,18 +1790,18 @@ v3msg_print(netdissect_options *ndo,
 	np += count;
 
 	if ((u_int)count < length)
-		ND_PRINT((ndo, "[%d extra after message SEQ]", length - count));
+		ND_PRINT("[%d extra after message SEQ]", length - count);
 
 	if (ndo->ndo_vflag) {
-		ND_PRINT((ndo, "} "));
+		ND_PRINT("} ");
 	}
 
 	if (model == 3) {
 	    if (ndo->ndo_vflag) {
-		ND_PRINT((ndo, "{ USM "));
+		ND_PRINT("{ USM ");
 	    }
 	} else {
-	    ND_PRINT((ndo, "[security model %d]", model));
+	    ND_PRINT("[security model %d]", model);
             return;
 	}
 
@@ -1845,7 +1812,7 @@ v3msg_print(netdissect_options *ndo,
 	if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
 		return;
 	if (elem.type != BE_STR) {
-		ND_PRINT((ndo, "[msgSecurityParameters!=STR]"));
+		ND_PRINT("[msgSecurityParameters!=STR]");
 		asn1_print(ndo, &elem);
 		return;
 	}
@@ -1855,18 +1822,18 @@ v3msg_print(netdissect_options *ndo,
 	if (model == 3) {
 	    usm_print(ndo, elem.data.str, elem.asnlen);
 	    if (ndo->ndo_vflag) {
-		ND_PRINT((ndo, "} "));
+		ND_PRINT("} ");
 	    }
 	}
 
 	if (ndo->ndo_vflag) {
-	    ND_PRINT((ndo, "{ ScopedPDU "));
+	    ND_PRINT("{ ScopedPDU ");
 	}
 
 	scopedpdu_print(ndo, np, length, 3);
 
 	if (ndo->ndo_vflag) {
-		ND_PRINT((ndo, "} "));
+		ND_PRINT("} ");
 	}
 }
 
@@ -1881,18 +1848,19 @@ snmp_print(netdissect_options *ndo,
 	int count = 0;
 	int version = 0;
 
-	ND_PRINT((ndo, " "));
+	ndo->ndo_protocol = "snmp";
+	ND_PRINT(" ");
 
 	/* initial Sequence */
 	if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
 		return;
 	if (elem.type != BE_SEQ) {
-		ND_PRINT((ndo, "[!init SEQ]"));
+		ND_PRINT("[!init SEQ]");
 		asn1_print(ndo, &elem);
 		return;
 	}
 	if ((u_int)count < length)
-		ND_PRINT((ndo, "[%d extra after iSEQ]", length - count));
+		ND_PRINT("[%d extra after iSEQ]", length - count);
 	/* descend */
 	length = elem.asnlen;
 	np = (const u_char *)elem.data.raw;
@@ -1901,7 +1869,7 @@ snmp_print(netdissect_options *ndo,
 	if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
 		return;
 	if (elem.type != BE_INT) {
-		ND_PRINT((ndo, "[version!=INT]"));
+		ND_PRINT("[version!=INT]");
 		asn1_print(ndo, &elem);
 		return;
 	}
@@ -1911,10 +1879,10 @@ snmp_print(netdissect_options *ndo,
 	case SNMP_VERSION_2:
 	case SNMP_VERSION_3:
 		if (ndo->ndo_vflag)
-			ND_PRINT((ndo, "{ %s ", SnmpVersion[elem.data.integer]));
+			ND_PRINT("{ %s ", SnmpVersion[elem.data.integer]);
 		break;
 	default:
-	        ND_PRINT((ndo, "SNMP [version = %d]", elem.data.integer));
+	        ND_PRINT("SNMP [version = %d]", elem.data.integer);
 		return;
 	}
 	version = elem.data.integer;
@@ -1930,11 +1898,11 @@ snmp_print(netdissect_options *ndo,
 		v3msg_print(ndo, np, length);
 		break;
 	default:
-		ND_PRINT((ndo, "[version = %d]", elem.data.integer));
+		ND_PRINT("[version = %d]", elem.data.integer);
 		break;
 	}
 
 	if (ndo->ndo_vflag) {
-		ND_PRINT((ndo, "} "));
+		ND_PRINT("} ");
 	}
 }