RSVP-TE: derive peers automatically from the TED (peers="auto")

RSVP-TE required its neighbours to be listed by hand in the "peers" parameter
(interface names), per router -- tedious and error-prone for anything but tiny
topologies. But RSVP's neighbours are exactly the directly-connected routers that
run the same TE control plane, and the TED already discovers them: for every
local interface it records the neighbour's router id and address.

Add a "peers" value "auto" (now the default) that derives the peer set from the
TED instead of a manual list:

- RsvpTe::setupHello() iterates the TED's local links (advrouter == our routerId)
  and sets up a HELLO with each directly-connected neighbour that runs RSVP
  (RsvpTe), skipping hosts (no router id) and non-RSVP routers.
- LinkStateRouting does the same for the interfaces it floods TE link-state on,
  filtering to neighbours that run link-state routing. (The two filters differ on
  purpose: an LDP-TE router is a link-state peer but not an RSVP HELLO peer.)
- MplsRouterBase.ned / RsvpTe.ned default peers to "auto". An explicit
  space-separated interface-name list still works as before (override).

Ordering: TED (base submodule) initializes before RsvpTe/LinkStateRouting, and
all three run at INITSTAGE_ROUTING_PROTOCOLS, so the TED is populated before the
peers are derived. Examples that set "peers" explicitly are unaffected
(byte-identical fingerprints).

Author: avarga

src/inet/networklayer/rsvpte/RsvpTe.cc

@@ -301,44 +301,87 @@ std::vector<RsvpTe::traffic_path_t>::iterator RsvpTe::findPath(traffic_session_t
     return it;
 }
 
+// Recursively tests whether a network node contains an RSVP-TE module.
+static bool moduleContainsRsvp(cModule *module)
+{
+    for (cModule::SubmoduleIterator it(module); !it.end(); ++it) {
+        cModule *submodule = *it;
+        if (dynamic_cast<RsvpTe *>(submodule) != nullptr)
+            return true;
+        if (moduleContainsRsvp(submodule))
+            return true;
+    }
+    return false;
+}
+
+bool RsvpTe::peerRunsRsvp(Ipv4Address peerInterface)
+{
+    cModule *peerNode = L3AddressResolver().findHostWithAddress(L3Address(peerInterface));
+    return peerNode != nullptr && moduleContainsRsvp(peerNode);
+}
+
 void RsvpTe::setupHello()
 {
     routerId = rt->getRouterId();
 
     helloInterval = par("helloInterval");
     helloTimeout = par("helloTimeout");
 
-    cStringTokenizer tokenizer(par("peers"));
-    const char *token;
-    while ((token = tokenizer.nextToken()) != nullptr) {
-        Ipv4Address peer = tedmod->getPeerByLocalAddress(CHK(ift->findInterfaceByName(token))->getProtocolData<Ipv4InterfaceData>()->getIPAddress());
+    const char *peers = par("peers");
+    if (!strcmp(peers, "auto")) {
+        // Derive the RSVP peers automatically from the Traffic Engineering
+        // Database (TED), which has already discovered every directly-connected
+        // neighbour by walking the topology -- analogous to how a real RSVP-TE
+        // speaker learns its adjacencies from the IGP-TE. Set up a HELLO with each
+        // directly-connected neighbour that actually runs RSVP (this skips plain
+        // IP routers and end hosts, which would never answer a HELLO).
+        for (auto& link : tedmod->ted) {
+            if (link.advrouter != routerId) // not one of our local links
+                continue;
+            if (link.linkid.isUnspecified()) // neighbour has no router id (e.g. a host)
+                continue;
+            if (!peerRunsRsvp(link.remote)) // neighbour does not speak RSVP
+                continue;
+            addHelloPeer(link.linkid);
+        }
+    }
+    else {
+        cStringTokenizer tokenizer(peers);
+        const char *token;
+        while ((token = tokenizer.nextToken()) != nullptr) {
+            Ipv4Address peer = tedmod->getPeerByLocalAddress(CHK(ift->findInterfaceByName(token))->getProtocolData<Ipv4InterfaceData>()->getIPAddress());
+            addHelloPeer(peer);
+        }
+    }
+}
 
-        HelloState h;
+void RsvpTe::addHelloPeer(Ipv4Address peer)
+{
+    HelloState h;
 
-        h.timer = new HelloTimerMsg("hello timer");
-        h.timer->setPeer(peer);
+    h.timer = new HelloTimerMsg("hello timer");
+    h.timer->setPeer(peer);
 
-        h.timeout = new HelloTimeoutMsg("hello timeout");
-        h.timeout->setPeer(peer);
+    h.timeout = new HelloTimeoutMsg("hello timeout");
+    h.timeout->setPeer(peer);
 
-        h.peer = peer;
+    h.peer = peer;
 
-        if (helloInterval > 0.0) {
-            // peer is down until we know he is ok
+    if (helloInterval > 0.0) {
+        // peer is down until we know he is ok
 
-            h.ok = false;
-        }
-        else {
-            // don't use HELLO at all, consider all peers running all the time
+        h.ok = false;
+    }
+    else {
+        // don't use HELLO at all, consider all peers running all the time
 
-            h.ok = true;
-        }
+        h.ok = true;
+    }
 
-        HelloList.push_back(h);
+    HelloList.push_back(h);
 
-        if (helloInterval > 0.0) {
-            startHello(peer, exponential(helloInterval));
-        }
+    if (helloInterval > 0.0) {
+        startHello(peer, exponential(helloInterval));
     }
 }
 

src/inet/networklayer/rsvpte/RsvpTe.h

@@ -218,6 +218,9 @@ class INET_API RsvpTe : public RoutingProtocolBase, public IScriptable
     virtual void sendPathNotify(int handler, const SessionObj& session, const SenderTemplateObj& sender, int status, simtime_t delay);
 
     virtual void setupHello();
+    virtual void addHelloPeer(Ipv4Address peer);
+    // True if the node owning peerInterface runs RSVP (used to auto-derive peers).
+    virtual bool peerRunsRsvp(Ipv4Address peerInterface);
     virtual void startHello(Ipv4Address peer, simtime_t delay);
     virtual void removeHello(HelloState *h);
 

src/inet/networklayer/rsvpte/RsvpTe.ned

@@ -91,7 +91,7 @@ simple RsvpTe extends SimpleModule
         string tedModule;
         string classifierModule; // The path to the module which implements the IIngressClassifier C++ interface
         xml traffic = default(xml("<sessions/>")); // Specifies paths to set up
-        string peers; // Names of the interfaces towards RSVP peers
+        string peers = default("auto"); // "auto" (default) derives the RSVP peers from the TED (every directly-connected RSVP-speaking neighbour); otherwise a space-separated list of the interface names towards the RSVP peers
         double helloInterval @unit(s);
         double helloTimeout @unit(s);
         @display("i=block/control");

src/inet/networklayer/ted/LinkStateRouting.cc

@@ -13,6 +13,7 @@
 #include "inet/common/ProtocolTag_m.h"
 #include "inet/common/Simsignals.h"
 #include "inet/common/stlutils.h"
+#include "inet/networklayer/common/L3AddressResolver.h"
 #include "inet/networklayer/common/L3AddressTag_m.h"
 #include "inet/networklayer/contract/IInterfaceTable.h"
 #include "inet/networklayer/ipv4/IIpv4RoutingTable.h"
@@ -32,6 +33,20 @@ LinkStateRouting::~LinkStateRouting()
     cancelAndDelete(announceMsg);
 }
 
+// Recursively tests whether a network node runs link-state routing (i.e. is an
+// RSVP-TE peer we should flood our TE link-state to).
+static bool moduleContainsLinkStateRouting(cModule *module)
+{
+    for (cModule::SubmoduleIterator it(module); !it.end(); ++it) {
+        cModule *submodule = *it;
+        if (dynamic_cast<LinkStateRouting *>(submodule) != nullptr)
+            return true;
+        if (moduleContainsLinkStateRouting(submodule))
+            return true;
+    }
+    return false;
+}
+
 void LinkStateRouting::initialize(int stage)
 {
     SimpleModule::initialize(stage);
@@ -46,13 +61,30 @@ void LinkStateRouting::initialize(int stage)
         cModule *host = getContainingNode(this);
         host->subscribe(tedChangedSignal, this);
 
-        // peers are given as interface names in the "peers" module parameter;
-        // store corresponding interface addresses in peerIfAddrs[]
-        cStringTokenizer tokenizer(par("peers"));
-        IInterfaceTable *ift = getModuleFromPar<IInterfaceTable>(par("interfaceTableModule"), this);
-        const char *token;
-        while ((token = tokenizer.nextToken()) != nullptr) {
-            peerIfAddrs.push_back(CHK(ift->findInterfaceByName(token))->getProtocolData<Ipv4InterfaceData>()->getIPAddress());
+        // Determine the local interfaces facing our RSVP-TE peers, and store their
+        // addresses in peerIfAddrs[]. With peers="auto" (the default) they are
+        // derived from the TED -- every directly-connected neighbour that also runs
+        // link-state routing (skipping hosts and non-TE routers); otherwise "peers"
+        // is a space-separated list of the peer-facing interface names.
+        const char *peers = par("peers");
+        if (!strcmp(peers, "auto")) {
+            for (auto& link : tedmod->ted) {
+                if (link.advrouter != routerId) // not one of our local links
+                    continue;
+                if (link.linkid.isUnspecified()) // neighbour has no router id (e.g. a host)
+                    continue;
+                cModule *peerNode = L3AddressResolver().findHostWithAddress(L3Address(link.remote));
+                if (peerNode != nullptr && moduleContainsLinkStateRouting(peerNode))
+                    peerIfAddrs.push_back(link.local);
+            }
+        }
+        else {
+            cStringTokenizer tokenizer(peers);
+            IInterfaceTable *ift = getModuleFromPar<IInterfaceTable>(par("interfaceTableModule"), this);
+            const char *token;
+            while ((token = tokenizer.nextToken()) != nullptr) {
+                peerIfAddrs.push_back(CHK(ift->findInterfaceByName(token))->getProtocolData<Ipv4InterfaceData>()->getIPAddress());
+            }
         }
 
         // schedule start of flooding link state info

src/inet/node/mpls/MplsRouterBase.ned

@@ -31,7 +31,7 @@ module MplsRouterBase extends Router
 {
     parameters:
         @display("i=abstract/router");
-        string peers;
+        string peers = default("auto"); // RSVP peers; "auto" derives them from the TED (see ~RsvpTe)
         string routerId = default("auto");
         *.routingTable.routerId = this.routerId;
         *.tedModule = default(absPath(".ted"));