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
	IPv6RoutingTable ()
virtual	~IPv6RoutingTable ()
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...
bool	isHomeAgent () const
	Determine whether normal Router or Home Agent. More...
void	setIsHomeAgent (bool value)
	Define whether normal Router or Home Agent. More...
bool	isMobileNode () const
	Determine whether a node is a Mobile Node or Correspondent Node: MN if TRUE or else a CN. More...
void	setIsMobileNode (bool value)
	Define whether a node is a Mobile Node or Correspondent Node: MN if TRUE or else a CN. More...
const IPv6Address &	getHomeAddress ()
bool	isHomeAddress (const IPv6Address &addr)
	Check whether provided address is a HoA. More...
void	deleteDefaultRoutes (int interfaceID)
	Deletes the current default routes for the given interface. More...
void	deleteAllRoutes ()
	Deletes all routes from the routing table. More...
void	deletePrefixes (int interfaceID)
	Deletes all prefixes registered for the given interface. More...
bool	hasMIPv6Support ()
	Can be used to check whether this node supports MIPv6 or not (MN, MR, HA or CN). More...
void	setMIPv6Support (bool value)
	This method is used to define whether the node support MIPv6 or not (MN, MR, HA or CN). More...
bool	isOnLinkAddress (const IPv6Address &address)
	Checks whether the provided address is in an on-link address with respect to the prefix advertisement list. More...
virtual bool	handleOperationStage (LifecycleOperation *operation, int stage, IDoneCallback *doneCallback) override
	ILifecycle method. 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 InterfaceEntry *	getInterfaceByAddress (const L3Address &address) const override
	Returns an interface given by its address. More...
virtual InterfaceEntry *	findInterfaceByLocalBroadcastAddress (const L3Address &dest) const
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 *	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...
Interfaces
virtual InterfaceEntry *	getInterfaceByAddress (const IPv6Address &address) const
	Returns an interface given by its address. 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 InterfaceEntry *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...
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)
virtual void	addRoute (IPv6Route *route)
bool	routeLessThan (const IPv6Route *a, const IPv6Route *b) const
virtual void	configureInterfaceForIPv6 (InterfaceEntry *ie)
virtual void	assignRequiredNodeAddresses (InterfaceEntry *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 (InterfaceEntry *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
IInterfaceTable *	ift = nullptr
bool	isrouter = false
bool	multicastForward = false
bool	useAdminDist = false
bool	ishome_agent = false
bool	ismobile_node = false
bool	mipv6Support = 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

typedef std::map<IPv6Address, DestCacheEntry> inet::IPv6RoutingTable::DestCache

protected

typedef std::vector<IPv6Route *> inet::IPv6RoutingTable::RouteList

protected

Constructor & Destructor Documentation

inet::IPv6RoutingTable::IPv6RoutingTable

(

)

{
}

inet::IPv6RoutingTable::~IPv6RoutingTable ( )

virtual

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

Member Function Documentation

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().

Referenced by inet::IPv6NeighbourDiscovery::processRAForRouterUpdates().

{
    // create route object
    IPv6Route *route = createNewRoute(IPv6Address(), 0, IRoute::ROUTER_ADVERTISEMENT);
    route->setInterface(ift->getInterfaceById(ifID));
    route->setNextHop(nextHop);
    route->setMetric(10);    //FIXME:should be filled from interface metric
    route->setAdminDist(IPv6Route::dStatic);

#ifdef WITH_xMIPv6
    route->setExpiryTime(routerLifetime);    // lifetime useful after transitioning to new AR // 27.07.08 - CB
#endif /* WITH_xMIPv6 */

    // then add it
    addRoute(route);
}

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

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.

Referenced by inet::IPv6NeighbourDiscovery::processRAPrefixInfo().

{
    // 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(NF_ROUTE_DELETED, route);
        route->setInterface(ift->getInterfaceById(interfaceId));
        route->setExpiryTime(expiryTime);
        emit(NF_ROUTE_ADDED, route);
    }
}

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.

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

{
    // 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(NF_ROUTE_DELETED, route);
        route->setInterface(ift->getInterfaceById(interfaceId));
        route->setExpiryTime(expiryTime);
        emit(NF_ROUTE_ADDED, route);
    }
}

void inet::IPv6RoutingTable::addRoute ( IPv6Route *  route )

protectedvirtual

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

{
    internalAddRoute(route);

    /*XXX: 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(NF_ROUTE_ADDED, route);
}

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)); }    //XXX contrast that with addStaticRoute()!

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

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.

Referenced by inet::FlatNetworkConfigurator6::addStaticRoutes(), and configureInterfaceForIPv6().

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

    // then add it
    addRoute(route);
}

void inet::IPv6RoutingTable::assignRequiredNodeAddresses ( InterfaceEntry *  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.

Referenced by configureInterfaceForIPv6().

{
    //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->ipv6Data()->assignAddress(IPv6Address("::1"), false, SIMTIME_ZERO, SIMTIME_ZERO);
        return;
    }
    //o  Its required Link-Local Address for each interface.

#ifndef WITH_xMIPv6
    //IPv6Address linkLocalAddr = IPv6Address().formLinkLocalAddress(ie->getInterfaceToken());
    //ie->ipv6Data()->assignAddress(linkLocalAddr, true, 0, 0);
#else /* WITH_xMIPv6 */
    IPv6Address linkLocalAddr = IPv6Address().formLinkLocalAddress(ie->getInterfaceToken());
    ie->ipv6Data()->assignAddress(linkLocalAddr, true, SIMTIME_ZERO, SIMTIME_ZERO);
#endif /* 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.
}

void inet::IPv6RoutingTable::configureInterfaceForIPv6 ( InterfaceEntry *  ie )

protectedvirtual

Referenced by initialize().

{
    IPv6InterfaceData *ipv6IfData = new IPv6InterfaceData();
    ie->setIPv6Data(ipv6IfData);

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

void inet::IPv6RoutingTable::configureInterfaceFromXML ( InterfaceEntry *  ie, cXMLElement *  cfg  )

protectedvirtual

Referenced by parseXMLConfigFile().

{
    /*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)*/
    IPv6InterfaceData *d = ie->ipv6Data();

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

void inet::IPv6RoutingTable::configureTunnelFromXML ( cXMLElement *  cfg )

protectedvirtual

Referenced by parseXMLConfigFile().

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

IPv6Route * inet::IPv6RoutingTable::createNewRoute ( IPv6Address  destPrefix, int  prefixLength, IRoute::SourceType  src  )

protectedvirtual

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

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

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

inlineoverridevirtual

Implements inet::IRoutingTable.

{ return new IPv6Route(IPv6Address(), 0, IRoute::MANUAL); }

void inet::IPv6RoutingTable::deleteAllRoutes

(

)

Deletes all routes from the routing table.

{
    EV_INFO << "/// Removing all routes from rt6 " << endl;

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

    routeList.clear();
    // TODO purge cache?
}

void inet::IPv6RoutingTable::deleteDefaultRoutes

(

int

interfaceID

)

Deletes the current default routes for the given interface.

Referenced by inet::IPv6NeighbourDiscovery::routersUnreachabilityDetection().

{
    ASSERT(interfaceID >= 0);

    EV_INFO << "/// Removing default route for interface=" << interfaceID << endl;

    for (auto it = routeList.begin(); it != routeList.end(); ) {
        // default routes have prefix length 0
        if ((*it)->getInterface() && (*it)->getInterface()->getInterfaceId() == interfaceID &&
            (*it)->getPrefixLength() == 0)
            it = internalDeleteRoute(it);
        else
            ++it;
    }
}

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

virtual

Deletes the routes that are using the specified interface.

Referenced by receiveSignal().

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

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

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.

Referenced by inet::IPv6NeighbourDiscovery::processRAPrefixInfo(), and inet::IPv6NeighbourDiscovery::timeoutPrefixEntry().

{
    // 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
        }
    }
}

void inet::IPv6RoutingTable::deletePrefixes

(

int

interfaceID

)

Deletes all prefixes registered for the given interface.

Referenced by inet::IPv6NeighbourDiscovery::routersUnreachabilityDetection().

{
    ASSERT(interfaceID >= 0);

    for (auto it = routeList.begin(); it != routeList.end(); ) {
        // "real" prefixes have a length of larger then 0
        if ((*it)->getInterface() && (*it)->getInterface()->getInterfaceId() == interfaceID &&
            (*it)->getPrefixLength() > 0)
            it = internalDeleteRoute(it);
        else
            ++it;
    }
}

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 = std::find(routeList.begin(), routeList.end(), route);
    if (it == routeList.end())
        return false;

    internalDeleteRoute(it);
    return true;
}

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.

Referenced by deleteRoute().

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

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.

Referenced by inet::IPv6NeighbourDiscovery::determineNextHop(), and inet::IPv6::determineOutputInterface().

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

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

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!

virtual InterfaceEntry* inet::IPv6RoutingTable::findInterfaceByLocalBroadcastAddress ( const L3Address &  dest ) const

inlinevirtual

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

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

const IPv6Address & inet::IPv6RoutingTable::getHomeAddress

(

)

{
    for (int i = 0; i < ift->getNumInterfaces(); ++i) {
        InterfaceEntry *ie = ift->getInterface(i);

        return ie->ipv6Data()->getMNHomeAddress();
    }

    return IPv6Address::UNSPECIFIED_ADDRESS;
}

InterfaceEntry * inet::IPv6RoutingTable::getInterfaceByAddress ( const IPv6Address &  address ) const

virtual

Returns an interface given by its address.

Returns nullptr if not found.

Referenced by inet::IPv6::encapsulate(), and getInterfaceByAddress().

{
    Enter_Method("getInterfaceByAddress(%s)=?", addr.str().c_str());

    if (addr.isUnspecified())
        return nullptr;

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

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

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

inlineoverridevirtual

Returns the kth multicast route.

Implements inet::IRoutingTable.

{ return nullptr;    /*TODO*/ }

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

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

inlineoverridevirtual

Returns the total number of multicast routes.

Implements inet::IRoutingTable.

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

int inet::IPv6RoutingTable::getNumRoutes ( ) const

overridevirtual

Return the number of routes.

Implements inet::IRoutingTable.

Referenced by refreshDisplay().

{
    return routeList.size();
}

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

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

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

inlineoverridevirtual

Returns routerId.

Implements inet::IRoutingTable.

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

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

overrideprotectedvirtual

Raises an error.

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

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

    }
    else if (dynamic_cast<NodeCrashOperation *>(operation)) {
        if ((NodeCrashOperation::Stage)stage == NodeCrashOperation::STAGE_CRASH)
            while (!routeList.empty())
                delete removeRoute(routeList[0]);

    }
    return true;
}

bool inet::IPv6RoutingTable::hasMIPv6Support ( )

inline

Can be used to check whether this node supports MIPv6 or not (MN, MR, HA or CN).

Referenced by inet::IPv6::localDeliver(), inet::IPv6::processExtensionHeaders(), and inet::IPv6NeighbourDiscovery::sendPeriodicRA().

{ return mipv6Support; }

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 = getModuleFromPar<IInterfaceTable>(par("interfaceTableModule"), this);

#ifdef 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 /* WITH_xMIPv6 */

        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_IPv6CONFIG_CHANGED, this);
    }
    else if (stage == INITSTAGE_NETWORK_LAYER) {
        // add IPv6InterfaceData to interfaces
        for (int i = 0; i < ift->getNumInterfaces(); i++) {
            InterfaceEntry *ie = ift->getInterface(i);
            configureInterfaceForIPv6(ie);
        }

        parseXMLConfigFile();

        // skip hosts
        if (isrouter) {
            // add globally routable prefixes to routing table
            for (int x = 0; x < ift->getNumInterfaces(); x++) {
                InterfaceEntry *ie = ift->getInterface(x);

                if (ie->isLoopback())
                    continue;

                for (int y = 0; y < ie->ipv6Data()->getNumAdvPrefixes(); y++)
                    if (ie->ipv6Data()->getAdvPrefix(y).prefix.isGlobal())
                        addOrUpdateOwnAdvPrefix(ie->ipv6Data()->getAdvPrefix(y).prefix,
                                ie->ipv6Data()->getAdvPrefix(y).prefixLength,
                                ie->getInterfaceId(), SIMTIME_ZERO);

            }
        }
    }
}

void inet::IPv6RoutingTable::internalAddRoute ( IPv6Route *  route )

protected

Referenced by addRoute(), and routeChanged().

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

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

protected

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

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

IPv6Route * inet::IPv6RoutingTable::internalRemoveRoute ( IPv6Route *  route )

protected

Referenced by removeRoute(), and routeChanged().

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

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

inlineoverridevirtual

Forwarding on/off.

Implements inet::IRoutingTable.

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

bool inet::IPv6RoutingTable::isHomeAddress

(

const IPv6Address &

addr

)

Check whether provided address is a HoA.

Referenced by inet::xMIPv6::processType2RH(), inet::IPv6::routePacket(), and inet::xMIPv6::validateHoTMessage().

{
    // check all interfaces whether they have the
    // provided address as HoA
    for (int i = 0; i < ift->getNumInterfaces(); ++i) {
        InterfaceEntry *ie = ift->getInterface(i);
        if (ie->ipv6Data()->getMNHomeAddress() == addr)
            return true;
    }

    return false;
}

bool inet::IPv6RoutingTable::isHomeAgent ( ) const

inline

Determine whether normal Router or Home Agent.

Referenced by inet::IPv6NeighbourDiscovery::createAndSendRAPacket(), inet::IPv6Tunneling::decapsulateDatagram(), inet::xMIPv6::processBUMessage(), inet::xMIPv6::removeTimerEntries(), and inet::IPv6::routePacket().

{ return ishome_agent; }

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

Referenced by inet::IPv6Tunneling::createTunnel(), inet::IPv6::handleMessageFromHL(), inet::IPv6NeighbourDiscovery::processNSForTentativeAddress(), inet::IPv6::routeMulticastPacket(), and inet::IPv6::routePacket().

{
    Enter_Method("isLocalAddress(%s) y/n", dest.str().c_str());

    // first, check if we have an interface with this address
    for (int i = 0; i < ift->getNumInterfaces(); i++) {
        InterfaceEntry *ie = ift->getInterface(i);
        if (ie->ipv6Data()->hasAddress(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))
        return true;

    // check for solicited-node multicast address
    if (dest.matches(IPv6Address::SOLICITED_NODE_PREFIX, 104)) {
        for (int i = 0; i < ift->getNumInterfaces(); i++) {
            InterfaceEntry *ie = ift->getInterface(i);
            if (ie->ipv6Data()->matchesSolicitedNodeMulticastAddress(dest))
                return true;
        }
    }
    return false;
}

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.

Referenced by isLocalAddress().

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

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

inlinevirtual

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

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

bool inet::IPv6RoutingTable::isMobileNode ( ) const

inline

Determine whether a node is a Mobile Node or Correspondent Node: MN if TRUE or else a CN.

Referenced by inet::IPv6Tunneling::decapsulateDatagram(), inet::xMIPv6::initialize(), inet::xMIPv6::initiateMIPv6Protocol(), inet::IPv6NeighbourDiscovery::makeTentativeAddressPermanent(), inet::xMIPv6::processBAMessage(), inet::xMIPv6::processBUMessage(), inet::IPv6NeighbourDiscovery::processRAPrefixInfoForAddrAutoConf(), inet::xMIPv6::removeTimerEntries(), inet::IPv6::resolveMACAddressAndSendPacket(), and inet::IPv6::routePacket().

{ return ismobile_node; }

virtual bool inet::IPv6RoutingTable::isMulticastForwardingEnabled ( )

inlinevirtual

{ return multicastForward; }

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

inlineoverridevirtual

Multicast forwarding on/off.

Implements inet::IRoutingTable.

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

bool inet::IPv6RoutingTable::isOnLinkAddress

(

const IPv6Address &

address

)

Checks whether the provided address is in an on-link address with respect to the prefix advertisement list.

Referenced by inet::xMIPv6::processBUMessage().

{
    for (int j = 0; j < ift->getNumInterfaces(); j++) {
        InterfaceEntry *ie = ift->getInterface(j);

        for (int i = 0; i < ie->ipv6Data()->getNumAdvPrefixes(); i++)
            if (address.matches(ie->ipv6Data()->getAdvPrefix(i).prefix, ie->ipv6Data()->getAdvPrefix(i).prefixLength))
                return true;

    }

    return false;
}

bool inet::IPv6RoutingTable::isPrefixPresent ( const IPv6Address &  prefix ) const

virtual

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

Referenced by inet::IPv6NeighbourDiscovery::processRAPrefixInfo().

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

    return false;
}

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

inlinevirtual

IP forwarding on/off.

Referenced by inet::IPv6Tunneling::createTunnel(), inet::IPv6::determineOutputInterface(), isLocalAddress(), inet::IPv6NeighbourDiscovery::makeTentativeAddressPermanent(), inet::IPv6::routeMulticastPacket(), inet::IPv6::routePacket(), inet::IPv6NeighbourDiscovery::sendSolicitedNA(), and inet::IPv6NeighbourDiscovery::sendUnsolicitedNA().

{ return isrouter; }

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.

Referenced by inet::IPv6::determineOutputInterface(), and inet::IPv6Tunneling::encapsulateDatagram().

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

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

inlineoverrideprotectedvirtual

{ return NUM_INIT_STAGES; }

void inet::IPv6RoutingTable::parseXMLConfigFile ( )

protectedvirtual

Referenced by initialize().

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

                InterfaceEntry *ie = ift->getInterfaceByName(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);
        }
    }
}

void inet::IPv6RoutingTable::printRoutingTable ( ) const

overridevirtual

Prints the routing table.

Implements inet::IRoutingTable.

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

void inet::IPv6RoutingTable::purgeDestCache ( )

virtual

Discard all entries in destination cache.

Referenced by addRoute().

{
    destCache.clear();
}

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.

Referenced by inet::IPv6NeighbourDiscovery::timeoutDefaultRouter().

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

void inet::IPv6RoutingTable::purgeDestCacheForInterfaceID

(

int

interfaceId

)

Removes all destination cache entries for the specified interface.

Referenced by receiveSignal().

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

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

    if (signalID == NF_INTERFACE_CREATED) {
        //TODO something like this:
        //InterfaceEntry *ie = check_and_cast<InterfaceEntry*>(details);
        //configureInterfaceForIPv6(ie);
    }
    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) {
        const InterfaceEntry *interfaceEntry = check_and_cast<const InterfaceEntryChangeDetails*>(obj)->getInterfaceEntry();
        int interfaceEntryId = interfaceEntry->getInterfaceId();

        // an interface went down
        if (!interfaceEntry->isUp()) {
            purgeDestCacheForInterfaceID(interfaceEntryId);
        }
    }
    else if (signalID == NF_INTERFACE_CONFIG_CHANGED) {
        //TODO invalidate routing cache (?)
    }
    else if (signalID == NF_INTERFACE_IPv6CONFIG_CHANGED) {
        //TODO
    }
}

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

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

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.

Referenced by handleOperationStage().

{
    route = internalRemoveRoute(route);
    if (route) {
        // TODO purge cache?

        emit(NF_ROUTE_DELETED, route);    // rather: going to be deleted
    }
    return route;
}

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.

Referenced by removeRoute().

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

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.

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

{
    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(NF_ROUTE_CHANGED, entry);    // TODO include fieldCode in the notification
}

bool inet::IPv6RoutingTable::routeLessThan ( const IPv6Route *  a, const IPv6Route *  b  ) const

protected

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

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

void inet::IPv6RoutingTable::setIsHomeAgent ( bool  value )

inline

Define whether normal Router or Home Agent.

Referenced by inet::xMIPv6::initialize().

{ ishome_agent = value; }

void inet::IPv6RoutingTable::setIsMobileNode ( bool  value )

inline

Define whether a node is a Mobile Node or Correspondent Node: MN if TRUE or else a CN.

Referenced by inet::xMIPv6::initialize().

{ ismobile_node = value; }

void inet::IPv6RoutingTable::setMIPv6Support ( bool  value )

inline

This method is used to define whether the node support MIPv6 or not (MN, MR, HA or CN).

Referenced by inet::xMIPv6::initialize().

{ mipv6Support = value; }

void inet::IPv6RoutingTable::updateDestCache ( const IPv6Address &  dest, const IPv6Address &  nextHopAddr, int  interfaceId, simtime_t  expiryTime  )

virtual

Add or update a destination cache entry.

Referenced by inet::IPv6NeighbourDiscovery::determineNextHop(), and inet::IPv6::determineOutputInterface().

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

Friends And Related Function Documentation

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 inet::IPv6RoutingTable::destCache

protected

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

IInterfaceTable* inet::IPv6RoutingTable::ift = nullptr

protected

Referenced by addDefaultRoute(), addOrUpdateOnLinkPrefix(), addOrUpdateOwnAdvPrefix(), addStaticRoute(), getHomeAddress(), getInterfaceByAddress(), initialize(), isHomeAddress(), isLocalAddress(), isOnLinkAddress(), and parseXMLConfigFile().

bool inet::IPv6RoutingTable::ishome_agent = false

protected

Referenced by initialize().

bool inet::IPv6RoutingTable::ismobile_node = false

protected

Referenced by initialize().

bool inet::IPv6RoutingTable::isrouter = false

protected

Referenced by configureInterfaceForIPv6(), and initialize().

bool inet::IPv6RoutingTable::mipv6Support = false

protected

Referenced by initialize().

bool inet::IPv6RoutingTable::multicastForward = false

protected

Referenced by initialize().

RouteList inet::IPv6RoutingTable::routeList

protected

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

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