inet::Ipv4RoutingTable Class Reference

Represents the routing table. More...

#include <Ipv4RoutingTable.h>

Inheritance diagram for inet::Ipv4RoutingTable:

Classes
class	RouteLessThan

Public Member Functions
	Ipv4RoutingTable ()
virtual	~Ipv4RoutingTable ()
virtual void	printRoutingTable () const override
	For debugging. More...
virtual void	printMulticastRoutingTable () const override
	For debugging. More...
virtual cModule *	getHostModule () override
	Returns the host or router this routing table lives in. More...
Interfaces
virtual NetworkInterface *	getInterfaceByAddress (const Ipv4Address &address) const override
	Returns an interface given by its address. More...
virtual bool	isAdminDistEnabled () const override
	AdminDist on/off. More...
virtual bool	isForwardingEnabled () const override
	Ipv4 forwarding on/off. More...
virtual bool	isMulticastForwardingEnabled () const override
	Ipv4 multicast forwarding on/off. More...
virtual Ipv4Address	getRouterId () const override
	Returns routerId. More...
virtual void	setRouterId (Ipv4Address a) override
	Sets routerId. More...
Routing functions (query the route table)
virtual bool	isLocalAddress (const Ipv4Address &dest) const override
	Checks if the address is a local one, i.e. More...
virtual bool	isLocalBroadcastAddress (const Ipv4Address &dest) const override
	Checks if the address is a local network broadcast address, i.e. More...
virtual NetworkInterface *	findInterfaceByLocalBroadcastAddress (const Ipv4Address &dest) const override
	Returns the interface entry having the specified address as its local broadcast address. More...
virtual Ipv4Route *	findBestMatchingRoute (const Ipv4Address &dest) const override
	The routing function. More...
virtual NetworkInterface *	getInterfaceForDestAddr (const Ipv4Address &dest) const override
	Convenience function based on findBestMatchingRoute(). More...
virtual Ipv4Address	getGatewayForDestAddr (const Ipv4Address &dest) const override
	Convenience function based on findBestMatchingRoute(). More...
Multicast routing functions
virtual bool	isLocalMulticastAddress (const Ipv4Address &dest) const override
	Checks if the address is in one of the local multicast group address list. More...
virtual const Ipv4MulticastRoute *	findBestMatchingMulticastRoute (const Ipv4Address &origin, const Ipv4Address &group) const override
	Returns route for a multicast source and multicast group. More...
Public Member Functions inherited from inet::IIpv4RoutingTable
virtual	~IIpv4RoutingTable ()
virtual NetworkInterface *	getInterfaceByAddress (const L3Address &address) const=0
	Returns an interface given by its address. More...
virtual bool	isLocalAddress (const L3Address &dest) const=0
	Checks if the address is a local one, i.e. More...
virtual IRoute *	findBestMatchingRoute (const L3Address &dest) const=0
	The routing function. More...
virtual bool	isLocalMulticastAddress (const L3Address &dest) const=0
	Checks if the address is in one of the local multicast group address list. More...
virtual IMulticastRoute *	findBestMatchingMulticastRoute (const L3Address &origin, const L3Address &group) const=0
	Returns route for a multicast origin and group. More...
virtual void	addRoute (IRoute *entry)=0
	Adds a route to the routing table. More...
virtual IRoute *	removeRoute (IRoute *entry)=0
	Removes the given route from the routing table, and returns it. More...
virtual bool	deleteRoute (IRoute *entry)=0
	Deletes the given route from the routing table. More...
virtual void	addMulticastRoute (IMulticastRoute *entry)=0
	Adds a multicast route to the routing table. More...
virtual IMulticastRoute *	removeMulticastRoute (IMulticastRoute *entry)=0
	Removes the given route from the routing table, and returns it. More...
virtual bool	deleteMulticastRoute (IMulticastRoute *entry)=0
	Deletes the given multicast route from the routing table. More...
Public Member Functions inherited from inet::IRoutingTable
virtual	~IRoutingTable ()
Public Member Functions inherited from inet::ILifecycle
virtual	~ILifecycle ()

Protected Types
typedef Ipv4MulticastRoute::OutInterface	OutInterface
typedef Ipv4MulticastRoute::OutInterfaceVector	OutInterfaceVector
typedef std::map< Ipv4Address, Ipv4Route * >	RoutingCache
typedef std::set< Ipv4Address >	AddressSet

Protected Member Functions
virtual void	configureRouterId ()
virtual void	updateNetmaskRoutes ()
virtual Ipv4Route *	createNewRoute ()
virtual void	refreshDisplay () const override
virtual void	deleteInterfaceRoutes (const NetworkInterface *entry)
virtual void	invalidateCache ()
bool	routeLessThan (const Ipv4Route *a, const Ipv4Route *b) const
void	internalAddRoute (Ipv4Route *entry)
Ipv4Route *	internalRemoveRoute (Ipv4Route *entry)
void	internalAddMulticastRoute (Ipv4MulticastRoute *entry)
Ipv4MulticastRoute *	internalRemoveMulticastRoute (Ipv4MulticastRoute *entry)
virtual int	numInitStages () const override
virtual void	initialize (int stage) override
virtual void	handleMessage (cMessage *) override
	Raises an error. More...
virtual void	receiveSignal (cComponent *source, simsignal_t signalID, cObject *obj, cObject *details) override
	Called by the signal handler whenever a change of a category occurs to which this client has subscribed. More...

Static Protected Member Functions
static bool	multicastRouteLessThan (const Ipv4MulticastRoute *a, const Ipv4MulticastRoute *b)

Protected Attributes
ModuleRefByPar< IInterfaceTable >	ift
Ipv4Address	routerId
const char *	netmaskRoutes = nullptr
bool	forwarding = false
bool	multicastForward = false
bool	isNodeUp = false
bool	useAdminDist = false
RoutingCache	routingCache
AddressSet	localBroadcastAddresses

Private Types
typedef std::vector< Ipv4Route * >	RouteVector
typedef std::vector< Ipv4MulticastRoute * >	MulticastRouteVector

Private Attributes
RouteVector	routes
MulticastRouteVector	multicastRoutes

Route table manipulation
virtual int	getNumRoutes () const override
	Returns the total number of routes (unicast, multicast, plus the default route). More...
virtual Ipv4Route *	getRoute (int k) const override
	Returns the kth route. More...
virtual Ipv4Route *	getDefaultRoute () const override
	Finds and returns the default route, or nullptr if it doesn't exist. More...
virtual void	addRoute (Ipv4Route *entry) override
	Adds a route to the routing table. More...
virtual Ipv4Route *	removeRoute (Ipv4Route *entry) override
	Removes the given route from the routing table, and returns it. More...
virtual bool	deleteRoute (Ipv4Route *entry) override
	Removes the given route from the routing table, and delete it. More...
virtual int	getNumMulticastRoutes () const override
	Returns the total number of multicast routes. More...
virtual Ipv4MulticastRoute *	getMulticastRoute (int k) const override
	Returns the kth multicast route. More...
virtual void	addMulticastRoute (Ipv4MulticastRoute *entry) override
	Adds a multicast route to the routing table. More...
virtual Ipv4MulticastRoute *	removeMulticastRoute (Ipv4MulticastRoute *entry) override
	Removes the given route from the routing table, and returns it. More...
virtual bool	deleteMulticastRoute (Ipv4MulticastRoute *entry) override
	Deletes the given multicast route from the routing table. More...
virtual void	purge () override
	Deletes invalid routes from the routing table. More...
virtual std::vector< Ipv4Address >	gatherAddresses () const override
	Utility function: Returns a vector of all addresses of the node. More...
virtual void	routeChanged (Ipv4Route *entry, int fieldCode) override
	To be called from route objects whenever a field changes. More...
virtual void	multicastRouteChanged (Ipv4MulticastRoute *entry, int fieldCode) override
	To be called from multicast route objects whenever a field changes. More...
virtual bool	handleOperationStage (LifecycleOperation *operation, IDoneCallback *doneCallback) override
	ILifecycle method. More...
virtual L3Address	getRouterIdAsGeneric () const override
	Returns routerId. More...
virtual bool	isLocalAddress (const L3Address &dest) const override
	Checks if the address is a local one, i.e. More...
virtual NetworkInterface *	getInterfaceByAddress (const L3Address &address) const override
	Returns an interface given by its address. More...
virtual IRoute *	findBestMatchingRoute (const L3Address &dest) const override
	The routing function. More...
virtual NetworkInterface *	getOutputInterfaceForDestination (const L3Address &dest) const override
	Convenience function based on findBestMatchingRoute(). More...
virtual L3Address	getNextHopForDestination (const L3Address &dest) const override
	Convenience function based on findBestMatchingRoute(). More...
virtual bool	isLocalMulticastAddress (const L3Address &dest) const override
	Checks if the address is in one of the local multicast group address list. More...
virtual IMulticastRoute *	findBestMatchingMulticastRoute (const L3Address &origin, const L3Address &group) const override
	Returns route for a multicast origin and group. More...
virtual IRoute *	createRoute () override
virtual void	addRoute (IRoute *entry) override
	Adds a route to the routing table. More...
virtual IRoute *	removeRoute (IRoute *entry) override
	Removes the given route from the routing table, and returns it. More...
virtual bool	deleteRoute (IRoute *entry) override
	Deletes the given route from the routing table. More...
virtual void	addMulticastRoute (IMulticastRoute *entry) override
	Adds a multicast route to the routing table. More...
virtual IMulticastRoute *	removeMulticastRoute (IMulticastRoute *entry) override
	Removes the given route from the routing table, and returns it. More...
virtual bool	deleteMulticastRoute (IMulticastRoute *entry) override
	Deletes the given multicast route from the routing table. More...

Detailed Description

Represents the routing table.

This object has one instance per host or router. It has methods to manage the route table and the interface table, so one can achieve functionality similar to the "route" and "ifconfig" commands.

See the NED documentation for general overview.

This is a simple module without gates, it requires function calls to it (message handling does nothing). Methods are provided for reading and updating the interface table and the route table, as well as for unicast and multicast routing.

Interfaces are dynamically registered: at the start of the simulation, every L2 module adds its own interface entry to the table.

The route table is read from a file (RoutingTableParser); the file can also fill in or overwrite interface settings. The route table can also be read and modified during simulation, typically by routing protocol implementations (e.g. OSPF).

Entries in the route table are represented by Ipv4Route objects. Ipv4Route objects can be polymorphic: if a routing protocol needs to store additional data, it can simply subclass from Ipv4Route, and add the derived object to the table.

Uses RoutingTableParser to read routing files (.irt, .mrt).

See also

NetworkInterface, Ipv4InterfaceData, Ipv4Route

Member Typedef Documentation

AddressSet

typedef std::set<Ipv4Address> inet::Ipv4RoutingTable::AddressSet

protected

MulticastRouteVector

typedef std::vector<Ipv4MulticastRoute *> inet::Ipv4RoutingTable::MulticastRouteVector

private

OutInterface

typedef Ipv4MulticastRoute::OutInterface inet::Ipv4RoutingTable::OutInterface

protected

OutInterfaceVector

typedef Ipv4MulticastRoute::OutInterfaceVector inet::Ipv4RoutingTable::OutInterfaceVector

protected

RouteVector

typedef std::vector<Ipv4Route *> inet::Ipv4RoutingTable::RouteVector

private

RoutingCache

typedef std::map<Ipv4Address, Ipv4Route *> inet::Ipv4RoutingTable::RoutingCache

protected

Constructor & Destructor Documentation

Ipv4RoutingTable()

inet::Ipv4RoutingTable::Ipv4RoutingTable ( )

inline

{}

~Ipv4RoutingTable()

inet::Ipv4RoutingTable::~Ipv4RoutingTable ( )

virtual

{
    for (auto& elem : routes)
        delete elem;
    for (auto& elem : multicastRoutes)
        delete elem;
}

Member Function Documentation

addMulticastRoute() [1/2]

virtual void inet::Ipv4RoutingTable::addMulticastRoute ( IMulticastRoute *  entry )

inlineoverrideprivatevirtual

Adds a multicast route to the routing table.

Routes are allowed to be modified while in the routing table. (There is a notification mechanism that allows routing table internals to be updated on a routing entry change.)

Implements inet::IRoutingTable.

{ addMulticastRoute(check_and_cast<Ipv4MulticastRoute *>(entry)); }

Referenced by addMulticastRoute().

addMulticastRoute() [2/2]

void inet::Ipv4RoutingTable::addMulticastRoute ( Ipv4MulticastRoute *  entry )

overridevirtual

Adds a multicast route to the routing table.

Routes are allowed to be modified while in the routing table. (There is a notification mechanism that allows routing table internals to be updated on a routing entry change.)

Implements inet::IIpv4RoutingTable.

{
    Enter_Method("addMulticastRoute(...)");
    internalAddMulticastRoute(entry);
    emit(mrouteAddedSignal, entry);
}

addRoute() [1/2]

void inet::Ipv4RoutingTable::addRoute ( Ipv4Route *  entry )

overridevirtual

Adds a route to the routing table.

Routes are allowed to be modified while in the routing table. (There is a notification mechanism that allows routing table internals to be updated on a routing entry change.)

Implements inet::IIpv4RoutingTable.

{
    Enter_Method("addRoute(...)");
    // This method should be called before calling entry->str()
    internalAddRoute(entry);
    EV_INFO << "add route " << entry->str() << "\n";
    emit(routeAddedSignal, entry);
}

addRoute() [2/2]

virtual void inet::Ipv4RoutingTable::addRoute ( IRoute *  entry )

inlineoverrideprivatevirtual

Adds a route to the routing table.

Routes are allowed to be modified while in the routing table. (There is a notification mechanism that allows routing table internals to be updated on a routing entry change.)

Implements inet::IRoutingTable.

{ addRoute(check_and_cast<Ipv4Route *>(entry)); }

Referenced by addRoute().

configureRouterId()

void inet::Ipv4RoutingTable::configureRouterId ( )

protectedvirtual

{
    if (routerId.isUnspecified()) { // not yet configured
        const char *routerIdStr = par("routerId");
        if (!strcmp(routerIdStr, "auto")) { // non-"auto" cases already handled earlier
            // choose highest interface address as routerId
            for (int i = 0; i < ift->getNumInterfaces(); ++i) {
                NetworkInterface *ie = ift->getInterface(i);
                if (!ie->isLoopback()) {
                    auto ipv4Data = ie->findProtocolData<Ipv4InterfaceData>();
                    if (ipv4Data && ipv4Data->getIPAddress().getInt() > routerId.getInt()) {
                        routerId = ipv4Data->getIPAddress();
                    }
                }
            }
        }
    }
    else { // already configured
           // if there is no interface with routerId yet, assign it to the loopback address;
           // TODO find out if this is a good practice, in which situations it is useful etc.
        if (getInterfaceByAddress(routerId) == nullptr) {
            NetworkInterface *lo0 = CHK(ift->findFirstLoopbackInterface());
            auto ipv4Data = lo0->getProtocolDataForUpdate<Ipv4InterfaceData>();
            ipv4Data->setIPAddress(routerId);
            ipv4Data->setNetmask(Ipv4Address::ALLONES_ADDRESS);
        }
    }
}

createNewRoute()

Ipv4Route * inet::Ipv4RoutingTable::createNewRoute ( )

protectedvirtual

{
    return new Ipv4Route();
}

createRoute()

virtual IRoute* inet::Ipv4RoutingTable::createRoute ( )

inlineoverridevirtual

Implements inet::IRoutingTable.

{ return new Ipv4Route(); }

deleteInterfaceRoutes()

void inet::Ipv4RoutingTable::deleteInterfaceRoutes ( const NetworkInterface *  entry )

protectedvirtual

{
    // delete unicast routes using this interface
    for (auto it = routes.begin(); it != routes.end();) {
        Ipv4Route *route = *it;
        if (route->getInterface() == entry) {
            it = routes.erase(it);
            invalidateCache();
            ASSERT(route->getRoutingTable() == this); // still filled in, for the listeners' benefit
            emit(routeDeletedSignal, route);
            delete route;
        }
        else
            ++it;
    }
 
    // delete or update multicast routes:
    //   1. delete routes has entry as input interface
    //   2. remove entry from output interface list
    for (auto it = multicastRoutes.begin(); it != multicastRoutes.end();) {
        Ipv4MulticastRoute *route = *it;
        if (route->getInInterface() && route->getInInterface()->getInterface() == entry) {
            it = multicastRoutes.erase(it);
            invalidateCache();
            ASSERT(route->getRoutingTable() == this); // still filled in, for the listeners' benefit
            emit(mrouteDeletedSignal, route);
            delete route;
        }
        else {
            if (route->removeOutInterface(entry)) {
                invalidateCache();
                emit(mrouteChangedSignal, route);
            }
            ++it;
        }
    }
}

deleteMulticastRoute() [1/2]

virtual bool inet::Ipv4RoutingTable::deleteMulticastRoute ( IMulticastRoute *  entry )

inlineoverrideprivatevirtual

Deletes the given multicast route from the routing table.

Returns true if the route was deleted, and false if it was not in the routing table.

Implements inet::IRoutingTable.

{ return deleteMulticastRoute(check_and_cast<Ipv4MulticastRoute *>(entry)); }

Referenced by deleteMulticastRoute().

deleteMulticastRoute() [2/2]

bool inet::Ipv4RoutingTable::deleteMulticastRoute ( Ipv4MulticastRoute *  entry )

overridevirtual

Deletes the given multicast route from the routing table.

Returns true if the route was deleted, and false if it was not in the routing table.

Implements inet::IIpv4RoutingTable.

{
    Enter_Method("deleteMulticastRoute(...)");
    entry = internalRemoveMulticastRoute(entry);
    if (entry != nullptr) {
        ASSERT(entry->getRoutingTable() == this); // still filled in, for the listeners' benefit
        emit(mrouteDeletedSignal, entry);
        delete entry;
    }
    return entry != nullptr;
}

deleteRoute() [1/2]

bool inet::Ipv4RoutingTable::deleteRoute ( Ipv4Route *  entry )

overridevirtual

Removes the given route from the routing table, and delete it.

Returns true if the route was deleted, and false if it was not in the routing table.

Implements inet::IIpv4RoutingTable.

{
    Enter_Method("deleteRoute(...)");
 
    entry = internalRemoveRoute(entry);
 
    if (entry != nullptr) {
        EV_INFO << "delete route " << entry->str() << "\n";
        ASSERT(entry->getRoutingTable() == this); // still filled in, for the listeners' benefit
        emit(routeDeletedSignal, entry);
        delete entry;
    }
    return entry != nullptr;
}

deleteRoute() [2/2]

virtual bool inet::Ipv4RoutingTable::deleteRoute ( IRoute *  entry )

inlineoverrideprivatevirtual

Deletes the given route from the routing table.

Returns true if the route was deleted, and false if it was not in the routing table.

Implements inet::IRoutingTable.

{ return deleteRoute(check_and_cast<Ipv4Route *>(entry)); }

Referenced by deleteRoute().

findBestMatchingMulticastRoute() [1/2]

const Ipv4MulticastRoute * inet::Ipv4RoutingTable::findBestMatchingMulticastRoute ( const Ipv4Address &  origin, const Ipv4Address &  group  ) const

overridevirtual

Returns route for a multicast source and multicast group.

Implements inet::IIpv4RoutingTable.

{
    Enter_Method("getMulticastRoutesFor(%u.%u.%u.%u, %u.%u.%u.%u)",
            origin.getDByte(0), origin.getDByte(1), origin.getDByte(2), origin.getDByte(3),
            group.getDByte(0), group.getDByte(1), group.getDByte(2), group.getDByte(3)); // note: str().c_str() too slow here here
 
    // TODO caching?
 
    for (auto e : multicastRoutes) {
        if (e->isValid() && e->matches(origin, group))
            return e;
    }
 
    return nullptr;
}

findBestMatchingMulticastRoute() [2/2]

virtual IMulticastRoute* inet::Ipv4RoutingTable::findBestMatchingMulticastRoute ( const L3Address &  origin, const L3Address &  group  ) const

inlineoverridevirtual

Returns route for a multicast origin and group.

Implements inet::IRoutingTable.

{ return const_cast<Ipv4MulticastRoute *>(findBestMatchingMulticastRoute(origin.toIpv4(), group.toIpv4())); } // TODO remove 'const' from Ipv4 method?

Referenced by findBestMatchingMulticastRoute().

findBestMatchingRoute() [1/2]

Ipv4Route * inet::Ipv4RoutingTable::findBestMatchingRoute ( const Ipv4Address &  dest ) const

overridevirtual

The routing function.

Performs longest prefix match for the given destination address, and returns the resulting route. Returns nullptr if there is no matching route.

Implements inet::IIpv4RoutingTable.

{
    Enter_Method("findBestMatchingRoute(%u.%u.%u.%u)", dest.getDByte(0), dest.getDByte(1), dest.getDByte(2), dest.getDByte(3)); // note: str().c_str() too slow here
 
    auto it = routingCache.find(dest);
    if (it != routingCache.end()) {
        if (it->second == nullptr || it->second->isValid())
            return it->second;
    }
 
    // find best match (one with longest prefix)
    // default route has zero prefix length, so (if exists) it'll be selected as last resort
    Ipv4Route *bestRoute = nullptr;
    for (auto e : routes) {
        if (e->isValid()) {
            if (Ipv4Address::maskedAddrAreEqual(dest, e->getDestination(), e->getNetmask())) { // match
                bestRoute = const_cast<Ipv4Route *>(e);
                break;
            }
        }
    }
 
    routingCache[dest] = bestRoute;
    return bestRoute;
}

findBestMatchingRoute() [2/2]

virtual IRoute* inet::Ipv4RoutingTable::findBestMatchingRoute ( const L3Address &  dest ) const

inlineoverridevirtual

The routing function.

Performs longest prefix match for the given destination address, and returns the resulting route. Returns nullptr if there is no matching route.

Implements inet::IRoutingTable.

{ return findBestMatchingRoute(dest.toIpv4()); }

Referenced by findBestMatchingRoute().

findInterfaceByLocalBroadcastAddress()

NetworkInterface * inet::Ipv4RoutingTable::findInterfaceByLocalBroadcastAddress ( const Ipv4Address &  dest ) const

overridevirtual

Returns the interface entry having the specified address as its local broadcast address.

Implements inet::IIpv4RoutingTable.

{
    Enter_Method("findInterfaceByLocalBroadcastAddress(%u.%u.%u.%u)", dest.getDByte(0), dest.getDByte(1), dest.getDByte(2), dest.getDByte(3)); // note: str().c_str() too slow here
 
    for (int i = 0; i < ift->getNumInterfaces(); i++) {
        NetworkInterface *ie = ift->getInterface(i);
        if (!ie->isBroadcast())
            continue;
        Ipv4Address interfaceAddr = ie->getProtocolData<Ipv4InterfaceData>()->getIPAddress();
        Ipv4Address broadcastAddr = interfaceAddr.makeBroadcastAddress(ie->getProtocolData<Ipv4InterfaceData>()->getNetmask());
        if (broadcastAddr == dest)
            return ie;
    }
    return nullptr;
}

gatherAddresses()

std::vector< Ipv4Address > inet::Ipv4RoutingTable::gatherAddresses ( ) const

overridevirtual

Utility function: Returns a vector of all addresses of the node.

Implements inet::IIpv4RoutingTable.

{
    std::vector<Ipv4Address> addressvector;
 
    for (int i = 0; i < ift->getNumInterfaces(); ++i)
        addressvector.push_back(ift->getInterface(i)->getProtocolData<Ipv4InterfaceData>()->getIPAddress());
    return addressvector;
}

getDefaultRoute()

Ipv4Route * inet::Ipv4RoutingTable::getDefaultRoute ( ) const

overridevirtual

Finds and returns the default route, or nullptr if it doesn't exist.

Implements inet::IIpv4RoutingTable.

{
    // if exists default route entry, it is the last valid entry
    for (RouteVector::const_reverse_iterator i = routes.rbegin(); i != routes.rend() && (*i)->getNetmask().isUnspecified(); ++i) {
        if ((*i)->isValid())
            return *i;
    }
    return nullptr;
}

getGatewayForDestAddr()

Ipv4Address inet::Ipv4RoutingTable::getGatewayForDestAddr ( const Ipv4Address &  dest ) const

overridevirtual

Convenience function based on findBestMatchingRoute().

Returns the gateway for the destination address. Returns the unspecified address if the destination is not in routing table or the gateway field is not filled in in the route.

Implements inet::IIpv4RoutingTable.

{
    Enter_Method("getGatewayForDestAddr(%u.%u.%u.%u)", dest.getDByte(0), dest.getDByte(1), dest.getDByte(2), dest.getDByte(3)); // note: str().c_str() too slow here
 
    const Ipv4Route *e = findBestMatchingRoute(dest);
    return e ? e->getGateway() : Ipv4Address();
}

getHostModule()

cModule * inet::Ipv4RoutingTable::getHostModule ( )

overridevirtual

Returns the host or router this routing table lives in.

Implements inet::IIpv4RoutingTable.

{
    return findContainingNode(this);
}

getInterfaceByAddress() [1/2]

NetworkInterface * inet::Ipv4RoutingTable::getInterfaceByAddress ( const Ipv4Address &  address ) const

overridevirtual

Returns an interface given by its address.

Returns nullptr if not found.

Implements inet::IIpv4RoutingTable.

{
    Enter_Method("getInterfaceByAddress(%u.%u.%u.%u)", addr.getDByte(0), addr.getDByte(1), addr.getDByte(2), addr.getDByte(3)); // note: str().c_str() too slow here
    return ift->findInterfaceByAddress(addr);
}

getInterfaceByAddress() [2/2]

virtual NetworkInterface* inet::Ipv4RoutingTable::getInterfaceByAddress ( const L3Address &  address ) const

inlineoverridevirtual

Returns an interface given by its address.

Returns nullptr if not found.

Implements inet::IRoutingTable.

{ return getInterfaceByAddress(address.toIpv4()); }

Referenced by getInterfaceByAddress().

getInterfaceForDestAddr()

NetworkInterface * inet::Ipv4RoutingTable::getInterfaceForDestAddr ( const Ipv4Address &  dest ) const

overridevirtual

Convenience function based on findBestMatchingRoute().

Returns the output interface for the packets with dest as destination address, or nullptr if the destination is not in routing table.

Implements inet::IIpv4RoutingTable.

{
    Enter_Method("getInterfaceForDestAddr(%u.%u.%u.%u)", dest.getDByte(0), dest.getDByte(1), dest.getDByte(2), dest.getDByte(3)); // note: str().c_str() too slow here
 
    const Ipv4Route *e = findBestMatchingRoute(dest);
    return e ? e->getInterface() : nullptr;
}

getMulticastRoute()

virtual Ipv4MulticastRoute* inet::Ipv4RoutingTable::getMulticastRoute ( int  k ) const

inlineoverridevirtual

Returns the kth multicast route.

Implements inet::IIpv4RoutingTable.

{ return k >= 0 && static_cast<size_t>(k) < multicastRoutes.size() ? multicastRoutes[k] : nullptr; }

getNextHopForDestination()

virtual L3Address inet::Ipv4RoutingTable::getNextHopForDestination ( const L3Address &  dest ) const

inlineoverridevirtual

Convenience function based on findBestMatchingRoute().

Returns the gateway for the destination address. Returns the unspecified address if the destination is not in routing table or the gateway field is not filled in in the route.

Implements inet::IRoutingTable.

{ return getGatewayForDestAddr(dest.toIpv4()); } // TODO inconsistent names

getNumMulticastRoutes()

virtual int inet::Ipv4RoutingTable::getNumMulticastRoutes ( ) const

inlineoverridevirtual

Returns the total number of multicast routes.

Implements inet::IRoutingTable.

{ return multicastRoutes.size(); }

getNumRoutes()

virtual int inet::Ipv4RoutingTable::getNumRoutes ( ) const

inlineoverridevirtual

Returns the total number of routes (unicast, multicast, plus the default route).

Implements inet::IRoutingTable.

{ return routes.size(); }

getOutputInterfaceForDestination()

virtual NetworkInterface* inet::Ipv4RoutingTable::getOutputInterfaceForDestination ( const L3Address &  dest ) const

inlineoverridevirtual

Convenience function based on findBestMatchingRoute().

Returns the output interface for the packets with dest as destination address, or nullptr if the destination is not in routing table.

Implements inet::IRoutingTable.

{ return getInterfaceForDestAddr(dest.toIpv4()); } // TODO inconsistent names

getRoute()

Ipv4Route * inet::Ipv4RoutingTable::getRoute ( int  k ) const

overridevirtual

Returns the kth route.

Implements inet::IIpv4RoutingTable.

{
    if (k < (int)routes.size())
        return routes[k];
    return nullptr;
}

getRouterId()

virtual Ipv4Address inet::Ipv4RoutingTable::getRouterId ( ) const

inlineoverridevirtual

Returns routerId.

Implements inet::IIpv4RoutingTable.

{ return routerId; }

getRouterIdAsGeneric()

virtual L3Address inet::Ipv4RoutingTable::getRouterIdAsGeneric ( ) const

inlineoverridevirtual

Returns routerId.

Implements inet::IRoutingTable.

{ return getRouterId(); }

handleMessage()

void inet::Ipv4RoutingTable::handleMessage ( cMessage *  msg )

overrideprotectedvirtual

Raises an error.

{
    throw cRuntimeError("This module doesn't process messages");
}

handleOperationStage()

bool inet::Ipv4RoutingTable::handleOperationStage ( LifecycleOperation *  operation, IDoneCallback *  doneCallback  )

overridevirtual

ILifecycle method.

Implements inet::ILifecycle.

{
    Enter_Method("handleOperationStage");
    int stage = operation->getCurrentStage();
    if (dynamic_cast<ModuleStartOperation *>(operation)) {
        if (static_cast<ModuleStartOperation::Stage>(stage) == ModuleStartOperation::STAGE_NETWORK_LAYER) {
            // read routing table file (and interface configuration)
            const char *filename = par("routingFile");
            RoutingTableParser parser(ift, this);
            if (*filename && parser.readRoutingTableFromFile(filename) == -1)
                throw cRuntimeError("Error reading routing table file %s", filename);
        }
        else if (static_cast<ModuleStartOperation::Stage>(stage) == ModuleStartOperation::STAGE_TRANSPORT_LAYER) {
            configureRouterId();
            updateNetmaskRoutes();
            isNodeUp = true;
        }
    }
    else if (dynamic_cast<ModuleStopOperation *>(operation)) {
        if (static_cast<ModuleStopOperation::Stage>(stage) == ModuleStopOperation::STAGE_NETWORK_LAYER) {
            while (!routes.empty())
                delete removeRoute(routes[0]);
            isNodeUp = false;
        }
    }
    else if (dynamic_cast<ModuleCrashOperation *>(operation)) {
        if (static_cast<ModuleCrashOperation::Stage>(stage) == ModuleCrashOperation::STAGE_CRASH) {
            while (!routes.empty())
                delete removeRoute(routes[0]);
            isNodeUp = false;
        }
    }
    return true;
}

initialize()

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

overrideprotectedvirtual

{
    cSimpleModule::initialize(stage);
 
    if (stage == INITSTAGE_LOCAL) {
        // get a pointer to the host module and IInterfaceTable
        cModule *host = getContainingNode(this);
        host->subscribe(interfaceCreatedSignal, this);
        host->subscribe(interfaceDeletedSignal, this);
        host->subscribe(interfaceStateChangedSignal, this);
        host->subscribe(interfaceConfigChangedSignal, this);
        host->subscribe(interfaceIpv4ConfigChangedSignal, this);
 
        ift.reference(this, "interfaceTableModule", true);
 
        netmaskRoutes = par("netmaskRoutes");
        forwarding = par("forwarding");
        multicastForward = par("multicastForwarding");
        useAdminDist = par("useAdminDist");
 
        WATCH_PTRVECTOR(routes);
        WATCH_PTRVECTOR(multicastRoutes);
        WATCH(netmaskRoutes);
        WATCH(forwarding);
        WATCH(multicastForward);
        WATCH(routerId);
    }
    else if (stage == INITSTAGE_ROUTER_ID_ASSIGNMENT) {
        cModule *node = findContainingNode(this);
        NodeStatus *nodeStatus = node ? check_and_cast_nullable<NodeStatus *>(node->getSubmodule("status")) : nullptr;
        isNodeUp = !nodeStatus || nodeStatus->getState() == NodeStatus::UP;
        if (isNodeUp) {
            // set routerId if param is not "" (==no routerId) or "auto" (in which case we'll
            // do it later in a later stage, after network configurators configured the interfaces)
            const char *routerIdStr = par("routerId");
            if (strcmp(routerIdStr, "") && strcmp(routerIdStr, "auto"))
                routerId = Ipv4Address(routerIdStr);
            // read routing table file (and interface configuration)
            const char *filename = par("routingFile");
            RoutingTableParser parser(ift, this);
            if (*filename && parser.readRoutingTableFromFile(filename) == -1)
                throw cRuntimeError("Error reading routing table file %s", filename);
            // routerID selection must be after network autoconfiguration assigned interface addresses
            configureRouterId();
        }
    }
    else if (stage == INITSTAGE_NETWORK_LAYER) {
        // we don't use notifications during initialize(), so we do it manually.
        updateNetmaskRoutes();
    }
}

internalAddMulticastRoute()

void inet::Ipv4RoutingTable::internalAddMulticastRoute ( Ipv4MulticastRoute *  entry )

protected

{
    if (!entry->getOriginNetmask().isValidNetmask())
        throw cRuntimeError("addMulticastRoute(): wrong netmask %s in multicast route", entry->getOriginNetmask().str().c_str());
 
    if ((entry->getOrigin().getInt() & ~entry->getOriginNetmask().getInt()) != 0)
        throw cRuntimeError("addMulticastRoute(): suspicious route: origin IP address %s has bits set outside netmask %s",
                entry->getOrigin().str().c_str(), entry->getOriginNetmask().str().c_str());
 
    if (!entry->getMulticastGroup().isUnspecified() && !entry->getMulticastGroup().isMulticast())
        throw cRuntimeError("addMulticastRoute(): group address (%s) is not a multicast address",
                entry->getMulticastGroup().str().c_str());
 
    // check that the interface exists
    if (entry->getInInterface() && !entry->getInInterface()->getInterface()->isMulticast())
        throw cRuntimeError("addMulticastRoute(): input interface must be multicast capable");
 
    for (unsigned int i = 0; i < entry->getNumOutInterfaces(); i++) {
        Ipv4MulticastRoute::OutInterface *outInterface = entry->getOutInterface(i);
        if (!outInterface)
            throw cRuntimeError("addMulticastRoute(): output interface cannot be nullptr");
        else if (!outInterface->getInterface()->isMulticast())
            throw cRuntimeError("addMulticastRoute(): output interface must be multicast capable");
        else if (entry->getInInterface() && outInterface->getInterface() == entry->getInInterface()->getInterface())
            throw cRuntimeError("addMulticastRoute(): output interface cannot be the same as the input interface");
    }
 
    // add to tables
    // we keep entries sorted by netmask desc, metric asc in routeList, so that we can
    // stop at the first match when doing the longest netmask matching
    auto pos =
        upper_bound(multicastRoutes.begin(), multicastRoutes.end(), entry, multicastRouteLessThan);
    multicastRoutes.insert(pos, entry);
    invalidateCache();
    entry->setRoutingTable(this);
}

internalAddRoute()

void inet::Ipv4RoutingTable::internalAddRoute ( Ipv4Route *  entry )

protected

{
    if (!entry->getNetmask().isValidNetmask())
        throw cRuntimeError("addRoute(): wrong netmask %s in route", entry->getNetmask().str().c_str());
 
    if (entry->getNetmask().getInt() != 0 && (entry->getDestination().getInt() & entry->getNetmask().getInt()) == 0)
        throw cRuntimeError("addRoute(): all bits of destination address %s is 0 inside non zero netmask %s",
                entry->getDestination().str().c_str(), entry->getNetmask().str().c_str());
 
    if ((entry->getDestination().getInt() & ~entry->getNetmask().getInt()) != 0)
        throw cRuntimeError("addRoute(): suspicious route: destination IP address %s has bits set outside netmask %s",
                entry->getDestination().str().c_str(), entry->getNetmask().str().c_str());
 
    // check that the interface exists
    if (!entry->getInterface())
        throw cRuntimeError("addRoute(): interface cannot be nullptr");
 
    // if this is a default route, remove old default route (we're replacing it)
    if (entry->getNetmask().isUnspecified()) {
        Ipv4Route *oldDefaultRoute = getDefaultRoute();
        if (oldDefaultRoute != nullptr)
            deleteRoute(oldDefaultRoute);
    }
 
    // The 'routes' vector may contain multiple routes with the same destination/netmask.
    // Routes are stored in descending netmask length and ascending administrative_distance/metric order,
    // so the first matching is the best one.
    // TODO Should only the route with the best metic be stored? Then the worse route should be deleted and
    //     internalAddRoute() should return a bool indicating if it was successful.
 
    // add to tables
    // we keep entries sorted by netmask desc, metric asc in routeList, so that we can
    // stop at the first match when doing the longest netmask matching
    auto pos = upper_bound(routes.begin(), routes.end(), entry, RouteLessThan(*this));
    routes.insert(pos, entry);
    invalidateCache();
    entry->setRoutingTable(this);
}

internalRemoveMulticastRoute()

Ipv4MulticastRoute * inet::Ipv4RoutingTable::internalRemoveMulticastRoute ( Ipv4MulticastRoute *  entry )

protected

{
    auto i = find(multicastRoutes, entry);
    if (i != multicastRoutes.end()) {
        multicastRoutes.erase(i);
        invalidateCache();
        return entry;
    }
    return nullptr;
}

internalRemoveRoute()

Ipv4Route * inet::Ipv4RoutingTable::internalRemoveRoute ( Ipv4Route *  entry )

protected

{
    auto i = find(routes, entry);
    if (i != routes.end()) {
        routes.erase(i);
        invalidateCache();
        return entry;
    }
    return nullptr;
}

invalidateCache()

void inet::Ipv4RoutingTable::invalidateCache ( )

protectedvirtual

{
    routingCache.clear();
    localBroadcastAddresses.clear();
}

isAdminDistEnabled()

virtual bool inet::Ipv4RoutingTable::isAdminDistEnabled ( ) const

inlineoverridevirtual

AdminDist on/off.

Implements inet::IRoutingTable.

{ return useAdminDist; }

isForwardingEnabled()

virtual bool inet::Ipv4RoutingTable::isForwardingEnabled ( ) const

inlineoverridevirtual

Ipv4 forwarding on/off.

Implements inet::IRoutingTable.

{ return forwarding; }

isLocalAddress() [1/2]

bool inet::Ipv4RoutingTable::isLocalAddress ( const Ipv4Address &  dest ) const

overridevirtual

Checks if the address is a local one, i.e.

one of the host's.

Implements inet::IIpv4RoutingTable.

{
    Enter_Method("isLocalAddress(%u.%u.%u.%u)", dest.getDByte(0), dest.getDByte(1), dest.getDByte(2), dest.getDByte(3)); // note: str().c_str() too slow here
    return ift->isLocalAddress(dest);
}

isLocalAddress() [2/2]

virtual bool inet::Ipv4RoutingTable::isLocalAddress ( const L3Address &  dest ) const

inlineoverridevirtual

Checks if the address is a local one, i.e.

one of the host's.

Implements inet::IRoutingTable.

{ return isLocalAddress(dest.toIpv4()); }

Referenced by isLocalAddress().

isLocalBroadcastAddress()

bool inet::Ipv4RoutingTable::isLocalBroadcastAddress ( const Ipv4Address &  dest ) const

overridevirtual

Checks if the address is a local network broadcast address, i.e.

one of the broadcast addresses derived from the interface addresses and netmasks.

Implements inet::IIpv4RoutingTable.

{
    Enter_Method("isLocalBroadcastAddress(%u.%u.%u.%u)", dest.getDByte(0), dest.getDByte(1), dest.getDByte(2), dest.getDByte(3)); // note: str().c_str() too slow here
 
    if (localBroadcastAddresses.empty()) {
        // collect interface addresses if not yet done
        for (int i = 0; i < ift->getNumInterfaces(); i++) {
            NetworkInterface *ie = ift->getInterface(i);
            if (!ie->isBroadcast())
                continue;
            Ipv4Address interfaceAddr = ie->getProtocolData<Ipv4InterfaceData>()->getIPAddress();
            Ipv4Address broadcastAddr = interfaceAddr.makeBroadcastAddress(ie->getProtocolData<Ipv4InterfaceData>()->getNetmask());
            if (!broadcastAddr.isUnspecified()) {
                localBroadcastAddresses.insert(broadcastAddr);
            }
        }
    }
 
    return contains(localBroadcastAddresses, dest);
}

isLocalMulticastAddress() [1/2]

bool inet::Ipv4RoutingTable::isLocalMulticastAddress ( const Ipv4Address &  dest ) const

overridevirtual

Checks if the address is in one of the local multicast group address list.

Implements inet::IIpv4RoutingTable.

{
    Enter_Method("isLocalMulticastAddress(%u.%u.%u.%u)", dest.getDByte(0), dest.getDByte(1), dest.getDByte(2), dest.getDByte(3)); // note: str().c_str() too slow here
 
    for (int i = 0; i < ift->getNumInterfaces(); i++) {
        NetworkInterface *ie = ift->getInterface(i);
        if (ie->getProtocolData<Ipv4InterfaceData>()->isMemberOfMulticastGroup(dest))
            return true;
    }
    return false;
}

isLocalMulticastAddress() [2/2]

virtual bool inet::Ipv4RoutingTable::isLocalMulticastAddress ( const L3Address &  dest ) const

inlineoverridevirtual

Checks if the address is in one of the local multicast group address list.

Implements inet::IRoutingTable.

{ return isLocalMulticastAddress(dest.toIpv4()); }

Referenced by isLocalMulticastAddress().

isMulticastForwardingEnabled()

virtual bool inet::Ipv4RoutingTable::isMulticastForwardingEnabled ( ) const

inlineoverridevirtual

Ipv4 multicast forwarding on/off.

Implements inet::IRoutingTable.

{ return multicastForward; }

multicastRouteChanged()

void inet::Ipv4RoutingTable::multicastRouteChanged ( Ipv4MulticastRoute *  entry, int  fieldCode  )

overridevirtual

To be called from multicast route objects whenever a field changes.

Used for maintaining internal data structures and firing "routing table changed" notifications.

Implements inet::IIpv4RoutingTable.

{
    if (fieldCode == Ipv4MulticastRoute::F_ORIGIN || fieldCode == Ipv4MulticastRoute::F_ORIGINMASK ||
        fieldCode == Ipv4MulticastRoute::F_MULTICASTGROUP || fieldCode == Ipv4MulticastRoute::F_METRIC) // our data structures depend on these fields
    {
        entry = internalRemoveMulticastRoute(entry);
        ASSERT(entry != nullptr); // failure means inconsistency: route was not found in this routing table
        internalAddMulticastRoute(entry);
    }
    emit(mrouteChangedSignal, entry); // TODO include fieldCode in the notification
}

multicastRouteLessThan()

bool inet::Ipv4RoutingTable::multicastRouteLessThan ( const Ipv4MulticastRoute *  a, const Ipv4MulticastRoute *  b  )

staticprotected

{
    // We want routes with longer
    // prefixes to be at front, so we compare them as "less".
    if (a->getOriginNetmask() != b->getOriginNetmask())
        return a->getOriginNetmask() > b->getOriginNetmask();
 
    // For metric, a smaller value is better (we report that as "less").
    if (a->getOrigin() != b->getOrigin())
        return a->getOrigin() < b->getOrigin();
 
    // put the unspecified group after the specified ones
    if (a->getMulticastGroup() != b->getMulticastGroup())
        return a->getMulticastGroup() > b->getMulticastGroup();
 
    return a->getMetric() < b->getMetric();
}

numInitStages()

virtual int inet::Ipv4RoutingTable::numInitStages ( ) const

inlineoverrideprotectedvirtual

{ return NUM_INIT_STAGES; }

printMulticastRoutingTable()

void inet::Ipv4RoutingTable::printMulticastRoutingTable ( ) const

overridevirtual

For debugging.

Implements inet::IIpv4RoutingTable.

{
    EV << "-- Multicast routing table --\n";
    EV << stringf("%-16s %-16s %-16s %-6s %-6s %s\n",
            "Source", "Netmask", "Group", "Metric", "In", "Outs");
 
    for (int i = 0; i < getNumMulticastRoutes(); i++) {
        Ipv4MulticastRoute *route = getMulticastRoute(i);
        EV << stringf("%-16s %-16s %-16s %-6d %-6s ",
                route->getOrigin().isUnspecified() ? "*" : route->getOrigin().str().c_str(),
                route->getOriginNetmask().isUnspecified() ? "*" : route->getOriginNetmask().str().c_str(),
                route->getMulticastGroup().isUnspecified() ? "*" : route->getMulticastGroup().str().c_str(),
                route->getMetric(),
                !route->getInInterface() ? "*" : route->getInInterface()->getInterface()->getInterfaceName());
        for (unsigned int i = 0; i < route->getNumOutInterfaces(); i++) {
            if (i != 0)
                EV << ",";
            EV << route->getOutInterface(i)->getInterface()->getInterfaceName();
        }
        EV << "\n";
    }
    EV << "\n";
}

printRoutingTable()

void inet::Ipv4RoutingTable::printRoutingTable ( ) const

overridevirtual

For debugging.

Implements inet::IRoutingTable.

{
    EV << "-- Routing table --\n";
    EV << stringf("%-16s %-16s %-16s %-4s %-16s %s\n",
            "Destination", "Netmask", "Gateway", "Iface", "", "Metric");
 
    for (int i = 0; i < getNumRoutes(); i++) {
        Ipv4Route *route = getRoute(i);
        NetworkInterface *interfacePtr = route->getInterface();
        EV << stringf("%-16s %-16s %-16s %-4s %-16s %6d\n",
                route->getDestination().isUnspecified() ? "*" : route->getDestination().str().c_str(),
                route->getNetmask().isUnspecified() ? "*" : route->getNetmask().str().c_str(),
                route->getGateway().isUnspecified() ? "*" : route->getGateway().str().c_str(),
                !interfacePtr ? "*" : interfacePtr->getInterfaceName(),
                !interfacePtr ? "(*)" : (std::string("(") + interfacePtr->getProtocolData<Ipv4InterfaceData>()->getIPAddress().str() + ")").c_str(),
                route->getMetric());
    }
    EV << "\n";
}

purge()

void inet::Ipv4RoutingTable::purge ( )

overridevirtual

Deletes invalid routes from the routing table.

Invalid routes are those where the isValid() method returns false.

Implements inet::IIpv4RoutingTable.

{
    // purge unicast routes
    for (auto it = routes.begin(); it != routes.end();) {
        Ipv4Route *route = *it;
        if (route->isValid())
            ++it;
        else {
            it = routes.erase(it);
            invalidateCache();
            ASSERT(route->getRoutingTable() == this); // still filled in, for the listeners' benefit
            emit(routeDeletedSignal, route);
            delete route;
        }
    }
 
    // purge multicast routes
    for (auto it = multicastRoutes.begin(); it != multicastRoutes.end();) {
        Ipv4MulticastRoute *route = *it;
        if (route->isValid())
            ++it;
        else {
            it = multicastRoutes.erase(it);
            invalidateCache();
            ASSERT(route->getRoutingTable() == this); // still filled in, for the listeners' benefit
            emit(mrouteDeletedSignal, route);
            delete route;
        }
    }
}

receiveSignal()

void inet::Ipv4RoutingTable::receiveSignal ( cComponent *  source, simsignal_t  signalID, cObject *  obj, cObject *  details  )

overrideprotectedvirtual

Called by the signal handler whenever a change of a category occurs to which this client has subscribed.

{
    if (getSimulation()->getContextType() == CTX_INITIALIZE)
        return; // ignore notifications during initialize
 
    Enter_Method("%s", cComponent::getSignalName(signalID));
 
    printSignalBanner(signalID, obj, details);
 
    if (signalID == interfaceCreatedSignal) {
        // add netmask route for the new interface
        updateNetmaskRoutes();
        invalidateCache();
    }
    else if (signalID == interfaceDeletedSignal) {
        // remove all routes that point to that interface
        const NetworkInterface *entry = check_and_cast<const NetworkInterface *>(obj);
        deleteInterfaceRoutes(entry);
        invalidateCache();
    }
    else if (signalID == interfaceStateChangedSignal) {
        invalidateCache();
        const auto *ieChangeDetails = check_and_cast<const NetworkInterfaceChangeDetails *>(obj);
        auto fieldId = ieChangeDetails->getFieldId();
        if (fieldId == NetworkInterface::F_STATE || fieldId == NetworkInterface::F_CARRIER) {
            const auto *entry = ieChangeDetails->getNetworkInterface();
            updateNetmaskRoutes();
            if (!entry->isUp())
                deleteInterfaceRoutes(entry);
            invalidateCache();
        }
    }
    else if (signalID == interfaceConfigChangedSignal) {
        invalidateCache();
    }
    else if (signalID == interfaceIpv4ConfigChangedSignal) {
        // if anything Ipv4-related changes in the interfaces, interface netmask
        // based routes have to be re-built.
        updateNetmaskRoutes();
        invalidateCache();
    }
}

refreshDisplay()

void inet::Ipv4RoutingTable::refreshDisplay ( ) const

overrideprotectedvirtual

{
    char buf[80];
    if (routerId.isUnspecified())
        sprintf(buf, "%d+%d routes", (int)routes.size(), (int)multicastRoutes.size());
    else
        sprintf(buf, "routerId: %s\n%d+%d routes", routerId.str().c_str(), (int)routes.size(), (int)multicastRoutes.size());
    getDisplayString().setTagArg("t", 0, buf);
}

removeMulticastRoute() [1/2]

virtual IMulticastRoute* inet::Ipv4RoutingTable::removeMulticastRoute ( IMulticastRoute *  entry )

inlineoverrideprivatevirtual

Removes the given route from the routing table, and returns it.

nullptr is returned of the route was not in the routing table.

Implements inet::IRoutingTable.

{ return removeMulticastRoute(check_and_cast<Ipv4MulticastRoute *>(entry)); }

Referenced by removeMulticastRoute().

removeMulticastRoute() [2/2]

Ipv4MulticastRoute * inet::Ipv4RoutingTable::removeMulticastRoute ( Ipv4MulticastRoute *  entry )

overridevirtual

Removes the given route from the routing table, and returns it.

nullptr is returned of the route was not in the routing table.

Implements inet::IIpv4RoutingTable.

{
    Enter_Method("removeMulticastRoute(...)");
 
    entry = internalRemoveMulticastRoute(entry);
 
    if (entry != nullptr) {
        ASSERT(entry->getRoutingTable() == this); // still filled in, for the listeners' benefit
        emit(mrouteDeletedSignal, entry);
        entry->setRoutingTable(nullptr);
    }
    return entry;
}

removeRoute() [1/2]

Ipv4Route * inet::Ipv4RoutingTable::removeRoute ( Ipv4Route *  entry )

overridevirtual

Removes the given route from the routing table, and returns it.

nullptr is returned of the route was not in the routing table.

Implements inet::IIpv4RoutingTable.

{
    Enter_Method("removeRoute(...)");
 
    entry = internalRemoveRoute(entry);
 
    if (entry != nullptr) {
        EV_INFO << "remove route " << entry->str() << "\n";
        ASSERT(entry->getRoutingTable() == this); // still filled in, for the listeners' benefit
        emit(routeDeletedSignal, entry);
        entry->setRoutingTable(nullptr);
    }
    return entry;
}

removeRoute() [2/2]

virtual IRoute* inet::Ipv4RoutingTable::removeRoute ( IRoute *  entry )

inlineoverrideprivatevirtual

Removes the given route from the routing table, and returns it.

nullptr is returned if the route was not in the routing table.

Implements inet::IRoutingTable.

{ return removeRoute(check_and_cast<Ipv4Route *>(entry)); }

Referenced by removeRoute().

routeChanged()

void inet::Ipv4RoutingTable::routeChanged ( Ipv4Route *  entry, int  fieldCode  )

overridevirtual

To be called from route objects whenever a field changes.

Used for maintaining internal data structures and firing "routing table changed" notifications.

Implements inet::IIpv4RoutingTable.

{
    if (fieldCode == Ipv4Route::F_DESTINATION || fieldCode == Ipv4Route::F_PREFIX_LENGTH || fieldCode == Ipv4Route::F_METRIC) { // our data structures depend on these fields
        entry = internalRemoveRoute(entry);
        ASSERT(entry != nullptr); // failure means inconsistency: route was not found in this routing table
        internalAddRoute(entry);
    }
    emit(routeChangedSignal, entry); // TODO include fieldCode in the notification
}

routeLessThan()

bool inet::Ipv4RoutingTable::routeLessThan ( const Ipv4Route *  a, const Ipv4Route *  b  ) const

protected

{
    // longer prefixes are better, because they are more specific
    if (a->getNetmask() != b->getNetmask())
        return a->getNetmask() > b->getNetmask();
 
    if (a->getDestination() != b->getDestination())
        return a->getDestination() < b->getDestination();
 
    // for the same destination/netmask:
 
    // smaller administration distance is better (if useAdminDist)
    if (useAdminDist && (a->getAdminDist() != b->getAdminDist()))
        return a->getAdminDist() < b->getAdminDist();
 
    // smaller metric is better
    return a->getMetric() < b->getMetric();
}

setRouterId()

void inet::Ipv4RoutingTable::setRouterId ( Ipv4Address  a )

overridevirtual

Sets routerId.

Implements inet::IIpv4RoutingTable.

{
    routerId = a;
}

updateNetmaskRoutes()

void inet::Ipv4RoutingTable::updateNetmaskRoutes ( )

protectedvirtual

{
    // first, delete all routes with src=IFACENETMASK
    for (unsigned int k = 0; k < routes.size(); k++) {
        if (routes[k]->getSourceType() == IRoute::IFACENETMASK) {
            auto it = routes.begin() + (k--); // '--' is necessary because indices shift down
            Ipv4Route *route = *it;
            routes.erase(it);
            invalidateCache();
            ASSERT(route->getRoutingTable() == this); // still filled in, for the listeners' benefit
            emit(routeDeletedSignal, route);
            delete route;
        }
    }
 
    // then re-add them, according to actual interface configuration
    // TODO say there's a node somewhere in the network that belongs to the interface's subnet
    // TODO and it is not on the same link, and the gateway does not use proxy ARP, how will packets reach that node?
    PatternMatcher interfaceNameMatcher(netmaskRoutes, false, true, true);
    for (int i = 0; i < ift->getNumInterfaces(); i++) {
        NetworkInterface *ie = ift->getInterface(i);
        if (ie->isUp() && interfaceNameMatcher.matches(ie->getFullName())) {
            auto ipv4Data = ie->findProtocolData<Ipv4InterfaceData>();
            if (ipv4Data && ipv4Data->getNetmask() != Ipv4Address::ALLONES_ADDRESS) {
                Ipv4Route *route = createNewRoute();
                route->setSourceType(IRoute::IFACENETMASK);
                route->setSource(ie);
                route->setDestination(ipv4Data->getIPAddress().doAnd(ipv4Data->getNetmask()));
                route->setNetmask(ipv4Data->getNetmask());
                route->setGateway(Ipv4Address());
                route->setAdminDist(Ipv4Route::dDirectlyConnected);
                route->setMetric(ipv4Data->getMetric());
                route->setInterface(ie);
                route->setRoutingTable(this);
                auto pos = upper_bound(routes.begin(), routes.end(), route, RouteLessThan(*this));
                routes.insert(pos, route);
                invalidateCache();
                emit(routeAddedSignal, route);
            }
        }
    }
}

Member Data Documentation

forwarding

bool inet::Ipv4RoutingTable::forwarding = false

protected

ift

ModuleRefByPar<IInterfaceTable> inet::Ipv4RoutingTable::ift

protected

isNodeUp

bool inet::Ipv4RoutingTable::isNodeUp = false

protected

localBroadcastAddresses

AddressSet inet::Ipv4RoutingTable::localBroadcastAddresses

mutableprotected

multicastForward

bool inet::Ipv4RoutingTable::multicastForward = false

protected

multicastRoutes

MulticastRouteVector inet::Ipv4RoutingTable::multicastRoutes

private

netmaskRoutes

const char* inet::Ipv4RoutingTable::netmaskRoutes = nullptr

protected

routerId

Ipv4Address inet::Ipv4RoutingTable::routerId

protected

routes

RouteVector inet::Ipv4RoutingTable::routes

private

routingCache

RoutingCache inet::Ipv4RoutingTable::routingCache

mutableprotected

useAdminDist

bool inet::Ipv4RoutingTable::useAdminDist = false

protected

---

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

• Ipv4RoutingTable.h
• Ipv4RoutingTable.cc