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 38static const char rcsid[] _U_ =
|
39 "@(#) $Header: /tcpdump/master/tcpdump/print-bgp.c,v 1.72.2.4 2004/03/24 00:04:04 guy Exp $";
|
39 "@(#) $Header: /tcpdump/master/tcpdump/print-bgp.c,v 1.91 2005/03/27 01:31:25 guy 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 54struct 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 67static 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 76struct 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 89struct 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 |
98struct 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 107struct 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 117struct 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 |
151static 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 178static 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 186static 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 198static 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 212static 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 231static 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 244static 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 255static 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 262static 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 272static 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 287static 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 295static 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 321static 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"},
|
312 { SAFNUM_RT_ROUTING_INFO, "Route Target Routing Information"},
|
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 361static 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 406static struct tok bgp_extd_comm_flag_values[] = { 407 { 0x8000, "vendor-specific"}, 408 { 0x4000, "non-transitive"}, 409 { 0, NULL}, 410}; 411 412static 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 442static 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
|
429static struct tok bgp_l2vpn_encaps_values[] = {
430 { 0, "Reserved"},
431 { 1, "Frame Relay"},
432 { 2, "ATM AAL5 VCC transport"},
433 { 3, "ATM transparent cell transport"},
434 { 4, "Ethernet VLAN"},
435 { 5, "Ethernet"},
436 { 6, "Cisco-HDLC"},
437 { 7, "PPP"},
438 { 8, "CEM"},
439 { 9, "ATM VCC cell transport"},
440 { 10, "ATM VPC cell transport"},
441 { 11, "MPLS"},
442 { 12, "VPLS"},
443 { 64, "IP-interworking"},
444 { 0, NULL},
445};
446
447static int
|
452int |
453decode_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 473trunc: 474 return -2; 475} 476 477static int 478decode_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 515trunc: 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 */
|
517static char *
|
522char * |
523bgp_vpn_rd_print (const u_char *pptr) { 524
|
520 /* allocate space for the following string
521 * xxx.xxx.xxx.xxx:xxxxx
522 * 21 bytes plus one termination byte */
523 static char rd[22];
|
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:
|
543 snprintf(pos, sizeof(rd) - (pos - rd), "%u:%u",
544 EXTRACT_32BITS(pptr+2), EXTRACT_16BITS(pptr+6));
|
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 559static int 560decode_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 586trunc: 587 return -2; 588} 589 590static int 591decode_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 621trunc: 622 return -2; 623} 624 625static int 626decode_labeled_vpn_l2(const u_char *pptr, char *buf, u_int buflen) 627{ 628 int plen,tlen,strlen,tlv_type,tlv_len,ttlv_len; 629 630 TCHECK2(pptr[0], 2); 631 plen=EXTRACT_16BITS(pptr); 632 tlen=plen; 633 pptr+=2; 634 TCHECK2(pptr[0],15); 635 strlen=snprintf(buf, buflen, "RD: %s, CE-ID: %u, Label-Block Offset: %u, Label Base %u", 636 bgp_vpn_rd_print(pptr), 637 EXTRACT_16BITS(pptr+8), 638 EXTRACT_16BITS(pptr+10), 639 EXTRACT_24BITS(pptr+12)>>4); /* the label is offsetted by 4 bits so lets shift it right */ 640 pptr+=15; 641 tlen-=15; 642 643 /* ok now the variable part - lets read out TLVs*/ 644 while (tlen>0) { 645 if (tlen < 3) 646 return -1; 647 TCHECK2(pptr[0], 3); 648 tlv_type=*pptr++; 649 tlv_len=EXTRACT_16BITS(pptr); 650 ttlv_len=tlv_len; 651 pptr+=2; 652 653 switch(tlv_type) { 654 case 1: 655 strlen+=snprintf(buf+strlen,buflen-strlen, "\n\t\tcircuit status vector (%u) length: %u: 0x", 656 tlv_type, 657 tlv_len); 658 ttlv_len=ttlv_len/8+1; /* how many bytes do we need to read ? */ 659 while (ttlv_len>0) { 660 TCHECK(pptr[0]); 661 strlen+=snprintf(buf+strlen,buflen-strlen, "%02x",*pptr++); 662 ttlv_len--; 663 } 664 break; 665 default: 666 snprintf(buf+strlen,buflen-strlen, "\n\t\tunknown TLV #%u, length: %u", 667 tlv_type, 668 tlv_len); 669 break; 670 } 671 tlen-=(tlv_len<<3); /* the tlv-length is expressed in bits so lets shift it tright */ 672 } 673 return plen+2; 674 675trunc: 676 return -2; 677} 678 679#ifdef INET6
|
676static int
|
680int |
681decode_prefix6(const u_char *pd, char *buf, u_int buflen) 682{ 683 struct in6_addr addr; 684 u_int plen; 685 686 TCHECK(pd[0]); 687 plen = pd[0]; 688 if (128 < plen) 689 return -1; 690 691 memset(&addr, 0, sizeof(addr)); 692 TCHECK2(pd[1], (plen + 7) / 8); 693 memcpy(&addr, &pd[1], (plen + 7) / 8); 694 if (plen % 8) { 695 addr.s6_addr[(plen + 7) / 8 - 1] &= 696 ((0xff00 >> (plen % 8)) & 0xff); 697 } 698 snprintf(buf, buflen, "%s/%d", getname6((u_char *)&addr), plen); 699 return 1 + (plen + 7) / 8; 700 701trunc: 702 return -2; 703} 704 705static int 706decode_labeled_prefix6(const u_char *pptr, char *buf, u_int buflen) 707{ 708 struct in6_addr addr; 709 u_int plen; 710 711 TCHECK(pptr[0]); 712 plen = pptr[0]; /* get prefix length */ 713 plen-=24; /* adjust prefixlen - labellength */ 714 715 if (128 < plen) 716 return -1; 717 718 memset(&addr, 0, sizeof(addr)); 719 TCHECK2(pptr[4], (plen + 7) / 8); 720 memcpy(&addr, &pptr[4], (plen + 7) / 8); 721 if (plen % 8) { 722 addr.s6_addr[(plen + 7) / 8 - 1] &= 723 ((0xff00 >> (plen % 8)) & 0xff); 724 } 725 /* the label may get offsetted by 4 bits so lets shift it right */ 726 snprintf(buf, buflen, "%s/%d, label:%u %s", 727 getname6((u_char *)&addr), 728 plen, 729 EXTRACT_24BITS(pptr+1)>>4, 730 ((pptr[3]&1)==0) ? "(BOGUS: Bottom of Stack NOT set!)" : "(bottom)" ); 731 732 return 4 + (plen + 7) / 8; 733 734trunc: 735 return -2; 736} 737 738static int 739decode_labeled_vpn_prefix6(const u_char *pptr, char *buf, u_int buflen) 740{ 741 struct in6_addr addr; 742 u_int plen; 743 744 TCHECK(pptr[0]); 745 plen = pptr[0]; /* get prefix length */ 746 747 plen-=(24+64); /* adjust prefixlen - labellength - RD len*/ 748 749 if (128 < plen) 750 return -1; 751 752 memset(&addr, 0, sizeof(addr)); 753 TCHECK2(pptr[12], (plen + 7) / 8); 754 memcpy(&addr, &pptr[12], (plen + 7) / 8); 755 if (plen % 8) { 756 addr.s6_addr[(plen + 7) / 8 - 1] &= 757 ((0xff00 >> (plen % 8)) & 0xff); 758 } 759 /* the label may get offsetted by 4 bits so lets shift it right */ 760 snprintf(buf, buflen, "RD: %s, %s/%d, label:%u %s", 761 bgp_vpn_rd_print(pptr+4), 762 getname6((u_char *)&addr), 763 plen, 764 EXTRACT_24BITS(pptr+1)>>4, 765 ((pptr[3]&1)==0) ? "(BOGUS: Bottom of Stack NOT set!)" : "(bottom)" ); 766 767 return 12 + (plen + 7) / 8; 768 769trunc: 770 return -2; 771} 772#endif 773 774static int
|
775decode_labeled_clnp_prefix(const u_char *pptr, char *buf, u_int buflen) 776{ 777 u_int8_t addr[19]; 778 u_int plen; 779 780 TCHECK(pptr[0]); 781 plen = pptr[0]; /* get prefix length */ 782 plen-=24; /* adjust prefixlen - labellength */ 783 784 if (152 < plen) 785 return -1; 786 787 memset(&addr, 0, sizeof(addr)); 788 TCHECK2(pptr[4], (plen + 7) / 8); 789 memcpy(&addr, &pptr[4], (plen + 7) / 8); 790 if (plen % 8) { 791 addr[(plen + 7) / 8 - 1] &= 792 ((0xff00 >> (plen % 8)) & 0xff); 793 } 794 /* the label may get offsetted by 4 bits so lets shift it right */ 795 snprintf(buf, buflen, "%s/%d, label:%u %s", 796 isonsap_string(addr,(plen + 7) / 8 - 1), 797 plen, 798 EXTRACT_24BITS(pptr+1)>>4, 799 ((pptr[3]&1)==0) ? "(BOGUS: Bottom of Stack NOT set!)" : "(bottom)" ); 800 801 return 4 + (plen + 7) / 8; 802 803trunc: 804 return -2; 805} 806 807static int 808decode_labeled_vpn_clnp_prefix(const u_char *pptr, char *buf, u_int buflen) 809{ 810 u_int8_t addr[19]; 811 u_int plen; 812 813 TCHECK(pptr[0]); 814 plen = pptr[0]; /* get prefix length */ 815 816 plen-=(24+64); /* adjust prefixlen - labellength - RD len*/ 817 818 if (152 < plen) 819 return -1; 820 821 memset(&addr, 0, sizeof(addr)); 822 TCHECK2(pptr[12], (plen + 7) / 8); 823 memcpy(&addr, &pptr[12], (plen + 7) / 8); 824 if (plen % 8) { 825 addr[(plen + 7) / 8 - 1] &= 826 ((0xff00 >> (plen % 8)) & 0xff); 827 } 828 /* the label may get offsetted by 4 bits so lets shift it right */ 829 snprintf(buf, buflen, "RD: %s, %s/%d, label:%u %s", 830 bgp_vpn_rd_print(pptr+4), 831 isonsap_string(addr,(plen + 7) / 8 - 1), 832 plen, 833 EXTRACT_24BITS(pptr+1)>>4, 834 ((pptr[3]&1)==0) ? "(BOGUS: Bottom of Stack NOT set!)" : "(bottom)" ); 835 836 return 12 + (plen + 7) / 8; 837 838trunc: 839 return -2; 840} 841 842static int |
843bgp_attr_print(const struct bgp_attr *attr, const u_char *pptr, int len) 844{ 845 int i; 846 u_int16_t af; 847 u_int8_t safi, snpa; 848 union { /* copy buffer for bandwidth values */ 849 float f; 850 u_int32_t i; 851 } bw; 852 int advance; 853 int tlen; 854 const u_char *tptr; 855 char buf[MAXHOSTNAMELEN + 100];
|
856 char tokbuf[TOKBUFSIZE]; |
857 858 tptr = pptr; 859 tlen=len; 860 861 switch (attr->bgpa_type) { 862 case BGPTYPE_ORIGIN: 863 if (len != 1) 864 printf("invalid len"); 865 else { 866 TCHECK(*tptr);
|
794 printf("%s", tok2str(bgp_origin_values, "Unknown Origin Typecode", tptr[0]));
|
867 printf("%s", tok2strbuf(bgp_origin_values, 868 "Unknown Origin Typecode", 869 tptr[0], 870 tokbuf, sizeof(tokbuf))); |
871 } 872 break;
|
873 |
874 case BGPTYPE_AS_PATH: 875 if (len % 2) { 876 printf("invalid len"); 877 break; 878 } 879 if (!len) { 880 printf("empty"); 881 break; 882 } 883 884 while (tptr < pptr + len) { 885 TCHECK(tptr[0]);
|
809 printf("%s", tok2str(bgp_as_path_segment_open_values, "?", tptr[0]));
|
886 printf("%s", tok2strbuf(bgp_as_path_segment_open_values, 887 "?", tptr[0], 888 tokbuf, sizeof(tokbuf))); |
889 for (i = 0; i < tptr[1] * 2; i += 2) { 890 TCHECK2(tptr[2 + i], 2); 891 printf("%u ", EXTRACT_16BITS(&tptr[2 + i])); 892 } 893 TCHECK(tptr[0]);
|
815 printf("%s", tok2str(bgp_as_path_segment_close_values, "?", tptr[0]));
|
894 printf("%s", tok2strbuf(bgp_as_path_segment_close_values, 895 "?", tptr[0], 896 tokbuf, sizeof(tokbuf))); |
897 TCHECK(tptr[1]); 898 tptr += 2 + tptr[1] * 2; 899 } 900 break; 901 case BGPTYPE_NEXT_HOP: 902 if (len != 4) 903 printf("invalid len"); 904 else { 905 TCHECK2(tptr[0], 4); 906 printf("%s", getname(tptr)); 907 } 908 break; 909 case BGPTYPE_MULTI_EXIT_DISC: 910 case BGPTYPE_LOCAL_PREF: 911 if (len != 4) 912 printf("invalid len"); 913 else { 914 TCHECK2(tptr[0], 4); 915 printf("%u", EXTRACT_32BITS(tptr)); 916 } 917 break; 918 case BGPTYPE_ATOMIC_AGGREGATE: 919 if (len != 0) 920 printf("invalid len"); 921 break; 922 case BGPTYPE_AGGREGATOR: 923 if (len != 6) { 924 printf("invalid len"); 925 break; 926 } 927 TCHECK2(tptr[0], 6); 928 printf(" AS #%u, origin %s", EXTRACT_16BITS(tptr), 929 getname(tptr + 2)); 930 break; 931 case BGPTYPE_COMMUNITIES: 932 if (len % 4) { 933 printf("invalid len"); 934 break; 935 } 936 while (tlen>0) { 937 u_int32_t comm; 938 TCHECK2(tptr[0], 4); 939 comm = EXTRACT_32BITS(tptr); 940 switch (comm) { 941 case BGP_COMMUNITY_NO_EXPORT: 942 printf(" NO_EXPORT"); 943 break; 944 case BGP_COMMUNITY_NO_ADVERT: 945 printf(" NO_ADVERTISE"); 946 break; 947 case BGP_COMMUNITY_NO_EXPORT_SUBCONFED: 948 printf(" NO_EXPORT_SUBCONFED"); 949 break; 950 default: 951 printf("%u:%u%s", 952 (comm >> 16) & 0xffff, 953 comm & 0xffff, 954 (tlen>4) ? ", " : ""); 955 break; 956 } 957 tlen -=4; 958 tptr +=4; 959 } 960 break; 961 case BGPTYPE_ORIGINATOR_ID: 962 if (len != 4) { 963 printf("invalid len"); 964 break; 965 } 966 TCHECK2(tptr[0], 4); 967 printf("%s",getname(tptr)); 968 break; 969 case BGPTYPE_CLUSTER_LIST: 970 if (len % 4) { 971 printf("invalid len"); 972 break; 973 } 974 while (tlen>0) { 975 TCHECK2(tptr[0], 4); 976 printf("%s%s", 977 getname(tptr), 978 (tlen>4) ? ", " : ""); 979 tlen -=4; 980 tptr +=4; 981 } 982 break; 983 case BGPTYPE_MP_REACH_NLRI: 984 TCHECK2(tptr[0], 3); 985 af = EXTRACT_16BITS(tptr); 986 safi = tptr[2]; 987 988 printf("\n\t AFI: %s (%u), %sSAFI: %s (%u)",
|
908 tok2str(bgp_afi_values, "Unknown AFI", af),
|
989 tok2strbuf(bgp_afi_values, "Unknown AFI", af, 990 tokbuf, sizeof(tokbuf)), |
991 af, 992 (safi>128) ? "vendor specific " : "", /* 128 is meanwhile wellknown */
|
911 tok2str(bgp_safi_values, "Unknown SAFI", safi),
|
993 tok2strbuf(bgp_safi_values, "Unknown SAFI", safi, 994 tokbuf, sizeof(tokbuf)), |
995 safi); 996
|
914 if (af == AFNUM_INET || af==AFNUM_L2VPN)
915 ;
|
997 switch(af<<8 | safi) { 998 case (AFNUM_INET<<8 | SAFNUM_UNICAST): 999 case (AFNUM_INET<<8 | SAFNUM_MULTICAST): 1000 case (AFNUM_INET<<8 | SAFNUM_UNIMULTICAST): 1001 case (AFNUM_INET<<8 | SAFNUM_LABUNICAST): 1002 case (AFNUM_INET<<8 | SAFNUM_RT_ROUTING_INFO): 1003 case (AFNUM_INET<<8 | SAFNUM_VPNUNICAST): 1004 case (AFNUM_INET<<8 | SAFNUM_VPNMULTICAST): 1005 case (AFNUM_INET<<8 | SAFNUM_VPNUNIMULTICAST): |
1006#ifdef INET6
|
917 else if (af == AFNUM_INET6)
918 ;
|
1007 case (AFNUM_INET6<<8 | SAFNUM_UNICAST): 1008 case (AFNUM_INET6<<8 | SAFNUM_MULTICAST): 1009 case (AFNUM_INET6<<8 | SAFNUM_UNIMULTICAST): 1010 case (AFNUM_INET6<<8 | SAFNUM_LABUNICAST): 1011 case (AFNUM_INET6<<8 | SAFNUM_RT_ROUTING_INFO): 1012 case (AFNUM_INET6<<8 | SAFNUM_VPNUNICAST): 1013 case (AFNUM_INET6<<8 | SAFNUM_VPNMULTICAST): 1014 case (AFNUM_INET6<<8 | SAFNUM_VPNUNIMULTICAST): |
1015#endif
|
920 else {
921 printf("\n\t no AFI %u decoder",af);
|
1016 case (AFNUM_NSAP<<8 | SAFNUM_UNICAST): 1017 case (AFNUM_NSAP<<8 | SAFNUM_MULTICAST): 1018 case (AFNUM_NSAP<<8 | SAFNUM_UNIMULTICAST): 1019 case (AFNUM_NSAP<<8 | SAFNUM_VPNUNICAST): 1020 case (AFNUM_NSAP<<8 | SAFNUM_VPNMULTICAST): 1021 case (AFNUM_NSAP<<8 | SAFNUM_VPNUNIMULTICAST): 1022 case (AFNUM_L2VPN<<8 | SAFNUM_VPNUNICAST): 1023 case (AFNUM_L2VPN<<8 | SAFNUM_VPNMULTICAST): 1024 case (AFNUM_L2VPN<<8 | SAFNUM_VPNUNIMULTICAST): 1025 break; 1026 default: 1027 printf("\n\t no AFI %u / SAFI %u decoder",af,safi); |
1028 if (vflag <= 1) 1029 print_unknown_data(tptr,"\n\t ",tlen);
|
1030 goto done; |
1031 break; 1032 } 1033 1034 tptr +=3; 1035 1036 TCHECK(tptr[0]); 1037 tlen = tptr[0]; 1038 tptr++; 1039 1040 if (tlen) {
|
934 printf("\n\t nexthop: ");
935 while (tlen > 0) {
936 switch (af) {
937 case AFNUM_INET:
938 switch(safi) {
939 case SAFNUM_UNICAST:
940 case SAFNUM_MULTICAST:
941 case SAFNUM_UNIMULTICAST:
942 case SAFNUM_LABUNICAST:
943 case SAFNUM_RT_ROUTING_INFO:
944 if (tlen < (int)sizeof(struct in_addr)) {
945 printf("invalid len");
946 tlen = 0;
947 } else {
948 TCHECK2(tptr[0], sizeof(struct in_addr));
949 printf("%s",getname(tptr));
950 tlen -= sizeof(struct in_addr);
951 tptr += sizeof(struct in_addr);
952 }
953 break;
954 case SAFNUM_VPNUNICAST:
955 case SAFNUM_VPNMULTICAST:
956 case SAFNUM_VPNUNIMULTICAST:
957 if (tlen < (int)(sizeof(struct in_addr)+BGP_VPN_RD_LEN)) {
958 printf("invalid len");
959 tlen = 0;
960 } else {
961 TCHECK2(tptr[0], sizeof(struct in_addr)+BGP_VPN_RD_LEN);
962 printf("RD: %s, %s",
963 bgp_vpn_rd_print(tptr),
964 getname(tptr+BGP_VPN_RD_LEN));
965 tlen -= (sizeof(struct in_addr)+BGP_VPN_RD_LEN);
966 tptr += (sizeof(struct in_addr)+BGP_VPN_RD_LEN);
967 }
968 break;
969 default:
970 TCHECK2(tptr[0], tlen);
971 printf("no SAFI %u decoder",safi);
972 if (vflag <= 1)
973 print_unknown_data(tptr,"\n\t ",tlen);
974 tptr += tlen;
975 tlen = 0;
976 break;
977 }
978 break;
|
1041 printf("\n\t nexthop: "); 1042 while (tlen > 0) { 1043 switch(af<<8 | safi) { 1044 case (AFNUM_INET<<8 | SAFNUM_UNICAST): 1045 case (AFNUM_INET<<8 | SAFNUM_MULTICAST): 1046 case (AFNUM_INET<<8 | SAFNUM_UNIMULTICAST): 1047 case (AFNUM_INET<<8 | SAFNUM_LABUNICAST): 1048 case (AFNUM_INET<<8 | SAFNUM_RT_ROUTING_INFO): 1049 if (tlen < (int)sizeof(struct in_addr)) { 1050 printf("invalid len"); 1051 tlen = 0; 1052 } else { 1053 TCHECK2(tptr[0], sizeof(struct in_addr)); 1054 printf("%s",getname(tptr)); 1055 tlen -= sizeof(struct in_addr); 1056 tptr += sizeof(struct in_addr); 1057 } 1058 break; 1059 case (AFNUM_INET<<8 | SAFNUM_VPNUNICAST): 1060 case (AFNUM_INET<<8 | SAFNUM_VPNMULTICAST): 1061 case (AFNUM_INET<<8 | SAFNUM_VPNUNIMULTICAST): 1062 if (tlen < (int)(sizeof(struct in_addr)+BGP_VPN_RD_LEN)) { 1063 printf("invalid len"); 1064 tlen = 0; 1065 } else { 1066 TCHECK2(tptr[0], sizeof(struct in_addr)+BGP_VPN_RD_LEN); 1067 printf("RD: %s, %s", 1068 bgp_vpn_rd_print(tptr), 1069 getname(tptr+BGP_VPN_RD_LEN)); 1070 tlen -= (sizeof(struct in_addr)+BGP_VPN_RD_LEN); 1071 tptr += (sizeof(struct in_addr)+BGP_VPN_RD_LEN); 1072 } 1073 break; |
1074#ifdef INET6
|
980 case AFNUM_INET6:
981 switch(safi) {
982 case SAFNUM_UNICAST:
983 case SAFNUM_MULTICAST:
984 case SAFNUM_UNIMULTICAST:
985 case SAFNUM_LABUNICAST:
986 case SAFNUM_RT_ROUTING_INFO:
987 if (tlen < (int)sizeof(struct in6_addr)) {
988 printf("invalid len");
989 tlen = 0;
990 } else {
991 TCHECK2(tptr[0], sizeof(struct in6_addr));
992 printf("%s", getname6(tptr));
993 tlen -= sizeof(struct in6_addr);
994 tptr += sizeof(struct in6_addr);
995 }
996 break;
997 case SAFNUM_VPNUNICAST:
998 case SAFNUM_VPNMULTICAST:
999 case SAFNUM_VPNUNIMULTICAST:
1000 if (tlen < (int)(sizeof(struct in6_addr)+BGP_VPN_RD_LEN)) {
1001 printf("invalid len");
1002 tlen = 0;
1003 } else {
1004 TCHECK2(tptr[0], sizeof(struct in6_addr)+BGP_VPN_RD_LEN);
1005 printf("RD: %s, %s",
1006 bgp_vpn_rd_print(tptr),
1007 getname6(tptr+BGP_VPN_RD_LEN));
1008 tlen -= (sizeof(struct in6_addr)+BGP_VPN_RD_LEN);
1009 tptr += (sizeof(struct in6_addr)+BGP_VPN_RD_LEN);
1010 }
1011 break;
1012 default:
1013 TCHECK2(tptr[0], tlen);
1014 printf("no SAFI %u decoder",safi);
1015 if (vflag <= 1)
1016 print_unknown_data(tptr,"\n\t ",tlen);
1017 tptr += tlen;
1018 tlen = 0;
1019 break;
1020 }
1021 break;
|
1075 case (AFNUM_INET6<<8 | SAFNUM_UNICAST): 1076 case (AFNUM_INET6<<8 | SAFNUM_MULTICAST): 1077 case (AFNUM_INET6<<8 | SAFNUM_UNIMULTICAST): 1078 case (AFNUM_INET6<<8 | SAFNUM_LABUNICAST): 1079 case (AFNUM_INET6<<8 | SAFNUM_RT_ROUTING_INFO): 1080 if (tlen < (int)sizeof(struct in6_addr)) { 1081 printf("invalid len"); 1082 tlen = 0; 1083 } else { 1084 TCHECK2(tptr[0], sizeof(struct in6_addr)); 1085 printf("%s", getname6(tptr)); 1086 tlen -= sizeof(struct in6_addr); 1087 tptr += sizeof(struct in6_addr); 1088 } 1089 break; 1090 case (AFNUM_INET6<<8 | SAFNUM_VPNUNICAST): 1091 case (AFNUM_INET6<<8 | SAFNUM_VPNMULTICAST): 1092 case (AFNUM_INET6<<8 | SAFNUM_VPNUNIMULTICAST): 1093 if (tlen < (int)(sizeof(struct in6_addr)+BGP_VPN_RD_LEN)) { 1094 printf("invalid len"); 1095 tlen = 0; 1096 } else { 1097 TCHECK2(tptr[0], sizeof(struct in6_addr)+BGP_VPN_RD_LEN); 1098 printf("RD: %s, %s", 1099 bgp_vpn_rd_print(tptr), 1100 getname6(tptr+BGP_VPN_RD_LEN)); 1101 tlen -= (sizeof(struct in6_addr)+BGP_VPN_RD_LEN); 1102 tptr += (sizeof(struct in6_addr)+BGP_VPN_RD_LEN); 1103 } 1104 break; |
1105#endif
|
1023 case AFNUM_L2VPN:
1024 switch(safi) {
1025 case SAFNUM_VPNUNICAST:
1026 case SAFNUM_VPNMULTICAST:
1027 case SAFNUM_VPNUNIMULTICAST:
1028 if (tlen < (int)sizeof(struct in_addr)) {
1029 printf("invalid len");
1030 tlen = 0;
1031 } else {
1032 TCHECK2(tptr[0], sizeof(struct in_addr));
1033 printf("%s", getname(tptr));
1034 tlen -= (sizeof(struct in_addr));
1035 tptr += (sizeof(struct in_addr));
1036 }
1037 break;
1038 default:
1039 TCHECK2(tptr[0], tlen);
1040 printf("no SAFI %u decoder",safi);
1041 if (vflag <= 1)
1042 print_unknown_data(tptr,"\n\t ",tlen);
1043 tptr += tlen;
1044 tlen = 0;
1045 break;
1046 }
1047 break;
|
1106 case (AFNUM_L2VPN<<8 | SAFNUM_VPNUNICAST): 1107 case (AFNUM_L2VPN<<8 | SAFNUM_VPNMULTICAST): 1108 case (AFNUM_L2VPN<<8 | SAFNUM_VPNUNIMULTICAST): 1109 if (tlen < (int)sizeof(struct in_addr)) { 1110 printf("invalid len"); 1111 tlen = 0; 1112 } else { 1113 TCHECK2(tptr[0], sizeof(struct in_addr)); 1114 printf("%s", getname(tptr)); 1115 tlen -= (sizeof(struct in_addr)); 1116 tptr += (sizeof(struct in_addr)); 1117 } 1118 break; 1119 case (AFNUM_NSAP<<8 | SAFNUM_UNICAST): 1120 case (AFNUM_NSAP<<8 | SAFNUM_MULTICAST): 1121 case (AFNUM_NSAP<<8 | SAFNUM_UNIMULTICAST): 1122 TCHECK2(tptr[0], tlen); 1123 printf("%s",isonsap_string(tptr,tlen)); 1124 tptr += tlen; 1125 tlen = 0; 1126 break; |
1127
|
1049 default:
1050 TCHECK2(tptr[0], tlen);
1051 printf("no AFI %u decoder",af);
1052 if (vflag <= 1)
1053 print_unknown_data(tptr,"\n\t ",tlen);
1054 tptr += tlen;
1055 tlen = 0;
1056 break;
1057 }
1058 }
|
1128 case (AFNUM_NSAP<<8 | SAFNUM_VPNUNICAST): 1129 case (AFNUM_NSAP<<8 | SAFNUM_VPNMULTICAST): 1130 case (AFNUM_NSAP<<8 | SAFNUM_VPNUNIMULTICAST): 1131 if (tlen < BGP_VPN_RD_LEN+1) { 1132 printf("invalid len"); 1133 tlen = 0; 1134 } else { 1135 TCHECK2(tptr[0], tlen); 1136 printf("RD: %s, %s", 1137 bgp_vpn_rd_print(tptr), 1138 isonsap_string(tptr+BGP_VPN_RD_LEN,tlen-BGP_VPN_RD_LEN)); 1139 /* rfc986 mapped IPv4 address ? */ 1140 if (EXTRACT_32BITS(tptr+BGP_VPN_RD_LEN) == 0x47000601) 1141 printf(" = %s", getname(tptr+BGP_VPN_RD_LEN+4)); 1142#ifdef INET6 1143 /* rfc1888 mapped IPv6 address ? */ 1144 else if (EXTRACT_24BITS(tptr+BGP_VPN_RD_LEN) == 0x350000) 1145 printf(" = %s", getname6(tptr+BGP_VPN_RD_LEN+3)); 1146#endif 1147 tptr += tlen; 1148 tlen = 0; 1149 } 1150 break; 1151 default: 1152 TCHECK2(tptr[0], tlen); 1153 printf("no AFI %u/SAFI %u decoder",af,safi); 1154 if (vflag <= 1) 1155 print_unknown_data(tptr,"\n\t ",tlen); 1156 tptr += tlen; 1157 tlen = 0; 1158 goto done; 1159 break; 1160 } 1161 } |
1162 } 1163 tptr += tlen; 1164 1165 TCHECK(tptr[0]); 1166 snpa = tptr[0]; 1167 tptr++; 1168 1169 if (snpa) { 1170 printf("\n\t %u SNPA", snpa); 1171 for (/*nothing*/; snpa > 0; snpa--) { 1172 TCHECK(tptr[0]); 1173 printf("\n\t %d bytes", tptr[0]); 1174 tptr += tptr[0] + 1; 1175 } 1176 } else { 1177 printf(", no SNPA"); 1178 } 1179 1180 while (len - (tptr - pptr) > 0) {
|
1078 switch (af) {
1079 case AFNUM_INET:
1080 switch (safi) {
1081 case SAFNUM_UNICAST:
1082 case SAFNUM_MULTICAST:
1083 case SAFNUM_UNIMULTICAST:
1084 advance = decode_prefix4(tptr, buf, sizeof(buf));
1085 if (advance == -1)
1086 printf("\n\t (illegal prefix length)");
1087 else if (advance == -2)
1088 goto trunc;
1089 else
1090 printf("\n\t %s", buf);
1091 break;
1092 case SAFNUM_LABUNICAST:
1093 advance = decode_labeled_prefix4(tptr, buf, sizeof(buf));
1094 if (advance == -1)
1095 printf("\n\t (illegal prefix length)");
1096 else if (advance == -2)
1097 goto trunc;
1098 else
1099 printf("\n\t %s", buf);
1100 break;
1101 case SAFNUM_VPNUNICAST:
1102 case SAFNUM_VPNMULTICAST:
1103 case SAFNUM_VPNUNIMULTICAST:
1104 advance = decode_labeled_vpn_prefix4(tptr, buf, sizeof(buf));
1105 if (advance == -1)
1106 printf("\n\t (illegal prefix length)");
1107 else if (advance == -2)
1108 goto trunc;
1109 else
1110 printf("\n\t %s", buf);
1111 break;
1112 case SAFNUM_RT_ROUTING_INFO:
1113 advance = decode_rt_routing_info(tptr, buf, sizeof(buf));
1114 if (advance == -1)
1115 printf("\n\t (illegal prefix length)");
1116 else if (advance == -2)
1117 goto trunc;
1118 else
1119 printf("\n\t %s", buf);
1120 break;
1121 default:
1122 TCHECK2(*(tptr-3),tlen);
1123 printf("\n\t no SAFI %u decoder",safi);
1124 if (vflag <= 1)
1125 print_unknown_data(tptr-3,"\n\t ",tlen);
1126 advance = 0;
1127 tptr = pptr + len;
1128 break;
1129 }
1130 break;
|
1181 switch (af<<8 | safi) { 1182 case (AFNUM_INET<<8 | SAFNUM_UNICAST): 1183 case (AFNUM_INET<<8 | SAFNUM_MULTICAST): 1184 case (AFNUM_INET<<8 | SAFNUM_UNIMULTICAST): 1185 advance = decode_prefix4(tptr, buf, sizeof(buf)); 1186 if (advance == -1) 1187 printf("\n\t (illegal prefix length)"); 1188 else if (advance == -2) 1189 goto trunc; 1190 else 1191 printf("\n\t %s", buf); 1192 break; 1193 case (AFNUM_INET<<8 | SAFNUM_LABUNICAST): 1194 advance = decode_labeled_prefix4(tptr, buf, sizeof(buf)); 1195 if (advance == -1) 1196 printf("\n\t (illegal prefix length)"); 1197 else if (advance == -2) 1198 goto trunc; 1199 else 1200 printf("\n\t %s", buf); 1201 break; 1202 case (AFNUM_INET<<8 | SAFNUM_VPNUNICAST): 1203 case (AFNUM_INET<<8 | SAFNUM_VPNMULTICAST): 1204 case (AFNUM_INET<<8 | SAFNUM_VPNUNIMULTICAST): 1205 advance = decode_labeled_vpn_prefix4(tptr, buf, sizeof(buf)); 1206 if (advance == -1) 1207 printf("\n\t (illegal prefix length)"); 1208 else if (advance == -2) 1209 goto trunc; 1210 else 1211 printf("\n\t %s", buf); 1212 break; 1213 case (AFNUM_INET<<8 | SAFNUM_RT_ROUTING_INFO): 1214 advance = decode_rt_routing_info(tptr, buf, sizeof(buf)); 1215 if (advance == -1) 1216 printf("\n\t (illegal prefix length)"); 1217 else if (advance == -2) 1218 goto trunc; 1219 else 1220 printf("\n\t %s", buf); 1221 break; |
1222#ifdef INET6
|
1132 case AFNUM_INET6:
1133 switch (safi) {
1134 case SAFNUM_UNICAST:
1135 case SAFNUM_MULTICAST:
1136 case SAFNUM_UNIMULTICAST:
1137 advance = decode_prefix6(tptr, buf, sizeof(buf));
1138 if (advance == -1)
1139 printf("\n\t (illegal prefix length)");
1140 else if (advance == -2)
1141 goto trunc;
1142 else
1143 printf("\n\t %s", buf);
1144 break;
1145 case SAFNUM_LABUNICAST:
1146 advance = decode_labeled_prefix6(tptr, buf, sizeof(buf));
1147 if (advance == -1)
1148 printf("\n\t (illegal prefix length)");
1149 else if (advance == -2)
1150 goto trunc;
1151 else
1152 printf("\n\t %s", buf);
1153 break;
1154 case SAFNUM_VPNUNICAST:
1155 case SAFNUM_VPNMULTICAST:
1156 case SAFNUM_VPNUNIMULTICAST:
1157 advance = decode_labeled_vpn_prefix6(tptr, buf, sizeof(buf));
1158 if (advance == -1)
1159 printf("\n\t (illegal prefix length)");
1160 else if (advance == -2)
1161 goto trunc;
1162 else
1163 printf("\n\t %s", buf);
1164 break;
1165 case SAFNUM_RT_ROUTING_INFO:
1166 advance = decode_rt_routing_info(tptr, buf, sizeof(buf));
1167 if (advance == -1)
1168 printf("\n\t (illegal prefix length)");
1169 else if (advance == -2)
1170 goto trunc;
1171 else
1172 printf("\n\t %s", buf);
1173 break;
1174 default:
1175 TCHECK2(*(tptr-3),tlen);
1176 printf("\n\t no SAFI %u decoder ",safi);
1177 if (vflag <= 1)
1178 print_unknown_data(tptr-3,"\n\t ",tlen);
1179 advance = 0;
1180 tptr = pptr + len;
1181 break;
1182 }
1183 break;
|
1223 case (AFNUM_INET6<<8 | SAFNUM_UNICAST): 1224 case (AFNUM_INET6<<8 | SAFNUM_MULTICAST): 1225 case (AFNUM_INET6<<8 | SAFNUM_UNIMULTICAST): 1226 advance = decode_prefix6(tptr, buf, sizeof(buf)); 1227 if (advance == -1) 1228 printf("\n\t (illegal prefix length)"); 1229 else if (advance == -2) 1230 goto trunc; 1231 else 1232 printf("\n\t %s", buf); 1233 break; 1234 case (AFNUM_INET6<<8 | SAFNUM_LABUNICAST): 1235 advance = decode_labeled_prefix6(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_INET6<<8 | SAFNUM_VPNUNICAST): 1244 case (AFNUM_INET6<<8 | SAFNUM_VPNMULTICAST): 1245 case (AFNUM_INET6<<8 | SAFNUM_VPNUNIMULTICAST): 1246 advance = decode_labeled_vpn_prefix6(tptr, buf, sizeof(buf)); 1247 if (advance == -1) 1248 printf("\n\t (illegal prefix length)"); 1249 else if (advance == -2) 1250 goto trunc; 1251 else 1252 printf("\n\t %s", buf); 1253 break; 1254 case (AFNUM_INET6<<8 | SAFNUM_RT_ROUTING_INFO): 1255 advance = decode_rt_routing_info(tptr, buf, sizeof(buf)); 1256 if (advance == -1) 1257 printf("\n\t (illegal prefix length)"); 1258 else if (advance == -2) 1259 goto trunc; 1260 else 1261 printf("\n\t %s", buf); 1262 break; |
1263#endif
|
1185 case AFNUM_L2VPN:
1186 switch(safi) {
1187 case SAFNUM_VPNUNICAST:
1188 case SAFNUM_VPNMULTICAST:
1189 case SAFNUM_VPNUNIMULTICAST:
1190 advance = decode_labeled_vpn_l2(tptr, buf, sizeof(buf));
1191 if (advance == -1)
1192 printf("\n\t (illegal length)");
1193 else if (advance == -2)
1194 goto trunc;
1195 else
1196 printf("\n\t %s", buf);
1197 break;
1198 default:
1199 TCHECK2(*tptr,tlen);
1200 printf("no SAFI %u decoder",safi);
1201 if (vflag <= 1)
1202 print_unknown_data(tptr,"\n\t ",tlen);
1203 advance = 0;
1204 tptr = pptr + len;
1205 break;
1206 }
1207 break;
1208
1209
1210 default:
1211 TCHECK2(*(tptr-3),tlen);
1212 printf("\n\t no AFI %u decoder ",af);
1213 if (vflag <= 1)
1214 print_unknown_data(tptr-3,"\n\t ",tlen);
1215 advance = 0;
1216 tptr = pptr + len;
1217 break;
1218 }
1219 tptr += advance;
|
1264 case (AFNUM_L2VPN<<8 | SAFNUM_VPNUNICAST): 1265 case (AFNUM_L2VPN<<8 | SAFNUM_VPNMULTICAST): 1266 case (AFNUM_L2VPN<<8 | SAFNUM_VPNUNIMULTICAST): 1267 advance = decode_labeled_vpn_l2(tptr, buf, sizeof(buf)); 1268 if (advance == -1) 1269 printf("\n\t (illegal length)"); 1270 else if (advance == -2) 1271 goto trunc; 1272 else 1273 printf("\n\t %s", buf); 1274 break; 1275 case (AFNUM_NSAP<<8 | SAFNUM_UNICAST): 1276 case (AFNUM_NSAP<<8 | SAFNUM_MULTICAST): 1277 case (AFNUM_NSAP<<8 | SAFNUM_UNIMULTICAST): 1278 advance = decode_labeled_clnp_prefix(tptr, buf, sizeof(buf)); 1279 if (advance == -1) 1280 printf("\n\t (illegal prefix length)"); 1281 else if (advance == -2) 1282 goto trunc; 1283 else 1284 printf("\n\t %s", buf); 1285 break; 1286 case (AFNUM_NSAP<<8 | SAFNUM_VPNUNICAST): 1287 case (AFNUM_NSAP<<8 | SAFNUM_VPNMULTICAST): 1288 case (AFNUM_NSAP<<8 | SAFNUM_VPNUNIMULTICAST): 1289 advance = decode_labeled_vpn_clnp_prefix(tptr, buf, sizeof(buf)); 1290 if (advance == -1) 1291 printf("\n\t (illegal prefix length)"); 1292 else if (advance == -2) 1293 goto trunc; 1294 else 1295 printf("\n\t %s", buf); 1296 break; 1297 default: 1298 TCHECK2(*tptr,tlen); 1299 printf("\n\t no AFI %u / SAFI %u decoder",af,safi); 1300 if (vflag <= 1) 1301 print_unknown_data(tptr,"\n\t ",tlen); 1302 advance = 0; 1303 tptr = pptr + len; 1304 break; 1305 } 1306 break; 1307 1308 tptr += advance; |
1309 }
|
1310 done: |
1311 break; 1312 1313 case BGPTYPE_MP_UNREACH_NLRI:
|
1224 TCHECK2(tptr[0], 3);
|
1314 TCHECK2(tptr[0], BGP_MP_NLRI_MINSIZE); |
1315 af = EXTRACT_16BITS(tptr); 1316 safi = tptr[2]; 1317 1318 printf("\n\t AFI: %s (%u), %sSAFI: %s (%u)",
|
1229 tok2str(bgp_afi_values, "Unknown AFI", af),
|
1319 tok2strbuf(bgp_afi_values, "Unknown AFI", af, 1320 tokbuf, sizeof(tokbuf)), |
1321 af, 1322 (safi>128) ? "vendor specific " : "", /* 128 is meanwhile wellknown */
|
1232 tok2str(bgp_safi_values, "Unknown SAFI", safi),
|
1323 tok2strbuf(bgp_safi_values, "Unknown SAFI", safi, 1324 tokbuf, sizeof(tokbuf)), |
1325 safi); 1326
|
1327 if (len == BGP_MP_NLRI_MINSIZE) 1328 printf("\n\t End-of-Rib Marker (empty NLRI)"); 1329 |
1330 tptr += 3; 1331 1332 while (len - (tptr - pptr) > 0) {
|
1238 switch (af) {
1239 case AFNUM_INET:
1240 switch (safi) {
1241 case SAFNUM_UNICAST:
1242 case SAFNUM_MULTICAST:
1243 case SAFNUM_UNIMULTICAST:
1244 advance = decode_prefix4(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 case SAFNUM_LABUNICAST:
1253 advance = decode_labeled_prefix4(tptr, buf, sizeof(buf));
1254 if (advance == -1)
1255 printf("\n\t (illegal prefix length)");
1256 else if (advance == -2)
1257 goto trunc;
1258 else
1259 printf("\n\t %s", buf);
1260 break;
1261 case SAFNUM_VPNUNICAST:
1262 case SAFNUM_VPNMULTICAST:
1263 case SAFNUM_VPNUNIMULTICAST:
1264 advance = decode_labeled_vpn_prefix4(tptr, buf, sizeof(buf));
1265 if (advance == -1)
1266 printf("\n\t (illegal prefix length)");
1267 else if (advance == -2)
1268 goto trunc;
1269 else
1270 printf("\n\t %s", buf);
1271 break;
1272 default:
1273 TCHECK2(*(tptr-3),tlen);
1274 printf("\n\t no SAFI %u decoder",safi);
1275 if (vflag <= 1)
1276 print_unknown_data(tptr-3,"\n\t ",tlen);
1277 advance = 0;
1278 tptr = pptr + len;
1279 break;
1280 }
1281 break;
1282
|
1333 switch (af<<8 | safi) { 1334 case (AFNUM_INET<<8 | SAFNUM_UNICAST): 1335 case (AFNUM_INET<<8 | SAFNUM_MULTICAST): 1336 case (AFNUM_INET<<8 | SAFNUM_UNIMULTICAST): 1337 advance = decode_prefix4(tptr, buf, sizeof(buf)); 1338 if (advance == -1) 1339 printf("\n\t (illegal prefix length)"); 1340 else if (advance == -2) 1341 goto trunc; 1342 else 1343 printf("\n\t %s", buf); 1344 break; 1345 case (AFNUM_INET<<8 | SAFNUM_LABUNICAST): 1346 advance = decode_labeled_prefix4(tptr, buf, sizeof(buf)); 1347 if (advance == -1) 1348 printf("\n\t (illegal prefix length)"); 1349 else if (advance == -2) 1350 goto trunc; 1351 else 1352 printf("\n\t %s", buf); 1353 break; 1354 case (AFNUM_INET<<8 | SAFNUM_VPNUNICAST): 1355 case (AFNUM_INET<<8 | SAFNUM_VPNMULTICAST): 1356 case (AFNUM_INET<<8 | SAFNUM_VPNUNIMULTICAST): 1357 advance = decode_labeled_vpn_prefix4(tptr, buf, sizeof(buf)); 1358 if (advance == -1) 1359 printf("\n\t (illegal prefix length)"); 1360 else if (advance == -2) 1361 goto trunc; 1362 else 1363 printf("\n\t %s", buf); 1364 break; |
1365#ifdef INET6
|
1284 case AFNUM_INET6:
1285 switch (safi) {
1286 case SAFNUM_UNICAST:
1287 case SAFNUM_MULTICAST:
1288 case SAFNUM_UNIMULTICAST:
1289 advance = decode_prefix6(tptr, buf, sizeof(buf));
1290 if (advance == -1)
1291 printf("\n\t (illegal prefix length)");
1292 else if (advance == -2)
1293 goto trunc;
1294 else
1295 printf("\n\t %s", buf);
1296 break;
1297 case SAFNUM_LABUNICAST:
1298 advance = decode_labeled_prefix6(tptr, buf, sizeof(buf));
1299 if (advance == -1)
1300 printf("\n\t (illegal prefix length)");
1301 else if (advance == -2)
1302 goto trunc;
1303 else
1304 printf("\n\t %s", buf);
1305 break;
1306 case SAFNUM_VPNUNICAST:
1307 case SAFNUM_VPNMULTICAST:
1308 case SAFNUM_VPNUNIMULTICAST:
1309 advance = decode_labeled_vpn_prefix6(tptr, buf, sizeof(buf));
1310 if (advance == -1)
1311 printf("\n\t (illegal prefix length)");
1312 else if (advance == -2)
1313 goto trunc;
1314 else
1315 printf("\n\t %s", buf);
1316 break;
1317 default:
1318 TCHECK2(*(tptr-3),tlen);
1319 printf("\n\t no SAFI %u decoder",safi);
1320 if (vflag <= 1)
1321 print_unknown_data(tptr-3,"\n\t ",tlen);
1322 advance = 0;
1323 tptr = pptr + len;
1324 break;
1325 }
1326 break;
|
1366 case (AFNUM_INET6<<8 | SAFNUM_UNICAST): 1367 case (AFNUM_INET6<<8 | SAFNUM_MULTICAST): 1368 case (AFNUM_INET6<<8 | SAFNUM_UNIMULTICAST): 1369 advance = decode_prefix6(tptr, buf, sizeof(buf)); 1370 if (advance == -1) 1371 printf("\n\t (illegal prefix length)"); 1372 else if (advance == -2) 1373 goto trunc; 1374 else 1375 printf("\n\t %s", buf); 1376 break; 1377 case (AFNUM_INET6<<8 | SAFNUM_LABUNICAST): 1378 advance = decode_labeled_prefix6(tptr, buf, sizeof(buf)); 1379 if (advance == -1) 1380 printf("\n\t (illegal prefix length)"); 1381 else if (advance == -2) 1382 goto trunc; 1383 else 1384 printf("\n\t %s", buf); 1385 break; 1386 case (AFNUM_INET6<<8 | SAFNUM_VPNUNICAST): 1387 case (AFNUM_INET6<<8 | SAFNUM_VPNMULTICAST): 1388 case (AFNUM_INET6<<8 | SAFNUM_VPNUNIMULTICAST): 1389 advance = decode_labeled_vpn_prefix6(tptr, buf, sizeof(buf)); 1390 if (advance == -1) 1391 printf("\n\t (illegal prefix length)"); 1392 else if (advance == -2) 1393 goto trunc; 1394 else 1395 printf("\n\t %s", buf); 1396 break; |
1397#endif
|
1328
1329 case AFNUM_L2VPN:
1330 switch(safi) {
1331 case SAFNUM_VPNUNICAST:
1332 case SAFNUM_VPNMULTICAST:
1333 case SAFNUM_VPNUNIMULTICAST:
1334 advance = decode_labeled_vpn_l2(tptr, buf, sizeof(buf));
1335 if (advance == -1)
1336 printf("\n\t (illegal length)");
1337 else if (advance == -2)
1338 goto trunc;
1339 else
1340 printf("\n\t %s", buf);
1341 break;
1342 default:
1343 TCHECK2(*(tptr-3),tlen);
1344 printf("no SAFI %u decoder",safi);
1345 if (vflag <= 1)
1346 print_unknown_data(tptr-3,"\n\t ",tlen);
1347 advance = 0;
1348 tptr = pptr + len;
1349 break;
1350 }
1351 break;
1352
1353 default:
1354 TCHECK2(*(tptr-3),tlen);
1355 printf("\n\t no AFI %u decoder",af);
1356 if (vflag <= 1)
1357 print_unknown_data(tptr-3,"\n\t ",tlen);
1358 advance = 0;
1359 tptr = pptr + len;
1360 break;
1361 }
1362
1363 tptr += advance;
|
1398 case (AFNUM_L2VPN<<8 | SAFNUM_VPNUNICAST): 1399 case (AFNUM_L2VPN<<8 | SAFNUM_VPNMULTICAST): 1400 case (AFNUM_L2VPN<<8 | SAFNUM_VPNUNIMULTICAST): 1401 advance = decode_labeled_vpn_l2(tptr, buf, sizeof(buf)); 1402 if (advance == -1) 1403 printf("\n\t (illegal length)"); 1404 else if (advance == -2) 1405 goto trunc; 1406 else 1407 printf("\n\t %s", buf); 1408 break; 1409 case (AFNUM_NSAP<<8 | SAFNUM_UNICAST): 1410 case (AFNUM_NSAP<<8 | SAFNUM_MULTICAST): 1411 case (AFNUM_NSAP<<8 | SAFNUM_UNIMULTICAST): 1412 advance = decode_labeled_clnp_prefix(tptr, buf, sizeof(buf)); 1413 if (advance == -1) 1414 printf("\n\t (illegal prefix length)"); 1415 else if (advance == -2) 1416 goto trunc; 1417 else 1418 printf("\n\t %s", buf); 1419 break; 1420 case (AFNUM_NSAP<<8 | SAFNUM_VPNUNICAST): 1421 case (AFNUM_NSAP<<8 | SAFNUM_VPNMULTICAST): 1422 case (AFNUM_NSAP<<8 | SAFNUM_VPNUNIMULTICAST): 1423 advance = decode_labeled_vpn_clnp_prefix(tptr, buf, sizeof(buf)); 1424 if (advance == -1) 1425 printf("\n\t (illegal prefix length)"); 1426 else if (advance == -2) 1427 goto trunc; 1428 else 1429 printf("\n\t %s", buf); 1430 break; 1431 default: 1432 TCHECK2(*(tptr-3),tlen); 1433 printf("no AFI %u / SAFI %u decoder",af,safi); 1434 if (vflag <= 1) 1435 print_unknown_data(tptr-3,"\n\t ",tlen); 1436 advance = 0; 1437 tptr = pptr + len; 1438 break; 1439 } 1440 break; 1441 tptr += advance; |
1442 } 1443 break; 1444 case BGPTYPE_EXTD_COMMUNITIES: 1445 if (len % 8) { 1446 printf("invalid len"); 1447 break; 1448 } 1449 while (tlen>0) { 1450 u_int16_t extd_comm; 1451 1452 TCHECK2(tptr[0], 2); 1453 extd_comm=EXTRACT_16BITS(tptr); 1454 1455 printf("\n\t %s (0x%04x), Flags [%s]",
|
1378 tok2str(bgp_extd_comm_subtype_values, "unknown extd community typecode", extd_comm),
|
1456 tok2strbuf(bgp_extd_comm_subtype_values, 1457 "unknown extd community typecode", 1458 extd_comm, tokbuf, sizeof(tokbuf)), |
1459 extd_comm, 1460 bittok2str(bgp_extd_comm_flag_values, "none", extd_comm)); 1461 1462 TCHECK2(*(tptr+2), 6); 1463 switch(extd_comm) { 1464 case BGP_EXT_COM_RT_0: 1465 case BGP_EXT_COM_RO_0: 1466 printf(": %u:%s", 1467 EXTRACT_16BITS(tptr+2), 1468 getname(tptr+4)); 1469 break; 1470 case BGP_EXT_COM_RT_1: 1471 case BGP_EXT_COM_RO_1: 1472 printf(": %s:%u", 1473 getname(tptr+2), 1474 EXTRACT_16BITS(tptr+6)); 1475 break; 1476 case BGP_EXT_COM_RT_2: 1477 case BGP_EXT_COM_RO_2: 1478 printf(": %u:%u", 1479 EXTRACT_32BITS(tptr+2), 1480 EXTRACT_16BITS(tptr+6)); 1481 break; 1482 case BGP_EXT_COM_LINKBAND: 1483 bw.i = EXTRACT_32BITS(tptr+2); 1484 printf(": bandwidth: %.3f Mbps", 1485 bw.f*8/1000000); 1486 break;
|
1487 case BGP_EXT_COM_CISCO_MCAST: 1488 printf(": AS %u, group %s", 1489 EXTRACT_16BITS(tptr+2), 1490 getname(tptr+4)); 1491 break; |
1492 case BGP_EXT_COM_VPN_ORIGIN: 1493 case BGP_EXT_COM_VPN_ORIGIN2: 1494 case BGP_EXT_COM_VPN_ORIGIN3: 1495 case BGP_EXT_COM_VPN_ORIGIN4: 1496 case BGP_EXT_COM_OSPF_RID: 1497 case BGP_EXT_COM_OSPF_RID2: 1498 printf("%s", getname(tptr+2)); 1499 break; 1500 case BGP_EXT_COM_OSPF_RTYPE: 1501 case BGP_EXT_COM_OSPF_RTYPE2: 1502 printf(": area:%s, router-type:%s, metric-type:%s%s", 1503 getname(tptr+2),
|
1419 tok2str(bgp_extd_comm_ospf_rtype_values,
1420 "unknown (0x%02x)",
1421 *(tptr+6)),
|
1504 tok2strbuf(bgp_extd_comm_ospf_rtype_values, 1505 "unknown (0x%02x)", 1506 *(tptr+6), 1507 tokbuf, sizeof(tokbuf)), |
1508 (*(tptr+7) & BGP_OSPF_RTYPE_METRIC_TYPE) ? "E2" : "", 1509 (*(tptr+6) == (BGP_OSPF_RTYPE_EXT ||BGP_OSPF_RTYPE_NSSA )) ? "E1" : ""); 1510 break; 1511 case BGP_EXT_COM_L2INFO: 1512 printf(": %s Control Flags [0x%02x]:MTU %u",
|
1427 tok2str(bgp_l2vpn_encaps_values,
1428 "unknown encaps",
1429 *(tptr+2)),
|
1513 tok2strbuf(l2vpn_encaps_values, 1514 "unknown encaps", 1515 *(tptr+2), 1516 tokbuf, sizeof(tokbuf)), |
1517 *(tptr+3), 1518 EXTRACT_16BITS(tptr+4)); 1519 break; 1520 default: 1521 print_unknown_data(tptr,"\n\t ",8); 1522 break; 1523 } 1524 tlen -=8; 1525 tptr +=8; 1526 } 1527 break; 1528
|
1529 case BGPTYPE_ATTR_SET: 1530 TCHECK2(tptr[0], 4); 1531 printf("\n\t Origin AS: %u", EXTRACT_32BITS(tptr)); 1532 tptr+=4; 1533 len -=4; 1534 1535 while (len >= 2 ) { 1536 int alen; 1537 struct bgp_attr bgpa; 1538 1539 TCHECK2(tptr[0], sizeof(bgpa)); 1540 memcpy(&bgpa, tptr, sizeof(bgpa)); 1541 alen = bgp_attr_len(&bgpa); 1542 tptr += bgp_attr_off(&bgpa); 1543 len -= bgp_attr_off(&bgpa); 1544 1545 printf("\n\t %s (%u), length: %u", 1546 tok2strbuf(bgp_attr_values, 1547 "Unknown Attribute", bgpa.bgpa_type, 1548 tokbuf, sizeof(tokbuf)), 1549 bgpa.bgpa_type, 1550 alen); 1551 1552 if (bgpa.bgpa_flags) { 1553 printf(", Flags [%s%s%s%s", 1554 bgpa.bgpa_flags & 0x80 ? "O" : "", 1555 bgpa.bgpa_flags & 0x40 ? "T" : "", 1556 bgpa.bgpa_flags & 0x20 ? "P" : "", 1557 bgpa.bgpa_flags & 0x10 ? "E" : ""); 1558 if (bgpa.bgpa_flags & 0xf) 1559 printf("+%x", bgpa.bgpa_flags & 0xf); 1560 printf("]: "); 1561 } 1562 /* FIXME check for recursion */ 1563 if (!bgp_attr_print(&bgpa, tptr, alen)) 1564 return 0; 1565 tptr += alen; 1566 len -= alen; 1567 } 1568 break; 1569 1570 |
1571 default: 1572 TCHECK2(*pptr,len); 1573 printf("\n\t no Attribute %u decoder",attr->bgpa_type); /* we have no decoder for the attribute */ 1574 if (vflag <= 1) 1575 print_unknown_data(pptr,"\n\t ",len); 1576 break; 1577 } 1578 if (vflag > 1 && len) /* omit zero length attributes*/ 1579 print_unknown_data(pptr,"\n\t ",len); 1580 return 1; 1581 1582trunc: 1583 return 0; 1584} 1585 1586static void 1587bgp_open_print(const u_char *dat, int length) 1588{ 1589 struct bgp_open bgpo; 1590 struct bgp_opt bgpopt; 1591 int hlen; 1592 const u_char *opt; 1593 int i,cap_type,cap_len,tcap_len,cap_offset;
|
1594 char tokbuf[TOKBUFSIZE]; 1595 char tokbuf2[TOKBUFSIZE]; |
1596 1597 TCHECK2(dat[0], BGP_OPEN_SIZE); 1598 memcpy(&bgpo, dat, BGP_OPEN_SIZE); 1599 hlen = ntohs(bgpo.bgpo_len); 1600 1601 printf("\n\t Version %d, ", bgpo.bgpo_version); 1602 printf("my AS %u, ", ntohs(bgpo.bgpo_myas)); 1603 printf("Holdtime %us, ", ntohs(bgpo.bgpo_holdtime)); 1604 printf("ID %s", getname((u_char *)&bgpo.bgpo_id)); 1605 printf("\n\t Optional parameters, length: %u", bgpo.bgpo_optlen); 1606 1607 /* some little sanity checking */ 1608 if (length < bgpo.bgpo_optlen+BGP_OPEN_SIZE) 1609 return; 1610 1611 /* ugly! */ 1612 opt = &((const struct bgp_open *)dat)->bgpo_optlen; 1613 opt++; 1614 1615 i = 0; 1616 while (i < bgpo.bgpo_optlen) { 1617 TCHECK2(opt[i], BGP_OPT_SIZE); 1618 memcpy(&bgpopt, &opt[i], BGP_OPT_SIZE); 1619 if (i + 2 + bgpopt.bgpopt_len > bgpo.bgpo_optlen) { 1620 printf("\n\t Option %d, length: %u", bgpopt.bgpopt_type, bgpopt.bgpopt_len); 1621 break; 1622 } 1623 1624 printf("\n\t Option %s (%u), length: %u",
|
1494 tok2str(bgp_opt_values,"Unknown", bgpopt.bgpopt_type),
|
1625 tok2strbuf(bgp_opt_values,"Unknown", 1626 bgpopt.bgpopt_type, 1627 tokbuf, sizeof(tokbuf)), |
1628 bgpopt.bgpopt_type, 1629 bgpopt.bgpopt_len); 1630 1631 /* now lets decode the options we know*/ 1632 switch(bgpopt.bgpopt_type) { 1633 case BGP_OPT_CAP: 1634 cap_type=opt[i+BGP_OPT_SIZE]; 1635 cap_len=opt[i+BGP_OPT_SIZE+1]; 1636 tcap_len=cap_len;
|
1504 printf("\n\t %s, length: %u",
1505 tok2str(bgp_capcode_values,"Unknown", cap_type),
|
1637 printf("\n\t %s (%u), length: %u", 1638 tok2strbuf(bgp_capcode_values, "Unknown", 1639 cap_type, tokbuf, sizeof(tokbuf)), 1640 cap_type, |
1641 cap_len); 1642 switch(cap_type) { 1643 case BGP_CAPCODE_MP: 1644 printf("\n\t\tAFI %s (%u), SAFI %s (%u)",
|
1510 tok2str(bgp_afi_values,"Unknown", EXTRACT_16BITS(opt+i+BGP_OPT_SIZE+2)),
|
1645 tok2strbuf(bgp_afi_values, "Unknown", 1646 EXTRACT_16BITS(opt+i+BGP_OPT_SIZE+2), 1647 tokbuf, sizeof(tokbuf)), |
1648 EXTRACT_16BITS(opt+i+BGP_OPT_SIZE+2),
|
1512 tok2str(bgp_safi_values,"Unknown", opt[i+BGP_OPT_SIZE+5]),
|
1649 tok2strbuf(bgp_safi_values, "Unknown", 1650 opt[i+BGP_OPT_SIZE+5], 1651 tokbuf, sizeof(tokbuf)), |
1652 opt[i+BGP_OPT_SIZE+5]); 1653 break; 1654 case BGP_CAPCODE_RESTART: 1655 printf("\n\t\tRestart Flags: [%s], Restart Time %us", 1656 ((opt[i+BGP_OPT_SIZE+2])&0x80) ? "R" : "none", 1657 EXTRACT_16BITS(opt+i+BGP_OPT_SIZE+2)&0xfff); 1658 tcap_len-=2; 1659 cap_offset=4; 1660 while(tcap_len>=4) { 1661 printf("\n\t\t AFI %s (%u), SAFI %s (%u), Forwarding state preserved: %s",
|
1523 tok2str(bgp_afi_values,"Unknown", EXTRACT_16BITS(opt+i+BGP_OPT_SIZE+cap_offset)),
|
1662 tok2strbuf(bgp_afi_values,"Unknown", 1663 EXTRACT_16BITS(opt+i+BGP_OPT_SIZE+cap_offset), 1664 tokbuf, sizeof(tokbuf)), |
1665 EXTRACT_16BITS(opt+i+BGP_OPT_SIZE+cap_offset),
|
1525 tok2str(bgp_safi_values,"Unknown", opt[i+BGP_OPT_SIZE+cap_offset+2]),
|
1666 tok2strbuf(bgp_safi_values,"Unknown", 1667 opt[i+BGP_OPT_SIZE+cap_offset+2], 1668 tokbuf2, sizeof(tokbuf2)), |
1669 opt[i+BGP_OPT_SIZE+cap_offset+2], 1670 ((opt[i+BGP_OPT_SIZE+cap_offset+3])&0x80) ? "yes" : "no" ); 1671 tcap_len-=4; 1672 cap_offset+=4; 1673 } 1674 break; 1675 case BGP_CAPCODE_RR: 1676 case BGP_CAPCODE_RR_CISCO: 1677 break; 1678 default: 1679 printf("\n\t\tno decoder for Capability %u", 1680 cap_type); 1681 if (vflag <= 1) 1682 print_unknown_data(&opt[i+BGP_OPT_SIZE+2],"\n\t\t",cap_len); 1683 break; 1684 } 1685 if (vflag > 1) 1686 print_unknown_data(&opt[i+BGP_OPT_SIZE+2],"\n\t\t",cap_len); 1687 break; 1688 case BGP_OPT_AUTH: 1689 default: 1690 printf("\n\t no decoder for option %u", 1691 bgpopt.bgpopt_type); 1692 break; 1693 } 1694 1695 i += BGP_OPT_SIZE + bgpopt.bgpopt_len; 1696 } 1697 return; 1698trunc: 1699 printf("[|BGP]"); 1700} 1701 1702static void 1703bgp_update_print(const u_char *dat, int length) 1704{ 1705 struct bgp bgp; 1706 struct bgp_attr bgpa; 1707 int hlen; 1708 const u_char *p; 1709 int len; 1710 int i;
|
1711 char tokbuf[TOKBUFSIZE]; |
1712 1713 TCHECK2(dat[0], BGP_SIZE); 1714 memcpy(&bgp, dat, BGP_SIZE); 1715 hlen = ntohs(bgp.bgp_len); 1716 p = dat + BGP_SIZE; /*XXX*/ 1717 1718 /* Unfeasible routes */ 1719 len = EXTRACT_16BITS(p); 1720 if (len) { 1721 /* 1722 * Without keeping state from the original NLRI message, 1723 * it's not possible to tell if this a v4 or v6 route, 1724 * so only try to decode it if we're not v6 enabled. 1725 */ 1726#ifdef INET6 1727 printf("\n\t Withdrawn routes: %d bytes", len); 1728#else 1729 char buf[MAXHOSTNAMELEN + 100]; 1730 int wpfx; 1731 1732 TCHECK2(p[2], len); 1733 i = 2; 1734 1735 printf("\n\t Withdrawn routes:"); 1736 1737 while(i < 2 + len) { 1738 wpfx = decode_prefix4(&p[i], buf, sizeof(buf)); 1739 if (wpfx == -1) { 1740 printf("\n\t (illegal prefix length)"); 1741 break; 1742 } else if (wpfx == -2) 1743 goto trunc; 1744 else { 1745 i += wpfx; 1746 printf("\n\t %s", buf); 1747 } 1748 } 1749#endif 1750 } 1751 p += 2 + len; 1752 1753 TCHECK2(p[0], 2); 1754 len = EXTRACT_16BITS(p);
|
1755 1756 if (len == 0 && length == BGP_UPDATE_MINSIZE) { 1757 printf("\n\t End-of-Rib Marker (empty NLRI)"); 1758 return; 1759 } 1760 |
1761 if (len) { 1762 /* do something more useful!*/ 1763 i = 2; 1764 while (i < 2 + len) { 1765 int alen, aoff; 1766 1767 TCHECK2(p[i], sizeof(bgpa)); 1768 memcpy(&bgpa, &p[i], sizeof(bgpa)); 1769 alen = bgp_attr_len(&bgpa); 1770 aoff = bgp_attr_off(&bgpa); 1771 1772 printf("\n\t %s (%u), length: %u",
|
1623 tok2str(bgp_attr_values, "Unknown Attribute", bgpa.bgpa_type),
|
1773 tok2strbuf(bgp_attr_values, "Unknown Attribute", 1774 bgpa.bgpa_type, 1775 tokbuf, sizeof(tokbuf)), |
1776 bgpa.bgpa_type, 1777 alen); 1778 1779 if (bgpa.bgpa_flags) { 1780 printf(", Flags [%s%s%s%s", 1781 bgpa.bgpa_flags & 0x80 ? "O" : "", 1782 bgpa.bgpa_flags & 0x40 ? "T" : "", 1783 bgpa.bgpa_flags & 0x20 ? "P" : "", 1784 bgpa.bgpa_flags & 0x10 ? "E" : ""); 1785 if (bgpa.bgpa_flags & 0xf) 1786 printf("+%x", bgpa.bgpa_flags & 0xf); 1787 printf("]: "); 1788 } 1789 if (!bgp_attr_print(&bgpa, &p[i + aoff], alen)) 1790 goto trunc; 1791 i += aoff + alen; 1792 }
|
1641 }
|
1793 } |
1794 p += 2 + len; 1795 1796 if (dat + length > p) { 1797 printf("\n\t Updated routes:"); 1798 while (dat + length > p) { 1799 char buf[MAXHOSTNAMELEN + 100]; 1800 i = decode_prefix4(p, buf, sizeof(buf)); 1801 if (i == -1) 1802 printf("\n\t (illegal prefix length)"); 1803 else if (i == -2) 1804 goto trunc; 1805 else { 1806 printf("\n\t %s", buf); 1807 p += i; 1808 } 1809 } 1810 } 1811 return; 1812trunc: 1813 printf("[|BGP]"); 1814} 1815 1816static void 1817bgp_notification_print(const u_char *dat, int length) 1818{ 1819 struct bgp_notification bgpn; 1820 int hlen; 1821 const u_char *tptr;
|
1822 char tokbuf[TOKBUFSIZE]; 1823 char tokbuf2[TOKBUFSIZE]; |
1824 1825 TCHECK2(dat[0], BGP_NOTIFICATION_SIZE); 1826 memcpy(&bgpn, dat, BGP_NOTIFICATION_SIZE); 1827 hlen = ntohs(bgpn.bgpn_len); 1828 1829 /* some little sanity checking */ 1830 if (length<BGP_NOTIFICATION_SIZE) 1831 return; 1832 1833 printf(", %s (%u)",
|
1680 tok2str(bgp_notify_major_values, "Unknown Error", bgpn.bgpn_major),
|
1834 tok2strbuf(bgp_notify_major_values, "Unknown Error", 1835 bgpn.bgpn_major, tokbuf, sizeof(tokbuf)), |
1836 bgpn.bgpn_major); 1837 1838 switch (bgpn.bgpn_major) { 1839 1840 case BGP_NOTIFY_MAJOR_MSG: 1841 printf(", subcode %s (%u)",
|
1687 tok2str(bgp_notify_minor_msg_values, "Unknown", bgpn.bgpn_minor),
|
1842 tok2strbuf(bgp_notify_minor_msg_values, "Unknown", 1843 bgpn.bgpn_minor, tokbuf, sizeof(tokbuf)), |
1844 bgpn.bgpn_minor); 1845 break; 1846 case BGP_NOTIFY_MAJOR_OPEN: 1847 printf(", subcode %s (%u)",
|
1692 tok2str(bgp_notify_minor_open_values, "Unknown", bgpn.bgpn_minor),
|
1848 tok2strbuf(bgp_notify_minor_open_values, "Unknown", 1849 bgpn.bgpn_minor, tokbuf, sizeof(tokbuf)), |
1850 bgpn.bgpn_minor); 1851 break; 1852 case BGP_NOTIFY_MAJOR_UPDATE: 1853 printf(", subcode %s (%u)",
|
1697 tok2str(bgp_notify_minor_update_values, "Unknown", bgpn.bgpn_minor),
|
1854 tok2strbuf(bgp_notify_minor_update_values, "Unknown", 1855 bgpn.bgpn_minor, tokbuf, sizeof(tokbuf)), |
1856 bgpn.bgpn_minor); 1857 break; 1858 case BGP_NOTIFY_MAJOR_CAP: 1859 printf(" subcode %s (%u)",
|
1702 tok2str(bgp_notify_minor_cap_values, "Unknown", bgpn.bgpn_minor),
|
1860 tok2strbuf(bgp_notify_minor_cap_values, "Unknown", 1861 bgpn.bgpn_minor, tokbuf, sizeof(tokbuf)), |
1862 bgpn.bgpn_minor); 1863 case BGP_NOTIFY_MAJOR_CEASE: 1864 printf(", subcode %s (%u)",
|
1706 tok2str(bgp_notify_minor_cease_values, "Unknown", bgpn.bgpn_minor),
|
1865 tok2strbuf(bgp_notify_minor_cease_values, "Unknown", 1866 bgpn.bgpn_minor, tokbuf, sizeof(tokbuf)), |
1867 bgpn.bgpn_minor); 1868 1869 /* draft-ietf-idr-cease-subcode-02 mentions optionally 7 bytes 1870 * for the maxprefix subtype, which may contain AFI, SAFI and MAXPREFIXES 1871 */ 1872 if(bgpn.bgpn_minor == BGP_NOTIFY_MINOR_CEASE_MAXPRFX && length >= BGP_NOTIFICATION_SIZE + 7) { 1873 tptr = dat + BGP_NOTIFICATION_SIZE; 1874 TCHECK2(*tptr, 7); 1875 printf(", AFI %s (%u), SAFI %s (%u), Max Prefixes: %u",
|
1716 tok2str(bgp_afi_values, "Unknown", EXTRACT_16BITS(tptr)),
|
1876 tok2strbuf(bgp_afi_values, "Unknown", 1877 EXTRACT_16BITS(tptr), tokbuf, sizeof(tokbuf)), |
1878 EXTRACT_16BITS(tptr),
|
1718 tok2str(bgp_safi_values, "Unknown", *(tptr+2)),
|
1879 tok2strbuf(bgp_safi_values, "Unknown", *(tptr+2), 1880 tokbuf2, sizeof(tokbuf)), |
1881 *(tptr+2), 1882 EXTRACT_32BITS(tptr+3)); 1883 } 1884 break; 1885 default: 1886 break; 1887 } 1888 1889 return; 1890trunc: 1891 printf("[|BGP]"); 1892} 1893 1894static void 1895bgp_route_refresh_print(const u_char *pptr, int len) { 1896 1897 const struct bgp_route_refresh *bgp_route_refresh_header;
|
1898 char tokbuf[TOKBUFSIZE]; 1899 char tokbuf2[TOKBUFSIZE]; 1900 |
1901 bgp_route_refresh_header = (const struct bgp_route_refresh *)pptr; 1902 1903 printf("\n\t AFI %s (%u), SAFI %s (%u)",
|
1739 tok2str(bgp_afi_values,"Unknown",
1740 EXTRACT_16BITS(&bgp_route_refresh_header->afi)), /* this stinks but the compiler pads the structure weird */
|
1904 tok2strbuf(bgp_afi_values,"Unknown", 1905 /* this stinks but the compiler pads the structure 1906 * weird */ 1907 EXTRACT_16BITS(&bgp_route_refresh_header->afi), 1908 tokbuf, sizeof(tokbuf)), |
1909 EXTRACT_16BITS(&bgp_route_refresh_header->afi),
|
1742 tok2str(bgp_safi_values,"Unknown",
1743 bgp_route_refresh_header->safi),
|
1910 tok2strbuf(bgp_safi_values,"Unknown", 1911 bgp_route_refresh_header->safi, 1912 tokbuf2, sizeof(tokbuf2)), |
1913 bgp_route_refresh_header->safi); 1914 1915 if (vflag > 1) 1916 print_unknown_data(pptr,"\n\t ", len); 1917 1918 return; 1919} 1920 1921static int 1922bgp_header_print(const u_char *dat, int length) 1923{ 1924 struct bgp bgp;
|
1925 char tokbuf[TOKBUFSIZE]; |
1926 1927 TCHECK2(dat[0], BGP_SIZE); 1928 memcpy(&bgp, dat, BGP_SIZE); 1929 printf("\n\t%s Message (%u), length: %u",
|
1760 tok2str(bgp_msg_values, "Unknown", bgp.bgp_type),
|
1930 tok2strbuf(bgp_msg_values, "Unknown", bgp.bgp_type, 1931 tokbuf, sizeof(tokbuf)), |
1932 bgp.bgp_type, 1933 length); 1934 1935 switch (bgp.bgp_type) { 1936 case BGP_OPEN: 1937 bgp_open_print(dat, length); 1938 break; 1939 case BGP_UPDATE: 1940 bgp_update_print(dat, length); 1941 break; 1942 case BGP_NOTIFICATION: 1943 bgp_notification_print(dat, length); 1944 break; 1945 case BGP_KEEPALIVE: 1946 break; 1947 case BGP_ROUTE_REFRESH: 1948 bgp_route_refresh_print(dat, length); 1949 break; 1950 default: 1951 /* we have no decoder for the BGP message */ 1952 printf("\n\t no Message %u decoder",bgp.bgp_type); 1953 print_unknown_data(dat,"\n\t ",length); 1954 break; 1955 } 1956 return 1; 1957trunc: 1958 printf("[|BGP]"); 1959 return 0; 1960} 1961 1962void 1963bgp_print(const u_char *dat, int length) 1964{ 1965 const u_char *p; 1966 const u_char *ep; 1967 const u_char *start; 1968 const u_char marker[] = { 1969 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 1970 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 1971 }; 1972 struct bgp bgp; 1973 u_int16_t hlen;
|
1974 char tokbuf[TOKBUFSIZE]; |
1975 1976 ep = dat + length; 1977 if (snapend < dat + length) 1978 ep = snapend; 1979 1980 printf(": BGP, length: %u",length); 1981 1982 if (vflag < 1) /* lets be less chatty */ 1983 return; 1984 1985 p = dat; 1986 start = p; 1987 while (p < snapend) { 1988 if (!TTEST2(p[0], 1)) 1989 break; 1990 if (p[0] != 0xff) { 1991 p++; 1992 continue; 1993 } 1994 1995 if (!TTEST2(p[0], sizeof(marker))) 1996 break; 1997 if (memcmp(p, marker, sizeof(marker)) != 0) { 1998 p++; 1999 continue; 2000 } 2001 2002 /* found BGP header */ 2003 TCHECK2(p[0], BGP_SIZE); /*XXX*/ 2004 memcpy(&bgp, p, BGP_SIZE); 2005 2006 if (start != p) 2007 printf(" [|BGP]"); 2008 2009 hlen = ntohs(bgp.bgp_len); 2010 if (hlen < BGP_SIZE) { 2011 printf("\n[|BGP Bogus header length %u < %u]", hlen, 2012 BGP_SIZE); 2013 break; 2014 } 2015 2016 if (TTEST2(p[0], hlen)) { 2017 if (!bgp_header_print(p, hlen)) 2018 return; 2019 p += hlen; 2020 start = p; 2021 } else {
|
1850 printf("\n[|BGP %s]", tok2str(bgp_msg_values, "Unknown Message Type",bgp.bgp_type));
|
2022 printf("\n[|BGP %s]", 2023 tok2strbuf(bgp_msg_values, 2024 "Unknown Message Type", 2025 bgp.bgp_type, 2026 tokbuf, sizeof(tokbuf))); |
2027 break; 2028 } 2029 } 2030 2031 return; 2032 2033trunc: 2034 printf(" [|BGP]"); 2035}
|