inet::WiseRoute Class Reference

Wiseroute is a simple loop-free routing algorithm that builds a routing tree from a central network point. More...

#include <WiseRoute.h>

Inheritance diagram for inet::WiseRoute:

Classes
struct	tRouteTableEntry

Public Member Functions
	WiseRoute ()
virtual int	numInitStages () const override
	Initialization of the module and some variables. More...
virtual void	initialize (int) override
virtual void	finish () override
virtual	~WiseRoute ()
const Protocol &	getProtocol () const override
virtual void	handleStartOperation (LifecycleOperation *operation) override
virtual void	handleStopOperation (LifecycleOperation *operation) override
virtual void	handleCrashOperation (LifecycleOperation *operation) override
Public Member Functions inherited from inet::NetworkProtocolBase
virtual void	handleRegisterService (const Protocol &protocol, cGate *gate, ServicePrimitive servicePrimitive) override
virtual void	handleRegisterProtocol (const Protocol &protocol, cGate *gate, ServicePrimitive servicePrimitive) override
Public Member Functions inherited from inet::OperationalMixin< cSimpleModule >
virtual	~OperationalMixin ()
	}@ More...
Public Member Functions inherited from inet::ILifecycle
virtual	~ILifecycle ()
Public Member Functions inherited from inet::DefaultProtocolRegistrationListener
virtual void	handleRegisterServiceGroup (const ProtocolGroup &protocolGroup, cGate *gate, ServicePrimitive servicePrimitive) override
virtual void	handleRegisterProtocolGroup (const ProtocolGroup &protocolGroup, cGate *gate, ServicePrimitive servicePrimitive) override
virtual void	handleRegisterAnyService (cGate *gate, ServicePrimitive servicePrimitive) override
virtual void	handleRegisterAnyProtocol (cGate *gate, ServicePrimitive servicePrimitive) override
Public Member Functions inherited from inet::INetworkProtocol
virtual	~INetworkProtocol ()

Protected Types
enum	messageKinds { SEND_ROUTE_FLOOD_TIMER = 101 }
enum	floodTypes { NOTAFLOOD, FORWARD, FORME, DUPLICATE }
typedef enum inet::WiseRoute::floodTypes	floodTypes
typedef struct inet::WiseRoute::tRouteTableEntry	tRouteTableEntry
typedef std::map< L3Address, tRouteTableEntry >	tRouteTable
typedef std::multimap< tRouteTable::key_type, unsigned long >	tFloodTable
Protected Types inherited from inet::OperationalMixin< cSimpleModule >
enum	State

Protected Member Functions
Handle Messages
Functions to redefine by the programmer These are the functions provided to add own functionality to your modules. These functions are called whenever a self message or a data message from the upper or lower layer arrives respectively.
virtual void	handleUpperPacket (Packet *packet) override
	Handle messages from upper layer. More...
virtual void	handleLowerPacket (Packet *packet) override
	Handle messages from lower layer. More...
virtual void	handleSelfMessage (cMessage *msg) override
	Handle self messages. More...
virtual void	updateRouteTable (const tRouteTable::key_type &origin, const L3Address &lastHop, double rssi, double ber)
	Update routing table. More...
void	decapsulate (Packet *packet)
	Decapsulate a message and delete original msg. More...
floodTypes	updateFloodTable (bool isFlood, const tFloodTable::key_type &srcAddr, const tFloodTable::key_type &destAddr, unsigned long seqNum)
	update flood table. More...
tFloodTable::key_type	getRoute (const tFloodTable::key_type &destAddr, bool iAmOrigin=false) const
	find a route to destination address. More...
virtual void	setDownControlInfo (Packet *const pMsg, const MacAddress &pDestAddr)
	Attaches a "control info" (NetwToMac) structure (object) to the message pMsg. More...
Protected Member Functions inherited from inet::NetworkProtocolBase
	NetworkProtocolBase ()
virtual	~NetworkProtocolBase ()
virtual void	sendUp (cMessage *message)
virtual void	sendDown (cMessage *message, int interfaceId=-1)
virtual bool	isUpperMessage (cMessage *message) const override
virtual bool	isLowerMessage (cMessage *message) const override
virtual bool	isInitializeStage (int stage) const override
virtual bool	isModuleStartStage (int stage) const override
virtual bool	isModuleStopStage (int stage) const override
virtual void	handleUpperCommand (cMessage *msg) override
Protected Member Functions inherited from inet::LayeredProtocolBase
virtual void	handleMessageWhenUp (cMessage *message) override
virtual void	handleUpperMessage (cMessage *message)
virtual void	handleLowerMessage (cMessage *message)
virtual void	handleLowerCommand (cMessage *message)
Protected Member Functions inherited from inet::OperationalMixin< cSimpleModule >
virtual int	numInitStages () const override
virtual void	refreshDisplay () const override
virtual void	handleMessage (cMessage *msg) override
virtual void	handleMessageWhenDown (cMessage *msg)
virtual bool	handleOperationStage (LifecycleOperation *operation, IDoneCallback *doneCallback) override
	Perform one stage of a lifecycle operation. More...
virtual State	getInitialOperationalState () const
	Returns initial operational state: OPERATING or NOT_OPERATING. More...
virtual void	handleActiveOperationTimeout (cMessage *message)
virtual bool	isUp () const
	utility functions More...
virtual bool	isDown () const
virtual void	setOperationalState (State newState)
virtual void	scheduleOperationTimeout (simtime_t timeout)
virtual void	setupActiveOperation (LifecycleOperation *operation, IDoneCallback *doneCallback, State)
virtual void	delayActiveOperationFinish (simtime_t timeout)
virtual void	startActiveOperationExtraTime (simtime_t delay=SIMTIME_ZERO)
virtual void	startActiveOperationExtraTimeOrFinish (simtime_t extraTime)
virtual void	finishActiveOperation ()

Protected Attributes
tRouteTable	routeTable
tFloodTable	floodTable
ModuleRefByPar< IArp >	arp
int	headerLength = 0
	Length of the NetwPkt header Read from omnetpp.ini. More...
L3Address	myNetwAddr
L3Address	sinkAddress
double	rssiThreshold = 0.0
	Minimal received RSSI necessary for adding source to routing table. More...
double	routeFloodsInterval = 0.0
	Interval [seconds] between two route floods. More...
unsigned long	floodSeqNumber = 0
	Flood sequence number. More...
cMessage *	routeFloodTimer = nullptr
long	nbDataPacketsForwarded = 0
long	nbDataPacketsReceived = 0
long	nbDataPacketsSent = 0
long	nbDuplicatedFloodsReceived = 0
long	nbFloodsSent = 0
long	nbPureUnicastSent = 0
long	nbRouteFloodsSent = 0
long	nbRouteFloodsReceived = 0
long	nbUnicastFloodForwarded = 0
long	nbPureUnicastForwarded = 0
long	nbGetRouteFailures = 0
long	nbRoutesRecorded = 0
long	nbHops = 0
cOutVector	receivedRSSI
cOutVector	routeRSSI
cOutVector	allReceivedRSSI
cOutVector	allReceivedBER
cOutVector	routeBER
cOutVector	receivedBER
cOutVector	nextHopSelectionForSink
bool	trace = false
Protected Attributes inherited from inet::NetworkProtocolBase
ModuleRefByPar< IInterfaceTable >	interfaceTable
std::set< const Protocol * >	upperProtocols
std::map< int, SocketDescriptor * >	socketIdToSocketDescriptor
Protected Attributes inherited from inet::OperationalMixin< cSimpleModule >
State	operationalState
simtime_t	lastChange
Operation	activeOperation
cMessage *	activeOperationTimeout
cMessage *	activeOperationExtraTimer

Private Member Functions
	WiseRoute (const WiseRoute &)
	Copy constructor is not allowed. More...
WiseRoute &	operator= (const WiseRoute &)
	Assignment operator is not allowed. More...

Detailed Description

Wiseroute is a simple loop-free routing algorithm that builds a routing tree from a central network point.

It is especially useful for wireless sensor networks and convergecast traffic, hence its name (Wireless Sensors Routing). The sink (the device at the center of the network) broadcasts a route building message. Each network node that receives it selects the sink as parent in the routing tree, and rebroadcasts the route building message. This procedure maximizes the probability that all network nodes can join the network, and avoids loops.

Author

Jerome Rousselot

Member Typedef Documentation

floodTypes

typedef enum inet::WiseRoute::floodTypes inet::WiseRoute::floodTypes

protected

tFloodTable

typedef std::multimap<tRouteTable::key_type, unsigned long> inet::WiseRoute::tFloodTable

protected

tRouteTable

typedef std::map<L3Address, tRouteTableEntry> inet::WiseRoute::tRouteTable

protected

tRouteTableEntry

typedef struct inet::WiseRoute::tRouteTableEntry inet::WiseRoute::tRouteTableEntry

protected

Member Enumeration Documentation

floodTypes

enum inet::WiseRoute::floodTypes

protected

Enumerator
NOTAFLOOD
FORWARD
FORME
DUPLICATE

messageKinds

enum inet::WiseRoute::messageKinds

protected

Enumerator
SEND_ROUTE_FLOOD_TIMER

Constructor & Destructor Documentation

WiseRoute() [1/2]

inet::WiseRoute::WiseRoute ( const WiseRoute &  )

private

Copy constructor is not allowed.

WiseRoute() [2/2]

inet::WiseRoute::WiseRoute ( )

inline

~WiseRoute()

inet::WiseRoute::~WiseRoute ( )

virtual

Member Function Documentation

decapsulate()

void inet::WiseRoute::decapsulate ( Packet *  packet )

protected

Decapsulate a message and delete original msg.

{
    if (isFlood) {
        auto pos = floodTable.lower_bound(srcAddr);
        auto posEnd = floodTable.upper_bound(srcAddr);
 
        while (pos != posEnd) {
            if (seqNum == pos->second)
                return DUPLICATE; // this flood is known, don't forward it.
            ++pos;
        }
        floodTable.insert(make_pair(srcAddr, seqNum));
        if (destAddr == myNetwAddr)
            return FORME;
        else
            return FORWARD;

finish()

void inet::WiseRoute::finish ( )

overridevirtual

{
    auto pos = routeTable.find(origin);
    receivedRSSI.record(rssi);
    receivedBER.record(ber);
    if (pos == routeTable.end()) {
        // A route towards origin does not exist yet. Insert the currently discovered one
        // only if the received RSSI is above the threshold.
        if (rssi > rssiThreshold) {
            tRouteTableEntry newEntry;
 
            // last hop from origin means next hop towards origin.
            newEntry.nextHop = lastHop;
            newEntry.rssi = rssi;
            routeRSSI.record(rssi);
            routeBER.record(ber);

getProtocol()

const Protocol& inet::WiseRoute::getProtocol ( ) const

inlineoverridevirtual

Implements inet::NetworkProtocolBase.

getRoute()

WiseRoute::tFloodTable::key_type inet::WiseRoute::getRoute ( const tFloodTable::key_type &  destAddr, bool  iAmOrigin = false  ) const

protected

find a route to destination address.

handleCrashOperation()

virtual void inet::WiseRoute::handleCrashOperation ( LifecycleOperation *  operation )

inlineoverridevirtual

Implements inet::OperationalMixin< cSimpleModule >.

handleLowerPacket()

void inet::WiseRoute::handleLowerPacket ( Packet *  packet )

overrideprotectedvirtual

Handle messages from lower layer.

Reimplemented from inet::LayeredProtocolBase.

         {
        const cObject *pCtrlInfo = nullptr;
        // If the message is a route flood, update the routing table.
        if (wiseRouteHeader->getHeaderKind() == ROUTE_FLOOD)
            updateRouteTable(initialSrcAddr, srcAddr, rssi, ber);
 
        if (finalDestAddr == myNetwAddr || finalDestAddr.isBroadcast()) {
            Packet *packetCopy;
            if (floodType == FORWARD) {
                // it's a flood. copy for delivery, forward original.
                // if we are here (see updateFloodTable()), finalDestAddr == IP Broadcast. Hence finalDestAddr,
                // initialSrcAddr, and destAddr have already been correctly set
                // at origin, as well as the MAC control info. Hence only update
                // local hop source address.
                packetCopy = packet->dup();
                wiseRouteHeader->setSourceAddress(myNetwAddr);
                pCtrlInfo = packet->removeControlInfo();
                wiseRouteHeader->setNbHops(wiseRouteHeader->getNbHops() + 1);
                auto p = new Packet(packet->getName());
                packet->popAtFront<WiseRouteHeader>();
                p->insertAtBack(packet->peekDataAt(b(0), packet->getDataLength()));
                wiseRouteHeader->setPayloadLengthField(p->getDataLength());
                p->insertAtFront(wiseRouteHeader);
                setDownControlInfo(p, MacAddress::BROADCAST_ADDRESS);
                sendDown(p);
                nbDataPacketsForwarded++;
                delete packet;
            }
            else {
                packetCopy = packet;
            }
            if (wiseRouteHeader->getHeaderKind() == DATA) {
                decapsulate(packetCopy);
                sendUp(packetCopy);
                nbDataPacketsReceived++;
            }
            else {
                nbRouteFloodsReceived++;
                delete packetCopy;
            }
        }
        else {
            // not for me. if flood, forward as flood. else select a route
            if (floodType == FORWARD) {
                wiseRouteHeader->setSourceAddress(myNetwAddr);
                pCtrlInfo = packet->removeControlInfo();
                wiseRouteHeader->setNbHops(wiseRouteHeader->getNbHops() + 1);
                auto p = new Packet(packet->getName());
                packet->popAtFront<WiseRouteHeader>();
                p->insertAtBack(packet->peekDataAt(b(0), packet->getDataLength()));
                wiseRouteHeader->setPayloadLengthField(p->getDataLength());
                p->insertAtFront(wiseRouteHeader);
                setDownControlInfo(p, MacAddress::BROADCAST_ADDRESS);
                sendDown(p);
                nbDataPacketsForwarded++;
                nbUnicastFloodForwarded++;
            }
            else {
                L3Address nextHop = getRoute(finalDestAddr);
                if (nextHop.isBroadcast()) {
                    // no route exist to destination, attempt to send to final destination
                    nextHop = finalDestAddr;
                    nbGetRouteFailures++;
                }
                wiseRouteHeader->setSourceAddress(myNetwAddr);
                wiseRouteHeader->setDestinationAddress(nextHop);
                pCtrlInfo = packet->removeControlInfo();
                MacAddress nextHopMacAddr = arp->resolveL3Address(nextHop, nullptr); // FIXME interface entry pointer needed
                if (nextHopMacAddr.isUnspecified())
                    throw cRuntimeError("Cannot immediately resolve MAC address. Please configure a GlobalArp module.");
                wiseRouteHeader->setNbHops(wiseRouteHeader->getNbHops() + 1);
                auto p = new Packet(packet->getName());
                packet->popAtFront<WiseRouteHeader>();
                p->insertAtBack(packet->peekDataAt(b(0), packet->getDataLength()));
                wiseRouteHeader->setPayloadLengthField(p->getDataLength());
                p->insertAtFront(wiseRouteHeader);
                setDownControlInfo(p, nextHopMacAddr);
                sendDown(p);
                nbDataPacketsForwarded++;
                nbPureUnicastForwarded++;
            }
            delete packet;
        }
        if (pCtrlInfo != nullptr)
            delete pCtrlInfo;
    }
}
 
void WiseRoute::handleUpperPacket(Packet *packet)
{
    L3Address finalDestAddr;
    L3Address nextHopAddr;
    MacAddress nextHopMacAddr;
    auto pkt = makeShared<WiseRouteHeader>();
 
    pkt->setChunkLength(B(headerLength));
 
    const auto& addrTag = packet->findTag<L3AddressReq>();
    if (addrTag == nullptr) {
        EV << "WiseRoute warning: Application layer did not specifiy a destination L3 address\n"
           << "\tusing broadcast address instead\n";
        finalDestAddr = myNetwAddr.getAddressType()->getBroadcastAddress();
    }
    else {

handleSelfMessage()

void inet::WiseRoute::handleSelfMessage ( cMessage *  msg )

overrideprotectedvirtual

Handle self messages.

Reimplemented from inet::LayeredProtocolBase.

         {
        EV << "WiseRoute - handleSelfMessage: got unexpected message of kind " << msg->getKind() << endl;
        delete msg;
    }
}
 
void WiseRoute::handleLowerPacket(Packet *packet)
{
    auto wiseRouteHeader = staticPtrCast<WiseRouteHeader>(packet->peekAtFront<WiseRouteHeader>()->dupShared());
    const L3Address& finalDestAddr = wiseRouteHeader->getFinalDestAddr();
    const L3Address& initialSrcAddr = wiseRouteHeader->getInitialSrcAddr();
    const L3Address& srcAddr = wiseRouteHeader->getSourceAddress();
    // KLUDGE get rssi and ber
    EV_ERROR << "Getting RSSI and BER from the received frame is not yet implemented. Using default values.\n";
    double rssi = 1; // TODO ctrlInfo->getRSSI();
    double ber = 0; // TODO ctrlInfo->getBitErrorRate();
    // Check whether the message is a flood and if it has to be forwarded.
    floodTypes floodType = updateFloodTable(wiseRouteHeader->getIsFlood(), initialSrcAddr, finalDestAddr,
                wiseRouteHeader->getSeqNum());
    allReceivedRSSI.record(rssi);
    allReceivedBER.record(ber);
    if (floodType == DUPLICATE) {

handleStartOperation()

virtual void inet::WiseRoute::handleStartOperation ( LifecycleOperation *  operation )

inlineoverridevirtual

Implements inet::OperationalMixin< cSimpleModule >.

handleStopOperation()

virtual void inet::WiseRoute::handleStopOperation ( LifecycleOperation *  operation )

inlineoverridevirtual

Implements inet::OperationalMixin< cSimpleModule >.

handleUpperPacket()

void inet::WiseRoute::handleUpperPacket ( Packet *  packet )

overrideprotectedvirtual

Handle messages from upper layer.

Reimplemented from inet::LayeredProtocolBase.

                        : CInfo removed, netw addr=" << destAddr << endl;
        finalDestAddr = destAddr;
    }
 
    pkt->setFinalDestAddr(finalDestAddr);
    pkt->setInitialSrcAddr(myNetwAddr);
    pkt->setSourceAddress(myNetwAddr);
    pkt->setNbHops(0);
    pkt->setProtocolId(static_cast<IpProtocolId>(ProtocolGroup::ipprotocol.getProtocolNumber(packet->getTag<PacketProtocolTag>()->getProtocol())));
 
    if (finalDestAddr.isBroadcast())
        nextHopAddr = myNetwAddr.getAddressType()->getBroadcastAddress();
    else
        nextHopAddr = getRoute(finalDestAddr, true);
    pkt->setDestinationAddress(nextHopAddr);
    if (nextHopAddr.isBroadcast()) {
        // it's a flood.
        nextHopMacAddr = MacAddress::BROADCAST_ADDRESS;
        pkt->setIsFlood(1);
        nbFloodsSent++;
        // record flood in flood table
        floodTable.insert(make_pair(myNetwAddr, floodSeqNumber));
        pkt->setSeqNum(floodSeqNumber);
        floodSeqNumber++;
        nbGetRouteFailures++;
    }
    else {
        pkt->setIsFlood(0);
        nbPureUnicastSent++;
        nextHopMacAddr = arp->resolveL3Address(nextHopAddr, nullptr); // FIXME interface entry pointer needed
        if (nextHopMacAddr.isUnspecified())
            throw cRuntimeError("Cannot immediately resolve MAC address. Please configure a GlobalArp module.");
    }
    pkt->setPayloadLengthField(packet->getDataLength());
    pkt->setHeaderKind(DATA);
    packet->insertAtFront(pkt);
    setDownControlInfo(packet, nextHopMacAddr);
    sendDown(packet);
    nbDataPacketsSent++;
}
 
void WiseRoute::finish()
{
    recordScalar("nbDataPacketsForwarded", nbDataPacketsForwarded);
    recordScalar("nbDataPacketsReceived", nbDataPacketsReceived);
    recordScalar("nbDataPacketsSent", nbDataPacketsSent);
    recordScalar("nbDuplicatedFloodsReceived", nbDuplicatedFloodsReceived);
    recordScalar("nbFloodsSent", nbFloodsSent);
    recordScalar("nbPureUnicastSent", nbPureUnicastSent);
    recordScalar("nbRouteFloodsSent", nbRouteFloodsSent);
    recordScalar("nbRouteFloodsReceived", nbRouteFloodsReceived);
    recordScalar("nbUnicastFloodForwarded", nbUnicastFloodForwarded);
    recordScalar("nbPureUnicastForwarded", nbPureUnicastForwarded);
    recordScalar("nbGetRouteFailures", nbGetRouteFailures);
    recordScalar("nbRoutesRecorded", nbRoutesRecorded);
    recordScalar("meanNbHops", (double)nbHops / (double)nbDataPacketsReceived);
}

initialize()

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

overridevirtual

Reimplemented from inet::NetworkProtocolBase.

                                                                 {
        for (int i = 0; i < interfaceTable->getNumInterfaces(); i++)
            interfaceTable->getInterface(i)->setHasModulePathAddress(true);
    }
    else if (stage == INITSTAGE_NETWORK_LAYER) {
        L3AddressResolver addressResolver;
        sinkAddress = addressResolver.resolve(par("sinkAddress"));
 
        IInterfaceTable *interfaceTable = getModuleFromPar<IInterfaceTable>(par("interfaceTableModule"), this);
        if (auto ie = interfaceTable->findFirstNonLoopbackInterface())
            myNetwAddr = ie->getNetworkAddress();
        else
            throw cRuntimeError("No non-loopback interface found!");
 
        // only schedule a flood of the node is a sink!!
        if (routeFloodsInterval > 0 && myNetwAddr == sinkAddress)
            scheduleAfter(uniform(0.5, 1.5), routeFloodTimer);
    }
}
 
WiseRoute::~WiseRoute()
{
    cancelAndDelete(routeFloodTimer);
}
 
void WiseRoute::handleSelfMessage(cMessage *msg)
{
    if (msg->getKind() == SEND_ROUTE_FLOOD_TIMER) {
        // Send route flood packet and restart the timer
        auto pkt = makeShared<WiseRouteHeader>();
        L3Address broadcastAddress = myNetwAddr.getAddressType()->getBroadcastAddress();
        pkt->setChunkLength(B(headerLength));
        pkt->setInitialSrcAddr(myNetwAddr);
        pkt->setFinalDestAddr(broadcastAddress);
        pkt->setSourceAddress(myNetwAddr);
        pkt->setDestinationAddress(broadcastAddress);

numInitStages()

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

inlineoverridevirtual

Initialization of the module and some variables.

operator=()

WiseRoute& inet::WiseRoute::operator= ( const WiseRoute &  )

private

Assignment operator is not allowed.

setDownControlInfo()

void inet::WiseRoute::setDownControlInfo ( Packet *const  pMsg, const MacAddress &  pDestAddr  )

protectedvirtual

Attaches a "control info" (NetwToMac) structure (object) to the message pMsg.

Attaches a "control info" structure (object) to the down message pMsg.

This is most useful when passing packets between protocol layers of a protocol stack, the control info will contain the destination MAC address.

The "control info" object will be deleted when the message is deleted. Only one "control info" structure can be attached (the second setL3ToL2ControlInfo() call throws an error).

Parameters

pMsg	The message where the "control info" shall be attached.
pDestAddr	The MAC address of the message receiver.

updateFloodTable()

WiseRoute::floodTypes inet::WiseRoute::updateFloodTable ( bool  isFlood, const tFloodTable::key_type &  srcAddr, const tFloodTable::key_type &  destAddr, unsigned long  seqNum  )

protected

update flood table.

returns detected flood type (general or unicast flood to forward, duplicate flood to delete, unicast flood to me

{
    // Find a route to dest address. As in the embedded code, if no route exists, indicate
    // final destination as next hop. If we'are lucky, final destination is one hop away...
    // If I am the origin of the packet and no route exists, use flood, hence return broadcast
    // address for next hop.
    tRouteTable::const_iterator pos = routeTable.find(destAddr);
    return (pos != routeTable.end()) ? pos->second.nextHop : myNetwAddr.getAddressType()->getBroadcastAddress();
}
 
void WiseRoute::setDownControlInfo(Packet *const pMsg, const MacAddress& pDestAddr)
{
    pMsg->addTagIfAbsent<MacAddressReq>()->setDestAddress(pDestAddr);

updateRouteTable()

void inet::WiseRoute::updateRouteTable ( const tRouteTable::key_type &  origin, const L3Address &  lastHop, double  rssi, double  ber  )

protectedvirtual

Update routing table.

The tuple provided in argument gives the next hop address to the origin. The table is updated only if the RSSI value is above the threshold.

                                        {
                // TODO nextHopSelectionForSink.record(static_cast<double>(lastHop));
            }
        }
    }
    else {
        // A route towards the node which originated the received packet already exists.
        // Replace its entry only if the route proposal that we just received has a stronger
        // RSSI.
//        tRouteTableEntry entry = pos->second;
//        if (entry.rssi > rssiThreshold) {
//            entry.nextHop = lastHop;
//            entry.rssi = rssi;
//            if (origin == 0)
//                nextHopSelectionForSink.record(lastHop);
//        }
    }
}
 
void WiseRoute::decapsulate(Packet *packet)
{
    auto wiseRouteHeader = packet->popAtFront<WiseRouteHeader>();
    auto payloadLength = wiseRouteHeader->getPayloadLengthField();
    if (packet->getDataLength() < payloadLength) {
        throw cRuntimeError("Data error: illegal payload length"); // FIXME packet drop
    }
    if (packet->getDataLength() > payloadLength)
        packet->setBackOffset(packet->getFrontOffset() + payloadLength);
    auto payloadProtocol = wiseRouteHeader->getProtocol();
    packet->addTagIfAbsent<NetworkProtocolInd>()->setProtocol(&getProtocol());
    packet->addTagIfAbsent<NetworkProtocolInd>()->setNetworkProtocolHeader(wiseRouteHeader);
    packet->addTagIfAbsent<DispatchProtocolReq>()->setProtocol(payloadProtocol);
    packet->addTagIfAbsent<PacketProtocolTag>()->setProtocol(payloadProtocol);
    packet->addTagIfAbsent<L3AddressInd>()->setSrcAddress(wiseRouteHeader->getInitialSrcAddr());
    nbHops = nbHops + wiseRouteHeader->getNbHops();

Member Data Documentation

allReceivedBER

cOutVector inet::WiseRoute::allReceivedBER

protected

allReceivedRSSI

cOutVector inet::WiseRoute::allReceivedRSSI

protected

arp

ModuleRefByPar<IArp> inet::WiseRoute::arp

protected

floodSeqNumber

unsigned long inet::WiseRoute::floodSeqNumber = 0

protected

Flood sequence number.

floodTable

tFloodTable inet::WiseRoute::floodTable

protected

Referenced by decapsulate().

headerLength

int inet::WiseRoute::headerLength = 0

protected

Length of the NetwPkt header Read from omnetpp.ini.

myNetwAddr

L3Address inet::WiseRoute::myNetwAddr

protected

Referenced by decapsulate().

nbDataPacketsForwarded

long inet::WiseRoute::nbDataPacketsForwarded = 0

protected

nbDataPacketsReceived

long inet::WiseRoute::nbDataPacketsReceived = 0

protected

nbDataPacketsSent

long inet::WiseRoute::nbDataPacketsSent = 0

protected

nbDuplicatedFloodsReceived

long inet::WiseRoute::nbDuplicatedFloodsReceived = 0

protected

nbFloodsSent

long inet::WiseRoute::nbFloodsSent = 0

protected

nbGetRouteFailures

long inet::WiseRoute::nbGetRouteFailures = 0

protected

nbHops

long inet::WiseRoute::nbHops = 0

protected

nbPureUnicastForwarded

long inet::WiseRoute::nbPureUnicastForwarded = 0

protected

nbPureUnicastSent

long inet::WiseRoute::nbPureUnicastSent = 0

protected

nbRouteFloodsReceived

long inet::WiseRoute::nbRouteFloodsReceived = 0

protected

nbRouteFloodsSent

long inet::WiseRoute::nbRouteFloodsSent = 0

protected

nbRoutesRecorded

long inet::WiseRoute::nbRoutesRecorded = 0

protected

nbUnicastFloodForwarded

long inet::WiseRoute::nbUnicastFloodForwarded = 0

protected

nextHopSelectionForSink

cOutVector inet::WiseRoute::nextHopSelectionForSink

protected

receivedBER

cOutVector inet::WiseRoute::receivedBER

protected

Referenced by finish().

receivedRSSI

cOutVector inet::WiseRoute::receivedRSSI

protected

Referenced by finish().

routeBER

cOutVector inet::WiseRoute::routeBER

protected

Referenced by finish().

routeFloodsInterval

double inet::WiseRoute::routeFloodsInterval = 0.0

protected

Interval [seconds] between two route floods.

A route flood is a simple flood from which other nodes can extract routing (next hop) information.

routeFloodTimer

cMessage* inet::WiseRoute::routeFloodTimer = nullptr

protected

routeRSSI

cOutVector inet::WiseRoute::routeRSSI

protected

Referenced by finish().

routeTable

tRouteTable inet::WiseRoute::routeTable

protected

Referenced by finish().

rssiThreshold

double inet::WiseRoute::rssiThreshold = 0.0

protected

Minimal received RSSI necessary for adding source to routing table.

Referenced by finish().

sinkAddress

L3Address inet::WiseRoute::sinkAddress

protected

trace

bool inet::WiseRoute::trace = false

protected

---

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

• WiseRoute.h
• WiseRoute.cc