packet-bgp.c

   1 /* packet-bgp.c
   2  * Routines for BGP packet dissection.
   3  * Copyright 1999, Jun-ichiro itojun Hagino <itojun@itojun.org>
   4  *
   5  * $Id
   6  *
   7  * Supports:
   8  * RFC1771 A Border Gateway Protocol 4 (BGP-4)
   9  * RFC1997 BGP Communities Attribute
  10  * RFC2283 Multiprotocol Extensions for BGP-4
  11  *
  12  * TODO:
  13  * RFC1966 BGP Route Reflection An alternative to full mesh IBGP
  14  * RFC1863 A BGP/IDRP Route Server alternative to a full mesh routing
  15  * RFC1965 Autonomous System Confederations for BGP
  16  * Destination Preference Attribute for BGP (work in progress)
  17  *
  18  * Ethereal - Network traffic analyzer
  19  * By Gerald Combs <gerald@unicom.net>
  20  * Copyright 1998 Gerald Combs
  21  *
  22  * This program is free software; you can redistribute it and/or
  23  * modify it under the terms of the GNU General Public License
  24  * as published by the Free Software Foundation; either version 2
  25  * of the License, or (at your option) any later version.
  26  *
  27  * This program is distributed in the hope that it will be useful,
  28  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  29  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  30  * GNU General Public License for more details.
  31  *
  32  * You should have received a copy of the GNU General Public License
  33  * along with this program; if not, write to the Free Software
  34  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  35  */
  36
  37 #ifdef HAVE_CONFIG_H
  38 # include "config.h"
  39 #endif
  40
  41 #include <stdio.h>
  42 #include <stdlib.h>
  43
  44 #ifdef HAVE_SYS_TYPES_H
  45 # include <sys/types.h>
  46 #endif
  47
  48 #ifdef HAVE_NETINET_IN_H
  49 # include <netinet/in.h>
  50 #endif
  51
  52 #ifdef NEED_SNPRINTF_H
  53 # ifdef HAVE_STDARG_H
  54 #  include <stdarg.h>
  55 # else
  56 #  include <varargs.h>
  57 # endif
  58 # include "snprintf.h"
  59 #endif
  60
  61 #include <string.h>
  62 #include <glib.h>
  63 #include "packet.h"
  64 #include "packet-bgp.h"
  65 #include "packet-ipv6.h"
  66 #include <arpa/inet.h>
  67
  68 static const value_string bgptypevals[] = {
  69     { BGP_OPEN, "OPEN Message" },
  70     { BGP_UPDATE, "UPDATE Message" },
  71     { BGP_NOTIFICATION, "NOTIFICATION Message" },
  72     { BGP_KEEPALIVE, "KEEPALIVE Message" },
  73     { 0, NULL },
  74 };
  75
  76 static const value_string bgpnotify_major[] = {
  77     { 1, "Message Header Error" },
  78     { 2, "OPEN Message Error" },
  79     { 3, "UPDATE Message Error" },
  80     { 4, "Hold Timer Expired" },
  81     { 5, "Finite State Machine Error" },
  82     { 6, "Cease" },
  83     { 0, NULL },
  84 };
  85
  86 static const value_string bgpnotify_minor_1[] = {
  87     { 1, "Connection Not Synchronized" },
  88     { 2, "Bad Message Length" },
  89     { 3, "Bad Message Type" },
  90     { 0, NULL },
  91 };
  92
  93 static const value_string bgpnotify_minor_2[] = {
  94     { 1, "Unsupported Version Number" },
  95     { 2, "Bad Peer AS" },
  96     { 3, "Bad BGP Identifier" },
  97     { 4, "Unsupported Optional Parameter" },
  98     { 5, "Authentication Failure" },
  99     { 6, "Unacceptable Hold Time" },
 100     { 0, NULL },
 101 };
 102
 103 static const value_string bgpnotify_minor_3[] = {
 104     { 1, "Malformed Attribute List" },
 105     { 2, "Unrecognized Well-known Attribute" },
 106     { 3, "Missing Well-known Attribute" },
 107     { 4, "Attribute Flags Error" },
 108     { 5, "Attribute Length Error" },
 109     { 6, "Invalid ORIGIN Attribute" },
 110     { 7, "AS Routing Loop" },
 111     { 8, "Invalid NEXT_HOP Attribute" },
 112     { 9, "Optional Attribute Error" },
 113     { 10, "Invalid Network Field" },
 114     { 11, "Malformed AS_PATH" },
 115     { 0, NULL },
 116 };
 117
 118 static const value_string *bgpnotify_minor[] = {
 119     NULL, bgpnotify_minor_1, bgpnotify_minor_2, bgpnotify_minor_3,
 120 };
 121
 122 static const value_string bgpattr_origin[] = {
 123     { 0, "IGP" },
 124     { 1, "EGP" },
 125     { 2, "INCOMPLETE" },
 126     { 0, NULL },
 127 };
 128
 129 static const value_string as_segment_type[] = {
 130     { 1, "AS_SET" },
 131     { 2, "AS_SEQUENCE" },
 132     { 3, "AS_CONFED_SET" },
 133     { 4, "AS_CONFED_SEQUENCE" },
 134     { 0, NULL },
 135 };
 136
 137 static const value_string bgpattr_type[] = {
 138     { BGPTYPE_ORIGIN, "ORIGIN" },
 139     { BGPTYPE_AS_PATH, "AS_PATH" },
 140     { BGPTYPE_NEXT_HOP, "NEXT_HOP" },
 141     { BGPTYPE_MULTI_EXIT_DISC, "MULTI_EXIT_DISC" },
 142     { BGPTYPE_LOCAL_PREF, "LOCAL_PREF" },
 143     { BGPTYPE_ATOMIC_AGGREGATE, "ATOMIC_AGGREGATE" },
 144     { BGPTYPE_AGGREGATOR, "AGGREGATOR" },
 145     { BGPTYPE_COMMUNITIES, "COMMUNITIES" },
 146     { BGPTYPE_ORIGINATOR_ID, "ORIGINATOR_ID" },
 147     { BGPTYPE_CLUSTER_LIST, "CLUSTER_LIST" },
 148     { BGPTYPE_MP_REACH_NLRI, "MP_REACH_NLRI" },
 149     { BGPTYPE_MP_UNREACH_NLRI, "MP_UNREACH_NLRI" },
 150     { 0, NULL },
 151 };
 152
 153 /* Subsequent address family identifier, RFC2283 section 7 */
 154 static const value_string bgpattr_nlri_safi[] = {
 155     { 0, "Reserved" },
 156     { 1, "Unicast" },
 157     { 2, "Multicast" },
 158     { 3, "Unicast+Multicast" },
 159     { 0, NULL },
 160 };
 161
 162 static const value_string afnumber[] = {
 163     { 0, "Reserved" },
 164     { AFNUM_INET, "IPv4" },
 165     { AFNUM_INET6, "IPv6" },
 166     { AFNUM_NSAP, "NSAP" },
 167     { AFNUM_HDLC, "HDLC" },
 168     { AFNUM_BBN1822, "BBN 1822" },
 169     { AFNUM_802, "802" },
 170     { AFNUM_E163, "E.163" },
 171     { AFNUM_E164, "E.164" },
 172     { AFNUM_F69, "F.69" },
 173     { AFNUM_X121, "X.121" },
 174     { AFNUM_IPX, "IPX" },
 175     { AFNUM_ATALK, "Appletalk" },
 176     { AFNUM_DECNET, "Decnet IV" },
 177     { AFNUM_BANYAN, "Banyan Vines" },
 178     { AFNUM_E164NSAP, "E.164 with NSAP subaddress" },
 179     { 65535, "Reserved" },
 180     { 0, NULL },
 181 };
 182
 183 static int proto_bgp = -1;
 184
 185 static gint ett_bgp = -1;
 186 static gint ett_bgp_unfeas = -1;
 187 static gint ett_bgp_attrs = -1;
 188 static gint ett_bgp_attr = -1;
 189 static gint ett_bgp_attr_flags = -1;
 190 static gint ett_bgp_mp_reach_nlri = -1;
 191 static gint ett_bgp_mp_unreach_nlri = -1;
 192 static gint ett_bgp_nlri = -1;
 193 static gint ett_bgp_open = -1;
 194 static gint ett_bgp_update = -1;
 195 static gint ett_bgp_notification = -1;
 196 static gint ett_bgp_as_paths = -1;
 197
 198 /*
 199  * Decode an IPv4 prefix.
 200  */
 201 static int
 202 decode_prefix4(const u_char *pd, char *buf, int buflen)
 203 {
 204     guint8 addr[4];   /* IP address                         */
 205     int    plen;      /* prefix length                      */
 206     int    length;    /* number of octets needed for prefix */
 207
 208     /* snarf length */
 209     plen = pd[0];
 210     if (plen < 0 || 32 < plen)
 211         return -1;
 212     length = (plen + 7) / 8;
 213
 214     /* snarf prefix */
 215     memset(addr, 0, sizeof(addr));
 216     memcpy(addr, &pd[1], length);
 217     if (plen % 8)
 218         addr[length - 1] &= ((0xff00 >> (plen % 8)) & 0xff);
 219
 220     /* hand back a formatted string */
 221     snprintf(buf, buflen, "%s/%d", ip_to_str(addr), plen);
 222     return(1 + length);
 223 }
 224
 225 /*
 226  * Decode an IPv6 prefix.
 227  */
 228 static int
 229 decode_prefix6(const u_char *pd, char *buf, int buflen)
 230 {
 231     struct e_in6_addr addr;     /* IPv6 address                       */
 232     int               plen;     /* prefix length                      */
 233     int               length;   /* number of octets needed for prefix */
 234
 235     /* snarf length */
 236     plen = pd[0];
 237     if (plen < 0 || 128 < plen)
 238         return -1;
 239     length = (plen + 7) / 8;
 240
 241     /* snarf prefix */
 242     memset(&addr, 0, sizeof(addr));
 243     memcpy(&addr, &pd[1], length);
 244     if (plen % 8)
 245         addr.s6_addr[length - 1] &= ((0xff00 >> (plen % 8)) & 0xff);
 246
 247     /* hand back a formatted string */
 248     snprintf(buf, buflen, "%s/%d", ip6_to_str(&addr), plen);
 249     return(1 + length);
 250 }
 251
 252 /*
 253  * Dissect a BGP OPEN message.
 254  */
 255 static void
 256 dissect_bgp_open(const u_char *pd, int offset, frame_data *fd, proto_tree *tree)
 257 {
 258     struct bgp_open bgpo;   /* BGP OPEN message   */
 259     int             hlen;   /* message length     */
 260
 261     /* snarf OPEN message */
 262     memcpy(&bgpo, &pd[offset], sizeof(bgpo));
 263     hlen = ntohs(bgpo.bgpo_len);
 264
 265     proto_tree_add_text(tree,
 266         offset + offsetof(struct bgp_open, bgpo_version), 1,
 267         "Version: %u", bgpo.bgpo_version);
 268     proto_tree_add_text(tree,
 269         offset + offsetof(struct bgp_open, bgpo_myas), 2,
 270         "My AS: %u", ntohs(bgpo.bgpo_myas));
 271     proto_tree_add_text(tree,
 272         offset + offsetof(struct bgp_open, bgpo_holdtime), 2,
 273         "Hold time: %u", ntohs(bgpo.bgpo_holdtime));
 274     proto_tree_add_text(tree,
 275         offset + offsetof(struct bgp_open, bgpo_id), 4,
 276         "BGP identifier: %s", ip_to_str((guint8 *)&bgpo.bgpo_id));
 277     proto_tree_add_text(tree,
 278         offset + offsetof(struct bgp_open, bgpo_optlen), 1,
 279         "Optional parameters length: %u %s", bgpo.bgpo_optlen,
 280         (bgpo.bgpo_optlen == 1) ? "byte" : "bytes");
 281
 282     if (hlen > sizeof(struct bgp_open)) {
 283         int openoff;
 284         openoff = ((char *)&bgpo.bgpo_optlen - (char *)&bgpo) + 1;
 285         proto_tree_add_text(tree,
 286             offset + openoff, hlen - openoff,
 287             "Optional parameters");
 288     }
 289 }
 290
 291 /*
 292  * Dissect a BGP UPDATE message.
 293  */
 294 static void
 295 dissect_bgp_update(const u_char *pd, int offset, frame_data *fd,
 296     proto_tree *tree)
 297 {
 298     struct bgp bgp;                        /* BGP header            */
 299     struct bgp_attr bgpa;                  /* path attributes       */
 300     int             hlen;                  /* message length        */
 301     const u_char    *p;                    /* packet offset pointer */
 302     const u_char    *q;                    /* tmp                   */
 303     const u_char    *end;                  /* message end           */
 304     int             len;                   /* tmp                   */
 305     proto_item      *ti;                   /* tree item             */
 306     proto_tree      *subtree;              /* subtree for attibutes */
 307     proto_tree      *subtree2;             /* subtree for attibutes */
 308     proto_tree      *subtree3;             /* subtree for attibutes */
 309     proto_tree      *as_paths_tree;        /* subtree for AS_PATHs  */
 310     proto_tree      *as_path_tree;         /* subtree for AS_PATH   */
 311     int             i, j;                  /* tmp                   */
 312     guint8          length;                /* AS_PATH length        */
 313     guint8          type;                  /* AS_PATH type          */
 314     char            *as_path_str = NULL;   /* AS_PATH string        */
 315     char            junk_buf[256];         /* tmp                   */
 316
 317
 318     /* snarf UPDATE message */
 319     memcpy(&bgp, &pd[offset], sizeof(bgp));
 320     hlen = ntohs(bgp.bgp_len);
 321     p = &pd[offset + BGP_HEADER_SIZE];  /*XXX*/
 322
 323     /* check for withdrawals */
 324     len = ntohs(*(guint16 *)p);
 325     proto_tree_add_text(tree, p - pd, 2,
 326         "Unfeasible routes length: %u %s", len, (len == 1) ? "byte" : "bytes");
 327     p += 2;
 328
 329     /* parse unfeasible prefixes */
 330     if (len > 0) {
 331         ti = proto_tree_add_text(tree, p - pd, len, "Withdrawn routes:");
 332         subtree = proto_item_add_subtree(ti, ett_bgp_unfeas);
 333
 334         /* parse each prefixes */
 335         end = p + len;
 336         while (p < end) {
 337             i = decode_prefix4(p, junk_buf, sizeof(junk_buf));
 338             proto_tree_add_text(subtree, p - pd, i, "%s", junk_buf);
 339             p += i;
 340         }
 341     }
 342     else {
 343         p += len;
 344     }
 345
 346     /* check for advertisements */
 347     len = ntohs(*(guint16 *)p);
 348     proto_tree_add_text(tree, p - pd, 2, "Total path attribute length: %u %s",
 349             len, (len == 1) ? "byte" : "bytes");
 350
 351     /* path attributes */
 352 /* --- move --- */
 353     if (len > 0) {
 354         ti = proto_tree_add_text(tree, p - pd + 2, len, "Path attributes");
 355         subtree = proto_item_add_subtree(ti, ett_bgp_attrs);
 356         i = 2;
 357         while (i < len) {
 358             int alen, aoff;
 359             char *msg;
 360             guint16 af;
 361             int off, snpa;
 362
 363             memcpy(&bgpa, &p[i], sizeof(bgpa));
 364             /* check for the Extended Length bit */
 365             if (bgpa.bgpa_flags & BGP_ATTR_FLAG_EXTENDED_LENGTH) {
 366                 alen = ntohs(*(guint16 *)&p[i + sizeof(bgpa)]);
 367                 aoff = sizeof(bgpa) + 2;
 368             } else {
 369                 alen = p[i + sizeof(bgpa)];
 370                 aoff = sizeof(bgpa) + 1;
 371             }
 372
 373             /* This is kind of ugly - similar code appears twice, but it
 374                helps browsing attrs.                                      */
 375             /* the first switch prints things in the title of the subtree */
 376             switch (bgpa.bgpa_type) {
 377             case BGPTYPE_ORIGIN:
 378                 if (alen != 1)
 379                     goto default_attribute_top;
 380                 msg = val_to_str(p[i + aoff], bgpattr_origin, "Unknown");
 381                 ti = proto_tree_add_text(subtree, p - pd + i, alen + aoff,
 382                         "%s: %s (%u %s)",
 383                         val_to_str(bgpa.bgpa_type, bgpattr_type, "Unknown"),
 384                         msg, alen + aoff, (alen + aoff == 1) ? "byte" :
 385                         "bytes");
 386                 break;
 387             case BGPTYPE_AS_PATH:
 388                 /* (p + i + 3) =
 389                    (p + current attribute + 3 bytes to first tuple) */
 390                 end = p + alen + i + 3;
 391                 q = p + i + 3;
 392                 /* must be freed by second switch!                         */
 393                 /* "alen * 6" (5 digits + space) should be a good estimate
 394                    of how long the AS path string could be                 */
 395                 as_path_str = malloc((alen + 1) * 6);
 396                 if (as_path_str == NULL) break;
 397                 as_path_str[0] = '\0';
 398
 399                 /* snarf each AS path */
 400                 while (q < end) {
 401                     type = *q++;
 402                     if (type == AS_SET) {
 403                         snprintf(as_path_str, 2, "{");
 404                     }
 405                     length = *q++;
 406
 407                     /* ignore confederation types until we support them */
 408                     if (type == AS_CONFED_SET || type == AS_CONFED_SEQUENCE) {
 409                         q += length;
 410                         break;
 411                     }
 412
 413                     /* snarf each value in path */
 414                     for (j = 0; j < length; j++) {
 415                         snprintf(junk_buf, sizeof(junk_buf), "%u%s", pntohs(q),
 416                                 (type == AS_SET) ? ", " : " ");
 417                         strncat(as_path_str, junk_buf, sizeof(junk_buf));
 418                         q += 2;
 419                     }
 420
 421                     /* cleanup end of string */
 422                     if (type == AS_SET) {
 423                         as_path_str[strlen(as_path_str) - 2] = '}';
 424                     }
 425                     else {
 426                         as_path_str[strlen(as_path_str) - 1] = '\0';
 427                     }
 428                 }
 429
 430                 /* check for empty AS_PATH */
 431                 if (alen == 0)
 432                     strncpy(as_path_str, "empty", 6);
 433
 434                 ti = proto_tree_add_text(subtree, p - pd + i, alen + aoff,
 435                         "%s: %s (%u %s)",
 436                         val_to_str(bgpa.bgpa_type, bgpattr_type, "Unknown"),
 437                         as_path_str, alen + aoff,
 438                         (alen + aoff == 1) ? "byte" : "bytes");
 439                 break;
 440             case BGPTYPE_NEXT_HOP:
 441                 if (alen != 4)
 442                     goto default_attribute_top;
 443                 ti = proto_tree_add_text(subtree, p - pd + i, alen + aoff,
 444                         "%s: %s (%u %s)",
 445                         val_to_str(bgpa.bgpa_type, bgpattr_type, "Unknown"),
 446                         ip_to_str(&p[i + aoff]), alen + aoff, (alen + aoff == 1)
 447                         ? "byte" : "bytes");
 448                 break;
 449             case BGPTYPE_MULTI_EXIT_DISC:
 450                 if (alen != 4)
 451                     goto default_attribute_top;
 452                 ti = proto_tree_add_text(subtree, p - pd + i, alen + aoff,
 453                         "%s: %u (%u %s)",
 454                         val_to_str(bgpa.bgpa_type, bgpattr_type, "Unknown"),
 455                         ntohl(*(guint32 *)&p[i + aoff]), alen + aoff,
 456                         (alen + aoff == 1) ? "byte" : "bytes");
 457                 break;
 458             case BGPTYPE_LOCAL_PREF:
 459                 if (alen != 4)
 460                     goto default_attribute_top;
 461                 ti = proto_tree_add_text(subtree, p - pd + i, alen + aoff,
 462                         "%s: %u (%u %s)",
 463                         val_to_str(bgpa.bgpa_type, bgpattr_type, "Unknown"),
 464                         ntohl(*(guint32 *)&p[i + aoff]), alen + aoff,
 465                         (alen + aoff == 1) ? "byte" : "bytes");
 466                 break;
 467             case BGPTYPE_ATOMIC_AGGREGATE:
 468                 if (alen != 0)
 469                     goto default_attribute_top;
 470                 ti = proto_tree_add_text(subtree, p - pd + i, alen + aoff,
 471                         "%s (%u %s)",
 472                         val_to_str(bgpa.bgpa_type, bgpattr_type, "Unknown"),
 473                         alen + aoff, (alen + aoff == 1) ? "byte" : "bytes");
 474                 break;
 475             case BGPTYPE_AGGREGATOR:
 476                 if (alen != 6)
 477                     goto default_attribute_top;
 478                 ti = proto_tree_add_text(subtree, p - pd + i, alen + aoff,
 479                         "%s: AS: %u origin: %s (%u %s)",
 480                         val_to_str(bgpa.bgpa_type, bgpattr_type, "Unknown"),
 481                         ntohs(*(guint16 *)&p[i + aoff]),
 482                         ip_to_str(&p[i + aoff + 2]), alen + aoff,
 483                         (alen + aoff == 1) ? "byte" : "bytes");
 484                 break;
 485             case BGPTYPE_COMMUNITIES:
 486                 if (alen != 4)
 487                     goto default_attribute_top;
 488
 489                 /* check for well-known communities */
 490                 if (ntohl(*(guint32 *)&p[i + aoff]) == BGP_COMM_NO_EXPORT)
 491                     strncpy(junk_buf, "NO_EXPORT", 10);
 492                 else if (ntohl(*(guint32 *)&p[i + aoff]) ==
 493                         BGP_COMM_NO_ADVERTISE)
 494                     strncpy(junk_buf, "NO_ADVERTISE", 13);
 495                 else if (ntohl(*(guint32 *)&p[i + aoff]) ==
 496                         BGP_COMM_NO_EXPORT_SUBCONFED)
 497                     strncpy(junk_buf, "NO_EXPORT_SUBCONFED", 20);
 498                 else {
 499                     snprintf(junk_buf, sizeof(junk_buf), "%u:%u",
 500                             ntohs(*(guint16 *)&p[i + aoff]),
 501                             ntohs(*(guint16 *)&p[i + aoff + 2]));
 502                 }
 503
 504                 ti = proto_tree_add_text(subtree, p - pd + i, alen + aoff,
 505                         "%s: %s (%u %s)",
 506                         val_to_str(bgpa.bgpa_type, bgpattr_type, "Unknown"),
 507                         junk_buf, alen + aoff,
 508                         (alen + aoff == 1) ? "byte" : "bytes");
 509                 break;
 510             case BGPTYPE_ORIGINATOR_ID:
 511                 if (alen != 4)
 512                     goto default_attribute_top;
 513                 ti = proto_tree_add_text(subtree, p - pd + i, alen + aoff,
 514                         "%s: %s (%u %s)",
 515                         val_to_str(bgpa.bgpa_type, bgpattr_type, "Unknown"),
 516                         ip_to_str(&p[i + aoff]), alen + aoff, (alen + aoff == 1)
 517                         ? "byte" : "bytes");
 518                 break;
 519             case BGPTYPE_CLUSTER_LIST:
 520             default:
 521             default_attribute_top:
 522                 ti = proto_tree_add_text(subtree, p - pd + i, alen + aoff,
 523                         "%s (%u %s)",
 524                         val_to_str(bgpa.bgpa_type, bgpattr_type, "Unknown"),
 525                         alen + aoff, (alen + aoff == 1) ? "byte" : "bytes");
 526             }
 527             subtree2 = proto_item_add_subtree(ti, ett_bgp_attr);
 528
 529             /* figure out flags */
 530             junk_buf[0] = '\0';
 531             if (bgpa.bgpa_flags & BGP_ATTR_FLAG_OPTIONAL) {
 532                  strncat(junk_buf, "Optional, ", 10);
 533             }
 534             else {
 535                  strncat(junk_buf, "Well-known, ", 12);
 536             }
 537             if (bgpa.bgpa_flags & BGP_ATTR_FLAG_TRANSITIVE) {
 538                  strncat(junk_buf, "Transitive, ", 12);
 539             }
 540             else {
 541                  strncat(junk_buf, "Non-transitive, ", 16);
 542             }
 543             if (bgpa.bgpa_flags & BGP_ATTR_FLAG_PARTIAL) {
 544                  strncat(junk_buf, "Partial, ", 9);
 545             }
 546             else {
 547                  strncat(junk_buf, "Complete, ", 10);
 548             }
 549             if (bgpa.bgpa_flags & BGP_ATTR_FLAG_EXTENDED_LENGTH) {
 550                  strncat(junk_buf, "Extended Length, ", 17);
 551             }
 552             /* stomp last ", " */
 553             j = strlen(junk_buf);
 554             junk_buf[j - 2] = '\0';
 555             ti = proto_tree_add_text(subtree2,
 556                     p - pd + i + offsetof(struct bgp_attr, bgpa_flags), 1,
 557                     "Flags: 0x%02x (%s)", bgpa.bgpa_flags, junk_buf);
 558             subtree3 = proto_item_add_subtree(ti, ett_bgp_attr_flags);
 559
 560             /* add flag bitfield subtrees */
 561             proto_tree_add_text(subtree3,
 562                     p - pd + i + offsetof(struct bgp_attr, bgpa_flags), 1,
 563                     "%s", decode_boolean_bitfield(bgpa.bgpa_flags,
 564                         BGP_ATTR_FLAG_OPTIONAL, 8, "Optional", "Well-known"));
 565             proto_tree_add_text(subtree3,
 566                     p - pd + i + offsetof(struct bgp_attr, bgpa_flags), 1,
 567                     "%s", decode_boolean_bitfield(bgpa.bgpa_flags,
 568                         BGP_ATTR_FLAG_TRANSITIVE, 8, "Transitive",
 569                         "Non-transitive"));
 570             proto_tree_add_text(subtree3,
 571                     p - pd + i + offsetof(struct bgp_attr, bgpa_flags), 1,
 572                     "%s", decode_boolean_bitfield(bgpa.bgpa_flags,
 573                         BGP_ATTR_FLAG_PARTIAL, 8, "Partial", "Complete"));
 574             proto_tree_add_text(subtree3,
 575                     p - pd + i + offsetof(struct bgp_attr, bgpa_flags), 1,
 576                     "%s", decode_boolean_bitfield(bgpa.bgpa_flags,
 577                         BGP_ATTR_FLAG_EXTENDED_LENGTH, 8, "Extended length",
 578                         "Regular length"));
 579
 580             proto_tree_add_text(subtree2,
 581                     p - pd + i + offsetof(struct bgp_attr, bgpa_type), 1,
 582                     "Type code: %s (%u)",
 583                     val_to_str(bgpa.bgpa_type, bgpattr_type, "Unknown"),
 584                     bgpa.bgpa_type);
 585
 586             proto_tree_add_text(subtree2, p - pd + i + sizeof(bgpa),
 587                     aoff - sizeof(bgpa), "Length: %d %s", alen,
 588                     (alen == 1) ? "byte" : "bytes");
 589
 590             /* the second switch prints things in the actual subtree of each
 591                attribute                                                     */
 592             switch (bgpa.bgpa_type) {
 593             case BGPTYPE_ORIGIN:
 594                 if (alen != 1) {
 595                     proto_tree_add_text(subtree2, p - pd + i + aoff, alen,
 596                             "Origin (invalid): %u %s", alen,
 597                              (alen == 1) ? "byte" : "bytes");
 598                 } else {
 599                     msg = val_to_str(p[i + aoff], bgpattr_origin, "Unknown");
 600                     proto_tree_add_text(subtree2, p - pd + i + aoff, 1,
 601                             "Origin: %s (%u)", msg, p[i + aoff]);
 602                 }
 603                 break;
 604             case BGPTYPE_AS_PATH:
 605                 /* check for empty AS_PATH */
 606                 if (alen == 0) {
 607                     free(as_path_str);
 608                     break;
 609                 }
 610
 611                 ti = proto_tree_add_text(subtree2, p - pd + i + aoff, alen,
 612                         "AS path: %s", as_path_str);
 613                 as_paths_tree = proto_item_add_subtree(ti, ett_bgp_as_paths);
 614
 615                 /* (p + i + 3) =
 616                    (p + current attribute + 3 bytes to first tuple) */
 617                 end = p + alen + i + 3;
 618                 q = p + i + 3;
 619
 620                 /* snarf each AS path tuple */
 621                 while (q < end) {
 622                     as_path_str[0] = '\0';
 623                     type = *q++;
 624                     if (type == AS_SET) {
 625                         snprintf(as_path_str, 2, "{");
 626                     }
 627                     length = *q++;
 628
 629                     /* ignore confederation types until we support them */
 630                     if (type == AS_CONFED_SET || type == AS_CONFED_SEQUENCE) {
 631                         q += length;
 632                         break;
 633                     }
 634
 635                     /* snarf each value in path, we're just going to reuse
 636                        as_path_str since we already have it malloced       */
 637                     for (j = 0; j < length; j++) {
 638                         snprintf(junk_buf, sizeof(junk_buf), "%u%s", pntohs(q),
 639                                 (type == AS_SET) ? ", " : " ");
 640                         strncat(as_path_str, junk_buf, sizeof(junk_buf));
 641                         q += 2;
 642                     }
 643
 644                     /* cleanup end of string */
 645                     if (type == AS_SET) {
 646                         as_path_str[strlen(as_path_str) - 2] = '}';
 647                     }
 648                     else {
 649                         as_path_str[strlen(as_path_str) - 1] = '\0';
 650                     }
 651
 652                     /* length here means number of ASs, ie length * 2 bytes */
 653                     ti = proto_tree_add_text(as_paths_tree,
 654                             q - pd - length * 2 - 2,
 655                             length * 2 + 2, "AS path segment: %s", as_path_str);
 656                     as_path_tree = proto_item_add_subtree(ti, ett_bgp_as_paths);
 657                     proto_tree_add_text(as_path_tree, q - pd - length * 2 - 2,
 658                             1, "Path segment type: %s (%u)",
 659                             val_to_str(type, as_segment_type, "Unknown"), type);
 660                     proto_tree_add_text(as_path_tree, q - pd - length * 2 - 1,
 661                             1, "Path segment length: %u %s", length,
 662                             (length == 1) ? "AS" : "ASs");
 663                     proto_tree_add_text(as_path_tree, q - pd - length * 2,
 664                             length * 2, "Path segment value: %s", as_path_str);
 665                 }
 666
 667                 free(as_path_str);
 668                 break;
 669             case BGPTYPE_NEXT_HOP:
 670                 if (alen != 4) {
 671                     proto_tree_add_text(subtree2, p - pd + i + aoff, alen,
 672                             "Next hop (invalid): %u %s", alen,
 673                             (alen == 1) ? "byte" : "bytes");
 674                 } else {
 675                     proto_tree_add_text(subtree2, p - pd + i + aoff, alen,
 676                             "Next hop: %s", ip_to_str(&p[i + aoff]));
 677                 }
 678                 break;
 679             case BGPTYPE_MULTI_EXIT_DISC:
 680                 if (alen != 4) {
 681                     proto_tree_add_text(subtree2, p - pd + i + aoff, alen,
 682                             "Multi exit discriminator (invalid): %u %s",
 683                             alen, (alen == 1) ? "byte" : "bytes");
 684                 } else {
 685                     proto_tree_add_text(subtree2, p - pd + i + aoff, alen,
 686                             "Multi exit discriminator: %u",
 687                             ntohl(*(guint32 *)&p[i + aoff]));
 688                 }
 689                 break;
 690             case BGPTYPE_LOCAL_PREF:
 691                 if (alen != 4) {
 692                     proto_tree_add_text(subtree2, p - pd + i + aoff, alen,
 693                             "Local preference (invalid): %u %s", alen,
 694                              (alen == 1) ? "byte" : "bytes");
 695                 } else {
 696                     proto_tree_add_text(subtree2, p - pd + i + aoff, alen,
 697                             "Local preference: %u",
 698                             ntohl(*(guint32 *)&p[i + aoff]));
 699                 }
 700                 break;
 701             case BGPTYPE_ATOMIC_AGGREGATE:
 702                 if (alen != 0) {
 703                     proto_tree_add_text(subtree2, p - pd + i + aoff, alen,
 704                             "Atomic aggregate (invalid): %u %s", alen,
 705                             (alen == 1) ? "byte" : "bytes");
 706                 }
 707                 break;
 708             case BGPTYPE_AGGREGATOR:
 709                 if (alen != 6) {
 710                     proto_tree_add_text(subtree2, p - pd + i + aoff, alen,
 711                             "Aggregator (invalid): %u %s", alen,
 712                             (alen == 1) ? "byte" : "bytes");
 713                 } else {
 714                     proto_tree_add_text(subtree2, p - pd + i + aoff, 2,
 715                             "Aggregator AS: %u",
 716                             ntohs(*(guint16 *)&p[i + aoff]));
 717                     proto_tree_add_text(subtree2, p - pd + i + aoff + 2, 4,
 718                             "Aggregator origin: %s",
 719                             ip_to_str(&p[i + aoff + 2]));
 720                 }
 721                 break;
 722             case BGPTYPE_COMMUNITIES:
 723                 if (alen != 4) {
 724                     proto_tree_add_text(subtree2, p - pd + i + aoff, 4,
 725                             "Communities (invalid): %u %s", alen,
 726                             (alen == 1) ? "byte" : "bytes");
 727                 }
 728                 /* check for reserved values */
 729                 else if (ntohs(*(guint16 *)&p[i + aoff]) == FOURHEX0 ||
 730                         ntohs(*(guint16 *)&p[i + aoff]) == FOURHEXF) {
 731                     /* check for well-known communities */
 732                     if (ntohl(*(guint32 *)&p[i + aoff]) == BGP_COMM_NO_EXPORT)
 733                         proto_tree_add_text(subtree2, p - pd + i + aoff, 4,
 734                                 "Communities: NO_EXPORT (0x%x)",
 735                                 ntohl(*(guint32 *)&p[i + aoff]));
 736                     else if (ntohl(*(guint32 *)&p[i + aoff]) ==
 737                             BGP_COMM_NO_ADVERTISE)
 738                         proto_tree_add_text(subtree2, p - pd + i + aoff, 4,
 739                                 "Communities: NO_ADVERTISE (0x%x)",
 740                                 ntohl(*(guint32 *)&p[i + aoff]));
 741                     else if (ntohl(*(guint32 *)&p[i + aoff]) ==
 742                             BGP_COMM_NO_EXPORT_SUBCONFED)
 743                         proto_tree_add_text(subtree2, p - pd + i + aoff, 4,
 744                                 "Communities: NO_EXPORT_SUBCONFED (0x%x)",
 745                                 ntohl(*(guint32 *)&p[i + aoff]));
 746                     else {
 747                         proto_tree_add_text(subtree2, p - pd + i + aoff, 4,
 748                                 "Communities (reserved): 0x%x",
 749                                 ntohl(*(guint32 *)&p[i + aoff]));
 750                     }
 751                 }
 752                 else {
 753                     proto_tree_add_text(subtree2, p - pd + i + aoff, 2,
 754                             "Communities AS: %u",
 755                             ntohs(*(guint16 *)&p[i + aoff]));
 756                     proto_tree_add_text(subtree2, p - pd + i + aoff + 2, 2,
 757                             "Communities value: %u",
 758                             ntohs(*(guint16 *)&p[i + aoff + 2]));
 759                 }
 760                 break;
 761             case BGPTYPE_ORIGINATOR_ID:
 762                 if (alen != 4) {
 763                     proto_tree_add_text(subtree2, p - pd + i + aoff, alen,
 764                             "Originator identifier (invalid): %u %s", alen,
 765                             (alen == 1) ? "byte" : "bytes");
 766                 } else {
 767                     proto_tree_add_text(subtree2, p - pd + i + aoff, alen,
 768                             "Originator identifier: %s",
 769                             ip_to_str(&p[i + aoff]));
 770                 }
 771                 break;
 772             case BGPTYPE_MP_REACH_NLRI:
 773                 af = ntohs(*(guint16 *)&p[i + aoff]);
 774                 proto_tree_add_text(subtree2, p - pd + i + aoff, 2,
 775                     "Address family: %s (%u)",
 776                     val_to_str(af, afnumber, "Unknown"), af);
 777                 proto_tree_add_text(subtree2, p - pd + i + aoff + 2, 1,
 778                     "Subsequent address family identifier: %s (%u)",
 779                     val_to_str(p[i + aoff + 2], bgpattr_nlri_safi,
 780                         p[i + aoff + 2] >= 128 ? "Vendor specific" : "Unknown"),
 781                     p[i + aoff + 2]);
 782                 ti = proto_tree_add_text(subtree2, p - pd + i + aoff + 3, 1,
 783                         "Next hop network address (%d %s)",
 784                         p[i + aoff + 3], (p[i + aoff + 3] == 1) ? "byte" :
 785                         "bytes");
 786                 if (af == AFNUM_INET || af == AFNUM_INET6) {
 787                     int j, advance;
 788                     const char *s;
 789
 790                     subtree3 = proto_item_add_subtree(ti, ett_bgp_mp_reach_nlri);
 791
 792                     j = 0;
 793                     while (j < p[i + aoff + 3]) {
 794                         if (af == AFNUM_INET)
 795                             advance = 4;
 796                         else if (af == AFNUM_INET6)
 797                             advance = 16;
 798                         else
 799                             break;
 800                         if (j + advance > p[i + aoff + 3])
 801                             break;
 802
 803                         if (af == AFNUM_INET)
 804                             s = ip_to_str(&p[i + aoff + 4 + j]);
 805                         else {
 806                             s = ip6_to_str((struct e_in6_addr *)
 807                                 &p[i + aoff + 4 + j]);
 808                         }
 809                         proto_tree_add_text(subtree3,
 810                             p - pd + i + aoff + 4 + j, advance,
 811                             "Next hop: %s", s);
 812                         j += advance;
 813                     }
 814                 }
 815
 816                 alen -= (p[i + aoff + 3] + 4);
 817                 aoff += (p[i + aoff + 3] + 4);
 818                 off = 0;
 819                 snpa = p[i + aoff];
 820                 ti = proto_tree_add_text(subtree2, p - pd + i + aoff, 1,
 821                         "Subnetwork points of attachment: %u", snpa);
 822                 off++;
 823                 if (snpa)
 824                     subtree3 = proto_item_add_subtree(ti, ett_bgp_mp_reach_nlri);
 825                 for (/*nothing*/; snpa > 0; snpa--) {
 826                     proto_tree_add_text(subtree3, p - pd + i + aoff + off, 1,
 827                         "SNPA length: ", p[i + aoff + off]);
 828                     off++;
 829                     proto_tree_add_text(subtree3, p - pd + i + aoff + off,
 830                         p[i + aoff + off - 1],
 831                         "SNPA (%u %s)", p[i + aoff + off - 1],
 832                         (p[i + aoff + off - 1] == 1) ? "byte" : "bytes");
 833                     off += p[i + aoff + off - 1];
 834                 }
 835
 836                 alen -= off;
 837                 aoff += off;
 838                 ti = proto_tree_add_text(subtree2, p - pd + i + aoff, alen,
 839                         "Network layer reachability information (%u %s)",
 840                         alen, (alen == 1) ? "byte" : "bytes");
 841                 if (alen)
 842                     subtree3 = proto_item_add_subtree(ti, ett_bgp_mp_unreach_nlri);
 843                 while (alen > 0) {
 844                     int advance;
 845                     char buf[256];
 846
 847                     if (af == AFNUM_INET) {
 848                         advance = decode_prefix4(&p[i + aoff], buf,
 849                             sizeof(buf));
 850                     } else if (af == AFNUM_INET6) {
 851                         advance = decode_prefix6(&p[i + aoff], buf,
 852                             sizeof(buf));
 853                     } else
 854                         break;
 855                     if (advance < 0)
 856                         break;
 857                     if (alen < advance)
 858                         break;
 859                     proto_tree_add_text(subtree3, p - pd + i + aoff, advance,
 860                         "Network layer reachability information: %s", buf);
 861
 862                     alen -= advance;
 863                     aoff += advance;
 864                 }
 865
 866                 break;
 867             case BGPTYPE_MP_UNREACH_NLRI:
 868                 af = ntohs(*(guint16 *)&p[i + aoff]);
 869                 proto_tree_add_text(subtree2, p - pd + i + aoff, 2,
 870                     "Address family: %s (%u)",
 871                     val_to_str(af, afnumber, "Unknown"), af);
 872                 proto_tree_add_text(subtree2, p - pd + i + aoff + 2, 1,
 873                     "Subsequent address family identifier: %s (%u)",
 874                     val_to_str(p[i + aoff + 2], bgpattr_nlri_safi,
 875                         p[i + aoff + 2] >= 128 ? "Vendor specific" : "Unknown"),
 876                     p[i + aoff + 2]);
 877                 ti = proto_tree_add_text(subtree2, p - pd + i + aoff + 3,
 878                         alen - 3, "Withdrawn routes (%u %s)", alen - 3,
 879                         (alen - 3 == 1) ? "byte" : "bytes");
 880
 881                 alen -= 3;
 882                 aoff += 3;
 883                 if (alen > 0)
 884                     subtree3 = proto_item_add_subtree(ti, ett_bgp_mp_unreach_nlri);
 885                 while (alen > 0) {
 886                     int advance;
 887                     char buf[256];
 888
 889                     if (af == AFNUM_INET) {
 890                         advance = decode_prefix4(&p[i + aoff], buf,
 891                             sizeof(buf));
 892                     } else if (af == AFNUM_INET6) {
 893                         advance = decode_prefix6(&p[i + aoff], buf,
 894                             sizeof(buf));
 895                     } else
 896                         break;
 897                     if (advance < 0)
 898                         break;
 899                     if (alen < advance)
 900                         break;
 901                     proto_tree_add_text(subtree3, p - pd + i + aoff, advance,
 902                         "Withdrawn route: %s", buf);
 903
 904                     alen -= advance;
 905                     aoff += advance;
 906                 }
 907
 908                 break;
 909             case BGPTYPE_CLUSTER_LIST:
 910             default:
 911                 proto_tree_add_text(subtree2, p - pd + i + aoff, alen,
 912                         "Unknown (%d %s)", alen, (alen == 1) ? "byte" :
 913                         "bytes");
 914                 break;
 915             }
 916
 917             i += alen + aoff;
 918         }
 919 /* --- move --- */
 920         p += 2 + len;
 921
 922         /* NLRI */
 923         len = hlen - (p - &pd[offset]);
 924
 925         /* parse prefixes */
 926         if (len > 0) {
 927            ti = proto_tree_add_text(tree, p - pd, len,
 928                    "Network layer reachability information: %u %s", len,
 929                    (len == 1) ? "byte" : "bytes");
 930             subtree = proto_item_add_subtree(ti, ett_bgp_nlri);
 931             end = p + len;
 932             while (p < end) {
 933                 i = decode_prefix4(p, junk_buf, sizeof(junk_buf));
 934                 proto_tree_add_text(subtree, p - pd, i, "%s", junk_buf);
 935                 p += i;
 936             }
 937         }
 938     }
 939 }
 940
 941 /*
 942  * Dissect a BGP NOTIFICATION message.
 943  */
 944 static void
 945 dissect_bgp_notification(const u_char *pd, int offset, frame_data *fd,
 946     proto_tree *tree)
 947 {
 948     struct bgp_notification bgpn;   /* BGP NOTIFICATION message */
 949     int                     hlen;   /* message length           */
 950     char                    *p;     /* string pointer           */
 951
 952     /* snarf message */
 953     memcpy(&bgpn, &pd[offset], sizeof(bgpn));
 954     hlen = ntohs(bgpn.bgpn_len);
 955
 956     /* print error code */
 957     proto_tree_add_text(tree,
 958         offset + offsetof(struct bgp_notification, bgpn_major), 1,
 959         "Error code: %s (%u)",
 960         val_to_str(bgpn.bgpn_major, bgpnotify_major, "Unknown"),
 961         bgpn.bgpn_major);
 962
 963     /* print error subcode */
 964     if (bgpn.bgpn_major < array_length(bgpnotify_minor)
 965      && bgpnotify_minor[bgpn.bgpn_major] != NULL) {
 966         p = val_to_str(bgpn.bgpn_minor, bgpnotify_minor[bgpn.bgpn_major],
 967             "Unknown");
 968     } else if (bgpn.bgpn_minor == 0)
 969         p = "Unspecified";
 970     else
 971         p = "Unknown";
 972     proto_tree_add_text(tree,
 973         offset + offsetof(struct bgp_notification, bgpn_minor), 1,
 974         "Error subcode: %s (%u)", p, bgpn.bgpn_minor);
 975
 976     /* only print if there is optional data */
 977     if (hlen > BGP_MIN_NOTIFICATION_MSG_SIZE) {
 978         proto_tree_add_text(tree, offset + BGP_MIN_NOTIFICATION_MSG_SIZE,
 979             hlen - BGP_MIN_NOTIFICATION_MSG_SIZE, "Data");
 980     }
 981 }
 982
 983 /*
 984  * Dissect a BGP packet.
 985  */
 986 void
 987 dissect_bgp(const u_char *pd, int offset, frame_data *fd, proto_tree *tree)
 988 {
 989     proto_item    *ti;           /* tree item                        */
 990     proto_tree    *bgp_tree;     /* BGP packet tree                  */
 991     proto_tree    *bgp1_tree;    /* BGP message tree                 */
 992     const u_char  *p;            /* packet offset pointer            */
 993     int           l, i;          /* tmp                              */
 994     int           found;         /* number of BGP messages in packet */
 995     static u_char marker[] = {   /* BGP message marker               */
 996         0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 997         0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 998     };
 999     struct bgp    bgp;           /* BGP header                       */
1000     int           hlen;          /* BGP header length                */
1001     char          *typ;          /* BGP message type                 */
1002
1003     if (check_col(fd, COL_PROTOCOL))
1004         col_add_str(fd, COL_PROTOCOL, "BGP");
1005
1006     p = &pd[offset];
1007     l = END_OF_FRAME;
1008     i = 0;
1009     found = -1;
1010     /* run through the TCP packet looking for BGP headers         */
1011     /* this is done twice, but this way each message type can be
1012        printed in the COL_INFO field                              */
1013     while (i < l) {
1014         /* look for bgp header */
1015         if (p[i] != 0xff) {
1016             i++;
1017             continue;
1018         }
1019         CHECK_SIZE(i, sizeof(marker), l);
1020         if (memcmp(&p[i], marker, sizeof(marker)) != 0) {
1021             i++;
1022             continue;
1023         }
1024
1025         memcpy(&bgp, &p[i], sizeof(bgp));
1026         found++;
1027         hlen = ntohs(bgp.bgp_len);
1028         typ = val_to_str(bgp.bgp_type, bgptypevals, "Unknown Message");
1029
1030         if (check_col(fd, COL_INFO)) {
1031             if (found == 0)
1032                 col_add_fstr(fd, COL_INFO, "%s", typ);
1033             else
1034                 col_append_fstr(fd, COL_INFO, ", %s", typ);
1035         }
1036
1037         i += hlen;
1038     }
1039
1040     if (tree) {
1041         ti = proto_tree_add_text(tree, offset, END_OF_FRAME,
1042                     "Border Gateway Protocol");
1043         bgp_tree = proto_item_add_subtree(ti, ett_bgp);
1044
1045         p = &pd[offset];
1046         l = END_OF_FRAME;
1047         i = 0;
1048         /* now, run through the TCP packet again, this time dissect */
1049         /* each message that we find */
1050         while (i < l) {
1051             /* look for bgp header */
1052             if (p[i] != 0xff) {
1053                 i++;
1054                 continue;
1055             }
1056             CHECK_SIZE(i, sizeof(marker), l);
1057             if (memcmp(&p[i], marker, sizeof(marker)) != 0) {
1058                 i++;
1059                 continue;
1060             }
1061
1062             memcpy(&bgp, &p[i], sizeof(bgp));
1063             hlen = ntohs(bgp.bgp_len);
1064             typ = val_to_str(bgp.bgp_type, bgptypevals, "Unknown Message");
1065             if (END_OF_FRAME < hlen) {
1066                 ti = proto_tree_add_text(bgp_tree, offset + i, END_OF_FRAME,
1067                             "%s (truncated)", typ);
1068             } else {
1069                 ti = proto_tree_add_text(bgp_tree, offset + i, hlen,
1070                             "%s", typ);
1071             }
1072             /* add a different tree for each message type */
1073             switch (bgp.bgp_type) {
1074             case BGP_OPEN:
1075                 bgp1_tree = proto_item_add_subtree(ti, ett_bgp_open);
1076                 break;
1077             case BGP_UPDATE:
1078                 bgp1_tree = proto_item_add_subtree(ti, ett_bgp_update);
1079                 break;
1080             case BGP_NOTIFICATION:
1081                 bgp1_tree = proto_item_add_subtree(ti, ett_bgp_notification);
1082                 break;
1083             case BGP_KEEPALIVE:
1084                 bgp1_tree = proto_item_add_subtree(ti, ett_bgp);
1085                 break;
1086             default:
1087                 bgp1_tree = proto_item_add_subtree(ti, ett_bgp);
1088                 break;
1089             }
1090
1091             proto_tree_add_text(bgp1_tree, offset + i, BGP_MARKER_SIZE,
1092                 "Marker", NULL);
1093
1094             if (hlen < BGP_HEADER_SIZE || hlen > BGP_MAX_PACKET_SIZE) {
1095                 proto_tree_add_text(bgp1_tree,
1096                     offset + i + offsetof(struct bgp, bgp_len), 2,
1097                     "Length (invalid): %u %s", hlen,
1098                     (hlen == 1) ? "byte" : "bytes");
1099             } else {
1100                 proto_tree_add_text(bgp1_tree,
1101                     offset + i + offsetof(struct bgp, bgp_len), 2,
1102                     "Length: %u %s", hlen,
1103                     (hlen == 1) ? "byte" : "bytes");
1104             }
1105
1106             proto_tree_add_text(bgp1_tree,
1107                 offset + i + offsetof(struct bgp, bgp_type), 1,
1108                 "Type: %s (%u)", typ, bgp.bgp_type);
1109
1110             CHECK_SIZE(i, hlen, l);
1111
1112             /* handle each message type */
1113             switch (bgp.bgp_type) {
1114             case BGP_OPEN:
1115                 dissect_bgp_open(pd, offset + i, fd, bgp1_tree);
1116                 break;
1117             case BGP_UPDATE:
1118                 dissect_bgp_update(pd, offset + i, fd, bgp1_tree);
1119                 break;
1120             case BGP_NOTIFICATION:
1121                 dissect_bgp_notification(pd, offset + i, fd, bgp1_tree);
1122                 break;
1123             case BGP_KEEPALIVE:
1124                 /* no data in KEEPALIVE messages */
1125                 break;
1126             default:
1127                 break;
1128             }
1129
1130             i += hlen;
1131         }
1132     }
1133 }
1134
1135 /*
1136  * Register ourselves.
1137  */
1138 void
1139 proto_register_bgp(void)
1140 {
1141     static gint *ett[] = {
1142       &ett_bgp,
1143       &ett_bgp_unfeas,
1144       &ett_bgp_attrs,
1145       &ett_bgp_attr,
1146       &ett_bgp_attr_flags,
1147       &ett_bgp_mp_reach_nlri,
1148       &ett_bgp_mp_unreach_nlri,
1149       &ett_bgp_nlri,
1150       &ett_bgp_open,
1151       &ett_bgp_update,
1152       &ett_bgp_notification,
1153       &ett_bgp_as_paths,
1154     };
1155
1156     proto_bgp = proto_register_protocol("Border Gateway Protocol", "bgp");
1157     proto_register_subtree_array(ett, array_length(ett));
1158 }