6/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.91.2.6 2005/06/03 07:31:43 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 "l2vpn.h"
  53
  54 struct bgp {
  55         u_int8_t bgp_marker[16];
  56         u_int16_t bgp_len;
  57         u_int8_t bgp_type;
  58 };
  59 #define BGP_SIZE                19      /* unaligned */
  60
  61 #define BGP_OPEN                1
  62 #define BGP_UPDATE              2
  63 #define BGP_NOTIFICATION        3
  64 #define BGP_KEEPALIVE           4
  65 #define BGP_ROUTE_REFRESH       5
  66
  67 static struct tok bgp_msg_values[] = {
  68     { BGP_OPEN,                 "Open"},
  69     { BGP_UPDATE,               "Update"},
  70     { BGP_NOTIFICATION,         "Notification"},
  71     { BGP_KEEPALIVE,            "Keepalive"},
  72     { BGP_ROUTE_REFRESH,        "Route Refresh"},
  73     { 0, NULL}
  74 };
  75
  76 struct bgp_open {
  77         u_int8_t bgpo_marker[16];
  78         u_int16_t bgpo_len;
  79         u_int8_t bgpo_type;
  80         u_int8_t bgpo_version;
  81         u_int16_t bgpo_myas;
  82         u_int16_t bgpo_holdtime;
  83         u_int32_t bgpo_id;
  84         u_int8_t bgpo_optlen;
  85         /* options should follow */
  86 };
  87 #define BGP_OPEN_SIZE           29      /* unaligned */
  88
  89 struct bgp_opt {
  90         u_int8_t bgpopt_type;
  91         u_int8_t bgpopt_len;
  92         /* variable length */
  93 };
  94 #define BGP_OPT_SIZE            2       /* some compilers may pad to 4 bytes */
  95
  96 #define BGP_UPDATE_MINSIZE      23
  97
  98 struct bgp_notification {
  99         u_int8_t bgpn_marker[16];
 100         u_int16_t bgpn_len;
 101         u_int8_t bgpn_type;
 102         u_int8_t bgpn_major;
 103         u_int8_t bgpn_minor;
 104 };
 105 #define BGP_NOTIFICATION_SIZE           21      /* unaligned */
 106
 107 struct bgp_route_refresh {
 108     u_int8_t  bgp_marker[16];
 109     u_int16_t len;
 110     u_int8_t  type;
 111     u_int8_t  afi[2]; /* the compiler messes this structure up               */
 112     u_int8_t  res;    /* when doing misaligned sequences of int8 and int16   */
 113     u_int8_t  safi;   /* afi should be int16 - so we have to access it using */
 114 };                    /* EXTRACT_16BITS(&bgp_route_refresh->afi) (sigh)      */
 115 #define BGP_ROUTE_REFRESH_SIZE          23
 116
 117 struct bgp_attr {
 118         u_int8_t bgpa_flags;
 119         u_int8_t bgpa_type;
 120         union {
 121                 u_int8_t len;
 122                 u_int16_t elen;
 123         } bgpa_len;
 124 #define bgp_attr_len(p) \
 125         (((p)->bgpa_flags & 0x10) ? \
 126                 EXTRACT_16BITS(&(p)->bgpa_len.elen) : (p)->bgpa_len.len)
 127 #define bgp_attr_off(p) \
 128         (((p)->bgpa_flags & 0x10) ? 4 : 3)
 129 };
 130
 131 #define BGPTYPE_ORIGIN                  1
 132 #define BGPTYPE_AS_PATH                 2
 133 #define BGPTYPE_NEXT_HOP                3
 134 #define BGPTYPE_MULTI_EXIT_DISC         4
 135 #define BGPTYPE_LOCAL_PREF              5
 136 #define BGPTYPE_ATOMIC_AGGREGATE        6
 137 #define BGPTYPE_AGGREGATOR              7
 138 #define BGPTYPE_COMMUNITIES             8       /* RFC1997 */
 139 #define BGPTYPE_ORIGINATOR_ID           9       /* RFC1998 */
 140 #define BGPTYPE_CLUSTER_LIST            10      /* RFC1998 */
 141 #define BGPTYPE_DPA                     11      /* draft-ietf-idr-bgp-dpa */
 142 #define BGPTYPE_ADVERTISERS             12      /* RFC1863 */
 143 #define BGPTYPE_RCID_PATH               13      /* RFC1863 */
 144 #define BGPTYPE_MP_REACH_NLRI           14      /* RFC2283 */
 145 #define BGPTYPE_MP_UNREACH_NLRI         15      /* RFC2283 */
 146 #define BGPTYPE_EXTD_COMMUNITIES        16      /* draft-ietf-idr-bgp-ext-communities */
 147 #define BGPTYPE_ATTR_SET               128      /* draft-marques-ppvpn-ibgp */
 148
 149 #define BGP_MP_NLRI_MINSIZE              3       /* End of RIB Marker detection */
 150
 151 static struct tok bgp_attr_values[] = {
 152     { BGPTYPE_ORIGIN,           "Origin"},
 153     { BGPTYPE_AS_PATH,          "AS Path"},
 154     { BGPTYPE_NEXT_HOP,         "Next Hop"},
 155     { BGPTYPE_MULTI_EXIT_DISC,  "Multi Exit Discriminator"},
 156     { BGPTYPE_LOCAL_PREF,       "Local Preference"},
 157     { BGPTYPE_ATOMIC_AGGREGATE, "Atomic Aggregate"},
 158     { BGPTYPE_AGGREGATOR,       "Aggregator"},
 159     { BGPTYPE_COMMUNITIES,      "Community"},
 160     { BGPTYPE_ORIGINATOR_ID,    "Originator ID"},
 161     { BGPTYPE_CLUSTER_LIST,     "Cluster List"},
 162     { BGPTYPE_DPA,              "DPA"},
 163     { BGPTYPE_ADVERTISERS,      "Advertisers"},
 164     { BGPTYPE_RCID_PATH,        "RCID Path / Cluster ID"},
 165     { BGPTYPE_MP_REACH_NLRI,    "Multi-Protocol Reach NLRI"},
 166     { BGPTYPE_MP_UNREACH_NLRI,  "Multi-Protocol Unreach NLRI"},
 167     { BGPTYPE_EXTD_COMMUNITIES, "Extended Community"},
 168     { BGPTYPE_ATTR_SET,         "Attribute Set"},
 169     { 255,                      "Reserved for development"},
 170     { 0, NULL}
 171 };
 172
 173 #define BGP_AS_SET             1
 174 #define BGP_AS_SEQUENCE        2
 175 #define BGP_CONFED_AS_SEQUENCE 3 /* draft-ietf-idr-rfc3065bis-01 */
 176 #define BGP_CONFED_AS_SET      4 /* draft-ietf-idr-rfc3065bis-01  */
 177
 178 static struct tok bgp_as_path_segment_open_values[] = {
 179     { BGP_AS_SEQUENCE,         ""},
 180     { BGP_AS_SET,              "{ "},
 181     { BGP_CONFED_AS_SEQUENCE,  "( "},
 182     { BGP_CONFED_AS_SET,       "({ "},
 183     { 0, NULL}
 184 };
 185
 186 static struct tok bgp_as_path_segment_close_values[] = {
 187     { BGP_AS_SEQUENCE,         ""},
 188     { BGP_AS_SET,              "}"},
 189     { BGP_CONFED_AS_SEQUENCE,  ")"},
 190     { BGP_CONFED_AS_SET,       "})"},
 191     { 0, NULL}
 192 };
 193
 194 #define BGP_OPT_AUTH                    1
 195 #define BGP_OPT_CAP                     2
 196
 197
 198 static struct tok bgp_opt_values[] = {
 199     { BGP_OPT_AUTH,             "Authentication Information"},
 200     { BGP_OPT_CAP,              "Capabilities Advertisement"},
 201     { 0, NULL}
 202 };
 203
 204 #define BGP_CAPCODE_MP                  1
 205 #define BGP_CAPCODE_RR                  2
 206 #define BGP_CAPCODE_ORF                 3 /* XXX */
 207 #define BGP_CAPCODE_RESTART            64 /* draft-ietf-idr-restart-05  */
 208 #define BGP_CAPCODE_AS_NEW             65 /* XXX */
 209 #define BGP_CAPCODE_DYN_CAP            67 /* XXX */
 210 #define BGP_CAPCODE_RR_CISCO          128
 211
 212 static struct tok bgp_capcode_values[] = {
 213     { BGP_CAPCODE_MP,           "Multiprotocol Extensions"},
 214     { BGP_CAPCODE_RR,           "Route Refresh"},
 215     { BGP_CAPCODE_ORF,          "Cooperative Route Filtering"},
 216     { BGP_CAPCODE_RESTART,      "Graceful Restart"},
 217     { BGP_CAPCODE_AS_NEW,       "32-Bit AS Number"},
 218     { BGP_CAPCODE_DYN_CAP,      "Dynamic Capability"},
 219     { BGP_CAPCODE_RR_CISCO,     "Route Refresh (Cisco)"},
 220     { 0, NULL}
 221 };
 222
 223 #define BGP_NOTIFY_MAJOR_MSG            1
 224 #define BGP_NOTIFY_MAJOR_OPEN           2
 225 #define BGP_NOTIFY_MAJOR_UPDATE         3
 226 #define BGP_NOTIFY_MAJOR_HOLDTIME       4
 227 #define BGP_NOTIFY_MAJOR_FSM            5
 228 #define BGP_NOTIFY_MAJOR_CEASE          6
 229 #define BGP_NOTIFY_MAJOR_CAP            7
 230
 231 static struct tok bgp_notify_major_values[] = {
 232     { BGP_NOTIFY_MAJOR_MSG,     "Message Header Error"},
 233     { BGP_NOTIFY_MAJOR_OPEN,    "OPEN Message Error"},
 234     { BGP_NOTIFY_MAJOR_UPDATE,  "UPDATE Message Error"},
 235     { BGP_NOTIFY_MAJOR_HOLDTIME,"Hold Timer Expired"},
 236     { BGP_NOTIFY_MAJOR_FSM,     "Finite State Machine Error"},
 237     { BGP_NOTIFY_MAJOR_CEASE,   "Cease"},
 238     { BGP_NOTIFY_MAJOR_CAP,     "Capability Message Error"},
 239     { 0, NULL}
 240 };
 241
 242 /* draft-ietf-idr-cease-subcode-02 */
 243 #define BGP_NOTIFY_MINOR_CEASE_MAXPRFX  1
 244 static struct tok bgp_notify_minor_cease_values[] = {
 245     { BGP_NOTIFY_MINOR_CEASE_MAXPRFX, "Maximum Number of Prefixes Reached"},
 246     { 2,                        "Administratively Shutdown"},
 247     { 3,                        "Peer Unconfigured"},
 248     { 4,                        "Administratively Reset"},
 249     { 5,                        "Connection Rejected"},
 250     { 6,                        "Other Configuration Change"},
 251     { 7,                        "Connection Collision Resolution"},
 252     { 0, NULL}
 253 };
 254
 255 static struct tok bgp_notify_minor_msg_values[] = {
 256     { 1,                        "Connection Not Synchronized"},
 257     { 2,                        "Bad Message Length"},
 258     { 3,                        "Bad Message Type"},
 259     { 0, NULL}
 260 };
 261
 262 static struct tok bgp_notify_minor_open_values[] = {
 263     { 1,                        "Unsupported Version Number"},
 264     { 2,                        "Bad Peer AS"},
 265     { 3,                        "Bad BGP Identifier"},
 266     { 4,                        "Unsupported Optional Parameter"},
 267     { 5,                        "Authentication Failure"},
 268     { 6,                        "Unacceptable Hold Time"},
 269     { 0, NULL}
 270 };
 271
 272 static struct tok bgp_notify_minor_update_values[] = {
 273     { 1,                        "Malformed Attribute List"},
 274     { 2,                        "Unrecognized Well-known Attribute"},
 275     { 3,                        "Missing Well-known Attribute"},
 276     { 4,                        "Attribute Flags Error"},
 277     { 5,                        "Attribute Length Error"},
 278     { 6,                        "Invalid ORIGIN Attribute"},
 279     { 7,                        "AS Routing Loop"},
 280     { 8,                        "Invalid NEXT_HOP Attribute"},
 281     { 9,                        "Optional Attribute Error"},
 282     { 10,                       "Invalid Network Field"},
 283     { 11,                       "Malformed AS_PATH"},
 284     { 0, NULL}
 285 };
 286
 287 static struct tok bgp_notify_minor_cap_values[] = {
 288     { 1,                        "Invalid Action Value" },
 289     { 2,                        "Invalid Capability Length" },
 290     { 3,                        "Malformed Capability Value" },
 291     { 4,                        "Unsupported Capability Code" },
 292     { 0, NULL }
 293 };
 294
 295 static struct tok bgp_origin_values[] = {
 296     { 0,                        "IGP"},
 297     { 1,                        "EGP"},
 298     { 2,                        "Incomplete"},
 299     { 0, NULL}
 300 };
 301
 302 /* Subsequent address family identifier, RFC2283 section 7 */
 303 #define SAFNUM_RES                      0
 304 #define SAFNUM_UNICAST                  1
 305 #define SAFNUM_MULTICAST                2
 306 #define SAFNUM_UNIMULTICAST             3
 307 /* labeled BGP RFC3107 */
 308 #define SAFNUM_LABUNICAST               4
 309 #define SAFNUM_TUNNEL                   64 /* XXX */
 310 #define SAFNUM_VPLS                     65 /* XXX */
 311 #define SAFNUM_MDT                      66 /* XXX */
 312 /* Section 4.3.4 of draft-rosen-rfc2547bis-03.txt  */
 313 #define SAFNUM_VPNUNICAST               128
 314 #define SAFNUM_VPNMULTICAST             129
 315 #define SAFNUM_VPNUNIMULTICAST          130
 316 /* draft-marques-ppvpn-rt-constrain-01.txt */
 317 #define SAFNUM_RT_ROUTING_INFO          132
 318
 319 #define BGP_VPN_RD_LEN                  8
 320
 321 static struct tok bgp_safi_values[] = {
 322     { SAFNUM_RES,               "Reserved"},
 323     { SAFNUM_UNICAST,           "Unicast"},
 324     { SAFNUM_MULTICAST,         "Multicast"},
 325     { SAFNUM_UNIMULTICAST,      "Unicast+Multicast"},
 326     { SAFNUM_LABUNICAST,        "labeled Unicast"},
 327     { SAFNUM_TUNNEL,            "Tunnel"},
 328     { SAFNUM_VPLS,              "VPLS"},
 329     { SAFNUM_MDT,               "MDT"},
 330     { SAFNUM_VPNUNICAST,        "labeled VPN Unicast"},
 331     { SAFNUM_VPNMULTICAST,      "labeled VPN Multicast"},
 332     { SAFNUM_VPNUNIMULTICAST,   "labeled VPN Unicast+Multicast"},
 333     { SAFNUM_RT_ROUTING_INFO,   "Route Target Routing Information"}, /* draft-marques-ppvpn-rt-constrain-01.txt */
 334     { 0, NULL }
 335 };
 336
 337 /* well-known community */
 338 #define BGP_COMMUNITY_NO_EXPORT                 0xffffff01
 339 #define BGP_COMMUNITY_NO_ADVERT                 0xffffff02
 340 #define BGP_COMMUNITY_NO_EXPORT_SUBCONFED       0xffffff03
 341
 342 /* RFC1700 address family numbers */
 343 #define AFNUM_INET      1
 344 #define AFNUM_INET6     2
 345 #define AFNUM_NSAP      3
 346 #define AFNUM_HDLC      4
 347 #define AFNUM_BBN1822   5
 348 #define AFNUM_802       6
 349 #define AFNUM_E163      7
 350 #define AFNUM_E164      8
 351 #define AFNUM_F69       9
 352 #define AFNUM_X121      10
 353 #define AFNUM_IPX       11
 354 #define AFNUM_ATALK     12
 355 #define AFNUM_DECNET    13
 356 #define AFNUM_BANYAN    14
 357 #define AFNUM_E164NSAP  15
 358 /* draft-kompella-ppvpn-l2vpn */
 359 #define AFNUM_L2VPN     196 /* still to be approved by IANA */
 360
 361 static struct tok bgp_afi_values[] = {
 362     { 0,                      "Reserved"},
 363     { AFNUM_INET,             "IPv4"},
 364     { AFNUM_INET6,            "IPv6"},
 365     { AFNUM_NSAP,             "NSAP"},
 366     { AFNUM_HDLC,             "HDLC"},
 367     { AFNUM_BBN1822,          "BBN 1822"},
 368     { AFNUM_802,              "802"},
 369     { AFNUM_E163,             "E.163"},
 370     { AFNUM_E164,             "E.164"},
 371     { AFNUM_F69,              "F.69"},
 372     { AFNUM_X121,             "X.121"},
 373     { AFNUM_IPX,              "Novell IPX"},
 374     { AFNUM_ATALK,            "Appletalk"},
 375     { AFNUM_DECNET,           "Decnet IV"},
 376     { AFNUM_BANYAN,           "Banyan Vines"},
 377     { AFNUM_E164NSAP,         "E.164 with NSAP subaddress"},
 378     { AFNUM_L2VPN,            "Layer-2 VPN"},
 379     { 0, NULL},
 380 };
 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_CISCO_MCAST 0x0009  /* cisco proprietary */
 392
 393 #define BGP_EXT_COM_VPN_ORIGIN  0x0005  /* OSPF Domain ID / VPN of Origin  - draft-rosen-vpns-ospf-bgp-mpls */
 394 #define BGP_EXT_COM_VPN_ORIGIN2 0x0105  /* duplicate - keep for backwards compatability */
 395 #define BGP_EXT_COM_VPN_ORIGIN3 0x0205  /* duplicate - keep for backwards compatability */
 396 #define BGP_EXT_COM_VPN_ORIGIN4 0x8005  /* duplicate - keep for backwards compatability */
 397
 398 #define BGP_EXT_COM_OSPF_RTYPE  0x0306  /* OSPF Route Type,Format Area(4B):RouteType(1B):Options(1B) */
 399 #define BGP_EXT_COM_OSPF_RTYPE2 0x8000  /* duplicate - keep for backwards compatability */
 400
 401 #define BGP_EXT_COM_OSPF_RID    0x0107  /* OSPF Router ID,Format RouterID(4B):Unused(2B) */
 402 #define BGP_EXT_COM_OSPF_RID2   0x8001  /* duplicate - keep for backwards compatability */
 403
 404 #define BGP_EXT_COM_L2INFO      0x800a  /* draft-kompella-ppvpn-l2vpn */
 405
 406 static struct tok bgp_extd_comm_flag_values[] = {
 407     { 0x8000,                  "vendor-specific"},
 408     { 0x4000,                  "non-transitive"},
 409     { 0, NULL},
 410 };
 411
 412 static struct tok bgp_extd_comm_subtype_values[] = {
 413     { BGP_EXT_COM_RT_0,        "target"},
 414     { BGP_EXT_COM_RT_1,        "target"},
 415     { BGP_EXT_COM_RT_2,        "target"},
 416     { BGP_EXT_COM_RO_0,        "origin"},
 417     { BGP_EXT_COM_RO_1,        "origin"},
 418     { BGP_EXT_COM_RO_2,        "origin"},
 419     { BGP_EXT_COM_LINKBAND,    "link-BW"},
 420     { BGP_EXT_COM_CISCO_MCAST, "mdt-group"},
 421     { BGP_EXT_COM_VPN_ORIGIN,  "ospf-domain"},
 422     { BGP_EXT_COM_VPN_ORIGIN2, "ospf-domain"},
 423     { BGP_EXT_COM_VPN_ORIGIN3, "ospf-domain"},
 424     { BGP_EXT_COM_VPN_ORIGIN4, "ospf-domain"},
 425     { BGP_EXT_COM_OSPF_RTYPE,  "ospf-route-type"},
 426     { BGP_EXT_COM_OSPF_RTYPE2, "ospf-route-type"},
 427     { BGP_EXT_COM_OSPF_RID,    "ospf-router-id"},
 428     { BGP_EXT_COM_OSPF_RID2,   "ospf-router-id"},
 429     { BGP_EXT_COM_L2INFO,      "layer2-info"},
 430     { 0, NULL},
 431 };
 432
 433 /* OSPF codes for  BGP_EXT_COM_OSPF_RTYPE draft-rosen-vpns-ospf-bgp-mpls  */
 434 #define BGP_OSPF_RTYPE_RTR      1 /* OSPF Router LSA */
 435 #define BGP_OSPF_RTYPE_NET      2 /* OSPF Network LSA */
 436 #define BGP_OSPF_RTYPE_SUM      3 /* OSPF Summary LSA */
 437 #define BGP_OSPF_RTYPE_EXT      5 /* OSPF External LSA, note that ASBR doesn't apply to MPLS-VPN */
 438 #define BGP_OSPF_RTYPE_NSSA     7 /* OSPF NSSA External*/
 439 #define BGP_OSPF_RTYPE_SHAM     129 /* OSPF-MPLS-VPN Sham link */
 440 #define BGP_OSPF_RTYPE_METRIC_TYPE 0x1 /* LSB of RTYPE Options Field */
 441
 442 static struct tok bgp_extd_comm_ospf_rtype_values[] = {
 443   { BGP_OSPF_RTYPE_RTR, "Router" },
 444   { BGP_OSPF_RTYPE_NET, "Network" },
 445   { BGP_OSPF_RTYPE_SUM, "Summary" },
 446   { BGP_OSPF_RTYPE_EXT, "External" },
 447   { BGP_OSPF_RTYPE_NSSA,"NSSA External" },
 448   { BGP_OSPF_RTYPE_SHAM,"MPLS-VPN Sham" },
 449   { 0, NULL },
 450 };
 451
 452 int
 453 decode_prefix4(const u_char *pptr, char *buf, u_int buflen)
 454 {
 455         struct in_addr addr;
 456         u_int plen;
 457
 458         TCHECK(pptr[0]);
 459         plen = pptr[0];
 460         if (32 < plen)
 461                 return -1;
 462
 463         memset(&addr, 0, sizeof(addr));
 464         TCHECK2(pptr[1], (plen + 7) / 8);
 465         memcpy(&addr, &pptr[1], (plen + 7) / 8);
 466         if (plen % 8) {
 467                 ((u_char *)&addr)[(plen + 7) / 8 - 1] &=
 468                         ((0xff00 >> (plen % 8)) & 0xff);
 469         }
 470         snprintf(buf, buflen, "%s/%d", getname((u_char *)&addr), plen);
 471         return 1 + (plen + 7) / 8;
 472
 473 trunc:
 474         return -2;
 475 }
 476
 477 static int
 478 decode_labeled_prefix4(const u_char *pptr, char *buf, u_int buflen)
 479 {
 480         struct in_addr addr;
 481         u_int plen;
 482
 483         TCHECK(pptr[0]);
 484         plen = pptr[0];   /* get prefix length */
 485
 486         /* this is one of the weirdnesses of rfc3107
 487            the label length (actually the label + COS bits)
 488            is added to the prefix length;
 489            we also do only read out just one label -
 490            there is no real application for advertisement of
 491            stacked labels in a a single BGP message
 492         */
 493
 494         plen-=24; /* adjust prefixlen - labellength */
 495
 496         if (32 < plen)
 497                 return -1;
 498
 499         memset(&addr, 0, sizeof(addr));
 500         TCHECK2(pptr[4], (plen + 7) / 8);
 501         memcpy(&addr, &pptr[4], (plen + 7) / 8);
 502         if (plen % 8) {
 503                 ((u_char *)&addr)[(plen + 7) / 8 - 1] &=
 504                         ((0xff00 >> (plen % 8)) & 0xff);
 505         }
 506         /* the label may get offsetted by 4 bits so lets shift it right */
 507         snprintf(buf, buflen, "%s/%d, label:%u %s",
 508                  getname((u_char *)&addr),
 509                  plen,
 510                  EXTRACT_24BITS(pptr+1)>>4,
 511                  ((pptr[3]&1)==0) ? "(BOGUS: Bottom of Stack NOT set!)" : "(bottom)" );
 512
 513         return 4 + (plen + 7) / 8;
 514
 515 trunc:
 516         return -2;
 517 }
 518
 519 /* RDs and RTs share the same semantics
 520  * we use bgp_vpn_rd_print for
 521  * printing route targets inside a NLRI */
 522 char *
 523 bgp_vpn_rd_print (const u_char *pptr) {
 524
 525    /* allocate space for the largest possible string */
 526     static char rd[sizeof("xxxxxxxxxx:xxxxx (xxx.xxx.xxx.xxx:xxxxx)")];
 527     char *pos = rd;
 528
 529     /* ok lets load the RD format */
 530     switch (EXTRACT_16BITS(pptr)) {
 531
 532         /* AS:IP-address fmt*/
 533     case 0:
 534         snprintf(pos, sizeof(rd) - (pos - rd), "%u:%u.%u.%u.%u",
 535             EXTRACT_16BITS(pptr+2), *(pptr+4), *(pptr+5), *(pptr+6), *(pptr+7));
 536         break;
 537         /* IP-address:AS fmt*/
 538
 539     case 1:
 540         snprintf(pos, sizeof(rd) - (pos - rd), "%u.%u.%u.%u:%u",
 541             *(pptr+2), *(pptr+3), *(pptr+4), *(pptr+5), EXTRACT_16BITS(pptr+6));
 542         break;
 543
 544         /* 4-byte-AS:number fmt*/
 545     case 2:
 546         snprintf(pos, sizeof(rd) - (pos - rd), "%u:%u (%u.%u.%u.%u:%u)",
 547             EXTRACT_32BITS(pptr+2), EXTRACT_16BITS(pptr+6),
 548             *(pptr+2), *(pptr+3), *(pptr+4), *(pptr+5), EXTRACT_16BITS(pptr+6));
 549         break;
 550     default:
 551         snprintf(pos, sizeof(rd) - (pos - rd), "unknown RD format");
 552         break;
 553     }
 554     pos += strlen(pos);
 555     *(pos) = '\0';
 556     return (rd);
 557 }
 558
 559 static int
 560 decode_rt_routing_info(const u_char *pptr, char *buf, u_int buflen)
 561 {
 562         u_int8_t route_target[8];
 563         u_int plen;
 564
 565         TCHECK(pptr[0]);
 566         plen = pptr[0];   /* get prefix length */
 567
 568         plen-=32; /* adjust prefix length */
 569
 570         if (0 < plen)
 571                 return -1;
 572
 573         memset(&route_target, 0, sizeof(route_target));
 574         TCHECK2(pptr[1], (plen + 7) / 8);
 575         memcpy(&route_target, &pptr[1], (plen + 7) / 8);
 576         if (plen % 8) {
 577                 ((u_char *)&route_target)[(plen + 7) / 8 - 1] &=
 578                         ((0xff00 >> (plen % 8)) & 0xff);
 579         }
 580         snprintf(buf, buflen, "origin AS: %u, route target %s",
 581                  EXTRACT_32BITS(pptr+1),
 582                  bgp_vpn_rd_print((u_char *)&route_target));
 583
 584         return 5 + (plen + 7) / 8;
 585
 586 trunc:
 587         return -2;
 588 }
 589
 590 static int
 591 decode_labeled_vpn_prefix4(const u_char *pptr, char *buf, u_int buflen)
 592 {
 593         struct in_addr addr;
 594         u_int plen;
 595
 596         TCHECK(pptr[0]);
 597         plen = pptr[0];   /* get prefix length */
 598
 599         plen-=(24+64); /* adjust prefixlen - labellength - RD len*/
 600
 601         if (32 < plen)
 602                 return -1;
 603
 604         memset(&addr, 0, sizeof(addr));
 605         TCHECK2(pptr[12], (plen + 7) / 8);
 606         memcpy(&addr, &pptr[12], (plen + 7) / 8);
 607         if (plen % 8) {
 608                 ((u_char *)&addr)[(plen + 7) / 8 - 1] &=
 609                         ((0xff00 >> (plen % 8)) & 0xff);
 610         }
 611         /* the label may get offsetted by 4 bits so lets shift it right */
 612         snprintf(buf, buflen, "RD: %s, %s/%d, label:%u %s",
 613                  bgp_vpn_rd_print(pptr+4),
 614                  getname((u_char *)&addr),
 615                  plen,
 616                  EXTRACT_24BITS(pptr+1)>>4,
 617                  ((pptr[3]&1)==0) ? "(BOGUS: Bottom of Stack NOT set!)" : "(bottom)" );
 618
 619         return 12 + (plen + 7) / 8;
 620
 621 trunc:
 622         return -2;
 623 }
 624
 625 /*
 626  * As I remember, some versions of systems have an snprintf() that
 627  * returns -1 if the buffer would have overflowed.  If the return
 628  * value is negative, set buflen to 0, to indicate that we've filled
 629  * the buffer up.
 630  *
 631  * If the return value is greater than buflen, that means that
 632  * the buffer would have overflowed; again, set buflen to 0 in
 633  * that case.
 634  */
 635 #define UPDATE_BUF_BUFLEN(buf, buflen, strlen) \
 636     if (strlen<0) \
 637         buflen=0; \
 638     else if ((u_int)strlen>buflen) \
 639         buflen=0; \
 640     else { \
 641         buflen-=strlen; \
 642         buf+=strlen; \
 643     }
 644
 645 static int
 646 decode_labeled_vpn_l2(const u_char *pptr, char *buf, u_int buflen)
 647 {
 648         int plen,tlen,strlen,tlv_type,tlv_len,ttlv_len;
 649
 650         TCHECK2(pptr[0], 2);
 651         plen=EXTRACT_16BITS(pptr);
 652         tlen=plen;
 653         pptr+=2;
 654         TCHECK2(pptr[0],15);
 655         buf[0]='\0';
 656         strlen=snprintf(buf, buflen, "RD: %s, CE-ID: %u, Label-Block Offset: %u, Label Base %u",
 657                         bgp_vpn_rd_print(pptr),
 658                         EXTRACT_16BITS(pptr+8),
 659                         EXTRACT_16BITS(pptr+10),
 660                         EXTRACT_24BITS(pptr+12)>>4); /* the label is offsetted by 4 bits so lets shift it right */
 661         UPDATE_BUF_BUFLEN(buf, buflen, strlen);
 662         pptr+=15;
 663         tlen-=15;
 664
 665         /* ok now the variable part - lets read out TLVs*/
 666         while (tlen>0) {
 667             if (tlen < 3)
 668                 return -1;
 669             TCHECK2(pptr[0], 3);
 670             tlv_type=*pptr++;
 671             tlv_len=EXTRACT_16BITS(pptr);
 672             ttlv_len=tlv_len;
 673             pptr+=2;
 674
 675             switch(tlv_type) {
 676             case 1:
 677                 if (buflen!=0) {
 678                     strlen=snprintf(buf,buflen, "\n\t\tcircuit status vector (%u) length: %u: 0x",
 679                                     tlv_type,
 680                                     tlv_len);
 681                     UPDATE_BUF_BUFLEN(buf, buflen, strlen);
 682                 }
 683                 ttlv_len=ttlv_len/8+1; /* how many bytes do we need to read ? */
 684                 while (ttlv_len>0) {
 685                     TCHECK(pptr[0]);
 686                     if (buflen!=0) {
 687                         strlen=snprintf(buf,buflen, "%02x",*pptr++);
 688                         UPDATE_BUF_BUFLEN(buf, buflen, strlen);
 689                     }
 690                     ttlv_len--;
 691                 }
 692                 break;
 693             default:
 694                 if (buflen!=0) {
 695                     strlen=snprintf(buf,buflen, "\n\t\tunknown TLV #%u, length: %u",
 696                                     tlv_type,
 697                                     tlv_len);
 698                     UPDATE_BUF_BUFLEN(buf, buflen, strlen);
 699                 }
 700                 break;
 701             }
 702             tlen-=(tlv_len<<3); /* the tlv-length is expressed in bits so lets shift it right */
 703         }
 704         return plen+2;
 705
 706 trunc:
 707         return -2;
 708 }
 709
 710 #ifdef INET6
 711 int
 712 decode_prefix6(const u_char *pd, char *buf, u_int buflen)
 713 {
 714         struct in6_addr addr;
 715         u_int plen;
 716
 717         TCHECK(pd[0]);
 718         plen = pd[0];
 719         if (128 < plen)
 720                 return -1;
 721
 722         memset(&addr, 0, sizeof(addr));
 723         TCHECK2(pd[1], (plen + 7) / 8);
 724         memcpy(&addr, &pd[1], (plen + 7) / 8);
 725         if (plen % 8) {
 726                 addr.s6_addr[(plen + 7) / 8 - 1] &=
 727                         ((0xff00 >> (plen % 8)) & 0xff);
 728         }
 729         snprintf(buf, buflen, "%s/%d", getname6((u_char *)&addr), plen);
 730         return 1 + (plen + 7) / 8;
 731
 732 trunc:
 733         return -2;
 734 }
 735
 736 static int
 737 decode_labeled_prefix6(const u_char *pptr, char *buf, u_int buflen)
 738 {
 739         struct in6_addr addr;
 740         u_int plen;
 741
 742         TCHECK(pptr[0]);
 743         plen = pptr[0]; /* get prefix length */
 744         plen-=24; /* adjust prefixlen - labellength */
 745
 746         if (128 < plen)
 747                 return -1;
 748
 749         memset(&addr, 0, sizeof(addr));
 750         TCHECK2(pptr[4], (plen + 7) / 8);
 751         memcpy(&addr, &pptr[4], (plen + 7) / 8);
 752         if (plen % 8) {
 753                 addr.s6_addr[(plen + 7) / 8 - 1] &=
 754                         ((0xff00 >> (plen % 8)) & 0xff);
 755         }
 756         /* the label may get offsetted by 4 bits so lets shift it right */
 757         snprintf(buf, buflen, "%s/%d, label:%u %s",
 758                  getname6((u_char *)&addr),
 759                  plen,
 760                  EXTRACT_24BITS(pptr+1)>>4,
 761                  ((pptr[3]&1)==0) ? "(BOGUS: Bottom of Stack NOT set!)" : "(bottom)" );
 762
 763         return 4 + (plen + 7) / 8;
 764
 765 trunc:
 766         return -2;
 767 }
 768
 769 static int
 770 decode_labeled_vpn_prefix6(const u_char *pptr, char *buf, u_int buflen)
 771 {
 772         struct in6_addr addr;
 773         u_int plen;
 774
 775         TCHECK(pptr[0]);
 776         plen = pptr[0];   /* get prefix length */
 777
 778         plen-=(24+64); /* adjust prefixlen - labellength - RD len*/
 779
 780         if (128 < plen)
 781                 return -1;
 782
 783         memset(&addr, 0, sizeof(addr));
 784         TCHECK2(pptr[12], (plen + 7) / 8);
 785         memcpy(&addr, &pptr[12], (plen + 7) / 8);
 786         if (plen % 8) {
 787                 addr.s6_addr[(plen + 7) / 8 - 1] &=
 788                         ((0xff00 >> (plen % 8)) & 0xff);
 789         }
 790         /* the label may get offsetted by 4 bits so lets shift it right */
 791         snprintf(buf, buflen, "RD: %s, %s/%d, label:%u %s",
 792                  bgp_vpn_rd_print(pptr+4),
 793                  getname6((u_char *)&addr),
 794                  plen,
 795                  EXTRACT_24BITS(pptr+1)>>4,
 796                  ((pptr[3]&1)==0) ? "(BOGUS: Bottom of Stack NOT set!)" : "(bottom)" );
 797
 798         return 12 + (plen + 7) / 8;
 799
 800 trunc:
 801         return -2;
 802 }
 803 #endif
 804
 805 static int
 806 decode_clnp_prefix(const u_char *pptr, char *buf, u_int buflen)
 807 {
 808         u_int8_t addr[19];
 809         u_int plen;
 810
 811         TCHECK(pptr[0]);
 812         plen = pptr[0]; /* get prefix length */
 813
 814         if (152 < plen)
 815                 return -1;
 816
 817         memset(&addr, 0, sizeof(addr));
 818         TCHECK2(pptr[4], (plen + 7) / 8);
 819         memcpy(&addr, &pptr[4], (plen + 7) / 8);
 820         if (plen % 8) {
 821                 addr[(plen + 7) / 8 - 1] &=
 822                         ((0xff00 >> (plen % 8)) & 0xff);
 823         }
 824         snprintf(buf, buflen, "%s/%d",
 825                  isonsap_string(addr,(plen + 7) / 8),
 826                  plen);
 827
 828         return 1 + (plen + 7) / 8;
 829
 830 trunc:
 831         return -2;
 832 }
 833
 834 static int
 835 decode_labeled_vpn_clnp_prefix(const u_char *pptr, char *buf, u_int buflen)
 836 {
 837         u_int8_t addr[19];
 838         u_int plen;
 839
 840         TCHECK(pptr[0]);
 841         plen = pptr[0];   /* get prefix length */
 842
 843         plen-=(24+64); /* adjust prefixlen - labellength - RD len*/
 844
 845         if (152 < plen)
 846                 return -1;
 847
 848         memset(&addr, 0, sizeof(addr));
 849         TCHECK2(pptr[12], (plen + 7) / 8);
 850         memcpy(&addr, &pptr[12], (plen + 7) / 8);
 851         if (plen % 8) {
 852                 addr[(plen + 7) / 8 - 1] &=
 853                         ((0xff00 >> (plen % 8)) & 0xff);
 854         }
 855         /* the label may get offsetted by 4 bits so lets shift it right */
 856         snprintf(buf, buflen, "RD: %s, %s/%d, label:%u %s",
 857                  bgp_vpn_rd_print(pptr+4),
 858                  isonsap_string(addr,(plen + 7) / 8),
 859                  plen,
 860                  EXTRACT_24BITS(pptr+1)>>4,
 861                  ((pptr[3]&1)==0) ? "(BOGUS: Bottom of Stack NOT set!)" : "(bottom)" );
 862
 863         return 12 + (plen + 7) / 8;
 864
 865 trunc:
 866         return -2;
 867 }
 868
 869 static int
 870 bgp_attr_print(const struct bgp_attr *attr, const u_char *pptr, int len)
 871 {
 872         int i;
 873         u_int16_t af;
 874         u_int8_t safi, snpa, nhlen;
 875         union { /* copy buffer for bandwidth values */
 876             float f;
 877             u_int32_t i;
 878         } bw;
 879         int advance;
 880         int tlen;
 881         const u_char *tptr;
 882         char buf[MAXHOSTNAMELEN + 100];
 883         char tokbuf[TOKBUFSIZE];
 884
 885         tptr = pptr;
 886         tlen=len;
 887
 888         switch (attr->bgpa_type) {
 889         case BGPTYPE_ORIGIN:
 890                 if (len != 1)
 891                         printf("invalid len");
 892                 else {
 893                         TCHECK(*tptr);
 894                         printf("%s", tok2strbuf(bgp_origin_values,
 895                                                 "Unknown Origin Typecode",
 896                                                 tptr[0],
 897                                                 tokbuf, sizeof(tokbuf)));
 898                 }
 899                 break;
 900
 901         case BGPTYPE_AS_PATH:
 902                 if (len % 2) {
 903                         printf("invalid len");
 904                         break;
 905                 }
 906                 if (!len) {
 907                         printf("empty");
 908                         break;
 909                 }
 910
 911                 while (tptr < pptr + len) {
 912                         TCHECK(tptr[0]);
 913                         printf("%s", tok2strbuf(bgp_as_path_segment_open_values,
 914                                                 "?", tptr[0],
 915                                                 tokbuf, sizeof(tokbuf)));
 916                         for (i = 0; i < tptr[1] * 2; i += 2) {
 917                             TCHECK2(tptr[2 + i], 2);
 918                             printf("%u ", EXTRACT_16BITS(&tptr[2 + i]));
 919                         }
 920                         TCHECK(tptr[0]);
 921                         printf("%s", tok2strbuf(bgp_as_path_segment_close_values,
 922                                                 "?", tptr[0],
 923                                                 tokbuf, sizeof(tokbuf)));
 924                         TCHECK(tptr[1]);
 925                         tptr += 2 + tptr[1] * 2;
 926                 }
 927                 break;
 928         case BGPTYPE_NEXT_HOP:
 929                 if (len != 4)
 930                         printf("invalid len");
 931                 else {
 932                         TCHECK2(tptr[0], 4);
 933                         printf("%s", getname(tptr));
 934                 }
 935                 break;
 936         case BGPTYPE_MULTI_EXIT_DISC:
 937         case BGPTYPE_LOCAL_PREF:
 938                 if (len != 4)
 939                         printf("invalid len");
 940                 else {
 941                         TCHECK2(tptr[0], 4);
 942                         printf("%u", EXTRACT_32BITS(tptr));
 943                 }
 944                 break;
 945         case BGPTYPE_ATOMIC_AGGREGATE:
 946                 if (len != 0)
 947                         printf("invalid len");
 948                 break;
 949         case BGPTYPE_AGGREGATOR:
 950                 if (len != 6) {
 951                         printf("invalid len");
 952                         break;
 953                 }
 954                 TCHECK2(tptr[0], 6);
 955                 printf(" AS #%u, origin %s", EXTRACT_16BITS(tptr),
 956                         getname(tptr + 2));
 957                 break;
 958         case BGPTYPE_COMMUNITIES:
 959                 if (len % 4) {
 960                         printf("invalid len");
 961                         break;
 962                 }
 963                 while (tlen>0) {
 964                         u_int32_t comm;
 965                         TCHECK2(tptr[0], 4);
 966                         comm = EXTRACT_32BITS(tptr);
 967                         switch (comm) {
 968                         case BGP_COMMUNITY_NO_EXPORT:
 969                                 printf(" NO_EXPORT");
 970                                 break;
 971                         case BGP_COMMUNITY_NO_ADVERT:
 972                                 printf(" NO_ADVERTISE");
 973                                 break;
 974                         case BGP_COMMUNITY_NO_EXPORT_SUBCONFED:
 975                                 printf(" NO_EXPORT_SUBCONFED");
 976                                 break;
 977                         default:
 978                                 printf("%u:%u%s",
 979                                        (comm >> 16) & 0xffff,
 980                                        comm & 0xffff,
 981                                        (tlen>4) ? ", " : "");
 982                                 break;
 983                         }
 984                         tlen -=4;
 985                         tptr +=4;
 986                 }
 987                 break;
 988         case BGPTYPE_ORIGINATOR_ID:
 989                 if (len != 4) {
 990                         printf("invalid len");
 991                         break;
 992                 }
 993                 TCHECK2(tptr[0], 4);
 994                 printf("%s",getname(tptr));
 995                 break;
 996         case BGPTYPE_CLUSTER_LIST:
 997                 if (len % 4) {
 998                         printf("invalid len");
 999                         break;
1000                 }
1001                 while (tlen>0) {
1002                         TCHECK2(tptr[0], 4);
1003                         printf("%s%s",
1004                                getname(tptr),
1005                                 (tlen>4) ? ", " : "");
1006                         tlen -=4;
1007                         tptr +=4;
1008                 }
1009                 break;
1010         case BGPTYPE_MP_REACH_NLRI:
1011                 TCHECK2(tptr[0], 3);
1012                 af = EXTRACT_16BITS(tptr);
1013                 safi = tptr[2];
1014
1015                 printf("\n\t    AFI: %s (%u), %sSAFI: %s (%u)",
1016                        tok2strbuf(bgp_afi_values, "Unknown AFI", af,
1017                                   tokbuf, sizeof(tokbuf)),
1018                        af,
1019                        (safi>128) ? "vendor specific " : "", /* 128 is meanwhile wellknown */
1020                        tok2strbuf(bgp_safi_values, "Unknown SAFI", safi,
1021                                   tokbuf, sizeof(tokbuf)),
1022                        safi);
1023
1024                 switch(af<<8 | safi) {
1025                 case (AFNUM_INET<<8 | SAFNUM_UNICAST):
1026                 case (AFNUM_INET<<8 | SAFNUM_MULTICAST):
1027                 case (AFNUM_INET<<8 | SAFNUM_UNIMULTICAST):
1028                 case (AFNUM_INET<<8 | SAFNUM_LABUNICAST):
1029                 case (AFNUM_INET<<8 | SAFNUM_RT_ROUTING_INFO):
1030                 case (AFNUM_INET<<8 | SAFNUM_VPNUNICAST):
1031                 case (AFNUM_INET<<8 | SAFNUM_VPNMULTICAST):
1032                 case (AFNUM_INET<<8 | SAFNUM_VPNUNIMULTICAST):
1033 #ifdef INET6
1034                 case (AFNUM_INET6<<8 | SAFNUM_UNICAST):
1035                 case (AFNUM_INET6<<8 | SAFNUM_MULTICAST):
1036                 case (AFNUM_INET6<<8 | SAFNUM_UNIMULTICAST):
1037                 case (AFNUM_INET6<<8 | SAFNUM_LABUNICAST):
1038                 case (AFNUM_INET6<<8 | SAFNUM_RT_ROUTING_INFO):
1039                 case (AFNUM_INET6<<8 | SAFNUM_VPNUNICAST):
1040                 case (AFNUM_INET6<<8 | SAFNUM_VPNMULTICAST):
1041                 case (AFNUM_INET6<<8 | SAFNUM_VPNUNIMULTICAST):
1042 #endif
1043                 case (AFNUM_NSAP<<8 | SAFNUM_UNICAST):
1044                 case (AFNUM_NSAP<<8 | SAFNUM_MULTICAST):
1045                 case (AFNUM_NSAP<<8 | SAFNUM_UNIMULTICAST):
1046                 case (AFNUM_NSAP<<8 | SAFNUM_VPNUNICAST):
1047                 case (AFNUM_NSAP<<8 | SAFNUM_VPNMULTICAST):
1048                 case (AFNUM_NSAP<<8 | SAFNUM_VPNUNIMULTICAST):
1049                 case (AFNUM_L2VPN<<8 | SAFNUM_VPNUNICAST):
1050                 case (AFNUM_L2VPN<<8 | SAFNUM_VPNMULTICAST):
1051                 case (AFNUM_L2VPN<<8 | SAFNUM_VPNUNIMULTICAST):
1052                     break;
1053                 default:
1054                     TCHECK2(tptr[0], tlen);
1055                     printf("\n\t    no AFI %u / SAFI %u decoder",af,safi);
1056                     if (vflag <= 1)
1057                         print_unknown_data(tptr,"\n\t    ",tlen);
1058                     goto done;
1059                     break;
1060                 }
1061
1062                 tptr +=3;
1063
1064                 TCHECK(tptr[0]);
1065                 nhlen = tptr[0];
1066                 tlen = nhlen;
1067                 tptr++;
1068
1069                 if (tlen) {
1070                     printf("\n\t    nexthop: ");
1071                     while (tlen > 0) {
1072                         switch(af<<8 | safi) {
1073                         case (AFNUM_INET<<8 | SAFNUM_UNICAST):
1074                         case (AFNUM_INET<<8 | SAFNUM_MULTICAST):
1075                         case (AFNUM_INET<<8 | SAFNUM_UNIMULTICAST):
1076                         case (AFNUM_INET<<8 | SAFNUM_LABUNICAST):
1077                         case (AFNUM_INET<<8 | SAFNUM_RT_ROUTING_INFO):
1078                             if (tlen < (int)sizeof(struct in_addr)) {
1079                                 printf("invalid len");
1080                                 tlen = 0;
1081                             } else {
1082                                 TCHECK2(tptr[0], sizeof(struct in_addr));
1083                                 printf("%s",getname(tptr));
1084                                 tlen -= sizeof(struct in_addr);
1085                                 tptr += sizeof(struct in_addr);
1086                             }
1087                             break;
1088                         case (AFNUM_INET<<8 | SAFNUM_VPNUNICAST):
1089                         case (AFNUM_INET<<8 | SAFNUM_VPNMULTICAST):
1090                         case (AFNUM_INET<<8 | SAFNUM_VPNUNIMULTICAST):
1091                             if (tlen < (int)(sizeof(struct in_addr)+BGP_VPN_RD_LEN)) {
1092                                 printf("invalid len");
1093                                 tlen = 0;
1094                             } else {
1095                                 TCHECK2(tptr[0], sizeof(struct in_addr)+BGP_VPN_RD_LEN);
1096                                 printf("RD: %s, %s",
1097                                        bgp_vpn_rd_print(tptr),
1098                                        getname(tptr+BGP_VPN_RD_LEN));
1099                                 tlen -= (sizeof(struct in_addr)+BGP_VPN_RD_LEN);
1100                                 tptr += (sizeof(struct in_addr)+BGP_VPN_RD_LEN);
1101                             }
1102                             break;
1103 #ifdef INET6
1104                         case (AFNUM_INET6<<8 | SAFNUM_UNICAST):
1105                         case (AFNUM_INET6<<8 | SAFNUM_MULTICAST):
1106                         case (AFNUM_INET6<<8 | SAFNUM_UNIMULTICAST):
1107                         case (AFNUM_INET6<<8 | SAFNUM_LABUNICAST):
1108                         case (AFNUM_INET6<<8 | SAFNUM_RT_ROUTING_INFO):
1109                             if (tlen < (int)sizeof(struct in6_addr)) {
1110                                 printf("invalid len");
1111                                 tlen = 0;
1112                             } else {
1113                                 TCHECK2(tptr[0], sizeof(struct in6_addr));
1114                                 printf("%s", getname6(tptr));
1115                                 tlen -= sizeof(struct in6_addr);
1116                                 tptr += sizeof(struct in6_addr);
1117                             }
1118                             break;
1119                         case (AFNUM_INET6<<8 | SAFNUM_VPNUNICAST):
1120                         case (AFNUM_INET6<<8 | SAFNUM_VPNMULTICAST):
1121                         case (AFNUM_INET6<<8 | SAFNUM_VPNUNIMULTICAST):
1122                             if (tlen < (int)(sizeof(struct in6_addr)+BGP_VPN_RD_LEN)) {
1123                                 printf("invalid len");
1124                                 tlen = 0;
1125                             } else {
1126                                 TCHECK2(tptr[0], sizeof(struct in6_addr)+BGP_VPN_RD_LEN);
1127                                 printf("RD: %s, %s",
1128                                        bgp_vpn_rd_print(tptr),
1129                                        getname6(tptr+BGP_VPN_RD_LEN));
1130                                 tlen -= (sizeof(struct in6_addr)+BGP_VPN_RD_LEN);
1131                                 tptr += (sizeof(struct in6_addr)+BGP_VPN_RD_LEN);
1132                             }
1133                             break;
1134 #endif
1135                         case (AFNUM_L2VPN<<8 | SAFNUM_VPNUNICAST):
1136                         case (AFNUM_L2VPN<<8 | SAFNUM_VPNMULTICAST):
1137                         case (AFNUM_L2VPN<<8 | SAFNUM_VPNUNIMULTICAST):
1138                             if (tlen < (int)sizeof(struct in_addr)) {
1139                                 printf("invalid len");
1140                                 tlen = 0;
1141                             } else {
1142                                 TCHECK2(tptr[0], sizeof(struct in_addr));
1143                                 printf("%s", getname(tptr));
1144                                 tlen -= (sizeof(struct in_addr));
1145                                 tptr += (sizeof(struct in_addr));
1146                             }
1147                             break;
1148                         case (AFNUM_NSAP<<8 | SAFNUM_UNICAST):
1149                         case (AFNUM_NSAP<<8 | SAFNUM_MULTICAST):
1150                         case (AFNUM_NSAP<<8 | SAFNUM_UNIMULTICAST):
1151                             TCHECK2(tptr[0], tlen);
1152                             printf("%s",isonsap_string(tptr,tlen));
1153                             tptr += tlen;
1154                             tlen = 0;
1155                             break;
1156
1157                         case (AFNUM_NSAP<<8 | SAFNUM_VPNUNICAST):
1158                         case (AFNUM_NSAP<<8 | SAFNUM_VPNMULTICAST):
1159                         case (AFNUM_NSAP<<8 | SAFNUM_VPNUNIMULTICAST):
1160                             if (tlen < BGP_VPN_RD_LEN+1) {
1161                                 printf("invalid len");
1162                                 tlen = 0;
1163                             } else {
1164                                 TCHECK2(tptr[0], tlen);
1165                                 printf("RD: %s, %s",
1166                                        bgp_vpn_rd_print(tptr),
1167                                        isonsap_string(tptr+BGP_VPN_RD_LEN,tlen-BGP_VPN_RD_LEN));
1168                                 /* rfc986 mapped IPv4 address ? */
1169                                 if (EXTRACT_32BITS(tptr+BGP_VPN_RD_LEN) ==  0x47000601)
1170                                     printf(" = %s", getname(tptr+BGP_VPN_RD_LEN+4));
1171 #ifdef INET6
1172                                 /* rfc1888 mapped IPv6 address ? */
1173                                 else if (EXTRACT_24BITS(tptr+BGP_VPN_RD_LEN) ==  0x350000)
1174                                     printf(" = %s", getname6(tptr+BGP_VPN_RD_LEN+3));
1175 #endif
1176                                 tptr += tlen;
1177                                 tlen = 0;
1178                             }
1179                             break;
1180                         default:
1181                             TCHECK2(tptr[0], tlen);
1182                             printf("no AFI %u/SAFI %u decoder",af,safi);
1183                             if (vflag <= 1)
1184                                 print_unknown_data(tptr,"\n\t    ",tlen);
1185                             tptr += tlen;
1186                             tlen = 0;
1187                             goto done;
1188                             break;
1189                         }
1190                     }
1191                 }
1192                 printf(", nh-length: %u", nhlen);
1193                 tptr += tlen;
1194
1195                 TCHECK(tptr[0]);
1196                 snpa = tptr[0];
1197                 tptr++;
1198
1199                 if (snpa) {
1200                         printf("\n\t    %u SNPA", snpa);
1201                         for (/*nothing*/; snpa > 0; snpa--) {
1202                                 TCHECK(tptr[0]);
1203                                 printf("\n\t      %d bytes", tptr[0]);
1204                                 tptr += tptr[0] + 1;
1205                         }
1206                 } else {
1207                         printf(", no SNPA");
1208                 }
1209
1210                 while (len - (tptr - pptr) > 0) {
1211                     switch (af<<8 | safi) {
1212                     case (AFNUM_INET<<8 | SAFNUM_UNICAST):
1213                     case (AFNUM_INET<<8 | SAFNUM_MULTICAST):
1214                     case (AFNUM_INET<<8 | SAFNUM_UNIMULTICAST):
1215                         advance = decode_prefix4(tptr, buf, sizeof(buf));
1216                         if (advance == -1)
1217                             printf("\n\t    (illegal prefix length)");
1218                         else if (advance == -2)
1219                             goto trunc;
1220                         else
1221                             printf("\n\t      %s", buf);
1222                         break;
1223                     case (AFNUM_INET<<8 | SAFNUM_LABUNICAST):
1224                         advance = decode_labeled_prefix4(tptr, buf, sizeof(buf));
1225                         if (advance == -1)
1226                             printf("\n\t    (illegal prefix length)");
1227                         else if (advance == -2)
1228                             goto trunc;
1229                         else
1230                             printf("\n\t      %s", buf);
1231                         break;
1232                     case (AFNUM_INET<<8 | SAFNUM_VPNUNICAST):
1233                     case (AFNUM_INET<<8 | SAFNUM_VPNMULTICAST):
1234                     case (AFNUM_INET<<8 | SAFNUM_VPNUNIMULTICAST):
1235                         advance = decode_labeled_vpn_prefix4(tptr, buf, sizeof(buf));
1236                         if (advance == -1)
1237                             printf("\n\t    (illegal prefix length)");
1238                         else if (advance == -2)
1239                             goto trunc;
1240                         else
1241                             printf("\n\t      %s", buf);
1242                         break;
1243                     case (AFNUM_INET<<8 | SAFNUM_RT_ROUTING_INFO):
1244                         advance = decode_rt_routing_info(tptr, buf, sizeof(buf));
1245                         if (advance == -1)
1246                             printf("\n\t    (illegal prefix length)");
1247                         else if (advance == -2)
1248                             goto trunc;
1249                         else
1250                             printf("\n\t      %s", buf);
1251                         break;
1252 #ifdef INET6
1253                     case (AFNUM_INET6<<8 | SAFNUM_UNICAST):
1254                     case (AFNUM_INET6<<8 | SAFNUM_MULTICAST):
1255                     case (AFNUM_INET6<<8 | SAFNUM_UNIMULTICAST):
1256                         advance = decode_prefix6(tptr, buf, sizeof(buf));
1257                         if (advance == -1)
1258                             printf("\n\t    (illegal prefix length)");
1259                         else if (advance == -2)
1260                             goto trunc;
1261                         else
1262                             printf("\n\t      %s", buf);
1263                         break;
1264                     case (AFNUM_INET6<<8 | SAFNUM_LABUNICAST):
1265                         advance = decode_labeled_prefix6(tptr, buf, sizeof(buf));
1266                         if (advance == -1)
1267                             printf("\n\t    (illegal prefix length)");
1268                         else if (advance == -2)
1269                             goto trunc;
1270                         else
1271                             printf("\n\t      %s", buf);
1272                         break;
1273                     case (AFNUM_INET6<<8 | SAFNUM_VPNUNICAST):
1274                     case (AFNUM_INET6<<8 | SAFNUM_VPNMULTICAST):
1275                     case (AFNUM_INET6<<8 | SAFNUM_VPNUNIMULTICAST):
1276                         advance = decode_labeled_vpn_prefix6(tptr, buf, sizeof(buf));
1277                         if (advance == -1)
1278                             printf("\n\t    (illegal prefix length)");
1279                         else if (advance == -2)
1280                             goto trunc;
1281                         else
1282                             printf("\n\t      %s", buf);
1283                         break;
1284                     case (AFNUM_INET6<<8 | SAFNUM_RT_ROUTING_INFO):
1285                         advance = decode_rt_routing_info(tptr, buf, sizeof(buf));
1286                         if (advance == -1)
1287                             printf("\n\t    (illegal prefix length)");
1288                         else if (advance == -2)
1289                             goto trunc;
1290                         else
1291                             printf("\n\t      %s", buf);
1292                         break;
1293 #endif
1294                     case (AFNUM_L2VPN<<8 | SAFNUM_VPNUNICAST):
1295                     case (AFNUM_L2VPN<<8 | SAFNUM_VPNMULTICAST):
1296                     case (AFNUM_L2VPN<<8 | SAFNUM_VPNUNIMULTICAST):
1297                         advance = decode_labeled_vpn_l2(tptr, buf, sizeof(buf));
1298                         if (advance == -1)
1299                             printf("\n\t    (illegal length)");
1300                         else if (advance == -2)
1301                             goto trunc;
1302                         else
1303                             printf("\n\t      %s", buf);
1304                         break;
1305                     case (AFNUM_NSAP<<8 | SAFNUM_UNICAST):
1306                     case (AFNUM_NSAP<<8 | SAFNUM_MULTICAST):
1307                     case (AFNUM_NSAP<<8 | SAFNUM_UNIMULTICAST):
1308                         advance = decode_clnp_prefix(tptr, buf, sizeof(buf));
1309                         if (advance == -1)
1310                             printf("\n\t    (illegal prefix length)");
1311                         else if (advance == -2)
1312                             goto trunc;
1313                         else
1314                             printf("\n\t      %s", buf);
1315                         break;
1316                     case (AFNUM_NSAP<<8 | SAFNUM_VPNUNICAST):
1317                     case (AFNUM_NSAP<<8 | SAFNUM_VPNMULTICAST):
1318                     case (AFNUM_NSAP<<8 | SAFNUM_VPNUNIMULTICAST):
1319                         advance = decode_labeled_vpn_clnp_prefix(tptr, buf, sizeof(buf));
1320                         if (advance == -1)
1321                             printf("\n\t    (illegal prefix length)");
1322                         else if (advance == -2)
1323                             goto trunc;
1324                         else
1325                             printf("\n\t      %s", buf);
1326                         break;
1327                     default:
1328                         TCHECK2(*tptr,tlen);
1329                         printf("\n\t    no AFI %u / SAFI %u decoder",af,safi);
1330                         if (vflag <= 1)
1331                             print_unknown_data(tptr,"\n\t    ",tlen);
1332                         advance = 0;
1333                         tptr = pptr + len;
1334                         break;
1335                     }
1336                     if (advance < 0)
1337                         break;
1338                     tptr += advance;
1339                 }
1340         done:
1341                 break;
1342
1343         case BGPTYPE_MP_UNREACH_NLRI:
1344                 TCHECK2(tptr[0], BGP_MP_NLRI_MINSIZE);
1345                 af = EXTRACT_16BITS(tptr);
1346                 safi = tptr[2];
1347
1348                 printf("\n\t    AFI: %s (%u), %sSAFI: %s (%u)",
1349                        tok2strbuf(bgp_afi_values, "Unknown AFI", af,
1350                                   tokbuf, sizeof(tokbuf)),
1351                        af,
1352                        (safi>128) ? "vendor specific " : "", /* 128 is meanwhile wellknown */
1353                        tok2strbuf(bgp_safi_values, "Unknown SAFI", safi,
1354                                   tokbuf, sizeof(tokbuf)),
1355                        safi);
1356
1357                 if (len == BGP_MP_NLRI_MINSIZE)
1358                     printf("\n\t      End-of-Rib Marker (empty NLRI)");
1359
1360                 tptr += 3;
1361
1362                 while (len - (tptr - pptr) > 0) {
1363                     switch (af<<8 | safi) {
1364                     case (AFNUM_INET<<8 | SAFNUM_UNICAST):
1365                     case (AFNUM_INET<<8 | SAFNUM_MULTICAST):
1366                     case (AFNUM_INET<<8 | SAFNUM_UNIMULTICAST):
1367                         advance = decode_prefix4(tptr, buf, sizeof(buf));
1368                         if (advance == -1)
1369                             printf("\n\t    (illegal prefix length)");
1370                         else if (advance == -2)
1371                             goto trunc;
1372                         else
1373                             printf("\n\t      %s", buf);
1374                         break;
1375                     case (AFNUM_INET<<8 | SAFNUM_LABUNICAST):
1376                         advance = decode_labeled_prefix4(tptr, buf, sizeof(buf));
1377                         if (advance == -1)
1378                             printf("\n\t    (illegal prefix length)");
1379                         else if (advance == -2)
1380                             goto trunc;
1381                         else
1382                             printf("\n\t      %s", buf);
1383                         break;
1384                     case (AFNUM_INET<<8 | SAFNUM_VPNUNICAST):
1385                     case (AFNUM_INET<<8 | SAFNUM_VPNMULTICAST):
1386                     case (AFNUM_INET<<8 | SAFNUM_VPNUNIMULTICAST):
1387                         advance = decode_labeled_vpn_prefix4(tptr, buf, sizeof(buf));
1388                         if (advance == -1)
1389                             printf("\n\t    (illegal prefix length)");
1390                         else if (advance == -2)
1391                             goto trunc;
1392                         else
1393                             printf("\n\t      %s", buf);
1394                         break;
1395 #ifdef INET6
1396                     case (AFNUM_INET6<<8 | SAFNUM_UNICAST):
1397                     case (AFNUM_INET6<<8 | SAFNUM_MULTICAST):
1398                     case (AFNUM_INET6<<8 | SAFNUM_UNIMULTICAST):
1399                         advance = decode_prefix6(tptr, buf, sizeof(buf));
1400                         if (advance == -1)
1401                             printf("\n\t    (illegal prefix length)");
1402                         else if (advance == -2)
1403                             goto trunc;
1404                         else
1405                             printf("\n\t      %s", buf);
1406                         break;
1407                     case (AFNUM_INET6<<8 | SAFNUM_LABUNICAST):
1408                         advance = decode_labeled_prefix6(tptr, buf, sizeof(buf));
1409                         if (advance == -1)
1410                             printf("\n\t    (illegal prefix length)");
1411                         else if (advance == -2)
1412                             goto trunc;
1413                         else
1414                             printf("\n\t      %s", buf);
1415                         break;
1416                     case (AFNUM_INET6<<8 | SAFNUM_VPNUNICAST):
1417                     case (AFNUM_INET6<<8 | SAFNUM_VPNMULTICAST):
1418                     case (AFNUM_INET6<<8 | SAFNUM_VPNUNIMULTICAST):
1419                         advance = decode_labeled_vpn_prefix6(tptr, buf, sizeof(buf));
1420                         if (advance == -1)
1421                             printf("\n\t    (illegal prefix length)");
1422                         else if (advance == -2)
1423                             goto trunc;
1424                         else
1425                             printf("\n\t      %s", buf);
1426                         break;
1427 #endif
1428                     case (AFNUM_L2VPN<<8 | SAFNUM_VPNUNICAST):
1429                     case (AFNUM_L2VPN<<8 | SAFNUM_VPNMULTICAST):
1430                     case (AFNUM_L2VPN<<8 | SAFNUM_VPNUNIMULTICAST):
1431                         advance = decode_labeled_vpn_l2(tptr, buf, sizeof(buf));
1432                         if (advance == -1)
1433                             printf("\n\t    (illegal length)");
1434                         else if (advance == -2)
1435                             goto trunc;
1436                         else
1437                             printf("\n\t      %s", buf);
1438                         break;
1439                     case (AFNUM_NSAP<<8 | SAFNUM_UNICAST):
1440                     case (AFNUM_NSAP<<8 | SAFNUM_MULTICAST):
1441                     case (AFNUM_NSAP<<8 | SAFNUM_UNIMULTICAST):
1442                         advance = decode_clnp_prefix(tptr, buf, sizeof(buf));
1443                         if (advance == -1)
1444                             printf("\n\t    (illegal prefix length)");
1445                         else if (advance == -2)
1446                             goto trunc;
1447                         else
1448                             printf("\n\t      %s", buf);
1449                         break;
1450                     case (AFNUM_NSAP<<8 | SAFNUM_VPNUNICAST):
1451                     case (AFNUM_NSAP<<8 | SAFNUM_VPNMULTICAST):
1452                     case (AFNUM_NSAP<<8 | SAFNUM_VPNUNIMULTICAST):
1453                         advance = decode_labeled_vpn_clnp_prefix(tptr, buf, sizeof(buf));
1454                         if (advance == -1)
1455                             printf("\n\t    (illegal prefix length)");
1456                         else if (advance == -2)
1457                             goto trunc;
1458                         else
1459                             printf("\n\t      %s", buf);
1460                         break;
1461                     default:
1462                         TCHECK2(*(tptr-3),tlen);
1463                         printf("no AFI %u / SAFI %u decoder",af,safi);
1464                         if (vflag <= 1)
1465                             print_unknown_data(tptr-3,"\n\t    ",tlen);
1466                         advance = 0;
1467                         tptr = pptr + len;
1468                         break;
1469                     }
1470                     if (advance < 0)
1471                         break;
1472                     tptr += advance;
1473                 }
1474                 break;
1475         case BGPTYPE_EXTD_COMMUNITIES:
1476                 if (len % 8) {
1477                         printf("invalid len");
1478                         break;
1479                 }
1480                 while (tlen>0) {
1481                     u_int16_t extd_comm;
1482
1483                     TCHECK2(tptr[0], 2);
1484                     extd_comm=EXTRACT_16BITS(tptr);
1485
1486                     printf("\n\t    %s (0x%04x), Flags [%s]",
1487                            tok2strbuf(bgp_extd_comm_subtype_values,
1488                                       "unknown extd community typecode",
1489                                       extd_comm, tokbuf, sizeof(tokbuf)),
1490                            extd_comm,
1491                            bittok2str(bgp_extd_comm_flag_values, "none", extd_comm));
1492
1493                     TCHECK2(*(tptr+2), 6);
1494                     switch(extd_comm) {
1495                     case BGP_EXT_COM_RT_0:
1496                     case BGP_EXT_COM_RO_0:
1497                         printf(": %u:%s",
1498                                EXTRACT_16BITS(tptr+2),
1499                                getname(tptr+4));
1500                         break;
1501                     case BGP_EXT_COM_RT_1:
1502                     case BGP_EXT_COM_RO_1:
1503                         printf(": %s:%u",
1504                                getname(tptr+2),
1505                                EXTRACT_16BITS(tptr+6));
1506                         break;
1507                     case BGP_EXT_COM_RT_2:
1508                     case BGP_EXT_COM_RO_2:
1509                         printf(": %u:%u",
1510                                EXTRACT_32BITS(tptr+2),
1511                                EXTRACT_16BITS(tptr+6));
1512                         break;
1513                     case BGP_EXT_COM_LINKBAND:
1514                         bw.i = EXTRACT_32BITS(tptr+2);
1515                         printf(": bandwidth: %.3f Mbps",
1516                                bw.f*8/1000000);
1517                         break;
1518                     case BGP_EXT_COM_CISCO_MCAST:
1519                         printf(": AS %u, group %s",
1520                                EXTRACT_16BITS(tptr+2),
1521                                getname(tptr+4));
1522                         break;
1523                     case BGP_EXT_COM_VPN_ORIGIN:
1524                     case BGP_EXT_COM_VPN_ORIGIN2:
1525                     case BGP_EXT_COM_VPN_ORIGIN3:
1526                     case BGP_EXT_COM_VPN_ORIGIN4:
1527                     case BGP_EXT_COM_OSPF_RID:
1528                     case BGP_EXT_COM_OSPF_RID2:
1529                         printf("%s", getname(tptr+2));
1530                         break;
1531                     case BGP_EXT_COM_OSPF_RTYPE:
1532                     case BGP_EXT_COM_OSPF_RTYPE2:
1533                         printf(": area:%s, router-type:%s, metric-type:%s%s",
1534                                getname(tptr+2),
1535                                tok2strbuf(bgp_extd_comm_ospf_rtype_values,
1536                                           "unknown (0x%02x)",
1537                                           *(tptr+6),
1538                                           tokbuf, sizeof(tokbuf)),
1539                                (*(tptr+7) &  BGP_OSPF_RTYPE_METRIC_TYPE) ? "E2" : "",
1540                                (*(tptr+6) == (BGP_OSPF_RTYPE_EXT ||BGP_OSPF_RTYPE_NSSA )) ? "E1" : "");
1541                         break;
1542                     case BGP_EXT_COM_L2INFO:
1543                         printf(": %s Control Flags [0x%02x]:MTU %u",
1544                                tok2strbuf(l2vpn_encaps_values,
1545                                           "unknown encaps",
1546                                           *(tptr+2),
1547                                           tokbuf, sizeof(tokbuf)),
1548                                        *(tptr+3),
1549                                EXTRACT_16BITS(tptr+4));
1550                         break;
1551                     default:
1552                         TCHECK2(*tptr,8);
1553                         print_unknown_data(tptr,"\n\t      ",8);
1554                         break;
1555                     }
1556                     tlen -=8;
1557                     tptr +=8;
1558                 }
1559                 break;
1560
1561         case BGPTYPE_ATTR_SET:
1562                 TCHECK2(tptr[0], 4);
1563                 printf("\n\t    Origin AS: %u", EXTRACT_32BITS(tptr));
1564                 tptr+=4;
1565                 len -=4;
1566
1567                 while (len >= 2 ) {
1568                     int alen;
1569                     struct bgp_attr bgpa;
1570
1571                     TCHECK2(tptr[0], sizeof(bgpa));
1572                     memcpy(&bgpa, tptr, sizeof(bgpa));
1573                     alen = bgp_attr_len(&bgpa);
1574                     tptr += bgp_attr_off(&bgpa);
1575                     len -= bgp_attr_off(&bgpa);
1576
1577                     printf("\n\t      %s (%u), length: %u",
1578                            tok2strbuf(bgp_attr_values,
1579                                       "Unknown Attribute", bgpa.bgpa_type,
1580                                       tokbuf, sizeof(tokbuf)),
1581                            bgpa.bgpa_type,
1582                            alen);
1583
1584                     if (bgpa.bgpa_flags) {
1585                         printf(", Flags [%s%s%s%s",
1586                                bgpa.bgpa_flags & 0x80 ? "O" : "",
1587                                bgpa.bgpa_flags & 0x40 ? "T" : "",
1588                                bgpa.bgpa_flags & 0x20 ? "P" : "",
1589                                bgpa.bgpa_flags & 0x10 ? "E" : "");
1590                         if (bgpa.bgpa_flags & 0xf)
1591                             printf("+%x", bgpa.bgpa_flags & 0xf);
1592                         printf("]: ");
1593                     }
1594                     /* FIXME check for recursion */
1595                     if (!bgp_attr_print(&bgpa, tptr, alen))
1596                         return 0;
1597                     tptr += alen;
1598                     len -= alen;
1599                 }
1600                 break;
1601
1602
1603         default:
1604             TCHECK2(*pptr,len);
1605             printf("\n\t    no Attribute %u decoder",attr->bgpa_type); /* we have no decoder for the attribute */
1606             if (vflag <= 1)
1607                 print_unknown_data(pptr,"\n\t    ",len);
1608             break;
1609         }
1610         if (vflag > 1 && len) { /* omit zero length attributes*/
1611             TCHECK2(*pptr,len);
1612             print_unknown_data(pptr,"\n\t    ",len);
1613         }
1614         return 1;
1615
1616 trunc:
1617         return 0;
1618 }
1619
1620 static void
1621 bgp_open_print(const u_char *dat, int length)
1622 {
1623         struct bgp_open bgpo;
1624         struct bgp_opt bgpopt;
1625         const u_char *opt;
1626         int i,cap_type,cap_len,tcap_len,cap_offset;
1627         char tokbuf[TOKBUFSIZE];
1628         char tokbuf2[TOKBUFSIZE];
1629
1630         TCHECK2(dat[0], BGP_OPEN_SIZE);
1631         memcpy(&bgpo, dat, BGP_OPEN_SIZE);
1632
1633         printf("\n\t  Version %d, ", bgpo.bgpo_version);
1634         printf("my AS %u, ", ntohs(bgpo.bgpo_myas));
1635         printf("Holdtime %us, ", ntohs(bgpo.bgpo_holdtime));
1636         printf("ID %s", getname((u_char *)&bgpo.bgpo_id));
1637         printf("\n\t  Optional parameters, length: %u", bgpo.bgpo_optlen);
1638
1639         /* some little sanity checking */
1640         if (length < bgpo.bgpo_optlen+BGP_OPEN_SIZE)
1641             return;
1642
1643         /* ugly! */
1644         opt = &((const struct bgp_open *)dat)->bgpo_optlen;
1645         opt++;
1646
1647         i = 0;
1648         while (i < bgpo.bgpo_optlen) {
1649                 TCHECK2(opt[i], BGP_OPT_SIZE);
1650                 memcpy(&bgpopt, &opt[i], BGP_OPT_SIZE);
1651                 if (i + 2 + bgpopt.bgpopt_len > bgpo.bgpo_optlen) {
1652                         printf("\n\t     Option %d, length: %u", bgpopt.bgpopt_type, bgpopt.bgpopt_len);
1653                         break;
1654                 }
1655
1656                 printf("\n\t    Option %s (%u), length: %u",
1657                        tok2strbuf(bgp_opt_values,"Unknown",
1658                                   bgpopt.bgpopt_type,
1659                                   tokbuf, sizeof(tokbuf)),
1660                        bgpopt.bgpopt_type,
1661                        bgpopt.bgpopt_len);
1662
1663                 /* now lets decode the options we know*/
1664                 switch(bgpopt.bgpopt_type) {
1665                 case BGP_OPT_CAP:
1666                     cap_type=opt[i+BGP_OPT_SIZE];
1667                     cap_len=opt[i+BGP_OPT_SIZE+1];
1668                     tcap_len=cap_len;
1669                     printf("\n\t      %s (%u), length: %u",
1670                            tok2strbuf(bgp_capcode_values, "Unknown",
1671                                       cap_type, tokbuf, sizeof(tokbuf)),
1672                            cap_type,
1673                            cap_len);
1674                     switch(cap_type) {
1675                     case BGP_CAPCODE_MP:
1676                         printf("\n\t\tAFI %s (%u), SAFI %s (%u)",
1677                                tok2strbuf(bgp_afi_values, "Unknown",
1678                                           EXTRACT_16BITS(opt+i+BGP_OPT_SIZE+2),
1679                                           tokbuf, sizeof(tokbuf)),
1680                                EXTRACT_16BITS(opt+i+BGP_OPT_SIZE+2),
1681                                tok2strbuf(bgp_safi_values, "Unknown",
1682                                           opt[i+BGP_OPT_SIZE+5],
1683                                           tokbuf, sizeof(tokbuf)),
1684                                opt[i+BGP_OPT_SIZE+5]);
1685                         break;
1686                     case BGP_CAPCODE_RESTART:
1687                         printf("\n\t\tRestart Flags: [%s], Restart Time %us",
1688                                ((opt[i+BGP_OPT_SIZE+2])&0x80) ? "R" : "none",
1689                                EXTRACT_16BITS(opt+i+BGP_OPT_SIZE+2)&0xfff);
1690                         tcap_len-=2;
1691                         cap_offset=4;
1692                         while(tcap_len>=4) {
1693                             printf("\n\t\t  AFI %s (%u), SAFI %s (%u), Forwarding state preserved: %s",
1694                                    tok2strbuf(bgp_afi_values,"Unknown",
1695                                               EXTRACT_16BITS(opt+i+BGP_OPT_SIZE+cap_offset),
1696                                               tokbuf, sizeof(tokbuf)),
1697                                    EXTRACT_16BITS(opt+i+BGP_OPT_SIZE+cap_offset),
1698                                    tok2strbuf(bgp_safi_values,"Unknown",
1699                                               opt[i+BGP_OPT_SIZE+cap_offset+2],
1700                                               tokbuf2, sizeof(tokbuf2)),
1701                                    opt[i+BGP_OPT_SIZE+cap_offset+2],
1702                                    ((opt[i+BGP_OPT_SIZE+cap_offset+3])&0x80) ? "yes" : "no" );
1703                             tcap_len-=4;
1704                             cap_offset+=4;
1705                         }
1706                         break;
1707                     case BGP_CAPCODE_RR:
1708                     case BGP_CAPCODE_RR_CISCO:
1709                         break;
1710                     default:
1711                         TCHECK2(opt[i+BGP_OPT_SIZE+2],cap_len);
1712                         printf("\n\t\tno decoder for Capability %u",
1713                                cap_type);
1714                         if (vflag <= 1)
1715                             print_unknown_data(&opt[i+BGP_OPT_SIZE+2],"\n\t\t",cap_len);
1716                         break;
1717                     }
1718                     if (vflag > 1) {
1719                         TCHECK2(opt[i+BGP_OPT_SIZE+2],cap_len);
1720                         print_unknown_data(&opt[i+BGP_OPT_SIZE+2],"\n\t\t",cap_len);
1721                     }
1722                     break;
1723                 case BGP_OPT_AUTH:
1724                 default:
1725                        printf("\n\t      no decoder for option %u",
1726                            bgpopt.bgpopt_type);
1727                        break;
1728                 }
1729
1730                 i += BGP_OPT_SIZE + bgpopt.bgpopt_len;
1731         }
1732         return;
1733 trunc:
1734         printf("[|BGP]");
1735 }
1736
1737 static void
1738 bgp_update_print(const u_char *dat, int length)
1739 {
1740         struct bgp bgp;
1741         struct bgp_attr bgpa;
1742         const u_char *p;
1743         int len;
1744         int i;
1745         char tokbuf[TOKBUFSIZE];
1746
1747         TCHECK2(dat[0], BGP_SIZE);
1748         memcpy(&bgp, dat, BGP_SIZE);
1749         p = dat + BGP_SIZE;     /*XXX*/
1750
1751         /* Unfeasible routes */
1752         len = EXTRACT_16BITS(p);
1753         if (len) {
1754                 /*
1755                  * Without keeping state from the original NLRI message,
1756                  * it's not possible to tell if this a v4 or v6 route,
1757                  * so only try to decode it if we're not v6 enabled.
1758                  */
1759 #ifdef INET6
1760                 printf("\n\t  Withdrawn routes: %d bytes", len);
1761 #else
1762                 char buf[MAXHOSTNAMELEN + 100];
1763                 int wpfx;
1764
1765                 TCHECK2(p[2], len);
1766                 i = 2;
1767
1768                 printf("\n\t  Withdrawn routes:");
1769
1770                 while(i < 2 + len) {
1771                         wpfx = decode_prefix4(&p[i], buf, sizeof(buf));
1772                         if (wpfx == -1) {
1773                                 printf("\n\t    (illegal prefix length)");
1774                                 break;
1775                         } else if (wpfx == -2)
1776                                 goto trunc;
1777                         else {
1778                                 i += wpfx;
1779                                 printf("\n\t    %s", buf);
1780                         }
1781                 }
1782 #endif
1783         }
1784         p += 2 + len;
1785
1786         TCHECK2(p[0], 2);
1787         len = EXTRACT_16BITS(p);
1788
1789         if (len == 0 && length == BGP_UPDATE_MINSIZE) {
1790             printf("\n\t  End-of-Rib Marker (empty NLRI)");
1791             return;
1792         }
1793
1794         if (len) {
1795                 /* do something more useful!*/
1796                 i = 2;
1797                 while (i < 2 + len) {
1798                         int alen, aoff;
1799
1800                         TCHECK2(p[i], sizeof(bgpa));
1801                         memcpy(&bgpa, &p[i], sizeof(bgpa));
1802                         alen = bgp_attr_len(&bgpa);
1803                         aoff = bgp_attr_off(&bgpa);
1804
1805                        printf("\n\t  %s (%u), length: %u",
1806                               tok2strbuf(bgp_attr_values, "Unknown Attribute",
1807                                          bgpa.bgpa_type,
1808                                          tokbuf, sizeof(tokbuf)),
1809                               bgpa.bgpa_type,
1810                               alen);
1811
1812                         if (bgpa.bgpa_flags) {
1813                                 printf(", Flags [%s%s%s%s",
1814                                         bgpa.bgpa_flags & 0x80 ? "O" : "",
1815                                         bgpa.bgpa_flags & 0x40 ? "T" : "",
1816                                         bgpa.bgpa_flags & 0x20 ? "P" : "",
1817                                         bgpa.bgpa_flags & 0x10 ? "E" : "");
1818                                 if (bgpa.bgpa_flags & 0xf)
1819                                         printf("+%x", bgpa.bgpa_flags & 0xf);
1820                                 printf("]: ");
1821                         }
1822                         if (!bgp_attr_print(&bgpa, &p[i + aoff], alen))
1823                                 goto trunc;
1824                         i += aoff + alen;
1825                 }
1826         }
1827         p += 2 + len;
1828
1829         if (dat + length > p) {
1830                 printf("\n\t  Updated routes:");
1831                 while (dat + length > p) {
1832                         char buf[MAXHOSTNAMELEN + 100];
1833                         i = decode_prefix4(p, buf, sizeof(buf));
1834                         if (i == -1) {
1835                                 printf("\n\t    (illegal prefix length)");
1836                                 break;
1837                         } else if (i == -2)
1838                                 goto trunc;
1839                         else {
1840                                 printf("\n\t    %s", buf);
1841                                 p += i;
1842                         }
1843                 }
1844         }
1845         return;
1846 trunc:
1847         printf("[|BGP]");
1848 }
1849
1850 static void
1851 bgp_notification_print(const u_char *dat, int length)
1852 {
1853         struct bgp_notification bgpn;
1854         const u_char *tptr;
1855         char tokbuf[TOKBUFSIZE];
1856         char tokbuf2[TOKBUFSIZE];
1857
1858         TCHECK2(dat[0], BGP_NOTIFICATION_SIZE);
1859         memcpy(&bgpn, dat, BGP_NOTIFICATION_SIZE);
1860
1861         /* some little sanity checking */
1862         if (length<BGP_NOTIFICATION_SIZE)
1863             return;
1864
1865         printf(", %s (%u)",
1866                tok2strbuf(bgp_notify_major_values, "Unknown Error",
1867                           bgpn.bgpn_major, tokbuf, sizeof(tokbuf)),
1868                bgpn.bgpn_major);
1869
1870         switch (bgpn.bgpn_major) {
1871
1872         case BGP_NOTIFY_MAJOR_MSG:
1873             printf(", subcode %s (%u)",
1874                    tok2strbuf(bgp_notify_minor_msg_values, "Unknown",
1875                               bgpn.bgpn_minor, tokbuf, sizeof(tokbuf)),
1876                    bgpn.bgpn_minor);
1877             break;
1878         case BGP_NOTIFY_MAJOR_OPEN:
1879             printf(", subcode %s (%u)",
1880                    tok2strbuf(bgp_notify_minor_open_values, "Unknown",
1881                               bgpn.bgpn_minor, tokbuf, sizeof(tokbuf)),
1882                    bgpn.bgpn_minor);
1883             break;
1884         case BGP_NOTIFY_MAJOR_UPDATE:
1885             printf(", subcode %s (%u)",
1886                    tok2strbuf(bgp_notify_minor_update_values, "Unknown",
1887                               bgpn.bgpn_minor, tokbuf, sizeof(tokbuf)),
1888                    bgpn.bgpn_minor);
1889             break;
1890         case BGP_NOTIFY_MAJOR_CAP:
1891             printf(" subcode %s (%u)",
1892                    tok2strbuf(bgp_notify_minor_cap_values, "Unknown",
1893                               bgpn.bgpn_minor, tokbuf, sizeof(tokbuf)),
1894                    bgpn.bgpn_minor);
1895         case BGP_NOTIFY_MAJOR_CEASE:
1896             printf(", subcode %s (%u)",
1897                    tok2strbuf(bgp_notify_minor_cease_values, "Unknown",
1898                               bgpn.bgpn_minor, tokbuf, sizeof(tokbuf)),
1899                    bgpn.bgpn_minor);
1900
1901             /* draft-ietf-idr-cease-subcode-02 mentions optionally 7 bytes
1902              * for the maxprefix subtype, which may contain AFI, SAFI and MAXPREFIXES
1903              */
1904             if(bgpn.bgpn_minor == BGP_NOTIFY_MINOR_CEASE_MAXPRFX && length >= BGP_NOTIFICATION_SIZE + 7) {
1905                 tptr = dat + BGP_NOTIFICATION_SIZE;
1906                 TCHECK2(*tptr, 7);
1907                 printf(", AFI %s (%u), SAFI %s (%u), Max Prefixes: %u",
1908                        tok2strbuf(bgp_afi_values, "Unknown",
1909                                   EXTRACT_16BITS(tptr), tokbuf, sizeof(tokbuf)),
1910                        EXTRACT_16BITS(tptr),
1911                        tok2strbuf(bgp_safi_values, "Unknown", *(tptr+2),
1912                                   tokbuf2, sizeof(tokbuf)),
1913                        *(tptr+2),
1914                        EXTRACT_32BITS(tptr+3));
1915             }
1916             break;
1917         default:
1918             break;
1919         }
1920
1921         return;
1922 trunc:
1923         printf("[|BGP]");
1924 }
1925
1926 static void
1927 bgp_route_refresh_print(const u_char *pptr, int len) {
1928
1929         const struct bgp_route_refresh *bgp_route_refresh_header;
1930         char tokbuf[TOKBUFSIZE];
1931         char tokbuf2[TOKBUFSIZE];
1932
1933         TCHECK2(pptr[0], BGP_ROUTE_REFRESH_SIZE);
1934
1935         /* some little sanity checking */
1936         if (len<BGP_ROUTE_REFRESH_SIZE)
1937             return;
1938
1939         bgp_route_refresh_header = (const struct bgp_route_refresh *)pptr;
1940
1941         printf("\n\t  AFI %s (%u), SAFI %s (%u)",
1942                tok2strbuf(bgp_afi_values,"Unknown",
1943                           /* this stinks but the compiler pads the structure
1944                            * weird */
1945                           EXTRACT_16BITS(&bgp_route_refresh_header->afi),
1946                           tokbuf, sizeof(tokbuf)),
1947                EXTRACT_16BITS(&bgp_route_refresh_header->afi),
1948                tok2strbuf(bgp_safi_values,"Unknown",
1949                           bgp_route_refresh_header->safi,
1950                           tokbuf2, sizeof(tokbuf2)),
1951                bgp_route_refresh_header->safi);
1952
1953         if (vflag > 1) {
1954             TCHECK2(*pptr, len);
1955             print_unknown_data(pptr,"\n\t  ", len);
1956         }
1957
1958         return;
1959 trunc:
1960         printf("[|BGP]");
1961 }
1962
1963 static int
1964 bgp_header_print(const u_char *dat, int length)
1965 {
1966         struct bgp bgp;
1967         char tokbuf[TOKBUFSIZE];
1968
1969         TCHECK2(dat[0], BGP_SIZE);
1970         memcpy(&bgp, dat, BGP_SIZE);
1971         printf("\n\t%s Message (%u), length: %u",
1972                tok2strbuf(bgp_msg_values, "Unknown", bgp.bgp_type,
1973                           tokbuf, sizeof(tokbuf)),
1974                bgp.bgp_type,
1975                length);
1976
1977         switch (bgp.bgp_type) {
1978         case BGP_OPEN:
1979                 bgp_open_print(dat, length);
1980                 break;
1981         case BGP_UPDATE:
1982                 bgp_update_print(dat, length);
1983                 break;
1984         case BGP_NOTIFICATION:
1985                 bgp_notification_print(dat, length);
1986                 break;
1987         case BGP_KEEPALIVE:
1988                 break;
1989         case BGP_ROUTE_REFRESH:
1990                 bgp_route_refresh_print(dat, length);
1991                 break;
1992         default:
1993                 /* we have no decoder for the BGP message */
1994                 TCHECK2(*dat, length);
1995                 printf("\n\t  no Message %u decoder",bgp.bgp_type);
1996                 print_unknown_data(dat,"\n\t  ",length);
1997                 break;
1998         }
1999         return 1;
2000 trunc:
2001         printf("[|BGP]");
2002         return 0;
2003 }
2004
2005 void
2006 bgp_print(const u_char *dat, int length)
2007 {
2008         const u_char *p;
2009         const u_char *ep;
2010         const u_char *start;
2011         const u_char marker[] = {
2012                 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
2013                 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
2014         };
2015         struct bgp bgp;
2016         u_int16_t hlen;
2017         char tokbuf[TOKBUFSIZE];
2018
2019         ep = dat + length;
2020         if (snapend < dat + length)
2021                 ep = snapend;
2022
2023         printf(": BGP, length: %u",length);
2024
2025         if (vflag < 1) /* lets be less chatty */
2026                 return;
2027
2028         p = dat;
2029         start = p;
2030         while (p < ep) {
2031                 if (!TTEST2(p[0], 1))
2032                         break;
2033                 if (p[0] != 0xff) {
2034                         p++;
2035                         continue;
2036                 }
2037
2038                 if (!TTEST2(p[0], sizeof(marker)))
2039                         break;
2040                 if (memcmp(p, marker, sizeof(marker)) != 0) {
2041                         p++;
2042                         continue;
2043                 }
2044
2045                 /* found BGP header */
2046                 TCHECK2(p[0], BGP_SIZE);        /*XXX*/
2047                 memcpy(&bgp, p, BGP_SIZE);
2048
2049                 if (start != p)
2050                         printf(" [|BGP]");
2051
2052                 hlen = ntohs(bgp.bgp_len);
2053                 if (hlen < BGP_SIZE) {
2054                         printf("\n[|BGP Bogus header length %u < %u]", hlen,
2055                             BGP_SIZE);
2056                         break;
2057                 }
2058
2059                 if (TTEST2(p[0], hlen)) {
2060                         if (!bgp_header_print(p, hlen))
2061                                 return;
2062                         p += hlen;
2063                         start = p;
2064                 } else {
2065                         printf("\n[|BGP %s]",
2066                                tok2strbuf(bgp_msg_values,
2067                                           "Unknown Message Type",
2068                                           bgp.bgp_type,
2069                                           tokbuf, sizeof(tokbuf)));
2070                         break;
2071                 }
2072         }
2073
2074         return;
2075
2076 trunc:
2077         printf(" [|BGP]");
2078 }