This module configures NextHopRoutingTable modules for a network. More...

#include <NextHopNetworkConfigurator.h>

Inheritance diagram for inet::NextHopNetworkConfigurator:

Protected Member Functions
virtual void	initialize (int stage) override

virtual IRoutingTable *	findRoutingTable (Node *node) override

virtual void	addStaticRoutes (Topology &topology)
	Adds static routes to all routing tables in the network. More...

virtual void	dumpRoutes (Topology &topology)

Protected Member Functions inherited from inet::L3NetworkConfiguratorBase
virtual int	numInitStages () const override

virtual void	handleMessage (cMessage *msg) override

virtual void	extractTopology (Topology &topology)
	Extracts network topology by walking through the module hierarchy. More...

virtual void	extractWiredNeighbors (Topology &topology, Topology::Link linkOut, LinkInfo linkInfo, std::map< int, NetworkInterface * > &interfacesSeen, std::vector< Node * > &nodesVisited)

virtual void	extractWirelessNeighbors (Topology &topology, const char wirelessId, LinkInfo linkInfo, std::map< int, NetworkInterface * > &interfacesSeen, std::vector< Node * > &nodesVisited)

virtual void	extractDeviceNeighbors (Topology &topology, Node node, LinkInfo linkInfo, std::map< int, NetworkInterface * > &interfacesSeen, std::vector< Node * > &deviceNodesVisited)

virtual InterfaceInfo *	determineGatewayForLink (LinkInfo *linkInfo)
	If this link has exactly one node that connects to other links as well, we can assume it is a "gateway" and return that (we'll use it in routing); otherwise return nullptr. More...

virtual double	computeNodeWeight (Node node, const char metric, cXMLElement *parameters)

virtual double	computeLinkWeight (Link link, const char metric, cXMLElement *parameters)

virtual double	computeWiredLinkWeight (Link link, const char metric, cXMLElement *parameters)

virtual double	computeWirelessLinkWeight (Link link, const char metric, cXMLElement *parameters)

virtual bool	isBridgeNode (Node *node)

virtual bool	isWirelessInterface (NetworkInterface *networkInterface)

virtual std::string	getWirelessId (NetworkInterface *networkInterface)
	If this function returns the same string for two wireless interfaces, they will be regarded as being in the same wireless network. More...

virtual InterfaceInfo *	createInterfaceInfo (Topology &topology, Node node, LinkInfo linkInfo, NetworkInterface *networkInterface)

virtual Topology::Link *	findLinkOut (Node *node, int gateId)

virtual InterfaceInfo *	findInterfaceInfo (Node node, NetworkInterface networkInterface)

virtual IInterfaceTable *	findInterfaceTable (Node *node)

virtual void	dumpTopology (Topology &topology)

Protected Member Functions inherited from inet::L3AddressResolver
virtual bool	getIpv4AddressFrom (L3Address &retAddr, IInterfaceTable *ift, bool netmask)

virtual bool	getIpv6AddressFrom (L3Address &retAddr, IInterfaceTable *ift, bool netmask)

virtual bool	getMacAddressFrom (L3Address &retAddr, IInterfaceTable *ift, bool netmask)

virtual bool	getModulePathAddressFrom (L3Address &retAddr, IInterfaceTable *ift, bool netmask)

virtual bool	getModuleIdAddressFrom (L3Address &retAddr, IInterfaceTable *ift, bool netmask)

virtual bool	getInterfaceIpv4Address (L3Address &ret, NetworkInterface *ie, bool mask)

virtual bool	getInterfaceIpv6Address (L3Address &ret, NetworkInterface *ie, bool mask)

virtual bool	getInterfaceMacAddress (L3Address &ret, NetworkInterface *ie, bool mask)

virtual bool	getInterfaceModulePathAddress (L3Address &ret, NetworkInterface *ie, bool mask)

virtual bool	getInterfaceModuleIdAddress (L3Address &ret, NetworkInterface *ie, bool mask)

virtual void	doCollectNetworkNodes (cModule parent, std::vector< cModule > &result)

Protected Attributes
bool	addStaticRoutesParameter

Topology	topology

Protected Attributes inherited from inet::L3NetworkConfiguratorBase
double	minLinkWeight = NaN

bool	configureIsolatedNetworksSeparatly = false

cXMLElement *	configuration = nullptr

Additional Inherited Members
Public Types inherited from inet::L3AddressResolver
enum	{ ADDR_IPv4 = 1, ADDR_IPv6 = 2, ADDR_MAC = 4, ADDR_MODULEPATH = 8, ADDR_MODULEID = 16, ADDR_MASK = 32 }

Public Member Functions inherited from inet::L3AddressResolver
	L3AddressResolver ()

virtual	~L3AddressResolver ()

virtual L3Address	resolve (const char *str, int addrType=DEFAULT_ADDR_TYPE)
	Accepts dotted decimal notation ("127.0.0.1"), module name of the host or router ("host[2]"), and empty string (""). More...

virtual std::vector< L3Address >	resolve (std::vector< std::string > strs, int addrType=DEFAULT_ADDR_TYPE)
	Utility function: Calls resolve() for each item in the string vector, and returns the result in an address vector. More...

virtual bool	tryResolve (const char *str, L3Address &result, int addrType=DEFAULT_ADDR_TYPE)
	Similar to resolve(), but returns false (instead of throwing an error) if the address cannot be resolved because the given host (or interface) doesn't have an address assigned yet. More...

bool	tryParse (L3Address &result, const char *addr, int addrType=DEFAULT_ADDR_TYPE)

virtual L3Address	addressOf (cModule *host, int addrType=DEFAULT_ADDR_TYPE)
	Returns Ipv4 or Ipv6 address of the given host or router. More...

virtual L3Address	addressOf (cModule host, const char ifname, int addrType=DEFAULT_ADDR_TYPE)
	Similar to addressOf(), but only looks at the given interface. More...

virtual L3Address	addressOf (cModule host, cModule destmod, int addrType=DEFAULT_ADDR_TYPE)
	Returns Ipv4 or Ipv6 address of the given host or router. More...

virtual L3Address	routerIdOf (cModule *host)
	Returns the router Id of the given router. More...

virtual L3Address	getAddressFrom (IInterfaceTable *ift, int addrType=DEFAULT_ADDR_TYPE)
	Returns the Ipv4 or Ipv6 address of the given host or router, given its IInterfaceTable module. More...

virtual L3Address	getAddressFrom (NetworkInterface *ie, int addrType=DEFAULT_ADDR_TYPE)
	Returns the Ipv4 or Ipv6 address of the given interface (of a host or router). More...

virtual IInterfaceTable *	interfaceTableOf (cModule *host)
	The function tries to look up the IInterfaceTable module as submodule `"interfaceTable"` or `"networkLayer.interfaceTable"` within the host/router module. More...

virtual IIpv4RoutingTable *	getIpv4RoutingTableOf (cModule *host)
	The function tries to look up the IIpv4RoutingTable module as submodule `"routingTable"` or `"networkLayer.routingTable"` within the host/router module. More...

virtual Ipv6RoutingTable *	getIpv6RoutingTableOf (cModule *host)
	The function tries to look up the Ipv6RoutingTable module as submodule `"routingTable6"` or `"networkLayer.routingTable6"` within the host/router module. More...

virtual IInterfaceTable *	findInterfaceTableOf (cModule *host)
	Like interfaceTableOf(), but doesn't throw error if not found. More...

virtual IIpv4RoutingTable *	findIpv4RoutingTableOf (cModule *host)
	Like routingTableOf(), but doesn't throw error if not found. More...

virtual Ipv6RoutingTable *	findIpv6RoutingTableOf (cModule *host)
	Like interfaceTableOf(), but doesn't throw error if not found. More...

virtual NextHopRoutingTable *	findNextHopRoutingTableOf (cModule *host)
	Like interfaceTableOf(), but doesn't throw error if not found. More...

virtual std::vector< cModule * >	collectNetworkNodes ()
	Collect modules that represent network nodes, as denoted by the @networkNode(true) annotation. More...

virtual cModule *	findHostWithAddress (const L3Address &addr)
	Find the Host with the specified address. More...

virtual NetworkInterface *	findInterfaceWithMacAddress (const MacAddress &addr)
	Find the interface with the specified MAC address. More...

virtual cModule *	findHostWithMacAddress (const MacAddress &addr)
	Find the host with the specified MAC address. More...

Detailed Description

This module configures NextHopRoutingTable modules for a network.

For more info please see the NED file.

Member Function Documentation

◆ addStaticRoutes()

void inet::NextHopNetworkConfigurator::addStaticRoutes ( Topology & topology )

protectedvirtual

Adds static routes to all routing tables in the network.

The algorithm uses Dijkstra's weighted shortest path algorithm. May add default routes and subnet routes if possible and requested.

 {
     // TODO it should be configurable (via xml?) which nodes need static routes filled in automatically
     // add static routes for all routing tables
     for (int i = 0; i < topology.getNumNodes(); i++) {
         Node *sourceNode = (Node *)topology.getNode(i);
         if (isBridgeNode(sourceNode))
             continue;
         NextHopRoutingTable *sourceRoutingTable = dynamic_cast<NextHopRoutingTable *>(sourceNode->routingTable);
  
         // calculate shortest paths from everywhere to sourceNode
         // we are going to use the paths in reverse direction (assuming all links are bidirectional)
         topology.calculateWeightedSingleShortestPathsTo(sourceNode);
  
         // add a route to all destinations in the network
         for (int j = 0; j < topology.getNumNodes(); j++) {
             // extract destination
             Node *destinationNode = (Node *)topology.getNode(j);
             if (sourceNode == destinationNode)
                 continue;
             if (destinationNode->getNumPaths() == 0)
                 continue;
             if (isBridgeNode(destinationNode))
                 continue;
             if (std::isinf(destinationNode->getDistanceToTarget()))
                 continue;
  
 //            int destinationGateId = destinationNode->getPath(0)->getLocalGateId();
             IInterfaceTable *destinationInterfaceTable = destinationNode->interfaceTable;
  
             // determine next hop interface
             // find next hop interface (the last IP interface on the path that is not in the source node)
             Node *node = destinationNode;
             Link *link = nullptr;
             InterfaceInfo *nextHopInterfaceInfo = nullptr;
             while (node != sourceNode) {
                 link = (Link *)node->getPath(0);
                 if (node != sourceNode && !isBridgeNode(node) && link->sourceInterfaceInfo && link->sourceInterfaceInfo->networkInterface->findProtocolData<NextHopInterfaceData>())
                     nextHopInterfaceInfo = static_cast<InterfaceInfo *>(link->sourceInterfaceInfo);
                 node = (Node *)node->getPath(0)->getLinkOutRemoteNode();
             }
  
             // determine source interface
             if (nextHopInterfaceInfo && link->destinationInterfaceInfo && link->destinationInterfaceInfo->addStaticRoute) {
                 NetworkInterface *nextHopNetworkInterface = nextHopInterfaceInfo->networkInterface;
                 NetworkInterface *sourceNetworkInterface = link->destinationInterfaceInfo->networkInterface;
                 // add the same routes for all destination interfaces (IP packets are accepted from any interface at the destination)
                 for (int j = 0; j < destinationInterfaceTable->getNumInterfaces(); j++) {
                     NetworkInterface *destinationNetworkInterface = destinationInterfaceTable->getInterface(j);
                     auto destIeNextHopInterfaceData = destinationNetworkInterface->findProtocolData<NextHopInterfaceData>();
                     if (destIeNextHopInterfaceData == nullptr)
                         continue;
                     L3Address destinationAddress = destIeNextHopInterfaceData->getAddress();
                     if (!destinationNetworkInterface->isLoopback() && !destinationAddress.isUnspecified() && nextHopNetworkInterface->findProtocolData<NextHopInterfaceData>()) {
                         NextHopRoute *route = new NextHopRoute();
                         route->setSourceType(IRoute::MANUAL);
                         route->setDestination(destinationAddress);
                         route->setInterface(sourceNetworkInterface);
                         L3Address nextHopAddress = nextHopNetworkInterface->getProtocolData<NextHopInterfaceData>()->getAddress();
                         if (nextHopAddress != destinationAddress)
                             route->setNextHop(nextHopAddress);
                         EV_DEBUG << "Adding route " << sourceNetworkInterface->getInterfaceFullPath() << " -> " << destinationNetworkInterface->getInterfaceFullPath() << " as " << route->str() << endl;
                         sourceRoutingTable->addRoute(route);
                     }
                 }
             }
         }
     }
 }

Referenced by initialize().

◆ dumpRoutes()

void inet::NextHopNetworkConfigurator::dumpRoutes ( Topology & topology )

protectedvirtual

 {
     for (int i = 0; i < topology.getNumNodes(); i++) {
         Node *node = (Node *)topology.getNode(i);
         if (node->routingTable) {
             EV_INFO << "Node " << node->module->getFullPath() << endl;
             node->routingTable->printRoutingTable();
             if (node->routingTable->getNumMulticastRoutes() > 0)
                 ; // TODO node->routingTable->printMulticastRoutingTable();
         }
     }
 }

Referenced by initialize().

◆ findRoutingTable()

IRoutingTable * inet::NextHopNetworkConfigurator::findRoutingTable ( Node * node )

overrideprotectedvirtual

Reimplemented from inet::L3NetworkConfiguratorBase.

 {
     return L3AddressResolver().findNextHopRoutingTableOf(node->module);
 }

◆ initialize()

void inet::NextHopNetworkConfigurator::initialize ( int stage )

overrideprotectedvirtual

Reimplemented from inet::L3NetworkConfiguratorBase.

 {
     L3NetworkConfiguratorBase::initialize(stage);
     if (stage == INITSTAGE_NETWORK_CONFIGURATION) {
         long initializeStartTime = clock();
         Topology topology;
         // extract topology into the Topology object, then fill in a LinkInfo[] vector
         TIME(extractTopology(topology));
         // dump the result if requested
         if (par("dumpTopology"))
             TIME(dumpTopology(topology));
         // calculate shortest paths, and add corresponding static routes
         if (par("addStaticRoutes"))
             TIME(addStaticRoutes(topology));
         // dump routes to module output
         if (par("dumpRoutes"))
             TIME(dumpRoutes(topology));
         printElapsedTime("initialize", initializeStartTime);
     }
 }

Member Data Documentation

◆ addStaticRoutesParameter

bool inet::NextHopNetworkConfigurator::addStaticRoutesParameter

protected

◆ topology

Topology inet::NextHopNetworkConfigurator::topology

protected

Referenced by addStaticRoutes(), dumpRoutes(), and initialize().

The documentation for this class was generated from the following files:

Protected Member Functions

Protected Attributes

Additional Inherited Members