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...
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...
virtual bool	handleOperationStage (LifecycleOperation *operation, int stage, 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 InterfaceEntry *	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 InterfaceEntry *	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
Interfaces
virtual void	configureInterfaceForIPv4 (InterfaceEntry *ie) override
virtual InterfaceEntry *	getInterfaceByAddress (const IPv4Address &address) const override
	Returns an interface given by its address. 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 InterfaceEntry *	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 InterfaceEntry *	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...
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...
Public Member Functions inherited from inet::IIPv4RoutingTable
virtual	~IIPv4RoutingTable ()
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	configureLoopbackForIPv4 ()
virtual void	configureRouterId ()
virtual void	updateNetmaskRoutes ()
virtual IPv4Route *	createNewRoute ()
virtual void	refreshDisplay () const override
virtual void	deleteInterfaceRoutes (const InterfaceEntry *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
IInterfaceTable *	ift = nullptr
IPv4Address	routerId
const char *	netmaskRoutes = nullptr
bool	forwarding = false
bool	multicastForward = false
bool	isNodeUp = false
bool	useAdminDist = false
RoutingCache	routingCache
AddressSet	localAddresses
AddressSet	localBroadcastAddresses

Private Types
typedef std::vector< IPv4Route * >	RouteVector
typedef std::vector< IPv4MulticastRoute * >	MulticastRouteVector

Private Member Functions
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...

Private Attributes
RouteVector	routes
MulticastRouteVector	multicastRoutes

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

InterfaceEntry, IPv4InterfaceData, IPv4Route

Member Typedef Documentation

typedef std::set<IPv4Address> inet::IPv4RoutingTable::AddressSet

protected

typedef std::vector<IPv4MulticastRoute *> inet::IPv4RoutingTable::MulticastRouteVector

private

typedef IPv4MulticastRoute::OutInterface inet::IPv4RoutingTable::OutInterface

protected

typedef IPv4MulticastRoute::OutInterfaceVector inet::IPv4RoutingTable::OutInterfaceVector

protected

typedef std::vector<IPv4Route *> inet::IPv4RoutingTable::RouteVector

private

typedef std::map<IPv4Address, IPv4Route *> inet::IPv4RoutingTable::RoutingCache

protected

Constructor & Destructor Documentation

inet::IPv4RoutingTable::IPv4RoutingTable ( )

inline

{}

inet::IPv4RoutingTable::~IPv4RoutingTable ( )

virtual

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

Member Function Documentation

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);

    invalidateCache();

    emit(NF_MROUTE_ADDED, entry);
}

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.

Referenced by addMulticastRoute().

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

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(...)");
    EV_INFO << "add route " << entry->info() << "\n";

    internalAddRoute(entry);

    invalidateCache();

    emit(NF_ROUTE_ADDED, entry);
}

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.

Referenced by addRoute().

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

void inet::IPv4RoutingTable::configureInterfaceForIPv4 ( InterfaceEntry *  ie )

overridevirtual

Implements inet::IIPv4RoutingTable.

{
    IPv4InterfaceData *d = new IPv4InterfaceData();
    ie->setIPv4Data(d);

    // metric: some hints: OSPF cost (2e9/bps value), MS KB article Q299540, ...
    d->setMetric((int)ceil(2e9 / ie->getDatarate()));    // use OSPF cost as default

    // join "224.0.0.1" and "224.0.0.2" (if router) multicast groups automatically
    if (ie->isMulticast()) {
        d->joinMulticastGroup(IPv4Address::ALL_HOSTS_MCAST);
        if (forwarding)
            d->joinMulticastGroup(IPv4Address::ALL_ROUTERS_MCAST);
    }
}

void inet::IPv4RoutingTable::configureLoopbackForIPv4 ( )

protectedvirtual

{
    InterfaceEntry *ie = ift->getFirstLoopbackInterface();
    if (ie) {
        // add IPv4 info. Set 127.0.0.1/8 as address by default --
        // we may reconfigure later it to be the routerId
        IPv4InterfaceData *d = new IPv4InterfaceData();
        d->setIPAddress(IPv4Address::LOOPBACK_ADDRESS);
        d->setNetmask(IPv4Address::LOOPBACK_NETMASK);
        d->setMetric(1);
        ie->setIPv4Data(d);
    }
}

void inet::IPv4RoutingTable::configureRouterId ( )

protectedvirtual

{
    if (routerId.isUnspecified()) {    // not yet configured
        const char *routerIdStr = par("routerId").stringValue();
        if (!strcmp(routerIdStr, "auto")) {    // non-"auto" cases already handled earlier
            // choose highest interface address as routerId
            for (int i = 0; i < ift->getNumInterfaces(); ++i) {
                InterfaceEntry *ie = ift->getInterface(i);
                if (!ie->isLoopback() && ie->ipv4Data() && ie->ipv4Data()->getIPAddress().getInt() > routerId.getInt())
                    routerId = ie->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) {
            InterfaceEntry *lo0 = ift->getFirstLoopbackInterface();
            ASSERT(lo0);
            lo0->ipv4Data()->setIPAddress(routerId);
            lo0->ipv4Data()->setNetmask(IPv4Address::ALLONES_ADDRESS);
        }
    }
}

IPv4Route * inet::IPv4RoutingTable::createNewRoute ( )

protectedvirtual

{
    return new IPv4Route();
}

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

inlineoverridevirtual

Implements inet::IRoutingTable.

{ return new IPv4Route(); }

void inet::IPv4RoutingTable::deleteInterfaceRoutes ( const InterfaceEntry *  entry )

protectedvirtual

{
    bool changed = false;

    // 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);
            ASSERT(route->getRoutingTable() == this);    // still filled in, for the listeners' benefit
            emit(NF_ROUTE_DELETED, route);
            delete route;
            changed = true;
        }
        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);
            ASSERT(route->getRoutingTable() == this);    // still filled in, for the listeners' benefit
            emit(NF_MROUTE_DELETED, route);
            delete route;
            changed = true;
        }
        else {
            bool removed = route->removeOutInterface(entry);
            if (removed) {
                emit(NF_MROUTE_CHANGED, route);
                changed = true;
            }
            ++it;
        }
    }

    if (changed) {
        invalidateCache();
    }
}

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) {
        invalidateCache();
        ASSERT(entry->getRoutingTable() == this);    // still filled in, for the listeners' benefit
        emit(NF_MROUTE_DELETED, entry);
        delete entry;
    }
    return entry != nullptr;
}

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.

Referenced by deleteMulticastRoute().

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

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->info() << "\n";
        invalidateCache();
        ASSERT(entry->getRoutingTable() == this);    // still filled in, for the listeners' benefit
        emit(NF_ROUTE_DELETED, entry);
        delete entry;
    }
    return entry != nullptr;
}

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.

Referenced by deleteRoute().

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

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;
}

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

inlineoverridevirtual

Returns route for a multicast origin and group.

Implements inet::IRoutingTable.

Referenced by findBestMatchingMulticastRoute().

{ return const_cast<IPv4MulticastRoute *>(findBestMatchingMulticastRoute(origin.toIPv4(), group.toIPv4())); }    //XXX remove 'const' from IPv4 method?

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;
}

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.

Referenced by findBestMatchingRoute().

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

InterfaceEntry * inet::IPv4RoutingTable::findInterfaceByLocalBroadcastAddress ( const IPv4Address &  dest ) const

overridevirtual

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

Implements inet::IIPv4RoutingTable.

{
    for (int i = 0; i < ift->getNumInterfaces(); i++) {
        InterfaceEntry *ie = ift->getInterface(i);
        if (!ie->isBroadcast())
            continue;
        IPv4Address interfaceAddr = ie->ipv4Data()->getIPAddress();
        IPv4Address broadcastAddr = interfaceAddr.makeBroadcastAddress(ie->ipv4Data()->getNetmask());
        if (broadcastAddr == dest)
            return ie;
    }
    return nullptr;
}

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)->ipv4Data()->getIPAddress());
    return addressvector;
}

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;
}

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();
}

cModule * inet::IPv4RoutingTable::getHostModule ( )

overridevirtual

Returns the host or router this routing table lives in.

Implements inet::IIPv4RoutingTable.

{
    return findContainingNode(this);
}

InterfaceEntry * 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

    if (addr.isUnspecified())
        return nullptr;
    for (int i = 0; i < ift->getNumInterfaces(); ++i) {
        InterfaceEntry *ie = ift->getInterface(i);
        if (ie->ipv4Data()->getIPAddress() == addr)
            return ie;
    }
    return nullptr;
}

virtual InterfaceEntry* inet::IPv4RoutingTable::getInterfaceByAddress ( const L3Address &  address ) const

inlineoverridevirtual

Returns an interface given by its address.

Returns nullptr if not found.

Implements inet::IRoutingTable.

Referenced by getInterfaceByAddress().

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

InterfaceEntry * 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;
}

virtual IPv4MulticastRoute* inet::IPv4RoutingTable::getMulticastRoute ( int  k ) const

inlineoverridevirtual

Returns the kth multicast route.

Implements inet::IIPv4RoutingTable.

{ return k < (int)multicastRoutes.size() ? multicastRoutes[k] : nullptr; }

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()); }    //XXX inconsistent names

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

inlineoverridevirtual

Returns the total number of multicast routes.

Implements inet::IRoutingTable.

{ return multicastRoutes.size(); }

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(); }

virtual InterfaceEntry* 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()); }    //XXX inconsistent names

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;
}

virtual IPv4Address inet::IPv4RoutingTable::getRouterId ( ) const

inlineoverridevirtual

Returns routerId.

Implements inet::IIPv4RoutingTable.

{ return routerId; }

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

inlineoverridevirtual

Returns routerId.

Implements inet::IRoutingTable.

{ return getRouterId(); }

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

overrideprotectedvirtual

Raises an error.

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

bool inet::IPv4RoutingTable::handleOperationStage ( LifecycleOperation *  operation, int  stage, IDoneCallback *  doneCallback  )

overridevirtual

ILifecycle method.

Implements inet::ILifecycle.

{
    Enter_Method_Silent();
    if (dynamic_cast<NodeStartOperation *>(operation)) {
        if ((NodeStartOperation::Stage)stage == NodeStartOperation::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 ((NodeStartOperation::Stage)stage == NodeStartOperation::STAGE_TRANSPORT_LAYER) {
            configureRouterId();
            updateNetmaskRoutes();
            isNodeUp = true;
        }
    }
    else if (dynamic_cast<NodeShutdownOperation *>(operation)) {
        if ((NodeShutdownOperation::Stage)stage == NodeShutdownOperation::STAGE_NETWORK_LAYER) {
            while (!routes.empty())
                delete removeRoute(routes[0]);
            isNodeUp = false;
        }
    }
    else if (dynamic_cast<NodeCrashOperation *>(operation)) {
        if ((NodeCrashOperation::Stage)stage == NodeCrashOperation::STAGE_CRASH) {
            while (!routes.empty())
                delete removeRoute(routes[0]);
            isNodeUp = false;
        }
    }
    return true;
}

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(NF_INTERFACE_CREATED, this);
        host->subscribe(NF_INTERFACE_DELETED, this);
        host->subscribe(NF_INTERFACE_STATE_CHANGED, this);
        host->subscribe(NF_INTERFACE_CONFIG_CHANGED, this);
        host->subscribe(NF_INTERFACE_IPv4CONFIG_CHANGED, this);

        ift = getModuleFromPar<IInterfaceTable>(par("interfaceTableModule"), this);

        netmaskRoutes = par("netmaskRoutes");
        forwarding = par("forwarding").boolValue();
        multicastForward = par("multicastForwarding");
        useAdminDist = par("useAdminDist");

        WATCH_PTRVECTOR(routes);
        WATCH_PTRVECTOR(multicastRoutes);
        WATCH(netmaskRoutes);
        WATCH(forwarding);
        WATCH(multicastForward);
        WATCH(routerId);
    }
    else if (stage == INITSTAGE_NETWORK_LAYER) {
        NodeStatus *nodeStatus = dynamic_cast<NodeStatus *>(findContainingNode(this)->getSubmodule("status"));
        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").stringValue();
            if (strcmp(routerIdStr, "") && strcmp(routerIdStr, "auto"))
                routerId = IPv4Address(routerIdStr);
        }
    }
    else if (stage == INITSTAGE_NETWORK_LAYER_3) {
        if (isNodeUp) {
            // 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
        if (isNodeUp)
            configureRouterId();

        // we don't use notifications during initialize(), so we do it manually.
        updateNetmaskRoutes();
    }
}

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);

    entry->setRoutingTable(this);
}

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.
    // XXX 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);

    entry->setRoutingTable(this);
}

IPv4MulticastRoute * inet::IPv4RoutingTable::internalRemoveMulticastRoute ( IPv4MulticastRoute *  entry )

protected

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

IPv4Route * inet::IPv4RoutingTable::internalRemoveRoute ( IPv4Route *  entry )

protected

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

void inet::IPv4RoutingTable::invalidateCache ( )

protectedvirtual

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

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

inlineoverridevirtual

IPv4 forwarding on/off.

Implements inet::IRoutingTable.

{ return forwarding; }

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

    if (localAddresses.empty()) {
        // collect interface addresses if not yet done
        for (int i = 0; i < ift->getNumInterfaces(); i++) {
            auto ipv4Data = ift->getInterface(i)->ipv4Data();
            if (ipv4Data != nullptr)
                localAddresses.insert(ipv4Data->getIPAddress());
        }
    }

    auto it = localAddresses.find(dest);
    return it != localAddresses.end();
}

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.

Referenced by isLocalAddress().

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

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++) {
            InterfaceEntry *ie = ift->getInterface(i);
            if (!ie->isBroadcast())
                continue;
            IPv4Address interfaceAddr = ie->ipv4Data()->getIPAddress();
            IPv4Address broadcastAddr = interfaceAddr.makeBroadcastAddress(ie->ipv4Data()->getNetmask());
            if (!broadcastAddr.isUnspecified()) {
                localBroadcastAddresses.insert(broadcastAddr);
            }
        }
    }

    auto it = localBroadcastAddresses.find(dest);
    return it != localBroadcastAddresses.end();
}

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++) {
        InterfaceEntry *ie = ift->getInterface(i);
        if (ie->ipv4Data()->isMemberOfMulticastGroup(dest))
            return true;
    }
    return false;
}

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.

Referenced by isLocalMulticastAddress().

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

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

inlineoverridevirtual

IPv4 multicast forwarding on/off.

Implements inet::IRoutingTable.

{ return multicastForward; }

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);

        invalidateCache();
    }
    emit(NF_MROUTE_CHANGED, entry);    // TODO include fieldCode in the notification
}

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();
}

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

inlineoverrideprotectedvirtual

{ return NUM_INIT_STAGES; }

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()->getName());
        for (unsigned int i = 0; i < route->getNumOutInterfaces(); i++) {
            if (i != 0)
                EV << ",";
            EV << route->getOutInterface(i)->getInterface()->getName();
        }
        EV << "\n";
    }
    EV << "\n";
}

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);
        InterfaceEntry *interfacePtr = route->getInterface();
        EV << stringf("%-16s %-16s %-16s %-4s (%s) %d\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->getName(),
                !interfacePtr ? "*  " : interfacePtr->ipv4Data()->getIPAddress().str().c_str(),
                route->getMetric());
    }
    EV << "\n";
}

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.

{
    bool deleted = false;

    // purge unicast routes
    for (auto it = routes.begin(); it != routes.end(); ) {
        IPv4Route *route = *it;
        if (route->isValid())
            ++it;
        else {
            it = routes.erase(it);
            ASSERT(route->getRoutingTable() == this);    // still filled in, for the listeners' benefit
            emit(NF_ROUTE_DELETED, route);
            delete route;
            deleted = true;
        }
    }

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

    if (deleted) {
        invalidateCache();
    }
}

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_Silent();
    printNotificationBanner(signalID, obj);

    if (signalID == NF_INTERFACE_CREATED) {
        // add netmask route for the new interface
        updateNetmaskRoutes();
    }
    else if (signalID == NF_INTERFACE_DELETED) {
        // remove all routes that point to that interface
        const InterfaceEntry *entry = check_and_cast<const InterfaceEntry *>(obj);
        deleteInterfaceRoutes(entry);
    }
    else if (signalID == NF_INTERFACE_STATE_CHANGED) {
        invalidateCache();
    }
    else if (signalID == NF_INTERFACE_CONFIG_CHANGED) {
        invalidateCache();
    }
    else if (signalID == NF_INTERFACE_IPv4CONFIG_CHANGED) {
        // if anything IPv4-related changes in the interfaces, interface netmask
        // based routes have to be re-built.
        updateNetmaskRoutes();
    }
}

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);
}

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) {
        invalidateCache();
        ASSERT(entry->getRoutingTable() == this);    // still filled in, for the listeners' benefit
        emit(NF_MROUTE_DELETED, entry);
        entry->setRoutingTable(nullptr);
    }
    return entry;
}

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.

Referenced by removeMulticastRoute().

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

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->info() << "\n";
        invalidateCache();
        ASSERT(entry->getRoutingTable() == this);    // still filled in, for the listeners' benefit
        emit(NF_ROUTE_DELETED, entry);
        entry->setRoutingTable(nullptr);
    }
    return entry;
}

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.

Referenced by removeRoute().

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

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);

        invalidateCache();
    }
    emit(NF_ROUTE_CHANGED, entry);    // TODO include fieldCode in the notification
}

bool inet::IPv4RoutingTable::routeLessThan ( const IPv4Route *  a, const IPv4Route *  b  ) const

protected

Referenced by inet::IPv4RoutingTable::RouteLessThan::operator()().

{
    // 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();
}

void inet::IPv4RoutingTable::setRouterId ( IPv4Address  a )

overridevirtual

Sets routerId.

Implements inet::IIPv4RoutingTable.

{
    routerId = a;
}

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);
            ASSERT(route->getRoutingTable() == this);    // still filled in, for the listeners' benefit
            emit(NF_ROUTE_DELETED, 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++) {
        InterfaceEntry *ie = ift->getInterface(i);
        if (interfaceNameMatcher.matches(ie->getFullName()) && ie->ipv4Data() && ie->ipv4Data()->getNetmask() != IPv4Address::ALLONES_ADDRESS)
        {
            IPv4Route *route = createNewRoute();
            route->setSourceType(IRoute::IFACENETMASK);
            route->setSource(ie);
            route->setDestination(ie->ipv4Data()->getIPAddress().doAnd(ie->ipv4Data()->getNetmask()));
            route->setNetmask(ie->ipv4Data()->getNetmask());
            route->setGateway(IPv4Address());
            route->setAdminDist(IPv4Route::dDirectlyConnected);
            route->setMetric(ie->ipv4Data()->getMetric());
            route->setInterface(ie);
            route->setRoutingTable(this);
            auto pos = upper_bound(routes.begin(), routes.end(), route, RouteLessThan(*this));
            routes.insert(pos, route);
            emit(NF_ROUTE_ADDED, route);
        }
    }

    invalidateCache();
}

Member Data Documentation

bool inet::IPv4RoutingTable::forwarding = false

protected

IInterfaceTable* inet::IPv4RoutingTable::ift = nullptr

protected

bool inet::IPv4RoutingTable::isNodeUp = false

protected

AddressSet inet::IPv4RoutingTable::localAddresses

mutableprotected

AddressSet inet::IPv4RoutingTable::localBroadcastAddresses

mutableprotected

bool inet::IPv4RoutingTable::multicastForward = false

protected

MulticastRouteVector inet::IPv4RoutingTable::multicastRoutes

private

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

protected

IPv4Address inet::IPv4RoutingTable::routerId

protected

RouteVector inet::IPv4RoutingTable::routes

private

RoutingCache inet::IPv4RoutingTable::routingCache

mutableprotected

bool inet::IPv4RoutingTable::useAdminDist = false

protected

---

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

• IPv4RoutingTable.h
• IPv4RoutingTable.cc