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.9.2.2 2000/01/25 18:32:53 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 sprintf(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 sprintf(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 sprintf(buf, "%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 sprintf(buf, "%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 += 4) { 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 & 0xffff); 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 } 728