Bgp: fix: make iBGP work over a multi-hop IGP with IPv6

Running BGP over an interior gateway protocol (the usual transit-AS setup) did
not work for IPv6 when an iBGP peer or a route's next hop was reachable only via
several IGP hops (e.g. OSPFv3). Four related problems, each fixed so the
directly-connected / IPv4 paths are unchanged:

- iBGP session start threw a fatal error ("No configuration interface for peer
  address") when the IGP had not yet installed a route to the peer. Defer the
  start and retry until the peer becomes reachable (BgpFsm Idle::ManualStart,
  BgpSession::scheduleStartRetry/isPeerReachable, BgpRouter::findNextSession).

- The iBGP path that adopts an existing (e.g. IGP) route into BGP cast the route
  unconditionally to Ipv4Route, aborting for IPv6. Use the generic IRoute;
  createBgpRoutingTableEntry() already builds the right v4/v6 entry.

- A locally-originated route is built from a connected route and has no next hop,
  so it was advertised over IPv6 iBGP with an unspecified MP_REACH_NLRI next hop.
  Advertise our own on-link address instead (RFC 4271: a router is the next hop
  for the networks it originates). IPv6 path only.

- An installed iBGP route used the (possibly multi-hop) BGP next hop directly as
  its gateway, so IPv6 neighbour discovery looked for it on the wrong link and
  failed. Resolve the next hop recursively through the IGP and install the
  immediate on-link next hop; a directly-connected next hop is kept as-is.

The bgpv4 and tutorials/bgp fingerprints are unchanged (these paths only trigger
for not-yet-reachable / multi-hop IPv6 next hops).

Author: avarga

src/inet/routing/bgpv4/BgpFsm.cc

@@ -33,6 +33,13 @@ void Idle::ManualStart()
     session._connectRetryCounter = 0;
     // - starts the ConnectRetryTimer with the initial value,
     session.stopConnectRetryTimer();
+    // For an internal (iBGP) session, the peer may not be reachable yet if the IGP
+    // (e.g. OSPFv3) has not converged. Defer the connection until a route to the peer
+    // exists, instead of failing in openTcpConnectionToPeer().
+    if (session.getType() == IGP && !session.isPeerReachable()) {
+        session.scheduleStartRetry();
+        return;
+    }
     // - listens for a connection that may be initiated by the remote BGP peer,
     session.listenConnectionFromPeer();
     // - initiates a TCP connection to the other BGP peer and,

src/inet/routing/bgpv4/BgpRouter.cc

@@ -687,7 +687,9 @@ BgpProcessResult BgpRouter::decisionProcess(const BgpUpdateMessage& msg, BgpRout
         if (rt->getRoute(indexIp)->getSourceType() != IRoute::BGP) {
             // and the Update msg is coming from IGP session
             if (_bgpSessions[sessionIndex]->getType() == IGP) {
-                Ipv4Route *oldEntry = check_and_cast<Ipv4Route *>(rt->getRoute(indexIp));
+                // works for both IPv4 and IPv6: createBgpRoutingTableEntry() takes the
+                // generic IRoute and builds the right (v4/v6) BGP entry
+                IRoute *oldEntry = rt->getRoute(indexIp);
                 BgpRouteInfo *bgpEntry = createBgpRoutingTableEntry(oldEntry);
                 bgpEntry->addAS(myAsId);
                 bgpEntry->setPathType(IGP);
@@ -709,6 +711,14 @@ BgpProcessResult BgpRouter::decisionProcess(const BgpUpdateMessage& msg, BgpRout
         if (_bgpSessions[sessionIndex]->getType() == IGP) {
             // if the next hop is reachable
             if (isReachable(entry->getNextHopAsGeneric())) {
+                // Resolve the (i)BGP next hop recursively through the IGP. An installed route
+                // must point at an on-link next hop, but an iBGP next hop can be several IGP
+                // hops away (e.g. behind an OSPF/OSPFv3 path); in that case replace it with the
+                // IGP's immediate next hop. A directly-connected next hop resolves to
+                // "unspecified" here and is kept as-is (so directly-connected iBGP is unchanged).
+                L3Address onLinkNextHop = rt->getNextHopForDestination(entry->getNextHopAsGeneric());
+                if (!onLinkNextHop.isUnspecified())
+                    entry->setNextHop(onLinkNextHop);
                 entry->setInterface(_bgpSessions[sessionIndex]->getLinkIntf());
                 rt->addRoute(entry->asRoute());
             }
@@ -844,6 +854,12 @@ void BgpRouter::updateSendProcess(BgpProcessResult type, SessionId sessionIndex,
                 : entry->getNextHopAsGeneric();
 
             if (isIpv6()) {
+                // a locally-originated route is built from a connected route and carries no
+                // learned next hop; advertise our own address on the link so that iBGP peers
+                // can resolve it via the IGP (RFC 4271: a router uses itself as the next hop
+                // for the networks it originates)
+                if (nextHop.isUnspecified())
+                    nextHop = getInterfaceAddress((elem).second->getLinkIntf());
                 // RFC 4760: carry the IPv6 next hop + reachability in MP_REACH_NLRI; ORIGIN stays
                 // a normal attribute. The legacy NEXT_HOP attribute and NLRI field are not used.
                 auto originAttr = new BgpUpdatePathAttributesOrigin;
@@ -983,8 +999,12 @@ SessionId BgpRouter::findNextSession(BgpSessionType type, bool startSession)
         // note: if the internal peer is not directly-connected to us, then we should know how to reach it.
         // this is done with the help of an intra-AS routing protocol (RIP, OSPF, EIGRP).
         NetworkInterface *linkIntf = rt->getOutputInterfaceForDestination(_bgpSessions[sessionId]->getPeerAddr());
-        if (linkIntf == nullptr)
-            throw cRuntimeError("No configuration interface for peer address: %s", _bgpSessions[sessionId]->getPeerAddr().str().c_str());
+        if (linkIntf == nullptr) {
+            // The IGP has not installed a route to this internal peer yet (it may still be
+            // converging). Defer the session start and retry, instead of failing.
+            _bgpSessions[sessionId]->scheduleStartRetry();
+            return sessionId;
+        }
 
         _bgpSessions[sessionId]->setlinkIntf(linkIntf);
         _bgpSessions[sessionId]->startConnection();

src/inet/routing/bgpv4/BgpSession.cc

@@ -97,6 +97,18 @@ void BgpSession::scheduleReconnect()
     _ptrStartEvent->setContextPointer(this);
 }
 
+void BgpSession::scheduleStartRetry()
+{
+    // The internal (iBGP) peer is not reachable yet because the IGP has not finished
+    // converging. Re-attempt the session start after a short delay instead of failing;
+    // each retry re-checks reachability (see Idle::ManualStart).
+    if (_ptrStartEvent == nullptr)
+        _ptrStartEvent = new cMessage("BGP Start", START_EVENT_KIND);
+    if (!_ptrStartEvent->isScheduled())
+        bgpRouter.scheduleAt(simTime() + 1, _ptrStartEvent);
+    _ptrStartEvent->setContextPointer(this);
+}
+
 void BgpSession::cancelReconnect()
 {
     // Once (re-)established, drop any pending reconnect so a stale Start event cannot later

src/inet/routing/bgpv4/BgpSession.h

@@ -68,6 +68,11 @@ class INET_API BgpSession : public cObject
 
     void startConnection();
     void scheduleReconnect();
+    // Retry starting this session shortly; used for an iBGP session whose peer is not
+    // reachable yet because the IGP (e.g. OSPFv3) has not finished converging.
+    void scheduleStartRetry();
+    // True if the routing table currently has a route towards this session's peer.
+    bool isPeerReachable() const { return bgpRouter.getIpRoutingTable()->getOutputInterfaceForDestination(_info.peerAddr) != nullptr; }
     void cancelReconnect();
     void restartHoldTimer();
     void restartKeepAliveTimer();