diff --git a/scapy/contrib/bgp.py b/scapy/contrib/bgp.py
index e6b86308e43fd3a836c0576e1f68bc443c8fab76..8ff0becc67c615eec2e58d0abde40c6f6aad2315 100644
--- a/scapy/contrib/bgp.py
+++ b/scapy/contrib/bgp.py
@@ -1,170 +1,2515 @@
-#! /usr/bin/env python
+# This file is part of Scapy
+# See http://www.secdev.org/projects/scapy for more information
+# Copyright (C) Philippe Biondi <phil@secdev.org>
+# This program is published under a GPLv2 license
-# http://trac.secdev.org/scapy/ticket/162
-
-# scapy.contrib.description = BGP
+# scapy.contrib.description = BGP v0.1
# scapy.contrib.status = loads
-from scapy.packet import *
-from scapy.fields import *
+"""
+BGP (Border Gateway Protocol).
+"""
+
+import struct
+import re
+import socket
+
+from scapy import pton_ntop
+from scapy.packet import Packet, Packet_metaclass, bind_layers
+from scapy.fields import (Field, BitField, BitEnumField, XBitField, ByteField,
+ ByteEnumField, ShortField, ShortEnumField, IntField,
+ IntEnumField, LongField, IEEEFloatField, StrField,
+ StrLenField, StrFixedLenField, FieldLenField,
+ FieldListField, PacketField, PacketListField,
+ IPField, FlagsField, ConditionalField,
+ MultiEnumField)
from scapy.layers.inet import TCP
+from scapy.layers.inet6 import IP6Field
+from scapy.config import conf, ConfClass
+from scapy.error import log_runtime
+
+
+#
+# Module configuration
+#
+
+
+class BGPConf(ConfClass):
+ """
+ BGP module configuration.
+ """
+
+ # By default, set to True in order to behave like an OLD speaker (RFC 6793)
+ use_2_bytes_asn = True
+
+
+bgp_module_conf = BGPConf()
+
+
+#
+# Constants
+#
+
+# RFC 4271: "The maximum message size is 4096 octets. All implementations are
+# required to support this maximum message size."
+BGP_MAXIMUM_MESSAGE_SIZE = 4096
+
+# RFC 4271: "Each message has a fixed-size header." Marker (16 bytes) +
+# Length (2 bytes) + Type (1 byte)
+_BGP_HEADER_SIZE = 19
+
+# Marker included in every message (RFC 4271: "This 16-octet field is
+# included for compatibility; it MUST be set to all ones")
+_BGP_HEADER_MARKER = "\xff" * 16
+
+# extended-length flag (RFC 4271 4.3. UPDATE Message Format -
+# Path Attributes)
+_BGP_PA_EXTENDED_LENGTH = 0x10
+
+# RFC 5492 (at least 2 bytes : code + length)
+_BGP_CAPABILITY_MIN_SIZE = 2
+
+# RFC 5492 (at least 3 bytes : type code + length)
+_BGP_PATH_ATTRIBUTE_MIN_SIZE = 3
+
+
+#
+# Fields and utilities
+#
+
+def _bits_to_bytes_len(length_in_bits):
+ """
+ Helper function that returns the numbers of bytes necessary to store the
+ given number of bits.
+ """
+
+ return (length_in_bits + 7) // 8
+
+
+class BGPFieldIPv4(Field):
+ """
+ IPv4 Field (CIDR)
+ """
+
+ def mask2iplen(self, mask):
+ """Get the IP field mask length (in bytes)."""
+ return (mask + 7) // 8
+
+ def h2i(self, pkt, h):
+ """x.x.x.x/y to "internal" representation."""
+ ip, mask = re.split("/", h)
+ return int(mask), ip
+
+ def i2h(self, pkt, i):
+ """"Internal" representation to "human" representation
+ (x.x.x.x/y)."""
+ mask, ip = i
+ return ip + "/" + str(mask)
+
+ def i2repr(self, pkt, i):
+ return self.i2h(pkt, i)
+
+ def i2len(self, pkt, i):
+ mask, ip = i
+ return self.mask2iplen(mask) + 1
+
+ def i2m(self, pkt, i):
+ """"Internal" (IP as bytes, mask as int) to "machine"
+ representation."""
+ mask, ip = i
+ ip = socket.inet_aton(ip)
+ return struct.pack(">B", mask) + ip[:self.mask2iplen(mask)]
+
+ def addfield(self, pkt, s, val):
+ return s + self.i2m(pkt, val)
+
+ def getfield(self, pkt, s):
+ length = self.mask2iplen(struct.unpack(">B", s[0])[0]) + 1
+ return s[length:], self.m2i(pkt, s[:length])
+
+ def m2i(self, pkt, m):
+ mask = struct.unpack(">B", m[0])[0]
+ mask2iplen_res = self.mask2iplen(mask)
+ ip = "".join(
+ [m[i + 1] if i < mask2iplen_res else "\x00" for i in range(4)])
+ return (mask, socket.inet_ntoa(ip))
+
+
+class BGPFieldIPv6(Field):
+ """IPv6 Field (CIDR)"""
+
+ def mask2iplen(self, mask):
+ """Get the IP field mask length (in bytes)."""
+ return (mask + 7) // 8
+
+ def h2i(self, pkt, h):
+ """x.x.x.x/y to internal representation."""
+ ip, mask = re.split("/", h)
+ return int(mask), ip
+
+ def i2h(self, pkt, i):
+ """"Internal" representation to "human" representation."""
+ mask, ip = i
+ return ip + "/" + str(mask)
+
+ def i2repr(self, pkt, i):
+ return self.i2h(pkt, i)
+
+ def i2len(self, pkt, i):
+ mask, ip = i
+ return self.mask2iplen(mask) + 1
+
+ def i2m(self, pkt, i):
+ """"Internal" (IP as bytes, mask as int) to "machine" representation."""
+ mask, ip = i
+ ip = pton_ntop.inet_pton(socket.AF_INET6, ip)
+ return struct.pack(">B", mask) + ip[:self.mask2iplen(mask)]
+
+ def addfield(self, pkt, s, val):
+ return s + self.i2m(pkt, val)
+
+ def getfield(self, pkt, s):
+ length = self.mask2iplen(struct.unpack(">B", s[0])[0]) + 1
+ return s[length:], self.m2i(pkt, s[:length])
+
+ def m2i(self, pkt, m):
+ mask = struct.unpack(">B", m[0])[0]
+ ip = "".join(
+ [m[i + 1] if i < self.mask2iplen(mask) else "\x00" for i in range(16)])
+ return (mask, pton_ntop.inet_ntop(socket.AF_INET6, ip))
+
+
+def has_extended_length(flags):
+ """
+ Used in BGPPathAttr to check if the extended-length flag is
+ set.
+ """
+
+ return flags & _BGP_PA_EXTENDED_LENGTH == _BGP_PA_EXTENDED_LENGTH
+
+
+class BGPNLRI_IPv4(Packet):
+ """
+ Packet handling IPv4 NLRI fields.
+ """
+
+ name = "IPv4 NLRI"
+ fields_desc = [BGPFieldIPv4("prefix", "0.0.0.0/0")]
+
+
+class BGPNLRI_IPv6(Packet):
+ """
+ Packet handling IPv6 NLRI fields.
+ """
+
+ name = "IPv6 NLRI"
+ fields_desc = [BGPFieldIPv6("prefix", "::/0")]
+
+
+class BGPNLRIPacketListField(PacketListField):
+ """
+ PacketListField handling NLRI fields.
+ """
+
+ def getfield(self, pkt, s):
+ lst = []
+ length = None
+ ret = ""
+
+ if self.length_from is not None:
+ length = self.length_from(pkt)
+
+ if length is not None:
+ remain, ret = s[:length], s[length:]
+ else:
+ index = s.find(_BGP_HEADER_MARKER)
+ if index != -1:
+ remain = s[:index]
+ ret = s[index:]
+ else:
+ remain = s
+
+ while remain:
+ mask_length_in_bits = struct.unpack("!B", remain[0])[0]
+ mask_length_in_bytes = (mask_length_in_bits + 7) // 8
+ current = remain[:mask_length_in_bytes + 1]
+ remain = remain[mask_length_in_bytes + 1:]
+ packet = self.m2i(pkt, current)
+ lst.append(packet)
+
+ return remain + ret, lst
+
+
+class _BGPInvalidDataException(Exception):
+ """
+ Raised when it is not possible to instantiate a BGP packet with the given
+ data.
+ """
+
+ def __init__(self, details):
+ Exception.__init__(
+ self,
+ "Impossible to build packet from the given data" + details
+ )
+
+def _get_cls(name, fallback_cls=conf.raw_layer):
+ """
+ Returns class named "name" if it exists, fallback_cls otherwise.
+ """
-class BGPIPField(Field):
- """Represents how bgp dose an ip prefix in (length, prefix)"""
- def mask2iplen(self,mask):
- """turn the mask into the length in bytes of the ip field"""
- return (mask + 7) // 8
- def h2i(self, pkt, h):
- """human x.x.x.x/y to internal"""
- ip,mask = re.split( '/', h)
- return int(mask), ip
- def i2h( self, pkt, i):
- mask, ip = i
- return ip + '/' + str( mask )
- def i2repr( self, pkt, i):
- """make it look nice"""
- return self.i2h(pkt,i)
- def i2len(self, pkt, i):
- """rely on integer division"""
- mask, ip = i
- return self.mask2iplen(mask) + 1
- def i2m(self, pkt, i):
- """internal (ip as bytes, mask as int) to machine"""
- mask, ip = i
- ip = inet_aton( ip )
- return struct.pack(">B",mask) + ip[:self.mask2iplen(mask)]
- def addfield(self, pkt, s, val):
- return s+self.i2m(pkt, val)
- def getfield(self, pkt, s):
- l = self.mask2iplen( struct.unpack(">B",s[0])[0] ) + 1
- return s[l:], self.m2i(pkt,s[:l])
- def m2i(self,pkt,m):
- mask = struct.unpack(">B",m[0])[0]
- ip = "".join(m[i + 1] if i < self.mask2iplen(mask) else '\x00'
- for i in xrange(4))
- return (mask,inet_ntoa(ip))
+ return globals().get(name, fallback_cls)
+
+
+#
+# Common dictionaries
+#
+
+_bgp_message_types = {
+ 0: "NONE",
+ 1: "OPEN",
+ 2: "UPDATE",
+ 3: "NOTIFICATION",
+ 4: "KEEPALIVE",
+ 5: "ROUTE-REFRESH"
+}
+
+
+#
+# AFIs
+#
+
+address_family_identifiers = {
+ 0: "Reserved",
+ 1: "IP (IP version 4)",
+ 2: "IP6 (IP version 6)",
+ 3: "NSAP",
+ 4: "HDLC (8-bit multidrop)",
+ 5: "BBN 1822",
+ 6: "802 (includes all 802 media plus Ethernet \"canonical format\")",
+ 7: "E.163",
+ 8: "E.164 (SMDS, Frame Relay, ATM)",
+ 9: "F.69 (Telex)",
+ 10: "X.121 (X.25, Frame Relay)",
+ 11: "IPX",
+ 12: "Appletalk",
+ 13: "Decnet IV",
+ 14: "Banyan Vines",
+ 15: "E.164 with NSAP format subaddress", # ANDY_MALIS
+ 16: "DNS (Domain Name System)",
+ 17: "Distinguished Name", # CHARLES_LYNN
+ 18: "AS Number", # CHARLES_LYNN
+ 19: "XTP over IP version 4", # MIKE_SAUL
+ 20: "XTP over IP version 6", # MIKE_SAUL
+ 21: "XTP native mode XTP", # MIKE_SAUL
+ 22: "Fibre Channel World-Wide Port Name", # MARK_BAKKE
+ 23: "Fibre Channel World-Wide Node Name", # MARK_BAKKE
+ 24: "GWID", # SUBRA_HEGDE
+ 25: "AFI for L2VPN information", # RFC 6074
+ 26: "MPLS-TP Section Endpoint Identifier", # RFC 7212
+ 27: "MPLS-TP LSP Endpoint Identifier", # RFC 7212
+ 28: "MPLS-TP Pseudowire Endpoint Identifier", # RFC 7212
+ 29: "MT IP: Multi-Topology IP version 4", # RFC 7307
+ 30: "MT IPv6: Multi-Topology IP version 6", # RFC 7307
+ 16384: "EIGRP Common Service Family", # DONNIE_SAVAGE
+ 16385: "EIGRP IPv4 Service Family", # DONNIE_SAVAGE
+ 16386: "EIGRP IPv6 Service Family", # DONNIE_SAVAGE
+ 16387: "LISP Canonical Address Format (LCAF)", # DAVID_MEYER
+ 16388: "BGP-LS", # RFC 7752
+ 16389: "48-bit MAC", # RFC 7042
+ 16390: "64-bit MAC", # RFC 7042
+ 16391: "OUI", # draft-ietf-trill-ia-appsubtlv
+ 16392: "MAC/24", # draft-ietf-trill-ia-appsubtlv
+ 16393: "MAC/40", # draft-ietf-trill-ia-appsubtlv
+ 16394: "IPv6/64", # draft-ietf-trill-ia-appsubtlv
+ 16395: "RBridge Port ID", # draft-ietf-trill-ia-appsubtlv
+ 16396: "TRILL Nickname", # RFC 7455
+ 65535: "Reserved"
+}
+
+
+subsequent_afis = {
+ 0: "Reserved", # RFC 4760
+ 1: "Network Layer Reachability Information used for unicast forwarding", # RFC 4760
+ 2: "Network Layer Reachability Information used for multicast forwarding", # RFC 4760
+ 3: "Reserved", # RFC 4760
+ 4: "Network Layer Reachability Information (NLRI) with MPLS Labels", # RFC 3107
+ 5: "MCAST-VPN", # RFC 6514
+ 6: "Network Layer Reachability Information used for Dynamic Placement of\
+ Multi-Segment Pseudowires", # RFC 7267
+ 7: "Encapsulation SAFI", # RFC 5512
+ 8: "MCAST-VPLS", # RFC 7117
+ 64: "Tunnel SAFI", # DRAFT-NALAWADE-KAPOOR-TUNNEL-SAFI-01
+ 65: "Virtual Private LAN Service (VPLS)", # RFC 6074
+ 66: "BGP MDT SAFI", # RFC 6037
+ 67: "BGP 4over6 SAFI", # RFC 5747
+ 68: "BGP 6over4 SAFI", # YONG_CUI
+ 69: "Layer-1 VPN auto-discovery information", # RFC 5195
+ 70: "BGP EVPNs", # RFC 7432
+ 71: "BGP-LS", # RFC 7752
+ 72: "BGP-LS-VPN", # RFC 7752
+ 128: "MPLS-labeled VPN address", # RFC 4364
+ 129: "Multicast for BGP/MPLS IP Virtual Private Networks (VPNs)", # RFC 6514
+ 132: "Route Target constraint", # RFC 4684
+ 133: "IPv4 dissemination of flow specification rules", # RFC 5575
+ 134: "VPNv4 dissemination of flow specification rules", # RFC 5575
+ 140: "VPN auto-discovery", # draft-ietf-l3vpn-bgpvpn-auto
+ 255: "Reserved" # RFC 4760
+}
+
+
+# Used by _bgp_dispatcher to instantiate the appropriate class
+_bgp_cls_by_type = {
+ 1: "BGPOpen",
+ 2: "BGPUpdate",
+ 3: "BGPNotification",
+ 4: "BGPKeepAlive",
+ 5: "BGPRouteRefresh",
+}
+
+
+#
+# Header
+#
class BGPHeader(Packet):
- """The first part of any BGP packet"""
- name = "BGP header"
- fields_desc = [
- XBitField("marker",0xffffffffffffffffffffffffffffffff, 0x80 ),
- ShortField("len", None),
- ByteEnumField("type", 4, {0:"none", 1:"open",2:"update",3:"notification",4:"keep_alive"}),
- ]
- def post_build(self, p, pay):
- if self.len is None and pay:
- l = len(p) + len(pay)
- p = p[:16]+struct.pack("!H", l)+p[18:]
- return p+pay
-
-class BGPOptionalParameter(Packet):
- """Format of optional Parameter for BGP Open"""
- name = "BGP Optional Parameters"
- fields_desc = [
- ByteField("type", 2),
- ByteField("len", None),
- StrLenField("value", "", length_from = lambda x: x.len),
- ]
- def post_build(self,p,pay):
- if self.len is None:
- l = len(p) - 2 # 2 is length without value
- p = p[:1]+struct.pack("!B", l)+p[2:]
- return p+pay
- def extract_padding(self, p):
- """any thing after this packet is extracted is padding"""
- return "",p
-
-class BGPOpen(Packet):
- """ Opens a new BGP session"""
- name = "BGP Open Header"
- fields_desc = [
- ByteField("version", 4),
- ShortField("AS", 0),
- ShortField("hold_time", 0),
- IPField("bgp_id","0.0.0.0"),
- ByteField("opt_parm_len", None),
- PacketListField("opt_parm",[], BGPOptionalParameter, length_from=lambda p:p.opt_parm_len),
- ]
- def post_build(self, p, pay):
- if self.opt_parm_len is None:
- l = len(p) - 10 # 10 is regular length with no additional options
- p = p[:9] + struct.pack("!B",l) +p[10:]
- return p+pay
-
-class BGPAuthenticationData(Packet):
+ """
+ The header of any BGP message.
+ References: RFC 4271
+ """
+
+ name = "HEADER"
+ fields_desc = [
+ XBitField(
+ "marker",
+ 0xffffffffffffffffffffffffffffffff,
+ 0x80
+ ),
+ ShortField("len", None),
+ ByteEnumField("type", 4, _bgp_message_types)
+ ]
+
+ def post_build(self, p, pay):
+ if self.len is None:
+ length = len(p)
+ if pay:
+ length = length + len(pay)
+ p = p[:16] + struct.pack("!H", length) + p[18:]
+ return p + pay
+
+ def guess_payload_class(self, payload):
+ return _get_cls(_bgp_cls_by_type.get(self.type, conf.raw_layer), conf.raw_layer)
+
+
+def _bgp_dispatcher(payload):
+ """
+ Returns the right class for a given BGP message.
+ """
+
+ cls = conf.raw_layer
+
+ # By default, calling BGP() will build a BGPHeader.
+ if payload is None:
+ cls = _get_cls("BGPHeader", conf.raw_layer)
+
+ else:
+ if len(payload) >= _BGP_HEADER_SIZE and\
+ payload[:16] == _BGP_HEADER_MARKER:
+
+ # Get BGP message type
+ message_type = struct.unpack("!B", payload[18])[0]
+ if message_type == 4:
+ cls = _get_cls("BGPKeepAlive")
+ else:
+ cls = _get_cls("BGPHeader")
+
+ return cls
+
+
+class BGP(Packet):
+ """
+ Every BGP message inherits from this class.
+ """
+
+ #
+ # BGP messages types
+
+ OPEN_TYPE = 1
+ UPDATE_TYPE = 2
+ NOTIFICATION_TYPE = 3
+ KEEPALIVE_TYPE = 4
+ ROUTEREFRESH_TYPE = 5
+
+ @classmethod
+ def dispatch_hook(cls, _pkt=None, *args, **kargs):
+ """
+ Returns the right class for the given data.
+ """
+
+ return _bgp_dispatcher(_pkt)
+
+ def guess_payload_class(self, p):
+ cls = None
+ if len(p) > 15 and p[:16] == _BGP_HEADER_MARKER:
+ cls = BGPHeader
+ return cls
+
+
+#
+# KEEPALIVE
+#
+
+class BGPKeepAlive(BGP, BGPHeader):
+
+ """
+ KEEPALIVE message.
+ """
+
+ name = "KEEPALIVE"
+
+
+#
+# OPEN
+#
+
+#
+# Optional Parameters Codes
+#
+
+optional_parameter_codes = {
+ 0: "Reserved",
+ 1: "Authentication (deprecated)",
+ 2: "Capabilities"
+}
+
+
+#
+# Capabilities
+#
+
+_capabilities = {
+ 0: "Reserved", # RFC 5492
+ 1: "Multiprotocol Extensions for BGP-4", # RFC 2858
+ 2: "Route Refresh Capability for BGP-4", # RFC 2918
+ 3: "Outbound Route Filtering Capability", # RFC 5291
+ 4: "Multiple routes to a destination capability", # RFC 3107
+ 5: "Extended Next Hop Encoding", # RFC 5549
+ 6: "BGP-Extended Message", # (TEMPORARY - registered 2015-09-30, expires 2016-09-30),
+ # draft-ietf-idr-bgp-extended-messages
+ 64: "Graceful Restart Capability", # RFC 4724
+ 65: "Support for 4-octet AS number capability", # RFC 6793
+ 66: "Deprecated (2003-03-06)",
+ 67: "Support for Dynamic Capability (capability specific)", # draft-ietf-idr-dynamic-cap
+ 68: "Multisession BGP Capability", # draft-ietf-idr-bgp-multisession
+ 69: "ADD-PATH Capability", # RFC-ietf-idr-add-paths-15
+ 70: "Enhanced Route Refresh Capability", # RFC 7313
+ 71: "Long-Lived Graceful Restart (LLGR) Capability", # draft-uttaro-idr-bgp-persistence
+ 73: "FQDN Capability", # draft-walton-bgp-hostname-capability
+ 128: "Route Refresh Capability for BGP-4 (Cisco)", # Cisco also uses 128 for RR capability
+ 130: "Outbound Route Filtering Capability (Cisco)", # Cisco also uses 130 for ORF capability
+}
+
+
+_capabilities_objects = {
+ 0x01: "BGPCapMultiprotocol", # RFC 2858
+ 0x02: "BGPCapGeneric", # RFC 2918
+ 0x03: "BGPCapORF", # RFC 5291
+ 0x40: "BGPCapGracefulRestart", # RFC 4724
+ 0x41: "BGPCapFourBytesASN", # RFC 4893
+ 0x46: "BGPCapGeneric", # Enhanced Route Refresh Capability, RFC 7313
+ 0x82: "BGPCapORF", # ORF / RFC 5291 (Cisco)
+}
+
+
+def _register_cls(registry, cls):
+ registry[cls.__name__] = cls
+ return cls
+
+
+_capabilities_registry = {}
+
+
+def _bgp_capability_dispatcher(payload):
+ """
+ Returns the right class for a given BGP capability.
+ """
+
+ cls = _capabilities_registry["BGPCapGeneric"]
+
+ # By default, calling BGPCapability() will build a "generic" capability.
+ if payload is None:
+ cls = _capabilities_registry["BGPCapGeneric"]
+
+ else:
+ length = len(payload)
+ if length >= _BGP_CAPABILITY_MIN_SIZE:
+ code = struct.unpack("!B", payload[0])[0]
+ cls = _get_cls(_capabilities_objects.get(code, "BGPCapGeneric"))
+
+ return cls
+
+
+class _BGPCap_metaclass(type):
+ def __new__(cls, clsname, bases, attrs):
+ newclass = super(_BGPCap_metaclass, cls).__new__(
+ cls, clsname, bases, attrs)
+ _register_cls(_capabilities_registry, newclass)
+ return newclass
+
+
+class _BGPCapability_metaclass(Packet_metaclass, _BGPCap_metaclass):
+ pass
+
+
+class BGPCapability(Packet):
+ """
+ Generic BGP capability.
+ """
+
+ __metaclass__ = _BGPCapability_metaclass
+
+ @classmethod
+ def dispatch_hook(cls, _pkt=None, *args, **kargs):
+ """
+ Returns the right class for the given data.
+ """
+
+ return _bgp_capability_dispatcher(_pkt)
+
+ def pre_dissect(self, s):
+ """
+ Check that the payload is long enough (at least 2 bytes).
+ """
+ length = len(s)
+ if length < _BGP_CAPABILITY_MIN_SIZE:
+ err = " ({}".format(length) + " is < _BGP_CAPABILITY_MIN_SIZE "
+ err += "({})).".format(_BGP_CAPABILITY_MIN_SIZE)
+ raise _BGPInvalidDataException(err)
+ return s
+
+ # Every BGP capability object inherits from BGPCapability.
+ def haslayer(self, cls):
+ ret = 0
+ if cls == BGPCapability:
+ # If cls is BGPCap (the parent class), check that the object is an
+ # instance of an existing BGP capability class.
+ for cap_class in _capabilities_registry:
+ if isinstance(self, _capabilities_registry[cap_class]):
+ ret = 1
+ break
+ elif cls in _capabilities_registry and isinstance(self, cls):
+ ret = 1
+ return ret
+
+ def getlayer(self, cls, nb=1, _track=None):
+ layer = None
+ if cls == BGPCapability:
+ for cap_class in _capabilities_registry:
+ if isinstance(self, _capabilities_registry[cap_class]):
+ layer = self
+ break
+ else:
+ layer = Packet.getlayer(self, cls, nb, _track)
+ return layer
+
+ def post_build(self, p, pay):
+ length = 0
+ if self.length is None:
+ # capability packet length - capability code (1 byte) -
+ # capability length (1 byte)
+ length = len(p) - 2
+ p = p[0] + struct.pack("!B", length) + p[2:]
+ return p + pay
+
+
+class BGPCapGeneric(BGPCapability):
+ """
+ This class provides an implementation of a generic capability.
+ """
+
+ name = "BGP Capability"
+ fields_desc = [
+ ByteEnumField("code", 0, _capabilities),
+ ByteField("length", 0),
+ ConditionalField(
+ StrLenField(
+ "cap_data",
+ '',
+ length_from=lambda p: p.length
+ ),
+ lambda p: p.length > 0
+ )
+ ]
+
+
+#
+# Multiprotocol Extensions for BGP-4
+#
+
+class BGPCapMultiprotocol(BGPCapability):
+ """
+ This class provides an implementation of the Multiprotocol
+ capability.
+ References: RFC 4760
+ """
+
+ name = "Multiprotocol Extensions for BGP-4"
+ fields_desc = [
+ ByteEnumField("code", 1, _capabilities),
+ ByteField("length", 4),
+ ShortEnumField("afi", 0, address_family_identifiers),
+ ByteField("reserved", 0),
+ ByteEnumField("safi", 0, subsequent_afis)
+ ]
+
+
+#
+# Outbound Route Filtering Capability for BGP-4
+#
+
+_orf_types = {
+ 0: "Reserved", # RFC 5291
+ 64: "Address Prefix ORF", # RFC 5292
+ 65: "CP-ORF", # RFC 7543
+}
+
+
+send_receive_values = {
+ 1: "receive",
+ 2: "send",
+ 3: "receive + send"
+}
+
+
+class BGPCapORFBlock(Packet):
+ """
+ The "ORFBlock" is made of <AFI, rsvd, SAFI, Number of ORFs, and
+ <ORF Type, Send/Receive> entries.
+ """
+
+ class ORFTuple(Packet):
+ """
+ Packet handling <ORF Types, Send/Receive> tuples.
+ """
+
+ # (ORF Type (1 octet) / Send/Receive (1 octet)) ....
+ name = "ORF Type"
+ fields_desc = [
+ ByteEnumField("orf_type", 0, _orf_types),
+ ByteEnumField("send_receive", 0, send_receive_values)
+ ]
+
+ name = "ORF Capability Entry"
+ fields_desc = [
+ ShortEnumField("afi", 0, address_family_identifiers),
+ ByteField("reserved", 0),
+ ByteEnumField("safi", 0, subsequent_afis),
+ FieldLenField(
+ "orf_number",
+ None,
+ count_of="entries",
+ fmt="!B"
+ ),
+ PacketListField(
+ "entries",
+ [],
+ ORFTuple,
+ count_from=lambda p: p.orf_number
+ )
+ ]
+
+ def post_build(self, p, pay):
+ count = None
+ if self.orf_number is None:
+ count = len(self.entries) # orf_type (1 byte) + send_receive (1 byte)
+ p = p[:4] + struct.pack("!B", count) + p[5:]
+ return p + pay
+
+
+class BGPCapORFBlockPacketListField(PacketListField):
+ """
+ Handles lists of BGPCapORFBlocks.
+ """
+
+ def getfield(self, pkt, s):
+ lst = []
+ length = None
+
+ if self.length_from is not None:
+ length = self.length_from(pkt)
+ remain = s
+ if length is not None:
+ remain = s[:length]
+
+ while remain:
+ # block length: afi (2 bytes) + reserved (1 byte) + safi (1 byte) +
+ # orf_number (1 byte) + entries (2 bytes * orf_number)
+ orf_number = struct.unpack("!B", remain[4])[0]
+ entries_length = orf_number * 2
+ current = remain[:5 + entries_length]
+ remain = remain[5 + entries_length:]
+ packet = self.m2i(pkt, current)
+ lst.append(packet)
+
+ return remain, lst
+
+
+class BGPCapORF(BGPCapability):
+ """
+ This class provides an implementation of the Outbound Route Filtering
+ capability.
+ References: RFC 5291
+ """
+
+ name = "Outbound Route Filtering Capability"
+ fields_desc = [
+ ByteEnumField("code", 3, _capabilities),
+ ByteField("length", None),
+ BGPCapORFBlockPacketListField(
+ "orf",
+ [],
+ BGPCapORFBlock,
+ length_from=lambda p: p.length
+ )
+ ]
+
+
+#
+# Graceful Restart capability
+#
+
+gr_address_family_flags = {
+ 128: "Forwarding state preserved (0x80: F bit set)"
+}
+
+
+class BGPCapGracefulRestart(BGPCapability):
+ """
+ This class provides an implementation of the Graceful Restart
+ capability.
+ References: RFC 4724
+ """
+
+ class GRTuple(Packet):
+
+ """Tuple <AFI, SAFI, Flags for address family>"""
+ name = "<AFI, SAFI, Flags for address family>"
+ fields_desc = [ShortEnumField("afi", 0, address_family_identifiers),
+ ByteEnumField("safi", 0, subsequent_afis),
+ ByteEnumField("flags", 0, gr_address_family_flags)]
+
+ name = "Graceful Restart Capability"
+ fields_desc = [ByteEnumField("code", 64, _capabilities),
+ ByteField("length", None),
+ BitField("restart_flags", 0, 4),
+ BitField("restart_time", 0, 12),
+ PacketListField("entries", [], GRTuple)]
+
+
+#
+# Support for 4-octet AS number capability
+#
+
+class BGPCapFourBytesASN(BGPCapability):
+ """
+ This class provides an implementation of the 4-octet AS number
+ capability.
+ References: RFC 4893
+ """
+
+ name = "Support for 4-octet AS number capability"
+ fields_desc = [ByteEnumField("code", 65, _capabilities),
+ ByteField("length", 4),
+ IntField("asn", 0)]
+
+
+#
+# Authentication Information optional parameter.
+#
+
+class BGPAuthenticationInformation(Packet):
+
+ """
+ Provides an implementation of the Authentication Information optional
+ parameter, which is now obsolete.
+ References: RFC 1771, RFC 1654, RFC 4271
+ """
+
name = "BGP Authentication Data"
+ fields_desc = [ByteField("authentication_code", 0),
+ StrField("authentication_data", None)]
+
+
+#
+# Optional Parameter.
+#
+
+
+class BGPOptParamPacketListField(PacketListField):
+ """
+ PacketListField handling the optional parameters (OPEN message).
+ """
+
+ def getfield(self, pkt, s):
+ lst = []
+
+ length = 0
+ if self.length_from is not None:
+ length = self.length_from(pkt)
+ remain = s
+ if length is not None:
+ remain, ret = s[:length], s[length:]
+
+ while remain:
+ param_len = struct.unpack("!B", remain[1])[0] # Get param length
+ current = remain[:2 + param_len]
+ remain = remain[2 + param_len:]
+ packet = self.m2i(pkt, current)
+ lst.append(packet)
+
+ return remain + ret, lst
+
+
+class BGPOptParam(Packet):
+ """
+ Provides an implementation the OPEN message optional parameters.
+ References: RFC 4271
+ """
+
+ name = "Optional parameter"
+ fields_desc = [
+ ByteEnumField("param_type", 2, optional_parameter_codes),
+ ByteField("param_length", None),
+ ConditionalField(
+ PacketField(
+ "param_value",
+ None,
+ BGPCapability
+ ),
+ lambda p: p.param_type == 2
+ ),
+ # It"s obsolete, but one can use it provided that
+ # param_type == 1.
+ ConditionalField(
+ PacketField(
+ "authentication_data",
+ None,
+ BGPAuthenticationInformation
+ ),
+ lambda p: p.param_type == 1
+ )
+ ]
+
+ def post_build(self, p, pay):
+ length = None
+ packet = p
+ if self.param_length is None:
+ if self.param_value is None and self.authentication_data is None:
+ length = 0
+ else:
+ length = len(p) - \
+ 2 # parameter type (1 byte) - parameter length (1 byte)
+ packet = p[0] + struct.pack("!B", length)
+ if (self.param_type == 2 and self.param_value is not None) or\
+ (self.param_type == 1 and self.authentication_data is not None):
+ packet = packet + p[2:]
+
+ return packet + pay
+
+
+#
+# OPEN
+#
+
+class BGPOpen(BGP):
+ """
+ OPEN messages are exchanged in order to open a new BGP session.
+ References: RFC 4271
+ """
+
+ name = "OPEN"
+ fields_desc = [
+ ByteField("version", 4),
+ ShortField("my_as", 0),
+ ShortField("hold_time", 0),
+ IPField("bgp_id", "0.0.0.0"),
+ FieldLenField(
+ "opt_param_len",
+ None,
+ length_of="opt_params",
+ fmt="!B"
+ ),
+ BGPOptParamPacketListField(
+ "opt_params",
+ [],
+ BGPOptParam,
+ length_from=lambda p: p.opt_param_len
+ )
+ ]
+
+ def post_build(self, p, pay):
+ if self.opt_param_len is None:
+ length = len(p) - 10 # 10 is regular length with no additional
+ # options
+ p = p[:9] + struct.pack("!B", length) + p[10:]
+ return p + pay
+
+
+#
+# UPDATE
+#
+
+#
+# Path attributes
+#
+
+#
+# Dictionaries
+
+path_attributes = {
+ 0: "Reserved",
+ 1: "ORIGIN", # RFC 4271
+ 2: "AS_PATH", # RFC 4271
+ 3: "NEXT_HOP", # RFC 4271
+ 4: "MULTI_EXIT_DISC", # RFC 4271
+ 5: "LOCAL_PREF", # RFC 4271
+ 6: "ATOMIC_AGGREGATE", # RFC 4271
+ 7: "AGGREGATOR", # RFC 4271
+ 8: "COMMUNITY", # RFC 1997
+ 9: "ORIGINATOR_ID", # RFC 4456
+ 10: "CLUSTER_LIST", # RFC 4456
+ 11: "DPA (deprecated)", # RFC 6938
+ 12: "ADVERTISER (Historic) (deprecated)", # RFC 4223, RFC 6938
+ 13: "RCID_PATH / CLUSTER_ID (Historic) (deprecated)", # RFC 4223, RFC 6938
+ 14: "MP_REACH_NLRI", # RFC 4760
+ 15: "MP_UNREACH_NLRI", # RFC 4760
+ 16: "EXTENDED COMMUNITIES", # RFC 4360
+ 17: "AS4_PATH", # RFC 6793
+ 18: "AS4_AGGREGATOR", # RFC 6793
+ 19: "SAFI Specific Attribute (SSA) (deprecated)", # draft-kapoor-nalawade-idr-bgp-ssa-00,
+ # draft-nalawade-idr-mdt-safi-00, draft-wijnands-mt-discovery-00
+ 20: "Connector Attribute (deprecated)", # RFC 6037
+ 21: "AS_PATHLIMIT (deprecated)", # draft-ietf-idr-as-pathlimit
+ 22: "PMSI_TUNNEL", # RFC 6514
+ 23: "Tunnel Encapsulation Attribute", # RFC 5512
+ 24: "Traffic Engineering", # RFC 5543
+ 25: "IPv6 Address Specific Extended Community", # RFC 5701
+ 26: "AIGP", # RFC 7311
+ 27: "PE Distinguisher Labels", # RFC 6514
+ 28: "BGP Entropy Label Capability Attribute (deprecated)", # RFC 6790, RFC 7447
+ 29: "BGP-LS Attribute", # RFC 7752
+ 40: "BGP Prefix-SID", # (TEMPORARY - registered 2015-09-30, expires 2016-09-30)
+ # draft-ietf-idr-bgp-prefix-sid
+ 128: "ATTR_SET", # RFC 6368
+ 255: "Reserved for development"
+}
+
+# http://www.iana.org/assignments/bgp-parameters/bgp-parameters.xml
+attributes_flags = {
+ 1: 0x40, # ORIGIN
+ 2: 0x40, # AS_PATH
+ 3: 0x40, # NEXT_HOP
+ 4: 0x80, # MULTI_EXIT_DISC
+ 5: 0x40, # LOCAL_PREF
+ 6: 0x40, # ATOMIC_AGGREGATE
+ 7: 0xc0, # AGGREGATOR
+ 8: 0xc0, # COMMUNITIES (RFC 1997)
+ 9: 0x80, # ORIGINATOR_ID (RFC 4456)
+ 10: 0x80, # CLUSTER_LIST (RFC 4456)
+ 11: 0xc0, # DPA (RFC 6938)
+ 12: 0x80, # ADVERTISER (RFC 1863, RFC 4223)
+ 13: 0x80, # RCID_PATH (RFC 1863, RFC 4223)
+ 14: 0x80, # MP_REACH_NLRI (RFC 4760)
+ 15: 0x80, # MP_UNREACH_NLRI (RFC 4760)
+ 16: 0xc0, # EXTENDED_COMMUNITIES (RFC 4360)
+ 17: 0xc0, # AS4_PATH (RFC 6793)
+ 18: 0xc0, # AS4_AGGREGATOR (RFC 6793)
+ 19: 0xc0, # SSA (draft-kapoor-nalawade-idr-bgp-ssa-00)
+ 20: 0xc0, # Connector (RFC 6037)
+ 21: 0xc0, # AS_PATHLIMIT (draft-ietf-idr-as-pathlimit)
+ 22: 0xc0, # PMSI_TUNNEL (RFC 6514)
+ 23: 0xc0, # Tunnel Encapsulation (RFC 5512)
+ 24: 0x80, # Traffic Engineering (RFC 5543)
+ 25: 0xc0, # IPv6 Address Specific Extended Community (RFC 5701)
+ 26: 0x80, # AIGP (RFC 7311)
+ 27: 0xc0, # PE Distinguisher Labels (RFC 6514)
+ 28: 0xc0, # BGP Entropy Label Capability Attribute
+ 29: 0x80, # BGP-LS Attribute
+ 40: 0xc0, # BGP Prefix-SID
+ 128: 0xc0 # ATTR_SET (RFC 6368)
+}
+
+
+class BGPPathAttrPacketListField(PacketListField):
+ """
+ PacketListField handling the path attributes (UPDATE message).
+ """
+
+ def getfield(self, pkt, s):
+ lst = []
+ length = 0
+
+ if self.length_from is not None:
+ length = self.length_from(pkt)
+ ret = ""
+ remain = s
+ if length is not None:
+ remain, ret = s[:length], s[length:]
+
+ while remain:
+ #
+ # Get the path attribute flags
+ flags = struct.unpack("!B", remain[0])[0]
+
+ attr_len = 0
+ if has_extended_length(flags):
+ attr_len = struct.unpack("!H", remain[2:4])[0]
+ current = remain[:4 + attr_len]
+ remain = remain[4 + attr_len:]
+ else:
+ attr_len = struct.unpack("!B", remain[2])[0]
+ current = remain[:3 + attr_len]
+ remain = remain[3 + attr_len:]
+
+ packet = self.m2i(pkt, current)
+ lst.append(packet)
+
+ return remain + ret, lst
+
+
+#
+# ORIGIN
+#
+
+class BGPPAOrigin(Packet):
+
+ """
+ Packet handling the ORIGIN attribute value.
+ References: RFC 4271
+ """
+
+ name = "ORIGIN"
+ fields_desc = [
+ ByteEnumField("origin", 0, {0: "IGP", 1: "EGP", 2: "INCOMPLETE"})]
+
+
+#
+# AS_PATH (2 bytes and 4 bytes)
+#
+
+as_path_segment_types = {
+ # RFC 4271
+ 1: "AS_SET",
+ 2: "AS_SEQUENCE",
+
+ # RFC 5065
+ 3: "AS_CONFED_SEQUENCE",
+ 4: "AS_CONFED_SET"
+}
+
+
+class ASPathSegmentPacketListField(PacketListField):
+ """
+ PacketListField handling AS_PATH segments.
+ """
+
+ def getfield(self, pkt, s):
+ lst = []
+ remain = s
+
+ while remain:
+ #
+ # Get the segment length
+ segment_length = struct.unpack("!B", remain[1])[0]
+
+ if bgp_module_conf.use_2_bytes_asn:
+ current = remain[:2 + segment_length * 2]
+ remain = remain[2 + segment_length * 2:]
+ else:
+ current = remain[:2 + segment_length * 4]
+ remain = remain[2 + segment_length * 4:]
+
+ packet = self.m2i(pkt, current)
+ lst.append(packet)
+
+ return remain, lst
+
+
+class BGPPAASPath(Packet):
+ """
+ Packet handling the AS_PATH attribute value (2 bytes ASNs, for old
+ speakers).
+ References: RFC 4271, RFC 5065
+ """
+
+ AS_TRANS = 23456
+
+ class ASPathSegment(Packet):
+ """
+ Provides an implementation for AS_PATH segments with 2 bytes ASNs.
+ """
+
+ fields_desc = [
+ ByteEnumField("segment_type", 2, as_path_segment_types),
+ ByteField("segment_length", None),
+ FieldListField("segment_value", [], ShortField("asn", 0))
+ ]
+
+ def post_build(self, p, pay):
+ segment_len = self.segment_length
+ if segment_len is None:
+ segment_len = len(self.segment_value)
+ p = p[0] + struct.pack("!B", segment_len) + p[2:]
+
+ return p + pay
+
+ name = "AS_PATH (RFC 4271)"
+ fields_desc = [
+ ASPathSegmentPacketListField("segments", [], ASPathSegment)]
+
+
+class BGPPAAS4BytesPath(Packet):
+ """
+ Packet handling the AS_PATH attribute value (4 bytes ASNs, for new
+ speakers -> ASNs are encoded as IntFields).
+ References: RFC 4893
+ """
+
+ class ASPathSegment(Packet):
+ """
+ Provides an implementation for AS_PATH segments with 4 bytes ASNs.
+ """
+
+ fields_desc = [ByteEnumField("segment_type", 2, as_path_segment_types),
+ ByteField("segment_length", None),
+ FieldListField("segment_value", [], IntField("asn", 0))]
+
+ def post_build(self, p, pay):
+ segment_len = self.segment_length
+ if segment_len is None:
+ segment_len = len(self.segment_value)
+ p = p[0] + struct.pack("!B", segment_len) + p[2:]
+
+ return p + pay
+
+ name = "AS_PATH (RFC 4893)"
fields_desc = [
- ByteField("AuthenticationCode", 0),
- ByteField("FormMeaning", 0),
- FieldLenField("Algorithm", 0),
- ]
-
-class BGPPathAttribute(Packet):
- "the attribute of total path"
- name = "BGP Attribute fields"
- fields_desc = [
- FlagsField("flags", 0x40, 8, ["NA0","NA1","NA2","NA3","Extended-Length","Partial","Transitive","Optional"]), #Extened leght may not work
- ByteEnumField("type", 1, {1:"ORIGIN", 2:"AS_PATH", 3:"NEXT_HOP", 4:"MULTI_EXIT_DISC", 5:"LOCAL_PREF", 6:"ATOMIC_AGGREGATE", 7:"AGGREGATOR"}),
- ByteField("attr_len", None),
- StrLenField("value", "", length_from = lambda p: p.attr_len),
- ]
- def post_build(self, p, pay):
- if self.attr_len is None:
- l = len(p) - 3 # 3 is regular length with no additional options
- p = p[:2] + struct.pack("!B",l) +p[3:]
- return p+pay
- def extract_padding(self, p):
- """any thing after this packet is extracted is padding"""
- return "",p
-
-class BGPUpdate(Packet):
- """Update the routes WithdrawnRoutes = UnfeasiableRoutes"""
- name = "BGP Update fields"
- fields_desc = [
- ShortField("withdrawn_len", None),
- FieldListField("withdrawn",[], BGPIPField("","0.0.0.0/0"), length_from=lambda p:p.withdrawn_len),
- ShortField("tp_len", None),
- PacketListField("total_path", [], BGPPathAttribute, length_from = lambda p: p.tp_len),
- FieldListField("nlri",[], BGPIPField("","0.0.0.0/0"), length_from=lambda p:p.underlayer.len - 23 - p.tp_len - p.withdrawn_len), # len should be BGPHeader.len
- ]
- def post_build(self,p,pay):
- wl = self.withdrawn_len
- subpacklen = lambda p: len ( str( p ))
- subfieldlen = lambda p: BGPIPField("", "0.0.0.0/0").i2len(self, p )
- if wl is None:
- wl = sum ( map ( subfieldlen , self.withdrawn))
- p = p[:0]+struct.pack("!H", wl)+p[2:]
- if self.tp_len is None:
- l = sum ( map ( subpacklen , self.total_path))
- p = p[:2+wl]+struct.pack("!H", l)+p[4+wl:]
- return p+pay
-
-class BGPNotification(Packet):
- name = "BGP Notification fields"
- fields_desc = [
- ByteEnumField("ErrorCode",0,{1:"Message Header Error",2:"OPEN Message Error",3:"UPDATE Messsage Error",4:"Hold Timer Expired",5:"Finite State Machine",6:"Cease"}),
- ByteEnumField("ErrorSubCode",0,{1:"MessageHeader",2:"OPENMessage",3:"UPDATEMessage"}),
- LongField("Data", 0),
- ]
-
-class BGPErrorSubcodes(Packet):
- name = "BGP Error Subcodes"
- Fields_desc = [
- ByteEnumField("MessageHeader",0,{1:"Connection Not Synchronized",2:"Bad Message Length",3:"Bad Messsage Type"}),
- ByteEnumField("OPENMessage",0,{1:"Unsupported Version Number",2:"Bad Peer AS",3:"Bad BGP Identifier",4:"Unsupported Optional Parameter",5:"Authentication Failure",6:"Unacceptable Hold Time"}),
- ByteEnumField("UPDATEMessage",0,{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"}),
- ]
-
-bind_layers( TCP, BGPHeader, dport=179)
-bind_layers( TCP, BGPHeader, sport=179)
-bind_layers( BGPHeader, BGPOpen, type=1)
-bind_layers( BGPHeader, BGPUpdate, type=2)
-bind_layers( BGPHeader, BGPHeader, type=4)
-
-
-if __name__ == "__main__":
- from scapy.main import interact
- interact(mydict=globals(), mybanner="BGP addon .05")
+ ASPathSegmentPacketListField("segments", [], ASPathSegment)]
+
+
+#
+# NEXT_HOP
+#
+
+class BGPPANextHop(Packet):
+ """
+ Packet handling the NEXT_HOP attribute value.
+ References: RFC 4271
+ """
+
+ name = "NEXT_HOP"
+ fields_desc = [IPField("next_hop", "0.0.0.0")]
+
+
+#
+# MULTI_EXIT_DISC
+#
+
+class BGPPAMultiExitDisc(Packet):
+ """
+ Packet handling the MULTI_EXIT_DISC attribute value.
+ References: RFC 4271
+ """
+
+ name = "MULTI_EXIT_DISC"
+ fields_desc = [IntField("med", 0)]
+
+
+#
+# LOCAL_PREF
+#
+
+class BGPPALocalPref(Packet):
+ """
+ Packet handling the LOCAL_PREF attribute value.
+ References: RFC 4271
+ """
+
+ name = "LOCAL_PREF"
+ fields_desc = [IntField("local_pref", 0)]
+
+
+#
+# ATOMIC_AGGREGATE
+#
+
+class BGPPAAtomicAggregate(Packet):
+ """
+ Packet handling the ATOMIC_AGGREGATE attribute value.
+ References: RFC 4271
+ """
+
+ name = "ATOMIC_AGGREGATE"
+
+
+#
+# AGGREGATOR
+#
+
+class BGPPAAggregator(Packet):
+ """
+ Packet handling the AGGREGATOR attribute value.
+ References: RFC 4271
+ """
+
+ name = "AGGREGATOR"
+ fields_desc = [ShortField("aggregator_asn", 0),
+ IPField("speaker_address", "0.0.0.0")]
+
+
+#
+# COMMUNITIES
+#
+
+# http://www.iana.org/assignments/bgp-well-known-communities/bgp-well-known-communities.xml
+well_known_communities = {
+ 0xFFFFFF01: "NO_EXPORT", # RFC 1997
+ 0xFFFFFF02: "NO_ADVERTISE", # RFC 1997
+ 0xFFFFFF03: "NO_EXPORT_SUBCONFED", # RFC 1997
+ 0xFFFFFF04: "NOPEER", # RFC 3765
+ 0xFFFF0000: "planned-shut", # draft-francois-bgp-gshut
+ 0xFFFF0001: "ACCEPT-OWN", # RFC 7611
+ 0xFFFF0002: "ROUTE_FILTER_TRANSLATED_v4", # draft-l3vpn-legacy-rtc
+ 0xFFFF0003: "ROUTE_FILTER_v4", # draft-l3vpn-legacy-rtc
+ 0xFFFF0004: "ROUTE_FILTER_TRANSLATED_v6", # draft-l3vpn-legacy-rtc
+ 0xFFFF0005: "ROUTE_FILTER_v6", # draft-l3vpn-legacy-rtc
+ 0xFFFF0006: "LLGR_STALE", # draft-uttaro-idr-bgp-persistence
+ 0xFFFF0007: "NO_LLGR", # draft-uttaro-idr-bgp-persistence
+ 0xFFFF0008: "accept-own-nexthop", # Ashutosh_Grewal
+}
+
+
+class BGPPACommunity(Packet):
+ """
+ Packet handling the COMMUNITIES attribute value.
+ References: RFC 1997
+ """
+
+ name = "COMMUNITIES"
+ fields_desc = [IntEnumField("community", 0, well_known_communities)]
+
+
+#
+# ORIGINATOR_ID
+#
+
+class BGPPAOriginatorID(Packet):
+ """
+ Packet handling the ORIGINATOR_ID attribute value.
+ References: RFC 4456
+ """
+
+ name = "ORIGINATOR_ID"
+ fields_desc = [IPField("originator_id", "0.0.0.0")]
+
+
+#
+# CLUSTER_LIST
+#
+
+class BGPPAClusterList(Packet):
+ """
+ Packet handling the CLUSTER_LIST attribute value.
+ References: RFC 4456
+ """
+
+ name = "CLUSTER_LIST"
+ fields_desc = [
+ FieldListField("cluster_list", [], IntField("cluster_id", 0))]
+
+
+#
+# EXTENDED COMMUNITIES (RFC 4360)
+#
+
+# BGP Transitive Extended Community Types
+# http://www.iana.org/assignments/bgp-extended-communities/bgp-extended-communities.xhtml#transitive
+_ext_comm_types = {
+ 0x00: "Transitive Two-Octet AS-Specific Extended Community", # RFC 7153
+ 0x01: "Transitive IPv4-Address-Specific Extended Community", # RFC 7153
+ 0x02: "Transitive Four-Octet AS-Specific Extended Community", # RFC 7153
+ 0x03: "Transitive Opaque Extended Community", # RFC 7153
+ 0x04: "QoS Marking", # Thomas_Martin_Knoll
+ 0x05: "CoS Capability", # Thomas_Martin_Knoll
+ 0x06: "EVPN", # RFC 7153
+ 0x07: "Unassigned",
+ 0x08: "Flow spec redirect/mirror to IP next-hop", # draft-simpson-idr-flowspec-redirect
+
+ # BGP Non-Transitive Extended Community Types
+ 0x40: "Non-Transitive Two-Octet AS-Specific Extended Community", # RFC 7153
+ 0x41: "Non-Transitive IPv4-Address-Specific Extended Community", # RFC 7153
+ 0x42: "Non-Transitive Four-Octet AS-Specific Extended Community", # RFC 7153
+ 0x43: "Non-Transitive Opaque Extended Community", # RFC 7153
+ 0x44: "QoS Marking", # Thomas_Martin_Knoll
+
+ 0x80: "Generic Transitive Experimental Use Extended Community", # RFC 7153
+ 0x81: "Generic Transitive Experimental Use Extended Community Part 2", # RFC 7674
+ 0x82: "Generic Transitive Experimental Use Extended Community Part 3", # RFC 7674
+}
+
+# EVPN Extended Community Sub-Types
+_ext_comm_evpn_subtypes = {
+ 0x00: "MAC Mobility", # RFC 7432
+ 0x01: "ESI Label", # RFC 7432
+ 0x02: "ES-Import Route Target", # RFC 7432
+ 0x03: "EVPN Router\"s MAC Extended Community",
+ # draft-sajassi-l2vpn-evpn-inter-subnet-forwarding
+ 0x04: "Layer 2 Extended Community", # draft-ietf-bess-evpn-vpws
+ 0x05: "E-TREE Extended Community", # draft-ietf-bess-evpn-etree
+ 0x06: "DF Election Extended Community", # draft-ietf-bess-evpn-df-election
+ 0x07: "I-SID Extended Community", # draft-sajassi-bess-evpn-virtual-eth-segment
+}
+
+# Transitive Two-Octet AS-Specific Extended Community Sub-Types
+_ext_comm_trans_two_octets_as_specific_subtypes = {
+ 0x02: "Route Target", # RFC 4360
+ 0x03: "Route Origin", # RFC 4360
+ 0x04: "Unassigned", # RFC 4360
+ 0x05: "OSPF Domain Identifier", # RFC 4577
+ 0x08: "BGP Data Collection", # RFC 4384
+ 0x09: "Source AS", # RFC 6514
+ 0x0a: "L2VPN Identifier", # RFC 6074
+ 0x0010: "Cisco VPN-Distinguisher", # Eric_Rosen
+}
+
+# Non-Transitive Two-Octet AS-Specific Extended Community Sub-Types
+_ext_comm_non_trans_two_octets_as_specific_subtypes = {
+ 0x04: "Link Bandwidth Extended Community", # draft-ietf-idr-link-bandwidth-00
+ 0x80: "Virtual-Network Identifier Extended Community",
+ # draft-drao-bgp-l3vpn-virtual-network-overlays
+}
+
+# Transitive Four-Octet AS-Specific Extended Community Sub-Types
+_ext_comm_trans_four_octets_as_specific_subtypes = {
+ 0x02: "Route Target", # RFC 5668
+ 0x03: "Route Origin", # RFC 5668
+ 0x04: "Generic", # draft-ietf-idr-as4octet-extcomm-generic-subtype
+ 0x05: "OSPF Domain Identifier", # RFC 4577
+ 0x08: "BGP Data Collection", # RFC 4384
+ 0x09: "Source AS", # RFC 6514
+ 0x10: "Cisco VPN Identifier", # Eric_Rosen
+}
+
+# Non-Transitive Four-Octet AS-Specific Extended Community Sub-Types
+_ext_comm_non_trans_four_octets_as_specific_subtypes = {
+ 0x04: "Generic", # draft-ietf-idr-as4octet-extcomm-generic-subtype
+}
+
+# Transitive IPv4-Address-Specific Extended Community Sub-Types
+_ext_comm_trans_ipv4_addr_specific_subtypes = {
+ 0x02: "Route Target", # RFC 4360
+ 0x03: "Route Origin", # RFC 4360
+ 0x05: "OSPF Domain Identifier", # RFC 4577
+ 0x07: "OSPF Route ID", # RFC 4577
+ 0x0a: "L2VPN Identifier", # RFC 6074
+ 0x0b: "VRF Route Import", # RFC 6514
+ 0x0c: "Flow-spec Redirect to IPv4", # draft-ietf-idr-flowspec-redirect
+ 0x10: "Cisco VPN-Distinguisher", # Eric_Rosen
+ 0x12: "Inter-Area P2MP Segmented Next-Hop", # RFC 7524
+}
+
+# Non-Transitive IPv4-Address-Specific Extended Community Sub-Types
+_ext_comm_non_trans_ipv4_addr_specific_subtypes = {}
+
+# Transitive Opaque Extended Community Sub-Types
+_ext_comm_trans_opaque_subtypes = {
+ 0x01: "Cost Community", # draft-ietf-idr-custom-decision
+ 0x03: "CP-ORF", # RFC 7543
+ 0x04: "Extranet Source Extended Community", # RFC 7900
+ 0x05: "Extranet Separation Extended Community", # RFC 7900
+ 0x06: "OSPF Route Type", # RFC 4577
+ 0x07: "Additional PMSI Tunnel Attribute Flags", # RFC 7902
+ 0x0b: "Color Extended Community", # RFC 5512
+ 0x0c: "Encapsulation Extended Community", # RFC 5512
+ 0x0d: "Default Gateway", # Yakov_Rekhter
+ 0x0e: "Point-to-Point-to-Multipoint (PPMP) Label", # Rishabh_Parekh
+ 0x13: "Route-Target Record", # draft-ietf-bess-service-chaining
+ 0x14: "Consistent Hash Sort Order", # draft-ietf-bess-service-chaining
+}
+
+# Non-Transitive Opaque Extended Community Sub-Types
+_ext_comm_non_trans_opaque_subtypes = {
+ 0x00: "BGP Origin Validation State", # draft-ietf-sidr-origin-validation-signaling
+ 0x01: "Cost Community", # draft-ietf-idr-custom-decision
+}
+
+# Generic Transitive Experimental Use Extended Community Sub-Types
+_ext_comm_generic_transitive_exp_subtypes = {
+ 0x00: "OSPF Route Type (deprecated)", # RFC 4577
+ 0x01: "OSPF Router ID (deprecated)", # RFC 4577
+ 0x05: "OSPF Domain Identifier (deprecated)", # RFC 4577
+ 0x06: "Flow spec traffic-rate", # RFC 5575
+ 0x07: "Flow spec traffic-action", # RFC 5575
+ 0x08: "Flow spec redirect AS-2byte format", # RFC 5575, RFC 7674
+ 0x09: "Flow spec traffic-remarking", # RFC 5575
+ 0x0a: "Layer2 Info Extended Community", # RFC 4761
+ 0x0b: "E-Tree Info", # RFC 7796
+}
+
+# Generic Transitive Experimental Use Extended Community Part 2 Sub-Types
+_ext_comm_generic_transitive_exp_part2_subtypes = {
+ 0x08: "Flow spec redirect IPv4 format", # RFC 7674
+}
+
+# Generic Transitive Experimental Use Extended Community Part 3 Sub-Types
+_ext_comm_generic_transitive_exp_part3_subtypes = {
+ 0x08: "Flow spec redirect AS-4byte format", # RFC 7674
+}
+
+# Traffic Action Fields
+_ext_comm_traffic_action_fields = {
+ 47: "Terminal Action", # RFC 5575
+ 46: "Sample", # RFC 5575
+}
+
+# Transitive IPv6-Address-Specific Extended Community Types
+_ext_comm_trans_ipv6_addr_specific_types = {
+ 0x0002: "Route Target", # RFC 5701
+ 0x0003: "Route Origin", # RFC 5701
+ 0x0004: "OSPFv3 Route Attributes (DEPRECATED)", # RFC 6565
+ 0x000b: "VRF Route Import", # RFC 6515, RFC 6514
+ 0x000c: "Flow-spec Redirect to IPv6", # draft-ietf-idr-flowspec-redirect-ip
+ 0x0010: "Cisco VPN-Distinguisher", # Eric_Rosen
+ 0x0011: "UUID-based Route Target", # Dhananjaya_Rao
+ 0x0012: "Inter-Area P2MP Segmented Next-Hop", # RFC 7524
+}
+
+# Non-Transitive IPv6-Address-Specific Extended Community Types
+_ext_comm_non_trans_ipv6_addr_specific_types = {}
+
+
+_ext_comm_subtypes_classes = {
+ 0x00: _ext_comm_trans_two_octets_as_specific_subtypes,
+ 0x01: _ext_comm_trans_ipv4_addr_specific_subtypes,
+ 0x02: _ext_comm_trans_four_octets_as_specific_subtypes,
+ 0x03: _ext_comm_trans_opaque_subtypes,
+ 0x06: _ext_comm_evpn_subtypes,
+ 0x40: _ext_comm_non_trans_two_octets_as_specific_subtypes,
+ 0x41: _ext_comm_non_trans_ipv4_addr_specific_subtypes,
+ 0x42: _ext_comm_non_trans_four_octets_as_specific_subtypes,
+ 0x43: _ext_comm_non_trans_opaque_subtypes,
+ 0x80: _ext_comm_generic_transitive_exp_subtypes,
+ 0x81: _ext_comm_generic_transitive_exp_part2_subtypes,
+ 0x82: _ext_comm_generic_transitive_exp_part3_subtypes,
+}
+
+
+#
+# Extended Community "templates"
+#
+
+class BGPPAExtCommTwoOctetASSpecific(Packet):
+ """
+ Packet handling the Two-Octet AS Specific Extended Community attribute
+ value.
+ References: RFC 4360
+ """
+
+ name = "Two-Octet AS Specific Extended Community"
+ fields_desc = [
+ ShortField("global_administrator", 0), IntField("local_administrator", 0)]
+
+
+class BGPPAExtCommFourOctetASSpecific(Packet):
+ """
+ Packet handling the Four-Octet AS Specific Extended Community
+ attribute value.
+ References: RFC 5668
+ """
+
+ name = "Four-Octet AS Specific Extended Community"
+ fields_desc = [
+ IntField("global_administrator", 0), ShortField("local_administrator", 0)]
+
+
+class BGPPAExtCommIPv4AddressSpecific(Packet):
+ """
+ Packet handling the IPv4 Address Specific Extended Community attribute
+ value.
+ References: RFC 4360
+ """
+
+ name = "IPv4 Address Specific Extended Community"
+ fields_desc = [
+ IntField("global_administrator", 0), ShortField("local_administrator", 0)]
+
+
+class BGPPAExtCommOpaque(Packet):
+ """
+ Packet handling the Opaque Extended Community attribute value.
+ References: RFC 4360
+ """
+
+ name = "Opaque Extended Community"
+ fields_desc = [StrFixedLenField("value", "", length=6)]
+
+
+#
+# FlowSpec related extended communities
+#
+
+class BGPPAExtCommTrafficRate(Packet):
+ """
+ Packet handling the (FlowSpec) "traffic-rate" extended community.
+ References: RFC 5575
+ """
+
+ name = "FlowSpec traffic-rate extended community"
+ fields_desc = [
+ ShortField("id", 0),
+ IEEEFloatField("rate", 0)
+ ]
+
+
+class BGPPAExtCommTrafficAction(Packet):
+ """
+ Packet handling the (FlowSpec) "traffic-action" extended community.
+ References: RFC 5575
+ """
+
+ name = "FlowSpec traffic-action extended community"
+ fields_desc = [
+ BitField("reserved", 0, 46),
+ BitField("sample", 0, 1),
+ BitField("terminal_action", 0, 1)
+ ]
+
+
+class BGPPAExtCommRedirectAS2Byte(Packet):
+ """
+ Packet handling the (FlowSpec) "redirect AS-2byte" extended community
+ (RFC 7674).
+ References: RFC 7674
+ """
+
+ name = "FlowSpec redirect AS-2byte extended community"
+ fields_desc = [
+ ShortField("asn", 0),
+ IntField("value", 0)
+ ]
+
+
+class BGPPAExtCommRedirectIPv4(Packet):
+ """
+ Packet handling the (FlowSpec) "redirect IPv4" extended community.
+ (RFC 7674).
+ References: RFC 7674
+ """
+
+ name = "FlowSpec redirect IPv4 extended community"
+ fields_desc = [
+ IntField("ip_addr", 0),
+ ShortField("value", 0)
+ ]
+
+
+class BGPPAExtCommRedirectAS4Byte(Packet):
+ """
+ Packet handling the (FlowSpec) "redirect AS-4byte" extended community.
+ (RFC 7674).
+ References: RFC 7674
+ """
+
+ name = "FlowSpec redirect AS-4byte extended community"
+ fields_desc = [
+ IntField("asn", 0),
+ ShortField("value", 0)
+ ]
+
+
+class BGPPAExtCommTrafficMarking(Packet):
+ """
+ Packet handling the (FlowSpec) "traffic-marking" extended community.
+ References: RFC 5575
+ """
+
+ name = "FlowSpec traffic-marking extended community"
+ fields_desc = [
+ BitEnumField("dscp", 48, 48, _ext_comm_traffic_action_fields)
+ ]
+
+
+class _ExtCommValuePacketField(PacketField):
+ """
+ PacketField handling Extended Communities "value parts".
+ """
+
+ __slots__ = ["type_from"]
+
+ def __init__(self, name, default, cls, remain=0, type_from=(0, 0)):
+ PacketField.__init__(self, name, default, cls, remain)
+ self.type_from = type_from
+
+ def m2i(self, pkt, m):
+ ret = None
+ type_high, type_low = self.type_from(pkt)
+
+ if type_high == 0x00 or type_high == 0x40:
+ # Two-Octet AS Specific Extended Community
+ ret = BGPPAExtCommTwoOctetASSpecific(m)
+
+ elif type_high == 0x01 or type_high == 0x41:
+ # IPv4 Address Specific
+ ret = BGPPAExtCommIPv4AddressSpecific(m)
+
+ elif type_high == 0x02 or type_high == 0x42:
+ # Four-octet AS Specific Extended Community
+ ret = BGPPAExtCommFourOctetASSpecific(m)
+
+ elif type_high == 0x03 or type_high == 0x43:
+ # Opaque
+ ret = BGPPAExtCommOpaque(m)
+
+ elif type_high == 0x80:
+ # FlowSpec
+ if type_low == 0x06:
+ ret = BGPPAExtCommTrafficRate(m)
+ elif type_low == 0x07:
+ ret = BGPPAExtCommTrafficAction(m)
+ elif type_low == 0x08:
+ ret = BGPPAExtCommRedirectAS2Byte(m)
+ elif type_low == 0x09:
+ ret = BGPPAExtCommTrafficMarking(m)
+
+ elif type_high == 0x81:
+ # FlowSpec
+ if type_low == 0x08:
+ ret = BGPPAExtCommRedirectIPv4(m)
+
+ elif type_high == 0x82:
+ # FlowSpec
+ if type_low == 0x08:
+ ret = BGPPAExtCommRedirectAS4Byte(m)
+
+ else:
+ ret = conf.raw_layer(m)
+
+ return ret
+
+
+class BGPPAIPv6AddressSpecificExtComm(Packet):
+ """
+ Provides an implementation of the IPv6 Address Specific Extended
+ Community attribute. This attribute is not defined using the existing
+ BGP Extended Community attribute (see the RFC 5701 excerpt below).
+ References: RFC 5701
+ """
+
+ name = "IPv6 Address Specific Extended Community"
+ fields_desc = [
+ IP6Field("global_administrator", "::"), ShortField("local_administrator", 0)]
+
+
+def _get_ext_comm_subtype(type_high):
+ """
+ Returns a ByteEnumField with the right sub-types dict for a given community.
+ http://www.iana.org/assignments/bgp-extended-communities/bgp-extended-communities.xhtml
+ """
+
+ return _ext_comm_subtypes_classes.get(type_high, {})
+
+
+class _TypeLowField(ByteField):
+ """
+ Field used to retrieve "dynamically" the right sub-type dict.
+ """
+
+ __slots__ = ["enum_from"]
+
+ def __init__(self, name, default, enum_from=None):
+ ByteField.__init__(self, name=name, default=default)
+ self.enum_from = enum_from
+
+ def i2repr(self, pkt, i):
+ enum = self.enum_from(pkt)
+ return enum.get(i, i)
+
+
+class BGPPAExtCommunity(Packet):
+ """
+ Provides an implementation of the Extended Communities attribute.
+ References: RFC 4360
+ """
+
+ name = "EXTENDED_COMMUNITY"
+ fields_desc = [
+ ByteEnumField("type_high", 0, _ext_comm_types),
+ _TypeLowField(
+ "type_low",
+ 0,
+ enum_from=lambda x: _get_ext_comm_subtype(x.type_high)
+ ),
+ _ExtCommValuePacketField(
+ "value",
+ None,
+ Packet,
+ type_from=lambda x: (x.type_high, x.type_low)
+ )
+ ]
+
+ def post_build(self, p, pay):
+ if self.value is None:
+ p = p[:2]
+ return p + pay
+
+
+class _ExtCommsPacketListField(PacketListField):
+ """
+ PacketListField handling a list of extended communities.
+ """
+
+ def getfield(self, pkt, s):
+ lst = []
+ length = len(s)
+ remain = s[:length]
+
+ while remain:
+ current = remain[:8]
+ remain = remain[8:]
+ packet = self.m2i(pkt, current)
+ lst.append(packet)
+
+ return remain, lst
+
+
+class BGPPAExtComms(Packet):
+ """
+ Packet handling the multiple extended communities.
+ """
+
+ name = "EXTENDED_COMMUNITIES"
+ fields_desc = [
+ _ExtCommsPacketListField(
+ "extended_communities",
+ [],
+ BGPPAExtCommunity
+ )
+ ]
+
+
+class MPReachNLRIPacketListField(PacketListField):
+ """
+ PacketListField handling the AFI specific part (except for the length of
+ Next Hop Network Address field, which is not AFI specific) of the
+ MP_REACH_NLRI attribute.
+ """
+
+ def getfield(self, pkt, s):
+ lst = []
+ remain = s
+
+ # IPv6
+ if pkt.afi == 2:
+ if pkt.safi == 1:
+ # BGPNLRI_IPv6
+ while remain:
+ mask = struct.unpack(">B", remain[0])[0]
+ length_in_bytes = (mask + 7) // 8
+ current = remain[:length_in_bytes + 1]
+ remain = remain[length_in_bytes + 1:]
+ prefix = BGPNLRI_IPv6(current)
+ lst.append(prefix)
+
+ return remain, lst
+
+
+class BGPPAMPReachNLRI(Packet):
+ """
+ Packet handling the MP_REACH_NLRI attribute value, for non IPv6
+ AFI.
+ References: RFC 4760
+ """
+
+ name = "MP_REACH_NLRI"
+ fields_desc = [
+ ShortEnumField("afi", 0, address_family_identifiers),
+ ByteEnumField("safi", 0, subsequent_afis),
+ ByteField("nh_addr_len", 0),
+ ConditionalField(IPField("nh_v4_addr", "0.0.0.0"),
+ lambda x: x.afi == 1 and x.nh_addr_len == 4),
+ ConditionalField(IP6Field("nh_v6_addr", "::"),
+ lambda x: x.afi == 2 and x.nh_addr_len == 16),
+ ConditionalField(IP6Field("nh_v6_global", "::"),
+ lambda x: x.afi == 2 and x.nh_addr_len == 32),
+ ConditionalField(IP6Field("nh_v6_link_local", "::"),
+ lambda x: x.afi == 2 and x.nh_addr_len == 32),
+ ByteField("reserved", 0),
+ MPReachNLRIPacketListField("nlri", [], Packet)]
+
+ def post_build(self, p, pay):
+ if self.nlri is None:
+ p = p[:3]
+
+ return p + pay
+
+
+#
+# MP_UNREACH_NLRI
+#
+
+class BGPPAMPUnreachNLRI_IPv6(Packet):
+ """
+ Packet handling the MP_UNREACH_NLRI attribute value, for IPv6 AFI.
+ """
+
+ name = "MP_UNREACH_NLRI (IPv6 NLRI)"
+ fields_desc = [BGPNLRIPacketListField(
+ "withdrawn_routes", [], BGPNLRI_IPv6)]
+
+
+class MPUnreachNLRIPacketField(PacketField):
+ """
+ PacketField handling the AFI specific part of the MP_UNREACH_NLRI
+ attribute.
+ """
+
+ def m2i(self, pkt, m):
+ ret = None
+
+ if pkt.afi == 2:
+ ret = BGPPAMPUnreachNLRI_IPv6(m)
+ else:
+ ret = conf.raw_layer(m)
+
+ return ret
+
+
+class BGPPAMPUnreachNLRI(Packet):
+ """
+ Packet handling the MP_UNREACH_NLRI attribute value, for non IPv6
+ AFI.
+ References: RFC 4760
+ """
+
+ name = "MP_UNREACH_NLRI"
+ fields_desc = [ShortEnumField("afi", 0, address_family_identifiers),
+ ByteEnumField("safi", 0, subsequent_afis),
+ MPUnreachNLRIPacketField("afi_safi_specific", None, Packet)]
+
+ def post_build(self, p, pay):
+ if self.afi_safi_specific is None:
+ p = p[:3]
+
+ return p + pay
+
+
+#
+# AS4_PATH
+#
+
+class BGPPAAS4Path(Packet):
+ """
+ Provides an implementation of the AS4_PATH attribute "value part".
+ References: RFC 4893
+ """
+
+ name = "AS4_PATH"
+ fields_desc = [
+ ByteEnumField(
+ "segment_type",
+ 2,
+ {1: "AS_SET", 2: "AS_SEQUENCE"}
+ ),
+ ByteField("segment_length", None),
+ FieldListField("segment_value", [], IntField("asn", 0))
+ ]
+
+ def post_build(self, p, pay):
+ if self.segment_length is None:
+ segment_len = len(self.segment_value)
+ p = p[0] + struct.pack("!B", segment_len) + p[2:]
+
+ return p + pay
+
+
+#
+# AS4_AGGREGATOR
+#
+
+class BGPPAAS4Aggregator(Packet):
+ """
+ Provides an implementation of the AS4_AGGREGATOR attribute
+ "value part".
+ References: RFC 4893
+ """
+
+ name = "AS4_AGGREGATOR "
+ fields_desc = [IntField("aggregator_asn", 0),
+ IPField("speaker_address", "0.0.0.0")]
+
+
+_path_attr_objects = {
+ 0x01: "BGPPAOrigin",
+ 0x02: "BGPPAASPath", # if bgp_module_conf.use_2_bytes_asn, BGPPAAS4BytesPath otherwise
+ 0x03: "BGPPANextHop",
+ 0x04: "BGPPAMultiExitDisc",
+ 0x05: "BGPPALocalPref",
+ 0x06: "BGPPAAtomicAggregate",
+ 0x07: "BGPPAAggregator",
+ 0x08: "BGPPACommunity",
+ 0x09: "BGPPAOriginatorID",
+ 0x0A: "BGPPAClusterList",
+ 0x0E: "BGPPAMPReachNLRI",
+ 0x0F: "BGPPAMPUnreachNLRI",
+ 0x10: "BGPPAExtComms",
+ 0x11: "BGPPAAS4Path",
+ 0x19: "BGPPAIPv6AddressSpecificExtComm"
+}
+
+
+class _PathAttrPacketField(PacketField):
+ """
+ PacketField handling path attribute value parts.
+ """
+
+ def m2i(self, pkt, m):
+ ret = None
+ type_code = pkt.type_code
+
+ # Reserved
+ if type_code == 0 or type_code == 255:
+ ret = conf.raw_layer(m)
+ # Unassigned
+ elif (type_code >= 30 and type_code <= 39) or\
+ (type_code >= 41 and type_code <= 127) or\
+ (type_code >= 129 and type_code <= 254):
+ ret = conf.raw_layer(m)
+ # Known path attributes
+ else:
+ if type_code == 0x02 and not bgp_module_conf.use_2_bytes_asn:
+ ret = BGPPAAS4BytesPath(m)
+ else:
+ ret = _get_cls(
+ _path_attr_objects.get(type_code, conf.raw_layer))(m)
+
+ return ret
+
+
+class BGPPathAttr(Packet):
+ """
+ Provides an implementation of the path attributes.
+ References: RFC 4271
+ """
+
+ name = "BGPPathAttr"
+ fields_desc = [
+ FlagsField("type_flags", 0x80, 8, [
+ "NA0",
+ "NA1",
+ "NA2",
+ "NA3",
+ "Extended-Length",
+ "Partial",
+ "Transitive",
+ "Optional"
+ ]),
+ ByteEnumField("type_code", 0, path_attributes),
+ ConditionalField(
+ ShortField("attr_ext_len", None),
+ lambda x: x.type_flags != None and\
+ has_extended_length(x.type_flags)
+ ),
+ ConditionalField(
+ ByteField("attr_len", None),
+ lambda x: x.type_flags != None and not\
+ has_extended_length(x.type_flags)
+ ),
+ _PathAttrPacketField("attribute", None, Packet)
+ ]
+
+ def post_build(self, p, pay):
+ flags_value = None
+ length = None
+ packet = None
+ extended_length = False
+
+ # Set default flags value ?
+ if self.type_flags is None:
+ # Set the standard value, if it is exists in attributes_flags.
+ if attributes_flags.has_key(self.type_code):
+ flags_value = attributes_flags.get(self.type_code)
+
+ # Otherwise, set to optional, non-transitive.
+ else:
+ flags_value = 0x80
+
+ extended_length = has_extended_length(flags_value)
+ else:
+ extended_length = has_extended_length(self.type_flags)
+
+ # Set the flags
+ if flags_value is None:
+ packet = p[:2]
+ else:
+ packet = struct.pack("!B", flags_value) + p[1]
+
+ # Add the length
+ if self.attr_len is None:
+ if self.attribute is None:
+ length = 0
+ else:
+ if extended_length:
+ length = len(p) - 4 # Flags + Type + Length (2 bytes)
+ else:
+ length = len(p) - 3 # Flags + Type + Length (1 byte)
+
+ if length is None:
+ if extended_length:
+ packet = packet + p[2:4]
+ else:
+ packet = packet + p[2]
+ else:
+ if extended_length:
+ packet = packet + struct.pack("!H", length)
+ else:
+ packet = packet + struct.pack("!B", length)
+
+ # Append the rest of the message
+ if extended_length:
+ if self.attribute != None:
+ packet = packet + p[4:]
+ else:
+ if self.attribute != None:
+ packet = packet + p[3:]
+
+ return packet + pay
+
+
+#
+# UPDATE
+#
+
+class BGPUpdate(BGP):
+ """
+ UPDATE messages allow peers to exchange routes.
+ References: RFC 4271
+ """
+
+ name = "UPDATE"
+ fields_desc = [
+ FieldLenField(
+ "withdrawn_routes_len",
+ None,
+ length_of="withdrawn_routes",
+ fmt="!H"
+ ),
+ BGPNLRIPacketListField(
+ "withdrawn_routes",
+ [],
+ BGPNLRI_IPv4,
+ length_from=lambda p: p.withdrawn_routes_len
+ ),
+ FieldLenField(
+ "path_attr_len",
+ None,
+ length_of="path_attr",
+ fmt="!H"
+ ),
+ BGPPathAttrPacketListField(
+ "path_attr",
+ [],
+ BGPPathAttr,
+ length_from=lambda p: p.path_attr_len
+ ),
+ BGPNLRIPacketListField("nlri", [], BGPNLRI_IPv4)
+ ]
+
+ def post_build(self, p, pay):
+ subpacklen = lambda p: len(p)
+ packet = ""
+ if self.withdrawn_routes_len is None:
+ wl = sum(map(subpacklen, self.withdrawn_routes))
+ packet = p[:0] + struct.pack("!H", wl) + p[2:]
+ if self.path_attr_len is None:
+ length = sum(map(subpacklen, self.path_attr))
+ packet = p[:2 + wl] + struct.pack("!H", length) + p[4 + wl:]
+
+ return packet + pay
+
+
+#
+# NOTIFICATION
+#
+
+#
+# RFC 4271, RFC 7313
+# http://www.iana.org/assignments/bgp-parameters/bgp-parameters.xhtml#bgp-parameters-3
+#
+_error_codes = {
+ 0x01: "Message Header Error",
+ 0x02: "OPEN Message Error",
+ 0x03: "UPDATE Message Error",
+ 0x04: "Hold Timer Expired",
+ 0x05: "Finite State Machine Error",
+ 0x06: "Cease",
+ 0x07: "ROUTE-REFRESH Message Error", # RFC 7313
+}
+
+#
+# http://www.iana.org/assignments/bgp-parameters/bgp-parameters.xhtml#bgp-parameters-4
+#
+_error_subcodes = {
+ # Reserved
+ 0: {},
+
+ # Header (RFC 4271)
+ 1:
+ {
+ 0: "Unspecific",
+ 1: "Connection Not Synchronized",
+ 2: "Bad Message Length",
+ 3: "Bad Message Type"
+ },
+
+ # OPEN (RFC 4271, RFC 5492)
+ 2:
+ {
+ 0: "Reserved",
+ 1: "Unsupported Version Number",
+ 2: "Bad Peer AS",
+ 3: "Bad BGP Identifier",
+ 4: "Unsupported Optional Parameter",
+ 5: "Authentication Failure - Deprecated (RFC 4271)",
+ 6: "Unacceptable Hold Time",
+ 7: "Unsupported Capability"
+ },
+
+ # UPDATE (RFC 4271)
+ 3:
+ {
+ 0: "Reserved",
+ 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 - Deprecated (RFC 4271)",
+ 8: "Invalid NEXT_HOP Attribute",
+ 9: "Optional Attribute Error",
+ 10: "Invalid Network Field",
+ 11: "Malformed AS_PATH"
+ },
+
+ # Hold Timer Expired
+ 4: {},
+
+ # Finite State Machine Error (RFC 6608)
+ 5:
+ {
+ 0: "Unspecified Error",
+ 1: "Receive Unexpected Message in OpenSent State",
+ 2: "Receive Unexpected Message in OpenConfirm State",
+ 3: "Receive Unexpected Message in Established State"
+ },
+
+ # Cease (RFC 4486)
+ 6:
+ {
+ 0: "Unspecified Error",
+ 1: "Maximum Number of Prefixes Reached",
+ 2: "Administrative Shutdown",
+ 3: "Peer De-configured",
+ 4: "Administrative Reset",
+ 5: "Connection Rejected",
+ 6: "Other Configuration Change",
+ 7: "Connection Collision Resolution",
+ 8: "Out of Resources",
+ },
+
+ # ROUTE-REFRESH (RFC 7313)
+ 7:
+ {
+ 0: "Reserved",
+ 1: "Invalid Message Length"
+ },
+}
+
+
+class BGPNotification(BGP):
+ """
+ NOTIFICATION messages end a BGP session.
+ References: RFC 4271
+ """
+
+ name = "NOTIFICATION"
+ fields_desc = [
+ ByteEnumField("error_code", 0, _error_codes),
+ MultiEnumField(
+ "error_subcode",
+ 0,
+ _error_subcodes,
+ depends_on=lambda p: p.error_code,
+ fmt="B"
+ ),
+ StrField(name="data", default=None)
+ ]
+
+
+#
+# ROUTE_REFRESH
+#
+
+_orf_when_to_refresh = {
+ 0x01: "IMMEDIATE",
+ 0x02: "DEFER"
+}
+
+
+_orf_actions = {
+ 0: "ADD",
+ 1: "REMOVE",
+ 2: "REMOVE-ALL"
+}
+
+
+_orf_match = {
+ 0: "PERMIT",
+ 1: "DENY"
+}
+
+
+_orf_entry_afi = 1
+_orf_entry_safi = 1
+
+
+def _update_orf_afi_safi(afi, safi):
+ """
+ Helper function that sets the afi / safi values
+ of ORP entries.
+ """
+
+ global _orf_entry_afi
+ global _orf_entry_safi
+
+ _orf_entry_afi = afi
+ _orf_entry_safi = safi
+
+
+class BGPORFEntry(Packet):
+ """
+ Provides an implementation of an ORF entry.
+ References: RFC 5291
+ """
+
+ name = "ORF entry"
+ fields_desc = [
+ BitEnumField("action", 0, 2, _orf_actions),
+ BitEnumField("match", 0, 1, _orf_match),
+ BitField("reserved", 0, 5),
+ StrField("value", "")
+ ]
+
+
+class _ORFNLRIPacketField(PacketField):
+ """
+ PacketField handling the ORF NLRI.
+ """
+
+ def m2i(self, pkt, m):
+ ret = None
+
+ if _orf_entry_afi == 1:
+ # IPv4
+ ret = BGPNLRI_IPv4(m)
+
+ elif _orf_entry_afi == 2:
+ # IPv6
+ ret = BGPNLRI_IPv6(m)
+
+ else:
+ ret = conf.raw_layer(m)
+
+ return ret
+
+
+class BGPORFAddressPrefix(BGPORFEntry):
+ """
+ Provides an implementation of the Address Prefix ORF (RFC 5292).
+ """
+
+ name = "Address Prefix ORF"
+ fields_desc = [
+ BitEnumField("action", 0, 2, _orf_actions),
+ BitEnumField("match", 0, 1, _orf_match),
+ BitField("reserved", 0, 5),
+ IntField("sequence", 0),
+ ByteField("min_len", 0),
+ ByteField("max_len", 0),
+ _ORFNLRIPacketField("prefix", "", Packet),
+ ]
+
+
+class BGPORFCoveringPrefix(Packet):
+ """
+ Provides an implementation of the CP-ORF (RFC 7543).
+ """
+
+ name = "CP-ORF"
+ fields_desc = [
+ BitEnumField("action", 0, 2, _orf_actions),
+ BitEnumField("match", 0, 1, _orf_match),
+ BitField("reserved", 0, 5),
+ IntField("sequence", 0),
+ ByteField("min_len", 0),
+ ByteField("max_len", 0),
+ LongField("rt", 0),
+ LongField("import_rt", 0),
+ ByteField("route_type", 0),
+ PacketField("host_addr", None, Packet)
+ ]
+
+
+class BGPORFEntryPacketListField(PacketListField):
+ """
+ PacketListField handling the ORF entries.
+ """
+
+ def m2i(self, pkt, m):
+ ret = None
+
+ # Cisco also uses 128
+ if pkt.orf_type == 64 or pkt.orf_type == 128:
+ ret = BGPORFAddressPrefix(m)
+
+ elif pkt.orf_type == 65:
+ ret = BGPORFCoveringPrefix(m)
+
+ else:
+ ret = conf.raw_layer(m)
+
+ return ret
+
+ def getfield(self, pkt, s):
+ lst = []
+ length = 0
+ if self.length_from is not None:
+ length = self.length_from(pkt)
+ remain = s
+ if length is not None:
+ remain, ret = s[:length], s[length:]
+
+ while remain:
+ orf_len = 0
+
+ # Get value length, depending on the ORF type
+ if pkt.orf_type == 64 or pkt.orf_type == 128:
+ # Address Prefix ORF
+ # Get the length, in bits, of the prefix
+ prefix_len = _bits_to_bytes_len(
+ struct.unpack("!B", remain[6])[0]
+ )
+ # flags (1 byte) + sequence (4 bytes) + min_len (1 byte) +
+ # max_len (1 byte) + mask_len (1 byte) + prefix_len
+ orf_len = 8 + prefix_len
+
+ elif pkt.orf_type == 65:
+ # Covering Prefix ORF
+
+ if _orf_entry_afi == 1:
+ # IPv4
+ # sequence (4 bytes) + min_len (1 byte) + max_len (1 byte) +
+ # rt (8 bytes) + import_rt (8 bytes) + route_type (1 byte)
+ orf_len = 23 + 4
+
+ elif _orf_entry_afi == 2:
+ # IPv6
+ # sequence (4 bytes) + min_len (1 byte) + max_len (1 byte) +
+ # rt (8 bytes) + import_rt (8 bytes) + route_type (1 byte)
+ orf_len = 23 + 16
+
+ elif _orf_entry_afi == 25:
+ # sequence (4 bytes) + min_len (1 byte) + max_len (1 byte) +
+ # rt (8 bytes) + import_rt (8 bytes)
+ route_type = struct.unpack("!B", remain[22])[0]
+
+ if route_type == 2:
+ # MAC / IP Advertisement Route
+ orf_len = 23 + 6
+
+ else:
+ orf_len = 23
+
+ current = remain[:orf_len]
+ remain = remain[orf_len:]
+ packet = self.m2i(pkt, current)
+ lst.append(packet)
+
+ return remain + ret, lst
+
+
+class BGPORF(Packet):
+ """
+ Provides an implementation of ORFs carried in the RR message.
+ References: RFC 5291
+ """
+
+ name = "ORF"
+ fields_desc = [
+ ByteEnumField("when_to_refresh", 0, _orf_when_to_refresh),
+ ByteEnumField("orf_type", 0, _orf_types),
+ FieldLenField("orf_len", None, length_of="entries", fmt="!H"),
+ BGPORFEntryPacketListField(
+ "entries",
+ [],
+ Packet,
+ length_from=lambda p: p.orf_len,
+ )
+ ]
+
+
+# RFC 7313
+# http://www.iana.org/assignments/bgp-parameters/bgp-parameters.xhtml#route-refresh-subcodes
+rr_message_subtypes = {
+ 0: "Route-Refresh",
+ 1: "BoRR",
+ 2: "EoRR",
+ 255: "Reserved"
+}
+
+
+class BGPRouteRefresh(BGP):
+ """
+ Provides an implementation of the ROUTE-REFRESH message.
+ References: RFC 2918, RFC 7313
+ """
+
+ name = "ROUTE-REFRESH"
+ fields_desc = [
+ ShortEnumField("afi", 1, address_family_identifiers),
+ ByteEnumField("subtype", 0, rr_message_subtypes),
+ ByteEnumField("safi", 1, subsequent_afis),
+ PacketField(
+ 'orf_data',
+ "", BGPORF,
+ lambda p: _update_orf_afi_safi(p.afi, p.safi)
+ )
+ ]
+
+
+#
+# Layer bindings
+#
+
+bind_layers(TCP, BGP, dport=179)
+bind_layers(TCP, BGP, sport=179)
+bind_layers(BGPHeader, BGPOpen, {"type": 1})
+bind_layers(BGPHeader, BGPUpdate, {"type": 2})
+bind_layers(BGPHeader, BGPNotification, {"type": 3})
+bind_layers(BGPHeader, BGPKeepAlive, {"type": 4})
+bind_layers(BGPHeader, BGPRouteRefresh, {"type": 5})
+
+# When loading the module, display the current module configuration.
+log_runtime.warning(
+ "[bgp.py] use_2_bytes_asn: %s", bgp_module_conf.use_2_bytes_asn)
diff --git a/scapy/contrib/bgp.uts b/scapy/contrib/bgp.uts
new file mode 100644
index 0000000000000000000000000000000000000000..489cdd7a21008aa5917be270dacc0cffd86b870b
--- /dev/null
+++ b/scapy/contrib/bgp.uts
@@ -0,0 +1,669 @@
+#################################### bgp.py ##################################
+% Regression tests for the bgp module
+
+# Default configuration : OLD speaker (see RFC 6793)
+bgp_module_conf.use_2_bytes_asn = True
+
+################################ BGPNLRI_IPv4 ################################
++ BGPNLRI_IPv4 class tests
+
+= BGPNLRI_IPv4 - Instantiation
+str(BGPNLRI_IPv4()) == '\x00'
+
+= BGPNLRI_IPv4 - Instantiation with specific values (1)
+str(BGPNLRI_IPv4(prefix = '255.255.255.255/32')) == ' \xff\xff\xff\xff'
+
+= BGPNLRI_IPv4 - Instantiation with specific values (2)
+str(BGPNLRI_IPv4(prefix = '0.0.0.0/0')) == '\x00'
+
+= BGPNLRI_IPv4 - Instantiation with specific values (3)
+str(BGPNLRI_IPv4(prefix = '192.0.2.0/24')) == '\x18\xc0\x00\x02'
+
+= BGPNLRI_IPv4 - Basic dissection
+nlri = BGPNLRI_IPv4('\x00')
+nlri.prefix == '0.0.0.0/0'
+
+= BGPNLRI_IPv4 - Dissection with specific values
+nlri = BGPNLRI_IPv4('\x18\xc0\x00\x02')
+nlri.prefix == '192.0.2.0/24'
+
+
+################################ BGPNLRI_IPv6 ################################
++ BGPNLRI_IPv6 class tests
+
+= BGPNLRI_IPv6 - Instantiation
+str(BGPNLRI_IPv6()) == '\x00'
+
+= BGPNLRI_IPv6 - Instantiation with specific values (1)
+str(BGPNLRI_IPv6(prefix = '::/0')) == '\x00'
+
+= BGPNLRI_IPv6 - Instantiation with specific values (2)
+str(BGPNLRI_IPv6(prefix = '2001:db8::/32')) == ' \x01\r\xb8'
+
+= BGPNLRI_IPv6 - Basic dissection
+nlri = BGPNLRI_IPv6('\x00')
+nlri.prefix == '::/0'
+
+= BGPNLRI_IPv6 - Dissection with specific values
+nlri = BGPNLRI_IPv6(' \x01\r\xb8')
+nlri.prefix == '2001:db8::/32'
+
+
+#################################### BGP #####################################
++ BGP class tests
+
+= BGP - Instantiation (Should be a KEEPALIVE)
+m = BGP()
+assert(str(m) == '\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x13\x04')
+assert(m.type == BGP.KEEPALIVE_TYPE)
+
+= BGP - Instantiation with specific values (1)
+str(BGP(type = 0)) == '\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x13\x00'
+
+= BGP - Instantiation with specific values (2)
+str(BGP(type = 1)) == '\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x13\x01'
+
+= BGP - Instantiation with specific values (3)
+str(BGP(type = 2)) == '\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x13\x02'
+
+= BGP - Instantiation with specific values (4)
+str(BGP(type = 3)) == '\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x13\x03'
+
+= BGP - Instantiation with specific values (5)
+str(BGP(type = 4)) == '\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x13\x04'
+
+= BGP - Instantiation with specific values (6)
+str(BGP(type = 5)) == '\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x13\x05'
+
+= BGP - Basic dissection
+h = BGP('\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x13\x04')
+assert(h.type == BGP.KEEPALIVE_TYPE)
+assert(h.len == 19)
+
+= BGP - Dissection with specific values
+h = BGP('\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x13\x01')
+assert(h.type == BGP.OPEN_TYPE)
+assert(h.len == 19)
+
+
+############################### BGPCapability #################################
++ BGPCapability class tests
+
+= BGPCapability - Instantiation (by default, should be a "generic" capability)
+str(BGPCapability())
+str(BGPCapability()) == '\x00\x00'
+
+= BGPCapability - Instantiation with specific values (1)
+c = BGPCapability(code = 70)
+assert(str(c) == 'F\x00')
+
+
+############################ BGPCapMultiprotocol ##############################
++ BGPCapMultiprotocol class tests
+
+= BGPCapMultiprotocol - Inheritance
+c = BGPCapMultiprotocol()
+assert(isinstance(c, BGPCapability))
+
+= BGPCapMultiprotocol - Instantiation
+str(BGPCapMultiprotocol()) == '\x01\x04\x00\x00\x00\x00'
+
+= BGPCapMultiprotocol - Instantiation with specific values (1)
+str(BGPCapMultiprotocol(afi = 1, safi = 1)) == '\x01\x04\x00\x01\x00\x01'
+
+= BGPCapMultiprotocol - Instantiation with specific values (2)
+str(BGPCapMultiprotocol(afi = 2, safi = 1)) == '\x01\x04\x00\x02\x00\x01'
+
+= BGPCapMultiprotocol - Dissection with specific values
+c = BGPCapMultiprotocol('\x01\x04\x00\x02\x00\x01')
+assert(c.code == 1)
+assert(c.length == 4)
+assert(c.afi == 2)
+assert(c.reserved == 0)
+assert(c.safi == 1)
+
+############################### BGPCapORFBlock ###############################
++ BGPCapORFBlock class tests
+
+= BGPCapORFBlock - Instantiation
+str(BGPCapORFBlock()) == '\x00\x00\x00\x00\x00'
+
+= BGPCapORFBlock - Instantiation with specific values (1)
+str(BGPCapORFBlock(afi = 1, safi = 1)) == '\x00\x01\x00\x01\x00'
+
+= BGPCapORFBlock - Instantiation with specific values (2)
+str(BGPCapORFBlock(afi = 2, safi = 1)) == '\x00\x02\x00\x01\x00'
+
+= BGPCapORFBlock - Basic dissection
+c = BGPCapORFBlock('\x00\x00\x00\x00\x00')
+c.afi == 0 and c.reserved == 0 and c.safi == 0 and c.orf_number == 0
+
+= BGPCapORFBlock - Dissection with specific values
+c = BGPCapORFBlock('\x00\x02\x00\x01\x00')
+c.afi == 2 and c.reserved == 0 and c.safi == 1 and c.orf_number == 0
+
+
+############################# BGPCapORFBlock.ORF ##############################
++ BGPCapORFBlock.ORF class tests
+
+= BGPCapORFBlock.ORF - Instantiation
+str(BGPCapORFBlock.ORFTuple()) == '\x00\x00'
+
+= BGPCapORFBlock.ORF - Instantiation with specific values (1)
+str(BGPCapORFBlock.ORFTuple(orf_type = 64, send_receive = 3)) == '@\x03'
+
+= BGPCapORFBlock.ORF - Basic dissection
+c = BGPCapORFBlock.ORFTuple('\x00\x00')
+c.orf_type == 0 and c.send_receive == 0
+
+= BGPCapORFBlock.ORF - Dissection with specific values
+c = BGPCapORFBlock.ORFTuple('@\x03')
+c.orf_type == 64 and c.send_receive == 3
+
+
+################################# BGPCapORF ###################################
++ BGPCapORF class tests
+
+= BGPCapORF - Inheritance
+c = BGPCapORF()
+assert(isinstance(c, BGPCapability))
+
+= BGPCapORF - Instantiation
+str(BGPCapORF()) == '\x03\x00'
+
+= BGPCapORF - Instantiation with specific values (1)
+str(BGPCapORF(orf = [BGPCapORFBlock(afi = 1, safi = 1, entries = [BGPCapORFBlock.ORFTuple(orf_type = 64, send_receive = 3)])])) == '\x03\x07\x00\x01\x00\x01\x01@\x03'
+
+= BGPCapORF - Instantiation with specific values (2)
+str(BGPCapORF(orf = [BGPCapORFBlock(afi = 1, safi = 1, entries = [BGPCapORFBlock.ORFTuple(orf_type = 64, send_receive = 3)]), BGPCapORFBlock(afi = 2, safi = 1, entries = [BGPCapORFBlock.ORFTuple(orf_type = 64, send_receive = 3)])])) == '\x03\x0e\x00\x01\x00\x01\x01@\x03\x00\x02\x00\x01\x01@\x03'
+
+= BGPCapORF - Basic dissection
+c = BGPCapORF('\x03\x00')
+c.code == 3 and c.length == 0
+
+= BGPCapORF - Dissection with specific values
+c = BGPCapORF(orf = [BGPCapORFBlock(afi = 1, safi = 1, entries = [BGPCapORFBlock.ORFTuple(orf_type = 64, send_receive = 3)]), BGPCapORFBlock(afi = 2, safi = 1, entries = [BGPCapORFBlock.ORFTuple(orf_type = 64, send_receive = 3)])])
+c.code == 3 and c.orf[0].afi == 1 and c.orf[0].safi == 1 and c.orf[0].entries[0].orf_type == 64 and c.orf[0].entries[0].send_receive == 3 and c.orf[1].afi == 2 and c.orf[1].safi == 1 and c.orf[1].entries[0].orf_type == 64 and c.orf[1].entries[0].send_receive == 3
+
+
+####################### BGPCapGracefulRestart.GRTuple #########################
++ BGPCapGracefulRestart.GRTuple class tests
+
+= BGPCapGracefulRestart.GRTuple - Instantiation
+str(BGPCapGracefulRestart.GRTuple()) == '\x00\x00\x00\x00'
+
+= BGPCapGracefulRestart.GRTuple - Instantiation with specific values
+str(BGPCapGracefulRestart.GRTuple(afi = 1, safi = 1, flags = 128)) == '\x00\x01\x01\x80'
+
+= BGPCapGracefulRestart.GRTuple - Basic dissection
+c = BGPCapGracefulRestart.GRTuple('\x00\x00\x00\x00')
+c.afi == 0 and c.safi == 0 and c.flags == 0
+
+= BGPCapGracefulRestart.GRTuple - Dissection with specific values
+c = BGPCapGracefulRestart.GRTuple('\x00\x01\x01\x80')
+c.afi == 1 and c.safi == 1 and c.flags == 128
+
+
+########################### BGPCapGracefulRestart #############################
++ BGPCapGracefulRestart class tests
+
+= BGPCapGracefulRestart - Inheritance
+c = BGPCapGracefulRestart()
+assert(isinstance(c, BGPCapGracefulRestart))
+
+= BGPCapGracefulRestart - Instantiation
+str(BGPCapGracefulRestart()) == '@\x02\x00\x00'
+
+= BGPCapGracefulRestart - Instantiation with specific values (1)
+str(BGPCapGracefulRestart(restart_time = 120, entries = [BGPCapGracefulRestart.GRTuple(afi = 1, safi = 1)])) == '@\x06\x00x\x00\x01\x01\x00'
+
+= BGPCapGracefulRestart - Instantiation with specific values (2)
+str(BGPCapGracefulRestart(restart_time = 120, entries = [BGPCapGracefulRestart.GRTuple(afi = 1, safi = 1)])) == '@\x06\x00x\x00\x01\x01\x00'
+
+= BGPCapGracefulRestart - Instantiation with specific values (3)
+str(BGPCapGracefulRestart(restart_time = 120, entries = [BGPCapGracefulRestart.GRTuple(afi = 1, safi = 1, flags = 128)])) == '@\x06\x00x\x00\x01\x01\x80'
+
+= BGPCapGracefulRestart - Instantiation with specific values (4)
+str(BGPCapGracefulRestart(restart_time = 120, restart_flags = 0x8, entries = [BGPCapGracefulRestart.GRTuple(afi = 1, safi = 1, flags = 128)])) == '@\x06\x80x\x00\x01\x01\x80'
+
+= BGPCapGracefulRestart - Basic dissection
+c = BGPCapGracefulRestart('@\x02\x00\x00')
+c.code == 64 and c.restart_flags == 0 and c.restart_time == 0
+
+= BGPCapGracefulRestart - Dissection with specific values
+c = BGPCapGracefulRestart('@\x06\x80x\x00\x01\x01\x80')
+c.code == 64 and c.restart_time == 120 and c.restart_flags == 0x8 and c.entries[0].afi == 1 and c.entries[0].safi == 1 and c.entries[0].flags == 128
+
+
+############################ BGPCapFourBytesASN ###############################
++ BGPCapFourBytesASN class tests
+
+= BGPCapFourBytesASN - Inheritance
+c = BGPCapFourBytesASN()
+assert(isinstance(c, BGPCapFourBytesASN))
+
+= BGPCapFourBytesASN - Instantiation
+str(BGPCapFourBytesASN()) == 'A\x04\x00\x00\x00\x00'
+
+= BGPCapFourBytesASN - Instantiation with specific values (1)
+str(BGPCapFourBytesASN(asn = 6555555)) == 'A\x04\x00d\x07\xa3'
+
+= BGPCapFourBytesASN - Instantiation with specific values (2)
+str(BGPCapFourBytesASN(asn = 4294967295)) == 'A\x04\xff\xff\xff\xff'
+
+= BGPCapFourBytesASN - Basic dissection
+c = BGPCapFourBytesASN('A\x04\x00\x00\x00\x00')
+c.code == 65 and c.length == 4 and c.asn == 0
+
+= BGPCapFourBytesASN - Dissection with specific values
+c = BGPCapFourBytesASN('A\x04\xff\xff\xff\xff')
+c.code == 65 and c.length == 4 and c.asn == 4294967295
+
+
+####################### BGPAuthenticationInformation ##########################
++ BGPAuthenticationInformation class tests
+
+= BGPAuthenticationInformation - Instantiation
+str(BGPAuthenticationInformation()) == '\x00'
+
+= BGPAuthenticationInformation - Basic dissection
+c = BGPAuthenticationInformation('\x00')
+c.authentication_code == 0 and c.authentication_data == None
+
+
+################################# BGPOptParam #################################
++ BGPOptParam class tests
+
+= BGPOptParam - Instantiation
+str(BGPOptParam()) == '\x02\x00'
+
+= BGPOptParam - Instantiation with specific values (1)
+str(BGPOptParam(param_type = 1)) == '\x01\x00'
+str(BGPOptParam(param_type = 1, param_value = BGPAuthenticationInformation())) == '\x01\x04'
+
+= BGPOptParam - Instantiation with specific values (2)
+str(BGPOptParam(param_type = 2)) == '\x02\x00'
+
+= BGPOptParam - Instantiation with specific values (3)
+str(BGPOptParam(param_type = 2, param_value = BGPCapFourBytesASN(asn = 4294967295))) == '\x02\x06A\x04\xff\xff\xff\xff'
+
+= BGPOptParam - Instantiation with specific values (4)
+str(BGPOptParam(param_type = 2, param_value = BGPCapability(code = 127))) == '\x02\x02\x7f\x00'
+
+= BGPOptParam - Instantiation with specific values (5)
+str(BGPOptParam(param_type = 2, param_value = BGPCapability(code = 255))) == '\x02\x02\xff\x00'
+
+= BGPOptParam - Basic dissection
+p = BGPOptParam('\x02\x00')
+p.param_type == 2 and p.param_length == 0
+
+= BGPOptParam - Dissection with specific values
+p = BGPOptParam('\x02\x06A\x04\xff\xff\xff\xff')
+p.param_type == 2 and p.param_length == 6 and p.param_value[0].code == 65 and p.param_value[0].length == 4 and p.param_value[0].asn == 4294967295
+
+
+################################### BGPOpen ###################################
++ BGPOpen class tests
+
+= BGPOpen - Instantiation
+str(BGPOpen()) == '\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+
+= BGPOpen - Instantiation with specific values (1)
+str(BGPOpen(my_as = 64501, bgp_id = "192.0.2.1")) == '\x04\xfb\xf5\x00\x00\xc0\x00\x02\x01\x00'
+
+= BGPOpen - Instantiation with specific values (2)
+opt = BGPOptParam(param_value = BGPCapMultiprotocol(afi = 1, safi = 1))
+str(BGPOpen(my_as = 64501, bgp_id = "192.0.2.1", opt_params = [opt])) == '\x04\xfb\xf5\x00\x00\xc0\x00\x02\x01\x08\x02\x06\x01\x04\x00\x01\x00\x01'
+
+= BGPOpen - Instantiation with specific values (3)
+cap = BGPOptParam(param_value = BGPCapMultiprotocol(afi = 1, safi = 1))
+capabilities = [cap]
+cap = BGPOptParam(param_value = BGPCapability(code = 128))
+capabilities.append(cap)
+cap = BGPOptParam(param_value = BGPCapability(code = 2))
+capabilities.append(cap)
+cap = BGPOptParam(param_value = BGPCapGracefulRestart(restart_time = 120, entries = [BGPCapGracefulRestart.GRTuple(afi = 1, safi= 1, flags = 128)]))
+capabilities.append(cap)
+cap = BGPOptParam(param_value = BGPCapFourBytesASN(asn = 64503))
+capabilities.append(cap)
+str(BGPOpen(my_as = 64503, bgp_id = "192.168.100.3", hold_time = 30, opt_params = capabilities)) == '\x04\xfb\xf7\x00\x1e\xc0\xa8d\x03"\x02\x06\x01\x04\x00\x01\x00\x01\x02\x02\x80\x00\x02\x02\x02\x00\x02\x08@\x06\x00x\x00\x01\x01\x80\x02\x06A\x04\x00\x00\xfb\xf7'
+
+= BGPOpen - Dissection with specific values (1)
+m = BGP('\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00?\x01\x04\xfb\xf7\x00\x1e\xc0\xa8d\x03"\x02\x06\x01\x04\x00\x01\x00\x01\x02\x02\x80\x00\x02\x02\x02\x00\x02\x08@\x06\x00x\x00\x01\x01\x80\x02\x06A\x04\x00\x00\xfb\xf7')
+assert(BGPHeader in m and BGPOpen in m)
+assert(m.len == 63)
+assert(m.type == BGP.OPEN_TYPE)
+assert(m.version == 4)
+assert(m.my_as == 64503)
+assert(m.hold_time == 30)
+assert(m.bgp_id == "192.168.100.3")
+assert(m.opt_param_len == 34)
+assert(isinstance(m.opt_params[0].param_value, BGPCapMultiprotocol))
+assert(isinstance(m.opt_params[1].param_value, BGPCapability))
+assert(isinstance(m.opt_params[2].param_value, BGPCapability))
+assert(isinstance(m.opt_params[3].param_value, BGPCapGracefulRestart))
+
+= BGPOpen - Dissection with specific values (2) (followed by a KEEPALIVE)
+messages = '\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00=\x01\x04\xfb\xf6\x00\xb4\xc0\xa8ze \x02\x06\x01\x04\x00\x01\x00\x01\x02\x06\x01\x04\x00\x02\x00\x01\x02\x02\x80\x00\x02\x02\x02\x00\x02\x06A\x04\x00\x00\xfb\xf6\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x13\x04'
+m = BGP(messages)
+str(m) == '\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00=\x01\x04\xfb\xf6\x00\xb4\xc0\xa8ze \x02\x06\x01\x04\x00\x01\x00\x01\x02\x06\x01\x04\x00\x02\x00\x01\x02\x02\x80\x00\x02\x02\x02\x00\x02\x06A\x04\x00\x00\xfb\xf6\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x13\x04'
+
+= BGPOpen - Dissection with specific values (3)
+m = BGP('\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x8f\x01\x04\xfd\xe8\x00\xb4\n\xff\xff\x01r\x02\x06\x01\x04\x00\x01\x00\x84\x02\x06\x01\x04\x00\x19\x00A\x02\x06\x01\x04\x00\x02\x00\x02\x02\x06\x01\x04\x00\x01\x00\x02\x02\x06\x01\x04\x00\x02\x00\x80\x02\x06\x01\x04\x00\x01\x00\x80\x02\x06\x01\x04\x00\x01\x00B\x02\x06\x01\x04\x00\x02\x00\x01\x02\x06\x01\x04\x00\x02\x00\x04\x02\x06\x01\x04\x00\x01\x00\x01\x02\x06\x01\x04\x00\x01\x00\x04\x02\x02\x80\x00\x02\x02\x02\x00\x02\x04@\x02\x80x\x02\x02F\x00\x02\x06A\x04\x00\x00\xfd\xe8')
+assert(BGPHeader in m and BGPOpen in m)
+
+= BGPOpen - Dissection with specific values (4)
+m = BGP('\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x8f\x01\x04\xfd\xe8\x00\xb4\n\xff\xff\x02r\x02\x06\x01\x04\x00\x01\x00\x84\x02\x06\x01\x04\x00\x19\x00A\x02\x06\x01\x04\x00\x02\x00\x02\x02\x06\x01\x04\x00\x01\x00\x02\x02\x06\x01\x04\x00\x02\x00\x80\x02\x06\x01\x04\x00\x01\x00\x80\x02\x06\x01\x04\x00\x01\x00B\x02\x06\x01\x04\x00\x02\x00\x01\x02\x06\x01\x04\x00\x02\x00\x04\x02\x06\x01\x04\x00\x01\x00\x01\x02\x06\x01\x04\x00\x01\x00\x04\x02\x02\x80\x00\x02\x02\x02\x00\x02\x04@\x02\x00x\x02\x02F\x00\x02\x06A\x04\x00\x00\xfd\xe8')
+assert(BGPHeader in m and BGPOpen in m)
+
+
+################################# BGPPAOrigin #################################
++ BGPPAOrigin class tests
+
+= BGPPAOrigin - Instantiation
+str(BGPPAOrigin()) == '\x00'
+
+= BGPPAOrigin - Instantiation with specific values
+str(BGPPAOrigin(origin = 1)) == '\x01'
+
+= BGPPAOrigin - Dissection
+a = BGPPAOrigin('\x00')
+a.origin == 0
+
+
+################################ BGPPAASPath ##################################
++ BGPPAASPath class tests
+
+= BGPPAASPath - Instantiation
+str(BGPPAASPath()) == ''
+
+= BGPPAASPath - Instantiation with specific values (1)
+str(BGPPAASPath(segments = [BGPPAASPath.ASPathSegment(segment_type = 2, segment_value = [64496, 64497, 64498])])) == '\x02\x03\xfb\xf0\xfb\xf1\xfb\xf2'
+
+= BGPPAASPath - Instantiation with specific values (2)
+str(BGPPAASPath(segments = [BGPPAASPath.ASPathSegment(segment_type = 1, segment_value = [64496, 64497, 64498])])) == '\x01\x03\xfb\xf0\xfb\xf1\xfb\xf2'
+
+= BGPPAASPath - Instantiation with specific values (3)
+str(BGPPAASPath(segments = [BGPPAASPath.ASPathSegment(segment_type = 1, segment_value = [64496, 64497, 64498]), BGPPAASPath.ASPathSegment(segment_type = 2, segment_value = [64500, 64501, 64502, 64502, 64503])])) == '\x01\x03\xfb\xf0\xfb\xf1\xfb\xf2\x02\x05\xfb\xf4\xfb\xf5\xfb\xf6\xfb\xf6\xfb\xf7'
+
+= BGPPAASPath - Dissection (1)
+a = BGPPAASPath('\x02\x03\xfb\xf0\xfb\xf1\xfb\xf2')
+a.segments[0].segment_type == 2 and a.segments[0].segment_length == 3 and a.segments[0].segment_value == [64496, 64497, 64498]
+
+= BGPPAASPath - Dissection (2)
+a = BGPPAASPath('\x01\x03\xfb\xf0\xfb\xf1\xfb\xf2\x02\x05\xfb\xf4\xfb\xf5\xfb\xf6\xfb\xf6\xfb\xf7')
+a.segments[0].segment_type == 1 and a.segments[0].segment_length == 3 and a.segments[0].segment_value == [64496, 64497, 64498] and a.segments[1].segment_type == 2 and a.segments[1].segment_length == 5 and a.segments[1].segment_value == [64500, 64501, 64502, 64502, 64503]
+
+
+############################### BGPPANextHop ##################################
++ BGPPANextHop class tests
+
+= BGPPANextHop - Instantiation
+str(BGPPANextHop()) == '\x00\x00\x00\x00'
+
+= BGPPANextHop - Instantiation with specific values
+str(BGPPANextHop(next_hop = "192.0.2.1")) == '\xc0\x00\x02\x01'
+
+= BGPPANextHop - Basic dissection
+a = BGPPANextHop('\x00\x00\x00\x00')
+a.next_hop == "0.0.0.0"
+
+= BGPPANextHop - Dissection with specific values
+a = BGPPANextHop('\xc0\x00\x02\x01')
+a.next_hop == '192.0.2.1'
+
+
+############################ BGPPAMultiExitDisc ##############################
++ BGPPAMultiExitDisc class tests
+
+= BGPPAMultiExitDisc - Instantiation
+str(BGPPAMultiExitDisc()) == '\x00\x00\x00\x00'
+
+= BGPPAMultiExitDisc - Instantiation with specific values (1)
+str(BGPPAMultiExitDisc(med = 4)) == '\x00\x00\x00\x04'
+
+= BGPPAMultiExitDisc - Basic dissection
+a = BGPPAMultiExitDisc('\x00\x00\x00\x00')
+a.med == 0
+
+
+############################## BGPPALocalPref ################################
++ BGPPALocalPref class tests
+
+= BGPPALocalPref - Instantiation
+str(BGPPALocalPref()) == '\x00\x00\x00\x00'
+
+= BGPPALocalPref - Instantiation with specific values (1)
+str(BGPPALocalPref(local_pref = 110)) == '\x00\x00\x00n'
+
+= BGPPALocalPref - Basic dissection
+a = BGPPALocalPref('\x00\x00\x00n')
+a.local_pref == 110
+
+
+############################## BGPPAAggregator ###############################
++ BGPPAAggregator class tests
+
+= BGPPAAggregator - Instantiation
+str(BGPPAAggregator()) == '\x00\x00\x00\x00\x00\x00'
+
+= BGPPAAggregator - Instantiation with specific values (1)
+str(BGPPAAggregator(aggregator_asn = 64500, speaker_address = "192.0.2.1")) == '\xfb\xf4\xc0\x00\x02\x01'
+
+= BGPPAAggregator - Dissection
+a = BGPPAAggregator('\xfb\xf4\xc0\x00\x02\x01')
+a.aggregator_asn == 64500 and a.speaker_address == "192.0.2.1"
+
+
+############################## BGPPACommunity ################################
++ BGPPACommunity class tests
+
+= BGPPACommunity - Basic instantiation
+str(BGPPACommunity()) == '\x00\x00\x00\x00'
+
+= BGPPACommunity - Instantiation with specific value
+str(BGPPACommunity(community = 0xFFFFFF01)) == '\xff\xff\xff\x01'
+
+= BGPPACommunity - Dissection
+a = BGPPACommunity('\xff\xff\xff\x01')
+a.community == 0xFFFFFF01
+
+
+############################ BGPPAOriginatorID ###############################
++ BGPPAOriginatorID class tests
+
+= BGPPAOriginatorID - Basic instantiation
+str(BGPPAOriginatorID()) == '\x00\x00\x00\x00'
+
+= BGPPAOriginatorID - Instantiation with specific value
+str(BGPPAOriginatorID(originator_id = '192.0.2.1')) == '\xc0\x00\x02\x01'
+
+= BGPPAOriginatorID - Dissection
+a = BGPPAOriginatorID('\xc0\x00\x02\x01')
+a.originator_id == "192.0.2.1"
+
+
+############################Â BGPPAClusterList ################################
++ BGPPAClusterList class tests
+
+= BGPPAClusterList - Basic instantiation
+str(BGPPAClusterList()) == ''
+
+= BGPPAClusterList - Instantiation with specific values
+str(BGPPAClusterList(cluster_list = [150000, 165465465, 132132])) == '\x00\x02I\xf0\t\xdc\xcdy\x00\x02\x04$'
+
+= BGPPAClusterList - Dissection
+a = BGPPAClusterList('\x00\x02I\xf0\t\xdc\xcdy\x00\x02\x04$')
+a.cluster_list[0] == 150000 and a.cluster_list[1] == 165465465 and a.cluster_list[2] == 132132
+
+
+###########################Â BGPPAMPReachNLRI ###############################
++ BGPPAMPReachNLRI class tests
+
+= BGPPAMPReachNLRI - Instantiation
+str(BGPPAMPReachNLRI()) == '\x00\x00\x00\x00\x00'
+
+= BGPPAMPReachNLRI - Instantiation with specific values (1)
+str(BGPPAMPReachNLRI(afi=2, safi=1, nh_addr_len=16, nh_v6_addr = "2001:db8::2", nlri = [BGPNLRI_IPv6(prefix = "2001:db8:2::/64")])) == '\x00\x02\x01\x10 \x01\r\xb8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00@ \x01\r\xb8\x00\x02\x00\x00'
+
+= BGPPAMPReachNLRI - Dissection (1)
+a = BGPPAMPReachNLRI('\x00\x02\x01 \x01\r\xb8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\xfe\x80\x00\x00\x00\x00\x00\x00\xc0\x02\x0b\xff\xfe~\x00\x00\x00@ \x01\r\xb8\x00\x02\x00\x02@ \x01\r\xb8\x00\x02\x00\x01@ \x01\r\xb8\x00\x02\x00\x00')
+a.afi == 2 and a.safi == 1 and a.nh_addr_len == 32 and a.nh_v6_global == "2001:db8::2" and a.nh_v6_link_local == "fe80::c002:bff:fe7e:0" and a.reserved == 0 and a.nlri[0].prefix == "2001:db8:2:2::/64" and a.nlri[1].prefix == "2001:db8:2:1::/64" and a.nlri[2].prefix == "2001:db8:2::/64"
+
+= BGPPAMPReachNLRI - Dissection (2)
+a = BGPPAMPReachNLRI('\x00\x02\x01 \xfe\x80\x00\x00\x00\x00\x00\x00\xfa\xc0\x01\x00\x15\xde\x15\x81\xfe\x80\x00\x00\x00\x00\x00\x00\xfa\xc0\x01\x00\x15\xde\x15\x81\x00\x06\x04\x05\x08\x04\x10\x03`\x03\x80\x03\xa0\x03\xc0\x04\xe0\x05\xf0\x06\xf8\t\xfe\x00\x16 \x01<\x08-\x07.\x040\x10?\xfe\x10 \x02\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00`\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff@\x01\x00\x00\x00\x00\x00\x00\x00\x17 \x01\x00 \x01\x00\x000 \x01\x00\x02\x00\x00 \x01\r\xb8\x1c \x01\x00\x10\x07\xfc\n\xfe\x80\x08\xff\n\xfe\xc0\x03 \x03@\x08_`\x00d\xff\x9b\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00\x08\x01\x07\x02')
+a.afi == 2 and a.safi == 1 and a.nh_addr_len == 32 and a.nh_v6_global == "fe80::fac0:100:15de:1581" and a.nh_v6_link_local == "fe80::fac0:100:15de:1581" and a.reserved == 0 and a.nlri[0].prefix == "400::/6" and a.nlri[1].prefix == "800::/5" and str(a.nlri[18]) == '`\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff' and a.nlri[35].prefix == "200::/7"
+
+
+#############################Â BGPPAMPUnreachNLRI #############################
++ BGPPAMPUnreachNLRI class tests
+
+= BGPPAMPUnreachNLRI - Instantiation
+str(BGPPAMPUnreachNLRI()) == '\x00\x00\x00'
+
+= BGPPAMPUnreachNLRI - Instantiation with specific values (1)
+str(BGPPAMPUnreachNLRI(afi = 2, safi = 1)) == '\x00\x02\x01'
+
+= BGPPAMPUnreachNLRI - Instantiation with specific values (2)
+str(BGPPAMPUnreachNLRI(afi = 2, safi = 1, afi_safi_specific = BGPPAMPUnreachNLRI_IPv6(withdrawn_routes = [BGPNLRI_IPv6(prefix = "2001:db8:2::/64")]))) == '\x00\x02\x01@ \x01\r\xb8\x00\x02\x00\x00'
+
+= BGPPAMPUnreachNLRI - Dissection (1)
+a = BGPPAMPUnreachNLRI('\x00\x02\x01')
+a.afi == 2 and a.safi == 1
+
+= BGPPAMPUnreachNLRI - Dissection (2)
+a = BGPPAMPUnreachNLRI('\x00\x02\x01\x03`\x03\x80\x03\xa0\x03\xc0\x04\xe0\x05\xf0\x06\xf8\x10 \x02`\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff@\x01\x00\x00\x00\x00\x00\x00\x00\x17 \x01\x00 \x01\x00\x000 \x01\x00\x02\x00\x00 \x01\r\xb8\n\xfe\xc0\x07\xfc\n\xfe\x80\x1c \x01\x00\x10\x03 \x06\x04\x03@\x08_\x05\x08\x04\x10')
+a.afi == 2 and a.safi == 1 and a.afi_safi_specific.withdrawn_routes[0].prefix == "6000::/3" and a.afi_safi_specific.withdrawn_routes[11].prefix == "2001::/32" and a.afi_safi_specific.withdrawn_routes[23].prefix == "1000::/4"
+
+
+#############################Â BGPPAAS4Aggregator #############################
++ BGPPAAS4Aggregator class tests
+
+= BGPPAAS4Aggregator - Instantiation
+str(BGPPAAS4Aggregator()) == '\x00\x00\x00\x00\x00\x00\x00\x00'
+
+= BGPPAAS4Aggregator - Instantiation with specific values
+str(BGPPAAS4Aggregator(aggregator_asn = 644566565, speaker_address = "192.0.2.1")) == '&kN%\xc0\x00\x02\x01'
+
+= BGPPAAS4Aggregator - Dissection
+a = BGPPAAS4Aggregator('&kN%\xc0\x00\x02\x01')
+a.aggregator_asn == 644566565 and a.speaker_address == "192.0.2.1"
+
+
+################################Â BGPPathAttr #################################
++ BGPPathAttr class tests
+
+= BGPPathAttr - Instantiation
+str(BGPPathAttr()) == '\x80\x00\x00'
+
+= BGPPathAttr - Instantiation with specific values (1)
+str(BGPPathAttr(type_code = 1, attribute = BGPPAOrigin(origin = 0)))
+
+= BGPPathAttr - Instantiation with specific values (2)
+str(BGPPathAttr(type_code = 2, attribute = BGPPAASPath(segments = [BGPPAASPath.ASPathSegment(segment_type = 2, segment_value = [64501, 64501, 64501])]))) == '\x80\x02\x08\x02\x03\xfb\xf5\xfb\xf5\xfb\xf5'
+
+= BGPPathAttr - Instantiation with specific values (3)
+
+str(BGPPathAttr(type_code = 14, attribute = BGPPAMPReachNLRI(afi = 2, safi = 1, nh_addr_len = 16, nh_v6_addr = "2001:db8::2", nlri = [BGPNLRI_IPv6(prefix = "2001:db8:2::/64")]))) == '\x80\x0e\x1e\x00\x02\x01\x10 \x01\r\xb8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00@ \x01\r\xb8\x00\x02\x00\x00'
+
+= BGPPathAttr - Dissection (1)
+a = BGPPathAttr('\x90\x0f\x00X\x00\x02\x01\x03`\x03\x80\x03\xa0\x03\xc0\x04\xe0\x05\xf0\x06\xf8\x10 \x02`\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff@\x01\x00\x00\x00\x00\x00\x00\x00\x17 \x01\x00 \x01\x00\x000 \x01\x00\x02\x00\x00 \x01\r\xb8\n\xfe\xc0\x07\xfc\n\xfe\x80\x1c \x01\x00\x10\x03 \x06\x04\x03@\x08_\x05\x08\x04\x10')
+a.type_flags == 0x90 and a.type_code == 15 and a.attr_ext_len == 88 and a.attribute.afi == 2 and a.attribute.safi == 1 and a.attribute.afi_safi_specific.withdrawn_routes[0].prefix == "6000::/3" and a.attribute.afi_safi_specific.withdrawn_routes[1].prefix == "8000::/3" and a.attribute.afi_safi_specific.withdrawn_routes[2].prefix == "a000::/3" and a.attribute.afi_safi_specific.withdrawn_routes[3].prefix == "c000::/3" and a.attribute.afi_safi_specific.withdrawn_routes[4].prefix == "e000::/4" and a.attribute.afi_safi_specific.withdrawn_routes[5].prefix == "f000::/5" and a.attribute.afi_safi_specific.withdrawn_routes[23].prefix == "1000::/4"
+
+
+#################################Â BGPUpdate ##################################
++ BGPUpdate class tests
+
+= BGPUpdate - Instantiation
+str(BGPUpdate()) == '\x00\x00\x00\x00'
+
+= BGPUpdate - Dissection (1)
+bgp_module_conf.use_2_bytes_asn = True
+m = BGP('\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x000\x02\x00\x19\x18\xc0\xa8\x96\x18\x07\x07\x07\x18\xc63d\x18\xc0\xa8\x01\x19\x06\x06\x06\x00\x18\xc0\xa8\x1a\x00\x00')
+assert(BGPHeader in m and BGPUpdate in m)
+assert(m.withdrawn_routes_len == 25)
+assert(m.withdrawn_routes[0].prefix == "192.168.150.0/24")
+assert(m.withdrawn_routes[5].prefix == "192.168.26.0/24")
+assert(m.path_attr_len == 0)
+
+= BGPUpdate - Behave like a NEW speaker (RFC 6793) - Dissection (2)
+bgp_module_conf.use_2_bytes_asn = False
+m = BGP('\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00=\x02\x00\x00\x00"@\x01\x01\x00@\x02\x06\x02\x01\x00\x00\xfb\xfa@\x03\x04\xc0\xa8\x10\x06\x80\x04\x04\x00\x00\x00\x00\xc0\x08\x04\xff\xff\xff\x01\x18\xc0\xa8\x01')
+assert(BGPHeader in m and BGPUpdate in m)
+assert(m.path_attr[1].attribute.segments[0].segment_value == [64506])
+assert(m.path_attr[4].attribute.community == 0xFFFFFF01)
+assert(m.nlri[0].prefix == "192.168.1.0/24")
+
+
+
+= BGPUpdate - Dissection (MP_REACH_NLRI)
+m = BGP('\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\xd8\x02\x00\x00\x00\xc1@\x01\x01\x00@\x02\x06\x02\x01\x00\x00\xfb\xf6\x90\x0e\x00\xb0\x00\x02\x01 \xfe\x80\x00\x00\x00\x00\x00\x00\xfa\xc0\x01\x00\x15\xde\x15\x81\xfe\x80\x00\x00\x00\x00\x00\x00\xfa\xc0\x01\x00\x15\xde\x15\x81\x00\x06\x04\x05\x08\x04\x10\x03`\x03\x80\x03\xa0\x03\xc0\x04\xe0\x05\xf0\x06\xf8\t\xfe\x00\x16 \x01<\x08-\x07.\x040\x10?\xfe\x10 \x02\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00`\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff@\x01\x00\x00\x00\x00\x00\x00\x00\x17 \x01\x00 \x01\x00\x000 \x01\x00\x02\x00\x00 \x01\r\xb8\x1c \x01\x00\x10\x07\xfc\n\xfe\x80\x08\xff\n\xfe\xc0\x03 \x03@\x08_`\x00d\xff\x9b\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00\x08\x01\x07\x02')
+assert(BGPHeader in m and BGPUpdate in m)
+assert(m.path_attr[2].attribute.afi == 2)
+assert(m.path_attr[2].attribute.safi == 1)
+assert(m.path_attr[2].attribute.nh_addr_len == 32)
+assert(m.path_attr[2].attribute.nh_v6_global == "fe80::fac0:100:15de:1581")
+assert(m.path_attr[2].attribute.nh_v6_link_local == "fe80::fac0:100:15de:1581")
+assert(m.path_attr[2].attribute.nlri[0].prefix == "400::/6")
+assert(m.nlri == [])
+
+= BGPUpdate - Dissection (MP_UNREACH_NLRI)
+m = BGP('\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00s\x02\x00\x00\x00\\\x90\x0f\x00X\x00\x02\x01\x03`\x03\x80\x03\xa0\x03\xc0\x04\xe0\x05\xf0\x06\xf8\x10 \x02`\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff@\x01\x00\x00\x00\x00\x00\x00\x00\x17 \x01\x00 \x01\x00\x000 \x01\x00\x02\x00\x00 \x01\r\xb8\n\xfe\xc0\x07\xfc\n\xfe\x80\x1c \x01\x00\x10\x03 \x06\x04\x03@\x08_\x05\x08\x04\x10')
+assert(BGPHeader in m and BGPUpdate in m)
+assert(m.path_attr[0].attribute.afi == 2)
+assert(m.path_attr[0].attribute.safi == 1)
+assert(m.path_attr[0].attribute.afi_safi_specific.withdrawn_routes[0].prefix == "6000::/3")
+assert(m.nlri == [])
+
+
+##########Â BGPNotification Class ###################################
++ BGPNotification class tests
+
+= BGPNotification - Instantiation
+str(BGPNotification()) == '\x00\x00'
+
+= BGPNotification - Dissection (Administratively Reset)
+m = BGP('\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x15\x03\x06\x04')
+m.type == BGP.NOTIFICATION_TYPE and m.error_code == 6 and m.error_subcode == 4
+
+= BGPNotification - Dissection (Bad Peer AS)
+m = BGP('\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x17\x03\x02\x02\x00\x00')
+m.type == BGP.NOTIFICATION_TYPE and m.error_code == 2 and m.error_subcode == 2
+
+= BGPNotification - Dissection (Attribute Flags Error)
+m = BGP('\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x19\x03\x03\x04\x80\x01\x01\x00')
+m.type == BGP.NOTIFICATION_TYPE and m.error_code == 3 and m.error_subcode == 4
+
+
+##########Â BGPRouteRefresh Class ###################################
++ BGPRouteRefresh class tests
+
+= BGPRouteRefresh - Instantiation
+str(BGPRouteRefresh()) == '\x00\x01\x00\x01'
+
+= BGPRouteRefresh - Instantiation with specific values
+str(BGPRouteRefresh(afi = 1, safi = 1)) == '\x00\x01\x00\x01'
+
+= BGPRouteRefresh - Dissection (1)
+m = BGP('\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x17\x05\x00\x02\x00\x01')
+m.type == BGP.ROUTEREFRESH_TYPE and m.len == 23 and m.afi == 2 and m.subtype == 0 and m.safi == 1
+
+
+= BGPRouteRefresh - Dissection (2) - With ORFs
+m = BGP('\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00.\x05\x00\x01\x00\x01\x01\x80\x00\x13 \x00\x00\x00\x05\x18\x18\x15\x01\x01\x00\x00\x00\x00\x00\n\x00 \x00')
+assert(m.type == BGP.ROUTEREFRESH_TYPE)
+assert(m.len == 46)
+assert(m.afi == 1)
+assert(m.subtype == 0)
+assert(m.safi == 1)
+assert(m.orf_data[0].when_to_refresh == 1)
+assert(m.orf_data[0].orf_type == 128)
+assert(m.orf_data[0].orf_len == 19)
+assert(len(m.orf_data[0].entries) == 2)
+assert(m.orf_data[0].entries[0].action == 0)
+assert(m.orf_data[0].entries[0].match == 1)
+assert(m.orf_data[0].entries[0].prefix.prefix == "1.1.0.0/21")
+assert(m.orf_data[0].entries[1].action == 0)
+assert(m.orf_data[0].entries[1].match == 0)
+assert(m.orf_data[0].entries[1].prefix.prefix == "0.0.0.0/0")
+