Fix a bunch of de-constifications.

[tcpdump] / print-snmp.c

diff --git a/print-snmp.c b/print-snmp.c
index 6f57c2f1e05ef2e807a7d9e0bc6c51e63c03aca2..b9372644a99f394754c101aad9081eefc5a9b65f 100644 (file)
--- a/print-snmp.c
+++ b/print-snmp.c
@@ -65,7 +65,7 @@
 #include <stdio.h>
 #include <string.h>
 
 #include <stdio.h>
 #include <string.h>
 

-#ifdef HAVE_SMI_H
+#ifdef USE_LIBSMI

 #include <smi.h>
 #endif
 
 #include <smi.h>
 #endif
 


@@ -311,10 +311,10 @@ static const struct obj_abrev {
                } while ((objp = objp->next) != NULL); \
        } \
        if (objp) { \
                } 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 \
                objp = objp->child; \
        } else \

-               printf(suppressdot?"%u":".%u", (o)); \
+               ND_PRINT((ndo, suppressdot?"%u":".%u", (o))); \

 }
 
 /*
 }
 
 /*


@@ -322,15 +322,15 @@ static const struct obj_abrev {
  * temporary internal representation while decoding an ASN.1 data stream.
  */
 struct be {
  * temporary internal representation while decoding an ASN.1 data stream.
  */
 struct be {

-       u_int32_t asnlen;
+       uint32_t asnlen;

        union {
        union {

-               caddr_t raw;
+               const uint8_t *raw;

                int32_t integer;
                int32_t integer;

-               u_int32_t uns;
+               uint32_t uns;

                const u_char *str;
                struct {
                const u_char *str;
                struct {

-                       u_int32_t high;
-                       u_int32_t low;
+                       uint32_t high;
+                       uint32_t low;

                } uns64;
        } data;
        u_short id;
                } uns64;
        } data;
        u_short id;


@@ -399,7 +399,8 @@ static const char *SnmpVersion[] = {
  * O/w, this returns the number of bytes parsed from "p".
  */
 static int
  * 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;
 {
        u_char form, class, id;
        int i, hdr;


@@ -407,10 +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) {
        elem->asnlen = 0;
        elem->type = BE_ANY;
        if (len < 1) {

-               fputs("[nothing to parse]", stdout);
+               ND_PRINT((ndo, "[nothing to parse]"));

                return -1;
        }
                return -1;
        }

-       TCHECK(*p);
+       ND_TCHECK(*p);

 
        /*
         * it would be nice to use a bit field, but you can't depend on them.
 
        /*
         * it would be nice to use a bit field, but you can't depend on them.


@@ -446,54 +447,54 @@ asn1_parse(register const u_char *p, u_int len, struct be *elem)
                 */
                for (id = 0; *p & ASN_BIT8; len--, hdr++, p++) {
                        if (len < 1) {
                 */
                for (id = 0; *p & ASN_BIT8; len--, hdr++, p++) {
                        if (len < 1) {

-                               fputs("[Xtagfield?]", stdout);
+                               ND_PRINT((ndo, "[Xtagfield?]"));

                                return -1;
                        }
                                return -1;
                        }

-                       TCHECK(*p);
+                       ND_TCHECK(*p);

                        id = (id << 7) | (*p & ~ASN_BIT8);
                }
                if (len < 1) {
                        id = (id << 7) | (*p & ~ASN_BIT8);
                }
                if (len < 1) {

-                       fputs("[Xtagfield?]", stdout);
+                       ND_PRINT((ndo, "[Xtagfield?]"));

                        return -1;
                }
                        return -1;
                }

-               TCHECK(*p);
+               ND_TCHECK(*p);

                elem->id = id = (id << 7) | *p;
                --len;
                ++hdr;
                ++p;
        }
        if (len < 1) {
                elem->id = id = (id << 7) | *p;
                --len;
                ++hdr;
                ++p;
        }
        if (len < 1) {

-               fputs("[no asnlen]", stdout);
+               ND_PRINT((ndo, "[no asnlen]"));

                return -1;
        }
                return -1;
        }

-       TCHECK(*p);
+       ND_TCHECK(*p);

        elem->asnlen = *p;
        p++; len--; hdr++;
        if (elem->asnlen & ASN_BIT8) {
        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) {
                elem->asnlen = 0;
                if (len < noct) {

-                       printf("[asnlen? %d<%d]", len, noct);
+                       ND_PRINT((ndo, "[asnlen? %d<%d]", len, noct));

                        return -1;
                }
                        return -1;
                }

-               TCHECK2(*p, noct);
+               ND_TCHECK2(*p, noct);

                for (; noct-- > 0; len--, hdr++)
                        elem->asnlen = (elem->asnlen << ASN_SHIFT8) | *p++;
        }
        if (len < elem->asnlen) {
                for (; noct-- > 0; len--, hdr++)
                        elem->asnlen = (elem->asnlen << ASN_SHIFT8) | *p++;
        }
        if (len < elem->asnlen) {

-               printf("[len%d<asnlen%u]", len, elem->asnlen);
+               ND_PRINT((ndo, "[len%d<asnlen%u]", len, elem->asnlen));

                return -1;
        }
        if (form >= sizeof(Form)/sizeof(Form[0])) {
                return -1;
        }
        if (form >= sizeof(Form)/sizeof(Form[0])) {

-               printf("[form?%d]", form);
+               ND_PRINT((ndo, "[form?%d]", form));

                return -1;
        }
        if (class >= sizeof(Class)/sizeof(Class[0])) {
                return -1;
        }
        if (class >= sizeof(Class)/sizeof(Class[0])) {

-               printf("[class?%c/%d]", *Form[form], class);
+               ND_PRINT((ndo, "[class?%c/%d]", *Form[form], class));

                return -1;
        }
        if ((int)id >= Class[class].numIDs) {
                return -1;
        }
        if ((int)id >= Class[class].numIDs) {

-               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;
        }
 
                return -1;
        }
 


@@ -512,7 +513,7 @@ asn1_parse(register const u_char *p, u_int len, struct be *elem)
                                elem->type = BE_INT;
                                data = 0;
 
                                elem->type = BE_INT;
                                data = 0;
 

-                               TCHECK2(*p, elem->asnlen);
+                               ND_TCHECK2(*p, elem->asnlen);

                                if (*p & ASN_BIT8)      /* negative */
                                        data = -1;
                                for (i = elem->asnlen; i-- > 0; p++)
                                if (*p & ASN_BIT8)      /* negative */
                                        data = -1;
                                for (i = elem->asnlen; i-- > 0; p++)


@@ -523,7 +524,7 @@ asn1_parse(register const u_char *p, u_int len, struct be *elem)
 
                        case OBJECTID:
                                elem->type = BE_OID;
 
                        case OBJECTID:
                                elem->type = BE_OID;

-                               elem->data.raw = (caddr_t)p;
+                               elem->data.raw = (const uint8_t *)p;

                                break;
 
                        case ASN_NULL:
                                break;
 
                        case ASN_NULL:


@@ -533,9 +534,8 @@ asn1_parse(register const u_char *p, u_int len, struct be *elem)
 
                        default:
                                elem->type = BE_OCTET;
 
                        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;
                                break;
                        }
                        break;


@@ -544,14 +544,14 @@ asn1_parse(register const u_char *p, u_int len, struct be *elem)
                        switch (id) {
                        case IPADDR:
                                elem->type = BE_INETADDR;
                        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: {
                                break;
 
                        case COUNTER:
                        case GAUGE:
                        case TIMETICKS: {

-                               register u_int32_t data;
-                               TCHECK2(*p, elem->asnlen);
+                               register uint32_t data;
+                               ND_TCHECK2(*p, elem->asnlen);

                                elem->type = BE_UNS;
                                data = 0;
                                for (i = elem->asnlen; i-- > 0; p++)
                                elem->type = BE_UNS;
                                data = 0;
                                for (i = elem->asnlen; i-- > 0; p++)


@@ -561,8 +561,8 @@ asn1_parse(register const u_char *p, u_int len, struct be *elem)
                        }
 
                        case COUNTER64: {
                        }
 
                        case COUNTER64: {

-                               register u_int32_t high, low;
-                               TCHECK2(*p, elem->asnlen);
+                               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++) {
                                elem->type = BE_UNS64;
                                high = 0, low = 0;
                                for (i = elem->asnlen; i-- > 0; p++) {


@@ -577,9 +577,9 @@ asn1_parse(register const u_char *p, u_int len, struct be *elem)
 
                        default:
                                elem->type = BE_OCTET;
 
                        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;
                                break;
                        }
                        break;


@@ -604,11 +604,10 @@ asn1_parse(register const u_char *p, u_int len, struct be *elem)
                        break;
 
                default:
                        break;
 
                default:

-                       printf("[P/%s/%s]",
-                               Class[class].name, Class[class].Id[id]);
-                       TCHECK2(*p, elem->asnlen);
+                       ND_PRINT((ndo, "[P/%s/%s]", Class[class].name, Class[class].Id[id]));
+                       ND_TCHECK2(*p, elem->asnlen);

                        elem->type = BE_OCTET;
                        elem->type = BE_OCTET;

-                       elem->data.raw = (caddr_t)p;
+                       elem->data.raw = (const uint8_t *)p;

                        break;
                }
                break;
                        break;
                }
                break;


@@ -619,27 +618,26 @@ asn1_parse(register const u_char *p, u_int len, struct be *elem)
                        switch (id) {
                        case SEQUENCE:
                                elem->type = BE_SEQ;
                        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;
                                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;
                                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;
                        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;
                        break;
                }
                break;


@@ -649,7 +647,7 @@ asn1_parse(register const u_char *p, u_int len, struct be *elem)
        return elem->asnlen + hdr;
 
 trunc:
        return elem->asnlen + hdr;
 
 trunc:

-       printf("%s", tstr);
+       ND_PRINT((ndo, "%s", tstr));

        return -1;
 }
 
        return -1;
 }
 


@@ -659,18 +657,19 @@ trunc:
  * BE form was added.
  */
 static int
  * BE form was added.
  */
 static int

-asn1_print(struct be *elem)
+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:
 
        switch (elem->type) {
 
        case BE_OCTET:

-               TCHECK2(*p, asnlen);
+               ND_TCHECK2(*p, asnlen);

                for (i = asnlen; i-- > 0; p++)
                for (i = asnlen; i-- > 0; p++)

-                       printf("_%.2x", *p);
+                       ND_PRINT((ndo, "_%.2x", *p));

                break;
 
        case BE_NULL:
                break;
 
        case BE_NULL:


@@ -679,24 +678,24 @@ asn1_print(struct be *elem)
        case BE_OID: {
                int o = 0, first = -1, i = asnlen;
 
        case BE_OID: {
                int o = 0, first = -1, i = asnlen;
 

-               if (!sflag && !nflag && asnlen > 2) {
+               if (!ndo->ndo_sflag && !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++) {
                        const struct obj_abrev *a = &obj_abrev_list[0];
                        size_t a_len = strlen(a->oid);
                        for (; a->node; a++) {

-                               TCHECK2(*p, a_len);
-                               if (memcmp(a->oid, (char *)p, a_len) == 0) {
+                               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);
                                        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;
                                }
                        }
                }
 
                                        first = 1;
                                        break;
                                }
                        }
                }
 

-               for (; !sflag && i-- > 0; p++) {
-                       TCHECK(*p);
+               for (; !ndo->ndo_sflag && i-- > 0; p++) {
+                       ND_TCHECK(*p);

                        o = (o << ASN_SHIFT7) + (*p & ~ASN_BIT8);
                        if (*p & ASN_LONGLEN)
                                continue;
                        o = (o << ASN_SHIFT7) + (*p & ~ASN_BIT8);
                        if (*p & ASN_LONGLEN)
                                continue;


@@ -707,7 +706,7 @@ asn1_print(struct be *elem)
                         */
                        if (first < 0) {
                                int s;
                         */
                        if (first < 0) {
                                int s;

-                               if (!nflag)
+                               if (!ndo->ndo_nflag)

                                        objp = mibroot;
                                first = 0;
                                s = o / OIDMUX;
                                        objp = mibroot;
                                first = 0;
                                s = o / OIDMUX;


@@ -724,11 +723,11 @@ asn1_print(struct be *elem)
        }
 
        case BE_INT:
        }
 
        case BE_INT:

-               printf("%d", elem->data.integer);
+               ND_PRINT((ndo, "%d", elem->data.integer));

                break;
 
        case BE_UNS:
                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 */
                break;
 
        case BE_UNS64: {        /* idea borrowed from by Marshall Rose */


@@ -736,16 +735,16 @@ asn1_print(struct be *elem)
                int j, carry;
                char *cpf, *cpl, last[6], first[30];
                if (elem->data.uns64.high == 0) {
                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?*/
                }
                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
 #else

-                       printf("%f", d);
+                       ND_PRINT((ndo, "%f", d));

 #endif
                        break;
                }
 #endif
                        break;
                }


@@ -769,68 +768,67 @@ asn1_print(struct be *elem)
                        }
                        *cpf = j + '0';
                }
                        }
                        *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;
                break;
        }
 
        case BE_STR: {
                register int printable = 1, first = 1;
                const u_char *p = elem->data.str;

-               TCHECK2(*p, asnlen);
+               ND_TCHECK2(*p, asnlen);

                for (i = asnlen; printable && i-- > 0; p++)
                        printable = ND_ISPRINT(*p);
                p = elem->data.str;
                if (printable) {
                for (i = asnlen; printable && i-- > 0; p++)
                        printable = ND_ISPRINT(*p);
                p = elem->data.str;
                if (printable) {

-                       putchar('"');
-                       if (fn_printn(p, asnlen, snapend)) {
-                               putchar('"');
+                       ND_PRINT((ndo, "\""));
+                       if (fn_printn(ndo, p, asnlen, ndo->ndo_snapend)) {
+                               ND_PRINT((ndo, "\""));

                                goto trunc;
                        }
                                goto trunc;
                        }

-                       putchar('"');
+                       ND_PRINT((ndo, "\""));

                } else
                        for (i = asnlen; i-- > 0; p++) {
                } 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:
                                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)
                break;
 
        case BE_INETADDR:
                if (asnlen != ASNLEN_INETADDR)

-                       printf("[inetaddr len!=%d]", ASNLEN_INETADDR);
-               TCHECK2(*p, asnlen);
+                       ND_PRINT((ndo, "[inetaddr len!=%d]", ASNLEN_INETADDR));
+               ND_TCHECK2(*p, asnlen);

                for (i = asnlen; i-- != 0; p++) {
                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:
                }
                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:
                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:
                break;
 
        case BE_ANY:

-               fputs("[BE_ANY!?]", stdout);
+               ND_PRINT((ndo, "[BE_ANY!?]"));

                break;
 
        default:
                break;
 
        default:

-               fputs("[be!?]", stdout);
+               ND_PRINT((ndo, "[be!?]"));

                break;
        }
        return 0;
 
 trunc:
                break;
        }
        return 0;
 
 trunc:

-       printf("%s", tstr);
+       ND_PRINT((ndo, "%s", tstr));

        return -1;
 }
 
        return -1;
 }
 


@@ -851,15 +849,15 @@ asn1_decode(u_char *p, u_int length)
        int i = 0;
 
        while (i >= 0 && length > 0) {
        int i = 0;
 
        while (i >= 0 && length > 0) {

-               i = asn1_parse(p, length, &elem);
+               i = asn1_parse(ndo, p, length, &elem);

                if (i >= 0) {
                if (i >= 0) {

-                       fputs(" ", stdout);
-                       if (asn1_print(&elem) < 0)
+                       ND_PRINT((ndo, " "));
+                       if (asn1_print(ndo, &elem) < 0)

                                return;
                        if (elem.type == BE_SEQ || elem.type == BE_PDU) {
                                return;
                        if (elem.type == BE_SEQ || elem.type == BE_PDU) {

-                               fputs(" {", stdout);
+                               ND_PRINT((ndo, " {"));

                                asn1_decode(elem.data.raw, elem.asnlen);
                                asn1_decode(elem.data.raw, elem.asnlen);

-                               fputs(" }", stdout);
+                               ND_PRINT((ndo, " }"));

                        }
                        length -= i;
                        p += i;
                        }
                        length -= i;
                        p += i;


@@ -868,7 +866,7 @@ asn1_decode(u_char *p, u_int length)
 }
 #endif
 
 }
 #endif
 

-#ifdef LIBSMI
+#ifdef USE_LIBSMI

 
 struct smi2be {
     SmiBasetype basetype;
 
 struct smi2be {
     SmiBasetype basetype;


@@ -892,15 +890,17 @@ static const struct smi2be smi2betab[] = {
 };
 
 static int
 };
 
 static int

-smi_decode_oid(struct be *elem, unsigned int *oid,
-              unsigned int oidsize, unsigned int *oidlen)
+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;
        int o = 0, first = -1, i = asnlen;

+       unsigned int firstval;

 
 

-       for (*oidlen = 0; sflag && i-- > 0; p++) {
-               TCHECK(*p);
+       for (*oidlen = 0; ndo->ndo_sflag && i-- > 0; p++) {
+               ND_TCHECK(*p);

                o = (o << ASN_SHIFT7) + (*p & ~ASN_BIT8);
                if (*p & ASN_LONGLEN)
                    continue;
                o = (o << ASN_SHIFT7) + (*p & ~ASN_BIT8);
                if (*p & ASN_LONGLEN)
                    continue;


@@ -911,12 +911,12 @@ smi_decode_oid(struct be *elem, unsigned int *oid,
                 */
                if (first < 0) {
                        first = 0;
                 */
                if (first < 0) {
                        first = 0;

+                       firstval = o / OIDMUX;
+                       if (firstval > 2) firstval = 2;
+                       o -= firstval * OIDMUX;

                        if (*oidlen < oidsize) {
                        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;
                }
                if (*oidlen < oidsize) {
                        oid[(*oidlen)++] = o;


@@ -926,7 +926,7 @@ smi_decode_oid(struct be *elem, unsigned int *oid,
        return 0;
 
 trunc:
        return 0;
 
 trunc:

-       printf("%s", tstr);
+       ND_PRINT((ndo, "%s", tstr));

        return -1;
 }
 
        return -1;
 }
 


@@ -1020,29 +1020,30 @@ static int smi_check_range(SmiType *smiType, struct be *elem)
        return ok;
 }
 
        return ok;
 }
 

-static SmiNode *smi_print_variable(struct be *elem, int *status)
+static SmiNode *
+smi_print_variable(netdissect_options *ndo,
+                   struct be *elem, int *status)

 {
        unsigned int oid[128], oidlen;
        SmiNode *smiNode = NULL;
        unsigned int i;
 
 {
        unsigned int oid[128], oidlen;
        SmiNode *smiNode = NULL;
        unsigned int i;
 

-       *status = smi_decode_oid(elem, oid, sizeof(oid)/sizeof(unsigned int),
+       *status = smi_decode_oid(ndo, elem, oid, sizeof(oid) / sizeof(unsigned int),

            &oidlen);
        if (*status < 0)
                return NULL;
        smiNode = smiGetNodeByOID(oidlen, oid);
        if (! smiNode) {
            &oidlen);
        if (*status < 0)
                return NULL;
        smiNode = smiGetNodeByOID(oidlen, oid);
        if (! smiNode) {

-               *status = asn1_print(elem);
+               *status = asn1_print(ndo, elem);

                return NULL;
        }
                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) {
        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;
                }
        }
        *status = 0;


@@ -1050,7 +1051,8 @@ static SmiNode *smi_print_variable(struct be *elem, int *status)
 }
 
 static int
 }
 
 static int

-smi_print_value(SmiNode *smiNode, u_char pduid, struct be *elem)
+smi_print_value(netdissect_options *ndo,
+                SmiNode *smiNode, u_char pduid, struct be *elem)

 {
        unsigned int i, oid[128], oidlen;
        SmiType *smiType;
 {
        unsigned int i, oid[128], oidlen;
        SmiType *smiType;


@@ -1059,43 +1061,43 @@ smi_print_value(SmiNode *smiNode, u_char pduid, struct be *elem)
 
        if (! smiNode || ! (smiNode->nodekind
                            & (SMI_NODEKIND_SCALAR | SMI_NODEKIND_COLUMN))) {
 
        if (! smiNode || ! (smiNode->nodekind
                            & (SMI_NODEKIND_SCALAR | SMI_NODEKIND_COLUMN))) {

-           return asn1_print(elem);
+           return asn1_print(ndo, elem);

        }
 
        if (elem->type == BE_NOSUCHOBJECT
            || elem->type == BE_NOSUCHINST
            || elem->type == BE_ENDOFMIBVIEW) {
        }
 
        if (elem->type == BE_NOSUCHOBJECT
            || elem->type == BE_NOSUCHINST
            || elem->type == BE_ENDOFMIBVIEW) {

-           return asn1_print(elem);
+           return asn1_print(ndo, elem);

        }
 
        if (NOTIFY_CLASS(pduid) && smiNode->access < SMI_ACCESS_NOTIFY) {
        }
 
        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) {
        }
 
        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) {
        }
 
        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) {
        }
 
        if (RESPONSE_CLASS(pduid)
            && smiNode->access == SMI_ACCESS_NOT_ACCESSIBLE) {

-           fputs("[noAccess]", stdout);
+           ND_PRINT((ndo, "[noAccess]"));

        }
 
        smiType = smiGetNodeType(smiNode);
        if (! smiType) {
        }
 
        smiType = smiGetNodeType(smiNode);
        if (! smiType) {

-           return asn1_print(elem);
+           return asn1_print(ndo, elem);

        }
 
        if (! smi_check_type(smiType->basetype, elem->type)) {
        }
 
        if (! smi_check_type(smiType->basetype, elem->type)) {

-           fputs("[wrongType]", stdout);
+           ND_PRINT((ndo, "[wrongType]"));

        }
 
        if (! smi_check_range(smiType, elem)) {
        }
 
        if (! smi_check_range(smiType, elem)) {

-           fputs("[outOfRange]", stdout);
+           ND_PRINT((ndo, "[outOfRange]"));

        }
 
        /* resolve bits to named bits */
        }
 
        /* resolve bits to named bits */


@@ -1111,20 +1113,19 @@ smi_print_value(SmiNode *smiNode, u_char pduid, struct be *elem)
                if (smiType->basetype == SMI_BASETYPE_BITS) {
                        /* print bit labels */
                } else {
                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) {
                                       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++) {
                                if (smiNode->oidlen < oidlen) {
                                        for (i = smiNode->oidlen;
                                             i < oidlen; i++) {

-                                               printf(".%u", oid[i]);
+                                               ND_PRINT((ndo, ".%u", oid[i]));

                                        }
                                }
                                done++;
                                        }
                                }
                                done++;


@@ -1139,8 +1140,8 @@ smi_print_value(SmiNode *smiNode, u_char pduid, struct be *elem)
                             nn = smiGetNextNamedNumber(nn)) {
                                 if (nn->value.value.integer32
                                     == elem->data.integer) {
                             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;
                                }
                                         done++;
                                         break;
                                }


@@ -1150,7 +1151,7 @@ smi_print_value(SmiNode *smiNode, u_char pduid, struct be *elem)
        }
 
        if (! done) {
        }
 
        if (! done) {

-               return asn1_print(elem);
+               return asn1_print(ndo, elem);

        }
        return 0;
 }
        }
        return 0;
 }


@@ -1193,61 +1194,62 @@ smi_print_value(SmiNode *smiNode, u_char pduid, struct be *elem)
  * Decode SNMP varBind
  */
 static void
  * Decode SNMP varBind
  */
 static void

-varbind_print(u_char pduid, const u_char *np, u_int length)
+varbind_print(netdissect_options *ndo,
+              u_char pduid, const u_char *np, u_int length)

 {
        struct be elem;
        int count = 0, ind;
 {
        struct be elem;
        int count = 0, ind;

-#ifdef LIBSMI
+#ifdef USE_LIBSMI

        SmiNode *smiNode = NULL;
 #endif
        int status;
 
        /* Sequence of varBind */
        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) {
                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)
                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;
        /* 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;
 
 
        for (ind = 1; length > 0; ind++) {
                const u_char *vbend;
                u_int vblength;
 

-               fputs(" ", stdout);
+               ND_PRINT((ndo, " "));

 
                /* Sequence */
 
                /* Sequence */

-               if ((count = asn1_parse(np, length, &elem)) < 0)
+               if ((count = asn1_parse(ndo, np, length, &elem)) < 0)

                        return;
                if (elem.type != BE_SEQ) {
                        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;
                        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) */
 
                /* 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) {
                        return;
                if (elem.type != BE_OID) {

-                       fputs("[objName!=OID]", stdout);
-                       asn1_print(&elem);
+                       ND_PRINT((ndo, "[objName!=OID]"));
+                       asn1_print(ndo, &elem);

                        return;
                }
                        return;
                }

-#ifdef LIBSMI
-               smiNode = smi_print_variable(&elem, &status);
+#ifdef USE_LIBSMI
+               smiNode = smi_print_variable(ndo, &elem, &status);

 #else
 #else

-               status = asn1_print(&elem);
+               status = asn1_print(ndo, &elem);

 #endif
                if (status < 0)
                        return;
 #endif
                if (status < 0)
                        return;


@@ -1256,24 +1258,24 @@ varbind_print(u_char pduid, const u_char *np, u_int length)
 
                if (pduid != GETREQ && pduid != GETNEXTREQ
                    && pduid != GETBULKREQ)
 
                if (pduid != GETREQ && pduid != GETNEXTREQ
                    && pduid != GETBULKREQ)

-                       fputs("=", stdout);
+                       ND_PRINT((ndo, "="));

 
                /* objVal (ANY) */
 
                /* 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) {
                        return;
                if (pduid == GETREQ || pduid == GETNEXTREQ
                    || pduid == GETBULKREQ) {
                        if (elem.type != BE_NULL) {

-                               fputs("[objVal!=NULL]", stdout);
-                               if (asn1_print(&elem) < 0)
+                               ND_PRINT((ndo, "[objVal!=NULL]"));
+                               if (asn1_print(ndo, &elem) < 0)

                                        return;
                        }
                } else {
                        if (elem.type != BE_NULL) {
                                        return;
                        }
                } else {
                        if (elem.type != BE_NULL) {

-#ifdef LIBSMI
-                               status = smi_print_value(smiNode, pduid, &elem);
+#ifdef USE_LIBSMI
+                               status = smi_print_value(ndo, smiNode, pduid, &elem);

 #else
 #else

-                               status = asn1_print(&elem);
+                               status = asn1_print(ndo, &elem);

 #endif
                        }
                        if (status < 0)
 #endif
                        }
                        if (status < 0)


@@ -1289,30 +1291,31 @@ varbind_print(u_char pduid, const u_char *np, u_int length)
  * GetBulk, Inform, V2Trap, and Report
  */
 static void
  * GetBulk, Inform, V2Trap, and Report
  */
 static void

-snmppdu_print(u_short 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;
 
        /* reqId (Integer) */
 {
        struct be elem;
        int count = 0, error;
 
        /* 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) {
                return;
        if (elem.type != BE_INT) {

-               fputs("[reqId!=INT]", stdout);
-               asn1_print(&elem);
+               ND_PRINT((ndo, "[reqId!=INT]"));
+               asn1_print(ndo, &elem);

                return;
        }
                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) */
        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) {
                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;
                return;
        }
        error = 0;


@@ -1320,48 +1323,47 @@ snmppdu_print(u_short pduid, const u_char *np, u_int length)
            || pduid == INFORMREQ || pduid == V2TRAP || pduid == REPORT)
            && elem.data.integer != 0) {
                char errbuf[20];
            || pduid == INFORMREQ || pduid == V2TRAP || pduid == REPORT)
            && elem.data.integer != 0) {
                char errbuf[20];

-               printf("[errorStatus(%s)!=0]",
-                       DECODE_ErrorStatus(elem.data.integer));
+               ND_PRINT((ndo, "[errorStatus(%s)!=0]",
+                       DECODE_ErrorStatus(elem.data.integer)));

        } else if (pduid == GETBULKREQ) {
        } 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[20];
        } else if (elem.data.integer != 0) {
                char errbuf[20];

-               printf(" %s", DECODE_ErrorStatus(elem.data.integer));
+               ND_PRINT((ndo, " %s", DECODE_ErrorStatus(elem.data.integer)));

                error = elem.data.integer;
        }
        length -= count;
        np += count;
 
        /* errorIndex (Integer) */
                error = 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) {
                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)
                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)
        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)
        else if (elem.data.integer != 0) {
                if (!error)

-                       printf("[errorIndex(%d) w/o errorStatus]",
-                               elem.data.integer);
+                       ND_PRINT((ndo, "[errorIndex(%d) w/o errorStatus]", elem.data.integer));

                else {
                else {

-                       printf("@%d", elem.data.integer);
+                       ND_PRINT((ndo, "@%d", elem.data.integer));

                        error = elem.data.integer;
                }
        } else if (error) {
                        error = elem.data.integer;
                }
        } else if (error) {

-               fputs("[errorIndex==0]", stdout);
+               ND_PRINT((ndo, "[errorIndex==0]"));

                error = 0;
        }
        length -= count;
        np += count;
 
                error = 0;
        }
        length -= count;
        np += count;
 

-       varbind_print(pduid, np, length);
+       varbind_print(ndo, pduid, np, length);

        return;
 }
 
        return;
 }
 


@@ -1369,89 +1371,90 @@ snmppdu_print(u_short pduid, const u_char *np, u_int length)
  * Decode SNMP Trap PDU
  */
 static void
  * 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;
 
 {
        struct be elem;
        int count = 0, generic;
 

-       putchar(' ');
+       ND_PRINT((ndo, " "));

 
        /* enterprise (oid) */
 
        /* 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) {
                return;
        if (elem.type != BE_OID) {

-               fputs("[enterprise!=OID]", stdout);
-               asn1_print(&elem);
+               ND_PRINT((ndo, "[enterprise!=OID]"));
+               asn1_print(ndo, &elem);

                return;
        }
                return;
        }

-       if (asn1_print(&elem) < 0)
+       if (asn1_print(ndo, &elem) < 0)

                return;
        length -= count;
        np += count;
 
                return;
        length -= count;
        np += count;
 

-       putchar(' ');
+       ND_PRINT((ndo, " "));

 
        /* agent-addr (inetaddr) */
 
        /* 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) {
                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;
        }
                return;
        }

-       if (asn1_print(&elem) < 0)
+       if (asn1_print(ndo, &elem) < 0)

                return;
        length -= count;
        np += count;
 
        /* generic-trap (Integer) */
                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) {
                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[20];
                return;
        }
        generic = elem.data.integer;
        {
                char buf[20];

-               printf(" %s", DECODE_GenericTrap(generic));
+               ND_PRINT((ndo, " %s", DECODE_GenericTrap(generic)));

        }
        length -= count;
        np += count;
 
        /* specific-trap (Integer) */
        }
        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) {
                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)
                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
        } else

-               printf(" s=%d", elem.data.integer);
+               ND_PRINT((ndo, " s=%d", elem.data.integer));

        length -= count;
        np += count;
 
        length -= count;
        np += count;
 

-       putchar(' ');
+       ND_PRINT((ndo, " "));

 
        /* time-stamp (TimeTicks) */
 
        /* 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 */
                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;
        }
                return;
        }

-       if (asn1_print(&elem) < 0)
+       if (asn1_print(ndo, &elem) < 0)

                return;
        length -= count;
        np += count;
 
                return;
        length -= count;
        np += count;
 

-       varbind_print (TRAP, np, length);
+       varbind_print(ndo, TRAP, np, length);

        return;
 }
 
        return;
 }
 


@@ -1459,45 +1462,46 @@ trappdu_print(const u_char *np, u_int length)
  * Decode arbitrary SNMP PDUs.
  */
 static void
  * 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) */
 {
        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) {
                return;
        if (pdu.type != BE_PDU) {

-               fputs("[no PDU]", stdout);
+               ND_PRINT((ndo, "[no PDU]"));

                return;
        }
        if ((u_int)count < length)
                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, "{ "));

        }
        }

-       if (asn1_print(&pdu) < 0)
+       if (asn1_print(ndo, &pdu) < 0)

                return;
                return;

-       fputs(" ", stdout);
+       ND_PRINT((ndo, " "));

        /* descend into PDU */
        length = pdu.asnlen;
        /* 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)) {
 
        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) {
                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:
                return;
        }
 
        switch (pdu.id) {
        case TRAP:

-               trappdu_print(np, length);
+               trappdu_print(ndo, np, length);

                break;
        case GETREQ:
        case GETNEXTREQ:
                break;
        case GETREQ:
        case GETNEXTREQ:


@@ -1507,12 +1511,12 @@ pdu_print(const u_char *np, u_int length, int version)
        case INFORMREQ:
        case V2TRAP:
        case REPORT:
        case INFORMREQ:
        case V2TRAP:
        case REPORT:

-               snmppdu_print(pdu.id, np, length);
+               snmppdu_print(ndo, pdu.id, np, length);

                break;
        }
 
                break;
        }
 

-       if (vflag) {
-               fputs(" } ", stdout);
+       if (ndo->ndo_vflag) {
+               ND_PRINT((ndo, " } "));

        }
 }
 
        }
 }
 


@@ -1520,185 +1524,189 @@ pdu_print(const u_char *np, u_int length, int version)
  * Decode a scoped SNMP PDU.
  */
 static void
  * 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 */
 {
        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) {
                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;
                return;
        }
        length = elem.asnlen;

-       np = (u_char *)elem.data.raw;
+       np = (const u_char *)elem.data.raw;

 
        /* contextEngineID (OCTET STRING) */
 
        /* 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) {
                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;
 
                return;
        }
        length -= count;
        np += count;
 

-       fputs("E= ", stdout);
+       ND_PRINT((ndo, "E= "));

        for (i = 0; i < (int)elem.asnlen; i++) {
        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) */
 
        /* 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) {
                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;
 
                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
 }
 
 /*
  * 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) */
 {
        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) {
                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 &&
                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" */
                    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;
 
        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
 }
 
 /*
  * 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 */
 {
         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) {
                return;
        if (elem.type != BE_SEQ) {

-               fputs("[!usm]", stdout);
-               asn1_print(&elem);
+               ND_PRINT((ndo, "[!usm]"));
+               asn1_print(ndo, &elem);

                return;
        }
        length = elem.asnlen;
                return;
        }
        length = elem.asnlen;

-       np = (u_char *)elem.data.raw;
+       np = (const u_char *)elem.data.raw;

 
        /* msgAuthoritativeEngineID (OCTET STRING) */
 
        /* 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) {
                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) */
                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) {
                return;
        if (elem.type != BE_INT) {

-               fputs("[msgAuthoritativeEngineBoots!=INT]", stdout);
-               asn1_print(&elem);
+               ND_PRINT((ndo, "[msgAuthoritativeEngineBoots!=INT]"));
+               asn1_print(ndo, &elem);

                return;
        }
                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) */
        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) {
                return;
        if (elem.type != BE_INT) {

-               fputs("[msgAuthoritativeEngineTime!=INT]", stdout);
-               asn1_print(&elem);
+               ND_PRINT((ndo, "[msgAuthoritativeEngineTime!=INT]"));
+               asn1_print(ndo, &elem);

                return;
        }
                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) */
        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) {
                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;
 
                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) */
 
        /* 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) {
                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) */
                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) {
                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)
                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
 }
 
 /*
  * 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;
 {
        struct be elem;
        int count = 0;


@@ -1708,75 +1716,74 @@ v3msg_print(const u_char *np, u_int length)
        int xlength = length;
 
        /* Sequence */
        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) {
                return;
        if (elem.type != BE_SEQ) {

-               fputs("[!message]", stdout);
-               asn1_print(&elem);
+               ND_PRINT((ndo, "[!message]"));
+               asn1_print(ndo, &elem);

                return;
        }
        length = elem.asnlen;
                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) */
        }
 
        /* 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) {
                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) */
                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) {
                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) */
                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) {
                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) {
                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) {
                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;
 
                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) */
 
        /* 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) {
                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;
                return;
        }
        model = elem.data.integer;


@@ -1784,18 +1791,18 @@ v3msg_print(const u_char *np, u_int length)
        np += count;
 
        if ((u_int)count < 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 (model == 3) {

-           if (vflag) {
-               fputs("{ USM ", stdout);
+           if (ndo->ndo_vflag) {
+               ND_PRINT((ndo, "{ USM "));

            }
        } else {
            }
        } else {

-           printf("[security model %d]", model);
+           ND_PRINT((ndo, "[security model %d]", model));

             return;
        }
 
             return;
        }
 


@@ -1803,31 +1810,31 @@ v3msg_print(const u_char *np, u_int length)
        length = xlength - (np - xnp);
 
        /* msgSecurityParameters (OCTET STRING) */
        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) {
                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) {
                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, "} "));

        }
 }
 
        }
 }
 


@@ -1835,34 +1842,35 @@ v3msg_print(const u_char *np, u_int length)
  * Decode SNMP header and pass on to PDU printing routines
  */
 void
  * 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;
 
 {
        struct be elem;
        int count = 0;
        int version = 0;
 

-       putchar(' ');
+       ND_PRINT((ndo, " "));

 
        /* initial Sequence */
 
        /* 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) {
                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)
                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;
        /* descend */
        length = elem.asnlen;

-       np = (u_char *)elem.data.raw;
+       np = (const u_char *)elem.data.raw;

 
        /* Version (INTEGER) */
 
        /* 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) {
                return;
        if (elem.type != BE_INT) {

-               fputs("[version!=INT]", stdout);
-               asn1_print(&elem);
+               ND_PRINT((ndo, "[version!=INT]"));
+               asn1_print(ndo, &elem);

                return;
        }
 
                return;
        }
 


@@ -1870,11 +1878,11 @@ snmp_print(const u_char *np, u_int length)
        case SNMP_VERSION_1:
        case SNMP_VERSION_2:
        case SNMP_VERSION_3:
        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:
                break;
        default:

-               printf("[version = %d]", elem.data.integer);
+               ND_PRINT((ndo, "[version = %d]", elem.data.integer));

                return;
        }
        version = elem.data.integer;
                return;
        }
        version = elem.data.integer;


@@ -1884,17 +1892,17 @@ snmp_print(const u_char *np, u_int length)
        switch (version) {
        case SNMP_VERSION_1:
         case SNMP_VERSION_2:
        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:
                break;
        case SNMP_VERSION_3:

-               v3msg_print(np, length);
+               v3msg_print(ndo, np, length);

                break;
        default:
                break;
        default:

-               printf("[version = %d]", elem.data.integer);
+               ND_PRINT((ndo, "[version = %d]", elem.data.integer));

                break;
        }
 
                break;
        }
 

-       if (vflag) {
-               fputs("} ", stdout);
+       if (ndo->ndo_vflag) {
+               ND_PRINT((ndo, "} "));

        }
 }
        }
 }