contrib/tcpdump/print-bgp.c

   1 /*
   2  * Copyright (C) 1999 WIDE Project.
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  * 3. Neither the name of the project nor the names of its contributors
  14  *    may be used to endorse or promote products derived from this software
  15  *    without specific prior written permission.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
  18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  20  * ARE DISCLAIMED.  IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
  21  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  27  * SUCH DAMAGE.
  28  *
  29  * Extensively modified by Hannes Gredler (hannes@juniper.net) for more
  30  * complete BGP support.
  31  */
  32
  33 #ifdef HAVE_CONFIG_H
  34 #include "config.h"
  35 #endif
  36
  37 #ifndef lint
  38 static const char rcsid[] _U_ =
  39      "@(#) $Header: /tcpdump/master/tcpdump/print-bgp.c,v 1.118 2007-12-07 15:54:52 hannes Exp $";
  40 #endif
  41
  42 #include <tcpdump-stdinc.h>
  43
  44 #include <stdio.h>
  45 #include <string.h>
  46
  47 #include "interface.h"
  48 #include "decode_prefix.h"
  49 #include "addrtoname.h"
  50 #include "extract.h"
  51 #include "bgp.h"
  52 #include "af.h"
  53 #include "l2vpn.h"
  54
  55 struct bgp {
  56         u_int8_t bgp_marker[16];
  57         u_int16_t bgp_len;
  58         u_int8_t bgp_type;
  59 };
  60 #define BGP_SIZE                19      /* unaligned */
  61
  62 #define BGP_OPEN                1
  63 #define BGP_UPDATE              2
  64 #define BGP_NOTIFICATION        3
  65 #define BGP_KEEPALIVE           4
  66 #define BGP_ROUTE_REFRESH       5
  67
  68 static struct tok bgp_msg_values[] = {
  69     { BGP_OPEN,                 "Open"},
  70     { BGP_UPDATE,               "Update"},
  71     { BGP_NOTIFICATION,         "Notification"},
  72     { BGP_KEEPALIVE,            "Keepalive"},
  73     { BGP_ROUTE_REFRESH,        "Route Refresh"},
  74     { 0, NULL}
  75 };
  76
  77 struct bgp_open {
  78         u_int8_t bgpo_marker[16];
  79         u_int16_t bgpo_len;
  80         u_int8_t bgpo_type;
  81         u_int8_t bgpo_version;
  82         u_int16_t bgpo_myas;
  83         u_int16_t bgpo_holdtime;
  84         u_int32_t bgpo_id;
  85         u_int8_t bgpo_optlen;
  86         /* options should follow */
  87 };
  88 #define BGP_OPEN_SIZE           29      /* unaligned */
  89
  90 struct bgp_opt {
  91         u_int8_t bgpopt_type;
  92         u_int8_t bgpopt_len;
  93         /* variable length */
  94 };
  95 #define BGP_OPT_SIZE            2       /* some compilers may pad to 4 bytes */
  96
  97 #define BGP_UPDATE_MINSIZE      23
  98
  99 struct bgp_notification {
 100         u_int8_t bgpn_marker[16];
 101         u_int16_t bgpn_len;
 102         u_int8_t bgpn_type;
 103         u_int8_t bgpn_major;
 104         u_int8_t bgpn_minor;
 105 };
 106 #define BGP_NOTIFICATION_SIZE           21      /* unaligned */
 107
 108 struct bgp_route_refresh {
 109     u_int8_t  bgp_marker[16];
 110     u_int16_t len;
 111     u_int8_t  type;
 112     u_int8_t  afi[2]; /* the compiler messes this structure up               */
 113     u_int8_t  res;    /* when doing misaligned sequences of int8 and int16   */
 114     u_int8_t  safi;   /* afi should be int16 - so we have to access it using */
 115 };                    /* EXTRACT_16BITS(&bgp_route_refresh->afi) (sigh)      */
 116 #define BGP_ROUTE_REFRESH_SIZE          23
 117
 118 struct bgp_attr {
 119         u_int8_t bgpa_flags;
 120         u_int8_t bgpa_type;
 121         union {
 122                 u_int8_t len;
 123                 u_int16_t elen;
 124         } bgpa_len;
 125 #define bgp_attr_len(p) \
 126         (((p)->bgpa_flags & 0x10) ? \
 127                 EXTRACT_16BITS(&(p)->bgpa_len.elen) : (p)->bgpa_len.len)
 128 #define bgp_attr_off(p) \
 129         (((p)->bgpa_flags & 0x10) ? 4 : 3)
 130 };
 131
 132 #define BGPTYPE_ORIGIN                  1
 133 #define BGPTYPE_AS_PATH                 2
 134 #define BGPTYPE_NEXT_HOP                3
 135 #define BGPTYPE_MULTI_EXIT_DISC         4
 136 #define BGPTYPE_LOCAL_PREF              5
 137 #define BGPTYPE_ATOMIC_AGGREGATE        6
 138 #define BGPTYPE_AGGREGATOR              7
 139 #define BGPTYPE_COMMUNITIES             8       /* RFC1997 */
 140 #define BGPTYPE_ORIGINATOR_ID           9       /* RFC1998 */
 141 #define BGPTYPE_CLUSTER_LIST            10      /* RFC1998 */
 142 #define BGPTYPE_DPA                     11      /* draft-ietf-idr-bgp-dpa */
 143 #define BGPTYPE_ADVERTISERS             12      /* RFC1863 */
 144 #define BGPTYPE_RCID_PATH               13      /* RFC1863 */
 145 #define BGPTYPE_MP_REACH_NLRI           14      /* RFC2283 */
 146 #define BGPTYPE_MP_UNREACH_NLRI         15      /* RFC2283 */
 147 #define BGPTYPE_EXTD_COMMUNITIES        16      /* draft-ietf-idr-bgp-ext-communities */
 148 #define BGPTYPE_AS4_PATH                17      /* RFC4893 */
 149 #define BGPTYPE_AGGREGATOR4             18      /* RFC4893 */
 150 #define BGPTYPE_PMSI_TUNNEL             22      /* draft-ietf-l3vpn-2547bis-mcast-bgp-02.txt */
 151 #define BGPTYPE_ATTR_SET               128      /* draft-marques-ppvpn-ibgp */
 152
 153 #define BGP_MP_NLRI_MINSIZE              3       /* End of RIB Marker detection */
 154
 155 static struct tok bgp_attr_values[] = {
 156     { BGPTYPE_ORIGIN,           "Origin"},
 157     { BGPTYPE_AS_PATH,          "AS Path"},
 158     { BGPTYPE_AS4_PATH,         "AS4 Path"},
 159     { BGPTYPE_NEXT_HOP,         "Next Hop"},
 160     { BGPTYPE_MULTI_EXIT_DISC,  "Multi Exit Discriminator"},
 161     { BGPTYPE_LOCAL_PREF,       "Local Preference"},
 162     { BGPTYPE_ATOMIC_AGGREGATE, "Atomic Aggregate"},
 163     { BGPTYPE_AGGREGATOR,       "Aggregator"},
 164     { BGPTYPE_AGGREGATOR4,      "Aggregator4"},
 165     { BGPTYPE_COMMUNITIES,      "Community"},
 166     { BGPTYPE_ORIGINATOR_ID,    "Originator ID"},
 167     { BGPTYPE_CLUSTER_LIST,     "Cluster List"},
 168     { BGPTYPE_DPA,              "DPA"},
 169     { BGPTYPE_ADVERTISERS,      "Advertisers"},
 170     { BGPTYPE_RCID_PATH,        "RCID Path / Cluster ID"},
 171     { BGPTYPE_MP_REACH_NLRI,    "Multi-Protocol Reach NLRI"},
 172     { BGPTYPE_MP_UNREACH_NLRI,  "Multi-Protocol Unreach NLRI"},
 173     { BGPTYPE_EXTD_COMMUNITIES, "Extended Community"},
 174     { BGPTYPE_PMSI_TUNNEL,      "PMSI Tunnel"},
 175     { BGPTYPE_ATTR_SET,         "Attribute Set"},
 176     { 255,                      "Reserved for development"},
 177     { 0, NULL}
 178 };
 179
 180 #define BGP_AS_SET             1
 181 #define BGP_AS_SEQUENCE        2
 182 #define BGP_CONFED_AS_SEQUENCE 3 /* draft-ietf-idr-rfc3065bis-01 */
 183 #define BGP_CONFED_AS_SET      4 /* draft-ietf-idr-rfc3065bis-01  */
 184
 185 #define BGP_AS_SEG_TYPE_MIN    BGP_AS_SET
 186 #define BGP_AS_SEG_TYPE_MAX    BGP_CONFED_AS_SET
 187
 188 static struct tok bgp_as_path_segment_open_values[] = {
 189     { BGP_AS_SEQUENCE,         ""},
 190     { BGP_AS_SET,              "{ "},
 191     { BGP_CONFED_AS_SEQUENCE,  "( "},
 192     { BGP_CONFED_AS_SET,       "({ "},
 193     { 0, NULL}
 194 };
 195
 196 static struct tok bgp_as_path_segment_close_values[] = {
 197     { BGP_AS_SEQUENCE,         ""},
 198     { BGP_AS_SET,              "}"},
 199     { BGP_CONFED_AS_SEQUENCE,  ")"},
 200     { BGP_CONFED_AS_SET,       "})"},
 201     { 0, NULL}
 202 };
 203
 204 #define BGP_OPT_AUTH                    1
 205 #define BGP_OPT_CAP                     2
 206
 207
 208 static struct tok bgp_opt_values[] = {
 209     { BGP_OPT_AUTH,             "Authentication Information"},
 210     { BGP_OPT_CAP,              "Capabilities Advertisement"},
 211     { 0, NULL}
 212 };
 213
 214 #define BGP_CAPCODE_MP                  1
 215 #define BGP_CAPCODE_RR                  2
 216 #define BGP_CAPCODE_ORF                 3 /* XXX */
 217 #define BGP_CAPCODE_RESTART            64 /* draft-ietf-idr-restart-05  */
 218 #define BGP_CAPCODE_AS_NEW             65 /* XXX */
 219 #define BGP_CAPCODE_DYN_CAP            67 /* XXX */
 220 #define BGP_CAPCODE_RR_CISCO          128
 221
 222 static struct tok bgp_capcode_values[] = {
 223     { BGP_CAPCODE_MP,           "Multiprotocol Extensions"},
 224     { BGP_CAPCODE_RR,           "Route Refresh"},
 225     { BGP_CAPCODE_ORF,          "Cooperative Route Filtering"},
 226     { BGP_CAPCODE_RESTART,      "Graceful Restart"},
 227     { BGP_CAPCODE_AS_NEW,       "32-Bit AS Number"},
 228     { BGP_CAPCODE_DYN_CAP,      "Dynamic Capability"},
 229     { BGP_CAPCODE_RR_CISCO,     "Route Refresh (Cisco)"},
 230     { 0, NULL}
 231 };
 232
 233 #define BGP_NOTIFY_MAJOR_MSG            1
 234 #define BGP_NOTIFY_MAJOR_OPEN           2
 235 #define BGP_NOTIFY_MAJOR_UPDATE         3
 236 #define BGP_NOTIFY_MAJOR_HOLDTIME       4
 237 #define BGP_NOTIFY_MAJOR_FSM            5
 238 #define BGP_NOTIFY_MAJOR_CEASE          6
 239 #define BGP_NOTIFY_MAJOR_CAP            7
 240
 241 static struct tok bgp_notify_major_values[] = {
 242     { BGP_NOTIFY_MAJOR_MSG,     "Message Header Error"},
 243     { BGP_NOTIFY_MAJOR_OPEN,    "OPEN Message Error"},
 244     { BGP_NOTIFY_MAJOR_UPDATE,  "UPDATE Message Error"},
 245     { BGP_NOTIFY_MAJOR_HOLDTIME,"Hold Timer Expired"},
 246     { BGP_NOTIFY_MAJOR_FSM,     "Finite State Machine Error"},
 247     { BGP_NOTIFY_MAJOR_CEASE,   "Cease"},
 248     { BGP_NOTIFY_MAJOR_CAP,     "Capability Message Error"},
 249     { 0, NULL}
 250 };
 251
 252 /* draft-ietf-idr-cease-subcode-02 */
 253 #define BGP_NOTIFY_MINOR_CEASE_MAXPRFX  1
 254 static struct tok bgp_notify_minor_cease_values[] = {
 255     { BGP_NOTIFY_MINOR_CEASE_MAXPRFX, "Maximum Number of Prefixes Reached"},
 256     { 2,                        "Administratively Shutdown"},
 257     { 3,                        "Peer Unconfigured"},
 258     { 4,                        "Administratively Reset"},
 259     { 5,                        "Connection Rejected"},
 260     { 6,                        "Other Configuration Change"},
 261     { 7,                        "Connection Collision Resolution"},
 262     { 0, NULL}
 263 };
 264
 265 static struct tok bgp_notify_minor_msg_values[] = {
 266     { 1,                        "Connection Not Synchronized"},
 267     { 2,                        "Bad Message Length"},
 268     { 3,                        "Bad Message Type"},
 269     { 0, NULL}
 270 };
 271
 272 static struct tok bgp_notify_minor_open_values[] = {
 273     { 1,                        "Unsupported Version Number"},
 274     { 2,                        "Bad Peer AS"},
 275     { 3,                        "Bad BGP Identifier"},
 276     { 4,                        "Unsupported Optional Parameter"},
 277     { 5,                        "Authentication Failure"},
 278     { 6,                        "Unacceptable Hold Time"},
 279     { 7,                        "Capability Message Error"},
 280     { 0, NULL}
 281 };
 282
 283 static struct tok bgp_notify_minor_update_values[] = {
 284     { 1,                        "Malformed Attribute List"},
 285     { 2,                        "Unrecognized Well-known Attribute"},
 286     { 3,                        "Missing Well-known Attribute"},
 287     { 4,                        "Attribute Flags Error"},
 288     { 5,                        "Attribute Length Error"},
 289     { 6,                        "Invalid ORIGIN Attribute"},
 290     { 7,                        "AS Routing Loop"},
 291     { 8,                        "Invalid NEXT_HOP Attribute"},
 292     { 9,                        "Optional Attribute Error"},
 293     { 10,                       "Invalid Network Field"},
 294     { 11,                       "Malformed AS_PATH"},
 295     { 0, NULL}
 296 };
 297
 298 static struct tok bgp_notify_minor_cap_values[] = {
 299     { 1,                        "Invalid Action Value" },
 300     { 2,                        "Invalid Capability Length" },
 301     { 3,                        "Malformed Capability Value" },
 302     { 4,                        "Unsupported Capability Code" },
 303     { 0, NULL }
 304 };
 305
 306 static struct tok bgp_origin_values[] = {
 307     { 0,                        "IGP"},
 308     { 1,                        "EGP"},
 309     { 2,                        "Incomplete"},
 310     { 0, NULL}
 311 };
 312
 313 #define BGP_PMSI_TUNNEL_RSVP_P2MP 1
 314 #define BGP_PMSI_TUNNEL_LDP_P2MP  2
 315 #define BGP_PMSI_TUNNEL_PIM_SSM   3
 316 #define BGP_PMSI_TUNNEL_PIM_SM    4
 317 #define BGP_PMSI_TUNNEL_PIM_BIDIR 5
 318 #define BGP_PMSI_TUNNEL_INGRESS   6
 319 #define BGP_PMSI_TUNNEL_LDP_MP2MP 7
 320
 321 static struct tok bgp_pmsi_tunnel_values[] = {
 322     { BGP_PMSI_TUNNEL_RSVP_P2MP, "RSVP-TE P2MP LSP"},
 323     { BGP_PMSI_TUNNEL_LDP_P2MP, "LDP P2MP LSP"},
 324     { BGP_PMSI_TUNNEL_PIM_SSM, "PIM-SSM Tree"},
 325     { BGP_PMSI_TUNNEL_PIM_SM, "PIM-SM Tree"},
 326     { BGP_PMSI_TUNNEL_PIM_BIDIR, "PIM-Bidir Tree"},
 327     { BGP_PMSI_TUNNEL_INGRESS, "Ingress Replication"},
 328     { BGP_PMSI_TUNNEL_LDP_MP2MP, "LDP MP2MP LSP"},
 329     { 0, NULL}
 330 };
 331
 332 static struct tok bgp_pmsi_flag_values[] = {
 333     { 0x01, "Leaf Information required"},
 334     { 0, NULL}
 335 };
 336
 337
 338 /* Subsequent address family identifier, RFC2283 section 7 */
 339 #define SAFNUM_RES                      0
 340 #define SAFNUM_UNICAST                  1
 341 #define SAFNUM_MULTICAST                2
 342 #define SAFNUM_UNIMULTICAST             3
 343 /* labeled BGP RFC3107 */
 344 #define SAFNUM_LABUNICAST               4
 345 /* draft-ietf-l3vpn-2547bis-mcast-bgp-02.txt */
 346 #define SAFNUM_MULTICAST_VPN            5
 347 #define SAFNUM_TUNNEL                   64 /* XXX */
 348 #define SAFNUM_VPLS                     65 /* XXX */
 349 /* draft-nalawade-idr-mdt-safi-03 */
 350 #define SAFNUM_MDT                      66
 351 /* Section 4.3.4 of draft-rosen-rfc2547bis-03.txt  */
 352 #define SAFNUM_VPNUNICAST               128
 353 #define SAFNUM_VPNMULTICAST             129
 354 #define SAFNUM_VPNUNIMULTICAST          130
 355 /* draft-marques-ppvpn-rt-constrain-01.txt */
 356 #define SAFNUM_RT_ROUTING_INFO          132
 357
 358 #define BGP_VPN_RD_LEN                  8
 359
 360 static struct tok bgp_safi_values[] = {
 361     { SAFNUM_RES,               "Reserved"},
 362     { SAFNUM_UNICAST,           "Unicast"},
 363     { SAFNUM_MULTICAST,         "Multicast"},
 364     { SAFNUM_UNIMULTICAST,      "Unicast+Multicast"},
 365     { SAFNUM_LABUNICAST,        "labeled Unicast"},
 366     { SAFNUM_TUNNEL,            "Tunnel"},
 367     { SAFNUM_VPLS,              "VPLS"},
 368     { SAFNUM_MDT,               "MDT"},
 369     { SAFNUM_VPNUNICAST,        "labeled VPN Unicast"},
 370     { SAFNUM_VPNMULTICAST,      "labeled VPN Multicast"},
 371     { SAFNUM_VPNUNIMULTICAST,   "labeled VPN Unicast+Multicast"},
 372     { SAFNUM_RT_ROUTING_INFO,   "Route Target Routing Information"},
 373     { SAFNUM_MULTICAST_VPN,     "Multicast VPN"},
 374     { 0, NULL }
 375 };
 376
 377 /* well-known community */
 378 #define BGP_COMMUNITY_NO_EXPORT                 0xffffff01
 379 #define BGP_COMMUNITY_NO_ADVERT                 0xffffff02
 380 #define BGP_COMMUNITY_NO_EXPORT_SUBCONFED       0xffffff03
 381
 382 /* Extended community type - draft-ietf-idr-bgp-ext-communities-05 */
 383 #define BGP_EXT_COM_RT_0        0x0002  /* Route Target,Format AS(2bytes):AN(4bytes) */
 384 #define BGP_EXT_COM_RT_1        0x0102  /* Route Target,Format IP address:AN(2bytes) */
 385 #define BGP_EXT_COM_RT_2        0x0202  /* Route Target,Format AN(4bytes):local(2bytes) */
 386 #define BGP_EXT_COM_RO_0        0x0003  /* Route Origin,Format AS(2bytes):AN(4bytes) */
 387 #define BGP_EXT_COM_RO_1        0x0103  /* Route Origin,Format IP address:AN(2bytes) */
 388 #define BGP_EXT_COM_RO_2        0x0203  /* Route Origin,Format AN(4bytes):local(2bytes) */
 389 #define BGP_EXT_COM_LINKBAND    0x4004  /* Link Bandwidth,Format AS(2B):Bandwidth(4B) */
 390                                         /* rfc2547 bgp-mpls-vpns */
 391 #define BGP_EXT_COM_VPN_ORIGIN  0x0005  /* OSPF Domain ID / VPN of Origin  - draft-rosen-vpns-ospf-bgp-mpls */
 392 #define BGP_EXT_COM_VPN_ORIGIN2 0x0105  /* duplicate - keep for backwards compatability */
 393 #define BGP_EXT_COM_VPN_ORIGIN3 0x0205  /* duplicate - keep for backwards compatability */
 394 #define BGP_EXT_COM_VPN_ORIGIN4 0x8005  /* duplicate - keep for backwards compatability */
 395
 396 #define BGP_EXT_COM_OSPF_RTYPE  0x0306  /* OSPF Route Type,Format Area(4B):RouteType(1B):Options(1B) */
 397 #define BGP_EXT_COM_OSPF_RTYPE2 0x8000  /* duplicate - keep for backwards compatability */
 398
 399 #define BGP_EXT_COM_OSPF_RID    0x0107  /* OSPF Router ID,Format RouterID(4B):Unused(2B) */
 400 #define BGP_EXT_COM_OSPF_RID2   0x8001  /* duplicate - keep for backwards compatability */
 401
 402 #define BGP_EXT_COM_L2INFO      0x800a  /* draft-kompella-ppvpn-l2vpn */
 403
 404 #define BGP_EXT_COM_SOURCE_AS   0x0009  /* RFC-ietf-l3vpn-2547bis-mcast-bgp-08.txt */
 405 #define BGP_EXT_COM_VRF_RT_IMP  0x010b  /* RFC-ietf-l3vpn-2547bis-mcast-bgp-08.txt */
 406 #define BGP_EXT_COM_L2VPN_RT_0  0x000a  /* L2VPN Identifier,Format AS(2bytes):AN(4bytes) */
 407 #define BGP_EXT_COM_L2VPN_RT_1  0xF10a  /* L2VPN Identifier,Format IP address:AN(2bytes) */
 408
 409
 410 /* http://www.cisco.com/en/US/tech/tk436/tk428/technologies_tech_note09186a00801eb09a.shtml  */
 411 #define BGP_EXT_COM_EIGRP_GEN   0x8800
 412 #define BGP_EXT_COM_EIGRP_METRIC_AS_DELAY  0x8801
 413 #define BGP_EXT_COM_EIGRP_METRIC_REL_NH_BW 0x8802
 414 #define BGP_EXT_COM_EIGRP_METRIC_LOAD_MTU  0x8803
 415 #define BGP_EXT_COM_EIGRP_EXT_REMAS_REMID  0x8804
 416 #define BGP_EXT_COM_EIGRP_EXT_REMPROTO_REMMETRIC 0x8805
 417
 418 static struct tok bgp_extd_comm_flag_values[] = {
 419     { 0x8000,                  "vendor-specific"},
 420     { 0x4000,                  "non-transitive"},
 421     { 0, NULL},
 422 };
 423
 424 static struct tok bgp_extd_comm_subtype_values[] = {
 425     { BGP_EXT_COM_RT_0,        "target"},
 426     { BGP_EXT_COM_RT_1,        "target"},
 427     { BGP_EXT_COM_RT_2,        "target"},
 428     { BGP_EXT_COM_RO_0,        "origin"},
 429     { BGP_EXT_COM_RO_1,        "origin"},
 430     { BGP_EXT_COM_RO_2,        "origin"},
 431     { BGP_EXT_COM_LINKBAND,    "link-BW"},
 432     { BGP_EXT_COM_VPN_ORIGIN,  "ospf-domain"},
 433     { BGP_EXT_COM_VPN_ORIGIN2, "ospf-domain"},
 434     { BGP_EXT_COM_VPN_ORIGIN3, "ospf-domain"},
 435     { BGP_EXT_COM_VPN_ORIGIN4, "ospf-domain"},
 436     { BGP_EXT_COM_OSPF_RTYPE,  "ospf-route-type"},
 437     { BGP_EXT_COM_OSPF_RTYPE2, "ospf-route-type"},
 438     { BGP_EXT_COM_OSPF_RID,    "ospf-router-id"},
 439     { BGP_EXT_COM_OSPF_RID2,   "ospf-router-id"},
 440     { BGP_EXT_COM_L2INFO,      "layer2-info"},
 441     { BGP_EXT_COM_EIGRP_GEN , "eigrp-general-route (flag, tag)" },
 442     { BGP_EXT_COM_EIGRP_METRIC_AS_DELAY , "eigrp-route-metric (AS, delay)" },
 443     { BGP_EXT_COM_EIGRP_METRIC_REL_NH_BW , "eigrp-route-metric (reliability, nexthop, bandwidth)" },
 444     { BGP_EXT_COM_EIGRP_METRIC_LOAD_MTU , "eigrp-route-metric (load, MTU)" },
 445     { BGP_EXT_COM_EIGRP_EXT_REMAS_REMID , "eigrp-external-route (remote-AS, remote-ID)" },
 446     { BGP_EXT_COM_EIGRP_EXT_REMPROTO_REMMETRIC , "eigrp-external-route (remote-proto, remote-metric)" },
 447     { BGP_EXT_COM_SOURCE_AS, "source-AS" },
 448     { BGP_EXT_COM_VRF_RT_IMP, "vrf-route-import"},
 449     { BGP_EXT_COM_L2VPN_RT_0, "l2vpn-id"},
 450     { BGP_EXT_COM_L2VPN_RT_1, "l2vpn-id"},
 451     { 0, NULL},
 452 };
 453
 454 /* OSPF codes for  BGP_EXT_COM_OSPF_RTYPE draft-rosen-vpns-ospf-bgp-mpls  */
 455 #define BGP_OSPF_RTYPE_RTR      1 /* OSPF Router LSA */
 456 #define BGP_OSPF_RTYPE_NET      2 /* OSPF Network LSA */
 457 #define BGP_OSPF_RTYPE_SUM      3 /* OSPF Summary LSA */
 458 #define BGP_OSPF_RTYPE_EXT      5 /* OSPF External LSA, note that ASBR doesn't apply to MPLS-VPN */
 459 #define BGP_OSPF_RTYPE_NSSA     7 /* OSPF NSSA External*/
 460 #define BGP_OSPF_RTYPE_SHAM     129 /* OSPF-MPLS-VPN Sham link */
 461 #define BGP_OSPF_RTYPE_METRIC_TYPE 0x1 /* LSB of RTYPE Options Field */
 462
 463 static struct tok bgp_extd_comm_ospf_rtype_values[] = {
 464   { BGP_OSPF_RTYPE_RTR, "Router" },
 465   { BGP_OSPF_RTYPE_NET, "Network" },
 466   { BGP_OSPF_RTYPE_SUM, "Summary" },
 467   { BGP_OSPF_RTYPE_EXT, "External" },
 468   { BGP_OSPF_RTYPE_NSSA,"NSSA External" },
 469   { BGP_OSPF_RTYPE_SHAM,"MPLS-VPN Sham" },
 470   { 0, NULL },
 471 };
 472
 473 #define TOKBUFSIZE 128
 474 static char astostr[20];
 475
 476 /*
 477  * as_printf
 478  *
 479  * Convert an AS number into a string and return string pointer.
 480  *
 481  * Bepending on bflag is set or not, AS number is converted into ASDOT notation
 482  * or plain number notation.
 483  *
 484  */
 485 static char *
 486 as_printf (char *str, int size, u_int asnum)
 487 {
 488         if (!bflag || asnum <= 0xFFFF) {
 489                 snprintf(str, size, "%u", asnum);
 490         } else {
 491                 snprintf(str, size, "%u.%u", asnum >> 16, asnum & 0xFFFF);
 492         }
 493         return str;
 494 }
 495
 496 int
 497 decode_prefix4(const u_char *pptr, char *buf, u_int buflen)
 498 {
 499         struct in_addr addr;
 500         u_int plen;
 501
 502         TCHECK(pptr[0]);
 503         plen = pptr[0];
 504         if (32 < plen)
 505                 return -1;
 506
 507         memset(&addr, 0, sizeof(addr));
 508         TCHECK2(pptr[1], (plen + 7) / 8);
 509         memcpy(&addr, &pptr[1], (plen + 7) / 8);
 510         if (plen % 8) {
 511                 ((u_char *)&addr)[(plen + 7) / 8 - 1] &=
 512                         ((0xff00 >> (plen % 8)) & 0xff);
 513         }
 514         snprintf(buf, buflen, "%s/%d", getname((u_char *)&addr), plen);
 515         return 1 + (plen + 7) / 8;
 516
 517 trunc:
 518         return -2;
 519 }
 520
 521 static int
 522 decode_labeled_prefix4(const u_char *pptr, char *buf, u_int buflen)
 523 {
 524         struct in_addr addr;
 525         u_int plen;
 526
 527         TCHECK(pptr[0]);
 528         plen = pptr[0];   /* get prefix length */
 529
 530         /* this is one of the weirdnesses of rfc3107
 531            the label length (actually the label + COS bits)
 532            is added to the prefix length;
 533            we also do only read out just one label -
 534            there is no real application for advertisement of
 535            stacked labels in a a single BGP message
 536         */
 537
 538         if (24 > plen)
 539                 return -1;
 540
 541         plen-=24; /* adjust prefixlen - labellength */
 542
 543         if (32 < plen)
 544                 return -1;
 545
 546         memset(&addr, 0, sizeof(addr));
 547         TCHECK2(pptr[4], (plen + 7) / 8);
 548         memcpy(&addr, &pptr[4], (plen + 7) / 8);
 549         if (plen % 8) {
 550                 ((u_char *)&addr)[(plen + 7) / 8 - 1] &=
 551                         ((0xff00 >> (plen % 8)) & 0xff);
 552         }
 553         /* the label may get offsetted by 4 bits so lets shift it right */
 554         snprintf(buf, buflen, "%s/%d, label:%u %s",
 555                  getname((u_char *)&addr),
 556                  plen,
 557                  EXTRACT_24BITS(pptr+1)>>4,
 558                  ((pptr[3]&1)==0) ? "(BOGUS: Bottom of Stack NOT set!)" : "(bottom)" );
 559
 560         return 4 + (plen + 7) / 8;
 561
 562 trunc:
 563         return -2;
 564 }
 565
 566 /*
 567  * bgp_vpn_ip_print
 568  *
 569  * print an ipv4 or ipv6 address into a buffer dependend on address length.
 570  */
 571 static char *
 572 bgp_vpn_ip_print (const u_char *pptr, u_int addr_length) {
 573
 574     /* worst case string is s fully formatted v6 address */
 575     static char addr[sizeof("1234:5678:89ab:cdef:1234:5678:89ab:cdef")];
 576     char *pos = addr;
 577
 578     switch(addr_length) {
 579     case (sizeof(struct in_addr) << 3): /* 32 */
 580         TCHECK2(pptr[0], sizeof(struct in_addr));
 581         snprintf(pos, sizeof(addr), "%s", ipaddr_string(pptr));
 582         break;
 583 #ifdef INET6
 584     case (sizeof(struct in6_addr) << 3): /* 128 */
 585         TCHECK2(pptr[0], sizeof(struct in6_addr));
 586         snprintf(pos, sizeof(addr), "%s", ip6addr_string(pptr));
 587         break;
 588 #endif
 589     default:
 590         snprintf(pos, sizeof(addr), "bogus address length %u", addr_length);
 591         break;
 592     }
 593     pos += strlen(pos);
 594
 595 trunc:
 596     *(pos) = '\0';
 597     return (addr);
 598 }
 599
 600 /*
 601  * bgp_vpn_sg_print
 602  *
 603  * print an multicast s,g entry into a buffer.
 604  * the s,g entry is encoded like this.
 605  *
 606  * +-----------------------------------+
 607  * | Multicast Source Length (1 octet) |
 608  * +-----------------------------------+
 609  * |   Multicast Source (Variable)     |
 610  * +-----------------------------------+
 611  * |  Multicast Group Length (1 octet) |
 612  * +-----------------------------------+
 613  * |  Multicast Group   (Variable)     |
 614  * +-----------------------------------+
 615  *
 616  * return the number of bytes read from the wire.
 617  */
 618 static int
 619 bgp_vpn_sg_print (const u_char *pptr, char *buf, u_int buflen) {
 620
 621     u_int8_t addr_length;
 622     u_int total_length, offset;
 623
 624     total_length = 0;
 625
 626     /* Source address length, encoded in bits */
 627     TCHECK2(pptr[0], 1);
 628     addr_length =  *pptr++;
 629
 630     /* Source address */
 631     TCHECK2(pptr[0], (addr_length >> 3));
 632     total_length += (addr_length >> 3) + 1;
 633     offset = strlen(buf);
 634     if (addr_length) {
 635         snprintf(buf + offset, buflen - offset, ", Source %s",
 636                  bgp_vpn_ip_print(pptr, addr_length));
 637         pptr += (addr_length >> 3);
 638     }
 639
 640     /* Group address length, encoded in bits */
 641     TCHECK2(pptr[0], 1);
 642     addr_length =  *pptr++;
 643
 644     /* Group address */
 645     TCHECK2(pptr[0], (addr_length >> 3));
 646     total_length += (addr_length >> 3) + 1;
 647     offset = strlen(buf);
 648     if (addr_length) {
 649         snprintf(buf + offset, buflen - offset, ", Group %s",
 650                  bgp_vpn_ip_print(pptr, addr_length));
 651         pptr += (addr_length >> 3);
 652     }
 653
 654 trunc:
 655     return (total_length);
 656 }
 657
 658
 659 /* RDs and RTs share the same semantics
 660  * we use bgp_vpn_rd_print for
 661  * printing route targets inside a NLRI */
 662 char *
 663 bgp_vpn_rd_print (const u_char *pptr) {
 664
 665    /* allocate space for the largest possible string */
 666     static char rd[sizeof("xxxxxxxxxx:xxxxx (xxx.xxx.xxx.xxx:xxxxx)")];
 667     char *pos = rd;
 668
 669     /* ok lets load the RD format */
 670     switch (EXTRACT_16BITS(pptr)) {
 671
 672         /* 2-byte-AS:number fmt*/
 673     case 0:
 674         snprintf(pos, sizeof(rd) - (pos - rd), "%u:%u (= %u.%u.%u.%u)",
 675                  EXTRACT_16BITS(pptr+2),
 676                  EXTRACT_32BITS(pptr+4),
 677                  *(pptr+4), *(pptr+5), *(pptr+6), *(pptr+7));
 678         break;
 679         /* IP-address:AS fmt*/
 680
 681     case 1:
 682         snprintf(pos, sizeof(rd) - (pos - rd), "%u.%u.%u.%u:%u",
 683             *(pptr+2), *(pptr+3), *(pptr+4), *(pptr+5), EXTRACT_16BITS(pptr+6));
 684         break;
 685
 686         /* 4-byte-AS:number fmt*/
 687     case 2:
 688         snprintf(pos, sizeof(rd) - (pos - rd), "%s:%u (%u.%u.%u.%u:%u)",
 689             as_printf(astostr, sizeof(astostr), EXTRACT_32BITS(pptr+2)),
 690             EXTRACT_16BITS(pptr+6), *(pptr+2), *(pptr+3), *(pptr+4),
 691             *(pptr+5), EXTRACT_16BITS(pptr+6));
 692         break;
 693     default:
 694         snprintf(pos, sizeof(rd) - (pos - rd), "unknown RD format");
 695         break;
 696     }
 697     pos += strlen(pos);
 698     *(pos) = '\0';
 699     return (rd);
 700 }
 701
 702 static int
 703 decode_rt_routing_info(const u_char *pptr, char *buf, u_int buflen)
 704 {
 705         u_int8_t route_target[8];
 706         u_int plen;
 707
 708         TCHECK(pptr[0]);
 709         plen = pptr[0];   /* get prefix length */
 710
 711         if (0 == plen)
 712                 return 1; /* default route target */
 713
 714         if (32 > plen)
 715                 return -1;
 716
 717         plen-=32; /* adjust prefix length */
 718
 719         if (64 < plen)
 720                 return -1;
 721
 722         memset(&route_target, 0, sizeof(route_target));
 723         TCHECK2(pptr[1], (plen + 7) / 8);
 724         memcpy(&route_target, &pptr[1], (plen + 7) / 8);
 725         if (plen % 8) {
 726                 ((u_char *)&route_target)[(plen + 7) / 8 - 1] &=
 727                         ((0xff00 >> (plen % 8)) & 0xff);
 728         }
 729         snprintf(buf, buflen, "origin AS: %s, route target %s",
 730             as_printf(astostr, sizeof(astostr), EXTRACT_32BITS(pptr+1)),
 731             bgp_vpn_rd_print((u_char *)&route_target));
 732
 733         return 5 + (plen + 7) / 8;
 734
 735 trunc:
 736         return -2;
 737 }
 738
 739 static int
 740 decode_labeled_vpn_prefix4(const u_char *pptr, char *buf, u_int buflen)
 741 {
 742         struct in_addr addr;
 743         u_int plen;
 744
 745         TCHECK(pptr[0]);
 746         plen = pptr[0];   /* get prefix length */
 747
 748         if ((24+64) > plen)
 749                 return -1;
 750
 751         plen-=(24+64); /* adjust prefixlen - labellength - RD len*/
 752
 753         if (32 < plen)
 754                 return -1;
 755
 756         memset(&addr, 0, sizeof(addr));
 757         TCHECK2(pptr[12], (plen + 7) / 8);
 758         memcpy(&addr, &pptr[12], (plen + 7) / 8);
 759         if (plen % 8) {
 760                 ((u_char *)&addr)[(plen + 7) / 8 - 1] &=
 761                         ((0xff00 >> (plen % 8)) & 0xff);
 762         }
 763         /* the label may get offsetted by 4 bits so lets shift it right */
 764         snprintf(buf, buflen, "RD: %s, %s/%d, label:%u %s",
 765                  bgp_vpn_rd_print(pptr+4),
 766                  getname((u_char *)&addr),
 767                  plen,
 768                  EXTRACT_24BITS(pptr+1)>>4,
 769                  ((pptr[3]&1)==0) ? "(BOGUS: Bottom of Stack NOT set!)" : "(bottom)" );
 770
 771         return 12 + (plen + 7) / 8;
 772
 773 trunc:
 774         return -2;
 775 }
 776
 777 /*
 778  * +-------------------------------+
 779  * |                               |
 780  * |  RD:IPv4-address (12 octets)  |
 781  * |                               |
 782  * +-------------------------------+
 783  * |  MDT Group-address (4 octets) |
 784  * +-------------------------------+
 785  */
 786
 787 #define MDT_VPN_NLRI_LEN 16
 788
 789 static int
 790 decode_mdt_vpn_nlri(const u_char *pptr, char *buf, u_int buflen)
 791 {
 792
 793     const u_char *rd;
 794     const u_char *vpn_ip;
 795
 796     TCHECK(pptr[0]);
 797
 798     /* if the NLRI is not predefined length, quit.*/
 799     if (*pptr != MDT_VPN_NLRI_LEN * NBBY)
 800         return -1;
 801     pptr++;
 802
 803     /* RD */
 804     TCHECK2(pptr[0], 8);
 805     rd = pptr;
 806     pptr+=8;
 807
 808     /* IPv4 address */
 809     TCHECK2(pptr[0], sizeof(struct in_addr));
 810     vpn_ip = pptr;
 811     pptr+=sizeof(struct in_addr);
 812
 813     /* MDT Group Address */
 814     TCHECK2(pptr[0], sizeof(struct in_addr));
 815
 816     snprintf(buf, buflen, "RD: %s, VPN IP Address: %s, MC Group Address: %s",
 817              bgp_vpn_rd_print(rd), ipaddr_string(vpn_ip), ipaddr_string(pptr));
 818
 819     return MDT_VPN_NLRI_LEN + 1;
 820
 821  trunc:
 822
 823 return -2;
 824 }
 825
 826 #define BGP_MULTICAST_VPN_ROUTE_TYPE_INTRA_AS_I_PMSI   1
 827 #define BGP_MULTICAST_VPN_ROUTE_TYPE_INTER_AS_I_PMSI   2
 828 #define BGP_MULTICAST_VPN_ROUTE_TYPE_S_PMSI            3
 829 #define BGP_MULTICAST_VPN_ROUTE_TYPE_INTRA_AS_SEG_LEAF 4
 830 #define BGP_MULTICAST_VPN_ROUTE_TYPE_SOURCE_ACTIVE     5
 831 #define BGP_MULTICAST_VPN_ROUTE_TYPE_SHARED_TREE_JOIN  6
 832 #define BGP_MULTICAST_VPN_ROUTE_TYPE_SOURCE_TREE_JOIN  7
 833
 834 static struct tok bgp_multicast_vpn_route_type_values[] = {
 835     { BGP_MULTICAST_VPN_ROUTE_TYPE_INTRA_AS_I_PMSI, "Intra-AS I-PMSI"},
 836     { BGP_MULTICAST_VPN_ROUTE_TYPE_INTER_AS_I_PMSI, "Inter-AS I-PMSI"},
 837     { BGP_MULTICAST_VPN_ROUTE_TYPE_S_PMSI, "S-PMSI"},
 838     { BGP_MULTICAST_VPN_ROUTE_TYPE_INTRA_AS_SEG_LEAF, "Intra-AS Segment-Leaf"},
 839     { BGP_MULTICAST_VPN_ROUTE_TYPE_SOURCE_ACTIVE, "Source-Active"},
 840     { BGP_MULTICAST_VPN_ROUTE_TYPE_SHARED_TREE_JOIN, "Shared Tree Join"},
 841     { BGP_MULTICAST_VPN_ROUTE_TYPE_SOURCE_TREE_JOIN, "Source Tree Join"},
 842 };
 843
 844 static int
 845 decode_multicast_vpn(const u_char *pptr, char *buf, u_int buflen)
 846 {
 847         u_int8_t route_type, route_length, addr_length, sg_length;
 848         u_int offset;
 849
 850         TCHECK2(pptr[0], 2);
 851         route_type = *pptr++;
 852         route_length = *pptr++;
 853
 854         snprintf(buf, buflen, "Route-Type: %s (%u), length: %u",
 855                  tok2str(bgp_multicast_vpn_route_type_values,
 856                          "Unknown", route_type),
 857                  route_type, route_length);
 858
 859         switch(route_type) {
 860         case BGP_MULTICAST_VPN_ROUTE_TYPE_INTRA_AS_I_PMSI:
 861             TCHECK2(pptr[0], BGP_VPN_RD_LEN);
 862             offset = strlen(buf);
 863             snprintf(buf + offset, buflen - offset, ", RD: %s, Originator %s",
 864                      bgp_vpn_rd_print(pptr),
 865                      bgp_vpn_ip_print(pptr + BGP_VPN_RD_LEN,
 866                                       (route_length - BGP_VPN_RD_LEN) << 3));
 867             break;
 868         case BGP_MULTICAST_VPN_ROUTE_TYPE_INTER_AS_I_PMSI:
 869             TCHECK2(pptr[0], BGP_VPN_RD_LEN + 4);
 870             offset = strlen(buf);
 871             snprintf(buf + offset, buflen - offset, ", RD: %s, Source-AS %s",
 872                 bgp_vpn_rd_print(pptr),
 873                 as_printf(astostr, sizeof(astostr),
 874                 EXTRACT_32BITS(pptr + BGP_VPN_RD_LEN)));
 875             break;
 876
 877         case BGP_MULTICAST_VPN_ROUTE_TYPE_S_PMSI:
 878             TCHECK2(pptr[0], BGP_VPN_RD_LEN);
 879             offset = strlen(buf);
 880             snprintf(buf + offset, buflen - offset, ", RD: %s",
 881                      bgp_vpn_rd_print(pptr));
 882             pptr += BGP_VPN_RD_LEN;
 883
 884             sg_length = bgp_vpn_sg_print(pptr, buf, buflen);
 885             addr_length =  route_length - sg_length;
 886
 887             TCHECK2(pptr[0], addr_length);
 888             offset = strlen(buf);
 889             snprintf(buf + offset, buflen - offset, ", Originator %s",
 890                      bgp_vpn_ip_print(pptr, addr_length << 3));
 891             break;
 892
 893         case BGP_MULTICAST_VPN_ROUTE_TYPE_SOURCE_ACTIVE:
 894             TCHECK2(pptr[0], BGP_VPN_RD_LEN);
 895             offset = strlen(buf);
 896             snprintf(buf + offset, buflen - offset, ", RD: %s",
 897                      bgp_vpn_rd_print(pptr));
 898             pptr += BGP_VPN_RD_LEN;
 899
 900             bgp_vpn_sg_print(pptr, buf, buflen);
 901             break;
 902
 903         case BGP_MULTICAST_VPN_ROUTE_TYPE_SHARED_TREE_JOIN: /* fall through */
 904         case BGP_MULTICAST_VPN_ROUTE_TYPE_SOURCE_TREE_JOIN:
 905             TCHECK2(pptr[0], BGP_VPN_RD_LEN);
 906             offset = strlen(buf);
 907             snprintf(buf + offset, buflen - offset, ", RD: %s, Source-AS %s",
 908                 bgp_vpn_rd_print(pptr),
 909                 as_printf(astostr, sizeof(astostr),
 910                 EXTRACT_32BITS(pptr + BGP_VPN_RD_LEN)));
 911             pptr += BGP_VPN_RD_LEN;
 912
 913             bgp_vpn_sg_print(pptr, buf, buflen);
 914             break;
 915
 916             /*
 917              * no per route-type printing yet.
 918              */
 919         case BGP_MULTICAST_VPN_ROUTE_TYPE_INTRA_AS_SEG_LEAF:
 920         default:
 921             break;
 922         }
 923
 924         return route_length + 2;
 925
 926 trunc:
 927         return -2;
 928 }
 929
 930 /*
 931  * As I remember, some versions of systems have an snprintf() that
 932  * returns -1 if the buffer would have overflowed.  If the return
 933  * value is negative, set buflen to 0, to indicate that we've filled
 934  * the buffer up.
 935  *
 936  * If the return value is greater than buflen, that means that
 937  * the buffer would have overflowed; again, set buflen to 0 in
 938  * that case.
 939  */
 940 #define UPDATE_BUF_BUFLEN(buf, buflen, strlen) \
 941     if (strlen<0) \
 942         buflen=0; \
 943     else if ((u_int)strlen>buflen) \
 944         buflen=0; \
 945     else { \
 946         buflen-=strlen; \
 947         buf+=strlen; \
 948     }
 949
 950 static int
 951 decode_labeled_vpn_l2(const u_char *pptr, char *buf, u_int buflen)
 952 {
 953         int plen,tlen,strlen,tlv_type,tlv_len,ttlv_len;
 954
 955         TCHECK2(pptr[0], 2);
 956         plen=EXTRACT_16BITS(pptr);
 957         tlen=plen;
 958         pptr+=2;
 959         /* Old and new L2VPN NLRI share AFI/SAFI
 960          *   -> Assume a 12 Byte-length NLRI is auto-discovery-only
 961          *      and > 17 as old format. Complain for the middle case
 962          */
 963         if (plen==12) {
 964             /* assume AD-only with RD, BGPNH */
 965             TCHECK2(pptr[0],12);
 966             buf[0]='\0';
 967             strlen=snprintf(buf, buflen, "RD: %s, BGPNH: %s",
 968                             bgp_vpn_rd_print(pptr),
 969                             /* need something like getname() here */
 970                             getname(pptr+8)
 971                             );
 972             UPDATE_BUF_BUFLEN(buf, buflen, strlen);
 973             pptr+=12;
 974             tlen-=12;
 975             return plen;
 976         } else if (plen>17) {
 977             /* assume old format */
 978             /* RD, ID, LBLKOFF, LBLBASE */
 979
 980             TCHECK2(pptr[0],15);
 981             buf[0]='\0';
 982             strlen=snprintf(buf, buflen, "RD: %s, CE-ID: %u, Label-Block Offset: %u, Label Base %u",
 983                             bgp_vpn_rd_print(pptr),
 984                             EXTRACT_16BITS(pptr+8),
 985                             EXTRACT_16BITS(pptr+10),
 986                             EXTRACT_24BITS(pptr+12)>>4); /* the label is offsetted by 4 bits so lets shift it right */
 987             UPDATE_BUF_BUFLEN(buf, buflen, strlen);
 988             pptr+=15;
 989             tlen-=15;
 990
 991             /* ok now the variable part - lets read out TLVs*/
 992             while (tlen>0) {
 993                 if (tlen < 3)
 994                     return -1;
 995                 TCHECK2(pptr[0], 3);
 996                 tlv_type=*pptr++;
 997                 tlv_len=EXTRACT_16BITS(pptr);
 998                 ttlv_len=tlv_len;
 999                 pptr+=2;
1000
1001                 switch(tlv_type) {
1002                 case 1:
1003                     if (buflen!=0) {
1004                         strlen=snprintf(buf,buflen, "\n\t\tcircuit status vector (%u) length: %u: 0x",
1005                                         tlv_type,
1006                                         tlv_len);
1007                         UPDATE_BUF_BUFLEN(buf, buflen, strlen);
1008                     }
1009                     ttlv_len=ttlv_len/8+1; /* how many bytes do we need to read ? */
1010                     while (ttlv_len>0) {
1011                         TCHECK(pptr[0]);
1012                         if (buflen!=0) {
1013                             strlen=snprintf(buf,buflen, "%02x",*pptr++);
1014                             UPDATE_BUF_BUFLEN(buf, buflen, strlen);
1015                         }
1016                         ttlv_len--;
1017                     }
1018                     break;
1019                 default:
1020                     if (buflen!=0) {
1021                         strlen=snprintf(buf,buflen, "\n\t\tunknown TLV #%u, length: %u",
1022                                         tlv_type,
1023                                         tlv_len);
1024                         UPDATE_BUF_BUFLEN(buf, buflen, strlen);
1025                     }
1026                     break;
1027                 }
1028                 tlen-=(tlv_len<<3); /* the tlv-length is expressed in bits so lets shift it right */
1029             }
1030             return plen+2;
1031
1032         } else {
1033             /* complain bitterly ? */
1034             /* fall through */
1035             goto trunc;
1036         }
1037
1038 trunc:
1039         return -2;
1040 }
1041
1042 #ifdef INET6
1043 int
1044 decode_prefix6(const u_char *pd, char *buf, u_int buflen)
1045 {
1046         struct in6_addr addr;
1047         u_int plen;
1048
1049         TCHECK(pd[0]);
1050         plen = pd[0];
1051         if (128 < plen)
1052                 return -1;
1053
1054         memset(&addr, 0, sizeof(addr));
1055         TCHECK2(pd[1], (plen + 7) / 8);
1056         memcpy(&addr, &pd[1], (plen + 7) / 8);
1057         if (plen % 8) {
1058                 addr.s6_addr[(plen + 7) / 8 - 1] &=
1059                         ((0xff00 >> (plen % 8)) & 0xff);
1060         }
1061         snprintf(buf, buflen, "%s/%d", getname6((u_char *)&addr), plen);
1062         return 1 + (plen + 7) / 8;
1063
1064 trunc:
1065         return -2;
1066 }
1067
1068 static int
1069 decode_labeled_prefix6(const u_char *pptr, char *buf, u_int buflen)
1070 {
1071         struct in6_addr addr;
1072         u_int plen;
1073
1074         TCHECK(pptr[0]);
1075         plen = pptr[0]; /* get prefix length */
1076
1077         if (24 > plen)
1078                 return -1;
1079
1080         plen-=24; /* adjust prefixlen - labellength */
1081
1082         if (128 < plen)
1083                 return -1;
1084
1085         memset(&addr, 0, sizeof(addr));
1086         TCHECK2(pptr[4], (plen + 7) / 8);
1087         memcpy(&addr, &pptr[4], (plen + 7) / 8);
1088         if (plen % 8) {
1089                 addr.s6_addr[(plen + 7) / 8 - 1] &=
1090                         ((0xff00 >> (plen % 8)) & 0xff);
1091         }
1092         /* the label may get offsetted by 4 bits so lets shift it right */
1093         snprintf(buf, buflen, "%s/%d, label:%u %s",
1094                  getname6((u_char *)&addr),
1095                  plen,
1096                  EXTRACT_24BITS(pptr+1)>>4,
1097                  ((pptr[3]&1)==0) ? "(BOGUS: Bottom of Stack NOT set!)" : "(bottom)" );
1098
1099         return 4 + (plen + 7) / 8;
1100
1101 trunc:
1102         return -2;
1103 }
1104
1105 static int
1106 decode_labeled_vpn_prefix6(const u_char *pptr, char *buf, u_int buflen)
1107 {
1108         struct in6_addr addr;
1109         u_int plen;
1110
1111         TCHECK(pptr[0]);
1112         plen = pptr[0];   /* get prefix length */
1113
1114         if ((24+64) > plen)
1115                 return -1;
1116
1117         plen-=(24+64); /* adjust prefixlen - labellength - RD len*/
1118
1119         if (128 < plen)
1120                 return -1;
1121
1122         memset(&addr, 0, sizeof(addr));
1123         TCHECK2(pptr[12], (plen + 7) / 8);
1124         memcpy(&addr, &pptr[12], (plen + 7) / 8);
1125         if (plen % 8) {
1126                 addr.s6_addr[(plen + 7) / 8 - 1] &=
1127                         ((0xff00 >> (plen % 8)) & 0xff);
1128         }
1129         /* the label may get offsetted by 4 bits so lets shift it right */
1130         snprintf(buf, buflen, "RD: %s, %s/%d, label:%u %s",
1131                  bgp_vpn_rd_print(pptr+4),
1132                  getname6((u_char *)&addr),
1133                  plen,
1134                  EXTRACT_24BITS(pptr+1)>>4,
1135                  ((pptr[3]&1)==0) ? "(BOGUS: Bottom of Stack NOT set!)" : "(bottom)" );
1136
1137         return 12 + (plen + 7) / 8;
1138
1139 trunc:
1140         return -2;
1141 }
1142 #endif
1143
1144 static int
1145 decode_clnp_prefix(const u_char *pptr, char *buf, u_int buflen)
1146 {
1147         u_int8_t addr[19];
1148         u_int plen;
1149
1150         TCHECK(pptr[0]);
1151         plen = pptr[0]; /* get prefix length */
1152
1153         if (152 < plen)
1154                 return -1;
1155
1156         memset(&addr, 0, sizeof(addr));
1157         TCHECK2(pptr[4], (plen + 7) / 8);
1158         memcpy(&addr, &pptr[4], (plen + 7) / 8);
1159         if (plen % 8) {
1160                 addr[(plen + 7) / 8 - 1] &=
1161                         ((0xff00 >> (plen % 8)) & 0xff);
1162         }
1163         snprintf(buf, buflen, "%s/%d",
1164                  isonsap_string(addr,(plen + 7) / 8),
1165                  plen);
1166
1167         return 1 + (plen + 7) / 8;
1168
1169 trunc:
1170         return -2;
1171 }
1172
1173 static int
1174 decode_labeled_vpn_clnp_prefix(const u_char *pptr, char *buf, u_int buflen)
1175 {
1176         u_int8_t addr[19];
1177         u_int plen;
1178
1179         TCHECK(pptr[0]);
1180         plen = pptr[0];   /* get prefix length */
1181
1182         if ((24+64) > plen)
1183                 return -1;
1184
1185         plen-=(24+64); /* adjust prefixlen - labellength - RD len*/
1186
1187         if (152 < plen)
1188                 return -1;
1189
1190         memset(&addr, 0, sizeof(addr));
1191         TCHECK2(pptr[12], (plen + 7) / 8);
1192         memcpy(&addr, &pptr[12], (plen + 7) / 8);
1193         if (plen % 8) {
1194                 addr[(plen + 7) / 8 - 1] &=
1195                         ((0xff00 >> (plen % 8)) & 0xff);
1196         }
1197         /* the label may get offsetted by 4 bits so lets shift it right */
1198         snprintf(buf, buflen, "RD: %s, %s/%d, label:%u %s",
1199                  bgp_vpn_rd_print(pptr+4),
1200                  isonsap_string(addr,(plen + 7) / 8),
1201                  plen,
1202                  EXTRACT_24BITS(pptr+1)>>4,
1203                  ((pptr[3]&1)==0) ? "(BOGUS: Bottom of Stack NOT set!)" : "(bottom)" );
1204
1205         return 12 + (plen + 7) / 8;
1206
1207 trunc:
1208         return -2;
1209 }
1210
1211 /*
1212  * bgp_attr_get_as_size
1213  *
1214  * Try to find the size of the ASs encoded in an as-path. It is not obvious, as
1215  * both Old speakers that do not support 4 byte AS, and the new speakers that do
1216  * support, exchange AS-Path with the same path-attribute type value 0x02.
1217  */
1218 static int
1219 bgp_attr_get_as_size (u_int8_t bgpa_type, const u_char *pptr, int len)
1220 {
1221     const u_char *tptr = pptr;
1222
1223     /*
1224      * If the path attribute is the optional AS4 path type, then we already
1225      * know, that ASs must be encoded in 4 byte format.
1226      */
1227     if (bgpa_type == BGPTYPE_AS4_PATH) {
1228         return 4;
1229     }
1230
1231     /*
1232      * Let us assume that ASs are of 2 bytes in size, and check if the AS-Path
1233      * TLV is good. If not, ask the caller to try with AS encoded as 4 bytes
1234      * each.
1235      */
1236     while (tptr < pptr + len) {
1237         TCHECK(tptr[0]);
1238
1239         /*
1240          * If we do not find a valid segment type, our guess might be wrong.
1241          */
1242         if (tptr[0] < BGP_AS_SEG_TYPE_MIN || tptr[0] > BGP_AS_SEG_TYPE_MAX) {
1243             goto trunc;
1244         }
1245         TCHECK(tptr[1]);
1246         tptr += 2 + tptr[1] * 2;
1247     }
1248
1249     /*
1250      * If we correctly reached end of the AS path attribute data content,
1251      * then most likely ASs were indeed encoded as 2 bytes.
1252      */
1253     if (tptr == pptr + len) {
1254         return 2;
1255     }
1256
1257 trunc:
1258
1259     /*
1260      * We can come here, either we did not have enough data, or if we
1261      * try to decode 4 byte ASs in 2 byte format. Either way, return 4,
1262      * so that calller can try to decode each AS as of 4 bytes. If indeed
1263      * there was not enough data, it will crib and end the parse anyways.
1264      */
1265    return 4;
1266 }
1267
1268 static int
1269 bgp_attr_print(const struct bgp_attr *attr, const u_char *pptr, int len)
1270 {
1271         int i;
1272         u_int16_t af;
1273         u_int8_t safi, snpa, nhlen;
1274         union { /* copy buffer for bandwidth values */
1275             float f;
1276             u_int32_t i;
1277         } bw;
1278         int advance;
1279         int tlen;
1280         const u_char *tptr;
1281         char buf[MAXHOSTNAMELEN + 100];
1282         char tokbuf[TOKBUFSIZE];
1283         int  as_size;
1284
1285         tptr = pptr;
1286         tlen=len;
1287
1288         switch (attr->bgpa_type) {
1289         case BGPTYPE_ORIGIN:
1290                 if (len != 1)
1291                         printf("invalid len");
1292                 else {
1293                         TCHECK(*tptr);
1294                         printf("%s", tok2strbuf(bgp_origin_values,
1295                                                 "Unknown Origin Typecode",
1296                                                 tptr[0],
1297                                                 tokbuf, sizeof(tokbuf)));
1298                 }
1299                 break;
1300
1301
1302         /*
1303          * Process AS4 byte path and AS2 byte path attributes here.
1304          */
1305         case BGPTYPE_AS4_PATH:
1306         case BGPTYPE_AS_PATH:
1307                 if (len % 2) {
1308                         printf("invalid len");
1309                         break;
1310                 }
1311                 if (!len) {
1312                         printf("empty");
1313                         break;
1314                 }
1315
1316                 /*
1317                  * BGP updates exchanged between New speakers that support 4
1318                  * byte AS, ASs are always encoded in 4 bytes. There is no
1319                  * definitive way to find this, just by the packet's
1320                  * contents. So, check for packet's TLV's sanity assuming
1321                  * 2 bytes first, and it does not pass, assume that ASs are
1322                  * encoded in 4 bytes format and move on.
1323                  */
1324                 as_size = bgp_attr_get_as_size(attr->bgpa_type, pptr, len);
1325
1326                 while (tptr < pptr + len) {
1327                         TCHECK(tptr[0]);
1328                         printf("%s", tok2strbuf(bgp_as_path_segment_open_values,
1329                                                 "?", tptr[0],
1330                                                 tokbuf, sizeof(tokbuf)));
1331                         for (i = 0; i < tptr[1] * as_size; i += as_size) {
1332                             TCHECK2(tptr[2 + i], as_size);
1333                             printf("%s ",
1334                                 as_printf(astostr, sizeof(astostr),
1335                                 as_size == 2 ?
1336                                 EXTRACT_16BITS(&tptr[2 + i]) :
1337                                 EXTRACT_32BITS(&tptr[2 + i])));
1338                         }
1339                         TCHECK(tptr[0]);
1340                         printf("%s", tok2strbuf(bgp_as_path_segment_close_values,
1341                                                 "?", tptr[0],
1342                                                 tokbuf, sizeof(tokbuf)));
1343                         TCHECK(tptr[1]);
1344                         tptr += 2 + tptr[1] * as_size;
1345                 }
1346                 break;
1347         case BGPTYPE_NEXT_HOP:
1348                 if (len != 4)
1349                         printf("invalid len");
1350                 else {
1351                         TCHECK2(tptr[0], 4);
1352                         printf("%s", getname(tptr));
1353                 }
1354                 break;
1355         case BGPTYPE_MULTI_EXIT_DISC:
1356         case BGPTYPE_LOCAL_PREF:
1357                 if (len != 4)
1358                         printf("invalid len");
1359                 else {
1360                         TCHECK2(tptr[0], 4);
1361                         printf("%u", EXTRACT_32BITS(tptr));
1362                 }
1363                 break;
1364         case BGPTYPE_ATOMIC_AGGREGATE:
1365                 if (len != 0)
1366                         printf("invalid len");
1367                 break;
1368         case BGPTYPE_AGGREGATOR:
1369
1370                 /*
1371                  * Depending on the AS encoded is of 2 bytes or of 4 bytes,
1372                  * the length of this PA can be either 6 bytes or 8 bytes.
1373                  */
1374                 if (len != 6 && len != 8) {
1375                     printf("invalid len");
1376                     break;
1377                 }
1378                 TCHECK2(tptr[0], len);
1379                 if (len == 6) {
1380                     printf(" AS #%s, origin %s",
1381                         as_printf(astostr, sizeof(astostr), EXTRACT_16BITS(tptr)),
1382                         getname(tptr + 2));
1383                 } else {
1384                     printf(" AS #%s, origin %s",
1385                         as_printf(astostr, sizeof(astostr),
1386                         EXTRACT_32BITS(tptr)), getname(tptr + 4));
1387                 }
1388                 break;
1389         case BGPTYPE_AGGREGATOR4:
1390                 if (len != 8) {
1391                         printf("invalid len");
1392                         break;
1393                 }
1394                 TCHECK2(tptr[0], 8);
1395                 printf(" AS #%s, origin %s",
1396                     as_printf(astostr, sizeof(astostr), EXTRACT_32BITS(tptr)),
1397                     getname(tptr + 4));
1398                 break;
1399         case BGPTYPE_COMMUNITIES:
1400                 if (len % 4) {
1401                         printf("invalid len");
1402                         break;
1403                 }
1404                 while (tlen>0) {
1405                         u_int32_t comm;
1406                         TCHECK2(tptr[0], 4);
1407                         comm = EXTRACT_32BITS(tptr);
1408                         switch (comm) {
1409                         case BGP_COMMUNITY_NO_EXPORT:
1410                                 printf(" NO_EXPORT");
1411                                 break;
1412                         case BGP_COMMUNITY_NO_ADVERT:
1413                                 printf(" NO_ADVERTISE");
1414                                 break;
1415                         case BGP_COMMUNITY_NO_EXPORT_SUBCONFED:
1416                                 printf(" NO_EXPORT_SUBCONFED");
1417                                 break;
1418                         default:
1419                                 printf("%u:%u%s",
1420                                        (comm >> 16) & 0xffff,
1421                                        comm & 0xffff,
1422                                        (tlen>4) ? ", " : "");
1423                                 break;
1424                         }
1425                         tlen -=4;
1426                         tptr +=4;
1427                 }
1428                 break;
1429         case BGPTYPE_ORIGINATOR_ID:
1430                 if (len != 4) {
1431                         printf("invalid len");
1432                         break;
1433                 }
1434                 TCHECK2(tptr[0], 4);
1435                 printf("%s",getname(tptr));
1436                 break;
1437         case BGPTYPE_CLUSTER_LIST:
1438                 if (len % 4) {
1439                         printf("invalid len");
1440                         break;
1441                 }
1442                 while (tlen>0) {
1443                         TCHECK2(tptr[0], 4);
1444                         printf("%s%s",
1445                                getname(tptr),
1446                                 (tlen>4) ? ", " : "");
1447                         tlen -=4;
1448                         tptr +=4;
1449                 }
1450                 break;
1451         case BGPTYPE_MP_REACH_NLRI:
1452                 TCHECK2(tptr[0], 3);
1453                 af = EXTRACT_16BITS(tptr);
1454                 safi = tptr[2];
1455
1456                 printf("\n\t    AFI: %s (%u), %sSAFI: %s (%u)",
1457                        tok2strbuf(af_values, "Unknown AFI", af,
1458                                   tokbuf, sizeof(tokbuf)),
1459                        af,
1460                        (safi>128) ? "vendor specific " : "", /* 128 is meanwhile wellknown */
1461                        tok2strbuf(bgp_safi_values, "Unknown SAFI", safi,
1462                                   tokbuf, sizeof(tokbuf)),
1463                        safi);
1464
1465                 switch(af<<8 | safi) {
1466                 case (AFNUM_INET<<8 | SAFNUM_UNICAST):
1467                 case (AFNUM_INET<<8 | SAFNUM_MULTICAST):
1468                 case (AFNUM_INET<<8 | SAFNUM_UNIMULTICAST):
1469                 case (AFNUM_INET<<8 | SAFNUM_LABUNICAST):
1470                 case (AFNUM_INET<<8 | SAFNUM_RT_ROUTING_INFO):
1471                 case (AFNUM_INET<<8 | SAFNUM_VPNUNICAST):
1472                 case (AFNUM_INET<<8 | SAFNUM_VPNMULTICAST):
1473                 case (AFNUM_INET<<8 | SAFNUM_VPNUNIMULTICAST):
1474                 case (AFNUM_INET<<8 | SAFNUM_MULTICAST_VPN):
1475                 case (AFNUM_INET<<8 | SAFNUM_MDT):
1476 #ifdef INET6
1477                 case (AFNUM_INET6<<8 | SAFNUM_UNICAST):
1478                 case (AFNUM_INET6<<8 | SAFNUM_MULTICAST):
1479                 case (AFNUM_INET6<<8 | SAFNUM_UNIMULTICAST):
1480                 case (AFNUM_INET6<<8 | SAFNUM_LABUNICAST):
1481                 case (AFNUM_INET6<<8 | SAFNUM_VPNUNICAST):
1482                 case (AFNUM_INET6<<8 | SAFNUM_VPNMULTICAST):
1483                 case (AFNUM_INET6<<8 | SAFNUM_VPNUNIMULTICAST):
1484 #endif
1485                 case (AFNUM_NSAP<<8 | SAFNUM_UNICAST):
1486                 case (AFNUM_NSAP<<8 | SAFNUM_MULTICAST):
1487                 case (AFNUM_NSAP<<8 | SAFNUM_UNIMULTICAST):
1488                 case (AFNUM_NSAP<<8 | SAFNUM_VPNUNICAST):
1489                 case (AFNUM_NSAP<<8 | SAFNUM_VPNMULTICAST):
1490                 case (AFNUM_NSAP<<8 | SAFNUM_VPNUNIMULTICAST):
1491                 case (AFNUM_L2VPN<<8 | SAFNUM_VPNUNICAST):
1492                 case (AFNUM_L2VPN<<8 | SAFNUM_VPNMULTICAST):
1493                 case (AFNUM_L2VPN<<8 | SAFNUM_VPNUNIMULTICAST):
1494                 case (AFNUM_VPLS<<8 | SAFNUM_VPLS):
1495                     break;
1496                 default:
1497                     TCHECK2(tptr[0], tlen);
1498                     printf("\n\t    no AFI %u / SAFI %u decoder",af,safi);
1499                     if (vflag <= 1)
1500                         print_unknown_data(tptr,"\n\t    ",tlen);
1501                     goto done;
1502                     break;
1503                 }
1504
1505                 tptr +=3;
1506
1507                 TCHECK(tptr[0]);
1508                 nhlen = tptr[0];
1509                 tlen = nhlen;
1510                 tptr++;
1511
1512                 if (tlen) {
1513                     printf("\n\t    nexthop: ");
1514                     while (tlen > 0) {
1515                         switch(af<<8 | safi) {
1516                         case (AFNUM_INET<<8 | SAFNUM_UNICAST):
1517                         case (AFNUM_INET<<8 | SAFNUM_MULTICAST):
1518                         case (AFNUM_INET<<8 | SAFNUM_UNIMULTICAST):
1519                         case (AFNUM_INET<<8 | SAFNUM_LABUNICAST):
1520                         case (AFNUM_INET<<8 | SAFNUM_RT_ROUTING_INFO):
1521                         case (AFNUM_INET<<8 | SAFNUM_MULTICAST_VPN):
1522                         case (AFNUM_INET<<8 | SAFNUM_MDT):
1523                             if (tlen < (int)sizeof(struct in_addr)) {
1524                                 printf("invalid len");
1525                                 tlen = 0;
1526                             } else {
1527                                 TCHECK2(tptr[0], sizeof(struct in_addr));
1528                                 printf("%s",getname(tptr));
1529                                 tlen -= sizeof(struct in_addr);
1530                                 tptr += sizeof(struct in_addr);
1531                             }
1532                             break;
1533                         case (AFNUM_INET<<8 | SAFNUM_VPNUNICAST):
1534                         case (AFNUM_INET<<8 | SAFNUM_VPNMULTICAST):
1535                         case (AFNUM_INET<<8 | SAFNUM_VPNUNIMULTICAST):
1536                             if (tlen < (int)(sizeof(struct in_addr)+BGP_VPN_RD_LEN)) {
1537                                 printf("invalid len");
1538                                 tlen = 0;
1539                             } else {
1540                                 TCHECK2(tptr[0], sizeof(struct in_addr)+BGP_VPN_RD_LEN);
1541                                 printf("RD: %s, %s",
1542                                        bgp_vpn_rd_print(tptr),
1543                                        getname(tptr+BGP_VPN_RD_LEN));
1544                                 tlen -= (sizeof(struct in_addr)+BGP_VPN_RD_LEN);
1545                                 tptr += (sizeof(struct in_addr)+BGP_VPN_RD_LEN);
1546                             }
1547                             break;
1548 #ifdef INET6
1549                         case (AFNUM_INET6<<8 | SAFNUM_UNICAST):
1550                         case (AFNUM_INET6<<8 | SAFNUM_MULTICAST):
1551                         case (AFNUM_INET6<<8 | SAFNUM_UNIMULTICAST):
1552                         case (AFNUM_INET6<<8 | SAFNUM_LABUNICAST):
1553                             if (tlen < (int)sizeof(struct in6_addr)) {
1554                                 printf("invalid len");
1555                                 tlen = 0;
1556                             } else {
1557                                 TCHECK2(tptr[0], sizeof(struct in6_addr));
1558                                 printf("%s", getname6(tptr));
1559                                 tlen -= sizeof(struct in6_addr);
1560                                 tptr += sizeof(struct in6_addr);
1561                             }
1562                             break;
1563                         case (AFNUM_INET6<<8 | SAFNUM_VPNUNICAST):
1564                         case (AFNUM_INET6<<8 | SAFNUM_VPNMULTICAST):
1565                         case (AFNUM_INET6<<8 | SAFNUM_VPNUNIMULTICAST):
1566                             if (tlen < (int)(sizeof(struct in6_addr)+BGP_VPN_RD_LEN)) {
1567                                 printf("invalid len");
1568                                 tlen = 0;
1569                             } else {
1570                                 TCHECK2(tptr[0], sizeof(struct in6_addr)+BGP_VPN_RD_LEN);
1571                                 printf("RD: %s, %s",
1572                                        bgp_vpn_rd_print(tptr),
1573                                        getname6(tptr+BGP_VPN_RD_LEN));
1574                                 tlen -= (sizeof(struct in6_addr)+BGP_VPN_RD_LEN);
1575                                 tptr += (sizeof(struct in6_addr)+BGP_VPN_RD_LEN);
1576                             }
1577                             break;
1578 #endif
1579                         case (AFNUM_VPLS<<8 | SAFNUM_VPLS):
1580                         case (AFNUM_L2VPN<<8 | SAFNUM_VPNUNICAST):
1581                         case (AFNUM_L2VPN<<8 | SAFNUM_VPNMULTICAST):
1582                         case (AFNUM_L2VPN<<8 | SAFNUM_VPNUNIMULTICAST):
1583                             if (tlen < (int)sizeof(struct in_addr)) {
1584                                 printf("invalid len");
1585                                 tlen = 0;
1586                             } else {
1587                                 TCHECK2(tptr[0], sizeof(struct in_addr));
1588                                 printf("%s", getname(tptr));
1589                                 tlen -= (sizeof(struct in_addr));
1590                                 tptr += (sizeof(struct in_addr));
1591                             }
1592                             break;
1593                         case (AFNUM_NSAP<<8 | SAFNUM_UNICAST):
1594                         case (AFNUM_NSAP<<8 | SAFNUM_MULTICAST):
1595                         case (AFNUM_NSAP<<8 | SAFNUM_UNIMULTICAST):
1596                             TCHECK2(tptr[0], tlen);
1597                             printf("%s",isonsap_string(tptr,tlen));
1598                             tptr += tlen;
1599                             tlen = 0;
1600                             break;
1601
1602                         case (AFNUM_NSAP<<8 | SAFNUM_VPNUNICAST):
1603                         case (AFNUM_NSAP<<8 | SAFNUM_VPNMULTICAST):
1604                         case (AFNUM_NSAP<<8 | SAFNUM_VPNUNIMULTICAST):
1605                             if (tlen < BGP_VPN_RD_LEN+1) {
1606                                 printf("invalid len");
1607                                 tlen = 0;
1608                             } else {
1609                                 TCHECK2(tptr[0], tlen);
1610                                 printf("RD: %s, %s",
1611                                        bgp_vpn_rd_print(tptr),
1612                                        isonsap_string(tptr+BGP_VPN_RD_LEN,tlen-BGP_VPN_RD_LEN));
1613                                 /* rfc986 mapped IPv4 address ? */
1614                                 if (EXTRACT_32BITS(tptr+BGP_VPN_RD_LEN) ==  0x47000601)
1615                                     printf(" = %s", getname(tptr+BGP_VPN_RD_LEN+4));
1616 #ifdef INET6
1617                                 /* rfc1888 mapped IPv6 address ? */
1618                                 else if (EXTRACT_24BITS(tptr+BGP_VPN_RD_LEN) ==  0x350000)
1619                                     printf(" = %s", getname6(tptr+BGP_VPN_RD_LEN+3));
1620 #endif
1621                                 tptr += tlen;
1622                                 tlen = 0;
1623                             }
1624                             break;
1625                         default:
1626                             TCHECK2(tptr[0], tlen);
1627                             printf("no AFI %u/SAFI %u decoder",af,safi);
1628                             if (vflag <= 1)
1629                                 print_unknown_data(tptr,"\n\t    ",tlen);
1630                             tptr += tlen;
1631                             tlen = 0;
1632                             goto done;
1633                             break;
1634                         }
1635                     }
1636                 }
1637                 printf(", nh-length: %u", nhlen);
1638                 tptr += tlen;
1639
1640                 TCHECK(tptr[0]);
1641                 snpa = tptr[0];
1642                 tptr++;
1643
1644                 if (snpa) {
1645                         printf("\n\t    %u SNPA", snpa);
1646                         for (/*nothing*/; snpa > 0; snpa--) {
1647                                 TCHECK(tptr[0]);
1648                                 printf("\n\t      %d bytes", tptr[0]);
1649                                 tptr += tptr[0] + 1;
1650                         }
1651                 } else {
1652                         printf(", no SNPA");
1653                 }
1654
1655                 while (len - (tptr - pptr) > 0) {
1656                     switch (af<<8 | safi) {
1657                     case (AFNUM_INET<<8 | SAFNUM_UNICAST):
1658                     case (AFNUM_INET<<8 | SAFNUM_MULTICAST):
1659                     case (AFNUM_INET<<8 | SAFNUM_UNIMULTICAST):
1660                         advance = decode_prefix4(tptr, buf, sizeof(buf));
1661                         if (advance == -1)
1662                             printf("\n\t    (illegal prefix length)");
1663                         else if (advance == -2)
1664                             goto trunc;
1665                         else
1666                             printf("\n\t      %s", buf);
1667                         break;
1668                     case (AFNUM_INET<<8 | SAFNUM_LABUNICAST):
1669                         advance = decode_labeled_prefix4(tptr, buf, sizeof(buf));
1670                         if (advance == -1)
1671                             printf("\n\t    (illegal prefix length)");
1672                         else if (advance == -2)
1673                             goto trunc;
1674                         else
1675                             printf("\n\t      %s", buf);
1676                         break;
1677                     case (AFNUM_INET<<8 | SAFNUM_VPNUNICAST):
1678                     case (AFNUM_INET<<8 | SAFNUM_VPNMULTICAST):
1679                     case (AFNUM_INET<<8 | SAFNUM_VPNUNIMULTICAST):
1680                         advance = decode_labeled_vpn_prefix4(tptr, buf, sizeof(buf));
1681                         if (advance == -1)
1682                             printf("\n\t    (illegal prefix length)");
1683                         else if (advance == -2)
1684                             goto trunc;
1685                         else
1686                             printf("\n\t      %s", buf);
1687                         break;
1688                     case (AFNUM_INET<<8 | SAFNUM_RT_ROUTING_INFO):
1689                         advance = decode_rt_routing_info(tptr, buf, sizeof(buf));
1690                         if (advance == -1)
1691                             printf("\n\t    (illegal prefix length)");
1692                         else if (advance == -2)
1693                             goto trunc;
1694                         else
1695                             printf("\n\t      %s", buf);
1696                         break;
1697                     case (AFNUM_INET<<8 | SAFNUM_MULTICAST_VPN): /* fall through */
1698                     case (AFNUM_INET6<<8 | SAFNUM_MULTICAST_VPN):
1699                         advance = decode_multicast_vpn(tptr, buf, sizeof(buf));
1700                         if (advance == -1)
1701                             printf("\n\t    (illegal prefix length)");
1702                         else if (advance == -2)
1703                             goto trunc;
1704                         else
1705                             printf("\n\t      %s", buf);
1706                         break;
1707
1708                     case (AFNUM_INET<<8 | SAFNUM_MDT):
1709                       advance = decode_mdt_vpn_nlri(tptr, buf, sizeof(buf));
1710                       if (advance == -1)
1711                             printf("\n\t    (illegal prefix length)");
1712                         else if (advance == -2)
1713                             goto trunc;
1714                         else
1715                             printf("\n\t      %s", buf);
1716                        break;
1717 #ifdef INET6
1718                     case (AFNUM_INET6<<8 | SAFNUM_UNICAST):
1719                     case (AFNUM_INET6<<8 | SAFNUM_MULTICAST):
1720                     case (AFNUM_INET6<<8 | SAFNUM_UNIMULTICAST):
1721                         advance = decode_prefix6(tptr, buf, sizeof(buf));
1722                         if (advance == -1)
1723                             printf("\n\t    (illegal prefix length)");
1724                         else if (advance == -2)
1725                             goto trunc;
1726                         else
1727                             printf("\n\t      %s", buf);
1728                         break;
1729                     case (AFNUM_INET6<<8 | SAFNUM_LABUNICAST):
1730                         advance = decode_labeled_prefix6(tptr, buf, sizeof(buf));
1731                         if (advance == -1)
1732                             printf("\n\t    (illegal prefix length)");
1733                         else if (advance == -2)
1734                             goto trunc;
1735                         else
1736                             printf("\n\t      %s", buf);
1737                         break;
1738                     case (AFNUM_INET6<<8 | SAFNUM_VPNUNICAST):
1739                     case (AFNUM_INET6<<8 | SAFNUM_VPNMULTICAST):
1740                     case (AFNUM_INET6<<8 | SAFNUM_VPNUNIMULTICAST):
1741                         advance = decode_labeled_vpn_prefix6(tptr, buf, sizeof(buf));
1742                         if (advance == -1)
1743                             printf("\n\t    (illegal prefix length)");
1744                         else if (advance == -2)
1745                             goto trunc;
1746                         else
1747                             printf("\n\t      %s", buf);
1748                         break;
1749 #endif
1750                     case (AFNUM_VPLS<<8 | SAFNUM_VPLS):
1751                     case (AFNUM_L2VPN<<8 | SAFNUM_VPNUNICAST):
1752                     case (AFNUM_L2VPN<<8 | SAFNUM_VPNMULTICAST):
1753                     case (AFNUM_L2VPN<<8 | SAFNUM_VPNUNIMULTICAST):
1754                         advance = decode_labeled_vpn_l2(tptr, buf, sizeof(buf));
1755                         if (advance == -1)
1756                             printf("\n\t    (illegal length)");
1757                         else if (advance == -2)
1758                             goto trunc;
1759                         else
1760                             printf("\n\t      %s", buf);
1761                         break;
1762                     case (AFNUM_NSAP<<8 | SAFNUM_UNICAST):
1763                     case (AFNUM_NSAP<<8 | SAFNUM_MULTICAST):
1764                     case (AFNUM_NSAP<<8 | SAFNUM_UNIMULTICAST):
1765                         advance = decode_clnp_prefix(tptr, buf, sizeof(buf));
1766                         if (advance == -1)
1767                             printf("\n\t    (illegal prefix length)");
1768                         else if (advance == -2)
1769                             goto trunc;
1770                         else
1771                             printf("\n\t      %s", buf);
1772                         break;
1773                     case (AFNUM_NSAP<<8 | SAFNUM_VPNUNICAST):
1774                     case (AFNUM_NSAP<<8 | SAFNUM_VPNMULTICAST):
1775                     case (AFNUM_NSAP<<8 | SAFNUM_VPNUNIMULTICAST):
1776                         advance = decode_labeled_vpn_clnp_prefix(tptr, buf, sizeof(buf));
1777                         if (advance == -1)
1778                             printf("\n\t    (illegal prefix length)");
1779                         else if (advance == -2)
1780                             goto trunc;
1781                         else
1782                             printf("\n\t      %s", buf);
1783                         break;
1784                     default:
1785                         TCHECK2(*tptr,tlen);
1786                         printf("\n\t    no AFI %u / SAFI %u decoder",af,safi);
1787                         if (vflag <= 1)
1788                             print_unknown_data(tptr,"\n\t    ",tlen);
1789                         advance = 0;
1790                         tptr = pptr + len;
1791                         break;
1792                     }
1793                     if (advance < 0)
1794                         break;
1795                     tptr += advance;
1796                 }
1797         done:
1798                 break;
1799
1800         case BGPTYPE_MP_UNREACH_NLRI:
1801                 TCHECK2(tptr[0], BGP_MP_NLRI_MINSIZE);
1802                 af = EXTRACT_16BITS(tptr);
1803                 safi = tptr[2];
1804
1805                 printf("\n\t    AFI: %s (%u), %sSAFI: %s (%u)",
1806                        tok2strbuf(af_values, "Unknown AFI", af,
1807                                   tokbuf, sizeof(tokbuf)),
1808                        af,
1809                        (safi>128) ? "vendor specific " : "", /* 128 is meanwhile wellknown */
1810                        tok2strbuf(bgp_safi_values, "Unknown SAFI", safi,
1811                                   tokbuf, sizeof(tokbuf)),
1812                        safi);
1813
1814                 if (len == BGP_MP_NLRI_MINSIZE)
1815                     printf("\n\t      End-of-Rib Marker (empty NLRI)");
1816
1817                 tptr += 3;
1818
1819                 while (len - (tptr - pptr) > 0) {
1820                     switch (af<<8 | safi) {
1821                     case (AFNUM_INET<<8 | SAFNUM_UNICAST):
1822                     case (AFNUM_INET<<8 | SAFNUM_MULTICAST):
1823                     case (AFNUM_INET<<8 | SAFNUM_UNIMULTICAST):
1824                         advance = decode_prefix4(tptr, buf, sizeof(buf));
1825                         if (advance == -1)
1826                             printf("\n\t    (illegal prefix length)");
1827                         else if (advance == -2)
1828                             goto trunc;
1829                         else
1830                             printf("\n\t      %s", buf);
1831                         break;
1832                     case (AFNUM_INET<<8 | SAFNUM_LABUNICAST):
1833                         advance = decode_labeled_prefix4(tptr, buf, sizeof(buf));
1834                         if (advance == -1)
1835                             printf("\n\t    (illegal prefix length)");
1836                         else if (advance == -2)
1837                             goto trunc;
1838                         else
1839                             printf("\n\t      %s", buf);
1840                         break;
1841                     case (AFNUM_INET<<8 | SAFNUM_VPNUNICAST):
1842                     case (AFNUM_INET<<8 | SAFNUM_VPNMULTICAST):
1843                     case (AFNUM_INET<<8 | SAFNUM_VPNUNIMULTICAST):
1844                         advance = decode_labeled_vpn_prefix4(tptr, buf, sizeof(buf));
1845                         if (advance == -1)
1846                             printf("\n\t    (illegal prefix length)");
1847                         else if (advance == -2)
1848                             goto trunc;
1849                         else
1850                             printf("\n\t      %s", buf);
1851                         break;
1852 #ifdef INET6
1853                     case (AFNUM_INET6<<8 | SAFNUM_UNICAST):
1854                     case (AFNUM_INET6<<8 | SAFNUM_MULTICAST):
1855                     case (AFNUM_INET6<<8 | SAFNUM_UNIMULTICAST):
1856                         advance = decode_prefix6(tptr, buf, sizeof(buf));
1857                         if (advance == -1)
1858                             printf("\n\t    (illegal prefix length)");
1859                         else if (advance == -2)
1860                             goto trunc;
1861                         else
1862                             printf("\n\t      %s", buf);
1863                         break;
1864                     case (AFNUM_INET6<<8 | SAFNUM_LABUNICAST):
1865                         advance = decode_labeled_prefix6(tptr, buf, sizeof(buf));
1866                         if (advance == -1)
1867                             printf("\n\t    (illegal prefix length)");
1868                         else if (advance == -2)
1869                             goto trunc;
1870                         else
1871                             printf("\n\t      %s", buf);
1872                         break;
1873                     case (AFNUM_INET6<<8 | SAFNUM_VPNUNICAST):
1874                     case (AFNUM_INET6<<8 | SAFNUM_VPNMULTICAST):
1875                     case (AFNUM_INET6<<8 | SAFNUM_VPNUNIMULTICAST):
1876                         advance = decode_labeled_vpn_prefix6(tptr, buf, sizeof(buf));
1877                         if (advance == -1)
1878                             printf("\n\t    (illegal prefix length)");
1879                         else if (advance == -2)
1880                             goto trunc;
1881                         else
1882                             printf("\n\t      %s", buf);
1883                         break;
1884 #endif
1885                     case (AFNUM_VPLS<<8 | SAFNUM_VPLS):
1886                     case (AFNUM_L2VPN<<8 | SAFNUM_VPNUNICAST):
1887                     case (AFNUM_L2VPN<<8 | SAFNUM_VPNMULTICAST):
1888                     case (AFNUM_L2VPN<<8 | SAFNUM_VPNUNIMULTICAST):
1889                         advance = decode_labeled_vpn_l2(tptr, buf, sizeof(buf));
1890                         if (advance == -1)
1891                             printf("\n\t    (illegal length)");
1892                         else if (advance == -2)
1893                             goto trunc;
1894                         else
1895                             printf("\n\t      %s", buf);
1896                         break;
1897                     case (AFNUM_NSAP<<8 | SAFNUM_UNICAST):
1898                     case (AFNUM_NSAP<<8 | SAFNUM_MULTICAST):
1899                     case (AFNUM_NSAP<<8 | SAFNUM_UNIMULTICAST):
1900                         advance = decode_clnp_prefix(tptr, buf, sizeof(buf));
1901                         if (advance == -1)
1902                             printf("\n\t    (illegal prefix length)");
1903                         else if (advance == -2)
1904                             goto trunc;
1905                         else
1906                             printf("\n\t      %s", buf);
1907                         break;
1908                     case (AFNUM_NSAP<<8 | SAFNUM_VPNUNICAST):
1909                     case (AFNUM_NSAP<<8 | SAFNUM_VPNMULTICAST):
1910                     case (AFNUM_NSAP<<8 | SAFNUM_VPNUNIMULTICAST):
1911                         advance = decode_labeled_vpn_clnp_prefix(tptr, buf, sizeof(buf));
1912                         if (advance == -1)
1913                             printf("\n\t    (illegal prefix length)");
1914                         else if (advance == -2)
1915                             goto trunc;
1916                         else
1917                             printf("\n\t      %s", buf);
1918                         break;
1919                     case (AFNUM_INET<<8 | SAFNUM_MDT):
1920                       advance = decode_mdt_vpn_nlri(tptr, buf, sizeof(buf));
1921                       if (advance == -1)
1922                             printf("\n\t    (illegal prefix length)");
1923                         else if (advance == -2)
1924                             goto trunc;
1925                         else
1926                             printf("\n\t      %s", buf);
1927                        break;
1928                     case (AFNUM_INET<<8 | SAFNUM_MULTICAST_VPN): /* fall through */
1929                     case (AFNUM_INET6<<8 | SAFNUM_MULTICAST_VPN):
1930                         advance = decode_multicast_vpn(tptr, buf, sizeof(buf));
1931                         if (advance == -1)
1932                             printf("\n\t    (illegal prefix length)");
1933                         else if (advance == -2)
1934                             goto trunc;
1935                         else
1936                             printf("\n\t      %s", buf);
1937                         break;
1938                     default:
1939                         TCHECK2(*(tptr-3),tlen);
1940                         printf("no AFI %u / SAFI %u decoder",af,safi);
1941                         if (vflag <= 1)
1942                             print_unknown_data(tptr-3,"\n\t    ",tlen);
1943                         advance = 0;
1944                         tptr = pptr + len;
1945                         break;
1946                     }
1947                     if (advance < 0)
1948                         break;
1949                     tptr += advance;
1950                 }
1951                 break;
1952         case BGPTYPE_EXTD_COMMUNITIES:
1953                 if (len % 8) {
1954                         printf("invalid len");
1955                         break;
1956                 }
1957                 while (tlen>0) {
1958                     u_int16_t extd_comm;
1959
1960                     TCHECK2(tptr[0], 2);
1961                     extd_comm=EXTRACT_16BITS(tptr);
1962
1963                     printf("\n\t    %s (0x%04x), Flags [%s]",
1964                            tok2strbuf(bgp_extd_comm_subtype_values,
1965                                       "unknown extd community typecode",
1966                                       extd_comm, tokbuf, sizeof(tokbuf)),
1967                            extd_comm,
1968                            bittok2str(bgp_extd_comm_flag_values, "none", extd_comm));
1969
1970                     TCHECK2(*(tptr+2), 6);
1971                     switch(extd_comm) {
1972                     case BGP_EXT_COM_RT_0:
1973                     case BGP_EXT_COM_RO_0:
1974                     case BGP_EXT_COM_L2VPN_RT_0:
1975                         printf(": %u:%u (= %s)",
1976                                EXTRACT_16BITS(tptr+2),
1977                                EXTRACT_32BITS(tptr+4),
1978                                getname(tptr+4));
1979                         break;
1980                     case BGP_EXT_COM_RT_1:
1981                     case BGP_EXT_COM_RO_1:
1982                     case BGP_EXT_COM_L2VPN_RT_1:
1983                     case BGP_EXT_COM_VRF_RT_IMP:
1984                         printf(": %s:%u",
1985                                getname(tptr+2),
1986                                EXTRACT_16BITS(tptr+6));
1987                         break;
1988                     case BGP_EXT_COM_RT_2:
1989                     case BGP_EXT_COM_RO_2:
1990                         printf(": %s:%u",
1991                             as_printf(astostr, sizeof(astostr),
1992                             EXTRACT_32BITS(tptr+2)), EXTRACT_16BITS(tptr+6));
1993                         break;
1994                     case BGP_EXT_COM_LINKBAND:
1995                         bw.i = EXTRACT_32BITS(tptr+2);
1996                         printf(": bandwidth: %.3f Mbps",
1997                                bw.f*8/1000000);
1998                         break;
1999                     case BGP_EXT_COM_VPN_ORIGIN:
2000                     case BGP_EXT_COM_VPN_ORIGIN2:
2001                     case BGP_EXT_COM_VPN_ORIGIN3:
2002                     case BGP_EXT_COM_VPN_ORIGIN4:
2003                     case BGP_EXT_COM_OSPF_RID:
2004                     case BGP_EXT_COM_OSPF_RID2:
2005                         printf("%s", getname(tptr+2));
2006                         break;
2007                     case BGP_EXT_COM_OSPF_RTYPE:
2008                     case BGP_EXT_COM_OSPF_RTYPE2:
2009                         printf(": area:%s, router-type:%s, metric-type:%s%s",
2010                                getname(tptr+2),
2011                                tok2strbuf(bgp_extd_comm_ospf_rtype_values,
2012                                           "unknown (0x%02x)",
2013                                           *(tptr+6),
2014                                           tokbuf, sizeof(tokbuf)),
2015                                (*(tptr+7) &  BGP_OSPF_RTYPE_METRIC_TYPE) ? "E2" : "",
2016                                ((*(tptr+6) == BGP_OSPF_RTYPE_EXT) || (*(tptr+6) == BGP_OSPF_RTYPE_NSSA)) ? "E1" : "");
2017                         break;
2018                     case BGP_EXT_COM_L2INFO:
2019                         printf(": %s Control Flags [0x%02x]:MTU %u",
2020                                tok2strbuf(l2vpn_encaps_values,
2021                                           "unknown encaps",
2022                                           *(tptr+2),
2023                                           tokbuf, sizeof(tokbuf)),
2024                                        *(tptr+3),
2025                                EXTRACT_16BITS(tptr+4));
2026                         break;
2027                     case BGP_EXT_COM_SOURCE_AS:
2028                         printf(": AS %u", EXTRACT_16BITS(tptr+2));
2029                         break;
2030                     default:
2031                         TCHECK2(*tptr,8);
2032                         print_unknown_data(tptr,"\n\t      ",8);
2033                         break;
2034                     }
2035                     tlen -=8;
2036                     tptr +=8;
2037                 }
2038                 break;
2039
2040         case BGPTYPE_PMSI_TUNNEL:
2041         {
2042                 u_int8_t tunnel_type, flags;
2043
2044                 tunnel_type = *(tptr+1);
2045                 flags = *tptr;
2046                 tlen = len;
2047
2048                 TCHECK2(tptr[0], 5);
2049                 printf("\n\t    Tunnel-type %s (%u), Flags [%s], MPLS Label %u",
2050                        tok2str(bgp_pmsi_tunnel_values, "Unknown", tunnel_type),
2051                        tunnel_type,
2052                        bittok2str(bgp_pmsi_flag_values, "none", flags),
2053                        EXTRACT_24BITS(tptr+2)>>4);
2054
2055                 tptr +=5;
2056                 tlen -= 5;
2057
2058                 switch (tunnel_type) {
2059                 case BGP_PMSI_TUNNEL_PIM_SM: /* fall through */
2060                 case BGP_PMSI_TUNNEL_PIM_BIDIR:
2061                     TCHECK2(tptr[0], 8);
2062                     printf("\n\t      Sender %s, P-Group %s",
2063                            ipaddr_string(tptr),
2064                            ipaddr_string(tptr+4));
2065                     break;
2066
2067                 case BGP_PMSI_TUNNEL_PIM_SSM:
2068                     TCHECK2(tptr[0], 8);
2069                     printf("\n\t      Root-Node %s, P-Group %s",
2070                            ipaddr_string(tptr),
2071                            ipaddr_string(tptr+4));
2072                     break;
2073                 case BGP_PMSI_TUNNEL_INGRESS:
2074                     TCHECK2(tptr[0], 4);
2075                     printf("\n\t      Tunnel-Endpoint %s",
2076                            ipaddr_string(tptr));
2077                     break;
2078                 case BGP_PMSI_TUNNEL_LDP_P2MP: /* fall through */
2079                 case BGP_PMSI_TUNNEL_LDP_MP2MP:
2080                     TCHECK2(tptr[0], 8);
2081                     printf("\n\t      Root-Node %s, LSP-ID 0x%08x",
2082                            ipaddr_string(tptr),
2083                            EXTRACT_32BITS(tptr+4));
2084                     break;
2085                 case BGP_PMSI_TUNNEL_RSVP_P2MP:
2086                     TCHECK2(tptr[0], 8);
2087                     printf("\n\t      Extended-Tunnel-ID %s, P2MP-ID 0x%08x",
2088                            ipaddr_string(tptr),
2089                            EXTRACT_32BITS(tptr+4));
2090                     break;
2091                 default:
2092                     if (vflag <= 1) {
2093                         print_unknown_data(tptr,"\n\t      ",tlen);
2094                     }
2095                 }
2096                 break;
2097         }
2098         case BGPTYPE_ATTR_SET:
2099                 TCHECK2(tptr[0], 4);
2100                 printf("\n\t    Origin AS: %s",
2101                     as_printf(astostr, sizeof(astostr), EXTRACT_32BITS(tptr)));
2102                 tptr+=4;
2103                 len -=4;
2104
2105                 while (len >= 2 ) {
2106                     int alen;
2107                     struct bgp_attr bgpa;
2108
2109                     TCHECK2(tptr[0], sizeof(bgpa));
2110                     memcpy(&bgpa, tptr, sizeof(bgpa));
2111                     alen = bgp_attr_len(&bgpa);
2112                     tptr += bgp_attr_off(&bgpa);
2113                     len -= bgp_attr_off(&bgpa);
2114
2115                     printf("\n\t      %s (%u), length: %u",
2116                            tok2strbuf(bgp_attr_values,
2117                                       "Unknown Attribute", bgpa.bgpa_type,
2118                                       tokbuf, sizeof(tokbuf)),
2119                            bgpa.bgpa_type,
2120                            alen);
2121
2122                     if (bgpa.bgpa_flags) {
2123                         printf(", Flags [%s%s%s%s",
2124                                bgpa.bgpa_flags & 0x80 ? "O" : "",
2125                                bgpa.bgpa_flags & 0x40 ? "T" : "",
2126                                bgpa.bgpa_flags & 0x20 ? "P" : "",
2127                                bgpa.bgpa_flags & 0x10 ? "E" : "");
2128                         if (bgpa.bgpa_flags & 0xf)
2129                             printf("+%x", bgpa.bgpa_flags & 0xf);
2130                         printf("]: ");
2131                     }
2132                     /* FIXME check for recursion */
2133                     if (!bgp_attr_print(&bgpa, tptr, alen))
2134                         return 0;
2135                     tptr += alen;
2136                     len -= alen;
2137                 }
2138                 break;
2139
2140
2141         default:
2142             TCHECK2(*pptr,len);
2143             printf("\n\t    no Attribute %u decoder",attr->bgpa_type); /* we have no decoder for the attribute */
2144             if (vflag <= 1)
2145                 print_unknown_data(pptr,"\n\t    ",len);
2146             break;
2147         }
2148         if (vflag > 1 && len) { /* omit zero length attributes*/
2149             TCHECK2(*pptr,len);
2150             print_unknown_data(pptr,"\n\t    ",len);
2151         }
2152         return 1;
2153
2154 trunc:
2155         return 0;
2156 }
2157
2158 static void
2159 bgp_open_print(const u_char *dat, int length)
2160 {
2161         struct bgp_open bgpo;
2162         struct bgp_opt bgpopt;
2163         const u_char *opt;
2164         int i,cap_type,cap_len,tcap_len,cap_offset;
2165         char tokbuf[TOKBUFSIZE];
2166         char tokbuf2[TOKBUFSIZE];
2167
2168         TCHECK2(dat[0], BGP_OPEN_SIZE);
2169         memcpy(&bgpo, dat, BGP_OPEN_SIZE);
2170
2171         printf("\n\t  Version %d, ", bgpo.bgpo_version);
2172         printf("my AS %s, ",
2173             as_printf(astostr, sizeof(astostr), ntohs(bgpo.bgpo_myas)));
2174         printf("Holdtime %us, ", ntohs(bgpo.bgpo_holdtime));
2175         printf("ID %s", getname((u_char *)&bgpo.bgpo_id));
2176         printf("\n\t  Optional parameters, length: %u", bgpo.bgpo_optlen);
2177
2178         /* some little sanity checking */
2179         if (length < bgpo.bgpo_optlen+BGP_OPEN_SIZE)
2180             return;
2181
2182         /* ugly! */
2183         opt = &((const struct bgp_open *)dat)->bgpo_optlen;
2184         opt++;
2185
2186         i = 0;
2187         while (i < bgpo.bgpo_optlen) {
2188                 TCHECK2(opt[i], BGP_OPT_SIZE);
2189                 memcpy(&bgpopt, &opt[i], BGP_OPT_SIZE);
2190                 if (i + 2 + bgpopt.bgpopt_len > bgpo.bgpo_optlen) {
2191                         printf("\n\t     Option %d, length: %u", bgpopt.bgpopt_type, bgpopt.bgpopt_len);
2192                         break;
2193                 }
2194
2195                 printf("\n\t    Option %s (%u), length: %u",
2196                        tok2strbuf(bgp_opt_values,"Unknown",
2197                                   bgpopt.bgpopt_type,
2198                                   tokbuf, sizeof(tokbuf)),
2199                        bgpopt.bgpopt_type,
2200                        bgpopt.bgpopt_len);
2201
2202                 /* now lets decode the options we know*/
2203                 switch(bgpopt.bgpopt_type) {
2204                 case BGP_OPT_CAP:
2205                     cap_type=opt[i+BGP_OPT_SIZE];
2206                     cap_len=opt[i+BGP_OPT_SIZE+1];
2207                     tcap_len=cap_len;
2208                     printf("\n\t      %s (%u), length: %u",
2209                            tok2strbuf(bgp_capcode_values, "Unknown",
2210                                       cap_type, tokbuf, sizeof(tokbuf)),
2211                            cap_type,
2212                            cap_len);
2213                     switch(cap_type) {
2214                     case BGP_CAPCODE_MP:
2215                         printf("\n\t\tAFI %s (%u), SAFI %s (%u)",
2216                                tok2strbuf(af_values, "Unknown",
2217                                           EXTRACT_16BITS(opt+i+BGP_OPT_SIZE+2),
2218                                           tokbuf, sizeof(tokbuf)),
2219                                EXTRACT_16BITS(opt+i+BGP_OPT_SIZE+2),
2220                                tok2strbuf(bgp_safi_values, "Unknown",
2221                                           opt[i+BGP_OPT_SIZE+5],
2222                                           tokbuf, sizeof(tokbuf)),
2223                                opt[i+BGP_OPT_SIZE+5]);
2224                         break;
2225                     case BGP_CAPCODE_RESTART:
2226                         printf("\n\t\tRestart Flags: [%s], Restart Time %us",
2227                                ((opt[i+BGP_OPT_SIZE+2])&0x80) ? "R" : "none",
2228                                EXTRACT_16BITS(opt+i+BGP_OPT_SIZE+2)&0xfff);
2229                         tcap_len-=2;
2230                         cap_offset=4;
2231                         while(tcap_len>=4) {
2232                             printf("\n\t\t  AFI %s (%u), SAFI %s (%u), Forwarding state preserved: %s",
2233                                    tok2strbuf(af_values,"Unknown",
2234                                               EXTRACT_16BITS(opt+i+BGP_OPT_SIZE+cap_offset),
2235                                               tokbuf, sizeof(tokbuf)),
2236                                    EXTRACT_16BITS(opt+i+BGP_OPT_SIZE+cap_offset),
2237                                    tok2strbuf(bgp_safi_values,"Unknown",
2238                                               opt[i+BGP_OPT_SIZE+cap_offset+2],
2239                                               tokbuf2, sizeof(tokbuf2)),
2240                                    opt[i+BGP_OPT_SIZE+cap_offset+2],
2241                                    ((opt[i+BGP_OPT_SIZE+cap_offset+3])&0x80) ? "yes" : "no" );
2242                             tcap_len-=4;
2243                             cap_offset+=4;
2244                         }
2245                         break;
2246                     case BGP_CAPCODE_RR:
2247                     case BGP_CAPCODE_RR_CISCO:
2248                         break;
2249                     case BGP_CAPCODE_AS_NEW:
2250
2251                         /*
2252                          * Extract the 4 byte AS number encoded.
2253                          */
2254                         TCHECK2(opt[i + BGP_OPT_SIZE + 2], cap_len);
2255                         if (cap_len == 4) {
2256                             printf("\n\t\t 4 Byte AS %s",
2257                                 as_printf(astostr, sizeof(astostr),
2258                                 EXTRACT_32BITS(opt + i + BGP_OPT_SIZE + 2)));
2259                         }
2260                         break;
2261                     default:
2262                         TCHECK2(opt[i+BGP_OPT_SIZE+2],cap_len);
2263                         printf("\n\t\tno decoder for Capability %u",
2264                                cap_type);
2265                         if (vflag <= 1)
2266                             print_unknown_data(&opt[i+BGP_OPT_SIZE+2],"\n\t\t",cap_len);
2267                         break;
2268                     }
2269                     if (vflag > 1) {
2270                         TCHECK2(opt[i+BGP_OPT_SIZE+2],cap_len);
2271                         print_unknown_data(&opt[i+BGP_OPT_SIZE+2],"\n\t\t",cap_len);
2272                     }
2273                     break;
2274                 case BGP_OPT_AUTH:
2275                 default:
2276                        printf("\n\t      no decoder for option %u",
2277                            bgpopt.bgpopt_type);
2278                        break;
2279                 }
2280
2281                 i += BGP_OPT_SIZE + bgpopt.bgpopt_len;
2282         }
2283         return;
2284 trunc:
2285         printf("[|BGP]");
2286 }
2287
2288 static void
2289 bgp_update_print(const u_char *dat, int length)
2290 {
2291         struct bgp bgp;
2292         struct bgp_attr bgpa;
2293         const u_char *p;
2294         int len;
2295         int i;
2296         char tokbuf[TOKBUFSIZE];
2297
2298         TCHECK2(dat[0], BGP_SIZE);
2299         memcpy(&bgp, dat, BGP_SIZE);
2300         p = dat + BGP_SIZE;     /*XXX*/
2301
2302         /* Unfeasible routes */
2303         len = EXTRACT_16BITS(p);
2304         if (len) {
2305                 /*
2306                  * Without keeping state from the original NLRI message,
2307                  * it's not possible to tell if this a v4 or v6 route,
2308                  * so only try to decode it if we're not v6 enabled.
2309                  */
2310 #ifdef INET6
2311                 printf("\n\t  Withdrawn routes: %d bytes", len);
2312 #else
2313                 char buf[MAXHOSTNAMELEN + 100];
2314                 int wpfx;
2315
2316                 TCHECK2(p[2], len);
2317                 i = 2;
2318
2319                 printf("\n\t  Withdrawn routes:");
2320
2321                 while(i < 2 + len) {
2322                         wpfx = decode_prefix4(&p[i], buf, sizeof(buf));
2323                         if (wpfx == -1) {
2324                                 printf("\n\t    (illegal prefix length)");
2325                                 break;
2326                         } else if (wpfx == -2)
2327                                 goto trunc;
2328                         else {
2329                                 i += wpfx;
2330                                 printf("\n\t    %s", buf);
2331                         }
2332                 }
2333 #endif
2334         }
2335         p += 2 + len;
2336
2337         TCHECK2(p[0], 2);
2338         len = EXTRACT_16BITS(p);
2339
2340         if (len == 0 && length == BGP_UPDATE_MINSIZE) {
2341             printf("\n\t  End-of-Rib Marker (empty NLRI)");
2342             return;
2343         }
2344
2345         if (len) {
2346                 /* do something more useful!*/
2347                 i = 2;
2348                 while (i < 2 + len) {
2349                         int alen, aoff;
2350
2351                         TCHECK2(p[i], sizeof(bgpa));
2352                         memcpy(&bgpa, &p[i], sizeof(bgpa));
2353                         alen = bgp_attr_len(&bgpa);
2354                         aoff = bgp_attr_off(&bgpa);
2355
2356                        printf("\n\t  %s (%u), length: %u",
2357                               tok2strbuf(bgp_attr_values, "Unknown Attribute",
2358                                          bgpa.bgpa_type,
2359                                          tokbuf, sizeof(tokbuf)),
2360                               bgpa.bgpa_type,
2361                               alen);
2362
2363                         if (bgpa.bgpa_flags) {
2364                                 printf(", Flags [%s%s%s%s",
2365                                         bgpa.bgpa_flags & 0x80 ? "O" : "",
2366                                         bgpa.bgpa_flags & 0x40 ? "T" : "",
2367                                         bgpa.bgpa_flags & 0x20 ? "P" : "",
2368                                         bgpa.bgpa_flags & 0x10 ? "E" : "");
2369                                 if (bgpa.bgpa_flags & 0xf)
2370                                         printf("+%x", bgpa.bgpa_flags & 0xf);
2371                                 printf("]: ");
2372                         }
2373                         if (!bgp_attr_print(&bgpa, &p[i + aoff], alen))
2374                                 goto trunc;
2375                         i += aoff + alen;
2376                 }
2377         }
2378         p += 2 + len;
2379
2380         if (dat + length > p) {
2381                 printf("\n\t  Updated routes:");
2382                 while (dat + length > p) {
2383                         char buf[MAXHOSTNAMELEN + 100];
2384                         i = decode_prefix4(p, buf, sizeof(buf));
2385                         if (i == -1) {
2386                                 printf("\n\t    (illegal prefix length)");
2387                                 break;
2388                         } else if (i == -2)
2389                                 goto trunc;
2390                         else {
2391                                 printf("\n\t    %s", buf);
2392                                 p += i;
2393                         }
2394                 }
2395         }
2396         return;
2397 trunc:
2398         printf("[|BGP]");
2399 }
2400
2401 static void
2402 bgp_notification_print(const u_char *dat, int length)
2403 {
2404         struct bgp_notification bgpn;
2405         const u_char *tptr;
2406         char tokbuf[TOKBUFSIZE];
2407         char tokbuf2[TOKBUFSIZE];
2408
2409         TCHECK2(dat[0], BGP_NOTIFICATION_SIZE);
2410         memcpy(&bgpn, dat, BGP_NOTIFICATION_SIZE);
2411
2412         /* some little sanity checking */
2413         if (length<BGP_NOTIFICATION_SIZE)
2414             return;
2415
2416         printf(", %s (%u)",
2417                tok2strbuf(bgp_notify_major_values, "Unknown Error",
2418                           bgpn.bgpn_major, tokbuf, sizeof(tokbuf)),
2419                bgpn.bgpn_major);
2420
2421         switch (bgpn.bgpn_major) {
2422
2423         case BGP_NOTIFY_MAJOR_MSG:
2424             printf(", subcode %s (%u)",
2425                    tok2strbuf(bgp_notify_minor_msg_values, "Unknown",
2426                               bgpn.bgpn_minor, tokbuf, sizeof(tokbuf)),
2427                    bgpn.bgpn_minor);
2428             break;
2429         case BGP_NOTIFY_MAJOR_OPEN:
2430             printf(", subcode %s (%u)",
2431                    tok2strbuf(bgp_notify_minor_open_values, "Unknown",
2432                               bgpn.bgpn_minor, tokbuf, sizeof(tokbuf)),
2433                    bgpn.bgpn_minor);
2434             break;
2435         case BGP_NOTIFY_MAJOR_UPDATE:
2436             printf(", subcode %s (%u)",
2437                    tok2strbuf(bgp_notify_minor_update_values, "Unknown",
2438                               bgpn.bgpn_minor, tokbuf, sizeof(tokbuf)),
2439                    bgpn.bgpn_minor);
2440             break;
2441         case BGP_NOTIFY_MAJOR_CAP:
2442             printf(" subcode %s (%u)",
2443                    tok2strbuf(bgp_notify_minor_cap_values, "Unknown",
2444                               bgpn.bgpn_minor, tokbuf, sizeof(tokbuf)),
2445                    bgpn.bgpn_minor);
2446         case BGP_NOTIFY_MAJOR_CEASE:
2447             printf(", subcode %s (%u)",
2448                    tok2strbuf(bgp_notify_minor_cease_values, "Unknown",
2449                               bgpn.bgpn_minor, tokbuf, sizeof(tokbuf)),
2450                    bgpn.bgpn_minor);
2451
2452             /* draft-ietf-idr-cease-subcode-02 mentions optionally 7 bytes
2453              * for the maxprefix subtype, which may contain AFI, SAFI and MAXPREFIXES
2454              */
2455             if(bgpn.bgpn_minor == BGP_NOTIFY_MINOR_CEASE_MAXPRFX && length >= BGP_NOTIFICATION_SIZE + 7) {
2456                 tptr = dat + BGP_NOTIFICATION_SIZE;
2457                 TCHECK2(*tptr, 7);
2458                 printf(", AFI %s (%u), SAFI %s (%u), Max Prefixes: %u",
2459                        tok2strbuf(af_values, "Unknown",
2460                                   EXTRACT_16BITS(tptr), tokbuf, sizeof(tokbuf)),
2461                        EXTRACT_16BITS(tptr),
2462                        tok2strbuf(bgp_safi_values, "Unknown", *(tptr+2),
2463                                   tokbuf2, sizeof(tokbuf)),
2464                        *(tptr+2),
2465                        EXTRACT_32BITS(tptr+3));
2466             }
2467             break;
2468         default:
2469             break;
2470         }
2471
2472         return;
2473 trunc:
2474         printf("[|BGP]");
2475 }
2476
2477 static void
2478 bgp_route_refresh_print(const u_char *pptr, int len) {
2479
2480         const struct bgp_route_refresh *bgp_route_refresh_header;
2481         char tokbuf[TOKBUFSIZE];
2482         char tokbuf2[TOKBUFSIZE];
2483
2484         TCHECK2(pptr[0], BGP_ROUTE_REFRESH_SIZE);
2485
2486         /* some little sanity checking */
2487         if (len<BGP_ROUTE_REFRESH_SIZE)
2488             return;
2489
2490         bgp_route_refresh_header = (const struct bgp_route_refresh *)pptr;
2491
2492         printf("\n\t  AFI %s (%u), SAFI %s (%u)",
2493                tok2strbuf(af_values,"Unknown",
2494                           /* this stinks but the compiler pads the structure
2495                            * weird */
2496                           EXTRACT_16BITS(&bgp_route_refresh_header->afi),
2497                           tokbuf, sizeof(tokbuf)),
2498                EXTRACT_16BITS(&bgp_route_refresh_header->afi),
2499                tok2strbuf(bgp_safi_values,"Unknown",
2500                           bgp_route_refresh_header->safi,
2501                           tokbuf2, sizeof(tokbuf2)),
2502                bgp_route_refresh_header->safi);
2503
2504         if (vflag > 1) {
2505             TCHECK2(*pptr, len);
2506             print_unknown_data(pptr,"\n\t  ", len);
2507         }
2508
2509         return;
2510 trunc:
2511         printf("[|BGP]");
2512 }
2513
2514 static int
2515 bgp_header_print(const u_char *dat, int length)
2516 {
2517         struct bgp bgp;
2518         char tokbuf[TOKBUFSIZE];
2519
2520         TCHECK2(dat[0], BGP_SIZE);
2521         memcpy(&bgp, dat, BGP_SIZE);
2522         printf("\n\t%s Message (%u), length: %u",
2523                tok2strbuf(bgp_msg_values, "Unknown", bgp.bgp_type,
2524                           tokbuf, sizeof(tokbuf)),
2525                bgp.bgp_type,
2526                length);
2527
2528         switch (bgp.bgp_type) {
2529         case BGP_OPEN:
2530                 bgp_open_print(dat, length);
2531                 break;
2532         case BGP_UPDATE:
2533                 bgp_update_print(dat, length);
2534                 break;
2535         case BGP_NOTIFICATION:
2536                 bgp_notification_print(dat, length);
2537                 break;
2538         case BGP_KEEPALIVE:
2539                 break;
2540         case BGP_ROUTE_REFRESH:
2541                 bgp_route_refresh_print(dat, length);
2542                 break;
2543         default:
2544                 /* we have no decoder for the BGP message */
2545                 TCHECK2(*dat, length);
2546                 printf("\n\t  no Message %u decoder",bgp.bgp_type);
2547                 print_unknown_data(dat,"\n\t  ",length);
2548                 break;
2549         }
2550         return 1;
2551 trunc:
2552         printf("[|BGP]");
2553         return 0;
2554 }
2555
2556 void
2557 bgp_print(const u_char *dat, int length)
2558 {
2559         const u_char *p;
2560         const u_char *ep;
2561         const u_char *start;
2562         const u_char marker[] = {
2563                 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
2564                 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
2565         };
2566         struct bgp bgp;
2567         u_int16_t hlen;
2568         char tokbuf[TOKBUFSIZE];
2569
2570         ep = dat + length;
2571         if (snapend < dat + length)
2572                 ep = snapend;
2573
2574         printf(": BGP, length: %u",length);
2575
2576         if (vflag < 1) /* lets be less chatty */
2577                 return;
2578
2579         p = dat;
2580         start = p;
2581         while (p < ep) {
2582                 if (!TTEST2(p[0], 1))
2583                         break;
2584                 if (p[0] != 0xff) {
2585                         p++;
2586                         continue;
2587                 }
2588
2589                 if (!TTEST2(p[0], sizeof(marker)))
2590                         break;
2591                 if (memcmp(p, marker, sizeof(marker)) != 0) {
2592                         p++;
2593                         continue;
2594                 }
2595
2596                 /* found BGP header */
2597                 TCHECK2(p[0], BGP_SIZE);        /*XXX*/
2598                 memcpy(&bgp, p, BGP_SIZE);
2599
2600                 if (start != p)
2601                         printf(" [|BGP]");
2602
2603                 hlen = ntohs(bgp.bgp_len);
2604                 if (hlen < BGP_SIZE) {
2605                         printf("\n[|BGP Bogus header length %u < %u]", hlen,
2606                             BGP_SIZE);
2607                         break;
2608                 }
2609
2610                 if (TTEST2(p[0], hlen)) {
2611                         if (!bgp_header_print(p, hlen))
2612                                 return;
2613                         p += hlen;
2614                         start = p;
2615                 } else {
2616                         printf("\n[|BGP %s]",
2617                                tok2strbuf(bgp_msg_values,
2618                                           "Unknown Message Type",
2619                                           bgp.bgp_type,
2620                                           tokbuf, sizeof(tokbuf)));
2621                         break;
2622                 }
2623         }
2624
2625         return;
2626
2627 trunc:
2628         printf(" [|BGP]");
2629 }
2630
2631 /*
2632  * Local Variables:
2633  * c-style: whitesmith
2634  * c-basic-offset: 4
2635  * End:
2636  */