icmp: clean up the extension code and comments.

[tcpdump] / print-bgp.c
diff --git a/print-bgp.c b/print-bgp.c

index d21a976a04cf45efb90b0fa9b2cfd0c86e32f6e4..ba927e4b26261dc7b010760e6647b1374900cff8 100644 (file)
--- a/print-bgp.c
+++ b/print-bgp.c
@@ -32,11 +32,13 @@
  
  /* \summary: Border Gateway Protocol (BGP) printer */
  
  
  /* \summary: Border Gateway Protocol (BGP) printer */
  
+/* specification: RFC 4271 */
+
  #ifdef HAVE_CONFIG_H
  #ifdef HAVE_CONFIG_H
-#include "config.h"
+#include <config.h>
  #endif
  
  #endif
  
-#include <netdissect-stdinc.h>
+#include "netdissect-stdinc.h"
  
  #include <stdio.h>
  #include <string.h>
  
  #include <stdio.h>
  #include <string.h>
@@ -78,13 +80,15 @@ struct bgp_open {
      nd_uint16_t bgpo_holdtime;
      nd_uint32_t bgpo_id;
      nd_uint8_t  bgpo_optlen;
      nd_uint16_t bgpo_holdtime;
      nd_uint32_t bgpo_id;
      nd_uint8_t  bgpo_optlen;
+    nd_uint8_t  bgpo_opttype;         /* RFC9072 */
+    nd_uint16_t bgpo_optlen_extended; /* RFC9072 */
      /* options should follow */
  };
  #define BGP_OPEN_SIZE        29    /* unaligned */
  
  struct bgp_opt {
      /* options should follow */
  };
  #define BGP_OPEN_SIZE        29    /* unaligned */
  
  struct bgp_opt {
-    nd_uint8_t bgpopt_type;
-    nd_uint8_t bgpopt_len;
+    nd_uint8_t  bgpopt_type;
+    nd_uint16_t bgpopt_len; /* Can be one or two bytes, depending on RFC9072 */
      /* variable length */
  };
  #define BGP_OPT_SIZE           2    /* some compilers may pad to 4 bytes */
      /* variable length */
  };
  #define BGP_OPT_SIZE           2    /* some compilers may pad to 4 bytes */
@@ -104,15 +108,27 @@ struct bgp_route_refresh {
      nd_uint16_t len;
      nd_uint8_t  type;   /* No padding after this; afi is, in fact, not aligned */
      nd_uint16_t afi;
      nd_uint16_t len;
      nd_uint8_t  type;   /* No padding after this; afi is, in fact, not aligned */
      nd_uint16_t afi;
-    nd_uint8_t  res;
+    nd_uint8_t  subtype;
      nd_uint8_t  safi;
  };
  #define BGP_ROUTE_REFRESH_SIZE          23
      nd_uint8_t  safi;
  };
  #define BGP_ROUTE_REFRESH_SIZE          23
+#define BGP_ROUTE_REFRESH_SUBTYPE_NORMAL 0
+#define BGP_ROUTE_REFRESH_SUBTYPE_BORR 1
+#define BGP_ROUTE_REFRESH_SUBTYPE_EORR 2
+#define BGP_ROUTE_REFRESH_SUBTYPE_RESERVED 255
+
+static const struct tok bgp_route_refresh_subtype_values[] = {
+    {BGP_ROUTE_REFRESH_SUBTYPE_NORMAL, "Normal route refresh request"},
+    {BGP_ROUTE_REFRESH_SUBTYPE_BORR,
+     "Demarcation of the beginning of a route refresh"},
+    {BGP_ROUTE_REFRESH_SUBTYPE_EORR,
+     "Demarcation of the ending of a route refresh"},
+    {0, NULL}};
  
  #define bgp_attr_lenlen(flags, p) \
  
  #define bgp_attr_lenlen(flags, p) \
-    (((flags) & 0x10) ? 2 : 1)
+    (((flags) & 0x10) ? 2U : 1U)
  #define bgp_attr_len(flags, p) \
  #define bgp_attr_len(flags, p) \
-    (((flags) & 0x10) ? EXTRACT_BE_U_2(p) : EXTRACT_U_1(p))
+    (((flags) & 0x10) ? GET_BE_U_2(p) : GET_U_1(p))
  
  #define BGPTYPE_ORIGIN                   1
  #define BGPTYPE_AS_PATH                  2
  
  #define BGPTYPE_ORIGIN                   1
  #define BGPTYPE_AS_PATH                  2
@@ -124,25 +140,22 @@ struct bgp_route_refresh {
  #define BGPTYPE_COMMUNITIES              8    /* RFC1997 */
  #define BGPTYPE_ORIGINATOR_ID            9    /* RFC4456 */
  #define BGPTYPE_CLUSTER_LIST            10    /* RFC4456 */
  #define BGPTYPE_COMMUNITIES              8    /* RFC1997 */
  #define BGPTYPE_ORIGINATOR_ID            9    /* RFC4456 */
  #define BGPTYPE_CLUSTER_LIST            10    /* RFC4456 */
-#define BGPTYPE_DPA                     11    /* deprecated, draft-ietf-idr-bgp-dpa */
-#define BGPTYPE_ADVERTISERS             12    /* deprecated RFC1863 */
-#define BGPTYPE_RCID_PATH               13    /* deprecated RFC1863 */
  #define BGPTYPE_MP_REACH_NLRI           14    /* RFC4760 */
  #define BGPTYPE_MP_UNREACH_NLRI         15    /* RFC4760 */
  #define BGPTYPE_MP_REACH_NLRI           14    /* RFC4760 */
  #define BGPTYPE_MP_UNREACH_NLRI         15    /* RFC4760 */
-#define BGPTYPE_EXTD_COMMUNITIES        16      /* RFC4360 */
-#define BGPTYPE_AS4_PATH                17      /* RFC6793 */
-#define BGPTYPE_AGGREGATOR4             18      /* RFC6793 */
-#define BGPTYPE_PMSI_TUNNEL             22      /* RFC6514 */
-#define BGPTYPE_TUNNEL_ENCAP            23      /* RFC5512 */
-#define BGPTYPE_TRAFFIC_ENG             24      /* RFC5543 */
-#define BGPTYPE_IPV6_EXTD_COMMUNITIES   25      /* RFC5701 */
-#define BGPTYPE_AIGP                    26      /* RFC7311 */
-#define BGPTYPE_PE_DISTINGUISHER_LABEL  27      /* RFC6514 */
-#define BGPTYPE_ENTROPY_LABEL           28      /* RFC6790 */
-#define BGPTYPE_LARGE_COMMUNITY         32      /* draft-ietf-idr-large-community-05 */
-#define BGPTYPE_ATTR_SET               128      /* RFC6368 */
-
-#define BGP_MP_NLRI_MINSIZE              3       /* End of RIB Marker detection */
+#define BGPTYPE_EXTD_COMMUNITIES        16    /* RFC4360 */
+#define BGPTYPE_AS4_PATH                17    /* RFC6793 */
+#define BGPTYPE_AGGREGATOR4             18    /* RFC6793 */
+#define BGPTYPE_PMSI_TUNNEL             22    /* RFC6514 */
+#define BGPTYPE_TUNNEL_ENCAP            23    /* RFC5512 */
+#define BGPTYPE_TRAFFIC_ENG             24    /* RFC5543 */
+#define BGPTYPE_IPV6_EXTD_COMMUNITIES   25    /* RFC5701 */
+#define BGPTYPE_AIGP                    26    /* RFC7311 */
+#define BGPTYPE_PE_DISTINGUISHER_LABEL  27    /* RFC6514 */
+#define BGPTYPE_ENTROPY_LABEL           28    /* RFC6790 */
+#define BGPTYPE_LARGE_COMMUNITY         32    /* draft-ietf-idr-large-community-05 */
+#define BGPTYPE_ATTR_SET               128    /* RFC6368 */
+
+#define BGP_MP_NLRI_MINSIZE              3    /* End of RIB Marker detection */
  
  static const struct tok bgp_attr_values[] = {
      { BGPTYPE_ORIGIN,           "Origin"},
  
  static const struct tok bgp_attr_values[] = {
      { BGPTYPE_ORIGIN,           "Origin"},
@@ -157,9 +170,6 @@ static const struct tok bgp_attr_values[] = {
      { BGPTYPE_COMMUNITIES,      "Community"},
      { BGPTYPE_ORIGINATOR_ID,    "Originator ID"},
      { BGPTYPE_CLUSTER_LIST,     "Cluster List"},
      { BGPTYPE_COMMUNITIES,      "Community"},
      { BGPTYPE_ORIGINATOR_ID,    "Originator ID"},
      { BGPTYPE_CLUSTER_LIST,     "Cluster List"},
-    { BGPTYPE_DPA,              "DPA"},
-    { BGPTYPE_ADVERTISERS,      "Advertisers"},
-    { BGPTYPE_RCID_PATH,        "RCID Path / Cluster ID"},
      { BGPTYPE_MP_REACH_NLRI,    "Multi-Protocol Reach NLRI"},
      { BGPTYPE_MP_UNREACH_NLRI,  "Multi-Protocol Unreach NLRI"},
      { BGPTYPE_EXTD_COMMUNITIES, "Extended Community"},
      { BGPTYPE_MP_REACH_NLRI,    "Multi-Protocol Reach NLRI"},
      { BGPTYPE_MP_UNREACH_NLRI,  "Multi-Protocol Unreach NLRI"},
      { BGPTYPE_EXTD_COMMUNITIES, "Extended Community"},
@@ -214,12 +224,15 @@ static const struct tok bgp_opt_values[] = {
  #define BGP_CAPCODE_ORF                 3 /* RFC5291 */
  #define BGP_CAPCODE_MR                  4 /* RFC3107 */
  #define BGP_CAPCODE_EXT_NH              5 /* RFC5549 */
  #define BGP_CAPCODE_ORF                 3 /* RFC5291 */
  #define BGP_CAPCODE_MR                  4 /* RFC3107 */
  #define BGP_CAPCODE_EXT_NH              5 /* RFC5549 */
+#define BGP_CAPCODE_EXT_MSG             6 /* RFC8654 */
+#define BGP_CAPCODE_ML                  8 /* RFC8277 */
  #define BGP_CAPCODE_RESTART            64 /* RFC4724  */
  #define BGP_CAPCODE_AS_NEW             65 /* RFC6793 */
  #define BGP_CAPCODE_DYN_CAP            67 /* draft-ietf-idr-dynamic-cap */
  #define BGP_CAPCODE_MULTISESS          68 /* draft-ietf-idr-bgp-multisession */
  #define BGP_CAPCODE_ADD_PATH           69 /* RFC7911 */
  #define BGP_CAPCODE_RESTART            64 /* RFC4724  */
  #define BGP_CAPCODE_AS_NEW             65 /* RFC6793 */
  #define BGP_CAPCODE_DYN_CAP            67 /* draft-ietf-idr-dynamic-cap */
  #define BGP_CAPCODE_MULTISESS          68 /* draft-ietf-idr-bgp-multisession */
  #define BGP_CAPCODE_ADD_PATH           69 /* RFC7911 */
-#define BGP_CAPCODE_ENH_RR             70 /* draft-keyur-bgp-enhanced-route-refresh */
+#define BGP_CAPCODE_ENH_RR             70 /* RFC7313 */
+#define BGP_CAPCODE_LLGR               71 /* draft-uttaro-idr-bgp-persistence-05 */
  #define BGP_CAPCODE_RR_CISCO          128
  
  static const struct tok bgp_capcode_values[] = {
  #define BGP_CAPCODE_RR_CISCO          128
  
  static const struct tok bgp_capcode_values[] = {
@@ -228,12 +241,15 @@ static const struct tok bgp_capcode_values[] = {
      { BGP_CAPCODE_ORF,          "Cooperative Route Filtering"},
      { BGP_CAPCODE_MR,           "Multiple Routes to a Destination"},
      { BGP_CAPCODE_EXT_NH,       "Extended Next Hop Encoding"},
      { BGP_CAPCODE_ORF,          "Cooperative Route Filtering"},
      { BGP_CAPCODE_MR,           "Multiple Routes to a Destination"},
      { BGP_CAPCODE_EXT_NH,       "Extended Next Hop Encoding"},
+    { BGP_CAPCODE_EXT_MSG,      "BGP Extended Message"},
+    { BGP_CAPCODE_ML,           "Multiple Labels"},
      { BGP_CAPCODE_RESTART,      "Graceful Restart"},
      { BGP_CAPCODE_AS_NEW,       "32-Bit AS Number"},
      { BGP_CAPCODE_DYN_CAP,      "Dynamic Capability"},
      { BGP_CAPCODE_MULTISESS,    "Multisession BGP"},
      { BGP_CAPCODE_ADD_PATH,     "Multiple Paths"},
      { BGP_CAPCODE_ENH_RR,       "Enhanced Route Refresh"},
      { BGP_CAPCODE_RESTART,      "Graceful Restart"},
      { BGP_CAPCODE_AS_NEW,       "32-Bit AS Number"},
      { BGP_CAPCODE_DYN_CAP,      "Dynamic Capability"},
      { BGP_CAPCODE_MULTISESS,    "Multisession BGP"},
      { BGP_CAPCODE_ADD_PATH,     "Multiple Paths"},
      { BGP_CAPCODE_ENH_RR,       "Enhanced Route Refresh"},
+    { BGP_CAPCODE_LLGR,         "Long-lived Graceful Restart"},
      { BGP_CAPCODE_RR_CISCO,     "Route Refresh (Cisco)"},
      { 0, NULL}
  };
      { BGP_CAPCODE_RR_CISCO,     "Route Refresh (Cisco)"},
      { 0, NULL}
  };
@@ -257,12 +273,10 @@ static const struct tok bgp_notify_major_values[] = {
      { 0, NULL}
  };
  
      { 0, NULL}
  };
  
-/* draft-ietf-idr-cease-subcode-02 */
+/* RFC 4486 */
  #define BGP_NOTIFY_MINOR_CEASE_MAXPRFX  1
  #define BGP_NOTIFY_MINOR_CEASE_MAXPRFX  1
-/* draft-ietf-idr-shutdown-07 */
  #define BGP_NOTIFY_MINOR_CEASE_SHUT     2
  #define BGP_NOTIFY_MINOR_CEASE_RESET    4
  #define BGP_NOTIFY_MINOR_CEASE_SHUT     2
  #define BGP_NOTIFY_MINOR_CEASE_RESET    4
-#define BGP_NOTIFY_MINOR_CEASE_ADMIN_SHUTDOWN_LEN   128
  static const struct tok bgp_notify_minor_cease_values[] = {
      { BGP_NOTIFY_MINOR_CEASE_MAXPRFX, "Maximum Number of Prefixes Reached"},
      { BGP_NOTIFY_MINOR_CEASE_SHUT,    "Administrative Shutdown"},
  static const struct tok bgp_notify_minor_cease_values[] = {
      { BGP_NOTIFY_MINOR_CEASE_MAXPRFX, "Maximum Number of Prefixes Reached"},
      { BGP_NOTIFY_MINOR_CEASE_SHUT,    "Administrative Shutdown"},
@@ -376,6 +390,8 @@ static const struct tok bgp_aigp_values[] = {
  #define SAFNUM_VPLS                     65
  /* RFC6037 */
  #define SAFNUM_MDT                      66
  #define SAFNUM_VPLS                     65
  /* RFC6037 */
  #define SAFNUM_MDT                      66
+/* RFC7432 */
+#define SAFNUM_EVPN                     70
  /* RFC4364 */
  #define SAFNUM_VPNUNICAST               128
  /* RFC6513 */
  /* RFC4364 */
  #define SAFNUM_VPNUNICAST               128
  /* RFC6513 */
@@ -395,6 +411,7 @@ static const struct tok bgp_safi_values[] = {
      { SAFNUM_TUNNEL,            "Tunnel"},
      { SAFNUM_VPLS,              "VPLS"},
      { SAFNUM_MDT,               "MDT"},
      { SAFNUM_TUNNEL,            "Tunnel"},
      { SAFNUM_VPLS,              "VPLS"},
      { SAFNUM_MDT,               "MDT"},
+    { SAFNUM_EVPN,              "EVPN"},
      { 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"},
@@ -408,7 +425,7 @@ static const struct tok bgp_safi_values[] = {
  #define BGP_COMMUNITY_NO_ADVERT              0xffffff02
  #define BGP_COMMUNITY_NO_EXPORT_SUBCONFED    0xffffff03
  
  #define BGP_COMMUNITY_NO_ADVERT              0xffffff02
  #define BGP_COMMUNITY_NO_EXPORT_SUBCONFED    0xffffff03
  
-/* Extended community type - draft-ietf-idr-bgp-ext-communities-05 */
+/* Extended community type - RFC 4360 */
  #define BGP_EXT_COM_RT_0        0x0002  /* Route Target,Format AS(2bytes):AN(4bytes) */
  #define BGP_EXT_COM_RT_1        0x0102  /* Route Target,Format IP address:AN(2bytes) */
  #define BGP_EXT_COM_RT_2        0x0202  /* Route Target,Format AN(4bytes):local(2bytes) */
  #define BGP_EXT_COM_RT_0        0x0002  /* Route Target,Format AS(2bytes):AN(4bytes) */
  #define BGP_EXT_COM_RT_1        0x0102  /* Route Target,Format IP address:AN(2bytes) */
  #define BGP_EXT_COM_RT_2        0x0202  /* Route Target,Format AN(4bytes):local(2bytes) */
@@ -424,6 +441,7 @@ static const struct tok bgp_safi_values[] = {
  
  #define BGP_EXT_COM_OSPF_RTYPE  0x0306  /* OSPF Route Type,Format Area(4B):RouteType(1B):Options(1B) */
  #define BGP_EXT_COM_OSPF_RTYPE2 0x8000  /* duplicate - keep for backwards compatibility */
  
  #define BGP_EXT_COM_OSPF_RTYPE  0x0306  /* OSPF Route Type,Format Area(4B):RouteType(1B):Options(1B) */
  #define BGP_EXT_COM_OSPF_RTYPE2 0x8000  /* duplicate - keep for backwards compatibility */
+#define BGP_EXT_COM_ENCAP       0x030c  /* rfc5512 */
  
  #define BGP_EXT_COM_OSPF_RID    0x0107  /* OSPF Router ID,Format RouterID(4B):Unused(2B) */
  #define BGP_EXT_COM_OSPF_RID2   0x8001  /* duplicate - keep for backwards compatibility */
  
  #define BGP_EXT_COM_OSPF_RID    0x0107  /* OSPF Router ID,Format RouterID(4B):Unused(2B) */
  #define BGP_EXT_COM_OSPF_RID2   0x8001  /* duplicate - keep for backwards compatibility */
@@ -435,7 +453,7 @@ static const struct tok bgp_safi_values[] = {
  #define BGP_EXT_COM_L2VPN_RT_0  0x000a  /* L2VPN Identifier,Format AS(2bytes):AN(4bytes) */
  #define BGP_EXT_COM_L2VPN_RT_1  0xF10a  /* L2VPN Identifier,Format IP address:AN(2bytes) */
  
  #define BGP_EXT_COM_L2VPN_RT_0  0x000a  /* L2VPN Identifier,Format AS(2bytes):AN(4bytes) */
  #define BGP_EXT_COM_L2VPN_RT_1  0xF10a  /* L2VPN Identifier,Format IP address:AN(2bytes) */
  
-/* http://www.cisco.com/en/US/tech/tk436/tk428/technologies_tech_note09186a00801eb09a.shtml  */
+/* https://www.cisco.com/en/US/tech/tk436/tk428/technologies_tech_note09186a00801eb09a.shtml  */
  #define BGP_EXT_COM_EIGRP_GEN                    0x8800
  #define BGP_EXT_COM_EIGRP_METRIC_AS_DELAY        0x8801
  #define BGP_EXT_COM_EIGRP_METRIC_REL_NH_BW       0x8802
  #define BGP_EXT_COM_EIGRP_GEN                    0x8800
  #define BGP_EXT_COM_EIGRP_METRIC_AS_DELAY        0x8801
  #define BGP_EXT_COM_EIGRP_METRIC_REL_NH_BW       0x8802
@@ -443,6 +461,9 @@ static const struct tok bgp_safi_values[] = {
  #define BGP_EXT_COM_EIGRP_EXT_REMAS_REMID        0x8804
  #define BGP_EXT_COM_EIGRP_EXT_REMPROTO_REMMETRIC 0x8805
  
  #define BGP_EXT_COM_EIGRP_EXT_REMAS_REMID        0x8804
  #define BGP_EXT_COM_EIGRP_EXT_REMPROTO_REMMETRIC 0x8805
  
+/* Optional Parameters */
+#define BGP_OPEN_NON_EXT_OPT_TYPE_EXTENDED_LENGTH 255 /* Non-Ext OP Type */
+
  static const struct tok bgp_extd_comm_flag_values[] = {
      { 0x8000,                  "vendor-specific"},
      { 0x4000,                  "non-transitive"},
  static const struct tok bgp_extd_comm_flag_values[] = {
      { 0x8000,                  "vendor-specific"},
      { 0x4000,                  "non-transitive"},
@@ -463,15 +484,16 @@ static const struct tok bgp_extd_comm_subtype_values[] = {
      { BGP_EXT_COM_VPN_ORIGIN4, "ospf-domain"},
      { BGP_EXT_COM_OSPF_RTYPE,  "ospf-route-type"},
      { BGP_EXT_COM_OSPF_RTYPE2, "ospf-route-type"},
      { BGP_EXT_COM_VPN_ORIGIN4, "ospf-domain"},
      { BGP_EXT_COM_OSPF_RTYPE,  "ospf-route-type"},
      { BGP_EXT_COM_OSPF_RTYPE2, "ospf-route-type"},
+    { BGP_EXT_COM_ENCAP,       "encapsulation"},
      { BGP_EXT_COM_OSPF_RID,    "ospf-router-id"},
      { BGP_EXT_COM_OSPF_RID2,   "ospf-router-id"},
      { BGP_EXT_COM_L2INFO,      "layer2-info"},
      { BGP_EXT_COM_OSPF_RID,    "ospf-router-id"},
      { BGP_EXT_COM_OSPF_RID2,   "ospf-router-id"},
      { BGP_EXT_COM_L2INFO,      "layer2-info"},
-    { BGP_EXT_COM_EIGRP_GEN , "eigrp-general-route (flag, tag)" },
-    { BGP_EXT_COM_EIGRP_METRIC_AS_DELAY , "eigrp-route-metric (AS, delay)" },
-    { BGP_EXT_COM_EIGRP_METRIC_REL_NH_BW , "eigrp-route-metric (reliability, nexthop, bandwidth)" },
-    { BGP_EXT_COM_EIGRP_METRIC_LOAD_MTU , "eigrp-route-metric (load, MTU)" },
-    { BGP_EXT_COM_EIGRP_EXT_REMAS_REMID , "eigrp-external-route (remote-AS, remote-ID)" },
-    { BGP_EXT_COM_EIGRP_EXT_REMPROTO_REMMETRIC , "eigrp-external-route (remote-proto, remote-metric)" },
+    { BGP_EXT_COM_EIGRP_GEN,   "eigrp-general-route (flag, tag)" },
+    { BGP_EXT_COM_EIGRP_METRIC_AS_DELAY, "eigrp-route-metric (AS, delay)" },
+    { BGP_EXT_COM_EIGRP_METRIC_REL_NH_BW, "eigrp-route-metric (reliability, nexthop, bandwidth)" },
+    { BGP_EXT_COM_EIGRP_METRIC_LOAD_MTU, "eigrp-route-metric (load, MTU)" },
+    { BGP_EXT_COM_EIGRP_EXT_REMAS_REMID, "eigrp-external-route (remote-AS, remote-ID)" },
+    { BGP_EXT_COM_EIGRP_EXT_REMPROTO_REMMETRIC, "eigrp-external-route (remote-proto, remote-metric)" },
      { BGP_EXT_COM_SOURCE_AS, "source-AS" },
      { BGP_EXT_COM_VRF_RT_IMP, "vrf-route-import"},
      { BGP_EXT_COM_L2VPN_RT_0, "l2vpn-id"},
      { BGP_EXT_COM_SOURCE_AS, "source-AS" },
      { BGP_EXT_COM_VRF_RT_IMP, "vrf-route-import"},
      { BGP_EXT_COM_L2VPN_RT_0, "l2vpn-id"},
@@ -479,6 +501,46 @@ static const struct tok bgp_extd_comm_subtype_values[] = {
      { 0, NULL},
  };
  
      { 0, NULL},
  };
  
+/* RFC RFC5512 BGP Tunnel Encapsulation Attribute Tunnel Types */
+#define BGP_ENCAP_TUNNEL_L2TPV3_IP  1
+#define BGP_ENCAP_TUNNEL_GRE        2
+#define BGP_ENCAP_TUNNEL_TRANSMIT   3
+#define BGP_ENCAP_TUNNEL_IPSEC      4
+#define BGP_ENCAP_TUNNEL_IP_IPSEC   5
+#define BGP_ENCAP_TUNNEL_MPLS_IP    6
+#define BGP_ENCAP_TUNNEL_IP_IP      7
+#define BGP_ENCAP_TUNNEL_VXLAN      8
+#define BGP_ENCAP_TUNNEL_NVGRE      9
+#define BGP_ENCAP_TUNNEL_MPLS       10
+#define BGP_ENCAP_TUNNEL_MPLS_GRE   11
+#define BGP_ENCAP_TUNNEL_VXLAN_GPE  12
+#define BGP_ENCAP_TUNNEL_MPLS_UDP   13
+#define BGP_ENCAP_TUNNEL_IPV6       14
+#define BGP_ENCAP_TUNNEL_SR_TE      15
+#define BGP_ENCAP_TUNNEL_BARE       16
+#define BGP_ENCAP_TUNNEL_SR         17
+
+static const struct tok bgp_extd_comm_encap_tunnel_values[] = {
+    { BGP_ENCAP_TUNNEL_L2TPV3_IP,    "L2TPv3 over IP"},
+    { BGP_ENCAP_TUNNEL_GRE,          "GRE"},
+    { BGP_ENCAP_TUNNEL_TRANSMIT,     "Transmit Tunnel"},
+    { BGP_ENCAP_TUNNEL_IPSEC,        "IPsec"},
+    { BGP_ENCAP_TUNNEL_IP_IPSEC,     "IP in IP with IPsec"},
+    { BGP_ENCAP_TUNNEL_MPLS_IP,      "MPLS in IP with IPsec"},
+    { BGP_ENCAP_TUNNEL_IP_IP,        "IP in IP"},
+    { BGP_ENCAP_TUNNEL_VXLAN,        "VXLAN"},
+    { BGP_ENCAP_TUNNEL_NVGRE,        "NVGRE"},
+    { BGP_ENCAP_TUNNEL_MPLS,         "MPLS"},
+    { BGP_ENCAP_TUNNEL_MPLS_GRE,     "MPLS in GRE"},
+    { BGP_ENCAP_TUNNEL_VXLAN_GPE,    "VXLAN GPE"},
+    { BGP_ENCAP_TUNNEL_MPLS_UDP,     "MPLS in UDP"},
+    { BGP_ENCAP_TUNNEL_IPV6,         "IPv6"},
+    { BGP_ENCAP_TUNNEL_SR_TE,        "SR TE"},
+    { BGP_ENCAP_TUNNEL_BARE,         "Bare"},
+    { BGP_ENCAP_TUNNEL_SR,           "SR"},
+    { 0, NULL},
+};
+
  /* OSPF codes for  BGP_EXT_COM_OSPF_RTYPE draft-rosen-vpns-ospf-bgp-mpls  */
  #define BGP_OSPF_RTYPE_RTR      1 /* OSPF Router LSA */
  #define BGP_OSPF_RTYPE_NET      2 /* OSPF Network LSA */
  /* OSPF codes for  BGP_EXT_COM_OSPF_RTYPE draft-rosen-vpns-ospf-bgp-mpls  */
  #define BGP_OSPF_RTYPE_RTR      1 /* OSPF Router LSA */
  #define BGP_OSPF_RTYPE_NET      2 /* OSPF Network LSA */
@@ -506,7 +568,7 @@ static const struct tok bgp_add_path_recvsend[] = {
      { 0, NULL },
  };
  
      { 0, NULL },
  };
  
-static char astostr[20];
+#define AS_STR_SIZE sizeof("xxxxx.xxxxx")
  
  /*
   * as_printf
  
  /*
   * as_printf
@@ -519,7 +581,7 @@ static char astostr[20];
   */
  static char *
  as_printf(netdissect_options *ndo,
   */
  static char *
  as_printf(netdissect_options *ndo,
-          char *str, int size, u_int asnum)
+          char *str, size_t size, u_int asnum)
  {
      if (!ndo->ndo_bflag || asnum <= 0xFFFF) {
          snprintf(str, size, "%u", asnum);
  {
      if (!ndo->ndo_bflag || asnum <= 0xFFFF) {
          snprintf(str, size, "%u", asnum);
@@ -533,47 +595,43 @@ as_printf(netdissect_options *ndo,
  
  int
  decode_prefix4(netdissect_options *ndo,
  
  int
  decode_prefix4(netdissect_options *ndo,
-               const u_char *pptr, u_int itemlen, char *buf, u_int buflen)
+               const u_char *pptr, u_int itemlen, char *buf, size_t buflen)
  {
  {
-    struct in_addr addr;
+    nd_ipv4 addr;
      u_int plen, plenbytes;
  
      u_int plen, plenbytes;
  
-    ND_TCHECK_1(pptr);
      ITEMCHECK(1);
      ITEMCHECK(1);
-    plen = EXTRACT_U_1(pptr);
+    plen = GET_U_1(pptr);
      if (32 < plen)
          return -1;
      itemlen -= 1;
  
      memset(&addr, 0, sizeof(addr));
      plenbytes = (plen + 7) / 8;
      if (32 < plen)
          return -1;
      itemlen -= 1;
  
      memset(&addr, 0, sizeof(addr));
      plenbytes = (plen + 7) / 8;
-    ND_TCHECK_LEN(pptr + 1, plenbytes);
      ITEMCHECK(plenbytes);
      ITEMCHECK(plenbytes);
-    memcpy(&addr, pptr + 1, plenbytes);
+    GET_CPY_BYTES(&addr, pptr + 1, plenbytes);
      if (plen % 8) {
          ((u_char *)&addr)[plenbytes - 1] &= ((0xff00 >> (plen % 8)) & 0xff);
      }
      if (plen % 8) {
          ((u_char *)&addr)[plenbytes - 1] &= ((0xff00 >> (plen % 8)) & 0xff);
      }
-    snprintf(buf, buflen, "%s/%d", ipaddr_string(ndo, &addr), plen);
+    snprintf(buf, buflen, "%s/%u", ipaddr_string(ndo, (const u_char *)&addr), plen);
      return 1 + plenbytes;
  
      return 1 + plenbytes;
  
-trunc:
-    return -2;
-
  badtlv:
  badtlv:
-    return -3;
+    return -2;
  }
  
  static int
  decode_labeled_prefix4(netdissect_options *ndo,
  }
  
  static int
  decode_labeled_prefix4(netdissect_options *ndo,
-                       const u_char *pptr, u_int itemlen, char *buf, u_int buflen)
+                       const u_char *pptr, u_int itemlen, char *buf,
+                       size_t buflen)
  {
  {
-    struct in_addr addr;
+    nd_ipv4 addr;
      u_int plen, plenbytes;
  
      /* prefix length and label = 4 bytes */
      ND_TCHECK_4(pptr);
      ITEMCHECK(4);
      u_int plen, plenbytes;
  
      /* prefix length and label = 4 bytes */
      ND_TCHECK_4(pptr);
      ITEMCHECK(4);
-    plen = EXTRACT_U_1(pptr);   /* get prefix length */
+    plen = GET_U_1(pptr);   /* get prefix length */
  
      /* this is one of the weirdnesses of rfc3107
         the label length (actually the label + COS bits)
  
      /* this is one of the weirdnesses of rfc3107
         the label length (actually the label + COS bits)
@@ -594,18 +652,17 @@ decode_labeled_prefix4(netdissect_options *ndo,
  
      memset(&addr, 0, sizeof(addr));
      plenbytes = (plen + 7) / 8;
  
      memset(&addr, 0, sizeof(addr));
      plenbytes = (plen + 7) / 8;
-    ND_TCHECK_LEN(pptr + 4, plenbytes);
      ITEMCHECK(plenbytes);
      ITEMCHECK(plenbytes);
-    memcpy(&addr, pptr + 4, plenbytes);
+    GET_CPY_BYTES(&addr, pptr + 4, plenbytes);
      if (plen % 8) {
          ((u_char *)&addr)[plenbytes - 1] &= ((0xff00 >> (plen % 8)) & 0xff);
      }
      /* the label may get offsetted by 4 bits so lets shift it right */
      if (plen % 8) {
          ((u_char *)&addr)[plenbytes - 1] &= ((0xff00 >> (plen % 8)) & 0xff);
      }
      /* the label may get offsetted by 4 bits so lets shift it right */
-    snprintf(buf, buflen, "%s/%d, label:%u %s",
-             ipaddr_string(ndo, &addr),
+    snprintf(buf, buflen, "%s/%u, label:%u %s",
+             ipaddr_string(ndo, (const u_char *)&addr),
               plen,
               plen,
-             EXTRACT_BE_U_3(pptr + 1)>>4,
-             ((pptr[3]&1)==0) ? "(BOGUS: Bottom of Stack NOT set!)" : "(bottom)" );
+             GET_BE_U_3(pptr + 1)>>4,
+             ((GET_U_1(pptr + 3) & 1) == 0) ? "(BOGUS: Bottom of Stack NOT set!)" : "(bottom)" );
  
      return 4 + plenbytes;
  
  
      return 4 + plenbytes;
  
@@ -619,7 +676,7 @@ badtlv:
  /*
   * bgp_vpn_ip_print
   *
  /*
   * bgp_vpn_ip_print
   *
- * print an ipv4 or ipv6 address into a buffer dependend on address length.
+ * print an ipv4 or ipv6 address into a buffer dependent on address length.
   */
  static char *
  bgp_vpn_ip_print(netdissect_options *ndo,
   */
  static char *
  bgp_vpn_ip_print(netdissect_options *ndo,
@@ -631,13 +688,11 @@ bgp_vpn_ip_print(netdissect_options *ndo,
      char *pos = addr;
  
      switch(addr_length) {
      char *pos = addr;
  
      switch(addr_length) {
-    case (sizeof(struct in_addr) << 3): /* 32 */
-        ND_TCHECK_LEN(pptr, sizeof(struct in_addr));
-        snprintf(pos, sizeof(addr), "%s", ipaddr_string(ndo, pptr));
+    case (sizeof(nd_ipv4) << 3): /* 32 */
+        snprintf(pos, sizeof(addr), "%s", GET_IPADDR_STRING(pptr));
          break;
          break;
-    case (sizeof(struct in6_addr) << 3): /* 128 */
-        ND_TCHECK_LEN(pptr, sizeof(struct in6_addr));
-        snprintf(pos, sizeof(addr), "%s", ip6addr_string(ndo, pptr));
+    case (sizeof(nd_ipv6) << 3): /* 128 */
+        snprintf(pos, sizeof(addr), "%s", GET_IP6ADDR_STRING(pptr));
          break;
      default:
          snprintf(pos, sizeof(addr), "bogus address length %u", addr_length);
          break;
      default:
          snprintf(pos, sizeof(addr), "bogus address length %u", addr_length);
@@ -645,7 +700,6 @@ bgp_vpn_ip_print(netdissect_options *ndo,
      }
      pos += strlen(pos);
  
      }
      pos += strlen(pos);
  
-trunc:
      *(pos) = '\0';
      return (addr);
  }
      *(pos) = '\0';
      return (addr);
  }
@@ -668,9 +722,9 @@ trunc:
   *
   * return the number of bytes read from the wire.
   */
   *
   * return the number of bytes read from the wire.
   */
-static int
+static u_int
  bgp_vpn_sg_print(netdissect_options *ndo,
  bgp_vpn_sg_print(netdissect_options *ndo,
-                 const u_char *pptr, char *buf, u_int buflen)
+                 const u_char *pptr, char *buf, size_t buflen)
  {
      uint8_t addr_length;
      u_int total_length, offset;
  {
      uint8_t addr_length;
      u_int total_length, offset;
@@ -678,14 +732,13 @@ bgp_vpn_sg_print(netdissect_options *ndo,
      total_length = 0;
  
      /* Source address length, encoded in bits */
      total_length = 0;
  
      /* Source address length, encoded in bits */
-    ND_TCHECK_1(pptr);
-    addr_length = EXTRACT_U_1(pptr);
+    addr_length = GET_U_1(pptr);
      pptr++;
  
      /* Source address */
      ND_TCHECK_LEN(pptr, (addr_length >> 3));
      total_length += (addr_length >> 3) + 1;
      pptr++;
  
      /* Source address */
      ND_TCHECK_LEN(pptr, (addr_length >> 3));
      total_length += (addr_length >> 3) + 1;
-    offset = strlen(buf);
+    offset = (u_int)strlen(buf);
      if (addr_length) {
          snprintf(buf + offset, buflen - offset, ", Source %s",
               bgp_vpn_ip_print(ndo, pptr, addr_length));
      if (addr_length) {
          snprintf(buf + offset, buflen - offset, ", Source %s",
               bgp_vpn_ip_print(ndo, pptr, addr_length));
@@ -693,14 +746,13 @@ bgp_vpn_sg_print(netdissect_options *ndo,
      }
  
      /* Group address length, encoded in bits */
      }
  
      /* Group address length, encoded in bits */
-    ND_TCHECK_1(pptr);
-    addr_length = EXTRACT_U_1(pptr);
+    addr_length = GET_U_1(pptr);
      pptr++;
  
      /* Group address */
      ND_TCHECK_LEN(pptr, (addr_length >> 3));
      total_length += (addr_length >> 3) + 1;
      pptr++;
  
      /* Group address */
      ND_TCHECK_LEN(pptr, (addr_length >> 3));
      total_length += (addr_length >> 3) + 1;
-    offset = strlen(buf);
+    offset = (u_int)strlen(buf);
      if (addr_length) {
          snprintf(buf + offset, buflen - offset, ", Group %s",
               bgp_vpn_ip_print(ndo, pptr, addr_length));
      if (addr_length) {
          snprintf(buf + offset, buflen - offset, ", Group %s",
               bgp_vpn_ip_print(ndo, pptr, addr_length));
@@ -711,44 +763,44 @@ trunc:
      return (total_length);
  }
  
      return (total_length);
  }
  
-/* RDs and RTs share the same semantics
- * we use bgp_vpn_rd_print for
- * printing route targets inside a NLRI */
-char *
+/* Print an RFC 4364 Route Distinguisher */
+const char *
  bgp_vpn_rd_print(netdissect_options *ndo,
                   const u_char *pptr)
  {
      /* allocate space for the largest possible string */
  bgp_vpn_rd_print(netdissect_options *ndo,
                   const u_char *pptr)
  {
      /* allocate space for the largest possible string */
-    static char rd[sizeof("xxxxxxxxxx:xxxxx (xxx.xxx.xxx.xxx:xxxxx)")];
+    static char rd[sizeof("xxxxx.xxxxx:xxxxx (xxx.xxx.xxx.xxx:xxxxx)")];
      char *pos = rd;
      char *pos = rd;
+    /* allocate space for the largest possible string */
+    char astostr[AS_STR_SIZE];
  
      /* ok lets load the RD format */
  
      /* ok lets load the RD format */
-    switch (EXTRACT_BE_U_2(pptr)) {
+    switch (GET_BE_U_2(pptr)) {
  
  
-        /* 2-byte-AS:number fmt*/
      case 0:
      case 0:
+        /* 2-byte-AS:number fmt */
          snprintf(pos, sizeof(rd) - (pos - rd), "%u:%u (= %u.%u.%u.%u)",
          snprintf(pos, sizeof(rd) - (pos - rd), "%u:%u (= %u.%u.%u.%u)",
-                 EXTRACT_BE_U_2(pptr + 2),
-                 EXTRACT_BE_U_4(pptr + 4),
-                 EXTRACT_U_1(pptr + 4), EXTRACT_U_1(pptr + 5),
-                 EXTRACT_U_1(pptr + 6), EXTRACT_U_1(pptr + 7));
+                    GET_BE_U_2(pptr + 2),
+                    GET_BE_U_4(pptr + 4),
+                    GET_U_1(pptr + 4), GET_U_1(pptr + 5),
+                    GET_U_1(pptr + 6), GET_U_1(pptr + 7));
          break;
          break;
-        /* IP-address:AS fmt*/
  
      case 1:
  
      case 1:
+        /* IP-address:AS fmt */
          snprintf(pos, sizeof(rd) - (pos - rd), "%u.%u.%u.%u:%u",
          snprintf(pos, sizeof(rd) - (pos - rd), "%u.%u.%u.%u:%u",
-                 EXTRACT_U_1(pptr + 2), EXTRACT_U_1(pptr + 3),
-                 EXTRACT_U_1(pptr + 4), EXTRACT_U_1(pptr + 5),
-                 EXTRACT_BE_U_2(pptr + 6));
+                    GET_U_1(pptr + 2), GET_U_1(pptr + 3),
+                    GET_U_1(pptr + 4), GET_U_1(pptr + 5),
+                    GET_BE_U_2(pptr + 6));
          break;
  
          break;
  
-        /* 4-byte-AS:number fmt*/
      case 2:
      case 2:
+        /* 4-byte-AS:number fmt */
          snprintf(pos, sizeof(rd) - (pos - rd), "%s:%u (%u.%u.%u.%u:%u)",
          snprintf(pos, sizeof(rd) - (pos - rd), "%s:%u (%u.%u.%u.%u:%u)",
-                 as_printf(ndo, astostr, sizeof(astostr), EXTRACT_BE_U_4(pptr + 2)),
-                 EXTRACT_BE_U_2(pptr + 6), EXTRACT_U_1(pptr + 2),
-                 EXTRACT_U_1(pptr + 3), EXTRACT_U_1(pptr + 4),
-                 EXTRACT_U_1(pptr + 5), EXTRACT_BE_U_2(pptr + 6));
+                    as_printf(ndo, astostr, sizeof(astostr), GET_BE_U_4(pptr + 2)),
+                    GET_BE_U_2(pptr + 6), GET_U_1(pptr + 2),
+                    GET_U_1(pptr + 3), GET_U_1(pptr + 4),
+                    GET_U_1(pptr + 5), GET_BE_U_2(pptr + 6));
          break;
      default:
          snprintf(pos, sizeof(rd) - (pos - rd), "unknown RD format");
          break;
      default:
          snprintf(pos, sizeof(rd) - (pos - rd), "unknown RD format");
@@ -759,17 +811,205 @@ bgp_vpn_rd_print(netdissect_options *ndo,
      return (rd);
  }
  
      return (rd);
  }
  
+/*
+ * Print an RFC 4360 Extended Community.
+ */
+static void
+bgp_extended_community_print(netdissect_options *ndo,
+                             const u_char *pptr)
+{
+    union { /* copy buffer for bandwidth values */
+        float f;
+        uint32_t i;
+    } bw;
+    /* allocate space for the largest possible string */
+    char astostr[AS_STR_SIZE];
+
+    switch (GET_BE_U_2(pptr)) {
+
+    case BGP_EXT_COM_RT_0:
+    case BGP_EXT_COM_RO_0:
+    case BGP_EXT_COM_L2VPN_RT_0:
+        ND_PRINT("%u:%u (= %s)",
+                 GET_BE_U_2(pptr + 2),
+                 GET_BE_U_4(pptr + 4),
+                 GET_IPADDR_STRING(pptr+4));
+        break;
+
+    case BGP_EXT_COM_RT_1:
+    case BGP_EXT_COM_RO_1:
+    case BGP_EXT_COM_L2VPN_RT_1:
+    case BGP_EXT_COM_VRF_RT_IMP:
+        ND_PRINT("%s:%u",
+                 GET_IPADDR_STRING(pptr+2),
+                 GET_BE_U_2(pptr + 6));
+        break;
+
+    case BGP_EXT_COM_RT_2:
+        case BGP_EXT_COM_RO_2:
+            ND_PRINT("%s:%u",
+                     as_printf(ndo, astostr, sizeof(astostr),
+                     GET_BE_U_4(pptr + 2)), GET_BE_U_2(pptr + 6));
+            break;
+
+    case BGP_EXT_COM_LINKBAND:
+            bw.i = GET_BE_U_4(pptr + 4);
+            ND_PRINT("bandwidth: %.3f Mbps",
+                     bw.f*8/1000000);
+            break;
+
+    case BGP_EXT_COM_VPN_ORIGIN:
+    case BGP_EXT_COM_VPN_ORIGIN2:
+    case BGP_EXT_COM_VPN_ORIGIN3:
+    case BGP_EXT_COM_VPN_ORIGIN4:
+    case BGP_EXT_COM_OSPF_RID:
+    case BGP_EXT_COM_OSPF_RID2:
+        ND_PRINT("%s", GET_IPADDR_STRING(pptr+2));
+        break;
+
+    case BGP_EXT_COM_OSPF_RTYPE:
+    case BGP_EXT_COM_OSPF_RTYPE2:
+        ND_PRINT("area:%s, router-type:%s, metric-type:%s%s",
+                 GET_IPADDR_STRING(pptr+2),
+                 tok2str(bgp_extd_comm_ospf_rtype_values,
+                         "unknown (0x%02x)",
+                         GET_U_1((pptr + 6))),
+                 (GET_U_1(pptr + 7) &  BGP_OSPF_RTYPE_METRIC_TYPE) ? "E2" : "",
+                 ((GET_U_1(pptr + 6) == BGP_OSPF_RTYPE_EXT) || (GET_U_1(pptr + 6) == BGP_OSPF_RTYPE_NSSA)) ? "E1" : "");
+        break;
+
+    case BGP_EXT_COM_L2INFO:
+        ND_PRINT("%s Control Flags [0x%02x]:MTU %u",
+                 tok2str(l2vpn_encaps_values,
+                         "unknown encaps",
+                         GET_U_1((pptr + 2))),
+                 GET_U_1((pptr + 3)),
+                 GET_BE_U_2(pptr + 4));
+        break;
+
+    case BGP_EXT_COM_SOURCE_AS:
+        ND_PRINT("AS %u", GET_BE_U_2(pptr + 2));
+        break;
+
+    case BGP_EXT_COM_ENCAP:
+        ND_PRINT("Tunnel type: %s", tok2str(bgp_extd_comm_encap_tunnel_values,
+                                           "unknown encaps",
+                                           GET_BE_U_2(pptr + 6)));
+        break;
+
+    default:
+        ND_PRINT("%02x%02x%02x%02x%02x%02x",
+                 GET_U_1(pptr + 2),
+                 GET_U_1(pptr + 3),
+                 GET_U_1(pptr + 4),
+                 GET_U_1(pptr + 5),
+                 GET_U_1(pptr + 6),
+                 GET_U_1(pptr + 7));
+        break;
+    }
+}
+
+/*
+ * RFC4684 (Section 4)/RFC2858 (Section 4).
+ * RTC membership prefix is structured as follows
+ * [prefix-len] [origin-as] [route-target]
+ * The route-target is encoded as RT ext-comms.
+ * Prefix-len may be 0, 32..96
+ *
+ * Note that pptr is not packet data - it is
+ * a buffer owned by our caller - therefore GET_*
+ * macros can not be used.
+ */
+static char *
+bgp_rt_prefix_print(netdissect_options *ndo,
+                    const u_char *pptr,
+                    u_int plen)
+{
+    /* allocate space for the largest possible string */
+    char rtc_prefix_in_hex[sizeof("0000 0000 0000 0000")] = "";
+    u_int rtc_prefix_in_hex_len = 0;
+    static char output[61]; /* max response string */
+    /* allocate space for the largest possible string */
+    char astostr[AS_STR_SIZE];
+    uint16_t ec_type = 0;
+    u_int octet_count;
+    u_int i;
+
+    if (plen == 0) {
+        snprintf(output, sizeof(output), "route-target: 0:0/0");
+        return (output);
+    }
+
+    /* hex representation of the prefix */
+    octet_count = (plen+7)/8;
+    for (i=0; i<octet_count; i++) {
+        rtc_prefix_in_hex_len += snprintf(rtc_prefix_in_hex+rtc_prefix_in_hex_len,
+                                sizeof(rtc_prefix_in_hex)-rtc_prefix_in_hex_len,
+                                "%02x%s", *(pptr+i),
+                                ((i%2 == 1) && (i<octet_count-1)) ? " " : "");
+            }
+
+    if (plen < 16) {
+       /*
+        * The prefix is too short to include the full ext-comm type,
+        * so we have no way to parse it further.
+        */
+        snprintf(output, sizeof(output), "route-target: partial-type: (%s/%d)",
+                 rtc_prefix_in_hex, plen);
+        return (output);
+    }
+
+    /*
+     * get the ext-comm type
+     * Note: pptr references a static 8 octet buffer with unused bits set to 0,
+     * hense EXTRACT_*() macros are safe.
+     */
+    ec_type = EXTRACT_BE_U_2(pptr);
+    switch (ec_type) {
+    case BGP_EXT_COM_RT_0:
+        /* 2-byte-AS:number fmt */
+        snprintf(output, sizeof(output), "route-target: %u:%u/%d (%s)",
+                 EXTRACT_BE_U_2(pptr+2),
+                 EXTRACT_BE_U_4(pptr+4),
+                 plen, rtc_prefix_in_hex);
+        break;
+
+    case BGP_EXT_COM_RT_1:
+        /* IP-address:AS fmt */
+        snprintf(output, sizeof(output), "route-target: %u.%u.%u.%u:%u/%d (%s)",
+                 *(pptr+2), *(pptr+3), *(pptr+4), *(pptr+5),
+                 EXTRACT_BE_U_2(pptr+6), plen, rtc_prefix_in_hex);
+        break;
+
+    case BGP_EXT_COM_RT_2:
+        /* 4-byte-AS:number fmt */
+        snprintf(output, sizeof(output), "route-target: %s:%u/%d (%s)",
+                 as_printf(ndo, astostr, sizeof(astostr), EXTRACT_BE_U_4(pptr+2)),
+                 EXTRACT_BE_U_2(pptr+6), plen, rtc_prefix_in_hex);
+        break;
+
+    default:
+        snprintf(output, sizeof(output), "route target: unknown-type(%04x) (%s/%d)",
+                 ec_type,
+                 rtc_prefix_in_hex, plen);
+        break;
+    }
+    return (output);
+}
+
+/* RFC 4684 */
  static int
  decode_rt_routing_info(netdissect_options *ndo,
  static int
  decode_rt_routing_info(netdissect_options *ndo,
-                       const u_char *pptr, char *buf, u_int buflen)
+                       const u_char *pptr)
  {
      uint8_t route_target[8];
      u_int plen;
  {
      uint8_t route_target[8];
      u_int plen;
-    char asbuf[sizeof(astostr)]; /* bgp_vpn_rd_print() overwrites astostr */
+    /* allocate space for the largest possible string */
+    char astostr[AS_STR_SIZE];
+    u_int num_octets;
  
      /* NLRI "prefix length" from RFC 2858 Section 4. */
  
      /* NLRI "prefix length" from RFC 2858 Section 4. */
-    ND_TCHECK_1(pptr);
-    plen = EXTRACT_U_1(pptr);   /* get prefix length */
+    plen = GET_U_1(pptr);   /* get prefix length */
  
      /* NLRI "prefix" (ibid), valid lengths are { 0, 32, 33, ..., 96 } bits.
       * RFC 4684 Section 4 defines the layout of "origin AS" and "route
  
      /* NLRI "prefix" (ibid), valid lengths are { 0, 32, 33, ..., 96 } bits.
       * RFC 4684 Section 4 defines the layout of "origin AS" and "route
@@ -777,53 +1017,52 @@ decode_rt_routing_info(netdissect_options *ndo,
       */
      if (0 == plen) {
          /* Without "origin AS", without "route target". */
       */
      if (0 == plen) {
          /* Without "origin AS", without "route target". */
-        snprintf(buf, buflen, "default route target");
+        ND_PRINT("\n\t      default route target");
          return 1;
      }
  
          return 1;
      }
  
-    if (32 > plen)
+    if (32 > plen) {
+        ND_PRINT("\n\t      (illegal prefix length)");
          return -1;
          return -1;
+    }
  
      /* With at least "origin AS", possibly with "route target". */
  
      /* With at least "origin AS", possibly with "route target". */
-    ND_TCHECK_4(pptr + 1);
-    as_printf(ndo, asbuf, sizeof(asbuf), EXTRACT_BE_U_4(pptr + 1));
+    as_printf(ndo, astostr, sizeof(astostr), GET_BE_U_4(pptr + 1));
  
      plen -= 32; /* adjust prefix length */
  
  
      plen -= 32; /* adjust prefix length */
  
-    if (64 < plen)
+    if (64 < plen) {
+        ND_PRINT("\n\t      (illegal prefix length)");
          return -1;
          return -1;
+    }
  
      /* From now on (plen + 7) / 8 evaluates to { 0, 1, 2, ..., 8 }
       * and gives the number of octets in the variable-length "route
       * target" field inside this NLRI "prefix". Look for it.
       */
      memset(&route_target, 0, sizeof(route_target));
  
      /* From now on (plen + 7) / 8 evaluates to { 0, 1, 2, ..., 8 }
       * and gives the number of octets in the variable-length "route
       * target" field inside this NLRI "prefix". Look for it.
       */
      memset(&route_target, 0, sizeof(route_target));
-    ND_TCHECK_LEN(pptr + 5, (plen + 7) / 8);
-    memcpy(&route_target, pptr + 5, (plen + 7) / 8);
-    /* Which specification says to do this? */
+    num_octets = (plen + 7) / 8;
+    GET_CPY_BYTES(&route_target, pptr + 5, num_octets);
+    /* If mask-len is not on octet boundary, ensure all extra bits are 0 */
      if (plen % 8) {
      if (plen % 8) {
-        ((u_char *)&route_target)[(plen + 7) / 8 - 1] &=
+        ((u_char *)&route_target)[num_octets - 1] &=
              ((0xff00 >> (plen % 8)) & 0xff);
      }
              ((0xff00 >> (plen % 8)) & 0xff);
      }
-    snprintf(buf, buflen, "origin AS: %s, route target %s",
-             asbuf,
-             bgp_vpn_rd_print(ndo, (u_char *)&route_target));
+    ND_PRINT("\n\t      origin AS: %s, %s",
+             astostr,
+             bgp_rt_prefix_print(ndo, (u_char *)&route_target, plen));
  
  
-    return 5 + (plen + 7) / 8;
-
-trunc:
-    return -2;
+    return 5 + num_octets;
  }
  
  static int
  decode_labeled_vpn_prefix4(netdissect_options *ndo,
  }
  
  static int
  decode_labeled_vpn_prefix4(netdissect_options *ndo,
-                           const u_char *pptr, char *buf, u_int buflen)
+                           const u_char *pptr, char *buf, size_t buflen)
  {
  {
-    struct in_addr addr;
+    nd_ipv4 addr;
      u_int plen;
  
      u_int plen;
  
-    ND_TCHECK_1(pptr);
-    plen = EXTRACT_U_1(pptr);   /* get prefix length */
+    plen = GET_U_1(pptr);   /* get prefix length */
  
      if ((24+64) > plen)
          return -1;
  
      if ((24+64) > plen)
          return -1;
@@ -834,24 +1073,20 @@ decode_labeled_vpn_prefix4(netdissect_options *ndo,
          return -1;
  
      memset(&addr, 0, sizeof(addr));
          return -1;
  
      memset(&addr, 0, sizeof(addr));
-    ND_TCHECK_LEN(pptr + 12, (plen + 7) / 8);
-    memcpy(&addr, pptr + 12, (plen + 7) / 8);
+    GET_CPY_BYTES(&addr, pptr + 12, (plen + 7) / 8);
      if (plen % 8) {
          ((u_char *)&addr)[(plen + 7) / 8 - 1] &=
              ((0xff00 >> (plen % 8)) & 0xff);
      }
      /* the label may get offsetted by 4 bits so lets shift it right */
      if (plen % 8) {
          ((u_char *)&addr)[(plen + 7) / 8 - 1] &=
              ((0xff00 >> (plen % 8)) & 0xff);
      }
      /* the label may get offsetted by 4 bits so lets shift it right */
-    snprintf(buf, buflen, "RD: %s, %s/%d, label:%u %s",
-             bgp_vpn_rd_print(ndo, pptr+4),
-             ipaddr_string(ndo, &addr),
-             plen,
-             EXTRACT_BE_U_3(pptr + 1)>>4,
-             ((pptr[3]&1)==0) ? "(BOGUS: Bottom of Stack NOT set!)" : "(bottom)" );
+    snprintf(buf, buflen, "RD: %s, %s/%u, label:%u %s",
+                bgp_vpn_rd_print(ndo, pptr+4),
+                ipaddr_string(ndo, (const u_char *)&addr),
+                plen,
+                GET_BE_U_3(pptr + 1)>>4,
+                ((GET_U_1(pptr + 3) & 1) == 0) ? "(BOGUS: Bottom of Stack NOT set!)" : "(bottom)" );
  
      return 12 + (plen + 7) / 8;
  
      return 12 + (plen + 7) / 8;
-
-trunc:
-    return -2;
  }
  
  /*
  }
  
  /*
@@ -868,15 +1103,13 @@ trunc:
  
  static int
  decode_mdt_vpn_nlri(netdissect_options *ndo,
  
  static int
  decode_mdt_vpn_nlri(netdissect_options *ndo,
-            const u_char *pptr, char *buf, u_int buflen)
+                    const u_char *pptr, char *buf, size_t buflen)
  {
      const u_char *rd;
      const u_char *vpn_ip;
  
  {
      const u_char *rd;
      const u_char *vpn_ip;
  
-    ND_TCHECK_1(pptr);
-
      /* if the NLRI is not predefined length, quit.*/
      /* if the NLRI is not predefined length, quit.*/
-    if (EXTRACT_U_1(pptr) != MDT_VPN_NLRI_LEN * 8)
+    if (GET_U_1(pptr) != MDT_VPN_NLRI_LEN * 8)
          return -1;
      pptr++;
  
          return -1;
      pptr++;
  
@@ -886,15 +1119,12 @@ decode_mdt_vpn_nlri(netdissect_options *ndo,
      pptr += 8;
  
      /* IPv4 address */
      pptr += 8;
  
      /* IPv4 address */
-    ND_TCHECK_LEN(pptr, sizeof(struct in_addr));
      vpn_ip = pptr;
      vpn_ip = pptr;
-    pptr += sizeof(struct in_addr);
+    pptr += sizeof(nd_ipv4);
  
      /* MDT Group Address */
  
      /* MDT Group Address */
-    ND_TCHECK_LEN(pptr, sizeof(struct in_addr));
-
      snprintf(buf, buflen, "RD: %s, VPN IP Address: %s, MC Group Address: %s",
      snprintf(buf, buflen, "RD: %s, VPN IP Address: %s, MC Group Address: %s",
-             bgp_vpn_rd_print(ndo, rd), ipaddr_string(ndo, vpn_ip), ipaddr_string(ndo, pptr));
+                bgp_vpn_rd_print(ndo, rd), GET_IPADDR_STRING(vpn_ip), GET_IPADDR_STRING(pptr));
  
      return MDT_VPN_NLRI_LEN + 1;
  
  
      return MDT_VPN_NLRI_LEN + 1;
  
@@ -923,15 +1153,17 @@ static const struct tok bgp_multicast_vpn_route_type_values[] = {
  
  static int
  decode_multicast_vpn(netdissect_options *ndo,
  
  static int
  decode_multicast_vpn(netdissect_options *ndo,
-             const u_char *pptr, char *buf, u_int buflen)
+                     const u_char *pptr, char *buf, size_t buflen)
  {
  {
-    uint8_t route_type, route_length, addr_length, sg_length;
+    /* allocate space for the largest possible string */
+    char astostr[AS_STR_SIZE];
+    uint8_t route_type, route_length;
+    u_int addr_length, sg_length;
      u_int offset;
  
      u_int offset;
  
-    ND_TCHECK_2(pptr);
-    route_type = EXTRACT_U_1(pptr);
+    route_type = GET_U_1(pptr);
      pptr++;
      pptr++;
-    route_length = EXTRACT_U_1(pptr);
+    route_length = GET_U_1(pptr);
      pptr++;
  
      snprintf(buf, buflen, "Route-Type: %s (%u), length: %u",
      pptr++;
  
      snprintf(buf, buflen, "Route-Type: %s (%u), length: %u",
@@ -942,42 +1174,42 @@ decode_multicast_vpn(netdissect_options *ndo,
      switch(route_type) {
      case BGP_MULTICAST_VPN_ROUTE_TYPE_INTRA_AS_I_PMSI:
          ND_TCHECK_LEN(pptr, BGP_VPN_RD_LEN);
      switch(route_type) {
      case BGP_MULTICAST_VPN_ROUTE_TYPE_INTRA_AS_I_PMSI:
          ND_TCHECK_LEN(pptr, BGP_VPN_RD_LEN);
-        offset = strlen(buf);
+        offset = (u_int)strlen(buf);
          snprintf(buf + offset, buflen - offset, ", RD: %s, Originator %s",
          snprintf(buf + offset, buflen - offset, ", RD: %s, Originator %s",
-                 bgp_vpn_rd_print(ndo, pptr),
-                 bgp_vpn_ip_print(ndo, pptr + BGP_VPN_RD_LEN,
-                                  (route_length - BGP_VPN_RD_LEN) << 3));
+                    bgp_vpn_rd_print(ndo, pptr),
+                    bgp_vpn_ip_print(ndo, pptr + BGP_VPN_RD_LEN,
+                                     (route_length - BGP_VPN_RD_LEN) << 3));
          break;
      case BGP_MULTICAST_VPN_ROUTE_TYPE_INTER_AS_I_PMSI:
          ND_TCHECK_LEN(pptr, BGP_VPN_RD_LEN + 4);
          break;
      case BGP_MULTICAST_VPN_ROUTE_TYPE_INTER_AS_I_PMSI:
          ND_TCHECK_LEN(pptr, BGP_VPN_RD_LEN + 4);
-        offset = strlen(buf);
+        offset = (u_int)strlen(buf);
          snprintf(buf + offset, buflen - offset, ", RD: %s, Source-AS %s",
          bgp_vpn_rd_print(ndo, pptr),
          as_printf(ndo, astostr, sizeof(astostr),
          snprintf(buf + offset, buflen - offset, ", RD: %s, Source-AS %s",
          bgp_vpn_rd_print(ndo, pptr),
          as_printf(ndo, astostr, sizeof(astostr),
-        EXTRACT_BE_U_4(pptr + BGP_VPN_RD_LEN)));
+        GET_BE_U_4(pptr + BGP_VPN_RD_LEN)));
          break;
  
      case BGP_MULTICAST_VPN_ROUTE_TYPE_S_PMSI:
          ND_TCHECK_LEN(pptr, BGP_VPN_RD_LEN);
          break;
  
      case BGP_MULTICAST_VPN_ROUTE_TYPE_S_PMSI:
          ND_TCHECK_LEN(pptr, BGP_VPN_RD_LEN);
-        offset = strlen(buf);
+        offset = (u_int)strlen(buf);
          snprintf(buf + offset, buflen - offset, ", RD: %s",
          snprintf(buf + offset, buflen - offset, ", RD: %s",
-                 bgp_vpn_rd_print(ndo, pptr));
+                    bgp_vpn_rd_print(ndo, pptr));
          pptr += BGP_VPN_RD_LEN;
  
          sg_length = bgp_vpn_sg_print(ndo, pptr, buf, buflen);
          addr_length =  route_length - sg_length;
  
          ND_TCHECK_LEN(pptr, addr_length);
          pptr += BGP_VPN_RD_LEN;
  
          sg_length = bgp_vpn_sg_print(ndo, pptr, buf, buflen);
          addr_length =  route_length - sg_length;
  
          ND_TCHECK_LEN(pptr, addr_length);
-        offset = strlen(buf);
+        offset = (u_int)strlen(buf);
          snprintf(buf + offset, buflen - offset, ", Originator %s",
          snprintf(buf + offset, buflen - offset, ", Originator %s",
-                 bgp_vpn_ip_print(ndo, pptr, addr_length << 3));
+                    bgp_vpn_ip_print(ndo, pptr, addr_length << 3));
          break;
  
      case BGP_MULTICAST_VPN_ROUTE_TYPE_SOURCE_ACTIVE:
          ND_TCHECK_LEN(pptr, BGP_VPN_RD_LEN);
          break;
  
      case BGP_MULTICAST_VPN_ROUTE_TYPE_SOURCE_ACTIVE:
          ND_TCHECK_LEN(pptr, BGP_VPN_RD_LEN);
-        offset = strlen(buf);
+        offset = (u_int)strlen(buf);
          snprintf(buf + offset, buflen - offset, ", RD: %s",
          snprintf(buf + offset, buflen - offset, ", RD: %s",
-                 bgp_vpn_rd_print(ndo, pptr));
+                    bgp_vpn_rd_print(ndo, pptr));
          pptr += BGP_VPN_RD_LEN;
  
          bgp_vpn_sg_print(ndo, pptr, buf, buflen);
          pptr += BGP_VPN_RD_LEN;
  
          bgp_vpn_sg_print(ndo, pptr, buf, buflen);
@@ -986,11 +1218,11 @@ decode_multicast_vpn(netdissect_options *ndo,
      case BGP_MULTICAST_VPN_ROUTE_TYPE_SHARED_TREE_JOIN: /* fall through */
      case BGP_MULTICAST_VPN_ROUTE_TYPE_SOURCE_TREE_JOIN:
          ND_TCHECK_LEN(pptr, BGP_VPN_RD_LEN + 4);
      case BGP_MULTICAST_VPN_ROUTE_TYPE_SHARED_TREE_JOIN: /* fall through */
      case BGP_MULTICAST_VPN_ROUTE_TYPE_SOURCE_TREE_JOIN:
          ND_TCHECK_LEN(pptr, BGP_VPN_RD_LEN + 4);
-        offset = strlen(buf);
+        offset = (u_int)strlen(buf);
          snprintf(buf + offset, buflen - offset, ", RD: %s, Source-AS %s",
          snprintf(buf + offset, buflen - offset, ", RD: %s, Source-AS %s",
-        bgp_vpn_rd_print(ndo, pptr),
-        as_printf(ndo, astostr, sizeof(astostr),
-        EXTRACT_BE_U_4(pptr + BGP_VPN_RD_LEN)));
+                    bgp_vpn_rd_print(ndo, pptr),
+                    as_printf(ndo, astostr, sizeof(astostr),
+                    GET_BE_U_4(pptr + BGP_VPN_RD_LEN)));
          pptr += BGP_VPN_RD_LEN + 4;
  
          bgp_vpn_sg_print(ndo, pptr, buf, buflen);
          pptr += BGP_VPN_RD_LEN + 4;
  
          bgp_vpn_sg_print(ndo, pptr, buf, buflen);
@@ -1032,89 +1264,105 @@ trunc:
  
  static int
  decode_labeled_vpn_l2(netdissect_options *ndo,
  
  static int
  decode_labeled_vpn_l2(netdissect_options *ndo,
-              const u_char *pptr, char *buf, u_int buflen)
+                      const u_char *pptr, char *buf, size_t buflen)
  {
  {
-    int plen,tlen,stringlen,tlv_type,tlv_len,ttlv_len;
+    u_int plen, tlen, tlv_type, tlv_len, ttlv_len;
+    int stringlen;
  
  
-    ND_TCHECK_2(pptr);
-    plen=EXTRACT_BE_U_2(pptr);
-    tlen=plen;
+    plen = GET_BE_U_2(pptr);
+    tlen = plen;
      pptr += 2;
      /* Old and new L2VPN NLRI share AFI/SAFI
       *   -> Assume a 12 Byte-length NLRI is auto-discovery-only
       *      and > 17 as old format. Complain for the middle case
       */
      pptr += 2;
      /* Old and new L2VPN NLRI share AFI/SAFI
       *   -> Assume a 12 Byte-length NLRI is auto-discovery-only
       *      and > 17 as old format. Complain for the middle case
       */
-    if (plen==12) {
+    if (plen == 12) {
          /* assume AD-only with RD, BGPNH */
          ND_TCHECK_LEN(pptr, 12);
          /* assume AD-only with RD, BGPNH */
          ND_TCHECK_LEN(pptr, 12);
-        buf[0]='\0';
-        stringlen=snprintf(buf, buflen, "RD: %s, BGPNH: %s",
-                           bgp_vpn_rd_print(ndo, pptr),
-                           ipaddr_string(ndo, pptr+8)
-                   );
+        buf[0] = '\0';
+        stringlen = snprintf(buf, buflen, "RD: %s, BGPNH: %s",
+                                bgp_vpn_rd_print(ndo, pptr),
+                                GET_IPADDR_STRING(pptr+8));
          UPDATE_BUF_BUFLEN(buf, buflen, stringlen);
          UPDATE_BUF_BUFLEN(buf, buflen, stringlen);
-        pptr+=12;
-        tlen-=12;
-        return plen;
-    } else if (plen>17) {
+        pptr += 12;
+        tlen -= 12;
+        return plen + 2;
+    } else if (plen > 17) {
          /* assume old format */
          /* RD, ID, LBLKOFF, LBLBASE */
  
          ND_TCHECK_LEN(pptr, 15);
          /* assume old format */
          /* RD, ID, LBLKOFF, LBLBASE */
  
          ND_TCHECK_LEN(pptr, 15);
-        buf[0]='\0';
-        stringlen=snprintf(buf, buflen, "RD: %s, CE-ID: %u, Label-Block Offset: %u, Label Base %u",
-                           bgp_vpn_rd_print(ndo, pptr),
-                           EXTRACT_BE_U_2(pptr + 8),
-                           EXTRACT_BE_U_2(pptr + 10),
-                           EXTRACT_BE_U_3(pptr + 12)>>4); /* the label is offsetted by 4 bits so lets shift it right */
+        buf[0] = '\0';
+        stringlen = snprintf(buf, buflen, "RD: %s, CE-ID: %u, Label-Block Offset: %u, Label Base %u",
+                                bgp_vpn_rd_print(ndo, pptr),
+                                GET_BE_U_2(pptr + 8),
+                                GET_BE_U_2(pptr + 10),
+                                GET_BE_U_3(pptr + 12)>>4); /* the label is offsetted by 4 bits so lets shift it right */
          UPDATE_BUF_BUFLEN(buf, buflen, stringlen);
          UPDATE_BUF_BUFLEN(buf, buflen, stringlen);
-        pptr+=15;
-        tlen-=15;
+        pptr += 15;
+        tlen -= 15;
  
          /* ok now the variable part - lets read out TLVs*/
  
          /* ok now the variable part - lets read out TLVs*/
-        while (tlen>0) {
-            if (tlen < 3)
-                return -1;
-            ND_TCHECK_3(pptr);
-            tlv_type=EXTRACT_U_1(pptr);
+        while (tlen != 0) {
+            if (tlen < 3) {
+                if (buflen != 0) {
+                    stringlen=snprintf(buf,buflen, "\n\t\tran past the end");
+                    UPDATE_BUF_BUFLEN(buf, buflen, stringlen);
+                }
+                return plen + 2;
+            }
+            tlv_type = GET_U_1(pptr);
              pptr++;
              pptr++;
-            tlv_len=EXTRACT_BE_U_2(pptr);
-            ttlv_len=tlv_len;
-            pptr+=2;
+            tlv_len = GET_BE_U_2(pptr);  /* length, in *bits* */
+            ttlv_len = (tlv_len + 7)/8;      /* length, in *bytes* */
+            pptr += 2;
  
              switch(tlv_type) {
              case 1:
  
              switch(tlv_type) {
              case 1:
-                if (buflen!=0) {
+                if (buflen != 0) {
                      stringlen=snprintf(buf,buflen, "\n\t\tcircuit status vector (%u) length: %u: 0x",
                      stringlen=snprintf(buf,buflen, "\n\t\tcircuit status vector (%u) length: %u: 0x",
-                                       tlv_type,
-                                       tlv_len);
+                                          tlv_type,
+                                          tlv_len);
                      UPDATE_BUF_BUFLEN(buf, buflen, stringlen);
                  }
                      UPDATE_BUF_BUFLEN(buf, buflen, stringlen);
                  }
-                ttlv_len=ttlv_len/8+1; /* how many bytes do we need to read ? */
-                while (ttlv_len>0) {
+                while (ttlv_len != 0) {
+                    if (tlen < 1) {
+                        if (buflen != 0) {
+                            stringlen=snprintf(buf,buflen, " (ran past the end)");
+                            UPDATE_BUF_BUFLEN(buf, buflen, stringlen);
+                        }
+                        return plen + 2;
+                    }
                      ND_TCHECK_1(pptr);
                      ND_TCHECK_1(pptr);
-                    if (buflen!=0) {
+                    if (buflen != 0) {
                          stringlen=snprintf(buf,buflen, "%02x",
                          stringlen=snprintf(buf,buflen, "%02x",
-                                           EXTRACT_U_1(pptr));
+                                              GET_U_1(pptr));
                          pptr++;
                          UPDATE_BUF_BUFLEN(buf, buflen, stringlen);
                      }
                      ttlv_len--;
                          pptr++;
                          UPDATE_BUF_BUFLEN(buf, buflen, stringlen);
                      }
                      ttlv_len--;
+                    tlen--;
                  }
                  break;
              default:
                  }
                  break;
              default:
-                if (buflen!=0) {
+                if (buflen != 0) {
                      stringlen=snprintf(buf,buflen, "\n\t\tunknown TLV #%u, length: %u",
                      stringlen=snprintf(buf,buflen, "\n\t\tunknown TLV #%u, length: %u",
-                                       tlv_type,
-                                       tlv_len);
+                                          tlv_type,
+                                          tlv_len);
                      UPDATE_BUF_BUFLEN(buf, buflen, stringlen);
                  }
                      UPDATE_BUF_BUFLEN(buf, buflen, stringlen);
                  }
+                if (tlen < ttlv_len) {
+                    if (buflen != 0) {
+                        stringlen=snprintf(buf,buflen, " (ran past the end)");
+                        UPDATE_BUF_BUFLEN(buf, buflen, stringlen);
+                    }
+                    return plen + 2;
+                }
+                tlen -= ttlv_len;
                  break;
              }
                  break;
              }
-            tlen-=(tlv_len<<3); /* the tlv-length is expressed in bits so lets shift it right */
          }
          }
-        return plen+2;
-
+        return plen + 2;
      } else {
          /* complain bitterly ? */
          /* fall through */
      } else {
          /* complain bitterly ? */
          /* fall through */
@@ -1127,48 +1375,43 @@ trunc:
  
  int
  decode_prefix6(netdissect_options *ndo,
  
  int
  decode_prefix6(netdissect_options *ndo,
-               const u_char *pd, u_int itemlen, char *buf, u_int buflen)
+               const u_char *pd, u_int itemlen, char *buf, size_t buflen)
  {
  {
-    struct in6_addr addr;
+    nd_ipv6 addr;
      u_int plen, plenbytes;
  
      u_int plen, plenbytes;
  
-    ND_TCHECK_1(pd);
      ITEMCHECK(1);
      ITEMCHECK(1);
-    plen = EXTRACT_U_1(pd);
+    plen = GET_U_1(pd);
      if (128 < plen)
          return -1;
      itemlen -= 1;
  
      memset(&addr, 0, sizeof(addr));
      plenbytes = (plen + 7) / 8;
      if (128 < plen)
          return -1;
      itemlen -= 1;
  
      memset(&addr, 0, sizeof(addr));
      plenbytes = (plen + 7) / 8;
-    ND_TCHECK_LEN(pd + 1, plenbytes);
      ITEMCHECK(plenbytes);
      ITEMCHECK(plenbytes);
-    memcpy(&addr, pd + 1, plenbytes);
+    GET_CPY_BYTES(&addr, pd + 1, plenbytes);
      if (plen % 8) {
      if (plen % 8) {
-        addr.s6_addr[plenbytes - 1] &=
+        addr[plenbytes - 1] &=
              ((0xff00 >> (plen % 8)) & 0xff);
      }
              ((0xff00 >> (plen % 8)) & 0xff);
      }
-    snprintf(buf, buflen, "%s/%d", ip6addr_string(ndo, &addr), plen);
+    snprintf(buf, buflen, "%s/%u", ip6addr_string(ndo, (const u_char *)&addr), plen);
      return 1 + plenbytes;
  
      return 1 + plenbytes;
  
-trunc:
-    return -2;
-
  badtlv:
  badtlv:
-    return -3;
+    return -2;
  }
  
  static int
  decode_labeled_prefix6(netdissect_options *ndo,
  }
  
  static int
  decode_labeled_prefix6(netdissect_options *ndo,
-               const u_char *pptr, u_int itemlen, char *buf, u_int buflen)
+               const u_char *pptr, u_int itemlen, char *buf, size_t buflen)
  {
  {
-    struct in6_addr addr;
+    nd_ipv6 addr;
      u_int plen, plenbytes;
  
      /* prefix length and label = 4 bytes */
      ND_TCHECK_4(pptr);
      ITEMCHECK(4);
      u_int plen, plenbytes;
  
      /* prefix length and label = 4 bytes */
      ND_TCHECK_4(pptr);
      ITEMCHECK(4);
-    plen = EXTRACT_U_1(pptr); /* get prefix length */
+    plen = GET_U_1(pptr); /* get prefix length */
  
      if (24 > plen)
          return -1;
  
      if (24 > plen)
          return -1;
@@ -1181,18 +1424,17 @@ decode_labeled_prefix6(netdissect_options *ndo,
  
      memset(&addr, 0, sizeof(addr));
      plenbytes = (plen + 7) / 8;
  
      memset(&addr, 0, sizeof(addr));
      plenbytes = (plen + 7) / 8;
-    ND_TCHECK_LEN(pptr + 4, plenbytes);
-    memcpy(&addr, pptr + 4, plenbytes);
+    GET_CPY_BYTES(&addr, pptr + 4, plenbytes);
      if (plen % 8) {
      if (plen % 8) {
-        addr.s6_addr[plenbytes - 1] &=
+        addr[plenbytes - 1] &=
              ((0xff00 >> (plen % 8)) & 0xff);
      }
      /* the label may get offsetted by 4 bits so lets shift it right */
              ((0xff00 >> (plen % 8)) & 0xff);
      }
      /* the label may get offsetted by 4 bits so lets shift it right */
-    snprintf(buf, buflen, "%s/%d, label:%u %s",
-             ip6addr_string(ndo, &addr),
-             plen,
-             EXTRACT_BE_U_3(pptr + 1)>>4,
-             ((pptr[3]&1)==0) ? "(BOGUS: Bottom of Stack NOT set!)" : "(bottom)" );
+    snprintf(buf, buflen, "%s/%u, label:%u %s",
+                ip6addr_string(ndo, (const u_char *)&addr),
+                plen,
+                GET_BE_U_3(pptr + 1)>>4,
+                ((GET_U_1(pptr + 3) & 1) == 0) ? "(BOGUS: Bottom of Stack NOT set!)" : "(bottom)" );
  
      return 4 + plenbytes;
  
  
      return 4 + plenbytes;
  
@@ -1205,13 +1447,12 @@ badtlv:
  
  static int
  decode_labeled_vpn_prefix6(netdissect_options *ndo,
  
  static int
  decode_labeled_vpn_prefix6(netdissect_options *ndo,
-                           const u_char *pptr, char *buf, u_int buflen)
+                           const u_char *pptr, char *buf, size_t buflen)
  {
  {
-    struct in6_addr addr;
+    nd_ipv6 addr;
      u_int plen;
  
      u_int plen;
  
-    ND_TCHECK_1(pptr);
-    plen = EXTRACT_U_1(pptr);   /* get prefix length */
+    plen = GET_U_1(pptr);   /* get prefix length */
  
      if ((24+64) > plen)
          return -1;
  
      if ((24+64) > plen)
          return -1;
@@ -1222,65 +1463,56 @@ decode_labeled_vpn_prefix6(netdissect_options *ndo,
          return -1;
  
      memset(&addr, 0, sizeof(addr));
          return -1;
  
      memset(&addr, 0, sizeof(addr));
-    ND_TCHECK_LEN(pptr + 12, (plen + 7) / 8);
-    memcpy(&addr, pptr + 12, (plen + 7) / 8);
+    GET_CPY_BYTES(&addr, pptr + 12, (plen + 7) / 8);
      if (plen % 8) {
      if (plen % 8) {
-        addr.s6_addr[(plen + 7) / 8 - 1] &=
+        addr[(plen + 7) / 8 - 1] &=
              ((0xff00 >> (plen % 8)) & 0xff);
      }
      /* the label may get offsetted by 4 bits so lets shift it right */
              ((0xff00 >> (plen % 8)) & 0xff);
      }
      /* the label may get offsetted by 4 bits so lets shift it right */
-    snprintf(buf, buflen, "RD: %s, %s/%d, label:%u %s",
-             bgp_vpn_rd_print(ndo, pptr+4),
-             ip6addr_string(ndo, &addr),
-             plen,
-             EXTRACT_BE_U_3(pptr + 1)>>4,
-              ((pptr[3]&1)==0) ? "(BOGUS: Bottom of Stack NOT set!)" : "(bottom)" );
+    snprintf(buf, buflen, "RD: %s, %s/%u, label:%u %s",
+                bgp_vpn_rd_print(ndo, pptr+4),
+                ip6addr_string(ndo, (const u_char *)&addr),
+                plen,
+                GET_BE_U_3(pptr + 1)>>4,
+                ((GET_U_1(pptr + 3) & 1) == 0) ? "(BOGUS: Bottom of Stack NOT set!)" : "(bottom)" );
  
      return 12 + (plen + 7) / 8;
  
      return 12 + (plen + 7) / 8;
-
-trunc:
-    return -2;
  }
  
  static int
  decode_clnp_prefix(netdissect_options *ndo,
  }
  
  static int
  decode_clnp_prefix(netdissect_options *ndo,
-                   const u_char *pptr, char *buf, u_int buflen)
+                   const u_char *pptr, char *buf, size_t buflen)
  {
      uint8_t addr[19];
      u_int plen;
  
  {
      uint8_t addr[19];
      u_int plen;
  
-    ND_TCHECK_1(pptr);
-    plen = EXTRACT_U_1(pptr); /* get prefix length */
+    plen = GET_U_1(pptr); /* get prefix length */
  
      if (152 < plen)
          return -1;
  
      memset(&addr, 0, sizeof(addr));
  
      if (152 < plen)
          return -1;
  
      memset(&addr, 0, sizeof(addr));
-    ND_TCHECK_LEN(pptr + 4, (plen + 7) / 8);
-    memcpy(&addr, pptr + 4, (plen + 7) / 8);
+    GET_CPY_BYTES(&addr, pptr + 4, (plen + 7) / 8);
      if (plen % 8) {
          addr[(plen + 7) / 8 - 1] &=
              ((0xff00 >> (plen % 8)) & 0xff);
      }
      if (plen % 8) {
          addr[(plen + 7) / 8 - 1] &=
              ((0xff00 >> (plen % 8)) & 0xff);
      }
-    snprintf(buf, buflen, "%s/%d",
-             isonsap_string(ndo, addr,(plen + 7) / 8),
-             plen);
+    /* Cannot use GET_ISONSAP_STRING (not packet buffer pointer) */
+    snprintf(buf, buflen, "%s/%u",
+                isonsap_string(ndo, addr,(plen + 7) / 8),
+                plen);
  
      return 1 + (plen + 7) / 8;
  
      return 1 + (plen + 7) / 8;
-
-trunc:
-    return -2;
  }
  
  static int
  decode_labeled_vpn_clnp_prefix(netdissect_options *ndo,
  }
  
  static int
  decode_labeled_vpn_clnp_prefix(netdissect_options *ndo,
-                   const u_char *pptr, char *buf, u_int buflen)
+                               const u_char *pptr, char *buf, size_t buflen)
  {
      uint8_t addr[19];
      u_int plen;
  
  {
      uint8_t addr[19];
      u_int plen;
  
-    ND_TCHECK_1(pptr);
-    plen = EXTRACT_U_1(pptr);   /* get prefix length */
+    plen = GET_U_1(pptr);   /* get prefix length */
  
      if ((24+64) > plen)
          return -1;
  
      if ((24+64) > plen)
          return -1;
@@ -1291,24 +1523,20 @@ decode_labeled_vpn_clnp_prefix(netdissect_options *ndo,
          return -1;
  
      memset(&addr, 0, sizeof(addr));
          return -1;
  
      memset(&addr, 0, sizeof(addr));
-    ND_TCHECK_LEN(pptr + 12, (plen + 7) / 8);
-    memcpy(&addr, pptr + 12, (plen + 7) / 8);
+    GET_CPY_BYTES(&addr, pptr + 12, (plen + 7) / 8);
      if (plen % 8) {
      if (plen % 8) {
-        addr[(plen + 7) / 8 - 1] &=
-            ((0xff00 >> (plen % 8)) & 0xff);
+        addr[(plen + 7) / 8 - 1] &= ((0xff00 >> (plen % 8)) & 0xff);
      }
      /* the label may get offsetted by 4 bits so lets shift it right */
      }
      /* the label may get offsetted by 4 bits so lets shift it right */
-    snprintf(buf, buflen, "RD: %s, %s/%d, label:%u %s",
-             bgp_vpn_rd_print(ndo, pptr+4),
-             isonsap_string(ndo, addr,(plen + 7) / 8),
-             plen,
-             EXTRACT_BE_U_3(pptr + 1)>>4,
-             ((pptr[3]&1)==0) ? "(BOGUS: Bottom of Stack NOT set!)" : "(bottom)" );
+    /* Cannot use GET_ISONSAP_STRING (not packet buffer pointer) */
+    snprintf(buf, buflen, "RD: %s, %s/%u, label:%u %s",
+                bgp_vpn_rd_print(ndo, pptr+4),
+                isonsap_string(ndo, addr,(plen + 7) / 8),
+                plen,
+                GET_BE_U_3(pptr + 1)>>4,
+                ((GET_U_1(pptr + 3) & 1) == 0) ? "(BOGUS: Bottom of Stack NOT set!)" : "(bottom)" );
  
      return 12 + (plen + 7) / 8;
  
      return 12 + (plen + 7) / 8;
-
-trunc:
-    return -2;
  }
  
  /*
  }
  
  /*
@@ -1318,9 +1546,9 @@ trunc:
   * both Old speakers that do not support 4 byte AS, and the new speakers that do
   * support, exchange AS-Path with the same path-attribute type value 0x02.
   */
   * both Old speakers that do not support 4 byte AS, and the new speakers that do
   * support, exchange AS-Path with the same path-attribute type value 0x02.
   */
-static int
+static u_int
  bgp_attr_get_as_size(netdissect_options *ndo,
  bgp_attr_get_as_size(netdissect_options *ndo,
-                     uint8_t bgpa_type, const u_char *pptr, int len)
+                     uint8_t bgpa_type, const u_char *pptr, u_int len)
  {
      const u_char *tptr = pptr;
  
  {
      const u_char *tptr = pptr;
  
@@ -1338,16 +1566,13 @@ bgp_attr_get_as_size(netdissect_options *ndo,
       * each.
       */
      while (tptr < pptr + len) {
       * each.
       */
      while (tptr < pptr + len) {
-        ND_TCHECK_1(tptr);
-
          /*
           * If we do not find a valid segment type, our guess might be wrong.
           */
          /*
           * If we do not find a valid segment type, our guess might be wrong.
           */
-        if (EXTRACT_U_1(tptr) < BGP_AS_SEG_TYPE_MIN || EXTRACT_U_1(tptr) > BGP_AS_SEG_TYPE_MAX) {
+        if (GET_U_1(tptr) < BGP_AS_SEG_TYPE_MIN || GET_U_1(tptr) > BGP_AS_SEG_TYPE_MAX) {
              goto trunc;
          }
              goto trunc;
          }
-        ND_TCHECK_1(tptr + 1);
-        tptr += 2 + EXTRACT_U_1(tptr + 1) * 2;
+        tptr += 2 + GET_U_1(tptr + 1) * 2;
      }
  
      /*
      }
  
      /*
@@ -1376,17 +1601,26 @@ trunc:
   * and if so it checks that standard BGP doesn't make sense.
   */
  static int
   * and if so it checks that standard BGP doesn't make sense.
   */
  static int
-check_add_path(const u_char *pptr, u_int length, u_int max_prefix_length)
+check_add_path(netdissect_options *ndo, const u_char *pptr, u_int length,
+               u_int max_prefix_length)
  {
      u_int offset, prefix_length;
  {
      u_int offset, prefix_length;
+
      if (length < 5) {
          return 0;
      }
  
      if (length < 5) {
          return 0;
      }
  
-    /* check if it could be add path */
+    /*
+     * Scan through the NLRI information under the assumpetion that
+     * it doesn't have path IDs.
+     */
      for (offset = 0; offset < length;) {
          offset += 4;
      for (offset = 0; offset < length;) {
          offset += 4;
-        prefix_length = pptr[offset];
+        if (!ND_TTEST_1(pptr + offset)) {
+            /* We ran out of captured data; quit scanning. */
+            break;
+        }
+        prefix_length = GET_U_1(pptr + offset);
          /*
           * Add 4 to cover the path id
           * and check the prefix length isn't greater than 32/128.
          /*
           * Add 4 to cover the path id
           * and check the prefix length isn't greater than 32/128.
@@ -1404,7 +1638,11 @@ check_add_path(const u_char *pptr, u_int length, u_int max_prefix_length)
  
      /* check it's not standard BGP */
      for (offset = 0; offset < length; ) {
  
      /* check it's not standard BGP */
      for (offset = 0; offset < length; ) {
-        prefix_length = pptr[offset];
+        if (!ND_TTEST_1(pptr + offset)) {
+            /* We ran out of captured data; quit scanning. */
+            break;
+        }
+        prefix_length = GET_U_1(pptr + offset);
          /*
           * If the prefix_length is zero (0.0.0.0/0)
           * and since it's not the only address (length >= 5)
          /*
           * If the prefix_length is zero (0.0.0.0/0)
           * and since it's not the only address (length >= 5)
@@ -1424,197 +1662,24 @@ check_add_path(const u_char *pptr, u_int length, u_int max_prefix_length)
  }
  
  static int
  }
  
  static int
-bgp_attr_print(netdissect_options *ndo,
-               u_int atype, const u_char *pptr, u_int len)
+bgp_mp_af_print(netdissect_options *ndo,
+               const u_char *tptr, u_int tlen,
+               uint16_t *afp, uint8_t *safip)
  {
  {
-    int i;
-    uint16_t af;
-    uint8_t safi, snpa, nhlen;
-    union { /* copy buffer for bandwidth values */
-        float f;
-        uint32_t i;
-    } bw;
-    int advance;
-    u_int tlen;
-    const u_char *tptr;
-    char buf[MAXHOSTNAMELEN + 100];
-    int as_size;
-    int add_path4, add_path6, path_id;
-
-    tptr = pptr;
-    tlen = len;
-
-    switch (atype) {
-    case BGPTYPE_ORIGIN:
-        if (len != 1)
-            ND_PRINT((ndo, "invalid len"));
-        else {
-            ND_TCHECK_1(tptr);
-            ND_PRINT((ndo, "%s", tok2str(bgp_origin_values,
-                      "Unknown Origin Typecode",
-                      EXTRACT_U_1(tptr))));
-        }
-        break;
-
-    /*
-     * Process AS4 byte path and AS2 byte path attributes here.
-     */
-    case BGPTYPE_AS4_PATH:
-    case BGPTYPE_AS_PATH:
-        if (len % 2) {
-            ND_PRINT((ndo, "invalid len"));
-            break;
-        }
-        if (!len) {
-            ND_PRINT((ndo, "empty"));
-            break;
-        }
-
-        /*
-         * BGP updates exchanged between New speakers that support 4
-         * byte AS, ASs are always encoded in 4 bytes. There is no
-         * definitive way to find this, just by the packet's
-         * contents. So, check for packet's TLV's sanity assuming
-         * 2 bytes first, and it does not pass, assume that ASs are
-         * encoded in 4 bytes format and move on.
-         */
-        as_size = bgp_attr_get_as_size(ndo, atype, pptr, len);
-
-        while (tptr < pptr + len) {
-            ND_TCHECK_1(tptr);
-            ND_PRINT((ndo, "%s", tok2str(bgp_as_path_segment_open_values,
-                      "?", EXTRACT_U_1(tptr))));
-            ND_TCHECK_1(tptr + 1);
-            for (i = 0; i < tptr[1] * as_size; i += as_size) {
-                ND_TCHECK_LEN(tptr + 2 + i, as_size);
-                ND_PRINT((ndo, "%s ",
-                          as_printf(ndo, astostr, sizeof(astostr),
-                as_size == 2 ?
-                    EXTRACT_BE_U_2(tptr + i + 2) :
-                    EXTRACT_BE_U_4(tptr + i + 2))));
-            }
-            ND_TCHECK_1(tptr);
-            ND_PRINT((ndo, "%s", tok2str(bgp_as_path_segment_close_values,
-                      "?", EXTRACT_U_1(tptr))));
-            ND_TCHECK_1(tptr + 1);
-            tptr += 2 + EXTRACT_U_1(tptr + 1) * as_size;
-        }
-        break;
-    case BGPTYPE_NEXT_HOP:
-        if (len != 4)
-            ND_PRINT((ndo, "invalid len"));
-        else {
-            ND_TCHECK_4(tptr);
-            ND_PRINT((ndo, "%s", ipaddr_string(ndo, tptr)));
-        }
-        break;
-    case BGPTYPE_MULTI_EXIT_DISC:
-    case BGPTYPE_LOCAL_PREF:
-        if (len != 4)
-            ND_PRINT((ndo, "invalid len"));
-        else {
-            ND_TCHECK_4(tptr);
-            ND_PRINT((ndo, "%u", EXTRACT_BE_U_4(tptr)));
-        }
-        break;
-    case BGPTYPE_ATOMIC_AGGREGATE:
-        if (len != 0)
-            ND_PRINT((ndo, "invalid len"));
-        break;
-    case BGPTYPE_AGGREGATOR:
+       uint16_t af;
+       uint8_t safi;
  
  
-        /*
-         * Depending on the AS encoded is of 2 bytes or of 4 bytes,
-         * the length of this PA can be either 6 bytes or 8 bytes.
-         */
-        if (len != 6 && len != 8) {
-            ND_PRINT((ndo, "invalid len"));
-            break;
-        }
-        ND_TCHECK_LEN(tptr, len);
-        if (len == 6) {
-            ND_PRINT((ndo, " AS #%s, origin %s",
-                      as_printf(ndo, astostr, sizeof(astostr), EXTRACT_BE_U_2(tptr)),
-                      ipaddr_string(ndo, tptr + 2)));
-        } else {
-            ND_PRINT((ndo, " AS #%s, origin %s",
-                      as_printf(ndo, astostr, sizeof(astostr),
-                      EXTRACT_BE_U_4(tptr)), ipaddr_string(ndo, tptr + 4)));
-        }
-        break;
-    case BGPTYPE_AGGREGATOR4:
-        if (len != 8) {
-            ND_PRINT((ndo, "invalid len"));
-            break;
-        }
-        ND_TCHECK_8(tptr);
-        ND_PRINT((ndo, " AS #%s, origin %s",
-                  as_printf(ndo, astostr, sizeof(astostr), EXTRACT_BE_U_4(tptr)),
-                  ipaddr_string(ndo, tptr + 4)));
-        break;
-    case BGPTYPE_COMMUNITIES:
-        if (len % 4) {
-            ND_PRINT((ndo, "invalid len"));
-            break;
-        }
-        while (tlen>0) {
-            uint32_t comm;
-            ND_TCHECK_4(tptr);
-            comm = EXTRACT_BE_U_4(tptr);
-            switch (comm) {
-            case BGP_COMMUNITY_NO_EXPORT:
-                ND_PRINT((ndo, " NO_EXPORT"));
-                break;
-            case BGP_COMMUNITY_NO_ADVERT:
-                ND_PRINT((ndo, " NO_ADVERTISE"));
-                break;
-            case BGP_COMMUNITY_NO_EXPORT_SUBCONFED:
-                ND_PRINT((ndo, " NO_EXPORT_SUBCONFED"));
-                break;
-            default:
-                ND_PRINT((ndo, "%u:%u%s",
-                         (comm >> 16) & 0xffff,
-                         comm & 0xffff,
-                         (tlen>4) ? ", " : ""));
-                break;
-            }
-            tlen -=4;
-            tptr +=4;
-        }
-        break;
-    case BGPTYPE_ORIGINATOR_ID:
-        if (len != 4) {
-            ND_PRINT((ndo, "invalid len"));
-            break;
-        }
-        ND_TCHECK_4(tptr);
-        ND_PRINT((ndo, "%s",ipaddr_string(ndo, tptr)));
-        break;
-    case BGPTYPE_CLUSTER_LIST:
-        if (len % 4) {
-            ND_PRINT((ndo, "invalid len"));
-            break;
-        }
-        while (tlen>0) {
-            ND_TCHECK_4(tptr);
-            ND_PRINT((ndo, "%s%s",
-                      ipaddr_string(ndo, tptr),
-                      (tlen>4) ? ", " : ""));
-            tlen -=4;
-            tptr +=4;
-        }
-        break;
-    case BGPTYPE_MP_REACH_NLRI:
-        ND_TCHECK_3(tptr);
-        af = EXTRACT_BE_U_2(tptr);
-        safi = EXTRACT_U_1(tptr + 2);
+        af = GET_BE_U_2(tptr);
+       *afp = af;
+        safi = GET_U_1(tptr + 2);
+       *safip = safi;
  
  
-        ND_PRINT((ndo, "\n\t    AFI: %s (%u), %sSAFI: %s (%u)",
+        ND_PRINT("\n\t    AFI: %s (%u), %sSAFI: %s (%u)",
                    tok2str(af_values, "Unknown AFI", af),
                    af,
                    (safi>128) ? "vendor specific " : "", /* 128 is meanwhile wellknown */
                    tok2str(bgp_safi_values, "Unknown SAFI", safi),
                    tok2str(af_values, "Unknown AFI", af),
                    af,
                    (safi>128) ? "vendor specific " : "", /* 128 is meanwhile wellknown */
                    tok2str(bgp_safi_values, "Unknown SAFI", safi),
-                  safi));
+                  safi);
  
          switch(af<<8 | safi) {
          case (AFNUM_INET<<8 | SAFNUM_UNICAST):
  
          switch(af<<8 | safi) {
          case (AFNUM_INET<<8 | SAFNUM_UNICAST):
@@ -1647,501 +1712,573 @@ bgp_attr_print(netdissect_options *ndo,
              break;
          default:
              ND_TCHECK_LEN(tptr, tlen);
              break;
          default:
              ND_TCHECK_LEN(tptr, tlen);
-            ND_PRINT((ndo, "\n\t    no AFI %u / SAFI %u decoder", af, safi));
+            ND_PRINT("\n\t    no AFI %u / SAFI %u decoder", af, safi);
              if (ndo->ndo_vflag <= 1)
                  print_unknown_data(ndo, tptr, "\n\t    ", tlen);
              if (ndo->ndo_vflag <= 1)
                  print_unknown_data(ndo, tptr, "\n\t    ", tlen);
-            goto done;
-            break;
-        }
-
-        tptr +=3;
-
-        ND_TCHECK_1(tptr);
-        nhlen = EXTRACT_U_1(tptr);
-        tlen = nhlen;
-        tptr++;
-
-        if (tlen) {
-            int nnh = 0;
-            ND_PRINT((ndo, "\n\t    nexthop: "));
-            while (tlen > 0) {
-                if (nnh++ > 0) {
-                    ND_PRINT((ndo,  ", " ));
-                }
-                switch(af<<8 | safi) {
-                case (AFNUM_INET<<8 | SAFNUM_UNICAST):
-                case (AFNUM_INET<<8 | SAFNUM_MULTICAST):
-                case (AFNUM_INET<<8 | SAFNUM_UNIMULTICAST):
-                case (AFNUM_INET<<8 | SAFNUM_LABUNICAST):
-                case (AFNUM_INET<<8 | SAFNUM_RT_ROUTING_INFO):
-                case (AFNUM_INET<<8 | SAFNUM_MULTICAST_VPN):
-                case (AFNUM_INET<<8 | SAFNUM_MDT):
-                    if (tlen < sizeof(struct in_addr)) {
-                        ND_PRINT((ndo, "invalid len"));
-                        tlen = 0;
-                    } else {
-                        ND_TCHECK_LEN(tptr, sizeof(struct in_addr));
-                        ND_PRINT((ndo, "%s",ipaddr_string(ndo, tptr)));
-                        tlen -= sizeof(struct in_addr);
-                        tptr += sizeof(struct in_addr);
-                    }
-                    break;
-                case (AFNUM_INET<<8 | SAFNUM_VPNUNICAST):
-                case (AFNUM_INET<<8 | SAFNUM_VPNMULTICAST):
-                case (AFNUM_INET<<8 | SAFNUM_VPNUNIMULTICAST):
-                    if (tlen < sizeof(struct in_addr)+BGP_VPN_RD_LEN) {
-                        ND_PRINT((ndo, "invalid len"));
-                        tlen = 0;
-                    } else {
-                        ND_TCHECK_LEN(tptr,
-                                      sizeof(struct in_addr) + BGP_VPN_RD_LEN);
-                        ND_PRINT((ndo, "RD: %s, %s",
-                                  bgp_vpn_rd_print(ndo, tptr),
-                                  ipaddr_string(ndo, tptr+BGP_VPN_RD_LEN)));
-                        tlen -= (sizeof(struct in_addr)+BGP_VPN_RD_LEN);
-                        tptr += (sizeof(struct in_addr)+BGP_VPN_RD_LEN);
-                    }
-                    break;
-                case (AFNUM_INET6<<8 | SAFNUM_UNICAST):
-                case (AFNUM_INET6<<8 | SAFNUM_MULTICAST):
-                case (AFNUM_INET6<<8 | SAFNUM_UNIMULTICAST):
-                case (AFNUM_INET6<<8 | SAFNUM_LABUNICAST):
-                    if (tlen < sizeof(struct in6_addr)) {
-                        ND_PRINT((ndo, "invalid len"));
-                        tlen = 0;
-                    } else {
-                        ND_TCHECK_LEN(tptr, sizeof(struct in6_addr));
-                        ND_PRINT((ndo, "%s", ip6addr_string(ndo, tptr)));
-                        tlen -= sizeof(struct in6_addr);
-                        tptr += sizeof(struct in6_addr);
-                    }
-                    break;
-                case (AFNUM_INET6<<8 | SAFNUM_VPNUNICAST):
-                case (AFNUM_INET6<<8 | SAFNUM_VPNMULTICAST):
-                case (AFNUM_INET6<<8 | SAFNUM_VPNUNIMULTICAST):
-                    if (tlen < sizeof(struct in6_addr)+BGP_VPN_RD_LEN) {
-                        ND_PRINT((ndo, "invalid len"));
-                        tlen = 0;
-                    } else {
-                        ND_TCHECK_LEN(tptr,
-                                      sizeof(struct in6_addr) + BGP_VPN_RD_LEN);
-                        ND_PRINT((ndo, "RD: %s, %s",
-                                  bgp_vpn_rd_print(ndo, tptr),
-                                  ip6addr_string(ndo, tptr+BGP_VPN_RD_LEN)));
-                        tlen -= (sizeof(struct in6_addr)+BGP_VPN_RD_LEN);
-                        tptr += (sizeof(struct in6_addr)+BGP_VPN_RD_LEN);
-                    }
-                    break;
-                case (AFNUM_VPLS<<8 | SAFNUM_VPLS):
-                case (AFNUM_L2VPN<<8 | SAFNUM_VPNUNICAST):
-                case (AFNUM_L2VPN<<8 | SAFNUM_VPNMULTICAST):
-                case (AFNUM_L2VPN<<8 | SAFNUM_VPNUNIMULTICAST):
-                    if (tlen < sizeof(struct in_addr)) {
-                        ND_PRINT((ndo, "invalid len"));
-                        tlen = 0;
-                    } else {
-                        ND_TCHECK_LEN(tptr, sizeof(struct in_addr));
-                        ND_PRINT((ndo, "%s", ipaddr_string(ndo, tptr)));
-                        tlen -= (sizeof(struct in_addr));
-                        tptr += (sizeof(struct in_addr));
-                    }
-                    break;
-                case (AFNUM_NSAP<<8 | SAFNUM_UNICAST):
-                case (AFNUM_NSAP<<8 | SAFNUM_MULTICAST):
-                case (AFNUM_NSAP<<8 | SAFNUM_UNIMULTICAST):
-                    ND_TCHECK_LEN(tptr, tlen);
-                    ND_PRINT((ndo, "%s", isonsap_string(ndo, tptr, tlen)));
-                    tptr += tlen;
-                    tlen = 0;
-                    break;
-
-                case (AFNUM_NSAP<<8 | SAFNUM_VPNUNICAST):
-                case (AFNUM_NSAP<<8 | SAFNUM_VPNMULTICAST):
-                case (AFNUM_NSAP<<8 | SAFNUM_VPNUNIMULTICAST):
-                    if (tlen < BGP_VPN_RD_LEN+1) {
-                        ND_PRINT((ndo, "invalid len"));
-                        tlen = 0;
-                    } else {
-                        ND_TCHECK_LEN(tptr, tlen);
-                        ND_PRINT((ndo, "RD: %s, %s",
-                                  bgp_vpn_rd_print(ndo, tptr),
-                                  isonsap_string(ndo, tptr+BGP_VPN_RD_LEN,tlen-BGP_VPN_RD_LEN)));
-                        /* rfc986 mapped IPv4 address ? */
-                        if (EXTRACT_BE_U_4(tptr + BGP_VPN_RD_LEN) ==  0x47000601)
-                            ND_PRINT((ndo, " = %s", ipaddr_string(ndo, tptr+BGP_VPN_RD_LEN+4)));
-                        /* rfc1888 mapped IPv6 address ? */
-                        else if (EXTRACT_BE_U_3(tptr + BGP_VPN_RD_LEN) ==  0x350000)
-                            ND_PRINT((ndo, " = %s", ip6addr_string(ndo, tptr+BGP_VPN_RD_LEN+3)));
-                        tptr += tlen;
-                        tlen = 0;
-                    }
-                    break;
-                default:
-                    ND_TCHECK_LEN(tptr, tlen);
-                    ND_PRINT((ndo, "no AFI %u/SAFI %u decoder", af, safi));
-                    if (ndo->ndo_vflag <= 1)
-                        print_unknown_data(ndo, tptr, "\n\t    ", tlen);
-                    tptr += tlen;
-                    tlen = 0;
-                    goto done;
-                    break;
-                }
-            }
-        }
-        ND_PRINT((ndo, ", nh-length: %u", nhlen));
-        tptr += tlen;
-
-        ND_TCHECK_1(tptr);
-        snpa = EXTRACT_U_1(tptr);
-        tptr++;
-
-        if (snpa) {
-            ND_PRINT((ndo, "\n\t    %u SNPA", snpa));
-            for (/*nothing*/; snpa > 0; snpa--) {
-                ND_TCHECK_1(tptr);
-                ND_PRINT((ndo, "\n\t      %d bytes", EXTRACT_U_1(tptr)));
-                tptr += EXTRACT_U_1(tptr) + 1;
-            }
-        } else {
-            ND_PRINT((ndo, ", no SNPA"));
+            return -1;
          }
          }
+       return 0;
+trunc:
+       return -2;
+}
  
  
-        add_path4 = check_add_path(tptr, (len-(tptr - pptr)), 32);
-        add_path6 = check_add_path(tptr, (len-(tptr - pptr)), 128);
+static int
+bgp_nlri_print(netdissect_options *ndo, uint16_t af, uint8_t safi,
+              const u_char *tptr, u_int len,
+              char *buf, size_t buflen,
+              int add_path4, int add_path6)
+{
+       int advance;
+       u_int path_id = 0;
  
  
-        while (tptr < pptr + len) {
-            switch (af<<8 | safi) {
+       switch (af<<8 | safi) {
              case (AFNUM_INET<<8 | SAFNUM_UNICAST):
              case (AFNUM_INET<<8 | SAFNUM_MULTICAST):
              case (AFNUM_INET<<8 | SAFNUM_UNIMULTICAST):
                  if (add_path4) {
              case (AFNUM_INET<<8 | SAFNUM_UNICAST):
              case (AFNUM_INET<<8 | SAFNUM_MULTICAST):
              case (AFNUM_INET<<8 | SAFNUM_UNIMULTICAST):
                  if (add_path4) {
-                    path_id = EXTRACT_BE_U_4(tptr);
+                    path_id = GET_BE_U_4(tptr);
                      tptr += 4;
                  }
                      tptr += 4;
                  }
-                advance = decode_prefix4(ndo, tptr, len, buf, sizeof(buf));
+                advance = decode_prefix4(ndo, tptr, len, buf, buflen);
                  if (advance == -1)
                  if (advance == -1)
-                    ND_PRINT((ndo, "\n\t    (illegal prefix length)"));
+                    ND_PRINT("\n\t    (illegal prefix length)");
                  else if (advance == -2)
                  else if (advance == -2)
-                    goto trunc;
-                else if (advance == -3)
                      break; /* bytes left, but not enough */
                  else
                      break; /* bytes left, but not enough */
                  else
-                    ND_PRINT((ndo, "\n\t      %s", buf));
+                    ND_PRINT("\n\t      %s", buf);
                  if (add_path4) {
                  if (add_path4) {
-                    ND_PRINT((ndo, "   Path Id: %d", path_id));
+                    ND_PRINT("   Path Id: %u", path_id);
+                   advance += 4;
                  }
                  break;
              case (AFNUM_INET<<8 | SAFNUM_LABUNICAST):
                  }
                  break;
              case (AFNUM_INET<<8 | SAFNUM_LABUNICAST):
-                advance = decode_labeled_prefix4(ndo, tptr, len, buf, sizeof(buf));
+                advance = decode_labeled_prefix4(ndo, tptr, len, buf, buflen);
                  if (advance == -1)
                  if (advance == -1)
-                    ND_PRINT((ndo, "\n\t    (illegal prefix length)"));
+                    ND_PRINT("\n\t    (illegal prefix length)");
                  else if (advance == -2)
                      goto trunc;
                  else if (advance == -3)
                      break; /* bytes left, but not enough */
                  else
                  else if (advance == -2)
                      goto trunc;
                  else if (advance == -3)
                      break; /* bytes left, but not enough */
                  else
-                    ND_PRINT((ndo, "\n\t      %s", buf));
+                    ND_PRINT("\n\t      %s", buf);
                  break;
              case (AFNUM_INET<<8 | SAFNUM_VPNUNICAST):
              case (AFNUM_INET<<8 | SAFNUM_VPNMULTICAST):
              case (AFNUM_INET<<8 | SAFNUM_VPNUNIMULTICAST):
                  break;
              case (AFNUM_INET<<8 | SAFNUM_VPNUNICAST):
              case (AFNUM_INET<<8 | SAFNUM_VPNMULTICAST):
              case (AFNUM_INET<<8 | SAFNUM_VPNUNIMULTICAST):
-                advance = decode_labeled_vpn_prefix4(ndo, tptr, buf, sizeof(buf));
+                advance = decode_labeled_vpn_prefix4(ndo, tptr, buf, buflen);
                  if (advance == -1)
                  if (advance == -1)
-                    ND_PRINT((ndo, "\n\t    (illegal prefix length)"));
-                else if (advance == -2)
-                    goto trunc;
+                    ND_PRINT("\n\t    (illegal prefix length)");
                  else
                  else
-                    ND_PRINT((ndo, "\n\t      %s", buf));
+                    ND_PRINT("\n\t      %s", buf);
                  break;
              case (AFNUM_INET<<8 | SAFNUM_RT_ROUTING_INFO):
                  break;
              case (AFNUM_INET<<8 | SAFNUM_RT_ROUTING_INFO):
-                advance = decode_rt_routing_info(ndo, tptr, buf, sizeof(buf));
-                if (advance == -1)
-                    ND_PRINT((ndo, "\n\t    (illegal prefix length)"));
-                else if (advance == -2)
-                    goto trunc;
-                else
-                    ND_PRINT((ndo, "\n\t      %s", buf));
+                advance = decode_rt_routing_info(ndo, tptr);
                  break;
              case (AFNUM_INET<<8 | SAFNUM_MULTICAST_VPN): /* fall through */
              case (AFNUM_INET6<<8 | SAFNUM_MULTICAST_VPN):
                  break;
              case (AFNUM_INET<<8 | SAFNUM_MULTICAST_VPN): /* fall through */
              case (AFNUM_INET6<<8 | SAFNUM_MULTICAST_VPN):
-                advance = decode_multicast_vpn(ndo, tptr, buf, sizeof(buf));
+                advance = decode_multicast_vpn(ndo, tptr, buf, buflen);
                  if (advance == -1)
                  if (advance == -1)
-                    ND_PRINT((ndo, "\n\t    (illegal prefix length)"));
+                    ND_PRINT("\n\t    (illegal prefix length)");
                  else if (advance == -2)
                      goto trunc;
                  else
                  else if (advance == -2)
                      goto trunc;
                  else
-                    ND_PRINT((ndo, "\n\t      %s", buf));
+                    ND_PRINT("\n\t      %s", buf);
                  break;
  
              case (AFNUM_INET<<8 | SAFNUM_MDT):
                  break;
  
              case (AFNUM_INET<<8 | SAFNUM_MDT):
-                advance = decode_mdt_vpn_nlri(ndo, tptr, buf, sizeof(buf));
+                advance = decode_mdt_vpn_nlri(ndo, tptr, buf, buflen);
                  if (advance == -1)
                  if (advance == -1)
-                    ND_PRINT((ndo, "\n\t    (illegal prefix length)"));
+                    ND_PRINT("\n\t    (illegal prefix length)");
                  else if (advance == -2)
                      goto trunc;
                  else
                  else if (advance == -2)
                      goto trunc;
                  else
-                    ND_PRINT((ndo, "\n\t      %s", buf));
+                    ND_PRINT("\n\t      %s", buf);
                  break;
              case (AFNUM_INET6<<8 | SAFNUM_UNICAST):
              case (AFNUM_INET6<<8 | SAFNUM_MULTICAST):
              case (AFNUM_INET6<<8 | SAFNUM_UNIMULTICAST):
                  if (add_path6) {
                  break;
              case (AFNUM_INET6<<8 | SAFNUM_UNICAST):
              case (AFNUM_INET6<<8 | SAFNUM_MULTICAST):
              case (AFNUM_INET6<<8 | SAFNUM_UNIMULTICAST):
                  if (add_path6) {
-                    path_id = EXTRACT_BE_U_4(tptr);
+                    path_id = GET_BE_U_4(tptr);
                      tptr += 4;
                  }
                      tptr += 4;
                  }
-                advance = decode_prefix6(ndo, tptr, len, buf, sizeof(buf));
+                advance = decode_prefix6(ndo, tptr, len, buf, buflen);
                  if (advance == -1)
                  if (advance == -1)
-                    ND_PRINT((ndo, "\n\t    (illegal prefix length)"));
+                    ND_PRINT("\n\t    (illegal prefix length)");
                  else if (advance == -2)
                  else if (advance == -2)
-                    goto trunc;
-                else if (advance == -3)
                      break; /* bytes left, but not enough */
                  else
                      break; /* bytes left, but not enough */
                  else
-                    ND_PRINT((ndo, "\n\t      %s", buf));
+                    ND_PRINT("\n\t      %s", buf);
                  if (add_path6) {
                  if (add_path6) {
-                    ND_PRINT((ndo, "   Path Id: %d", path_id));
+                    ND_PRINT("   Path Id: %u", path_id);
+                   advance += 4;
                  }
                  break;
              case (AFNUM_INET6<<8 | SAFNUM_LABUNICAST):
                  }
                  break;
              case (AFNUM_INET6<<8 | SAFNUM_LABUNICAST):
-                advance = decode_labeled_prefix6(ndo, tptr, len, buf, sizeof(buf));
+                advance = decode_labeled_prefix6(ndo, tptr, len, buf, buflen);
                  if (advance == -1)
                  if (advance == -1)
-                    ND_PRINT((ndo, "\n\t    (illegal prefix length)"));
+                    ND_PRINT("\n\t    (illegal prefix length)");
                  else if (advance == -2)
                      goto trunc;
                  else if (advance == -3)
                      break; /* bytes left, but not enough */
                  else
                  else if (advance == -2)
                      goto trunc;
                  else if (advance == -3)
                      break; /* bytes left, but not enough */
                  else
-                    ND_PRINT((ndo, "\n\t      %s", buf));
+                    ND_PRINT("\n\t      %s", buf);
                  break;
              case (AFNUM_INET6<<8 | SAFNUM_VPNUNICAST):
              case (AFNUM_INET6<<8 | SAFNUM_VPNMULTICAST):
              case (AFNUM_INET6<<8 | SAFNUM_VPNUNIMULTICAST):
                  break;
              case (AFNUM_INET6<<8 | SAFNUM_VPNUNICAST):
              case (AFNUM_INET6<<8 | SAFNUM_VPNMULTICAST):
              case (AFNUM_INET6<<8 | SAFNUM_VPNUNIMULTICAST):
-                advance = decode_labeled_vpn_prefix6(ndo, tptr, buf, sizeof(buf));
+                advance = decode_labeled_vpn_prefix6(ndo, tptr, buf, buflen);
                  if (advance == -1)
                  if (advance == -1)
-                    ND_PRINT((ndo, "\n\t    (illegal prefix length)"));
-                else if (advance == -2)
-                    goto trunc;
+                    ND_PRINT("\n\t    (illegal prefix length)");
                  else
                  else
-                    ND_PRINT((ndo, "\n\t      %s", buf));
+                    ND_PRINT("\n\t      %s", buf);
                  break;
              case (AFNUM_VPLS<<8 | SAFNUM_VPLS):
              case (AFNUM_L2VPN<<8 | SAFNUM_VPNUNICAST):
              case (AFNUM_L2VPN<<8 | SAFNUM_VPNMULTICAST):
              case (AFNUM_L2VPN<<8 | SAFNUM_VPNUNIMULTICAST):
                  break;
              case (AFNUM_VPLS<<8 | SAFNUM_VPLS):
              case (AFNUM_L2VPN<<8 | SAFNUM_VPNUNICAST):
              case (AFNUM_L2VPN<<8 | SAFNUM_VPNMULTICAST):
              case (AFNUM_L2VPN<<8 | SAFNUM_VPNUNIMULTICAST):
-                advance = decode_labeled_vpn_l2(ndo, tptr, buf, sizeof(buf));
+                advance = decode_labeled_vpn_l2(ndo, tptr, buf, buflen);
                  if (advance == -1)
                  if (advance == -1)
-                    ND_PRINT((ndo, "\n\t    (illegal length)"));
+                    ND_PRINT("\n\t    (illegal length)");
                  else if (advance == -2)
                      goto trunc;
                  else
                  else if (advance == -2)
                      goto trunc;
                  else
-                    ND_PRINT((ndo, "\n\t      %s", buf));
+                    ND_PRINT("\n\t      %s", buf);
                  break;
              case (AFNUM_NSAP<<8 | SAFNUM_UNICAST):
              case (AFNUM_NSAP<<8 | SAFNUM_MULTICAST):
              case (AFNUM_NSAP<<8 | SAFNUM_UNIMULTICAST):
                  break;
              case (AFNUM_NSAP<<8 | SAFNUM_UNICAST):
              case (AFNUM_NSAP<<8 | SAFNUM_MULTICAST):
              case (AFNUM_NSAP<<8 | SAFNUM_UNIMULTICAST):
-                advance = decode_clnp_prefix(ndo, tptr, buf, sizeof(buf));
+                advance = decode_clnp_prefix(ndo, tptr, buf, buflen);
                  if (advance == -1)
                  if (advance == -1)
-                    ND_PRINT((ndo, "\n\t    (illegal prefix length)"));
-                else if (advance == -2)
-                    goto trunc;
+                    ND_PRINT("\n\t    (illegal prefix length)");
                  else
                  else
-                    ND_PRINT((ndo, "\n\t      %s", buf));
+                    ND_PRINT("\n\t      %s", buf);
                  break;
              case (AFNUM_NSAP<<8 | SAFNUM_VPNUNICAST):
              case (AFNUM_NSAP<<8 | SAFNUM_VPNMULTICAST):
              case (AFNUM_NSAP<<8 | SAFNUM_VPNUNIMULTICAST):
                  break;
              case (AFNUM_NSAP<<8 | SAFNUM_VPNUNICAST):
              case (AFNUM_NSAP<<8 | SAFNUM_VPNMULTICAST):
              case (AFNUM_NSAP<<8 | SAFNUM_VPNUNIMULTICAST):
-                advance = decode_labeled_vpn_clnp_prefix(ndo, tptr, buf, sizeof(buf));
+                advance = decode_labeled_vpn_clnp_prefix(ndo, tptr, buf, buflen);
                  if (advance == -1)
                  if (advance == -1)
-                    ND_PRINT((ndo, "\n\t    (illegal prefix length)"));
-                else if (advance == -2)
-                    goto trunc;
+                    ND_PRINT("\n\t    (illegal prefix length)");
                  else
                  else
-                    ND_PRINT((ndo, "\n\t      %s", buf));
+                    ND_PRINT("\n\t      %s", buf);
+                break;
+            default:
+               /*
+                * This should not happen, we should have been protected
+                * by bgp_mp_af_print()'s return value.
+                */
+                ND_PRINT("\n\t    ERROR: no AFI %u / SAFI %u decoder", af, safi);
+                advance = -4;
+                break;
+       }
+       return advance;
+trunc: /* we rely on the caller to recognize -2 return value */
+       return -2;
+}
+
+static int
+bgp_attr_print(netdissect_options *ndo,
+               uint8_t atype, const u_char *pptr, u_int len,
+               const unsigned attr_set_level)
+{
+    /* allocate space for the largest possible string */
+    char astostr[AS_STR_SIZE];
+    u_int i;
+    uint16_t af;
+    uint8_t safi, snpa, nhlen;
+    int advance;
+    u_int tlen;
+    const u_char *tptr;
+    char buf[MAXHOSTNAMELEN + 100];
+    u_int as_size;
+    int add_path4, add_path6;
+    int ret;
+
+    tptr = pptr;
+    tlen = len;
+
+    switch (atype) {
+    case BGPTYPE_ORIGIN:
+        if (len != 1)
+            ND_PRINT("invalid len");
+        else {
+            ND_PRINT("%s", tok2str(bgp_origin_values,
+                      "Unknown Origin Typecode",
+                      GET_U_1(tptr)));
+        }
+        break;
+
+    /*
+     * Process AS4 byte path and AS2 byte path attributes here.
+     */
+    case BGPTYPE_AS4_PATH:
+    case BGPTYPE_AS_PATH:
+        if (len % 2) {
+            ND_PRINT("invalid len");
+            break;
+        }
+        if (!len) {
+            ND_PRINT("empty");
+            break;
+        }
+
+        /*
+         * BGP updates exchanged between New speakers that support 4
+         * byte AS, ASs are always encoded in 4 bytes. There is no
+         * definitive way to find this, just by the packet's
+         * contents. So, check for packet's TLV's sanity assuming
+         * 2 bytes first, and it does not pass, assume that ASs are
+         * encoded in 4 bytes format and move on.
+         */
+        as_size = bgp_attr_get_as_size(ndo, atype, pptr, len);
+
+        while (tptr < pptr + len) {
+            ND_PRINT("%s", tok2str(bgp_as_path_segment_open_values,
+                      "?", GET_U_1(tptr)));
+            for (i = 0; i < GET_U_1(tptr + 1) * as_size; i += as_size) {
+                ND_TCHECK_LEN(tptr + 2 + i, as_size);
+                ND_PRINT("%s ",
+                          as_printf(ndo, astostr, sizeof(astostr),
+                          as_size == 2 ?
+                              GET_BE_U_2(tptr + i + 2) :
+                              GET_BE_U_4(tptr + i + 2)));
+            }
+            ND_PRINT("%s", tok2str(bgp_as_path_segment_close_values,
+                      "?", GET_U_1(tptr)));
+            tptr += 2 + GET_U_1(tptr + 1) * as_size;
+        }
+        break;
+    case BGPTYPE_NEXT_HOP:
+        if (len != 4)
+            ND_PRINT("invalid len");
+        else {
+            ND_PRINT("%s", GET_IPADDR_STRING(tptr));
+        }
+        break;
+    case BGPTYPE_MULTI_EXIT_DISC:
+    case BGPTYPE_LOCAL_PREF:
+        if (len != 4)
+            ND_PRINT("invalid len");
+        else {
+            ND_PRINT("%u", GET_BE_U_4(tptr));
+        }
+        break;
+    case BGPTYPE_ATOMIC_AGGREGATE:
+        if (len != 0)
+            ND_PRINT("invalid len");
+        break;
+    case BGPTYPE_AGGREGATOR:
+
+        /*
+         * Depending on the AS encoded is of 2 bytes or of 4 bytes,
+         * the length of this PA can be either 6 bytes or 8 bytes.
+         */
+        if (len != 6 && len != 8) {
+            ND_PRINT("invalid len");
+            break;
+        }
+        ND_TCHECK_LEN(tptr, len);
+        if (len == 6) {
+            ND_PRINT(" AS #%s, origin %s",
+                      as_printf(ndo, astostr, sizeof(astostr), GET_BE_U_2(tptr)),
+                      GET_IPADDR_STRING(tptr + 2));
+        } else {
+            ND_PRINT(" AS #%s, origin %s",
+                      as_printf(ndo, astostr, sizeof(astostr),
+                      GET_BE_U_4(tptr)), GET_IPADDR_STRING(tptr + 4));
+        }
+        break;
+    case BGPTYPE_AGGREGATOR4:
+        if (len != 8) {
+            ND_PRINT("invalid len");
+            break;
+        }
+        ND_PRINT(" AS #%s, origin %s",
+                  as_printf(ndo, astostr, sizeof(astostr), GET_BE_U_4(tptr)),
+                  GET_IPADDR_STRING(tptr + 4));
+        break;
+    case BGPTYPE_COMMUNITIES:
+        if (len % 4) {
+            ND_PRINT("invalid len");
+            break;
+        }
+        while (tlen != 0) {
+            uint32_t comm;
+            ND_TCHECK_4(tptr);
+            if (tlen < 4)
+                goto trunc;
+            comm = GET_BE_U_4(tptr);
+            switch (comm) {
+            case BGP_COMMUNITY_NO_EXPORT:
+                ND_PRINT(" NO_EXPORT");
+                break;
+            case BGP_COMMUNITY_NO_ADVERT:
+                ND_PRINT(" NO_ADVERTISE");
+                break;
+            case BGP_COMMUNITY_NO_EXPORT_SUBCONFED:
+                ND_PRINT(" NO_EXPORT_SUBCONFED");
                  break;
              default:
                  break;
              default:
-                ND_TCHECK_LEN(tptr, tlen);
-                ND_PRINT((ndo, "\n\t    no AFI %u / SAFI %u decoder", af, safi));
-                if (ndo->ndo_vflag <= 1)
-                    print_unknown_data(ndo, tptr, "\n\t    ", tlen);
-                advance = 0;
-                tptr = pptr + len;
+                ND_PRINT("%u:%u%s",
+                         (comm >> 16) & 0xffff,
+                         comm & 0xffff,
+                         (tlen>4) ? ", " : "");
                  break;
              }
                  break;
              }
+            tlen -=4;
+            tptr +=4;
+        }
+        break;
+    case BGPTYPE_ORIGINATOR_ID:
+        if (len != 4) {
+            ND_PRINT("invalid len");
+            break;
+        }
+        ND_PRINT("%s",GET_IPADDR_STRING(tptr));
+        break;
+    case BGPTYPE_CLUSTER_LIST:
+        if (len % 4) {
+            ND_PRINT("invalid len");
+            break;
+        }
+        while (tlen != 0) {
+            if (tlen < 4)
+                goto trunc;
+            ND_PRINT("%s%s",
+                      GET_IPADDR_STRING(tptr),
+                      (tlen>4) ? ", " : "");
+            tlen -=4;
+            tptr +=4;
+        }
+        break;
+    case BGPTYPE_MP_REACH_NLRI:
+        ND_TCHECK_3(tptr);
+        if (tlen < 3)
+            goto trunc;
+       ret = bgp_mp_af_print(ndo, tptr, tlen, &af, &safi);
+       if (ret == -2)
+           goto trunc;
+       if (ret < 0)
+           break;
+
+        tptr += 3;
+        tlen -= 3;
+
+        ND_TCHECK_1(tptr);
+        if (tlen < 1)
+            goto trunc;
+        nhlen = GET_U_1(tptr);
+        tptr++;
+        tlen--;
+
+        if (nhlen) {
+            u_int nnh = 0;
+            uint8_t tnhlen = nhlen;
+            if (tlen < tnhlen)
+                goto trunc;
+            ND_PRINT("\n\t    nexthop: ");
+            while (tnhlen != 0) {
+                if (nnh++ > 0) {
+                    ND_PRINT(", " );
+                }
+                switch(af<<8 | safi) {
+                case (AFNUM_INET<<8 | SAFNUM_UNICAST):
+                case (AFNUM_INET<<8 | SAFNUM_MULTICAST):
+                case (AFNUM_INET<<8 | SAFNUM_UNIMULTICAST):
+                case (AFNUM_INET<<8 | SAFNUM_LABUNICAST):
+                case (AFNUM_INET<<8 | SAFNUM_RT_ROUTING_INFO):
+                case (AFNUM_INET<<8 | SAFNUM_MULTICAST_VPN):
+                case (AFNUM_INET<<8 | SAFNUM_MDT):
+                    if (tnhlen < sizeof(nd_ipv4)) {
+                        ND_PRINT("invalid len");
+                        tptr += tnhlen;
+                        tlen -= tnhlen;
+                        tnhlen = 0;
+                    } else {
+                        ND_PRINT("%s",GET_IPADDR_STRING(tptr));
+                        tptr += sizeof(nd_ipv4);
+                        tnhlen -= sizeof(nd_ipv4);
+                        tlen -= sizeof(nd_ipv4);
+                    }
+                    break;
+                case (AFNUM_INET<<8 | SAFNUM_VPNUNICAST):
+                case (AFNUM_INET<<8 | SAFNUM_VPNMULTICAST):
+                case (AFNUM_INET<<8 | SAFNUM_VPNUNIMULTICAST):
+                    if (tnhlen < sizeof(nd_ipv4)+BGP_VPN_RD_LEN) {
+                        ND_PRINT("invalid len");
+                        tptr += tnhlen;
+                        tlen -= tnhlen;
+                        tnhlen = 0;
+                    } else {
+                        ND_PRINT("RD: %s, %s",
+                                  bgp_vpn_rd_print(ndo, tptr),
+                                  GET_IPADDR_STRING(tptr+BGP_VPN_RD_LEN));
+                        tptr += (sizeof(nd_ipv4)+BGP_VPN_RD_LEN);
+                        tlen -= (sizeof(nd_ipv4)+BGP_VPN_RD_LEN);
+                        tnhlen -= (sizeof(nd_ipv4)+BGP_VPN_RD_LEN);
+                    }
+                    break;
+                case (AFNUM_INET6<<8 | SAFNUM_UNICAST):
+                case (AFNUM_INET6<<8 | SAFNUM_MULTICAST):
+                case (AFNUM_INET6<<8 | SAFNUM_UNIMULTICAST):
+                case (AFNUM_INET6<<8 | SAFNUM_LABUNICAST):
+                    if (tnhlen < sizeof(nd_ipv6)) {
+                        ND_PRINT("invalid len");
+                        tptr += tnhlen;
+                        tlen -= tnhlen;
+                        tnhlen = 0;
+                    } else {
+                        ND_PRINT("%s", GET_IP6ADDR_STRING(tptr));
+                        tptr += sizeof(nd_ipv6);
+                        tlen -= sizeof(nd_ipv6);
+                        tnhlen -= sizeof(nd_ipv6);
+                    }
+                    break;
+                case (AFNUM_INET6<<8 | SAFNUM_VPNUNICAST):
+                case (AFNUM_INET6<<8 | SAFNUM_VPNMULTICAST):
+                case (AFNUM_INET6<<8 | SAFNUM_VPNUNIMULTICAST):
+                    if (tnhlen < sizeof(nd_ipv6)+BGP_VPN_RD_LEN) {
+                        ND_PRINT("invalid len");
+                        tptr += tnhlen;
+                        tlen -= tnhlen;
+                        tnhlen = 0;
+                    } else {
+                        ND_PRINT("RD: %s, %s",
+                                  bgp_vpn_rd_print(ndo, tptr),
+                                  GET_IP6ADDR_STRING(tptr+BGP_VPN_RD_LEN));
+                        tptr += (sizeof(nd_ipv6)+BGP_VPN_RD_LEN);
+                        tlen -= (sizeof(nd_ipv6)+BGP_VPN_RD_LEN);
+                        tnhlen -= (sizeof(nd_ipv6)+BGP_VPN_RD_LEN);
+                    }
+                    break;
+                case (AFNUM_VPLS<<8 | SAFNUM_VPLS):
+                case (AFNUM_L2VPN<<8 | SAFNUM_VPNUNICAST):
+                case (AFNUM_L2VPN<<8 | SAFNUM_VPNMULTICAST):
+                case (AFNUM_L2VPN<<8 | SAFNUM_VPNUNIMULTICAST):
+                    if (tnhlen < sizeof(nd_ipv4)) {
+                        ND_PRINT("invalid len");
+                        tptr += tnhlen;
+                        tlen -= tnhlen;
+                        tnhlen = 0;
+                    } else {
+                        ND_PRINT("%s", GET_IPADDR_STRING(tptr));
+                        tptr += (sizeof(nd_ipv4));
+                        tlen -= (sizeof(nd_ipv4));
+                        tnhlen -= (sizeof(nd_ipv4));
+                    }
+                    break;
+                case (AFNUM_NSAP<<8 | SAFNUM_UNICAST):
+                case (AFNUM_NSAP<<8 | SAFNUM_MULTICAST):
+                case (AFNUM_NSAP<<8 | SAFNUM_UNIMULTICAST):
+                    ND_PRINT("%s", GET_ISONSAP_STRING(tptr, tnhlen));
+                    tptr += tnhlen;
+                    tlen -= tnhlen;
+                    tnhlen = 0;
+                    break;
+
+                case (AFNUM_NSAP<<8 | SAFNUM_VPNUNICAST):
+                case (AFNUM_NSAP<<8 | SAFNUM_VPNMULTICAST):
+                case (AFNUM_NSAP<<8 | SAFNUM_VPNUNIMULTICAST):
+                    if (tnhlen < BGP_VPN_RD_LEN+1) {
+                        ND_PRINT("invalid len");
+                        tptr += tnhlen;
+                        tlen -= tnhlen;
+                        tnhlen = 0;
+                    } else {
+                        ND_TCHECK_LEN(tptr, tnhlen);
+                        ND_PRINT("RD: %s, %s",
+                                  bgp_vpn_rd_print(ndo, tptr),
+                                  GET_ISONSAP_STRING(tptr+BGP_VPN_RD_LEN,tnhlen-BGP_VPN_RD_LEN));
+                        /* rfc986 mapped IPv4 address ? */
+                        if (GET_BE_U_4(tptr + BGP_VPN_RD_LEN) ==  0x47000601)
+                            ND_PRINT(" = %s", GET_IPADDR_STRING(tptr+BGP_VPN_RD_LEN+4));
+                        /* rfc1888 mapped IPv6 address ? */
+                        else if (GET_BE_U_3(tptr + BGP_VPN_RD_LEN) ==  0x350000)
+                            ND_PRINT(" = %s", GET_IP6ADDR_STRING(tptr+BGP_VPN_RD_LEN+3));
+                        tptr += tnhlen;
+                        tlen -= tnhlen;
+                        tnhlen = 0;
+                    }
+                    break;
+                default:
+                   /*
+                    * bgp_mp_af_print() should have saved us from
+                    * an unsupported AFI/SAFI.
+                    */
+                    ND_PRINT("ERROR: no AFI %u/SAFI %u nexthop decoder", af, safi);
+                    tptr += tnhlen;
+                    tlen -= tnhlen;
+                    tnhlen = 0;
+                    goto done;
+                    break;
+                }
+            }
+        }
+        ND_PRINT(", nh-length: %u", nhlen);
+
+        /* As per RFC 2858; this is reserved in RFC 4760 */
+        if (tlen < 1)
+            goto trunc;
+        snpa = GET_U_1(tptr);
+        tptr++;
+        tlen--;
+
+        if (snpa) {
+            ND_PRINT("\n\t    %u SNPA", snpa);
+            for (/*nothing*/; snpa != 0; snpa--) {
+                uint8_t snpalen;
+               if (tlen < 1)
+                   goto trunc;
+                snpalen = GET_U_1(tptr);
+                ND_PRINT("\n\t      %u bytes", snpalen);
+                tptr++;
+                tlen--;
+                if (tlen < snpalen)
+                    goto trunc;
+                ND_TCHECK_LEN(tptr, snpalen);
+                tptr += snpalen;
+                tlen -= snpalen;
+            }
+        } else {
+            ND_PRINT(", no SNPA");
+        }
+
+        add_path4 = check_add_path(ndo, tptr, (len-ND_BYTES_BETWEEN(tptr, pptr)), 32);
+        add_path6 = check_add_path(ndo, tptr, (len-ND_BYTES_BETWEEN(tptr, pptr)), 128);
+
+        while (tptr < pptr + len) {
+            advance = bgp_nlri_print(ndo, af, safi, tptr, len, buf, sizeof(buf),
+                    add_path4, add_path6);
+            if (advance == -2)
+                goto trunc;
              if (advance < 0)
                  break;
              tptr += advance;
          }
              if (advance < 0)
                  break;
              tptr += advance;
          }
-    done:
          break;
  
      case BGPTYPE_MP_UNREACH_NLRI:
          ND_TCHECK_LEN(tptr, BGP_MP_NLRI_MINSIZE);
          break;
  
      case BGPTYPE_MP_UNREACH_NLRI:
          ND_TCHECK_LEN(tptr, BGP_MP_NLRI_MINSIZE);
-        af = EXTRACT_BE_U_2(tptr);
-        safi = EXTRACT_U_1(tptr + 2);
-
-        ND_PRINT((ndo, "\n\t    AFI: %s (%u), %sSAFI: %s (%u)",
-                  tok2str(af_values, "Unknown AFI", af),
-                  af,
-                  (safi>128) ? "vendor specific " : "", /* 128 is meanwhile wellknown */
-                  tok2str(bgp_safi_values, "Unknown SAFI", safi),
-                  safi));
+       ret = bgp_mp_af_print(ndo, tptr, tlen, &af, &safi);
+       if (ret == -2)
+           goto trunc;
+       if (ret < 0)
+           break;
  
          if (len == BGP_MP_NLRI_MINSIZE)
  
          if (len == BGP_MP_NLRI_MINSIZE)
-            ND_PRINT((ndo, "\n\t      End-of-Rib Marker (empty NLRI)"));
+            ND_PRINT("\n\t      End-of-Rib Marker (empty NLRI)");
  
          tptr += 3;
  
  
          tptr += 3;
  
-        add_path4 = check_add_path(tptr, (len-(tptr - pptr)), 32);
-        add_path6 = check_add_path(tptr, (len-(tptr - pptr)), 128);
+        add_path4 = check_add_path(ndo, tptr, (len-ND_BYTES_BETWEEN(tptr, pptr)), 32);
+        add_path6 = check_add_path(ndo, tptr, (len-ND_BYTES_BETWEEN(tptr, pptr)), 128);
  
          while (tptr < pptr + len) {
  
          while (tptr < pptr + len) {
-            switch (af<<8 | safi) {
-            case (AFNUM_INET<<8 | SAFNUM_UNICAST):
-            case (AFNUM_INET<<8 | SAFNUM_MULTICAST):
-            case (AFNUM_INET<<8 | SAFNUM_UNIMULTICAST):
-                if (add_path4) {
-                    path_id = EXTRACT_BE_U_4(tptr);
-                    tptr += 4;
-                }
-                advance = decode_prefix4(ndo, tptr, len, buf, sizeof(buf));
-                if (advance == -1)
-                    ND_PRINT((ndo, "\n\t    (illegal prefix length)"));
-                else if (advance == -2)
-                    goto trunc;
-                else if (advance == -3)
-                    break; /* bytes left, but not enough */
-                else
-                    ND_PRINT((ndo, "\n\t      %s", buf));
-                if (add_path4) {
-                    ND_PRINT((ndo, "   Path Id: %d", path_id));
-                }
-                break;
-            case (AFNUM_INET<<8 | SAFNUM_LABUNICAST):
-                advance = decode_labeled_prefix4(ndo, tptr, len, buf, sizeof(buf));
-                if (advance == -1)
-                    ND_PRINT((ndo, "\n\t    (illegal prefix length)"));
-                else if (advance == -2)
-                    goto trunc;
-                else if (advance == -3)
-                    break; /* bytes left, but not enough */
-                else
-                    ND_PRINT((ndo, "\n\t      %s", buf));
-                break;
-            case (AFNUM_INET<<8 | SAFNUM_VPNUNICAST):
-            case (AFNUM_INET<<8 | SAFNUM_VPNMULTICAST):
-            case (AFNUM_INET<<8 | SAFNUM_VPNUNIMULTICAST):
-                advance = decode_labeled_vpn_prefix4(ndo, tptr, buf, sizeof(buf));
-                if (advance == -1)
-                    ND_PRINT((ndo, "\n\t    (illegal prefix length)"));
-                else if (advance == -2)
-                    goto trunc;
-                else
-                    ND_PRINT((ndo, "\n\t      %s", buf));
-                break;
-            case (AFNUM_INET6<<8 | SAFNUM_UNICAST):
-            case (AFNUM_INET6<<8 | SAFNUM_MULTICAST):
-            case (AFNUM_INET6<<8 | SAFNUM_UNIMULTICAST):
-                if (add_path6) {
-                    path_id = EXTRACT_BE_U_4(tptr);
-                    tptr += 4;
-                }
-                advance = decode_prefix6(ndo, tptr, len, buf, sizeof(buf));
-                if (advance == -1)
-                    ND_PRINT((ndo, "\n\t    (illegal prefix length)"));
-                else if (advance == -2)
-                    goto trunc;
-                else if (advance == -3)
-                    break; /* bytes left, but not enough */
-                else
-                    ND_PRINT((ndo, "\n\t      %s", buf));
-                if (add_path6) {
-                    ND_PRINT((ndo, "   Path Id: %d", path_id));
-                }
-                break;
-            case (AFNUM_INET6<<8 | SAFNUM_LABUNICAST):
-                advance = decode_labeled_prefix6(ndo, tptr, len, buf, sizeof(buf));
-                if (advance == -1)
-                    ND_PRINT((ndo, "\n\t    (illegal prefix length)"));
-                else if (advance == -2)
-                    goto trunc;
-                else if (advance == -3)
-                    break; /* bytes left, but not enough */
-                else
-                    ND_PRINT((ndo, "\n\t      %s", buf));
-                break;
-            case (AFNUM_INET6<<8 | SAFNUM_VPNUNICAST):
-            case (AFNUM_INET6<<8 | SAFNUM_VPNMULTICAST):
-            case (AFNUM_INET6<<8 | SAFNUM_VPNUNIMULTICAST):
-                advance = decode_labeled_vpn_prefix6(ndo, tptr, buf, sizeof(buf));
-                if (advance == -1)
-                    ND_PRINT((ndo, "\n\t    (illegal prefix length)"));
-                else if (advance == -2)
-                    goto trunc;
-                else
-                    ND_PRINT((ndo, "\n\t      %s", buf));
-                break;
-            case (AFNUM_VPLS<<8 | SAFNUM_VPLS):
-            case (AFNUM_L2VPN<<8 | SAFNUM_VPNUNICAST):
-            case (AFNUM_L2VPN<<8 | SAFNUM_VPNMULTICAST):
-            case (AFNUM_L2VPN<<8 | SAFNUM_VPNUNIMULTICAST):
-                advance = decode_labeled_vpn_l2(ndo, tptr, buf, sizeof(buf));
-                if (advance == -1)
-                    ND_PRINT((ndo, "\n\t    (illegal length)"));
-                else if (advance == -2)
-                    goto trunc;
-                else
-                    ND_PRINT((ndo, "\n\t      %s", buf));
-                break;
-            case (AFNUM_NSAP<<8 | SAFNUM_UNICAST):
-            case (AFNUM_NSAP<<8 | SAFNUM_MULTICAST):
-            case (AFNUM_NSAP<<8 | SAFNUM_UNIMULTICAST):
-                advance = decode_clnp_prefix(ndo, tptr, buf, sizeof(buf));
-                if (advance == -1)
-                    ND_PRINT((ndo, "\n\t    (illegal prefix length)"));
-                else if (advance == -2)
-                    goto trunc;
-                else
-                    ND_PRINT((ndo, "\n\t      %s", buf));
-                break;
-            case (AFNUM_NSAP<<8 | SAFNUM_VPNUNICAST):
-            case (AFNUM_NSAP<<8 | SAFNUM_VPNMULTICAST):
-            case (AFNUM_NSAP<<8 | SAFNUM_VPNUNIMULTICAST):
-                advance = decode_labeled_vpn_clnp_prefix(ndo, tptr, buf, sizeof(buf));
-                if (advance == -1)
-                    ND_PRINT((ndo, "\n\t    (illegal prefix length)"));
-                else if (advance == -2)
-                    goto trunc;
-                else
-                    ND_PRINT((ndo, "\n\t      %s", buf));
-                break;
-            case (AFNUM_INET<<8 | SAFNUM_MDT):
-                advance = decode_mdt_vpn_nlri(ndo, tptr, buf, sizeof(buf));
-                if (advance == -1)
-                    ND_PRINT((ndo, "\n\t    (illegal prefix length)"));
-                else if (advance == -2)
-                    goto trunc;
-                else
-                    ND_PRINT((ndo, "\n\t      %s", buf));
-                break;
-            case (AFNUM_INET<<8 | SAFNUM_MULTICAST_VPN): /* fall through */
-            case (AFNUM_INET6<<8 | SAFNUM_MULTICAST_VPN):
-                advance = decode_multicast_vpn(ndo, tptr, buf, sizeof(buf));
-                if (advance == -1)
-                    ND_PRINT((ndo, "\n\t    (illegal prefix length)"));
-                else if (advance == -2)
-                    goto trunc;
-                else
-                    ND_PRINT((ndo, "\n\t      %s", buf));
-                break;
-            default:
-                ND_TCHECK_LEN(tptr - 3, tlen);
-                ND_PRINT((ndo, "no AFI %u / SAFI %u decoder", af, safi));
-                if (ndo->ndo_vflag <= 1)
-                    print_unknown_data(ndo, tptr-3, "\n\t    ", tlen);
-                advance = 0;
-                tptr = pptr + len;
-                break;
-            }
+            advance = bgp_nlri_print(ndo, af, safi, tptr, len, buf, sizeof(buf),
+                    add_path4, add_path6);
+            if (advance == -2)
+                goto trunc;
              if (advance < 0)
                  break;
              tptr += advance;
              if (advance < 0)
                  break;
              tptr += advance;
@@ -2149,85 +2286,29 @@ bgp_attr_print(netdissect_options *ndo,
          break;
      case BGPTYPE_EXTD_COMMUNITIES:
          if (len % 8) {
          break;
      case BGPTYPE_EXTD_COMMUNITIES:
          if (len % 8) {
-            ND_PRINT((ndo, "invalid len"));
+            ND_PRINT("invalid len");
              break;
          }
              break;
          }
-        while (tlen>0) {
+        while (tlen != 0) {
              uint16_t extd_comm;
  
              ND_TCHECK_2(tptr);
              uint16_t extd_comm;
  
              ND_TCHECK_2(tptr);
-            extd_comm=EXTRACT_BE_U_2(tptr);
+            if (tlen < 2)
+                goto trunc;
+            extd_comm=GET_BE_U_2(tptr);
  
  
-            ND_PRINT((ndo, "\n\t    %s (0x%04x), Flags [%s]",
+            ND_PRINT("\n\t    %s (0x%04x), Flags [%s]",
                        tok2str(bgp_extd_comm_subtype_values,
                                "unknown extd community typecode",
                                extd_comm),
                        extd_comm,
                        tok2str(bgp_extd_comm_subtype_values,
                                "unknown extd community typecode",
                                extd_comm),
                        extd_comm,
-                      bittok2str(bgp_extd_comm_flag_values, "none", extd_comm)));
-
-            ND_TCHECK_6(tptr + 2);
-            switch(extd_comm) {
-            case BGP_EXT_COM_RT_0:
-            case BGP_EXT_COM_RO_0:
-            case BGP_EXT_COM_L2VPN_RT_0:
-                ND_PRINT((ndo, ": %u:%u (= %s)",
-                          EXTRACT_BE_U_2(tptr + 2),
-                          EXTRACT_BE_U_4(tptr + 4),
-                          ipaddr_string(ndo, tptr+4)));
-                break;
-            case BGP_EXT_COM_RT_1:
-            case BGP_EXT_COM_RO_1:
-            case BGP_EXT_COM_L2VPN_RT_1:
-            case BGP_EXT_COM_VRF_RT_IMP:
-                ND_PRINT((ndo, ": %s:%u",
-                          ipaddr_string(ndo, tptr+2),
-                          EXTRACT_BE_U_2(tptr + 6)));
-                break;
-            case BGP_EXT_COM_RT_2:
-            case BGP_EXT_COM_RO_2:
-                ND_PRINT((ndo, ": %s:%u",
-                          as_printf(ndo, astostr, sizeof(astostr),
-                          EXTRACT_BE_U_4(tptr + 2)), EXTRACT_BE_U_2(tptr + 6)));
-                break;
-            case BGP_EXT_COM_LINKBAND:
-                bw.i = EXTRACT_BE_U_4(tptr + 2);
-                ND_PRINT((ndo, ": bandwidth: %.3f Mbps",
-                          bw.f*8/1000000));
-                break;
-            case BGP_EXT_COM_VPN_ORIGIN:
-            case BGP_EXT_COM_VPN_ORIGIN2:
-            case BGP_EXT_COM_VPN_ORIGIN3:
-            case BGP_EXT_COM_VPN_ORIGIN4:
-            case BGP_EXT_COM_OSPF_RID:
-            case BGP_EXT_COM_OSPF_RID2:
-                ND_PRINT((ndo, "%s", ipaddr_string(ndo, tptr+2)));
-                break;
-            case BGP_EXT_COM_OSPF_RTYPE:
-            case BGP_EXT_COM_OSPF_RTYPE2:
-                ND_PRINT((ndo, ": area:%s, router-type:%s, metric-type:%s%s",
-                          ipaddr_string(ndo, tptr+2),
-                          tok2str(bgp_extd_comm_ospf_rtype_values,
-                                  "unknown (0x%02x)",
-                                  EXTRACT_U_1((tptr + 6))),
-                          (EXTRACT_U_1(tptr + 7) &  BGP_OSPF_RTYPE_METRIC_TYPE) ? "E2" : "",
-                          ((EXTRACT_U_1(tptr + 6) == BGP_OSPF_RTYPE_EXT) || (EXTRACT_U_1(tptr + 6) == BGP_OSPF_RTYPE_NSSA)) ? "E1" : ""));
-                break;
-            case BGP_EXT_COM_L2INFO:
-                ND_PRINT((ndo, ": %s Control Flags [0x%02x]:MTU %u",
-                          tok2str(l2vpn_encaps_values,
-                                  "unknown encaps",
-                                  EXTRACT_U_1((tptr + 2))),
-                          EXTRACT_U_1((tptr + 3)),
-                          EXTRACT_BE_U_2(tptr + 4)));
-                break;
-            case BGP_EXT_COM_SOURCE_AS:
-                ND_PRINT((ndo, ": AS %u", EXTRACT_BE_U_2(tptr + 2)));
-                break;
-            default:
-                ND_TCHECK_8(tptr);
-                print_unknown_data(ndo, tptr, "\n\t      ", 8);
-                break;
-            }
+                      bittok2str(bgp_extd_comm_flag_values, "none", extd_comm));
+
+            ND_TCHECK_8(tptr);
+            if (tlen < 8)
+                goto trunc;
+            ND_PRINT(": ");
+            bgp_extended_community_print(ndo, tptr);
              tlen -= 8;
              tptr += 8;
          }
              tlen -= 8;
              tptr += 8;
          }
@@ -2238,15 +2319,16 @@ bgp_attr_print(netdissect_options *ndo,
          uint8_t tunnel_type, flags;
  
          ND_TCHECK_5(tptr);
          uint8_t tunnel_type, flags;
  
          ND_TCHECK_5(tptr);
-        flags = EXTRACT_U_1(tptr);
-        tunnel_type = EXTRACT_U_1(tptr + 1);
-        tlen = len;
+        if (tlen < 5)
+            goto trunc;
+        flags = GET_U_1(tptr);
+        tunnel_type = GET_U_1(tptr + 1);
  
  
-        ND_PRINT((ndo, "\n\t    Tunnel-type %s (%u), Flags [%s], MPLS Label %u",
+        ND_PRINT("\n\t    Tunnel-type %s (%u), Flags [%s], MPLS Label %u",
                    tok2str(bgp_pmsi_tunnel_values, "Unknown", tunnel_type),
                    tunnel_type,
                    bittok2str(bgp_pmsi_flag_values, "none", flags),
                    tok2str(bgp_pmsi_tunnel_values, "Unknown", tunnel_type),
                    tunnel_type,
                    bittok2str(bgp_pmsi_flag_values, "none", flags),
-                  EXTRACT_BE_U_3(tptr + 2)>>4));
+                  GET_BE_U_3(tptr + 2)>>4);
  
          tptr +=5;
          tlen -= 5;
  
          tptr +=5;
          tlen -= 5;
@@ -2254,35 +2336,30 @@ bgp_attr_print(netdissect_options *ndo,
          switch (tunnel_type) {
          case BGP_PMSI_TUNNEL_PIM_SM: /* fall through */
          case BGP_PMSI_TUNNEL_PIM_BIDIR:
          switch (tunnel_type) {
          case BGP_PMSI_TUNNEL_PIM_SM: /* fall through */
          case BGP_PMSI_TUNNEL_PIM_BIDIR:
-            ND_TCHECK_8(tptr);
-            ND_PRINT((ndo, "\n\t      Sender %s, P-Group %s",
-                      ipaddr_string(ndo, tptr),
-                      ipaddr_string(ndo, tptr+4)));
+            ND_PRINT("\n\t      Sender %s, P-Group %s",
+                      GET_IPADDR_STRING(tptr),
+                      GET_IPADDR_STRING(tptr+4));
              break;
  
          case BGP_PMSI_TUNNEL_PIM_SSM:
              break;
  
          case BGP_PMSI_TUNNEL_PIM_SSM:
-            ND_TCHECK_8(tptr);
-            ND_PRINT((ndo, "\n\t      Root-Node %s, P-Group %s",
-                      ipaddr_string(ndo, tptr),
-                      ipaddr_string(ndo, tptr+4)));
+            ND_PRINT("\n\t      Root-Node %s, P-Group %s",
+                      GET_IPADDR_STRING(tptr),
+                      GET_IPADDR_STRING(tptr+4));
              break;
          case BGP_PMSI_TUNNEL_INGRESS:
              break;
          case BGP_PMSI_TUNNEL_INGRESS:
-            ND_TCHECK_4(tptr);
-            ND_PRINT((ndo, "\n\t      Tunnel-Endpoint %s",
-                      ipaddr_string(ndo, tptr)));
+            ND_PRINT("\n\t      Tunnel-Endpoint %s",
+                      GET_IPADDR_STRING(tptr));
              break;
          case BGP_PMSI_TUNNEL_LDP_P2MP: /* fall through */
          case BGP_PMSI_TUNNEL_LDP_MP2MP:
              break;
          case BGP_PMSI_TUNNEL_LDP_P2MP: /* fall through */
          case BGP_PMSI_TUNNEL_LDP_MP2MP:
-            ND_TCHECK_8(tptr);
-            ND_PRINT((ndo, "\n\t      Root-Node %s, LSP-ID 0x%08x",
-                      ipaddr_string(ndo, tptr),
-                      EXTRACT_BE_U_4(tptr + 4)));
+            ND_PRINT("\n\t      Root-Node %s, LSP-ID 0x%08x",
+                      GET_IPADDR_STRING(tptr),
+                      GET_BE_U_4(tptr + 4));
              break;
          case BGP_PMSI_TUNNEL_RSVP_P2MP:
              break;
          case BGP_PMSI_TUNNEL_RSVP_P2MP:
-            ND_TCHECK_8(tptr);
-            ND_PRINT((ndo, "\n\t      Extended-Tunnel-ID %s, P2MP-ID 0x%08x",
-                      ipaddr_string(ndo, tptr),
-                      EXTRACT_BE_U_4(tptr + 4)));
+            ND_PRINT("\n\t      Extended-Tunnel-ID %s, P2MP-ID 0x%08x",
+                      GET_IPADDR_STRING(tptr),
+                      GET_BE_U_4(tptr + 4));
              break;
          default:
              if (ndo->ndo_vflag <= 1) {
              break;
          default:
              if (ndo->ndo_vflag <= 1) {
@@ -2296,20 +2373,15 @@ bgp_attr_print(netdissect_options *ndo,
          uint8_t type;
          uint16_t length;
  
          uint8_t type;
          uint16_t length;
  
-        tlen = len;
-
          while (tlen >= 3) {
          while (tlen >= 3) {
-
-            ND_TCHECK_3(tptr);
-
-            type = EXTRACT_U_1(tptr);
-            length = EXTRACT_BE_U_2(tptr + 1);
+            type = GET_U_1(tptr);
+            length = GET_BE_U_2(tptr + 1);
              tptr += 3;
              tlen -= 3;
  
              tptr += 3;
              tlen -= 3;
  
-            ND_PRINT((ndo, "\n\t    %s TLV (%u), length %u",
+            ND_PRINT("\n\t    %s TLV (%u), length %u",
                        tok2str(bgp_aigp_values, "Unknown", type),
                        tok2str(bgp_aigp_values, "Unknown", type),
-                      type, length));
+                      type, length);
  
              if (length < 3)
                  goto trunc;
  
              if (length < 3)
                  goto trunc;
@@ -2318,15 +2390,16 @@ bgp_attr_print(netdissect_options *ndo,
              /*
               * Check if we can read the TLV data.
               */
              /*
               * Check if we can read the TLV data.
               */
-            ND_TCHECK_LEN(tptr + 3, length);
+            if (tlen < length)
+                goto trunc;
  
              switch (type) {
  
              case BGP_AIGP_TLV:
                  if (length < 8)
                      goto trunc;
  
              switch (type) {
  
              case BGP_AIGP_TLV:
                  if (length < 8)
                      goto trunc;
-                ND_PRINT((ndo, ", metric %" PRIu64,
-                          EXTRACT_BE_U_8(tptr)));
+                ND_PRINT(", metric %" PRIu64,
+                          GET_BE_U_8(tptr));
                  break;
  
              default:
                  break;
  
              default:
@@ -2344,8 +2417,8 @@ bgp_attr_print(netdissect_options *ndo,
          ND_TCHECK_4(tptr);
          if (len < 4)
              goto trunc;
          ND_TCHECK_4(tptr);
          if (len < 4)
              goto trunc;
-        ND_PRINT((ndo, "\n\t    Origin AS: %s",
-                  as_printf(ndo, astostr, sizeof(astostr), EXTRACT_BE_U_4(tptr))));
+        ND_PRINT("\n\t    Origin AS: %s",
+                  as_printf(ndo, astostr, sizeof(astostr), GET_BE_U_4(tptr)));
          tptr += 4;
          len -= 4;
  
          tptr += 4;
          len -= 4;
  
@@ -2353,39 +2426,61 @@ bgp_attr_print(netdissect_options *ndo,
              u_int aflags, alenlen, alen;
  
              ND_TCHECK_2(tptr);
              u_int aflags, alenlen, alen;
  
              ND_TCHECK_2(tptr);
-            if (len < 2)
-                goto trunc;
-            aflags = EXTRACT_U_1(tptr);
-            atype = EXTRACT_U_1(tptr + 1);
+            if (len < 2) {
+                ND_PRINT(" [path attr too short]");
+                tptr += len;
+                break;
+            }
+            aflags = GET_U_1(tptr);
+            atype = GET_U_1(tptr + 1);
              tptr += 2;
              len -= 2;
              alenlen = bgp_attr_lenlen(aflags, tptr);
              ND_TCHECK_LEN(tptr, alenlen);
              tptr += 2;
              len -= 2;
              alenlen = bgp_attr_lenlen(aflags, tptr);
              ND_TCHECK_LEN(tptr, alenlen);
-            if (len < alenlen)
-                goto trunc;
+            if (len < alenlen) {
+                ND_PRINT(" [path attr too short]");
+                tptr += len;
+                break;
+            }
              alen = bgp_attr_len(aflags, tptr);
              tptr += alenlen;
              len -= alenlen;
  
              alen = bgp_attr_len(aflags, tptr);
              tptr += alenlen;
              len -= alenlen;
  
-            ND_PRINT((ndo, "\n\t      %s (%u), length: %u",
+            ND_PRINT("\n\t      %s (%u), length: %u",
                        tok2str(bgp_attr_values,
                                "Unknown Attribute", atype),
                        atype,
                        tok2str(bgp_attr_values,
                                "Unknown Attribute", atype),
                        atype,
-                      alen));
+                      alen);
  
              if (aflags) {
  
              if (aflags) {
-                ND_PRINT((ndo, ", Flags [%s%s%s%s",
+                ND_PRINT(", Flags [%s%s%s%s",
                            aflags & 0x80 ? "O" : "",
                            aflags & 0x40 ? "T" : "",
                            aflags & 0x20 ? "P" : "",
                            aflags & 0x80 ? "O" : "",
                            aflags & 0x40 ? "T" : "",
                            aflags & 0x20 ? "P" : "",
-                          aflags & 0x10 ? "E" : ""));
+                          aflags & 0x10 ? "E" : "");
                  if (aflags & 0xf)
                  if (aflags & 0xf)
-                    ND_PRINT((ndo, "+%x", aflags & 0xf));
-                ND_PRINT((ndo, "]: "));
+                    ND_PRINT("+%x", aflags & 0xf);
+                ND_PRINT("]");
              }
              }
-            /* FIXME check for recursion */
-            if (!bgp_attr_print(ndo, atype, tptr, alen))
-            return 0;
+            ND_PRINT(": ");
+            if (len < alen) {
+                ND_PRINT(" [path attr too short]");
+                tptr += len;
+                break;
+            }
+            /*
+             * The protocol encoding per se allows ATTR_SET to be nested
+             * as many times as the message can accommodate. This printer
+             * used to be able to recurse into ATTR_SET contents until the
+             * stack exhaustion, but now there is a limit on that (if live
+             * protocol exchange goes that many levels deep, something is
+             * probably wrong anyway). Feel free to refine this value if
+             * you can find the spec with respective normative text.
+             */
+            if (attr_set_level == 10)
+                ND_PRINT("(too many nested levels, not recursing)");
+            else if (!bgp_attr_print(ndo, atype, tptr, alen, attr_set_level + 1))
+                return 0;
              tptr += alen;
              len -= alen;
          }
              tptr += alen;
              len -= alen;
          }
@@ -2393,28 +2488,32 @@ bgp_attr_print(netdissect_options *ndo,
  
      case BGPTYPE_LARGE_COMMUNITY:
          if (len == 0 || len % 12) {
  
      case BGPTYPE_LARGE_COMMUNITY:
          if (len == 0 || len % 12) {
-            ND_PRINT((ndo, "invalid len"));
+            ND_PRINT("invalid len");
              break;
          }
              break;
          }
-        ND_PRINT((ndo, "\n\t    "));
-        while (len > 0) {
-            ND_TCHECK_LEN(tptr, 12);
-            ND_PRINT((ndo, "%u:%u:%u%s",
-                      EXTRACT_BE_U_4(tptr),
-                      EXTRACT_BE_U_4(tptr + 4),
-                      EXTRACT_BE_U_4(tptr + 8),
-                      (len > 12) ? ", " : ""));
+        ND_PRINT("\n\t    ");
+        while (len != 0) {
+            ND_PRINT("%u:%u:%u%s",
+                      GET_BE_U_4(tptr),
+                      GET_BE_U_4(tptr + 4),
+                      GET_BE_U_4(tptr + 8),
+                      (len > 12) ? ", " : "");
              tptr += 12;
              tptr += 12;
+            /*
+             * len will always be a multiple of 12, as per the above,
+             * so this will never underflow.
+             */
              len -= 12;
          }
          break;
      default:
          ND_TCHECK_LEN(pptr, len);
              len -= 12;
          }
          break;
      default:
          ND_TCHECK_LEN(pptr, len);
-        ND_PRINT((ndo, "\n\t    no Attribute %u decoder", atype)); /* we have no decoder for the attribute */
+        ND_PRINT("\n\t    no Attribute %u decoder", atype); /* we have no decoder for the attribute */
          if (ndo->ndo_vflag <= 1)
              print_unknown_data(ndo, pptr, "\n\t    ", len);
          break;
      }
          if (ndo->ndo_vflag <= 1)
              print_unknown_data(ndo, pptr, "\n\t    ", len);
          break;
      }
+done:
      if (ndo->ndo_vflag > 1 && len) { /* omit zero length attributes*/
          ND_TCHECK_LEN(pptr, len);
          print_unknown_data(ndo, pptr, "\n\t    ", len);
      if (ndo->ndo_vflag > 1 && len) { /* omit zero length attributes*/
          ND_TCHECK_LEN(pptr, len);
          print_unknown_data(ndo, pptr, "\n\t    ", len);
@@ -2429,91 +2528,124 @@ static void
  bgp_capabilities_print(netdissect_options *ndo,
                         const u_char *opt, u_int caps_len)
  {
  bgp_capabilities_print(netdissect_options *ndo,
                         const u_char *opt, u_int caps_len)
  {
+    /* allocate space for the largest possible string */
+    char astostr[AS_STR_SIZE];
      u_int cap_type, cap_len, tcap_len, cap_offset;
      u_int i = 0;
  
      while (i < caps_len) {
          ND_TCHECK_LEN(opt + i, BGP_CAP_HEADER_SIZE);
      u_int cap_type, cap_len, tcap_len, cap_offset;
      u_int i = 0;
  
      while (i < caps_len) {
          ND_TCHECK_LEN(opt + i, BGP_CAP_HEADER_SIZE);
-        cap_type=EXTRACT_U_1(opt + i);
-        cap_len=EXTRACT_U_1(opt + i + 1);
-        tcap_len=cap_len;
-        ND_PRINT((ndo, "\n\t      %s (%u), length: %u",
+        cap_type=GET_U_1(opt + i);
+        cap_len=GET_U_1(opt + i + 1);
+        ND_PRINT("\n\t      %s (%u), length: %u",
                    tok2str(bgp_capcode_values, "Unknown", cap_type),
                    cap_type,
                    tok2str(bgp_capcode_values, "Unknown", cap_type),
                    cap_type,
-                  cap_len));
+                  cap_len);
          ND_TCHECK_LEN(opt + 2 + i, cap_len);
          switch (cap_type) {
          case BGP_CAPCODE_MP:
          ND_TCHECK_LEN(opt + 2 + i, cap_len);
          switch (cap_type) {
          case BGP_CAPCODE_MP:
-            ND_PRINT((ndo, "\n\t\tAFI %s (%u), SAFI %s (%u)",
-               tok2str(af_values, "Unknown", EXTRACT_BE_U_2(opt + i + 2)),
-               EXTRACT_BE_U_2(opt + i + 2),
-               tok2str(bgp_safi_values, "Unknown", EXTRACT_U_1(opt + i + 5)),
-               EXTRACT_U_1(opt + i + 5)));
+            /* AFI (16 bits), Reserved (8 bits), SAFI (8 bits) */
+            if (cap_len < 4) {
+                ND_PRINT(" (too short, < 4)");
+                return;
+            }
+            ND_PRINT("\n\t\tAFI %s (%u), SAFI %s (%u)",
+               tok2str(af_values, "Unknown", GET_BE_U_2(opt + i + 2)),
+               GET_BE_U_2(opt + i + 2),
+               tok2str(bgp_safi_values, "Unknown", GET_U_1(opt + i + 5)),
+               GET_U_1(opt + i + 5));
+            break;
+        case BGP_CAPCODE_ML:
+            cap_offset = 2;
+            tcap_len = cap_len;
+            while (tcap_len >= 4) {
+                ND_PRINT( "\n\t\tAFI %s (%u), SAFI %s (%u), Count: %u",
+                       tok2str(af_values, "Unknown",
+                                  GET_BE_U_2(opt + i + cap_offset)),
+                       GET_BE_U_2(opt + i + cap_offset),
+                       tok2str(bgp_safi_values, "Unknown",
+                                  GET_U_1(opt + i + cap_offset + 2)),
+                       GET_U_1(opt + i + cap_offset + 2),
+                       GET_U_1(opt + i + cap_offset + 3));
+                tcap_len -= 4;
+                cap_offset += 4;
+            }
              break;
          case BGP_CAPCODE_RESTART:
              break;
          case BGP_CAPCODE_RESTART:
-            ND_PRINT((ndo, "\n\t\tRestart Flags: [%s], Restart Time %us",
-                      ((EXTRACT_U_1(opt + i + 2))&0x80) ? "R" : "none",
-                      EXTRACT_BE_U_2(opt + i + 2)&0xfff));
+            /* Restart Flags (4 bits), Restart Time in seconds (12 bits) */
+            if (cap_len < 2) {
+                ND_PRINT(" (too short, < 2)");
+                return;
+            }
+            tcap_len=cap_len;
+            ND_PRINT("\n\t\tRestart Flags: [%s], Restart Time %us",
+                      ((GET_U_1(opt + i + 2))&0x80) ? "R" : "none",
+                      GET_BE_U_2(opt + i + 2)&0xfff);
              tcap_len-=2;
              cap_offset=4;
              while(tcap_len>=4) {
              tcap_len-=2;
              cap_offset=4;
              while(tcap_len>=4) {
-                ND_PRINT((ndo, "\n\t\t  AFI %s (%u), SAFI %s (%u), Forwarding state preserved: %s",
+                ND_PRINT("\n\t\t  AFI %s (%u), SAFI %s (%u), Forwarding state preserved: %s",
                            tok2str(af_values,"Unknown",
                            tok2str(af_values,"Unknown",
-                                  EXTRACT_BE_U_2(opt + i + cap_offset)),
-                          EXTRACT_BE_U_2(opt + i + cap_offset),
+                                  GET_BE_U_2(opt + i + cap_offset)),
+                          GET_BE_U_2(opt + i + cap_offset),
                            tok2str(bgp_safi_values,"Unknown",
                            tok2str(bgp_safi_values,"Unknown",
-                                  EXTRACT_U_1(opt + i + cap_offset + 2)),
-                          EXTRACT_U_1(opt + (i + cap_offset + 2)),
-                          ((EXTRACT_U_1(opt + (i + cap_offset + 3)))&0x80) ? "yes" : "no" ));
+                                  GET_U_1(opt + i + cap_offset + 2)),
+                          GET_U_1(opt + (i + cap_offset + 2)),
+                          ((GET_U_1(opt + (i + cap_offset + 3)))&0x80) ? "yes" : "no" );
                  tcap_len -= 4;
                  cap_offset += 4;
              }
              break;
          case BGP_CAPCODE_RR:
                  tcap_len -= 4;
                  cap_offset += 4;
              }
              break;
          case BGP_CAPCODE_RR:
+        case BGP_CAPCODE_LLGR:
          case BGP_CAPCODE_RR_CISCO:
          case BGP_CAPCODE_RR_CISCO:
+        case BGP_CAPCODE_EXT_MSG:
+        case BGP_CAPCODE_ENH_RR:
              break;
          case BGP_CAPCODE_AS_NEW:
              break;
          case BGP_CAPCODE_AS_NEW:
-
              /*
               * Extract the 4 byte AS number encoded.
               */
              /*
               * Extract the 4 byte AS number encoded.
               */
-            if (cap_len == 4) {
-            ND_PRINT((ndo, "\n\t\t 4 Byte AS %s",
-                      as_printf(ndo, astostr, sizeof(astostr),
-                      EXTRACT_BE_U_4(opt + i + 2))));
+            if (cap_len < 4) {
+                ND_PRINT(" (too short, < 4)");
+                return;
              }
              }
+            ND_PRINT("\n\t\t 4 Byte AS %s",
+                      as_printf(ndo, astostr, sizeof(astostr),
+                      GET_BE_U_4(opt + i + 2)));
              break;
          case BGP_CAPCODE_ADD_PATH:
              break;
          case BGP_CAPCODE_ADD_PATH:
-            cap_offset=2;
-            if (tcap_len == 0) {
-                ND_PRINT((ndo, " (bogus)")); /* length */
+            if (cap_len == 0) {
+                ND_PRINT(" (bogus)"); /* length */
                  break;
              }
                  break;
              }
-            while (tcap_len > 0) {
+            tcap_len=cap_len;
+            cap_offset=2;
+            while (tcap_len != 0) {
                  if (tcap_len < 4) {
                  if (tcap_len < 4) {
-                    ND_PRINT((ndo, "\n\t\t(invalid)"));
+                    nd_print_invalid(ndo);
                      break;
                  }
                      break;
                  }
-                ND_PRINT((ndo, "\n\t\tAFI %s (%u), SAFI %s (%u), Send/Receive: %s",
-                          tok2str(af_values,"Unknown",EXTRACT_BE_U_2(opt + i + cap_offset)),
-                          EXTRACT_BE_U_2(opt + i + cap_offset),
-                          tok2str(bgp_safi_values,"Unknown",EXTRACT_U_1(opt + i + cap_offset + 2)),
-                          EXTRACT_U_1(opt + (i + cap_offset + 2)),
-                          tok2str(bgp_add_path_recvsend,"Bogus (0x%02x)",EXTRACT_U_1(opt + i + cap_offset + 3))
-                ));
+                ND_PRINT("\n\t\tAFI %s (%u), SAFI %s (%u), Send/Receive: %s",
+                          tok2str(af_values,"Unknown",GET_BE_U_2(opt + i + cap_offset)),
+                          GET_BE_U_2(opt + i + cap_offset),
+                          tok2str(bgp_safi_values,"Unknown",GET_U_1(opt + i + cap_offset + 2)),
+                          GET_U_1(opt + (i + cap_offset + 2)),
+                          tok2str(bgp_add_path_recvsend,"Bogus (0x%02x)",GET_U_1(opt + i + cap_offset + 3))
+                );
                  tcap_len -= 4;
                  cap_offset += 4;
              }
              break;
          default:
                  tcap_len -= 4;
                  cap_offset += 4;
              }
              break;
          default:
-            ND_PRINT((ndo, "\n\t\tno decoder for Capability %u",
-                      cap_type));
+            ND_PRINT("\n\t\tno decoder for Capability %u",
+                      cap_type);
              if (ndo->ndo_vflag <= 1)
                  print_unknown_data(ndo, opt + i + 2, "\n\t\t",
                                     cap_len);
              break;
          }
              if (ndo->ndo_vflag <= 1)
                  print_unknown_data(ndo, opt + i + 2, "\n\t\t",
                                     cap_len);
              break;
          }
-        if (ndo->ndo_vflag > 1 && cap_len > 0) {
+        if (ndo->ndo_vflag > 1 && cap_len != 0) {
              print_unknown_data(ndo, opt + i + 2, "\n\t\t", cap_len);
          }
          i += BGP_CAP_HEADER_SIZE + cap_len;
              print_unknown_data(ndo, opt + i + 2, "\n\t\t", cap_len);
          }
          i += BGP_CAP_HEADER_SIZE + cap_len;
@@ -2521,18 +2653,24 @@ bgp_capabilities_print(netdissect_options *ndo,
      return;
  
  trunc:
      return;
  
  trunc:
-    ND_PRINT((ndo, "[|BGP]"));
+    nd_print_trunc(ndo);
  }
  
  static void
  bgp_open_print(netdissect_options *ndo,
                 const u_char *dat, u_int length)
  {
  }
  
  static void
  bgp_open_print(netdissect_options *ndo,
                 const u_char *dat, u_int length)
  {
+    /* allocate space for the largest possible string */
+    char astostr[AS_STR_SIZE];
      const struct bgp_open *bgp_open_header;
      u_int optslen;
      const struct bgp_open *bgp_open_header;
      u_int optslen;
+    uint8_t opsttype;
      const struct bgp_opt *bgpopt;
      const u_char *opt;
      u_int i;
      const struct bgp_opt *bgpopt;
      const u_char *opt;
      u_int i;
+    uint8_t extended_opt_params = 0;
+    u_int open_size = BGP_OPEN_SIZE;
+    u_int opt_size = BGP_OPT_SIZE;
  
      ND_TCHECK_LEN(dat, BGP_OPEN_SIZE);
      if (length < BGP_OPEN_SIZE)
  
      ND_TCHECK_LEN(dat, BGP_OPEN_SIZE);
      if (length < BGP_OPEN_SIZE)
@@ -2540,79 +2678,87 @@ bgp_open_print(netdissect_options *ndo,
  
      bgp_open_header = (const struct bgp_open *)dat;
  
  
      bgp_open_header = (const struct bgp_open *)dat;
  
-    ND_PRINT((ndo, "\n\t  Version %u, ",
-        EXTRACT_U_1(bgp_open_header->bgpo_version)));
-    ND_PRINT((ndo, "my AS %s, ",
-        as_printf(ndo, astostr, sizeof(astostr), EXTRACT_BE_U_2(bgp_open_header->bgpo_myas))));
-    ND_PRINT((ndo, "Holdtime %us, ",
-        EXTRACT_BE_U_2(bgp_open_header->bgpo_holdtime)));
-    ND_PRINT((ndo, "ID %s", ipaddr_string(ndo, &bgp_open_header->bgpo_id)));
-    optslen = EXTRACT_U_1(bgp_open_header->bgpo_optlen);
-    ND_PRINT((ndo, "\n\t  Optional parameters, length: %u", optslen));
+    ND_PRINT("\n\t  Version %u, ",
+        GET_U_1(bgp_open_header->bgpo_version));
+    ND_PRINT("my AS %s, ",
+        as_printf(ndo, astostr, sizeof(astostr), GET_BE_U_2(bgp_open_header->bgpo_myas)));
+    ND_PRINT("Holdtime %us, ",
+        GET_BE_U_2(bgp_open_header->bgpo_holdtime));
+    ND_PRINT("ID %s", GET_IPADDR_STRING(bgp_open_header->bgpo_id));
+    optslen = GET_U_1(bgp_open_header->bgpo_optlen);
+    opsttype = GET_U_1(bgp_open_header->bgpo_opttype);
+    if (opsttype == BGP_OPEN_NON_EXT_OPT_TYPE_EXTENDED_LENGTH) {
+        optslen = GET_BE_U_2(bgp_open_header->bgpo_optlen_extended);
+        extended_opt_params = 1;
+        open_size += 3;
+        opt_size += 1;
+    }
+    ND_PRINT("\n\t  Optional parameters%s, length: %u",
+             extended_opt_params ? " (Extended)" : "", optslen);
  
  
-    opt = dat + BGP_OPEN_SIZE;
-    length -= BGP_OPEN_SIZE;
+    opt = dat + open_size;
+    length -= open_size;
  
      i = 0;
      while (i < optslen) {
  
      i = 0;
      while (i < optslen) {
-        uint8_t opt_type, opt_len;
+        uint8_t opt_type;
+        uint16_t opt_len;
  
  
-        ND_TCHECK_LEN(opt + i, BGP_OPT_SIZE);
-        if (length < BGP_OPT_SIZE + i)
+        ND_TCHECK_LEN(opt + i, opt_size);
+        if (length < opt_size + i)
              goto trunc;
          bgpopt = (const struct bgp_opt *)(opt + i);
              goto trunc;
          bgpopt = (const struct bgp_opt *)(opt + i);
-        opt_type = EXTRACT_U_1(bgpopt->bgpopt_type);
-        opt_len = EXTRACT_U_1(bgpopt->bgpopt_len);
-        if (BGP_OPT_SIZE + i + opt_len > optslen) {
-            ND_PRINT((ndo, "\n\t     Option %u, length: %u, goes past the end of the options",
-                      opt_type, opt_len));
+        opt_type = GET_U_1(bgpopt->bgpopt_type);
+        opt_len = extended_opt_params ? GET_BE_U_2(bgpopt->bgpopt_len)
+                                      : GET_U_1(bgpopt->bgpopt_len);
+        if (opt_size + i + opt_len > optslen) {
+            ND_PRINT("\n\t     Option %u, length: %u, goes past the end of the options",
+                      opt_type, opt_len);
              break;
          }
  
              break;
          }
  
-        ND_PRINT((ndo, "\n\t    Option %s (%u), length: %u",
+        ND_PRINT("\n\t    Option %s (%u), length: %u",
                    tok2str(bgp_opt_values,"Unknown",opt_type),
                    opt_type,
                    tok2str(bgp_opt_values,"Unknown",opt_type),
                    opt_type,
-                  opt_len));
+                  opt_len);
  
          /* now let's decode the options we know*/
          switch(opt_type) {
  
          case BGP_OPT_CAP:
  
          /* now let's decode the options we know*/
          switch(opt_type) {
  
          case BGP_OPT_CAP:
-            bgp_capabilities_print(ndo, opt + BGP_OPT_SIZE + i,
+            bgp_capabilities_print(ndo, opt + opt_size + i,
                                     opt_len);
              break;
  
          case BGP_OPT_AUTH:
          default:
                                     opt_len);
              break;
  
          case BGP_OPT_AUTH:
          default:
-               ND_PRINT((ndo, "\n\t      no decoder for option %u",
-               opt_type));
+               ND_PRINT("\n\t      no decoder for option %u",
+               opt_type);
                 break;
          }
                 break;
          }
-        i += BGP_OPT_SIZE + opt_len;
+        i += opt_size + opt_len;
      }
      return;
  trunc:
      }
      return;
  trunc:
-    ND_PRINT((ndo, "[|BGP]"));
+    nd_print_trunc(ndo);
  }
  
  static void
  bgp_update_print(netdissect_options *ndo,
  }
  
  static void
  bgp_update_print(netdissect_options *ndo,
-                 const u_char *dat, int length)
+                 const u_char *dat, u_int length)
  {
  {
-    const struct bgp *bgp_header;
      const u_char *p;
      const u_char *p;
-    int withdrawn_routes_len;
+    u_int withdrawn_routes_len;
      char buf[MAXHOSTNAMELEN + 100];
      int wpfx;
      char buf[MAXHOSTNAMELEN + 100];
      int wpfx;
-    int len;
+    u_int len;
      int i;
      int add_path;
      int i;
      int add_path;
-    int path_id;
+    u_int path_id = 0;
  
      ND_TCHECK_LEN(dat, BGP_SIZE);
      if (length < BGP_SIZE)
          goto trunc;
  
      ND_TCHECK_LEN(dat, BGP_SIZE);
      if (length < BGP_SIZE)
          goto trunc;
-    bgp_header = (const struct bgp *)dat;
      p = dat + BGP_SIZE;
      length -= BGP_SIZE;
  
      p = dat + BGP_SIZE;
      length -= BGP_SIZE;
  
@@ -2620,7 +2766,7 @@ bgp_update_print(netdissect_options *ndo,
      ND_TCHECK_2(p);
      if (length < 2)
          goto trunc;
      ND_TCHECK_2(p);
      if (length < 2)
          goto trunc;
-    withdrawn_routes_len = EXTRACT_BE_U_2(p);
+    withdrawn_routes_len = GET_BE_U_2(p);
      p += 2;
      length -= 2;
      if (withdrawn_routes_len > 1) {
      p += 2;
      length -= 2;
      if (withdrawn_routes_len > 1) {
@@ -2632,27 +2778,30 @@ bgp_update_print(netdissect_options *ndo,
          ND_TCHECK_LEN(p, withdrawn_routes_len);
          if (length < withdrawn_routes_len)
              goto trunc;
          ND_TCHECK_LEN(p, withdrawn_routes_len);
          if (length < withdrawn_routes_len)
              goto trunc;
-        ND_PRINT((ndo, "\n\t  Withdrawn routes:"));
-        add_path = check_add_path(p, withdrawn_routes_len, 32);
-        while (withdrawn_routes_len > 0) {
+        ND_PRINT("\n\t  Withdrawn routes:");
+        add_path = check_add_path(ndo, p, withdrawn_routes_len, 32);
+        while (withdrawn_routes_len != 0) {
              if (add_path) {
              if (add_path) {
-                path_id = EXTRACT_BE_U_4(p);
+                if (withdrawn_routes_len < 4) {
+                    p += withdrawn_routes_len;
+                    length -= withdrawn_routes_len;
+                    break;
+                }
+                path_id = GET_BE_U_4(p);
                  p += 4;
                  length -= 4;
                  withdrawn_routes_len -= 4;
              }
              wpfx = decode_prefix4(ndo, p, withdrawn_routes_len, buf, sizeof(buf));
              if (wpfx == -1) {
                  p += 4;
                  length -= 4;
                  withdrawn_routes_len -= 4;
              }
              wpfx = decode_prefix4(ndo, p, withdrawn_routes_len, buf, sizeof(buf));
              if (wpfx == -1) {
-                ND_PRINT((ndo, "\n\t    (illegal prefix length)"));
+                ND_PRINT("\n\t    (illegal prefix length)");
                  break;
              } else if (wpfx == -2)
                  break;
              } else if (wpfx == -2)
-                goto trunc;
-            else if (wpfx == -3)
                  goto trunc; /* bytes left, but not enough */
              else {
                  goto trunc; /* bytes left, but not enough */
              else {
-                ND_PRINT((ndo, "\n\t    %s", buf));
+                ND_PRINT("\n\t    %s", buf);
                  if (add_path) {
                  if (add_path) {
-                    ND_PRINT((ndo, "   Path Id: %d", path_id));
+                    ND_PRINT("   Path Id: %u", path_id);
                  }
                  p += wpfx;
                  length -= wpfx;
                  }
                  p += wpfx;
                  length -= wpfx;
@@ -2660,6 +2809,9 @@ bgp_update_print(netdissect_options *ndo,
              }
          }
      } else {
              }
          }
      } else {
+        ND_TCHECK_LEN(p, withdrawn_routes_len);
+        if (length < withdrawn_routes_len)
+            goto trunc;
          p += withdrawn_routes_len;
          length -= withdrawn_routes_len;
      }
          p += withdrawn_routes_len;
          length -= withdrawn_routes_len;
      }
@@ -2667,62 +2819,78 @@ bgp_update_print(netdissect_options *ndo,
      ND_TCHECK_2(p);
      if (length < 2)
          goto trunc;
      ND_TCHECK_2(p);
      if (length < 2)
          goto trunc;
-    len = EXTRACT_BE_U_2(p);
+    len = GET_BE_U_2(p);
      p += 2;
      length -= 2;
  
      if (withdrawn_routes_len == 0 && len == 0 && length == 0) {
          /* No withdrawn routes, no path attributes, no NLRI */
      p += 2;
      length -= 2;
  
      if (withdrawn_routes_len == 0 && len == 0 && length == 0) {
          /* No withdrawn routes, no path attributes, no NLRI */
-        ND_PRINT((ndo, "\n\t  End-of-Rib Marker (empty NLRI)"));
+        ND_PRINT("\n\t  End-of-Rib Marker (empty NLRI)");
          return;
      }
  
      if (len) {
          return;
      }
  
      if (len) {
+        /* Make sure the path attributes don't go past the end of the packet */
+        if (length < len)
+            goto trunc;
          /* do something more useful!*/
          while (len) {
          /* do something more useful!*/
          while (len) {
-            int aflags, atype, alenlen, alen;
+            uint8_t aflags, atype, alenlen;
+            uint16_t alen;
  
              ND_TCHECK_2(p);
  
              ND_TCHECK_2(p);
-            if (len < 2)
-                goto trunc;
              if (length < 2)
                  goto trunc;
              if (length < 2)
                  goto trunc;
-            aflags = EXTRACT_U_1(p);
-            atype = EXTRACT_U_1(p + 1);
+            if (len < 2) {
+                ND_PRINT("\n\t  [path attrs too short]");
+                p += len;
+                length -= len;
+                break;
+            }
+            aflags = GET_U_1(p);
+            atype = GET_U_1(p + 1);
              p += 2;
              len -= 2;
              length -= 2;
              alenlen = bgp_attr_lenlen(aflags, p);
              ND_TCHECK_LEN(p, alenlen);
              p += 2;
              len -= 2;
              length -= 2;
              alenlen = bgp_attr_lenlen(aflags, p);
              ND_TCHECK_LEN(p, alenlen);
-            if (len < alenlen)
-                goto trunc;
              if (length < alenlen)
                  goto trunc;
              if (length < alenlen)
                  goto trunc;
+            if (len < alenlen) {
+                ND_PRINT("\n\t  [path attrs too short]");
+                p += len;
+                length -= len;
+                break;
+            }
              alen = bgp_attr_len(aflags, p);
              p += alenlen;
              len -= alenlen;
              length -= alenlen;
  
              alen = bgp_attr_len(aflags, p);
              p += alenlen;
              len -= alenlen;
              length -= alenlen;
  
-            ND_PRINT((ndo, "\n\t  %s (%u), length: %u",
+            ND_PRINT("\n\t  %s (%u), length: %u",
                        tok2str(bgp_attr_values, "Unknown Attribute", atype),
                        atype,
                        tok2str(bgp_attr_values, "Unknown Attribute", atype),
                        atype,
-                      alen));
+                      alen);
  
              if (aflags) {
  
              if (aflags) {
-                ND_PRINT((ndo, ", Flags [%s%s%s%s",
+                ND_PRINT(", Flags [%s%s%s%s",
                            aflags & 0x80 ? "O" : "",
                            aflags & 0x40 ? "T" : "",
                            aflags & 0x20 ? "P" : "",
                            aflags & 0x80 ? "O" : "",
                            aflags & 0x40 ? "T" : "",
                            aflags & 0x20 ? "P" : "",
-                          aflags & 0x10 ? "E" : ""));
+                          aflags & 0x10 ? "E" : "");
                  if (aflags & 0xf)
                  if (aflags & 0xf)
-                    ND_PRINT((ndo, "+%x", aflags & 0xf));
-                ND_PRINT((ndo, "]: "));
+                    ND_PRINT("+%x", aflags & 0xf);
+                ND_PRINT("]: ");
+            }
+            if (len < alen) {
+                ND_PRINT(" [path attrs too short]");
+                p += len;
+                length -= len;
+                break;
              }
              }
-            if (len < alen)
-                goto trunc;
              if (length < alen)
                  goto trunc;
              if (length < alen)
                  goto trunc;
-            if (!bgp_attr_print(ndo, atype, p, alen))
+            if (!bgp_attr_print(ndo, atype, p, alen, 0))
                  goto trunc;
              p += alen;
              len -= alen;
                  goto trunc;
              p += alen;
              len -= alen;
@@ -2731,26 +2899,27 @@ bgp_update_print(netdissect_options *ndo,
      }
  
      if (length) {
      }
  
      if (length) {
-        add_path = check_add_path(p, length, 32);
-        ND_PRINT((ndo, "\n\t  Updated routes:"));
-        while (length > 0) {
+        add_path = check_add_path(ndo, p, length, 32);
+        ND_PRINT("\n\t  Updated routes:");
+        while (length != 0) {
              if (add_path) {
              if (add_path) {
-                path_id = EXTRACT_BE_U_4(p);
+                ND_TCHECK_4(p);
+                if (length < 4)
+                    goto trunc;
+                path_id = GET_BE_U_4(p);
                  p += 4;
                  length -= 4;
              }
              i = decode_prefix4(ndo, p, length, buf, sizeof(buf));
              if (i == -1) {
                  p += 4;
                  length -= 4;
              }
              i = decode_prefix4(ndo, p, length, buf, sizeof(buf));
              if (i == -1) {
-                ND_PRINT((ndo, "\n\t    (illegal prefix length)"));
+                ND_PRINT("\n\t    (illegal prefix length)");
                  break;
              } else if (i == -2)
                  break;
              } else if (i == -2)
-                goto trunc;
-            else if (i == -3)
                  goto trunc; /* bytes left, but not enough */
              else {
                  goto trunc; /* bytes left, but not enough */
              else {
-                ND_PRINT((ndo, "\n\t    %s", buf));
+                ND_PRINT("\n\t    %s", buf);
                  if (add_path) {
                  if (add_path) {
-                    ND_PRINT((ndo, "   Path Id: %d", path_id));
+                    ND_PRINT("   Path Id: %u", path_id);
                  }
                  p += i;
                  length -= i;
                  }
                  p += i;
                  length -= i;
@@ -2759,114 +2928,108 @@ bgp_update_print(netdissect_options *ndo,
      }
      return;
  trunc:
      }
      return;
  trunc:
-    ND_PRINT((ndo, "[|BGP]"));
+    nd_print_trunc(ndo);
  }
  
  static void
  bgp_notification_print(netdissect_options *ndo,
  }
  
  static void
  bgp_notification_print(netdissect_options *ndo,
-                       const u_char *dat, int length)
+                       const u_char *dat, u_int length)
  {
      const struct bgp_notification *bgp_notification_header;
      const u_char *tptr;
      uint8_t bgpn_major, bgpn_minor;
  {
      const struct bgp_notification *bgp_notification_header;
      const u_char *tptr;
      uint8_t bgpn_major, bgpn_minor;
-    uint8_t shutdown_comm_length;
-    uint8_t remainder_offset;
  
      ND_TCHECK_LEN(dat, BGP_NOTIFICATION_SIZE);
      if (length<BGP_NOTIFICATION_SIZE)
          return;
  
      bgp_notification_header = (const struct bgp_notification *)dat;
  
      ND_TCHECK_LEN(dat, BGP_NOTIFICATION_SIZE);
      if (length<BGP_NOTIFICATION_SIZE)
          return;
  
      bgp_notification_header = (const struct bgp_notification *)dat;
-    bgpn_major = EXTRACT_U_1(bgp_notification_header->bgpn_major);
-    bgpn_minor = EXTRACT_U_1(bgp_notification_header->bgpn_minor);
+    bgpn_major = GET_U_1(bgp_notification_header->bgpn_major);
+    bgpn_minor = GET_U_1(bgp_notification_header->bgpn_minor);
  
  
-    ND_PRINT((ndo, ", %s (%u)",
+    ND_PRINT(", %s (%u)",
                tok2str(bgp_notify_major_values, "Unknown Error",
                        bgpn_major),
                tok2str(bgp_notify_major_values, "Unknown Error",
                        bgpn_major),
-              bgpn_major));
+              bgpn_major);
  
      switch (bgpn_major) {
  
      case BGP_NOTIFY_MAJOR_MSG:
  
      switch (bgpn_major) {
  
      case BGP_NOTIFY_MAJOR_MSG:
-        ND_PRINT((ndo, ", subcode %s (%u)",
+        ND_PRINT(", subcode %s (%u)",
                    tok2str(bgp_notify_minor_msg_values, "Unknown",
                            bgpn_minor),
                    tok2str(bgp_notify_minor_msg_values, "Unknown",
                            bgpn_minor),
-                  bgpn_minor));
+                  bgpn_minor);
          break;
      case BGP_NOTIFY_MAJOR_OPEN:
          break;
      case BGP_NOTIFY_MAJOR_OPEN:
-        ND_PRINT((ndo, ", subcode %s (%u)",
+        ND_PRINT(", subcode %s (%u)",
                    tok2str(bgp_notify_minor_open_values, "Unknown",
                            bgpn_minor),
                    tok2str(bgp_notify_minor_open_values, "Unknown",
                            bgpn_minor),
-                  bgpn_minor));
+                  bgpn_minor);
          break;
      case BGP_NOTIFY_MAJOR_UPDATE:
          break;
      case BGP_NOTIFY_MAJOR_UPDATE:
-        ND_PRINT((ndo, ", subcode %s (%u)",
+        ND_PRINT(", subcode %s (%u)",
                    tok2str(bgp_notify_minor_update_values, "Unknown",
                            bgpn_minor),
                    tok2str(bgp_notify_minor_update_values, "Unknown",
                            bgpn_minor),
-                  bgpn_minor));
+                  bgpn_minor);
          break;
      case BGP_NOTIFY_MAJOR_FSM:
          break;
      case BGP_NOTIFY_MAJOR_FSM:
-        ND_PRINT((ndo, " subcode %s (%u)",
+        ND_PRINT(" subcode %s (%u)",
                    tok2str(bgp_notify_minor_fsm_values, "Unknown",
                            bgpn_minor),
                    tok2str(bgp_notify_minor_fsm_values, "Unknown",
                            bgpn_minor),
-                  bgpn_minor));
+                  bgpn_minor);
          break;
      case BGP_NOTIFY_MAJOR_CAP:
          break;
      case BGP_NOTIFY_MAJOR_CAP:
-        ND_PRINT((ndo, " subcode %s (%u)",
+        ND_PRINT(" subcode %s (%u)",
                    tok2str(bgp_notify_minor_cap_values, "Unknown",
                            bgpn_minor),
                    tok2str(bgp_notify_minor_cap_values, "Unknown",
                            bgpn_minor),
-                  bgpn_minor));
+                  bgpn_minor);
          break;
      case BGP_NOTIFY_MAJOR_CEASE:
          break;
      case BGP_NOTIFY_MAJOR_CEASE:
-        ND_PRINT((ndo, ", subcode %s (%u)",
+        ND_PRINT(", subcode %s (%u)",
                    tok2str(bgp_notify_minor_cease_values, "Unknown",
                            bgpn_minor),
                    tok2str(bgp_notify_minor_cease_values, "Unknown",
                            bgpn_minor),
-                  bgpn_minor));
+                  bgpn_minor);
  
  
-        /* draft-ietf-idr-cease-subcode-02 mentions optionally 7 bytes
+        /* RFC 4486 mentions optionally 7 bytes
           * for the maxprefix subtype, which may contain AFI, SAFI and MAXPREFIXES
           */
          if(bgpn_minor == BGP_NOTIFY_MINOR_CEASE_MAXPRFX && length >= BGP_NOTIFICATION_SIZE + 7) {
              tptr = dat + BGP_NOTIFICATION_SIZE;
           * for the maxprefix subtype, which may contain AFI, SAFI and MAXPREFIXES
           */
          if(bgpn_minor == BGP_NOTIFY_MINOR_CEASE_MAXPRFX && length >= BGP_NOTIFICATION_SIZE + 7) {
              tptr = dat + BGP_NOTIFICATION_SIZE;
-            ND_TCHECK_7(tptr);
-            ND_PRINT((ndo, ", AFI %s (%u), SAFI %s (%u), Max Prefixes: %u",
-                      tok2str(af_values, "Unknown", EXTRACT_BE_U_2(tptr)),
-                      EXTRACT_BE_U_2(tptr),
-                      tok2str(bgp_safi_values, "Unknown", EXTRACT_U_1((tptr + 2))),
-                      EXTRACT_U_1((tptr + 2)),
-                      EXTRACT_BE_U_4(tptr + 3)));
+            ND_PRINT(", AFI %s (%u), SAFI %s (%u), Max Prefixes: %u",
+                      tok2str(af_values, "Unknown", GET_BE_U_2(tptr)),
+                      GET_BE_U_2(tptr),
+                      tok2str(bgp_safi_values, "Unknown", GET_U_1((tptr + 2))),
+                      GET_U_1((tptr + 2)),
+                      GET_BE_U_4(tptr + 3));
          }
          /*
          }
          /*
-         * draft-ietf-idr-shutdown describes a method to send a communication
+         * RFC 9003 describes a method to send a communication
           * intended for human consumption regarding the Administrative Shutdown
           */
          if ((bgpn_minor == BGP_NOTIFY_MINOR_CEASE_SHUT ||
               bgpn_minor == BGP_NOTIFY_MINOR_CEASE_RESET) &&
               length >= BGP_NOTIFICATION_SIZE + 1) {
              tptr = dat + BGP_NOTIFICATION_SIZE;
           * intended for human consumption regarding the Administrative Shutdown
           */
          if ((bgpn_minor == BGP_NOTIFY_MINOR_CEASE_SHUT ||
               bgpn_minor == BGP_NOTIFY_MINOR_CEASE_RESET) &&
               length >= BGP_NOTIFICATION_SIZE + 1) {
              tptr = dat + BGP_NOTIFICATION_SIZE;
-            ND_TCHECK_1(tptr);
-            shutdown_comm_length = EXTRACT_U_1(tptr);
-            remainder_offset = 0;
+            uint8_t shutdown_comm_length = GET_U_1(tptr);
+            uint8_t remainder_offset = 0;
              /* garbage, hexdump it all */
              /* garbage, hexdump it all */
-            if (shutdown_comm_length > BGP_NOTIFY_MINOR_CEASE_ADMIN_SHUTDOWN_LEN ||
-                shutdown_comm_length > length - (BGP_NOTIFICATION_SIZE + 1)) {
-                ND_PRINT((ndo, ", invalid Shutdown Communication length"));
+            if (shutdown_comm_length > length - (BGP_NOTIFICATION_SIZE + 1)) {
+                ND_PRINT(", invalid Shutdown Communication length");
              }
              else if (shutdown_comm_length == 0) {
              }
              else if (shutdown_comm_length == 0) {
-                ND_PRINT((ndo, ", empty Shutdown Communication"));
+                ND_PRINT(", empty Shutdown Communication");
                  remainder_offset += 1;
              }
              /* a proper shutdown communication */
              else {
                  remainder_offset += 1;
              }
              /* a proper shutdown communication */
              else {
-                ND_TCHECK_LEN(tptr + 1, shutdown_comm_length);
-                ND_PRINT((ndo, ", Shutdown Communication (length: %u): \"", shutdown_comm_length));
-                (void)fn_printn(ndo, tptr+1, shutdown_comm_length, NULL);
-                ND_PRINT((ndo, "\""));
+                ND_PRINT(", Shutdown Communication (length: %u): \"", shutdown_comm_length);
+                nd_printjn(ndo, tptr+1, shutdown_comm_length);
+                ND_PRINT("\"");
                  remainder_offset += shutdown_comm_length + 1;
              }
              /* if there is trailing data, hexdump it */
              if(length - (remainder_offset + BGP_NOTIFICATION_SIZE) > 0) {
                  remainder_offset += shutdown_comm_length + 1;
              }
              /* if there is trailing data, hexdump it */
              if(length - (remainder_offset + BGP_NOTIFICATION_SIZE) > 0) {
-                ND_PRINT((ndo, ", Data: (length: %u)", length - (remainder_offset + BGP_NOTIFICATION_SIZE)));
+                ND_PRINT(", Data: (length: %u)", length - (remainder_offset + BGP_NOTIFICATION_SIZE));
                  hex_print(ndo, "\n\t\t", tptr + remainder_offset, length - (remainder_offset + BGP_NOTIFICATION_SIZE));
              }
          }
                  hex_print(ndo, "\n\t\t", tptr + remainder_offset, length - (remainder_offset + BGP_NOTIFICATION_SIZE));
              }
          }
@@ -2877,12 +3040,12 @@ bgp_notification_print(netdissect_options *ndo,
  
      return;
  trunc:
  
      return;
  trunc:
-    ND_PRINT((ndo, "[|BGP]"));
+    nd_print_trunc(ndo);
  }
  
  static void
  bgp_route_refresh_print(netdissect_options *ndo,
  }
  
  static void
  bgp_route_refresh_print(netdissect_options *ndo,
-                        const u_char *pptr, int len)
+                        const u_char *pptr, u_int len)
  {
      const struct bgp_route_refresh *bgp_route_refresh_header;
  
  {
      const struct bgp_route_refresh *bgp_route_refresh_header;
  
@@ -2894,13 +3057,16 @@ bgp_route_refresh_print(netdissect_options *ndo,
  
      bgp_route_refresh_header = (const struct bgp_route_refresh *)pptr;
  
  
      bgp_route_refresh_header = (const struct bgp_route_refresh *)pptr;
  
-    ND_PRINT((ndo, "\n\t  AFI %s (%u), SAFI %s (%u)",
-              tok2str(af_values,"Unknown",
-                      EXTRACT_BE_U_2(bgp_route_refresh_header->afi)),
-              EXTRACT_BE_U_2(bgp_route_refresh_header->afi),
-              tok2str(bgp_safi_values,"Unknown",
-                      EXTRACT_U_1(bgp_route_refresh_header->safi)),
-              EXTRACT_U_1(bgp_route_refresh_header->safi)));
+    ND_PRINT("\n\t  AFI %s (%u), SAFI %s (%u), Subtype %s (%u)",
+             tok2str(af_values, "Unknown",
+                     GET_BE_U_2(bgp_route_refresh_header->afi)),
+             GET_BE_U_2(bgp_route_refresh_header->afi),
+             tok2str(bgp_safi_values, "Unknown",
+                     GET_U_1(bgp_route_refresh_header->safi)),
+             GET_U_1(bgp_route_refresh_header->safi),
+             tok2str(bgp_route_refresh_subtype_values, "Unknown",
+                     GET_U_1(bgp_route_refresh_header->subtype)),
+             GET_U_1(bgp_route_refresh_header->subtype));
  
      if (ndo->ndo_vflag > 1) {
          ND_TCHECK_LEN(pptr, len);
  
      if (ndo->ndo_vflag > 1) {
          ND_TCHECK_LEN(pptr, len);
@@ -2909,7 +3075,7 @@ bgp_route_refresh_print(netdissect_options *ndo,
  
      return;
  trunc:
  
      return;
  trunc:
-    ND_PRINT((ndo, "[|BGP]"));
+    nd_print_trunc(ndo);
  }
  
  static int
  }
  
  static int
@@ -2921,12 +3087,12 @@ bgp_pdu_print(netdissect_options *ndo,
  
      ND_TCHECK_LEN(dat, BGP_SIZE);
      bgp_header = (const struct bgp *)dat;
  
      ND_TCHECK_LEN(dat, BGP_SIZE);
      bgp_header = (const struct bgp *)dat;
-    bgp_type = EXTRACT_U_1(bgp_header->bgp_type);
+    bgp_type = GET_U_1(bgp_header->bgp_type);
  
  
-    ND_PRINT((ndo, "\n\t%s Message (%u), length: %u",
+    ND_PRINT("\n\t%s Message (%u), length: %u",
                tok2str(bgp_msg_values, "Unknown", bgp_type),
                bgp_type,
                tok2str(bgp_msg_values, "Unknown", bgp_type),
                bgp_type,
-              length));
+              length);
  
      switch (bgp_type) {
      case BGP_OPEN:
  
      switch (bgp_type) {
      case BGP_OPEN:
@@ -2946,22 +3112,22 @@ bgp_pdu_print(netdissect_options *ndo,
      default:
          /* we have no decoder for the BGP message */
          ND_TCHECK_LEN(dat, length);
      default:
          /* we have no decoder for the BGP message */
          ND_TCHECK_LEN(dat, length);
-        ND_PRINT((ndo, "\n\t  no Message %u decoder", bgp_type));
+        ND_PRINT("\n\t  no Message %u decoder", bgp_type);
          print_unknown_data(ndo, dat, "\n\t  ", length);
          break;
      }
      return 1;
  trunc:
          print_unknown_data(ndo, dat, "\n\t  ", length);
          break;
      }
      return 1;
  trunc:
-    ND_PRINT((ndo, "[|BGP]"));
+    nd_print_trunc(ndo);
      return 0;
  }
  
  void
  bgp_print(netdissect_options *ndo,
      return 0;
  }
  
  void
  bgp_print(netdissect_options *ndo,
-          const u_char *dat, int length)
+          const u_char *dat, u_int length _U_)
  {
      const u_char *p;
  {
      const u_char *p;
-    const u_char *ep;
+    const u_char *ep = ndo->ndo_snapend;
      const u_char *start;
      const u_char marker[] = {
          0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
      const u_char *start;
      const u_char marker[] = {
          0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
@@ -2970,11 +3136,8 @@ bgp_print(netdissect_options *ndo,
      const struct bgp *bgp_header;
      uint16_t hlen;
  
      const struct bgp *bgp_header;
      uint16_t hlen;
  
-    ep = dat + length;
-    if (ndo->ndo_snapend < dat + length)
-        ep = ndo->ndo_snapend;
-
-    ND_PRINT((ndo, ": BGP"));
+    ndo->ndo_protocol = "bgp";
+    ND_PRINT(": BGP");
  
      if (ndo->ndo_vflag < 1) /* lets be less chatty */
          return;
  
      if (ndo->ndo_vflag < 1) /* lets be less chatty */
          return;
@@ -2984,7 +3147,7 @@ bgp_print(netdissect_options *ndo,
      while (p < ep) {
          if (!ND_TTEST_1(p))
              break;
      while (p < ep) {
          if (!ND_TTEST_1(p))
              break;
-        if (EXTRACT_U_1(p) != 0xff) {
+        if (GET_U_1(p) != 0xff) {
              p++;
              continue;
          }
              p++;
              continue;
          }
@@ -3001,12 +3164,12 @@ bgp_print(netdissect_options *ndo,
          bgp_header = (const struct bgp *)p;
  
          if (start != p)
          bgp_header = (const struct bgp *)p;
  
          if (start != p)
-            ND_PRINT((ndo, " [|BGP]"));
+            nd_print_trunc(ndo);
  
  
-        hlen = EXTRACT_BE_U_2(bgp_header->bgp_len);
+        hlen = GET_BE_U_2(bgp_header->bgp_len);
          if (hlen < BGP_SIZE) {
          if (hlen < BGP_SIZE) {
-            ND_PRINT((ndo, "\n[|BGP Bogus header length %u < %u]", hlen,
-                      BGP_SIZE));
+            ND_PRINT("\nmessage length %u < %u", hlen, BGP_SIZE);
+            nd_print_invalid(ndo);
              break;
          }
  
              break;
          }
  
@@ -3016,10 +3179,10 @@ bgp_print(netdissect_options *ndo,
              p += hlen;
              start = p;
          } else {
              p += hlen;
              start = p;
          } else {
-            ND_PRINT((ndo, "\n[|BGP %s]",
+            ND_PRINT("\n[|BGP %s]",
                        tok2str(bgp_msg_values,
                                "Unknown Message Type",
                        tok2str(bgp_msg_values,
                                "Unknown Message Type",
-                              EXTRACT_U_1(bgp_header->bgp_type))));
+                              GET_U_1(bgp_header->bgp_type)));
              break;
          }
      }
              break;
          }
      }
@@ -3027,12 +3190,5 @@ bgp_print(netdissect_options *ndo,
      return;
  
  trunc:
      return;
  
  trunc:
-    ND_PRINT((ndo, " [|BGP]"));
+    nd_print_trunc(ndo);
  }
  }
-
-/*
- * Local Variables:
- * c-style: whitesmith
- * c-basic-offset: 4
- * End:
- */