inet::IPv6Tunneling Class Reference

Management of IP tunnels. More...

#include <IPv6Tunneling.h>

Inheritance diagram for inet::IPv6Tunneling:

Classes
struct	equalTunnel
struct	Tunnel

Public Types
enum	TunnelType {   INVALID = 0, SPLIT, NON_SPLIT, NORMAL,   T2RH, HA_OPT, MOBILITY }

Public Member Functions
	IPv6Tunneling ()
virtual void	initialize (int stage) override
	Initialize tunnel manager. More...
virtual int	numInitStages () const override
virtual void	handleMessage (cMessage *msg) override
	Receive messages from IPv6 module and encapsulate/decapsulate them. More...
virtual bool	handleOperationStage (LifecycleOperation *operation, int stage, IDoneCallback *doneCallback) override
	Perform one stage of a lifecycle operation. More...
int	createTunnel (TunnelType tunnelType, const IPv6Address &src, const IPv6Address &dest, const IPv6Address &destTrigger=IPv6Address::UNSPECIFIED_ADDRESS)
	Creates a tunnel with given entry and exit point, which will be used for datagrams destined for destTrigger. More...
bool	destroyTunnel (const IPv6Address &src, const IPv6Address &dest, const IPv6Address &destTrigger)
	Creates a pseudo-tunnel for use with either Type 2 Routing Header or Home Address Option with given entry and exit point, which will be used for datagrams destined for destTrigger. More...
void	destroyTunnels (const IPv6Address &entry)
	Remove all tunnels with provided entry point. More...
void	destroyTunnel (const IPv6Address &entry, const IPv6Address &exit)
	Remove the tunnel with the provided entry and exit point. More...
void	destroyTunnelForExitAndTrigger (const IPv6Address &exit, const IPv6Address &trigger)
	Remove the tunnel with the provided exit point and trigger. More...
void	destroyTunnelForEntryAndTrigger (const IPv6Address &entry, const IPv6Address &trigger)
	Remove the tunnel with the provided entry point and trigger. More...
void	destroyTunnelFromTrigger (const IPv6Address &trigger)
	Remove the tunnel with the provided destination trigger. More...
int	getVIfIndexForDest (const IPv6Address &destAddress)
	Returns the virtual interface identifier for the tunnel which has the provided destination as destination trigger. More...
virtual int	getVIfIndexForDest (const IPv6Address &destAddress, TunnelType tunnelType)
	This method is equivalent for getVIfIndexForDest() except that it only searches for either "normal" or mobility tunnels. More...
bool	isTunnelExit (const IPv6Address &exit)
	This method is equivalent for getVIfIndexForDest() except that it only searches for pseudo tunnels (T2RH, etc.). More...
Public Member Functions inherited from inet::ILifecycle
virtual	~ILifecycle ()

Protected Types
typedef std::map< int, struct Tunnel >	Tunnels
typedef Tunnels::const_iterator	TI

Protected Member Functions
int	findTunnel (const IPv6Address &src, const IPv6Address &dest, const IPv6Address &destTrigger) const
	Returns the type of the tunnels: non-split, split, T2RH, ... More...
void	encapsulateDatagram (IPv6Datagram *dgram)
	Encapsulate a datagram with tunnel headers. More...
void	decapsulateDatagram (IPv6Datagram *dgram)
	Strip tunnel headers from datagram. More...

Protected Attributes
IInterfaceTable *	ift = nullptr
IPv6RoutingTable *	rt = nullptr
Tunnels	tunnels
int	vIfIndexTop = 0
int	noOfNonSplitTunnels = 0

Private Member Functions
int	lookupTunnels (const IPv6Address &dest)
	Search through all tunnels and locate one entry which is anything but a non-split tunnel and has a destination trigger for the provided address. More...
int	doPrefixMatch (const IPv6Address &dest)
	Search through all tunnels and locate one entry which is a non-split tunnel (later on this could be exteded to searching for a tunnel that has a prefix matching the provided address). More...
void	resetVIfIndex ()
	Reset the vIfIndex to its starting value if no tunnels exist anymore. More...

Friends
std::ostream &	operator<< (std::ostream &os, const IPv6Tunneling::Tunnel &tun)

Detailed Description

Management of IP tunnels.

Member Typedef Documentation

typedef Tunnels::const_iterator inet::IPv6Tunneling::TI

protected

typedef std::map<int, struct Tunnel> inet::IPv6Tunneling::Tunnels

protected

Member Enumeration Documentation

enum inet::IPv6Tunneling::TunnelType

Enumerator
INVALID
SPLIT
NON_SPLIT
NORMAL
T2RH
HA_OPT
MOBILITY

                    {
        INVALID = 0,
        SPLIT,
        NON_SPLIT,
        NORMAL,    // either split or non-split
        T2RH,
        HA_OPT,
        MOBILITY    // either T2RH or HA_OPT
    };

Constructor & Destructor Documentation

inet::IPv6Tunneling::IPv6Tunneling

(

)

{
}

Member Function Documentation

int inet::IPv6Tunneling::createTunnel	(	TunnelType	tunnelType,
		const IPv6Address &	src,
		const IPv6Address &	dest,
		const IPv6Address &	destTrigger = IPv6Address::UNSPECIFIED_ADDRESS
	)

Creates a tunnel with given entry and exit point, which will be used for datagrams destined for destTrigger.

Type of tunnel (normal tunnel, mobility related pseudo-tunnel) is determined by first parameter. Returns virtual interface index.

Referenced by inet::IPv6RoutingTable::configureTunnelFromXML(), inet::xMIPv6::processBAMessage(), and inet::xMIPv6::processBUMessage().

{
    ASSERT(entry != IPv6Address::UNSPECIFIED_ADDRESS);
    ASSERT(exit != IPv6Address::UNSPECIFIED_ADDRESS);

    // Test for entry and exit point node pointing to same node i.e. localDeliver
    // addresses to prevent loopback encapsulation 4.1.2
    if ((tunnelType == NORMAL || tunnelType == SPLIT || tunnelType == NON_SPLIT)    // check does not work for T2RH or HoA_Opt. Why?
        && rt->isLocalAddress(entry) && rt->isLocalAddress(exit))
    {
        EV_INFO << "Cannot create tunnel with local endpoints (prevents loopback tunneling)" << endl;
        return 0;
    }

    int search = findTunnel(entry, exit, destTrigger);
    if (search != 0) {
        EV_INFO << "Tunnel with entry = " << entry << ", exit = " << exit << " and trigger = "
                << destTrigger << " already exists!" << endl;
        return search;
    }

    if (vIfIndexTop <= (ift->getBiggestInterfaceId()))
        throw cRuntimeError("Error: Not more than %d tunnels supported!", INT_MAX - ift->getBiggestInterfaceId());

    if ((destTrigger == IPv6Address::UNSPECIFIED_ADDRESS) && (noOfNonSplitTunnels == 1))
        throw cRuntimeError("Error: Not more than 1 non-split tunnel supported!");

    // 6.1-6.2
    ASSERT(entry.isUnicast());
    tunnels[vIfIndexTop] = Tunnel(entry, exit, destTrigger);

    if (tunnelType == NORMAL || tunnelType == SPLIT || tunnelType == NON_SPLIT) {
        if (destTrigger == IPv6Address::UNSPECIFIED_ADDRESS) {
            // this is a "full" tunnel over which everything gets routed
            tunnels[vIfIndexTop].tunnelType = NON_SPLIT;
            noOfNonSplitTunnels++;
        }

        // default values: 5.
        // 6.4
        tunnels[vIfIndexTop].trafficClass = 0;

        // 6.5
        tunnels[vIfIndexTop].flowLabel = 0;

        // 6.3
        // The tunnel hop limit default value for hosts is the IPv6 Neighbor
        // Discovery advertised hop limit [ND-Spec].
        if (rt->isRouter())
            tunnels[vIfIndexTop].hopLimit = IPv6__INET_DEFAULT_ROUTER_HOPLIMIT;
        else
            tunnels[vIfIndexTop].hopLimit = 255;

        // 6.7
        // TODO perform path MTU on link (interface resolved via exit address)
        tunnels[vIfIndexTop].tunnelMTU = IPv6_MIN_MTU - 40;

        EV_INFO << "Tunneling: Created tunnel with entry=" << entry << ", exit=" << exit
                << " and trigger=" << destTrigger << endl;
    }
    else if (tunnelType == T2RH || tunnelType == HA_OPT) {
        tunnels[vIfIndexTop].tunnelType = tunnelType;

        if (tunnelType == T2RH)
            EV_INFO << "Tunneling: Created RH2 path with entry=" << entry << ", exit=" << exit
                    << " and trigger=" << destTrigger << endl;
        else
            EV_INFO << "Tunneling: Created HA option path with entry=" << entry << ", exit=" << exit
                    << " and trigger=" << destTrigger << endl;
    }
    else {
        throw cRuntimeError("tunnel type %d not supported for createTunnel()", tunnelType);
    }

    if (hasGUI())
        bubble("Created Tunnel");

    return vIfIndexTop--;    // decrement vIfIndex for use with next createTunnel() call
}

void inet::IPv6Tunneling::decapsulateDatagram ( IPv6Datagram *  dgram )

protected

Strip tunnel headers from datagram.

Referenced by handleMessage().

{
    // decapsulation is performed in IPv6 module
    // just update controlInfo
    IPv6ControlInfo *controlInfo = check_and_cast<IPv6ControlInfo *>(dgram->removeControlInfo());

#ifdef WITH_xMIPv6
    // we only decapsulate packets for which we have a tunnel
    // where the exit point is equal to the packets source
    // 11.9.07 - CB
    if (rt->isHomeAgent() && !isTunnelExit(controlInfo->getSrcAddr())) {
        /*RFC 3775, 10.4.5
           Otherwise, when a home agent decapsulates a tunneled packet from
           the mobile node, the home agent MUST verify that the Source
           Address in the tunnel IP header is the mobile node's primary
           care-of address.  Otherwise, any node in the Internet could send
           traffic through the home agent and escape ingress filtering
           limitations.  This simple check forces the attacker to know the
           current location of the real mobile node and be able to defeat
           ingress filtering. This check is not necessary if the reverse-
           tunneled packet is protected by ESP in tunnel mode.*/
        EV_INFO << "Dropping packet: source address of tunnel IP header different from tunnel exit points!" << endl;
        delete controlInfo;
        delete dgram;
        return;
    }
#endif // ifdef WITH_xMIPv6

    // FIX: we leave the interface Id to it's previous value to make sure
    // that later processing knowns from which interface the datagram came from
    // (important if several interfaces are available)
    //controlInfo->setInterfaceId(-1);
    dgram->setControlInfo(controlInfo);

    send(dgram, "linkLayerOut");

#ifdef WITH_xMIPv6
    // Alain Tigyo, 21.03.2008
    // The following code is used for triggering RO to a CN
    InterfaceEntry *ie = ift->getInterfaceById(controlInfo->getInterfaceId());
    if (rt->isMobileNode() && (controlInfo->getSrcAddr() == ie->ipv6Data()->getHomeAgentAddress())
        && (dgram->getTransportProtocol() != IP_PROT_IPv6EXT_MOB))
    {
        EV_INFO << "Checking Route Optimization for: " << dgram->getSrcAddress() << endl;
        xMIPv6 *mipv6 = findModuleFromPar<xMIPv6>(par("xmipv6Module"), this);
        if (mipv6)
            mipv6->triggerRouteOptimization(dgram->getSrcAddress(), ie->ipv6Data()->getMNHomeAddress(), ie);
    }
#endif // ifdef WITH_xMIPv6
}

bool inet::IPv6Tunneling::destroyTunnel	(	const IPv6Address &	src,
		const IPv6Address &	dest,
		const IPv6Address &	destTrigger
	)

Creates a pseudo-tunnel for use with either Type 2 Routing Header or Home Address Option with given entry and exit point, which will be used for datagrams destined for destTrigger.

Returns virtual interface index. Remove tunnel and the associated entries from destination cache

Referenced by inet::xMIPv6::cancelEntries(), destroyTunnel(), destroyTunnelForEntryAndTrigger(), destroyTunnelForExitAndTrigger(), destroyTunnelFromTrigger(), destroyTunnels(), inet::xMIPv6::handleBULExpiry(), and inet::xMIPv6::returningHome().

{
    EV_INFO << "Destroy tunnel entry =" << src << ", exit = " << dest
            << ", destTrigger = " << destTrigger << "\n";

    // search for tunnel with given entry and exit point as well as trigger
    int vIfIndex = findTunnel(src, dest, destTrigger);

    if (vIfIndex == 0) {
        EV_WARN << "Tunnel not found\n";
        return false;
    }

    // if we delete a non-split tunnel, then we can
    // also decrement the appropriate counter
    if (tunnels[vIfIndex].tunnelType == NON_SPLIT)
        noOfNonSplitTunnels--;

    // TODO store vIfIndex for later reuse when creating a new tunnel
    tunnels.erase(vIfIndex);

    // reset the index if we do not have a single tunnel anymore
    resetVIfIndex();

    if (hasGUI())
        bubble("Destroyed Tunnel");

    return true;
}

void inet::IPv6Tunneling::destroyTunnel	(	const IPv6Address &	entry,
		const IPv6Address &	exit
	)

Remove the tunnel with the provided entry and exit point.

{
    for (auto it = tunnels.begin(); it != tunnels.end(); ) {
        if (it->second.entry == entry && it->second.exit == exit) {
            destroyTunnel(it->second.entry, it->second.exit, it->second.destTrigger);
            break;
        }
        else
            ++it;
    }

    // reset the index if we do not have a single tunnel anymore
    resetVIfIndex();
}

void inet::IPv6Tunneling::destroyTunnelForEntryAndTrigger	(	const IPv6Address &	entry,
		const IPv6Address &	trigger
	)

Remove the tunnel with the provided entry point and trigger.

Referenced by inet::xMIPv6::cancelEntries(), and inet::xMIPv6::processBUMessage().

{
    for (auto it = tunnels.begin(); it != tunnels.end(); ) {
        if (it->second.entry == entry && it->second.destTrigger == trigger) {
            destroyTunnel(it->second.entry, it->second.exit, it->second.destTrigger);
            break;
        }
        else
            ++it;
    }

    // reset the index if we do not have a single tunnel anymore
    resetVIfIndex();
}

void inet::IPv6Tunneling::destroyTunnelForExitAndTrigger	(	const IPv6Address &	exit,
		const IPv6Address &	trigger
	)

Remove the tunnel with the provided exit point and trigger.

Referenced by inet::xMIPv6::initiateMIPv6Protocol(), inet::xMIPv6::processBAMessage(), and inet::xMIPv6::returningHome().

{
    for (auto it = tunnels.begin(); it != tunnels.end(); ) {
        if (it->second.exit == exit && it->second.destTrigger == trigger) {
            destroyTunnel(it->second.entry, it->second.exit, it->second.destTrigger);
            break;
        }
        else
            ++it;
    }

    // reset the index if we do not have a single tunnel anymore
    resetVIfIndex();
}

void inet::IPv6Tunneling::destroyTunnelFromTrigger

(

const IPv6Address &

trigger

)

Remove the tunnel with the provided destination trigger.

Referenced by inet::xMIPv6::handleBCExpiry(), and inet::xMIPv6::processBUMessage().

{
    for (auto & elem : tunnels) {
        if (elem.second.destTrigger == trigger) {
            destroyTunnel(elem.second.entry, elem.second.exit, elem.second.destTrigger);

            // reset the index if we do not have a single tunnel anymore
            resetVIfIndex();

            return;    // there can not be more than one tunnel for a trigger
        }
    }
}

void inet::IPv6Tunneling::destroyTunnels

(

const IPv6Address &

entry

)

Remove all tunnels with provided entry point.

{
    for (auto it = tunnels.begin(); it != tunnels.end(); ) {
        if (it->second.entry == entry) {
            auto oldIt = it;
            ++it;

            destroyTunnel(oldIt->second.entry, oldIt->second.exit, oldIt->second.destTrigger);
        }
        else
            ++it;
    }

    // reset the index if we do not have a single tunnel anymore
    resetVIfIndex();
}

int inet::IPv6Tunneling::doPrefixMatch ( const IPv6Address &  dest )

private

Search through all tunnels and locate one entry which is a non-split tunnel (later on this could be exteded to searching for a tunnel that has a prefix matching the provided address).

Referenced by encapsulateDatagram(), and getVIfIndexForDest().

{
    int outInterfaceId = -1;

    // we'll just stop at the first match, because it is assumed that not
    // more than a single non-split tunnel is possible
    for (auto & elem : tunnels) {
        if (elem.second.tunnelType == NON_SPLIT) {
            outInterfaceId = elem.first;
            break;
        }
    }

    return outInterfaceId;
}

void inet::IPv6Tunneling::encapsulateDatagram ( IPv6Datagram *  dgram )

protected

Encapsulate a datagram with tunnel headers.

Attaches a Type 2 Routing Header in the control info if the datagram is routed over an appropriate RH2 pseudo tunnel.

Referenced by handleMessage().

{
    int vIfIndex = -1;

    if (dgram->getTransportProtocol() == IP_PROT_IPv6EXT_MOB) {
        // only look at non-split tunnel
        // (HoTI is only sent over HA tunnel)
        vIfIndex = doPrefixMatch(dgram->getDestAddress());
    }

    if ((dgram->getTransportProtocol() != IP_PROT_IPv6EXT_MOB) || (vIfIndex == -1)) {
        // look up all tunnels for dgram's destination
        vIfIndex = getVIfIndexForDest(dgram->getDestAddress());
        //EV << "looked up again!" << endl;
    }

    if (vIfIndex == -1)
        throw cRuntimeError("encapsulateDatagram(): tunnel not existent");

    // TODO copy information from old ctrlInfo into new one (Traffic Class, Flow label, etc.)
    delete dgram->removeControlInfo();

#ifdef WITH_xMIPv6
    if ((tunnels[vIfIndex].tunnelType == T2RH) || (tunnels[vIfIndex].tunnelType == HA_OPT)) {
        // pseudo-tunnel for Type 2 Routing Header
        // or Home Address Option

        IPv6Address src = dgram->getSrcAddress();
        IPv6Address dest = dgram->getDestAddress();
        IPv6Address rh2;    //dest

        if (src.isUnspecified()) {
            // if we do not have a valid source address, we'll have to ask
            // the routing table for the correct interface.
            int interfaceId;
            (void)(rt->lookupDestCache(dest, interfaceId));
        }

        if (tunnels[vIfIndex].tunnelType == T2RH) {    // update 15.01.08 - CB
            // this is the CN -> MN path
            src = tunnels[vIfIndex].entry;    // CN address
            dest = tunnels[vIfIndex].exit;    // CoA
            rh2 = tunnels[vIfIndex].destTrigger;    // HoA
        }
        else {
            // path MN -> CN
            src = tunnels[vIfIndex].entry;    // CoA
            dest = tunnels[vIfIndex].destTrigger;    // CN address
            rh2 = tunnels[vIfIndex].exit;    // HoA
        }

        // and now construct the new control info for the packet
        IPv6ControlInfo *controlInfo = new IPv6ControlInfo();
        controlInfo->setProtocol(dgram->getTransportProtocol());

        // get rid of the encapsulation of the IPv6 module
        cMessage *packet = dgram->decapsulate();
        delete dgram;

        if (tunnels[vIfIndex].tunnelType == T2RH) {
            // construct Type 2 Routing Header (RFC 3775 - 6.4.1)
            /*For a type 2 routing header, the Hdr Ext Len MUST be 2.  The Segments
               Left value describes the number of route segments remaining; i.e.,
               number of explicitly listed intermediate nodes still to be visited
               before reaching the final destination.  Segments Left MUST be 1.*/
            IPv6RoutingHeader *t2RH = new IPv6RoutingHeader();
            t2RH->setRoutingType(2);
            t2RH->setSegmentsLeft(1);
            t2RH->setAddressArraySize(1);
            // old src becomes address of T2RH
            t2RH->setAddress(0, rh2);

            // append T2RH to routing headers
            controlInfo->addExtensionHeader(t2RH);

            EV_INFO << "Added Type 2 Routing Header." << endl;
        }
        else {    // HA_OPT
                  /*The Home Address option is carried by the Destination Option
                     extension header (Next Header value = 60).  It is used in a packet
                     sent by a mobile node while away from home, to inform the recipient
                     of the mobile node's home address.*/
            HomeAddressOption *haOpt = new HomeAddressOption();
            haOpt->setHomeAddress(rh2);

            // append HA option to routing headers
            controlInfo->addExtensionHeader(haOpt);

            EV_INFO << "Added Home Address Option header." << endl;
        }

        // new src is tunnel entry (either CoA or CN)
        controlInfo->setSrcAddr(src);
        // copy old dest addr
        controlInfo->setDestAddr(dest);

        packet->setControlInfo(controlInfo);
        send(packet, "upperLayerOut");
    }
    else {
#endif    // WITH_xMIPv6
          // normal tunnel - just modify controlInfo and send
          // datagram back to IPv6 module for encapsulation

    IPv6ControlInfo *controlInfo = new IPv6ControlInfo();
    controlInfo->setProtocol(IP_PROT_IPv6);
    controlInfo->setSrcAddr(tunnels[vIfIndex].entry);
    controlInfo->setDestAddr(tunnels[vIfIndex].exit);
    controlInfo->setInterfaceId(-1);

    dgram->setControlInfo(controlInfo);
    send(dgram, "upperLayerOut");
#ifdef WITH_xMIPv6
}

#endif // ifdef WITH_xMIPv6
}

int inet::IPv6Tunneling::findTunnel ( const IPv6Address &  src, const IPv6Address &  dest, const IPv6Address &  destTrigger  ) const

protected

Returns the type of the tunnels: non-split, split, T2RH, ...

Returns the vIfIndex of tunnel if found, 0 otherwise.

Referenced by createTunnel(), and destroyTunnel().

{
    TI it = find_if(tunnels.begin(), tunnels.end(),
                bind1st(equalTunnel(), std::make_pair((int)0, Tunnel(src, dest, destTrigger))));

    if (it != tunnels.end())
        return it->first;

    return 0;
}

int inet::IPv6Tunneling::getVIfIndexForDest

(

const IPv6Address &

destAddress

)

Returns the virtual interface identifier for the tunnel which has the provided destination as destination trigger.

This is done by first looking at the split tunnels; if no split tunnels are found, a prefix matching on the non-split tunnels is then performed. In case both searches do not return a search hit, a value of -1 is returned.

Referenced by encapsulateDatagram(), inet::IPv6::routePacket(), and inet::xMIPv6::triggerRouteOptimization().

{
    //Enter_Method("Looking up Tunnels (%s)", destAddress.str().c_str());
    EV_INFO << "Looking up tunnels...";

    // first we look for tunnels with destAddress as trigger
    int vIfIndex = lookupTunnels(destAddress);

    if (vIfIndex == -1) {
        // then the only chance left for finding a suitable tunnel
        // is to find a non-split tunnel
        vIfIndex = doPrefixMatch(destAddress);
    }

    EV_DETAIL << "found vIf=" << vIfIndex << endl;

    return vIfIndex;
}

int inet::IPv6Tunneling::getVIfIndexForDest ( const IPv6Address &  destAddress, TunnelType  tunnelType  )

virtual

This method is equivalent for getVIfIndexForDest() except that it only searches for either "normal" or mobility tunnels.

{
    int outInterfaceId = -1;

    for (auto & elem : tunnels) {
        if (tunnelType == NORMAL || tunnelType == NON_SPLIT || tunnelType == SPLIT) {
            // we search here for tunnels which have a destination trigger and
            // check whether the trigger is equal to the destination
            // only "normal" tunnels, both split and non-split, are possible entry points
            if ((elem.second.tunnelType == NON_SPLIT) ||
                (elem.second.tunnelType == SPLIT && elem.second.destTrigger == destAddress))
            {
                outInterfaceId = elem.first;
                break;
            }
        }
        else if (tunnelType == MOBILITY || tunnelType == HA_OPT || tunnelType == T2RH) {
            if (elem.second.tunnelType != NON_SPLIT &&
                elem.second.tunnelType != SPLIT &&
                elem.second.destTrigger == destAddress
                )
            {
                outInterfaceId = elem.first;
                break;
            }
        }
    }

    return outInterfaceId;
}

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

overridevirtual

Receive messages from IPv6 module and encapsulate/decapsulate them.

{
    IPv6Datagram *dgram = check_and_cast<IPv6Datagram *>(msg);

    if (msg->getArrivalGate()->isName("upperLayerIn")) {
        // decapsulate
        decapsulateDatagram(dgram);
    }
    else if (msg->getArrivalGate()->isName("linkLayerIn")) {
        // encapsulate
        encapsulateDatagram(dgram);
    }
    else
        throw cRuntimeError("IPv6Tunneling: Unknown gate: %s!", msg->getArrivalGate()->getFullName());
}

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

overridevirtual

Perform one stage of a lifecycle operation.

Processing may be done entirely within this method, or may be a longer process that involves nonzero simulation time or several events, and is triggered by this method call.

Return value: true = "done"; false = "not yet done, will invoke doneCallback when done"

Implements inet::ILifecycle.

{
    throw cRuntimeError("Lifecycle operation support not implemented");
}

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

overridevirtual

Initialize tunnel manager.

{
    cSimpleModule::initialize(stage);

    if (stage == INITSTAGE_LOCAL) {
        ift = getModuleFromPar<IInterfaceTable>(par("interfaceTableModule"), this);
        rt = getModuleFromPar<IPv6RoutingTable>(par("routingTableModule"), this);

        vIfIndexTop = INT_MAX;    // virtual interface number set to maximum int value
        noOfNonSplitTunnels = 0;    // current number of non-split tunnels on this host

        WATCH_MAP(tunnels);
    }
    else if (stage == INITSTAGE_NETWORK_LAYER) {
        bool isOperational;
        NodeStatus *nodeStatus = dynamic_cast<NodeStatus *>(findContainingNode(this)->getSubmodule("status"));
        isOperational = (!nodeStatus) || nodeStatus->getState() == NodeStatus::UP;
        if (!isOperational)
            throw cRuntimeError("This module doesn't support starting in node DOWN state");
    }
}

bool inet::IPv6Tunneling::isTunnelExit

(

const IPv6Address &

exit

)

This method is equivalent for getVIfIndexForDest() except that it only searches for pseudo tunnels (T2RH, etc.).

Check if there exists a tunnel with exit equal to the provided address.

Referenced by decapsulateDatagram().

{
    for (auto & elem : tunnels) {
        // mobility "tunnels" are not relevant for decapsulation
        // 17.10.07 - same for Home Address Option
        if (elem.second.tunnelType != T2RH && elem.second.tunnelType != HA_OPT
            && elem.second.exit == exit)
        {
            return true;
        }
    }

    return false;
}

int inet::IPv6Tunneling::lookupTunnels ( const IPv6Address &  dest )

private

Search through all tunnels and locate one entry which is anything but a non-split tunnel and has a destination trigger for the provided address.

Referenced by getVIfIndexForDest().

{
    int outInterfaceId = -1;

    // we search here for tunnels which have a destination trigger and
    // check whether the trigger is equal to the destination
    // only split tunnels or mobility paths are possible entry points
    for (auto & elem : tunnels) {
        if ((elem.second.tunnelType != NON_SPLIT) && (elem.second.destTrigger == dest)) {
            outInterfaceId = elem.first;
            break;
        }
    }

    return outInterfaceId;
}

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

inlineoverridevirtual

{ return NUM_INIT_STAGES; }

void inet::IPv6Tunneling::resetVIfIndex ( )

inlineprivate

Reset the vIfIndex to its starting value if no tunnels exist anymore.

Referenced by destroyTunnel(), destroyTunnelForEntryAndTrigger(), destroyTunnelForExitAndTrigger(), destroyTunnelFromTrigger(), and destroyTunnels().

{ if (tunnels.size() == 0) vIfIndexTop = INT_MAX; };

Friends And Related Function Documentation

std::ostream& operator<< ( std::ostream &  os, const IPv6Tunneling::Tunnel &  tun  )

friend

{
    os << "tunnel entry = " << tun.entry << ", exit = " << tun.exit << ", tunnelMTU = "
       << tun.tunnelMTU << ", dest = " << tun.destTrigger << ", type: ";

    switch (tun.tunnelType) {
        case IPv6Tunneling::SPLIT:
            os << "split tunnel";
            break;

        case IPv6Tunneling::NON_SPLIT:
            os << "non-split tunnel";
            break;

        case IPv6Tunneling::T2RH:
            os << "T2RH path";
            break;

        case IPv6Tunneling::HA_OPT:
            os << "Home Address Option path";
            break;

        default:
            throw cRuntimeError("Not a valid type for an existing tunnel!");
            break;
    }

    os << endl;

    return os;
}

Member Data Documentation

IInterfaceTable* inet::IPv6Tunneling::ift = nullptr

protected

Referenced by createTunnel(), decapsulateDatagram(), and initialize().

int inet::IPv6Tunneling::noOfNonSplitTunnels = 0

protected

Referenced by createTunnel(), destroyTunnel(), and initialize().

IPv6RoutingTable* inet::IPv6Tunneling::rt = nullptr

protected

Referenced by createTunnel(), decapsulateDatagram(), encapsulateDatagram(), and initialize().

Tunnels inet::IPv6Tunneling::tunnels

protected

Referenced by createTunnel(), destroyTunnel(), destroyTunnelForEntryAndTrigger(), destroyTunnelForExitAndTrigger(), destroyTunnelFromTrigger(), destroyTunnels(), doPrefixMatch(), encapsulateDatagram(), findTunnel(), getVIfIndexForDest(), initialize(), isTunnelExit(), and lookupTunnels().

int inet::IPv6Tunneling::vIfIndexTop = 0

protected

Referenced by createTunnel(), and initialize().

---

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

• IPv6Tunneling.h
• IPv6Tunneling.cc