]> The Tcpdump Group git mirrors - tcpdump/blob - print-bgp.c
projects / tcpdump / blob
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
use strlcpy/cat
[tcpdump] / print-bgp.c
1 /*
2 * Copyright (C) 1999 WIDE Project.
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 * 3. Neither the name of the project nor the names of its contributors
14 * may be used to endorse or promote products derived from this software
15 * without specific prior written permission.
16 *
17 * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
18 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20 * ARE DISCLAIMED. IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
21 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27 * SUCH DAMAGE.
28 *
29 * Extensively modified by Hannes Gredler (hannes@juniper.net) for more
30 * complete BGP support.
31 */
32
33 #ifdef HAVE_CONFIG_H
34 #include "config.h"
35 #endif
36
37 #ifndef lint
38 static const char rcsid[] =
39 "@(#) $Header: /tcpdump/master/tcpdump/print-bgp.c,v 1.70 2003-08-13 02:26:53 itojun 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 "addrtoname.h"
49 #include "extract.h"
50
51 struct 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
58 #define BGP_OPEN 1
59 #define BGP_UPDATE 2
60 #define BGP_NOTIFICATION 3
61 #define BGP_KEEPALIVE 4
62 #define BGP_ROUTE_REFRESH 5
63
64 static struct tok bgp_msg_values[] = {
65 { BGP_OPEN, "Open"},
66 { BGP_UPDATE, "Update"},
67 { BGP_NOTIFICATION, "Notification"},
68 { BGP_KEEPALIVE, "Keepalive"},
69 { BGP_ROUTE_REFRESH, "Route Refresh"},
70 { 0, NULL}
71 };
72
73 struct bgp_open {
74 u_int8_t bgpo_marker[16];
75 u_int16_t bgpo_len;
76 u_int8_t bgpo_type;
77 u_int8_t bgpo_version;
78 u_int16_t bgpo_myas;
79 u_int16_t bgpo_holdtime;
80 u_int32_t bgpo_id;
81 u_int8_t bgpo_optlen;
82 /* options should follow */
83 };
84 #define BGP_OPEN_SIZE 29 /* unaligned */
85
86 struct 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
93 struct 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 */
101
102 struct bgp_route_refresh {
103 u_int8_t bgp_marker[16];
104 u_int16_t len;
105 u_int8_t type;
106 u_int8_t afi[2]; /* the compiler messes this structure up */
107 u_int8_t res; /* when doing misaligned sequences of int8 and int16 */
108 u_int8_t safi; /* afi should be int16 - so we have to access it using */
109 }; /* EXTRACT_16BITS(&bgp_route_refresh->afi) (sigh) */
110 #define BGP_ROUTE_REFRESH_SIZE 23
111
112 struct bgp_attr {
113 u_int8_t bgpa_flags;
114 u_int8_t bgpa_type;
115 union {
116 u_int8_t len;
117 u_int16_t elen;
118 } bgpa_len;
119 #define bgp_attr_len(p) \
120 (((p)->bgpa_flags & 0x10) ? \
121 EXTRACT_16BITS(&(p)->bgpa_len.elen) : (p)->bgpa_len.len)
122 #define bgp_attr_off(p) \
123 (((p)->bgpa_flags & 0x10) ? 4 : 3)
124 };
125
126 #define BGPTYPE_ORIGIN 1
127 #define BGPTYPE_AS_PATH 2
128 #define BGPTYPE_NEXT_HOP 3
129 #define BGPTYPE_MULTI_EXIT_DISC 4
130 #define BGPTYPE_LOCAL_PREF 5
131 #define BGPTYPE_ATOMIC_AGGREGATE 6
132 #define BGPTYPE_AGGREGATOR 7
133 #define BGPTYPE_COMMUNITIES 8 /* RFC1997 */
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 */
142
143 static 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"},
160 { 255, "Reserved for development"},
161 { 0, NULL}
162 };
163
164 #define BGP_OPT_AUTH 1
165 #define BGP_OPT_CAP 2
166
167
168 static struct tok bgp_opt_values[] = {
169 { BGP_OPT_AUTH, "Authentication Information"},
170 { BGP_OPT_CAP, "Capabilities Advertisement"},
171 { 0, NULL}
172 };
173
174 #define BGP_CAPCODE_MP 1
175 #define BGP_CAPCODE_RR 2
176 #define BGP_CAPCODE_RESTART 64 /* draft-ietf-idr-restart-05 */
177 #define BGP_CAPCODE_RR_CISCO 128
178
179 static struct tok bgp_capcode_values[] = {
180 { BGP_CAPCODE_MP, "Multiprotocol Extensions"},
181 { BGP_CAPCODE_RR, "Route Refresh"},
182 { BGP_CAPCODE_RESTART, "Graceful Restart"},
183 { BGP_CAPCODE_RR_CISCO, "Route Refresh (Cisco)"},
184 { 0, NULL}
185 };
186
187 #define BGP_NOTIFY_MAJOR_MSG 1
188 #define BGP_NOTIFY_MAJOR_OPEN 2
189 #define BGP_NOTIFY_MAJOR_UPDATE 3
190 #define BGP_NOTIFY_MAJOR_HOLDTIME 4
191 #define BGP_NOTIFY_MAJOR_FSM 5
192 #define BGP_NOTIFY_MAJOR_CEASE 6
193 #define BGP_NOTIFY_MAJOR_CAP 7
194
195 static struct tok bgp_notify_major_values[] = {
196 { BGP_NOTIFY_MAJOR_MSG, "Message Header Error"},
197 { BGP_NOTIFY_MAJOR_OPEN, "OPEN Message Error"},
198 { BGP_NOTIFY_MAJOR_UPDATE, "UPDATE Message Error"},
199 { BGP_NOTIFY_MAJOR_HOLDTIME,"Hold Timer Expired"},
200 { BGP_NOTIFY_MAJOR_FSM, "Finite State Machine Error"},
201 { BGP_NOTIFY_MAJOR_CEASE, "Cease"},
202 { BGP_NOTIFY_MAJOR_CAP, "Capability Message Error"},
203 { 0, NULL}
204 };
205
206 /* draft-ietf-idr-cease-subcode-02 */
207 #define BGP_NOTIFY_MINOR_CEASE_MAXPRFX 1
208 static struct tok bgp_notify_minor_cease_values[] = {
209 { BGP_NOTIFY_MINOR_CEASE_MAXPRFX, "Maximum Number of Prefixes Reached"},
210 { 2, "Administratively Shutdown"},
211 { 3, "Peer Unconfigured"},
212 { 4, "Administratively Reset"},
213 { 5, "Connection Rejected"},
214 { 6, "Other Configuration Change"},
215 { 7, "Connection Collision Resolution"},
216 { 0, NULL}
217 };
218
219 static struct tok bgp_notify_minor_msg_values[] = {
220 { 1, "Connection Not Synchronized"},
221 { 2, "Bad Message Length"},
222 { 3, "Bad Message Type"},
223 { 0, NULL}
224 };
225
226 static struct tok bgp_notify_minor_open_values[] = {
227 { 1, "Unsupported Version Number"},
228 { 2, "Bad Peer AS"},
229 { 3, "Bad BGP Identifier"},
230 { 4, "Unsupported Optional Parameter"},
231 { 5, "Authentication Failure"},
232 { 6, "Unacceptable Hold Time"},
233 { 0, NULL}
234 };
235
236 static struct tok bgp_notify_minor_update_values[] = {
237 { 1, "Malformed Attribute List"},
238 { 2, "Unrecognized Well-known Attribute"},
239 { 3, "Missing Well-known Attribute"},
240 { 4, "Attribute Flags Error"},
241 { 5, "Attribute Length Error"},
242 { 6, "Invalid ORIGIN Attribute"},
243 { 7, "AS Routing Loop"},
244 { 8, "Invalid NEXT_HOP Attribute"},
245 { 9, "Optional Attribute Error"},
246 { 10, "Invalid Network Field"},
247 { 11, "Malformed AS_PATH"},
248 { 0, NULL}
249 };
250
251 static struct tok bgp_notify_minor_cap_values[] = {
252 { 1, "Invalid Action Value" },
253 { 2, "Invalid Capability Length" },
254 { 3, "Malformed Capability Value" },
255 { 4, "Unsupported Capability Code" },
256 { 0, NULL }
257 };
258
259 static struct tok bgp_origin_values[] = {
260 { 0, "IGP"},
261 { 1, "EGP"},
262 { 2, "Incomplete"},
263 { 0, NULL}
264 };
265
266 /* Subsequent address family identifier, RFC2283 section 7 */
267 #define SAFNUM_RES 0
268 #define SAFNUM_UNICAST 1
269 #define SAFNUM_MULTICAST 2
270 #define SAFNUM_UNIMULTICAST 3
271 /* labeled BGP RFC3107 */
272 #define SAFNUM_LABUNICAST 4
273 /* Section 4.3.4 of draft-rosen-rfc2547bis-03.txt */
274 #define SAFNUM_VPNUNICAST 128
275 #define SAFNUM_VPNMULTICAST 129
276 #define SAFNUM_VPNUNIMULTICAST 130
277
278 #define BGP_VPN_RD_LEN 8
279
280 static struct tok bgp_safi_values[] = {
281 { SAFNUM_RES, "Reserved"},
282 { SAFNUM_UNICAST, "Unicast"},
283 { SAFNUM_MULTICAST, "Multicast"},
284 { SAFNUM_UNIMULTICAST, "Unicast+Multicast"},
285 { SAFNUM_LABUNICAST, "labeled Unicast"},
286 { SAFNUM_VPNUNICAST, "labeled VPN Unicast"},
287 { SAFNUM_VPNMULTICAST, "labeled VPN Multicast"},
288 { SAFNUM_VPNUNIMULTICAST, "labeled VPN Unicast+Multicast"},
289 { 0, NULL }
290 };
291
292 /* well-known community */
293 #define BGP_COMMUNITY_NO_EXPORT 0xffffff01
294 #define BGP_COMMUNITY_NO_ADVERT 0xffffff02
295 #define BGP_COMMUNITY_NO_EXPORT_SUBCONFED 0xffffff03
296
297 /* RFC1700 address family numbers */
298 #define AFNUM_INET 1
299 #define AFNUM_INET6 2
300 #define AFNUM_NSAP 3
301 #define AFNUM_HDLC 4
302 #define AFNUM_BBN1822 5
303 #define AFNUM_802 6
304 #define AFNUM_E163 7
305 #define AFNUM_E164 8
306 #define AFNUM_F69 9
307 #define AFNUM_X121 10
308 #define AFNUM_IPX 11
309 #define AFNUM_ATALK 12
310 #define AFNUM_DECNET 13
311 #define AFNUM_BANYAN 14
312 #define AFNUM_E164NSAP 15
313 /* draft-kompella-ppvpn-l2vpn */
314 #define AFNUM_L2VPN 196 /* still to be approved by IANA */
315
316 static struct tok bgp_afi_values[] = {
317 { 0, "Reserved"},
318 { AFNUM_INET, "IPv4"},
319 { AFNUM_INET6, "IPv6"},
320 { AFNUM_NSAP, "NSAP"},
321 { AFNUM_HDLC, "HDLC"},
322 { AFNUM_BBN1822, "BBN 1822"},
323 { AFNUM_802, "802"},
324 { AFNUM_E163, "E.163"},
325 { AFNUM_E164, "E.164"},
326 { AFNUM_F69, "F.69"},
327 { AFNUM_X121, "X.121"},
328 { AFNUM_IPX, "Novell IPX"},
329 { AFNUM_ATALK, "Appletalk"},
330 { AFNUM_DECNET, "Decnet IV"},
331 { AFNUM_BANYAN, "Banyan Vines"},
332 { AFNUM_E164NSAP, "E.164 with NSAP subaddress"},
333 { AFNUM_L2VPN, "Layer-2 VPN"},
334 { 0, NULL},
335 };
336
337 /* Extended community type - draft-ietf-idr-bgp-ext-communities-05 */
338 #define BGP_EXT_COM_RT_0 0x0002 /* Route Target,Format AS(2bytes):AN(4bytes) */
339 #define BGP_EXT_COM_RT_1 0x0102 /* Route Target,Format IP address:AN(2bytes) */
340 #define BGP_EXT_COM_RT_2 0x0202 /* Route Target,Format AN(4bytes):local(2bytes) */
341 #define BGP_EXT_COM_RO_0 0x0003 /* Route Origin,Format AS(2bytes):AN(4bytes) */
342 #define BGP_EXT_COM_RO_1 0x0103 /* Route Origin,Format IP address:AN(2bytes) */
343 #define BGP_EXT_COM_RO_2 0x0203 /* Route Origin,Format AN(4bytes):local(2bytes) */
344 #define BGP_EXT_COM_LINKBAND 0x4004 /* Link Bandwidth,Format AS(2B):Bandwidth(4B) */
345 /* rfc2547 bgp-mpls-vpns */
346
347 #define BGP_EXT_COM_VPN_ORIGIN 0x0005 /* OSPF Domain ID / VPN of Origin - draft-rosen-vpns-ospf-bgp-mpls */
348 #define BGP_EXT_COM_VPN_ORIGIN2 0x0105 /* duplicate - keep for backwards compatability */
349 #define BGP_EXT_COM_VPN_ORIGIN3 0x0205 /* duplicate - keep for backwards compatability */
350 #define BGP_EXT_COM_VPN_ORIGIN4 0x8005 /* duplicate - keep for backwards compatability */
351
352 #define BGP_EXT_COM_OSPF_RTYPE 0x0306 /* OSPF Route Type,Format Area(4B):RouteType(1B):Options(1B) */
353 #define BGP_EXT_COM_OSPF_RTYPE2 0x8000 /* duplicate - keep for backwards compatability */
354
355 #define BGP_EXT_COM_OSPF_RID 0x0107 /* OSPF Router ID,Format RouterID(4B):Unused(2B) */
356 #define BGP_EXT_COM_OSPF_RID2 0x8001 /* duplicate - keep for backwards compatability */
357
358 #define BGP_EXT_COM_L2INFO 0x800a /* draft-kompella-ppvpn-l2vpn */
359
360 static struct tok bgp_extd_comm_flag_values[] = {
361 { 0x8000, "vendor-specific"},
362 { 0x4000, "non-transitive"},
363 { 0, NULL},
364 };
365
366 static struct tok bgp_extd_comm_subtype_values[] = {
367 { BGP_EXT_COM_RT_0, "target"},
368 { BGP_EXT_COM_RT_1, "target"},
369 { BGP_EXT_COM_RT_2, "target"},
370 { BGP_EXT_COM_RO_0, "origin"},
371 { BGP_EXT_COM_RO_1, "origin"},
372 { BGP_EXT_COM_RO_2, "origin"},
373 { BGP_EXT_COM_LINKBAND, "link-BW"},
374 { BGP_EXT_COM_VPN_ORIGIN, "ospf-domain"},
375 { BGP_EXT_COM_VPN_ORIGIN2, "ospf-domain"},
376 { BGP_EXT_COM_VPN_ORIGIN3, "ospf-domain"},
377 { BGP_EXT_COM_VPN_ORIGIN4, "ospf-domain"},
378 { BGP_EXT_COM_OSPF_RTYPE, "ospf-route-type"},
379 { BGP_EXT_COM_OSPF_RTYPE2, "ospf-route-type"},
380 { BGP_EXT_COM_OSPF_RID, "ospf-router-id"},
381 { BGP_EXT_COM_OSPF_RID2, "ospf-router-id"},
382 { BGP_EXT_COM_L2INFO, "layer2-info"},
383 { 0, NULL},
384 };
385
386 /* OSPF codes for BGP_EXT_COM_OSPF_RTYPE draft-rosen-vpns-ospf-bgp-mpls */
387 #define BGP_OSPF_RTYPE_RTR 1 /* OSPF Router LSA */
388 #define BGP_OSPF_RTYPE_NET 2 /* OSPF Network LSA */
389 #define BGP_OSPF_RTYPE_SUM 3 /* OSPF Summary LSA */
390 #define BGP_OSPF_RTYPE_EXT 5 /* OSPF External LSA, note that ASBR doesn't apply to MPLS-VPN */
391 #define BGP_OSPF_RTYPE_NSSA 7 /* OSPF NSSA External*/
392 #define BGP_OSPF_RTYPE_SHAM 129 /* OSPF-MPLS-VPN Sham link */
393 #define BGP_OSPF_RTYPE_METRIC_TYPE 0x1 /* LSB of RTYPE Options Field */
394
395 static struct tok bgp_extd_comm_ospf_rtype_values[] = {
396 { BGP_OSPF_RTYPE_RTR, "Router" },
397 { BGP_OSPF_RTYPE_NET, "Network" },
398 { BGP_OSPF_RTYPE_SUM, "Summary" },
399 { BGP_OSPF_RTYPE_EXT, "External" },
400 { BGP_OSPF_RTYPE_NSSA,"NSSA External" },
401 { BGP_OSPF_RTYPE_SHAM,"MPLS-VPN Sham" },
402 { 0, NULL },
403 };
404
405 static struct tok bgp_l2vpn_encaps_values[] = {
406 { 0, "Reserved"},
407 { 1, "Frame Relay"},
408 { 2, "ATM AAL5 VCC transport"},
409 { 3, "ATM transparent cell transport"},
410 { 4, "Ethernet VLAN"},
411 { 5, "Ethernet"},
412 { 6, "Cisco-HDLC"},
413 { 7, "PPP"},
414 { 8, "CEM"},
415 { 9, "ATM VCC cell transport"},
416 { 10, "ATM VPC cell transport"},
417 { 11, "MPLS"},
418 { 12, "VPLS"},
419 { 64, "IP-interworking"},
420 { 0, NULL},
421 };
422
423 static int
424 decode_prefix4(const u_char *pptr, char *buf, u_int buflen)
425 {
426 struct in_addr addr;
427 u_int plen;
428
429 plen = pptr[0];
430 if (32 < plen)
431 return -1;
432
433 memset(&addr, 0, sizeof(addr));
434 memcpy(&addr, &pptr[1], (plen + 7) / 8);
435 if (plen % 8) {
436 ((u_char *)&addr)[(plen + 7) / 8 - 1] &=
437 ((0xff00 >> (plen % 8)) & 0xff);
438 }
439 snprintf(buf, buflen, "%s/%d", getname((u_char *)&addr), plen);
440 return 1 + (plen + 7) / 8;
441 }
442
443 static int
444 decode_labeled_prefix4(const u_char *pptr, char *buf, u_int buflen)
445 {
446 struct in_addr addr;
447 u_int plen;
448
449 plen = pptr[0]; /* get prefix length */
450
451 /* this is one of the weirdnesses of rfc3107
452 the label length (actually the label + COS bits)
453 is added to the prefix length;
454 we also do only read out just one label -
455 there is no real application for advertisement of
456 stacked labels in a a single BGP message
457 */
458
459 plen-=24; /* adjust prefixlen - labellength */
460
461 if (32 < plen)
462 return -1;
463
464 memset(&addr, 0, sizeof(addr));
465 memcpy(&addr, &pptr[4], (plen + 7) / 8);
466 if (plen % 8) {
467 ((u_char *)&addr)[(plen + 7) / 8 - 1] &=
468 ((0xff00 >> (plen % 8)) & 0xff);
469 }
470 /* the label may get offsetted by 4 bits so lets shift it right */
471 snprintf(buf, buflen, "%s/%d, label:%u %s",
472 getname((u_char *)&addr),
473 plen,
474 EXTRACT_24BITS(pptr+1)>>4,
475 ((pptr[3]&1)==0) ? "(BOGUS: Bottom of Stack NOT set!)" : "(bottom)" );
476
477 return 4 + (plen + 7) / 8;
478 }
479
480 static char *
481 bgp_vpn_rd_print (const u_char *pptr) {
482
483 /* allocate space for the following string
484 * xxx.xxx.xxx.xxx:xxxxx
485 * 21 bytes plus one termination byte */
486 static char rd[22];
487 char *pos = rd;
488
489 /* ok lets load the RD format */
490 switch (EXTRACT_16BITS(pptr)) {
491 /* AS:IP-address fmt*/
492 case 0:
493 snprintf(pos, sizeof(rd) - (pos - rd), "%u:%u.%u.%u.%u",
494 EXTRACT_16BITS(pptr+2), *(pptr+4), *(pptr+5), *(pptr+6), *(pptr+7));
495 break;
496 /* IP-address:AS fmt*/
497 case 1:
498 snprintf(pos, sizeof(rd) - (pos - rd), "%u.%u.%u.%u:%u",
499 *(pptr+2), *(pptr+3), *(pptr+4), *(pptr+5), EXTRACT_16BITS(pptr+6));
500 break;
501 default:
502 snprintf(pos, sizeof(rd) - (pos - rd), "unknown RD format");
503 break;
504 }
505 pos += strlen(pos);
506 *(pos) = '\0';
507 return (rd);
508 }
509
510 static int
511 decode_labeled_vpn_prefix4(const u_char *pptr, char *buf, u_int buflen)
512 {
513 struct in_addr addr;
514 u_int plen;
515
516 plen = pptr[0]; /* get prefix length */
517
518 plen-=(24+64); /* adjust prefixlen - labellength - RD len*/
519
520 if (32 < plen)
521 return -1;
522
523 memset(&addr, 0, sizeof(addr));
524 memcpy(&addr, &pptr[12], (plen + 7) / 8);
525 if (plen % 8) {
526 ((u_char *)&addr)[(plen + 7) / 8 - 1] &=
527 ((0xff00 >> (plen % 8)) & 0xff);
528 }
529 /* the label may get offsetted by 4 bits so lets shift it right */
530 snprintf(buf, buflen, "RD: %s, %s/%d, label:%u %s",
531 bgp_vpn_rd_print(pptr+4),
532 getname((u_char *)&addr),
533 plen,
534 EXTRACT_24BITS(pptr+1)>>4,
535 ((pptr[3]&1)==0) ? "(BOGUS: Bottom of Stack NOT set!)" : "(bottom)" );
536
537 return 12 + (plen + 7) / 8;
538 }
539
540 static int
541 decode_labeled_vpn_l2(const u_char *pptr, char *buf, u_int buflen)
542 {
543 int plen,tlen,strlen,tlv_type,tlv_len,ttlv_len;
544 plen=EXTRACT_16BITS(pptr);
545 tlen=plen;
546 pptr+=2;
547 strlen=snprintf(buf, buflen, "RD: %s, CE-ID: %u, Label-Block Offset: %u, Label Base %u",
548 bgp_vpn_rd_print(pptr),
549 EXTRACT_16BITS(pptr+8),
550 EXTRACT_16BITS(pptr+10),
551 EXTRACT_24BITS(pptr+12)>>4); /* the label is offsetted by 4 bits so lets shift it right */
552 pptr+=15;
553 tlen-=15;
554
555 /* ok now the variable part - lets read out TLVs*/
556 while (tlen>0) {
557 tlv_type=*pptr++;
558 tlv_len=EXTRACT_16BITS(pptr);
559 ttlv_len=tlv_len;
560 pptr+=2;
561
562 switch(tlv_type) {
563 case 1:
564 strlen+=snprintf(buf+strlen,buflen-strlen, "\n\t\tcircuit status vector (%u) length: %u: 0x",
565 tlv_type,
566 tlv_len);
567 ttlv_len=ttlv_len/8+1; /* how many bytes do we need to read ? */
568 while (ttlv_len>0) {
569 strlen+=snprintf(buf+strlen,buflen-strlen, "%02x",*pptr++);
570 ttlv_len--;
571 }
572 break;
573 default:
574 snprintf(buf+strlen,buflen-strlen, "\n\t\tunknown TLV #%u, length: %u",
575 tlv_type,
576 tlv_len);
577 break;
578 }
579 tlen-=(tlv_len<<3); /* the tlv-length is expressed in bits so lets shift it tright */
580 }
581 return plen+2;
582 }
583
584 #ifdef INET6
585 static int
586 decode_prefix6(const u_char *pd, char *buf, u_int buflen)
587 {
588 struct in6_addr addr;
589 u_int plen;
590
591 plen = pd[0];
592 if (128 < plen)
593 return -1;
594
595 memset(&addr, 0, sizeof(addr));
596 memcpy(&addr, &pd[1], (plen + 7) / 8);
597 if (plen % 8) {
598 addr.s6_addr[(plen + 7) / 8 - 1] &=
599 ((0xff00 >> (plen % 8)) & 0xff);
600 }
601 snprintf(buf, buflen, "%s/%d", getname6((u_char *)&addr), plen);
602 return 1 + (plen + 7) / 8;
603 }
604
605 static int
606 decode_labeled_prefix6(const u_char *pptr, char *buf, u_int buflen)
607 {
608 struct in6_addr addr;
609 u_int plen;
610
611 plen = pptr[0]; /* get prefix length */
612 plen-=24; /* adjust prefixlen - labellength */
613
614 if (128 < plen)
615 return -1;
616
617 memset(&addr, 0, sizeof(addr));
618 memcpy(&addr, &pptr[4], (plen + 7) / 8);
619 if (plen % 8) {
620 addr.s6_addr[(plen + 7) / 8 - 1] &=
621 ((0xff00 >> (plen % 8)) & 0xff);
622 }
623 /* the label may get offsetted by 4 bits so lets shift it right */
624 snprintf(buf, buflen, "%s/%d, label:%u %s",
625 getname6((u_char *)&addr),
626 plen,
627 EXTRACT_24BITS(pptr+1)>>4,
628 ((pptr[3]&1)==0) ? "(BOGUS: Bottom of Stack NOT set!)" : "(bottom)" );
629
630 return 4 + (plen + 7) / 8;
631 }
632
633 static int
634 decode_labeled_vpn_prefix6(const u_char *pptr, char *buf, u_int buflen)
635 {
636 struct in6_addr addr;
637 u_int plen;
638
639 plen = pptr[0]; /* get prefix length */
640
641 plen-=(24+64); /* adjust prefixlen - labellength - RD len*/
642
643 if (128 < plen)
644 return -1;
645
646 memset(&addr, 0, sizeof(addr));
647 memcpy(&addr, &pptr[12], (plen + 7) / 8);
648 if (plen % 8) {
649 addr.s6_addr[(plen + 7) / 8 - 1] &=
650 ((0xff00 >> (plen % 8)) & 0xff);
651 }
652 /* the label may get offsetted by 4 bits so lets shift it right */
653 snprintf(buf, buflen, "RD: %s, %s/%d, label:%u %s",
654 bgp_vpn_rd_print(pptr+4),
655 getname6((u_char *)&addr),
656 plen,
657 EXTRACT_24BITS(pptr+1)>>4,
658 ((pptr[3]&1)==0) ? "(BOGUS: Bottom of Stack NOT set!)" : "(bottom)" );
659
660 return 12 + (plen + 7) / 8;
661 }
662 #endif
663
664 static void
665 bgp_attr_print(const struct bgp_attr *attr, const u_char *pptr, int len)
666 {
667 int i;
668 u_int16_t af;
669 u_int8_t safi, snpa;
670 union { /* copy buffer for bandwidth values */
671 float f;
672 u_int32_t i;
673 } bw;
674 int advance;
675 int tlen;
676 const u_char *tptr;
677 char buf[MAXHOSTNAMELEN + 100];
678
679 tptr = pptr;
680 tlen=len;
681
682 switch (attr->bgpa_type) {
683 case BGPTYPE_ORIGIN:
684 if (len != 1)
685 printf("invalid len");
686 else
687 printf("%s", tok2str(bgp_origin_values, "Unknown Origin Typecode", tptr[0]));
688 break;
689 case BGPTYPE_AS_PATH:
690 if (len % 2) {
691 printf("invalid len");
692 break;
693 }
694 if (!len) {
695 printf("empty");
696 break;
697 }
698 while (tptr < pptr + len) {
699 /*
700 * under RFC1965, p[0] means:
701 * 1: AS_SET 2: AS_SEQUENCE
702 * 3: AS_CONFED_SET 4: AS_CONFED_SEQUENCE
703 */
704 if (tptr[0] == 3 || tptr[0] == 4)
705 printf("confed");
706 printf("%s", (tptr[0] & 1) ? "{" : "");
707 for (i = 0; i < tptr[1] * 2; i += 2) {
708 printf("%s%u", i == 0 ? "" : " ",
709 EXTRACT_16BITS(&tptr[2 + i]));
710 }
711 printf("%s", (tptr[0] & 1) ? "}" : "");
712 tptr += 2 + tptr[1] * 2;
713 }
714 break;
715 case BGPTYPE_NEXT_HOP:
716 if (len != 4)
717 printf("invalid len");
718 else
719 printf("%s", getname(tptr));
720 break;
721 case BGPTYPE_MULTI_EXIT_DISC:
722 case BGPTYPE_LOCAL_PREF:
723 if (len != 4)
724 printf("invalid len");
725 else
726 printf("%u", EXTRACT_32BITS(tptr));
727 break;
728 case BGPTYPE_ATOMIC_AGGREGATE:
729 if (len != 0)
730 printf("invalid len");
731 break;
732 case BGPTYPE_AGGREGATOR:
733 if (len != 6) {
734 printf("invalid len");
735 break;
736 }
737 printf(" AS #%u, origin %s", EXTRACT_16BITS(tptr),
738 getname(tptr + 2));
739 break;
740 case BGPTYPE_COMMUNITIES:
741 if (len % 4) {
742 printf("invalid len");
743 break;
744 }
745 while (tlen>0) {
746 u_int32_t comm;
747 comm = EXTRACT_32BITS(tptr);
748 switch (comm) {
749 case BGP_COMMUNITY_NO_EXPORT:
750 printf(" NO_EXPORT");
751 break;
752 case BGP_COMMUNITY_NO_ADVERT:
753 printf(" NO_ADVERTISE");
754 break;
755 case BGP_COMMUNITY_NO_EXPORT_SUBCONFED:
756 printf(" NO_EXPORT_SUBCONFED");
757 break;
758 default:
759 printf("%u:%u%s",
760 (comm >> 16) & 0xffff,
761 comm & 0xffff,
762 (tlen>4) ? ", " : "");
763 break;
764 }
765 tlen -=4;
766 tptr +=4;
767 }
768 break;
769 case BGPTYPE_ORIGINATOR_ID:
770 if (len != 4) {
771 printf("invalid len");
772 break;
773 }
774 printf("%s",getname(tptr));
775 break;
776 case BGPTYPE_CLUSTER_LIST:
777 while (tlen>0) {
778 printf("%s%s",
779 getname(tptr),
780 (tlen>4) ? ", " : "");
781 tlen -=4;
782 tptr +=4;
783 }
784 break;
785 case BGPTYPE_MP_REACH_NLRI:
786 af = EXTRACT_16BITS(tptr);
787 safi = tptr[2];
788
789 printf("\n\t AFI: %s (%u), %sSAFI: %s (%u)",
790 tok2str(bgp_afi_values, "Unknown AFI", af),
791 af,
792 (safi>128) ? "vendor specific " : "", /* 128 is meanwhile wellknown */
793 tok2str(bgp_safi_values, "Unknown SAFI", safi),
794 safi);
795
796 if (af == AFNUM_INET || af==AFNUM_L2VPN)
797 ;
798 #ifdef INET6
799 else if (af == AFNUM_INET6)
800 ;
801 #endif
802 else {
803 printf("\n\t no AFI %u decoder",af);
804 if (vflag <= 1)
805 print_unknown_data(tptr,"\n\t ",tlen);
806 break;
807 }
808
809 tptr +=3;
810
811 tlen = tptr[0];
812 tptr++;
813
814 if (tlen) {
815 printf("\n\t nexthop: ");
816 while (tlen > 0) {
817 switch (af) {
818 case AFNUM_INET:
819 switch(safi) {
820 case SAFNUM_UNICAST:
821 case SAFNUM_MULTICAST:
822 case SAFNUM_UNIMULTICAST:
823 case SAFNUM_LABUNICAST:
824 printf("%s",getname(tptr));
825 tlen -= sizeof(struct in_addr);
826 tptr += sizeof(struct in_addr);
827 break;
828 case SAFNUM_VPNUNICAST:
829 case SAFNUM_VPNMULTICAST:
830 case SAFNUM_VPNUNIMULTICAST:
831 printf("RD: %s, %s",
832 bgp_vpn_rd_print(tptr),
833 getname(tptr+BGP_VPN_RD_LEN));
834 tlen -= (sizeof(struct in_addr)+BGP_VPN_RD_LEN);
835 tptr += (sizeof(struct in_addr)+BGP_VPN_RD_LEN);
836 break;
837 default:
838 printf("no SAFI %u decoder",safi);
839 if (vflag <= 1)
840 print_unknown_data(tptr,"\n\t ",tlen);
841 break;
842 }
843 break;
844 #ifdef INET6
845 case AFNUM_INET6:
846 switch(safi) {
847 case SAFNUM_UNICAST:
848 case SAFNUM_MULTICAST:
849 case SAFNUM_UNIMULTICAST:
850 case SAFNUM_LABUNICAST:
851 printf("%s", getname6(tptr));
852 tlen -= sizeof(struct in6_addr);
853 tptr += sizeof(struct in6_addr);
854 break;
855 case SAFNUM_VPNUNICAST:
856 case SAFNUM_VPNMULTICAST:
857 case SAFNUM_VPNUNIMULTICAST:
858 printf("RD: %s, %s",
859 bgp_vpn_rd_print(tptr),
860 getname6(tptr+BGP_VPN_RD_LEN));
861 tlen -= (sizeof(struct in6_addr)+BGP_VPN_RD_LEN);
862 tptr += (sizeof(struct in6_addr)+BGP_VPN_RD_LEN);
863 break;
864 default:
865 printf("no SAFI %u decoder",safi);
866 if (vflag <= 1)
867 print_unknown_data(tptr,"\n\t ",tlen);
868 break;
869 }
870 break;
871 #endif
872 case AFNUM_L2VPN:
873 switch(safi) {
874 case SAFNUM_VPNUNICAST:
875 case SAFNUM_VPNMULTICAST:
876 case SAFNUM_VPNUNIMULTICAST:
877 printf("%s", getname(tptr));
878 tlen -= (sizeof(struct in_addr));
879 tptr += (sizeof(struct in_addr));
880 break;
881 default:
882 printf("no SAFI %u decoder",safi);
883 if (vflag <= 1)
884 print_unknown_data(tptr,"\n\t ",tlen);
885 break;
886 }
887 break;
888
889 default:
890 printf("no AFI %u decoder",af);
891 if (vflag <= 1)
892 print_unknown_data(tptr,"\n\t ",tlen);
893 break;
894 }
895 }
896 }
897 tptr += tlen;
898
899 snpa = tptr[0];
900 tptr++;
901
902 if (snpa) {
903 printf("\n\t %u SNPA", snpa);
904 for (/*nothing*/; snpa > 0; snpa--) {
905 printf("\n\t %d bytes", tptr[0]);
906 tptr += tptr[0] + 1;
907 }
908 } else {
909 printf(", no SNPA");
910 }
911
912 while (len - (tptr - pptr) > 0) {
913 switch (af) {
914 case AFNUM_INET:
915 switch (safi) {
916 case SAFNUM_UNICAST:
917 case SAFNUM_MULTICAST:
918 case SAFNUM_UNIMULTICAST:
919 advance = decode_prefix4(tptr, buf, sizeof(buf));
920 if (advance >= 0)
921 printf("\n\t %s", buf);
922 else
923 printf("\n\t (illegal prefix length)");
924 break;
925 case SAFNUM_LABUNICAST:
926 advance = decode_labeled_prefix4(tptr, buf, sizeof(buf));
927 printf("\n\t %s", buf);
928 break;
929 case SAFNUM_VPNUNICAST:
930 case SAFNUM_VPNMULTICAST:
931 case SAFNUM_VPNUNIMULTICAST:
932 advance = decode_labeled_vpn_prefix4(tptr, buf, sizeof(buf));
933 printf("\n\t %s", buf);
934 break;
935 default:
936 printf("\n\t no SAFI %u decoder",safi);
937 if (vflag <= 1)
938 print_unknown_data(tptr-3,"\n\t ",tlen);
939 advance = 0;
940 tptr = pptr + len;
941 break;
942 }
943 break;
944 #ifdef INET6
945 case AFNUM_INET6:
946 switch (safi) {
947 case SAFNUM_UNICAST:
948 case SAFNUM_MULTICAST:
949 case SAFNUM_UNIMULTICAST:
950 advance = decode_prefix6(tptr, buf, sizeof(buf));
951 printf("\n\t %s", buf);
952 break;
953 case SAFNUM_LABUNICAST:
954 advance = decode_labeled_prefix6(tptr, buf, sizeof(buf));
955 printf("\n\t %s", buf);
956 break;
957 case SAFNUM_VPNUNICAST:
958 case SAFNUM_VPNMULTICAST:
959 case SAFNUM_VPNUNIMULTICAST:
960 advance = decode_labeled_vpn_prefix6(tptr, buf, sizeof(buf));
961 printf("\n\t %s", buf);
962 break;
963 default:
964 printf("\n\t no SAFI %u decoder ",safi);
965 if (vflag <= 1)
966 print_unknown_data(tptr-3,"\n\t ",tlen);
967 advance = 0;
968 tptr = pptr + len;
969 break;
970 }
971 break;
972 #endif
973 case AFNUM_L2VPN:
974 switch(safi) {
975 case SAFNUM_VPNUNICAST:
976 case SAFNUM_VPNMULTICAST:
977 case SAFNUM_VPNUNIMULTICAST:
978 advance = decode_labeled_vpn_l2(tptr, buf, sizeof(buf));
979 printf("\n\t %s", buf);
980 break;
981 default:
982 printf("no SAFI %u decoder",safi);
983 if (vflag <= 1)
984 print_unknown_data(tptr,"\n\t ",tlen);
985 advance = 0;
986 tptr = pptr + len;
987 break;
988 }
989 break;
990
991
992 default:
993 printf("\n\t no AFI %u decoder ",af);
994 if (vflag <= 1)
995 print_unknown_data(tptr-3,"\n\t ",tlen);
996 advance = 0;
997 tptr = pptr + len;
998 break;
999 }
1000 tptr += advance;
1001 }
1002 break;
1003
1004 case BGPTYPE_MP_UNREACH_NLRI:
1005 af = EXTRACT_16BITS(tptr);
1006 safi = tptr[2];
1007
1008 printf("\n\t AFI: %s (%u), %sSAFI: %s (%u)",
1009 tok2str(bgp_afi_values, "Unknown AFI", af),
1010 af,
1011 (safi>128) ? "vendor specific " : "", /* 128 is meanwhile wellknown */
1012 tok2str(bgp_safi_values, "Unknown SAFI", safi),
1013 safi);
1014
1015 tptr += 3;
1016
1017 while (len - (tptr - pptr) > 0) {
1018 switch (af) {
1019 case AFNUM_INET:
1020 switch (safi) {
1021 case SAFNUM_UNICAST:
1022 case SAFNUM_MULTICAST:
1023 case SAFNUM_UNIMULTICAST:
1024 advance = decode_prefix4(tptr, buf, sizeof(buf));
1025 if (advance >= 0)
1026 printf("\n\t %s", buf);
1027 else
1028 printf("\n\t (illegal prefix length)");
1029 break;
1030 case SAFNUM_LABUNICAST:
1031 advance = decode_labeled_prefix4(tptr, buf, sizeof(buf));
1032 printf("\n\t %s", buf);
1033 break;
1034 case SAFNUM_VPNUNICAST:
1035 case SAFNUM_VPNMULTICAST:
1036 case SAFNUM_VPNUNIMULTICAST:
1037 advance = decode_labeled_vpn_prefix4(tptr, buf, sizeof(buf));
1038 printf("\n\t %s", buf);
1039 break;
1040 default:
1041 printf("\n\t no SAFI %u decoder",safi);
1042 if (vflag <= 1)
1043 print_unknown_data(tptr-3,"\n\t ",tlen);
1044 advance = 0;
1045 tptr = pptr + len;
1046 break;
1047 }
1048 break;
1049
1050 #ifdef INET6
1051 case AFNUM_INET6:
1052 switch (safi) {
1053 case SAFNUM_UNICAST:
1054 case SAFNUM_MULTICAST:
1055 case SAFNUM_UNIMULTICAST:
1056 advance = decode_prefix6(tptr, buf, sizeof(buf));
1057 printf("\n\t %s", buf);
1058 break;
1059 case SAFNUM_LABUNICAST:
1060 advance = decode_labeled_prefix6(tptr, buf, sizeof(buf));
1061 printf("\n\t %s", buf);
1062 break;
1063 case SAFNUM_VPNUNICAST:
1064 case SAFNUM_VPNMULTICAST:
1065 case SAFNUM_VPNUNIMULTICAST:
1066 advance = decode_labeled_vpn_prefix6(tptr, buf, sizeof(buf));
1067 printf("\n\t %s", buf);
1068 break;
1069 default:
1070 printf("\n\t no SAFI %u decoder",safi);
1071 if (vflag <= 1)
1072 print_unknown_data(tptr-3,"\n\t ",tlen);
1073 advance = 0;
1074 tptr = pptr + len;
1075 break;
1076 }
1077 break;
1078 #endif
1079
1080 case AFNUM_L2VPN:
1081 switch(safi) {
1082 case SAFNUM_VPNUNICAST:
1083 case SAFNUM_VPNMULTICAST:
1084 case SAFNUM_VPNUNIMULTICAST:
1085 advance = decode_labeled_vpn_l2(tptr, buf, sizeof(buf));
1086 printf("\n\t %s", buf);
1087 break;
1088 default:
1089 printf("no SAFI %u decoder",safi);
1090 if (vflag <= 1)
1091 print_unknown_data(tptr-3,"\n\t ",tlen);
1092 advance = 0;
1093 tptr = pptr + len;
1094 break;
1095 }
1096 break;
1097
1098 default:
1099 printf("\n\t no AFI %u decoder",af);
1100 if (vflag <= 1)
1101 print_unknown_data(tptr-3,"\n\t ",tlen);
1102 advance = 0;
1103 tptr = pptr + len;
1104 break;
1105 }
1106
1107 tptr += advance;
1108 }
1109 break;
1110 case BGPTYPE_EXTD_COMMUNITIES:
1111 if (len % 8) {
1112 printf("invalid len");
1113 break;
1114 }
1115 while (tlen>0) {
1116 u_int16_t extd_comm;
1117 extd_comm=EXTRACT_16BITS(tptr);
1118
1119 printf("\n\t %s (0x%04x), Flags [%s]",
1120 tok2str(bgp_extd_comm_subtype_values, "unknown extd community typecode", extd_comm),
1121 extd_comm,
1122 bittok2str(bgp_extd_comm_flag_values, "none", extd_comm));
1123
1124 switch(extd_comm) {
1125 case BGP_EXT_COM_RT_0:
1126 case BGP_EXT_COM_RO_0:
1127 printf(": %u:%s",
1128 EXTRACT_16BITS(tptr+2),
1129 getname(tptr+4));
1130 break;
1131 case BGP_EXT_COM_RT_1:
1132 case BGP_EXT_COM_RO_1:
1133 printf(": %s:%u",
1134 getname(tptr+2),
1135 EXTRACT_16BITS(tptr+6));
1136 break;
1137 case BGP_EXT_COM_RT_2:
1138 case BGP_EXT_COM_RO_2:
1139 printf(": %u:%u",
1140 EXTRACT_32BITS(tptr+2),
1141 EXTRACT_16BITS(tptr+6));
1142 break;
1143 case BGP_EXT_COM_LINKBAND:
1144 bw.i = EXTRACT_32BITS(tptr+2);
1145 printf(": bandwidth: %.3f Mbps",
1146 bw.f*8/1000000);
1147 break;
1148 case BGP_EXT_COM_VPN_ORIGIN:
1149 case BGP_EXT_COM_VPN_ORIGIN2:
1150 case BGP_EXT_COM_VPN_ORIGIN3:
1151 case BGP_EXT_COM_VPN_ORIGIN4:
1152 case BGP_EXT_COM_OSPF_RID:
1153 case BGP_EXT_COM_OSPF_RID2:
1154 printf("%s", getname(tptr+2));
1155 break;
1156 case BGP_EXT_COM_OSPF_RTYPE:
1157 case BGP_EXT_COM_OSPF_RTYPE2:
1158 printf(": area:%s, router-type:%s, metric-type:%s%s",
1159 getname(tptr+2),
1160 tok2str(bgp_extd_comm_ospf_rtype_values,
1161 "unknown (0x%02x)",
1162 *(tptr+6)),
1163 (*(tptr+7) & BGP_OSPF_RTYPE_METRIC_TYPE) ? "E2" : "",
1164 (*(tptr+6) == (BGP_OSPF_RTYPE_EXT ||BGP_OSPF_RTYPE_NSSA )) ? "E1" : "");
1165 break;
1166 case BGP_EXT_COM_L2INFO:
1167 printf(": %s Control Flags [0x%02x]:MTU %u",
1168 tok2str(bgp_l2vpn_encaps_values,
1169 "unknown encaps",
1170 *(tptr+2)),
1171 *(tptr+3),
1172 EXTRACT_16BITS(tptr+4));
1173 break;
1174 default:
1175 print_unknown_data(tptr,"\n\t ",8);
1176 break;
1177 }
1178 tlen -=8;
1179 tptr +=8;
1180 }
1181 break;
1182
1183 default:
1184 printf("\n\t no Attribute %u decoder",attr->bgpa_type); /* we have no decoder for the attribute */
1185 if (vflag <= 1)
1186 print_unknown_data(pptr,"\n\t ",len);
1187 break;
1188 }
1189 if (vflag > 1 && len) /* omit zero length attributes*/
1190 print_unknown_data(pptr,"\n\t ",len);
1191 }
1192
1193 static void
1194 bgp_open_print(const u_char *dat, int length)
1195 {
1196 struct bgp_open bgpo;
1197 struct bgp_opt bgpopt;
1198 int hlen;
1199 const u_char *opt;
1200 int i,cap_type,cap_len,tcap_len,cap_offset;
1201
1202 TCHECK2(dat[0], BGP_OPEN_SIZE);
1203 memcpy(&bgpo, dat, BGP_OPEN_SIZE);
1204 hlen = ntohs(bgpo.bgpo_len);
1205
1206 printf("\n\t Version %d, ", bgpo.bgpo_version);
1207 printf("my AS %u, ", ntohs(bgpo.bgpo_myas));
1208 printf("Holdtime %us, ", ntohs(bgpo.bgpo_holdtime));
1209 printf("ID %s", getname((u_char *)&bgpo.bgpo_id));
1210 printf("\n\t Optional parameters, length: %u", bgpo.bgpo_optlen);
1211
1212 /* some little sanity checking */
1213 if (length < bgpo.bgpo_optlen+BGP_OPEN_SIZE)
1214 return;
1215
1216 /* ugly! */
1217 opt = &((const struct bgp_open *)dat)->bgpo_optlen;
1218 opt++;
1219
1220 i = 0;
1221 while (i < bgpo.bgpo_optlen) {
1222 TCHECK2(opt[i], BGP_OPT_SIZE);
1223 memcpy(&bgpopt, &opt[i], BGP_OPT_SIZE);
1224 if (i + 2 + bgpopt.bgpopt_len > bgpo.bgpo_optlen) {
1225 printf("\n\t Option %d, length: %u", bgpopt.bgpopt_type, bgpopt.bgpopt_len);
1226 break;
1227 }
1228
1229 printf("\n\t Option %s (%u), length: %u",
1230 tok2str(bgp_opt_values,"Unknown", bgpopt.bgpopt_type),
1231 bgpopt.bgpopt_type,
1232 bgpopt.bgpopt_len);
1233
1234 /* now lets decode the options we know*/
1235 switch(bgpopt.bgpopt_type) {
1236 case BGP_OPT_CAP:
1237 cap_type=opt[i+BGP_OPT_SIZE];
1238 cap_len=opt[i+BGP_OPT_SIZE+1];
1239 tcap_len=cap_len;
1240 printf("\n\t %s, length: %u",
1241 tok2str(bgp_capcode_values,"Unknown", cap_type),
1242 cap_len);
1243 switch(cap_type) {
1244 case BGP_CAPCODE_MP:
1245 printf("\n\t\tAFI %s (%u), SAFI %s (%u)",
1246 tok2str(bgp_afi_values,"Unknown", EXTRACT_16BITS(opt+i+BGP_OPT_SIZE+2)),
1247 EXTRACT_16BITS(opt+i+BGP_OPT_SIZE+2),
1248 tok2str(bgp_safi_values,"Unknown", opt[i+BGP_OPT_SIZE+5]),
1249 opt[i+BGP_OPT_SIZE+5]);
1250 break;
1251 case BGP_CAPCODE_RESTART:
1252 printf("\n\t\tRestart Flags: [%s], Restart Time %us",
1253 ((opt[i+BGP_OPT_SIZE+2])&0x80) ? "R" : "none",
1254 EXTRACT_16BITS(opt+i+BGP_OPT_SIZE+2)&0xfff);
1255 tcap_len-=2;
1256 cap_offset=4;
1257 while(tcap_len>=4) {
1258 printf("\n\t\t AFI %s (%u), SAFI %s (%u), Forwarding state preserved: %s",
1259 tok2str(bgp_afi_values,"Unknown", EXTRACT_16BITS(opt+i+BGP_OPT_SIZE+cap_offset)),
1260 EXTRACT_16BITS(opt+i+BGP_OPT_SIZE+cap_offset),
1261 tok2str(bgp_safi_values,"Unknown", opt[i+BGP_OPT_SIZE+cap_offset+2]),
1262 opt[i+BGP_OPT_SIZE+cap_offset+2],
1263 ((opt[i+BGP_OPT_SIZE+cap_offset+3])&0x80) ? "yes" : "no" );
1264 tcap_len-=4;
1265 cap_offset+=4;
1266 }
1267 break;
1268 case BGP_CAPCODE_RR:
1269 case BGP_CAPCODE_RR_CISCO:
1270 break;
1271 default:
1272 printf("\n\t\tno decoder for Capability %u",
1273 cap_type);
1274 if (vflag <= 1)
1275 print_unknown_data(&opt[i+BGP_OPT_SIZE+2],"\n\t\t",cap_len);
1276 break;
1277 }
1278 if (vflag > 1)
1279 print_unknown_data(&opt[i+BGP_OPT_SIZE+2],"\n\t\t",cap_len);
1280 break;
1281 case BGP_OPT_AUTH:
1282 default:
1283 printf("\n\t no decoder for option %u",
1284 bgpopt.bgpopt_type);
1285 break;
1286 }
1287
1288 i += BGP_OPT_SIZE + bgpopt.bgpopt_len;
1289 }
1290 return;
1291 trunc:
1292 printf("[|BGP]");
1293 }
1294
1295 static void
1296 bgp_update_print(const u_char *dat, int length)
1297 {
1298 struct bgp bgp;
1299 struct bgp_attr bgpa;
1300 int hlen;
1301 const u_char *p;
1302 int len;
1303 int i;
1304
1305 TCHECK2(dat[0], BGP_SIZE);
1306 memcpy(&bgp, dat, BGP_SIZE);
1307 hlen = ntohs(bgp.bgp_len);
1308 p = dat + BGP_SIZE; /*XXX*/
1309
1310 /* Unfeasible routes */
1311 len = EXTRACT_16BITS(p);
1312 if (len) {
1313 /*
1314 * Without keeping state from the original NLRI message,
1315 * it's not possible to tell if this a v4 or v6 route,
1316 * so only try to decode it if we're not v6 enabled.
1317 */
1318 #ifdef INET6
1319 printf("\n\t Withdrawn routes: %d bytes", len);
1320 #else
1321 char buf[MAXHOSTNAMELEN + 100];
1322 int wpfx;
1323
1324 TCHECK2(p[2], len);
1325 i = 2;
1326
1327 printf("\n\t Withdrawn routes:");
1328
1329 while(i < 2 + len) {
1330 wpfx = decode_prefix4(&p[i], buf, sizeof(buf));
1331 if (wpfx >= 0) {
1332 i += wpfx;
1333 printf("\n\t %s", buf);
1334 } else {
1335 printf("\n\t (illegal prefix length)");
1336 break;
1337 }
1338 }
1339 #endif
1340 }
1341 p += 2 + len;
1342
1343 TCHECK2(p[0], 2);
1344 len = EXTRACT_16BITS(p);
1345 if (len) {
1346 /* do something more useful!*/
1347 i = 2;
1348 while (i < 2 + len) {
1349 int alen, aoff;
1350
1351 TCHECK2(p[i], sizeof(bgpa));
1352 memcpy(&bgpa, &p[i], sizeof(bgpa));
1353 alen = bgp_attr_len(&bgpa);
1354 aoff = bgp_attr_off(&bgpa);
1355
1356 printf("\n\t %s (%u), length: %u",
1357 tok2str(bgp_attr_values, "Unknown Attribute", bgpa.bgpa_type),
1358 bgpa.bgpa_type,
1359 alen);
1360
1361 if (bgpa.bgpa_flags) {
1362 printf(", Flags [%s%s%s%s",
1363 bgpa.bgpa_flags & 0x80 ? "O" : "",
1364 bgpa.bgpa_flags & 0x40 ? "T" : "",
1365 bgpa.bgpa_flags & 0x20 ? "P" : "",
1366 bgpa.bgpa_flags & 0x10 ? "E" : "");
1367 if (bgpa.bgpa_flags & 0xf)
1368 printf("+%x", bgpa.bgpa_flags & 0xf);
1369 printf("]: ");
1370 }
1371 bgp_attr_print(&bgpa, &p[i + aoff], alen);
1372 i += aoff + alen;
1373 }
1374 }
1375 p += 2 + len;
1376
1377 if (dat + length > p) {
1378 printf("\n\t Updated routes:");
1379 while (dat + length > p) {
1380 char buf[MAXHOSTNAMELEN + 100];
1381 i = decode_prefix4(p, buf, sizeof(buf));
1382 if (i >= 0) {
1383 printf("\n\t %s", buf);
1384 p += i;
1385 } else {
1386 printf("\n\t (illegal prefix length)");
1387 break;
1388 }
1389 }
1390 }
1391 return;
1392 trunc:
1393 printf("[|BGP]");
1394 }
1395
1396 static void
1397 bgp_notification_print(const u_char *dat, int length)
1398 {
1399 struct bgp_notification bgpn;
1400 int hlen;
1401 const u_char *tptr;
1402
1403 TCHECK2(dat[0], BGP_NOTIFICATION_SIZE);
1404 memcpy(&bgpn, dat, BGP_NOTIFICATION_SIZE);
1405 hlen = ntohs(bgpn.bgpn_len);
1406
1407 /* some little sanity checking */
1408 if (length<BGP_NOTIFICATION_SIZE)
1409 return;
1410
1411 printf(", %s (%u)",
1412 tok2str(bgp_notify_major_values, "Unknown Error", bgpn.bgpn_major),
1413 bgpn.bgpn_major);
1414
1415 switch (bgpn.bgpn_major) {
1416
1417 case BGP_NOTIFY_MAJOR_MSG:
1418 printf(", subcode %s (%u)",
1419 tok2str(bgp_notify_minor_msg_values, "Unknown", bgpn.bgpn_minor),
1420 bgpn.bgpn_minor);
1421 break;
1422 case BGP_NOTIFY_MAJOR_OPEN:
1423 printf(", subcode %s (%u)",
1424 tok2str(bgp_notify_minor_open_values, "Unknown", bgpn.bgpn_minor),
1425 bgpn.bgpn_minor);
1426 break;
1427 case BGP_NOTIFY_MAJOR_UPDATE:
1428 printf(", subcode %s (%u)",
1429 tok2str(bgp_notify_minor_update_values, "Unknown", bgpn.bgpn_minor),
1430 bgpn.bgpn_minor);
1431 break;
1432 case BGP_NOTIFY_MAJOR_CAP:
1433 printf(" subcode %s (%u)",
1434 tok2str(bgp_notify_minor_cap_values, "Unknown", bgpn.bgpn_minor),
1435 bgpn.bgpn_minor);
1436 case BGP_NOTIFY_MAJOR_CEASE:
1437 printf(", subcode %s (%u)",
1438 tok2str(bgp_notify_minor_cease_values, "Unknown", bgpn.bgpn_minor),
1439 bgpn.bgpn_minor);
1440
1441 /* draft-ietf-idr-cease-subcode-02 mentions optionally 7 bytes
1442 * for the maxprefix subtype, which may contain AFI, SAFI and MAXPREFIXES
1443 */
1444 if(bgpn.bgpn_minor == BGP_NOTIFY_MINOR_CEASE_MAXPRFX && length >= BGP_NOTIFICATION_SIZE + 7) {
1445 tptr = dat + BGP_NOTIFICATION_SIZE;
1446 TCHECK2(*tptr, 7);
1447 printf(", AFI %s (%u), SAFI %s (%u), Max Prefixes: %u",
1448 tok2str(bgp_afi_values, "Unknown", EXTRACT_16BITS(tptr)),
1449 EXTRACT_16BITS(tptr),
1450 tok2str(bgp_safi_values, "Unknown", *(tptr+2)),
1451 *(tptr+2),
1452 EXTRACT_32BITS(tptr+3));
1453 }
1454 break;
1455 default:
1456 break;
1457 }
1458
1459 return;
1460 trunc:
1461 printf("[|BGP]");
1462 }
1463
1464 static void
1465 bgp_route_refresh_print(const u_char *pptr, int len) {
1466
1467 const struct bgp_route_refresh *bgp_route_refresh_header;
1468 bgp_route_refresh_header = (const struct bgp_route_refresh *)pptr;
1469
1470 printf("\n\t AFI %s (%u), SAFI %s (%u)",
1471 tok2str(bgp_afi_values,"Unknown",
1472 EXTRACT_16BITS(&bgp_route_refresh_header->afi)), /* this stinks but the compiler pads the structure weird */
1473 EXTRACT_16BITS(&bgp_route_refresh_header->afi),
1474 tok2str(bgp_safi_values,"Unknown",
1475 bgp_route_refresh_header->safi),
1476 bgp_route_refresh_header->safi);
1477
1478 if (vflag > 1)
1479 print_unknown_data(pptr,"\n\t ", len);
1480
1481 return;
1482 }
1483
1484 static void
1485 bgp_header_print(const u_char *dat, int length)
1486 {
1487 struct bgp bgp;
1488
1489 TCHECK2(dat[0], BGP_SIZE);
1490 memcpy(&bgp, dat, BGP_SIZE);
1491 printf("\n\t%s Message (%u), length: %u",
1492 tok2str(bgp_msg_values, "Unknown", bgp.bgp_type),
1493 bgp.bgp_type,
1494 length);
1495
1496 switch (bgp.bgp_type) {
1497 case BGP_OPEN:
1498 bgp_open_print(dat, length);
1499 break;
1500 case BGP_UPDATE:
1501 bgp_update_print(dat, length);
1502 break;
1503 case BGP_NOTIFICATION:
1504 bgp_notification_print(dat, length);
1505 break;
1506 case BGP_KEEPALIVE:
1507 break;
1508 case BGP_ROUTE_REFRESH:
1509 bgp_route_refresh_print(dat, length);
1510 break;
1511 default:
1512 /* we have no decoder for the BGP message */
1513 printf("\n\t no Message %u decoder",bgp.bgp_type);
1514 print_unknown_data(dat,"\n\t ",length);
1515 break;
1516 }
1517 return;
1518 trunc:
1519 printf("[|BGP]");
1520 }
1521
1522 void
1523 bgp_print(const u_char *dat, int length)
1524 {
1525 const u_char *p;
1526 const u_char *ep;
1527 const u_char *start;
1528 const u_char marker[] = {
1529 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1530 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1531 };
1532 struct bgp bgp;
1533 u_int16_t hlen;
1534
1535 ep = dat + length;
1536 if (snapend < dat + length)
1537 ep = snapend;
1538
1539 printf(": BGP, length: %u",length);
1540
1541 if (vflag < 1) /* lets be less chatty */
1542 return;
1543
1544 p = dat;
1545 start = p;
1546 while (p < snapend) {
1547 if (!TTEST2(p[0], 1))
1548 break;
1549 if (p[0] != 0xff) {
1550 p++;
1551 continue;
1552 }
1553
1554 if (!TTEST2(p[0], sizeof(marker)))
1555 break;
1556 if (memcmp(p, marker, sizeof(marker)) != 0) {
1557 p++;
1558 continue;
1559 }
1560
1561 /* found BGP header */
1562 TCHECK2(p[0], BGP_SIZE); /*XXX*/
1563 memcpy(&bgp, p, BGP_SIZE);
1564
1565 if (start != p)
1566 printf(" [|BGP]");
1567
1568 hlen = ntohs(bgp.bgp_len);
1569 if (hlen < BGP_SIZE) {
1570 printf("\n[|BGP Bogus header length %u < %u]", hlen,
1571 BGP_SIZE);
1572 break;
1573 }
1574
1575 if (TTEST2(p[0], hlen)) {
1576 bgp_header_print(p, hlen);
1577 p += hlen;
1578 start = p;
1579 } else {
1580 printf("\n[|BGP %s]", tok2str(bgp_msg_values, "Unknown Message Type",bgp.bgp_type));
1581 break;
1582 }
1583 }
1584
1585 return;
1586
1587 trunc:
1588 printf(" [|BGP]");
1589 }
[mirror] the TCPdump network dissector