?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
This commit sets new users to see the DragonFly-tips fortunes instead
[dragonfly.git] / contrib / tcpdump-3.8.3 / print-bgp.c
blobbfa472a83fa7635a6178aaf3c609acc5943d72d8
1 /*
2 * Copyright (C) 1999 WIDE Project.
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 * 3. Neither the name of the project nor the names of its contributors
14 * may be used to endorse or promote products derived from this software
15 * without specific prior written permission.
16 *
17 * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
18 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20 * ARE DISCLAIMED. IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
21 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27 * SUCH DAMAGE.
28 *
29 * Extensively modified by Hannes Gredler (hannes@juniper.net) for more
30 * complete BGP support.
31 */
32
33 #ifdef HAVE_CONFIG_H
34 #include "config.h"
35 #endif
36
37 #ifndef lint
38 static const char rcsid[] _U_ =
39 "@(#) $Header: /tcpdump/master/tcpdump/print-bgp.c,v 1.72.2.4 2004/03/24 00:04:04 guy Exp $";
40 #endif
41
42 #include <tcpdump-stdinc.h>
43
44 #include <stdio.h>
45 #include <string.h>
46
47 #include "interface.h"
48 #include "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_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 */
168
169 static struct tok bgp_as_path_segment_open_values[] = {
170 { BGP_AS_SEQUENCE, ""},
171 { BGP_AS_SET, "{ "},
172 { BGP_CONFED_AS_SEQUENCE, "( "},
173 { BGP_CONFED_AS_SET, "({ "},
174 { 0, NULL}
175 };
176
177 static struct tok bgp_as_path_segment_close_values[] = {
178 { BGP_AS_SEQUENCE, ""},
179 { BGP_AS_SET, "}"},
180 { BGP_CONFED_AS_SEQUENCE, ")"},
181 { BGP_CONFED_AS_SET, "})"},
182 { 0, NULL}
183 };
184
185 #define BGP_OPT_AUTH 1
186 #define BGP_OPT_CAP 2
187
188
189 static 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
197 #define BGP_CAPCODE_RESTART 64 /* draft-ietf-idr-restart-05 */
198 #define BGP_CAPCODE_RR_CISCO 128
199
200 static struct tok bgp_capcode_values[] = {
201 { BGP_CAPCODE_MP, "Multiprotocol Extensions"},
202 { BGP_CAPCODE_RR, "Route Refresh"},
203 { BGP_CAPCODE_RESTART, "Graceful Restart"},
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
212 #define BGP_NOTIFY_MAJOR_FSM 5
213 #define BGP_NOTIFY_MAJOR_CEASE 6
214 #define BGP_NOTIFY_MAJOR_CAP 7
215
216 static struct tok bgp_notify_major_values[] = {
217 { BGP_NOTIFY_MAJOR_MSG, "Message Header Error"},
218 { BGP_NOTIFY_MAJOR_OPEN, "OPEN Message Error"},
219 { BGP_NOTIFY_MAJOR_UPDATE, "UPDATE Message Error"},
220 { BGP_NOTIFY_MAJOR_HOLDTIME,"Hold Timer Expired"},
221 { BGP_NOTIFY_MAJOR_FSM, "Finite State Machine Error"},
222 { BGP_NOTIFY_MAJOR_CEASE, "Cease"},
223 { BGP_NOTIFY_MAJOR_CAP, "Capability Message Error"},
224 { 0, NULL}
225 };
226
227 /* draft-ietf-idr-cease-subcode-02 */
228 #define BGP_NOTIFY_MINOR_CEASE_MAXPRFX 1
229 static struct tok bgp_notify_minor_cease_values[] = {
230 { BGP_NOTIFY_MINOR_CEASE_MAXPRFX, "Maximum Number of Prefixes Reached"},
231 { 2, "Administratively Shutdown"},
232 { 3, "Peer Unconfigured"},
233 { 4, "Administratively Reset"},
234 { 5, "Connection Rejected"},
235 { 6, "Other Configuration Change"},
236 { 7, "Connection Collision Resolution"},
237 { 0, NULL}
238 };
239
240 static struct tok bgp_notify_minor_msg_values[] = {
241 { 1, "Connection Not Synchronized"},
242 { 2, "Bad Message Length"},
243 { 3, "Bad Message Type"},
244 { 0, NULL}
245 };
246
247 static struct tok bgp_notify_minor_open_values[] = {
248 { 1, "Unsupported Version Number"},
249 { 2, "Bad Peer AS"},
250 { 3, "Bad BGP Identifier"},
251 { 4, "Unsupported Optional Parameter"},
252 { 5, "Authentication Failure"},
253 { 6, "Unacceptable Hold Time"},
254 { 0, NULL}
255 };
256
257 static struct tok bgp_notify_minor_update_values[] = {
258 { 1, "Malformed Attribute List"},
259 { 2, "Unrecognized Well-known Attribute"},
260 { 3, "Missing Well-known Attribute"},
261 { 4, "Attribute Flags Error"},
262 { 5, "Attribute Length Error"},
263 { 6, "Invalid ORIGIN Attribute"},
264 { 7, "AS Routing Loop"},
265 { 8, "Invalid NEXT_HOP Attribute"},
266 { 9, "Optional Attribute Error"},
267 { 10, "Invalid Network Field"},
268 { 11, "Malformed AS_PATH"},
269 { 0, NULL}
270 };
271
272 static struct tok bgp_notify_minor_cap_values[] = {
273 { 1, "Invalid Action Value" },
274 { 2, "Invalid Capability Length" },
275 { 3, "Malformed Capability Value" },
276 { 4, "Unsupported Capability Code" },
277 { 0, NULL }
278 };
279
280 static struct tok bgp_origin_values[] = {
281 { 0, "IGP"},
282 { 1, "EGP"},
283 { 2, "Incomplete"},
284 { 0, NULL}
285 };
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
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
303 static 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"},
309 { SAFNUM_VPNUNICAST, "labeled VPN Unicast"},
310 { SAFNUM_VPNMULTICAST, "labeled VPN Multicast"},
311 { SAFNUM_VPNUNIMULTICAST, "labeled VPN Unicast+Multicast"},
312 { SAFNUM_RT_ROUTING_INFO, "Route Target Routing Information"},
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
321 /* RFC1700 address family numbers */
322 #define AFNUM_INET 1
323 #define AFNUM_INET6 2
324 #define AFNUM_NSAP 3
325 #define AFNUM_HDLC 4
326 #define AFNUM_BBN1822 5
327 #define AFNUM_802 6
328 #define AFNUM_E163 7
329 #define AFNUM_E164 8
330 #define AFNUM_F69 9
331 #define AFNUM_X121 10
332 #define AFNUM_IPX 11
333 #define AFNUM_ATALK 12
334 #define AFNUM_DECNET 13
335 #define AFNUM_BANYAN 14
336 #define AFNUM_E164NSAP 15
337 /* draft-kompella-ppvpn-l2vpn */
338 #define AFNUM_L2VPN 196 /* still to be approved by IANA */
339
340 static struct tok bgp_afi_values[] = {
341 { 0, "Reserved"},
342 { AFNUM_INET, "IPv4"},
343 { AFNUM_INET6, "IPv6"},
344 { AFNUM_NSAP, "NSAP"},
345 { AFNUM_HDLC, "HDLC"},
346 { AFNUM_BBN1822, "BBN 1822"},
347 { AFNUM_802, "802"},
348 { AFNUM_E163, "E.163"},
349 { AFNUM_E164, "E.164"},
350 { AFNUM_F69, "F.69"},
351 { AFNUM_X121, "X.121"},
352 { AFNUM_IPX, "Novell IPX"},
353 { AFNUM_ATALK, "Appletalk"},
354 { AFNUM_DECNET, "Decnet IV"},
355 { AFNUM_BANYAN, "Banyan Vines"},
356 { AFNUM_E164NSAP, "E.164 with NSAP subaddress"},
357 { AFNUM_L2VPN, "Layer-2 VPN"},
358 { 0, NULL},
359 };
360
361 /* Extended community type - draft-ietf-idr-bgp-ext-communities-05 */
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 */
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 */
378
379 #define BGP_EXT_COM_OSPF_RID 0x0107 /* OSPF Router ID,Format RouterID(4B):Unused(2B) */
380 #define BGP_EXT_COM_OSPF_RID2 0x8001 /* duplicate - keep for backwards compatability */
381
382 #define BGP_EXT_COM_L2INFO 0x800a /* draft-kompella-ppvpn-l2vpn */
383
384 static struct tok bgp_extd_comm_flag_values[] = {
385 { 0x8000, "vendor-specific"},
386 { 0x4000, "non-transitive"},
387 { 0, NULL},
388 };
389
390 static 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"},
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"},
406 { BGP_EXT_COM_L2INFO, "layer2-info"},
407 { 0, NULL},
408 };
409
410 /* OSPF codes for BGP_EXT_COM_OSPF_RTYPE draft-rosen-vpns-ospf-bgp-mpls */
411 #define BGP_OSPF_RTYPE_RTR 1 /* OSPF Router LSA */
412 #define BGP_OSPF_RTYPE_NET 2 /* OSPF Network LSA */
413 #define BGP_OSPF_RTYPE_SUM 3 /* OSPF Summary LSA */
414 #define BGP_OSPF_RTYPE_EXT 5 /* OSPF External LSA, note that ASBR doesn't apply to MPLS-VPN */
415 #define BGP_OSPF_RTYPE_NSSA 7 /* OSPF NSSA External*/
416 #define BGP_OSPF_RTYPE_SHAM 129 /* OSPF-MPLS-VPN Sham link */
417 #define BGP_OSPF_RTYPE_METRIC_TYPE 0x1 /* LSB of RTYPE Options Field */
418
419 static struct tok bgp_extd_comm_ospf_rtype_values[] = {
420 { BGP_OSPF_RTYPE_RTR, "Router" },
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
429 static 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
447 static int
448 decode_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)
456 return -1;
457
458 memset(&addr, 0, sizeof(addr));
459 TCHECK2(pptr[1], (plen + 7) / 8);
460 memcpy(&addr, &pptr[1], (plen + 7) / 8);
461 if (plen % 8) {
462 ((u_char *)&addr)[(plen + 7) / 8 - 1] &=
463 ((0xff00 >> (plen % 8)) & 0xff);
464 }
465 snprintf(buf, buflen, "%s/%d", getname((u_char *)&addr), plen);
466 return 1 + (plen + 7) / 8;
467
468 trunc:
469 return -2;
470 }
471
472 static int
473 decode_labeled_prefix4(const u_char *pptr, char *buf, u_int buflen)
474 {
475 struct in_addr addr;
476 u_int plen;
477
478 TCHECK(pptr[0]);
479 plen = pptr[0]; /* get prefix length */
480
481 /* this is one of the weirdnesses of rfc3107
482 the label length (actually the label + COS bits)
483 is added to the prefix length;
484 we also do only read out just one label -
485 there is no real application for advertisement of
486 stacked labels in a a single BGP message
487 */
488
489 plen-=24; /* adjust prefixlen - labellength */
490
491 if (32 < plen)
492 return -1;
493
494 memset(&addr, 0, sizeof(addr));
495 TCHECK2(pptr[4], (plen + 7) / 8);
496 memcpy(&addr, &pptr[4], (plen + 7) / 8);
497 if (plen % 8) {
498 ((u_char *)&addr)[(plen + 7) / 8 - 1] &=
499 ((0xff00 >> (plen % 8)) & 0xff);
500 }
501 /* the label may get offsetted by 4 bits so lets shift it right */
502 snprintf(buf, buflen, "%s/%d, label:%u %s",
503 getname((u_char *)&addr),
504 plen,
505 EXTRACT_24BITS(pptr+1)>>4,
506 ((pptr[3]&1)==0) ? "(BOGUS: Bottom of Stack NOT set!)" : "(bottom)" );
507
508 return 4 + (plen + 7) / 8;
509
510 trunc:
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 */
517 static char *
518 bgp_vpn_rd_print (const u_char *pptr) {
519
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];
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:
543 snprintf(pos, sizeof(rd) - (pos - rd), "%u:%u",
544 EXTRACT_32BITS(pptr+2), 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);
553 }
554
555 static int
556 decode_rt_routing_info(const u_char *pptr, char *buf, u_int buflen)
557 {
558 u_int8_t route_target[8];
559 u_int plen;
560
561 TCHECK(pptr[0]);
562 plen = pptr[0]; /* get prefix length */
563
564 plen-=32; /* adjust prefix length */
565
566 if (0 < plen)
567 return -1;
568
569 memset(&route_target, 0, sizeof(route_target));
570 TCHECK2(pptr[1], (plen + 7) / 8);
571 memcpy(&route_target, &pptr[1], (plen + 7) / 8);
572 if (plen % 8) {
573 ((u_char *)&route_target)[(plen + 7) / 8 - 1] &=
574 ((0xff00 >> (plen % 8)) & 0xff);
575 }
576 snprintf(buf, buflen, "origin AS: %u, route target %s",
577 EXTRACT_32BITS(pptr+1),
578 bgp_vpn_rd_print((u_char *)&route_target));
579
580 return 5 + (plen + 7) / 8;
581
582 trunc:
583 return -2;
584 }
585
586 static int
587 decode_labeled_vpn_prefix4(const u_char *pptr, char *buf, u_int buflen)
588 {
589 struct in_addr addr;
590 u_int plen;
591
592 TCHECK(pptr[0]);
593 plen = pptr[0]; /* get prefix length */
594
595 plen-=(24+64); /* adjust prefixlen - labellength - RD len*/
596
597 if (32 < plen)
598 return -1;
599
600 memset(&addr, 0, sizeof(addr));
601 TCHECK2(pptr[12], (plen + 7) / 8);
602 memcpy(&addr, &pptr[12], (plen + 7) / 8);
603 if (plen % 8) {
604 ((u_char *)&addr)[(plen + 7) / 8 - 1] &=
605 ((0xff00 >> (plen % 8)) & 0xff);
606 }
607 /* the label may get offsetted by 4 bits so lets shift it right */
608 snprintf(buf, buflen, "RD: %s, %s/%d, label:%u %s",
609 bgp_vpn_rd_print(pptr+4),
610 getname((u_char *)&addr),
611 plen,
612 EXTRACT_24BITS(pptr+1)>>4,
613 ((pptr[3]&1)==0) ? "(BOGUS: Bottom of Stack NOT set!)" : "(bottom)" );
614
615 return 12 + (plen + 7) / 8;
616
617 trunc:
618 return -2;
619 }
620
621 static int
622 decode_labeled_vpn_l2(const u_char *pptr, char *buf, u_int buflen)
623 {
624 int plen,tlen,strlen,tlv_type,tlv_len,ttlv_len;
625
626 TCHECK2(pptr[0], 2);
627 plen=EXTRACT_16BITS(pptr);
628 tlen=plen;
629 pptr+=2;
630 TCHECK2(pptr[0],15);
631 strlen=snprintf(buf, buflen, "RD: %s, CE-ID: %u, Label-Block Offset: %u, Label Base %u",
632 bgp_vpn_rd_print(pptr),
633 EXTRACT_16BITS(pptr+8),
634 EXTRACT_16BITS(pptr+10),
635 EXTRACT_24BITS(pptr+12)>>4); /* the label is offsetted by 4 bits so lets shift it right */
636 pptr+=15;
637 tlen-=15;
638
639 /* ok now the variable part - lets read out TLVs*/
640 while (tlen>0) {
641 if (tlen < 3)
642 return -1;
643 TCHECK2(pptr[0], 3);
644 tlv_type=*pptr++;
645 tlv_len=EXTRACT_16BITS(pptr);
646 ttlv_len=tlv_len;
647 pptr+=2;
648
649 switch(tlv_type) {
650 case 1:
651 strlen+=snprintf(buf+strlen,buflen-strlen, "\n\t\tcircuit status vector (%u) length: %u: 0x",
652 tlv_type,
653 tlv_len);
654 ttlv_len=ttlv_len/8+1; /* how many bytes do we need to read ? */
655 while (ttlv_len>0) {
656 TCHECK(pptr[0]);
657 strlen+=snprintf(buf+strlen,buflen-strlen, "%02x",*pptr++);
658 ttlv_len--;
659 }
660 break;
661 default:
662 snprintf(buf+strlen,buflen-strlen, "\n\t\tunknown TLV #%u, length: %u",
663 tlv_type,
664 tlv_len);
665 break;
666 }
667 tlen-=(tlv_len<<3); /* the tlv-length is expressed in bits so lets shift it tright */
668 }
669 return plen+2;
670
671 trunc:
672 return -2;
673 }
674
675 #ifdef INET6
676 static int
677 decode_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)
685 return -1;
686
687 memset(&addr, 0, sizeof(addr));
688 TCHECK2(pd[1], (plen + 7) / 8);
689 memcpy(&addr, &pd[1], (plen + 7) / 8);
690 if (plen % 8) {
691 addr.s6_addr[(plen + 7) / 8 - 1] &=
692 ((0xff00 >> (plen % 8)) & 0xff);
693 }
694 snprintf(buf, buflen, "%s/%d", getname6((u_char *)&addr), plen);
695 return 1 + (plen + 7) / 8;
696
697 trunc:
698 return -2;
699 }
700
701 static int
702 decode_labeled_prefix6(const u_char *pptr, char *buf, u_int buflen)
703 {
704 struct in6_addr addr;
705 u_int plen;
706
707 TCHECK(pptr[0]);
708 plen = pptr[0]; /* get prefix length */
709 plen-=24; /* adjust prefixlen - labellength */
710
711 if (128 < plen)
712 return -1;
713
714 memset(&addr, 0, sizeof(addr));
715 TCHECK2(pptr[4], (plen + 7) / 8);
716 memcpy(&addr, &pptr[4], (plen + 7) / 8);
717 if (plen % 8) {
718 addr.s6_addr[(plen + 7) / 8 - 1] &=
719 ((0xff00 >> (plen % 8)) & 0xff);
720 }
721 /* the label may get offsetted by 4 bits so lets shift it right */
722 snprintf(buf, buflen, "%s/%d, label:%u %s",
723 getname6((u_char *)&addr),
724 plen,
725 EXTRACT_24BITS(pptr+1)>>4,
726 ((pptr[3]&1)==0) ? "(BOGUS: Bottom of Stack NOT set!)" : "(bottom)" );
727
728 return 4 + (plen + 7) / 8;
729
730 trunc:
731 return -2;
732 }
733
734 static int
735 decode_labeled_vpn_prefix6(const u_char *pptr, char *buf, u_int buflen)
736 {
737 struct in6_addr addr;
738 u_int plen;
739
740 TCHECK(pptr[0]);
741 plen = pptr[0]; /* get prefix length */
742
743 plen-=(24+64); /* adjust prefixlen - labellength - RD len*/
744
745 if (128 < plen)
746 return -1;
747
748 memset(&addr, 0, sizeof(addr));
749 TCHECK2(pptr[12], (plen + 7) / 8);
750 memcpy(&addr, &pptr[12], (plen + 7) / 8);
751 if (plen % 8) {
752 addr.s6_addr[(plen + 7) / 8 - 1] &=
753 ((0xff00 >> (plen % 8)) & 0xff);
754 }
755 /* the label may get offsetted by 4 bits so lets shift it right */
756 snprintf(buf, buflen, "RD: %s, %s/%d, label:%u %s",
757 bgp_vpn_rd_print(pptr+4),
758 getname6((u_char *)&addr),
759 plen,
760 EXTRACT_24BITS(pptr+1)>>4,
761 ((pptr[3]&1)==0) ? "(BOGUS: Bottom of Stack NOT set!)" : "(bottom)" );
762
763 return 12 + (plen + 7) / 8;
764
765 trunc:
766 return -2;
767 }
768 #endif
769
770 static int
771 bgp_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];
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);
794 printf("%s", tok2str(bgp_origin_values, "Unknown Origin Typecode", tptr[0]));
795 }
796 break;
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]);
809 printf("%s", tok2str(bgp_as_path_segment_open_values, "?", tptr[0]));
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]);
815 printf("%s", tok2str(bgp_as_path_segment_close_values, "?", tptr[0]));
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 {
824 TCHECK2(tptr[0], 4);
825 printf("%s", getname(tptr));
826 }
827 break;
828 case BGPTYPE_MULTI_EXIT_DISC:
829 case BGPTYPE_LOCAL_PREF:
830 if (len != 4)
831 printf("invalid len");
832 else {
833 TCHECK2(tptr[0], 4);
834 printf("%u", EXTRACT_32BITS(tptr));
835 }
836 break;
837 case BGPTYPE_ATOMIC_AGGREGATE:
838 if (len != 0)
839 printf("invalid len");
840 break;
841 case BGPTYPE_AGGREGATOR:
842 if (len != 6) {
843 printf("invalid len");
844 break;
845 }
846 TCHECK2(tptr[0], 6);
847 printf(" AS #%u, origin %s", EXTRACT_16BITS(tptr),
848 getname(tptr + 2));
849 break;
850 case BGPTYPE_COMMUNITIES:
851 if (len % 4) {
852 printf("invalid len");
853 break;
854 }
855 while (tlen>0) {
856 u_int32_t comm;
857 TCHECK2(tptr[0], 4);
858 comm = EXTRACT_32BITS(tptr);
859 switch (comm) {
860 case BGP_COMMUNITY_NO_EXPORT:
861 printf(" NO_EXPORT");
862 break;
863 case BGP_COMMUNITY_NO_ADVERT:
864 printf(" NO_ADVERTISE");
865 break;
866 case BGP_COMMUNITY_NO_EXPORT_SUBCONFED:
867 printf(" NO_EXPORT_SUBCONFED");
868 break;
869 default:
870 printf("%u:%u%s",
871 (comm >> 16) & 0xffff,
872 comm & 0xffff,
873 (tlen>4) ? ", " : "");
874 break;
875 }
876 tlen -=4;
877 tptr +=4;
878 }
879 break;
880 case BGPTYPE_ORIGINATOR_ID:
881 if (len != 4) {
882 printf("invalid len");
883 break;
884 }
885 TCHECK2(tptr[0], 4);
886 printf("%s",getname(tptr));
887 break;
888 case BGPTYPE_CLUSTER_LIST:
889 if (len % 4) {
890 printf("invalid len");
891 break;
892 }
893 while (tlen>0) {
894 TCHECK2(tptr[0], 4);
895 printf("%s%s",
896 getname(tptr),
897 (tlen>4) ? ", " : "");
898 tlen -=4;
899 tptr +=4;
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)",
908 tok2str(bgp_afi_values, "Unknown AFI", af),
909 af,
910 (safi>128) ? "vendor specific " : "", /* 128 is meanwhile wellknown */
911 tok2str(bgp_safi_values, "Unknown SAFI", safi),
912 safi);
913
914 if (af == AFNUM_INET || af==AFNUM_L2VPN)
915 ;
916 #ifdef INET6
917 else if (af == AFNUM_INET6)
918 ;
919 #endif
920 else {
921 printf("\n\t no AFI %u decoder",af);
922 if (vflag <= 1)
923 print_unknown_data(tptr,"\n\t ",tlen);
924 break;
925 }
926
927 tptr +=3;
928
929 TCHECK(tptr[0]);
930 tlen = tptr[0];
931 tptr++;
932
933 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;
979 #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;
1022 #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;
1048
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 }
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) {
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;
1131 #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;
1184 #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;
1220 }
1221 break;
1222
1223 case BGPTYPE_MP_UNREACH_NLRI:
1224 TCHECK2(tptr[0], 3);
1225 af = EXTRACT_16BITS(tptr);
1226 safi = tptr[2];
1227
1228 printf("\n\t AFI: %s (%u), %sSAFI: %s (%u)",
1229 tok2str(bgp_afi_values, "Unknown AFI", af),
1230 af,
1231 (safi>128) ? "vendor specific " : "", /* 128 is meanwhile wellknown */
1232 tok2str(bgp_safi_values, "Unknown SAFI", safi),
1233 safi);
1234
1235 tptr += 3;
1236
1237 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
1283 #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;
1327 #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;
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]",
1378 tok2str(bgp_extd_comm_subtype_values, "unknown extd community typecode", extd_comm),
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",
1387 EXTRACT_16BITS(tptr+2),
1388 getname(tptr+4));
1389 break;
1390 case BGP_EXT_COM_RT_1:
1391 case BGP_EXT_COM_RO_1:
1392 printf(": %s:%u",
1393 getname(tptr+2),
1394 EXTRACT_16BITS(tptr+6));
1395 break;
1396 case BGP_EXT_COM_RT_2:
1397 case BGP_EXT_COM_RO_2:
1398 printf(": %u:%u",
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;
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),
1419 tok2str(bgp_extd_comm_ospf_rtype_values,
1420 "unknown (0x%02x)",
1421 *(tptr+6)),
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",
1427 tok2str(bgp_l2vpn_encaps_values,
1428 "unknown encaps",
1429 *(tptr+2)),
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
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*/
1450 print_unknown_data(pptr,"\n\t ",len);
1451 return 1;
1452
1453 trunc:
1454 return 0;
1455 }
1456
1457 static void
1458 bgp_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;
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));
1473 printf("ID %s", getname((u_char *)&bgpo.bgpo_id));
1474 printf("\n\t Optional parameters, length: %u", bgpo.bgpo_optlen);
1475
1476 /* some little sanity checking */
1477 if (length < bgpo.bgpo_optlen+BGP_OPEN_SIZE)
1478 return;
1479
1480 /* ugly! */
1481 opt = &((const struct bgp_open *)dat)->bgpo_optlen;
1482 opt++;
1483
1484 i = 0;
1485 while (i < bgpo.bgpo_optlen) {
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",
1494 tok2str(bgp_opt_values,"Unknown", bgpopt.bgpopt_type),
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;
1504 printf("\n\t %s, length: %u",
1505 tok2str(bgp_capcode_values,"Unknown", cap_type),
1506 cap_len);
1507 switch(cap_type) {
1508 case BGP_CAPCODE_MP:
1509 printf("\n\t\tAFI %s (%u), SAFI %s (%u)",
1510 tok2str(bgp_afi_values,"Unknown", EXTRACT_16BITS(opt+i+BGP_OPT_SIZE+2)),
1511 EXTRACT_16BITS(opt+i+BGP_OPT_SIZE+2),
1512 tok2str(bgp_safi_values,"Unknown", opt[i+BGP_OPT_SIZE+5]),
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",
1523 tok2str(bgp_afi_values,"Unknown", EXTRACT_16BITS(opt+i+BGP_OPT_SIZE+cap_offset)),
1524 EXTRACT_16BITS(opt+i+BGP_OPT_SIZE+cap_offset),
1525 tok2str(bgp_safi_values,"Unknown", opt[i+BGP_OPT_SIZE+cap_offset+2]),
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:
1534 break;
1535 default:
1536 printf("\n\t\tno decoder for Capability %u",
1537 cap_type);
1538 if (vflag <= 1)
1539 print_unknown_data(&opt[i+BGP_OPT_SIZE+2],"\n\t\t",cap_len);
1540 break;
1541 }
1542 if (vflag > 1)
1543 print_unknown_data(&opt[i+BGP_OPT_SIZE+2],"\n\t\t",cap_len);
1544 break;
1545 case BGP_OPT_AUTH:
1546 default:
1547 printf("\n\t no decoder for option %u",
1548 bgpopt.bgpopt_type);
1549 break;
1550 }
1551
1552 i += BGP_OPT_SIZE + bgpopt.bgpopt_len;
1553 }
1554 return;
1555 trunc:
1556 printf("[|BGP]");
1557 }
1558
1559 static void
1560 bgp_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;
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);
1576 if (len) {
1577 /*
1578 * Without keeping state from the original NLRI message,
1579 * it's not possible to tell if this a v4 or v6 route,
1580 * so only try to decode it if we're not v6 enabled.
1581 */
1582 #ifdef INET6
1583 printf("\n\t Withdrawn routes: %d bytes", len);
1584 #else
1585 char buf[MAXHOSTNAMELEN + 100];
1586 int wpfx;
1587
1588 TCHECK2(p[2], len);
1589 i = 2;
1590
1591 printf("\n\t Withdrawn routes:");
1592
1593 while(i < 2 + len) {
1594 wpfx = decode_prefix4(&p[i], buf, sizeof(buf));
1595 if (wpfx == -1) {
1596 printf("\n\t (illegal prefix length)");
1597 break;
1598 } else if (wpfx == -2)
1599 goto trunc;
1600 else {
1601 i += wpfx;
1602 printf("\n\t %s", buf);
1603 }
1604 }
1605 #endif
1606 }
1607 p += 2 + len;
1608
1609 TCHECK2(p[0], 2);
1610 len = EXTRACT_16BITS(p);
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",
1623 tok2str(bgp_attr_values, "Unknown Attribute", bgpa.bgpa_type),
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 }
1641 }
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)
1650 printf("\n\t (illegal prefix length)");
1651 else if (i == -2)
1652 goto trunc;
1653 else {
1654 printf("\n\t %s", buf);
1655 p += i;
1656 }
1657 }
1658 }
1659 return;
1660 trunc:
1661 printf("[|BGP]");
1662 }
1663
1664 static void
1665 bgp_notification_print(const u_char *dat, int length)
1666 {
1667 struct bgp_notification bgpn;
1668 int hlen;
1669 const u_char *tptr;
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)",
1680 tok2str(bgp_notify_major_values, "Unknown Error", bgpn.bgpn_major),
1681 bgpn.bgpn_major);
1682
1683 switch (bgpn.bgpn_major) {
1684
1685 case BGP_NOTIFY_MAJOR_MSG:
1686 printf(", subcode %s (%u)",
1687 tok2str(bgp_notify_minor_msg_values, "Unknown", bgpn.bgpn_minor),
1688 bgpn.bgpn_minor);
1689 break;
1690 case BGP_NOTIFY_MAJOR_OPEN:
1691 printf(", subcode %s (%u)",
1692 tok2str(bgp_notify_minor_open_values, "Unknown", bgpn.bgpn_minor),
1693 bgpn.bgpn_minor);
1694 break;
1695 case BGP_NOTIFY_MAJOR_UPDATE:
1696 printf(", subcode %s (%u)",
1697 tok2str(bgp_notify_minor_update_values, "Unknown", bgpn.bgpn_minor),
1698 bgpn.bgpn_minor);
1699 break;
1700 case BGP_NOTIFY_MAJOR_CAP:
1701 printf(" subcode %s (%u)",
1702 tok2str(bgp_notify_minor_cap_values, "Unknown", bgpn.bgpn_minor),
1703 bgpn.bgpn_minor);
1704 case BGP_NOTIFY_MAJOR_CEASE:
1705 printf(", subcode %s (%u)",
1706 tok2str(bgp_notify_minor_cease_values, "Unknown", bgpn.bgpn_minor),
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",
1716 tok2str(bgp_afi_values, "Unknown", EXTRACT_16BITS(tptr)),
1717 EXTRACT_16BITS(tptr),
1718 tok2str(bgp_safi_values, "Unknown", *(tptr+2)),
1719 *(tptr+2),
1720 EXTRACT_32BITS(tptr+3));
1721 }
1722 break;
1723 default:
1724 break;
1725 }
1726
1727 return;
1728 trunc:
1729 printf("[|BGP]");
1730 }
1731
1732 static void
1733 bgp_route_refresh_print(const u_char *pptr, int len) {
1734
1735 const struct bgp_route_refresh *bgp_route_refresh_header;
1736 bgp_route_refresh_header = (const struct bgp_route_refresh *)pptr;
1737
1738 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 */
1741 EXTRACT_16BITS(&bgp_route_refresh_header->afi),
1742 tok2str(bgp_safi_values,"Unknown",
1743 bgp_route_refresh_header->safi),
1744 bgp_route_refresh_header->safi);
1745
1746 if (vflag > 1)
1747 print_unknown_data(pptr,"\n\t ", len);
1748
1749 return;
1750 }
1751
1752 static int
1753 bgp_header_print(const u_char *dat, int length)
1754 {
1755 struct bgp bgp;
1756
1757 TCHECK2(dat[0], BGP_SIZE);
1758 memcpy(&bgp, dat, BGP_SIZE);
1759 printf("\n\t%s Message (%u), length: %u",
1760 tok2str(bgp_msg_values, "Unknown", bgp.bgp_type),
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:
1769 bgp_update_print(dat, length);
1770 break;
1771 case BGP_NOTIFICATION:
1772 bgp_notification_print(dat, length);
1773 break;
1774 case BGP_KEEPALIVE:
1775 break;
1776 case BGP_ROUTE_REFRESH:
1777 bgp_route_refresh_print(dat, length);
1778 break;
1779 default:
1780 /* we have no decoder for the BGP message */
1781 printf("\n\t no Message %u decoder",bgp.bgp_type);
1782 print_unknown_data(dat,"\n\t ",length);
1783 break;
1784 }
1785 return 1;
1786 trunc:
1787 printf("[|BGP]");
1788 return 0;
1789 }
1790
1791 void
1792 bgp_print(const u_char *dat, int length)
1793 {
1794 const u_char *p;
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;
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 */
1811 return;
1812
1813 p = dat;
1814 start = p;
1815 while (p < snapend) {
1816 if (!TTEST2(p[0], 1))
1817 break;
1818 if (p[0] != 0xff) {
1819 p++;
1820 continue;
1821 }
1822
1823 if (!TTEST2(p[0], sizeof(marker)))
1824 break;
1825 if (memcmp(p, marker, sizeof(marker)) != 0) {
1826 p++;
1827 continue;
1828 }
1829
1830 /* found BGP header */
1831 TCHECK2(p[0], BGP_SIZE); /*XXX*/
1832 memcpy(&bgp, p, BGP_SIZE);
1833
1834 if (start != p)
1835 printf(" [|BGP]");
1836
1837 hlen = ntohs(bgp.bgp_len);
1838 if (hlen < BGP_SIZE) {
1839 printf("\n[|BGP Bogus header length %u < %u]", hlen,
1840 BGP_SIZE);
1841 break;
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 {
1850 printf("\n[|BGP %s]", tok2str(bgp_msg_values, "Unknown Message Type",bgp.bgp_type));
1851 break;
1852 }
1853 }
1854
1855 return;
1856
1857 trunc:
1858 printf(" [|BGP]");
1859 }
DragonFly BSD