inet::Ipv6RoutingTable Class Reference

Represents the Ipv6 routing table and neighbour discovery data structures. More...

#include <Ipv6RoutingTable.h>

Inheritance diagram for inet::Ipv6RoutingTable:

Classes
struct	DestCacheEntry
class	RouteLessThan

Public Member Functions
virtual void	addRoute (Ipv6Route *route)
	Ipv6RoutingTable ()
virtual	~Ipv6RoutingTable ()
Interfaces
virtual NetworkInterface *	getInterfaceByAddress (const Ipv6Address &address) const
	Returns an interface given by its address. More...
virtual bool	isRouter () const
	IP forwarding on/off. More...
virtual bool	isMulticastForwardingEnabled ()
virtual void	routeChanged (Ipv6Route *entry, int fieldCode)
	To be called from route objects whenever a field changes. More...
Routing functions
virtual bool	isLocalAddress (const Ipv6Address &dest) const
	Checks if the address is one of the host's addresses, i.e. More...
const Ipv6Address &	lookupDestCache (const Ipv6Address &dest, int &outInterfaceId)
	Looks up the given destination address in the Destination Cache, then returns the next-hop address and the interface in the outInterfaceId variable. More...
const Ipv6Route *	doLongestPrefixMatch (const Ipv6Address &dest)
	Performs longest prefix match in the routing table and returns the resulting route, or nullptr if there was no match. More...
virtual bool	isPrefixPresent (const Ipv6Address &prefix) const
	Checks if the given prefix already exists in the routing table (prefix list) More...
Managing the destination cache
virtual void	updateDestCache (const Ipv6Address &dest, const Ipv6Address &nextHopAddr, int interfaceId, simtime_t expiryTime)
	Add or update a destination cache entry. More...
virtual void	purgeDestCache ()
	Discard all entries in destination cache. More...
virtual void	purgeDestCacheEntriesToNeighbour (const Ipv6Address &nextHopAddr, int interfaceId)
	Discard all entries in destination cache where next hop is the given address on the given interface. More...
void	purgeDestCacheForInterfaceId (int interfaceId)
	Removes all destination cache entries for the specified interface. More...
Managing prefixes and the route table
virtual void	addOrUpdateOnLinkPrefix (const Ipv6Address &destPrefix, int prefixLength, int interfaceId, simtime_t expiryTime)
	Add on-link prefix (route of type FROM_RA), or update existing one. More...
virtual void	deleteOnLinkPrefix (const Ipv6Address &destPrefix, int prefixLength)
	Remove an on-link prefix. More...
virtual void	addOrUpdateOwnAdvPrefix (const Ipv6Address &destPrefix, int prefixLength, int interfaceId, simtime_t expiryTime)
	Add route of type OWN_ADV_PREFIX. More...
virtual void	addStaticRoute (const Ipv6Address &destPrefix, int prefixLength, unsigned int interfaceId, const Ipv6Address &nextHop, int metric=0)
	Creates a static route. More...
virtual void	addDefaultRoute (const Ipv6Address &raSrcAddr, unsigned int ifID, simtime_t routerLifetime)
	Adds a default route for a host. More...
virtual void	addRoutingProtocolRoute (Ipv6Route *route)
	Adds the given getRoute(which can be OSPF, BGP, RIP or any other route) with src==ROUTING_PROT. More...
virtual Ipv6Route *	removeRoute (Ipv6Route *route)
	Removes the given route from the routing table, and returns it. More...
virtual bool	deleteRoute (Ipv6Route *route)
	Deletes the given route from the route table. More...
virtual void	deleteInterfaceRoutes (const NetworkInterface *entry)
	Deletes the routes that are using the specified interface. More...
virtual int	getNumRoutes () const override
	Return the number of routes. More...
virtual Ipv6Route *	getRoute (int i) const override
	Return the ith route. More...
virtual bool	handleOperationStage (LifecycleOperation *operation, IDoneCallback *doneCallback) override
	ILifecycle method. More...
virtual bool	isAdminDistEnabled () const override
	Administrative distance on/off. More...
virtual bool	isForwardingEnabled () const override
	Forwarding on/off. More...
virtual bool	isMulticastForwardingEnabled () const override
	Multicast forwarding on/off. 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 bool	isLocalBroadcastAddress (const L3Address &dest) const
virtual NetworkInterface *	getInterfaceByAddress (const L3Address &address) const override
	Returns an interface given by its address. More...
virtual NetworkInterface *	findInterfaceByLocalBroadcastAddress (const L3Address &dest) const
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 *	getDefaultRoute () const override
	Finds and returns the default route, or nullptr if it doesn't exist. More...
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 IMulticastRoute *	getMulticastRoute (int i) const override
	Returns the kth multicast route. More...
virtual int	getNumMulticastRoutes () const override
	Returns the total number of multicast routes. 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...
virtual IRoute *	createRoute () override
virtual void	printRoutingTable () const override
	Prints 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 std::map< Ipv6Address, DestCacheEntry >	DestCache
typedef std::vector< Ipv6Route * >	RouteList

Protected Member Functions
virtual Ipv6Route *	createNewRoute (Ipv6Address destPrefix, int prefixLength, IRoute::SourceType src)
bool	routeLessThan (const Ipv6Route *a, const Ipv6Route *b) const
virtual void	configureInterfaceForIpv6 (NetworkInterface *ie)
virtual void	assignRequiredNodeAddresses (NetworkInterface *ie)
	RFC 3513: Section 2.8 A Node's Required Address Assign the various addresses to the node's respective interface. More...
virtual void	configureInterfaceFromXml (NetworkInterface *ie, cXMLElement *cfg)
virtual void	configureTunnelFromXml (cXMLElement *cfg)
void	internalAddRoute (Ipv6Route *route)
Ipv6Route *	internalRemoveRoute (Ipv6Route *route)
RouteList::iterator	internalDeleteRoute (RouteList::iterator it)
virtual void	refreshDisplay () const override
virtual int	numInitStages () const override
virtual void	initialize (int stage) override
virtual void	parseXmlConfigFile ()
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...

Protected Attributes
ModuleRefByPar< IInterfaceTable >	ift
bool	isrouter = false
bool	multicastForward = false
bool	useAdminDist = false
DestCache	destCache
RouteList	routeList

Friends
std::ostream &	operator<< (std::ostream &os, const DestCacheEntry &e)

Detailed Description

Represents the Ipv6 routing table and neighbour discovery data structures.

This object has one instance per host or router.

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.

The route table is read from a file. The route table can also be read and modified during simulation, typically by routing protocol implementations.

Member Typedef Documentation

DestCache

typedef std::map<Ipv6Address, DestCacheEntry> inet::Ipv6RoutingTable::DestCache

protected

RouteList

typedef std::vector<Ipv6Route *> inet::Ipv6RoutingTable::RouteList

protected

Constructor & Destructor Documentation

Ipv6RoutingTable()

inet::Ipv6RoutingTable::Ipv6RoutingTable

(

)

{
}

~Ipv6RoutingTable()

inet::Ipv6RoutingTable::~Ipv6RoutingTable ( )

virtual

{
    for (auto& elem : routeList)
        delete elem;
}

Member Function Documentation

addDefaultRoute()

void inet::Ipv6RoutingTable::addDefaultRoute ( const Ipv6Address &  raSrcAddr, unsigned int  ifID, simtime_t  routerLifetime  )

virtual

Adds a default route for a host.

This method requires the RA's source address and the router expiry time plus the simTime().

{
    // create route object
    Ipv6Route *route = createNewRoute(Ipv6Address(), 0, IRoute::ROUTER_ADVERTISEMENT);
    route->setInterface(ift->getInterfaceById(ifID));
    route->setNextHop(nextHop);
    route->setMetric(10); // FIXMEshould be filled from interface metric
    route->setAdminDist(Ipv6Route::dStatic);
 
#ifdef INET_WITH_xMIPv6
    route->setExpiryTime(routerLifetime); // lifetime useful after transitioning to new AR // 27.07.08 - CB
#endif /* INET_WITH_xMIPv6 */
 
    // then add it
    addRoute(route);
}

addMulticastRoute()

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

inlineoverridevirtual

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.

{ /*TODO addMulticastRoute(entry);*/ }

addOrUpdateOnLinkPrefix()

void inet::Ipv6RoutingTable::addOrUpdateOnLinkPrefix ( const Ipv6Address &  destPrefix, int  prefixLength, int  interfaceId, simtime_t  expiryTime  )

virtual

Add on-link prefix (route of type FROM_RA), or update existing one.

To be called from code processing on-link prefixes in Router Advertisements. Expiry time can be derived from the Valid Lifetime field in the Router Advertisements.

NOTE: This method does NOT update the lifetime of matching addresses in the IInterfaceTable (see Ipv6InterfaceData); that has to be done separately.

{
    // see if prefix exists in table
    Ipv6Route *route = nullptr;
    for (auto& elem : routeList) {
        if ((elem)->getSourceType() == IRoute::ROUTER_ADVERTISEMENT && (elem)->getDestPrefix() == destPrefix && (elem)->getPrefixLength() == prefixLength) {
            route = elem;
            break;
        }
    }
 
    if (route == nullptr) {
        // create new route object
        Ipv6Route *route = createNewRoute(destPrefix, prefixLength, IRoute::ROUTER_ADVERTISEMENT);
        route->setInterface(ift->getInterfaceById(interfaceId));
        route->setExpiryTime(expiryTime);
        route->setMetric(0);
        route->setAdminDist(Ipv6Route::dDirectlyConnected);
 
        // then add it
        addRoute(route);
    }
    else {
        // update existing one; notification-wise, we pretend the route got removed then re-added
        emit(routeDeletedSignal, route);
        route->setInterface(ift->getInterfaceById(interfaceId));
        route->setExpiryTime(expiryTime);
        emit(routeAddedSignal, route);
    }
}

addOrUpdateOwnAdvPrefix()

void inet::Ipv6RoutingTable::addOrUpdateOwnAdvPrefix ( const Ipv6Address &  destPrefix, int  prefixLength, int  interfaceId, simtime_t  expiryTime  )

virtual

Add route of type OWN_ADV_PREFIX.

This is a prefix that this router advertises on this interface.

{
    // FIXME this is very similar to the one above -- refactor!!
 
    // see if prefix exists in table
    Ipv6Route *route = nullptr;
    for (auto& elem : routeList) {
        if ((elem)->getSourceType() == IRoute::OWN_ADV_PREFIX && (elem)->getDestPrefix() == destPrefix && (elem)->getPrefixLength() == prefixLength) {
            route = elem;
            break;
        }
    }
 
    if (route == nullptr) {
        // create new route object
        Ipv6Route *route = createNewRoute(destPrefix, prefixLength, IRoute::OWN_ADV_PREFIX);
        route->setInterface(ift->getInterfaceById(interfaceId));
        route->setExpiryTime(expiryTime);
        route->setMetric(0);
        route->setAdminDist(Ipv6Route::dDirectlyConnected);
 
        // then add it
        addRoute(route);
    }
    else {
        // update existing one; notification-wise, we pretend the route got removed then re-added
        emit(routeDeletedSignal, route);
        route->setInterface(ift->getInterfaceById(interfaceId));
        route->setExpiryTime(expiryTime);
        emit(routeAddedSignal, route);
    }
}

Referenced by inet::Ipv6FlatNetworkConfigurator::addOwnAdvPrefixRoutes(), and initialize().

addRoute() [1/2]

void inet::Ipv6RoutingTable::addRoute ( Ipv6Route *  route )

virtual

{
    internalAddRoute(route);
 
    /*TODO this deletes some cache entries we want to keep, but the node MUST update
       the Destination Cache in such a way that the latest route information are used.*/
    purgeDestCache();
 
    emit(routeAddedSignal, route);
}

Referenced by addDefaultRoute(), addOrUpdateOnLinkPrefix(), addOrUpdateOwnAdvPrefix(), addRoutingProtocolRoute(), and addStaticRoute().

addRoute() [2/2]

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

inlineoverridevirtual

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.

{ addRoutingProtocolRoute(check_and_cast<Ipv6Route *>(entry)); } // TODO contrast that with addStaticRoute()!

addRoutingProtocolRoute()

void inet::Ipv6RoutingTable::addRoutingProtocolRoute ( Ipv6Route *  route )

virtual

Adds the given getRoute(which can be OSPF, BGP, RIP or any other route) with src==ROUTING_PROT.

To store additional information with the route, one can subclass from Ipv6Route and add more fields.

{
    // TODO ASSERT(route->getSrc()==Ipv6Route::ROUTING_PROT);
    addRoute(route);
}

addStaticRoute()

void inet::Ipv6RoutingTable::addStaticRoute ( const Ipv6Address &  destPrefix, int  prefixLength, unsigned int  interfaceId, const Ipv6Address &  nextHop, int  metric = 0  )

virtual

Creates a static route.

If metric is omitted, it gets initialized to the interface's metric value.

{
    // create route object
    Ipv6Route *route = createNewRoute(destPrefix, prefixLength, IRoute::MANUAL);
    route->setInterface(ift->getInterfaceById(interfaceId));
    route->setNextHop(nextHop);
    if (metric == 0)
        metric = 10; // TODO should be filled from interface metric
    route->setMetric(metric);
    route->setAdminDist(Ipv6Route::dStatic);
 
    // then add it
    addRoute(route);
}

Referenced by inet::Ipv6FlatNetworkConfigurator::addStaticRoutes(), and configureInterfaceForIpv6().

assignRequiredNodeAddresses()

void inet::Ipv6RoutingTable::assignRequiredNodeAddresses ( NetworkInterface *  ie )

protectedvirtual

RFC 3513: Section 2.8 A Node's Required Address Assign the various addresses to the node's respective interface.

This should be done when the Ipv6 Protocol stack is created.

{
    // RFC 3513 Section 2.8:A Node's Required Addresses
    /*A host is required to recognize the following addresses as
       identifying itself:*/
 
    // o  The loopback address.
    if (ie->isLoopback()) {
        ie->getProtocolDataForUpdate<Ipv6InterfaceData>()->assignAddress(Ipv6Address("::1"), false, SIMTIME_ZERO, SIMTIME_ZERO);
        return;
    }
    // o  Its required Link-Local Address for each interface.
 
#ifndef INET_WITH_xMIPv6
//    Ipv6Address linkLocalAddr = Ipv6Address().formLinkLocalAddress(ie->getInterfaceToken());
//    ie->getProtocolData<Ipv6InterfaceData>()->assignAddress(linkLocalAddr, true, 0, 0);
#else /* INET_WITH_xMIPv6 */
    Ipv6Address linkLocalAddr = Ipv6Address().formLinkLocalAddress(ie->getInterfaceToken());
    ie->getProtocolDataForUpdate<Ipv6InterfaceData>()->assignAddress(linkLocalAddr, true, SIMTIME_ZERO, SIMTIME_ZERO);
#endif /* INET_WITH_xMIPv6 */
 
    /*o  Any additional Unicast and Anycast Addresses that have been configured
       for the node's interfaces (manually or automatically).*/
 
    // FIXME FIXME Andras: commented out the following lines, because these addresses
    // are implicitly checked for in isLocalAddress()  (we don't want redundancy,
    // and manually adding solicited-node mcast address for each and every address
    // is very error-prone!)
    //
    // o  The All-Nodes Multicast Addresses defined in section 2.7.1.
 
    /*o  The Solicited-Node Multicast Address for each of its unicast and anycast
       addresses.*/
 
    // o  Multicast Addresses of all other groups to which the node belongs.
 
    /*A router is required to recognize all addresses that a host is
       required to recognize, plus the following addresses as identifying
       itself:*/
    /*o  The Subnet-Router Anycast Addresses for all interfaces for
       which it is configured to act as a router.*/
 
    // o  All other Anycast Addresses with which the router has been configured.
    // o  The All-Routers Multicast Addresses defined in section 2.7.1.
}

Referenced by configureInterfaceForIpv6().

configureInterfaceForIpv6()

void inet::Ipv6RoutingTable::configureInterfaceForIpv6 ( NetworkInterface *  ie )

protectedvirtual

{
    auto ipv6IfData = ie->addProtocolData<Ipv6InterfaceData>();
 
    // for routers, turn on advertisements by default
    // FIXME we will use this isRouter flag for now. what if future implementations
    // have 2 interfaces where one interface is configured as a router and the other
    // as a host?
    ipv6IfData->setAdvSendAdvertisements(isrouter); // Added by WEI
 
    // metric: some hints: OSPF cost (2e9/bps value), MS KB article Q299540, ...
    //d->setMetric((int)ceil(2e9/ie->getDatarate())); // use OSPF cost as default
    // FIXME TODO fill in the rest
 
    assignRequiredNodeAddresses(ie);
 
    // add link-local prefix to each interface according to RFC 4861 5.1
    if (!ie->isLoopback())
        addStaticRoute(Ipv6Address::LINKLOCAL_PREFIX, 10, ie->getInterfaceId(), Ipv6Address::UNSPECIFIED_ADDRESS);
 
    if (ie->isMulticast()) {
        // TODO join other ALL_NODES_x and ALL_ROUTERS_x addresses too?
        ipv6IfData->joinMulticastGroup(Ipv6Address::ALL_NODES_2);
        if (isrouter)
            ipv6IfData->joinMulticastGroup(Ipv6Address::ALL_ROUTERS_2);
    }
}

Referenced by initialize().

configureInterfaceFromXml()

void inet::Ipv6RoutingTable::configureInterfaceFromXml ( NetworkInterface *  ie, cXMLElement *  cfg  )

protectedvirtual

{
    /*XML parsing capabilities tweaked by WEI. For now, we can configure a specific
       node's interface. We can set advertising prefixes and other variables to be used
       in RAs. The Ipv6 interface data gets overwritten if lines 249 to 262 is uncommented.
       The fix is to create an XML file with all the default values. Customised XML files
       can be used for future protocols that requires different values. (MIPv6)*/
    auto d = ie->getProtocolDataForUpdate<Ipv6InterfaceData>();
 
    // parse basic config (attributes)
    d->setAdvSendAdvertisements(toBool(getRequiredAttr(cfg, "AdvSendAdvertisements")));
    // TODO leave this off first!! They overwrite stuff!
 
    /* TODO Wei commented out the stuff below. To be checked why (Andras).
       d->setMaxRtrAdvInterval(utils::atod(getRequiredAttr(cfg, "MaxRtrAdvInterval")));
       d->setMinRtrAdvInterval(utils::atod(getRequiredAttr(cfg, "MinRtrAdvInterval")));
       d->setAdvManagedFlag(toBool(getRequiredAttr(cfg, "AdvManagedFlag")));
       d->setAdvOtherConfigFlag(toBool(getRequiredAttr(cfg, "AdvOtherConfigFlag")));
       d->setAdvLinkMTU(utils::atoul(getRequiredAttr(cfg, "AdvLinkMTU")));
       d->setAdvReachableTime(utils::atoul(getRequiredAttr(cfg, "AdvReachableTime")));
       d->setAdvRetransTimer(utils::atoul(getRequiredAttr(cfg, "AdvRetransTimer")));
       d->setAdvCurHopLimit(utils::atoul(getRequiredAttr(cfg, "AdvCurHopLimit")));
       d->setAdvDefaultLifetime(utils::atoul(getRequiredAttr(cfg, "AdvDefaultLifetime")));
       ie->setMtu(utils::atoul(getRequiredAttr(cfg, "HostLinkMTU")));
       d->setCurHopLimit(utils::atoul(getRequiredAttr(cfg, "HostCurHopLimit")));
       d->setBaseReachableTime(utils::atoul(getRequiredAttr(cfg, "HostBaseReachableTime")));
       d->setRetransTimer(utils::atoul(getRequiredAttr(cfg, "HostRetransTimer")));
       d->setDupAddrDetectTransmits(utils::atoul(getRequiredAttr(cfg, "HostDupAddrDetectTransmits")));
     */
 
    // parse prefixes (AdvPrefix elements; they should be inside an AdvPrefixList
    // element, but we don't check that)
    cXMLElementList prefixList = cfg->getElementsByTagName("AdvPrefix");
    for (auto& elem : prefixList) {
        cXMLElement *node = elem;
        Ipv6InterfaceData::AdvPrefix prefix;
 
        // FIXME todo implement: advValidLifetime, advPreferredLifetime can
        // store (absolute) expiry time (if >0) or lifetime (delta) (if <0);
        // 0 should be treated as infinity
        int pfxLen;
        if (!prefix.prefix.tryParseAddrWithPrefix(node->getNodeValue(), pfxLen))
            throw cRuntimeError("Element <%s> at %s: wrong Ipv6Address/prefix syntax %s",
                    node->getTagName(), node->getSourceLocation(), node->getNodeValue());
 
        prefix.prefixLength = pfxLen;
        prefix.advValidLifetime = utils::atoul(getRequiredAttr(node, "AdvValidLifetime"));
        prefix.advOnLinkFlag = toBool(getRequiredAttr(node, "AdvOnLinkFlag"));
        prefix.advPreferredLifetime = utils::atoul(getRequiredAttr(node, "AdvPreferredLifetime"));
        prefix.advAutonomousFlag = toBool(getRequiredAttr(node, "AdvAutonomousFlag"));
        d->addAdvPrefix(prefix);
    }
 
    // parse addresses
    cXMLElementList addrList = cfg->getChildrenByTagName("inetAddr");
    for (auto& elem : addrList) {
        cXMLElement *node = elem;
        Ipv6Address address = Ipv6Address(node->getNodeValue());
        // We can now decide if the address is tentative or not.
        d->assignAddress(address, toBool(getRequiredAttr(node, "tentative")), SIMTIME_ZERO, SIMTIME_ZERO); // set up with infinite lifetimes
    }
}

Referenced by parseXmlConfigFile().

configureTunnelFromXml()

void inet::Ipv6RoutingTable::configureTunnelFromXml ( cXMLElement *  cfg )

protectedvirtual

{
    Ipv6Tunneling *tunneling = getModuleFromPar<Ipv6Tunneling>(par("ipv6TunnelingModule"), this);
 
    // parse basic config (attributes)
    cXMLElementList tunnelList = cfg->getElementsByTagName("tunnelEntry");
    for (auto& elem : tunnelList) {
        cXMLElement *node = elem;
 
        Ipv6Address entry, exit, trigger;
        entry.set(getRequiredAttr(node, "entryPoint"));
        exit.set(getRequiredAttr(node, "exitPoint"));
 
        cXMLElementList triggerList = node->getElementsByTagName("triggers");
 
        if (triggerList.size() != 1)
            throw cRuntimeError("element <%s> at %s: Only exactly one trigger allowed",
                    node->getTagName(), node->getSourceLocation());
 
        cXMLElement *triggerNode = triggerList[0];
        trigger.set(getRequiredAttr(triggerNode, "destination"));
 
        EV_INFO << "New tunnel: " << "entry=" << entry << ",exit=" << exit << ",trigger=" << trigger << endl;
        tunneling->createTunnel(Ipv6Tunneling::NORMAL, entry, exit, trigger);
    }
}

Referenced by parseXmlConfigFile().

createNewRoute()

Ipv6Route * inet::Ipv6RoutingTable::createNewRoute ( Ipv6Address  destPrefix, int  prefixLength, IRoute::SourceType  src  )

protectedvirtual

{
    return new Ipv6Route(destPrefix, prefixLength, src);
}

Referenced by addDefaultRoute(), addOrUpdateOnLinkPrefix(), addOrUpdateOwnAdvPrefix(), and addStaticRoute().

createRoute()

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

inlineoverridevirtual

Implements inet::IRoutingTable.

{ return new Ipv6Route(Ipv6Address(), 0, IRoute::MANUAL); }

deleteInterfaceRoutes()

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

virtual

Deletes the routes that are using the specified interface.

{
    bool changed = false;
 
    // delete unicast routes using this interface
    for (auto it = routeList.begin(); it != routeList.end();) {
        Ipv6Route *route = *it;
        if (route->getInterface() == entry) {
            it = internalDeleteRoute(it);
            changed = true;
        }
        else
            ++it;
    }
 
    // TODO delete or update multicast routes:
    //   1. delete routes has entry as parent
    //   2. remove entry from children list
 
    if (changed) {
//        invalidateCache();
    }
}

Referenced by receiveSignal().

deleteMulticastRoute()

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

inlineoverridevirtual

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 false; /*TODO deleteMulticastRoute(entry);*/ }

deleteOnLinkPrefix()

void inet::Ipv6RoutingTable::deleteOnLinkPrefix ( const Ipv6Address &  destPrefix, int  prefixLength  )

virtual

Remove an on-link prefix.

To be called when the prefix gets advertised with zero lifetime, or to purge an expired prefix.

NOTE: This method does NOT remove the matching addresses from the IInterfaceTable (see Ipv6InterfaceData); that has to be done separately.

{
    // scan the routing table for this prefix and remove it
    for (auto it = routeList.begin(); it != routeList.end(); it++) {
        if ((*it)->getSourceType() == IRoute::ROUTER_ADVERTISEMENT && (*it)->getDestPrefix() == destPrefix && (*it)->getPrefixLength() == prefixLength) {
            internalDeleteRoute(it);
            return; // there can be only one such route, addOrUpdateOnLinkPrefix() guarantees that
        }
    }
}

deleteRoute() [1/2]

bool inet::Ipv6RoutingTable::deleteRoute ( Ipv6Route *  route )

virtual

Deletes the given route from the route table.

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

{
    auto it = find(routeList, route);
    if (it == routeList.end())
        return false;
 
    internalDeleteRoute(it);
    return true;
}

deleteRoute() [2/2]

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

inlineoverridevirtual

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

Referenced by deleteRoute().

doLongestPrefixMatch()

const Ipv6Route * inet::Ipv6RoutingTable::doLongestPrefixMatch

(

const Ipv6Address &

dest

)

Performs longest prefix match in the routing table and returns the resulting route, or nullptr if there was no match.

{
    Enter_Method("doLongestPrefixMatch(%s)", dest.str().c_str());
 
    // we'll just stop at the first match, because the table is sorted
    // by prefix lengths and metric (see addRoute())
 
    auto it = routeList.begin();
    while (it != routeList.end()) {
        if (dest.matches((*it)->getDestPrefix(), (*it)->getPrefixLength())) {
            if (simTime() > (*it)->getExpiryTime() && (*it)->getExpiryTime() != 0) { // since 0 represents infinity.
                if ((*it)->getSourceType() == IRoute::ROUTER_ADVERTISEMENT) {
                    EV_INFO << "Expired prefix detected!!" << endl;
                    it = internalDeleteRoute(it); // TODO update display string
                }
            }
            else
                return *it;
        }
        else
            ++it;
    }
    // FIXME todo: if we selected an expired route, throw it out and select again!
    return nullptr;
}

findBestMatchingMulticastRoute()

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

inlineoverridevirtual

Returns route for a multicast origin and group.

Implements inet::IRoutingTable.

{ return nullptr; /*TODO findBestMatchingMulticastRoute(origin.toIPv6(), group.toIPv6());*/ }

findBestMatchingRoute()

virtual IRoute* inet::Ipv6RoutingTable::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 const_cast<Ipv6Route *>((const_cast<Ipv6RoutingTable *>(this))->doLongestPrefixMatch(dest.toIpv6())); } // FIXME what a name??!! also: remove const; ALSO: THIS DOES NOT UPDATE DESTCACHE LIKE METHODS BUILT ON IT!

findInterfaceByLocalBroadcastAddress()

virtual NetworkInterface* inet::Ipv6RoutingTable::findInterfaceByLocalBroadcastAddress ( const L3Address &  dest ) const

inlinevirtual

{ return nullptr; /*TODO findInterfaceByLocalBroadcastAddress(dest.toIPv6());*/ }

getDefaultRoute()

virtual IRoute* inet::Ipv6RoutingTable::getDefaultRoute ( ) const

inlineoverridevirtual

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

Implements inet::IRoutingTable.

{ return nullptr; /*TODO getDefaultRoute();*/ }

getInterfaceByAddress() [1/2]

NetworkInterface * inet::Ipv6RoutingTable::getInterfaceByAddress ( const Ipv6Address &  address ) const

virtual

Returns an interface given by its address.

Returns nullptr if not found.

{
    Enter_Method("getInterfaceByAddress(%s)=?", addr.str().c_str());
 
    return ift->findInterfaceByAddress(addr);
}

Referenced by getInterfaceByAddress().

getInterfaceByAddress() [2/2]

NetworkInterface * inet::Ipv6RoutingTable::getInterfaceByAddress ( const L3Address &  address ) const

overridevirtual

Returns an interface given by its address.

Returns nullptr if not found.

Implements inet::IRoutingTable.

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

getMulticastRoute()

virtual IMulticastRoute* inet::Ipv6RoutingTable::getMulticastRoute ( int  k ) const

inlineoverridevirtual

Returns the kth multicast route.

Implements inet::IRoutingTable.

{ return nullptr; /*TODO*/ }

getNextHopForDestination()

virtual L3Address inet::Ipv6RoutingTable::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.

{ const Ipv6Route *e = (const_cast<Ipv6RoutingTable *>(this))->doLongestPrefixMatch(dest.toIpv6()); return e ? e->getNextHopAsGeneric() : L3Address(); }

getNumMulticastRoutes()

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

inlineoverridevirtual

Returns the total number of multicast routes.

Implements inet::IRoutingTable.

{ return 0; /*TODO getNumMulticastRoutes();*/ }

getNumRoutes()

int inet::Ipv6RoutingTable::getNumRoutes ( ) const

overridevirtual

Return the number of routes.

Implements inet::IRoutingTable.

{
    return routeList.size();
}

Referenced by inet::ospfv3::Ospfv3Process::isInRoutingTable6(), and refreshDisplay().

getOutputInterfaceForDestination()

virtual NetworkInterface* inet::Ipv6RoutingTable::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.

{ const Ipv6Route *e = (const_cast<Ipv6RoutingTable *>(this))->doLongestPrefixMatch(dest.toIpv6()); return e ? e->getInterface() : nullptr; }

getRoute()

Ipv6Route * inet::Ipv6RoutingTable::getRoute ( int  i ) const

overridevirtual

Return the ith route.

Implements inet::IRoutingTable.

{
    ASSERT(i >= 0 && i < (int)routeList.size());
    return routeList[i];
}

Referenced by inet::ospfv3::Ospfv3Process::isInRoutingTable6().

getRouterIdAsGeneric()

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

inlineoverridevirtual

Returns routerId.

Implements inet::IRoutingTable.

{ return L3Address(Ipv6Address()); /*TODO getRouterId();*/ }

handleMessage()

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

overrideprotectedvirtual

Raises an error.

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

handleOperationStage()

bool inet::Ipv6RoutingTable::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)
            ; // TODO
    }
    else if (dynamic_cast<ModuleStopOperation *>(operation)) {
        if (static_cast<ModuleStopOperation::Stage>(stage) == ModuleStopOperation::STAGE_NETWORK_LAYER)
            while (!routeList.empty())
                delete removeRoute(routeList[0]);
 
    }
    else if (dynamic_cast<ModuleCrashOperation *>(operation)) {
        if (static_cast<ModuleCrashOperation::Stage>(stage) == ModuleCrashOperation::STAGE_CRASH)
            while (!routeList.empty())
                delete removeRoute(routeList[0]);
 
    }
    return true;
}

initialize()

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

overrideprotectedvirtual

{
    cSimpleModule::initialize(stage);
 
    if (stage == INITSTAGE_LOCAL) {
        WATCH_PTRVECTOR(routeList);
        WATCH_MAP(destCache); // FIXME commented out for now
        isrouter = par("isRouter");
        multicastForward = par("multicastForwarding");
        useAdminDist = par("useAdminDist");
        WATCH(isrouter);
 
        ift.reference(this, "interfaceTableModule", true);
 
#ifdef INET_WITH_xMIPv6
        // the following MIPv6 related flags will be overridden by the MIPv6 module (if existing)
        ishome_agent = false;
        WATCH(ishome_agent);
 
        ismobile_node = false;
        WATCH(ismobile_node);
 
        mipv6Support = false; // 4.9.07 - CB
#endif /* INET_WITH_xMIPv6 */
 
        cModule *host = getContainingNode(this);
 
        host->subscribe(interfaceCreatedSignal, this);
        host->subscribe(interfaceDeletedSignal, this);
        host->subscribe(interfaceStateChangedSignal, this);
        host->subscribe(interfaceConfigChangedSignal, this);
        host->subscribe(interfaceIpv6ConfigChangedSignal, this);
    }
    // TODO INITSTAGE
    else if (stage == INITSTAGE_LINK_LAYER) {
        // add Ipv6InterfaceData to interfaces
        for (int i = 0; i < ift->getNumInterfaces(); i++) {
            NetworkInterface *ie = ift->getInterface(i);
            configureInterfaceForIpv6(ie);
        }
    }
    // TODO INITSTAGE
    else if (stage == INITSTAGE_NETWORK_CONFIGURATION) {
        parseXmlConfigFile();
 
        // skip hosts
        if (isrouter) {
            // add globally routable prefixes to routing table
            for (int x = 0; x < ift->getNumInterfaces(); x++) {
                NetworkInterface *ie = ift->getInterface(x);
 
                if (ie->isLoopback())
                    continue;
 
                for (int y = 0; y < ie->getProtocolData<Ipv6InterfaceData>()->getNumAdvPrefixes(); y++)
                    if (ie->getProtocolData<Ipv6InterfaceData>()->getAdvPrefix(y).prefix.isGlobal())
                        addOrUpdateOwnAdvPrefix(ie->getProtocolData<Ipv6InterfaceData>()->getAdvPrefix(y).prefix,
                                ie->getProtocolData<Ipv6InterfaceData>()->getAdvPrefix(y).prefixLength,
                                ie->getInterfaceId(), SIMTIME_ZERO);
 
            }
        }
    }
}

internalAddRoute()

void inet::Ipv6RoutingTable::internalAddRoute ( Ipv6Route *  route )

protected

{
    ASSERT(route->getRoutingTable() == nullptr);
 
    routeList.push_back(route);
    route->setRoutingTable(this);
 
    // we keep entries sorted by prefix length in routeList, so that we can
    // stop at the first match when doing the longest prefix matching
    std::stable_sort(routeList.begin(), routeList.end(), RouteLessThan(*this));
}

Referenced by addRoute(), and routeChanged().

internalDeleteRoute()

Ipv6RoutingTable::RouteList::iterator inet::Ipv6RoutingTable::internalDeleteRoute ( RouteList::iterator  it )

protected

{
    ASSERT(it != routeList.end());
    Ipv6Route *route = *it;
    it = routeList.erase(it);
    emit(routeDeletedSignal, route);
    // TODO purge cache?
    delete route;
    return it;
}

Referenced by deleteInterfaceRoutes(), deleteOnLinkPrefix(), deleteRoute(), and doLongestPrefixMatch().

internalRemoveRoute()

Ipv6Route * inet::Ipv6RoutingTable::internalRemoveRoute ( Ipv6Route *  route )

protected

{
    auto i = find(routeList, route);
    if (i != routeList.end()) {
        ASSERT(route->getRoutingTable() == this);
        routeList.erase(i);
        route->setRoutingTable(nullptr);
        return route;
    }
    return nullptr;
}

Referenced by removeRoute(), and routeChanged().

isAdminDistEnabled()

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

inlineoverridevirtual

Administrative distance on/off.

Implements inet::IRoutingTable.

{ return useAdminDist; }

isForwardingEnabled()

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

inlineoverridevirtual

Forwarding on/off.

Implements inet::IRoutingTable.

{ return isRouter(); } // TODO inconsistent names

isLocalAddress() [1/2]

bool inet::Ipv6RoutingTable::isLocalAddress ( const Ipv6Address &  dest ) const

virtual

Checks if the address is one of the host's addresses, i.e.

assigned to one of its interfaces (tentatively or not).

{
    Enter_Method("isLocalAddress(%s) y/n", dest.str().c_str());
 
    // first, check if we have an interface with this address
    if (ift->isLocalAddress(dest))
        return true;
 
    // then check for special, preassigned multicast addresses
    // (these addresses occur more rarely than specific interface addresses,
    // that's why we check for them last)
 
    if (dest == Ipv6Address::ALL_NODES_1 || dest == Ipv6Address::ALL_NODES_2)
        return true;
 
    if (isRouter() && (dest == Ipv6Address::ALL_ROUTERS_1 || dest == Ipv6Address::ALL_ROUTERS_2 || dest == Ipv6Address::ALL_ROUTERS_5 ||
                       dest == Ipv6Address::ALL_OSPF_ROUTERS_MCAST || dest == Ipv6Address::ALL_OSPF_DESIGNATED_ROUTERS_MCAST))
        return true;
 
    // check for solicited-node multicast address
    if (dest.matches(Ipv6Address::SOLICITED_NODE_PREFIX, 104)) {
        for (int i = 0; i < ift->getNumInterfaces(); i++) {
            NetworkInterface *ie = ift->getInterface(i);
            if (ie->getProtocolData<Ipv6InterfaceData>()->matchesSolicitedNodeMulticastAddress(dest))
                return true;
        }
    }
    return false;
}

isLocalAddress() [2/2]

virtual bool inet::Ipv6RoutingTable::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.toIpv6()); }

Referenced by isLocalAddress().

isLocalBroadcastAddress()

virtual bool inet::Ipv6RoutingTable::isLocalBroadcastAddress ( const L3Address &  dest ) const

inlinevirtual

{ return false; /*TODO isLocalBroadcastAddress(dest.toIPv6());*/ }

isLocalMulticastAddress()

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

inlineoverridevirtual

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

Implements inet::IRoutingTable.

{ return false; /*TODO isLocalMulticastAddress(dest.toIPv6());*/ }

isMulticastForwardingEnabled() [1/2]

virtual bool inet::Ipv6RoutingTable::isMulticastForwardingEnabled ( )

inlinevirtual

{ return multicastForward; }

isMulticastForwardingEnabled() [2/2]

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

inlineoverridevirtual

Multicast forwarding on/off.

Implements inet::IRoutingTable.

{ return true; /*TODO isMulticastForwardingEnabled();*/ }

isPrefixPresent()

bool inet::Ipv6RoutingTable::isPrefixPresent ( const Ipv6Address &  prefix ) const

virtual

Checks if the given prefix already exists in the routing table (prefix list)

{
    for (const auto& elem : routeList)
        if (prefix.matches((elem)->getDestPrefix(), 128))
            return true;
 
    return false;
}

isRouter()

virtual bool inet::Ipv6RoutingTable::isRouter ( ) const

inlinevirtual

IP forwarding on/off.

{ return isrouter; }

Referenced by isLocalAddress().

lookupDestCache()

const Ipv6Address & inet::Ipv6RoutingTable::lookupDestCache	(	const Ipv6Address &	dest,
		int &	outInterfaceId
	)

Looks up the given destination address in the Destination Cache, then returns the next-hop address and the interface in the outInterfaceId variable.

If the destination is not in the cache, outInterfaceId is set to -1 and the unspecified address is returned. The caller should check for interfaceId==-1, because unspecified address is also returned if the link layer doesn't use addresses at all (e.g. PPP).

NOTE: outInterfaceId is an OUTPUT parameter – its initial value is ignored, and the lookupDestCache() sets it to the correct value instead.

{
    Enter_Method("lookupDestCache(%s)", dest.str().c_str());
 
    auto it = destCache.find(dest);
    if (it == destCache.end()) {
        outInterfaceId = -1;
        return Ipv6Address::UNSPECIFIED_ADDRESS;
    }
    DestCacheEntry& entry = it->second;
    if (entry.expiryTime > 0 && simTime() > entry.expiryTime) {
        destCache.erase(it);
        outInterfaceId = -1;
        return Ipv6Address::UNSPECIFIED_ADDRESS;
    }
 
    outInterfaceId = entry.interfaceId;
    return entry.nextHopAddr;
}

numInitStages()

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

inlineoverrideprotectedvirtual

{ return NUM_INIT_STAGES; }

parseXmlConfigFile()

void inet::Ipv6RoutingTable::parseXmlConfigFile ( )

protectedvirtual

{
    cModule *host = getContainingNode(this);
 
    // configure interfaces from XML config file
    cXMLElement *config = par("routes");
    for (cXMLElement *child = config->getFirstChild(); child; child = child->getNextSibling()) {
//        std::cout << "configuring interfaces from XML file." << endl;
//        std::cout << "selected element is: " << child->getTagName() << endl;
        // we ensure that the selected element is local.
        if (opp_strcmp(child->getTagName(), "local") != 0)
            continue;
        // ensure that this is the right parent module we are configuring.
        if (opp_strcmp(child->getAttribute("node"), host->getFullName()) != 0)
            continue;
        // Go one level deeper.
//        child = child->getFirstChild();
        for (cXMLElement *ifTag = child->getFirstChild(); ifTag; ifTag = ifTag->getNextSibling()) {
            // The next tag should be "interface".
            if (opp_strcmp(ifTag->getTagName(), "interface") == 0) {
//                std::cout << "Getting attribute: name" << endl;
                const char *ifname = ifTag->getAttribute("name");
                if (!ifname)
                    throw cRuntimeError("<interface> without name attribute at %s", child->getSourceLocation());
 
                NetworkInterface *ie = ift->findInterfaceByName(ifname);
                if (!ie)
                    throw cRuntimeError("no interface named %s was registered, %s", ifname, child->getSourceLocation());
 
                configureInterfaceFromXml(ie, ifTag);
            }
            else if (opp_strcmp(ifTag->getTagName(), "tunnel") == 0)
                configureTunnelFromXml(ifTag);
        }
    }
}

Referenced by initialize().

printRoutingTable()

void inet::Ipv6RoutingTable::printRoutingTable ( ) const

overridevirtual

Prints the routing table.

Implements inet::IRoutingTable.

{
    for (const auto& elem : routeList)
        EV_INFO << (elem)->getInterface()->getInterfaceFullPath() << " -> " << (elem)->getDestinationAsGeneric().str() << " as " << (elem)->str() << endl;
}

purgeDestCache()

void inet::Ipv6RoutingTable::purgeDestCache ( )

virtual

Discard all entries in destination cache.

{
    destCache.clear();
}

Referenced by addRoute().

purgeDestCacheEntriesToNeighbour()

void inet::Ipv6RoutingTable::purgeDestCacheEntriesToNeighbour ( const Ipv6Address &  nextHopAddr, int  interfaceId  )

virtual

Discard all entries in destination cache where next hop is the given address on the given interface.

This is typically called when a router becomes unreachable, and all destinations going via that router have to go though router selection again.

{
    for (auto it = destCache.begin(); it != destCache.end();) {
        if (it->second.interfaceId == interfaceId && it->second.nextHopAddr == nextHopAddr) {
            // move the iterator past this element before removing it
            destCache.erase(it++);
        }
        else {
            it++;
        }
    }
}

purgeDestCacheForInterfaceId()

void inet::Ipv6RoutingTable::purgeDestCacheForInterfaceId

(

int

interfaceId

)

Removes all destination cache entries for the specified interface.

{
    for (auto it = destCache.begin(); it != destCache.end();) {
        if (it->second.interfaceId == interfaceId) {
            // move the iterator past this element before removing it
            destCache.erase(it++);
        }
        else {
            ++it;
        }
    }
}

Referenced by receiveSignal().

receiveSignal()

void inet::Ipv6RoutingTable::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) {
        // TODO something like this:
//        NetworkInterface *ie = check_and_cast<NetworkInterface*>(details);
//        configureInterfaceForIPv6(ie);
    }
    else if (signalID == interfaceDeletedSignal) {
        // remove all routes that point to that interface
        const NetworkInterface *entry = check_and_cast<const NetworkInterface *>(obj);
        deleteInterfaceRoutes(entry);
    }
    else if (signalID == interfaceStateChangedSignal) {
        const NetworkInterface *networkInterface = check_and_cast<const NetworkInterfaceChangeDetails *>(obj)->getNetworkInterface();
        int networkInterfaceId = networkInterface->getInterfaceId();
 
        // an interface went down
        if (!networkInterface->isUp()) {
            deleteInterfaceRoutes(networkInterface);
            purgeDestCacheForInterfaceId(networkInterfaceId);
        }
    }
    else if (signalID == interfaceConfigChangedSignal) {
        // TODO invalidate routing cache (?)
    }
    else if (signalID == interfaceIpv6ConfigChangedSignal) {
        // TODO
    }
}

refreshDisplay()

void inet::Ipv6RoutingTable::refreshDisplay ( ) const

overrideprotectedvirtual

{
    std::stringstream os;
 
    os << getNumRoutes() << " routes\n" << destCache.size() << " destcache entries";
    getDisplayString().setTagArg("t", 0, os.str().c_str());
}

removeMulticastRoute()

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

inlineoverridevirtual

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.

{ /*TODO removeMulticastRoute(entry);*/ return entry; }

removeRoute() [1/2]

Ipv6Route * inet::Ipv6RoutingTable::removeRoute ( Ipv6Route *  route )

virtual

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

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

{
    route = internalRemoveRoute(route);
    if (route) {
        // TODO purge cache?
 
        emit(routeDeletedSignal, route); // rather: going to be deleted
    }
    return route;
}

Referenced by handleOperationStage().

removeRoute() [2/2]

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

inlineoverridevirtual

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

Referenced by removeRoute().

routeChanged()

void inet::Ipv6RoutingTable::routeChanged ( Ipv6Route *  entry, int  fieldCode  )

virtual

To be called from route objects whenever a field changes.

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

{
    if (fieldCode == Ipv6Route::F_DESTINATION || fieldCode == Ipv6Route::F_PREFIX_LENGTH || fieldCode == Ipv6Route::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(routeChangedSignal, entry); // TODO include fieldCode in the notification
}

Referenced by inet::Ipv6Route::changed().

routeLessThan()

bool inet::Ipv6RoutingTable::routeLessThan ( const Ipv6Route *  a, const Ipv6Route *  b  ) const

protected

{
    // helper for sort() in addRoute(). We want routes with longer
    // prefixes to be at front, so we compare them as "less".
    // For metric, a smaller value is better (we report that as "less").
    if (a->getPrefixLength() != b->getPrefixLength())
        return a->getPrefixLength() > b->getPrefixLength();
 
    // smaller administrative distance is better
    if (useAdminDist && (a->getAdminDist() != b->getAdminDist()))
        return a->getAdminDist() < b->getAdminDist();
 
    // smaller metric is better
    return a->getMetric() < b->getMetric();
}

updateDestCache()

void inet::Ipv6RoutingTable::updateDestCache ( const Ipv6Address &  dest, const Ipv6Address &  nextHopAddr, int  interfaceId, simtime_t  expiryTime  )

virtual

Add or update a destination cache entry.

{
    DestCacheEntry& entry = destCache[dest];
    entry.nextHopAddr = nextHopAddr;
    entry.interfaceId = interfaceId;
    entry.expiryTime = expiryTime;
}

Friends And Related Function Documentation

operator<<

std::ostream& operator<< ( std::ostream &  os, const DestCacheEntry &  e  )

friend

{
    os << "if=" << e.interfaceId << " " << e.nextHopAddr; // FIXME try printing interface name
    return os;
};

Member Data Documentation

destCache

DestCache inet::Ipv6RoutingTable::destCache

protected

Referenced by initialize(), lookupDestCache(), purgeDestCache(), purgeDestCacheEntriesToNeighbour(), purgeDestCacheForInterfaceId(), refreshDisplay(), and updateDestCache().

ift

ModuleRefByPar<IInterfaceTable> inet::Ipv6RoutingTable::ift

protected

Referenced by addDefaultRoute(), addOrUpdateOnLinkPrefix(), addOrUpdateOwnAdvPrefix(), addStaticRoute(), getInterfaceByAddress(), initialize(), isLocalAddress(), and parseXmlConfigFile().

isrouter

bool inet::Ipv6RoutingTable::isrouter = false

protected

Referenced by configureInterfaceForIpv6(), and initialize().

multicastForward

bool inet::Ipv6RoutingTable::multicastForward = false

protected

Referenced by initialize().

routeList

RouteList inet::Ipv6RoutingTable::routeList

protected

Referenced by addOrUpdateOnLinkPrefix(), addOrUpdateOwnAdvPrefix(), deleteInterfaceRoutes(), deleteOnLinkPrefix(), deleteRoute(), doLongestPrefixMatch(), getNumRoutes(), getRoute(), handleOperationStage(), initialize(), internalAddRoute(), internalDeleteRoute(), internalRemoveRoute(), isPrefixPresent(), printRoutingTable(), and ~Ipv6RoutingTable().

useAdminDist

bool inet::Ipv6RoutingTable::useAdminDist = false

protected

Referenced by initialize(), and routeLessThan().

---

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

• Ipv6RoutingTable.h
• Ipv6RoutingTable.cc