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