add tracefiles for infinite loop testing

[tcpdump] / print-bgp.c

diff --git a/print-bgp.c b/print-bgp.c
index 239425b14863c7448f577f42e5fc23d33963a81e..08908019f8845fa3d9ffcdfcc16bb254cedc1b5c 100644 (file)
--- a/print-bgp.c
+++ b/print-bgp.c
@@ -34,6 +34,10 @@
 #include "config.h"
 #endif
 
 #include "config.h"
 #endif
 

+#ifndef lint
+static const char rcsid[] _U_ =
+     "@(#) $Header: /tcpdump/master/tcpdump/print-bgp.c,v 1.72.2.5 2005-04-27 18:42:28 hannes Exp $";
+#endif

 
 #include <tcpdump-stdinc.h>
 
 
 #include <tcpdump-stdinc.h>
 


@@ -44,10 +48,6 @@
 #include "addrtoname.h"
 #include "extract.h"
 
 #include "addrtoname.h"
 #include "extract.h"
 

-#ifndef lint
-static const char rcsid[] _U_ =
-     "@(#) $Header: /tcpdump/master/tcpdump/print-bgp.c,v 1.72.2.1 2003-11-15 22:28:42 guy Exp $";
-#endif

 struct bgp {
        u_int8_t bgp_marker[16];
        u_int16_t bgp_len;
 struct bgp {
        u_int8_t bgp_marker[16];
        u_int16_t bgp_len;


@@ -161,6 +161,27 @@ static struct tok bgp_attr_values[] = {
     { 0, NULL}
 };
 
     { 0, NULL}
 };
 

+#define BGP_AS_SET             1
+#define BGP_AS_SEQUENCE        2
+#define BGP_CONFED_AS_SEQUENCE 3 /* draft-ietf-idr-rfc3065bis-01 */
+#define BGP_CONFED_AS_SET      4 /* draft-ietf-idr-rfc3065bis-01  */
+
+static struct tok bgp_as_path_segment_open_values[] = {
+    { BGP_AS_SEQUENCE,         ""},
+    { BGP_AS_SET,              "{ "},
+    { BGP_CONFED_AS_SEQUENCE,  "( "},
+    { BGP_CONFED_AS_SET,       "({ "},
+    { 0, NULL}
+};
+
+static struct tok bgp_as_path_segment_close_values[] = {
+    { BGP_AS_SEQUENCE,         ""},
+    { BGP_AS_SET,              "}"},
+    { BGP_CONFED_AS_SEQUENCE,  ")"},
+    { BGP_CONFED_AS_SET,       "})"},
+    { 0, NULL}
+};
+

 #define BGP_OPT_AUTH                    1
 #define BGP_OPT_CAP                     2
 
 #define BGP_OPT_AUTH                    1
 #define BGP_OPT_CAP                     2
 


@@ -429,11 +450,13 @@ decode_prefix4(const u_char *pptr, char *buf, u_int buflen)
        struct in_addr addr;
        u_int plen;
 
        struct in_addr addr;
        u_int plen;
 

+       TCHECK(pptr[0]);

        plen = pptr[0];
        if (32 < plen)
                return -1;
 
        memset(&addr, 0, sizeof(addr));
        plen = pptr[0];
        if (32 < plen)
                return -1;
 
        memset(&addr, 0, sizeof(addr));

+       TCHECK2(pptr[1], (plen + 7) / 8);

        memcpy(&addr, &pptr[1], (plen + 7) / 8);
        if (plen % 8) {
                ((u_char *)&addr)[(plen + 7) / 8 - 1] &=
        memcpy(&addr, &pptr[1], (plen + 7) / 8);
        if (plen % 8) {
                ((u_char *)&addr)[(plen + 7) / 8 - 1] &=


@@ -441,6 +464,9 @@ decode_prefix4(const u_char *pptr, char *buf, u_int buflen)
        }
        snprintf(buf, buflen, "%s/%d", getname((u_char *)&addr), plen);
        return 1 + (plen + 7) / 8;
        }
        snprintf(buf, buflen, "%s/%d", getname((u_char *)&addr), plen);
        return 1 + (plen + 7) / 8;

+
+trunc:
+       return -2;

 }
 
 static int
 }
 
 static int


@@ -449,6 +475,7 @@ decode_labeled_prefix4(const u_char *pptr, char *buf, u_int buflen)
        struct in_addr addr;
        u_int plen;
 
        struct in_addr addr;
        u_int plen;
 

+       TCHECK(pptr[0]);

        plen = pptr[0];   /* get prefix length */
 
         /* this is one of the weirdnesses of rfc3107
        plen = pptr[0];   /* get prefix length */
 
         /* this is one of the weirdnesses of rfc3107


@@ -465,6 +492,7 @@ decode_labeled_prefix4(const u_char *pptr, char *buf, u_int buflen)
                return -1;
 
        memset(&addr, 0, sizeof(addr));
                return -1;
 
        memset(&addr, 0, sizeof(addr));

+       TCHECK2(pptr[4], (plen + 7) / 8);

        memcpy(&addr, &pptr[4], (plen + 7) / 8);
        if (plen % 8) {
                ((u_char *)&addr)[(plen + 7) / 8 - 1] &=
        memcpy(&addr, &pptr[4], (plen + 7) / 8);
        if (plen % 8) {
                ((u_char *)&addr)[(plen + 7) / 8 - 1] &=


@@ -478,6 +506,9 @@ decode_labeled_prefix4(const u_char *pptr, char *buf, u_int buflen)
                  ((pptr[3]&1)==0) ? "(BOGUS: Bottom of Stack NOT set!)" : "(bottom)" );
 
        return 4 + (plen + 7) / 8;
                  ((pptr[3]&1)==0) ? "(BOGUS: Bottom of Stack NOT set!)" : "(bottom)" );
 
        return 4 + (plen + 7) / 8;

+
+trunc:
+       return -2;

 }
 
 /* RDs and RTs share the same semantics
 }
 
 /* RDs and RTs share the same semantics


@@ -527,6 +558,7 @@ decode_rt_routing_info(const u_char *pptr, char *buf, u_int buflen)
        u_int8_t route_target[8];
        u_int plen;
 
        u_int8_t route_target[8];
        u_int plen;
 

+       TCHECK(pptr[0]);

        plen = pptr[0];   /* get prefix length */
 
         plen-=32; /* adjust prefix length */
        plen = pptr[0];   /* get prefix length */
 
         plen-=32; /* adjust prefix length */


@@ -535,6 +567,7 @@ decode_rt_routing_info(const u_char *pptr, char *buf, u_int buflen)
                return -1;
 
        memset(&route_target, 0, sizeof(route_target));
                return -1;
 
        memset(&route_target, 0, sizeof(route_target));

+       TCHECK2(pptr[1], (plen + 7) / 8);

        memcpy(&route_target, &pptr[1], (plen + 7) / 8);
        if (plen % 8) {
                ((u_char *)&route_target)[(plen + 7) / 8 - 1] &=
        memcpy(&route_target, &pptr[1], (plen + 7) / 8);
        if (plen % 8) {
                ((u_char *)&route_target)[(plen + 7) / 8 - 1] &=


@@ -545,6 +578,9 @@ decode_rt_routing_info(const u_char *pptr, char *buf, u_int buflen)
                  bgp_vpn_rd_print((u_char *)&route_target));
 
        return 5 + (plen + 7) / 8;
                  bgp_vpn_rd_print((u_char *)&route_target));
 
        return 5 + (plen + 7) / 8;

+
+trunc:
+       return -2;

 }
 
 static int
 }
 
 static int


@@ -553,6 +589,7 @@ decode_labeled_vpn_prefix4(const u_char *pptr, char *buf, u_int buflen)
        struct in_addr addr;
        u_int plen;
 
        struct in_addr addr;
        u_int plen;
 

+       TCHECK(pptr[0]);

        plen = pptr[0];   /* get prefix length */
 
         plen-=(24+64); /* adjust prefixlen - labellength - RD len*/
        plen = pptr[0];   /* get prefix length */
 
         plen-=(24+64); /* adjust prefixlen - labellength - RD len*/


@@ -561,6 +598,7 @@ decode_labeled_vpn_prefix4(const u_char *pptr, char *buf, u_int buflen)
                return -1;
 
        memset(&addr, 0, sizeof(addr));
                return -1;
 
        memset(&addr, 0, sizeof(addr));

+       TCHECK2(pptr[12], (plen + 7) / 8);

        memcpy(&addr, &pptr[12], (plen + 7) / 8);
        if (plen % 8) {
                ((u_char *)&addr)[(plen + 7) / 8 - 1] &=
        memcpy(&addr, &pptr[12], (plen + 7) / 8);
        if (plen % 8) {
                ((u_char *)&addr)[(plen + 7) / 8 - 1] &=


@@ -575,15 +613,21 @@ decode_labeled_vpn_prefix4(const u_char *pptr, char *buf, u_int buflen)
                  ((pptr[3]&1)==0) ? "(BOGUS: Bottom of Stack NOT set!)" : "(bottom)" );
 
        return 12 + (plen + 7) / 8;
                  ((pptr[3]&1)==0) ? "(BOGUS: Bottom of Stack NOT set!)" : "(bottom)" );
 
        return 12 + (plen + 7) / 8;

+
+trunc:
+       return -2;

 }
 
 static int
 decode_labeled_vpn_l2(const u_char *pptr, char *buf, u_int buflen)
 {
         int plen,tlen,strlen,tlv_type,tlv_len,ttlv_len;
 }
 
 static int
 decode_labeled_vpn_l2(const u_char *pptr, char *buf, u_int buflen)
 {
         int plen,tlen,strlen,tlv_type,tlv_len,ttlv_len;

+
+       TCHECK2(pptr[0], 2);

         plen=EXTRACT_16BITS(pptr);
         tlen=plen;
         pptr+=2;
         plen=EXTRACT_16BITS(pptr);
         tlen=plen;
         pptr+=2;

+       TCHECK2(pptr[0],15);

         strlen=snprintf(buf, buflen, "RD: %s, CE-ID: %u, Label-Block Offset: %u, Label Base %u",
                         bgp_vpn_rd_print(pptr),
                         EXTRACT_16BITS(pptr+8),
         strlen=snprintf(buf, buflen, "RD: %s, CE-ID: %u, Label-Block Offset: %u, Label Base %u",
                         bgp_vpn_rd_print(pptr),
                         EXTRACT_16BITS(pptr+8),


@@ -594,6 +638,9 @@ decode_labeled_vpn_l2(const u_char *pptr, char *buf, u_int buflen)
 
         /* ok now the variable part - lets read out TLVs*/
         while (tlen>0) {
 
         /* ok now the variable part - lets read out TLVs*/
         while (tlen>0) {

+            if (tlen < 3)
+                return -1;
+            TCHECK2(pptr[0], 3);

             tlv_type=*pptr++;
             tlv_len=EXTRACT_16BITS(pptr);
             ttlv_len=tlv_len;
             tlv_type=*pptr++;
             tlv_len=EXTRACT_16BITS(pptr);
             ttlv_len=tlv_len;


@@ -606,6 +653,7 @@ decode_labeled_vpn_l2(const u_char *pptr, char *buf, u_int buflen)
                                  tlv_len);
                 ttlv_len=ttlv_len/8+1; /* how many bytes do we need to read ? */
                 while (ttlv_len>0) {
                                  tlv_len);
                 ttlv_len=ttlv_len/8+1; /* how many bytes do we need to read ? */
                 while (ttlv_len>0) {

+                    TCHECK(pptr[0]);

                     strlen+=snprintf(buf+strlen,buflen-strlen, "%02x",*pptr++);
                     ttlv_len--;
                 }
                     strlen+=snprintf(buf+strlen,buflen-strlen, "%02x",*pptr++);
                     ttlv_len--;
                 }


@@ -619,6 +667,9 @@ decode_labeled_vpn_l2(const u_char *pptr, char *buf, u_int buflen)
             tlen-=(tlv_len<<3); /* the tlv-length is expressed in bits so lets shift it tright */
         }
         return plen+2;
             tlen-=(tlv_len<<3); /* the tlv-length is expressed in bits so lets shift it tright */
         }
         return plen+2;

+
+trunc:
+        return -2;

 }
 
 #ifdef INET6
 }
 
 #ifdef INET6


@@ -628,11 +679,13 @@ decode_prefix6(const u_char *pd, char *buf, u_int buflen)
        struct in6_addr addr;
        u_int plen;
 
        struct in6_addr addr;
        u_int plen;
 

+       TCHECK(pd[0]);

        plen = pd[0];
        if (128 < plen)
                return -1;
 
        memset(&addr, 0, sizeof(addr));
        plen = pd[0];
        if (128 < plen)
                return -1;
 
        memset(&addr, 0, sizeof(addr));

+       TCHECK2(pd[1], (plen + 7) / 8);

        memcpy(&addr, &pd[1], (plen + 7) / 8);
        if (plen % 8) {
                addr.s6_addr[(plen + 7) / 8 - 1] &=
        memcpy(&addr, &pd[1], (plen + 7) / 8);
        if (plen % 8) {
                addr.s6_addr[(plen + 7) / 8 - 1] &=


@@ -640,6 +693,9 @@ decode_prefix6(const u_char *pd, char *buf, u_int buflen)
        }
        snprintf(buf, buflen, "%s/%d", getname6((u_char *)&addr), plen);
        return 1 + (plen + 7) / 8;
        }
        snprintf(buf, buflen, "%s/%d", getname6((u_char *)&addr), plen);
        return 1 + (plen + 7) / 8;

+
+trunc:
+       return -2;

 }
 
 static int
 }
 
 static int


@@ -648,6 +704,7 @@ decode_labeled_prefix6(const u_char *pptr, char *buf, u_int buflen)
        struct in6_addr addr;
        u_int plen;
 
        struct in6_addr addr;
        u_int plen;
 

+       TCHECK(pptr[0]);

        plen = pptr[0]; /* get prefix length */
         plen-=24; /* adjust prefixlen - labellength */
 
        plen = pptr[0]; /* get prefix length */
         plen-=24; /* adjust prefixlen - labellength */
 


@@ -655,6 +712,7 @@ decode_labeled_prefix6(const u_char *pptr, char *buf, u_int buflen)
                return -1;
 
        memset(&addr, 0, sizeof(addr));
                return -1;
 
        memset(&addr, 0, sizeof(addr));

+       TCHECK2(pptr[4], (plen + 7) / 8);

        memcpy(&addr, &pptr[4], (plen + 7) / 8);
        if (plen % 8) {
                addr.s6_addr[(plen + 7) / 8 - 1] &=
        memcpy(&addr, &pptr[4], (plen + 7) / 8);
        if (plen % 8) {
                addr.s6_addr[(plen + 7) / 8 - 1] &=


@@ -668,6 +726,9 @@ decode_labeled_prefix6(const u_char *pptr, char *buf, u_int buflen)
                  ((pptr[3]&1)==0) ? "(BOGUS: Bottom of Stack NOT set!)" : "(bottom)" );
 
        return 4 + (plen + 7) / 8;
                  ((pptr[3]&1)==0) ? "(BOGUS: Bottom of Stack NOT set!)" : "(bottom)" );
 
        return 4 + (plen + 7) / 8;

+
+trunc:
+       return -2;

 }
 
 static int
 }
 
 static int


@@ -676,6 +737,7 @@ decode_labeled_vpn_prefix6(const u_char *pptr, char *buf, u_int buflen)
        struct in6_addr addr;
        u_int plen;
 
        struct in6_addr addr;
        u_int plen;
 

+       TCHECK(pptr[0]);

        plen = pptr[0];   /* get prefix length */
 
         plen-=(24+64); /* adjust prefixlen - labellength - RD len*/
        plen = pptr[0];   /* get prefix length */
 
         plen-=(24+64); /* adjust prefixlen - labellength - RD len*/


@@ -684,6 +746,7 @@ decode_labeled_vpn_prefix6(const u_char *pptr, char *buf, u_int buflen)
                return -1;
 
        memset(&addr, 0, sizeof(addr));
                return -1;
 
        memset(&addr, 0, sizeof(addr));

+       TCHECK2(pptr[12], (plen + 7) / 8);

        memcpy(&addr, &pptr[12], (plen + 7) / 8);
        if (plen % 8) {
                addr.s6_addr[(plen + 7) / 8 - 1] &=
        memcpy(&addr, &pptr[12], (plen + 7) / 8);
        if (plen % 8) {
                addr.s6_addr[(plen + 7) / 8 - 1] &=


@@ -698,10 +761,13 @@ decode_labeled_vpn_prefix6(const u_char *pptr, char *buf, u_int buflen)
                  ((pptr[3]&1)==0) ? "(BOGUS: Bottom of Stack NOT set!)" : "(bottom)" );
 
        return 12 + (plen + 7) / 8;
                  ((pptr[3]&1)==0) ? "(BOGUS: Bottom of Stack NOT set!)" : "(bottom)" );
 
        return 12 + (plen + 7) / 8;

+
+trunc:
+       return -2;

 }
 #endif
 
 }
 #endif
 

-static void
+static int

 bgp_attr_print(const struct bgp_attr *attr, const u_char *pptr, int len)
 {
        int i;
 bgp_attr_print(const struct bgp_attr *attr, const u_char *pptr, int len)
 {
        int i;


@@ -723,8 +789,10 @@ bgp_attr_print(const struct bgp_attr *attr, const u_char *pptr, int len)
        case BGPTYPE_ORIGIN:
                if (len != 1)
                        printf("invalid len");
        case BGPTYPE_ORIGIN:
                if (len != 1)
                        printf("invalid len");

-               else
+               else {
+                       TCHECK(*tptr);

                        printf("%s", tok2str(bgp_origin_values, "Unknown Origin Typecode", tptr[0]));
                        printf("%s", tok2str(bgp_origin_values, "Unknown Origin Typecode", tptr[0]));

+               }

                break;
        case BGPTYPE_AS_PATH:
                if (len % 2) {
                break;
        case BGPTYPE_AS_PATH:
                if (len % 2) {


@@ -735,35 +803,36 @@ bgp_attr_print(const struct bgp_attr *attr, const u_char *pptr, int len)
                        printf("empty");
                        break;
                 }
                        printf("empty");
                        break;
                 }

+

                while (tptr < pptr + len) {
                while (tptr < pptr + len) {

-                       /*
-                        * under RFC1965, p[0] means:
-                        * 1: AS_SET 2: AS_SEQUENCE
-                        * 3: AS_CONFED_SET 4: AS_CONFED_SEQUENCE
-                        */
-                       if (tptr[0] == 3 || tptr[0] == 4)
-                               printf("confed");
-                       printf("%s", (tptr[0] & 1) ? "{" : "");
-                       for (i = 0; i < tptr[1] * 2; i += 2) {
-                               printf("%s%u", i == 0 ? "" : " ",
-                                       EXTRACT_16BITS(&tptr[2 + i]));
-                       }
-                       printf("%s", (tptr[0] & 1) ? "}" : "");
-                       tptr += 2 + tptr[1] * 2;
+                       TCHECK(tptr[0]);
+                        printf("%s", tok2str(bgp_as_path_segment_open_values, "?", tptr[0]));
+                        for (i = 0; i < tptr[1] * 2; i += 2) {
+                            TCHECK2(tptr[2 + i], 2);
+                            printf("%u ", EXTRACT_16BITS(&tptr[2 + i]));
+                        }
+                       TCHECK(tptr[0]);
+                        printf("%s", tok2str(bgp_as_path_segment_close_values, "?", tptr[0]));
+                        TCHECK(tptr[1]);
+                        tptr += 2 + tptr[1] * 2;

                }
                break;
        case BGPTYPE_NEXT_HOP:
                if (len != 4)
                        printf("invalid len");
                }
                break;
        case BGPTYPE_NEXT_HOP:
                if (len != 4)
                        printf("invalid len");

-               else
+               else {
+                       TCHECK2(tptr[0], 4);

                        printf("%s", getname(tptr));
                        printf("%s", getname(tptr));

+               }

                break;
        case BGPTYPE_MULTI_EXIT_DISC:
        case BGPTYPE_LOCAL_PREF:
                if (len != 4)
                        printf("invalid len");
                break;
        case BGPTYPE_MULTI_EXIT_DISC:
        case BGPTYPE_LOCAL_PREF:
                if (len != 4)
                        printf("invalid len");

-               else
+               else {
+                       TCHECK2(tptr[0], 4);

                        printf("%u", EXTRACT_32BITS(tptr));
                        printf("%u", EXTRACT_32BITS(tptr));

+               }

                break;
        case BGPTYPE_ATOMIC_AGGREGATE:
                if (len != 0)
                break;
        case BGPTYPE_ATOMIC_AGGREGATE:
                if (len != 0)


@@ -774,6 +843,7 @@ bgp_attr_print(const struct bgp_attr *attr, const u_char *pptr, int len)
                        printf("invalid len");
                        break;
                }
                        printf("invalid len");
                        break;
                }

+               TCHECK2(tptr[0], 6);

                printf(" AS #%u, origin %s", EXTRACT_16BITS(tptr),
                        getname(tptr + 2));
                break;
                printf(" AS #%u, origin %s", EXTRACT_16BITS(tptr),
                        getname(tptr + 2));
                break;


@@ -784,6 +854,7 @@ bgp_attr_print(const struct bgp_attr *attr, const u_char *pptr, int len)
                }
                while (tlen>0) {
                        u_int32_t comm;
                }
                while (tlen>0) {
                        u_int32_t comm;

+                       TCHECK2(tptr[0], 4);

                        comm = EXTRACT_32BITS(tptr);
                        switch (comm) {
                        case BGP_COMMUNITY_NO_EXPORT:
                        comm = EXTRACT_32BITS(tptr);
                        switch (comm) {
                        case BGP_COMMUNITY_NO_EXPORT:


@@ -811,10 +882,16 @@ bgp_attr_print(const struct bgp_attr *attr, const u_char *pptr, int len)
                        printf("invalid len");
                        break;
                }
                        printf("invalid len");
                        break;
                }

+               TCHECK2(tptr[0], 4);

                 printf("%s",getname(tptr));
                 break;
         case BGPTYPE_CLUSTER_LIST:
                 printf("%s",getname(tptr));
                 break;
         case BGPTYPE_CLUSTER_LIST:

+               if (len % 4) {
+                       printf("invalid len");
+                       break;
+               }

                 while (tlen>0) {
                 while (tlen>0) {

+                       TCHECK2(tptr[0], 4);

                         printf("%s%s",
                                getname(tptr),
                                 (tlen>4) ? ", " : "");
                         printf("%s%s",
                                getname(tptr),
                                 (tlen>4) ? ", " : "");


@@ -823,6 +900,7 @@ bgp_attr_print(const struct bgp_attr *attr, const u_char *pptr, int len)
                 }
                 break;
        case BGPTYPE_MP_REACH_NLRI:
                 }
                 break;
        case BGPTYPE_MP_REACH_NLRI:

+               TCHECK2(tptr[0], 3);

                af = EXTRACT_16BITS(tptr);
                safi = tptr[2];
        
                af = EXTRACT_16BITS(tptr);
                safi = tptr[2];
        


@@ -848,6 +926,7 @@ bgp_attr_print(const struct bgp_attr *attr, const u_char *pptr, int len)
 
                 tptr +=3;
 
 
                 tptr +=3;
 

+               TCHECK(tptr[0]);

                tlen = tptr[0];
                 tptr++;
 
                tlen = tptr[0];
                 tptr++;
 


@@ -862,23 +941,38 @@ bgp_attr_print(const struct bgp_attr *attr, const u_char *pptr, int len)
                                     case SAFNUM_UNIMULTICAST:
                                     case SAFNUM_LABUNICAST:
                                     case SAFNUM_RT_ROUTING_INFO:
                                     case SAFNUM_UNIMULTICAST:
                                     case SAFNUM_LABUNICAST:
                                     case SAFNUM_RT_ROUTING_INFO:

-                                       printf("%s",getname(tptr));
-                                       tlen -= sizeof(struct in_addr);
-                                        tptr += sizeof(struct in_addr);
+                                       if (tlen < (int)sizeof(struct in_addr)) {
+                                           printf("invalid len");
+                                           tlen = 0;
+                                       } else {
+                                           TCHECK2(tptr[0], sizeof(struct in_addr));
+                                           printf("%s",getname(tptr));
+                                           tlen -= sizeof(struct in_addr);
+                                           tptr += sizeof(struct in_addr);
+                                       }

                                        break;
                                     case SAFNUM_VPNUNICAST:
                                     case SAFNUM_VPNMULTICAST:
                                     case SAFNUM_VPNUNIMULTICAST:
                                        break;
                                     case SAFNUM_VPNUNICAST:
                                     case SAFNUM_VPNMULTICAST:
                                     case SAFNUM_VPNUNIMULTICAST:

-                                        printf("RD: %s, %s",
+                                       if (tlen < (int)(sizeof(struct in_addr)+BGP_VPN_RD_LEN)) {
+                                           printf("invalid len");
+                                           tlen = 0;
+                                       } else {
+                                           TCHECK2(tptr[0], sizeof(struct in_addr)+BGP_VPN_RD_LEN);
+                                           printf("RD: %s, %s",

                                                bgp_vpn_rd_print(tptr),
                                                getname(tptr+BGP_VPN_RD_LEN));
                                                bgp_vpn_rd_print(tptr),
                                                getname(tptr+BGP_VPN_RD_LEN));

-                                       tlen -= (sizeof(struct in_addr)+BGP_VPN_RD_LEN);
-                                        tptr += (sizeof(struct in_addr)+BGP_VPN_RD_LEN);
+                                           tlen -= (sizeof(struct in_addr)+BGP_VPN_RD_LEN);
+                                           tptr += (sizeof(struct in_addr)+BGP_VPN_RD_LEN);
+                                       }

                                         break;
                                     default:
                                         break;
                                     default:

-                                        printf("no SAFI %u decoder",safi);                                        
+                                        TCHECK2(tptr[0], tlen);
+                                        printf("no SAFI %u decoder",safi);

                                         if (vflag <= 1)
                                             print_unknown_data(tptr,"\n\t    ",tlen);
                                         if (vflag <= 1)
                                             print_unknown_data(tptr,"\n\t    ",tlen);

+                                        tptr += tlen;
+                                        tlen = 0;

                                         break;
                                     }
                                     break;
                                         break;
                                     }
                                     break;


@@ -890,23 +984,38 @@ bgp_attr_print(const struct bgp_attr *attr, const u_char *pptr, int len)
                                     case SAFNUM_UNIMULTICAST:
                                     case SAFNUM_LABUNICAST:
                                     case SAFNUM_RT_ROUTING_INFO:
                                     case SAFNUM_UNIMULTICAST:
                                     case SAFNUM_LABUNICAST:
                                     case SAFNUM_RT_ROUTING_INFO:

-                                        printf("%s", getname6(tptr));
-                                        tlen -= sizeof(struct in6_addr);
-                                        tptr += sizeof(struct in6_addr);
+                                       if (tlen < (int)sizeof(struct in6_addr)) {
+                                           printf("invalid len");
+                                           tlen = 0;
+                                       } else {
+                                           TCHECK2(tptr[0], sizeof(struct in6_addr));
+                                           printf("%s", getname6(tptr));
+                                           tlen -= sizeof(struct in6_addr);
+                                           tptr += sizeof(struct in6_addr);
+                                       }

                                         break;
                                     case SAFNUM_VPNUNICAST:
                                     case SAFNUM_VPNMULTICAST:
                                     case SAFNUM_VPNUNIMULTICAST:
                                         break;
                                     case SAFNUM_VPNUNICAST:
                                     case SAFNUM_VPNMULTICAST:
                                     case SAFNUM_VPNUNIMULTICAST:

-                                        printf("RD: %s, %s",
+                                       if (tlen < (int)(sizeof(struct in6_addr)+BGP_VPN_RD_LEN)) {
+                                           printf("invalid len");
+                                           tlen = 0;
+                                       } else {
+                                           TCHECK2(tptr[0], sizeof(struct in6_addr)+BGP_VPN_RD_LEN);
+                                           printf("RD: %s, %s",

                                                bgp_vpn_rd_print(tptr),
                                                getname6(tptr+BGP_VPN_RD_LEN));
                                                bgp_vpn_rd_print(tptr),
                                                getname6(tptr+BGP_VPN_RD_LEN));

-                                       tlen -= (sizeof(struct in6_addr)+BGP_VPN_RD_LEN);
-                                        tptr += (sizeof(struct in6_addr)+BGP_VPN_RD_LEN);
+                                           tlen -= (sizeof(struct in6_addr)+BGP_VPN_RD_LEN);
+                                           tptr += (sizeof(struct in6_addr)+BGP_VPN_RD_LEN);
+                                       }

                                         break;
                                     default:
                                         break;
                                     default:

+                                        TCHECK2(tptr[0], tlen);

                                         printf("no SAFI %u decoder",safi);
                                         if (vflag <= 1)
                                             print_unknown_data(tptr,"\n\t    ",tlen);                                        
                                         printf("no SAFI %u decoder",safi);
                                         if (vflag <= 1)
                                             print_unknown_data(tptr,"\n\t    ",tlen);                                        

+                                        tptr += tlen;
+                                        tlen = 0;

                                         break;
                                     }
                                     break;
                                         break;
                                     }
                                     break;


@@ -916,39 +1025,53 @@ bgp_attr_print(const struct bgp_attr *attr, const u_char *pptr, int len)
                                     case SAFNUM_VPNUNICAST:
                                     case SAFNUM_VPNMULTICAST:
                                     case SAFNUM_VPNUNIMULTICAST:
                                     case SAFNUM_VPNUNICAST:
                                     case SAFNUM_VPNMULTICAST:
                                     case SAFNUM_VPNUNIMULTICAST:

-                                        printf("%s", getname(tptr));
-                                       tlen -= (sizeof(struct in_addr));
-                                        tptr += (sizeof(struct in_addr));
-                                        break;                                   
+                                       if (tlen < (int)sizeof(struct in_addr)) {
+                                           printf("invalid len");
+                                           tlen = 0;
+                                       } else {
+                                           TCHECK2(tptr[0], sizeof(struct in_addr));
+                                           printf("%s", getname(tptr));
+                                           tlen -= (sizeof(struct in_addr));
+                                           tptr += (sizeof(struct in_addr));
+                                       }
+                                        break;

                                    default:
                                    default:

+                                        TCHECK2(tptr[0], tlen);

                                         printf("no SAFI %u decoder",safi);
                                         if (vflag <= 1)
                                             print_unknown_data(tptr,"\n\t    ",tlen);                                        
                                         printf("no SAFI %u decoder",safi);
                                         if (vflag <= 1)
                                             print_unknown_data(tptr,"\n\t    ",tlen);                                        

+                                        tptr += tlen;
+                                        tlen = 0;

                                         break;
                                    }
                                    break;
 
                                default:
                                         break;
                                    }
                                    break;
 
                                default:

+                                    TCHECK2(tptr[0], tlen);

                                     printf("no AFI %u decoder",af);
                                     if (vflag <= 1)
                                       print_unknown_data(tptr,"\n\t    ",tlen);
                                     printf("no AFI %u decoder",af);
                                     if (vflag <= 1)
                                       print_unknown_data(tptr,"\n\t    ",tlen);

+                                    tptr += tlen;
+                                    tlen = 0;

                                     break;
                                }
                        }
                }
                tptr += tlen;
 
                                     break;
                                }
                        }
                }
                tptr += tlen;
 

+               TCHECK(tptr[0]);

                snpa = tptr[0];
                tptr++;
 
                if (snpa) {
                        printf("\n\t    %u SNPA", snpa);
                        for (/*nothing*/; snpa > 0; snpa--) {
                snpa = tptr[0];
                tptr++;
 
                if (snpa) {
                        printf("\n\t    %u SNPA", snpa);
                        for (/*nothing*/; snpa > 0; snpa--) {

+                               TCHECK(tptr[0]);

                                printf("\n\t      %d bytes", tptr[0]);
                                tptr += tptr[0] + 1;
                        }
                } else {
                                printf("\n\t      %d bytes", tptr[0]);
                                tptr += tptr[0] + 1;
                        }
                } else {

-                printf(", no SNPA");
+                       printf(", no SNPA");

                 }
 
                while (len - (tptr - pptr) > 0) {
                 }
 
                while (len - (tptr - pptr) > 0) {


@@ -959,26 +1082,44 @@ bgp_attr_print(const struct bgp_attr *attr, const u_char *pptr, int len)
                             case SAFNUM_MULTICAST:
                             case SAFNUM_UNIMULTICAST:
                                 advance = decode_prefix4(tptr, buf, sizeof(buf));
                             case SAFNUM_MULTICAST:
                             case SAFNUM_UNIMULTICAST:
                                 advance = decode_prefix4(tptr, buf, sizeof(buf));

-                               if (advance >= 0)
+                               if (advance == -1)
+                                        printf("\n\t    (illegal prefix length)");
+                               else if (advance == -2)
+                                        goto trunc;
+                               else

                                        printf("\n\t      %s", buf);
                                        printf("\n\t      %s", buf);

-                               else 
-                                       printf("\n\t    (illegal prefix length)");

                                 break;
                             case SAFNUM_LABUNICAST:
                                 advance = decode_labeled_prefix4(tptr, buf, sizeof(buf));
                                 break;
                             case SAFNUM_LABUNICAST:
                                 advance = decode_labeled_prefix4(tptr, buf, sizeof(buf));

-                                printf("\n\t      %s", buf);
+                               if (advance == -1)
+                                        printf("\n\t    (illegal prefix length)");
+                               else if (advance == -2)
+                                        goto trunc;
+                               else
+                                        printf("\n\t      %s", buf);

                                 break;
                             case SAFNUM_VPNUNICAST:
                             case SAFNUM_VPNMULTICAST:
                             case SAFNUM_VPNUNIMULTICAST:
                                 advance = decode_labeled_vpn_prefix4(tptr, buf, sizeof(buf));
                                 break;
                             case SAFNUM_VPNUNICAST:
                             case SAFNUM_VPNMULTICAST:
                             case SAFNUM_VPNUNIMULTICAST:
                                 advance = decode_labeled_vpn_prefix4(tptr, buf, sizeof(buf));

-                                printf("\n\t      %s", buf);
+                               if (advance == -1)
+                                        printf("\n\t    (illegal prefix length)");
+                               else if (advance == -2)
+                                        goto trunc;
+                               else
+                                        printf("\n\t      %s", buf);

                                 break;
                             case SAFNUM_RT_ROUTING_INFO:
                                 advance = decode_rt_routing_info(tptr, buf, sizeof(buf));
                                 break;
                             case SAFNUM_RT_ROUTING_INFO:
                                 advance = decode_rt_routing_info(tptr, buf, sizeof(buf));

-                                printf("\n\t      %s", buf);
+                               if (advance == -1)
+                                        printf("\n\t    (illegal prefix length)");
+                               else if (advance == -2)
+                                        goto trunc;
+                               else
+                                        printf("\n\t      %s", buf);

                                 break;
                             default:
                                 break;
                             default:

+                                TCHECK2(*(tptr-3),tlen);

                                 printf("\n\t      no SAFI %u decoder",safi);
                                 if (vflag <= 1)
                                     print_unknown_data(tptr-3,"\n\t    ",tlen);
                                 printf("\n\t      no SAFI %u decoder",safi);
                                 if (vflag <= 1)
                                     print_unknown_data(tptr-3,"\n\t    ",tlen);


@@ -994,23 +1135,44 @@ bgp_attr_print(const struct bgp_attr *attr, const u_char *pptr, int len)
                             case SAFNUM_MULTICAST:
                             case SAFNUM_UNIMULTICAST:
                                advance = decode_prefix6(tptr, buf, sizeof(buf));
                             case SAFNUM_MULTICAST:
                             case SAFNUM_UNIMULTICAST:
                                advance = decode_prefix6(tptr, buf, sizeof(buf));

-                               printf("\n\t      %s", buf);
+                               if (advance == -1)
+                                       printf("\n\t    (illegal prefix length)");
+                               else if (advance == -2)
+                                       goto trunc;
+                               else
+                                       printf("\n\t      %s", buf);

                                break;
                             case SAFNUM_LABUNICAST:
                                 advance = decode_labeled_prefix6(tptr, buf, sizeof(buf));
                                break;
                             case SAFNUM_LABUNICAST:
                                 advance = decode_labeled_prefix6(tptr, buf, sizeof(buf));

-                                printf("\n\t      %s", buf);
+                               if (advance == -1)
+                                       printf("\n\t    (illegal prefix length)");
+                               else if (advance == -2)
+                                       goto trunc;
+                               else
+                                       printf("\n\t      %s", buf);

                                 break;
                             case SAFNUM_VPNUNICAST:
                             case SAFNUM_VPNMULTICAST:
                             case SAFNUM_VPNUNIMULTICAST:
                                 advance = decode_labeled_vpn_prefix6(tptr, buf, sizeof(buf));
                                 break;
                             case SAFNUM_VPNUNICAST:
                             case SAFNUM_VPNMULTICAST:
                             case SAFNUM_VPNUNIMULTICAST:
                                 advance = decode_labeled_vpn_prefix6(tptr, buf, sizeof(buf));

-                                printf("\n\t      %s", buf);
+                               if (advance == -1)
+                                       printf("\n\t    (illegal prefix length)");
+                               else if (advance == -2)
+                                       goto trunc;
+                               else
+                                       printf("\n\t      %s", buf);

                                 break;
                             case SAFNUM_RT_ROUTING_INFO:
                                 advance = decode_rt_routing_info(tptr, buf, sizeof(buf));
                                 break;
                             case SAFNUM_RT_ROUTING_INFO:
                                 advance = decode_rt_routing_info(tptr, buf, sizeof(buf));

-                                printf("\n\t      %s", buf);
+                               if (advance == -1)
+                                       printf("\n\t    (illegal prefix length)");
+                               else if (advance == -2)
+                                       goto trunc;
+                               else
+                                       printf("\n\t      %s", buf);

                                 break;
                             default:
                                 break;
                             default:

+                                TCHECK2(*(tptr-3),tlen);

                                 printf("\n\t      no SAFI %u decoder ",safi);
                                 if (vflag <= 1)
                                     print_unknown_data(tptr-3,"\n\t    ",tlen);
                                 printf("\n\t      no SAFI %u decoder ",safi);
                                 if (vflag <= 1)
                                     print_unknown_data(tptr-3,"\n\t    ",tlen);


@@ -1026,12 +1188,18 @@ bgp_attr_print(const struct bgp_attr *attr, const u_char *pptr, int len)
                             case SAFNUM_VPNMULTICAST:
                             case SAFNUM_VPNUNIMULTICAST:
                                advance = decode_labeled_vpn_l2(tptr, buf, sizeof(buf));
                             case SAFNUM_VPNMULTICAST:
                             case SAFNUM_VPNUNIMULTICAST:
                                advance = decode_labeled_vpn_l2(tptr, buf, sizeof(buf));

-                                printf("\n\t      %s", buf);         
+                               if (advance == -1)
+                                       printf("\n\t    (illegal length)");
+                               else if (advance == -2)
+                                       goto trunc;
+                               else
+                                        printf("\n\t      %s", buf);         

                                 break;                                   
                             default:
                                 break;                                   
                             default:

+                                TCHECK2(*tptr,tlen);

                                 printf("no SAFI %u decoder",safi);
                                 if (vflag <= 1)
                                 printf("no SAFI %u decoder",safi);
                                 if (vflag <= 1)

-                                    print_unknown_data(tptr,"\n\t    ",tlen);                                        
+                                    print_unknown_data(tptr,"\n\t    ",tlen);

                                 advance = 0;
                                tptr = pptr + len;
                                 break;
                                 advance = 0;
                                tptr = pptr + len;
                                 break;


@@ -1040,6 +1208,7 @@ bgp_attr_print(const struct bgp_attr *attr, const u_char *pptr, int len)
 
 
                        default:
 
 
                        default:

+                            TCHECK2(*(tptr-3),tlen);

                             printf("\n\t      no AFI %u decoder ",af);
                             if (vflag <= 1)
                                     print_unknown_data(tptr-3,"\n\t    ",tlen);
                             printf("\n\t      no AFI %u decoder ",af);
                             if (vflag <= 1)
                                     print_unknown_data(tptr-3,"\n\t    ",tlen);


@@ -1047,11 +1216,14 @@ bgp_attr_print(const struct bgp_attr *attr, const u_char *pptr, int len)
                             tptr = pptr + len;
                             break;
                        }
                             tptr = pptr + len;
                             break;
                        }

+                        if (advance < 0) /* infinite loop protection */
+                            break;

                        tptr += advance;
                }
                break;
 
        case BGPTYPE_MP_UNREACH_NLRI:
                        tptr += advance;
                }
                break;
 
        case BGPTYPE_MP_UNREACH_NLRI:

+               TCHECK2(tptr[0], 3);

                af = EXTRACT_16BITS(tptr);
                safi = tptr[2];
 
                af = EXTRACT_16BITS(tptr);
                safi = tptr[2];
 


@@ -1072,22 +1244,35 @@ bgp_attr_print(const struct bgp_attr *attr, const u_char *pptr, int len)
                             case SAFNUM_MULTICAST:
                             case SAFNUM_UNIMULTICAST:
                                 advance = decode_prefix4(tptr, buf, sizeof(buf));
                             case SAFNUM_MULTICAST:
                             case SAFNUM_UNIMULTICAST:
                                 advance = decode_prefix4(tptr, buf, sizeof(buf));

-                               if (advance >= 0) 
+                               if (advance == -1)
+                                        printf("\n\t    (illegal prefix length)");
+                               else if (advance == -2)
+                                        goto trunc;
+                               else

                                        printf("\n\t      %s", buf);
                                        printf("\n\t      %s", buf);

-                               else
-                                       printf("\n\t    (illegal prefix length)");

                                 break;
                             case SAFNUM_LABUNICAST:
                                 advance = decode_labeled_prefix4(tptr, buf, sizeof(buf));
                                 break;
                             case SAFNUM_LABUNICAST:
                                 advance = decode_labeled_prefix4(tptr, buf, sizeof(buf));

-                                printf("\n\t      %s", buf);
+                               if (advance == -1)
+                                        printf("\n\t    (illegal prefix length)");
+                               else if (advance == -2)
+                                        goto trunc;
+                               else
+                                        printf("\n\t      %s", buf);

                                 break;
                             case SAFNUM_VPNUNICAST:
                             case SAFNUM_VPNMULTICAST:
                             case SAFNUM_VPNUNIMULTICAST:
                                 advance = decode_labeled_vpn_prefix4(tptr, buf, sizeof(buf));
                                 break;
                             case SAFNUM_VPNUNICAST:
                             case SAFNUM_VPNMULTICAST:
                             case SAFNUM_VPNUNIMULTICAST:
                                 advance = decode_labeled_vpn_prefix4(tptr, buf, sizeof(buf));

-                                printf("\n\t      %s", buf);
+                               if (advance == -1)
+                                        printf("\n\t    (illegal prefix length)");
+                               else if (advance == -2)
+                                        goto trunc;
+                               else
+                                        printf("\n\t      %s", buf);

                                 break;
                             default:
                                 break;
                             default:

+                                TCHECK2(*(tptr-3),tlen);

                                 printf("\n\t      no SAFI %u decoder",safi);
                                 if (vflag <= 1)
                                     print_unknown_data(tptr-3,"\n\t    ",tlen);
                                 printf("\n\t      no SAFI %u decoder",safi);
                                 if (vflag <= 1)
                                     print_unknown_data(tptr-3,"\n\t    ",tlen);


@@ -1104,19 +1289,35 @@ bgp_attr_print(const struct bgp_attr *attr, const u_char *pptr, int len)
                             case SAFNUM_MULTICAST:
                             case SAFNUM_UNIMULTICAST:
                                advance = decode_prefix6(tptr, buf, sizeof(buf));
                             case SAFNUM_MULTICAST:
                             case SAFNUM_UNIMULTICAST:
                                advance = decode_prefix6(tptr, buf, sizeof(buf));

-                               printf("\n\t      %s", buf);
+                               if (advance == -1)
+                                       printf("\n\t    (illegal prefix length)");
+                               else if (advance == -2)
+                                       goto trunc;
+                               else
+                                       printf("\n\t      %s", buf);

                                break;
                             case SAFNUM_LABUNICAST:
                                 advance = decode_labeled_prefix6(tptr, buf, sizeof(buf));
                                break;
                             case SAFNUM_LABUNICAST:
                                 advance = decode_labeled_prefix6(tptr, buf, sizeof(buf));

-                                printf("\n\t      %s", buf);
+                               if (advance == -1)
+                                       printf("\n\t    (illegal prefix length)");
+                               else if (advance == -2)
+                                       goto trunc;
+                               else
+                                        printf("\n\t      %s", buf);

                                 break;
                             case SAFNUM_VPNUNICAST:
                             case SAFNUM_VPNMULTICAST:
                             case SAFNUM_VPNUNIMULTICAST:
                                 advance = decode_labeled_vpn_prefix6(tptr, buf, sizeof(buf));
                                 break;
                             case SAFNUM_VPNUNICAST:
                             case SAFNUM_VPNMULTICAST:
                             case SAFNUM_VPNUNIMULTICAST:
                                 advance = decode_labeled_vpn_prefix6(tptr, buf, sizeof(buf));

-                                printf("\n\t      %s", buf);
+                               if (advance == -1)
+                                       printf("\n\t    (illegal prefix length)");
+                               else if (advance == -2)
+                                       goto trunc;
+                               else
+                                        printf("\n\t      %s", buf);

                                 break;
                             default:
                                 break;
                             default:

+                                TCHECK2(*(tptr-3),tlen);

                                 printf("\n\t      no SAFI %u decoder",safi);
                                 if (vflag <= 1)
                                     print_unknown_data(tptr-3,"\n\t    ",tlen);
                                 printf("\n\t      no SAFI %u decoder",safi);
                                 if (vflag <= 1)
                                     print_unknown_data(tptr-3,"\n\t    ",tlen);


@@ -1133,9 +1334,15 @@ bgp_attr_print(const struct bgp_attr *attr, const u_char *pptr, int len)
                             case SAFNUM_VPNMULTICAST:
                             case SAFNUM_VPNUNIMULTICAST:
                                advance = decode_labeled_vpn_l2(tptr, buf, sizeof(buf));
                             case SAFNUM_VPNMULTICAST:
                             case SAFNUM_VPNUNIMULTICAST:
                                advance = decode_labeled_vpn_l2(tptr, buf, sizeof(buf));

-                                printf("\n\t      %s", buf);         
+                               if (advance == -1)
+                                       printf("\n\t    (illegal length)");
+                               else if (advance == -2)
+                                       goto trunc;
+                               else
+                                        printf("\n\t      %s", buf);         

                                 break;                                   
                             default:
                                 break;                                   
                             default:

+                                TCHECK2(*(tptr-3),tlen);

                                 printf("no SAFI %u decoder",safi);
                                 if (vflag <= 1)
                                     print_unknown_data(tptr-3,"\n\t    ",tlen);                                        
                                 printf("no SAFI %u decoder",safi);
                                 if (vflag <= 1)
                                     print_unknown_data(tptr-3,"\n\t    ",tlen);                                        


@@ -1146,6 +1353,7 @@ bgp_attr_print(const struct bgp_attr *attr, const u_char *pptr, int len)
                             break;
 
                        default:
                             break;
 
                        default:

+                               TCHECK2(*(tptr-3),tlen);

                                printf("\n\t    no AFI %u decoder",af);
                                 if (vflag <= 1)
                                     print_unknown_data(tptr-3,"\n\t    ",tlen);
                                printf("\n\t    no AFI %u decoder",af);
                                 if (vflag <= 1)
                                     print_unknown_data(tptr-3,"\n\t    ",tlen);


@@ -1164,6 +1372,8 @@ bgp_attr_print(const struct bgp_attr *attr, const u_char *pptr, int len)
                }
                 while (tlen>0) {
                     u_int16_t extd_comm;
                }
                 while (tlen>0) {
                     u_int16_t extd_comm;

+
+                    TCHECK2(tptr[0], 2);

                     extd_comm=EXTRACT_16BITS(tptr);
 
                    printf("\n\t    %s (0x%04x), Flags [%s]",
                     extd_comm=EXTRACT_16BITS(tptr);
 
                    printf("\n\t    %s (0x%04x), Flags [%s]",


@@ -1171,6 +1381,7 @@ bgp_attr_print(const struct bgp_attr *attr, const u_char *pptr, int len)
                           extd_comm,
                           bittok2str(bgp_extd_comm_flag_values, "none", extd_comm));
 
                           extd_comm,
                           bittok2str(bgp_extd_comm_flag_values, "none", extd_comm));
 

+                    TCHECK2(*(tptr+2), 6);

                     switch(extd_comm) {
                     case BGP_EXT_COM_RT_0:
                     case BGP_EXT_COM_RO_0:
                     switch(extd_comm) {
                     case BGP_EXT_COM_RT_0:
                     case BGP_EXT_COM_RO_0:


@@ -1231,6 +1442,7 @@ bgp_attr_print(const struct bgp_attr *attr, const u_char *pptr, int len)
                 break;
 
        default:
                 break;
 
        default:

+           TCHECK2(*pptr,len);

             printf("\n\t    no Attribute %u decoder",attr->bgpa_type); /* we have no decoder for the attribute */
             if (vflag <= 1)
                 print_unknown_data(pptr,"\n\t    ",len);
             printf("\n\t    no Attribute %u decoder",attr->bgpa_type); /* we have no decoder for the attribute */
             if (vflag <= 1)
                 print_unknown_data(pptr,"\n\t    ",len);


@@ -1238,6 +1450,10 @@ bgp_attr_print(const struct bgp_attr *attr, const u_char *pptr, int len)
        }
         if (vflag > 1 && len) /* omit zero length attributes*/
             print_unknown_data(pptr,"\n\t    ",len);
        }
         if (vflag > 1 && len) /* omit zero length attributes*/
             print_unknown_data(pptr,"\n\t    ",len);

+        return 1;
+
+trunc:
+        return 0;

 }
 
 static void
 }
 
 static void


@@ -1378,12 +1594,14 @@ bgp_update_print(const u_char *dat, int length)
 
                while(i < 2 + len) {
                        wpfx = decode_prefix4(&p[i], buf, sizeof(buf));
 
                while(i < 2 + len) {
                        wpfx = decode_prefix4(&p[i], buf, sizeof(buf));

-                       if (wpfx >= 0) {
-                               i += wpfx;
-                               printf("\n\t    %s", buf);
-                       } else {
+                       if (wpfx == -1) {

                                printf("\n\t    (illegal prefix length)");
                                break;
                                printf("\n\t    (illegal prefix length)");
                                break;

+                       } else if (wpfx == -2)
+                               goto trunc;
+                       else {
+                               i += wpfx;
+                               printf("\n\t    %s", buf);

                        }
                }
 #endif
                        }
                }
 #endif


@@ -1418,7 +1636,8 @@ bgp_update_print(const u_char *dat, int length)
                                        printf("+%x", bgpa.bgpa_flags & 0xf);
                                printf("]: ");
                        }
                                        printf("+%x", bgpa.bgpa_flags & 0xf);
                                printf("]: ");
                        }

-                       bgp_attr_print(&bgpa, &p[i + aoff], alen);
+                       if (!bgp_attr_print(&bgpa, &p[i + aoff], alen))
+                               goto trunc;

                        i += aoff + alen;
                }
        }
                        i += aoff + alen;
                }
        }


@@ -1429,12 +1648,13 @@ bgp_update_print(const u_char *dat, int length)
                while (dat + length > p) {
                        char buf[MAXHOSTNAMELEN + 100];
                        i = decode_prefix4(p, buf, sizeof(buf));
                while (dat + length > p) {
                        char buf[MAXHOSTNAMELEN + 100];
                        i = decode_prefix4(p, buf, sizeof(buf));

-                       if (i >= 0) {
+                       if (i == -1)
+                               printf("\n\t    (illegal prefix length)");
+                       else if (i == -2)
+                               goto trunc;
+                       else {

                                printf("\n\t    %s", buf);
                                p += i;
                                printf("\n\t    %s", buf);
                                p += i;

-                       } else {
-                               printf("\n\t    (illegal prefix length)");
-                               break;

                        }
                }
        }
                        }
                }
        }


@@ -1531,7 +1751,7 @@ bgp_route_refresh_print(const u_char *pptr, int len) {
         return;
 }
 
         return;
 }
 

-static void
+static int

 bgp_header_print(const u_char *dat, int length)
 {
        struct bgp bgp;
 bgp_header_print(const u_char *dat, int length)
 {
        struct bgp bgp;


@@ -1564,9 +1784,10 @@ bgp_header_print(const u_char *dat, int length)
             print_unknown_data(dat,"\n\t  ",length);
                 break;
        }
             print_unknown_data(dat,"\n\t  ",length);
                 break;
        }

-       return;
+       return 1;

 trunc:
        printf("[|BGP]");
 trunc:
        printf("[|BGP]");

+       return 0;

 }
 
 void
 }
 
 void


@@ -1623,7 +1844,8 @@ bgp_print(const u_char *dat, int length)
                }
 
                if (TTEST2(p[0], hlen)) {
                }
 
                if (TTEST2(p[0], hlen)) {

-                       bgp_header_print(p, hlen);
+                       if (!bgp_header_print(p, hlen))
+                               return;

                        p += hlen;
                        start = p;
                } else {
                        p += hlen;
                        start = p;
                } else {