print-bgp.c (127668) | print-bgp.c (146773) |
---|---|
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 --- 22 unchanged lines hidden (view full) --- 31 */ 32 33#ifdef HAVE_CONFIG_H 34#include "config.h" 35#endif 36 37#ifndef lint 38static const char rcsid[] _U_ = | 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 --- 22 unchanged lines hidden (view full) --- 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" | 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" |
|
48#include "addrtoname.h" 49#include "extract.h" | 49#include "addrtoname.h" 50#include "extract.h" |
51#include "bgp.h" 52#include "l2vpn.h" |
|
50 51struct bgp { 52 u_int8_t bgp_marker[16]; 53 u_int16_t bgp_len; 54 u_int8_t bgp_type; 55}; 56#define BGP_SIZE 19 /* unaligned */ 57 --- 27 unchanged lines hidden (view full) --- 85 86struct bgp_opt { 87 u_int8_t bgpopt_type; 88 u_int8_t bgpopt_len; 89 /* variable length */ 90}; 91#define BGP_OPT_SIZE 2 /* some compilers may pad to 4 bytes */ 92 | 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 --- 27 unchanged lines hidden (view full) --- 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 |
|
93struct bgp_notification { 94 u_int8_t bgpn_marker[16]; 95 u_int16_t bgpn_len; 96 u_int8_t bgpn_type; 97 u_int8_t bgpn_major; 98 u_int8_t bgpn_minor; 99}; 100#define BGP_NOTIFICATION_SIZE 21 /* unaligned */ --- 33 unchanged lines hidden (view full) --- 134#define BGPTYPE_ORIGINATOR_ID 9 /* RFC1998 */ 135#define BGPTYPE_CLUSTER_LIST 10 /* RFC1998 */ 136#define BGPTYPE_DPA 11 /* draft-ietf-idr-bgp-dpa */ 137#define BGPTYPE_ADVERTISERS 12 /* RFC1863 */ 138#define BGPTYPE_RCID_PATH 13 /* RFC1863 */ 139#define BGPTYPE_MP_REACH_NLRI 14 /* RFC2283 */ 140#define BGPTYPE_MP_UNREACH_NLRI 15 /* RFC2283 */ 141#define BGPTYPE_EXTD_COMMUNITIES 16 /* draft-ietf-idr-bgp-ext-communities */ | 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 */ --- 33 unchanged lines hidden (view full) --- 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 */ |
|
142 | 148 |
149#define BGP_MP_NLRI_MINSIZE 3 /* End of RIB Marker detection */ 150 |
|
143static struct tok bgp_attr_values[] = { 144 { BGPTYPE_ORIGIN, "Origin"}, 145 { BGPTYPE_AS_PATH, "AS Path"}, 146 { BGPTYPE_NEXT_HOP, "Next Hop"}, 147 { BGPTYPE_MULTI_EXIT_DISC, "Multi Exit Discriminator"}, 148 { BGPTYPE_LOCAL_PREF, "Local Preference"}, 149 { BGPTYPE_ATOMIC_AGGREGATE, "Atomic Aggregate"}, 150 { BGPTYPE_AGGREGATOR, "Aggregator"}, 151 { BGPTYPE_COMMUNITIES, "Community"}, 152 { BGPTYPE_ORIGINATOR_ID, "Originator ID"}, 153 { BGPTYPE_CLUSTER_LIST, "Cluster List"}, 154 { BGPTYPE_DPA, "DPA"}, 155 { BGPTYPE_ADVERTISERS, "Advertisers"}, 156 { BGPTYPE_RCID_PATH, "RCID Path / Cluster ID"}, 157 { BGPTYPE_MP_REACH_NLRI, "Multi-Protocol Reach NLRI"}, 158 { BGPTYPE_MP_UNREACH_NLRI, "Multi-Protocol Unreach NLRI"}, 159 { BGPTYPE_EXTD_COMMUNITIES, "Extended Community"}, | 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"}, |
|
160 { 255, "Reserved for development"}, 161 { 0, NULL} 162}; 163 164#define BGP_AS_SET 1 165#define BGP_AS_SEQUENCE 2 166#define BGP_CONFED_AS_SEQUENCE 3 /* draft-ietf-idr-rfc3065bis-01 */ 167#define BGP_CONFED_AS_SET 4 /* draft-ietf-idr-rfc3065bis-01 */ --- 21 unchanged lines hidden (view full) --- 189static struct tok bgp_opt_values[] = { 190 { BGP_OPT_AUTH, "Authentication Information"}, 191 { BGP_OPT_CAP, "Capabilities Advertisement"}, 192 { 0, NULL} 193}; 194 195#define BGP_CAPCODE_MP 1 196#define BGP_CAPCODE_RR 2 | 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 */ --- 21 unchanged lines hidden (view full) --- 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 */ |
|
197#define BGP_CAPCODE_RESTART 64 /* draft-ietf-idr-restart-05 */ | 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 */ |
|
198#define BGP_CAPCODE_RR_CISCO 128 199 200static struct tok bgp_capcode_values[] = { 201 { BGP_CAPCODE_MP, "Multiprotocol Extensions"}, 202 { BGP_CAPCODE_RR, "Route Refresh"}, | 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"}, |
|
203 { BGP_CAPCODE_RESTART, "Graceful Restart"}, | 216 { BGP_CAPCODE_RESTART, "Graceful Restart"}, |
217 { BGP_CAPCODE_AS_NEW, "32-Bit AS Number"}, 218 { BGP_CAPCODE_DYN_CAP, "Dynamic Capability"}, |
|
204 { BGP_CAPCODE_RR_CISCO, "Route Refresh (Cisco)"}, 205 { 0, NULL} 206}; 207 208#define BGP_NOTIFY_MAJOR_MSG 1 209#define BGP_NOTIFY_MAJOR_OPEN 2 210#define BGP_NOTIFY_MAJOR_UPDATE 3 211#define BGP_NOTIFY_MAJOR_HOLDTIME 4 --- 74 unchanged lines hidden (view full) --- 286 287/* Subsequent address family identifier, RFC2283 section 7 */ 288#define SAFNUM_RES 0 289#define SAFNUM_UNICAST 1 290#define SAFNUM_MULTICAST 2 291#define SAFNUM_UNIMULTICAST 3 292/* labeled BGP RFC3107 */ 293#define SAFNUM_LABUNICAST 4 | 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 --- 74 unchanged lines hidden (view full) --- 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 */ |
|
294/* Section 4.3.4 of draft-rosen-rfc2547bis-03.txt */ 295#define SAFNUM_VPNUNICAST 128 296#define SAFNUM_VPNMULTICAST 129 297#define SAFNUM_VPNUNIMULTICAST 130 298/* draft-marques-ppvpn-rt-constrain-01.txt */ 299#define SAFNUM_RT_ROUTING_INFO 132 300 301#define BGP_VPN_RD_LEN 8 302 303static struct tok bgp_safi_values[] = { 304 { SAFNUM_RES, "Reserved"}, 305 { SAFNUM_UNICAST, "Unicast"}, 306 { SAFNUM_MULTICAST, "Multicast"}, 307 { SAFNUM_UNIMULTICAST, "Unicast+Multicast"}, 308 { SAFNUM_LABUNICAST, "labeled Unicast"}, | 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"}, |
|
309 { SAFNUM_VPNUNICAST, "labeled VPN Unicast"}, 310 { SAFNUM_VPNMULTICAST, "labeled VPN Multicast"}, 311 { SAFNUM_VPNUNIMULTICAST, "labeled VPN Unicast+Multicast"}, | 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 */ |
313 { 0, NULL } 314}; 315 316/* well-known community */ 317#define BGP_COMMUNITY_NO_EXPORT 0xffffff01 318#define BGP_COMMUNITY_NO_ADVERT 0xffffff02 319#define BGP_COMMUNITY_NO_EXPORT_SUBCONFED 0xffffff03 320 --- 41 unchanged lines hidden (view full) --- 362#define BGP_EXT_COM_RT_0 0x0002 /* Route Target,Format AS(2bytes):AN(4bytes) */ 363#define BGP_EXT_COM_RT_1 0x0102 /* Route Target,Format IP address:AN(2bytes) */ 364#define BGP_EXT_COM_RT_2 0x0202 /* Route Target,Format AN(4bytes):local(2bytes) */ 365#define BGP_EXT_COM_RO_0 0x0003 /* Route Origin,Format AS(2bytes):AN(4bytes) */ 366#define BGP_EXT_COM_RO_1 0x0103 /* Route Origin,Format IP address:AN(2bytes) */ 367#define BGP_EXT_COM_RO_2 0x0203 /* Route Origin,Format AN(4bytes):local(2bytes) */ 368#define BGP_EXT_COM_LINKBAND 0x4004 /* Link Bandwidth,Format AS(2B):Bandwidth(4B) */ 369 /* rfc2547 bgp-mpls-vpns */ | 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 --- 41 unchanged lines hidden (view full) --- 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 */ |
|
370 371#define BGP_EXT_COM_VPN_ORIGIN 0x0005 /* OSPF Domain ID / VPN of Origin - draft-rosen-vpns-ospf-bgp-mpls */ 372#define BGP_EXT_COM_VPN_ORIGIN2 0x0105 /* duplicate - keep for backwards compatability */ 373#define BGP_EXT_COM_VPN_ORIGIN3 0x0205 /* duplicate - keep for backwards compatability */ 374#define BGP_EXT_COM_VPN_ORIGIN4 0x8005 /* duplicate - keep for backwards compatability */ 375 376#define BGP_EXT_COM_OSPF_RTYPE 0x0306 /* OSPF Route Type,Format Area(4B):RouteType(1B):Options(1B) */ 377#define BGP_EXT_COM_OSPF_RTYPE2 0x8000 /* duplicate - keep for backwards compatability */ --- 12 unchanged lines hidden (view full) --- 390static struct tok bgp_extd_comm_subtype_values[] = { 391 { BGP_EXT_COM_RT_0, "target"}, 392 { BGP_EXT_COM_RT_1, "target"}, 393 { BGP_EXT_COM_RT_2, "target"}, 394 { BGP_EXT_COM_RO_0, "origin"}, 395 { BGP_EXT_COM_RO_1, "origin"}, 396 { BGP_EXT_COM_RO_2, "origin"}, 397 { BGP_EXT_COM_LINKBAND, "link-BW"}, | 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 */ --- 12 unchanged lines hidden (view full) --- 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"}, |
|
398 { BGP_EXT_COM_VPN_ORIGIN, "ospf-domain"}, 399 { BGP_EXT_COM_VPN_ORIGIN2, "ospf-domain"}, 400 { BGP_EXT_COM_VPN_ORIGIN3, "ospf-domain"}, 401 { BGP_EXT_COM_VPN_ORIGIN4, "ospf-domain"}, 402 { BGP_EXT_COM_OSPF_RTYPE, "ospf-route-type"}, 403 { BGP_EXT_COM_OSPF_RTYPE2, "ospf-route-type"}, 404 { BGP_EXT_COM_OSPF_RID, "ospf-router-id"}, 405 { BGP_EXT_COM_OSPF_RID2, "ospf-router-id"}, --- 15 unchanged lines hidden (view full) --- 421 { BGP_OSPF_RTYPE_NET, "Network" }, 422 { BGP_OSPF_RTYPE_SUM, "Summary" }, 423 { BGP_OSPF_RTYPE_EXT, "External" }, 424 { BGP_OSPF_RTYPE_NSSA,"NSSA External" }, 425 { BGP_OSPF_RTYPE_SHAM,"MPLS-VPN Sham" }, 426 { 0, NULL }, 427}; 428 | 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"}, --- 15 unchanged lines hidden (view full) --- 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 |
448decode_prefix4(const u_char *pptr, char *buf, u_int buflen) 449{ 450 struct in_addr addr; 451 u_int plen; 452 453 TCHECK(pptr[0]); 454 plen = pptr[0]; 455 if (32 < plen) --- 53 unchanged lines hidden (view full) --- 509 510trunc: 511 return -2; 512} 513 514/* RDs and RTs share the same semantics 515 * we use bgp_vpn_rd_print for 516 * printing route targets inside a NLRI */ | 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) --- 53 unchanged lines hidden (view full) --- 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 * |
518bgp_vpn_rd_print (const u_char *pptr) { 519 | 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)")]; |
524 char *pos = rd; 525 526 /* ok lets load the RD format */ 527 switch (EXTRACT_16BITS(pptr)) { 528 529 /* AS:IP-address fmt*/ 530 case 0: 531 snprintf(pos, sizeof(rd) - (pos - rd), "%u:%u.%u.%u.%u", 532 EXTRACT_16BITS(pptr+2), *(pptr+4), *(pptr+5), *(pptr+6), *(pptr+7)); 533 break; 534 /* IP-address:AS fmt*/ 535 536 case 1: 537 snprintf(pos, sizeof(rd) - (pos - rd), "%u.%u.%u.%u:%u", 538 *(pptr+2), *(pptr+3), *(pptr+4), *(pptr+5), EXTRACT_16BITS(pptr+6)); 539 break; 540 541 /* 4-byte-AS:number fmt*/ 542 case 2: | 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)); |
545 break; 546 default: 547 snprintf(pos, sizeof(rd) - (pos - rd), "unknown RD format"); 548 break; 549 } 550 pos += strlen(pos); 551 *(pos) = '\0'; 552 return (rd); --- 115 unchanged lines hidden (view full) --- 668 } 669 return plen+2; 670 671trunc: 672 return -2; 673} 674 675#ifdef INET6 | 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); --- 115 unchanged lines hidden (view full) --- 672 } 673 return plen+2; 674 675trunc: 676 return -2; 677} 678 679#ifdef INET6 |
676static int | 680int |
677decode_prefix6(const u_char *pd, char *buf, u_int buflen) 678{ 679 struct in6_addr addr; 680 u_int plen; 681 682 TCHECK(pd[0]); 683 plen = pd[0]; 684 if (128 < plen) --- 78 unchanged lines hidden (view full) --- 763 return 12 + (plen + 7) / 8; 764 765trunc: 766 return -2; 767} 768#endif 769 770static int | 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) --- 78 unchanged lines hidden (view full) --- 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 |
|
771bgp_attr_print(const struct bgp_attr *attr, const u_char *pptr, int len) 772{ 773 int i; 774 u_int16_t af; 775 u_int8_t safi, snpa; 776 union { /* copy buffer for bandwidth values */ 777 float f; 778 u_int32_t i; 779 } bw; 780 int advance; 781 int tlen; 782 const u_char *tptr; 783 char buf[MAXHOSTNAMELEN + 100]; | 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]; |
|
784 785 tptr = pptr; 786 tlen=len; 787 788 switch (attr->bgpa_type) { 789 case BGPTYPE_ORIGIN: 790 if (len != 1) 791 printf("invalid len"); 792 else { 793 TCHECK(*tptr); | 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))); |
795 } 796 break; | 871 } 872 break; |
873 |
|
797 case BGPTYPE_AS_PATH: 798 if (len % 2) { 799 printf("invalid len"); 800 break; 801 } 802 if (!len) { 803 printf("empty"); 804 break; 805 } 806 807 while (tptr < pptr + len) { 808 TCHECK(tptr[0]); | 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))); |
810 for (i = 0; i < tptr[1] * 2; i += 2) { 811 TCHECK2(tptr[2 + i], 2); 812 printf("%u ", EXTRACT_16BITS(&tptr[2 + i])); 813 } 814 TCHECK(tptr[0]); | 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))); |
816 TCHECK(tptr[1]); 817 tptr += 2 + tptr[1] * 2; 818 } 819 break; 820 case BGPTYPE_NEXT_HOP: 821 if (len != 4) 822 printf("invalid len"); 823 else { --- 76 unchanged lines hidden (view full) --- 900 } 901 break; 902 case BGPTYPE_MP_REACH_NLRI: 903 TCHECK2(tptr[0], 3); 904 af = EXTRACT_16BITS(tptr); 905 safi = tptr[2]; 906 907 printf("\n\t AFI: %s (%u), %sSAFI: %s (%u)", | 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 { --- 76 unchanged lines hidden (view full) --- 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)), |
909 af, 910 (safi>128) ? "vendor specific " : "", /* 128 is meanwhile wellknown */ | 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)), |
912 safi); 913 | 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): |
916#ifdef INET6 | 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): |
919#endif | 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); |
922 if (vflag <= 1) 923 print_unknown_data(tptr,"\n\t ",tlen); | 1028 if (vflag <= 1) 1029 print_unknown_data(tptr,"\n\t ",tlen); |
1030 goto done; |
|
924 break; 925 } 926 927 tptr +=3; 928 929 TCHECK(tptr[0]); 930 tlen = tptr[0]; 931 tptr++; 932 933 if (tlen) { | 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; |
979#ifdef INET6 | 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; |
1022#endif | 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; |
1048 | 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 } |
1059 } 1060 tptr += tlen; 1061 1062 TCHECK(tptr[0]); 1063 snpa = tptr[0]; 1064 tptr++; 1065 1066 if (snpa) { 1067 printf("\n\t %u SNPA", snpa); 1068 for (/*nothing*/; snpa > 0; snpa--) { 1069 TCHECK(tptr[0]); 1070 printf("\n\t %d bytes", tptr[0]); 1071 tptr += tptr[0] + 1; 1072 } 1073 } else { 1074 printf(", no SNPA"); 1075 } 1076 1077 while (len - (tptr - pptr) > 0) { | 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; |
1131#ifdef INET6 | 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; |
1184#endif | 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; |
1220 } | 1309 } |
1310 done: |
|
1221 break; 1222 1223 case BGPTYPE_MP_UNREACH_NLRI: | 1311 break; 1312 1313 case BGPTYPE_MP_UNREACH_NLRI: |
1224 TCHECK2(tptr[0], 3); | 1314 TCHECK2(tptr[0], BGP_MP_NLRI_MINSIZE); |
1225 af = EXTRACT_16BITS(tptr); 1226 safi = tptr[2]; 1227 1228 printf("\n\t AFI: %s (%u), %sSAFI: %s (%u)", | 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)), |
1230 af, 1231 (safi>128) ? "vendor specific " : "", /* 128 is meanwhile wellknown */ | 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)), |
1233 safi); 1234 | 1325 safi); 1326 |
1327 if (len == BGP_MP_NLRI_MINSIZE) 1328 printf("\n\t End-of-Rib Marker (empty NLRI)"); 1329 |
|
1235 tptr += 3; 1236 1237 while (len - (tptr - pptr) > 0) { | 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; |
1283#ifdef INET6 | 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; |
1327#endif | 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; |
1364 } 1365 break; 1366 case BGPTYPE_EXTD_COMMUNITIES: 1367 if (len % 8) { 1368 printf("invalid len"); 1369 break; 1370 } 1371 while (tlen>0) { 1372 u_int16_t extd_comm; 1373 1374 TCHECK2(tptr[0], 2); 1375 extd_comm=EXTRACT_16BITS(tptr); 1376 1377 printf("\n\t %s (0x%04x), Flags [%s]", | 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)), |
1379 extd_comm, 1380 bittok2str(bgp_extd_comm_flag_values, "none", extd_comm)); 1381 1382 TCHECK2(*(tptr+2), 6); 1383 switch(extd_comm) { 1384 case BGP_EXT_COM_RT_0: 1385 case BGP_EXT_COM_RO_0: 1386 printf(": %u:%s", --- 12 unchanged lines hidden (view full) --- 1399 EXTRACT_32BITS(tptr+2), 1400 EXTRACT_16BITS(tptr+6)); 1401 break; 1402 case BGP_EXT_COM_LINKBAND: 1403 bw.i = EXTRACT_32BITS(tptr+2); 1404 printf(": bandwidth: %.3f Mbps", 1405 bw.f*8/1000000); 1406 break; | 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", --- 12 unchanged lines hidden (view full) --- 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; |
|
1407 case BGP_EXT_COM_VPN_ORIGIN: 1408 case BGP_EXT_COM_VPN_ORIGIN2: 1409 case BGP_EXT_COM_VPN_ORIGIN3: 1410 case BGP_EXT_COM_VPN_ORIGIN4: 1411 case BGP_EXT_COM_OSPF_RID: 1412 case BGP_EXT_COM_OSPF_RID2: 1413 printf("%s", getname(tptr+2)); 1414 break; 1415 case BGP_EXT_COM_OSPF_RTYPE: 1416 case BGP_EXT_COM_OSPF_RTYPE2: 1417 printf(": area:%s, router-type:%s, metric-type:%s%s", 1418 getname(tptr+2), | 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)), |
1422 (*(tptr+7) & BGP_OSPF_RTYPE_METRIC_TYPE) ? "E2" : "", 1423 (*(tptr+6) == (BGP_OSPF_RTYPE_EXT ||BGP_OSPF_RTYPE_NSSA )) ? "E1" : ""); 1424 break; 1425 case BGP_EXT_COM_L2INFO: 1426 printf(": %s Control Flags [0x%02x]:MTU %u", | 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)), |
1430 *(tptr+3), 1431 EXTRACT_16BITS(tptr+4)); 1432 break; 1433 default: 1434 print_unknown_data(tptr,"\n\t ",8); 1435 break; 1436 } 1437 tlen -=8; 1438 tptr +=8; 1439 } 1440 break; 1441 | 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 |
|
1442 default: 1443 TCHECK2(*pptr,len); 1444 printf("\n\t no Attribute %u decoder",attr->bgpa_type); /* we have no decoder for the attribute */ 1445 if (vflag <= 1) 1446 print_unknown_data(pptr,"\n\t ",len); 1447 break; 1448 } 1449 if (vflag > 1 && len) /* omit zero length attributes*/ --- 7 unchanged lines hidden (view full) --- 1457static void 1458bgp_open_print(const u_char *dat, int length) 1459{ 1460 struct bgp_open bgpo; 1461 struct bgp_opt bgpopt; 1462 int hlen; 1463 const u_char *opt; 1464 int i,cap_type,cap_len,tcap_len,cap_offset; | 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*/ --- 7 unchanged lines hidden (view full) --- 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]; |
|
1465 1466 TCHECK2(dat[0], BGP_OPEN_SIZE); 1467 memcpy(&bgpo, dat, BGP_OPEN_SIZE); 1468 hlen = ntohs(bgpo.bgpo_len); 1469 1470 printf("\n\t Version %d, ", bgpo.bgpo_version); 1471 printf("my AS %u, ", ntohs(bgpo.bgpo_myas)); 1472 printf("Holdtime %us, ", ntohs(bgpo.bgpo_holdtime)); --- 13 unchanged lines hidden (view full) --- 1486 TCHECK2(opt[i], BGP_OPT_SIZE); 1487 memcpy(&bgpopt, &opt[i], BGP_OPT_SIZE); 1488 if (i + 2 + bgpopt.bgpopt_len > bgpo.bgpo_optlen) { 1489 printf("\n\t Option %d, length: %u", bgpopt.bgpopt_type, bgpopt.bgpopt_len); 1490 break; 1491 } 1492 1493 printf("\n\t Option %s (%u), length: %u", | 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)); --- 13 unchanged lines hidden (view full) --- 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)), |
1495 bgpopt.bgpopt_type, 1496 bgpopt.bgpopt_len); 1497 1498 /* now lets decode the options we know*/ 1499 switch(bgpopt.bgpopt_type) { 1500 case BGP_OPT_CAP: 1501 cap_type=opt[i+BGP_OPT_SIZE]; 1502 cap_len=opt[i+BGP_OPT_SIZE+1]; 1503 tcap_len=cap_len; | 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, |
1506 cap_len); 1507 switch(cap_type) { 1508 case BGP_CAPCODE_MP: 1509 printf("\n\t\tAFI %s (%u), SAFI %s (%u)", | 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)), |
1511 EXTRACT_16BITS(opt+i+BGP_OPT_SIZE+2), | 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)), |
1513 opt[i+BGP_OPT_SIZE+5]); 1514 break; 1515 case BGP_CAPCODE_RESTART: 1516 printf("\n\t\tRestart Flags: [%s], Restart Time %us", 1517 ((opt[i+BGP_OPT_SIZE+2])&0x80) ? "R" : "none", 1518 EXTRACT_16BITS(opt+i+BGP_OPT_SIZE+2)&0xfff); 1519 tcap_len-=2; 1520 cap_offset=4; 1521 while(tcap_len>=4) { 1522 printf("\n\t\t AFI %s (%u), SAFI %s (%u), Forwarding state preserved: %s", | 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)), |
1524 EXTRACT_16BITS(opt+i+BGP_OPT_SIZE+cap_offset), | 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)), |
1526 opt[i+BGP_OPT_SIZE+cap_offset+2], 1527 ((opt[i+BGP_OPT_SIZE+cap_offset+3])&0x80) ? "yes" : "no" ); 1528 tcap_len-=4; 1529 cap_offset+=4; 1530 } 1531 break; 1532 case BGP_CAPCODE_RR: 1533 case BGP_CAPCODE_RR_CISCO: --- 26 unchanged lines hidden (view full) --- 1560bgp_update_print(const u_char *dat, int length) 1561{ 1562 struct bgp bgp; 1563 struct bgp_attr bgpa; 1564 int hlen; 1565 const u_char *p; 1566 int len; 1567 int i; | 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: --- 26 unchanged lines hidden (view full) --- 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]; |
|
1568 1569 TCHECK2(dat[0], BGP_SIZE); 1570 memcpy(&bgp, dat, BGP_SIZE); 1571 hlen = ntohs(bgp.bgp_len); 1572 p = dat + BGP_SIZE; /*XXX*/ 1573 1574 /* Unfeasible routes */ 1575 len = EXTRACT_16BITS(p); --- 27 unchanged lines hidden (view full) --- 1603 } 1604 } 1605#endif 1606 } 1607 p += 2 + len; 1608 1609 TCHECK2(p[0], 2); 1610 len = EXTRACT_16BITS(p); | 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); --- 27 unchanged lines hidden (view full) --- 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 |
|
1611 if (len) { 1612 /* do something more useful!*/ 1613 i = 2; 1614 while (i < 2 + len) { 1615 int alen, aoff; 1616 1617 TCHECK2(p[i], sizeof(bgpa)); 1618 memcpy(&bgpa, &p[i], sizeof(bgpa)); 1619 alen = bgp_attr_len(&bgpa); 1620 aoff = bgp_attr_off(&bgpa); 1621 1622 printf("\n\t %s (%u), length: %u", | 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)), |
1624 bgpa.bgpa_type, 1625 alen); 1626 1627 if (bgpa.bgpa_flags) { 1628 printf(", Flags [%s%s%s%s", 1629 bgpa.bgpa_flags & 0x80 ? "O" : "", 1630 bgpa.bgpa_flags & 0x40 ? "T" : "", 1631 bgpa.bgpa_flags & 0x20 ? "P" : "", 1632 bgpa.bgpa_flags & 0x10 ? "E" : ""); 1633 if (bgpa.bgpa_flags & 0xf) 1634 printf("+%x", bgpa.bgpa_flags & 0xf); 1635 printf("]: "); 1636 } 1637 if (!bgp_attr_print(&bgpa, &p[i + aoff], alen)) 1638 goto trunc; 1639 i += aoff + alen; 1640 } | 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 } |
1642 p += 2 + len; 1643 1644 if (dat + length > p) { 1645 printf("\n\t Updated routes:"); 1646 while (dat + length > p) { 1647 char buf[MAXHOSTNAMELEN + 100]; 1648 i = decode_prefix4(p, buf, sizeof(buf)); 1649 if (i == -1) --- 12 unchanged lines hidden (view full) --- 1662} 1663 1664static void 1665bgp_notification_print(const u_char *dat, int length) 1666{ 1667 struct bgp_notification bgpn; 1668 int hlen; 1669 const u_char *tptr; | 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) --- 12 unchanged lines hidden (view full) --- 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]; |
|
1670 1671 TCHECK2(dat[0], BGP_NOTIFICATION_SIZE); 1672 memcpy(&bgpn, dat, BGP_NOTIFICATION_SIZE); 1673 hlen = ntohs(bgpn.bgpn_len); 1674 1675 /* some little sanity checking */ 1676 if (length<BGP_NOTIFICATION_SIZE) 1677 return; 1678 1679 printf(", %s (%u)", | 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)), |
1681 bgpn.bgpn_major); 1682 1683 switch (bgpn.bgpn_major) { 1684 1685 case BGP_NOTIFY_MAJOR_MSG: 1686 printf(", subcode %s (%u)", | 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)), |
1688 bgpn.bgpn_minor); 1689 break; 1690 case BGP_NOTIFY_MAJOR_OPEN: 1691 printf(", subcode %s (%u)", | 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)), |
1693 bgpn.bgpn_minor); 1694 break; 1695 case BGP_NOTIFY_MAJOR_UPDATE: 1696 printf(", subcode %s (%u)", | 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)), |
1698 bgpn.bgpn_minor); 1699 break; 1700 case BGP_NOTIFY_MAJOR_CAP: 1701 printf(" subcode %s (%u)", | 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)), |
1703 bgpn.bgpn_minor); 1704 case BGP_NOTIFY_MAJOR_CEASE: 1705 printf(", subcode %s (%u)", | 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)), |
1707 bgpn.bgpn_minor); 1708 1709 /* draft-ietf-idr-cease-subcode-02 mentions optionally 7 bytes 1710 * for the maxprefix subtype, which may contain AFI, SAFI and MAXPREFIXES 1711 */ 1712 if(bgpn.bgpn_minor == BGP_NOTIFY_MINOR_CEASE_MAXPRFX && length >= BGP_NOTIFICATION_SIZE + 7) { 1713 tptr = dat + BGP_NOTIFICATION_SIZE; 1714 TCHECK2(*tptr, 7); 1715 printf(", AFI %s (%u), SAFI %s (%u), Max Prefixes: %u", | 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)), |
1717 EXTRACT_16BITS(tptr), | 1878 EXTRACT_16BITS(tptr), |
1718 tok2str(bgp_safi_values, "Unknown", *(tptr+2)), | 1879 tok2strbuf(bgp_safi_values, "Unknown", *(tptr+2), 1880 tokbuf2, sizeof(tokbuf)), |
1719 *(tptr+2), 1720 EXTRACT_32BITS(tptr+3)); 1721 } 1722 break; 1723 default: 1724 break; 1725 } 1726 1727 return; 1728trunc: 1729 printf("[|BGP]"); 1730} 1731 1732static void 1733bgp_route_refresh_print(const u_char *pptr, int len) { 1734 1735 const struct bgp_route_refresh *bgp_route_refresh_header; | 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 |
|
1736 bgp_route_refresh_header = (const struct bgp_route_refresh *)pptr; 1737 1738 printf("\n\t AFI %s (%u), SAFI %s (%u)", | 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)), |
1741 EXTRACT_16BITS(&bgp_route_refresh_header->afi), | 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)), |
1744 bgp_route_refresh_header->safi); 1745 1746 if (vflag > 1) 1747 print_unknown_data(pptr,"\n\t ", len); 1748 1749 return; 1750} 1751 1752static int 1753bgp_header_print(const u_char *dat, int length) 1754{ 1755 struct bgp bgp; | 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]; |
|
1756 1757 TCHECK2(dat[0], BGP_SIZE); 1758 memcpy(&bgp, dat, BGP_SIZE); 1759 printf("\n\t%s Message (%u), length: %u", | 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)), |
1761 bgp.bgp_type, 1762 length); 1763 1764 switch (bgp.bgp_type) { 1765 case BGP_OPEN: 1766 bgp_open_print(dat, length); 1767 break; 1768 case BGP_UPDATE: --- 26 unchanged lines hidden (view full) --- 1795 const u_char *ep; 1796 const u_char *start; 1797 const u_char marker[] = { 1798 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 1799 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 1800 }; 1801 struct bgp bgp; 1802 u_int16_t hlen; | 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: --- 26 unchanged lines hidden (view full) --- 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]; |
|
1803 1804 ep = dat + length; 1805 if (snapend < dat + length) 1806 ep = snapend; 1807 1808 printf(": BGP, length: %u",length); 1809 1810 if (vflag < 1) /* lets be less chatty */ --- 31 unchanged lines hidden (view full) --- 1842 } 1843 1844 if (TTEST2(p[0], hlen)) { 1845 if (!bgp_header_print(p, hlen)) 1846 return; 1847 p += hlen; 1848 start = p; 1849 } else { | 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 */ --- 31 unchanged lines hidden (view full) --- 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))); |
1851 break; 1852 } 1853 } 1854 1855 return; 1856 1857trunc: 1858 printf(" [|BGP]"); 1859} | 2027 break; 2028 } 2029 } 2030 2031 return; 2032 2033trunc: 2034 printf(" [|BGP]"); 2035} |