Address Michael's comments.

[tcpdump] / print-snmp.c

diff --git a/print-snmp.c b/print-snmp.c
index b5835dc1033c06f5e29d73242a73ea8950582163..728da6beb79ebca0bdeac14455d50173676bd2fa 100644 (file)
--- a/print-snmp.c
+++ b/print-snmp.c
@@ -1,16 +1,29 @@
 /*
  * Copyright (c) 1990, 1991, 1993, 1994, 1995, 1996, 1997
 /*
  * Copyright (c) 1990, 1991, 1993, 1994, 1995, 1996, 1997

- *     The Regents of the University of California.  All rights reserved.
+ *     John Robert LoVerso. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

  *
  *

- * Redistribution and use in source and binary forms are permitted
- * provided that the above copyright notice and this paragraph are
- * duplicated in all such forms and that any documentation,
- * advertising materials, and other materials related to such
- * distribution and use acknowledge that the software was developed
- * by John Robert LoVerso.
- * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
- * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.

  *
  * This implementation has been influenced by the CMU SNMP release,
  * by Steve Waldbusser.  However, this shares no code with that system.
  *
  * This implementation has been influenced by the CMU SNMP release,
  * by Steve Waldbusser.  However, this shares no code with that system.


@@ -44,21 +57,16 @@
  */
 
 #ifndef lint
  */
 
 #ifndef lint

-static const char rcsid[] =
-    "@(#) $Header: /tcpdump/master/tcpdump/print-snmp.c,v 1.39 1999-12-22 06:27:22 itojun Exp $ (LBL)";
+static const char rcsid[] _U_ =
+    "@(#) $Header: /tcpdump/master/tcpdump/print-snmp.c,v 1.64 2005-05-06 07:56:53 guy Exp $ (LBL)";

 #endif
 
 #ifdef HAVE_CONFIG_H
 #include "config.h"
 #endif
 
 #endif
 
 #ifdef HAVE_CONFIG_H
 #include "config.h"
 #endif
 

-#include <sys/param.h>
-#include <sys/time.h>
+#include <tcpdump-stdinc.h>

 
 

-#include <ctype.h>
-#ifdef HAVE_MEMORY_H
-#include <memory.h>
-#endif

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


@@ -69,11 +77,13 @@ static const char rcsid[] =
 #include "interface.h"
 #include "addrtoname.h"
 
 #include "interface.h"
 #include "addrtoname.h"
 

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

 /*
  * Universal ASN.1 types
  * (we only care about the tag values for those allowed in the Internet SMI)
  */
 /*
  * Universal ASN.1 types
  * (we only care about the tag values for those allowed in the Internet SMI)
  */

-char *Universal[] = {
+const char *Universal[] = {

        "U-0",
        "Boolean",
        "Integer",
        "U-0",
        "Boolean",
        "Integer",


@@ -96,7 +106,7 @@ char *Universal[] = {
 /*
  * Application-wide ASN.1 types from the Internet SMI and their tags
  */
 /*
  * Application-wide ASN.1 types from the Internet SMI and their tags
  */

-char *Application[] = {
+const char *Application[] = {

        "IpAddress",
 #define IPADDR 0
        "Counter",
        "IpAddress",
 #define IPADDR 0
        "Counter",


@@ -115,7 +125,7 @@ char *Application[] = {
 /*
  * Context-specific ASN.1 types for the SNMP PDUs and their tags
  */
 /*
  * Context-specific ASN.1 types for the SNMP PDUs and their tags
  */

-char *Context[] = {
+const char *Context[] = {

        "GetRequest",
 #define GETREQ 0
        "GetNextRequest",
        "GetRequest",
 #define GETREQ 0
        "GetNextRequest",


@@ -145,7 +155,7 @@ char *Context[] = {
 /*
  * Context-specific ASN.1 types for the SNMP Exceptions and their tags
  */
 /*
  * Context-specific ASN.1 types for the SNMP Exceptions and their tags
  */

-char *Exceptions[] = {
+const char *Exceptions[] = {

        "noSuchObject",
 #define NOSUCHOBJECT 0
        "noSuchInstance",
        "noSuchObject",
 #define NOSUCHOBJECT 0
        "noSuchInstance",


@@ -158,14 +168,14 @@ char *Exceptions[] = {
  * Private ASN.1 types
  * The Internet SMI does not specify any
  */
  * Private ASN.1 types
  * The Internet SMI does not specify any
  */

-char *Private[] = {
+const char *Private[] = {

        "P-0"
 };
 
 /*
  * error-status values for any SNMP PDU
  */
        "P-0"
 };
 
 /*
  * error-status values for any SNMP PDU
  */

-char *ErrorStatus[] = {
+const char *ErrorStatus[] = {

        "noError",
        "tooBig",
        "noSuchName",
        "noError",
        "tooBig",
        "noSuchName",


@@ -187,13 +197,14 @@ char *ErrorStatus[] = {
        "inconsistentName"
 };
 #define DECODE_ErrorStatus(e) \
        "inconsistentName"
 };
 #define DECODE_ErrorStatus(e) \

-       ( e >= 0 && e < sizeof(ErrorStatus)/sizeof(ErrorStatus[0]) \
-       ? ErrorStatus[e] : (sprintf(errbuf, "err=%u", e), errbuf))
+       ( e >= 0 && (size_t)e < sizeof(ErrorStatus)/sizeof(ErrorStatus[0]) \
+               ? ErrorStatus[e] \
+               : (snprintf(errbuf, sizeof(errbuf), "err=%u", e), errbuf))

 
 /*
  * generic-trap values in the SNMP Trap-PDU
  */
 
 /*
  * generic-trap values in the SNMP Trap-PDU
  */

-char *GenericTrap[] = {
+const char *GenericTrap[] = {

        "coldStart",
        "warmStart",
        "linkDown",
        "coldStart",
        "warmStart",
        "linkDown",


@@ -201,11 +212,12 @@ char *GenericTrap[] = {
        "authenticationFailure",
        "egpNeighborLoss",
        "enterpriseSpecific"
        "authenticationFailure",
        "egpNeighborLoss",
        "enterpriseSpecific"

-#define GT_ENTERPRISE 7
+#define GT_ENTERPRISE 6

 };
 #define DECODE_GenericTrap(t) \
 };
 #define DECODE_GenericTrap(t) \

-       ( t >= 0 && t < sizeof(GenericTrap)/sizeof(GenericTrap[0]) \
-       ? GenericTrap[t] : (sprintf(buf, "gt=%d", t), buf))
+       ( t >= 0 && (size_t)t < sizeof(GenericTrap)/sizeof(GenericTrap[0]) \
+               ? GenericTrap[t] \
+               : (snprintf(buf, sizeof(buf), "gt=%d", t), buf))

 
 /*
  * ASN.1 type class table
 
 /*
  * ASN.1 type class table


@@ -214,8 +226,8 @@ char *GenericTrap[] = {
  */
 #define defineCLASS(x) { "x", x, sizeof(x)/sizeof(x[0]) } /* not ANSI-C */
 struct {
  */
 #define defineCLASS(x) { "x", x, sizeof(x)/sizeof(x[0]) } /* not ANSI-C */
 struct {

-       char    *name;
-       char    **Id;
+       const char      *name;
+       const char      **Id;

            int numIDs;
     } Class[] = {
        defineCLASS(Universal),
            int numIDs;
     } Class[] = {
        defineCLASS(Universal),


@@ -233,7 +245,7 @@ struct {
 /*
  * defined forms for ASN.1 types
  */
 /*
  * defined forms for ASN.1 types
  */

-char *Form[] = {
+const char *Form[] = {

        "Primitive",
 #define PRIMITIVE      0
        "Constructed",
        "Primitive",
 #define PRIMITIVE      0
        "Constructed",


@@ -245,7 +257,7 @@ char *Form[] = {
  * This is stored as a general-order tree.
  */
 struct obj {
  * This is stored as a general-order tree.
  */
 struct obj {

-       char    *desc;                  /* name of object */
+       const char      *desc;          /* name of object */

        u_char  oid;                    /* sub-id following parent */
        u_char  type;                   /* object type (unused) */
        struct obj *child, *next;       /* child and next sibling pointers */
        u_char  oid;                    /* sub-id following parent */
        u_char  type;                   /* object type (unused) */
        struct obj *child, *next;       /* child and next sibling pointers */


@@ -267,9 +279,9 @@ struct obj {
  * private enterprises tree, and the experimental tree.
  */
 struct obj_abrev {
  * private enterprises tree, and the experimental tree.
  */
 struct obj_abrev {

-       char *prefix;                   /* prefix for this abrev */
+       const char *prefix;             /* prefix for this abrev */

        struct obj *node;               /* pointer into object table */
        struct obj *node;               /* pointer into object table */

-       char *oid;                      /* ASN.1 encoded OID */
+       const char *oid;                /* ASN.1 encoded 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 */


@@ -348,7 +360,7 @@ struct be {
 /*
  * SNMP versions recognized by this module
  */
 /*
  * SNMP versions recognized by this module
  */

-char *SnmpVersion[] = {
+const char *SnmpVersion[] = {

        "SNMPv1",
 #define SNMP_VERSION_1 0
        "SNMPv2c",
        "SNMPv1",
 #define SNMP_VERSION_1 0
        "SNMPv2c",


@@ -382,13 +394,6 @@ char *SnmpVersion[] = {
 
 #define ASN_ID_EXT 0x1f                /* extension ID in tag field */
 
 
 #define ASN_ID_EXT 0x1f                /* extension ID in tag field */
 

-/*
- * truncated==1 means the packet was complete, but we don't have all of
- * it to decode.
- */
-static int truncated;
-#define ifNotTruncated if (truncated) fputs("[|snmp]", stdout); else
-

 /*
  * This decodes the next ASN.1 object in the stream pointed to by "p"
  * (and of real-length "len") and stores the intermediate data in the
 /*
  * This decodes the next ASN.1 object in the stream pointed to by "p"
  * (and of real-length "len") and stores the intermediate data in the


@@ -406,9 +411,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) {

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

                return -1;
        }
                return -1;
        }

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


@@ -429,65 +435,69 @@ asn1_parse(register const u_char *p, u_int len, struct be *elem)
        elem->form = form;
        elem->class = class;
        elem->id = id;
        elem->form = form;
        elem->class = class;
        elem->id = id;

-       if (vflag)
-               printf("|%.2x", *p);

        p++; len--; hdr = 1;
        /* extended tag field */
        if (id == ASN_ID_EXT) {
        p++; len--; hdr = 1;
        /* extended tag field */
        if (id == ASN_ID_EXT) {

-               for (id = 0; *p & ASN_BIT8 && len > 0; len--, hdr++, p++) {
-                       if (vflag)
-                               printf("|%.2x", *p);
+               /*
+                * The ID follows, as a sequence of octets with the
+                * 8th bit set and the remaining 7 bits being
+                * the next 7 bits of the value, terminated with
+                * an octet with the 8th bit not set.
+                *
+                * First, assemble all the octets with the 8th
+                * bit set.  XXX - this doesn't handle a value
+                * that won't fit in 32 bits.
+                */
+               for (id = 0; *p & ASN_BIT8; len--, hdr++, p++) {
+                       if (len < 1) {
+                               fputs("[Xtagfield?]", stdout);
+                               return -1;
+                       }
+                       TCHECK(*p);

                        id = (id << 7) | (*p & ~ASN_BIT8);
                }
                        id = (id << 7) | (*p & ~ASN_BIT8);
                }

-               if (len == 0 && *p & ASN_BIT8) {
-                       ifNotTruncated fputs("[Xtagfield?]", stdout);
+               if (len < 1) {
+                       fputs("[Xtagfield?]", stdout);

                        return -1;
                }
                        return -1;
                }

+               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) {

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

                return -1;
        }
                return -1;
        }

+       TCHECK(*p);

        elem->asnlen = *p;
        elem->asnlen = *p;

-       if (vflag)
-               printf("|%.2x", *p);

        p++; len--; hdr++;
        if (elem->asnlen & ASN_BIT8) {
        p++; len--; hdr++;
        if (elem->asnlen & ASN_BIT8) {

-               int noct = elem->asnlen % ASN_BIT8;
+               u_int32_t noct = elem->asnlen % ASN_BIT8;

                elem->asnlen = 0;
                if (len < noct) {
                elem->asnlen = 0;
                if (len < noct) {

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

                        return -1;
                }
                        return -1;
                }

-               for (; noct-- > 0; len--, hdr++) {
-                       if (vflag)
-                               printf("|%.2x", *p);
+               TCHECK2(*p, noct);
+               for (; noct-- > 0; len--, hdr++)

                        elem->asnlen = (elem->asnlen << ASN_SHIFT8) | *p++;
                        elem->asnlen = (elem->asnlen << ASN_SHIFT8) | *p++;

-               }

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

-               if (!truncated) {
-                       printf("[len%d<asnlen%u]", len, elem->asnlen);
-                       return -1;
-               }
-               /* maybe should check at least 4? */
-               elem->asnlen = len;
+               printf("[len%d<asnlen%u]", len, elem->asnlen);
+               return -1;

        }
        if (form >= sizeof(Form)/sizeof(Form[0])) {
        }
        if (form >= sizeof(Form)/sizeof(Form[0])) {

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

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

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

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

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

                return -1;
        }
 
                return -1;
        }
 


@@ -506,6 +516,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);

                                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++)


@@ -544,6 +555,7 @@ asn1_parse(register const u_char *p, u_int len, struct be *elem)
                        case GAUGE:
                        case TIMETICKS: {
                                register u_int32_t data;
                        case GAUGE:
                        case TIMETICKS: {
                                register u_int32_t data;

+                               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++)


@@ -554,10 +566,11 @@ asn1_parse(register const u_char *p, u_int len, struct be *elem)
 
                        case COUNTER64: {
                                register u_int32_t high, low;
 
                        case COUNTER64: {
                                register u_int32_t high, low;

+                               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++) {

-                                       high = (high << 8) | 
+                                       high = (high << 8) |

                                            ((low & 0xFF000000) >> 24);
                                        low = (low << 8) | *p;
                                }
                                            ((low & 0xFF000000) >> 24);
                                        low = (low << 8) | *p;
                                }


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

-                       elem->type = BE_OCTET;
-                       elem->data.raw = (caddr_t)p;

                        printf("[P/%s/%s]",
                                Class[class].name, Class[class].Id[id]);
                        printf("[P/%s/%s]",
                                Class[class].name, Class[class].Id[id]);

+                       TCHECK2(*p, elem->asnlen);
+                       elem->type = BE_OCTET;
+                       elem->data.raw = (caddr_t)p;

                        break;
                }
                break;
                        break;
                }
                break;


@@ -637,6 +651,10 @@ asn1_parse(register const u_char *p, u_int len, struct be *elem)
        p += elem->asnlen;
        len -= elem->asnlen;
        return elem->asnlen + hdr;
        p += elem->asnlen;
        len -= elem->asnlen;
        return elem->asnlen + hdr;

+
+trunc:
+       fputs("[|snmp]", stdout);
+       return -1;

 }
 
 /*
 }
 
 /*


@@ -644,17 +662,18 @@ asn1_parse(register const u_char *p, u_int len, struct be *elem)
  * This used to be an integral part of asn1_parse() before the intermediate
  * BE form was added.
  */
  * This used to be an integral part of asn1_parse() before the intermediate
  * BE form was added.
  */

-static void
+static int

 asn1_print(struct be *elem)
 {
        u_char *p = (u_char *)elem->data.raw;
        u_int32_t asnlen = elem->asnlen;
 asn1_print(struct be *elem)
 {
        u_char *p = (u_char *)elem->data.raw;
        u_int32_t asnlen = elem->asnlen;

-       int i;
+       u_int32_t i;

 
        switch (elem->type) {
 
        case BE_OCTET:
 
        switch (elem->type) {
 
        case BE_OCTET:

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

                        printf("_%.2x", *p);
                break;
 
                        printf("_%.2x", *p);
                break;
 


@@ -662,13 +681,14 @@ asn1_print(struct be *elem)
                break;
 
        case BE_OID: {
                break;
 
        case BE_OID: {

-       int o = 0, first = -1, i = asnlen;
+               int o = 0, first = -1, i = asnlen;

 
                if (!sflag && !nflag && asnlen > 2) {
                        struct obj_abrev *a = &obj_abrev_list[0];
 
                if (!sflag && !nflag && asnlen > 2) {
                        struct obj_abrev *a = &obj_abrev_list[0];

+                       size_t a_len = strlen(a->oid);

                        for (; a->node; a++) {
                        for (; a->node; a++) {

-                               if (!memcmp(a->oid, (char *)p,
-                                   strlen(a->oid))) {
+                               TCHECK2(*p, a_len);
+                               if (memcmp(a->oid, (char *)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);


@@ -680,19 +700,24 @@ asn1_print(struct be *elem)
                }
 
                for (; !sflag && i-- > 0; p++) {
                }
 
                for (; !sflag && i-- > 0; p++) {

+                       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;

-                       
+

                        /*
                         * first subitem encodes two items with 1st*OIDMUX+2nd
                        /*
                         * first subitem encodes two items with 1st*OIDMUX+2nd

+                        * (see X.690:1997 clause 8.19 for the details)

                         */
                        if (first < 0) {
                         */
                        if (first < 0) {

+                               int s;

                                if (!nflag)
                                        objp = mibroot;
                                first = 0;
                                if (!nflag)
                                        objp = mibroot;
                                first = 0;

-                               OBJ_PRINT(o/OIDMUX, first);
-                               o %= OIDMUX;
+                               s = o / OIDMUX;
+                               if (s > 2) s = 2;
+                               OBJ_PRINT(s, first);
+                               o -= s * OIDMUX;

                        }
                        OBJ_PRINT(o, first);
                        if (--first < 0)
                        }
                        OBJ_PRINT(o, first);
                        if (--first < 0)


@@ -719,9 +744,9 @@ asn1_print(struct be *elem)
                        break;
                }
                d = elem->data.uns64.high * 4294967296.0;       /* 2^32 */
                        break;
                }
                d = elem->data.uns64.high * 4294967296.0;       /* 2^32 */

-               if (elem->data.uns64.high <= 0x1fffff) { 
+               if (elem->data.uns64.high <= 0x1fffff) {

                        d += elem->data.uns64.low;
                        d += elem->data.uns64.low;

-#if 0 /*is looks illegal, but what is the intention???*/
+#if 0 /*is looks illegal, but what is the intention?*/

                        printf("%.f", d);
 #else
                        printf("%f", d);
                        printf("%.f", d);
 #else
                        printf("%f", d);


@@ -729,12 +754,13 @@ asn1_print(struct be *elem)
                        break;
                }
                d += (elem->data.uns64.low & 0xfffff000);
                        break;
                }
                d += (elem->data.uns64.low & 0xfffff000);

-#if 0 /*is looks illegal, but what is the intention???*/
-               sprintf(first, "%.f", d);
+#if 0 /*is looks illegal, but what is the intention?*/
+               snprintf(first, sizeof(first), "%.f", d);

 #else
 #else

-               sprintf(first, "%f", d);
+               snprintf(first, sizeof(first), "%f", d);

 #endif
 #endif

-               sprintf(last, "%5.5d", elem->data.uns64.low & 0xfff);
+               snprintf(last, sizeof(last), "%5.5d",
+                   elem->data.uns64.low & 0xfff);

                for (carry = 0, cpf = first+strlen(first)-1, cpl = last+4;
                     cpl >= last;
                     cpf--, cpl--) {
                for (carry = 0, cpf = first+strlen(first)-1, cpl = last+4;
                     cpl >= last;
                     cpf--, cpl--) {


@@ -754,12 +780,16 @@ asn1_print(struct be *elem)
        case BE_STR: {
                register int printable = 1, first = 1;
                const u_char *p = elem->data.str;
        case BE_STR: {
                register int printable = 1, first = 1;
                const u_char *p = elem->data.str;

+               TCHECK2(*p, asnlen);

                for (i = asnlen; printable && i-- > 0; p++)
                        printable = isprint(*p) || isspace(*p);
                p = elem->data.str;
                if (printable) {
                        putchar('"');
                for (i = asnlen; printable && i-- > 0; p++)
                        printable = isprint(*p) || isspace(*p);
                p = elem->data.str;
                if (printable) {
                        putchar('"');

-                       (void)fn_print(p, p + asnlen);
+                       if (fn_printn(p, asnlen, snapend)) {
+                               putchar('"');
+                               goto trunc;
+                       }

                        putchar('"');
                } else
                        for (i = asnlen; i-- > 0; p++) {
                        putchar('"');
                } else
                        for (i = asnlen; i-- > 0; p++) {


@@ -776,7 +806,8 @@ asn1_print(struct be *elem)
        case BE_INETADDR:
                if (asnlen != ASNLEN_INETADDR)
                        printf("[inetaddr len!=%d]", ASNLEN_INETADDR);
        case BE_INETADDR:
                if (asnlen != ASNLEN_INETADDR)
                        printf("[inetaddr len!=%d]", ASNLEN_INETADDR);

-               for (i = asnlen; i-- > 0; p++) {
+               TCHECK2(*p, asnlen);
+               for (i = asnlen; i-- != 0; p++) {

                        printf((i == asnlen-1) ? "%u" : ".%u", *p);
                }
                break;
                        printf((i == asnlen-1) ? "%u" : ".%u", *p);
                }
                break;


@@ -800,6 +831,11 @@ asn1_print(struct be *elem)
                fputs("[be!?]", stdout);
                break;
        }
                fputs("[be!?]", stdout);
                break;
        }

+       return 0;
+
+trunc:
+       fputs("[|snmp]", stdout);
+       return -1;

 }
 
 #ifdef notdef
 }
 
 #ifdef notdef


@@ -822,7 +858,8 @@ asn1_decode(u_char *p, u_int length)
                i = asn1_parse(p, length, &elem);
                if (i >= 0) {
                        fputs(" ", stdout);
                i = asn1_parse(p, length, &elem);
                if (i >= 0) {
                        fputs(" ", stdout);

-                       asn1_print(&elem);
+                       if (asn1_print(&elem) < 0)
+                               return;

                        if (elem.type == BE_SEQ || elem.type == BE_PDU) {
                                fputs(" {", stdout);
                                asn1_decode(elem.data.raw, elem.asnlen);
                        if (elem.type == BE_SEQ || elem.type == BE_PDU) {
                                fputs(" {", stdout);
                                asn1_decode(elem.data.raw, elem.asnlen);


@@ -842,7 +879,7 @@ struct smi2be {
     int be;
 };
 
     int be;
 };
 

-struct smi2be smi2betab[] = {
+static struct smi2be smi2betab[] = {

     { SMI_BASETYPE_INTEGER32,          BE_INT },
     { SMI_BASETYPE_OCTETSTRING,                BE_STR },
     { SMI_BASETYPE_OCTETSTRING,                BE_INETADDR },
     { SMI_BASETYPE_INTEGER32,          BE_INT },
     { SMI_BASETYPE_OCTETSTRING,                BE_STR },
     { SMI_BASETYPE_OCTETSTRING,                BE_INETADDR },


@@ -858,29 +895,43 @@ struct smi2be smi2betab[] = {
     { SMI_BASETYPE_UNKNOWN,            BE_NONE }
 };
 
     { SMI_BASETYPE_UNKNOWN,            BE_NONE }
 };
 

-static void smi_decode_oid(struct be *elem, unsigned int *oid,
-                          unsigned int *oidlen)
+static int
+smi_decode_oid(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;
        int o = 0, first = -1, i = asnlen;
 
        for (*oidlen = 0; sflag && i-- > 0; p++) {
 {
        u_char *p = (u_char *)elem->data.raw;
        u_int32_t asnlen = elem->asnlen;
        int o = 0, first = -1, i = asnlen;
 
        for (*oidlen = 0; sflag && i-- > 0; p++) {

+               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;

-           
+

                /*
                 * first subitem encodes two items with 1st*OIDMUX+2nd
                /*
                 * first subitem encodes two items with 1st*OIDMUX+2nd

+                * (see X.690:1997 clause 8.19 for the details)

                 */
                if (first < 0) {
                        first = 0;
                 */
                if (first < 0) {
                        first = 0;

-                       oid[(*oidlen)++] = o/OIDMUX;
-                       o %= OIDMUX;
+                       if (*oidlen < oidsize) {
+                           oid[*oidlen] = o / OIDMUX;
+                           if (oid[*oidlen] > 2) oid[*oidlen] = 2;
+                       }
+                       o -= oid[*oidlen] * OIDMUX;
+                       if (*oidlen < oidsize) (*oidlen)++;
+               }
+               if (*oidlen < oidsize) {
+                       oid[(*oidlen)++] = o;

                }
                }

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

                o = 0;
        }
                o = 0;
        }

+       return 0;
+
+trunc:
+       fputs("[|snmp]", stdout);
+       return -1;

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


@@ -899,8 +950,8 @@ static int smi_check_type(SmiBasetype basetype, int be)
 static int smi_check_a_range(SmiType *smiType, SmiRange *smiRange,
                             struct be *elem)
 {
 static int smi_check_a_range(SmiType *smiType, SmiRange *smiRange,
                             struct be *elem)
 {

-    int ok;
-    
+    int ok = 1;
+

     switch (smiType->basetype) {
     case SMI_BASETYPE_OBJECTIDENTIFIER:
     case SMI_BASETYPE_OCTETSTRING:
     switch (smiType->basetype) {
     case SMI_BASETYPE_OBJECTIDENTIFIER:
     case SMI_BASETYPE_OCTETSTRING:


@@ -917,12 +968,12 @@ static int smi_check_a_range(SmiType *smiType, SmiRange *smiRange,
        ok = (elem->data.integer >= smiRange->minValue.value.integer32
              && elem->data.integer <= smiRange->maxValue.value.integer32);
        break;
        ok = (elem->data.integer >= smiRange->minValue.value.integer32
              && elem->data.integer <= smiRange->maxValue.value.integer32);
        break;

-           
+

     case SMI_BASETYPE_UNSIGNED32:
        ok = (elem->data.uns >= smiRange->minValue.value.unsigned32
              && elem->data.uns <= smiRange->maxValue.value.unsigned32);
        break;
     case SMI_BASETYPE_UNSIGNED32:
        ok = (elem->data.uns >= smiRange->minValue.value.unsigned32
              && elem->data.uns <= smiRange->maxValue.value.unsigned32);
        break;

-       
+

     case SMI_BASETYPE_UNSIGNED64:
        /* XXX */
        break;
     case SMI_BASETYPE_UNSIGNED64:
        /* XXX */
        break;


@@ -937,6 +988,10 @@ static int smi_check_a_range(SmiType *smiType, SmiRange *smiRange,
     case SMI_BASETYPE_UNKNOWN:
        ok = 1;
        break;
     case SMI_BASETYPE_UNKNOWN:
        ok = 1;
        break;

+
+    default:
+       ok = 0;
+       break;

     }
 
     return ok;
     }
 
     return ok;


@@ -947,45 +1002,45 @@ static int smi_check_range(SmiType *smiType, struct be *elem)
         SmiRange *smiRange;
        int ok = 1;
 
         SmiRange *smiRange;
        int ok = 1;
 

-       for (smiRange = smiGetFirstRange(smiType->module, smiType->name);
+       for (smiRange = smiGetFirstRange(smiType);

             smiRange;
             smiRange = smiGetNextRange(smiRange)) {
 
            ok = smi_check_a_range(smiType, smiRange, elem);
             smiRange;
             smiRange = smiGetNextRange(smiRange)) {
 
            ok = smi_check_a_range(smiType, smiRange, elem);

-           
+

            if (ok) {
            if (ok) {

-               smiFreeRange(smiRange);

                break;
            }
        }
 
                break;
            }
        }
 

-       if (ok && smiType->parentmodule && smiType->parentname) {
+       if (ok) {

            SmiType *parentType;
            SmiType *parentType;

-           parentType = smiGetType(smiType->parentmodule,
-                                   smiType->parentname);
+           parentType = smiGetParentType(smiType);

            if (parentType) {
                ok = smi_check_range(parentType, elem);
            if (parentType) {
                ok = smi_check_range(parentType, elem);

-               smiFreeType(parentType);

            }
        }
 
        return ok;
 }
 
            }
        }
 
        return ok;
 }
 

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

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

-       int i;
+       unsigned int i;

 
 

-       smi_decode_oid(elem, oid, &oidlen);
+       *status = smi_decode_oid(elem, oid, sizeof(oid)/sizeof(unsigned int),
+           &oidlen);
+       if (*status < 0)
+               return NULL;

        smiNode = smiGetNodeByOID(oidlen, oid);
        if (! smiNode) {
        smiNode = smiGetNodeByOID(oidlen, oid);
        if (! smiNode) {

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

                return NULL;
        }
        if (vflag) {
                return NULL;
        }
        if (vflag) {

-               fputs(smiNode->module, stdout);
+               fputs(smiGetNodeModule(smiNode)->name, stdout);

                fputs("::", stdout);
        }
        fputs(smiNode->name, stdout);
                fputs("::", stdout);
        }
        fputs(smiNode->name, stdout);


@@ -994,20 +1049,27 @@ static SmiNode *smi_print_variable(struct be *elem)
                        printf(".%u", oid[i]);
                }
        }
                        printf(".%u", oid[i]);
                }
        }

+       *status = 0;

        return smiNode;
 }
 
        return smiNode;
 }
 

-static void smi_print_value(SmiNode *smiNode, u_char pduid, struct be *elem)
+static int
+smi_print_value(SmiNode *smiNode, u_char pduid, struct be *elem)

 {
 {

-       unsigned int oid[128], oidlen;
+       unsigned int i, oid[128], oidlen;

        SmiType *smiType;
        SmiNamedNumber *nn;
        SmiType *smiType;
        SmiNamedNumber *nn;

-       int i, done = 0;
+       int done = 0;

 
        if (! smiNode || ! (smiNode->nodekind
                            & (SMI_NODEKIND_SCALAR | SMI_NODEKIND_COLUMN))) {
 
        if (! smiNode || ! (smiNode->nodekind
                            & (SMI_NODEKIND_SCALAR | SMI_NODEKIND_COLUMN))) {

-           asn1_print(elem);
-           return;
+           return asn1_print(elem);
+       }
+
+       if (elem->type == BE_NOSUCHOBJECT
+           || elem->type == BE_NOSUCHINST
+           || elem->type == BE_ENDOFMIBVIEW) {
+           return asn1_print(elem);

        }
 
        if (NOTIFY_CLASS(pduid) && smiNode->access < SMI_ACCESS_NOTIFY) {
        }
 
        if (NOTIFY_CLASS(pduid) && smiNode->access < SMI_ACCESS_NOTIFY) {


@@ -1027,18 +1089,17 @@ static void smi_print_value(SmiNode *smiNode, u_char pduid, struct be *elem)
            fputs("[noAccess]", stdout);
        }
 
            fputs("[noAccess]", stdout);
        }
 

-       if (! smi_check_type(smiNode->basetype, elem->type)) {
-           fputs("[wrongType]", stdout);
+       smiType = smiGetNodeType(smiNode);
+       if (! smiType) {
+           return asn1_print(elem);

        }
 
        }
 

-       smiType = smiGetType(smiNode->typemodule, smiNode->typename);
-       if (! smiType) {
-           asn1_print(elem);
-           return;
+       if (! smi_check_type(smiType->basetype, elem->type)) {
+           fputs("[wrongType]", stdout);

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

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

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


@@ -1048,23 +1109,24 @@ static void smi_print_value(SmiNode *smiNode, u_char pduid, struct be *elem)
        /* apply display hints (integer, octetstring) */
 
        /* convert instance identifier to index type values */
        /* apply display hints (integer, octetstring) */
 
        /* convert instance identifier to index type values */

-       
+

        switch (elem->type) {
        case BE_OID:
        switch (elem->type) {
        case BE_OID:

-               if (smiNode->basetype == SMI_BASETYPE_BITS
-                   && smiNode->typemodule && smiNode->typename) {
+               if (smiType->basetype == SMI_BASETYPE_BITS) {

                        /* print bit labels */
                } else {
                        /* print bit labels */
                } else {

-                       smi_decode_oid(elem, oid, &oidlen);
+                       smi_decode_oid(elem, oid,
+                                      sizeof(oid)/sizeof(unsigned int),
+                                      &oidlen);

                        smiNode = smiGetNodeByOID(oidlen, oid);
                        if (smiNode) {
                                if (vflag) {
                        smiNode = smiGetNodeByOID(oidlen, oid);
                        if (smiNode) {
                                if (vflag) {

-                                       fputs(smiNode->module, stdout);
+                                       fputs(smiGetNodeModule(smiNode)->name, stdout);

                                        fputs("::", stdout);
                                }
                                fputs(smiNode->name, stdout);
                                if (smiNode->oidlen < oidlen) {
                                        fputs("::", stdout);
                                }
                                fputs(smiNode->name, stdout);
                                if (smiNode->oidlen < oidlen) {

-                                       for (i = smiNode->oidlen; 
+                                       for (i = smiNode->oidlen;

                                             i < oidlen; i++) {
                                                printf(".%u", oid[i]);
                                        }
                                             i < oidlen; i++) {
                                                printf(".%u", oid[i]);
                                        }


@@ -1075,10 +1137,8 @@ static void smi_print_value(SmiNode *smiNode, u_char pduid, struct be *elem)
                break;
 
        case BE_INT:
                break;
 
        case BE_INT:

-               if (smiNode->basetype == SMI_BASETYPE_ENUM
-                   && smiNode->typemodule && smiNode->typename) {
-                       for (nn = smiGetFirstNamedNumber(smiNode->typemodule,
-                                                        smiNode->typename);
+               if (smiType->basetype == SMI_BASETYPE_ENUM) {
+                       for (nn = smiGetFirstNamedNumber(smiType);

                             nn;
                             nn = smiGetNextNamedNumber(nn)) {
                                 if (nn->value.value.integer32
                             nn;
                             nn = smiGetNextNamedNumber(nn)) {
                                 if (nn->value.value.integer32


@@ -1094,12 +1154,9 @@ static void smi_print_value(SmiNode *smiNode, u_char pduid, struct be *elem)
        }
 
        if (! done) {
        }
 
        if (! done) {

-               asn1_print(elem);
-       }
-
-       if (smiType) {
-               smiFreeType(smiType);
+               return asn1_print(elem);

        }
        }

+       return 0;

 }
 #endif
 
 }
 #endif
 


@@ -1147,6 +1204,7 @@ varbind_print(u_char pduid, const u_char *np, u_int length)
 #ifdef LIBSMI
        SmiNode *smiNode = NULL;
 #endif
 #ifdef LIBSMI
        SmiNode *smiNode = NULL;
 #endif

+       int status;

 
        /* Sequence of varBind */
        if ((count = asn1_parse(np, length, &elem)) < 0)
 
        /* Sequence of varBind */
        if ((count = asn1_parse(np, length, &elem)) < 0)


@@ -1156,7 +1214,7 @@ varbind_print(u_char pduid, const u_char *np, u_int length)
                asn1_print(&elem);
                return;
        }
                asn1_print(&elem);
                return;
        }

-       if (count < length)
+       if ((u_int)count < length)

                printf("[%d extra after SEQ of varbind]", length - count);
        /* descend */
        length = elem.asnlen;
                printf("[%d extra after SEQ of varbind]", length - count);
        /* descend */
        length = elem.asnlen;


@@ -1191,16 +1249,18 @@ varbind_print(u_char pduid, const u_char *np, u_int length)
                        return;
                }
 #ifdef LIBSMI
                        return;
                }
 #ifdef LIBSMI

-               smiNode = smi_print_variable(&elem);
+               smiNode = smi_print_variable(&elem, &status);

 #else
 #else

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

 #endif
 #endif

+               if (status < 0)
+                       return;

                length -= count;
                np += count;
 
                if (pduid != GETREQ && pduid != GETNEXTREQ
                    && pduid != GETBULKREQ)
                length -= count;
                np += count;
 
                if (pduid != GETREQ && pduid != GETNEXTREQ
                    && pduid != GETBULKREQ)

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

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


@@ -1209,17 +1269,19 @@ varbind_print(u_char pduid, const u_char *np, u_int length)
                    || pduid == GETBULKREQ) {
                        if (elem.type != BE_NULL) {
                                fputs("[objVal!=NULL]", stdout);
                    || pduid == GETBULKREQ) {
                        if (elem.type != BE_NULL) {
                                fputs("[objVal!=NULL]", stdout);

-                               asn1_print(&elem);
+                               if (asn1_print(&elem) < 0)
+                                       return;

                        }
                } else {
                        if (elem.type != BE_NULL) {
 #ifdef LIBSMI
                        }
                } else {
                        if (elem.type != BE_NULL) {
 #ifdef LIBSMI

-                               smi_print_value(smiNode, pduid, &elem);
-                               smiFreeNode(smiNode);
+                               status = smi_print_value(smiNode, pduid, &elem);

 #else
 #else

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

 #endif
                        }
 #endif
                        }

+                       if (status < 0)
+                               return;

                }
                length = vblength;
                np = vbend;
                }
                length = vblength;
                np = vbend;


@@ -1231,7 +1293,7 @@ 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_char pduid, const u_char *np, u_int length)
+snmppdu_print(u_short pduid, const u_char *np, u_int length)

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


@@ -1244,7 +1306,8 @@ snmppdu_print(u_char pduid, const u_char *np, u_int length)
                asn1_print(&elem);
                return;
        }
                asn1_print(&elem);
                return;
        }

-       /* ignore the reqId */
+       if (vflag)
+               printf("R=%d ", elem.data.integer);

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


@@ -1260,13 +1323,13 @@ snmppdu_print(u_char pduid, const u_char *np, u_int length)
        if ((pduid == GETREQ || pduid == GETNEXTREQ || pduid == SETREQ
            || pduid == INFORMREQ || pduid == V2TRAP || pduid == REPORT)
            && elem.data.integer != 0) {
        if ((pduid == GETREQ || pduid == GETNEXTREQ || pduid == SETREQ
            || pduid == INFORMREQ || pduid == V2TRAP || pduid == REPORT)
            && elem.data.integer != 0) {

-               char errbuf[10];
+               char errbuf[20];

                printf("[errorStatus(%s)!=0]",
                        DECODE_ErrorStatus(elem.data.integer));
        } else if (pduid == GETBULKREQ) {
                printf(" N=%d", elem.data.integer);
        } else if (elem.data.integer != 0) {
                printf("[errorStatus(%s)!=0]",
                        DECODE_ErrorStatus(elem.data.integer));
        } else if (pduid == GETBULKREQ) {
                printf(" N=%d", elem.data.integer);
        } else if (elem.data.integer != 0) {

-               char errbuf[10];
+               char errbuf[20];

                printf(" %s", DECODE_ErrorStatus(elem.data.integer));
                error = elem.data.integer;
        }
                printf(" %s", DECODE_ErrorStatus(elem.data.integer));
                error = elem.data.integer;
        }


@@ -1325,7 +1388,8 @@ trappdu_print(const u_char *np, u_int length)
                asn1_print(&elem);
                return;
        }
                asn1_print(&elem);
                return;
        }

-       asn1_print(&elem);
+       if (asn1_print(&elem) < 0)
+               return;

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


@@ -1339,7 +1403,8 @@ trappdu_print(const u_char *np, u_int length)
                asn1_print(&elem);
                return;
        }
                asn1_print(&elem);
                return;
        }

-       asn1_print(&elem);
+       if (asn1_print(&elem) < 0)
+               return;

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


@@ -1353,7 +1418,7 @@ trappdu_print(const u_char *np, u_int length)
        }
        generic = elem.data.integer;
        {
        }
        generic = elem.data.integer;
        {

-               char buf[10];
+               char buf[20];

                printf(" %s", DECODE_GenericTrap(generic));
        }
        length -= count;
                printf(" %s", DECODE_GenericTrap(generic));
        }
        length -= count;


@@ -1385,7 +1450,8 @@ trappdu_print(const u_char *np, u_int length)
                asn1_print(&elem);
                return;
        }
                asn1_print(&elem);
                return;
        }

-       asn1_print(&elem);
+       if (asn1_print(&elem) < 0)
+               return;

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


@@ -1409,15 +1475,20 @@ pdu_print(const u_char *np, u_int length, int version)
                fputs("[no PDU]", stdout);
                return;
        }
                fputs("[no PDU]", stdout);
                return;
        }

-       if (count < length)
+       if ((u_int)count < length)

                printf("[%d extra after PDU]", length - count);
                printf("[%d extra after PDU]", length - count);

-       asn1_print(&pdu);
+       if (vflag) {
+               fputs("{ ", stdout);
+       }
+       if (asn1_print(&pdu) < 0)
+               return;
+       fputs(" ", stdout);

        /* descend into PDU */
        length = pdu.asnlen;
        np = (u_char *)pdu.data.raw;
 
        if (version == SNMP_VERSION_1 &&
        /* descend into PDU */
        length = pdu.asnlen;
        np = (u_char *)pdu.data.raw;
 
        if (version == SNMP_VERSION_1 &&

-           (pdu.id == GETBULKREQ || pdu.id == INFORMREQ || 
+           (pdu.id == GETBULKREQ || pdu.id == INFORMREQ ||

             pdu.id == V2TRAP || pdu.id == REPORT)) {
                printf("[v2 PDU in v1 message]");
                return;
             pdu.id == V2TRAP || pdu.id == REPORT)) {
                printf("[v2 PDU in v1 message]");
                return;


@@ -1443,6 +1514,10 @@ pdu_print(const u_char *np, u_int length, int version)
                snmppdu_print(pdu.id, np, length);
                break;
        }
                snmppdu_print(pdu.id, np, length);
                break;
        }

+
+       if (vflag) {
+               fputs(" } ", stdout);
+       }

 }
 
 /*
 }
 
 /*


@@ -1516,8 +1591,9 @@ community_print(const u_char *np, u_int length, int version)
                return;
        }
        /* default community */
                return;
        }
        /* default community */

-       if (strncmp((char *)elem.data.str, DEF_COMMUNITY,
-           sizeof(DEF_COMMUNITY) - 1))
+       if (!(elem.asnlen == sizeof(DEF_COMMUNITY) - 1 &&
+           strncmp((char *)elem.data.str, DEF_COMMUNITY,
+                   sizeof(DEF_COMMUNITY) - 1) == 0))

                /* ! "public" */
                printf("C=%.*s ", (int)elem.asnlen, elem.data.str);
        length -= count;
                /* ! "public" */
                printf("C=%.*s ", (int)elem.asnlen, elem.data.str);
        length -= count;


@@ -1565,7 +1641,7 @@ usm_print(const u_char *np, u_int length)
                asn1_print(&elem);
                return;
        }
                asn1_print(&elem);
                return;
        }

-       if (vflag) 
+       if (vflag)

                printf("B=%d ", elem.data.integer);
        length -= count;
        np += count;
                printf("B=%d ", elem.data.integer);
        length -= count;
        np += count;


@@ -1578,7 +1654,7 @@ usm_print(const u_char *np, u_int length)
                asn1_print(&elem);
                return;
        }
                asn1_print(&elem);
                return;
        }

-       if (vflag) 
+       if (vflag)

                printf("T=%d ", elem.data.integer);
        length -= count;
        np += count;
                printf("T=%d ", elem.data.integer);
        length -= count;
        np += count;


@@ -1618,7 +1694,7 @@ usm_print(const u_char *np, u_int length)
        length -= count;
         np += count;
 
        length -= count;
         np += count;
 

-       if (count < length)
+       if ((u_int)count < length)

                printf("[%d extra after usm SEQ]", length - count);
 }
 
                printf("[%d extra after usm SEQ]", length - count);
 }
 


@@ -1646,6 +1722,10 @@ v3msg_print(const u_char *np, u_int length)
        length = elem.asnlen;
        np = (u_char *)elem.data.raw;
 
        length = elem.asnlen;
        np = (u_char *)elem.data.raw;
 

+       if (vflag) {
+               fputs("{ ", stdout);
+       }
+

        /* msgID (INTEGER) */
        if ((count = asn1_parse(np, length, &elem)) < 0)
                return;
        /* msgID (INTEGER) */
        if ((count = asn1_parse(np, length, &elem)) < 0)
                return;


@@ -1681,7 +1761,7 @@ v3msg_print(const u_char *np, u_int length)
                return;
        }
        flags = elem.data.str[0];
                return;
        }
        flags = elem.data.str[0];

-       if (flags != 0x00 && flags != 0x01 && flags != 0x03 
+       if (flags != 0x00 && flags != 0x01 && flags != 0x03

            && flags != 0x04 && flags != 0x05 && flags != 0x07) {
                printf("[msgFlags=0x%02X]", flags);
                return;
            && flags != 0x04 && flags != 0x05 && flags != 0x07) {
                printf("[msgFlags=0x%02X]", flags);
                return;


@@ -1707,12 +1787,16 @@ v3msg_print(const u_char *np, u_int length)
        length -= count;
        np += count;
 
        length -= count;
        np += count;
 

-       if (count < length)
+       if ((u_int)count < length)

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

+       if (vflag) {
+               fputs("} ", stdout);
+       }
+

        if (model == 3) {
            if (vflag) {
        if (model == 3) {
            if (vflag) {

-               fputs("USM ", stdout);
+               fputs("{ USM ", stdout);

            }
        } else {
            printf("[security model %d]", model);
            }
        } else {
            printf("[security model %d]", model);


@@ -1735,13 +1819,20 @@ v3msg_print(const u_char *np, u_int length)
 
        if (model == 3) {
            usm_print(elem.data.str, elem.asnlen);
 
        if (model == 3) {
            usm_print(elem.data.str, elem.asnlen);

+           if (vflag) {
+               fputs("} ", stdout);
+           }

        }
 
        if (vflag) {
        }
 
        if (vflag) {

-           fputs("ScopedPDU ", stdout);
+           fputs("{ ScopedPDU ", stdout);

        }
 
        scopedpdu_print(np, length, 3);
        }
 
        scopedpdu_print(np, length, 3);

+
+       if (vflag) {
+               fputs("} ", stdout);
+       }

 }
 
 /*
 }
 
 /*


@@ -1754,14 +1845,6 @@ snmp_print(const u_char *np, u_int length)
        int count = 0;
        int version = 0;
 
        int count = 0;
        int version = 0;
 

-       truncated = 0;
-
-       /* truncated packet? */
-       if (np + length > snapend) {
-               truncated = 1;
-               length = snapend - np;
-       }
-

        putchar(' ');
 
        /* initial Sequence */
        putchar(' ');
 
        /* initial Sequence */


@@ -1772,7 +1855,7 @@ snmp_print(const u_char *np, u_int length)
                asn1_print(&elem);
                return;
        }
                asn1_print(&elem);
                return;
        }

-       if (count < length)
+       if ((u_int)count < length)

                printf("[%d extra after iSEQ]", length - count);
        /* descend */
        length = elem.asnlen;
                printf("[%d extra after iSEQ]", length - count);
        /* descend */
        length = elem.asnlen;


@@ -1792,7 +1875,7 @@ snmp_print(const u_char *np, u_int length)
        case SNMP_VERSION_2:
        case SNMP_VERSION_3:
                if (vflag)
        case SNMP_VERSION_2:
        case SNMP_VERSION_3:
                if (vflag)

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

                break;
        default:
                printf("[version = %d]", elem.data.integer);
                break;
        default:
                printf("[version = %d]", elem.data.integer);


@@ -1814,4 +1897,8 @@ snmp_print(const u_char *np, u_int length)
                printf("[version = %d]", elem.data.integer);
                break;
        }
                printf("[version = %d]", elem.data.integer);
                break;
        }

+
+       if (vflag) {
+               fputs("} ", stdout);
+       }

 }
 }