Bgp: multiprotocol capability negotiation in OPEN (RFC 4760 / RFC 5492)

For an IPv6 BGP session the speaker now advertises the Multiprotocol Extensions
capability in the OPEN message, so the peer learns we use the IPv6 (AFI=2,
SAFI=1) address family instead of relying on out-of-band agreement. IPv4 unicast
is BGP's default address family (RFC 4271), so IPv4 sessions send no capabilities
and their OPEN encoding (and all 8 IPv4 bgpv4 fingerprints) stay byte-identical.

- BgpHeader.msg: add the RFC 5492 Capabilities optional parameter
  (BgpOptionalParameterCapabilities, parameter type 2) carrying a list of
  capabilities, and the RFC 4760 Multiprotocol Extensions capability
  (BgpCapabilityMultiprotocol, code 1: AFI + reserved + SAFI).
- BgpSession::sendOpenMessage(): for IPv6 sessions attach one Multiprotocol
  capability (AFI=2, SAFI=1) and size the optional-parameters / total / chunk
  lengths accordingly; IPv4 sessions are unchanged.
- BgpHeaderSerializer: serialize and deserialize the Capabilities parameter and
  Multiprotocol capability (unknown optional-parameter / capability types still
  round-trip as raw / header-only). Also fixes a latent infinite-loop guard in
  the raw optional-parameter serialize loop.
- BgpRouter::printOpenMessage(): parse and log the peer's advertised
  capabilities (AFI/SAFI). Advertise + parse only; no enforcement / NOTIFICATION.

Verified: new tests/unit/Bgp_open_capability_serializer.test (serialize->
deserialize round-trip for IPv6 and IPv4 advertisements) PASSES; IPv4
(Bgp2RoutersInAS: OPEN carries no capabilities, sessions ESTABLISHED, UPDATEs
flow) stays byte-identical, IPv6 (BgpIpv6Basic: hostA->hostB 20/21 pings)
advertises the capability and converges. Only the 2 IPv6 bgpv4 fingerprints
(BgpIpv6Basic, BgpAndOspfv3) change; the 8 IPv4 ones are byte-identical.

Author: avarga

src/inet/routing/bgpv4/BgpRouter.cc

@@ -1034,6 +1034,16 @@ void BgpRouter::printOpenMessage(const BgpOpenMessage& openMsg)
         EV_INFO << "  Optional parameter " << i + 1 << ": \n";
         EV_INFO << "    Parameter type: " << optParam->getParameterType() << "\n";
         EV_INFO << "    Parameter length: " << optParam->getParameterValueLength() << "\n";
+        if (auto caps = dynamic_cast<const BgpOptionalParameterCapabilities *>(optParam)) {
+            for (size_t c = 0; c < caps->getCapabilityArraySize(); c++) {
+                auto cap = caps->getCapability(c);
+                if (auto mp = dynamic_cast<const BgpCapabilityMultiprotocol *>(cap))
+                    EV_INFO << "    Capability: Multiprotocol Extensions, AFI=" << mp->getAfi()
+                            << " SAFI=" << (int)mp->getSafi() << "\n";
+                else
+                    EV_INFO << "    Capability: code " << (int)cap->getCapabilityCode() << "\n";
+            }
+        }
     }
 }
 

src/inet/routing/bgpv4/BgpSession.cc

@@ -150,6 +150,28 @@ void BgpSession::sendOpenMessage()
     // BGP Identifier is a 4-octet router id; for IPv6 it cannot be the (IPv6) local address
     openMsg->setBgpIdentifier(bgpRouter.isIpv6() ? bgpRouter.getRouterId() : _info.socket->getLocalAddress().toIpv4());
 
+    // For an IPv6 session, advertise the Multiprotocol Extensions capability (RFC 4760 /
+    // RFC 5492) so the peer learns we use the IPv6 (AFI=2, SAFI=1) address family. IPv4
+    // unicast is BGP's default address family (RFC 4271), so for IPv4 sessions the OPEN
+    // carries no capabilities (and stays byte-identical to the pre-MP-BGP encoding).
+    if (bgpRouter.isIpv6()) {
+        auto *mpCap = new BgpCapabilityMultiprotocol();
+        mpCap->setAfi(2); // IPv6
+        mpCap->setSafi(1); // unicast
+        auto *capsParam = new BgpOptionalParameterCapabilities();
+        capsParam->setCapabilityArraySize(1);
+        capsParam->setCapability(0, mpCap);
+        // parameter value = the capability list: capCode(1) + capLen(1) + value(capabilityLength)
+        capsParam->setParameterValueLength(2 + mpCap->getCapabilityLength());
+        openMsg->setOptionalParameterArraySize(1);
+        openMsg->setOptionalParameter(0, capsParam);
+        // optional parameters total = paramType(1) + paramLen(1) + parameter value
+        unsigned short optParamsLength = 2 + capsParam->getParameterValueLength();
+        openMsg->setOptionalParametersLength(optParamsLength);
+        openMsg->setTotalLength((BGP_HEADER_OCTETS + BGP_OPEN_OCTETS).get<B>() + optParamsLength);
+        openMsg->setChunkLength(BGP_HEADER_OCTETS + BGP_OPEN_OCTETS + B(optParamsLength));
+    }
+
     EV_INFO << "Sending BGP Open message to " << _info.peerAddr.str()
             << " on interface " << _info.linkIntf->getInterfaceName()
             << "[" << _info.linkIntf->getInterfaceId() << "] with contents:\n";

src/inet/routing/bgpv4/bgpmessage/BgpHeader.msg

@@ -76,13 +76,45 @@ class BgpOptionalParameterBase
     unsigned short parameterValueLength;
 }
 
-//TODO add accepted BgpOptionalParameter variants
-
 class BgpOptionalParameterRaw extends BgpOptionalParameterBase
 {
     char value[];
 }
 
+//
+// Base for a BGP capability advertised inside a Capabilities optional parameter
+// (RFC 5492). On the wire: Capability Code (1 octet) + Capability Length (1 octet)
+// + Capability Value (Capability Length octets).
+//
+class BgpCapabilityBase
+{
+    @packetData;
+    uint8_t capabilityCode;
+    uint8_t capabilityLength;   // length (in octets) of the capability value
+}
+
+//
+// Multiprotocol Extensions capability (RFC 4760, section 8); advertises one
+// (AFI, SAFI) pair the speaker supports. AFI=1 IPv4, AFI=2 IPv6; SAFI=1 unicast.
+//
+class BgpCapabilityMultiprotocol extends BgpCapabilityBase
+{
+    capabilityCode = 1;
+    capabilityLength = 4;
+    uint16_t afi;               // Address Family Identifier
+    uint8_t reserved = 0;       // 1 octet, sent as 0
+    uint8_t safi;               // Subsequent Address Family Identifier
+}
+
+//
+// Capabilities Optional Parameter (RFC 5492); carries one or more capabilities.
+//
+class BgpOptionalParameterCapabilities extends BgpOptionalParameterBase
+{
+    parameterType = 2;          // Capabilities (RFC 5492)
+    BgpCapabilityBase *capability[] @owned;
+}
+
 //
 // Represents a BGPv4 OPEN message.
 //

src/inet/routing/bgpv4/bgpmessage/BgpHeaderSerializer.cc

@@ -79,13 +79,31 @@ void BgpHeaderSerializer::serialize(MemoryOutputStream& stream, const Ptr<const
             stream.writeByte(optionalParametersLength);
             unsigned short numOptionalParametersBytes = 0;
             for (size_t i = 0; i < bgpOpenMessage->getOptionalParameterArraySize(); ++i) {
-                const BgpOptionalParameterRaw *optionalParameter = static_cast<const BgpOptionalParameterRaw *>(bgpOpenMessage->getOptionalParameter(i));
+                const BgpOptionalParameterBase *optionalParameter = bgpOpenMessage->getOptionalParameter(i);
                 stream.writeByte(optionalParameter->getParameterType());
                 unsigned short parameterValueLength = optionalParameter->getParameterValueLength();
                 stream.writeByte(parameterValueLength);
-                for (size_t e = 0; optionalParameter->getValueArraySize(); ++e) {
-                    stream.writeByte(optionalParameter->getValue(e));
+                if (auto caps = dynamic_cast<const BgpOptionalParameterCapabilities *>(optionalParameter)) {
+                    // RFC 5492 Capabilities: a list of <code, length, value> capabilities
+                    for (size_t c = 0; c < caps->getCapabilityArraySize(); ++c) {
+                        const BgpCapabilityBase *cap = caps->getCapability(c);
+                        stream.writeByte(cap->getCapabilityCode());
+                        stream.writeByte(cap->getCapabilityLength());
+                        if (auto mp = dynamic_cast<const BgpCapabilityMultiprotocol *>(cap)) {
+                            stream.writeUint16Be(mp->getAfi());
+                            stream.writeByte(mp->getReserved());
+                            stream.writeByte(mp->getSafi());
+                        }
+                        else
+                            throw cRuntimeError("Cannot serialize BGP OPEN Message: unknown BGP capability code %d.", cap->getCapabilityCode());
+                    }
+                }
+                else if (auto raw = dynamic_cast<const BgpOptionalParameterRaw *>(optionalParameter)) {
+                    for (size_t e = 0; e < raw->getValueArraySize(); ++e)
+                        stream.writeByte(raw->getValue(e));
                 }
+                else
+                    throw cRuntimeError("Cannot serialize BGP OPEN Message: unknown optional parameter type %d.", optionalParameter->getParameterType());
                 numOptionalParametersBytes += 2 + parameterValueLength;
             }
             if (numOptionalParametersBytes != optionalParametersLength)
@@ -262,11 +280,43 @@ const Ptr<Chunk> BgpHeaderSerializer::deserialize(MemoryInputStream& stream) con
             bgpOpenMessage->setOptionalParametersLength(optionalParametersLength);
             for (size_t i = 0; optionalParametersLength > 0; ++i) {
                 bgpOpenMessage->setOptionalParameterArraySize(i + 1);
-                BgpOptionalParameterRaw *optionalParameter = new BgpOptionalParameterRaw();
-                optionalParameter->setParameterType(stream.readByte());
+                uint8_t parameterType = stream.readByte();
                 uint8_t parameterValueLength = stream.readByte();
-                optionalParameter->setParameterValueLength(parameterValueLength);
                 optionalParametersLength -= (2 + parameterValueLength);
+                if (parameterType == 2) {
+                    // RFC 5492 Capabilities optional parameter: a list of capabilities
+                    BgpOptionalParameterCapabilities *caps = new BgpOptionalParameterCapabilities();
+                    caps->setParameterValueLength(parameterValueLength);
+                    uint8_t remaining = parameterValueLength;
+                    for (size_t c = 0; remaining > 0; ++c) {
+                        uint8_t capabilityCode = stream.readByte();
+                        uint8_t capabilityLength = stream.readByte();
+                        remaining -= (2 + capabilityLength);
+                        caps->setCapabilityArraySize(c + 1);
+                        if (capabilityCode == 1 && capabilityLength == 4) {
+                            // Multiprotocol Extensions (RFC 4760)
+                            BgpCapabilityMultiprotocol *mp = new BgpCapabilityMultiprotocol();
+                            mp->setAfi(stream.readUint16Be());
+                            mp->setReserved(stream.readByte());
+                            mp->setSafi(stream.readByte());
+                            caps->setCapability(c, mp);
+                        }
+                        else {
+                            // unknown capability: keep its header, skip the value bytes
+                            BgpCapabilityBase *cap = new BgpCapabilityBase();
+                            cap->setCapabilityCode(capabilityCode);
+                            cap->setCapabilityLength(capabilityLength);
+                            for (uint8_t k = 0; k < capabilityLength; ++k)
+                                stream.readByte();
+                            caps->setCapability(c, cap);
+                        }
+                    }
+                    bgpOpenMessage->setOptionalParameter(i, caps);
+                    continue;
+                }
+                BgpOptionalParameterRaw *optionalParameter = new BgpOptionalParameterRaw();
+                optionalParameter->setParameterType(parameterType);
+                optionalParameter->setParameterValueLength(parameterValueLength);
                 for (size_t e = 0; parameterValueLength > 0; ++e) {
                     optionalParameter->setValueArraySize(e + 1);
                     optionalParameter->setValue(e, stream.readByte());

tests/unit/Bgp_open_capability_serializer.test

@@ -0,0 +1,90 @@
+%description:
+Round-trip serialization of the BGP OPEN message carrying the RFC 5492 Capabilities
+optional parameter with an RFC 4760 Multiprotocol Extensions capability (AFI/SAFI).
+Verifies serialize->bytes->deserialize reproduces the capability and the expected
+on-wire length, for both the IPv6 (AFI=2) and IPv4 (AFI=1) advertisements.
+
+%includes:
+#include "inet/common/packet/Packet.h"
+#include "inet/common/packet/chunk/BytesChunk.h"
+#include "inet/routing/bgpv4/bgpmessage/BgpHeader_m.h"
+
+using namespace inet;
+using namespace inet::bgp;
+
+%global:
+
+// build an OPEN advertising one Multiprotocol capability for the given AFI/SAFI,
+// exactly as BgpSession::sendOpenMessage() does
+static Ptr<BgpOpenMessage> makeOpen(uint16_t afi, uint8_t safi)
+{
+    auto open = makeShared<BgpOpenMessage>();
+    open->setMyAS(64500);
+    open->setHoldTime(SimTime(180, SIMTIME_S));
+    open->setBgpIdentifier(Ipv4Address("1.2.3.4"));
+
+    auto *mp = new BgpCapabilityMultiprotocol();
+    mp->setAfi(afi);
+    mp->setSafi(safi);
+    auto *caps = new BgpOptionalParameterCapabilities();
+    caps->setCapabilityArraySize(1);
+    caps->setCapability(0, mp);
+    caps->setParameterValueLength(2 + mp->getCapabilityLength());
+    open->setOptionalParameterArraySize(1);
+    open->setOptionalParameter(0, caps);
+    unsigned short optLen = 2 + caps->getParameterValueLength();
+    open->setOptionalParametersLength(optLen);
+    open->setTotalLength((BGP_HEADER_OCTETS + BGP_OPEN_OCTETS).get<B>() + optLen);
+    open->setChunkLength(BGP_HEADER_OCTETS + BGP_OPEN_OCTETS + B(optLen));
+    return open;
+}
+
+static Ptr<const BgpOpenMessage> roundTrip(const Ptr<const BgpOpenMessage>& original)
+{
+    Packet pkt("test");
+    pkt.insertAtFront(original);
+    auto bytes = pkt.peekAllAsBytes();      // forces serialize()
+    Packet pkt2("test2");
+    pkt2.insertAtFront(bytes);
+    auto hdr = pkt2.popAtFront<BgpHeader>(); // forces deserialize()
+    return dynamicPtrCast<const BgpOpenMessage>(hdr);
+}
+
+static void checkAf(uint16_t afi, uint8_t safi)
+{
+    auto open = makeOpen(afi, safi);
+
+    // OPEN base (29) + one capabilities param (2) + one MP capability (2 + 4) = 37 octets
+    Packet sz("sz"); sz.insertAtFront(open);
+    ASSERT(sz.getDataLength() == B(37));
+
+    auto o2 = roundTrip(staticPtrCast<const BgpOpenMessage>(open));
+    ASSERT(o2 != nullptr);
+    ASSERT(o2->getMyAS() == 64500);
+    ASSERT(o2->getBgpIdentifier() == Ipv4Address("1.2.3.4"));
+    ASSERT(o2->getOptionalParametersLength() == 8);
+    ASSERT(o2->getOptionalParameterArraySize() == 1);
+
+    auto caps = dynamic_cast<const BgpOptionalParameterCapabilities *>(o2->getOptionalParameter(0));
+    ASSERT(caps != nullptr);
+    ASSERT(caps->getParameterType() == 2);
+    ASSERT(caps->getCapabilityArraySize() == 1);
+
+    auto mp = dynamic_cast<const BgpCapabilityMultiprotocol *>(caps->getCapability(0));
+    ASSERT(mp != nullptr);
+    ASSERT(mp->getCapabilityCode() == 1);
+    ASSERT(mp->getCapabilityLength() == 4);
+    ASSERT(mp->getAfi() == afi);
+    ASSERT(mp->getSafi() == safi);
+    EV << "  AFI=" << afi << " SAFI=" << (int)safi << " round-trip PASS" << endl;
+}
+
+%activity:
+
+EV << "=== BGP OPEN Multiprotocol capability round-trip ===" << endl;
+checkAf(2, 1);   // IPv6 unicast
+checkAf(1, 1);   // IPv4 unicast
+EV << "All BGP OPEN capability round-trips passed." << endl;
+
+%contains: stdout
+All BGP OPEN capability round-trips passed.