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...
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::LifecycleUnsupported
virtual bool	handleOperationStage (LifecycleOperation *operation, IDoneCallback *doneCallback) override
	Perform one stage of a lifecycle operation. 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 (Packet *packet)
	Encapsulate a datagram with tunnel headers. More...
void	decapsulateDatagram (Packet *packet)
	Strip tunnel headers from datagram. More...

Protected Attributes
ModuleRefByPar< IInterfaceTable >	ift
ModuleRefByPar< Ipv6RoutingTable >	rt
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

TI

typedef Tunnels::const_iterator inet::Ipv6Tunneling::TI

protected

Tunnels

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

protected

Member Enumeration Documentation

TunnelType

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

Ipv6Tunneling()

inet::Ipv6Tunneling::Ipv6Tunneling

(

)

{
}

Member Function Documentation

createTunnel()

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.

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

Referenced by inet::Ipv6RoutingTable::configureTunnelFromXml().

decapsulateDatagram()

void inet::Ipv6Tunneling::decapsulateDatagram ( Packet *  packet )

protected

Strip tunnel headers from datagram.

{
    auto ipv6Header = packet->peekAtFront<Ipv6Header>();
    // decapsulation is performed in Ipv6 module
    Ipv6Address srcAddr = packet->getTag<L3AddressInd>()->getSrcAddress().toIpv6();
 
#ifdef INET_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(srcAddr)) {
        /*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 packet;
        return;
    }
#endif // ifdef INET_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);
 
    send(packet, "linkLayerOut");
 
#ifdef INET_WITH_xMIPv6
    // Alain Tigyo, 21.03.2008
    // The following code is used for triggering RO to a CN
    NetworkInterface *ie = ift->getInterfaceById(packet->getTag<InterfaceInd>()->getInterfaceId());
    if (rt->isMobileNode() && (srcAddr == ie->getProtocolData<Ipv6InterfaceData>()->getHomeAgentAddress())
        && (ipv6Header->getProtocolId() != IP_PROT_IPv6EXT_MOB))
    {
        EV_INFO << "Checking Route Optimization for: " << ipv6Header->getSrcAddress() << endl;
        xMIPv6 *mipv6 = findModuleFromPar<xMIPv6>(par("xmipv6Module"), this);
        if (mipv6)
            mipv6->triggerRouteOptimization(ipv6Header->getSrcAddress(), ie->getProtocolData<Ipv6InterfaceData>()->getMNHomeAddress(), ie);
    }
#endif // ifdef INET_WITH_xMIPv6
}

Referenced by handleMessage().

destroyTunnel() [1/2]

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

destroyTunnel() [2/2]

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

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

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

destroyTunnelForEntryAndTrigger()

void inet::Ipv6Tunneling::destroyTunnelForEntryAndTrigger	(	const Ipv6Address &	entry,
		const Ipv6Address &	trigger
	)

Remove the tunnel with the provided entry point and trigger.

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

destroyTunnelForExitAndTrigger()

void inet::Ipv6Tunneling::destroyTunnelForExitAndTrigger	(	const Ipv6Address &	exit,
		const Ipv6Address &	trigger
	)

Remove the tunnel with the provided exit point and trigger.

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

destroyTunnelFromTrigger()

void inet::Ipv6Tunneling::destroyTunnelFromTrigger

(

const Ipv6Address &

trigger

)

Remove the tunnel with the provided destination trigger.

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

destroyTunnels()

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

doPrefixMatch()

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

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

Referenced by encapsulateDatagram(), and getVIfIndexForDest().

encapsulateDatagram()

void inet::Ipv6Tunneling::encapsulateDatagram ( Packet *  packet )

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.

{
    auto ipv6Header = packet->peekAtFront<Ipv6Header>();
    int vIfIndex = -1;
 
    if (ipv6Header->getProtocolId() == IP_PROT_IPv6EXT_MOB) {
        // only look at non-split tunnel
        // (HoTI is only sent over HA tunnel)
        vIfIndex = doPrefixMatch(ipv6Header->getDestAddress());
    }
 
    if ((ipv6Header->getProtocolId() != IP_PROT_IPv6EXT_MOB) || (vIfIndex == -1)) {
        // look up all tunnels for dgram's destination
        vIfIndex = getVIfIndexForDest(ipv6Header->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 packet->removeControlInfo();
 
#ifdef INET_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 = ipv6Header->getSrcAddress();
        Ipv6Address dest = ipv6Header->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
        }
 
        // get rid of the encapsulation of the Ipv6 module
        packet->popAtFront<Ipv6Header>();
        packet->addTagIfAbsent<PacketProtocolTag>()->setProtocol(ipv6Header->getProtocol());
 
        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);
            t2RH->setByteLength(B(8 + 1 * 16));
            // old src becomes address of T2RH
            t2RH->setAddress(0, rh2);
 
            // append T2RH to routing headers
            packet->addTagIfAbsent<Ipv6ExtHeaderReq>()->appendExtensionHeader(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
            packet->addTagIfAbsent<Ipv6ExtHeaderReq>()->appendExtensionHeader(haOpt);
 
            EV_INFO << "Added Home Address Option header." << endl;
        }
 
        auto addresses = packet->addTagIfAbsent<L3AddressReq>();
        // new src is tunnel entry (either CoA or CN)
        addresses->setSrcAddress(src);
        // copy old dest addr
        addresses->setDestAddress(dest);
 
        send(packet, "upperLayerOut");
    }
    else {
#endif // INET_WITH_xMIPv6
    // normal tunnel - just modify controlInfo and send
    // datagram back to Ipv6 module for encapsulation
 
    packet->addTagIfAbsent<PacketProtocolTag>()->setProtocol(&Protocol::ipv6);
    auto addresses = packet->addTagIfAbsent<L3AddressReq>();
    addresses->setSrcAddress(tunnels[vIfIndex].entry);
    addresses->setDestAddress(tunnels[vIfIndex].exit);
 
    send(packet, "upperLayerOut");
#ifdef INET_WITH_xMIPv6
}
 
#endif // ifdef INET_WITH_xMIPv6
}

Referenced by handleMessage().

findTunnel()

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.

{
    TI it = std::find_if(tunnels.begin(), tunnels.end(),
                std::bind(equalTunnel(),
                    std::make_pair((int)0, Tunnel(src, dest, destTrigger)),
                    std::placeholders::_1));
 
    if (it != tunnels.end())
        return it->first;
 
    return 0;
}

Referenced by createTunnel(), and destroyTunnel().

getVIfIndexForDest() [1/2]

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.

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

Referenced by encapsulateDatagram().

getVIfIndexForDest() [2/2]

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

handleMessage()

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

overridevirtual

Receive messages from Ipv6 module and encapsulate/decapsulate them.

{
    Packet *packet = check_and_cast<Packet *>(msg);
 
    if (packet->getArrivalGate()->isName("upperLayerIn")) {
        // decapsulate
        decapsulateDatagram(packet);
    }
    else if (packet->getArrivalGate()->isName("linkLayerIn")) {
        // encapsulate
        encapsulateDatagram(packet);
    }
    else
        throw cRuntimeError("Ipv6Tunneling: Unknown gate: %s!", packet->getArrivalGate()->getFullName());
}

initialize()

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

overridevirtual

Initialize tunnel manager.

{
    cSimpleModule::initialize(stage);
 
    if (stage == INITSTAGE_LOCAL) {
        ift.reference(this, "interfaceTableModule", true);
        rt.reference(this, "routingTableModule", true);
 
        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) {
        cModule *node = findContainingNode(this);
        NodeStatus *nodeStatus = node ? check_and_cast_nullable<NodeStatus *>(node->getSubmodule("status")) : nullptr;
        bool isOperational = (!nodeStatus) || nodeStatus->getState() == NodeStatus::UP;
        if (!isOperational)
            throw cRuntimeError("This module doesn't support starting in node DOWN state");
    }
}

isTunnelExit()

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.

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

Referenced by decapsulateDatagram().

lookupTunnels()

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.

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

Referenced by getVIfIndexForDest().

numInitStages()

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

inlineoverridevirtual

{ return NUM_INIT_STAGES; }

resetVIfIndex()

void inet::Ipv6Tunneling::resetVIfIndex ( )

inlineprivate

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

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

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

Friends And Related Function Documentation

operator<<

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

ift

ModuleRefByPar<IInterfaceTable> inet::Ipv6Tunneling::ift

protected

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

noOfNonSplitTunnels

int inet::Ipv6Tunneling::noOfNonSplitTunnels = 0

protected

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

rt

ModuleRefByPar<Ipv6RoutingTable> inet::Ipv6Tunneling::rt

protected

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

tunnels

Tunnels inet::Ipv6Tunneling::tunnels

protected

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

vIfIndexTop

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