]> The Tcpdump Group git mirrors - tcpdump/blob - print-bgp.c
projects / tcpdump / blob
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
s/sprintf/snprintf/.
[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
30 #ifdef HAVE_CONFIG_H
31 #include "config.h"
32 #endif
33
34 #ifndef lint
35 static const char rcsid[] =
36 "@(#) $Header: /tcpdump/master/tcpdump/print-bgp.c,v 1.11 2000-01-17 06:24:24 itojun Exp $";
37 #endif
38
39 #include <sys/param.h>
40 #include <sys/time.h>
41 #include <sys/types.h>
42 #include <sys/socket.h>
43
44 #include <netinet/in.h>
45 #include <netinet/in_systm.h>
46 #include <netinet/ip.h>
47 #include <netinet/ip_var.h>
48 #include <netinet/udp.h>
49 #include <netinet/udp_var.h>
50
51 #include <errno.h>
52 #include <stdio.h>
53 #include <string.h>
54
55 #include "interface.h"
56 #include "addrtoname.h"
57
58 struct bgp {
59 u_int8_t bgp_marker[16];
60 u_int16_t bgp_len;
61 u_int8_t bgp_type;
62 };
63 #define BGP_SIZE 19 /* unaligned */
64
65 #define BGP_OPEN 1
66 #define BGP_UPDATE 2
67 #define BGP_NOTIFICATION 3
68 #define BGP_KEEPALIVE 4
69
70 struct bgp_open {
71 u_int8_t bgpo_marker[16];
72 u_int16_t bgpo_len;
73 u_int8_t bgpo_type;
74 u_int8_t bgpo_version;
75 u_int16_t bgpo_myas;
76 u_int16_t bgpo_holdtime;
77 u_int32_t bgpo_id;
78 u_int8_t bgpo_optlen;
79 /* options should follow */
80 };
81
82 struct bgp_opt {
83 u_int8_t bgpopt_type;
84 u_int8_t bgpopt_len;
85 /* variable length */
86 };
87
88 struct bgp_notification {
89 u_int8_t bgpn_marker[16];
90 u_int16_t bgpn_len;
91 u_int8_t bgpn_type;
92 u_int8_t bgpn_major;
93 u_int8_t bgpn_minor;
94 /* data should follow */
95 };
96
97 struct bgp_attr {
98 u_int8_t bgpa_flags;
99 u_int8_t bgpa_type;
100 union {
101 u_int8_t len;
102 u_int16_t elen;
103 } bgpa_len;
104 #define bgp_attr_len(p) \
105 (((p)->bgpa_flags & 0x10) ? \
106 ntohs((p)->bgpa_len.elen) : (p)->bgpa_len.len)
107 #define bgp_attr_off(p) \
108 (((p)->bgpa_flags & 0x10) ? 4 : 3)
109 };
110
111 #define BGPTYPE_ORIGIN 1
112 #define BGPTYPE_AS_PATH 2
113 #define BGPTYPE_NEXT_HOP 3
114 #define BGPTYPE_MULTI_EXIT_DISC 4
115 #define BGPTYPE_LOCAL_PREF 5
116 #define BGPTYPE_ATOMIC_AGGREGATE 6
117 #define BGPTYPE_AGGREGATOR 7
118 #define BGPTYPE_COMMUNITIES 8 /* RFC1997 */
119 #define BGPTYPE_ORIGINATOR_ID 9 /* RFC1998 */
120 #define BGPTYPE_CLUSTER_LIST 10 /* RFC1998 */
121 #define BGPTYPE_DPA 11 /* work in progress */
122 #define BGPTYPE_ADVERTISERS 12 /* RFC1863 */
123 #define BGPTYPE_RCID_PATH 13 /* RFC1863 */
124 #define BGPTYPE_MP_REACH_NLRI 14 /* RFC2283 */
125 #define BGPTYPE_MP_UNREACH_NLRI 15 /* RFC2283 */
126
127
128 static const char *bgptype[] = {
129 NULL, "OPEN", "UPDATE", "NOTIFICATION", "KEEPALIVE",
130 };
131 #define bgp_type(x) num_or_str(bgptype, sizeof(bgptype)/sizeof(bgptype[0]), (x))
132
133 static const char *bgpopt_type[] = {
134 NULL, "Authentication Information",
135 };
136 #define bgp_opttype(x) \
137 num_or_str(bgpopt_type, sizeof(bgpopt_type)/sizeof(bgpopt_type[0]), (x))
138
139 static const char *bgpnotify_major[] = {
140 NULL, "Message Header Error",
141 "OPEN Message Error", "UPDATE Message Error",
142 "Hold Timer Expired", "Finite State Machine Error",
143 "Cease",
144 };
145 #define bgp_notify_major(x) \
146 num_or_str(bgpnotify_major, \
147 sizeof(bgpnotify_major)/sizeof(bgpnotify_major[0]), (x))
148
149 static const char *bgpnotify_minor_1[] = {
150 NULL, "Connection Not Synchronized",
151 "Bad Message Length", "Bad Message Type",
152 };
153
154 static const char *bgpnotify_minor_2[] = {
155 NULL, "Unsupported Version Number",
156 "Bad Peer AS", "Bad BGP Identifier",
157 "Unsupported Optional Parameter", "Authentication Failure",
158 "Unacceptable Hold Time",
159 };
160
161 static const char *bgpnotify_minor_3[] = {
162 NULL, "Malformed Attribute List",
163 "Unrecognized Well-known Attribute", "Missing Well-known Attribute",
164 "Attribute Flags Error", "Attribute Length Error",
165 "Invalid ORIGIN Attribute", "AS Routing Loop",
166 "Invalid NEXT_HOP Attribute", "Optional Attribute Error",
167 "Invalid Network Field", "Malformed AS_PATH",
168 };
169
170 static const char **bgpnotify_minor[] = {
171 NULL, bgpnotify_minor_1, bgpnotify_minor_2, bgpnotify_minor_3,
172 };
173 static const int bgpnotify_minor_siz[] = {
174 0, sizeof(bgpnotify_minor_1)/sizeof(bgpnotify_minor_1[0]),
175 sizeof(bgpnotify_minor_2)/sizeof(bgpnotify_minor_2[0]),
176 sizeof(bgpnotify_minor_3)/sizeof(bgpnotify_minor_3[0]),
177 };
178
179 static const char *bgpattr_origin[] = {
180 "IGP", "EGP", "INCOMPLETE",
181 };
182 #define bgp_attr_origin(x) \
183 num_or_str(bgpattr_origin, \
184 sizeof(bgpattr_origin)/sizeof(bgpattr_origin[0]), (x))
185
186 static const char *bgpattr_type[] = {
187 NULL, "ORIGIN", "AS_PATH", "NEXT_HOP",
188 "MULTI_EXIT_DISC", "LOCAL_PREF", "ATOMIC_AGGREGATE", "AGGREGATOR",
189 "COMMUNITIES", "ORIGINATOR_ID", "CLUSTER_LIST", "DPA",
190 "ADVERTISERS", "RCID_PATH", "MP_REACH_NLRI", "MP_UNREACH_NLRI",
191 };
192 #define bgp_attr_type(x) \
193 num_or_str(bgpattr_type, \
194 sizeof(bgpattr_type)/sizeof(bgpattr_type[0]), (x))
195
196 /* Subsequent address family identifier, RFC2283 section 7 */
197 static const char *bgpattr_nlri_safi[] = {
198 "Reserved", "Unicast", "Multicast", "Unicast+Multicast",
199 };
200 #define bgp_attr_nlri_safi(x) \
201 num_or_str(bgpattr_nlri_safi, \
202 sizeof(bgpattr_nlri_safi)/sizeof(bgpattr_nlri_safi[0]), (x))
203
204 /* well-known community */
205 #define BGP_COMMUNITY_NO_EXPORT 0xffffff01
206 #define BGP_COMMUNITY_NO_ADVERT 0xffffff02
207 #define BGP_COMMUNITY_NO_EXPORT_SUBCONFED 0xffffff03
208
209 /* RFC1700 address family numbers */
210 #define AFNUM_INET 1
211 #define AFNUM_INET6 2
212 #define AFNUM_NSAP 3
213 #define AFNUM_HDLC 4
214 #define AFNUM_BBN1822 5
215 #define AFNUM_802 6
216 #define AFNUM_E163 7
217 #define AFNUM_E164 8
218 #define AFNUM_F69 9
219 #define AFNUM_X121 10
220 #define AFNUM_IPX 11
221 #define AFNUM_ATALK 12
222 #define AFNUM_DECNET 13
223 #define AFNUM_BANYAN 14
224 #define AFNUM_E164NSAP 15
225
226 static const char *afnumber[] = {
227 "Reserved", "IPv4", "IPv6", "NSAP", "HDLC",
228 "BBN 1822", "802", "E.163", "E.164", "F.69",
229 "X.121", "IPX", "Appletalk", "Decnet IV", "Banyan Vines",
230 "E.164 with NSAP subaddress",
231 };
232 #define af_name(x) \
233 (((x) == 65535) ? afnumber[0] : \
234 num_or_str(afnumber, \
235 sizeof(afnumber)/sizeof(afnumber[0]), (x)))
236
237
238 static const char *
239 num_or_str(const char **table, size_t siz, int value)
240 {
241 static char buf[20];
242 if (value < 0 || siz <= value || table[value] == NULL) {
243 snprintf(buf, sizeof(buf), "#%d", value);
244 return buf;
245 } else
246 return table[value];
247 }
248
249 static const char *
250 bgp_notify_minor(int major, int minor)
251 {
252 static const char **table;
253 int siz;
254 static char buf[20];
255 const char *p;
256
257 if (0 <= major
258 && major < sizeof(bgpnotify_minor)/sizeof(bgpnotify_minor[0])
259 && bgpnotify_minor[major]) {
260 table = bgpnotify_minor[major];
261 siz = bgpnotify_minor_siz[major];
262 if (0 <= minor && minor < siz && table[minor])
263 p = table[minor];
264 else
265 p = NULL;
266 } else
267 p = NULL;
268 if (p == NULL) {
269 snprintf(buf, sizeof(buf), "#%d", minor);
270 return buf;
271 } else
272 return p;
273 }
274
275 static int
276 decode_prefix4(const u_char *pd, char *buf, int buflen)
277 {
278 struct in_addr addr;
279 int plen;
280
281 plen = pd[0];
282 if (plen < 0 || 32 < plen)
283 return -1;
284
285 memset(&addr, 0, sizeof(addr));
286 memcpy(&addr, &pd[1], (plen + 7) / 8);
287 if (plen % 8) {
288 ((u_char *)&addr)[(plen + 7) / 8 - 1] &=
289 ((0xff00 >> (plen % 8)) & 0xff);
290 }
291 snprintf(buf, buflen, "%s/%d", getname((char *)&addr), plen);
292 return 1 + (plen + 7) / 8;
293 }
294
295 #ifdef INET6
296 static int
297 decode_prefix6(const u_char *pd, char *buf, int buflen)
298 {
299 struct in6_addr addr;
300 int plen;
301
302 plen = pd[0];
303 if (plen < 0 || 128 < plen)
304 return -1;
305
306 memset(&addr, 0, sizeof(addr));
307 memcpy(&addr, &pd[1], (plen + 7) / 8);
308 if (plen % 8) {
309 addr.s6_addr[(plen + 7) / 8 - 1] &=
310 ((0xff00 >> (plen % 8)) & 0xff);
311 }
312 snprintf(buf, buflen, "%s/%d", getname6((char *)&addr), plen);
313 return 1 + (plen + 7) / 8;
314 }
315 #endif
316
317 static void
318 bgp_attr_print(const struct bgp_attr *attr, const u_char *dat, int len)
319 {
320 int i;
321 u_int16_t af;
322 u_int8_t safi, snpa;
323 int advance;
324 int tlen;
325 const u_char *p;
326 char buf[256];
327
328 p = dat;
329
330 switch (attr->bgpa_type) {
331 case BGPTYPE_ORIGIN:
332 if (len != 1)
333 printf(" invalid len");
334 else
335 printf(" %s", bgp_attr_origin(p[0]));
336 break;
337 case BGPTYPE_AS_PATH:
338 if (len % 2) {
339 printf(" invalid len");
340 break;
341 }
342 while (p < dat + len) {
343 /*
344 * under RFC1965, p[0] means:
345 * 1: AS_SET 2: AS_SEQUENCE
346 * 3: AS_CONFED_SET 4: AS_CONFED_SEQUENCE
347 */
348 printf(" ");
349 if (p[0] == 3 || p[0] == 4)
350 printf("confed");
351 printf("%s", (p[0] & 1) ? "{" : "");
352 for (i = 0; i < p[1]; i += 2) {
353 printf("%s%u", i == 0 ? "" : " ",
354 ntohs(*(u_int16_t *)&p[2 + i]));
355 }
356 printf("%s", (p[0] & 1) ? "}" : "");
357 p += 2 + p[1] * 2;
358 }
359 break;
360 case BGPTYPE_NEXT_HOP:
361 if (len != 4)
362 printf(" invalid len");
363 else
364 printf(" %s", getname(p));
365 break;
366 case BGPTYPE_MULTI_EXIT_DISC:
367 case BGPTYPE_LOCAL_PREF:
368 if (len != 4)
369 printf(" invalid len");
370 else
371 printf(" %u", (u_int32_t)ntohl(*(u_int32_t *)p));
372 break;
373 case BGPTYPE_ATOMIC_AGGREGATE:
374 if (len != 0)
375 printf(" invalid len");
376 break;
377 case BGPTYPE_AGGREGATOR:
378 if (len != 6) {
379 printf(" invalid len");
380 break;
381 }
382 printf(" AS #%u, origin %s", ntohs(*(u_int16_t *)p),
383 getname(p + 2));
384 break;
385 case BGPTYPE_COMMUNITIES:
386 if (len % 4) {
387 printf(" invalid len");
388 break;
389 }
390 for (i = 0; i < len; i++) {
391 u_int32_t comm;
392 comm = (u_int32_t)ntohl(*(u_int32_t *)&p[i]);
393 switch (comm) {
394 case BGP_COMMUNITY_NO_EXPORT:
395 printf(" NO_EXPORT");
396 break;
397 case BGP_COMMUNITY_NO_ADVERT:
398 printf(" NO_ADVERTISE");
399 break;
400 case BGP_COMMUNITY_NO_EXPORT_SUBCONFED:
401 printf(" NO_EXPORT_SUBCONFED");
402 break;
403 default:
404 printf(" (AS #%d value 0x%04x)",
405 (comm >> 16) & 0xffff, comm & 0xfffff);
406 break;
407 }
408 }
409 break;
410 case BGPTYPE_MP_REACH_NLRI:
411 af = ntohs(*(u_int16_t *)p);
412 safi = p[2];
413 if (safi >= 128)
414 printf(" %s vendor specific,", af_name(af));
415 else {
416 printf(" %s %s,", af_name(af),
417 bgp_attr_nlri_safi(safi));
418 }
419 p += 3;
420
421 if (af == AFNUM_INET)
422 ;
423 #ifdef INET6
424 else if (af == AFNUM_INET6)
425 ;
426 #endif
427 else
428 break;
429
430 tlen = p[0];
431 if (tlen) {
432 printf(" nexthop");
433 if (af == AFNUM_INET)
434 advance = 4;
435 #ifdef INET6
436 else if (af == AFNUM_INET6)
437 advance = 16;
438 #endif
439
440 for (i = 0; i < tlen; i += advance) {
441 if (af == AFNUM_INET)
442 printf(" %s", getname(p + 1 + i));
443 #ifdef INET6
444 else if (af == AFNUM_INET6)
445 printf(" %s", getname6(p + 1 + i));
446 #endif
447 }
448 printf(",");
449 }
450 p += 1 + tlen;
451
452 snpa = p[0];
453 p++;
454 if (snpa) {
455 printf(" %u snpa", snpa);
456 for (/*nothing*/; snpa > 0; snpa--) {
457 printf("(%d bytes)", p[0]);
458 p += p[0] + 1;
459 }
460 printf(",");
461 }
462
463 printf(" NLRI");
464 while (len - (p - dat) > 0) {
465 if (af == AFNUM_INET)
466 advance = decode_prefix4(p, buf, sizeof(buf));
467 #ifdef INET6
468 else if (af == AFNUM_INET6)
469 advance = decode_prefix6(p, buf, sizeof(buf));
470 #endif
471 printf(" %s", buf);
472
473 p += advance;
474 }
475
476 break;
477
478 case BGPTYPE_MP_UNREACH_NLRI:
479 af = ntohs(*(u_int16_t *)p);
480 safi = p[2];
481 if (safi >= 128)
482 printf(" %s vendor specific,", af_name(af));
483 else {
484 printf(" %s %s,", af_name(af),
485 bgp_attr_nlri_safi(safi));
486 }
487 p += 3;
488
489 printf(" Withdraw");
490 while (len - (p - dat) > 0) {
491 if (af == AFNUM_INET)
492 advance = decode_prefix4(p, buf, sizeof(buf));
493 #ifdef INET6
494 else if (af == AFNUM_INET6)
495 advance = decode_prefix6(p, buf, sizeof(buf));
496 #endif
497 printf(" %s", buf);
498
499 p += advance;
500 }
501 break;
502 default:
503 break;
504 }
505 }
506
507 static void
508 bgp_open_print(const u_char *dat, int length)
509 {
510 struct bgp_open bgpo;
511 struct bgp_opt bgpopt;
512 int hlen;
513 const u_char *opt;
514 int i;
515
516 memcpy(&bgpo, dat, sizeof(bgpo));
517 hlen = ntohs(bgpo.bgpo_len);
518
519 printf(": Version %d,", bgpo.bgpo_version);
520 printf(" AS #%u,", ntohs(bgpo.bgpo_myas));
521 printf(" Holdtime %u,", ntohs(bgpo.bgpo_holdtime));
522 printf(" ID %s,", getname((char *)&bgpo.bgpo_id));
523 printf(" Option length %u", bgpo.bgpo_optlen);
524
525 /* ugly! */
526 opt = &((struct bgp_open *)dat)->bgpo_optlen;
527 opt++;
528
529 for (i = 0; i < bgpo.bgpo_optlen; i++) {
530 memcpy(&bgpopt, &opt[i], sizeof(bgpopt));
531 if (i + 2 + bgpopt.bgpopt_len > bgpo.bgpo_optlen) {
532 printf(" [|opt %d %d]", bgpopt.bgpopt_len, bgpopt.bgpopt_type);
533 break;
534 }
535
536 printf(" (option %s, len=%d)", bgp_opttype(bgpopt.bgpopt_type),
537 bgpopt.bgpopt_len);
538 i += sizeof(bgpopt) + bgpopt.bgpopt_len;
539 }
540 }
541
542 static void
543 bgp_update_print(const u_char *dat, int length)
544 {
545 struct bgp bgp;
546 struct bgp_attr bgpa;
547 int hlen;
548 const u_char *p;
549 int len;
550 int i;
551 int newline;
552
553 memcpy(&bgp, dat, sizeof(bgp));
554 hlen = ntohs(bgp.bgp_len);
555 p = dat + BGP_SIZE; /*XXX*/
556 printf(":");
557
558 /* Unfeasible routes */
559 len = ntohs(*(u_int16_t *)p);
560 if (len) {
561 printf(" (Withdrawn routes: %d bytes)", len);
562 }
563 p += 2 + len;
564
565 len = ntohs(*(u_int16_t *)p);
566 if (len) {
567 /* do something more useful!*/
568 i = 2;
569 printf(" (Path attributes:"); /* ) */
570 newline = 0;
571 while (i < 2 + len) {
572 int alen, aoff;
573
574 memcpy(&bgpa, &p[i], sizeof(bgpa));
575 alen = bgp_attr_len(&bgpa);
576 aoff = bgp_attr_off(&bgpa);
577
578 if (vflag && newline)
579 printf("\n\t\t");
580 else
581 printf(" ");
582 printf("("); /* ) */
583 printf("%s", bgp_attr_type(bgpa.bgpa_type));
584 if (bgpa.bgpa_flags) {
585 printf("[%s%s%s%s]",
586 bgpa.bgpa_flags & 0x80 ? "O" : "",
587 bgpa.bgpa_flags & 0x40 ? "T" : "",
588 bgpa.bgpa_flags & 0x20 ? "P" : "",
589 bgpa.bgpa_flags & 0x00 ? "E" : "");
590 }
591
592 bgp_attr_print(&bgpa, &p[i + aoff], alen);
593 newline = 1;
594
595 /* ( */
596 printf(")");
597
598 i += aoff + alen;
599 }
600
601 /* ( */
602 printf(")");
603 }
604 p += 2 + len;
605
606 if (len && dat + length > p)
607 printf("\n\t\t");
608 if (dat + length > p) {
609 printf("(NLRI:"); /* ) */
610 while (dat + length > p) {
611 char buf[256];
612 i = decode_prefix4(p, buf, sizeof(buf));
613 printf(" %s", buf);
614 if (i < 0)
615 break;
616 p += i;
617 }
618
619 /* ( */
620 printf(")");
621 }
622 }
623
624 static void
625 bgp_notification_print(const u_char *dat, int length)
626 {
627 struct bgp_notification bgpn;
628 int hlen;
629
630 memcpy(&bgpn, dat, sizeof(bgpn));
631 hlen = ntohs(bgpn.bgpn_len);
632
633 printf(": error %s,", bgp_notify_major(bgpn.bgpn_major));
634 printf(" subcode %s",
635 bgp_notify_minor(bgpn.bgpn_major, bgpn.bgpn_minor));
636 }
637
638 static void
639 bgp_header_print(const u_char *dat, int length)
640 {
641 struct bgp bgp;
642
643 memcpy(&bgp, dat, sizeof(bgp));
644 printf("(%s", bgp_type(bgp.bgp_type)); /* ) */
645
646 switch (bgp.bgp_type) {
647 case BGP_OPEN:
648 bgp_open_print(dat, length);
649 break;
650 case BGP_UPDATE:
651 bgp_update_print(dat, length);
652 break;
653 case BGP_NOTIFICATION:
654 bgp_notification_print(dat, length);
655 break;
656 }
657
658 /* ( */
659 printf(")");
660 }
661
662 void
663 bgp_print(const u_char *dat, int length)
664 {
665 const u_char *p;
666 const u_char *ep;
667 const u_char *start;
668 const u_char marker[] = {
669 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
670 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
671 };
672 struct bgp bgp;
673 u_int16_t hlen;
674 int newline;
675
676 ep = dat + length;
677 if (snapend < dat + length)
678 ep = snapend;
679
680 printf(": BGP");
681
682 p = dat;
683 newline = 0;
684 start = p;
685 while (p < snapend) {
686 if (!TTEST2(p[0], 1))
687 break;
688 if (p[0] != 0xff) {
689 p++;
690 continue;
691 }
692
693 if (!TTEST2(p[0], sizeof(marker)))
694 break;
695 if (memcmp(p, marker, sizeof(marker)) != 0) {
696 p++;
697 continue;
698 }
699
700 /* found BGP header */
701 TCHECK2(p[0], BGP_SIZE); /*XXX*/
702 memcpy(&bgp, p, sizeof(bgp));
703
704 if (start != p)
705 printf(" [|BGP]");
706
707 hlen = ntohs(bgp.bgp_len);
708 if (vflag && newline)
709 printf("\n\t");
710 else
711 printf(" ");
712 if (TTEST2(p[0], hlen)) {
713 bgp_header_print(p, hlen);
714 newline = 1;
715 p += hlen;
716 start = p;
717 } else {
718 printf("[|BGP %s]", bgp_type(bgp.bgp_type));
719 break;
720 }
721 }
722
723 return;
724
725 trunc:
726 printf(" [|BGP]");
727 }
[mirror] the TCPdump network dissector