1999-10-15 17:00:47 +00:00
|
|
|
/* packet-bgp.c
|
1999-11-06 01:28:50 +00:00
|
|
|
* Routines for BGP packet dissection.
|
1999-10-15 17:00:47 +00:00
|
|
|
* Copyright 1999, Jun-ichiro itojun Hagino <itojun@itojun.org>
|
|
|
|
*
|
2004-07-18 00:24:25 +00:00
|
|
|
* $Id$
|
2001-06-10 02:08:11 +00:00
|
|
|
*
|
2006-05-21 04:49:01 +00:00
|
|
|
* Wireshark - Network traffic analyzer
|
|
|
|
* By Gerald Combs <gerald@wireshark.org>
|
1999-10-15 17:00:47 +00:00
|
|
|
* Copyright 1998 Gerald Combs
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or
|
|
|
|
* modify it under the terms of the GNU General Public License
|
|
|
|
* as published by the Free Software Foundation; either version 2
|
|
|
|
* of the License, or (at your option) any later version.
|
2001-06-10 02:08:11 +00:00
|
|
|
*
|
1999-10-15 17:00:47 +00:00
|
|
|
* This program is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU General Public License for more details.
|
2001-06-10 02:08:11 +00:00
|
|
|
*
|
1999-10-15 17:00:47 +00:00
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
* along with this program; if not, write to the Free Software
|
|
|
|
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
|
|
|
*/
|
2007-08-23 20:42:27 +00:00
|
|
|
/* Supports:
|
|
|
|
* RFC1771 A Border Gateway Protocol 4 (BGP-4)
|
|
|
|
* RFC1965 Autonomous System Confederations for BGP
|
|
|
|
* RFC1997 BGP Communities Attribute
|
|
|
|
* RFC2547 BGP/MPLS VPNs
|
|
|
|
* RFC2796 BGP Route Reflection An alternative to full mesh IBGP
|
|
|
|
* RFC2842 Capabilities Advertisement with BGP-4
|
|
|
|
* RFC2858 Multiprotocol Extensions for BGP-4
|
|
|
|
* RFC2918 Route Refresh Capability for BGP-4
|
|
|
|
* RFC3107 Carrying Label Information in BGP-4
|
|
|
|
* draft-ietf-idr-as4bytes-06
|
|
|
|
* draft-ietf-idr-dynamic-cap-03
|
|
|
|
* draft-ietf-idr-bgp-ext-communities-05
|
2009-01-10 11:06:50 +00:00
|
|
|
* draft-knoll-idr-qos-attribute-03
|
2010-01-23 11:58:53 +00:00
|
|
|
* draft-nalawade-kapoor-tunnel-safi-05
|
2007-08-23 20:42:27 +00:00
|
|
|
*
|
|
|
|
* TODO:
|
|
|
|
* Destination Preference Attribute for BGP (work in progress)
|
|
|
|
* RFC1863 A BGP/IDRP Route Server alternative to a full mesh routing
|
|
|
|
*/
|
1999-10-15 17:00:47 +00:00
|
|
|
|
|
|
|
#ifdef HAVE_CONFIG_H
|
|
|
|
# include "config.h"
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#include <stdio.h>
|
|
|
|
#include <stdlib.h>
|
|
|
|
|
|
|
|
#include <string.h>
|
|
|
|
#include <glib.h>
|
2000-08-11 13:37:21 +00:00
|
|
|
|
2002-01-21 07:37:49 +00:00
|
|
|
#include <epan/packet.h>
|
2004-03-06 03:25:10 +00:00
|
|
|
#include <epan/addr_and_mask.h>
|
1999-11-01 06:57:01 +00:00
|
|
|
#include "packet-bgp.h"
|
1999-10-16 15:35:27 +00:00
|
|
|
#include "packet-ipv6.h"
|
2003-04-05 11:20:54 +00:00
|
|
|
#include "packet-frame.h"
|
2004-09-29 00:52:45 +00:00
|
|
|
#include <epan/afn.h>
|
2004-09-27 22:55:15 +00:00
|
|
|
#include <epan/prefs.h>
|
2005-08-31 08:49:10 +00:00
|
|
|
#include <epan/emem.h>
|
|
|
|
|
2009-03-28 00:27:03 +00:00
|
|
|
/* #define MAX_STR_LEN 256 */
|
2000-01-10 17:33:17 +00:00
|
|
|
|
1999-10-15 17:00:47 +00:00
|
|
|
static const value_string bgptypevals[] = {
|
1999-11-01 06:57:01 +00:00
|
|
|
{ BGP_OPEN, "OPEN Message" },
|
|
|
|
{ BGP_UPDATE, "UPDATE Message" },
|
|
|
|
{ BGP_NOTIFICATION, "NOTIFICATION Message" },
|
|
|
|
{ BGP_KEEPALIVE, "KEEPALIVE Message" },
|
2000-12-25 05:28:40 +00:00
|
|
|
{ BGP_ROUTE_REFRESH, "ROUTE-REFRESH Message" },
|
2003-01-28 05:25:18 +00:00
|
|
|
{ BGP_CAPABILITY, "CAPABILITY Message" },
|
2001-05-16 18:52:37 +00:00
|
|
|
{ BGP_ROUTE_REFRESH_CISCO, "Cisco ROUTE-REFRESH Message" },
|
2007-08-23 20:42:27 +00:00
|
|
|
{ 0, NULL }
|
1999-10-15 17:00:47 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
static const value_string bgpnotify_major[] = {
|
|
|
|
{ 1, "Message Header Error" },
|
|
|
|
{ 2, "OPEN Message Error" },
|
|
|
|
{ 3, "UPDATE Message Error" },
|
|
|
|
{ 4, "Hold Timer Expired" },
|
|
|
|
{ 5, "Finite State Machine Error" },
|
|
|
|
{ 6, "Cease" },
|
2003-01-28 05:25:18 +00:00
|
|
|
{ 7, "CAPABILITY Message Error" },
|
2007-08-23 20:42:27 +00:00
|
|
|
{ 0, NULL }
|
1999-10-15 17:00:47 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
static const value_string bgpnotify_minor_1[] = {
|
|
|
|
{ 1, "Connection Not Synchronized" },
|
|
|
|
{ 2, "Bad Message Length" },
|
|
|
|
{ 3, "Bad Message Type" },
|
2007-08-23 20:42:27 +00:00
|
|
|
{ 0, NULL }
|
1999-10-15 17:00:47 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
static const value_string bgpnotify_minor_2[] = {
|
|
|
|
{ 1, "Unsupported Version Number" },
|
|
|
|
{ 2, "Bad Peer AS" },
|
|
|
|
{ 3, "Bad BGP Identifier" },
|
|
|
|
{ 4, "Unsupported Optional Parameter" },
|
|
|
|
{ 5, "Authentication Failure" },
|
|
|
|
{ 6, "Unacceptable Hold Time" },
|
2000-12-28 05:13:14 +00:00
|
|
|
{ 7, "Unsupported Capability" },
|
2007-08-23 20:42:27 +00:00
|
|
|
{ 0, NULL }
|
1999-10-15 17:00:47 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
static const value_string bgpnotify_minor_3[] = {
|
|
|
|
{ 1, "Malformed Attribute List" },
|
|
|
|
{ 2, "Unrecognized Well-known Attribute" },
|
|
|
|
{ 3, "Missing Well-known Attribute" },
|
|
|
|
{ 4, "Attribute Flags Error" },
|
|
|
|
{ 5, "Attribute Length Error" },
|
|
|
|
{ 6, "Invalid ORIGIN Attribute" },
|
|
|
|
{ 7, "AS Routing Loop" },
|
|
|
|
{ 8, "Invalid NEXT_HOP Attribute" },
|
|
|
|
{ 9, "Optional Attribute Error" },
|
|
|
|
{ 10, "Invalid Network Field" },
|
|
|
|
{ 11, "Malformed AS_PATH" },
|
2007-08-23 20:42:27 +00:00
|
|
|
{ 0, NULL }
|
1999-10-15 17:00:47 +00:00
|
|
|
};
|
|
|
|
|
2003-05-28 20:59:46 +00:00
|
|
|
/* draft-ietf-idr-cease-subcode-02 */
|
|
|
|
static const value_string bgpnotify_minor_6[] = {
|
|
|
|
{ 1, "Maximum Number of Prefixes Reached"},
|
|
|
|
{ 2, "Administratively Shutdown"},
|
|
|
|
{ 3, "Peer Unconfigured"},
|
|
|
|
{ 4, "Administratively Reset"},
|
|
|
|
{ 5, "Connection Rejected"},
|
|
|
|
{ 6, "Other Configuration Change"},
|
|
|
|
{ 7, "Connection Collision Resolution"},
|
2007-08-23 20:42:27 +00:00
|
|
|
{ 0, NULL }
|
2003-05-28 20:59:46 +00:00
|
|
|
};
|
|
|
|
|
2003-01-28 05:25:18 +00:00
|
|
|
static const value_string bgpnotify_minor_7[] = {
|
|
|
|
{ 1, "Invalid Action Value" },
|
|
|
|
{ 2, "Invalid Capability Length" },
|
|
|
|
{ 3, "Malformed Capability Value" },
|
2003-05-28 20:59:46 +00:00
|
|
|
{ 4, "Unsupported Capability Code" },
|
2007-08-23 20:42:27 +00:00
|
|
|
{ 0, NULL }
|
2003-01-28 05:25:18 +00:00
|
|
|
};
|
|
|
|
|
1999-10-15 17:00:47 +00:00
|
|
|
static const value_string *bgpnotify_minor[] = {
|
2003-05-28 20:59:46 +00:00
|
|
|
NULL,
|
|
|
|
bgpnotify_minor_1, /* open */
|
|
|
|
bgpnotify_minor_2, /* update */
|
|
|
|
bgpnotify_minor_3, /* notification */
|
|
|
|
NULL, /* hold-timer expired */
|
|
|
|
NULL, /* FSM error */
|
|
|
|
bgpnotify_minor_6, /* cease */
|
|
|
|
bgpnotify_minor_7 /* capability */
|
1999-10-15 17:00:47 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
static const value_string bgpattr_origin[] = {
|
|
|
|
{ 0, "IGP" },
|
|
|
|
{ 1, "EGP" },
|
|
|
|
{ 2, "INCOMPLETE" },
|
2007-08-23 20:42:27 +00:00
|
|
|
{ 0, NULL }
|
1999-10-15 17:00:47 +00:00
|
|
|
};
|
|
|
|
|
1999-11-22 07:05:21 +00:00
|
|
|
static const value_string as_segment_type[] = {
|
|
|
|
{ 1, "AS_SET" },
|
|
|
|
{ 2, "AS_SEQUENCE" },
|
2000-12-28 05:13:14 +00:00
|
|
|
/* RFC1965 has the wrong values, corrected in */
|
|
|
|
/* draft-ietf-idr-bgp-confed-rfc1965bis-01.txt */
|
2000-04-11 14:21:37 +00:00
|
|
|
{ 4, "AS_CONFED_SET" },
|
|
|
|
{ 3, "AS_CONFED_SEQUENCE" },
|
2007-08-23 20:42:27 +00:00
|
|
|
{ 0, NULL }
|
1999-11-22 07:05:21 +00:00
|
|
|
};
|
|
|
|
|
1999-10-15 17:00:47 +00:00
|
|
|
static const value_string bgpattr_type[] = {
|
|
|
|
{ BGPTYPE_ORIGIN, "ORIGIN" },
|
|
|
|
{ BGPTYPE_AS_PATH, "AS_PATH" },
|
|
|
|
{ BGPTYPE_NEXT_HOP, "NEXT_HOP" },
|
|
|
|
{ BGPTYPE_MULTI_EXIT_DISC, "MULTI_EXIT_DISC" },
|
|
|
|
{ BGPTYPE_LOCAL_PREF, "LOCAL_PREF" },
|
|
|
|
{ BGPTYPE_ATOMIC_AGGREGATE, "ATOMIC_AGGREGATE" },
|
|
|
|
{ BGPTYPE_AGGREGATOR, "AGGREGATOR" },
|
1999-11-22 07:05:21 +00:00
|
|
|
{ BGPTYPE_COMMUNITIES, "COMMUNITIES" },
|
|
|
|
{ BGPTYPE_ORIGINATOR_ID, "ORIGINATOR_ID" },
|
|
|
|
{ BGPTYPE_CLUSTER_LIST, "CLUSTER_LIST" },
|
1999-10-16 00:21:07 +00:00
|
|
|
{ BGPTYPE_MP_REACH_NLRI, "MP_REACH_NLRI" },
|
|
|
|
{ BGPTYPE_MP_UNREACH_NLRI, "MP_UNREACH_NLRI" },
|
2001-06-10 02:08:11 +00:00
|
|
|
{ BGPTYPE_EXTENDED_COMMUNITY, "EXTENDED_COMMUNITIES" },
|
2003-01-28 05:25:18 +00:00
|
|
|
{ BGPTYPE_NEW_AS_PATH, "NEW_AS_PATH" },
|
|
|
|
{ BGPTYPE_NEW_AGGREGATOR, "NEW_AGGREGATOR" },
|
2005-01-07 11:43:05 +00:00
|
|
|
{ BGPTYPE_SAFI_SPECIFIC_ATTR, "SAFI_SPECIFIC_ATTRIBUTE" },
|
2007-08-23 20:42:27 +00:00
|
|
|
{ 0, NULL }
|
1999-10-16 00:21:07 +00:00
|
|
|
};
|
|
|
|
|
2009-01-10 11:06:50 +00:00
|
|
|
static const value_string bgpext_com8_type[] = {
|
|
|
|
{ BGP_EXT_COM_QOS_MARK_T, "QoS Marking - transitive" },
|
|
|
|
{ BGP_EXT_COM_QOS_MARK_NT, "QoS Marking - non-transitive" },
|
2009-05-25 06:48:40 +00:00
|
|
|
{ BGP_EXT_COM_COS_CAP_T, "CoS Capability - transitive" },
|
2009-01-10 11:06:50 +00:00
|
|
|
{ 0, NULL }
|
|
|
|
};
|
|
|
|
|
2001-06-10 02:08:11 +00:00
|
|
|
static const value_string bgpext_com_type[] = {
|
|
|
|
{ BGP_EXT_COM_RT_0, "Route Target" },
|
|
|
|
{ BGP_EXT_COM_RT_1, "Route Target" },
|
2003-05-19 20:36:49 +00:00
|
|
|
{ BGP_EXT_COM_RT_2, "Route Target" },
|
2001-06-10 02:08:11 +00:00
|
|
|
{ BGP_EXT_COM_RO_0, "Route Origin" },
|
|
|
|
{ BGP_EXT_COM_RO_1, "Route Origin" },
|
2003-05-19 20:36:49 +00:00
|
|
|
{ BGP_EXT_COM_RO_2, "Route Origin" },
|
2001-07-08 22:59:51 +00:00
|
|
|
{ BGP_EXT_COM_LINKBAND, "Link Bandwidth" },
|
|
|
|
{ BGP_EXT_COM_VPN_ORIGIN, "OSPF Domain" },
|
|
|
|
{ BGP_EXT_COM_OSPF_RTYPE, "OSPF Route Type" },
|
|
|
|
{ BGP_EXT_COM_OSPF_RID, "OSPF Router ID" },
|
2002-08-24 10:22:29 +00:00
|
|
|
{ BGP_EXT_COM_L2INFO, "Layer 2 Information" },
|
2007-08-23 20:42:27 +00:00
|
|
|
{ 0, NULL }
|
1999-10-15 17:00:47 +00:00
|
|
|
};
|
|
|
|
|
2009-01-10 11:06:50 +00:00
|
|
|
static const value_string qos_tech_type[] = {
|
|
|
|
{ QOS_TECH_TYPE_DSCP, "DiffServ enabled IP (DSCP encoding)" },
|
|
|
|
{ QOS_TECH_TYPE_802_1q, "Ethernet using 802.1q priority tag" },
|
|
|
|
{ QOS_TECH_TYPE_E_LSP, "MPLS using E-LSP" },
|
|
|
|
{ QOS_TECH_TYPE_VC, "Virtual Channel (VC) encoding" },
|
|
|
|
{ QOS_TECH_TYPE_GMPLS_TIME, "GMPLS - time slot encoding" },
|
|
|
|
{ QOS_TECH_TYPE_GMPLS_LAMBDA, "GMPLS - lambda encoding" },
|
|
|
|
{ QOS_TECH_TYPE_GMPLS_FIBRE, "GMPLS - fibre encoding" },
|
|
|
|
{ 0, NULL }
|
|
|
|
};
|
|
|
|
|
2005-01-07 11:43:05 +00:00
|
|
|
static const value_string bgp_ssa_type[] = {
|
|
|
|
{ BGP_SSA_L2TPv3 , "L2TPv3 Tunnel" },
|
|
|
|
{ BGP_SSA_mGRE , "mGRE Tunnel" },
|
|
|
|
{ BGP_SSA_IPSec , "IPSec Tunnel" },
|
|
|
|
{ BGP_SSA_MPLS , "MPLS Tunnel" },
|
2010-01-23 11:58:53 +00:00
|
|
|
{ BGP_SSA_L2TPv3_IN_IPSec , "L2TPv3 in IPSec Tunnel" },
|
|
|
|
{ BGP_SSA_mGRE_IN_IPSec , "mGRE in IPSec Tunnel" },
|
2007-08-23 20:42:27 +00:00
|
|
|
{ 0, NULL }
|
2005-01-07 11:43:05 +00:00
|
|
|
};
|
|
|
|
|
2002-08-24 10:22:29 +00:00
|
|
|
static const value_string bgp_l2vpn_encaps[] = {
|
|
|
|
{ 0, "Reserved"},
|
|
|
|
{ 1, "Frame Relay"},
|
|
|
|
{ 2, "ATM AAL5 VCC transport"},
|
2002-08-28 21:04:11 +00:00
|
|
|
{ 3, "ATM transparent cell transport"},
|
|
|
|
{ 4, "Ethernet VLAN"},
|
|
|
|
{ 5, "Ethernet"},
|
|
|
|
{ 6, "Cisco-HDLC"},
|
|
|
|
{ 7, "PPP"},
|
|
|
|
{ 8, "CEM"},
|
|
|
|
{ 9, "ATM VCC cell transport"},
|
|
|
|
{ 10, "ATM VPC cell transport"},
|
|
|
|
{ 11, "MPLS"},
|
|
|
|
{ 12, "VPLS"},
|
|
|
|
{ 64, "IP-interworking"},
|
2007-08-23 20:42:27 +00:00
|
|
|
{ 0, NULL }
|
2002-08-24 10:22:29 +00:00
|
|
|
};
|
|
|
|
|
2001-07-08 22:59:51 +00:00
|
|
|
static const value_string bgpext_ospf_rtype[] = {
|
2002-08-28 21:04:11 +00:00
|
|
|
{ BGP_OSPF_RTYPE_RTR, "Router" },
|
|
|
|
{ BGP_OSPF_RTYPE_NET, "Network" },
|
|
|
|
{ BGP_OSPF_RTYPE_SUM, "Summary" },
|
|
|
|
{ BGP_OSPF_RTYPE_EXT, "External" },
|
2001-07-08 22:59:51 +00:00
|
|
|
{ BGP_OSPF_RTYPE_NSSA,"NSSA External" },
|
2002-08-28 21:04:11 +00:00
|
|
|
{ BGP_OSPF_RTYPE_SHAM,"MPLS-VPN Sham" },
|
2007-08-23 20:42:27 +00:00
|
|
|
{ 0, NULL }
|
2001-07-08 22:59:51 +00:00
|
|
|
};
|
|
|
|
|
2001-06-10 02:08:11 +00:00
|
|
|
/* Subsequent address family identifier, RFC2858 */
|
|
|
|
static const value_string bgpattr_nlri_safi[] = {
|
|
|
|
{ 0, "Reserved" },
|
|
|
|
{ SAFNUM_UNICAST, "Unicast" },
|
|
|
|
{ SAFNUM_MULCAST, "Multicast" },
|
|
|
|
{ SAFNUM_UNIMULC, "Unicast+Multicast" },
|
2002-10-15 17:19:06 +00:00
|
|
|
{ SAFNUM_MPLS_LABEL, "Labeled Unicast"},
|
2005-01-07 11:43:05 +00:00
|
|
|
{ SAFNUM_TUNNEL, "Tunnel"},
|
2005-10-11 05:23:27 +00:00
|
|
|
{ SAFNUM_VPLS, "VPLS"},
|
2002-08-27 08:41:43 +00:00
|
|
|
{ SAFNUM_LAB_VPNUNICAST, "Labeled VPN Unicast" }, /* draft-rosen-rfc2547bis-03 */
|
|
|
|
{ SAFNUM_LAB_VPNMULCAST, "Labeled VPN Multicast" },
|
|
|
|
{ SAFNUM_LAB_VPNUNIMULC, "Labeled VPN Unicast+Multicast" },
|
2007-08-23 20:42:27 +00:00
|
|
|
{ 0, NULL }
|
2001-06-10 02:08:11 +00:00
|
|
|
};
|
|
|
|
|
2001-11-03 21:25:12 +00:00
|
|
|
/* ORF Type, draft-ietf-idr-route-filter-04.txt */
|
|
|
|
static const value_string orf_type_vals[] = {
|
|
|
|
{ 2, "Communities ORF-Type" },
|
|
|
|
{ 3, "Extended Communities ORF-Type" },
|
2002-08-15 18:52:04 +00:00
|
|
|
{ 128, "Cisco PrefixList ORF-Type" },
|
|
|
|
{ 129, "Cisco CommunityList ORF-Type" },
|
|
|
|
{ 130, "Cisco Extended CommunityList ORF-Type" },
|
|
|
|
{ 131, "Cisco AsPathList ORF-Type" },
|
2007-08-23 20:42:27 +00:00
|
|
|
{ 0, NULL }
|
2001-11-03 21:25:12 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
/* ORF Send/Receive, draft-ietf-idr-route-filter-04.txt */
|
|
|
|
static const value_string orf_send_recv_vals[] = {
|
|
|
|
{ 1, "Receive" },
|
|
|
|
{ 2, "Send" },
|
|
|
|
{ 3, "Both" },
|
2007-08-23 20:42:27 +00:00
|
|
|
{ 0, NULL }
|
2001-11-03 21:25:12 +00:00
|
|
|
};
|
|
|
|
|
2002-08-15 18:52:04 +00:00
|
|
|
/* ORF Send/Receive, draft-ietf-idr-route-filter-04.txt */
|
|
|
|
static const value_string orf_when_vals[] = {
|
|
|
|
{ 1, "Immediate" },
|
|
|
|
{ 2, "Defer" },
|
2007-08-23 20:42:27 +00:00
|
|
|
{ 0, NULL }
|
2002-08-15 18:52:04 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
static const value_string orf_entry_action_vals[] = {
|
|
|
|
{ 0, "Add" },
|
|
|
|
{ 0x40, "Remove" },
|
|
|
|
{ 0x80, "RemoveAll" },
|
2007-08-23 20:42:27 +00:00
|
|
|
{ 0, NULL }
|
2002-08-15 18:52:04 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
static const value_string orf_entry_match_vals[] = {
|
|
|
|
{ 0, "Permit" },
|
|
|
|
{ 0x20, "Deny" },
|
2007-08-23 20:42:27 +00:00
|
|
|
{ 0, NULL }
|
2002-08-15 18:52:04 +00:00
|
|
|
};
|
2003-01-28 05:25:18 +00:00
|
|
|
|
|
|
|
static const value_string capability_vals[] = {
|
|
|
|
{ BGP_CAPABILITY_RESERVED, "Reserved capability" },
|
|
|
|
{ BGP_CAPABILITY_MULTIPROTOCOL, "Multiprotocol extensions capability" },
|
|
|
|
{ BGP_CAPABILITY_ROUTE_REFRESH, "Route refresh capability" },
|
|
|
|
{ BGP_CAPABILITY_COOPERATIVE_ROUTE_FILTERING, "Cooperative route filtering capability" },
|
|
|
|
{ BGP_CAPABILITY_GRACEFUL_RESTART, "Graceful Restart capability" },
|
|
|
|
{ BGP_CAPABILITY_4_OCTET_AS_NUMBER, "Support for 4-octet AS number capability" },
|
|
|
|
{ BGP_CAPABILITY_DYNAMIC_CAPABILITY, "Support for Dynamic capability" },
|
|
|
|
{ BGP_CAPABILITY_ROUTE_REFRESH_CISCO, "Route refresh capability" },
|
|
|
|
{ BGP_CAPABILITY_ORF_CISCO, "Cooperative route filtering capability" },
|
2007-08-23 20:42:27 +00:00
|
|
|
{ 0, NULL }
|
2003-01-28 05:25:18 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
/* Capability Message action code */
|
|
|
|
static const value_string bgpcap_action[] = {
|
|
|
|
{ 0, "advertising a capability" },
|
|
|
|
{ 1, "removing a capability" },
|
2007-08-23 20:42:27 +00:00
|
|
|
{ 0, NULL }
|
2003-01-28 05:25:18 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
|
2001-06-10 02:08:11 +00:00
|
|
|
/* Maximal size of an IP address string */
|
|
|
|
#define MAX_SIZE_OF_IP_ADDR_STRING 16
|
|
|
|
|
1999-10-15 17:00:47 +00:00
|
|
|
static int proto_bgp = -1;
|
2000-08-20 18:10:12 +00:00
|
|
|
static int hf_bgp_type = -1;
|
2003-04-24 09:00:27 +00:00
|
|
|
static int hf_bgp_next_hop = -1;
|
|
|
|
static int hf_bgp_as_path = -1;
|
|
|
|
static int hf_bgp_cluster_identifier = -1;
|
|
|
|
static int hf_bgp_community_as = -1;
|
|
|
|
static int hf_bgp_community_value = -1;
|
|
|
|
static int hf_bgp_origin = -1;
|
|
|
|
static int hf_bgp_cluster_list = -1;
|
|
|
|
static int hf_bgp_originator_id = -1;
|
2005-01-07 11:43:05 +00:00
|
|
|
static int hf_bgp_ssa_t = -1;
|
|
|
|
static int hf_bgp_ssa_type = -1;
|
|
|
|
static int hf_bgp_ssa_len = -1;
|
|
|
|
static int hf_bgp_ssa_value = -1;
|
|
|
|
static int hf_bgp_ssa_l2tpv3_pref = -1;
|
|
|
|
static int hf_bgp_ssa_l2tpv3_s = -1;
|
|
|
|
static int hf_bgp_ssa_l2tpv3_unused = -1;
|
|
|
|
static int hf_bgp_ssa_l2tpv3_cookie_len = -1;
|
|
|
|
static int hf_bgp_ssa_l2tpv3_session_id = -1;
|
|
|
|
static int hf_bgp_ssa_l2tpv3_cookie = -1;
|
2003-04-24 09:00:27 +00:00
|
|
|
static int hf_bgp_local_pref = -1;
|
|
|
|
static int hf_bgp_multi_exit_disc = -1;
|
|
|
|
static int hf_bgp_aggregator_as = -1;
|
|
|
|
static int hf_bgp_aggregator_origin = -1;
|
|
|
|
static int hf_bgp_mp_reach_nlri_ipv4_prefix = -1;
|
|
|
|
static int hf_bgp_mp_unreach_nlri_ipv4_prefix = -1;
|
2005-01-07 11:43:05 +00:00
|
|
|
static int hf_bgp_mp_nlri_tnl_id = -1;
|
2003-04-24 09:00:27 +00:00
|
|
|
static int hf_bgp_withdrawn_prefix = -1;
|
|
|
|
static int hf_bgp_nlri_prefix = -1;
|
1999-10-15 17:00:47 +00:00
|
|
|
|
1999-11-16 11:44:20 +00:00
|
|
|
static gint ett_bgp = -1;
|
2003-04-24 09:00:27 +00:00
|
|
|
static gint ett_bgp_prefix = -1;
|
1999-11-16 11:44:20 +00:00
|
|
|
static gint ett_bgp_unfeas = -1;
|
|
|
|
static gint ett_bgp_attrs = -1;
|
|
|
|
static gint ett_bgp_attr = -1;
|
|
|
|
static gint ett_bgp_attr_flags = -1;
|
2001-06-15 08:01:31 +00:00
|
|
|
static gint ett_bgp_mp_nhna = -1;
|
1999-11-16 11:44:20 +00:00
|
|
|
static gint ett_bgp_mp_reach_nlri = -1;
|
|
|
|
static gint ett_bgp_mp_unreach_nlri = -1;
|
2001-06-10 02:08:11 +00:00
|
|
|
static gint ett_bgp_mp_snpa = -1;
|
1999-11-16 11:44:20 +00:00
|
|
|
static gint ett_bgp_nlri = -1;
|
|
|
|
static gint ett_bgp_open = -1;
|
|
|
|
static gint ett_bgp_update = -1;
|
|
|
|
static gint ett_bgp_notification = -1;
|
2000-12-25 05:28:40 +00:00
|
|
|
static gint ett_bgp_route_refresh = -1; /* ROUTE-REFRESH message tree */
|
2003-01-28 05:25:18 +00:00
|
|
|
static gint ett_bgp_capability = -1;
|
1999-11-23 20:56:49 +00:00
|
|
|
static gint ett_bgp_as_paths = -1;
|
2003-04-24 09:00:27 +00:00
|
|
|
static gint ett_bgp_as_path_segments = -1;
|
2000-01-25 09:24:42 +00:00
|
|
|
static gint ett_bgp_communities = -1;
|
2000-12-25 05:28:40 +00:00
|
|
|
static gint ett_bgp_cluster_list = -1; /* cluster list tree */
|
|
|
|
static gint ett_bgp_options = -1; /* optional parameters tree */
|
|
|
|
static gint ett_bgp_option = -1; /* an optional parameter tree */
|
2009-01-10 11:06:50 +00:00
|
|
|
static gint ett_bgp_extended_communities = -1; /* extended communities list tree */
|
|
|
|
static gint ett_bgp_ext_com_flags = -1; /* extended communities flags tree */
|
2005-01-07 11:43:05 +00:00
|
|
|
static gint ett_bgp_ssa = -1; /* safi specific attribute */
|
|
|
|
static gint ett_bgp_ssa_subtree = -1; /* safi specific attribute Subtrees */
|
2002-08-15 18:52:04 +00:00
|
|
|
static gint ett_bgp_orf = -1; /* orf (outbound route filter) tree */
|
|
|
|
static gint ett_bgp_orf_entry = -1; /* orf entry tree */
|
2002-01-17 09:25:55 +00:00
|
|
|
|
|
|
|
/* desegmentation */
|
|
|
|
static gboolean bgp_desegment = TRUE;
|
|
|
|
|
2003-01-28 05:25:18 +00:00
|
|
|
static gint bgp_asn_len = 0;
|
|
|
|
|
1999-11-11 21:08:52 +00:00
|
|
|
/*
|
|
|
|
* Decode an IPv4 prefix.
|
|
|
|
*/
|
1999-10-16 15:35:27 +00:00
|
|
|
static int
|
2003-04-24 09:00:27 +00:00
|
|
|
decode_prefix4(proto_tree *tree, int hf_addr, tvbuff_t *tvb, gint offset,
|
2005-07-28 07:53:38 +00:00
|
|
|
guint16 tlen, const char *tag)
|
1999-10-16 15:35:27 +00:00
|
|
|
{
|
2003-04-24 09:00:27 +00:00
|
|
|
proto_item *ti;
|
|
|
|
proto_tree *prefix_tree;
|
|
|
|
union {
|
|
|
|
guint8 addr_bytes[4];
|
|
|
|
guint32 addr;
|
|
|
|
} ip_addr; /* IP address */
|
2002-10-15 02:29:54 +00:00
|
|
|
guint8 plen; /* prefix length */
|
1999-11-22 07:05:21 +00:00
|
|
|
int length; /* number of octets needed for prefix */
|
1999-10-16 15:35:27 +00:00
|
|
|
|
2004-03-06 03:25:10 +00:00
|
|
|
/* snarf length and prefix */
|
2001-04-17 21:25:13 +00:00
|
|
|
plen = tvb_get_guint8(tvb, offset);
|
2004-03-06 03:25:10 +00:00
|
|
|
length = ipv4_addr_and_mask(tvb, offset + 1, ip_addr.addr_bytes, plen);
|
|
|
|
if (length < 0) {
|
|
|
|
proto_tree_add_text(tree, tvb, offset, 1, "%s length %u invalid (> 32)",
|
2003-04-24 09:00:27 +00:00
|
|
|
tag, plen);
|
1999-10-16 15:35:27 +00:00
|
|
|
return -1;
|
2003-04-24 09:00:27 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* put prefix into protocol tree */
|
|
|
|
ti = proto_tree_add_text(tree, tvb, offset,
|
|
|
|
tlen != 0 ? tlen : 1 + length, "%s/%u",
|
|
|
|
ip_to_str(ip_addr.addr_bytes), plen);
|
|
|
|
prefix_tree = proto_item_add_subtree(ti, ett_bgp_prefix);
|
|
|
|
proto_tree_add_text(prefix_tree, tvb, offset, 1, "%s prefix length: %u",
|
|
|
|
tag, plen);
|
|
|
|
if (hf_addr != -1) {
|
|
|
|
proto_tree_add_ipv4(prefix_tree, hf_addr, tvb, offset + 1, length,
|
|
|
|
ip_addr.addr);
|
|
|
|
} else {
|
|
|
|
proto_tree_add_text(prefix_tree, tvb, offset + 1, length,
|
|
|
|
"%s prefix: %s", tag, ip_to_str(ip_addr.addr_bytes));
|
|
|
|
}
|
1999-11-22 07:05:21 +00:00
|
|
|
return(1 + length);
|
1999-10-16 15:35:27 +00:00
|
|
|
}
|
|
|
|
|
1999-11-11 21:08:52 +00:00
|
|
|
/*
|
|
|
|
* Decode an IPv6 prefix.
|
|
|
|
*/
|
1999-10-16 15:35:27 +00:00
|
|
|
static int
|
2003-04-24 09:00:27 +00:00
|
|
|
decode_prefix6(proto_tree *tree, int hf_addr, tvbuff_t *tvb, gint offset,
|
2005-07-28 07:53:38 +00:00
|
|
|
guint16 tlen, const char *tag)
|
1999-10-16 15:35:27 +00:00
|
|
|
{
|
2003-04-24 09:00:27 +00:00
|
|
|
proto_item *ti;
|
|
|
|
proto_tree *prefix_tree;
|
1999-11-22 07:05:21 +00:00
|
|
|
struct e_in6_addr addr; /* IPv6 address */
|
|
|
|
int plen; /* prefix length */
|
|
|
|
int length; /* number of octets needed for prefix */
|
1999-10-16 15:35:27 +00:00
|
|
|
|
2004-03-06 03:25:10 +00:00
|
|
|
/* snarf length and prefix */
|
2001-04-17 21:25:13 +00:00
|
|
|
plen = tvb_get_guint8(tvb, offset);
|
2004-03-06 03:25:10 +00:00
|
|
|
length = ipv6_addr_and_mask(tvb, offset + 1, &addr, plen);
|
|
|
|
if (length < 0) {
|
2003-04-24 09:00:27 +00:00
|
|
|
proto_tree_add_text(tree, tvb, offset, 1, "%s length %u invalid",
|
|
|
|
tag, plen);
|
1999-10-16 15:35:27 +00:00
|
|
|
return -1;
|
2003-04-24 09:00:27 +00:00
|
|
|
}
|
1999-11-22 07:05:21 +00:00
|
|
|
|
2003-04-24 09:00:27 +00:00
|
|
|
/* put prefix into protocol tree */
|
|
|
|
ti = proto_tree_add_text(tree, tvb, offset,
|
|
|
|
tlen != 0 ? tlen : 1 + length, "%s/%u",
|
|
|
|
ip6_to_str(&addr), plen);
|
|
|
|
prefix_tree = proto_item_add_subtree(ti, ett_bgp_prefix);
|
|
|
|
proto_tree_add_text(prefix_tree, tvb, offset, 1, "%s prefix length: %u",
|
|
|
|
tag, plen);
|
|
|
|
if (hf_addr != -1) {
|
|
|
|
proto_tree_add_ipv6(prefix_tree, hf_addr, tvb, offset + 1, length,
|
2005-09-12 06:21:35 +00:00
|
|
|
addr.bytes);
|
2003-04-24 09:00:27 +00:00
|
|
|
} else {
|
|
|
|
proto_tree_add_text(prefix_tree, tvb, offset + 1, length,
|
|
|
|
"%s prefix: %s", tag, ip6_to_str(&addr));
|
|
|
|
}
|
1999-11-22 07:05:21 +00:00
|
|
|
return(1 + length);
|
1999-10-16 15:35:27 +00:00
|
|
|
}
|
|
|
|
|
2002-08-27 08:41:43 +00:00
|
|
|
|
|
|
|
|
2001-06-10 02:08:11 +00:00
|
|
|
/*
|
|
|
|
* Decode an MPLS label stack
|
2005-10-15 23:59:56 +00:00
|
|
|
* XXX - We should change *buf to **buf, use ep_alloc() and drop the buflen
|
|
|
|
* argument.
|
2001-06-10 02:08:11 +00:00
|
|
|
*/
|
2004-01-06 02:29:36 +00:00
|
|
|
static guint
|
2009-03-28 00:27:03 +00:00
|
|
|
decode_MPLS_stack(tvbuff_t *tvb, gint offset, emem_strbuf_t *stack_strbuf)
|
2001-06-10 02:08:11 +00:00
|
|
|
{
|
|
|
|
guint32 label_entry; /* an MPLS label enrty (label + COS field + stack bit */
|
2008-06-27 04:52:56 +00:00
|
|
|
gint indx; /* index for the label stack */
|
2001-06-10 02:08:11 +00:00
|
|
|
|
2008-06-27 04:52:56 +00:00
|
|
|
indx = offset ;
|
2001-06-10 02:08:11 +00:00
|
|
|
label_entry = 0x000000 ;
|
|
|
|
|
2009-03-28 00:27:03 +00:00
|
|
|
ep_strbuf_truncate(stack_strbuf, 0);
|
2001-06-10 02:08:11 +00:00
|
|
|
|
2002-05-21 21:44:28 +00:00
|
|
|
while ((label_entry & 0x000001) == 0) {
|
2001-06-10 02:08:11 +00:00
|
|
|
|
2008-06-27 04:52:56 +00:00
|
|
|
label_entry = tvb_get_ntoh24(tvb, indx) ;
|
2002-05-20 01:01:11 +00:00
|
|
|
|
|
|
|
/* withdrawn routes may contain 0 or 0x800000 in the first label */
|
2008-06-27 04:52:56 +00:00
|
|
|
if((indx-offset)==0&&(label_entry==0||label_entry==0x800000)) {
|
2009-03-28 00:27:03 +00:00
|
|
|
ep_strbuf_append(stack_strbuf, "0 (withdrawn)");
|
2002-05-20 01:01:11 +00:00
|
|
|
return (1);
|
|
|
|
}
|
2002-05-21 21:55:47 +00:00
|
|
|
|
2009-03-28 00:27:03 +00:00
|
|
|
ep_strbuf_append_printf(stack_strbuf, "%u%s", label_entry >> 4,
|
|
|
|
((label_entry & 0x000001) == 0) ? "," : " (bottom)");
|
2009-03-28 00:35:02 +00:00
|
|
|
|
2008-06-27 04:52:56 +00:00
|
|
|
indx += 3 ;
|
2002-05-21 21:55:47 +00:00
|
|
|
|
|
|
|
if ((label_entry & 0x000001) == 0) {
|
|
|
|
/* real MPLS multi-label stack in BGP? - maybe later; for now, it must be a bogus packet */
|
2009-03-28 00:27:03 +00:00
|
|
|
ep_strbuf_append(stack_strbuf, " (BOGUS: Bottom of Stack NOT set!)");
|
2002-05-21 21:55:47 +00:00
|
|
|
break;
|
2002-08-28 21:04:11 +00:00
|
|
|
}
|
2001-06-10 02:08:11 +00:00
|
|
|
}
|
|
|
|
|
2008-06-27 04:52:56 +00:00
|
|
|
return((indx - offset) / 3);
|
2001-06-10 02:08:11 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Decode a multiprotocol address
|
|
|
|
*/
|
|
|
|
|
|
|
|
static int
|
2009-03-28 00:27:03 +00:00
|
|
|
mp_addr_to_str (guint16 afi, guint8 safi, tvbuff_t *tvb, gint offset, emem_strbuf_t *strbuf)
|
2001-06-10 02:08:11 +00:00
|
|
|
{
|
|
|
|
int length; /* length of the address in byte */
|
2005-09-13 00:50:43 +00:00
|
|
|
guint32 ip4addr,ip4addr2; /* IPv4 address */
|
2001-06-10 02:08:11 +00:00
|
|
|
guint16 rd_type; /* Route Distinguisher type */
|
|
|
|
struct e_in6_addr ip6addr; /* IPv6 address */
|
2005-08-31 08:49:10 +00:00
|
|
|
|
2001-06-10 02:08:11 +00:00
|
|
|
length = 0 ;
|
|
|
|
switch (afi) {
|
|
|
|
case AFNUM_INET:
|
|
|
|
switch (safi) {
|
|
|
|
case SAFNUM_UNICAST:
|
|
|
|
case SAFNUM_MULCAST:
|
|
|
|
case SAFNUM_UNIMULC:
|
2002-05-15 21:40:25 +00:00
|
|
|
case SAFNUM_MPLS_LABEL:
|
2005-01-07 11:43:05 +00:00
|
|
|
case SAFNUM_TUNNEL:
|
2001-06-10 02:08:11 +00:00
|
|
|
length = 4 ;
|
2005-09-13 00:50:43 +00:00
|
|
|
ip4addr = tvb_get_ipv4(tvb, offset);
|
2009-03-28 00:27:03 +00:00
|
|
|
ep_strbuf_append(strbuf, ip_to_str((guint8 *)&ip4addr));
|
2001-06-10 02:08:11 +00:00
|
|
|
break;
|
2002-08-24 10:22:29 +00:00
|
|
|
case SAFNUM_LAB_VPNUNICAST:
|
|
|
|
case SAFNUM_LAB_VPNMULCAST:
|
|
|
|
case SAFNUM_LAB_VPNUNIMULC:
|
2001-06-10 02:08:11 +00:00
|
|
|
rd_type=tvb_get_ntohs(tvb,offset) ;
|
|
|
|
switch (rd_type) {
|
|
|
|
case FORMAT_AS2_LOC:
|
2002-11-04 22:00:14 +00:00
|
|
|
length = 8 + sizeof(ip4addr);
|
2005-09-13 00:50:43 +00:00
|
|
|
ip4addr = tvb_get_ipv4(tvb, offset + 8); /* Next Hop */
|
2009-03-28 00:27:03 +00:00
|
|
|
ep_strbuf_printf(strbuf, "Empty Label Stack RD=%u:%u IPv4=%s",
|
2001-06-10 02:08:11 +00:00
|
|
|
tvb_get_ntohs(tvb, offset + 2),
|
|
|
|
tvb_get_ntohl(tvb, offset + 4),
|
2005-09-13 00:50:43 +00:00
|
|
|
ip_to_str((guint8 *)&ip4addr));
|
2001-06-10 02:08:11 +00:00
|
|
|
break;
|
|
|
|
case FORMAT_IP_LOC:
|
2002-11-04 22:00:14 +00:00
|
|
|
length = 8 + sizeof(ip4addr);
|
2005-09-13 00:50:43 +00:00
|
|
|
ip4addr = tvb_get_ipv4(tvb, offset + 2); /* IP part of the RD */
|
|
|
|
ip4addr2 = tvb_get_ipv4(tvb, offset + 8); /* Next Hop */
|
2009-03-28 00:27:03 +00:00
|
|
|
ep_strbuf_printf(strbuf, "Empty Label Stack RD=%s:%u IPv4=%s",
|
2005-09-13 00:50:43 +00:00
|
|
|
ip_to_str((guint8 *)&ip4addr),
|
2001-06-10 02:08:11 +00:00
|
|
|
tvb_get_ntohs(tvb, offset + 6),
|
2005-09-13 00:50:43 +00:00
|
|
|
ip_to_str((guint8 *)&ip4addr2));
|
2001-06-10 02:08:11 +00:00
|
|
|
break ;
|
|
|
|
default:
|
|
|
|
length = 0 ;
|
2009-03-28 00:27:03 +00:00
|
|
|
ep_strbuf_printf(strbuf, "Unknown (0x%04x) labeled VPN IPv4 address format",rd_type);
|
2001-06-10 02:08:11 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
2002-08-27 08:41:43 +00:00
|
|
|
length = 0 ;
|
2009-03-28 00:27:03 +00:00
|
|
|
ep_strbuf_printf(strbuf, "Unknown SAFI (%u) for AFI %u", safi, afi);
|
2002-08-27 08:41:43 +00:00
|
|
|
break;
|
2001-06-10 02:08:11 +00:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
case AFNUM_INET6:
|
2002-08-27 08:41:43 +00:00
|
|
|
switch (safi) {
|
2002-11-04 22:00:14 +00:00
|
|
|
case SAFNUM_UNICAST:
|
2002-08-27 08:41:43 +00:00
|
|
|
case SAFNUM_MULCAST:
|
|
|
|
case SAFNUM_UNIMULC:
|
2004-01-23 19:19:44 +00:00
|
|
|
case SAFNUM_MPLS_LABEL:
|
2005-01-07 11:43:05 +00:00
|
|
|
case SAFNUM_TUNNEL:
|
2002-08-27 08:41:43 +00:00
|
|
|
length = 16 ;
|
2005-09-11 21:25:37 +00:00
|
|
|
tvb_get_ipv6(tvb, offset, &ip6addr);
|
2009-03-28 00:27:03 +00:00
|
|
|
ep_strbuf_printf(strbuf, "%s", ip6_to_str(&ip6addr));
|
2002-08-27 08:41:43 +00:00
|
|
|
break;
|
2002-11-04 22:00:14 +00:00
|
|
|
case SAFNUM_LAB_VPNUNICAST:
|
|
|
|
case SAFNUM_LAB_VPNMULCAST:
|
|
|
|
case SAFNUM_LAB_VPNUNIMULC:
|
|
|
|
rd_type=tvb_get_ntohs(tvb,offset) ;
|
|
|
|
switch (rd_type) {
|
|
|
|
case FORMAT_AS2_LOC:
|
|
|
|
length = 8 + 16;
|
2005-09-11 21:25:37 +00:00
|
|
|
tvb_get_ipv6(tvb, offset + 8, &ip6addr); /* Next Hop */
|
2009-03-28 00:27:03 +00:00
|
|
|
ep_strbuf_printf(strbuf, "Empty Label Stack RD=%u:%u IPv6=%s",
|
2002-11-04 22:00:14 +00:00
|
|
|
tvb_get_ntohs(tvb, offset + 2),
|
|
|
|
tvb_get_ntohl(tvb, offset + 4),
|
|
|
|
ip6_to_str(&ip6addr));
|
|
|
|
break;
|
|
|
|
case FORMAT_IP_LOC:
|
|
|
|
length = 8 + 16;
|
2005-09-13 00:50:43 +00:00
|
|
|
ip4addr = tvb_get_ipv4(tvb, offset + 2); /* IP part of the RD */
|
2005-09-11 21:25:37 +00:00
|
|
|
tvb_get_ipv6(tvb, offset + 8, &ip6addr); /* Next Hop */
|
2009-03-28 00:27:03 +00:00
|
|
|
ep_strbuf_printf(strbuf, "Empty Label Stack RD=%s:%u IPv6=%s",
|
2005-09-13 00:50:43 +00:00
|
|
|
ip_to_str((guint8 *)&ip4addr),
|
2002-11-04 22:00:14 +00:00
|
|
|
tvb_get_ntohs(tvb, offset + 6),
|
|
|
|
ip6_to_str(&ip6addr));
|
|
|
|
break ;
|
|
|
|
default:
|
|
|
|
length = 0 ;
|
2009-03-28 00:27:03 +00:00
|
|
|
ep_strbuf_printf(strbuf, "Unknown (0x%04x) labeled VPN IPv6 address format",rd_type);
|
2002-11-04 22:00:14 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
break;
|
2002-08-27 08:41:43 +00:00
|
|
|
default:
|
|
|
|
length = 0 ;
|
2009-03-28 00:27:03 +00:00
|
|
|
ep_strbuf_printf(strbuf, "Unknown SAFI (%u) for AFI %u", safi, afi);
|
2002-08-27 08:41:43 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case AFNUM_L2VPN:
|
2005-10-11 05:23:27 +00:00
|
|
|
case AFNUM_L2VPN_OLD:
|
2002-08-27 08:41:43 +00:00
|
|
|
switch (safi) {
|
|
|
|
case SAFNUM_LAB_VPNUNICAST: /* only labeles prefixes do make sense */
|
|
|
|
case SAFNUM_LAB_VPNMULCAST:
|
|
|
|
case SAFNUM_LAB_VPNUNIMULC:
|
2005-10-11 05:23:27 +00:00
|
|
|
case SAFNUM_VPLS:
|
2002-08-27 08:41:43 +00:00
|
|
|
length = 4; /* the next-hop is simply an ipv4 addr */
|
2005-09-13 00:50:43 +00:00
|
|
|
ip4addr = tvb_get_ipv4(tvb, offset + 0);
|
2009-03-28 00:27:03 +00:00
|
|
|
ep_strbuf_printf(strbuf, "IPv4=%s",
|
2005-09-13 00:50:43 +00:00
|
|
|
ip_to_str((guint8 *)&ip4addr));
|
2002-08-27 08:41:43 +00:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
length = 0 ;
|
2009-03-28 00:27:03 +00:00
|
|
|
ep_strbuf_printf(strbuf, "Unknown SAFI (%u) for AFI %u", safi, afi);
|
2002-08-28 21:04:11 +00:00
|
|
|
break;
|
2002-08-27 08:41:43 +00:00
|
|
|
}
|
2001-06-10 02:08:11 +00:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
length = 0 ;
|
2009-03-28 00:27:03 +00:00
|
|
|
ep_strbuf_printf(strbuf, "Unknown AFI (%u) value", afi);
|
2001-06-10 02:08:11 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
return(length) ;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Decode a multiprotocol prefix
|
|
|
|
*/
|
|
|
|
static int
|
2003-04-24 09:00:27 +00:00
|
|
|
decode_prefix_MP(proto_tree *tree, int hf_addr4, int hf_addr6,
|
2005-07-28 07:53:38 +00:00
|
|
|
guint16 afi, guint8 safi, tvbuff_t *tvb, gint offset, const char *tag)
|
2001-06-10 02:08:11 +00:00
|
|
|
{
|
2003-04-24 09:00:27 +00:00
|
|
|
int start_offset = offset;
|
|
|
|
proto_item *ti;
|
|
|
|
proto_tree *prefix_tree;
|
|
|
|
int total_length; /* length of the entire item */
|
|
|
|
int length; /* length of the prefix address, in bytes */
|
2004-01-06 02:29:36 +00:00
|
|
|
guint plen; /* length of the prefix address, in bits */
|
|
|
|
guint labnum; /* number of labels */
|
2005-01-07 11:43:05 +00:00
|
|
|
guint16 tnl_id; /* Tunnel Identifier */
|
2006-07-03 08:38:30 +00:00
|
|
|
int ce_id,labblk_off,labblk_size;
|
2003-04-24 09:00:27 +00:00
|
|
|
union {
|
|
|
|
guint8 addr_bytes[4];
|
|
|
|
guint32 addr;
|
|
|
|
} ip4addr, ip4addr2; /* IPv4 address */
|
|
|
|
struct e_in6_addr ip6addr; /* IPv6 address */
|
|
|
|
guint16 rd_type; /* Route Distinguisher type */
|
2009-03-28 00:27:03 +00:00
|
|
|
emem_strbuf_t *stack_strbuf; /* label stack */
|
2001-06-10 02:08:11 +00:00
|
|
|
|
|
|
|
switch (afi) {
|
2002-05-15 21:40:25 +00:00
|
|
|
|
2003-04-24 09:00:27 +00:00
|
|
|
case AFNUM_INET:
|
|
|
|
switch (safi) {
|
|
|
|
|
|
|
|
case SAFNUM_UNICAST:
|
|
|
|
case SAFNUM_MULCAST:
|
|
|
|
case SAFNUM_UNIMULC:
|
|
|
|
total_length = decode_prefix4(tree, hf_addr4, tvb, offset, 0, tag);
|
|
|
|
if (total_length < 0)
|
|
|
|
return -1;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case SAFNUM_MPLS_LABEL:
|
|
|
|
plen = tvb_get_guint8(tvb, offset);
|
2009-04-14 18:31:02 +00:00
|
|
|
stack_strbuf = ep_strbuf_new_label(NULL);
|
2009-03-28 00:27:03 +00:00
|
|
|
labnum = decode_MPLS_stack(tvb, offset + 1, stack_strbuf);
|
2003-04-24 09:00:27 +00:00
|
|
|
|
|
|
|
offset += (1 + labnum * 3);
|
|
|
|
if (plen <= (labnum * 3*8)) {
|
|
|
|
proto_tree_add_text(tree, tvb, start_offset, 1,
|
2004-10-01 07:07:03 +00:00
|
|
|
"%s Labeled IPv4 prefix length %u invalid",
|
|
|
|
tag, plen);
|
2003-04-24 09:00:27 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
plen -= (labnum * 3*8);
|
2004-03-06 03:25:10 +00:00
|
|
|
length = ipv4_addr_and_mask(tvb, offset, ip4addr.addr_bytes, plen);
|
|
|
|
if (length < 0) {
|
2003-04-24 09:00:27 +00:00
|
|
|
proto_tree_add_text(tree, tvb, start_offset, 1,
|
2004-10-01 07:07:03 +00:00
|
|
|
"%s Labeled IPv4 prefix length %u invalid",
|
2003-04-24 09:00:27 +00:00
|
|
|
tag, plen + (labnum * 3*8));
|
|
|
|
return -1;
|
|
|
|
}
|
2001-06-10 02:08:11 +00:00
|
|
|
|
2003-04-24 09:00:27 +00:00
|
|
|
ti = proto_tree_add_text(tree, tvb, start_offset,
|
2004-10-01 07:07:03 +00:00
|
|
|
(offset + length) - start_offset,
|
|
|
|
"Label Stack=%s IPv4=%s/%u",
|
2009-03-28 00:27:03 +00:00
|
|
|
stack_strbuf->str, ip_to_str(ip4addr.addr_bytes), plen);
|
2003-04-24 09:00:27 +00:00
|
|
|
prefix_tree = proto_item_add_subtree(ti, ett_bgp_prefix);
|
2004-10-01 07:07:03 +00:00
|
|
|
proto_tree_add_text(prefix_tree, tvb, start_offset, 1, "%s Prefix length: %u",
|
|
|
|
tag, plen + labnum * 3 * 8);
|
|
|
|
proto_tree_add_text(prefix_tree, tvb, start_offset + 1, 3 * labnum, "%s Label Stack: %s",
|
2009-03-28 00:27:03 +00:00
|
|
|
tag, stack_strbuf->str);
|
2003-04-24 09:00:27 +00:00
|
|
|
if (hf_addr4 != -1) {
|
2004-10-01 07:07:03 +00:00
|
|
|
proto_tree_add_ipv4(prefix_tree, hf_addr4, tvb, offset,
|
2003-04-24 09:00:27 +00:00
|
|
|
length, ip4addr.addr);
|
|
|
|
} else {
|
2004-10-01 07:07:03 +00:00
|
|
|
proto_tree_add_text(prefix_tree, tvb, offset, length,
|
2003-04-24 09:00:27 +00:00
|
|
|
"%s IPv4 prefix: %s",
|
|
|
|
tag, ip_to_str(ip4addr.addr_bytes));
|
|
|
|
}
|
|
|
|
total_length = (1 + labnum*3) + length;
|
|
|
|
break;
|
|
|
|
|
2005-01-07 11:43:05 +00:00
|
|
|
case SAFNUM_TUNNEL:
|
|
|
|
plen = tvb_get_guint8(tvb, offset);
|
|
|
|
if (plen <= 16){
|
|
|
|
proto_tree_add_text(tree, tvb, start_offset, 1,
|
|
|
|
"%s Tunnel IPv4 prefix length %u invalid",
|
|
|
|
tag, plen);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
tnl_id = tvb_get_ntohs(tvb, offset + 1);
|
|
|
|
offset += 3; /* Length + Tunnel Id */
|
|
|
|
plen -= 16; /* 2-octet Identifier */
|
|
|
|
length = ipv4_addr_and_mask(tvb, offset, ip4addr.addr_bytes, plen);
|
|
|
|
if (length < 0) {
|
|
|
|
proto_tree_add_text(tree, tvb, start_offset, 1,
|
|
|
|
"%s Tunnel IPv4 prefix length %u invalid",
|
|
|
|
tag, plen + 16);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
ti = proto_tree_add_text(tree, tvb, start_offset,
|
|
|
|
(offset + length) - start_offset,
|
|
|
|
"Tunnel Identifier=0x%x IPv4=%s/%u",
|
|
|
|
tnl_id, ip_to_str(ip4addr.addr_bytes), plen);
|
|
|
|
prefix_tree = proto_item_add_subtree(ti, ett_bgp_prefix);
|
|
|
|
|
|
|
|
proto_tree_add_text(prefix_tree, tvb, start_offset, 1, "%s Prefix length: %u",
|
|
|
|
tag, plen + 16);
|
|
|
|
proto_tree_add_item(prefix_tree, hf_bgp_mp_nlri_tnl_id, tvb,
|
|
|
|
start_offset + 1, 2, FALSE);
|
|
|
|
if (hf_addr4 != -1) {
|
|
|
|
proto_tree_add_ipv4(prefix_tree, hf_addr4, tvb, offset,
|
|
|
|
length, ip4addr.addr);
|
|
|
|
} else {
|
|
|
|
proto_tree_add_text(prefix_tree, tvb, offset, length,
|
|
|
|
"%s IPv4 prefix: %s",
|
|
|
|
tag, ip_to_str(ip4addr.addr_bytes));
|
|
|
|
}
|
|
|
|
total_length = 1 + 2 + length; /* length field + Tunnel Id + IPv4 len */
|
|
|
|
break;
|
|
|
|
|
2003-04-24 09:00:27 +00:00
|
|
|
case SAFNUM_LAB_VPNUNICAST:
|
|
|
|
case SAFNUM_LAB_VPNMULCAST:
|
|
|
|
case SAFNUM_LAB_VPNUNIMULC:
|
|
|
|
plen = tvb_get_guint8(tvb, offset);
|
2009-04-14 18:31:02 +00:00
|
|
|
stack_strbuf = ep_strbuf_new_label(NULL);
|
2009-03-28 00:27:03 +00:00
|
|
|
labnum = decode_MPLS_stack(tvb, offset + 1, stack_strbuf);
|
2003-04-24 09:00:27 +00:00
|
|
|
|
|
|
|
offset += (1 + labnum * 3);
|
|
|
|
if (plen <= (labnum * 3*8)) {
|
|
|
|
proto_tree_add_text(tree, tvb, start_offset, 1,
|
2004-10-01 07:07:03 +00:00
|
|
|
"%s Labeled VPN IPv4 prefix length %u invalid",
|
|
|
|
tag, plen);
|
2003-04-24 09:00:27 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
plen -= (labnum * 3*8);
|
|
|
|
|
|
|
|
rd_type = tvb_get_ntohs(tvb, offset);
|
2006-03-15 18:53:54 +00:00
|
|
|
if (plen < 8*8) {
|
2003-04-24 09:00:27 +00:00
|
|
|
proto_tree_add_text(tree, tvb, start_offset, 1,
|
2004-10-01 07:07:03 +00:00
|
|
|
"%s Labeled VPN IPv4 prefix length %u invalid",
|
2003-04-24 09:00:27 +00:00
|
|
|
tag, plen + (labnum * 3*8));
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
plen -= 8*8;
|
2001-06-10 02:08:11 +00:00
|
|
|
|
2003-04-24 09:00:27 +00:00
|
|
|
switch (rd_type) {
|
2001-06-10 02:08:11 +00:00
|
|
|
|
2003-04-24 09:00:27 +00:00
|
|
|
case FORMAT_AS2_LOC: /* Code borrowed from the decode_prefix4 function */
|
2004-03-06 03:25:10 +00:00
|
|
|
length = ipv4_addr_and_mask(tvb, offset + 8, ip4addr.addr_bytes, plen);
|
|
|
|
if (length < 0) {
|
2003-04-24 09:00:27 +00:00
|
|
|
proto_tree_add_text(tree, tvb, start_offset, 1,
|
2004-10-01 07:07:03 +00:00
|
|
|
"%s Labeled VPN IPv4 prefix length %u invalid",
|
2003-04-24 09:00:27 +00:00
|
|
|
tag, plen + (labnum * 3*8) + 8*8);
|
|
|
|
return -1;
|
|
|
|
}
|
2001-06-10 02:08:11 +00:00
|
|
|
|
2003-04-24 09:00:27 +00:00
|
|
|
ti = proto_tree_add_text(tree, tvb, start_offset,
|
|
|
|
(offset + 8 + length) - start_offset,
|
2004-10-01 07:07:03 +00:00
|
|
|
"Label Stack=%s RD=%u:%u, IPv4=%s/%u",
|
2009-03-28 00:27:03 +00:00
|
|
|
stack_strbuf->str,
|
2003-04-24 09:00:27 +00:00
|
|
|
tvb_get_ntohs(tvb, offset + 2),
|
|
|
|
tvb_get_ntohl(tvb, offset + 4),
|
|
|
|
ip_to_str(ip4addr.addr_bytes), plen);
|
|
|
|
prefix_tree = proto_item_add_subtree(ti, ett_bgp_prefix);
|
2004-10-01 07:07:03 +00:00
|
|
|
proto_tree_add_text(prefix_tree, tvb, start_offset, 1, "%s Prefix length: %u",
|
|
|
|
tag, plen + labnum * 3 * 8 + 8 * 8);
|
|
|
|
proto_tree_add_text(prefix_tree, tvb, start_offset + 1, 3 * labnum,
|
2009-03-28 00:27:03 +00:00
|
|
|
"%s Label Stack: %s", tag, stack_strbuf->str);
|
2004-10-01 07:07:03 +00:00
|
|
|
proto_tree_add_text(prefix_tree, tvb, start_offset + 1 + 3 * labnum, 8,
|
|
|
|
"%s Route Distinguisher: %u:%u", tag, tvb_get_ntohs(tvb, offset + 2),
|
|
|
|
tvb_get_ntohl(tvb, offset + 4));
|
2003-04-24 09:00:27 +00:00
|
|
|
if (hf_addr4 != -1) {
|
|
|
|
proto_tree_add_ipv4(prefix_tree, hf_addr4, tvb,
|
|
|
|
offset + 8, length, ip4addr.addr);
|
|
|
|
} else {
|
|
|
|
proto_tree_add_text(prefix_tree, tvb, offset + 8,
|
|
|
|
length, "%s IPv4 prefix: %s", tag,
|
|
|
|
ip_to_str(ip4addr.addr_bytes));
|
2001-06-10 02:08:11 +00:00
|
|
|
}
|
2003-04-24 09:00:27 +00:00
|
|
|
total_length = (1 + labnum * 3 + 8) + length;
|
2001-06-10 02:08:11 +00:00
|
|
|
break;
|
2002-11-04 22:00:14 +00:00
|
|
|
|
2003-04-24 09:00:27 +00:00
|
|
|
case FORMAT_IP_LOC: /* Code borrowed from the decode_prefix4 function */
|
|
|
|
tvb_memcpy(tvb, ip4addr.addr_bytes, offset + 2, 4);
|
2002-11-04 22:00:14 +00:00
|
|
|
|
2004-03-06 03:25:10 +00:00
|
|
|
length = ipv4_addr_and_mask(tvb, offset + 8, ip4addr2.addr_bytes, plen);
|
|
|
|
if (length < 0) {
|
2003-04-24 09:00:27 +00:00
|
|
|
proto_tree_add_text(tree, tvb, start_offset, 1,
|
2004-10-01 07:07:03 +00:00
|
|
|
"%s Labeled VPN IPv4 prefix length %u invalid",
|
2003-04-24 09:00:27 +00:00
|
|
|
tag, plen + (labnum * 3*8) + 8*8);
|
|
|
|
return -1;
|
|
|
|
}
|
2002-11-04 22:00:14 +00:00
|
|
|
|
2003-04-24 09:00:27 +00:00
|
|
|
ti = proto_tree_add_text(tree, tvb, start_offset,
|
|
|
|
(offset + 8 + length) - start_offset,
|
2004-10-01 07:07:03 +00:00
|
|
|
"Label Stack=%s RD=%s:%u, IPv4=%s/%u",
|
2009-03-28 00:27:03 +00:00
|
|
|
stack_strbuf->str,
|
2003-04-24 09:00:27 +00:00
|
|
|
ip_to_str(ip4addr.addr_bytes),
|
|
|
|
tvb_get_ntohs(tvb, offset + 6),
|
|
|
|
ip_to_str(ip4addr2.addr_bytes),
|
|
|
|
plen);
|
2004-10-01 07:07:03 +00:00
|
|
|
prefix_tree = proto_item_add_subtree(ti, ett_bgp_prefix);
|
|
|
|
proto_tree_add_text(prefix_tree, tvb, start_offset, 1, "%s Prefix length: %u",
|
|
|
|
tag, plen + labnum * 3 * 8 + 8 * 8);
|
|
|
|
proto_tree_add_text(prefix_tree, tvb, start_offset + 1, 3 * labnum,
|
2009-03-28 00:27:03 +00:00
|
|
|
"%s Label Stack: %s", tag, stack_strbuf->str);
|
2004-10-01 07:07:03 +00:00
|
|
|
proto_tree_add_text(prefix_tree, tvb, start_offset + 1 + 3 * labnum, 8,
|
|
|
|
"%s Route Distinguisher: %s:%u", tag, ip_to_str(ip4addr.addr_bytes),
|
|
|
|
tvb_get_ntohs(tvb, offset + 6));
|
|
|
|
if (hf_addr4 != -1) {
|
|
|
|
proto_tree_add_ipv4(prefix_tree, hf_addr4, tvb,
|
|
|
|
offset + 8, length, ip4addr2.addr);
|
|
|
|
} else {
|
|
|
|
proto_tree_add_text(prefix_tree, tvb, offset + 8,
|
|
|
|
length, "%s IPv4 prefix: %s", tag,
|
|
|
|
ip_to_str(ip4addr2.addr_bytes));
|
|
|
|
}
|
2003-04-24 09:00:27 +00:00
|
|
|
total_length = (1 + labnum * 3 + 8) + length;
|
|
|
|
break;
|
2002-11-04 22:00:14 +00:00
|
|
|
|
2003-04-24 09:00:27 +00:00
|
|
|
default:
|
|
|
|
proto_tree_add_text(tree, tvb, start_offset,
|
|
|
|
(offset - start_offset) + 2,
|
2004-10-01 07:07:03 +00:00
|
|
|
"Unknown labeled VPN IPv4 address format %u", rd_type);
|
2003-04-24 09:00:27 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
break;
|
2002-11-04 22:00:14 +00:00
|
|
|
|
2003-04-24 09:00:27 +00:00
|
|
|
default:
|
|
|
|
proto_tree_add_text(tree, tvb, start_offset, 0,
|
|
|
|
"Unknown SAFI (%u) for AFI %u", safi, afi);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case AFNUM_INET6:
|
|
|
|
switch (safi) {
|
|
|
|
|
|
|
|
case SAFNUM_UNICAST:
|
|
|
|
case SAFNUM_MULCAST:
|
|
|
|
case SAFNUM_UNIMULC:
|
|
|
|
total_length = decode_prefix6(tree, hf_addr6, tvb, offset, 0, tag);
|
|
|
|
if (total_length < 0)
|
|
|
|
return -1;
|
|
|
|
break;
|
|
|
|
|
2004-01-23 19:19:44 +00:00
|
|
|
case SAFNUM_MPLS_LABEL:
|
|
|
|
plen = tvb_get_guint8(tvb, offset);
|
2009-04-14 18:31:02 +00:00
|
|
|
stack_strbuf = ep_strbuf_new_label(NULL);
|
2009-03-28 00:27:03 +00:00
|
|
|
labnum = decode_MPLS_stack(tvb, offset + 1, stack_strbuf);
|
2004-01-23 19:19:44 +00:00
|
|
|
|
|
|
|
offset += (1 + labnum * 3);
|
|
|
|
if (plen <= (labnum * 3*8)) {
|
|
|
|
proto_tree_add_text(tree, tvb, start_offset, 1,
|
2004-10-01 07:07:03 +00:00
|
|
|
"%s Labeled IPv6 prefix length %u invalid", tag, plen);
|
2004-01-23 19:19:44 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
plen -= (labnum * 3*8);
|
|
|
|
|
2004-03-06 03:25:10 +00:00
|
|
|
length = ipv6_addr_and_mask(tvb, offset, &ip6addr, plen);
|
|
|
|
if (length < 0) {
|
2004-03-06 02:26:31 +00:00
|
|
|
proto_tree_add_text(tree, tvb, start_offset, 1,
|
2005-01-07 11:43:05 +00:00
|
|
|
"%s Labeled IPv6 prefix length %u invalid",
|
|
|
|
tag, plen + (labnum * 3*8));
|
2004-03-06 02:26:31 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2004-01-23 19:19:44 +00:00
|
|
|
ti = proto_tree_add_text(tree, tvb, start_offset,
|
|
|
|
(offset + length) - start_offset,
|
2004-10-01 07:07:03 +00:00
|
|
|
"Label Stack=%s, IPv6=%s/%u",
|
2009-03-28 00:27:03 +00:00
|
|
|
stack_strbuf->str,
|
2004-01-23 19:19:44 +00:00
|
|
|
ip6_to_str(&ip6addr), plen);
|
|
|
|
total_length = (1 + labnum * 3) + length;
|
|
|
|
break;
|
|
|
|
|
2005-01-07 11:43:05 +00:00
|
|
|
case SAFNUM_TUNNEL:
|
|
|
|
plen = tvb_get_guint8(tvb, offset);
|
|
|
|
if (plen <= 16){
|
|
|
|
proto_tree_add_text(tree, tvb, start_offset, 1,
|
|
|
|
"%s Tunnel IPv6 prefix length %u invalid",
|
|
|
|
tag, plen);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
tnl_id = tvb_get_ntohs(tvb, offset + 1);
|
|
|
|
offset += 3; /* Length + Tunnel Id */
|
|
|
|
plen -= 16; /* 2-octet Identifier */
|
|
|
|
length = ipv6_addr_and_mask(tvb, offset, &ip6addr, plen);
|
|
|
|
if (length < 0) {
|
|
|
|
proto_tree_add_text(tree, tvb, start_offset, 1,
|
|
|
|
"%s Tunnel IPv6 prefix length %u invalid",
|
|
|
|
tag, plen + 16);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
ti = proto_tree_add_text(tree, tvb, start_offset,
|
|
|
|
(offset + length) - start_offset,
|
|
|
|
"Tunnel Identifier=0x%x IPv6=%s/%u",
|
|
|
|
tnl_id, ip6_to_str(&ip6addr), plen);
|
|
|
|
total_length = (1 + 2) + length; /* length field + Tunnel Id + IPv4 len */
|
|
|
|
break;
|
|
|
|
|
2003-04-24 09:00:27 +00:00
|
|
|
case SAFNUM_LAB_VPNUNICAST:
|
|
|
|
case SAFNUM_LAB_VPNMULCAST:
|
|
|
|
case SAFNUM_LAB_VPNUNIMULC:
|
|
|
|
plen = tvb_get_guint8(tvb, offset);
|
2009-04-14 18:31:02 +00:00
|
|
|
stack_strbuf = ep_strbuf_new_label(NULL);
|
2009-03-28 00:27:03 +00:00
|
|
|
labnum = decode_MPLS_stack(tvb, offset + 1, stack_strbuf);
|
2003-04-24 09:00:27 +00:00
|
|
|
|
|
|
|
offset += (1 + labnum * 3);
|
|
|
|
if (plen <= (labnum * 3*8)) {
|
|
|
|
proto_tree_add_text(tree, tvb, start_offset, 1,
|
2004-10-01 07:07:03 +00:00
|
|
|
"%s Labeled VPN IPv6 prefix length %u invalid", tag, plen);
|
2003-04-24 09:00:27 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
plen -= (labnum * 3*8);
|
|
|
|
|
|
|
|
rd_type = tvb_get_ntohs(tvb,offset);
|
2006-03-15 18:53:54 +00:00
|
|
|
if (plen < 8*8) {
|
2003-04-24 09:00:27 +00:00
|
|
|
proto_tree_add_text(tree, tvb, start_offset, 1,
|
2004-10-01 07:07:03 +00:00
|
|
|
"%s Labeled VPN IPv6 prefix length %u invalid",
|
2003-04-24 09:00:27 +00:00
|
|
|
tag, plen + (labnum * 3*8));
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
plen -= 8*8;
|
2002-11-04 22:00:14 +00:00
|
|
|
|
2003-04-24 09:00:27 +00:00
|
|
|
switch (rd_type) {
|
2002-11-04 22:00:14 +00:00
|
|
|
|
2003-04-24 09:00:27 +00:00
|
|
|
case FORMAT_AS2_LOC:
|
2004-03-06 03:25:10 +00:00
|
|
|
length = ipv6_addr_and_mask(tvb, offset + 8, &ip6addr, plen);
|
|
|
|
if (length < 0) {
|
2003-04-24 09:00:27 +00:00
|
|
|
proto_tree_add_text(tree, tvb, start_offset, 1,
|
2004-10-01 07:07:03 +00:00
|
|
|
"%s Labeled VPN IPv6 prefix length %u invalid",
|
2003-04-24 09:00:27 +00:00
|
|
|
tag, plen + (labnum * 3*8) + 8*8);
|
|
|
|
return -1;
|
2002-08-27 08:41:43 +00:00
|
|
|
}
|
2003-04-24 09:00:27 +00:00
|
|
|
|
|
|
|
ti = proto_tree_add_text(tree, tvb, start_offset,
|
|
|
|
(offset + 8 + length) - start_offset,
|
2004-10-01 07:07:03 +00:00
|
|
|
"Label Stack=%s RD=%u:%u, IPv6=%s/%u",
|
2009-03-28 00:27:03 +00:00
|
|
|
stack_strbuf->str,
|
2003-04-24 09:00:27 +00:00
|
|
|
tvb_get_ntohs(tvb, offset + 2),
|
|
|
|
tvb_get_ntohl(tvb, offset + 4),
|
|
|
|
ip6_to_str(&ip6addr), plen);
|
|
|
|
total_length = (1 + labnum * 3 + 8) + length;
|
2002-08-27 08:41:43 +00:00
|
|
|
break;
|
2002-08-28 21:04:11 +00:00
|
|
|
|
2009-03-28 00:35:02 +00:00
|
|
|
case FORMAT_IP_LOC:
|
2003-04-24 09:00:27 +00:00
|
|
|
tvb_memcpy(tvb, ip4addr.addr_bytes, offset + 2, 4);
|
|
|
|
|
2004-03-06 03:25:10 +00:00
|
|
|
length = ipv6_addr_and_mask(tvb, offset + 8, &ip6addr, plen);
|
|
|
|
if (length < 0) {
|
2003-04-24 09:00:27 +00:00
|
|
|
proto_tree_add_text(tree, tvb, start_offset, 1,
|
2004-10-01 07:07:03 +00:00
|
|
|
"%s Labeled VPN IPv6 prefix length %u invalid",
|
2003-04-24 09:00:27 +00:00
|
|
|
tag, plen + (labnum * 3*8) + 8*8);
|
|
|
|
return -1;
|
2002-08-27 08:41:43 +00:00
|
|
|
}
|
2003-04-24 09:00:27 +00:00
|
|
|
|
|
|
|
ti = proto_tree_add_text(tree, tvb, start_offset,
|
|
|
|
(offset + 8 + length) - start_offset,
|
2004-10-01 07:07:03 +00:00
|
|
|
"Label Stack=%s RD=%s:%u, IPv6=%s/%u",
|
2009-03-28 00:27:03 +00:00
|
|
|
stack_strbuf->str,
|
2003-04-24 09:00:27 +00:00
|
|
|
ip_to_str(ip4addr.addr_bytes),
|
|
|
|
tvb_get_ntohs(tvb, offset + 6),
|
|
|
|
ip6_to_str(&ip6addr), plen);
|
|
|
|
total_length = (1 + labnum * 3 + 8) + length;
|
2002-08-27 08:41:43 +00:00
|
|
|
break;
|
2003-04-24 09:00:27 +00:00
|
|
|
|
|
|
|
default:
|
|
|
|
proto_tree_add_text(tree, tvb, start_offset, 0,
|
2004-10-01 07:07:03 +00:00
|
|
|
"Unknown labeled VPN IPv6 address format %u", rd_type);
|
2003-04-24 09:00:27 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
2001-06-10 02:08:11 +00:00
|
|
|
default:
|
2003-04-24 09:00:27 +00:00
|
|
|
proto_tree_add_text(tree, tvb, start_offset, 0,
|
|
|
|
"Unknown SAFI (%u) for AFI %u", safi, afi);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case AFNUM_L2VPN:
|
2005-10-11 05:23:27 +00:00
|
|
|
case AFNUM_L2VPN_OLD:
|
2003-04-24 09:00:27 +00:00
|
|
|
switch (safi) {
|
|
|
|
|
|
|
|
case SAFNUM_LAB_VPNUNICAST:
|
|
|
|
case SAFNUM_LAB_VPNMULCAST:
|
|
|
|
case SAFNUM_LAB_VPNUNIMULC:
|
2005-10-11 05:23:27 +00:00
|
|
|
case SAFNUM_VPLS:
|
2004-01-06 02:29:36 +00:00
|
|
|
plen = tvb_get_ntohs(tvb,offset);
|
2003-04-24 09:00:27 +00:00
|
|
|
rd_type=tvb_get_ntohs(tvb,offset+2);
|
|
|
|
ce_id=tvb_get_ntohs(tvb,offset+10);
|
|
|
|
labblk_off=tvb_get_ntohs(tvb,offset+12);
|
2006-07-03 08:38:30 +00:00
|
|
|
labblk_size=tvb_get_ntohs(tvb,offset+14);
|
2009-04-14 18:31:02 +00:00
|
|
|
stack_strbuf = ep_strbuf_new_label(NULL);
|
2009-03-28 00:27:03 +00:00
|
|
|
labnum = decode_MPLS_stack(tvb, offset + 16, stack_strbuf);
|
2003-04-24 09:00:27 +00:00
|
|
|
|
|
|
|
switch (rd_type) {
|
|
|
|
|
|
|
|
case FORMAT_AS2_LOC:
|
|
|
|
tvb_memcpy(tvb, ip4addr.addr_bytes, offset + 6, 4);
|
|
|
|
proto_tree_add_text(tree, tvb, start_offset,
|
|
|
|
(offset + plen + 1) - start_offset,
|
2006-07-03 08:38:30 +00:00
|
|
|
"RD: %u:%s, CE-ID: %u, Label-Block Offset: %u, "
|
|
|
|
"Label-Block Size: %u Label Base %s",
|
2003-04-24 09:00:27 +00:00
|
|
|
tvb_get_ntohs(tvb, offset + 4),
|
|
|
|
ip_to_str(ip4addr.addr_bytes),
|
|
|
|
ce_id,
|
|
|
|
labblk_off,
|
2007-10-11 22:04:32 +00:00
|
|
|
labblk_size,
|
2009-03-28 00:27:03 +00:00
|
|
|
stack_strbuf->str);
|
2003-04-24 09:00:27 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case FORMAT_IP_LOC:
|
|
|
|
tvb_memcpy(tvb, ip4addr.addr_bytes, offset + 4, 4);
|
|
|
|
proto_tree_add_text(tree, tvb, offset,
|
|
|
|
(offset + plen + 1) - start_offset,
|
2006-07-03 08:38:30 +00:00
|
|
|
"RD: %s:%u, CE-ID: %u, Label-Block Offset: %u, "
|
|
|
|
"Label-Block Size: %u, Label Base %s",
|
2003-04-24 09:00:27 +00:00
|
|
|
ip_to_str(ip4addr.addr_bytes),
|
|
|
|
tvb_get_ntohs(tvb, offset + 8),
|
|
|
|
ce_id,
|
|
|
|
labblk_off,
|
2006-07-03 08:38:30 +00:00
|
|
|
labblk_size,
|
2009-03-28 00:27:03 +00:00
|
|
|
stack_strbuf->str);
|
2001-06-10 02:08:11 +00:00
|
|
|
break;
|
2003-04-24 09:00:27 +00:00
|
|
|
|
|
|
|
default:
|
|
|
|
proto_tree_add_text(tree, tvb, start_offset,
|
|
|
|
(offset - start_offset) + 2,
|
|
|
|
"Unknown labeled VPN address format %u", rd_type);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
/* FIXME there are subTLVs left to decode ... for now lets omit them */
|
|
|
|
total_length = plen+2;
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
proto_tree_add_text(tree, tvb, start_offset, 0,
|
|
|
|
"Unknown SAFI (%u) for AFI %u", safi, afi);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
proto_tree_add_text(tree, tvb, start_offset, 0,
|
|
|
|
"Unknown AFI (%u) value", afi);
|
|
|
|
return -1;
|
2001-06-10 02:08:11 +00:00
|
|
|
}
|
2003-04-24 09:00:27 +00:00
|
|
|
return(total_length);
|
2001-06-10 02:08:11 +00:00
|
|
|
}
|
|
|
|
|
2003-01-28 05:25:18 +00:00
|
|
|
/*
|
|
|
|
* Dissect a BGP capability.
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
dissect_bgp_capability_item(tvbuff_t *tvb, int *p, proto_tree *tree, int ctype, int clen)
|
|
|
|
{
|
|
|
|
proto_tree *subtree;
|
|
|
|
proto_item *ti;
|
|
|
|
guint8 orfnum; /* number of ORFs */
|
|
|
|
guint8 orftype; /* ORF Type */
|
|
|
|
guint8 orfsendrecv; /* ORF Send/Receive */
|
|
|
|
int tclen; /* capability length */
|
|
|
|
int i;
|
|
|
|
|
|
|
|
/* check the capability type */
|
|
|
|
switch (ctype) {
|
|
|
|
case BGP_CAPABILITY_RESERVED:
|
|
|
|
proto_tree_add_text(tree, tvb, *p - 2, 1,
|
|
|
|
"Capability code: %s (%d)", val_to_str(ctype,
|
|
|
|
capability_vals, "Unknown capability"), ctype);
|
|
|
|
proto_tree_add_text(tree, tvb, *p - 1,
|
2007-08-23 20:42:27 +00:00
|
|
|
1, "Capability length: %u byte%s", clen,
|
|
|
|
plurality(clen, "", "s"));
|
2003-01-28 05:25:18 +00:00
|
|
|
if (clen != 0) {
|
|
|
|
proto_tree_add_text(tree, tvb, *p,
|
|
|
|
clen, "Capability value: Unknown");
|
|
|
|
}
|
|
|
|
*p += clen;
|
|
|
|
break;
|
|
|
|
case BGP_CAPABILITY_MULTIPROTOCOL:
|
|
|
|
proto_tree_add_text(tree, tvb, *p - 2, 1,
|
|
|
|
"Capability code: %s (%d)", val_to_str(ctype,
|
|
|
|
capability_vals, "Unknown capability"), ctype);
|
|
|
|
if (clen != 4) {
|
|
|
|
proto_tree_add_text(tree, tvb, *p - 1,
|
|
|
|
1, "Capability length: Invalid");
|
|
|
|
proto_tree_add_text(tree, tvb, *p,
|
|
|
|
clen, "Capability value: Unknown");
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
proto_tree_add_text(tree, tvb, *p - 1,
|
2007-08-23 20:42:27 +00:00
|
|
|
1, "Capability length: %u byte%s", clen,
|
|
|
|
plurality(clen, "", "s"));
|
2003-01-28 05:25:18 +00:00
|
|
|
ti = proto_tree_add_text(tree, tvb, *p, clen, "Capability value");
|
|
|
|
subtree = proto_item_add_subtree(ti, ett_bgp_option);
|
|
|
|
/* AFI */
|
|
|
|
i = tvb_get_ntohs(tvb, *p);
|
|
|
|
proto_tree_add_text(subtree, tvb, *p,
|
|
|
|
2, "Address family identifier: %s (%u)",
|
|
|
|
val_to_str(i, afn_vals, "Unknown"), i);
|
|
|
|
*p += 2;
|
|
|
|
/* Reserved */
|
|
|
|
proto_tree_add_text(subtree, tvb, *p, 1, "Reserved: 1 byte");
|
|
|
|
(*p)++;
|
|
|
|
/* SAFI */
|
|
|
|
i = tvb_get_guint8(tvb, *p);
|
|
|
|
proto_tree_add_text(subtree, tvb, *p,
|
|
|
|
1, "Subsequent address family identifier: %s (%u)",
|
|
|
|
val_to_str(i, bgpattr_nlri_safi,
|
|
|
|
i >= 128 ? "Vendor specific" : "Unknown"), i);
|
|
|
|
(*p)++;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case BGP_CAPABILITY_GRACEFUL_RESTART:
|
|
|
|
proto_tree_add_text(tree, tvb, *p - 2, 1,
|
|
|
|
"Capability code: %s (%d)", val_to_str(ctype,
|
|
|
|
capability_vals, "Unknown capability"), ctype);
|
|
|
|
if (clen < 6) {
|
|
|
|
proto_tree_add_text(tree, tvb, *p,
|
|
|
|
clen, "Capability value: Invalid");
|
2009-02-23 22:07:19 +00:00
|
|
|
*p += clen;
|
2003-01-28 05:25:18 +00:00
|
|
|
}
|
|
|
|
else {
|
|
|
|
proto_tree_add_text(tree, tvb, *p - 1,
|
2007-08-23 20:42:27 +00:00
|
|
|
1, "Capability length: %u byte%s", clen,
|
|
|
|
plurality(clen, "", "s"));
|
2003-01-28 05:25:18 +00:00
|
|
|
ti = proto_tree_add_text(tree, tvb, *p, clen, "Capability value");
|
|
|
|
subtree = proto_item_add_subtree(ti, ett_bgp_option);
|
|
|
|
/* Timers */
|
|
|
|
i = tvb_get_ntohs(tvb, *p);
|
|
|
|
proto_tree_add_text(subtree, tvb, *p,
|
|
|
|
2, "Restart Flags: [%s], Restart Time %us",
|
|
|
|
(i&0x8000) ? "R" : "none", i&0xfff);
|
|
|
|
*p += 2;
|
|
|
|
tclen = clen - 2;
|
|
|
|
/*
|
|
|
|
* what follows is alist of AFI/SAFI/flag triplets
|
|
|
|
* read it until the TLV ends
|
|
|
|
*/
|
|
|
|
while (tclen >=4) {
|
|
|
|
/* AFI */
|
|
|
|
i = tvb_get_ntohs(tvb, *p);
|
|
|
|
proto_tree_add_text(subtree, tvb, *p,
|
|
|
|
2, "Address family identifier: %s (%u)",
|
|
|
|
val_to_str(i, afn_vals, "Unknown"), i);
|
|
|
|
*p += 2;
|
|
|
|
/* SAFI */
|
|
|
|
i = tvb_get_guint8(tvb, *p);
|
|
|
|
proto_tree_add_text(subtree, tvb, *p,
|
|
|
|
1, "Subsequent address family identifier: %s (%u)",
|
|
|
|
val_to_str(i, bgpattr_nlri_safi,
|
|
|
|
i >= 128 ? "Vendor specific" : "Unknown"), i);
|
|
|
|
(*p)++;
|
|
|
|
/* flags */
|
|
|
|
i = tvb_get_guint8(tvb, *p);
|
|
|
|
proto_tree_add_text(subtree, tvb, *p, 1,
|
|
|
|
"Preserve forwarding state: %s",
|
|
|
|
(i&0x80) ? "yes" : "no");
|
|
|
|
(*p)++;
|
|
|
|
tclen-=4;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case BGP_CAPABILITY_4_OCTET_AS_NUMBER:
|
|
|
|
proto_tree_add_text(tree, tvb, *p - 2, 1,
|
|
|
|
"Capability code: %s (%d)", val_to_str(ctype,
|
|
|
|
capability_vals, "Unknown capability"), ctype);
|
|
|
|
if (clen != 4) {
|
|
|
|
proto_tree_add_text(tree, tvb, *p,
|
|
|
|
clen, "Capability value: Invalid");
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
proto_tree_add_text(tree, tvb, *p - 1,
|
2007-08-23 20:42:27 +00:00
|
|
|
1, "Capability length: %u byte%s", clen,
|
|
|
|
plurality(clen, "", "s"));
|
2003-01-28 05:25:18 +00:00
|
|
|
ti = proto_tree_add_text(tree, tvb, *p, clen, "Capability value");
|
|
|
|
subtree = proto_item_add_subtree(ti, ett_bgp_option);
|
|
|
|
proto_tree_add_text(subtree, tvb, *p, 4,
|
|
|
|
"AS number: %d", tvb_get_ntohl(tvb, *p));
|
|
|
|
}
|
|
|
|
*p += clen;
|
|
|
|
break;
|
|
|
|
case BGP_CAPABILITY_DYNAMIC_CAPABILITY:
|
|
|
|
proto_tree_add_text(tree, tvb, *p - 2, 1,
|
|
|
|
"Capability code: %s (%d)", val_to_str(ctype,
|
|
|
|
capability_vals, "Unknown capability"), ctype);
|
|
|
|
proto_tree_add_text(tree, tvb, *p - 1, 1,
|
2007-08-23 20:42:27 +00:00
|
|
|
"Capability length: %u byte%s", clen,
|
|
|
|
plurality(clen, "", "s"));
|
2003-01-28 05:25:18 +00:00
|
|
|
if (clen > 0) {
|
|
|
|
ti = proto_tree_add_text(tree, tvb, *p, clen, "Capability value");
|
|
|
|
subtree = proto_item_add_subtree(ti, ett_bgp_option);
|
|
|
|
for (i = 0; (int)i <= clen; i++) {
|
|
|
|
proto_tree_add_text(subtree, tvb, *p, 1,
|
|
|
|
"Capability code: %s (%d)", val_to_str(ctype,
|
|
|
|
capability_vals, "Unknown capability"),
|
|
|
|
tvb_get_guint8(tvb, *p));
|
|
|
|
(*p)++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case BGP_CAPABILITY_ROUTE_REFRESH_CISCO:
|
|
|
|
case BGP_CAPABILITY_ROUTE_REFRESH:
|
|
|
|
proto_tree_add_text(tree, tvb, *p - 2, 1,
|
|
|
|
"Capability code: %s (%d)", val_to_str(ctype,
|
|
|
|
capability_vals, "Unknown capability"), ctype);
|
|
|
|
if (clen != 0) {
|
|
|
|
proto_tree_add_text(tree, tvb, *p,
|
|
|
|
clen, "Capability value: Invalid");
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
proto_tree_add_text(tree, tvb, *p - 1,
|
2007-08-23 20:42:27 +00:00
|
|
|
1, "Capability length: %u byte%s", clen,
|
|
|
|
plurality(clen, "", "s"));
|
2003-01-28 05:25:18 +00:00
|
|
|
}
|
|
|
|
*p += clen;
|
|
|
|
break;
|
|
|
|
case BGP_CAPABILITY_ORF_CISCO:
|
|
|
|
case BGP_CAPABILITY_COOPERATIVE_ROUTE_FILTERING:
|
|
|
|
proto_tree_add_text(tree, tvb, *p - 2, 1,
|
|
|
|
"Capability code: %s (%d)", val_to_str(ctype,
|
|
|
|
capability_vals, "Unknown capability"), ctype);
|
|
|
|
proto_tree_add_text(tree, tvb, *p - 1,
|
2007-08-23 20:42:27 +00:00
|
|
|
1, "Capability length: %u byte%s", clen,
|
|
|
|
plurality(clen, "", "s"));
|
2003-01-28 05:25:18 +00:00
|
|
|
ti = proto_tree_add_text(tree, tvb, *p, clen, "Capability value");
|
|
|
|
subtree = proto_item_add_subtree(ti, ett_bgp_option);
|
|
|
|
/* AFI */
|
|
|
|
i = tvb_get_ntohs(tvb, *p);
|
|
|
|
proto_tree_add_text(subtree, tvb, *p,
|
|
|
|
2, "Address family identifier: %s (%u)",
|
|
|
|
val_to_str(i, afn_vals, "Unknown"), i);
|
|
|
|
*p += 2;
|
|
|
|
/* Reserved */
|
|
|
|
proto_tree_add_text(subtree, tvb, *p, 1, "Reserved: 1 byte");
|
|
|
|
(*p)++;
|
|
|
|
/* SAFI */
|
|
|
|
i = tvb_get_guint8(tvb, *p);
|
|
|
|
proto_tree_add_text(subtree, tvb, *p,
|
|
|
|
1, "Subsequent address family identifier: %s (%u)",
|
|
|
|
val_to_str(i, bgpattr_nlri_safi,
|
|
|
|
i >= 128 ? "Vendor specific" : "Unknown"), i);
|
|
|
|
(*p)++;
|
|
|
|
/* Number of ORFs */
|
|
|
|
orfnum = tvb_get_guint8(tvb, *p);
|
|
|
|
proto_tree_add_text(subtree, tvb, *p, 1, "Number of ORFs: %u", orfnum);
|
|
|
|
(*p)++;
|
|
|
|
for (i=0; i<orfnum; i++) {
|
|
|
|
/* ORF Type */
|
|
|
|
orftype = tvb_get_guint8(tvb, *p);
|
|
|
|
proto_tree_add_text(subtree, tvb, *p, 1, "ORF Type: %s (%u)",
|
|
|
|
val_to_str(orftype, orf_type_vals,"Unknown"), orftype);
|
|
|
|
(*p)++;
|
|
|
|
/* Send/Receive */
|
|
|
|
orfsendrecv = tvb_get_guint8(tvb, *p);
|
|
|
|
proto_tree_add_text(subtree, tvb, *p,
|
|
|
|
1, "Send/Receive: %s (%u)",
|
|
|
|
val_to_str(orfsendrecv, orf_send_recv_vals,
|
|
|
|
"Uknown"), orfsendrecv);
|
|
|
|
(*p)++;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
/* unknown capability */
|
|
|
|
default:
|
|
|
|
proto_tree_add_text(tree, tvb, *p - 2, 1,
|
|
|
|
"Capability code: %s (%d)", val_to_str(ctype,
|
|
|
|
capability_vals, "Unknown capability"), ctype);
|
|
|
|
proto_tree_add_text(tree, tvb, *p - 2,
|
|
|
|
1, "Capability code: %s (%d)",
|
|
|
|
ctype >= 128 ? "Private use" : "Unknown", ctype);
|
|
|
|
proto_tree_add_text(tree, tvb, *p - 1,
|
2007-08-23 20:42:27 +00:00
|
|
|
1, "Capability length: %u byte%s", clen,
|
|
|
|
plurality(clen, "", "s"));
|
2003-01-28 05:25:18 +00:00
|
|
|
if (clen != 0) {
|
|
|
|
proto_tree_add_text(tree, tvb, *p,
|
|
|
|
clen, "Capability value: Unknown");
|
|
|
|
}
|
|
|
|
*p += clen;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
1999-11-06 01:28:50 +00:00
|
|
|
/*
|
|
|
|
* Dissect a BGP OPEN message.
|
|
|
|
*/
|
2002-01-30 23:04:02 +00:00
|
|
|
static const value_string community_vals[] = {
|
|
|
|
{ BGP_COMM_NO_EXPORT, "NO_EXPORT" },
|
|
|
|
{ BGP_COMM_NO_ADVERTISE, "NO_ADVERTISE" },
|
|
|
|
{ BGP_COMM_NO_EXPORT_SUBCONFED, "NO_EXPORT_SUBCONFED" },
|
|
|
|
{ 0, NULL }
|
|
|
|
};
|
|
|
|
|
1999-10-15 17:00:47 +00:00
|
|
|
static void
|
2003-04-05 11:20:54 +00:00
|
|
|
dissect_bgp_open(tvbuff_t *tvb, proto_tree *tree)
|
1999-10-15 17:00:47 +00:00
|
|
|
{
|
2000-12-25 05:28:40 +00:00
|
|
|
struct bgp_open bgpo; /* BGP OPEN message */
|
|
|
|
int hlen; /* message length */
|
|
|
|
int ptype; /* parameter type */
|
|
|
|
int plen; /* parameter length */
|
|
|
|
int ctype; /* capability type */
|
2003-01-28 05:25:18 +00:00
|
|
|
int clen; /* capability length */
|
2001-09-13 22:06:55 +00:00
|
|
|
int cend; /* capabilities end */
|
2000-12-25 05:28:40 +00:00
|
|
|
int ostart; /* options start */
|
2001-04-17 21:25:13 +00:00
|
|
|
int oend; /* options end */
|
|
|
|
int p; /* tvb offset counter */
|
2000-12-25 05:28:40 +00:00
|
|
|
proto_item *ti; /* tree item */
|
|
|
|
proto_tree *subtree; /* subtree for options */
|
2001-09-13 22:06:55 +00:00
|
|
|
proto_tree *subtree1; /* subtree for an option */
|
2000-12-25 05:28:40 +00:00
|
|
|
proto_tree *subtree2; /* subtree for an option */
|
1999-10-15 17:00:47 +00:00
|
|
|
|
1999-11-06 01:28:50 +00:00
|
|
|
/* snarf OPEN message */
|
2003-04-05 11:20:54 +00:00
|
|
|
tvb_memcpy(tvb, bgpo.bgpo_marker, 0, BGP_MIN_OPEN_MSG_SIZE);
|
2002-08-02 23:36:07 +00:00
|
|
|
hlen = g_ntohs(bgpo.bgpo_len);
|
1999-10-15 17:00:47 +00:00
|
|
|
|
2001-04-17 21:25:13 +00:00
|
|
|
proto_tree_add_text(tree, tvb,
|
2003-04-05 11:20:54 +00:00
|
|
|
offsetof(struct bgp_open, bgpo_version), 1,
|
1999-10-15 17:00:47 +00:00
|
|
|
"Version: %u", bgpo.bgpo_version);
|
2001-04-17 21:25:13 +00:00
|
|
|
proto_tree_add_text(tree, tvb,
|
2003-04-05 11:20:54 +00:00
|
|
|
offsetof(struct bgp_open, bgpo_myas), 2,
|
2002-08-02 23:36:07 +00:00
|
|
|
"My AS: %u", g_ntohs(bgpo.bgpo_myas));
|
2001-04-17 21:25:13 +00:00
|
|
|
proto_tree_add_text(tree, tvb,
|
2003-04-05 11:20:54 +00:00
|
|
|
offsetof(struct bgp_open, bgpo_holdtime), 2,
|
2002-08-02 23:36:07 +00:00
|
|
|
"Hold time: %u", g_ntohs(bgpo.bgpo_holdtime));
|
2001-04-17 21:25:13 +00:00
|
|
|
proto_tree_add_text(tree, tvb,
|
2003-04-05 11:20:54 +00:00
|
|
|
offsetof(struct bgp_open, bgpo_id), 4,
|
1999-11-22 07:05:21 +00:00
|
|
|
"BGP identifier: %s", ip_to_str((guint8 *)&bgpo.bgpo_id));
|
2001-04-17 21:25:13 +00:00
|
|
|
proto_tree_add_text(tree, tvb,
|
2003-04-05 11:20:54 +00:00
|
|
|
offsetof(struct bgp_open, bgpo_optlen), 1,
|
2007-08-23 20:42:27 +00:00
|
|
|
"Optional parameters length: %u byte%s", bgpo.bgpo_optlen,
|
|
|
|
plurality(bgpo.bgpo_optlen, "", "s"));
|
1999-11-06 01:28:50 +00:00
|
|
|
|
2000-12-25 05:28:40 +00:00
|
|
|
/* optional parameters */
|
|
|
|
if (bgpo.bgpo_optlen > 0) {
|
|
|
|
/* add a subtree and setup some offsets */
|
2003-04-05 11:20:54 +00:00
|
|
|
ostart = BGP_MIN_OPEN_MSG_SIZE;
|
2001-06-10 02:08:11 +00:00
|
|
|
ti = proto_tree_add_text(tree, tvb, ostart, bgpo.bgpo_optlen,
|
2000-12-25 05:28:40 +00:00
|
|
|
"Optional parameters");
|
|
|
|
subtree = proto_item_add_subtree(ti, ett_bgp_options);
|
2003-04-05 11:20:54 +00:00
|
|
|
p = ostart;
|
2000-12-25 05:28:40 +00:00
|
|
|
oend = p + bgpo.bgpo_optlen;
|
|
|
|
|
|
|
|
/* step through all of the optional parameters */
|
|
|
|
while (p < oend) {
|
|
|
|
|
|
|
|
/* grab the type and length */
|
2001-04-17 21:25:13 +00:00
|
|
|
ptype = tvb_get_guint8(tvb, p++);
|
|
|
|
plen = tvb_get_guint8(tvb, p++);
|
2001-06-10 02:08:11 +00:00
|
|
|
|
|
|
|
/* check the type */
|
2000-12-25 05:28:40 +00:00
|
|
|
switch (ptype) {
|
|
|
|
case BGP_OPTION_AUTHENTICATION:
|
2001-04-17 21:25:13 +00:00
|
|
|
proto_tree_add_text(subtree, tvb, p - 2, 2 + plen,
|
2007-08-23 20:42:27 +00:00
|
|
|
"Authentication information (%u byte%s)", plen,
|
|
|
|
plurality(plen, "", "s"));
|
2000-12-25 05:28:40 +00:00
|
|
|
break;
|
|
|
|
case BGP_OPTION_CAPABILITY:
|
|
|
|
/* grab the capability code */
|
2001-09-13 22:06:55 +00:00
|
|
|
cend = p - 1 + plen;
|
2001-04-17 21:25:13 +00:00
|
|
|
ctype = tvb_get_guint8(tvb, p++);
|
|
|
|
clen = tvb_get_guint8(tvb, p++);
|
2001-09-13 22:06:55 +00:00
|
|
|
ti = proto_tree_add_text(subtree, tvb, p - 4,
|
|
|
|
2 + plen, "Capabilities Advertisement (%u bytes)",
|
|
|
|
2 + plen);
|
|
|
|
subtree1 = proto_item_add_subtree(ti, ett_bgp_option);
|
|
|
|
proto_tree_add_text(subtree1, tvb, p - 4,
|
|
|
|
1, "Parameter type: Capabilities (2)");
|
|
|
|
proto_tree_add_text(subtree1, tvb, p - 3,
|
2007-08-23 20:42:27 +00:00
|
|
|
1, "Parameter length: %u byte%s", plen,
|
|
|
|
plurality(plen, "", "s"));
|
2001-09-13 22:06:55 +00:00
|
|
|
p -= 2;
|
|
|
|
|
|
|
|
/* step through all of the capabilities */
|
|
|
|
while (p < cend) {
|
|
|
|
ctype = tvb_get_guint8(tvb, p++);
|
|
|
|
clen = tvb_get_guint8(tvb, p++);
|
|
|
|
|
2003-01-28 05:25:18 +00:00
|
|
|
ti = proto_tree_add_text(subtree1, tvb, p - 2,
|
2007-08-23 20:42:27 +00:00
|
|
|
2 + clen, "%s (%u byte%s)", val_to_str(ctype,
|
2003-01-28 05:25:18 +00:00
|
|
|
capability_vals, "Unknown capability"),
|
2007-08-23 20:42:27 +00:00
|
|
|
2 + clen, plurality(clen, "", "s"));
|
2003-01-28 05:25:18 +00:00
|
|
|
subtree2 = proto_item_add_subtree(ti, ett_bgp_option);
|
|
|
|
dissect_bgp_capability_item(tvb, &p,
|
|
|
|
subtree2, ctype, clen);
|
2001-09-13 22:06:55 +00:00
|
|
|
}
|
2000-12-25 05:28:40 +00:00
|
|
|
break;
|
|
|
|
default:
|
2001-04-17 21:25:13 +00:00
|
|
|
proto_tree_add_text(subtree, tvb, p - 2, 2 + plen,
|
2000-12-25 05:28:40 +00:00
|
|
|
"Unknown optional parameter");
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
1999-10-15 17:00:47 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
1999-11-11 21:08:52 +00:00
|
|
|
/*
|
|
|
|
* Dissect a BGP UPDATE message.
|
|
|
|
*/
|
1999-10-15 17:00:47 +00:00
|
|
|
static void
|
2003-04-05 11:20:54 +00:00
|
|
|
dissect_bgp_update(tvbuff_t *tvb, proto_tree *tree)
|
2003-01-28 05:25:18 +00:00
|
|
|
{
|
2000-03-29 06:27:54 +00:00
|
|
|
struct bgp_attr bgpa; /* path attributes */
|
2002-10-15 02:29:54 +00:00
|
|
|
guint16 hlen; /* message length */
|
2001-04-17 21:25:13 +00:00
|
|
|
gint o; /* packet offset */
|
|
|
|
gint q; /* tmp */
|
|
|
|
gint end; /* message end */
|
2009-01-10 11:06:50 +00:00
|
|
|
guint16 ext_com; /* EXTENDED COMMUNITY extended length type */
|
|
|
|
guint8 ext_com8; /* EXTENDED COMMUNITY regular type */
|
|
|
|
gboolean is_regular_type; /* flag for regular types */
|
|
|
|
gboolean is_extended_type; /* flag for extended types */
|
2002-10-15 02:29:54 +00:00
|
|
|
guint16 len; /* tmp */
|
2001-06-10 02:08:11 +00:00
|
|
|
int advance; /* tmp */
|
2000-03-29 06:27:54 +00:00
|
|
|
proto_item *ti; /* tree item */
|
2001-06-10 02:08:11 +00:00
|
|
|
proto_tree *subtree; /* subtree for attributes */
|
|
|
|
proto_tree *subtree2; /* subtree for attributes */
|
|
|
|
proto_tree *subtree3; /* subtree for attributes */
|
2002-08-27 19:12:35 +00:00
|
|
|
proto_tree *subtree4; /* subtree for attributes */
|
2009-01-10 11:06:50 +00:00
|
|
|
proto_tree *subtree5; /* subtree for attributes */
|
2000-03-29 06:27:54 +00:00
|
|
|
proto_tree *as_paths_tree; /* subtree for AS_PATHs */
|
|
|
|
proto_tree *as_path_tree; /* subtree for AS_PATH */
|
2003-04-24 09:00:27 +00:00
|
|
|
proto_tree *as_path_segment_tree; /* subtree for AS_PATH segments */
|
2000-03-29 06:27:54 +00:00
|
|
|
proto_tree *communities_tree; /* subtree for COMMUNITIES */
|
|
|
|
proto_tree *community_tree; /* subtree for a community */
|
|
|
|
proto_tree *cluster_list_tree; /* subtree for CLUSTER_LIST */
|
|
|
|
int i, j; /* tmp */
|
|
|
|
guint8 length; /* AS_PATH length */
|
|
|
|
guint8 type; /* AS_PATH type */
|
2003-04-24 09:00:27 +00:00
|
|
|
guint32 as_path_item; /* item in AS_PATH segment */
|
2009-03-28 00:27:03 +00:00
|
|
|
emem_strbuf_t *as_path_emstr = NULL; /* AS_PATH */
|
|
|
|
emem_strbuf_t *communities_emstr = NULL; /* COMMUNITIES */
|
|
|
|
emem_strbuf_t *cluster_list_emstr = NULL; /* CLUSTER_LIST */
|
|
|
|
emem_strbuf_t *junk_emstr; /* tmp */
|
2005-09-13 00:50:43 +00:00
|
|
|
guint32 ipaddr; /* IPv4 address */
|
2003-04-24 09:00:27 +00:00
|
|
|
guint32 aggregator_as;
|
2005-01-07 11:43:05 +00:00
|
|
|
guint16 ssa_type; /* SSA T + Type */
|
|
|
|
guint16 ssa_len; /* SSA TLV Length */
|
|
|
|
guint8 ssa_v3_len; /* SSA L2TPv3 Cookie Length */
|
2005-09-13 00:50:43 +00:00
|
|
|
gfloat linkband; /* Link bandwidth */
|
1999-11-22 07:05:21 +00:00
|
|
|
|
2003-04-05 11:20:54 +00:00
|
|
|
hlen = tvb_get_ntohs(tvb, BGP_MARKER_SIZE);
|
|
|
|
o = BGP_HEADER_SIZE;
|
2009-04-14 18:31:02 +00:00
|
|
|
junk_emstr = ep_strbuf_new_label(NULL);
|
1999-11-11 21:08:52 +00:00
|
|
|
|
|
|
|
/* check for withdrawals */
|
2001-04-17 21:25:13 +00:00
|
|
|
len = tvb_get_ntohs(tvb, o);
|
2001-06-10 02:08:11 +00:00
|
|
|
proto_tree_add_text(tree, tvb, o, 2,
|
2007-08-23 20:42:27 +00:00
|
|
|
"Unfeasible routes length: %u byte%s", len, plurality(len, "", "s"));
|
2001-04-17 21:25:13 +00:00
|
|
|
o += 2;
|
1999-11-22 07:05:21 +00:00
|
|
|
|
|
|
|
/* parse unfeasible prefixes */
|
1999-11-11 21:08:52 +00:00
|
|
|
if (len > 0) {
|
2001-04-17 21:25:13 +00:00
|
|
|
ti = proto_tree_add_text(tree, tvb, o, len, "Withdrawn routes:");
|
1999-11-16 11:44:20 +00:00
|
|
|
subtree = proto_item_add_subtree(ti, ett_bgp_unfeas);
|
1999-11-22 07:05:21 +00:00
|
|
|
|
2003-04-24 09:00:27 +00:00
|
|
|
/* parse each prefix */
|
2001-04-17 21:25:13 +00:00
|
|
|
end = o + len;
|
|
|
|
while (o < end) {
|
2003-04-24 09:00:27 +00:00
|
|
|
i = decode_prefix4(subtree, hf_bgp_withdrawn_prefix, tvb, o, len,
|
|
|
|
"Withdrawn route");
|
|
|
|
if (i < 0)
|
2002-10-10 01:36:53 +00:00
|
|
|
return;
|
2001-04-17 21:25:13 +00:00
|
|
|
o += i;
|
1999-11-22 07:05:21 +00:00
|
|
|
}
|
|
|
|
}
|
2002-10-15 02:29:54 +00:00
|
|
|
|
1999-11-11 21:08:52 +00:00
|
|
|
/* check for advertisements */
|
2001-04-17 21:25:13 +00:00
|
|
|
len = tvb_get_ntohs(tvb, o);
|
2007-08-23 20:42:27 +00:00
|
|
|
proto_tree_add_text(tree, tvb, o, 2, "Total path attribute length: %u byte%s",
|
|
|
|
len, plurality(len, "", "s"));
|
1999-11-11 21:08:52 +00:00
|
|
|
|
|
|
|
/* path attributes */
|
|
|
|
if (len > 0) {
|
2001-04-17 21:25:13 +00:00
|
|
|
ti = proto_tree_add_text(tree, tvb, o + 2, len, "Path attributes");
|
1999-11-16 11:44:20 +00:00
|
|
|
subtree = proto_item_add_subtree(ti, ett_bgp_attrs);
|
1999-10-15 17:00:47 +00:00
|
|
|
i = 2;
|
|
|
|
while (i < len) {
|
2008-06-27 04:52:56 +00:00
|
|
|
proto_item *hidden_item;
|
2005-06-26 19:56:52 +00:00
|
|
|
const char *msg;
|
2003-01-28 05:25:18 +00:00
|
|
|
int off;
|
|
|
|
gint k;
|
2009-03-28 00:35:02 +00:00
|
|
|
guint16 alen, tlen, aoff, aoff_save;
|
1999-10-16 15:35:27 +00:00
|
|
|
guint16 af;
|
2008-06-27 04:52:56 +00:00
|
|
|
guint8 saf, snpa;
|
2003-01-28 05:25:18 +00:00
|
|
|
guint8 nexthop_len;
|
|
|
|
guint8 asn_len = 0;
|
1999-10-15 17:00:47 +00:00
|
|
|
|
2001-04-17 21:25:13 +00:00
|
|
|
tvb_memcpy(tvb, (guint8 *)&bgpa, o + i, sizeof(bgpa));
|
1999-11-22 07:05:21 +00:00
|
|
|
/* check for the Extended Length bit */
|
1999-11-11 21:08:52 +00:00
|
|
|
if (bgpa.bgpa_flags & BGP_ATTR_FLAG_EXTENDED_LENGTH) {
|
2001-04-17 21:25:13 +00:00
|
|
|
alen = tvb_get_ntohs(tvb, o + i + sizeof(bgpa));
|
1999-10-15 17:00:47 +00:00
|
|
|
aoff = sizeof(bgpa) + 2;
|
|
|
|
} else {
|
2001-04-17 21:25:13 +00:00
|
|
|
alen = tvb_get_guint8(tvb, o + i + sizeof(bgpa));
|
1999-10-15 17:00:47 +00:00
|
|
|
aoff = sizeof(bgpa) + 1;
|
|
|
|
}
|
2002-08-24 10:22:29 +00:00
|
|
|
tlen = alen;
|
2001-04-17 21:25:13 +00:00
|
|
|
|
2001-06-10 02:08:11 +00:00
|
|
|
/* This is kind of ugly - similar code appears twice, but it
|
1999-11-22 07:05:21 +00:00
|
|
|
helps browsing attrs. */
|
|
|
|
/* the first switch prints things in the title of the subtree */
|
1999-10-31 00:20:44 +00:00
|
|
|
switch (bgpa.bgpa_type) {
|
|
|
|
case BGPTYPE_ORIGIN:
|
2002-08-24 10:22:29 +00:00
|
|
|
if (tlen != 1)
|
1999-10-31 00:20:44 +00:00
|
|
|
goto default_attribute_top;
|
2001-04-17 21:25:13 +00:00
|
|
|
msg = val_to_str(tvb_get_guint8(tvb, o + i + aoff), bgpattr_origin, "Unknown");
|
2002-08-24 10:22:29 +00:00
|
|
|
ti = proto_tree_add_text(subtree, tvb, o + i, tlen + aoff,
|
2007-08-23 20:42:27 +00:00
|
|
|
"%s: %s (%u byte%s)",
|
1999-10-31 00:20:44 +00:00
|
|
|
val_to_str(bgpa.bgpa_type, bgpattr_type, "Unknown"),
|
2007-08-23 20:42:27 +00:00
|
|
|
msg, tlen + aoff, plurality(tlen + aoff, "", "s"));
|
1999-10-31 00:20:44 +00:00
|
|
|
break;
|
|
|
|
case BGPTYPE_AS_PATH:
|
2003-01-28 05:25:18 +00:00
|
|
|
case BGPTYPE_NEW_AS_PATH:
|
2002-01-15 10:12:17 +00:00
|
|
|
/* (o + i + aoff) =
|
|
|
|
(o + current attribute + aoff bytes to first tuple) */
|
|
|
|
q = o + i + aoff;
|
2002-08-24 10:22:29 +00:00
|
|
|
end = q + tlen;
|
1999-11-22 07:05:21 +00:00
|
|
|
/* must be freed by second switch! */
|
2003-01-28 05:25:18 +00:00
|
|
|
/* "tlen * 11" (10 digits + space) should be a good estimate
|
1999-11-11 21:08:52 +00:00
|
|
|
of how long the AS path string could be */
|
2009-03-28 00:27:03 +00:00
|
|
|
if (as_path_emstr == NULL)
|
|
|
|
as_path_emstr = ep_strbuf_sized_new((tlen + 1) * 11, 0);
|
|
|
|
ep_strbuf_truncate(as_path_emstr, 0);
|
2001-06-10 02:08:11 +00:00
|
|
|
|
2003-01-28 05:25:18 +00:00
|
|
|
/* estimate the length of the AS number */
|
2009-03-28 00:35:02 +00:00
|
|
|
if (bgpa.bgpa_type == BGPTYPE_NEW_AS_PATH)
|
2003-01-28 05:25:18 +00:00
|
|
|
asn_len = 4;
|
|
|
|
else {
|
|
|
|
if (bgp_asn_len == 0) {
|
|
|
|
k = q;
|
|
|
|
while (k < end) {
|
|
|
|
k++;
|
|
|
|
length = tvb_get_guint8(tvb, k++);
|
|
|
|
k += length * 2;
|
|
|
|
}
|
|
|
|
asn_len = (k == end) ? 2 : 4;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
asn_len = bgp_asn_len;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
1999-11-11 21:08:52 +00:00
|
|
|
/* snarf each AS path */
|
|
|
|
while (q < end) {
|
2003-01-28 05:25:18 +00:00
|
|
|
type = tvb_get_guint8(tvb, q++);
|
2009-03-28 00:27:03 +00:00
|
|
|
if (as_path_emstr->len > 1 &&
|
|
|
|
as_path_emstr->str[as_path_emstr->len - 1] != ' ')
|
|
|
|
ep_strbuf_append_c(as_path_emstr, ' ');
|
1999-11-11 21:08:52 +00:00
|
|
|
if (type == AS_SET) {
|
2009-03-28 00:27:03 +00:00
|
|
|
ep_strbuf_append_c(as_path_emstr, '{');
|
1999-11-11 21:08:52 +00:00
|
|
|
}
|
2000-04-11 14:21:37 +00:00
|
|
|
else if (type == AS_CONFED_SET) {
|
2009-03-28 00:27:03 +00:00
|
|
|
ep_strbuf_append_c(as_path_emstr, '[');
|
1999-11-22 07:05:21 +00:00
|
|
|
}
|
2000-04-11 14:21:37 +00:00
|
|
|
else if (type == AS_CONFED_SEQUENCE) {
|
2009-03-28 00:27:03 +00:00
|
|
|
ep_strbuf_append_c(as_path_emstr, '(');
|
2003-01-28 05:25:18 +00:00
|
|
|
}
|
|
|
|
length = tvb_get_guint8(tvb, q++);
|
1999-11-22 07:05:21 +00:00
|
|
|
|
1999-11-11 21:08:52 +00:00
|
|
|
/* snarf each value in path */
|
|
|
|
for (j = 0; j < length; j++) {
|
2009-03-28 00:27:03 +00:00
|
|
|
ep_strbuf_append_printf(as_path_emstr, "%u%s",
|
2003-01-28 05:25:18 +00:00
|
|
|
(asn_len == 2) ?
|
|
|
|
tvb_get_ntohs(tvb, q) : tvb_get_ntohl(tvb, q),
|
|
|
|
(type == AS_SET || type == AS_CONFED_SET) ?
|
|
|
|
", " : " ");
|
|
|
|
q += asn_len;
|
1999-11-11 21:08:52 +00:00
|
|
|
}
|
2001-06-10 02:08:11 +00:00
|
|
|
|
1999-11-11 21:08:52 +00:00
|
|
|
/* cleanup end of string */
|
|
|
|
if (type == AS_SET) {
|
2009-03-28 00:27:03 +00:00
|
|
|
ep_strbuf_truncate(as_path_emstr, as_path_emstr->len - 2);
|
|
|
|
ep_strbuf_append_c(as_path_emstr, '}');
|
1999-11-11 21:08:52 +00:00
|
|
|
}
|
2000-04-11 14:21:37 +00:00
|
|
|
else if (type == AS_CONFED_SET) {
|
2009-03-28 00:27:03 +00:00
|
|
|
ep_strbuf_truncate(as_path_emstr, as_path_emstr->len - 2);
|
|
|
|
ep_strbuf_append_c(as_path_emstr, ']');
|
2000-04-11 14:21:37 +00:00
|
|
|
}
|
|
|
|
else if (type == AS_CONFED_SEQUENCE) {
|
2009-03-28 00:27:03 +00:00
|
|
|
ep_strbuf_truncate(as_path_emstr, as_path_emstr->len - 1);
|
|
|
|
ep_strbuf_append_c(as_path_emstr, ')');
|
2000-04-11 14:21:37 +00:00
|
|
|
}
|
1999-11-11 21:08:52 +00:00
|
|
|
else {
|
2009-03-28 00:27:03 +00:00
|
|
|
ep_strbuf_truncate(as_path_emstr, as_path_emstr->len - 1);
|
1999-11-11 21:08:52 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
1999-12-08 08:12:27 +00:00
|
|
|
/* check for empty AS_PATH */
|
2002-08-24 10:22:29 +00:00
|
|
|
if (tlen == 0)
|
2009-03-28 00:27:03 +00:00
|
|
|
ep_strbuf_printf(as_path_emstr, "empty");
|
1999-12-08 08:12:27 +00:00
|
|
|
|
2002-08-24 10:22:29 +00:00
|
|
|
ti = proto_tree_add_text(subtree, tvb, o + i, tlen + aoff,
|
2007-08-23 20:42:27 +00:00
|
|
|
"%s: %s (%u byte%s)",
|
1999-12-08 08:12:27 +00:00
|
|
|
val_to_str(bgpa.bgpa_type, bgpattr_type, "Unknown"),
|
2009-03-28 00:27:03 +00:00
|
|
|
as_path_emstr->str, tlen + aoff,
|
2007-08-23 20:42:27 +00:00
|
|
|
plurality(tlen + aoff, "", "s"));
|
1999-10-31 00:20:44 +00:00
|
|
|
break;
|
|
|
|
case BGPTYPE_NEXT_HOP:
|
2002-08-24 10:22:29 +00:00
|
|
|
if (tlen != 4)
|
1999-10-31 00:20:44 +00:00
|
|
|
goto default_attribute_top;
|
2005-09-13 00:50:43 +00:00
|
|
|
ipaddr = tvb_get_ipv4(tvb, o + i + aoff);
|
2002-08-24 10:22:29 +00:00
|
|
|
ti = proto_tree_add_text(subtree, tvb, o + i, tlen + aoff,
|
2007-08-23 20:42:27 +00:00
|
|
|
"%s: %s (%u byte%s)",
|
1999-10-31 00:20:44 +00:00
|
|
|
val_to_str(bgpa.bgpa_type, bgpattr_type, "Unknown"),
|
2007-08-23 20:42:27 +00:00
|
|
|
ip_to_str((guint8 *)&ipaddr), tlen + aoff,
|
|
|
|
plurality(tlen + aoff, "", "s"));
|
1999-10-31 00:20:44 +00:00
|
|
|
break;
|
|
|
|
case BGPTYPE_MULTI_EXIT_DISC:
|
2002-08-24 10:22:29 +00:00
|
|
|
if (tlen != 4)
|
1999-10-31 00:20:44 +00:00
|
|
|
goto default_attribute_top;
|
2002-08-24 10:22:29 +00:00
|
|
|
ti = proto_tree_add_text(subtree, tvb, o + i, tlen + aoff,
|
2007-08-23 20:42:27 +00:00
|
|
|
"%s: %u (%u byte%s)",
|
1999-10-31 00:20:44 +00:00
|
|
|
val_to_str(bgpa.bgpa_type, bgpattr_type, "Unknown"),
|
2002-08-24 10:22:29 +00:00
|
|
|
tvb_get_ntohl(tvb, o + i + aoff), tlen + aoff,
|
2007-08-23 20:42:27 +00:00
|
|
|
plurality(tlen + aoff, "", "s"));
|
1999-10-31 00:20:44 +00:00
|
|
|
break;
|
|
|
|
case BGPTYPE_LOCAL_PREF:
|
2002-08-24 10:22:29 +00:00
|
|
|
if (tlen != 4)
|
1999-10-31 00:20:44 +00:00
|
|
|
goto default_attribute_top;
|
2002-08-24 10:22:29 +00:00
|
|
|
ti = proto_tree_add_text(subtree, tvb, o + i, tlen + aoff,
|
2007-08-23 20:42:27 +00:00
|
|
|
"%s: %u (%u byte%s)",
|
1999-10-31 00:20:44 +00:00
|
|
|
val_to_str(bgpa.bgpa_type, bgpattr_type, "Unknown"),
|
2002-08-24 10:22:29 +00:00
|
|
|
tvb_get_ntohl(tvb, o + i + aoff), tlen + aoff,
|
2007-08-23 20:42:27 +00:00
|
|
|
plurality(tlen + aoff, "", "s"));
|
1999-10-31 00:20:44 +00:00
|
|
|
break;
|
1999-11-11 21:08:52 +00:00
|
|
|
case BGPTYPE_ATOMIC_AGGREGATE:
|
2002-08-24 10:22:29 +00:00
|
|
|
if (tlen != 0)
|
1999-10-31 00:20:44 +00:00
|
|
|
goto default_attribute_top;
|
2002-08-24 10:22:29 +00:00
|
|
|
ti = proto_tree_add_text(subtree, tvb, o + i, tlen + aoff,
|
2007-08-23 20:42:27 +00:00
|
|
|
"%s (%u byte%s)",
|
1999-10-31 00:20:44 +00:00
|
|
|
val_to_str(bgpa.bgpa_type, bgpattr_type, "Unknown"),
|
2007-08-23 20:42:27 +00:00
|
|
|
tlen + aoff, plurality(tlen + aoff, "", "s"));
|
1999-10-31 00:20:44 +00:00
|
|
|
break;
|
1999-11-22 07:05:21 +00:00
|
|
|
case BGPTYPE_AGGREGATOR:
|
2003-01-28 05:25:18 +00:00
|
|
|
if (tlen != 6 && tlen != 8)
|
|
|
|
goto default_attribute_top;
|
|
|
|
case BGPTYPE_NEW_AGGREGATOR:
|
|
|
|
if (bgpa.bgpa_type == BGPTYPE_NEW_AGGREGATOR && tlen != 8)
|
1999-11-22 07:05:21 +00:00
|
|
|
goto default_attribute_top;
|
2003-01-28 05:25:18 +00:00
|
|
|
asn_len = tlen - 4;
|
2005-09-13 00:50:43 +00:00
|
|
|
ipaddr = tvb_get_ipv4(tvb, o + i + aoff + asn_len);
|
2002-08-24 10:22:29 +00:00
|
|
|
ti = proto_tree_add_text(subtree, tvb, o + i, tlen + aoff,
|
2007-08-23 20:42:27 +00:00
|
|
|
"%s: AS: %u origin: %s (%u byte%s)",
|
1999-11-22 07:05:21 +00:00
|
|
|
val_to_str(bgpa.bgpa_type, bgpattr_type, "Unknown"),
|
2003-01-28 05:25:18 +00:00
|
|
|
(asn_len == 2) ? tvb_get_ntohs(tvb, o + i + aoff) :
|
|
|
|
tvb_get_ntohl(tvb, o + i + aoff),
|
2005-09-13 00:50:43 +00:00
|
|
|
ip_to_str((guint8 *)&ipaddr),
|
2007-08-23 20:42:27 +00:00
|
|
|
tlen + aoff, plurality(tlen + aoff, "", "s"));
|
1999-11-22 07:05:21 +00:00
|
|
|
break;
|
|
|
|
case BGPTYPE_COMMUNITIES:
|
2002-08-24 10:22:29 +00:00
|
|
|
if (tlen % 4 != 0)
|
1999-11-22 07:05:21 +00:00
|
|
|
goto default_attribute_top;
|
|
|
|
|
2002-01-15 10:12:17 +00:00
|
|
|
/* (o + i + aoff) =
|
|
|
|
(o + current attribute + aoff bytes to first tuple) */
|
|
|
|
q = o + i + aoff;
|
2002-08-24 10:22:29 +00:00
|
|
|
end = q + tlen;
|
2000-03-29 06:27:54 +00:00
|
|
|
/* must be freed by second switch! */
|
2002-08-24 10:22:29 +00:00
|
|
|
/* "tlen * 12" (5 digits, a :, 5 digits + space ) should be
|
2001-06-10 02:08:11 +00:00
|
|
|
a good estimate of how long the communities string could
|
2000-03-29 06:27:54 +00:00
|
|
|
be */
|
2009-03-28 00:27:03 +00:00
|
|
|
if (communities_emstr == NULL)
|
|
|
|
communities_emstr = ep_strbuf_sized_new((tlen + 1) * 12, 0);
|
|
|
|
ep_strbuf_truncate(communities_emstr, 0);
|
2000-03-29 06:27:54 +00:00
|
|
|
|
|
|
|
/* snarf each community */
|
|
|
|
while (q < end) {
|
|
|
|
/* check for well-known communities */
|
2001-04-17 21:25:13 +00:00
|
|
|
if (tvb_get_ntohl(tvb, q) == BGP_COMM_NO_EXPORT)
|
2009-03-28 00:27:03 +00:00
|
|
|
ep_strbuf_append(communities_emstr, "NO_EXPORT ");
|
2001-04-17 21:25:13 +00:00
|
|
|
else if (tvb_get_ntohl(tvb, q) == BGP_COMM_NO_ADVERTISE)
|
2009-03-28 00:27:03 +00:00
|
|
|
ep_strbuf_append(communities_emstr, "NO_ADVERTISE ");
|
2001-04-17 21:25:13 +00:00
|
|
|
else if (tvb_get_ntohl(tvb, q) == BGP_COMM_NO_EXPORT_SUBCONFED)
|
2009-03-28 00:27:03 +00:00
|
|
|
ep_strbuf_append(communities_emstr, "NO_EXPORT_SUBCONFED ");
|
2000-03-29 06:27:54 +00:00
|
|
|
else {
|
2009-03-28 00:27:03 +00:00
|
|
|
ep_strbuf_append_printf(communities_emstr, "%u:%u ",
|
2001-06-10 02:08:11 +00:00
|
|
|
tvb_get_ntohs(tvb, q),
|
2001-04-17 21:25:13 +00:00
|
|
|
tvb_get_ntohs(tvb, q + 2));
|
2000-03-29 06:27:54 +00:00
|
|
|
}
|
2001-06-10 02:08:11 +00:00
|
|
|
q += 4;
|
2000-03-29 06:27:54 +00:00
|
|
|
}
|
|
|
|
/* cleanup end of string */
|
2009-03-28 00:27:03 +00:00
|
|
|
ep_strbuf_truncate(communities_emstr, communities_emstr->len - 1);
|
1999-11-22 07:05:21 +00:00
|
|
|
|
2002-08-24 10:22:29 +00:00
|
|
|
ti = proto_tree_add_text(subtree, tvb, o + i, tlen + aoff,
|
2007-08-23 20:42:27 +00:00
|
|
|
"%s: %s (%u byte%s)",
|
1999-11-22 07:05:21 +00:00
|
|
|
val_to_str(bgpa.bgpa_type, bgpattr_type, "Unknown"),
|
2009-03-28 00:27:03 +00:00
|
|
|
communities_emstr->str, tlen + aoff,
|
2007-08-23 20:42:27 +00:00
|
|
|
plurality(tlen + aoff, "", "s"));
|
2003-04-24 09:00:27 +00:00
|
|
|
break;
|
1999-11-22 07:05:21 +00:00
|
|
|
case BGPTYPE_ORIGINATOR_ID:
|
2002-08-24 10:22:29 +00:00
|
|
|
if (tlen != 4)
|
1999-11-22 07:05:21 +00:00
|
|
|
goto default_attribute_top;
|
2005-09-13 00:50:43 +00:00
|
|
|
ipaddr = tvb_get_ipv4(tvb, o + i + aoff);
|
2002-08-24 10:22:29 +00:00
|
|
|
ti = proto_tree_add_text(subtree, tvb, o + i, tlen + aoff,
|
2007-08-23 20:42:27 +00:00
|
|
|
"%s: %s (%u byte%s)",
|
1999-11-22 07:05:21 +00:00
|
|
|
val_to_str(bgpa.bgpa_type, bgpattr_type, "Unknown"),
|
2005-09-13 00:50:43 +00:00
|
|
|
ip_to_str((guint8 *)&ipaddr),
|
2007-08-23 20:42:27 +00:00
|
|
|
tlen + aoff, plurality(tlen + aoff, "", "s"));
|
1999-11-22 07:05:21 +00:00
|
|
|
break;
|
|
|
|
case BGPTYPE_CLUSTER_LIST:
|
2002-08-24 10:22:29 +00:00
|
|
|
if (tlen % 4 != 0)
|
2000-03-29 06:27:54 +00:00
|
|
|
goto default_attribute_top;
|
|
|
|
|
2002-01-15 10:12:17 +00:00
|
|
|
/* (o + i + aoff) =
|
|
|
|
(o + current attribute + aoff bytes to first tuple) */
|
|
|
|
q = o + i + aoff;
|
2002-08-24 10:22:29 +00:00
|
|
|
end = q + tlen;
|
2000-03-29 06:27:54 +00:00
|
|
|
/* must be freed by second switch! */
|
2002-08-24 10:22:29 +00:00
|
|
|
/* "tlen * 16" (12 digits, 3 dots + space ) should be
|
2001-06-10 02:08:11 +00:00
|
|
|
a good estimate of how long the cluster_list string could
|
2000-03-29 06:27:54 +00:00
|
|
|
be */
|
2009-03-28 00:27:03 +00:00
|
|
|
if (cluster_list_emstr == NULL)
|
|
|
|
cluster_list_emstr = ep_strbuf_sized_new((tlen + 1) * 16, 0);
|
|
|
|
ep_strbuf_truncate(cluster_list_emstr, 0);
|
2000-03-29 06:27:54 +00:00
|
|
|
|
|
|
|
/* snarf each cluster list */
|
|
|
|
while (q < end) {
|
2005-09-13 00:50:43 +00:00
|
|
|
ipaddr = tvb_get_ipv4(tvb, q);
|
2009-03-28 00:27:03 +00:00
|
|
|
ep_strbuf_append_printf(cluster_list_emstr, "%s ", ip_to_str((guint8 *)&ipaddr));
|
2001-06-10 02:08:11 +00:00
|
|
|
q += 4;
|
2000-03-29 06:27:54 +00:00
|
|
|
}
|
|
|
|
/* cleanup end of string */
|
2009-03-28 00:27:03 +00:00
|
|
|
ep_strbuf_truncate(cluster_list_emstr, cluster_list_emstr->len - 1);
|
2000-03-29 06:27:54 +00:00
|
|
|
|
2002-08-24 10:22:29 +00:00
|
|
|
ti = proto_tree_add_text(subtree, tvb, o + i, tlen + aoff,
|
2007-08-23 20:42:27 +00:00
|
|
|
"%s: %s (%u byte%s)",
|
2000-03-29 06:27:54 +00:00
|
|
|
val_to_str(bgpa.bgpa_type, bgpattr_type, "Unknown"),
|
2009-03-28 00:27:03 +00:00
|
|
|
cluster_list_emstr->str, tlen + aoff,
|
2007-08-23 20:42:27 +00:00
|
|
|
plurality(tlen + aoff, "", "s"));
|
2000-03-29 06:27:54 +00:00
|
|
|
break;
|
2001-06-10 02:08:11 +00:00
|
|
|
case BGPTYPE_EXTENDED_COMMUNITY:
|
2002-08-24 10:22:29 +00:00
|
|
|
if (tlen %8 != 0)
|
|
|
|
break;
|
|
|
|
ti = proto_tree_add_text(subtree,tvb,o+i,tlen+aoff,
|
2007-08-23 20:42:27 +00:00
|
|
|
"%s: (%u byte%s)",
|
2001-06-10 02:08:11 +00:00
|
|
|
val_to_str(bgpa.bgpa_type,bgpattr_type,"Unknown"),
|
2002-08-27 19:12:35 +00:00
|
|
|
tlen + aoff,
|
2007-08-23 20:42:27 +00:00
|
|
|
plurality(tlen + aoff, "", "s"));
|
2001-06-10 02:08:11 +00:00
|
|
|
break;
|
2005-01-07 11:43:05 +00:00
|
|
|
case BGPTYPE_SAFI_SPECIFIC_ATTR:
|
|
|
|
ti = proto_tree_add_text(subtree,tvb,o+i,tlen+aoff,
|
2007-08-23 20:42:27 +00:00
|
|
|
"%s: (%u byte%s)",
|
2005-01-07 11:43:05 +00:00
|
|
|
val_to_str(bgpa.bgpa_type,bgpattr_type,"Unknown"),
|
|
|
|
tlen + aoff,
|
2007-08-23 20:42:27 +00:00
|
|
|
plurality(tlen + aoff, "", "s"));
|
2005-01-07 11:43:05 +00:00
|
|
|
break;
|
2001-06-10 02:08:11 +00:00
|
|
|
|
1999-10-31 00:20:44 +00:00
|
|
|
default:
|
|
|
|
default_attribute_top:
|
2002-08-24 10:22:29 +00:00
|
|
|
ti = proto_tree_add_text(subtree, tvb, o + i, tlen + aoff,
|
2007-08-23 20:42:27 +00:00
|
|
|
"%s (%u byte%s)",
|
1999-10-31 00:20:44 +00:00
|
|
|
val_to_str(bgpa.bgpa_type, bgpattr_type, "Unknown"),
|
2007-08-23 20:42:27 +00:00
|
|
|
tlen + aoff, plurality(tlen + aoff, "", "s"));
|
2000-03-29 06:27:54 +00:00
|
|
|
} /* end of first switch */
|
1999-11-16 11:44:20 +00:00
|
|
|
subtree2 = proto_item_add_subtree(ti, ett_bgp_attr);
|
1999-10-15 17:00:47 +00:00
|
|
|
|
1999-11-11 21:08:52 +00:00
|
|
|
/* figure out flags */
|
2009-03-28 00:27:03 +00:00
|
|
|
ep_strbuf_truncate(junk_emstr, 0);
|
1999-11-22 07:05:21 +00:00
|
|
|
if (bgpa.bgpa_flags & BGP_ATTR_FLAG_OPTIONAL) {
|
2009-03-28 00:27:03 +00:00
|
|
|
ep_strbuf_append(junk_emstr, "Optional, ");
|
1999-11-22 07:05:21 +00:00
|
|
|
}
|
|
|
|
else {
|
2009-03-28 00:27:03 +00:00
|
|
|
ep_strbuf_append(junk_emstr, "Well-known, ");
|
1999-11-22 07:05:21 +00:00
|
|
|
}
|
|
|
|
if (bgpa.bgpa_flags & BGP_ATTR_FLAG_TRANSITIVE) {
|
2009-03-28 00:27:03 +00:00
|
|
|
ep_strbuf_append(junk_emstr, "Transitive, ");
|
1999-11-22 07:05:21 +00:00
|
|
|
}
|
|
|
|
else {
|
2009-03-28 00:27:03 +00:00
|
|
|
ep_strbuf_append(junk_emstr, "Non-transitive, ");
|
1999-11-22 07:05:21 +00:00
|
|
|
}
|
|
|
|
if (bgpa.bgpa_flags & BGP_ATTR_FLAG_PARTIAL) {
|
2009-03-28 00:27:03 +00:00
|
|
|
ep_strbuf_append(junk_emstr, "Partial");
|
1999-11-22 07:05:21 +00:00
|
|
|
}
|
|
|
|
else {
|
2009-03-28 00:27:03 +00:00
|
|
|
ep_strbuf_append(junk_emstr, "Complete");
|
1999-11-22 07:05:21 +00:00
|
|
|
}
|
|
|
|
if (bgpa.bgpa_flags & BGP_ATTR_FLAG_EXTENDED_LENGTH) {
|
2009-03-28 00:27:03 +00:00
|
|
|
ep_strbuf_append(junk_emstr, ", Extended Length");
|
1999-11-22 07:05:21 +00:00
|
|
|
}
|
2001-04-17 21:25:13 +00:00
|
|
|
ti = proto_tree_add_text(subtree2, tvb,
|
|
|
|
o + i + offsetof(struct bgp_attr, bgpa_flags), 1,
|
2009-03-28 00:27:03 +00:00
|
|
|
"Flags: 0x%02x (%s)", bgpa.bgpa_flags, junk_emstr->str);
|
1999-11-16 11:44:20 +00:00
|
|
|
subtree3 = proto_item_add_subtree(ti, ett_bgp_attr_flags);
|
1999-11-22 07:05:21 +00:00
|
|
|
|
|
|
|
/* add flag bitfield subtrees */
|
2001-04-17 21:25:13 +00:00
|
|
|
proto_tree_add_text(subtree3, tvb,
|
|
|
|
o + i + offsetof(struct bgp_attr, bgpa_flags), 1,
|
1999-10-15 17:00:47 +00:00
|
|
|
"%s", decode_boolean_bitfield(bgpa.bgpa_flags,
|
1999-11-11 21:08:52 +00:00
|
|
|
BGP_ATTR_FLAG_OPTIONAL, 8, "Optional", "Well-known"));
|
2001-04-17 21:25:13 +00:00
|
|
|
proto_tree_add_text(subtree3, tvb,
|
|
|
|
o + i + offsetof(struct bgp_attr, bgpa_flags), 1,
|
1999-10-15 17:00:47 +00:00
|
|
|
"%s", decode_boolean_bitfield(bgpa.bgpa_flags,
|
2001-06-10 02:08:11 +00:00
|
|
|
BGP_ATTR_FLAG_TRANSITIVE, 8, "Transitive",
|
1999-11-11 21:08:52 +00:00
|
|
|
"Non-transitive"));
|
2001-04-17 21:25:13 +00:00
|
|
|
proto_tree_add_text(subtree3, tvb,
|
|
|
|
o + i + offsetof(struct bgp_attr, bgpa_flags), 1,
|
1999-10-15 17:00:47 +00:00
|
|
|
"%s", decode_boolean_bitfield(bgpa.bgpa_flags,
|
1999-11-11 21:08:52 +00:00
|
|
|
BGP_ATTR_FLAG_PARTIAL, 8, "Partial", "Complete"));
|
2001-04-17 21:25:13 +00:00
|
|
|
proto_tree_add_text(subtree3, tvb,
|
|
|
|
o + i + offsetof(struct bgp_attr, bgpa_flags), 1,
|
1999-10-15 17:00:47 +00:00
|
|
|
"%s", decode_boolean_bitfield(bgpa.bgpa_flags,
|
2001-06-10 02:08:11 +00:00
|
|
|
BGP_ATTR_FLAG_EXTENDED_LENGTH, 8, "Extended length",
|
1999-11-11 21:08:52 +00:00
|
|
|
"Regular length"));
|
1999-10-15 17:00:47 +00:00
|
|
|
|
2001-04-17 21:25:13 +00:00
|
|
|
proto_tree_add_text(subtree2, tvb,
|
|
|
|
o + i + offsetof(struct bgp_attr, bgpa_type), 1,
|
1999-11-11 21:08:52 +00:00
|
|
|
"Type code: %s (%u)",
|
1999-10-15 17:00:47 +00:00
|
|
|
val_to_str(bgpa.bgpa_type, bgpattr_type, "Unknown"),
|
|
|
|
bgpa.bgpa_type);
|
2001-06-10 02:08:11 +00:00
|
|
|
|
|
|
|
proto_tree_add_text(subtree2, tvb, o + i + sizeof(bgpa),
|
2007-08-23 20:42:27 +00:00
|
|
|
aoff - sizeof(bgpa), "Length: %d byte%s", tlen,
|
|
|
|
plurality(tlen, "", "s"));
|
1999-10-16 00:21:07 +00:00
|
|
|
|
2001-06-10 02:08:11 +00:00
|
|
|
/* the second switch prints things in the actual subtree of each
|
|
|
|
attribute */
|
1999-10-15 17:00:47 +00:00
|
|
|
switch (bgpa.bgpa_type) {
|
|
|
|
case BGPTYPE_ORIGIN:
|
2002-08-24 10:22:29 +00:00
|
|
|
if (tlen != 1) {
|
|
|
|
proto_tree_add_text(subtree2, tvb, o + i + aoff, tlen,
|
2007-08-23 20:42:27 +00:00
|
|
|
"Origin (invalid): %u byte%s", tlen,
|
|
|
|
plurality(tlen, "", "s"));
|
1999-10-15 17:00:47 +00:00
|
|
|
} else {
|
2003-04-24 09:00:27 +00:00
|
|
|
proto_tree_add_item(subtree2, hf_bgp_origin, tvb,
|
|
|
|
o + i + aoff, 1, FALSE);
|
1999-10-15 17:00:47 +00:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
case BGPTYPE_AS_PATH:
|
2003-01-28 05:25:18 +00:00
|
|
|
case BGPTYPE_NEW_AS_PATH:
|
2002-08-24 10:22:29 +00:00
|
|
|
ti = proto_tree_add_text(subtree2, tvb, o + i + aoff, tlen,
|
2009-03-28 00:27:03 +00:00
|
|
|
"AS path: %s", as_path_emstr->str);
|
1999-11-23 20:56:49 +00:00
|
|
|
as_paths_tree = proto_item_add_subtree(ti, ett_bgp_as_paths);
|
1999-11-22 07:05:21 +00:00
|
|
|
|
2002-01-15 10:12:17 +00:00
|
|
|
/* (o + i + aoff) =
|
|
|
|
(o + current attribute + aoff bytes to first tuple) */
|
|
|
|
q = o + i + aoff;
|
2002-08-24 10:22:29 +00:00
|
|
|
end = q + tlen;
|
2001-06-10 02:08:11 +00:00
|
|
|
|
2000-04-11 14:21:37 +00:00
|
|
|
/* snarf each AS path tuple, we have to step through each one
|
|
|
|
again to make a separate subtree so we can't just reuse
|
2003-05-20 03:01:21 +00:00
|
|
|
as_path_gstr from above */
|
2009-03-28 00:35:02 +00:00
|
|
|
/* XXX - Can we use some g_string*() trickery instead, e.g.
|
2003-05-20 03:01:21 +00:00
|
|
|
g_string_erase()? */
|
1999-11-22 07:05:21 +00:00
|
|
|
while (q < end) {
|
2009-03-28 00:27:03 +00:00
|
|
|
ep_strbuf_truncate(as_path_emstr, 0);
|
2001-04-17 21:25:13 +00:00
|
|
|
type = tvb_get_guint8(tvb, q++);
|
1999-11-22 07:05:21 +00:00
|
|
|
if (type == AS_SET) {
|
2009-03-28 00:27:03 +00:00
|
|
|
ep_strbuf_append_c(as_path_emstr, '{');
|
1999-11-22 07:05:21 +00:00
|
|
|
}
|
2000-04-11 14:21:37 +00:00
|
|
|
else if (type == AS_CONFED_SET) {
|
2009-03-28 00:27:03 +00:00
|
|
|
ep_strbuf_append_c(as_path_emstr, '[');
|
1999-11-22 07:05:21 +00:00
|
|
|
}
|
2000-04-11 14:21:37 +00:00
|
|
|
else if (type == AS_CONFED_SEQUENCE) {
|
2009-03-28 00:27:03 +00:00
|
|
|
ep_strbuf_append_c(as_path_emstr, '(');
|
2000-04-11 14:21:37 +00:00
|
|
|
}
|
2001-04-17 21:25:13 +00:00
|
|
|
length = tvb_get_guint8(tvb, q++);
|
1999-11-22 07:05:21 +00:00
|
|
|
|
2003-05-20 03:01:21 +00:00
|
|
|
/* snarf each value in path */
|
1999-11-22 07:05:21 +00:00
|
|
|
for (j = 0; j < length; j++) {
|
2009-03-28 00:27:03 +00:00
|
|
|
ep_strbuf_append_printf(as_path_emstr, "%u%s",
|
2009-03-28 00:35:02 +00:00
|
|
|
(asn_len == 2) ?
|
2003-01-28 05:25:18 +00:00
|
|
|
tvb_get_ntohs(tvb, q) : tvb_get_ntohl(tvb, q),
|
|
|
|
(type == AS_SET || type == AS_CONFED_SET) ? ", " : " ");
|
|
|
|
q += asn_len;
|
1999-11-22 07:05:21 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* cleanup end of string */
|
|
|
|
if (type == AS_SET) {
|
2009-03-28 00:27:03 +00:00
|
|
|
ep_strbuf_truncate(as_path_emstr, as_path_emstr->len - 2);
|
|
|
|
ep_strbuf_append_c(as_path_emstr, '}');
|
1999-11-22 07:05:21 +00:00
|
|
|
}
|
2000-04-11 14:21:37 +00:00
|
|
|
else if (type == AS_CONFED_SET) {
|
2009-03-28 00:27:03 +00:00
|
|
|
ep_strbuf_truncate(as_path_emstr, as_path_emstr->len - 2);
|
|
|
|
ep_strbuf_append_c(as_path_emstr, ']');
|
2000-04-11 14:21:37 +00:00
|
|
|
}
|
|
|
|
else if (type == AS_CONFED_SEQUENCE) {
|
2009-03-28 00:27:03 +00:00
|
|
|
ep_strbuf_truncate(as_path_emstr, as_path_emstr->len - 1);
|
|
|
|
ep_strbuf_append_c(as_path_emstr, ')');
|
2000-04-11 14:21:37 +00:00
|
|
|
}
|
1999-11-22 07:05:21 +00:00
|
|
|
else {
|
2009-03-28 00:27:03 +00:00
|
|
|
ep_strbuf_truncate(as_path_emstr, as_path_emstr->len - 1);
|
1999-11-22 07:05:21 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* length here means number of ASs, ie length * 2 bytes */
|
2001-06-10 02:08:11 +00:00
|
|
|
ti = proto_tree_add_text(as_paths_tree, tvb,
|
2003-01-28 05:25:18 +00:00
|
|
|
q - length * asn_len - 2,
|
2009-03-28 00:27:03 +00:00
|
|
|
length * asn_len + 2, "AS path segment: %s", as_path_emstr->str);
|
1999-11-23 20:56:49 +00:00
|
|
|
as_path_tree = proto_item_add_subtree(ti, ett_bgp_as_paths);
|
2003-01-28 05:25:18 +00:00
|
|
|
proto_tree_add_text(as_path_tree, tvb, q - length * asn_len - 2,
|
1999-11-22 07:05:21 +00:00
|
|
|
1, "Path segment type: %s (%u)",
|
|
|
|
val_to_str(type, as_segment_type, "Unknown"), type);
|
2003-01-28 05:25:18 +00:00
|
|
|
proto_tree_add_text(as_path_tree, tvb, q - length * asn_len - 1,
|
2007-08-23 20:42:27 +00:00
|
|
|
1, "Path segment length: %u AS%s", length,
|
|
|
|
plurality(length, "", "s"));
|
2000-04-11 14:21:37 +00:00
|
|
|
|
|
|
|
/* backup and reprint path segment value(s) only */
|
2003-01-28 05:25:18 +00:00
|
|
|
q -= asn_len * length;
|
2003-04-24 09:00:27 +00:00
|
|
|
ti = proto_tree_add_text(as_path_tree, tvb, q,
|
|
|
|
length * asn_len, "Path segment value:");
|
|
|
|
as_path_segment_tree = proto_item_add_subtree(ti,
|
|
|
|
ett_bgp_as_path_segments);
|
2000-04-11 14:21:37 +00:00
|
|
|
for (j = 0; j < length; j++) {
|
2009-03-28 00:35:02 +00:00
|
|
|
as_path_item = (asn_len == 2) ?
|
2003-04-24 09:00:27 +00:00
|
|
|
tvb_get_ntohs(tvb, q) : tvb_get_ntohl(tvb, q);
|
|
|
|
proto_item_append_text(ti, " %u", as_path_item);
|
2008-05-09 13:59:10 +00:00
|
|
|
hidden_item = proto_tree_add_uint(as_path_tree, hf_bgp_as_path, tvb,
|
2003-04-24 09:00:27 +00:00
|
|
|
q, asn_len, as_path_item);
|
2008-05-09 13:59:10 +00:00
|
|
|
PROTO_ITEM_SET_HIDDEN(hidden_item);
|
2003-01-28 05:25:18 +00:00
|
|
|
q += asn_len;
|
2000-04-11 14:21:37 +00:00
|
|
|
}
|
1999-11-22 07:05:21 +00:00
|
|
|
}
|
|
|
|
|
1999-10-31 00:20:44 +00:00
|
|
|
break;
|
1999-10-15 17:00:47 +00:00
|
|
|
case BGPTYPE_NEXT_HOP:
|
2002-08-24 10:22:29 +00:00
|
|
|
if (tlen != 4) {
|
|
|
|
proto_tree_add_text(subtree2, tvb, o + i + aoff, tlen,
|
2007-08-23 20:42:27 +00:00
|
|
|
"Next hop (invalid): %u byte%s", tlen,
|
|
|
|
plurality(tlen, "", "s"));
|
1999-10-15 17:00:47 +00:00
|
|
|
} else {
|
2003-04-24 09:00:27 +00:00
|
|
|
proto_tree_add_item(subtree2, hf_bgp_next_hop, tvb,
|
|
|
|
o + i + aoff, tlen, FALSE);
|
1999-10-15 17:00:47 +00:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
case BGPTYPE_MULTI_EXIT_DISC:
|
2002-08-24 10:22:29 +00:00
|
|
|
if (tlen != 4) {
|
|
|
|
proto_tree_add_text(subtree2, tvb, o + i + aoff, tlen,
|
2007-08-23 20:42:27 +00:00
|
|
|
"Multiple exit discriminator (invalid): %u byte%s",
|
|
|
|
tlen, plurality(tlen, "", "s"));
|
1999-10-15 17:00:47 +00:00
|
|
|
} else {
|
2003-04-24 09:00:27 +00:00
|
|
|
proto_tree_add_item(subtree2, hf_bgp_multi_exit_disc, tvb,
|
|
|
|
o + i + aoff, tlen, FALSE);
|
1999-10-15 17:00:47 +00:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
case BGPTYPE_LOCAL_PREF:
|
2002-08-24 10:22:29 +00:00
|
|
|
if (tlen != 4) {
|
|
|
|
proto_tree_add_text(subtree2, tvb, o + i + aoff, tlen,
|
2007-08-23 20:42:27 +00:00
|
|
|
"Local preference (invalid): %u byte%s", tlen,
|
|
|
|
plurality(tlen, "", "s"));
|
1999-10-15 17:00:47 +00:00
|
|
|
} else {
|
2003-05-15 05:35:42 +00:00
|
|
|
proto_tree_add_item(subtree2, hf_bgp_local_pref, tvb,
|
2003-04-24 09:00:27 +00:00
|
|
|
o + i + aoff, tlen, FALSE);
|
1999-10-15 17:00:47 +00:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
case BGPTYPE_ATOMIC_AGGREGATE:
|
2002-08-24 10:22:29 +00:00
|
|
|
if (tlen != 0) {
|
|
|
|
proto_tree_add_text(subtree2, tvb, o + i + aoff, tlen,
|
2007-08-23 20:42:27 +00:00
|
|
|
"Atomic aggregate (invalid): %u byte%s", tlen,
|
|
|
|
plurality(tlen, "", "s"));
|
1999-11-22 07:05:21 +00:00
|
|
|
}
|
1999-10-15 17:00:47 +00:00
|
|
|
break;
|
|
|
|
case BGPTYPE_AGGREGATOR:
|
2003-01-28 05:25:18 +00:00
|
|
|
if (tlen != 6 && tlen != 8) {
|
2002-08-24 10:22:29 +00:00
|
|
|
proto_tree_add_text(subtree2, tvb, o + i + aoff, tlen,
|
2007-08-23 20:42:27 +00:00
|
|
|
"Aggregator (invalid): %u byte%s", tlen,
|
|
|
|
plurality(tlen, "", "s"));
|
2003-01-28 05:25:18 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
case BGPTYPE_NEW_AGGREGATOR:
|
|
|
|
if (bgpa.bgpa_type == BGPTYPE_NEW_AGGREGATOR && tlen != 8)
|
|
|
|
proto_tree_add_text(subtree2, tvb, o + i + aoff, tlen,
|
2007-08-23 20:42:27 +00:00
|
|
|
"Aggregator (invalid): %u byte%s", tlen,
|
|
|
|
plurality(tlen, "", "s"));
|
2003-01-28 05:25:18 +00:00
|
|
|
else {
|
|
|
|
asn_len = tlen - 4;
|
2003-04-24 09:00:27 +00:00
|
|
|
aggregator_as = (asn_len == 2) ?
|
2003-01-28 05:25:18 +00:00
|
|
|
tvb_get_ntohs(tvb, o + i + aoff) :
|
2003-04-24 09:00:27 +00:00
|
|
|
tvb_get_ntohl(tvb, o + i + aoff);
|
|
|
|
proto_tree_add_uint(subtree2, hf_bgp_aggregator_as, tvb,
|
|
|
|
o + i + aoff, asn_len, aggregator_as);
|
|
|
|
proto_tree_add_item(subtree2, hf_bgp_aggregator_origin, tvb,
|
|
|
|
o + i + aoff + asn_len, 4, FALSE);
|
1999-10-15 17:00:47 +00:00
|
|
|
}
|
1999-10-16 15:35:27 +00:00
|
|
|
break;
|
1999-11-22 07:05:21 +00:00
|
|
|
case BGPTYPE_COMMUNITIES:
|
2002-08-24 10:22:29 +00:00
|
|
|
if (tlen % 4 != 0) {
|
|
|
|
proto_tree_add_text(subtree2, tvb, o + i + aoff, tlen,
|
2007-08-23 20:42:27 +00:00
|
|
|
"Communities (invalid): %u byte%s", tlen,
|
|
|
|
plurality(tlen, "", "s"));
|
2000-03-29 06:27:54 +00:00
|
|
|
break;
|
1999-11-22 07:05:21 +00:00
|
|
|
}
|
2000-01-25 09:24:42 +00:00
|
|
|
|
2002-08-24 10:22:29 +00:00
|
|
|
ti = proto_tree_add_text(subtree2, tvb, o + i + aoff, tlen,
|
2009-03-28 00:27:03 +00:00
|
|
|
"Communities: %s", communities_emstr->str);
|
2001-06-10 02:08:11 +00:00
|
|
|
communities_tree = proto_item_add_subtree(ti,
|
2000-03-29 06:27:54 +00:00
|
|
|
ett_bgp_communities);
|
|
|
|
|
2002-01-15 10:12:17 +00:00
|
|
|
/* (o + i + aoff) =
|
|
|
|
(o + current attribute + aoff bytes to first tuple) */
|
|
|
|
q = o + i + aoff;
|
2002-08-24 10:22:29 +00:00
|
|
|
end = q + tlen;
|
2000-03-29 06:27:54 +00:00
|
|
|
|
|
|
|
/* snarf each community */
|
|
|
|
while (q < end) {
|
|
|
|
/* check for reserved values */
|
2002-01-30 23:04:02 +00:00
|
|
|
guint32 community = tvb_get_ntohl(tvb, q);
|
|
|
|
if ((community & 0xFFFF0000) == FOURHEX0 ||
|
|
|
|
(community & 0xFFFF0000) == FOURHEXF) {
|
|
|
|
proto_tree_add_text(communities_tree, tvb,
|
|
|
|
q - 3 + aoff, 4,
|
|
|
|
"Community: %s (0x%08x)",
|
|
|
|
val_to_str(community, community_vals, "(reserved)"),
|
|
|
|
community);
|
2000-03-29 06:27:54 +00:00
|
|
|
}
|
|
|
|
else {
|
2001-04-17 21:25:13 +00:00
|
|
|
ti = proto_tree_add_text(communities_tree, tvb,
|
2001-06-10 02:08:11 +00:00
|
|
|
q - 3 + aoff, 4, "Community: %u:%u",
|
2001-04-17 21:25:13 +00:00
|
|
|
tvb_get_ntohs(tvb, q), tvb_get_ntohs(tvb, q + 2));
|
2001-06-10 02:08:11 +00:00
|
|
|
community_tree = proto_item_add_subtree(ti,
|
2000-03-29 06:27:54 +00:00
|
|
|
ett_bgp_communities);
|
2003-04-24 09:00:27 +00:00
|
|
|
proto_tree_add_item(community_tree, hf_bgp_community_as,
|
|
|
|
tvb, q - 3 + aoff, 2, FALSE);
|
|
|
|
proto_tree_add_item(community_tree, hf_bgp_community_value,
|
|
|
|
tvb, q - 1 + aoff, 2, FALSE);
|
2000-03-29 06:27:54 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
q += 4;
|
|
|
|
}
|
2000-01-25 09:24:42 +00:00
|
|
|
|
1999-11-22 07:05:21 +00:00
|
|
|
break;
|
|
|
|
case BGPTYPE_ORIGINATOR_ID:
|
2002-08-24 10:22:29 +00:00
|
|
|
if (tlen != 4) {
|
|
|
|
proto_tree_add_text(subtree2, tvb, o + i + aoff, tlen,
|
2007-08-23 20:42:27 +00:00
|
|
|
"Originator identifier (invalid): %u byte%s", tlen,
|
|
|
|
plurality(tlen, "", "s"));
|
1999-11-22 07:05:21 +00:00
|
|
|
} else {
|
2003-04-24 09:00:27 +00:00
|
|
|
proto_tree_add_item(subtree2, hf_bgp_originator_id, tvb,
|
|
|
|
o + i + aoff, tlen, FALSE);
|
1999-11-22 07:05:21 +00:00
|
|
|
}
|
|
|
|
break;
|
2001-06-10 02:08:11 +00:00
|
|
|
case BGPTYPE_MP_REACH_NLRI:
|
2001-07-03 02:38:27 +00:00
|
|
|
/*
|
|
|
|
* RFC 2545 specifies that there may be more than one
|
|
|
|
* address in the MP_REACH_NLRI attribute in section
|
|
|
|
* 3, "Constructing the Next Hop field".
|
2001-07-03 02:49:38 +00:00
|
|
|
*
|
|
|
|
* Yes, RFC 2858 says you can't do that, and, yes, RFC
|
|
|
|
* 2858 obsoletes RFC 2283, which says you can do that,
|
|
|
|
* but that doesn't mean we shouldn't dissect packets
|
|
|
|
* that conform to RFC 2283 but not RFC 2858, as some
|
|
|
|
* device on the network might implement the 2283-style
|
|
|
|
* BGP extensions rather than RFC 2858-style extensions.
|
2001-07-03 02:38:27 +00:00
|
|
|
*/
|
2001-04-17 21:25:13 +00:00
|
|
|
af = tvb_get_ntohs(tvb, o + i + aoff);
|
|
|
|
proto_tree_add_text(subtree2, tvb, o + i + aoff, 2,
|
1999-10-16 15:35:27 +00:00
|
|
|
"Address family: %s (%u)",
|
There is really no need to have the BGP dissector and the LDP dissector
have two independent "value_string" tables mapping RFC 1700 address
family numbers to names, nor is there any need to have the BGP dissector
and the PIM dissector have two independent sets of #defines for RFC 1700
address family numbers; put a single "value_string" table in "afn.c" and
put a declaration of it, and #defines for the address family numbers,
into "afn.h", and have the dissectors use that.
Move the #define for PGM into "ipproto.h", and add an entry for it in
the "value_string" table in "ipproto.c".
Have the PGM dissector use the standard Ethereal mechanisms for
resolving addresses, and have it use "value_string" tables for mapping
option types, the OPX bits, and packet types to strings. Use
"bytes_to_str()" to turn byte arrays into strings of hex digits. Pass
the packet type string to "dissect_pgmopts()" as an argument, rather
than making it a global. Don't use "proto_tree_add_XXX_format" routines
if you can possibly just use "proto_tree_add_XXX"; give various fields
the correct radix and type, and VALS() strings if necessary, to make
that happen (and to make filtering on them more pleasant). Put the
type, length, and total length of the options into the protocol tree as
separate fields. Don't have separate type, length, and OPX fields for
every type of option; one field will suffice. Don't format a string
with "sprintf()" and then pass that string to "col_add_fstr()" with a
format of "%s" and the string as an argument - "col_add_fstr()" can
format strings itself (that's what the "f" stands for). Don't byte-swap
and then un-byte-swap IPv4 address fields in the header, just leave them
network byte order to start with. Use the correct fields for
"proto_tree_add_XXX", rather than using the same field multiple times.
Quit early if an address family identifier isn't AFNUM_INET, as that
means the structure we use to dissect the header doesn't match the
actual header.
svn path=/trunk/; revision=3761
2001-07-21 10:27:13 +00:00
|
|
|
val_to_str(af, afn_vals, "Unknown"), af);
|
2001-06-10 02:08:11 +00:00
|
|
|
saf = tvb_get_guint8(tvb, o + i + aoff + 2) ;
|
2001-04-17 21:25:13 +00:00
|
|
|
proto_tree_add_text(subtree2, tvb, o + i + aoff + 2, 1,
|
1999-10-16 15:35:27 +00:00
|
|
|
"Subsequent address family identifier: %s (%u)",
|
2001-06-10 02:08:11 +00:00
|
|
|
val_to_str(saf, bgpattr_nlri_safi, saf >= 128 ? "Vendor specific" : "Unknown"),
|
|
|
|
saf);
|
2004-10-01 07:07:03 +00:00
|
|
|
nexthop_len = tvb_get_guint8(tvb, o + i + aoff + 3);
|
|
|
|
ti = proto_tree_add_text(subtree2, tvb, o + i + aoff + 3,
|
|
|
|
nexthop_len + 1,
|
2007-08-23 20:42:27 +00:00
|
|
|
"Next hop network address (%d byte%s)",
|
|
|
|
nexthop_len, plurality(nexthop_len, "", "s"));
|
2004-10-01 07:07:03 +00:00
|
|
|
subtree3 = proto_item_add_subtree(ti, ett_bgp_mp_nhna);
|
2005-10-11 05:23:27 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* The addresses don't contain lengths, so if we
|
|
|
|
* don't understand the address family type, we
|
|
|
|
* cannot parse the subsequent addresses as we
|
|
|
|
* don't know how long they are.
|
|
|
|
*/
|
|
|
|
switch (af) {
|
|
|
|
default:
|
2004-10-01 07:07:03 +00:00
|
|
|
proto_tree_add_text(subtree3, tvb, o + i + aoff + 4,
|
|
|
|
nexthop_len, "Unknown Address Family");
|
2005-10-11 05:23:27 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case AFNUM_INET:
|
|
|
|
case AFNUM_INET6:
|
|
|
|
case AFNUM_L2VPN:
|
|
|
|
case AFNUM_L2VPN_OLD:
|
|
|
|
|
2004-10-01 07:07:03 +00:00
|
|
|
j = 0;
|
|
|
|
while (j < nexthop_len) {
|
|
|
|
advance = mp_addr_to_str(af, saf, tvb, o + i + aoff + 4 + j,
|
2009-03-28 00:27:03 +00:00
|
|
|
junk_emstr) ;
|
2004-10-01 07:07:03 +00:00
|
|
|
if (advance == 0) /* catch if this is a unknown AFI type*/
|
2005-10-11 05:23:27 +00:00
|
|
|
break;
|
2004-10-01 07:07:03 +00:00
|
|
|
if (j + advance > nexthop_len)
|
|
|
|
break;
|
|
|
|
proto_tree_add_text(subtree3, tvb,o + i + aoff + 4 + j,
|
2009-03-28 00:35:02 +00:00
|
|
|
advance, "Next hop: %s (%u)", junk_emstr->str, advance);
|
2004-10-01 07:07:03 +00:00
|
|
|
j += advance;
|
|
|
|
}
|
2005-10-11 05:23:27 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2007-08-23 09:16:31 +00:00
|
|
|
aoff_save = aoff;
|
2002-08-24 10:22:29 +00:00
|
|
|
tlen -= nexthop_len + 4;
|
2001-06-15 08:01:31 +00:00
|
|
|
aoff += nexthop_len + 4 ;
|
2001-06-10 02:08:11 +00:00
|
|
|
|
|
|
|
off = 0;
|
2001-04-17 21:25:13 +00:00
|
|
|
snpa = tvb_get_guint8(tvb, o + i + aoff);
|
|
|
|
ti = proto_tree_add_text(subtree2, tvb, o + i + aoff, 1,
|
1999-10-16 15:35:27 +00:00
|
|
|
"Subnetwork points of attachment: %u", snpa);
|
|
|
|
off++;
|
2001-06-10 02:08:11 +00:00
|
|
|
if (snpa) {
|
|
|
|
subtree3 = proto_item_add_subtree(ti, ett_bgp_mp_snpa);
|
|
|
|
for (/*nothing*/; snpa > 0; snpa--) {
|
|
|
|
proto_tree_add_text(subtree3, tvb, o + i + aoff + off, 1,
|
|
|
|
"SNPA length: %u", tvb_get_guint8(tvb, o + i + aoff + off));
|
|
|
|
off++;
|
|
|
|
proto_tree_add_text(subtree3, tvb, o + i + aoff + off,
|
|
|
|
tvb_get_guint8(tvb, o + i + aoff + off - 1),
|
2007-08-23 20:42:27 +00:00
|
|
|
"SNPA (%u byte%s)", tvb_get_guint8(tvb, o + i + aoff + off - 1),
|
|
|
|
plurality(tvb_get_guint8(tvb, o + i + aoff + off - 1), "", "s"));
|
2001-06-10 02:08:11 +00:00
|
|
|
off += tvb_get_guint8(tvb, o + i + aoff + off - 1);
|
|
|
|
}
|
|
|
|
}
|
2002-08-24 10:22:29 +00:00
|
|
|
tlen -= off;
|
1999-10-16 15:35:27 +00:00
|
|
|
aoff += off;
|
2002-08-28 21:04:11 +00:00
|
|
|
|
2002-08-24 10:22:29 +00:00
|
|
|
ti = proto_tree_add_text(subtree2, tvb, o + i + aoff, tlen,
|
2007-08-23 20:42:27 +00:00
|
|
|
"Network layer reachability information (%u byte%s)",
|
|
|
|
tlen, plurality(tlen, "", "s"));
|
2002-08-24 10:22:29 +00:00
|
|
|
if (tlen) {
|
2004-10-01 07:07:03 +00:00
|
|
|
subtree3 = proto_item_add_subtree(ti,ett_bgp_mp_reach_nlri);
|
|
|
|
if (af != AFNUM_INET && af != AFNUM_INET6 && af != AFNUM_L2VPN) {
|
|
|
|
proto_tree_add_text(subtree3, tvb, o + i + aoff,
|
|
|
|
tlen, "Unknown Address Family");
|
|
|
|
} else {
|
2002-08-24 10:22:29 +00:00
|
|
|
while (tlen > 0) {
|
2003-04-24 09:00:27 +00:00
|
|
|
advance = decode_prefix_MP(subtree3,
|
|
|
|
hf_bgp_mp_reach_nlri_ipv4_prefix,
|
|
|
|
-1,
|
|
|
|
af, saf,
|
|
|
|
tvb, o + i + aoff, "MP Reach NLRI");
|
|
|
|
if (advance < 0)
|
|
|
|
break;
|
2002-08-24 10:22:29 +00:00
|
|
|
tlen -= advance;
|
2001-06-10 02:08:11 +00:00
|
|
|
aoff += advance;
|
|
|
|
}
|
2004-10-01 07:07:03 +00:00
|
|
|
}
|
2001-06-10 02:08:11 +00:00
|
|
|
}
|
2007-08-23 09:16:31 +00:00
|
|
|
aoff = aoff_save;
|
1999-10-16 15:35:27 +00:00
|
|
|
break;
|
2001-06-10 02:08:11 +00:00
|
|
|
case BGPTYPE_MP_UNREACH_NLRI:
|
|
|
|
af = tvb_get_ntohs(tvb, o + i + aoff);
|
2001-04-17 21:25:13 +00:00
|
|
|
proto_tree_add_text(subtree2, tvb, o + i + aoff, 2,
|
1999-10-16 15:35:27 +00:00
|
|
|
"Address family: %s (%u)",
|
There is really no need to have the BGP dissector and the LDP dissector
have two independent "value_string" tables mapping RFC 1700 address
family numbers to names, nor is there any need to have the BGP dissector
and the PIM dissector have two independent sets of #defines for RFC 1700
address family numbers; put a single "value_string" table in "afn.c" and
put a declaration of it, and #defines for the address family numbers,
into "afn.h", and have the dissectors use that.
Move the #define for PGM into "ipproto.h", and add an entry for it in
the "value_string" table in "ipproto.c".
Have the PGM dissector use the standard Ethereal mechanisms for
resolving addresses, and have it use "value_string" tables for mapping
option types, the OPX bits, and packet types to strings. Use
"bytes_to_str()" to turn byte arrays into strings of hex digits. Pass
the packet type string to "dissect_pgmopts()" as an argument, rather
than making it a global. Don't use "proto_tree_add_XXX_format" routines
if you can possibly just use "proto_tree_add_XXX"; give various fields
the correct radix and type, and VALS() strings if necessary, to make
that happen (and to make filtering on them more pleasant). Put the
type, length, and total length of the options into the protocol tree as
separate fields. Don't have separate type, length, and OPX fields for
every type of option; one field will suffice. Don't format a string
with "sprintf()" and then pass that string to "col_add_fstr()" with a
format of "%s" and the string as an argument - "col_add_fstr()" can
format strings itself (that's what the "f" stands for). Don't byte-swap
and then un-byte-swap IPv4 address fields in the header, just leave them
network byte order to start with. Use the correct fields for
"proto_tree_add_XXX", rather than using the same field multiple times.
Quit early if an address family identifier isn't AFNUM_INET, as that
means the structure we use to dissect the header doesn't match the
actual header.
svn path=/trunk/; revision=3761
2001-07-21 10:27:13 +00:00
|
|
|
val_to_str(af, afn_vals, "Unknown"), af);
|
2001-06-10 02:08:11 +00:00
|
|
|
saf = tvb_get_guint8(tvb, o + i + aoff + 2) ;
|
2001-04-17 21:25:13 +00:00
|
|
|
proto_tree_add_text(subtree2, tvb, o + i + aoff + 2, 1,
|
1999-10-16 15:35:27 +00:00
|
|
|
"Subsequent address family identifier: %s (%u)",
|
2001-06-10 02:08:11 +00:00
|
|
|
val_to_str(saf, bgpattr_nlri_safi, saf >= 128 ? "Vendor specific" : "Unknown"),
|
|
|
|
saf);
|
2001-04-17 21:25:13 +00:00
|
|
|
ti = proto_tree_add_text(subtree2, tvb, o + i + aoff + 3,
|
2007-08-23 20:42:27 +00:00
|
|
|
tlen - 3, "Withdrawn routes (%u byte%s)", tlen - 3,
|
|
|
|
plurality(tlen - 3, "", "s"));
|
1999-10-16 15:35:27 +00:00
|
|
|
|
2007-08-23 09:16:31 +00:00
|
|
|
aoff_save = aoff;
|
2002-08-24 10:22:29 +00:00
|
|
|
tlen -= 3;
|
1999-10-16 15:35:27 +00:00
|
|
|
aoff += 3;
|
2002-08-24 10:22:29 +00:00
|
|
|
if (tlen > 0) {
|
2003-04-24 09:00:27 +00:00
|
|
|
subtree3 = proto_item_add_subtree(ti,ett_bgp_mp_unreach_nlri);
|
|
|
|
|
|
|
|
while (tlen > 0) {
|
|
|
|
advance = decode_prefix_MP(subtree3,
|
|
|
|
hf_bgp_mp_unreach_nlri_ipv4_prefix,
|
|
|
|
-1,
|
|
|
|
af, saf,
|
|
|
|
tvb, o + i + aoff, "MP Unreach NLRI");
|
|
|
|
if (advance < 0)
|
|
|
|
break;
|
|
|
|
tlen -= advance;
|
|
|
|
aoff += advance;
|
|
|
|
}
|
2001-06-10 02:08:11 +00:00
|
|
|
}
|
2007-08-23 09:16:31 +00:00
|
|
|
aoff = aoff_save;
|
2001-06-10 02:08:11 +00:00
|
|
|
break;
|
1999-11-22 07:05:21 +00:00
|
|
|
case BGPTYPE_CLUSTER_LIST:
|
2002-08-24 10:22:29 +00:00
|
|
|
if (tlen % 4 != 0) {
|
|
|
|
proto_tree_add_text(subtree2, tvb, o + i + aoff, tlen,
|
2007-08-23 20:42:27 +00:00
|
|
|
"Cluster list (invalid): %u byte%s", tlen,
|
|
|
|
plurality(tlen, "", "s"));
|
2000-03-29 06:27:54 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2002-08-24 10:22:29 +00:00
|
|
|
ti = proto_tree_add_text(subtree2, tvb, o + i + aoff, tlen,
|
2009-03-28 00:27:03 +00:00
|
|
|
"Cluster list: %s", cluster_list_emstr->str);
|
2001-06-10 02:08:11 +00:00
|
|
|
cluster_list_tree = proto_item_add_subtree(ti,
|
2000-03-29 06:27:54 +00:00
|
|
|
ett_bgp_cluster_list);
|
|
|
|
|
2002-01-15 10:12:17 +00:00
|
|
|
/* (o + i + aoff) =
|
|
|
|
(o + current attribute + aoff bytes to first tuple) */
|
|
|
|
q = o + i + aoff;
|
2002-08-24 10:22:29 +00:00
|
|
|
end = q + tlen;
|
2000-03-29 06:27:54 +00:00
|
|
|
|
|
|
|
/* snarf each cluster identifier */
|
|
|
|
while (q < end) {
|
2003-04-24 09:00:27 +00:00
|
|
|
proto_tree_add_item(cluster_list_tree, hf_bgp_cluster_list,
|
|
|
|
tvb, q - 3 + aoff, 4, FALSE);
|
2000-03-29 06:27:54 +00:00
|
|
|
q += 4;
|
|
|
|
}
|
|
|
|
|
|
|
|
break;
|
2003-04-24 09:00:27 +00:00
|
|
|
case BGPTYPE_EXTENDED_COMMUNITY:
|
2002-08-24 10:22:29 +00:00
|
|
|
if (tlen %8 != 0) {
|
2007-08-23 20:42:27 +00:00
|
|
|
proto_tree_add_text(subtree3, tvb, o + i + aoff, tlen, "Extended community (invalid) : %u byte%s", tlen,
|
|
|
|
plurality(tlen, "", "s"));
|
2001-06-10 02:08:11 +00:00
|
|
|
} else {
|
|
|
|
q = o + i + aoff ;
|
2002-08-24 10:22:29 +00:00
|
|
|
end = o + i + aoff + tlen ;
|
|
|
|
ti = proto_tree_add_text(subtree2,tvb,q,tlen, "Carried Extended communities");
|
2007-08-23 20:42:27 +00:00
|
|
|
subtree3 = proto_item_add_subtree(ti,ett_bgp_extended_communities);
|
2001-06-10 02:08:11 +00:00
|
|
|
|
|
|
|
while (q < end) {
|
2009-01-10 11:06:50 +00:00
|
|
|
ext_com8 = tvb_get_guint8(tvb,q); /* handle regular types (8 bit) */
|
|
|
|
ext_com = tvb_get_ntohs(tvb,q); /* handle extended length types (16 bit) */
|
2009-03-28 00:27:03 +00:00
|
|
|
ep_strbuf_printf(junk_emstr, "%s", val_to_str(ext_com8,bgpext_com8_type,"Unknown"));
|
2009-01-10 11:06:50 +00:00
|
|
|
is_regular_type = FALSE;
|
|
|
|
is_extended_type = FALSE;
|
|
|
|
/* handle regular types (8 bit) */
|
|
|
|
switch (ext_com8) {
|
|
|
|
case BGP_EXT_COM_QOS_MARK_T:
|
|
|
|
case BGP_EXT_COM_QOS_MARK_NT:
|
|
|
|
is_regular_type = TRUE;
|
2009-03-28 00:27:03 +00:00
|
|
|
ti = proto_tree_add_text(subtree3,tvb,q,8, "%s",junk_emstr->str);
|
2009-01-10 11:06:50 +00:00
|
|
|
|
|
|
|
subtree4 = proto_item_add_subtree(ti,ett_bgp_extended_communities);
|
|
|
|
ti = proto_tree_add_text(subtree4, tvb, q, 1,
|
|
|
|
"Type: 0x%02x", tvb_get_guint8(tvb,q));
|
|
|
|
ti = proto_tree_add_text(subtree4, tvb, q+1, 1,
|
|
|
|
"Flags: 0x%02x", tvb_get_guint8(tvb,q+1));
|
|
|
|
subtree5 = proto_item_add_subtree(ti,ett_bgp_ext_com_flags);
|
|
|
|
/* add flag bitfield */
|
|
|
|
ti = proto_tree_add_text(subtree5, tvb, q+1, 1, "%s", decode_boolean_bitfield(tvb_get_guint8(tvb,q+1),
|
|
|
|
0x10, 8, "Remarking", "No Remarking"));
|
|
|
|
ti = proto_tree_add_text(subtree5, tvb, q+1, 1, "%s", decode_boolean_bitfield(tvb_get_guint8(tvb,q+1),
|
|
|
|
0x08, 8, "Ignored marking", "No Ignored marking"));
|
|
|
|
ti = proto_tree_add_text(subtree5, tvb, q+1, 1, "%s", decode_boolean_bitfield(tvb_get_guint8(tvb,q+1),
|
|
|
|
0x04, 8, "Aggregation of markings", "No Aggregation of markings"));
|
|
|
|
|
|
|
|
ti = proto_tree_add_text(subtree4, tvb, q+2, 1,
|
|
|
|
"QoS Set Number: 0x%02x", tvb_get_guint8(tvb,q+2));
|
|
|
|
ti = proto_tree_add_text(subtree4, tvb, q+3, 1,
|
|
|
|
"Technology Type: 0x%02x (%s)", tvb_get_guint8(tvb,q+3),
|
|
|
|
val_to_str(tvb_get_guint8(tvb,q+3),qos_tech_type,"Unknown"));
|
|
|
|
ti = proto_tree_add_text(subtree4, tvb, q+4, 2,
|
2009-01-14 22:01:10 +00:00
|
|
|
"QoS Marking O (16 bit): %s", decode_numeric_bitfield(tvb_get_ntohs(tvb,q+4),
|
2009-01-10 11:06:50 +00:00
|
|
|
0xffff, 16, "0x%04x"));
|
|
|
|
ti = proto_tree_add_text(subtree4, tvb, q+6, 1,
|
2009-01-14 22:01:10 +00:00
|
|
|
"QoS Marking A (8 bit): %s (decimal %d)", decode_numeric_bitfield(tvb_get_guint8(tvb,q+6),
|
2009-01-10 11:06:50 +00:00
|
|
|
0xff, 8, "0x%02x"), tvb_get_guint8(tvb,q+6));
|
|
|
|
ti = proto_tree_add_text(subtree4, tvb, q+7, 1,
|
2009-01-14 22:01:10 +00:00
|
|
|
"Defaults to zero: 0x%02x", tvb_get_guint8(tvb,q+7));
|
|
|
|
break;
|
2009-05-25 06:48:40 +00:00
|
|
|
case BGP_EXT_COM_COS_CAP_T:
|
2009-01-14 22:01:10 +00:00
|
|
|
is_regular_type = TRUE;
|
2009-03-28 00:27:03 +00:00
|
|
|
ti = proto_tree_add_text(subtree3,tvb,q,8, "%s",junk_emstr->str);
|
2009-01-14 22:01:10 +00:00
|
|
|
|
|
|
|
subtree4 = proto_item_add_subtree(ti,ett_bgp_extended_communities);
|
|
|
|
ti = proto_tree_add_text(subtree4, tvb, q, 1,
|
|
|
|
"Type: 0x%02x", tvb_get_guint8(tvb,q));
|
|
|
|
ti = proto_tree_add_text(subtree4, tvb, q+1, 1,
|
|
|
|
"Flags byte 1 : 0x%02x", tvb_get_guint8(tvb,q+1));
|
|
|
|
subtree5 = proto_item_add_subtree(ti,ett_bgp_ext_com_flags);
|
|
|
|
/* add flag bitfield */
|
|
|
|
ti = proto_tree_add_text(subtree5, tvb, q+1, 1, "%s", decode_boolean_bitfield(tvb_get_guint8(tvb,q+1),
|
|
|
|
0x80, 8, "BE class supported", "BE class NOT supported"));
|
|
|
|
ti = proto_tree_add_text(subtree5, tvb, q+1, 1, "%s", decode_boolean_bitfield(tvb_get_guint8(tvb,q+1),
|
|
|
|
0x40, 8, "EF class supported", "EF class NOT supported"));
|
|
|
|
ti = proto_tree_add_text(subtree5, tvb, q+1, 1, "%s", decode_boolean_bitfield(tvb_get_guint8(tvb,q+1),
|
|
|
|
0x20, 8, "AF class supported", "AF class NOT supported"));
|
|
|
|
ti = proto_tree_add_text(subtree5, tvb, q+1, 1, "%s", decode_boolean_bitfield(tvb_get_guint8(tvb,q+1),
|
|
|
|
0x10, 8, "LE class supported", "LE class NOT supported"));
|
|
|
|
ti = proto_tree_add_text(subtree4, tvb, q+2, 1,
|
2009-03-28 00:35:02 +00:00
|
|
|
"Flags byte 2..7 : 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x",
|
2009-01-14 22:01:10 +00:00
|
|
|
tvb_get_guint8(tvb,q+2),tvb_get_guint8(tvb,q+3),tvb_get_guint8(tvb,q+4),
|
|
|
|
tvb_get_guint8(tvb,q+5),tvb_get_guint8(tvb,q+6),tvb_get_guint8(tvb,q+7));
|
2009-01-10 11:06:50 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!is_regular_type) {
|
2009-03-28 00:27:03 +00:00
|
|
|
ep_strbuf_append(junk_emstr, val_to_str(ext_com,bgpext_com_type,"Unknown"));
|
2009-01-10 11:06:50 +00:00
|
|
|
|
|
|
|
/* handle extended length types (16 bit) */
|
|
|
|
switch (ext_com) {
|
|
|
|
case BGP_EXT_COM_RT_0:
|
|
|
|
case BGP_EXT_COM_RT_2:
|
|
|
|
case BGP_EXT_COM_RO_0:
|
|
|
|
case BGP_EXT_COM_RO_2:
|
|
|
|
is_extended_type = TRUE;
|
2009-03-28 00:27:03 +00:00
|
|
|
ep_strbuf_append_printf(junk_emstr, ": %u%s%d",
|
2009-01-10 11:06:50 +00:00
|
|
|
tvb_get_ntohs(tvb,q+2),":",tvb_get_ntohl(tvb,q+4));
|
2009-03-28 00:27:03 +00:00
|
|
|
proto_tree_add_text(subtree3,tvb,q,8, "%s",junk_emstr->str);
|
2009-01-10 11:06:50 +00:00
|
|
|
break ;
|
|
|
|
case BGP_EXT_COM_RT_1:
|
|
|
|
case BGP_EXT_COM_RO_1:
|
|
|
|
is_extended_type = TRUE;
|
|
|
|
ipaddr = tvb_get_ipv4(tvb,q+2);
|
2009-03-28 00:27:03 +00:00
|
|
|
ep_strbuf_append_printf(junk_emstr, ": %s%s%u",
|
2009-01-10 11:06:50 +00:00
|
|
|
ip_to_str((guint8 *)&ipaddr),":",tvb_get_ntohs(tvb,q+6));
|
2009-03-28 00:27:03 +00:00
|
|
|
proto_tree_add_text(subtree3,tvb,q,8, "%s",junk_emstr->str);
|
2009-01-10 11:06:50 +00:00
|
|
|
break;
|
|
|
|
case BGP_EXT_COM_VPN_ORIGIN:
|
|
|
|
case BGP_EXT_COM_OSPF_RID:
|
|
|
|
is_extended_type = TRUE;
|
|
|
|
ipaddr = tvb_get_ipv4(tvb,q+2);
|
2009-03-28 00:27:03 +00:00
|
|
|
ep_strbuf_append_printf(junk_emstr, ": %s", ip_to_str((guint8 *)&ipaddr));
|
|
|
|
proto_tree_add_text(subtree3,tvb,q,8, "%s",junk_emstr->str);
|
2009-01-10 11:06:50 +00:00
|
|
|
break;
|
|
|
|
case BGP_EXT_COM_OSPF_RTYPE:
|
|
|
|
is_extended_type = TRUE;
|
|
|
|
ipaddr = tvb_get_ipv4(tvb,q+2);
|
2009-03-28 00:27:03 +00:00
|
|
|
ep_strbuf_append_printf(junk_emstr, ": Area: %s, Type: %s", ip_to_str((guint8 *)&ipaddr),
|
2009-01-10 11:06:50 +00:00
|
|
|
val_to_str(tvb_get_guint8(tvb,q+6),bgpext_ospf_rtype,"Unknown"));
|
|
|
|
/* print OSPF Metric type if selected */
|
|
|
|
/* always print E2 even if not external route -- receiving router should ignore */
|
|
|
|
if ( (tvb_get_guint8(tvb,q+7)) & BGP_OSPF_RTYPE_METRIC_TYPE ) {
|
2009-03-28 00:27:03 +00:00
|
|
|
ep_strbuf_append(junk_emstr, " E2");
|
2009-01-10 11:06:50 +00:00
|
|
|
} else if ((tvb_get_guint8(tvb,q+6)==BGP_OSPF_RTYPE_EXT) || (tvb_get_guint8(tvb,q+6)==BGP_OSPF_RTYPE_NSSA)) {
|
2009-03-28 00:27:03 +00:00
|
|
|
ep_strbuf_append(junk_emstr, " E1");
|
2009-01-10 11:06:50 +00:00
|
|
|
} else {
|
2009-03-28 00:27:03 +00:00
|
|
|
ep_strbuf_append(junk_emstr, ", no options");
|
2009-01-10 11:06:50 +00:00
|
|
|
}
|
2009-03-28 00:27:03 +00:00
|
|
|
proto_tree_add_text(subtree3,tvb,q,8, "%s",junk_emstr->str);
|
2009-01-10 11:06:50 +00:00
|
|
|
break;
|
|
|
|
case BGP_EXT_COM_LINKBAND:
|
|
|
|
is_extended_type = TRUE;
|
|
|
|
linkband = tvb_get_ntohieee_float(tvb,q+2);
|
2009-03-28 00:27:03 +00:00
|
|
|
ep_strbuf_append_printf(junk_emstr, ": %.3f Mbps", linkband*8/1000000);
|
|
|
|
proto_tree_add_text(subtree3,tvb,q,8, "%s",junk_emstr->str);
|
2009-01-10 11:06:50 +00:00
|
|
|
break;
|
|
|
|
case BGP_EXT_COM_L2INFO:
|
|
|
|
is_extended_type = TRUE;
|
2009-03-28 00:35:02 +00:00
|
|
|
ep_strbuf_append_printf(junk_emstr,
|
2009-01-10 11:06:50 +00:00
|
|
|
": %s, Control Flags: %s%s%s%s%s, MTU: %u byte%s",
|
|
|
|
val_to_str(tvb_get_guint8(tvb,q+2),bgp_l2vpn_encaps,"Unknown"),
|
|
|
|
tvb_get_guint8(tvb,q+3) ? "" : "none",
|
|
|
|
tvb_get_ntohs(tvb,q+3)&0x08 ? "Q" : "",
|
|
|
|
tvb_get_ntohs(tvb,q+3)&0x04 ? "F" : "",
|
|
|
|
tvb_get_ntohs(tvb,q+3)&0x02 ? "C" : "",
|
|
|
|
tvb_get_ntohs(tvb,q+3)&0x01 ? "S" : "",
|
|
|
|
tvb_get_ntohs(tvb,q+4),
|
|
|
|
plurality(tvb_get_ntohs(tvb,q+4), "", "s"));
|
2009-03-28 00:27:03 +00:00
|
|
|
ti = proto_tree_add_text(subtree3,tvb,q,8, "%s",junk_emstr->str);
|
2009-01-10 11:06:50 +00:00
|
|
|
|
|
|
|
subtree4 = proto_item_add_subtree(ti,ett_bgp_extended_communities);
|
|
|
|
proto_tree_add_text(subtree4,tvb,q+2,1, "Encapsulation: %s",
|
|
|
|
val_to_str(tvb_get_guint8(tvb,q+2),bgp_l2vpn_encaps,"Unknown"));
|
|
|
|
proto_tree_add_text(subtree4,tvb,q+3,1, "Control Flags: %s%sControl Word %s required, Sequenced delivery %s required",
|
|
|
|
tvb_get_ntohs(tvb,q+3)&0x08 ? "Q flag (Reserved) set" : "",
|
|
|
|
tvb_get_ntohs(tvb,q+3)&0x04 ? "F flag (reserved) set" : "",
|
|
|
|
tvb_get_ntohs(tvb,q+3)&0x02 ? "is" : "not",
|
|
|
|
tvb_get_ntohs(tvb,q+3)&0x01 ? "is" : "not");
|
|
|
|
proto_tree_add_text(subtree4,tvb,q+4,2, "MTU: %u byte%s",
|
|
|
|
tvb_get_ntohs(tvb,q+4),
|
|
|
|
plurality(tvb_get_ntohs(tvb,q+4), "", "s"));
|
|
|
|
break;
|
|
|
|
}
|
2002-08-27 08:41:43 +00:00
|
|
|
}
|
2009-01-10 11:06:50 +00:00
|
|
|
if (!is_regular_type && !is_extended_type)
|
|
|
|
proto_tree_add_text(subtree3,tvb,q,8, "%s","Unknown");
|
|
|
|
q = q + 8;
|
2001-06-10 02:08:11 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
2005-01-07 11:43:05 +00:00
|
|
|
case BGPTYPE_SAFI_SPECIFIC_ATTR:
|
|
|
|
q = o + i + aoff;
|
|
|
|
end = o + i + aoff + tlen ;
|
|
|
|
|
|
|
|
while(q < end) {
|
|
|
|
ssa_type = tvb_get_ntohs(tvb, q) & BGP_SSA_TYPE;
|
|
|
|
ssa_len = tvb_get_ntohs(tvb, q + 2);
|
|
|
|
|
|
|
|
ti = proto_tree_add_text(subtree2, tvb, q, MIN(ssa_len + 4, end - q),
|
|
|
|
"%s Information",
|
|
|
|
val_to_str(ssa_type, bgp_ssa_type, "Unknown SSA"));
|
|
|
|
subtree3 = proto_item_add_subtree(ti, ett_bgp_ssa);
|
|
|
|
|
|
|
|
proto_tree_add_item(subtree3, hf_bgp_ssa_t, tvb,
|
|
|
|
q, 1, FALSE);
|
2008-05-09 13:59:10 +00:00
|
|
|
hidden_item = proto_tree_add_item(subtree3, hf_bgp_ssa_type, tvb,
|
2005-01-07 11:43:05 +00:00
|
|
|
q, 2, FALSE);
|
2008-06-27 04:52:56 +00:00
|
|
|
PROTO_ITEM_SET_HIDDEN(hidden_item);
|
2005-01-07 11:43:05 +00:00
|
|
|
proto_tree_add_text(subtree3, tvb, q, 2,
|
|
|
|
"Type: %s", val_to_str(ssa_type, bgp_ssa_type, "Unknown"));
|
|
|
|
if ((ssa_len == 0) || (q + ssa_len > end)) {
|
|
|
|
proto_tree_add_text(subtree3, tvb, q + 2, end - q - 2,
|
|
|
|
"Invalid Length of %u", ssa_len);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
proto_tree_add_item(subtree3, hf_bgp_ssa_len, tvb,
|
|
|
|
q + 2, 2, FALSE);
|
|
|
|
|
|
|
|
switch(ssa_type){
|
|
|
|
case BGP_SSA_L2TPv3:
|
|
|
|
proto_tree_add_item(subtree3, hf_bgp_ssa_l2tpv3_pref, tvb,
|
|
|
|
q + 4, 2, FALSE);
|
|
|
|
|
|
|
|
ti = proto_tree_add_text(subtree3, tvb, q + 6, 1, "Flags");
|
|
|
|
subtree4 = proto_item_add_subtree(ti, ett_bgp_ssa_subtree) ;
|
|
|
|
proto_tree_add_item(subtree4, hf_bgp_ssa_l2tpv3_s, tvb,
|
|
|
|
q + 6, 1, FALSE);
|
|
|
|
proto_tree_add_item(subtree4, hf_bgp_ssa_l2tpv3_unused, tvb,
|
|
|
|
q + 6, 1, FALSE);
|
|
|
|
|
|
|
|
ssa_v3_len = tvb_get_guint8(tvb, q + 7);
|
|
|
|
if (ssa_v3_len + 8 == ssa_len){
|
|
|
|
proto_tree_add_item(subtree3, hf_bgp_ssa_l2tpv3_cookie_len, tvb,
|
|
|
|
q + 7, 1, FALSE);
|
|
|
|
} else {
|
|
|
|
proto_tree_add_text(subtree3, tvb, q + 7, 1,
|
|
|
|
"Invalid Cookie Length of %u", ssa_v3_len);
|
2010-01-23 11:58:53 +00:00
|
|
|
q += ssa_len + 4; /* 4 from type and length */
|
2005-01-07 11:43:05 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
proto_tree_add_item(subtree3, hf_bgp_ssa_l2tpv3_session_id, tvb,
|
|
|
|
q + 8, 4, FALSE);
|
|
|
|
if (ssa_v3_len)
|
|
|
|
proto_tree_add_item(subtree3, hf_bgp_ssa_l2tpv3_cookie, tvb,
|
|
|
|
q + 12, ssa_v3_len, FALSE);
|
2010-01-23 11:58:53 +00:00
|
|
|
q += ssa_len + 4; /* 4 from type and length */
|
2005-01-07 11:43:05 +00:00
|
|
|
break;
|
|
|
|
case BGP_SSA_mGRE:
|
|
|
|
case BGP_SSA_IPSec:
|
|
|
|
case BGP_SSA_MPLS:
|
|
|
|
default:
|
|
|
|
proto_tree_add_item(subtree3, hf_bgp_ssa_value, tvb,
|
|
|
|
q + 4, ssa_len, FALSE);
|
2010-01-23 11:58:53 +00:00
|
|
|
q += ssa_len + 4; /* 4 from type and length */
|
|
|
|
break;
|
|
|
|
case BGP_SSA_L2TPv3_IN_IPSec:
|
|
|
|
case BGP_SSA_mGRE_IN_IPSec:
|
|
|
|
/* These contain BGP_SSA_IPSec and BGP_SSA_L2TPv3/BGP_SSA_mGRE */
|
|
|
|
q += 4; /* 4 from type and length */
|
2005-01-07 11:43:05 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
1999-10-16 00:21:07 +00:00
|
|
|
default:
|
2002-08-24 10:22:29 +00:00
|
|
|
proto_tree_add_text(subtree2, tvb, o + i + aoff, tlen,
|
2007-08-23 20:42:27 +00:00
|
|
|
"Unknown (%u byte%s)", tlen, plurality(tlen, "", "s"));
|
1999-10-16 00:21:07 +00:00
|
|
|
break;
|
2000-03-29 06:27:54 +00:00
|
|
|
} /* end of second switch */
|
1999-10-15 17:00:47 +00:00
|
|
|
|
|
|
|
i += alen + aoff;
|
|
|
|
}
|
2001-06-10 02:08:11 +00:00
|
|
|
|
2001-04-17 21:25:13 +00:00
|
|
|
o += 2 + len;
|
1999-11-11 21:08:52 +00:00
|
|
|
|
|
|
|
/* NLRI */
|
2003-04-05 11:20:54 +00:00
|
|
|
len = hlen - o;
|
1999-11-11 21:08:52 +00:00
|
|
|
|
1999-11-22 07:05:21 +00:00
|
|
|
/* parse prefixes */
|
1999-11-11 21:08:52 +00:00
|
|
|
if (len > 0) {
|
2003-04-24 09:00:27 +00:00
|
|
|
ti = proto_tree_add_text(tree, tvb, o, len,
|
2007-08-23 20:42:27 +00:00
|
|
|
"Network layer reachability information: %u byte%s", len,
|
|
|
|
plurality(len, "", "s"));
|
1999-11-16 11:44:20 +00:00
|
|
|
subtree = proto_item_add_subtree(ti, ett_bgp_nlri);
|
2001-04-17 21:25:13 +00:00
|
|
|
end = o + len;
|
|
|
|
while (o < end) {
|
2003-04-24 09:00:27 +00:00
|
|
|
i = decode_prefix4(subtree, hf_bgp_nlri_prefix, tvb, o, 0,
|
|
|
|
"NLRI");
|
|
|
|
if (i < 0)
|
2002-10-10 01:36:53 +00:00
|
|
|
return;
|
2001-04-17 21:25:13 +00:00
|
|
|
o += i;
|
1999-11-11 21:08:52 +00:00
|
|
|
}
|
|
|
|
}
|
1999-10-15 17:00:47 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
1999-11-02 00:11:58 +00:00
|
|
|
/*
|
|
|
|
* Dissect a BGP NOTIFICATION message.
|
|
|
|
*/
|
1999-10-15 17:00:47 +00:00
|
|
|
static void
|
2003-04-05 11:20:54 +00:00
|
|
|
dissect_bgp_notification(tvbuff_t *tvb, proto_tree *tree)
|
1999-10-15 17:00:47 +00:00
|
|
|
{
|
1999-11-06 01:28:50 +00:00
|
|
|
struct bgp_notification bgpn; /* BGP NOTIFICATION message */
|
1999-11-22 07:05:21 +00:00
|
|
|
int hlen; /* message length */
|
2005-06-26 19:56:52 +00:00
|
|
|
const char *p; /* string pointer */
|
1999-10-15 17:00:47 +00:00
|
|
|
|
1999-11-02 00:11:58 +00:00
|
|
|
/* snarf message */
|
2003-04-05 11:20:54 +00:00
|
|
|
tvb_memcpy(tvb, bgpn.bgpn_marker, 0, BGP_MIN_NOTIFICATION_MSG_SIZE);
|
2002-08-02 23:36:07 +00:00
|
|
|
hlen = g_ntohs(bgpn.bgpn_len);
|
1999-10-15 17:00:47 +00:00
|
|
|
|
1999-11-02 00:11:58 +00:00
|
|
|
/* print error code */
|
2001-04-17 21:25:13 +00:00
|
|
|
proto_tree_add_text(tree, tvb,
|
2003-04-05 11:20:54 +00:00
|
|
|
offsetof(struct bgp_notification, bgpn_major), 1,
|
1999-10-15 17:00:47 +00:00
|
|
|
"Error code: %s (%u)",
|
|
|
|
val_to_str(bgpn.bgpn_major, bgpnotify_major, "Unknown"),
|
|
|
|
bgpn.bgpn_major);
|
|
|
|
|
1999-11-02 00:11:58 +00:00
|
|
|
/* print error subcode */
|
1999-10-15 17:00:47 +00:00
|
|
|
if (bgpn.bgpn_major < array_length(bgpnotify_minor)
|
|
|
|
&& bgpnotify_minor[bgpn.bgpn_major] != NULL) {
|
|
|
|
p = val_to_str(bgpn.bgpn_minor, bgpnotify_minor[bgpn.bgpn_major],
|
|
|
|
"Unknown");
|
1999-11-02 00:11:58 +00:00
|
|
|
} else if (bgpn.bgpn_minor == 0)
|
|
|
|
p = "Unspecified";
|
|
|
|
else
|
|
|
|
p = "Unknown";
|
2001-04-17 21:25:13 +00:00
|
|
|
proto_tree_add_text(tree, tvb,
|
2003-04-05 11:20:54 +00:00
|
|
|
offsetof(struct bgp_notification, bgpn_minor), 1,
|
1999-10-15 17:00:47 +00:00
|
|
|
"Error subcode: %s (%u)", p, bgpn.bgpn_minor);
|
1999-11-02 00:11:58 +00:00
|
|
|
|
|
|
|
/* only print if there is optional data */
|
|
|
|
if (hlen > BGP_MIN_NOTIFICATION_MSG_SIZE) {
|
2003-04-05 11:20:54 +00:00
|
|
|
proto_tree_add_text(tree, tvb, BGP_MIN_NOTIFICATION_MSG_SIZE,
|
1999-11-02 00:11:58 +00:00
|
|
|
hlen - BGP_MIN_NOTIFICATION_MSG_SIZE, "Data");
|
|
|
|
}
|
1999-10-15 17:00:47 +00:00
|
|
|
}
|
|
|
|
|
2000-12-25 05:28:40 +00:00
|
|
|
/*
|
|
|
|
* Dissect a BGP ROUTE-REFRESH message.
|
|
|
|
*/
|
|
|
|
static void
|
2003-04-05 11:20:54 +00:00
|
|
|
dissect_bgp_route_refresh(tvbuff_t *tvb, proto_tree *tree)
|
2000-12-25 05:28:40 +00:00
|
|
|
{
|
2002-10-15 02:29:54 +00:00
|
|
|
guint16 i; /* tmp */
|
2002-08-15 18:52:04 +00:00
|
|
|
int p; /* tvb offset counter */
|
|
|
|
int pend; /* end of list of entries for one orf type */
|
2002-10-15 02:29:54 +00:00
|
|
|
guint16 hlen; /* tvb RR msg length */
|
2002-08-15 18:52:04 +00:00
|
|
|
proto_item *ti; /* tree item */
|
|
|
|
proto_item *ti1; /* tree item */
|
|
|
|
proto_tree *subtree; /* tree for orf */
|
|
|
|
proto_tree *subtree1; /* tree for orf entry */
|
|
|
|
guint8 orftype; /* ORF Type */
|
|
|
|
guint8 orfwhen; /* ORF flag: immediate, defer */
|
2002-10-15 02:29:54 +00:00
|
|
|
guint16 orflen; /* ORF len */
|
2002-08-15 18:52:04 +00:00
|
|
|
guint8 entryflag; /* ORF Entry flag: action(add,del,delall) match(permit,deny) */
|
2002-10-15 02:29:54 +00:00
|
|
|
guint32 entryseq; /* ORF Entry sequence number */
|
2002-08-15 18:52:04 +00:00
|
|
|
int entrylen; /* ORF Entry length */
|
|
|
|
guint8 pfx_ge; /* ORF PrefixList mask lower bound */
|
|
|
|
guint8 pfx_le; /* ORF PrefixList mask upper bound */
|
2003-04-24 09:00:27 +00:00
|
|
|
int advance; /* tmp */
|
2002-08-15 18:52:04 +00:00
|
|
|
|
2002-08-28 21:04:11 +00:00
|
|
|
|
|
|
|
/*
|
2002-08-15 18:52:04 +00:00
|
|
|
example 1
|
|
|
|
00 1c 05 hlen=28
|
|
|
|
00 01 00 01 afi,safi= ipv4-unicast
|
|
|
|
02 80 00 01 defer, prefix-orf, len=1
|
|
|
|
80 removeall
|
|
|
|
example 2
|
|
|
|
00 25 05 hlen=37
|
|
|
|
00 01 00 01 afi,saif= ipv4-unicast
|
|
|
|
01 80 00 0a immediate, prefix-orf, len=10
|
|
|
|
00 add
|
|
|
|
00 00 00 05 seqno = 5
|
|
|
|
12 ge = 18
|
|
|
|
18 le = 24
|
|
|
|
10 07 02 prefix = 7.2.0.0/16
|
|
|
|
*/
|
2003-04-05 11:20:54 +00:00
|
|
|
hlen = tvb_get_ntohs(tvb, BGP_MARKER_SIZE);
|
|
|
|
p = BGP_HEADER_SIZE;
|
2000-12-25 05:28:40 +00:00
|
|
|
/* AFI */
|
2002-08-15 18:52:04 +00:00
|
|
|
i = tvb_get_ntohs(tvb, p);
|
2002-08-28 21:04:11 +00:00
|
|
|
proto_tree_add_text(tree, tvb, p, 2,
|
2000-12-25 05:28:40 +00:00
|
|
|
"Address family identifier: %s (%u)",
|
There is really no need to have the BGP dissector and the LDP dissector
have two independent "value_string" tables mapping RFC 1700 address
family numbers to names, nor is there any need to have the BGP dissector
and the PIM dissector have two independent sets of #defines for RFC 1700
address family numbers; put a single "value_string" table in "afn.c" and
put a declaration of it, and #defines for the address family numbers,
into "afn.h", and have the dissectors use that.
Move the #define for PGM into "ipproto.h", and add an entry for it in
the "value_string" table in "ipproto.c".
Have the PGM dissector use the standard Ethereal mechanisms for
resolving addresses, and have it use "value_string" tables for mapping
option types, the OPX bits, and packet types to strings. Use
"bytes_to_str()" to turn byte arrays into strings of hex digits. Pass
the packet type string to "dissect_pgmopts()" as an argument, rather
than making it a global. Don't use "proto_tree_add_XXX_format" routines
if you can possibly just use "proto_tree_add_XXX"; give various fields
the correct radix and type, and VALS() strings if necessary, to make
that happen (and to make filtering on them more pleasant). Put the
type, length, and total length of the options into the protocol tree as
separate fields. Don't have separate type, length, and OPX fields for
every type of option; one field will suffice. Don't format a string
with "sprintf()" and then pass that string to "col_add_fstr()" with a
format of "%s" and the string as an argument - "col_add_fstr()" can
format strings itself (that's what the "f" stands for). Don't byte-swap
and then un-byte-swap IPv4 address fields in the header, just leave them
network byte order to start with. Use the correct fields for
"proto_tree_add_XXX", rather than using the same field multiple times.
Quit early if an address family identifier isn't AFNUM_INET, as that
means the structure we use to dissect the header doesn't match the
actual header.
svn path=/trunk/; revision=3761
2001-07-21 10:27:13 +00:00
|
|
|
val_to_str(i, afn_vals, "Unknown"), i);
|
2002-08-15 18:52:04 +00:00
|
|
|
p += 2;
|
2000-12-25 05:28:40 +00:00
|
|
|
/* Reserved */
|
2002-08-28 21:04:11 +00:00
|
|
|
proto_tree_add_text(tree, tvb, p, 1,
|
2000-12-25 05:28:40 +00:00
|
|
|
"Reserved: 1 byte");
|
2002-08-15 18:52:04 +00:00
|
|
|
p++;
|
2000-12-25 05:28:40 +00:00
|
|
|
/* SAFI */
|
2002-08-15 18:52:04 +00:00
|
|
|
i = tvb_get_guint8(tvb, p);
|
2002-08-28 21:04:11 +00:00
|
|
|
proto_tree_add_text(tree, tvb, p, 1,
|
2000-12-25 05:28:40 +00:00
|
|
|
"Subsequent address family identifier: %s (%u)",
|
|
|
|
val_to_str(i, bgpattr_nlri_safi,
|
2001-06-10 02:08:11 +00:00
|
|
|
i >= 128 ? "Vendor specific" : "Unknown"),
|
2000-12-25 05:28:40 +00:00
|
|
|
i);
|
2002-08-15 18:52:04 +00:00
|
|
|
p++;
|
|
|
|
if ( hlen == BGP_HEADER_SIZE + 4 )
|
|
|
|
return;
|
2003-04-05 11:20:54 +00:00
|
|
|
while (p < hlen) {
|
2002-08-15 18:52:04 +00:00
|
|
|
/* ORF type */
|
|
|
|
orfwhen = tvb_get_guint8(tvb, p);
|
|
|
|
orftype = tvb_get_guint8(tvb, p+1);
|
|
|
|
orflen = tvb_get_ntohs(tvb, p+2);
|
|
|
|
ti = proto_tree_add_text(tree, tvb, p , orflen + 4 , "ORF information (%u bytes)", orflen + 4);
|
|
|
|
subtree = proto_item_add_subtree(ti, ett_bgp_orf);
|
|
|
|
proto_tree_add_text(subtree, tvb, p , 1, "ORF flag: %s", val_to_str(orfwhen, orf_when_vals,"UNKNOWN"));
|
|
|
|
proto_tree_add_text(subtree, tvb, p+1 , 1, "ORF type: %s", val_to_str(orftype, orf_type_vals,"UNKNOWN"));
|
2007-08-23 20:42:27 +00:00
|
|
|
proto_tree_add_text(subtree, tvb, p+2 , 2, "ORF len: %u byte%s", orflen, plurality(orflen, "", "s"));
|
2002-08-15 18:52:04 +00:00
|
|
|
p += 4;
|
|
|
|
|
2003-04-24 09:00:27 +00:00
|
|
|
if (orftype != BGP_ORF_PREFIX_CISCO) {
|
|
|
|
proto_tree_add_text(subtree, tvb, p, orflen,
|
|
|
|
"ORFEntry-Unknown (%u bytes)", orflen);
|
|
|
|
p += orflen;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
pend = p + orflen;
|
|
|
|
while (p < pend) {
|
|
|
|
entryflag = tvb_get_guint8(tvb, p);
|
|
|
|
if ((entryflag & BGP_ORF_ACTION) == BGP_ORF_REMOVEALL) {
|
|
|
|
ti1 = proto_tree_add_text(subtree, tvb, p, 1,
|
|
|
|
"ORFEntry-PrefixList (1 byte)");
|
|
|
|
subtree1 = proto_item_add_subtree(ti1, ett_bgp_orf_entry);
|
|
|
|
proto_tree_add_text(subtree1, tvb, p , 1, "RemoveAll");
|
|
|
|
p++;
|
|
|
|
} else {
|
|
|
|
ti1 = proto_tree_add_text(subtree, tvb, p, -1,
|
|
|
|
"ORFEntry-PrefixList");
|
|
|
|
subtree1 = proto_item_add_subtree(ti1, ett_bgp_orf_entry);
|
|
|
|
proto_tree_add_text(subtree1, tvb, p, 1,
|
|
|
|
"ACTION: %s MATCH: %s",
|
|
|
|
val_to_str(entryflag&BGP_ORF_ACTION,
|
|
|
|
orf_entry_action_vals, "UNKNOWN"),
|
|
|
|
val_to_str(entryflag&BGP_ORF_MATCH,
|
|
|
|
orf_entry_match_vals, "UNKNOWN"));
|
|
|
|
p++;
|
|
|
|
entryseq = tvb_get_ntohl(tvb, p);
|
|
|
|
proto_tree_add_text(subtree1, tvb, p, 4,
|
|
|
|
"Entry Sequence No: %u", entryseq);
|
|
|
|
p += 4;
|
|
|
|
pfx_ge = tvb_get_guint8(tvb, p);
|
|
|
|
proto_tree_add_text(subtree1, tvb, p, 1,
|
|
|
|
"PrefixMask length lower bound: %u", pfx_ge);
|
|
|
|
p++;
|
|
|
|
pfx_le = tvb_get_guint8(tvb, p);
|
|
|
|
proto_tree_add_text(subtree1, tvb, p, 1,
|
|
|
|
"PrefixMask length upper bound: %u", pfx_le);
|
|
|
|
p++;
|
|
|
|
|
|
|
|
advance = decode_prefix4(subtree1, -1, tvb, p, 0, "ORF");
|
|
|
|
if (advance < 0)
|
|
|
|
break;
|
|
|
|
entrylen = 7 + 1 + advance;
|
|
|
|
|
|
|
|
proto_item_append_text(ti1, " (%u bytes)", entrylen);
|
|
|
|
proto_item_set_len(ti1, entrylen);
|
|
|
|
p += advance;
|
|
|
|
}
|
|
|
|
}
|
2002-08-15 18:52:04 +00:00
|
|
|
}
|
2000-12-25 05:28:40 +00:00
|
|
|
}
|
|
|
|
|
2003-01-28 05:25:18 +00:00
|
|
|
/*
|
|
|
|
* Dissect a BGP CAPABILITY message.
|
|
|
|
*/
|
|
|
|
static void
|
2003-04-05 11:20:54 +00:00
|
|
|
dissect_bgp_capability(tvbuff_t *tvb, proto_tree *tree)
|
2003-01-28 05:25:18 +00:00
|
|
|
{
|
2003-04-05 11:20:54 +00:00
|
|
|
int offset = 0;
|
2003-01-28 05:25:18 +00:00
|
|
|
proto_item *ti;
|
|
|
|
proto_tree *subtree;
|
|
|
|
guint8 action;
|
|
|
|
int ctype;
|
|
|
|
int clen;
|
|
|
|
int mend;
|
|
|
|
|
|
|
|
mend = offset + tvb_get_ntohs(tvb, offset + BGP_MARKER_SIZE);
|
|
|
|
offset += BGP_HEADER_SIZE;
|
|
|
|
/* step through all of the capabilities */
|
|
|
|
while (offset < mend) {
|
|
|
|
action = tvb_get_guint8(tvb, offset++);
|
|
|
|
ctype = tvb_get_guint8(tvb, offset++);
|
|
|
|
clen = tvb_get_guint8(tvb, offset++);
|
|
|
|
|
2009-03-28 00:35:02 +00:00
|
|
|
ti = proto_tree_add_text(tree, tvb, offset - 2, 2 + clen,
|
2007-08-23 20:42:27 +00:00
|
|
|
"%s (%u byte%s)", val_to_str(ctype, capability_vals,
|
|
|
|
"Unknown capability"), 2 + clen, plurality(clen, "", "s"));
|
2003-01-28 05:25:18 +00:00
|
|
|
subtree = proto_item_add_subtree(ti, ett_bgp_option);
|
|
|
|
proto_tree_add_text(subtree, tvb, offset-2, 1, "Action: %d (%s)",
|
|
|
|
action, val_to_str(action, bgpcap_action, "Invalid action value"));
|
|
|
|
dissect_bgp_capability_item(tvb, &offset, subtree, ctype, clen);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2003-04-05 11:20:54 +00:00
|
|
|
static void
|
2008-11-22 15:55:01 +00:00
|
|
|
dissect_bgp_pdu(tvbuff_t *volatile tvb, packet_info *pinfo, proto_tree *tree,
|
2003-04-05 11:20:54 +00:00
|
|
|
gboolean first)
|
|
|
|
{
|
|
|
|
guint16 bgp_len; /* Message length */
|
|
|
|
guint8 bgp_type; /* Message type */
|
2005-06-26 19:56:52 +00:00
|
|
|
const char *typ; /* Message type (string) */
|
2003-04-05 11:20:54 +00:00
|
|
|
proto_item *ti; /* tree item */
|
|
|
|
proto_tree *bgp_tree; /* BGP packet tree */
|
|
|
|
proto_tree *bgp1_tree; /* BGP message tree */
|
|
|
|
|
|
|
|
bgp_len = tvb_get_ntohs(tvb, BGP_MARKER_SIZE);
|
|
|
|
bgp_type = tvb_get_guint8(tvb, BGP_MARKER_SIZE + 2);
|
2003-04-24 09:00:27 +00:00
|
|
|
typ = val_to_str(bgp_type, bgptypevals, "Unknown message type (0x%02x)");
|
2003-04-05 11:20:54 +00:00
|
|
|
|
|
|
|
if (check_col(pinfo->cinfo, COL_INFO)) {
|
|
|
|
if (first)
|
2007-10-23 05:50:00 +00:00
|
|
|
col_add_str(pinfo->cinfo, COL_INFO, typ);
|
2003-04-05 11:20:54 +00:00
|
|
|
else
|
|
|
|
col_append_fstr(pinfo->cinfo, COL_INFO, ", %s", typ);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (tree) {
|
|
|
|
ti = proto_tree_add_item(tree, proto_bgp, tvb, 0, -1, FALSE);
|
|
|
|
bgp_tree = proto_item_add_subtree(ti, ett_bgp);
|
|
|
|
|
|
|
|
ti = proto_tree_add_text(bgp_tree, tvb, 0, -1, "%s", typ);
|
|
|
|
|
|
|
|
/* add a different tree for each message type */
|
|
|
|
switch (bgp_type) {
|
|
|
|
case BGP_OPEN:
|
|
|
|
bgp1_tree = proto_item_add_subtree(ti, ett_bgp_open);
|
|
|
|
break;
|
|
|
|
case BGP_UPDATE:
|
|
|
|
bgp1_tree = proto_item_add_subtree(ti, ett_bgp_update);
|
|
|
|
break;
|
|
|
|
case BGP_NOTIFICATION:
|
|
|
|
bgp1_tree = proto_item_add_subtree(ti, ett_bgp_notification);
|
|
|
|
break;
|
|
|
|
case BGP_KEEPALIVE:
|
|
|
|
bgp1_tree = proto_item_add_subtree(ti, ett_bgp);
|
|
|
|
break;
|
|
|
|
case BGP_ROUTE_REFRESH_CISCO:
|
|
|
|
case BGP_ROUTE_REFRESH:
|
|
|
|
bgp1_tree = proto_item_add_subtree(ti, ett_bgp_route_refresh);
|
|
|
|
break;
|
|
|
|
case BGP_CAPABILITY:
|
|
|
|
bgp1_tree = proto_item_add_subtree(ti, ett_bgp_capability);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
bgp1_tree = proto_item_add_subtree(ti, ett_bgp);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
proto_tree_add_text(bgp1_tree, tvb, 0, BGP_MARKER_SIZE,
|
|
|
|
"Marker: 16 bytes");
|
|
|
|
|
|
|
|
if (bgp_len < BGP_HEADER_SIZE || bgp_len > BGP_MAX_PACKET_SIZE) {
|
|
|
|
proto_tree_add_text(bgp1_tree, tvb, BGP_MARKER_SIZE, 2,
|
2007-08-23 20:42:27 +00:00
|
|
|
"Length (invalid): %u byte%s", bgp_len,
|
|
|
|
plurality(bgp_len, "", "s"));
|
2003-04-05 11:20:54 +00:00
|
|
|
return;
|
|
|
|
} else {
|
|
|
|
proto_tree_add_text(bgp1_tree, tvb, BGP_MARKER_SIZE, 2,
|
2007-08-23 20:42:27 +00:00
|
|
|
"Length: %u byte%s", bgp_len,
|
|
|
|
plurality(bgp_len, "", "s"));
|
2003-04-05 11:20:54 +00:00
|
|
|
}
|
|
|
|
|
2003-04-24 09:00:27 +00:00
|
|
|
proto_tree_add_uint(bgp1_tree, hf_bgp_type, tvb,
|
2003-04-05 11:20:54 +00:00
|
|
|
BGP_MARKER_SIZE + 2, 1,
|
2003-04-24 09:00:27 +00:00
|
|
|
bgp_type);
|
2003-04-05 11:20:54 +00:00
|
|
|
|
|
|
|
switch (bgp_type) {
|
|
|
|
case BGP_OPEN:
|
|
|
|
dissect_bgp_open(tvb, bgp1_tree);
|
|
|
|
break;
|
|
|
|
case BGP_UPDATE:
|
|
|
|
dissect_bgp_update(tvb, bgp1_tree);
|
|
|
|
break;
|
|
|
|
case BGP_NOTIFICATION:
|
|
|
|
dissect_bgp_notification(tvb, bgp1_tree);
|
|
|
|
break;
|
|
|
|
case BGP_KEEPALIVE:
|
|
|
|
/* no data in KEEPALIVE messages */
|
|
|
|
break;
|
|
|
|
case BGP_ROUTE_REFRESH_CISCO:
|
|
|
|
case BGP_ROUTE_REFRESH:
|
|
|
|
dissect_bgp_route_refresh(tvb, bgp1_tree);
|
|
|
|
break;
|
|
|
|
case BGP_CAPABILITY:
|
|
|
|
dissect_bgp_capability(tvb, bgp1_tree);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2003-01-28 05:25:18 +00:00
|
|
|
|
1999-11-02 00:11:58 +00:00
|
|
|
/*
|
|
|
|
* Dissect a BGP packet.
|
|
|
|
*/
|
2000-04-08 07:07:42 +00:00
|
|
|
static void
|
2001-04-17 21:25:13 +00:00
|
|
|
dissect_bgp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
|
1999-10-15 17:00:47 +00:00
|
|
|
{
|
2003-04-05 11:20:54 +00:00
|
|
|
volatile int offset = 0; /* offset into the tvbuff */
|
|
|
|
gint reported_length_remaining;
|
|
|
|
guint8 bgp_marker[BGP_MARKER_SIZE]; /* Marker (should be all ones */
|
2002-08-02 23:36:07 +00:00
|
|
|
static guchar marker[] = { /* BGP message marker */
|
1999-10-15 17:00:47 +00:00
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
|
|
|
|
};
|
2003-04-05 11:20:54 +00:00
|
|
|
proto_item *ti; /* tree item */
|
|
|
|
proto_tree *bgp_tree; /* BGP packet tree */
|
|
|
|
guint16 bgp_len; /* Message length */
|
|
|
|
int offset_before;
|
|
|
|
guint length_remaining;
|
|
|
|
guint length;
|
|
|
|
volatile gboolean first = TRUE; /* TRUE for the first BGP message in packet */
|
2008-11-22 15:55:01 +00:00
|
|
|
tvbuff_t *volatile next_tvb;
|
1999-10-15 17:00:47 +00:00
|
|
|
|
2009-08-09 06:26:46 +00:00
|
|
|
col_set_str(pinfo->cinfo, COL_PROTOCOL, "BGP");
|
2009-08-09 07:36:13 +00:00
|
|
|
col_clear(pinfo->cinfo, COL_INFO);
|
1999-10-15 17:00:47 +00:00
|
|
|
|
2003-04-05 11:20:54 +00:00
|
|
|
/*
|
|
|
|
* Scan through the TCP payload looking for a BGP marker.
|
|
|
|
*/
|
|
|
|
while ((reported_length_remaining = tvb_reported_length_remaining(tvb, offset))
|
2006-03-08 11:09:02 +00:00
|
|
|
> 0) {
|
2003-04-05 11:20:54 +00:00
|
|
|
/*
|
|
|
|
* "reported_length_remaining" is the number of bytes of TCP payload
|
|
|
|
* remaining. If it's more than the length of a BGP marker,
|
|
|
|
* we check only the number of bytes in a BGP marker.
|
|
|
|
*/
|
|
|
|
if (reported_length_remaining > BGP_MARKER_SIZE)
|
|
|
|
reported_length_remaining = BGP_MARKER_SIZE;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* OK, is there a BGP marker starting at the specified offset -
|
|
|
|
* or, at least, the beginning of a BGP marker running to the end
|
|
|
|
* of the TCP payload?
|
|
|
|
*
|
|
|
|
* This will throw an exception if the frame is short; that's what
|
|
|
|
* we want.
|
|
|
|
*/
|
|
|
|
tvb_memcpy(tvb, bgp_marker, offset, reported_length_remaining);
|
|
|
|
if (memcmp(bgp_marker, marker, reported_length_remaining) == 0) {
|
|
|
|
/*
|
|
|
|
* Yes - stop scanning and start processing BGP packets.
|
|
|
|
*/
|
|
|
|
break;
|
1999-11-01 09:51:59 +00:00
|
|
|
}
|
|
|
|
|
2003-04-05 11:20:54 +00:00
|
|
|
/*
|
|
|
|
* No - keep scanning through the tvbuff to try to find a marker.
|
|
|
|
*/
|
|
|
|
offset++;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If we skipped any bytes, mark it as a BGP continuation.
|
|
|
|
*/
|
|
|
|
if (offset > 0) {
|
|
|
|
ti = proto_tree_add_item(tree, proto_bgp, tvb, 0, -1, FALSE);
|
|
|
|
bgp_tree = proto_item_add_subtree(ti, ett_bgp);
|
2002-01-17 09:25:55 +00:00
|
|
|
|
2003-04-05 11:20:54 +00:00
|
|
|
proto_tree_add_text(bgp_tree, tvb, 0, offset, "Continuation");
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Now process the BGP packets in the TCP payload.
|
|
|
|
*
|
|
|
|
* XXX - perhaps "tcp_dissect_pdus()" should take a starting
|
|
|
|
* offset, in which case we can replace the loop below with
|
|
|
|
* a call to "tcp_dissect_pdus()".
|
|
|
|
*/
|
2006-03-08 11:09:02 +00:00
|
|
|
while (tvb_reported_length_remaining(tvb, offset) > 0) {
|
2002-01-17 09:25:55 +00:00
|
|
|
/*
|
2003-04-05 11:20:54 +00:00
|
|
|
* This will throw an exception if we don't have any data left.
|
|
|
|
* That's what we want. (See "tcp_dissect_pdus()", which is
|
|
|
|
* similar.)
|
2002-01-17 09:25:55 +00:00
|
|
|
*/
|
2003-04-05 11:20:54 +00:00
|
|
|
length_remaining = tvb_ensure_length_remaining(tvb, offset);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Can we do reassembly?
|
|
|
|
*/
|
|
|
|
if (bgp_desegment && pinfo->can_desegment) {
|
|
|
|
/*
|
|
|
|
* Yes - would a BGP header starting at this offset be split
|
|
|
|
* across segment boundaries?
|
|
|
|
*/
|
|
|
|
if (length_remaining < BGP_HEADER_SIZE) {
|
2002-01-17 09:25:55 +00:00
|
|
|
/*
|
2003-04-05 11:20:54 +00:00
|
|
|
* Yes. Tell the TCP dissector where the data for this
|
|
|
|
* message starts in the data it handed us, and how many
|
|
|
|
* more bytes we need, and return.
|
2002-01-17 09:25:55 +00:00
|
|
|
*/
|
2003-04-05 11:20:54 +00:00
|
|
|
pinfo->desegment_offset = offset;
|
|
|
|
pinfo->desegment_len = BGP_HEADER_SIZE - length_remaining;
|
2002-01-17 09:25:55 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2003-04-05 11:20:54 +00:00
|
|
|
/*
|
|
|
|
* Get the length and type from the BGP header.
|
|
|
|
*/
|
|
|
|
bgp_len = tvb_get_ntohs(tvb, offset + BGP_MARKER_SIZE);
|
|
|
|
if (bgp_len < BGP_HEADER_SIZE) {
|
|
|
|
/*
|
|
|
|
* The BGP length doesn't include the BGP header; report that
|
|
|
|
* as an error.
|
|
|
|
*/
|
|
|
|
show_reported_bounds_error(tvb, pinfo, tree);
|
|
|
|
return;
|
1999-11-01 09:51:59 +00:00
|
|
|
}
|
1999-11-01 06:57:01 +00:00
|
|
|
|
2003-04-05 11:20:54 +00:00
|
|
|
/*
|
|
|
|
* Can we do reassembly?
|
|
|
|
*/
|
|
|
|
if (bgp_desegment && pinfo->can_desegment) {
|
|
|
|
/*
|
|
|
|
* Yes - is the PDU split across segment boundaries?
|
|
|
|
*/
|
|
|
|
if (length_remaining < bgp_len) {
|
|
|
|
/*
|
|
|
|
* Yes. Tell the TCP dissector where the data for this
|
|
|
|
* message starts in the data it handed us, and how many
|
|
|
|
* more bytes we need, and return.
|
|
|
|
*/
|
|
|
|
pinfo->desegment_offset = offset;
|
|
|
|
pinfo->desegment_len = bgp_len - length_remaining;
|
2002-10-15 03:47:47 +00:00
|
|
|
return;
|
1999-10-15 17:00:47 +00:00
|
|
|
}
|
2003-04-05 11:20:54 +00:00
|
|
|
}
|
1999-11-01 06:57:01 +00:00
|
|
|
|
2003-04-05 11:20:54 +00:00
|
|
|
/*
|
|
|
|
* Construct a tvbuff containing the amount of the payload we have
|
|
|
|
* available. Make its reported length the amount of data in the PDU.
|
|
|
|
*
|
|
|
|
* XXX - if reassembly isn't enabled. the subdissector will throw a
|
|
|
|
* BoundsError exception, rather than a ReportedBoundsError exception.
|
|
|
|
* We really want a tvbuff where the length is "length", the reported
|
|
|
|
* length is "plen", and the "if the snapshot length were infinite"
|
|
|
|
* length is the minimum of the reported length of the tvbuff handed
|
|
|
|
* to us and "plen", with a new type of exception thrown if the offset
|
|
|
|
* is within the reported length but beyond that third length, with
|
|
|
|
* that exception getting the "Unreassembled Packet" error.
|
|
|
|
*/
|
|
|
|
length = length_remaining;
|
|
|
|
if (length > bgp_len)
|
|
|
|
length = bgp_len;
|
|
|
|
next_tvb = tvb_new_subset(tvb, offset, length, bgp_len);
|
1999-10-15 17:00:47 +00:00
|
|
|
|
2003-04-05 11:20:54 +00:00
|
|
|
/*
|
|
|
|
* Dissect the PDU.
|
|
|
|
*
|
|
|
|
* Catch the ReportedBoundsError exception; if this particular message
|
|
|
|
* happens to get a ReportedBoundsError exception, that doesn't mean
|
|
|
|
* that we should stop dissecting PDUs within this frame or chunk of
|
|
|
|
* reassembled data.
|
|
|
|
*
|
|
|
|
* If it gets a BoundsError, we can stop, as there's nothing more to
|
|
|
|
* see, so we just re-throw it.
|
|
|
|
*/
|
|
|
|
TRY {
|
|
|
|
dissect_bgp_pdu(next_tvb, pinfo, tree, first);
|
1999-10-15 17:00:47 +00:00
|
|
|
}
|
2003-04-05 11:20:54 +00:00
|
|
|
CATCH(BoundsError) {
|
|
|
|
RETHROW;
|
|
|
|
}
|
|
|
|
CATCH(ReportedBoundsError) {
|
|
|
|
show_reported_bounds_error(tvb, pinfo, tree);
|
|
|
|
}
|
|
|
|
ENDTRY;
|
|
|
|
|
|
|
|
first = FALSE;
|
2002-01-17 09:25:55 +00:00
|
|
|
|
2003-04-05 11:20:54 +00:00
|
|
|
/*
|
|
|
|
* Step to the next PDU.
|
|
|
|
* Make sure we don't overflow.
|
|
|
|
*/
|
|
|
|
offset_before = offset;
|
|
|
|
offset += bgp_len;
|
|
|
|
if (offset <= offset_before)
|
|
|
|
break;
|
1999-10-15 17:00:47 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
1999-11-02 00:11:58 +00:00
|
|
|
/*
|
|
|
|
* Register ourselves.
|
|
|
|
*/
|
1999-10-15 17:00:47 +00:00
|
|
|
void
|
|
|
|
proto_register_bgp(void)
|
|
|
|
{
|
2000-08-20 18:10:12 +00:00
|
|
|
|
|
|
|
static hf_register_info hf[] = {
|
|
|
|
{ &hf_bgp_type,
|
2003-04-24 09:00:27 +00:00
|
|
|
{ "Type", "bgp.type", FT_UINT8, BASE_DEC,
|
2001-06-18 02:18:27 +00:00
|
|
|
VALS(bgptypevals), 0x0, "BGP message type", HFILL }},
|
2003-04-24 09:00:27 +00:00
|
|
|
{ &hf_bgp_aggregator_as,
|
|
|
|
{ "Aggregator AS", "bgp.aggregator_as", FT_UINT16, BASE_DEC,
|
2007-08-23 20:42:27 +00:00
|
|
|
NULL, 0x0, NULL, HFILL}},
|
2003-04-24 09:00:27 +00:00
|
|
|
{ &hf_bgp_aggregator_origin,
|
|
|
|
{ "Aggregator origin", "bgp.aggregator_origin", FT_IPv4, BASE_NONE,
|
2009-03-28 00:35:02 +00:00
|
|
|
NULL, 0x0, NULL, HFILL}},
|
2003-04-24 09:00:27 +00:00
|
|
|
{ &hf_bgp_as_path,
|
|
|
|
{ "AS Path", "bgp.as_path", FT_UINT16, BASE_DEC,
|
2007-08-23 20:42:27 +00:00
|
|
|
NULL, 0x0, NULL, HFILL}},
|
2003-04-24 09:00:27 +00:00
|
|
|
{ &hf_bgp_cluster_identifier,
|
|
|
|
{ "Cluster identifier", "bgp.cluster_identifier", FT_IPv4, BASE_NONE,
|
2007-08-23 20:42:27 +00:00
|
|
|
NULL, 0x0, NULL, HFILL}},
|
2003-04-24 09:00:27 +00:00
|
|
|
{ &hf_bgp_community_as,
|
|
|
|
{ "Community AS", "bgp.community_as", FT_UINT16, BASE_DEC,
|
2007-08-23 20:42:27 +00:00
|
|
|
NULL, 0x0, NULL, HFILL}},
|
2003-04-24 09:00:27 +00:00
|
|
|
{ &hf_bgp_community_value,
|
|
|
|
{ "Community value", "bgp.community_value", FT_UINT16, BASE_DEC,
|
2007-08-23 20:42:27 +00:00
|
|
|
NULL, 0x0, NULL, HFILL}},
|
2003-04-24 09:00:27 +00:00
|
|
|
{ &hf_bgp_local_pref,
|
|
|
|
{ "Local preference", "bgp.local_pref", FT_UINT32, BASE_DEC,
|
2007-08-23 20:42:27 +00:00
|
|
|
NULL, 0x0, NULL, HFILL}},
|
2003-04-24 09:00:27 +00:00
|
|
|
{ &hf_bgp_mp_reach_nlri_ipv4_prefix,
|
|
|
|
{ "MP Reach NLRI IPv4 prefix", "bgp.mp_reach_nlri_ipv4_prefix", FT_IPv4, BASE_NONE,
|
2007-08-23 20:42:27 +00:00
|
|
|
NULL, 0x0, NULL, HFILL}},
|
2003-04-24 09:00:27 +00:00
|
|
|
{ &hf_bgp_mp_unreach_nlri_ipv4_prefix,
|
|
|
|
{ "MP Unreach NLRI IPv4 prefix", "bgp.mp_unreach_nlri_ipv4_prefix", FT_IPv4, BASE_NONE,
|
2009-03-28 00:35:02 +00:00
|
|
|
NULL, 0x0, NULL, HFILL}},
|
2005-01-07 11:43:05 +00:00
|
|
|
{ &hf_bgp_mp_nlri_tnl_id,
|
|
|
|
{ "MP Reach NLRI Tunnel Identifier", "bgp.mp_nlri_tnl_id", FT_UINT16, BASE_HEX,
|
2007-08-23 20:42:27 +00:00
|
|
|
NULL, 0x0, NULL, HFILL}},
|
2003-04-24 09:00:27 +00:00
|
|
|
{ &hf_bgp_multi_exit_disc,
|
|
|
|
{ "Multiple exit discriminator", "bgp.multi_exit_disc", FT_UINT32, BASE_DEC,
|
2007-08-23 20:42:27 +00:00
|
|
|
NULL, 0x0, NULL, HFILL}},
|
2003-04-24 09:00:27 +00:00
|
|
|
{ &hf_bgp_next_hop,
|
|
|
|
{ "Next hop", "bgp.next_hop", FT_IPv4, BASE_NONE,
|
2009-03-28 00:35:02 +00:00
|
|
|
NULL, 0x0, NULL, HFILL}},
|
2003-04-24 09:00:27 +00:00
|
|
|
{ &hf_bgp_nlri_prefix,
|
|
|
|
{ "NLRI prefix", "bgp.nlri_prefix", FT_IPv4, BASE_NONE,
|
2009-03-28 00:35:02 +00:00
|
|
|
NULL, 0x0, NULL, HFILL}},
|
2003-04-24 09:00:27 +00:00
|
|
|
{ &hf_bgp_origin,
|
|
|
|
{ "Origin", "bgp.origin", FT_UINT8, BASE_DEC,
|
2007-08-23 20:42:27 +00:00
|
|
|
VALS(bgpattr_origin), 0x0, NULL, HFILL}},
|
2003-04-24 09:00:27 +00:00
|
|
|
{ &hf_bgp_originator_id,
|
|
|
|
{ "Originator identifier", "bgp.originator_id", FT_IPv4, BASE_NONE,
|
2007-08-23 20:42:27 +00:00
|
|
|
NULL, 0x0, NULL, HFILL}},
|
2005-01-07 11:43:05 +00:00
|
|
|
{ &hf_bgp_ssa_t,
|
|
|
|
{ "Transitive bit", "bgp.ssa_t", FT_BOOLEAN, 8,
|
|
|
|
NULL, 0x80, "SSA Transitive bit", HFILL}},
|
|
|
|
{ &hf_bgp_ssa_type,
|
|
|
|
{ "SSA Type", "bgp.ssa_type", FT_UINT16, BASE_DEC,
|
From Kovarththanan Rajaratnam via bug 3548:
(1) Trailing/leading spaces are removed from 'name's/'blurb's
(2) Duplicate 'blurb's are replaced with NULL
(3) Empty ("") 'blurb's are replaced with NULL
(4) BASE_NONE, NULL, 0x0 are used for 'display', 'strings' and 'bitmask' fields
for FT_NONE, FT_BYTES, FT_IPv4, FT_IPv6, FT_ABSOLUTE_TIME, FT_RELATIVE_TIME,
FT_PROTOCOL, FT_STRING and FT_STRINGZ field types
(5) Only allow non-zero value for 'display' if 'bitmask' is non-zero
svn path=/trunk/; revision=28770
2009-06-18 21:30:42 +00:00
|
|
|
VALS(bgp_ssa_type), 0x7FFF, NULL, HFILL}},
|
2005-01-07 11:43:05 +00:00
|
|
|
{ &hf_bgp_ssa_len,
|
|
|
|
{ "Length", "bgp.ssa_len", FT_UINT16, BASE_DEC,
|
|
|
|
NULL, 0x0, "SSA Length", HFILL}},
|
|
|
|
{ &hf_bgp_ssa_value,
|
From Kovarththanan Rajaratnam via bug 3548:
(1) Trailing/leading spaces are removed from 'name's/'blurb's
(2) Duplicate 'blurb's are replaced with NULL
(3) Empty ("") 'blurb's are replaced with NULL
(4) BASE_NONE, NULL, 0x0 are used for 'display', 'strings' and 'bitmask' fields
for FT_NONE, FT_BYTES, FT_IPv4, FT_IPv6, FT_ABSOLUTE_TIME, FT_RELATIVE_TIME,
FT_PROTOCOL, FT_STRING and FT_STRINGZ field types
(5) Only allow non-zero value for 'display' if 'bitmask' is non-zero
svn path=/trunk/; revision=28770
2009-06-18 21:30:42 +00:00
|
|
|
{ "Value", "bgp.ssa_value", FT_BYTES, BASE_NONE,
|
2005-01-07 11:43:05 +00:00
|
|
|
NULL, 0x0, "SSA Value", HFILL}},
|
|
|
|
{ &hf_bgp_ssa_l2tpv3_pref,
|
|
|
|
{ "Preference", "bgp.ssa_l2tpv3_pref", FT_UINT16, BASE_DEC,
|
From Kovarththanan Rajaratnam via bug 3548:
(1) Trailing/leading spaces are removed from 'name's/'blurb's
(2) Duplicate 'blurb's are replaced with NULL
(3) Empty ("") 'blurb's are replaced with NULL
(4) BASE_NONE, NULL, 0x0 are used for 'display', 'strings' and 'bitmask' fields
for FT_NONE, FT_BYTES, FT_IPv4, FT_IPv6, FT_ABSOLUTE_TIME, FT_RELATIVE_TIME,
FT_PROTOCOL, FT_STRING and FT_STRINGZ field types
(5) Only allow non-zero value for 'display' if 'bitmask' is non-zero
svn path=/trunk/; revision=28770
2009-06-18 21:30:42 +00:00
|
|
|
NULL, 0x0, NULL, HFILL}},
|
2005-01-07 11:43:05 +00:00
|
|
|
{ &hf_bgp_ssa_l2tpv3_s,
|
|
|
|
{ "Sequencing bit", "bgp.ssa_l2tpv3_s", FT_BOOLEAN, 8,
|
|
|
|
NULL, 0x80, "Sequencing S-bit", HFILL}},
|
|
|
|
{ &hf_bgp_ssa_l2tpv3_unused,
|
|
|
|
{ "Unused", "bgp.ssa_l2tpv3_Unused", FT_BOOLEAN, 8,
|
|
|
|
NULL, 0x7F, "Unused Flags", HFILL}},
|
|
|
|
{ &hf_bgp_ssa_l2tpv3_cookie_len,
|
|
|
|
{ "Cookie Length", "bgp.ssa_l2tpv3_cookie_len", FT_UINT8, BASE_DEC,
|
From Kovarththanan Rajaratnam via bug 3548:
(1) Trailing/leading spaces are removed from 'name's/'blurb's
(2) Duplicate 'blurb's are replaced with NULL
(3) Empty ("") 'blurb's are replaced with NULL
(4) BASE_NONE, NULL, 0x0 are used for 'display', 'strings' and 'bitmask' fields
for FT_NONE, FT_BYTES, FT_IPv4, FT_IPv6, FT_ABSOLUTE_TIME, FT_RELATIVE_TIME,
FT_PROTOCOL, FT_STRING and FT_STRINGZ field types
(5) Only allow non-zero value for 'display' if 'bitmask' is non-zero
svn path=/trunk/; revision=28770
2009-06-18 21:30:42 +00:00
|
|
|
NULL, 0x0, NULL, HFILL}},
|
2005-01-07 11:43:05 +00:00
|
|
|
{ &hf_bgp_ssa_l2tpv3_session_id,
|
|
|
|
{ "Session ID", "bgp.ssa_l2tpv3_session_id", FT_UINT32, BASE_DEC,
|
From Kovarththanan Rajaratnam via bug 3548:
(1) Trailing/leading spaces are removed from 'name's/'blurb's
(2) Duplicate 'blurb's are replaced with NULL
(3) Empty ("") 'blurb's are replaced with NULL
(4) BASE_NONE, NULL, 0x0 are used for 'display', 'strings' and 'bitmask' fields
for FT_NONE, FT_BYTES, FT_IPv4, FT_IPv6, FT_ABSOLUTE_TIME, FT_RELATIVE_TIME,
FT_PROTOCOL, FT_STRING and FT_STRINGZ field types
(5) Only allow non-zero value for 'display' if 'bitmask' is non-zero
svn path=/trunk/; revision=28770
2009-06-18 21:30:42 +00:00
|
|
|
NULL, 0x0, NULL, HFILL}},
|
2005-01-07 11:43:05 +00:00
|
|
|
{ &hf_bgp_ssa_l2tpv3_cookie,
|
From Kovarththanan Rajaratnam via bug 3548:
(1) Trailing/leading spaces are removed from 'name's/'blurb's
(2) Duplicate 'blurb's are replaced with NULL
(3) Empty ("") 'blurb's are replaced with NULL
(4) BASE_NONE, NULL, 0x0 are used for 'display', 'strings' and 'bitmask' fields
for FT_NONE, FT_BYTES, FT_IPv4, FT_IPv6, FT_ABSOLUTE_TIME, FT_RELATIVE_TIME,
FT_PROTOCOL, FT_STRING and FT_STRINGZ field types
(5) Only allow non-zero value for 'display' if 'bitmask' is non-zero
svn path=/trunk/; revision=28770
2009-06-18 21:30:42 +00:00
|
|
|
{ "Cookie", "bgp.ssa_l2tpv3_cookie", FT_BYTES, BASE_NONE,
|
|
|
|
NULL, 0x0, NULL, HFILL}},
|
2003-04-24 09:00:27 +00:00
|
|
|
{ &hf_bgp_withdrawn_prefix,
|
|
|
|
{ "Withdrawn prefix", "bgp.withdrawn_prefix", FT_IPv4, BASE_NONE,
|
2009-03-28 00:35:02 +00:00
|
|
|
NULL, 0x0, NULL, HFILL}},
|
2003-04-25 14:44:43 +00:00
|
|
|
{ &hf_bgp_cluster_list,
|
From Kovarththanan Rajaratnam via bug 3548:
(1) Trailing/leading spaces are removed from 'name's/'blurb's
(2) Duplicate 'blurb's are replaced with NULL
(3) Empty ("") 'blurb's are replaced with NULL
(4) BASE_NONE, NULL, 0x0 are used for 'display', 'strings' and 'bitmask' fields
for FT_NONE, FT_BYTES, FT_IPv4, FT_IPv6, FT_ABSOLUTE_TIME, FT_RELATIVE_TIME,
FT_PROTOCOL, FT_STRING and FT_STRINGZ field types
(5) Only allow non-zero value for 'display' if 'bitmask' is non-zero
svn path=/trunk/; revision=28770
2009-06-18 21:30:42 +00:00
|
|
|
{ "Cluster List", "bgp.cluster_list", FT_BYTES, BASE_NONE,
|
2009-03-28 00:35:02 +00:00
|
|
|
NULL, 0x0, NULL, HFILL}}
|
2000-08-20 18:10:12 +00:00
|
|
|
};
|
|
|
|
|
1999-11-16 11:44:20 +00:00
|
|
|
static gint *ett[] = {
|
|
|
|
&ett_bgp,
|
2003-04-24 09:00:27 +00:00
|
|
|
&ett_bgp_prefix,
|
1999-11-16 11:44:20 +00:00
|
|
|
&ett_bgp_unfeas,
|
|
|
|
&ett_bgp_attrs,
|
|
|
|
&ett_bgp_attr,
|
|
|
|
&ett_bgp_attr_flags,
|
2001-06-15 08:01:31 +00:00
|
|
|
&ett_bgp_mp_nhna,
|
1999-11-16 11:44:20 +00:00
|
|
|
&ett_bgp_mp_reach_nlri,
|
|
|
|
&ett_bgp_mp_unreach_nlri,
|
2001-06-10 02:08:11 +00:00
|
|
|
&ett_bgp_mp_snpa,
|
1999-11-16 11:44:20 +00:00
|
|
|
&ett_bgp_nlri,
|
|
|
|
&ett_bgp_open,
|
|
|
|
&ett_bgp_update,
|
|
|
|
&ett_bgp_notification,
|
2000-12-25 05:28:40 +00:00
|
|
|
&ett_bgp_route_refresh,
|
2003-01-28 05:25:18 +00:00
|
|
|
&ett_bgp_capability,
|
1999-11-23 20:56:49 +00:00
|
|
|
&ett_bgp_as_paths,
|
2003-04-24 09:00:27 +00:00
|
|
|
&ett_bgp_as_path_segments,
|
2000-01-25 09:24:42 +00:00
|
|
|
&ett_bgp_communities,
|
2000-03-29 06:27:54 +00:00
|
|
|
&ett_bgp_cluster_list,
|
2000-12-25 05:28:40 +00:00
|
|
|
&ett_bgp_options,
|
|
|
|
&ett_bgp_option,
|
2002-08-15 18:52:04 +00:00
|
|
|
&ett_bgp_extended_communities,
|
2009-01-10 11:06:50 +00:00
|
|
|
&ett_bgp_ext_com_flags,
|
2005-01-07 11:43:05 +00:00
|
|
|
&ett_bgp_ssa,
|
|
|
|
&ett_bgp_ssa_subtree,
|
2002-08-15 18:52:04 +00:00
|
|
|
&ett_bgp_orf,
|
|
|
|
&ett_bgp_orf_entry
|
1999-11-16 11:44:20 +00:00
|
|
|
};
|
2002-01-17 09:25:55 +00:00
|
|
|
module_t *bgp_module;
|
2003-01-28 05:25:18 +00:00
|
|
|
static enum_val_t asn_len[] = {
|
2004-05-24 02:25:21 +00:00
|
|
|
{"auto-detect", "Auto-detect", 0},
|
|
|
|
{"2", "2 octet", 2},
|
|
|
|
{"4", "4 octet", 4},
|
|
|
|
{NULL, NULL, -1}
|
2003-01-28 05:25:18 +00:00
|
|
|
};
|
1999-11-16 11:44:20 +00:00
|
|
|
|
2001-01-03 06:56:03 +00:00
|
|
|
proto_bgp = proto_register_protocol("Border Gateway Protocol",
|
|
|
|
"BGP", "bgp");
|
2000-08-20 18:10:12 +00:00
|
|
|
proto_register_field_array(proto_bgp, hf, array_length(hf));
|
1999-11-16 11:44:20 +00:00
|
|
|
proto_register_subtree_array(ett, array_length(ett));
|
2002-01-17 09:25:55 +00:00
|
|
|
|
|
|
|
bgp_module = prefs_register_protocol(proto_bgp, NULL);
|
|
|
|
prefs_register_bool_preference(bgp_module, "desegment",
|
2004-08-21 09:02:52 +00:00
|
|
|
"Reassemble BGP messages spanning multiple TCP segments",
|
|
|
|
"Whether the BGP dissector should reassemble messages spanning multiple TCP segments."
|
|
|
|
" To use this option, you must also enable \"Allow subdissectors to reassemble TCP streams\" in the TCP protocol settings.",
|
2002-01-17 09:25:55 +00:00
|
|
|
&bgp_desegment);
|
2003-01-28 05:25:18 +00:00
|
|
|
prefs_register_enum_preference(bgp_module, "asn_len",
|
|
|
|
"Length of the AS number",
|
|
|
|
"BGP dissector detect the length of the AS number in AS_PATH attributes automatically or manually (NOTE: Automatic detection is not 100% accurate)",
|
|
|
|
&bgp_asn_len, asn_len, FALSE);
|
1999-10-15 17:00:47 +00:00
|
|
|
}
|
2000-04-08 07:07:42 +00:00
|
|
|
|
|
|
|
void
|
|
|
|
proto_reg_handoff_bgp(void)
|
|
|
|
{
|
2001-12-03 04:00:26 +00:00
|
|
|
dissector_handle_t bgp_handle;
|
|
|
|
|
|
|
|
bgp_handle = create_dissector_handle(dissect_bgp, proto_bgp);
|
|
|
|
dissector_add("tcp.port", BGP_TCP_PORT, bgp_handle);
|
2000-04-08 07:07:42 +00:00
|
|
|
}
|