OpenFlow: Use bittok2str(), fix OF1.0 port status.

[tcpdump] / print-snmp.c

diff --git a/print-snmp.c b/print-snmp.c
index 3ca219016d89c600dc9c5b8787665fd9fc9e9b7f..a38fee2e4f25970a7035553a2918f67c5e5e78ef 100644 (file)
--- a/print-snmp.c
+++ b/print-snmp.c
@@ -59,10 +59,10 @@
 /* \summary: Simple Network Management Protocol (SNMP) printer */
 
 #ifdef HAVE_CONFIG_H
 /* \summary: Simple Network Management Protocol (SNMP) printer */
 
 #ifdef HAVE_CONFIG_H

-#include "config.h"
+#include <config.h>

 #endif
 
 #endif
 

-#include <netdissect-stdinc.h>
+#include "netdissect-stdinc.h"

 
 #include <stdio.h>
 #include <string.h>
 
 #include <stdio.h>
 #include <string.h>


@@ -71,11 +71,13 @@
 #include <smi.h>
 #endif
 
 #include <smi.h>
 #endif
 

+#include "netdissect-ctype.h"
+

 #include "netdissect.h"
 #include "netdissect.h"

+#include "extract.h"

 
 #undef OPAQUE  /* defined in <wingdi.h> */
 
 
 #undef OPAQUE  /* defined in <wingdi.h> */
 

-static const char tstr[] = "[|snmp]";

 
 /*
  * Universal ASN.1 types
 
 /*
  * Universal ASN.1 types


@@ -276,28 +278,46 @@ static struct obj {
  * Currently, this includes the prefixes for the Internet MIB, the
  * private enterprises tree, and the experimental tree.
  */
  * Currently, this includes the prefixes for the Internet MIB, the
  * private enterprises tree, and the experimental tree.
  */

+#define OID_FIRST_OCTET(x, y)  (((x)*40) + (y))        /* X.690 8.19.4 */
+
+#ifndef NO_ABREV_MIB
+static const uint8_t mib_oid[] = { OID_FIRST_OCTET(1, 3), 6, 1, 2, 1 };
+#endif
+#ifndef NO_ABREV_ENTER
+static const uint8_t enterprises_oid[] = { OID_FIRST_OCTET(1, 3), 6, 1, 4, 1 };
+#endif
+#ifndef NO_ABREV_EXPERI
+static const uint8_t experimental_oid[] = { OID_FIRST_OCTET(1, 3), 6, 1, 3 };
+#endif
+#ifndef NO_ABBREV_SNMPMODS
+static const uint8_t snmpModules_oid[] = { OID_FIRST_OCTET(1, 3), 6, 1, 6, 3 };
+#endif
+
+#define OBJ_ABBREV_ENTRY(prefix, obj) \
+       { prefix, &_ ## obj ## _obj, obj ## _oid, sizeof (obj ## _oid) }

 static const struct obj_abrev {
        const char *prefix;             /* prefix for this abrev */
        struct obj *node;               /* pointer into object table */
 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 */
+       const uint8_t *oid;             /* ASN.1 encoded OID */
+       size_t oid_len;                 /* length of OID */

 } obj_abrev_list[] = {
 #ifndef NO_ABREV_MIB
        /* .iso.org.dod.internet.mgmt.mib */
 } obj_abrev_list[] = {
 #ifndef NO_ABREV_MIB
        /* .iso.org.dod.internet.mgmt.mib */

-       { "",   &_mib_obj,              "\53\6\1\2\1" },
+       OBJ_ABBREV_ENTRY("",    mib),

 #endif
 #ifndef NO_ABREV_ENTER
        /* .iso.org.dod.internet.private.enterprises */
 #endif
 #ifndef NO_ABREV_ENTER
        /* .iso.org.dod.internet.private.enterprises */

-       { "E:", &_enterprises_obj,      "\53\6\1\4\1" },
+       OBJ_ABBREV_ENTRY("E:",  enterprises),

 #endif
 #ifndef NO_ABREV_EXPERI
        /* .iso.org.dod.internet.experimental */
 #endif
 #ifndef NO_ABREV_EXPERI
        /* .iso.org.dod.internet.experimental */

-       { "X:", &_experimental_obj,     "\53\6\1\3" },
+       OBJ_ABBREV_ENTRY("X:",  experimental),

 #endif
 #ifndef NO_ABBREV_SNMPMODS
        /* .iso.org.dod.internet.snmpV2.snmpModules */
 #endif
 #ifndef NO_ABBREV_SNMPMODS
        /* .iso.org.dod.internet.snmpV2.snmpModules */

-        { "S:", &_snmpModules_obj,      "\53\6\1\6\3" },
+       OBJ_ABBREV_ENTRY("S:",  snmpModules),

 #endif
 #endif

-       { 0,0,0 }
+       { 0,0,0,0 }

 };
 
 /*
 };
 
 /*


@@ -313,10 +333,10 @@ static const struct obj_abrev {
                } while ((objp = objp->next) != NULL); \
        } \
        if (objp) { \
                } while ((objp = objp->next) != NULL); \
        } \
        if (objp) { \

-               ND_PRINT((ndo, suppressdot?"%s":".%s", objp->desc)); \
+               ND_PRINT(suppressdot?"%s":".%s", objp->desc); \

                objp = objp->child; \
        } else \
                objp = objp->child; \
        } else \

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

 }
 
 /*
 }
 
 /*


@@ -399,18 +419,17 @@ static const char *SnmpVersion[] = {
  */
 static int
 asn1_parse(netdissect_options *ndo,
  */
 static int
 asn1_parse(netdissect_options *ndo,

-           register const u_char *p, u_int len, struct be *elem)
+           const u_char *p, u_int len, struct be *elem)

 {
        u_char form, class, id;
 {
        u_char form, class, id;

-       int i, hdr;
+       u_int i, hdr;

 
        elem->asnlen = 0;
        elem->type = BE_ANY;
        if (len < 1) {
 
        elem->asnlen = 0;
        elem->type = BE_ANY;
        if (len < 1) {

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

                return -1;
        }
                return -1;
        }

-       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.


@@ -419,14 +438,14 @@ asn1_parse(netdissect_options *ndo,
         *  +---+---+---+---+---+---+---+---+
         *    7   6   5   4   3   2   1   0
         */
         *  +---+---+---+---+---+---+---+---+
         *    7   6   5   4   3   2   1   0
         */

-       id = *p & ASN_ID_BITS;          /* lower 5 bits, range 00-1f */
+       id = GET_U_1(p) & ASN_ID_BITS;          /* lower 5 bits, range 00-1f */

 #ifdef notdef
 #ifdef notdef

-       form = (*p & 0xe0) >> 5;        /* move upper 3 bits to lower 3 */
+       form = (GET_U_1(p) & 0xe0) >> 5;        /* move upper 3 bits to lower 3 */

        class = form >> 1;              /* bits 7&6 -> bits 1&0, range 0-3 */
        form &= 0x1;                    /* bit 5 -> bit 0, range 0-1 */
 #else
        class = form >> 1;              /* bits 7&6 -> bits 1&0, range 0-3 */
        form &= 0x1;                    /* bit 5 -> bit 0, range 0-1 */
 #else

-       form = (u_char)(*p & ASN_FORM_BITS) >> ASN_FORM_SHIFT;
-       class = (u_char)(*p & ASN_CLASS_BITS) >> ASN_CLASS_SHIFT;
+       form = (u_char)(GET_U_1(p) & ASN_FORM_BITS) >> ASN_FORM_SHIFT;
+       class = (u_char)(GET_U_1(p) & ASN_CLASS_BITS) >> ASN_CLASS_SHIFT;

 #endif
        elem->form = form;
        elem->class = class;
 #endif
        elem->form = form;
        elem->class = class;


@@ -445,62 +464,61 @@ asn1_parse(netdissect_options *ndo,
                 * that won't fit in 32 bits.
                 */
                id = 0;
                 * that won't fit in 32 bits.
                 */
                id = 0;

-               ND_TCHECK(*p);
-               while (*p & ASN_BIT8) {
+               while (GET_U_1(p) & ASN_BIT8) {

                        if (len < 1) {
                        if (len < 1) {

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

                                return -1;
                        }
                                return -1;
                        }

-                       id = (id << 7) | (*p & ~ASN_BIT8);
+                       id = (id << 7) | (GET_U_1(p) & ~ASN_BIT8);

                        len--;
                        hdr++;
                        p++;
                        len--;
                        hdr++;
                        p++;

-                       ND_TCHECK(*p);

                }
                if (len < 1) {
                }
                if (len < 1) {

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

                        return -1;
                }
                        return -1;
                }

-               ND_TCHECK(*p);
-               elem->id = id = (id << 7) | *p;
+               elem->id = id = (id << 7) | GET_U_1(p);

                --len;
                ++hdr;
                ++p;
        }
        if (len < 1) {
                --len;
                ++hdr;
                ++p;
        }
        if (len < 1) {

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

                return -1;
        }
                return -1;
        }

-       ND_TCHECK(*p);
-       elem->asnlen = *p;
+       elem->asnlen = GET_U_1(p);

        p++; len--; hdr++;
        if (elem->asnlen & ASN_BIT8) {
                uint32_t noct = elem->asnlen % ASN_BIT8;
                elem->asnlen = 0;
                if (len < noct) {
        p++; len--; hdr++;
        if (elem->asnlen & ASN_BIT8) {
                uint32_t noct = elem->asnlen % ASN_BIT8;
                elem->asnlen = 0;
                if (len < noct) {

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

                        return -1;
                }
                        return -1;
                }

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

        }
        if (len < elem->asnlen) {
        }
        if (len < elem->asnlen) {

-               ND_PRINT((ndo, "[len%d<asnlen%u]", len, elem->asnlen));
+               ND_PRINT("[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])) {

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

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

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

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

-               ND_PRINT((ndo, "[id?%c/%s/%d]", *Form[form], Class[class].name, id));
+               ND_PRINT("[id?%c/%s/%d]", *Form[form], Class[class].name, id);

                return -1;
        }
                return -1;
        }

+       ND_TCHECK_LEN(p, elem->asnlen);

 
        switch (form) {
        case PRIMITIVE:
 
        switch (form) {
        case PRIMITIVE:


@@ -513,19 +531,18 @@ asn1_parse(netdissect_options *ndo,
                                break;
 
                        case INTEGER: {
                                break;
 
                        case INTEGER: {

-                               register int32_t data;
+                               int32_t data;

                                elem->type = BE_INT;
                                data = 0;
 
                                if (elem->asnlen == 0) {
                                elem->type = BE_INT;
                                data = 0;
 
                                if (elem->asnlen == 0) {

-                                       ND_PRINT((ndo, "[asnlen=0]"));
+                                       ND_PRINT("[asnlen=0]");

                                        return -1;
                                }
                                        return -1;
                                }

-                               ND_TCHECK2(*p, elem->asnlen);
-                               if (*p & ASN_BIT8)      /* negative */
+                               if (GET_U_1(p) & ASN_BIT8)      /* negative */

                                        data = -1;
                                        data = -1;

-                               for (i = elem->asnlen; i-- > 0; p++)
-                                       data = (data << ASN_SHIFT8) | *p;
+                               for (i = elem->asnlen; i != 0; p++, i--)
+                                       data = (data << ASN_SHIFT8) | GET_U_1(p);

                                elem->data.integer = data;
                                break;
                        }
                                elem->data.integer = data;
                                break;
                        }


@@ -543,7 +560,7 @@ asn1_parse(netdissect_options *ndo,
                        default:
                                elem->type = BE_OCTET;
                                elem->data.raw = (const uint8_t *)p;
                        default:
                                elem->type = BE_OCTET;
                                elem->data.raw = (const uint8_t *)p;

-                               ND_PRINT((ndo, "[P/U/%s]", Class[class].Id[id]));
+                               ND_PRINT("[P/U/%s]", Class[class].Id[id]);

                                break;
                        }
                        break;
                                break;
                        }
                        break;


@@ -558,23 +575,21 @@ asn1_parse(netdissect_options *ndo,
                        case COUNTER:
                        case GAUGE:
                        case TIMETICKS: {
                        case COUNTER:
                        case GAUGE:
                        case TIMETICKS: {

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

                                elem->type = BE_UNS;
                                data = 0;
                                elem->type = BE_UNS;
                                data = 0;

-                               for (i = elem->asnlen; i-- > 0; p++)
-                                       data = (data << 8) + *p;
+                               for (i = elem->asnlen; i != 0; p++, i--)
+                                       data = (data << 8) + GET_U_1(p);

                                elem->data.uns = data;
                                break;
                        }
 
                        case COUNTER64: {
                                elem->data.uns = data;
                                break;
                        }
 
                        case COUNTER64: {

-                               register uint64_t data64;
-                               ND_TCHECK2(*p, elem->asnlen);
+                               uint64_t data64;

                                elem->type = BE_UNS64;
                                data64 = 0;
                                elem->type = BE_UNS64;
                                data64 = 0;

-                               for (i = elem->asnlen; i-- > 0; p++)
-                                       data64 = (data64 << 8) + *p;
+                               for (i = elem->asnlen; i != 0; p++, i--)
+                                       data64 = (data64 << 8) + GET_U_1(p);

                                elem->data.uns64 = data64;
                                break;
                        }
                                elem->data.uns64 = data64;
                                break;
                        }


@@ -582,8 +597,8 @@ asn1_parse(netdissect_options *ndo,
                        default:
                                elem->type = BE_OCTET;
                                elem->data.raw = (const uint8_t *)p;
                        default:
                                elem->type = BE_OCTET;
                                elem->data.raw = (const uint8_t *)p;

-                               ND_PRINT((ndo, "[P/A/%s]",
-                                       Class[class].Id[id]));
+                               ND_PRINT("[P/A/%s]",
+                                       Class[class].Id[id]);

                                break;
                        }
                        break;
                                break;
                        }
                        break;


@@ -608,8 +623,7 @@ asn1_parse(netdissect_options *ndo,
                        break;
 
                default:
                        break;
 
                default:

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

                        elem->type = BE_OCTET;
                        elem->data.raw = (const uint8_t *)p;
                        break;
                        elem->type = BE_OCTET;
                        elem->data.raw = (const uint8_t *)p;
                        break;


@@ -628,7 +642,7 @@ asn1_parse(netdissect_options *ndo,
                        default:
                                elem->type = BE_OCTET;
                                elem->data.raw = (const uint8_t *)p;
                        default:
                                elem->type = BE_OCTET;
                                elem->data.raw = (const uint8_t *)p;

-                               ND_PRINT((ndo, "C/U/%s", Class[class].Id[id]));
+                               ND_PRINT("C/U/%s", Class[class].Id[id]);

                                break;
                        }
                        break;
                                break;
                        }
                        break;


@@ -641,7 +655,7 @@ asn1_parse(netdissect_options *ndo,
                default:
                        elem->type = BE_OCTET;
                        elem->data.raw = (const uint8_t *)p;
                default:
                        elem->type = BE_OCTET;
                        elem->data.raw = (const uint8_t *)p;

-                       ND_PRINT((ndo, "C/%s/%s", Class[class].name, Class[class].Id[id]));
+                       ND_PRINT("C/%s/%s", Class[class].name, Class[class].Id[id]);

                        break;
                }
                break;
                        break;
                }
                break;


@@ -651,7 +665,7 @@ asn1_parse(netdissect_options *ndo,
        return elem->asnlen + hdr;
 
 trunc:
        return elem->asnlen + hdr;
 
 trunc:

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

        return -1;
 }
 
        return -1;
 }
 


@@ -662,46 +676,46 @@ asn1_print_octets(netdissect_options *ndo, struct be *elem)
        uint32_t asnlen = elem->asnlen;
        uint32_t i;
 
        uint32_t asnlen = elem->asnlen;
        uint32_t i;
 

-       ND_TCHECK2(*p, asnlen);
-       for (i = asnlen; i-- > 0; p++)
-               ND_PRINT((ndo, "_%.2x", *p));
+       ND_TCHECK_LEN(p, asnlen);
+       for (i = asnlen; i != 0; p++, i--)
+               ND_PRINT("_%.2x", GET_U_1(p));

        return 0;
 
 trunc:
        return 0;
 
 trunc:

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

        return -1;
 }
 
 static int
 asn1_print_string(netdissect_options *ndo, struct be *elem)
 {
        return -1;
 }
 
 static int
 asn1_print_string(netdissect_options *ndo, struct be *elem)
 {

-       register int printable = 1, first = 1;
+       int printable = 1, first = 1;

        const u_char *p;
        uint32_t asnlen = elem->asnlen;
        uint32_t i;
 
        p = elem->data.str;
        const u_char *p;
        uint32_t asnlen = elem->asnlen;
        uint32_t i;
 
        p = elem->data.str;

-       ND_TCHECK2(*p, asnlen);
-       for (i = asnlen; printable && i-- > 0; p++)
-               printable = ND_ISPRINT(*p);
+       ND_TCHECK_LEN(p, asnlen);
+       for (i = asnlen; printable && i != 0; p++, i--)
+               printable = ND_ASCII_ISPRINT(GET_U_1(p));

        p = elem->data.str;
        if (printable) {
        p = elem->data.str;
        if (printable) {

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

                        goto trunc;
                }
                        goto trunc;
                }

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

        } else {
        } else {

-               for (i = asnlen; i-- > 0; p++) {
-                       ND_PRINT((ndo, first ? "%.2x" : "_%.2x", *p));
+               for (i = asnlen; i != 0; p++, i--) {
+                       ND_PRINT(first ? "%.2x" : "_%.2x", GET_U_1(p));

                        first = 0;
                }
        }
        return 0;
 
 trunc:
                        first = 0;
                }
        }
        return 0;
 
 trunc:

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

        return -1;
 }
 
        return -1;
 }
 


@@ -733,65 +747,62 @@ asn1_print(netdissect_options *ndo,
 
                p = (const u_char *)elem->data.raw;
                i = asnlen;
 
                p = (const u_char *)elem->data.raw;
                i = asnlen;

-               if (!nd_smi_module_loaded) {
-                       if (!ndo->ndo_nflag && asnlen > 2) {
-                               const struct obj_abrev *a = &obj_abrev_list[0];
-                               for (; a->node; a++) {
-                                       size_t a_len = strlen(a->oid);
-                                       ND_TCHECK2(*p, a_len);
-                                       if (memcmp(a->oid, p, a_len) == 0) {
-                                               objp = a->node->child;
-                                               if (i < a_len)
-                                                       goto trunc;
-                                               i -= a_len;
-                                               p += a_len;
-                                               ND_PRINT((ndo, "%s", a->prefix));
-                                               first = 1;
-                                               break;
-                                       }
+               if (!ndo->ndo_nflag && asnlen > 2) {
+                       const struct obj_abrev *a = &obj_abrev_list[0];
+                       for (; a->node; a++) {
+                               if (i < a->oid_len)
+                                       continue;
+                               if (!ND_TTEST_LEN(p, a->oid_len))
+                                       continue;
+                               if (memcmp(a->oid, p, a->oid_len) == 0) {
+                                       objp = a->node->child;
+                                       i -= a->oid_len;
+                                       p += a->oid_len;
+                                       ND_PRINT("%s", a->prefix);
+                                       first = 1;
+                                       break;

                                }
                        }
                                }
                        }

+               }

 
 

-                       for (; i-- > 0; p++) {
-                               ND_TCHECK(*p);
-                               o = (o << ASN_SHIFT7) + (*p & ~ASN_BIT8);
-                               if (*p & ASN_LONGLEN)
-                                       continue;
-
-                               /*
-                                * first subitem encodes two items with
-                                * 1st*OIDMUX+2nd
-                                * (see X.690:1997 clause 8.19 for the details)
-                                */
-                               if (first < 0) {
-                                       int s;
-                                       if (!ndo->ndo_nflag)
-                                               objp = mibroot;
-                                       first = 0;
-                                       s = o / OIDMUX;
-                                       if (s > 2) s = 2;
-                                       OBJ_PRINT(s, first);
-                                       o -= s * OIDMUX;
-                               }
-                               OBJ_PRINT(o, first);
-                               if (--first < 0)
-                                       first = 0;
-                               o = 0;
+               for (; i != 0; p++, i--) {
+                       o = (o << ASN_SHIFT7) + (GET_U_1(p) & ~ASN_BIT8);
+                       if (GET_U_1(p) & ASN_LONGLEN)
+                               continue;
+
+                       /*
+                        * first subitem encodes two items with
+                        * 1st*OIDMUX+2nd
+                        * (see X.690:1997 clause 8.19 for the details)
+                        */
+                       if (first < 0) {
+                               int s;
+                               if (!ndo->ndo_nflag)
+                                       objp = mibroot;
+                               first = 0;
+                               s = o / OIDMUX;
+                               if (s > 2) s = 2;
+                               OBJ_PRINT(s, first);
+                               o -= s * OIDMUX;

                        }
                        }

+                       OBJ_PRINT(o, first);
+                       if (--first < 0)
+                               first = 0;
+                       o = 0;

                }
                break;
        }
 
        case BE_INT:
                }
                break;
        }
 
        case BE_INT:

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

                break;
 
        case BE_UNS:
                break;
 
        case BE_UNS:

-               ND_PRINT((ndo, "%u", elem->data.uns));
+               ND_PRINT("%u", elem->data.uns);

                break;
 
        case BE_UNS64:
                break;
 
        case BE_UNS64:

-               ND_PRINT((ndo, "%" PRIu64, elem->data.uns64));
+               ND_PRINT("%" PRIu64, elem->data.uns64);

                break;
 
        case BE_STR:
                break;
 
        case BE_STR:


@@ -800,41 +811,41 @@ asn1_print(netdissect_options *ndo,
                break;
 
        case BE_SEQ:
                break;
 
        case BE_SEQ:

-               ND_PRINT((ndo, "Seq(%u)", elem->asnlen));
+               ND_PRINT("Seq(%u)", elem->asnlen);

                break;
 
        case BE_INETADDR:
                if (asnlen != ASNLEN_INETADDR)
                break;
 
        case BE_INETADDR:
                if (asnlen != ASNLEN_INETADDR)

-                       ND_PRINT((ndo, "[inetaddr len!=%d]", ASNLEN_INETADDR));
+                       ND_PRINT("[inetaddr len!=%d]", ASNLEN_INETADDR);

                p = (const u_char *)elem->data.raw;
                p = (const u_char *)elem->data.raw;

-               ND_TCHECK2(*p, asnlen);
-               for (i = asnlen; i-- != 0; p++) {
-                       ND_PRINT((ndo, (i == asnlen-1) ? "%u" : ".%u", *p));
+               ND_TCHECK_LEN(p, asnlen);
+               for (i = asnlen; i != 0; p++, i--) {
+                       ND_PRINT((i == asnlen) ? "%u" : ".%u", GET_U_1(p));

                }
                break;
 
        case BE_NOSUCHOBJECT:
        case BE_NOSUCHINST:
        case BE_ENDOFMIBVIEW:
                }
                break;
 
        case BE_NOSUCHOBJECT:
        case BE_NOSUCHINST:
        case BE_ENDOFMIBVIEW:

-               ND_PRINT((ndo, "[%s]", Class[EXCEPTIONS].Id[elem->id]));
+               ND_PRINT("[%s]", Class[EXCEPTIONS].Id[elem->id]);

                break;
 
        case BE_PDU:
                break;
 
        case BE_PDU:

-               ND_PRINT((ndo, "%s(%u)", Class[CONTEXT].Id[elem->id], elem->asnlen));
+               ND_PRINT("%s(%u)", Class[CONTEXT].Id[elem->id], elem->asnlen);

                break;
 
        case BE_ANY:
                break;
 
        case BE_ANY:

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

                break;
 
        default:
                break;
 
        default:

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

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

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

        return -1;
 }
 
        return -1;
 }
 


@@ -857,13 +868,13 @@ asn1_decode(u_char *p, u_int length)
        while (i >= 0 && length > 0) {
                i = asn1_parse(ndo, p, length, &elem);
                if (i >= 0) {
        while (i >= 0 && length > 0) {
                i = asn1_parse(ndo, p, length, &elem);
                if (i >= 0) {

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

                        if (asn1_print(ndo, &elem) < 0)
                                return;
                        if (elem.type == BE_SEQ || elem.type == BE_PDU) {
                        if (asn1_print(ndo, &elem) < 0)
                                return;
                        if (elem.type == BE_SEQ || elem.type == BE_PDU) {

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

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

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

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


@@ -902,40 +913,34 @@ smi_decode_oid(netdissect_options *ndo,
 {
        const u_char *p = (const u_char *)elem->data.raw;
        uint32_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;
+       uint32_t i = asnlen;
+       int o = 0, first = -1;

        unsigned int firstval;
 
        unsigned int firstval;
 

-       if (nd_smi_module_loaded) {
-               for (*oidlen = 0; i-- > 0; p++) {
-                       ND_TCHECK(*p);
-                       o = (o << ASN_SHIFT7) + (*p & ~ASN_BIT8);
-                       if (*p & ASN_LONGLEN)
-                           continue;
+       for (*oidlen = 0; i != 0; p++, i--) {
+               o = (o << ASN_SHIFT7) + (GET_U_1(p) & ~ASN_BIT8);
+               if (GET_U_1(p) & ASN_LONGLEN)
+                   continue;

 
 

-                       /*
-                        * first subitem encodes two items with 1st*OIDMUX+2nd
-                        * (see X.690:1997 clause 8.19 for the details)
-                        */
-                       if (first < 0) {
-                               first = 0;
-                               firstval = o / OIDMUX;
-                               if (firstval > 2) firstval = 2;
-                               o -= firstval * OIDMUX;
-                               if (*oidlen < oidsize) {
-                                   oid[(*oidlen)++] = firstval;
-                               }
-                       }
+               /*
+                * first subitem encodes two items with 1st*OIDMUX+2nd
+                * (see X.690:1997 clause 8.19 for the details)
+                */
+               if (first < 0) {
+                       first = 0;
+                       firstval = o / OIDMUX;
+                       if (firstval > 2) firstval = 2;
+                       o -= firstval * OIDMUX;

                        if (*oidlen < oidsize) {
                        if (*oidlen < oidsize) {

-                               oid[(*oidlen)++] = o;
+                           oid[(*oidlen)++] = firstval;

                        }
                        }

-                       o = 0;

                }
                }

+               if (*oidlen < oidsize) {
+                       oid[(*oidlen)++] = o;
+               }
+               o = 0;

        }
        return 0;
        }
        return 0;

-
-trunc:
-       ND_PRINT((ndo, "%s", tstr));
-       return -1;

 }
 
 static int smi_check_type(SmiBasetype basetype, int be)
 }
 
 static int smi_check_type(SmiBasetype basetype, int be)


@@ -1036,6 +1041,10 @@ smi_print_variable(netdissect_options *ndo,
        SmiNode *smiNode = NULL;
        unsigned int i;
 
        SmiNode *smiNode = NULL;
        unsigned int i;
 

+       if (!nd_smi_module_loaded) {
+               *status = asn1_print(ndo, elem);
+               return NULL;
+       }

        *status = smi_decode_oid(ndo, elem, oid, sizeof(oid) / sizeof(unsigned int),
            &oidlen);
        if (*status < 0)
        *status = smi_decode_oid(ndo, elem, oid, sizeof(oid) / sizeof(unsigned int),
            &oidlen);
        if (*status < 0)


@@ -1046,12 +1055,12 @@ smi_print_variable(netdissect_options *ndo,
                return NULL;
        }
        if (ndo->ndo_vflag) {
                return NULL;
        }
        if (ndo->ndo_vflag) {

-               ND_PRINT((ndo, "%s::", smiGetNodeModule(smiNode)->name));
+               ND_PRINT("%s::", smiGetNodeModule(smiNode)->name);

        }
        }

-       ND_PRINT((ndo, "%s", smiNode->name));
+       ND_PRINT("%s", smiNode->name);

        if (smiNode->oidlen < oidlen) {
                for (i = smiNode->oidlen; i < oidlen; i++) {
        if (smiNode->oidlen < oidlen) {
                for (i = smiNode->oidlen; i < oidlen; i++) {

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

                }
        }
        *status = 0;
                }
        }
        *status = 0;


@@ -1079,20 +1088,20 @@ smi_print_value(netdissect_options *ndo,
        }
 
        if (NOTIFY_CLASS(pduid) && smiNode->access < SMI_ACCESS_NOTIFY) {
        }
 
        if (NOTIFY_CLASS(pduid) && smiNode->access < SMI_ACCESS_NOTIFY) {

-           ND_PRINT((ndo, "[notNotifyable]"));
+           ND_PRINT("[notNotifyable]");

        }
 
        if (READ_CLASS(pduid) && smiNode->access < SMI_ACCESS_READ_ONLY) {
        }
 
        if (READ_CLASS(pduid) && smiNode->access < SMI_ACCESS_READ_ONLY) {

-           ND_PRINT((ndo, "[notReadable]"));
+           ND_PRINT("[notReadable]");

        }
 
        if (WRITE_CLASS(pduid) && smiNode->access < SMI_ACCESS_READ_WRITE) {
        }
 
        if (WRITE_CLASS(pduid) && smiNode->access < SMI_ACCESS_READ_WRITE) {

-           ND_PRINT((ndo, "[notWritable]"));
+           ND_PRINT("[notWritable]");

        }
 
        if (RESPONSE_CLASS(pduid)
            && smiNode->access == SMI_ACCESS_NOT_ACCESSIBLE) {
        }
 
        if (RESPONSE_CLASS(pduid)
            && smiNode->access == SMI_ACCESS_NOT_ACCESSIBLE) {

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

        }
 
        smiType = smiGetNodeType(smiNode);
        }
 
        smiType = smiGetNodeType(smiNode);


@@ -1101,11 +1110,11 @@ smi_print_value(netdissect_options *ndo,
        }
 
        if (! smi_check_type(smiType->basetype, elem->type)) {
        }
 
        if (! smi_check_type(smiType->basetype, elem->type)) {

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

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

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

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


@@ -1121,22 +1130,24 @@ smi_print_value(netdissect_options *ndo,
                if (smiType->basetype == SMI_BASETYPE_BITS) {
                        /* print bit labels */
                } else {
                if (smiType->basetype == SMI_BASETYPE_BITS) {
                        /* print bit labels */
                } else {

-                       smi_decode_oid(ndo, elem, oid,
-                                      sizeof(oid)/sizeof(unsigned int),
-                                      &oidlen);
-                       smiNode = smiGetNodeByOID(oidlen, oid);
-                       if (smiNode) {
-                               if (ndo->ndo_vflag) {
-                                       ND_PRINT((ndo, "%s::", smiGetNodeModule(smiNode)->name));
-                               }
-                               ND_PRINT((ndo, "%s", smiNode->name));
-                               if (smiNode->oidlen < oidlen) {
-                                       for (i = smiNode->oidlen;
-                                            i < oidlen; i++) {
-                                               ND_PRINT((ndo, ".%u", oid[i]));
+                       if (nd_smi_module_loaded &&
+                           smi_decode_oid(ndo, elem, oid,
+                                          sizeof(oid)/sizeof(unsigned int),
+                                          &oidlen) == 0) {
+                               smiNode = smiGetNodeByOID(oidlen, oid);
+                               if (smiNode) {
+                                       if (ndo->ndo_vflag) {
+                                               ND_PRINT("%s::", smiGetNodeModule(smiNode)->name);
+                                       }
+                                       ND_PRINT("%s", smiNode->name);
+                                       if (smiNode->oidlen < oidlen) {
+                                               for (i = smiNode->oidlen;
+                                                    i < oidlen; i++) {
+                                                       ND_PRINT(".%u", oid[i]);
+                                               }

                                        }
                                        }

+                                       done++;

                                }
                                }

-                               done++;

                        }
                }
                break;
                        }
                }
                break;


@@ -1148,8 +1159,8 @@ smi_print_value(netdissect_options *ndo,
                             nn = smiGetNextNamedNumber(nn)) {
                                 if (nn->value.value.integer32
                                     == elem->data.integer) {
                             nn = smiGetNextNamedNumber(nn)) {
                                 if (nn->value.value.integer32
                                     == elem->data.integer) {

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

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


@@ -1216,12 +1227,12 @@ varbind_print(netdissect_options *ndo,
        if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
                return;
        if (elem.type != BE_SEQ) {
        if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
                return;
        if (elem.type != BE_SEQ) {

-               ND_PRINT((ndo, "[!SEQ of varbind]"));
+               ND_PRINT("[!SEQ of varbind]");

                asn1_print(ndo, &elem);
                return;
        }
        if ((u_int)count < length)
                asn1_print(ndo, &elem);
                return;
        }
        if ((u_int)count < length)

-               ND_PRINT((ndo, "[%d extra after SEQ of varbind]", length - count));
+               ND_PRINT("[%d extra after SEQ of varbind]", length - count);

        /* descend */
        length = elem.asnlen;
        np = (const u_char *)elem.data.raw;
        /* descend */
        length = elem.asnlen;
        np = (const u_char *)elem.data.raw;


@@ -1230,13 +1241,13 @@ varbind_print(netdissect_options *ndo,
                const u_char *vbend;
                u_int vblength;
 
                const u_char *vbend;
                u_int vblength;
 

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

 
                /* Sequence */
                if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
                        return;
                if (elem.type != BE_SEQ) {
 
                /* Sequence */
                if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
                        return;
                if (elem.type != BE_SEQ) {

-                       ND_PRINT((ndo, "[!varbind]"));
+                       ND_PRINT("[!varbind]");

                        asn1_print(ndo, &elem);
                        return;
                }
                        asn1_print(ndo, &elem);
                        return;
                }


@@ -1250,7 +1261,7 @@ varbind_print(netdissect_options *ndo,
                if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
                        return;
                if (elem.type != BE_OID) {
                if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
                        return;
                if (elem.type != BE_OID) {

-                       ND_PRINT((ndo, "[objName!=OID]"));
+                       ND_PRINT("[objName!=OID]");

                        asn1_print(ndo, &elem);
                        return;
                }
                        asn1_print(ndo, &elem);
                        return;
                }


@@ -1266,7 +1277,7 @@ varbind_print(netdissect_options *ndo,
 
                if (pduid != GETREQ && pduid != GETNEXTREQ
                    && pduid != GETBULKREQ)
 
                if (pduid != GETREQ && pduid != GETNEXTREQ
                    && pduid != GETBULKREQ)

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

 
                /* objVal (ANY) */
                if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
 
                /* objVal (ANY) */
                if ((count = asn1_parse(ndo, np, length, &elem)) < 0)


@@ -1274,7 +1285,7 @@ varbind_print(netdissect_options *ndo,
                if (pduid == GETREQ || pduid == GETNEXTREQ
                    || pduid == GETBULKREQ) {
                        if (elem.type != BE_NULL) {
                if (pduid == GETREQ || pduid == GETNEXTREQ
                    || pduid == GETBULKREQ) {
                        if (elem.type != BE_NULL) {

-                               ND_PRINT((ndo, "[objVal!=NULL]"));
+                               ND_PRINT("[objVal!=NULL]");

                                if (asn1_print(ndo, &elem) < 0)
                                        return;
                        }
                                if (asn1_print(ndo, &elem) < 0)
                                        return;
                        }


@@ -1309,12 +1320,12 @@ snmppdu_print(netdissect_options *ndo,
        if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
                return;
        if (elem.type != BE_INT) {
        if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
                return;
        if (elem.type != BE_INT) {

-               ND_PRINT((ndo, "[reqId!=INT]"));
+               ND_PRINT("[reqId!=INT]");

                asn1_print(ndo, &elem);
                return;
        }
        if (ndo->ndo_vflag)
                asn1_print(ndo, &elem);
                return;
        }
        if (ndo->ndo_vflag)

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

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


@@ -1322,7 +1333,7 @@ snmppdu_print(netdissect_options *ndo,
        if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
                return;
        if (elem.type != BE_INT) {
        if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
                return;
        if (elem.type != BE_INT) {

-               ND_PRINT((ndo, "[errorStatus!=INT]"));
+               ND_PRINT("[errorStatus!=INT]");

                asn1_print(ndo, &elem);
                return;
        }
                asn1_print(ndo, &elem);
                return;
        }


@@ -1331,13 +1342,13 @@ snmppdu_print(netdissect_options *ndo,
            || 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];

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

        } else if (pduid == GETBULKREQ) {
        } else if (pduid == GETBULKREQ) {

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

        } else if (elem.data.integer != 0) {
                char errbuf[20];
        } else if (elem.data.integer != 0) {
                char errbuf[20];

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

                error_status = elem.data.integer;
        }
        length -= count;
                error_status = elem.data.integer;
        }
        length -= count;


@@ -1347,29 +1358,28 @@ snmppdu_print(netdissect_options *ndo,
        if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
                return;
        if (elem.type != BE_INT) {
        if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
                return;
        if (elem.type != BE_INT) {

-               ND_PRINT((ndo, "[errorIndex!=INT]"));
+               ND_PRINT("[errorIndex!=INT]");

                asn1_print(ndo, &elem);
                return;
        }
        if ((pduid == GETREQ || pduid == GETNEXTREQ || pduid == SETREQ
            || pduid == INFORMREQ || pduid == V2TRAP || pduid == REPORT)
            && elem.data.integer != 0)
                asn1_print(ndo, &elem);
                return;
        }
        if ((pduid == GETREQ || pduid == GETNEXTREQ || pduid == SETREQ
            || pduid == INFORMREQ || pduid == V2TRAP || pduid == REPORT)
            && elem.data.integer != 0)

-               ND_PRINT((ndo, "[errorIndex(%d)!=0]", elem.data.integer));
+               ND_PRINT("[errorIndex(%d)!=0]", elem.data.integer);

        else if (pduid == GETBULKREQ)
        else if (pduid == GETBULKREQ)

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

        else if (elem.data.integer != 0) {
                if (!error_status)
        else if (elem.data.integer != 0) {
                if (!error_status)

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

                else
                else

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

        } else if (error_status) {
        } else if (error_status) {

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

        }
        length -= count;
        np += count;
 
        varbind_print(ndo, pduid, np, length);
        }
        length -= count;
        np += count;
 
        varbind_print(ndo, pduid, np, length);

-       return;

 }
 
 /*
 }
 
 /*


@@ -1382,13 +1392,13 @@ trappdu_print(netdissect_options *ndo,
        struct be elem;
        int count = 0, generic;
 
        struct be elem;
        int count = 0, generic;
 

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

 
        /* enterprise (oid) */
        if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
                return;
        if (elem.type != BE_OID) {
 
        /* enterprise (oid) */
        if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
                return;
        if (elem.type != BE_OID) {

-               ND_PRINT((ndo, "[enterprise!=OID]"));
+               ND_PRINT("[enterprise!=OID]");

                asn1_print(ndo, &elem);
                return;
        }
                asn1_print(ndo, &elem);
                return;
        }


@@ -1397,13 +1407,13 @@ trappdu_print(netdissect_options *ndo,
        length -= count;
        np += count;
 
        length -= count;
        np += count;
 

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

 
        /* agent-addr (inetaddr) */
        if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
                return;
        if (elem.type != BE_INETADDR) {
 
        /* agent-addr (inetaddr) */
        if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
                return;
        if (elem.type != BE_INETADDR) {

-               ND_PRINT((ndo, "[agent-addr!=INETADDR]"));
+               ND_PRINT("[agent-addr!=INETADDR]");

                asn1_print(ndo, &elem);
                return;
        }
                asn1_print(ndo, &elem);
                return;
        }


@@ -1416,14 +1426,14 @@ trappdu_print(netdissect_options *ndo,
        if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
                return;
        if (elem.type != BE_INT) {
        if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
                return;
        if (elem.type != BE_INT) {

-               ND_PRINT((ndo, "[generic-trap!=INT]"));
+               ND_PRINT("[generic-trap!=INT]");

                asn1_print(ndo, &elem);
                return;
        }
        generic = elem.data.integer;
        {
                char buf[20];
                asn1_print(ndo, &elem);
                return;
        }
        generic = elem.data.integer;
        {
                char buf[20];

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

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


@@ -1432,25 +1442,25 @@ trappdu_print(netdissect_options *ndo,
        if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
                return;
        if (elem.type != BE_INT) {
        if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
                return;
        if (elem.type != BE_INT) {

-               ND_PRINT((ndo, "[specific-trap!=INT]"));
+               ND_PRINT("[specific-trap!=INT]");

                asn1_print(ndo, &elem);
                return;
        }
        if (generic != GT_ENTERPRISE) {
                if (elem.data.integer != 0)
                asn1_print(ndo, &elem);
                return;
        }
        if (generic != GT_ENTERPRISE) {
                if (elem.data.integer != 0)

-                       ND_PRINT((ndo, "[specific-trap(%d)!=0]", elem.data.integer));
+                       ND_PRINT("[specific-trap(%d)!=0]", elem.data.integer);

        } else
        } else

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

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

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

 
        /* time-stamp (TimeTicks) */
        if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
                return;
        if (elem.type != BE_UNS) {                      /* XXX */
 
        /* time-stamp (TimeTicks) */
        if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
                return;
        if (elem.type != BE_UNS) {                      /* XXX */

-               ND_PRINT((ndo, "[time-stamp!=TIMETICKS]"));
+               ND_PRINT("[time-stamp!=TIMETICKS]");

                asn1_print(ndo, &elem);
                return;
        }
                asn1_print(ndo, &elem);
                return;
        }


@@ -1460,7 +1470,6 @@ trappdu_print(netdissect_options *ndo,
        np += count;
 
        varbind_print(ndo, TRAP, np, length);
        np += count;
 
        varbind_print(ndo, TRAP, np, length);

-       return;

 }
 
 /*
 }
 
 /*


@@ -1477,17 +1486,17 @@ pdu_print(netdissect_options *ndo,
        if ((count = asn1_parse(ndo, np, length, &pdu)) < 0)
                return;
        if (pdu.type != BE_PDU) {
        if ((count = asn1_parse(ndo, np, length, &pdu)) < 0)
                return;
        if (pdu.type != BE_PDU) {

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

                return;
        }
        if ((u_int)count < length)
                return;
        }
        if ((u_int)count < length)

-               ND_PRINT((ndo, "[%d extra after PDU]", length - count));
+               ND_PRINT("[%d extra after PDU]", length - count);

        if (ndo->ndo_vflag) {
        if (ndo->ndo_vflag) {

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

        }
        if (asn1_print(ndo, &pdu) < 0)
                return;
        }
        if (asn1_print(ndo, &pdu) < 0)
                return;

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

        /* descend into PDU */
        length = pdu.asnlen;
        np = (const u_char *)pdu.data.raw;
        /* descend into PDU */
        length = pdu.asnlen;
        np = (const u_char *)pdu.data.raw;


@@ -1495,12 +1504,12 @@ pdu_print(netdissect_options *ndo,
        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)) {

-               ND_PRINT((ndo, "[v2 PDU in v1 message]"));
+               ND_PRINT("[v2 PDU in v1 message]");

                return;
        }
 
        if (version == SNMP_VERSION_2 && pdu.id == TRAP) {
                return;
        }
 
        if (version == SNMP_VERSION_2 && pdu.id == TRAP) {

-               ND_PRINT((ndo, "[v1 PDU in v2 message]"));
+               ND_PRINT("[v1 PDU in v2 message]");

                return;
        }
 
                return;
        }
 


@@ -1521,7 +1530,7 @@ pdu_print(netdissect_options *ndo,
        }
 
        if (ndo->ndo_vflag) {
        }
 
        if (ndo->ndo_vflag) {

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

        }
 }
 
        }
 }
 


@@ -1539,7 +1548,7 @@ scopedpdu_print(netdissect_options *ndo,
        if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
                return;
        if (elem.type != BE_SEQ) {
        if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
                return;
        if (elem.type != BE_SEQ) {

-               ND_PRINT((ndo, "[!scoped PDU]"));
+               ND_PRINT("[!scoped PDU]");

                asn1_print(ndo, &elem);
                return;
        }
                asn1_print(ndo, &elem);
                return;
        }


@@ -1550,33 +1559,33 @@ scopedpdu_print(netdissect_options *ndo,
        if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
                return;
        if (elem.type != BE_STR) {
        if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
                return;
        if (elem.type != BE_STR) {

-               ND_PRINT((ndo, "[contextEngineID!=STR]"));
+               ND_PRINT("[contextEngineID!=STR]");

                asn1_print(ndo, &elem);
                return;
        }
        length -= count;
        np += count;
 
                asn1_print(ndo, &elem);
                return;
        }
        length -= count;
        np += count;
 

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

        if (asn1_print_octets(ndo, &elem) == -1)
                return;
        if (asn1_print_octets(ndo, &elem) == -1)
                return;

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

 
        /* contextName (OCTET STRING) */
        if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
                return;
        if (elem.type != BE_STR) {
 
        /* contextName (OCTET STRING) */
        if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
                return;
        if (elem.type != BE_STR) {

-               ND_PRINT((ndo, "[contextName!=STR]"));
+               ND_PRINT("[contextName!=STR]");

                asn1_print(ndo, &elem);
                return;
        }
        length -= count;
        np += count;
 
                asn1_print(ndo, &elem);
                return;
        }
        length -= count;
        np += count;
 

-       ND_PRINT((ndo, "C="));
+       ND_PRINT("C=");

        if (asn1_print_string(ndo, &elem) == -1)
                return;
        if (asn1_print_string(ndo, &elem) == -1)
                return;

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

 
        pdu_print(ndo, np, length, version);
 }
 
        pdu_print(ndo, np, length, version);
 }


@@ -1595,7 +1604,7 @@ community_print(netdissect_options *ndo,
        if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
                return;
        if (elem.type != BE_STR) {
        if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
                return;
        if (elem.type != BE_STR) {

-               ND_PRINT((ndo, "[comm!=STR]"));
+               ND_PRINT("[comm!=STR]");

                asn1_print(ndo, &elem);
                return;
        }
                asn1_print(ndo, &elem);
                return;
        }


@@ -1604,10 +1613,10 @@ community_print(netdissect_options *ndo,
            strncmp((const char *)elem.data.str, DEF_COMMUNITY,
                    sizeof(DEF_COMMUNITY) - 1) == 0)) {
                /* ! "public" */
            strncmp((const char *)elem.data.str, DEF_COMMUNITY,
                    sizeof(DEF_COMMUNITY) - 1) == 0)) {
                /* ! "public" */

-               ND_PRINT((ndo, "C="));
+               ND_PRINT("C=");

                if (asn1_print_string(ndo, &elem) == -1)
                        return;
                if (asn1_print_string(ndo, &elem) == -1)
                        return;

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

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


@@ -1629,7 +1638,7 @@ usm_print(netdissect_options *ndo,
        if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
                return;
        if (elem.type != BE_SEQ) {
        if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
                return;
        if (elem.type != BE_SEQ) {

-               ND_PRINT((ndo, "[!usm]"));
+               ND_PRINT("[!usm]");

                asn1_print(ndo, &elem);
                return;
        }
                asn1_print(ndo, &elem);
                return;
        }


@@ -1640,7 +1649,7 @@ usm_print(netdissect_options *ndo,
        if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
                return;
        if (elem.type != BE_STR) {
        if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
                return;
        if (elem.type != BE_STR) {

-               ND_PRINT((ndo, "[msgAuthoritativeEngineID!=STR]"));
+               ND_PRINT("[msgAuthoritativeEngineID!=STR]");

                asn1_print(ndo, &elem);
                return;
        }
                asn1_print(ndo, &elem);
                return;
        }


@@ -1651,12 +1660,12 @@ usm_print(netdissect_options *ndo,
        if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
                return;
        if (elem.type != BE_INT) {
        if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
                return;
        if (elem.type != BE_INT) {

-               ND_PRINT((ndo, "[msgAuthoritativeEngineBoots!=INT]"));
+               ND_PRINT("[msgAuthoritativeEngineBoots!=INT]");

                asn1_print(ndo, &elem);
                return;
        }
        if (ndo->ndo_vflag)
                asn1_print(ndo, &elem);
                return;
        }
        if (ndo->ndo_vflag)

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

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


@@ -1664,12 +1673,12 @@ usm_print(netdissect_options *ndo,
        if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
                return;
        if (elem.type != BE_INT) {
        if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
                return;
        if (elem.type != BE_INT) {

-               ND_PRINT((ndo, "[msgAuthoritativeEngineTime!=INT]"));
+               ND_PRINT("[msgAuthoritativeEngineTime!=INT]");

                asn1_print(ndo, &elem);
                return;
        }
        if (ndo->ndo_vflag)
                asn1_print(ndo, &elem);
                return;
        }
        if (ndo->ndo_vflag)

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

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


@@ -1677,23 +1686,23 @@ usm_print(netdissect_options *ndo,
        if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
                return;
        if (elem.type != BE_STR) {
        if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
                return;
        if (elem.type != BE_STR) {

-               ND_PRINT((ndo, "[msgUserName!=STR]"));
+               ND_PRINT("[msgUserName!=STR]");

                asn1_print(ndo, &elem);
                return;
        }
        length -= count;
         np += count;
 
                asn1_print(ndo, &elem);
                return;
        }
        length -= count;
         np += count;
 

-       ND_PRINT((ndo, "U="));
+       ND_PRINT("U=");

        if (asn1_print_string(ndo, &elem) == -1)
                return;
        if (asn1_print_string(ndo, &elem) == -1)
                return;

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

 
        /* msgAuthenticationParameters (OCTET STRING) */
        if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
                return;
        if (elem.type != BE_STR) {
 
        /* msgAuthenticationParameters (OCTET STRING) */
        if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
                return;
        if (elem.type != BE_STR) {

-               ND_PRINT((ndo, "[msgAuthenticationParameters!=STR]"));
+               ND_PRINT("[msgAuthenticationParameters!=STR]");

                asn1_print(ndo, &elem);
                return;
        }
                asn1_print(ndo, &elem);
                return;
        }


@@ -1704,7 +1713,7 @@ usm_print(netdissect_options *ndo,
        if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
                return;
        if (elem.type != BE_STR) {
        if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
                return;
        if (elem.type != BE_STR) {

-               ND_PRINT((ndo, "[msgPrivacyParameters!=STR]"));
+               ND_PRINT("[msgPrivacyParameters!=STR]");

                asn1_print(ndo, &elem);
                return;
        }
                asn1_print(ndo, &elem);
                return;
        }


@@ -1712,7 +1721,7 @@ usm_print(netdissect_options *ndo,
         np += count;
 
        if ((u_int)count < length)
         np += count;
 
        if ((u_int)count < length)

-               ND_PRINT((ndo, "[%d extra after usm SEQ]", length - count));
+               ND_PRINT("[%d extra after usm SEQ]", length - count);

 }
 
 /*
 }
 
 /*


@@ -1733,7 +1742,7 @@ v3msg_print(netdissect_options *ndo,
        if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
                return;
        if (elem.type != BE_SEQ) {
        if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
                return;
        if (elem.type != BE_SEQ) {

-               ND_PRINT((ndo, "[!message]"));
+               ND_PRINT("[!message]");

                asn1_print(ndo, &elem);
                return;
        }
                asn1_print(ndo, &elem);
                return;
        }


@@ -1741,14 +1750,14 @@ v3msg_print(netdissect_options *ndo,
        np = (const u_char *)elem.data.raw;
 
        if (ndo->ndo_vflag) {
        np = (const u_char *)elem.data.raw;
 
        if (ndo->ndo_vflag) {

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

        }
 
        /* msgID (INTEGER) */
        if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
                return;
        if (elem.type != BE_INT) {
        }
 
        /* msgID (INTEGER) */
        if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
                return;
        if (elem.type != BE_INT) {

-               ND_PRINT((ndo, "[msgID!=INT]"));
+               ND_PRINT("[msgID!=INT]");

                asn1_print(ndo, &elem);
                return;
        }
                asn1_print(ndo, &elem);
                return;
        }


@@ -1759,7 +1768,7 @@ v3msg_print(netdissect_options *ndo,
        if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
                return;
        if (elem.type != BE_INT) {
        if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
                return;
        if (elem.type != BE_INT) {

-               ND_PRINT((ndo, "[msgMaxSize!=INT]"));
+               ND_PRINT("[msgMaxSize!=INT]");

                asn1_print(ndo, &elem);
                return;
        }
                asn1_print(ndo, &elem);
                return;
        }


@@ -1770,33 +1779,33 @@ v3msg_print(netdissect_options *ndo,
        if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
                return;
        if (elem.type != BE_STR) {
        if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
                return;
        if (elem.type != BE_STR) {

-               ND_PRINT((ndo, "[msgFlags!=STR]"));
+               ND_PRINT("[msgFlags!=STR]");

                asn1_print(ndo, &elem);
                return;
        }
        if (elem.asnlen != 1) {
                asn1_print(ndo, &elem);
                return;
        }
        if (elem.asnlen != 1) {

-               ND_PRINT((ndo, "[msgFlags size %d]", elem.asnlen));
+               ND_PRINT("[msgFlags size %d]", elem.asnlen);

                return;
        }
                return;
        }

-       flags = elem.data.str[0];
+       flags = GET_U_1(elem.data.str);

        if (flags != 0x00 && flags != 0x01 && flags != 0x03
            && flags != 0x04 && flags != 0x05 && flags != 0x07) {
        if (flags != 0x00 && flags != 0x01 && flags != 0x03
            && flags != 0x04 && flags != 0x05 && flags != 0x07) {

-               ND_PRINT((ndo, "[msgFlags=0x%02X]", flags));
+               ND_PRINT("[msgFlags=0x%02X]", flags);

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

-       ND_PRINT((ndo, "F=%s%s%s ",
+       ND_PRINT("F=%s%s%s ",

                  flags & 0x01 ? "a" : "",
                  flags & 0x02 ? "p" : "",
                  flags & 0x01 ? "a" : "",
                  flags & 0x02 ? "p" : "",

-                 flags & 0x04 ? "r" : ""));
+                 flags & 0x04 ? "r" : "");

 
        /* msgSecurityModel (INTEGER) */
        if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
                return;
        if (elem.type != BE_INT) {
 
        /* msgSecurityModel (INTEGER) */
        if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
                return;
        if (elem.type != BE_INT) {

-               ND_PRINT((ndo, "[msgSecurityModel!=INT]"));
+               ND_PRINT("[msgSecurityModel!=INT]");

                asn1_print(ndo, &elem);
                return;
        }
                asn1_print(ndo, &elem);
                return;
        }


@@ -1805,18 +1814,18 @@ v3msg_print(netdissect_options *ndo,
        np += count;
 
        if ((u_int)count < length)
        np += count;
 
        if ((u_int)count < length)

-               ND_PRINT((ndo, "[%d extra after message SEQ]", length - count));
+               ND_PRINT("[%d extra after message SEQ]", length - count);

 
        if (ndo->ndo_vflag) {
 
        if (ndo->ndo_vflag) {

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

        }
 
        if (model == 3) {
            if (ndo->ndo_vflag) {
        }
 
        if (model == 3) {
            if (ndo->ndo_vflag) {

-               ND_PRINT((ndo, "{ USM "));
+               ND_PRINT("{ USM ");

            }
        } else {
            }
        } else {

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

             return;
        }
 
             return;
        }
 


@@ -1827,7 +1836,7 @@ v3msg_print(netdissect_options *ndo,
        if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
                return;
        if (elem.type != BE_STR) {
        if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
                return;
        if (elem.type != BE_STR) {

-               ND_PRINT((ndo, "[msgSecurityParameters!=STR]"));
+               ND_PRINT("[msgSecurityParameters!=STR]");

                asn1_print(ndo, &elem);
                return;
        }
                asn1_print(ndo, &elem);
                return;
        }


@@ -1837,18 +1846,18 @@ v3msg_print(netdissect_options *ndo,
        if (model == 3) {
            usm_print(ndo, elem.data.str, elem.asnlen);
            if (ndo->ndo_vflag) {
        if (model == 3) {
            usm_print(ndo, elem.data.str, elem.asnlen);
            if (ndo->ndo_vflag) {

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

            }
        }
 
        if (ndo->ndo_vflag) {
            }
        }
 
        if (ndo->ndo_vflag) {

-           ND_PRINT((ndo, "{ ScopedPDU "));
+           ND_PRINT("{ ScopedPDU ");

        }
 
        scopedpdu_print(ndo, np, length, 3);
 
        if (ndo->ndo_vflag) {
        }
 
        scopedpdu_print(ndo, np, length, 3);
 
        if (ndo->ndo_vflag) {

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

        }
 }
 
        }
 }
 


@@ -1863,18 +1872,19 @@ snmp_print(netdissect_options *ndo,
        int count = 0;
        int version = 0;
 
        int count = 0;
        int version = 0;
 

-       ND_PRINT((ndo, " "));
+       ndo->ndo_protocol = "snmp";
+       ND_PRINT(" ");

 
        /* initial Sequence */
        if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
                return;
        if (elem.type != BE_SEQ) {
 
        /* initial Sequence */
        if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
                return;
        if (elem.type != BE_SEQ) {

-               ND_PRINT((ndo, "[!init SEQ]"));
+               ND_PRINT("[!init SEQ]");

                asn1_print(ndo, &elem);
                return;
        }
        if ((u_int)count < length)
                asn1_print(ndo, &elem);
                return;
        }
        if ((u_int)count < length)

-               ND_PRINT((ndo, "[%d extra after iSEQ]", length - count));
+               ND_PRINT("[%d extra after iSEQ]", length - count);

        /* descend */
        length = elem.asnlen;
        np = (const u_char *)elem.data.raw;
        /* descend */
        length = elem.asnlen;
        np = (const u_char *)elem.data.raw;


@@ -1883,7 +1893,7 @@ snmp_print(netdissect_options *ndo,
        if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
                return;
        if (elem.type != BE_INT) {
        if ((count = asn1_parse(ndo, np, length, &elem)) < 0)
                return;
        if (elem.type != BE_INT) {

-               ND_PRINT((ndo, "[version!=INT]"));
+               ND_PRINT("[version!=INT]");

                asn1_print(ndo, &elem);
                return;
        }
                asn1_print(ndo, &elem);
                return;
        }


@@ -1893,10 +1903,10 @@ snmp_print(netdissect_options *ndo,
        case SNMP_VERSION_2:
        case SNMP_VERSION_3:
                if (ndo->ndo_vflag)
        case SNMP_VERSION_2:
        case SNMP_VERSION_3:
                if (ndo->ndo_vflag)

-                       ND_PRINT((ndo, "{ %s ", SnmpVersion[elem.data.integer]));
+                       ND_PRINT("{ %s ", SnmpVersion[elem.data.integer]);

                break;
        default:
                break;
        default:

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

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


@@ -1912,11 +1922,11 @@ snmp_print(netdissect_options *ndo,
                v3msg_print(ndo, np, length);
                break;
        default:
                v3msg_print(ndo, np, length);
                break;
        default:

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

                break;
        }
 
        if (ndo->ndo_vflag) {
                break;
        }
 
        if (ndo->ndo_vflag) {

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

        }
 }
        }
 }