]> The Tcpdump Group git mirrors - tcpdump/blobdiff - print-bgp.c
projects / tcpdump / blobdiff
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
add tracefiles for infinite loop testing
[tcpdump] / print-bgp.c
diff --git a/print-bgp.c b/print-bgp.c
index b335e78696a52239c106faeb84009210a38e7992..08908019f8845fa3d9ffcdfcc16bb254cedc1b5c 100644 (file)
--- a/print-bgp.c
+++ b/print-bgp.c
@@ -35,8 +35,8 @@
 #endif
 
 #ifndef lint
 #endif
 
 #ifndef lint
-static const char rcsid[] =
-     "@(#) $Header: /tcpdump/master/tcpdump/print-bgp.c,v 1.69 2003-07-01 08:33:43 guy Exp $";
+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>
 #endif
 
 #include <tcpdump-stdinc.h>
@@ -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
 
@@ -274,6 +295,8 @@ static struct tok bgp_origin_values[] = {
 #define SAFNUM_VPNUNICAST               128
 #define SAFNUM_VPNMULTICAST             129
 #define SAFNUM_VPNUNIMULTICAST          130
 #define SAFNUM_VPNUNICAST               128
 #define SAFNUM_VPNMULTICAST             129
 #define SAFNUM_VPNUNIMULTICAST          130
+/* draft-marques-ppvpn-rt-constrain-01.txt */
+#define SAFNUM_RT_ROUTING_INFO          132
 
 #define BGP_VPN_RD_LEN                  8
 
 
 #define BGP_VPN_RD_LEN                  8
 
@@ -286,6 +309,7 @@ static struct tok bgp_safi_values[] = {
     { SAFNUM_VPNUNICAST,        "labeled VPN Unicast"},
     { SAFNUM_VPNMULTICAST,      "labeled VPN Multicast"},
     { SAFNUM_VPNUNIMULTICAST,   "labeled VPN Unicast+Multicast"},
     { SAFNUM_VPNUNICAST,        "labeled VPN Unicast"},
     { SAFNUM_VPNMULTICAST,      "labeled VPN Multicast"},
     { SAFNUM_VPNUNIMULTICAST,   "labeled VPN Unicast+Multicast"},
+    { SAFNUM_RT_ROUTING_INFO,   "Route Target Routing Information"},
     { 0, NULL }
 };
 
     { 0, NULL }
 };
 
@@ -426,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] &=
@@ -438,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
@@ -446,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
@@ -462,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] &=
@@ -475,8 +506,14 @@ 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
+ * we use bgp_vpn_rd_print for
+ * printing route targets inside a NLRI */
 static char *
 bgp_vpn_rd_print (const u_char *pptr) {
 
 static char *
 bgp_vpn_rd_print (const u_char *pptr) {
 
@@ -488,39 +525,71 @@ bgp_vpn_rd_print (const u_char *pptr) {
 
     /* ok lets load the RD format */
     switch (EXTRACT_16BITS(pptr)) {
 
     /* ok lets load the RD format */
     switch (EXTRACT_16BITS(pptr)) {
+
         /* AS:IP-address fmt*/
     case 0:
         /* AS:IP-address fmt*/
     case 0:
-        sprintf(pos, "%u:%u.%u.%u.%u",
-                     EXTRACT_16BITS(pptr+2),
-                     *(pptr+4),
-                     *(pptr+5),
-                     *(pptr+6),
-                     *(pptr+7));
+        snprintf(pos, sizeof(rd) - (pos - rd), "%u:%u.%u.%u.%u",
+            EXTRACT_16BITS(pptr+2), *(pptr+4), *(pptr+5), *(pptr+6), *(pptr+7));
         break;
         /* IP-address:AS fmt*/
         break;
         /* IP-address:AS fmt*/
+
     case 1:
     case 1:
-        sprintf(pos, "%u.%u.%u.%u:%u",
-                     *(pptr+2),
-                     *(pptr+3),
-                     *(pptr+4),
-                     *(pptr+5),
-                     EXTRACT_16BITS(pptr+6));
+        snprintf(pos, sizeof(rd) - (pos - rd), "%u.%u.%u.%u:%u",
+            *(pptr+2), *(pptr+3), *(pptr+4), *(pptr+5), EXTRACT_16BITS(pptr+6));
+        break;
+
+        /* 4-byte-AS:number fmt*/
+    case 2:
+        snprintf(pos, sizeof(rd) - (pos - rd), "%u:%u",
+            EXTRACT_32BITS(pptr+2), EXTRACT_16BITS(pptr+6));
         break;
     default:
         break;
     default:
-        sprintf(pos, "unknown RD format");
+        snprintf(pos, sizeof(rd) - (pos - rd), "unknown RD format");
         break;
     }
         break;
     }
-    pos+=strlen(pos);
+    pos += strlen(pos);
     *(pos) = '\0';
     return (rd);
 }
 
     *(pos) = '\0';
     return (rd);
 }
 
+static int
+decode_rt_routing_info(const u_char *pptr, char *buf, u_int buflen)
+{
+       u_int8_t route_target[8];
+       u_int plen;
+
+       TCHECK(pptr[0]);
+       plen = pptr[0];   /* get prefix length */
+
+        plen-=32; /* adjust prefix length */
+
+       if (0 < plen)
+               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] &=
+                       ((0xff00 >> (plen % 8)) & 0xff);
+       }
+       snprintf(buf, buflen, "origin AS: %u, route target %s",
+                 EXTRACT_32BITS(pptr+1),
+                 bgp_vpn_rd_print((u_char *)&route_target));
+
+       return 5 + (plen + 7) / 8;
+
+trunc:
+       return -2;
+}
+
 static int
 decode_labeled_vpn_prefix4(const u_char *pptr, char *buf, u_int buflen)
 {
        struct in_addr addr;
        u_int plen;
 
 static int
 decode_labeled_vpn_prefix4(const u_char *pptr, char *buf, u_int buflen)
 {
        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*/
@@ -529,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] &=
@@ -543,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),
@@ -562,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;
@@ -574,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--;
                 }
@@ -587,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
@@ -596,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] &=
@@ -608,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
@@ -616,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 */
 
@@ -623,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] &=
@@ -636,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
@@ -644,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*/
@@ -652,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] &=
@@ -666,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;
@@ -691,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) {
@@ -703,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)
@@ -742,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;
@@ -752,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:
@@ -779,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) ? ", " : "");
@@ -791,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];
        
@@ -816,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++;
 
@@ -829,23 +940,39 @@ bgp_attr_print(const struct bgp_attr *attr, const u_char *pptr, int len)
                                     case SAFNUM_MULTICAST:
                                     case SAFNUM_UNIMULTICAST:
                                     case SAFNUM_LABUNICAST:
                                     case SAFNUM_MULTICAST:
                                     case SAFNUM_UNIMULTICAST:
                                     case SAFNUM_LABUNICAST:
-                                       printf("%s",getname(tptr));
-                                       tlen -= sizeof(struct in_addr);
-                                        tptr += sizeof(struct in_addr);
+                                    case SAFNUM_RT_ROUTING_INFO:
+                                       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;
@@ -856,23 +983,39 @@ bgp_attr_print(const struct bgp_attr *attr, const u_char *pptr, int len)
                                     case SAFNUM_MULTICAST:
                                     case SAFNUM_UNIMULTICAST:
                                     case SAFNUM_LABUNICAST:
                                     case SAFNUM_MULTICAST:
                                     case SAFNUM_UNIMULTICAST:
                                     case SAFNUM_LABUNICAST:
-                                        printf("%s", getname6(tptr));
-                                        tlen -= sizeof(struct in6_addr);
-                                        tptr += sizeof(struct in6_addr);
+                                    case SAFNUM_RT_ROUTING_INFO:
+                                       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;
@@ -882,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) {
@@ -925,22 +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));
+                               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);
@@ -956,19 +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));
+                               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);
@@ -984,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;
@@ -998,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);
@@ -1005,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];
 
@@ -1030,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);
@@ -1062,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);
@@ -1091,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);                                        
@@ -1104,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);
@@ -1122,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]",
@@ -1129,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:
@@ -1189,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);
@@ -1196,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
@@ -1336,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
@@ -1376,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;
                }
        }
@@ -1387,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;
                        }
                }
        }
                        }
                }
        }
@@ -1489,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;
@@ -1522,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
@@ -1581,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 {
[mirror] the TCPdump network dissector