X-Git-Url: https://git.tcpdump.org/tcpdump/blobdiff_plain/bbc1cfa669a5f51ed26bae3784447076e3fbc80f..refs/pull/494/head:/print-snmp.c

diff --git a/print-snmp.c b/print-snmp.c
index d7c72d91..a2aa0742 100644
--- a/print-snmp.c
+++ b/print-snmp.c
@@ -56,32 +56,30 @@
  #	@(#)snmp.awk.x	1.1 (LANL) 1/15/90
  */
 
-#ifndef lint
-static const char rcsid[] _U_ =
-    "@(#) $Header: /tcpdump/master/tcpdump/print-snmp.c,v 1.58 2003-11-16 09:36:38 guy Exp $ (LBL)";
-#endif
-
 #ifdef HAVE_CONFIG_H
 #include "config.h"
 #endif
 
-#include <tcpdump-stdinc.h>
+#include <netdissect-stdinc.h>
 
 #include <stdio.h>
 #include <string.h>
 
-#ifdef HAVE_SMI_H
+#ifdef USE_LIBSMI
 #include <smi.h>
 #endif
 
-#include "interface.h"
-#include "addrtoname.h"
+#include "netdissect.h"
+
+#undef OPAQUE  /* defined in <wingdi.h> */
+
+static const char tstr[] = "[|snmp]";
 
 /*
  * Universal ASN.1 types
  * (we only care about the tag values for those allowed in the Internet SMI)
  */
-const char *Universal[] = {
+static const char *Universal[] = {
 	"U-0",
 	"Boolean",
 	"Integer",
@@ -104,7 +102,7 @@ const char *Universal[] = {
 /*
  * Application-wide ASN.1 types from the Internet SMI and their tags
  */
-const char *Application[] = {
+static const char *Application[] = {
 	"IpAddress",
 #define IPADDR 0
 	"Counter",
@@ -123,7 +121,7 @@ const char *Application[] = {
 /*
  * Context-specific ASN.1 types for the SNMP PDUs and their tags
  */
-const char *Context[] = {
+static const char *Context[] = {
 	"GetRequest",
 #define GETREQ 0
 	"GetNextRequest",
@@ -153,7 +151,7 @@ const char *Context[] = {
 /*
  * Context-specific ASN.1 types for the SNMP Exceptions and their tags
  */
-const char *Exceptions[] = {
+static const char *Exceptions[] = {
 	"noSuchObject",
 #define NOSUCHOBJECT 0
 	"noSuchInstance",
@@ -166,14 +164,14 @@ const char *Exceptions[] = {
  * Private ASN.1 types
  * The Internet SMI does not specify any
  */
-const char *Private[] = {
+static const char *Private[] = {
 	"P-0"
 };
 
 /*
  * error-status values for any SNMP PDU
  */
-const char *ErrorStatus[] = {
+static const char *ErrorStatus[] = {
 	"noError",
 	"tooBig",
 	"noSuchName",
@@ -202,7 +200,7 @@ const char *ErrorStatus[] = {
 /*
  * generic-trap values in the SNMP Trap-PDU
  */
-const char *GenericTrap[] = {
+static const char *GenericTrap[] = {
 	"coldStart",
 	"warmStart",
 	"linkDown",
@@ -210,7 +208,7 @@ const char *GenericTrap[] = {
 	"authenticationFailure",
 	"egpNeighborLoss",
 	"enterpriseSpecific"
-#define GT_ENTERPRISE 7
+#define GT_ENTERPRISE 6
 };
 #define DECODE_GenericTrap(t) \
 	( t >= 0 && (size_t)t < sizeof(GenericTrap)/sizeof(GenericTrap[0]) \
@@ -223,7 +221,7 @@ const char *GenericTrap[] = {
  * type definitions.
  */
 #define defineCLASS(x) { "x", x, sizeof(x)/sizeof(x[0]) } /* not ANSI-C */
-struct {
+static const struct {
 	const char	*name;
 	const char	**Id;
 	    int	numIDs;
@@ -243,7 +241,7 @@ struct {
 /*
  * defined forms for ASN.1 types
  */
-const char *Form[] = {
+static const char *Form[] = {
 	"Primitive",
 #define PRIMITIVE	0
 	"Constructed",
@@ -276,7 +274,7 @@ struct obj {
  * Currently, this includes the prefixes for the Internet MIB, the
  * private enterprises tree, and the experimental tree.
  */
-struct obj_abrev {
+static const struct obj_abrev {
 	const char *prefix;		/* prefix for this abrev */
 	struct obj *node;		/* pointer into object table */
 	const char *oid;		/* ASN.1 encoded OID */
@@ -313,10 +311,10 @@ struct obj_abrev {
 		} while ((objp = objp->next) != NULL); \
 	} \
 	if (objp) { \
-		printf(suppressdot?"%s":".%s", objp->desc); \
+		ND_PRINT((ndo, suppressdot?"%s":".%s", objp->desc)); \
 		objp = objp->child; \
 	} else \
-		printf(suppressdot?"%u":".%u", (o)); \
+		ND_PRINT((ndo, suppressdot?"%u":".%u", (o))); \
 }
 
 /*
@@ -324,15 +322,15 @@ struct obj_abrev {
  * temporary internal representation while decoding an ASN.1 data stream.
  */
 struct be {
-	u_int32_t asnlen;
+	uint32_t asnlen;
 	union {
-		caddr_t raw;
+		const uint8_t *raw;
 		int32_t integer;
-		u_int32_t uns;
+		uint32_t uns;
 		const u_char *str;
 	        struct {
-		        u_int32_t high;
-		        u_int32_t low;
+		        uint32_t high;
+		        uint32_t low;
 		} uns64;
 	} data;
 	u_short id;
@@ -358,7 +356,7 @@ struct be {
 /*
  * SNMP versions recognized by this module
  */
-const char *SnmpVersion[] = {
+static const char *SnmpVersion[] = {
 	"SNMPv1",
 #define SNMP_VERSION_1	0
 	"SNMPv2c",
@@ -392,13 +390,6 @@ const char *SnmpVersion[] = {
 
 #define ASN_ID_EXT 0x1f		/* extension ID in tag field */
 
-/*
- * truncated==1 means the packet was complete, but we don't have all of
- * it to decode.
- */
-static int truncated;
-#define ifNotTruncated if (truncated) fputs("[|snmp]", stdout); else
-
 /*
  * This decodes the next ASN.1 object in the stream pointed to by "p"
  * (and of real-length "len") and stores the intermediate data in the
@@ -408,7 +399,8 @@ static int truncated;
  * O/w, this returns the number of bytes parsed from "p".
  */
 static int
-asn1_parse(register const u_char *p, u_int len, struct be *elem)
+asn1_parse(netdissect_options *ndo,
+           register const u_char *p, u_int len, struct be *elem)
 {
 	u_char form, class, id;
 	int i, hdr;
@@ -416,9 +408,10 @@ asn1_parse(register const u_char *p, u_int len, struct be *elem)
 	elem->asnlen = 0;
 	elem->type = BE_ANY;
 	if (len < 1) {
-		ifNotTruncated fputs("[nothing to parse]", stdout);
+		ND_PRINT((ndo, "[nothing to parse]"));
 		return -1;
 	}
+	ND_TCHECK(*p);
 
 	/*
 	 * it would be nice to use a bit field, but you can't depend on them.
@@ -442,52 +435,66 @@ asn1_parse(register const u_char *p, u_int len, struct be *elem)
 	p++; len--; hdr = 1;
 	/* extended tag field */
 	if (id == ASN_ID_EXT) {
-		for (id = 0; *p & ASN_BIT8 && len > 0; len--, hdr++, p++)
+		/*
+		 * The ID follows, as a sequence of octets with the
+		 * 8th bit set and the remaining 7 bits being
+		 * the next 7 bits of the value, terminated with
+		 * an octet with the 8th bit not set.
+		 *
+		 * First, assemble all the octets with the 8th
+		 * bit set.  XXX - this doesn't handle a value
+		 * that won't fit in 32 bits.
+		 */
+		for (id = 0; *p & ASN_BIT8; len--, hdr++, p++) {
+			if (len < 1) {
+				ND_PRINT((ndo, "[Xtagfield?]"));
+				return -1;
+			}
+			ND_TCHECK(*p);
 			id = (id << 7) | (*p & ~ASN_BIT8);
-		if (len == 0 && *p & ASN_BIT8) {
-			ifNotTruncated fputs("[Xtagfield?]", stdout);
+		}
+		if (len < 1) {
+			ND_PRINT((ndo, "[Xtagfield?]"));
 			return -1;
 		}
+		ND_TCHECK(*p);
 		elem->id = id = (id << 7) | *p;
 		--len;
 		++hdr;
 		++p;
 	}
 	if (len < 1) {
-		ifNotTruncated fputs("[no asnlen]", stdout);
+		ND_PRINT((ndo, "[no asnlen]"));
 		return -1;
 	}
+	ND_TCHECK(*p);
 	elem->asnlen = *p;
 	p++; len--; hdr++;
 	if (elem->asnlen & ASN_BIT8) {
-		u_int32_t noct = elem->asnlen % ASN_BIT8;
+		uint32_t noct = elem->asnlen % ASN_BIT8;
 		elem->asnlen = 0;
 		if (len < noct) {
-			ifNotTruncated printf("[asnlen? %d<%d]", len, noct);
+			ND_PRINT((ndo, "[asnlen? %d<%d]", len, noct));
 			return -1;
 		}
+		ND_TCHECK2(*p, noct);
 		for (; noct-- > 0; len--, hdr++)
 			elem->asnlen = (elem->asnlen << ASN_SHIFT8) | *p++;
 	}
 	if (len < elem->asnlen) {
-		if (!truncated) {
-			printf("[len%d<asnlen%u]", len, elem->asnlen);
-			return -1;
-		}
-		/* maybe should check at least 4? */
-		elem->asnlen = len;
+		ND_PRINT((ndo, "[len%d<asnlen%u]", len, elem->asnlen));
+		return -1;
 	}
 	if (form >= sizeof(Form)/sizeof(Form[0])) {
-		ifNotTruncated printf("[form?%d]", form);
+		ND_PRINT((ndo, "[form?%d]", form));
 		return -1;
 	}
 	if (class >= sizeof(Class)/sizeof(Class[0])) {
-		ifNotTruncated printf("[class?%c/%d]", *Form[form], class);
+		ND_PRINT((ndo, "[class?%c/%d]", *Form[form], class));
 		return -1;
 	}
 	if ((int)id >= Class[class].numIDs) {
-		ifNotTruncated printf("[id?%c/%s/%d]", *Form[form],
-			Class[class].name, id);
+		ND_PRINT((ndo, "[id?%c/%s/%d]", *Form[form], Class[class].name, id));
 		return -1;
 	}
 
@@ -506,6 +513,7 @@ asn1_parse(register const u_char *p, u_int len, struct be *elem)
 				elem->type = BE_INT;
 				data = 0;
 
+				ND_TCHECK2(*p, elem->asnlen);
 				if (*p & ASN_BIT8)	/* negative */
 					data = -1;
 				for (i = elem->asnlen; i-- > 0; p++)
@@ -516,7 +524,7 @@ asn1_parse(register const u_char *p, u_int len, struct be *elem)
 
 			case OBJECTID:
 				elem->type = BE_OID;
-				elem->data.raw = (caddr_t)p;
+				elem->data.raw = (const uint8_t *)p;
 				break;
 
 			case ASN_NULL:
@@ -526,9 +534,8 @@ asn1_parse(register const u_char *p, u_int len, struct be *elem)
 
 			default:
 				elem->type = BE_OCTET;
-				elem->data.raw = (caddr_t)p;
-				printf("[P/U/%s]",
-					Class[class].Id[id]);
+				elem->data.raw = (const uint8_t *)p;
+				ND_PRINT((ndo, "[P/U/%s]", Class[class].Id[id]));
 				break;
 			}
 			break;
@@ -537,13 +544,14 @@ asn1_parse(register const u_char *p, u_int len, struct be *elem)
 			switch (id) {
 			case IPADDR:
 				elem->type = BE_INETADDR;
-				elem->data.raw = (caddr_t)p;
+				elem->data.raw = (const uint8_t *)p;
 				break;
 
 			case COUNTER:
 			case GAUGE:
 			case TIMETICKS: {
-				register u_int32_t data;
+				register uint32_t data;
+				ND_TCHECK2(*p, elem->asnlen);
 				elem->type = BE_UNS;
 				data = 0;
 				for (i = elem->asnlen; i-- > 0; p++)
@@ -553,7 +561,8 @@ asn1_parse(register const u_char *p, u_int len, struct be *elem)
 			}
 
 			case COUNTER64: {
-				register u_int32_t high, low;
+				register uint32_t high, low;
+				ND_TCHECK2(*p, elem->asnlen);
 			        elem->type = BE_UNS64;
 				high = 0, low = 0;
 				for (i = elem->asnlen; i-- > 0; p++) {
@@ -568,9 +577,9 @@ asn1_parse(register const u_char *p, u_int len, struct be *elem)
 
 			default:
 				elem->type = BE_OCTET;
-				elem->data.raw = (caddr_t)p;
-				printf("[P/A/%s]",
-					Class[class].Id[id]);
+				elem->data.raw = (const uint8_t *)p;
+				ND_PRINT((ndo, "[P/A/%s]",
+					Class[class].Id[id]));
 				break;
 			}
 			break;
@@ -595,10 +604,10 @@ asn1_parse(register const u_char *p, u_int len, struct be *elem)
 			break;
 
 		default:
+			ND_PRINT((ndo, "[P/%s/%s]", Class[class].name, Class[class].Id[id]));
+			ND_TCHECK2(*p, elem->asnlen);
 			elem->type = BE_OCTET;
-			elem->data.raw = (caddr_t)p;
-			printf("[P/%s/%s]",
-				Class[class].name, Class[class].Id[id]);
+			elem->data.raw = (const uint8_t *)p;
 			break;
 		}
 		break;
@@ -609,27 +618,26 @@ asn1_parse(register const u_char *p, u_int len, struct be *elem)
 			switch (id) {
 			case SEQUENCE:
 				elem->type = BE_SEQ;
-				elem->data.raw = (caddr_t)p;
+				elem->data.raw = (const uint8_t *)p;
 				break;
 
 			default:
 				elem->type = BE_OCTET;
-				elem->data.raw = (caddr_t)p;
-				printf("C/U/%s", Class[class].Id[id]);
+				elem->data.raw = (const uint8_t *)p;
+				ND_PRINT((ndo, "C/U/%s", Class[class].Id[id]));
 				break;
 			}
 			break;
 
 		case CONTEXT:
 			elem->type = BE_PDU;
-			elem->data.raw = (caddr_t)p;
+			elem->data.raw = (const uint8_t *)p;
 			break;
 
 		default:
 			elem->type = BE_OCTET;
-			elem->data.raw = (caddr_t)p;
-			printf("C/%s/%s",
-				Class[class].name, Class[class].Id[id]);
+			elem->data.raw = (const uint8_t *)p;
+			ND_PRINT((ndo, "C/%s/%s", Class[class].name, Class[class].Id[id]));
 			break;
 		}
 		break;
@@ -637,6 +645,10 @@ asn1_parse(register const u_char *p, u_int len, struct be *elem)
 	p += elem->asnlen;
 	len -= elem->asnlen;
 	return elem->asnlen + hdr;
+
+trunc:
+	ND_PRINT((ndo, "%s", tstr));
+	return -1;
 }
 
 /*
@@ -644,42 +656,47 @@ asn1_parse(register const u_char *p, u_int len, struct be *elem)
  * This used to be an integral part of asn1_parse() before the intermediate
  * BE form was added.
  */
-static void
-asn1_print(struct be *elem)
+static int
+asn1_print(netdissect_options *ndo,
+           struct be *elem)
 {
-	u_char *p = (u_char *)elem->data.raw;
-	u_int32_t asnlen = elem->asnlen;
-	u_int32_t i;
+	const u_char *p = (const u_char *)elem->data.raw;
+	uint32_t asnlen = elem->asnlen;
+	uint32_t i;
 
 	switch (elem->type) {
 
 	case BE_OCTET:
+		ND_TCHECK2(*p, asnlen);
 		for (i = asnlen; i-- > 0; p++)
-			printf("_%.2x", *p);
+			ND_PRINT((ndo, "_%.2x", *p));
 		break;
 
 	case BE_NULL:
 		break;
 
 	case BE_OID: {
-	int o = 0, first = -1, i = asnlen;
+		int o = 0, first = -1;
 
-		if (!sflag && !nflag && asnlen > 2) {
-			struct obj_abrev *a = &obj_abrev_list[0];
+		i = asnlen;
+		if (!ndo->ndo_mflag && !ndo->ndo_nflag && asnlen > 2) {
+			const struct obj_abrev *a = &obj_abrev_list[0];
+			size_t a_len = strlen(a->oid);
 			for (; a->node; a++) {
-				if (!memcmp(a->oid, (char *)p,
-				    strlen(a->oid))) {
+				ND_TCHECK2(*p, a_len);
+				if (memcmp(a->oid, p, a_len) == 0) {
 					objp = a->node->child;
 					i -= strlen(a->oid);
 					p += strlen(a->oid);
-					fputs(a->prefix, stdout);
+					ND_PRINT((ndo, "%s", a->prefix));
 					first = 1;
 					break;
 				}
 			}
 		}
 
-		for (; !sflag && i-- > 0; p++) {
+		for (; !ndo->ndo_mflag && i-- > 0; p++) {
+			ND_TCHECK(*p);
 			o = (o << ASN_SHIFT7) + (*p & ~ASN_BIT8);
 			if (*p & ASN_LONGLEN)
 			        continue;
@@ -690,7 +707,7 @@ asn1_print(struct be *elem)
 			 */
 			if (first < 0) {
 			        int s;
-				if (!nflag)
+				if (!ndo->ndo_nflag)
 					objp = mibroot;
 				first = 0;
 				s = o / OIDMUX;
@@ -707,11 +724,11 @@ asn1_print(struct be *elem)
 	}
 
 	case BE_INT:
-		printf("%d", elem->data.integer);
+		ND_PRINT((ndo, "%d", elem->data.integer));
 		break;
 
 	case BE_UNS:
-		printf("%u", elem->data.uns);
+		ND_PRINT((ndo, "%u", elem->data.uns));
 		break;
 
 	case BE_UNS64: {	/* idea borrowed from by Marshall Rose */
@@ -719,16 +736,16 @@ asn1_print(struct be *elem)
 		int j, carry;
 		char *cpf, *cpl, last[6], first[30];
 		if (elem->data.uns64.high == 0) {
-		        printf("%u", elem->data.uns64.low);
-		        break;
+			ND_PRINT((ndo, "%u", elem->data.uns64.low));
+			break;
 		}
 		d = elem->data.uns64.high * 4294967296.0;	/* 2^32 */
 		if (elem->data.uns64.high <= 0x1fffff) {
 		        d += elem->data.uns64.low;
 #if 0 /*is looks illegal, but what is the intention?*/
-			printf("%.f", d);
+			ND_PRINT((ndo, "%.f", d));
 #else
-			printf("%f", d);
+			ND_PRINT((ndo, "%f", d));
 #endif
 			break;
 		}
@@ -752,59 +769,69 @@ asn1_print(struct be *elem)
 		        }
 			*cpf = j + '0';
 		}
-		fputs(first, stdout);
+		ND_PRINT((ndo, "%s", first));
 		break;
 	}
 
 	case BE_STR: {
 		register int printable = 1, first = 1;
-		const u_char *p = elem->data.str;
+
+		p = elem->data.str;
+		ND_TCHECK2(*p, asnlen);
 		for (i = asnlen; printable && i-- > 0; p++)
-			printable = isprint(*p) || isspace(*p);
+			printable = ND_ISPRINT(*p);
 		p = elem->data.str;
 		if (printable) {
-			putchar('"');
-			(void)fn_print(p, p + asnlen);
-			putchar('"');
+			ND_PRINT((ndo, "\""));
+			if (fn_printn(ndo, p, asnlen, ndo->ndo_snapend)) {
+				ND_PRINT((ndo, "\""));
+				goto trunc;
+			}
+			ND_PRINT((ndo, "\""));
 		} else
 			for (i = asnlen; i-- > 0; p++) {
-				printf(first ? "%.2x" : "_%.2x", *p);
+				ND_PRINT((ndo, first ? "%.2x" : "_%.2x", *p));
 				first = 0;
 			}
 		break;
 	}
 
 	case BE_SEQ:
-		printf("Seq(%u)", elem->asnlen);
+		ND_PRINT((ndo, "Seq(%u)", elem->asnlen));
 		break;
 
 	case BE_INETADDR:
 		if (asnlen != ASNLEN_INETADDR)
-			printf("[inetaddr len!=%d]", ASNLEN_INETADDR);
+			ND_PRINT((ndo, "[inetaddr len!=%d]", ASNLEN_INETADDR));
+		ND_TCHECK2(*p, asnlen);
 		for (i = asnlen; i-- != 0; p++) {
-			printf((i == asnlen-1) ? "%u" : ".%u", *p);
+			ND_PRINT((ndo, (i == asnlen-1) ? "%u" : ".%u", *p));
 		}
 		break;
 
 	case BE_NOSUCHOBJECT:
 	case BE_NOSUCHINST:
 	case BE_ENDOFMIBVIEW:
-	        printf("[%s]", Class[EXCEPTIONS].Id[elem->id]);
+		ND_PRINT((ndo, "[%s]", Class[EXCEPTIONS].Id[elem->id]));
 		break;
 
 	case BE_PDU:
-		printf("%s(%u)",
-			Class[CONTEXT].Id[elem->id], elem->asnlen);
+		ND_PRINT((ndo, "%s(%u)", Class[CONTEXT].Id[elem->id], elem->asnlen));
 		break;
 
 	case BE_ANY:
-		fputs("[BE_ANY!?]", stdout);
+		ND_PRINT((ndo, "[BE_ANY!?]"));
 		break;
 
 	default:
-		fputs("[be!?]", stdout);
+		ND_PRINT((ndo, "[be!?]"));
 		break;
 	}
+	return 0;
+
+trunc:
+	ND_PRINT((ndo, "%s", tstr));
+	return -1;
 }
 
 #ifdef notdef
@@ -824,14 +851,15 @@ asn1_decode(u_char *p, u_int length)
 	int i = 0;
 
 	while (i >= 0 && length > 0) {
-		i = asn1_parse(p, length, &elem);
+		i = asn1_parse(ndo, p, length, &elem);
 		if (i >= 0) {
-			fputs(" ", stdout);
-			asn1_print(&elem);
+			ND_PRINT((ndo, " "));
+			if (asn1_print(ndo, &elem) < 0)
+				return;
 			if (elem.type == BE_SEQ || elem.type == BE_PDU) {
-				fputs(" {", stdout);
+				ND_PRINT((ndo, " {"));
 				asn1_decode(elem.data.raw, elem.asnlen);
-				fputs(" }", stdout);
+				ND_PRINT((ndo, " }"));
 			}
 			length -= i;
 			p += i;
@@ -840,14 +868,14 @@ asn1_decode(u_char *p, u_int length)
 }
 #endif
 
-#ifdef LIBSMI
+#ifdef USE_LIBSMI
 
 struct smi2be {
     SmiBasetype basetype;
     int be;
 };
 
-static struct smi2be smi2betab[] = {
+static const struct smi2be smi2betab[] = {
     { SMI_BASETYPE_INTEGER32,		BE_INT },
     { SMI_BASETYPE_OCTETSTRING,		BE_STR },
     { SMI_BASETYPE_OCTETSTRING,		BE_INETADDR },
@@ -863,14 +891,18 @@ static struct smi2be smi2betab[] = {
     { SMI_BASETYPE_UNKNOWN,		BE_NONE }
 };
 
-static void smi_decode_oid(struct be *elem, unsigned int *oid,
-			   unsigned int oidsize, unsigned int *oidlen)
+static int
+smi_decode_oid(netdissect_options *ndo,
+               struct be *elem, unsigned int *oid,
+               unsigned int oidsize, unsigned int *oidlen)
 {
-	u_char *p = (u_char *)elem->data.raw;
-	u_int32_t asnlen = elem->asnlen;
+	const u_char *p = (const u_char *)elem->data.raw;
+	uint32_t asnlen = elem->asnlen;
 	int o = 0, first = -1, i = asnlen;
+	unsigned int firstval;
 
-	for (*oidlen = 0; sflag && i-- > 0; p++) {
+	for (*oidlen = 0; ndo->ndo_mflag && i-- > 0; p++) {
+		ND_TCHECK(*p);
 	        o = (o << ASN_SHIFT7) + (*p & ~ASN_BIT8);
 		if (*p & ASN_LONGLEN)
 		    continue;
@@ -881,18 +913,23 @@ static void smi_decode_oid(struct be *elem, unsigned int *oid,
 		 */
 		if (first < 0) {
 		        first = 0;
+			firstval = o / OIDMUX;
+			if (firstval > 2) firstval = 2;
+			o -= firstval * OIDMUX;
 			if (*oidlen < oidsize) {
-			    oid[*oidlen] = o / OIDMUX;
-			    if (oid[*oidlen] > 2) oid[*oidlen] = 2;
+			    oid[(*oidlen)++] = firstval;
 			}
-			o -= oid[*oidlen] * OIDMUX;
-			if (*oidlen < oidsize) (*oidlen)++;
 		}
 		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)
@@ -949,6 +986,10 @@ static int smi_check_a_range(SmiType *smiType, SmiRange *smiRange,
     case SMI_BASETYPE_UNKNOWN:
 	ok = 1;
 	break;
+
+    default:
+	ok = 0;
+	break;
     }
 
     return ok;
@@ -981,80 +1022,84 @@ static int smi_check_range(SmiType *smiType, struct be *elem)
 	return ok;
 }
 
-static SmiNode *smi_print_variable(struct be *elem)
+static SmiNode *
+smi_print_variable(netdissect_options *ndo,
+                   struct be *elem, int *status)
 {
 	unsigned int oid[128], oidlen;
 	SmiNode *smiNode = NULL;
-	int i;
+	unsigned int i;
 
-	smi_decode_oid(elem, oid, sizeof(oid)/sizeof(unsigned int), &oidlen);
+	*status = smi_decode_oid(ndo, elem, oid, sizeof(oid) / sizeof(unsigned int),
+	    &oidlen);
+	if (*status < 0)
+		return NULL;
 	smiNode = smiGetNodeByOID(oidlen, oid);
 	if (! smiNode) {
-	        asn1_print(elem);
+		*status = asn1_print(ndo, elem);
 		return NULL;
 	}
-	if (vflag) {
-		fputs(smiGetNodeModule(smiNode)->name, stdout);
-		fputs("::", stdout);
+	if (ndo->ndo_vflag) {
+		ND_PRINT((ndo, "%s::", smiGetNodeModule(smiNode)->name));
 	}
-	fputs(smiNode->name, stdout);
+	ND_PRINT((ndo, "%s", smiNode->name));
 	if (smiNode->oidlen < oidlen) {
-	        for (i = smiNode->oidlen; i < oidlen; i++) {
-		        printf(".%u", oid[i]);
+		for (i = smiNode->oidlen; i < oidlen; i++) {
+			ND_PRINT((ndo, ".%u", oid[i]));
 		}
 	}
+	*status = 0;
 	return smiNode;
 }
 
-static void smi_print_value(SmiNode *smiNode, u_char pduid, struct be *elem)
+static int
+smi_print_value(netdissect_options *ndo,
+                SmiNode *smiNode, u_short pduid, struct be *elem)
 {
-	unsigned int oid[128], oidlen;
+	unsigned int i, oid[128], oidlen;
 	SmiType *smiType;
 	SmiNamedNumber *nn;
-	int i, done = 0;
+	int done = 0;
 
 	if (! smiNode || ! (smiNode->nodekind
 			    & (SMI_NODEKIND_SCALAR | SMI_NODEKIND_COLUMN))) {
-	    asn1_print(elem);
-	    return;
+	    return asn1_print(ndo, elem);
 	}
 
 	if (elem->type == BE_NOSUCHOBJECT
 	    || elem->type == BE_NOSUCHINST
 	    || elem->type == BE_ENDOFMIBVIEW) {
-	    asn1_print(elem);
-	    return;
+	    return asn1_print(ndo, elem);
 	}
 
 	if (NOTIFY_CLASS(pduid) && smiNode->access < SMI_ACCESS_NOTIFY) {
-	    fputs("[notNotifyable]", stdout);
+	    ND_PRINT((ndo, "[notNotifyable]"));
 	}
 
 	if (READ_CLASS(pduid) && smiNode->access < SMI_ACCESS_READ_ONLY) {
-	    fputs("[notReadable]", stdout);
+	    ND_PRINT((ndo, "[notReadable]"));
 	}
 
 	if (WRITE_CLASS(pduid) && smiNode->access < SMI_ACCESS_READ_WRITE) {
-	    fputs("[notWritable]", stdout);
+	    ND_PRINT((ndo, "[notWritable]"));
 	}
 
 	if (RESPONSE_CLASS(pduid)
 	    && smiNode->access == SMI_ACCESS_NOT_ACCESSIBLE) {
-	    fputs("[noAccess]", stdout);
+	    ND_PRINT((ndo, "[noAccess]"));
 	}
 
 	smiType = smiGetNodeType(smiNode);
 	if (! smiType) {
-	    asn1_print(elem);
-	    return;
+	    return asn1_print(ndo, elem);
 	}
 
 	if (! smi_check_type(smiType->basetype, elem->type)) {
-	    fputs("[wrongType]", stdout);
+	    ND_PRINT((ndo, "[wrongType]"));
 	}
 
 	if (! smi_check_range(smiType, elem)) {
-	    fputs("[outOfRange]", stdout);
+	    ND_PRINT((ndo, "[outOfRange]"));
 	}
 
 	/* resolve bits to named bits */
@@ -1070,20 +1115,19 @@ static void smi_print_value(SmiNode *smiNode, u_char pduid, struct be *elem)
 	        if (smiType->basetype == SMI_BASETYPE_BITS) {
 		        /* print bit labels */
 		} else {
-		        smi_decode_oid(elem, oid,
+		        smi_decode_oid(ndo, elem, oid,
 				       sizeof(oid)/sizeof(unsigned int),
 				       &oidlen);
 			smiNode = smiGetNodeByOID(oidlen, oid);
 			if (smiNode) {
-			        if (vflag) {
-					fputs(smiGetNodeModule(smiNode)->name, stdout);
-					fputs("::", stdout);
+			        if (ndo->ndo_vflag) {
+					ND_PRINT((ndo, "%s::", smiGetNodeModule(smiNode)->name));
 				}
-				fputs(smiNode->name, stdout);
+				ND_PRINT((ndo, "%s", smiNode->name));
 				if (smiNode->oidlen < oidlen) {
 				        for (i = smiNode->oidlen;
 					     i < oidlen; i++) {
-					        printf(".%u", oid[i]);
+					        ND_PRINT((ndo, ".%u", oid[i]));
 					}
 				}
 				done++;
@@ -1098,8 +1142,8 @@ static void smi_print_value(SmiNode *smiNode, u_char pduid, struct be *elem)
 			     nn = smiGetNextNamedNumber(nn)) {
 			         if (nn->value.value.integer32
 				     == elem->data.integer) {
-				         fputs(nn->name, stdout);
-					 printf("(%d)", elem->data.integer);
+				         ND_PRINT((ndo, "%s", nn->name));
+					 ND_PRINT((ndo, "(%d)", elem->data.integer));
 					 done++;
 					 break;
 				}
@@ -1109,8 +1153,9 @@ static void smi_print_value(SmiNode *smiNode, u_char pduid, struct be *elem)
 	}
 
 	if (! done) {
-	        asn1_print(elem);
+		return asn1_print(ndo, elem);
 	}
+	return 0;
 }
 #endif
 
@@ -1151,85 +1196,92 @@ static void smi_print_value(SmiNode *smiNode, u_char pduid, struct be *elem)
  * Decode SNMP varBind
  */
 static void
-varbind_print(u_char pduid, const u_char *np, u_int length)
+varbind_print(netdissect_options *ndo,
+              u_short pduid, const u_char *np, u_int length)
 {
 	struct be elem;
 	int count = 0, ind;
-#ifdef LIBSMI
+#ifdef USE_LIBSMI
 	SmiNode *smiNode = NULL;
 #endif
+	int status;
 
 	/* Sequence of varBind */
-	if ((count = asn1_parse(np, length, &elem)) < 0)
+	if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
 		return;
 	if (elem.type != BE_SEQ) {
-		fputs("[!SEQ of varbind]", stdout);
-		asn1_print(&elem);
+		ND_PRINT((ndo, "[!SEQ of varbind]"));
+		asn1_print(ndo, &elem);
 		return;
 	}
 	if ((u_int)count < length)
-		printf("[%d extra after SEQ of varbind]", length - count);
+		ND_PRINT((ndo, "[%d extra after SEQ of varbind]", length - count));
 	/* descend */
 	length = elem.asnlen;
-	np = (u_char *)elem.data.raw;
+	np = (const u_char *)elem.data.raw;
 
 	for (ind = 1; length > 0; ind++) {
 		const u_char *vbend;
 		u_int vblength;
 
-		fputs(" ", stdout);
+		ND_PRINT((ndo, " "));
 
 		/* Sequence */
-		if ((count = asn1_parse(np, length, &elem)) < 0)
+		if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
 			return;
 		if (elem.type != BE_SEQ) {
-			fputs("[!varbind]", stdout);
-			asn1_print(&elem);
+			ND_PRINT((ndo, "[!varbind]"));
+			asn1_print(ndo, &elem);
 			return;
 		}
 		vbend = np + count;
 		vblength = length - count;
 		/* descend */
 		length = elem.asnlen;
-		np = (u_char *)elem.data.raw;
+		np = (const u_char *)elem.data.raw;
 
 		/* objName (OID) */
-		if ((count = asn1_parse(np, length, &elem)) < 0)
+		if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
 			return;
 		if (elem.type != BE_OID) {
-			fputs("[objName!=OID]", stdout);
-			asn1_print(&elem);
+			ND_PRINT((ndo, "[objName!=OID]"));
+			asn1_print(ndo, &elem);
 			return;
 		}
-#ifdef LIBSMI
-		smiNode = smi_print_variable(&elem);
+#ifdef USE_LIBSMI
+		smiNode = smi_print_variable(ndo, &elem, &status);
 #else
-		asn1_print(&elem);
+		status = asn1_print(ndo, &elem);
 #endif
+		if (status < 0)
+			return;
 		length -= count;
 		np += count;
 
 		if (pduid != GETREQ && pduid != GETNEXTREQ
 		    && pduid != GETBULKREQ)
-				fputs("=", stdout);
+			ND_PRINT((ndo, "="));
 
 		/* objVal (ANY) */
-		if ((count = asn1_parse(np, length, &elem)) < 0)
+		if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
 			return;
 		if (pduid == GETREQ || pduid == GETNEXTREQ
 		    || pduid == GETBULKREQ) {
 			if (elem.type != BE_NULL) {
-				fputs("[objVal!=NULL]", stdout);
-				asn1_print(&elem);
+				ND_PRINT((ndo, "[objVal!=NULL]"));
+				if (asn1_print(ndo, &elem) < 0)
+					return;
 			}
 		} else {
 		        if (elem.type != BE_NULL) {
-#ifdef LIBSMI
-			        smi_print_value(smiNode, pduid, &elem);
+#ifdef USE_LIBSMI
+				status = smi_print_value(ndo, smiNode, pduid, &elem);
 #else
-				asn1_print(&elem);
+				status = asn1_print(ndo, &elem);
 #endif
 			}
+			if (status < 0)
+				return;
 		}
 		length = vblength;
 		np = vbend;
@@ -1241,79 +1293,76 @@ varbind_print(u_char pduid, const u_char *np, u_int length)
  * GetBulk, Inform, V2Trap, and Report
  */
 static void
-snmppdu_print(u_char pduid, const u_char *np, u_int length)
+snmppdu_print(netdissect_options *ndo,
+              u_short pduid, const u_char *np, u_int length)
 {
 	struct be elem;
-	int count = 0, error;
+	int count = 0, error_status;
 
 	/* reqId (Integer) */
-	if ((count = asn1_parse(np, length, &elem)) < 0)
+	if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
 		return;
 	if (elem.type != BE_INT) {
-		fputs("[reqId!=INT]", stdout);
-		asn1_print(&elem);
+		ND_PRINT((ndo, "[reqId!=INT]"));
+		asn1_print(ndo, &elem);
 		return;
 	}
-	if (vflag)
-		printf("R=%d ", elem.data.integer);
+	if (ndo->ndo_vflag)
+		ND_PRINT((ndo, "R=%d ", elem.data.integer));
 	length -= count;
 	np += count;
 
 	/* errorStatus (Integer) */
-	if ((count = asn1_parse(np, length, &elem)) < 0)
+	if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
 		return;
 	if (elem.type != BE_INT) {
-		fputs("[errorStatus!=INT]", stdout);
-		asn1_print(&elem);
+		ND_PRINT((ndo, "[errorStatus!=INT]"));
+		asn1_print(ndo, &elem);
 		return;
 	}
-	error = 0;
+	error_status = 0;
 	if ((pduid == GETREQ || pduid == GETNEXTREQ || pduid == SETREQ
 	    || pduid == INFORMREQ || pduid == V2TRAP || pduid == REPORT)
 	    && elem.data.integer != 0) {
-		char errbuf[10];
-		printf("[errorStatus(%s)!=0]",
-			DECODE_ErrorStatus(elem.data.integer));
+		char errbuf[20];
+		ND_PRINT((ndo, "[errorStatus(%s)!=0]",
+			DECODE_ErrorStatus(elem.data.integer)));
 	} else if (pduid == GETBULKREQ) {
-	        printf(" N=%d", elem.data.integer);
+		ND_PRINT((ndo, " N=%d", elem.data.integer));
 	} else if (elem.data.integer != 0) {
-		char errbuf[10];
-		printf(" %s", DECODE_ErrorStatus(elem.data.integer));
-		error = elem.data.integer;
+		char errbuf[20];
+		ND_PRINT((ndo, " %s", DECODE_ErrorStatus(elem.data.integer)));
+		error_status = elem.data.integer;
 	}
 	length -= count;
 	np += count;
 
 	/* errorIndex (Integer) */
-	if ((count = asn1_parse(np, length, &elem)) < 0)
+	if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
 		return;
 	if (elem.type != BE_INT) {
-		fputs("[errorIndex!=INT]", stdout);
-		asn1_print(&elem);
+		ND_PRINT((ndo, "[errorIndex!=INT]"));
+		asn1_print(ndo, &elem);
 		return;
 	}
 	if ((pduid == GETREQ || pduid == GETNEXTREQ || pduid == SETREQ
 	    || pduid == INFORMREQ || pduid == V2TRAP || pduid == REPORT)
 	    && elem.data.integer != 0)
-		printf("[errorIndex(%d)!=0]", elem.data.integer);
+		ND_PRINT((ndo, "[errorIndex(%d)!=0]", elem.data.integer));
 	else if (pduid == GETBULKREQ)
-	        printf(" M=%d", elem.data.integer);
+		ND_PRINT((ndo, " M=%d", elem.data.integer));
 	else if (elem.data.integer != 0) {
-		if (!error)
-			printf("[errorIndex(%d) w/o errorStatus]",
-				elem.data.integer);
-		else {
-			printf("@%d", elem.data.integer);
-			error = elem.data.integer;
-		}
-	} else if (error) {
-		fputs("[errorIndex==0]", stdout);
-		error = 0;
+		if (!error_status)
+			ND_PRINT((ndo, "[errorIndex(%d) w/o errorStatus]", elem.data.integer));
+		else
+			ND_PRINT((ndo, "@%d", elem.data.integer));
+	} else if (error_status) {
+		ND_PRINT((ndo, "[errorIndex==0]"));
 	}
 	length -= count;
 	np += count;
 
-	varbind_print(pduid, np, length);
+	varbind_print(ndo, pduid, np, length);
 	return;
 }
 
@@ -1321,86 +1370,90 @@ snmppdu_print(u_char pduid, const u_char *np, u_int length)
  * Decode SNMP Trap PDU
  */
 static void
-trappdu_print(const u_char *np, u_int length)
+trappdu_print(netdissect_options *ndo,
+              const u_char *np, u_int length)
 {
 	struct be elem;
 	int count = 0, generic;
 
-	putchar(' ');
+	ND_PRINT((ndo, " "));
 
 	/* enterprise (oid) */
-	if ((count = asn1_parse(np, length, &elem)) < 0)
+	if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
 		return;
 	if (elem.type != BE_OID) {
-		fputs("[enterprise!=OID]", stdout);
-		asn1_print(&elem);
+		ND_PRINT((ndo, "[enterprise!=OID]"));
+		asn1_print(ndo, &elem);
 		return;
 	}
-	asn1_print(&elem);
+	if (asn1_print(ndo, &elem) < 0)
+		return;
 	length -= count;
 	np += count;
 
-	putchar(' ');
+	ND_PRINT((ndo, " "));
 
 	/* agent-addr (inetaddr) */
-	if ((count = asn1_parse(np, length, &elem)) < 0)
+	if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
 		return;
 	if (elem.type != BE_INETADDR) {
-		fputs("[agent-addr!=INETADDR]", stdout);
-		asn1_print(&elem);
+		ND_PRINT((ndo, "[agent-addr!=INETADDR]"));
+		asn1_print(ndo, &elem);
 		return;
 	}
-	asn1_print(&elem);
+	if (asn1_print(ndo, &elem) < 0)
+		return;
 	length -= count;
 	np += count;
 
 	/* generic-trap (Integer) */
-	if ((count = asn1_parse(np, length, &elem)) < 0)
+	if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
 		return;
 	if (elem.type != BE_INT) {
-		fputs("[generic-trap!=INT]", stdout);
-		asn1_print(&elem);
+		ND_PRINT((ndo, "[generic-trap!=INT]"));
+		asn1_print(ndo, &elem);
 		return;
 	}
 	generic = elem.data.integer;
 	{
-		char buf[10];
-		printf(" %s", DECODE_GenericTrap(generic));
+		char buf[20];
+		ND_PRINT((ndo, " %s", DECODE_GenericTrap(generic)));
 	}
 	length -= count;
 	np += count;
 
 	/* specific-trap (Integer) */
-	if ((count = asn1_parse(np, length, &elem)) < 0)
+	if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
 		return;
 	if (elem.type != BE_INT) {
-		fputs("[specific-trap!=INT]", stdout);
-		asn1_print(&elem);
+		ND_PRINT((ndo, "[specific-trap!=INT]"));
+		asn1_print(ndo, &elem);
 		return;
 	}
 	if (generic != GT_ENTERPRISE) {
 		if (elem.data.integer != 0)
-			printf("[specific-trap(%d)!=0]", elem.data.integer);
+			ND_PRINT((ndo, "[specific-trap(%d)!=0]", elem.data.integer));
 	} else
-		printf(" s=%d", elem.data.integer);
+		ND_PRINT((ndo, " s=%d", elem.data.integer));
 	length -= count;
 	np += count;
 
-	putchar(' ');
+	ND_PRINT((ndo, " "));
 
 	/* time-stamp (TimeTicks) */
-	if ((count = asn1_parse(np, length, &elem)) < 0)
+	if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
 		return;
 	if (elem.type != BE_UNS) {			/* XXX */
-		fputs("[time-stamp!=TIMETICKS]", stdout);
-		asn1_print(&elem);
+		ND_PRINT((ndo, "[time-stamp!=TIMETICKS]"));
+		asn1_print(ndo, &elem);
 		return;
 	}
-	asn1_print(&elem);
+	if (asn1_print(ndo, &elem) < 0)
+		return;
 	length -= count;
 	np += count;
 
-	varbind_print (TRAP, np, length);
+	varbind_print(ndo, TRAP, np, length);
 	return;
 }
 
@@ -1408,44 +1461,46 @@ trappdu_print(const u_char *np, u_int length)
  * Decode arbitrary SNMP PDUs.
  */
 static void
-pdu_print(const u_char *np, u_int length, int version)
+pdu_print(netdissect_options *ndo,
+          const u_char *np, u_int length, int version)
 {
 	struct be pdu;
 	int count = 0;
 
 	/* PDU (Context) */
-	if ((count = asn1_parse(np, length, &pdu)) < 0)
+	if ((count = asn1_parse(ndo, np, length, &pdu)) < 0)
 		return;
 	if (pdu.type != BE_PDU) {
-		fputs("[no PDU]", stdout);
+		ND_PRINT((ndo, "[no PDU]"));
 		return;
 	}
 	if ((u_int)count < length)
-		printf("[%d extra after PDU]", length - count);
-	if (vflag) {
-		fputs("{ ", stdout);
+		ND_PRINT((ndo, "[%d extra after PDU]", length - count));
+	if (ndo->ndo_vflag) {
+		ND_PRINT((ndo, "{ "));
 	}
-	asn1_print(&pdu);
-	fputs(" ", stdout);
+	if (asn1_print(ndo, &pdu) < 0)
+		return;
+	ND_PRINT((ndo, " "));
 	/* descend into PDU */
 	length = pdu.asnlen;
-	np = (u_char *)pdu.data.raw;
+	np = (const u_char *)pdu.data.raw;
 
 	if (version == SNMP_VERSION_1 &&
 	    (pdu.id == GETBULKREQ || pdu.id == INFORMREQ ||
 	     pdu.id == V2TRAP || pdu.id == REPORT)) {
-	        printf("[v2 PDU in v1 message]");
+	        ND_PRINT((ndo, "[v2 PDU in v1 message]"));
 		return;
 	}
 
 	if (version == SNMP_VERSION_2 && pdu.id == TRAP) {
-	        printf("[v1 PDU in v2 message]");
+		ND_PRINT((ndo, "[v1 PDU in v2 message]"));
 		return;
 	}
 
 	switch (pdu.id) {
 	case TRAP:
-		trappdu_print(np, length);
+		trappdu_print(ndo, np, length);
 		break;
 	case GETREQ:
 	case GETNEXTREQ:
@@ -1455,12 +1510,12 @@ pdu_print(const u_char *np, u_int length, int version)
 	case INFORMREQ:
 	case V2TRAP:
 	case REPORT:
-		snmppdu_print(pdu.id, np, length);
+		snmppdu_print(ndo, pdu.id, np, length);
 		break;
 	}
 
-	if (vflag) {
-		fputs(" } ", stdout);
+	if (ndo->ndo_vflag) {
+		ND_PRINT((ndo, " } "));
 	}
 }
 
@@ -1468,185 +1523,189 @@ pdu_print(const u_char *np, u_int length, int version)
  * Decode a scoped SNMP PDU.
  */
 static void
-scopedpdu_print(const u_char *np, u_int length, int version)
+scopedpdu_print(netdissect_options *ndo,
+                const u_char *np, u_int length, int version)
 {
 	struct be elem;
 	int i, count = 0;
 
 	/* Sequence */
-	if ((count = asn1_parse(np, length, &elem)) < 0)
+	if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
 		return;
 	if (elem.type != BE_SEQ) {
-		fputs("[!scoped PDU]", stdout);
-		asn1_print(&elem);
+		ND_PRINT((ndo, "[!scoped PDU]"));
+		asn1_print(ndo, &elem);
 		return;
 	}
 	length = elem.asnlen;
-	np = (u_char *)elem.data.raw;
+	np = (const u_char *)elem.data.raw;
 
 	/* contextEngineID (OCTET STRING) */
-	if ((count = asn1_parse(np, length, &elem)) < 0)
+	if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
 		return;
 	if (elem.type != BE_STR) {
-		fputs("[contextEngineID!=STR]", stdout);
-		asn1_print(&elem);
+		ND_PRINT((ndo, "[contextEngineID!=STR]"));
+		asn1_print(ndo, &elem);
 		return;
 	}
 	length -= count;
 	np += count;
 
-	fputs("E= ", stdout);
+	ND_PRINT((ndo, "E= "));
 	for (i = 0; i < (int)elem.asnlen; i++) {
-            printf("0x%02X", elem.data.str[i]);
-        }
-	fputs(" ", stdout);
+		ND_PRINT((ndo, "0x%02X", elem.data.str[i]));
+	}
+	ND_PRINT((ndo, " "));
 
 	/* contextName (OCTET STRING) */
-	if ((count = asn1_parse(np, length, &elem)) < 0)
+	if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
 		return;
 	if (elem.type != BE_STR) {
-		fputs("[contextName!=STR]", stdout);
-		asn1_print(&elem);
+		ND_PRINT((ndo, "[contextName!=STR]"));
+		asn1_print(ndo, &elem);
 		return;
 	}
 	length -= count;
 	np += count;
 
-	printf("C=%.*s ", (int)elem.asnlen, elem.data.str);
+	ND_PRINT((ndo, "C=%.*s ", (int)elem.asnlen, elem.data.str));
 
-	pdu_print(np, length, version);
+	pdu_print(ndo, np, length, version);
 }
 
 /*
  * Decode SNMP Community Header (SNMPv1 and SNMPv2c)
  */
 static void
-community_print(const u_char *np, u_int length, int version)
+community_print(netdissect_options *ndo,
+                const u_char *np, u_int length, int version)
 {
 	struct be elem;
 	int count = 0;
 
 	/* Community (String) */
-	if ((count = asn1_parse(np, length, &elem)) < 0)
+	if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
 		return;
 	if (elem.type != BE_STR) {
-		fputs("[comm!=STR]", stdout);
-		asn1_print(&elem);
+		ND_PRINT((ndo, "[comm!=STR]"));
+		asn1_print(ndo, &elem);
 		return;
 	}
 	/* default community */
 	if (!(elem.asnlen == sizeof(DEF_COMMUNITY) - 1 &&
-	    strncmp((char *)elem.data.str, DEF_COMMUNITY,
+	    strncmp((const char *)elem.data.str, DEF_COMMUNITY,
 	            sizeof(DEF_COMMUNITY) - 1) == 0))
 		/* ! "public" */
-		printf("C=%.*s ", (int)elem.asnlen, elem.data.str);
+		ND_PRINT((ndo, "C=%.*s ", (int)elem.asnlen, elem.data.str));
 	length -= count;
 	np += count;
 
-	pdu_print(np, length, version);
+	pdu_print(ndo, np, length, version);
 }
 
 /*
  * Decode SNMPv3 User-based Security Message Header (SNMPv3)
  */
 static void
-usm_print(const u_char *np, u_int length)
+usm_print(netdissect_options *ndo,
+          const u_char *np, u_int length)
 {
         struct be elem;
 	int count = 0;
 
 	/* Sequence */
-	if ((count = asn1_parse(np, length, &elem)) < 0)
+	if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
 		return;
 	if (elem.type != BE_SEQ) {
-		fputs("[!usm]", stdout);
-		asn1_print(&elem);
+		ND_PRINT((ndo, "[!usm]"));
+		asn1_print(ndo, &elem);
 		return;
 	}
 	length = elem.asnlen;
-	np = (u_char *)elem.data.raw;
+	np = (const u_char *)elem.data.raw;
 
 	/* msgAuthoritativeEngineID (OCTET STRING) */
-	if ((count = asn1_parse(np, length, &elem)) < 0)
+	if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
 		return;
 	if (elem.type != BE_STR) {
-		fputs("[msgAuthoritativeEngineID!=STR]", stdout);
-		asn1_print(&elem);
+		ND_PRINT((ndo, "[msgAuthoritativeEngineID!=STR]"));
+		asn1_print(ndo, &elem);
 		return;
 	}
 	length -= count;
 	np += count;
 
 	/* msgAuthoritativeEngineBoots (INTEGER) */
-	if ((count = asn1_parse(np, length, &elem)) < 0)
+	if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
 		return;
 	if (elem.type != BE_INT) {
-		fputs("[msgAuthoritativeEngineBoots!=INT]", stdout);
-		asn1_print(&elem);
+		ND_PRINT((ndo, "[msgAuthoritativeEngineBoots!=INT]"));
+		asn1_print(ndo, &elem);
 		return;
 	}
-	if (vflag)
-	        printf("B=%d ", elem.data.integer);
+	if (ndo->ndo_vflag)
+		ND_PRINT((ndo, "B=%d ", elem.data.integer));
 	length -= count;
 	np += count;
 
 	/* msgAuthoritativeEngineTime (INTEGER) */
-	if ((count = asn1_parse(np, length, &elem)) < 0)
+	if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
 		return;
 	if (elem.type != BE_INT) {
-		fputs("[msgAuthoritativeEngineTime!=INT]", stdout);
-		asn1_print(&elem);
+		ND_PRINT((ndo, "[msgAuthoritativeEngineTime!=INT]"));
+		asn1_print(ndo, &elem);
 		return;
 	}
-	if (vflag)
-	        printf("T=%d ", elem.data.integer);
+	if (ndo->ndo_vflag)
+		ND_PRINT((ndo, "T=%d ", elem.data.integer));
 	length -= count;
 	np += count;
 
 	/* msgUserName (OCTET STRING) */
-	if ((count = asn1_parse(np, length, &elem)) < 0)
+	if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
 		return;
 	if (elem.type != BE_STR) {
-		fputs("[msgUserName!=STR]", stdout);
-		asn1_print(&elem);
+		ND_PRINT((ndo, "[msgUserName!=STR]"));
+		asn1_print(ndo, &elem);
 		return;
 	}
 	length -= count;
         np += count;
 
-	printf("U=%.*s ", (int)elem.asnlen, elem.data.str);
+	ND_PRINT((ndo, "U=%.*s ", (int)elem.asnlen, elem.data.str));
 
 	/* msgAuthenticationParameters (OCTET STRING) */
-	if ((count = asn1_parse(np, length, &elem)) < 0)
+	if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
 		return;
 	if (elem.type != BE_STR) {
-		fputs("[msgAuthenticationParameters!=STR]", stdout);
-		asn1_print(&elem);
+		ND_PRINT((ndo, "[msgAuthenticationParameters!=STR]"));
+		asn1_print(ndo, &elem);
 		return;
 	}
 	length -= count;
         np += count;
 
 	/* msgPrivacyParameters (OCTET STRING) */
-	if ((count = asn1_parse(np, length, &elem)) < 0)
+	if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
 		return;
 	if (elem.type != BE_STR) {
-		fputs("[msgPrivacyParameters!=STR]", stdout);
-		asn1_print(&elem);
+		ND_PRINT((ndo, "[msgPrivacyParameters!=STR]"));
+		asn1_print(ndo, &elem);
 		return;
 	}
 	length -= count;
         np += count;
 
 	if ((u_int)count < length)
-		printf("[%d extra after usm SEQ]", length - count);
+		ND_PRINT((ndo, "[%d extra after usm SEQ]", length - count));
 }
 
 /*
  * Decode SNMPv3 Message Header (SNMPv3)
  */
 static void
-v3msg_print(const u_char *np, u_int length)
+v3msg_print(netdissect_options *ndo,
+            const u_char *np, u_int length)
 {
 	struct be elem;
 	int count = 0;
@@ -1656,75 +1715,74 @@ v3msg_print(const u_char *np, u_int length)
 	int xlength = length;
 
 	/* Sequence */
-	if ((count = asn1_parse(np, length, &elem)) < 0)
+	if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
 		return;
 	if (elem.type != BE_SEQ) {
-		fputs("[!message]", stdout);
-		asn1_print(&elem);
+		ND_PRINT((ndo, "[!message]"));
+		asn1_print(ndo, &elem);
 		return;
 	}
 	length = elem.asnlen;
-	np = (u_char *)elem.data.raw;
+	np = (const u_char *)elem.data.raw;
 
-	if (vflag) {
-		fputs("{ ", stdout);
+	if (ndo->ndo_vflag) {
+		ND_PRINT((ndo, "{ "));
 	}
 
 	/* msgID (INTEGER) */
-	if ((count = asn1_parse(np, length, &elem)) < 0)
+	if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
 		return;
 	if (elem.type != BE_INT) {
-		fputs("[msgID!=INT]", stdout);
-		asn1_print(&elem);
+		ND_PRINT((ndo, "[msgID!=INT]"));
+		asn1_print(ndo, &elem);
 		return;
 	}
 	length -= count;
 	np += count;
 
 	/* msgMaxSize (INTEGER) */
-	if ((count = asn1_parse(np, length, &elem)) < 0)
+	if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
 		return;
 	if (elem.type != BE_INT) {
-		fputs("[msgMaxSize!=INT]", stdout);
-		asn1_print(&elem);
+		ND_PRINT((ndo, "[msgMaxSize!=INT]"));
+		asn1_print(ndo, &elem);
 		return;
 	}
 	length -= count;
 	np += count;
 
 	/* msgFlags (OCTET STRING) */
-	if ((count = asn1_parse(np, length, &elem)) < 0)
+	if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
 		return;
 	if (elem.type != BE_STR) {
-		fputs("[msgFlags!=STR]", stdout);
-		asn1_print(&elem);
+		ND_PRINT((ndo, "[msgFlags!=STR]"));
+		asn1_print(ndo, &elem);
 		return;
 	}
 	if (elem.asnlen != 1) {
-	        printf("[msgFlags size %d]", elem.asnlen);
+		ND_PRINT((ndo, "[msgFlags size %d]", elem.asnlen));
 		return;
 	}
 	flags = elem.data.str[0];
 	if (flags != 0x00 && flags != 0x01 && flags != 0x03
 	    && flags != 0x04 && flags != 0x05 && flags != 0x07) {
-		printf("[msgFlags=0x%02X]", flags);
+		ND_PRINT((ndo, "[msgFlags=0x%02X]", flags));
 		return;
 	}
 	length -= count;
 	np += count;
 
-	fputs("F=", stdout);
-	if (flags & 0x01) fputs("a", stdout);
-	if (flags & 0x02) fputs("p", stdout);
-	if (flags & 0x04) fputs("r", stdout);
-	fputs(" ", stdout);
+	ND_PRINT((ndo, "F=%s%s%s ",
+	          flags & 0x01 ? "a" : "",
+	          flags & 0x02 ? "p" : "",
+	          flags & 0x04 ? "r" : ""));
 
 	/* msgSecurityModel (INTEGER) */
-	if ((count = asn1_parse(np, length, &elem)) < 0)
+	if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
 		return;
 	if (elem.type != BE_INT) {
-		fputs("[msgSecurityModel!=INT]", stdout);
-		asn1_print(&elem);
+		ND_PRINT((ndo, "[msgSecurityModel!=INT]"));
+		asn1_print(ndo, &elem);
 		return;
 	}
 	model = elem.data.integer;
@@ -1732,18 +1790,18 @@ v3msg_print(const u_char *np, u_int length)
 	np += count;
 
 	if ((u_int)count < length)
-		printf("[%d extra after message SEQ]", length - count);
+		ND_PRINT((ndo, "[%d extra after message SEQ]", length - count));
 
-	if (vflag) {
-		fputs("} ", stdout);
+	if (ndo->ndo_vflag) {
+		ND_PRINT((ndo, "} "));
 	}
 
 	if (model == 3) {
-	    if (vflag) {
-		fputs("{ USM ", stdout);
+	    if (ndo->ndo_vflag) {
+		ND_PRINT((ndo, "{ USM "));
 	    }
 	} else {
-	    printf("[security model %d]", model);
+	    ND_PRINT((ndo, "[security model %d]", model));
             return;
 	}
 
@@ -1751,31 +1809,31 @@ v3msg_print(const u_char *np, u_int length)
 	length = xlength - (np - xnp);
 
 	/* msgSecurityParameters (OCTET STRING) */
-	if ((count = asn1_parse(np, length, &elem)) < 0)
+	if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
 		return;
 	if (elem.type != BE_STR) {
-		fputs("[msgSecurityParameters!=STR]", stdout);
-		asn1_print(&elem);
+		ND_PRINT((ndo, "[msgSecurityParameters!=STR]"));
+		asn1_print(ndo, &elem);
 		return;
 	}
 	length -= count;
 	np += count;
 
 	if (model == 3) {
-	    usm_print(elem.data.str, elem.asnlen);
-	    if (vflag) {
-		fputs("} ", stdout);
+	    usm_print(ndo, elem.data.str, elem.asnlen);
+	    if (ndo->ndo_vflag) {
+		ND_PRINT((ndo, "} "));
 	    }
 	}
 
-	if (vflag) {
-	    fputs("{ ScopedPDU ", stdout);
+	if (ndo->ndo_vflag) {
+	    ND_PRINT((ndo, "{ ScopedPDU "));
 	}
 
-	scopedpdu_print(np, length, 3);
+	scopedpdu_print(ndo, np, length, 3);
 
-	if (vflag) {
-		fputs("} ", stdout);
+	if (ndo->ndo_vflag) {
+		ND_PRINT((ndo, "} "));
 	}
 }
 
@@ -1783,42 +1841,35 @@ v3msg_print(const u_char *np, u_int length)
  * Decode SNMP header and pass on to PDU printing routines
  */
 void
-snmp_print(const u_char *np, u_int length)
+snmp_print(netdissect_options *ndo,
+           const u_char *np, u_int length)
 {
 	struct be elem;
 	int count = 0;
 	int version = 0;
 
-	truncated = 0;
-
-	/* truncated packet? */
-	if (np + length > snapend) {
-		truncated = 1;
-		length = snapend - np;
-	}
-
-	putchar(' ');
+	ND_PRINT((ndo, " "));
 
 	/* initial Sequence */
-	if ((count = asn1_parse(np, length, &elem)) < 0)
+	if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
 		return;
 	if (elem.type != BE_SEQ) {
-		fputs("[!init SEQ]", stdout);
-		asn1_print(&elem);
+		ND_PRINT((ndo, "[!init SEQ]"));
+		asn1_print(ndo, &elem);
 		return;
 	}
 	if ((u_int)count < length)
-		printf("[%d extra after iSEQ]", length - count);
+		ND_PRINT((ndo, "[%d extra after iSEQ]", length - count));
 	/* descend */
 	length = elem.asnlen;
-	np = (u_char *)elem.data.raw;
+	np = (const u_char *)elem.data.raw;
 
 	/* Version (INTEGER) */
-	if ((count = asn1_parse(np, length, &elem)) < 0)
+	if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
 		return;
 	if (elem.type != BE_INT) {
-		fputs("[version!=INT]", stdout);
-		asn1_print(&elem);
+		ND_PRINT((ndo, "[version!=INT]"));
+		asn1_print(ndo, &elem);
 		return;
 	}
 
@@ -1826,11 +1877,11 @@ snmp_print(const u_char *np, u_int length)
 	case SNMP_VERSION_1:
 	case SNMP_VERSION_2:
 	case SNMP_VERSION_3:
-	        if (vflag)
-		        printf("{ %s ", SnmpVersion[elem.data.integer]);
+		if (ndo->ndo_vflag)
+			ND_PRINT((ndo, "{ %s ", SnmpVersion[elem.data.integer]));
 		break;
 	default:
-	        printf("[version = %d]", elem.data.integer);
+	        ND_PRINT((ndo, "[version = %d]", elem.data.integer));
 		return;
 	}
 	version = elem.data.integer;
@@ -1840,17 +1891,17 @@ snmp_print(const u_char *np, u_int length)
 	switch (version) {
 	case SNMP_VERSION_1:
         case SNMP_VERSION_2:
-		community_print(np, length, version);
+		community_print(ndo, np, length, version);
 		break;
 	case SNMP_VERSION_3:
-		v3msg_print(np, length);
+		v3msg_print(ndo, np, length);
 		break;
 	default:
-	        printf("[version = %d]", elem.data.integer);
+		ND_PRINT((ndo, "[version = %d]", elem.data.integer));
 		break;
 	}
 
-	if (vflag) {
-		fputs("} ", stdout);
+	if (ndo->ndo_vflag) {
+		ND_PRINT((ndo, "} "));
 	}
 }