inet::AODVRouting Class Reference

#include <AODVRouting.h>

Inheritance diagram for inet::AODVRouting:

Classes
class	RREQIdentifier
class	RREQIdentifierCompare

Public Member Functions
	AODVRouting ()
virtual	~AODVRouting ()
Public Member Functions inherited from inet::ILifecycle
virtual	~ILifecycle ()
Public Member Functions inherited from inet::INetfilter::IHook
virtual	~IHook ()

Protected Member Functions
void	handleMessage (cMessage *msg) override
void	initialize (int stage) override
virtual int	numInitStages () const override
void	startRouteDiscovery (const L3Address &target, unsigned int timeToLive=0)
void	completeRouteDiscovery (const L3Address &target)
bool	hasOngoingRouteDiscovery (const L3Address &destAddr)
void	cancelRouteDiscovery (const L3Address &destAddr)
void	updateRoutingTable (IRoute *route, const L3Address &nextHop, unsigned int hopCount, bool hasValidDestNum, unsigned int destSeqNum, bool isActive, simtime_t lifeTime)
IRoute *	createRoute (const L3Address &destAddr, const L3Address &nextHop, unsigned int hopCount, bool hasValidDestNum, unsigned int destSeqNum, bool isActive, simtime_t lifeTime)
bool	updateValidRouteLifeTime (const L3Address &destAddr, simtime_t lifetime)
void	scheduleExpungeRoutes ()
void	expungeRoutes ()
AODVRREPACK *	createRREPACK ()
AODVRREP *	createHelloMessage ()
AODVRREQ *	createRREQ (const L3Address &destAddr)
AODVRREP *	createRREP (AODVRREQ *rreq, IRoute *destRoute, IRoute *originatorRoute, const L3Address &sourceAddr)
AODVRREP *	createGratuitousRREP (AODVRREQ *rreq, IRoute *originatorRoute)
AODVRERR *	createRERR (const std::vector< UnreachableNode > &unreachableNodes)
void	handleRREP (AODVRREP *rrep, const L3Address &sourceAddr)
void	handleRREQ (AODVRREQ *rreq, const L3Address &sourceAddr, unsigned int timeToLive)
void	handleRERR (AODVRERR *rerr, const L3Address &sourceAddr)
void	handleHelloMessage (AODVRREP *helloMessage)
void	handleRREPACK (AODVRREPACK *rrepACK, const L3Address &neighborAddr)
void	sendRREQ (AODVRREQ *rreq, const L3Address &destAddr, unsigned int timeToLive)
void	sendRREPACK (AODVRREPACK *rrepACK, const L3Address &destAddr)
void	sendRREP (AODVRREP *rrep, const L3Address &destAddr, unsigned int timeToLive)
void	sendGRREP (AODVRREP *grrep, const L3Address &destAddr, unsigned int timeToLive)
void	forwardRREP (AODVRREP *rrep, const L3Address &destAddr, unsigned int timeToLive)
void	forwardRREQ (AODVRREQ *rreq, unsigned int timeToLive)
void	handleRREPACKTimer ()
void	handleBlackListTimer ()
void	sendHelloMessagesIfNeeded ()
void	handleWaitForRREP (WaitForRREP *rrepTimer)
void	sendRERRWhenNoRouteToForward (const L3Address &unreachableAddr)
void	handleLinkBreakSendRERR (const L3Address &unreachableAddr)
virtual void	receiveSignal (cComponent *source, simsignal_t signalID, cObject *obj, cObject *details) override
Result	ensureRouteForDatagram (INetworkDatagram *datagram)
virtual Result	datagramPreRoutingHook (INetworkDatagram *datagram, const InterfaceEntry *inputInterfaceEntry, const InterfaceEntry *&outputInterfaceEntry, L3Address &nextHopAddress) override
	This is the first hook called by the network protocol before it routes a datagram that was received from the lower layer. More...
virtual Result	datagramForwardHook (INetworkDatagram *datagram, const InterfaceEntry *inputInterfaceEntry, const InterfaceEntry *&outputInterfaceEntry, L3Address &nextHopAddress) override
	This is the second hook called by the network protocol before it sends a datagram to the lower layer. More...
virtual Result	datagramPostRoutingHook (INetworkDatagram *datagram, const InterfaceEntry *inputInterfaceEntry, const InterfaceEntry *&outputInterfaceEntry, L3Address &nextHopAddress) override
	This is the last hook called by the network protocol before it sends a datagram to the lower layer. More...
virtual Result	datagramLocalInHook (INetworkDatagram *datagram, const InterfaceEntry *inputInterfaceEntry) override
	This is the last hook called by the network protocol before it sends a datagram to the upper layer. More...
virtual Result	datagramLocalOutHook (INetworkDatagram *datagram, const InterfaceEntry *&outputInterfaceEntry, L3Address &nextHopAddress) override
	This is the first hook called by the network protocol before it routes a datagram that was received from the upper layer. More...
void	delayDatagram (INetworkDatagram *datagram)
L3Address	getSelfIPAddress () const
void	sendAODVPacket (AODVControlPacket *packet, const L3Address &destAddr, unsigned int timeToLive, double delay)
void	clearState ()
virtual bool	handleOperationStage (LifecycleOperation *operation, int stage, IDoneCallback *doneCallback) override
	Perform one stage of a lifecycle operation. More...

Protected Attributes
IL3AddressType *	addressType = nullptr
cModule *	host = nullptr
IRoutingTable *	routingTable = nullptr
IInterfaceTable *	interfaceTable = nullptr
INetfilter *	networkProtocol = nullptr
unsigned int	rerrRatelimit = 0
unsigned int	aodvUDPPort = 0
bool	askGratuitousRREP = false
bool	useHelloMessages = false
simtime_t	maxJitter
simtime_t	activeRouteTimeout
simtime_t	helloInterval
unsigned int	netDiameter = 0
unsigned int	rreqRetries = 0
unsigned int	rreqRatelimit = 0
unsigned int	timeoutBuffer = 0
unsigned int	ttlStart = 0
unsigned int	ttlIncrement = 0
unsigned int	ttlThreshold = 0
unsigned int	localAddTTL = 0
unsigned int	allowedHelloLoss = 0
simtime_t	nodeTraversalTime
cPar *	jitterPar = nullptr
cPar *	periodicJitter = nullptr
simtime_t	deletePeriod
simtime_t	myRouteTimeout
simtime_t	blacklistTimeout
simtime_t	netTraversalTime
simtime_t	nextHopWait
simtime_t	pathDiscoveryTime
unsigned int	rreqId = 0
unsigned int	sequenceNum = 0
std::map< L3Address, WaitForRREP * >	waitForRREPTimers
std::map< RREQIdentifier, simtime_t, RREQIdentifierCompare >	rreqsArrivalTime
L3Address	failedNextHop
std::map< L3Address, simtime_t >	blacklist
unsigned int	rerrCount = 0
unsigned int	rreqCount = 0
simtime_t	lastBroadcastTime
std::map< L3Address, unsigned int >	addressToRreqRetries
cMessage *	helloMsgTimer = nullptr
cMessage *	expungeTimer = nullptr
cMessage *	counterTimer = nullptr
cMessage *	rrepAckTimer = nullptr
cMessage *	blacklistTimer = nullptr
simtime_t	rebootTime
bool	isOperational = false
std::multimap< L3Address, INetworkDatagram * >	targetAddressToDelayedPackets

Additional Inherited Members
Public Types inherited from inet::INetfilter::IHook
enum	Type {   PREROUTING, LOCALIN, FORWARD, POSTROUTING,   LOCALOUT }
enum	Result { ACCEPT, DROP, QUEUE, STOLEN }

Constructor & Destructor Documentation

inet::AODVRouting::AODVRouting

(

)

{
}

inet::AODVRouting::~AODVRouting ( )

virtual

{
    clearState();
    delete helloMsgTimer;
    delete expungeTimer;
    delete counterTimer;
    delete rrepAckTimer;
    delete blacklistTimer;
}

Member Function Documentation

void inet::AODVRouting::cancelRouteDiscovery ( const L3Address &  destAddr )

protected

Referenced by handleWaitForRREP().

{
    ASSERT(hasOngoingRouteDiscovery(destAddr));
    auto lt = targetAddressToDelayedPackets.lower_bound(destAddr);
    auto ut = targetAddressToDelayedPackets.upper_bound(destAddr);
    for (auto it = lt; it != ut; it++)
        networkProtocol->dropQueuedDatagram(const_cast<const INetworkDatagram *>(it->second));

    targetAddressToDelayedPackets.erase(lt, ut);

    auto waitRREPIter = waitForRREPTimers.find(destAddr);
    ASSERT(waitRREPIter != waitForRREPTimers.end());
    cancelAndDelete(waitRREPIter->second);
    waitForRREPTimers.erase(waitRREPIter);
}

void inet::AODVRouting::clearState ( )

protected

Referenced by handleOperationStage(), and ~AODVRouting().

{
    rerrCount = rreqCount = rreqId = sequenceNum = 0;
    addressToRreqRetries.clear();
    for (auto & elem : waitForRREPTimers)
        cancelAndDelete(elem.second);

    // FIXME: Drop the queued datagrams.
    //for (auto it = targetAddressToDelayedPackets.begin(); it != targetAddressToDelayedPackets.end(); it++)
    //    networkProtocol->dropQueuedDatagram(const_cast<const INetworkDatagram *>(it->second));

    targetAddressToDelayedPackets.clear();

    waitForRREPTimers.clear();
    rreqsArrivalTime.clear();

    if (useHelloMessages)
        cancelEvent(helloMsgTimer);
    if (expungeTimer)
        cancelEvent(expungeTimer);
    if (counterTimer)
        cancelEvent(counterTimer);
    if (blacklistTimer)
        cancelEvent(blacklistTimer);
    if (rrepAckTimer)
        cancelEvent(rrepAckTimer);
}

void inet::AODVRouting::completeRouteDiscovery ( const L3Address &  target )

protected

Referenced by handleRREP().

{
    EV_DETAIL << "Completing route discovery, originator " << getSelfIPAddress() << ", target " << target << endl;
    ASSERT(hasOngoingRouteDiscovery(target));

    auto lt = targetAddressToDelayedPackets.lower_bound(target);
    auto ut = targetAddressToDelayedPackets.upper_bound(target);

    // reinject the delayed datagrams
    for (auto it = lt; it != ut; it++) {
        INetworkDatagram *datagram = it->second;
        EV_DETAIL << "Sending queued datagram: source " << datagram->getSourceAddress() << ", destination " << datagram->getDestinationAddress() << endl;
        networkProtocol->reinjectQueuedDatagram(const_cast<const INetworkDatagram *>(datagram));
    }

    // clear the multimap
    targetAddressToDelayedPackets.erase(lt, ut);

    // we have a route for the destination, thus we must cancel the WaitForRREPTimer events
    auto waitRREPIter = waitForRREPTimers.find(target);
    ASSERT(waitRREPIter != waitForRREPTimers.end());
    cancelAndDelete(waitRREPIter->second);
    waitForRREPTimers.erase(waitRREPIter);
}

AODVRREP * inet::AODVRouting::createGratuitousRREP ( AODVRREQ *  rreq, IRoute *  originatorRoute  )

protected

Referenced by handleRREQ().

{
    ASSERT(originatorRoute != nullptr);
    AODVRREP *grrep = new AODVRREP("AODV-GRREP");
    AODVRouteData *routeData = check_and_cast<AODVRouteData *>(originatorRoute->getProtocolData());

    // Hop Count                        The Hop Count as indicated in the
    //                                  node's route table entry for the
    //                                  originator
    //
    // Destination IP Address           The IP address of the node that
    //                                  originated the RREQ
    //
    // Destination Sequence Number      The Originator Sequence Number from
    //                                  the RREQ
    //
    // Originator IP Address            The IP address of the Destination
    //                                  node in the RREQ
    //
    // Lifetime                         The remaining lifetime of the route
    //                                  towards the originator of the RREQ,
    //                                  as known by the intermediate node.

    grrep->setPacketType(RREP);
    grrep->setHopCount(originatorRoute->getMetric());
    grrep->setDestAddr(rreq->getOriginatorAddr());
    grrep->setDestSeqNum(rreq->getOriginatorSeqNum());
    grrep->setOriginatorAddr(rreq->getDestAddr());
    grrep->setLifeTime(routeData->getLifeTime());

    grrep->setByteLength(20);
    return grrep;
}

AODVRREP * inet::AODVRouting::createHelloMessage ( )

protected

Referenced by sendHelloMessagesIfNeeded().

{
    // called a Hello message, with the RREP
    // message fields set as follows:
    //
    //    Destination IP Address         The node's IP address.
    //
    //    Destination Sequence Number    The node's latest sequence number.
    //
    //    Hop Count                      0
    //
    //    Lifetime                       ALLOWED_HELLO_LOSS *HELLO_INTERVAL

    AODVRREP *helloMessage = new AODVRREP("AODV-HelloMsg");
    helloMessage->setPacketType(RREP);
    helloMessage->setDestAddr(getSelfIPAddress());
    helloMessage->setDestSeqNum(sequenceNum);
    helloMessage->setHopCount(0);
    helloMessage->setLifeTime(allowedHelloLoss * helloInterval);
    helloMessage->setByteLength(20);

    return helloMessage;
}

AODVRERR * inet::AODVRouting::createRERR ( const std::vector< UnreachableNode > &  unreachableNodes )

protected

Referenced by handleLinkBreakSendRERR(), handleRERR(), and sendRERRWhenNoRouteToForward().

{
    AODVRERR *rerr = new AODVRERR("AODV-RERR");
    unsigned int destCount = unreachableNodes.size();

    rerr->setPacketType(RERR);
    rerr->setDestCount(destCount);
    rerr->setUnreachableNodesArraySize(destCount);

    for (unsigned int i = 0; i < destCount; i++) {
        UnreachableNode node;
        node.addr = unreachableNodes[i].addr;
        node.seqNum = unreachableNodes[i].seqNum;
        rerr->setUnreachableNodes(i, node);
    }

    rerr->setByteLength(4 + 4 * 2 * destCount);
    return rerr;
}

IRoute * inet::AODVRouting::createRoute ( const L3Address &  destAddr, const L3Address &  nextHop, unsigned int  hopCount, bool  hasValidDestNum, unsigned int  destSeqNum, bool  isActive, simtime_t  lifeTime  )

protected

Referenced by handleHelloMessage(), handleRREP(), and handleRREQ().

{
    IRoute *newRoute = routingTable->createRoute();
    AODVRouteData *newProtocolData = new AODVRouteData();

    newProtocolData->setHasValidDestNum(hasValidDestNum);

    // active route
    newProtocolData->setIsActive(isActive);

    // A route towards a destination that has a routing table entry
    // that is marked as valid.  Only active routes can be used to
    // forward data packets.

    newProtocolData->setLifeTime(lifeTime);
    newProtocolData->setDestSeqNum(destSeqNum);

    InterfaceEntry *ifEntry = interfaceTable->getInterfaceByName("wlan0");    // TODO: IMPLEMENT: multiple interfaces
    if (ifEntry)
        newRoute->setInterface(ifEntry);

    newRoute->setDestination(destAddr);
    newRoute->setSourceType(IRoute::AODV);
    newRoute->setSource(this);
    newRoute->setProtocolData(newProtocolData);
    newRoute->setMetric(hopCount);
    newRoute->setNextHop(nextHop);
    newRoute->setPrefixLength(addressType->getMaxPrefixLength());    // TODO:

    EV_DETAIL << "Adding new route " << newRoute << endl;
    routingTable->addRoute(newRoute);
    scheduleExpungeRoutes();
    return newRoute;
}

AODVRREP * inet::AODVRouting::createRREP ( AODVRREQ *  rreq, IRoute *  destRoute, IRoute *  originatorRoute, const L3Address &  sourceAddr  )

protected

Referenced by handleRREQ().

{
    AODVRREP *rrep = new AODVRREP("AODV-RREP");
    rrep->setPacketType(RREP);

    // When generating a RREP message, a node copies the Destination IP
    // Address and the Originator Sequence Number from the RREQ message into
    // the corresponding fields in the RREP message.

    rrep->setDestAddr(rreq->getDestAddr());
    rrep->setOriginatorSeqNum(rreq->getOriginatorSeqNum());

    // OriginatorAddr = The IP address of the node which originated the RREQ
    // for which the route is supplied.
    rrep->setOriginatorAddr(rreq->getOriginatorAddr());

    // Processing is slightly different, depending on whether the node is
    // itself the requested destination (see section 6.6.1), or instead
    // if it is an intermediate node with an fresh enough route to the destination
    // (see section 6.6.2).

    if (rreq->getDestAddr() == getSelfIPAddress()) {    // node is itself the requested destination
        // If the generating node is the destination itself, it MUST increment
        // its own sequence number by one if the sequence number in the RREQ
        // packet is equal to that incremented value.

        if (!rreq->getUnknownSeqNumFlag() && sequenceNum + 1 == rreq->getDestSeqNum())
            sequenceNum++;

        // The destination node places its (perhaps newly incremented)
        // sequence number into the Destination Sequence Number field of
        // the RREP,
        rrep->setDestSeqNum(sequenceNum);

        // and enters the value zero in the Hop Count field
        // of the RREP.
        rrep->setHopCount(0);

        // The destination node copies the value MY_ROUTE_TIMEOUT
        // into the Lifetime field of the RREP.
        rrep->setLifeTime(myRouteTimeout);
    }
    else {    // intermediate node
              // it copies its known sequence number for the destination into
              // the Destination Sequence Number field in the RREP message.
        AODVRouteData *destRouteData = check_and_cast<AODVRouteData *>(destRoute->getProtocolData());
        AODVRouteData *originatorRouteData = check_and_cast<AODVRouteData *>(originatorRoute->getProtocolData());
        rrep->setDestSeqNum(destRouteData->getDestSeqNum());

        // The intermediate node updates the forward route entry by placing the
        // last hop node (from which it received the RREQ, as indicated by the
        // source IP address field in the IP header) into the precursor list for
        // the forward route entry -- i.e., the entry for the Destination IP
        // Address.
        destRouteData->addPrecursor(lastHopAddr);

        // The intermediate node also updates its route table entry
        // for the node originating the RREQ by placing the next hop towards the
        // destination in the precursor list for the reverse route entry --
        // i.e., the entry for the Originator IP Address field of the RREQ
        // message data.

        originatorRouteData->addPrecursor(destRoute->getNextHopAsGeneric());

        // The intermediate node places its distance in hops from the
        // destination (indicated by the hop count in the routing table)
        // Hop Count field in the RREP.

        rrep->setHopCount(destRoute->getMetric());

        // The Lifetime field of the RREP is calculated by subtracting the
        // current time from the expiration time in its route table entry.

        rrep->setLifeTime(destRouteData->getLifeTime() - simTime());
    }

    rrep->setByteLength(20);
    return rrep;
}

AODVRREPACK * inet::AODVRouting::createRREPACK ( )

protected

Referenced by handleRREP().

{
    AODVRREPACK *rrepACK = new AODVRREPACK("AODV-RREPACK");
    rrepACK->setPacketType(RREPACK);
    rrepACK->setByteLength(2);
    return rrepACK;
}

AODVRREQ * inet::AODVRouting::createRREQ ( const L3Address &  destAddr )

protected

Referenced by handleWaitForRREP(), and startRouteDiscovery().

{
    AODVRREQ *rreqPacket = new AODVRREQ("AODV-RREQ");

    rreqPacket->setGratuitousRREPFlag(askGratuitousRREP);
    IRoute *lastKnownRoute = routingTable->findBestMatchingRoute(destAddr);

    rreqPacket->setPacketType(RREQ);

    // The Originator Sequence Number in the RREQ message is the
    // node's own sequence number, which is incremented prior to
    // insertion in a RREQ.
    sequenceNum++;

    rreqPacket->setOriginatorSeqNum(sequenceNum);

    if (lastKnownRoute && lastKnownRoute->getSource() == this) {
        // The Destination Sequence Number field in the RREQ message is the last
        // known destination sequence number for this destination and is copied
        // from the Destination Sequence Number field in the routing table.

        AODVRouteData *routeData = check_and_cast<AODVRouteData *>(lastKnownRoute->getProtocolData());
        if (routeData && routeData->hasValidDestNum()) {
            rreqPacket->setDestSeqNum(routeData->getDestSeqNum());
            rreqPacket->setUnknownSeqNumFlag(false);
        }
        else
            rreqPacket->setUnknownSeqNumFlag(true);
    }
    else
        rreqPacket->setUnknownSeqNumFlag(true); // If no sequence number is known, the unknown sequence number flag MUST be set.

    rreqPacket->setOriginatorAddr(getSelfIPAddress());
    rreqPacket->setDestAddr(destAddr);

    // The RREQ ID field is incremented by one from the last RREQ ID used
    // by the current node. Each node maintains only one RREQ ID.
    rreqId++;
    rreqPacket->setRreqId(rreqId);

    // The Hop Count field is set to zero.
    rreqPacket->setHopCount(0);

    // Before broadcasting the RREQ, the originating node buffers the RREQ
    // ID and the Originator IP address (its own address) of the RREQ for
    // PATH_DISCOVERY_TIME.
    // In this way, when the node receives the packet again from its neighbors,
    // it will not reprocess and re-forward the packet.

    RREQIdentifier rreqIdentifier(getSelfIPAddress(), rreqId);
    rreqsArrivalTime[rreqIdentifier] = simTime();
    rreqPacket->setByteLength(24);
    return rreqPacket;
}

INetfilter::IHook::Result inet::AODVRouting::datagramForwardHook ( INetworkDatagram *  datagram, const InterfaceEntry *  inputInterfaceEntry, const InterfaceEntry *&  outputInterfaceEntry, L3Address &  nextHopAddress  )

overrideprotectedvirtual

This is the second hook called by the network protocol before it sends a datagram to the lower layer.

This is done after the datagramPreRoutingHook or the datagramLocalInHook is called and the datagram is routed.

Implements inet::INetfilter::IHook.

{
    // TODO: Implement: Actions After Reboot
    // If the node receives a data packet for some other destination, it SHOULD
    // broadcast a RERR as described in subsection 6.11 and MUST reset the waiting
    // timer to expire after current time plus DELETE_PERIOD.

    Enter_Method("datagramForwardHook");
    const L3Address& destAddr = datagram->getDestinationAddress();
    const L3Address& sourceAddr = datagram->getSourceAddress();
    IRoute *ipSource = routingTable->findBestMatchingRoute(sourceAddr);

    if (destAddr.isBroadcast() || routingTable->isLocalAddress(destAddr) || destAddr.isMulticast()) {
        if (routingTable->isLocalAddress(destAddr) && ipSource && ipSource->getSource() == this)
            updateValidRouteLifeTime(ipSource->getNextHopAsGeneric(), simTime() + activeRouteTimeout);

        return ACCEPT;
    }

    // TODO: IMPLEMENT: check if the datagram is a data packet or we take control packets as data packets

    IRoute *routeDest = routingTable->findBestMatchingRoute(destAddr);
    AODVRouteData *routeDestData = routeDest ? dynamic_cast<AODVRouteData *>(routeDest->getProtocolData()) : nullptr;

    // Each time a route is used to forward a data packet, its Active Route
    // Lifetime field of the source, destination and the next hop on the
    // path to the destination is updated to be no less than the current
    // time plus ACTIVE_ROUTE_TIMEOUT

    updateValidRouteLifeTime(sourceAddr, simTime() + activeRouteTimeout);
    updateValidRouteLifeTime(destAddr, simTime() + activeRouteTimeout);

    if (routeDest && routeDest->getSource() == this)
        updateValidRouteLifeTime(routeDest->getNextHopAsGeneric(), simTime() + activeRouteTimeout);

    // Since the route between each originator and destination pair is expected
    // to be symmetric, the Active Route Lifetime for the previous hop, along the
    // reverse path back to the IP source, is also updated to be no less than the
    // current time plus ACTIVE_ROUTE_TIMEOUT.

    if (ipSource && ipSource->getSource() == this)
        updateValidRouteLifeTime(ipSource->getNextHopAsGeneric(), simTime() + activeRouteTimeout);

    EV_INFO << "We can't forward datagram because we have no active route for " << destAddr << endl;
    if (routeDest && routeDestData && !routeDestData->isActive()) {    // exists but is not active
        // A node initiates processing for a RERR message in three situations:
        // (ii)      if it gets a data packet destined to a node for which it
        //           does not have an active route and is not repairing (if
        //           using local repair)

        // TODO: check if it is not repairing (if using local repair)

        // 1. The destination sequence number of this routing entry, if it
        // exists and is valid, is incremented for cases (i) and (ii) above,
        // and copied from the incoming RERR in case (iii) above.

        if (routeDestData->hasValidDestNum())
            routeDestData->setDestSeqNum(routeDestData->getDestSeqNum() + 1);

        // 2. The entry is invalidated by marking the route entry as invalid <- it is invalid

        // 3. The Lifetime field is updated to current time plus DELETE_PERIOD.
        //    Before this time, the entry SHOULD NOT be deleted.
        routeDestData->setLifeTime(simTime() + deletePeriod);

        sendRERRWhenNoRouteToForward(destAddr);
    }
    else if (!routeDest || routeDest->getSource() != this) // doesn't exist at all
        sendRERRWhenNoRouteToForward(destAddr);

    return ACCEPT;
}

virtual Result inet::AODVRouting::datagramLocalInHook ( INetworkDatagram *  datagram, const InterfaceEntry *  inputInterfaceEntry  )

inlineoverrideprotectedvirtual

This is the last hook called by the network protocol before it sends a datagram to the upper layer.

This is done after the datagramPreRoutingHook is called and the datagram is routed.

Implements inet::INetfilter::IHook.

{ return ACCEPT; }

virtual Result inet::AODVRouting::datagramLocalOutHook ( INetworkDatagram *  datagram, const InterfaceEntry *&  outputInterfaceEntry, L3Address &  nextHopAddress  )

inlineoverrideprotectedvirtual

This is the first hook called by the network protocol before it routes a datagram that was received from the upper layer.

The nextHopAddress is ignored when the outputInterfaceEntry is a nullptr. After this is done

Implements inet::INetfilter::IHook.

{ Enter_Method("datagramLocalOutHook"); return ensureRouteForDatagram(datagram); }

virtual Result inet::AODVRouting::datagramPostRoutingHook ( INetworkDatagram *  datagram, const InterfaceEntry *  inputInterfaceEntry, const InterfaceEntry *&  outputInterfaceEntry, L3Address &  nextHopAddress  )

inlineoverrideprotectedvirtual

This is the last hook called by the network protocol before it sends a datagram to the lower layer.

Implements inet::INetfilter::IHook.

{ return ACCEPT; }

virtual Result inet::AODVRouting::datagramPreRoutingHook ( INetworkDatagram *  datagram, const InterfaceEntry *  inputInterfaceEntry, const InterfaceEntry *&  outputInterfaceEntry, L3Address &  nextHopAddress  )

inlineoverrideprotectedvirtual

This is the first hook called by the network protocol before it routes a datagram that was received from the lower layer.

The nextHopAddress is ignored when the outputInterfaceEntry is nullptr.

Implements inet::INetfilter::IHook.

{ Enter_Method("datagramPreRoutingHook"); return ensureRouteForDatagram(datagram); }

void inet::AODVRouting::delayDatagram ( INetworkDatagram *  datagram )

protected

Referenced by ensureRouteForDatagram().

{
    EV_DETAIL << "Queuing datagram, source " << datagram->getSourceAddress() << ", destination " << datagram->getDestinationAddress() << endl;
    const L3Address& target = datagram->getDestinationAddress();
    targetAddressToDelayedPackets.insert(std::pair<L3Address, INetworkDatagram *>(target, datagram));
}

INetfilter::IHook::Result inet::AODVRouting::ensureRouteForDatagram ( INetworkDatagram *  datagram )

protected

{
    Enter_Method("datagramPreRoutingHook");
    const L3Address& destAddr = datagram->getDestinationAddress();
    const L3Address& sourceAddr = datagram->getSourceAddress();

    if (destAddr.isBroadcast() || routingTable->isLocalAddress(destAddr) || destAddr.isMulticast())
        return ACCEPT;
    else {
        EV_INFO << "Finding route for source " << sourceAddr << " with destination " << destAddr << endl;
        IRoute *route = routingTable->findBestMatchingRoute(destAddr);
        AODVRouteData *routeData = route ? dynamic_cast<AODVRouteData *>(route->getProtocolData()) : nullptr;
        bool isActive = routeData && routeData->isActive();
        if (isActive && !route->getNextHopAsGeneric().isUnspecified()) {
            EV_INFO << "Active route found: " << route << endl;

            // Each time a route is used to forward a data packet, its Active Route
            // Lifetime field of the source, destination and the next hop on the
            // path to the destination is updated to be no less than the current
            // time plus ACTIVE_ROUTE_TIMEOUT.

            updateValidRouteLifeTime(destAddr, simTime() + activeRouteTimeout);
            updateValidRouteLifeTime(route->getNextHopAsGeneric(), simTime() + activeRouteTimeout);

            return ACCEPT;
        }
        else if (sourceAddr.isUnspecified() || routingTable->isLocalAddress(sourceAddr)) {
            bool isInactive = routeData && !routeData->isActive();
            // A node disseminates a RREQ when it determines that it needs a route
            // to a destination and does not have one available.  This can happen if
            // the destination is previously unknown to the node, or if a previously
            // valid route to the destination expires or is marked as invalid.

            EV_INFO << (isInactive ? "Inactive" : "Missing") << " route for destination " << destAddr << endl;

            delayDatagram(datagram);

            if (!hasOngoingRouteDiscovery(destAddr)) {
                // When a new route to the same destination is required at a later time
                // (e.g., upon route loss), the TTL in the RREQ IP header is initially
                // set to the Hop Count plus TTL_INCREMENT.
                if (isInactive)
                    startRouteDiscovery(destAddr, route->getMetric() + ttlIncrement);
                else
                    startRouteDiscovery(destAddr);
            }
            else
                EV_DETAIL << "Route discovery is in progress, originator " << getSelfIPAddress() << " target " << destAddr << endl;

            return QUEUE;
        }
        else
            return ACCEPT;
    }
}

void inet::AODVRouting::expungeRoutes ( )

protected

Referenced by handleMessage().

{
    for (int i = 0; i < routingTable->getNumRoutes(); i++) {
        IRoute *route = routingTable->getRoute(i);
        if (route->getSource() == this) {
            AODVRouteData *routeData = check_and_cast<AODVRouteData *>(route->getProtocolData());
            ASSERT(routeData != nullptr);
            if (routeData->getLifeTime() <= simTime()) {
                if (routeData->isActive()) {
                    EV_DETAIL << "Route to " << route->getDestinationAsGeneric() << " expired and set to inactive. It will be deleted after DELETE_PERIOD time" << endl;
                    // An expired routing table entry SHOULD NOT be expunged before
                    // (current_time + DELETE_PERIOD) (see section 6.11).  Otherwise, the
                    // soft state corresponding to the route (e.g., last known hop count)
                    // will be lost.
                    routeData->setIsActive(false);
                    routeData->setLifeTime(simTime() + deletePeriod);
                }
                else {
                    // Any routing table entry waiting for a RREP SHOULD NOT be expunged
                    // before (current_time + 2 * NET_TRAVERSAL_TIME).
                    if (hasOngoingRouteDiscovery(route->getDestinationAsGeneric())) {
                        EV_DETAIL << "Route to " << route->getDestinationAsGeneric() << " expired and is inactive, but we are waiting for a RREP to this destination, so we extend its lifetime with 2 * NET_TRAVERSAL_TIME" << endl;
                        routeData->setLifeTime(simTime() + 2 * netTraversalTime);
                    }
                    else {
                        EV_DETAIL << "Route to " << route->getDestinationAsGeneric() << " expired and is inactive and we are not expecting any RREP to this destination, so we delete this route" << endl;
                        routingTable->deleteRoute(route);
                    }
                }
            }
        }
    }
    scheduleExpungeRoutes();
}

void inet::AODVRouting::forwardRREP ( AODVRREP *  rrep, const L3Address &  destAddr, unsigned int  timeToLive  )

protected

Referenced by handleRREP().

{
    EV_INFO << "Forwarding the Route Reply to the node " << rrep->getOriginatorAddr() << " which originated the Route Request" << endl;

    // RFC 5148:
    // When a node forwards a message, it SHOULD be jittered by delaying it
    // by a random duration.  This delay SHOULD be generated uniformly in an
    // interval between zero and MAXJITTER.
    sendAODVPacket(rrep, destAddr, 100, jitterPar->doubleValue());
}

void inet::AODVRouting::forwardRREQ ( AODVRREQ *  rreq, unsigned int  timeToLive  )

protected

Referenced by handleRREQ().

{
    EV_INFO << "Forwarding the Route Request message with TTL= " << timeToLive << endl;
    sendAODVPacket(rreq, addressType->getBroadcastAddress(), timeToLive, jitterPar->doubleValue());
}

L3Address inet::AODVRouting::getSelfIPAddress ( ) const

protected

Referenced by completeRouteDiscovery(), createHelloMessage(), createRREP(), createRREQ(), ensureRouteForDatagram(), handleRREP(), handleRREQ(), initialize(), sendAODVPacket(), and startRouteDiscovery().

{
    return routingTable->getRouterIdAsGeneric();
}

void inet::AODVRouting::handleBlackListTimer ( )

protected

Referenced by handleMessage().

{
    simtime_t nextTime = SimTime::getMaxTime();

    for (auto it = blacklist.begin(); it != blacklist.end(); ) {
        auto current = it++;

        // Nodes are removed from the blacklist set after a BLACKLIST_TIMEOUT period
        if (current->second <= simTime()) {
            EV_DETAIL << "Blacklist lifetime has expired for " << current->first << " removing it from the blacklisted addresses" << endl;
            blacklist.erase(current);
        }
        else if (nextTime > current->second)
            nextTime = current->second;
    }

    if (nextTime != SimTime::getMaxTime())
        scheduleAt(nextTime, blacklistTimer);
}

void inet::AODVRouting::handleHelloMessage ( AODVRREP *  helloMessage )

protected

Referenced by handleRREP().

{
    const L3Address& helloOriginatorAddr = helloMessage->getDestAddr();
    IRoute *routeHelloOriginator = routingTable->findBestMatchingRoute(helloOriginatorAddr);

    // Whenever a node receives a Hello message from a neighbor, the node
    // SHOULD make sure that it has an active route to the neighbor, and
    // create one if necessary.  If a route already exists, then the
    // Lifetime for the route should be increased, if necessary, to be at
    // least ALLOWED_HELLO_LOSS * HELLO_INTERVAL.  The route to the
    // neighbor, if it exists, MUST subsequently contain the latest
    // Destination Sequence Number from the Hello message.  The current node
    // can now begin using this route to forward data packets.  Routes that
    // are created by hello messages and not used by any other active routes
    // will have empty precursor lists and would not trigger a RERR message
    // if the neighbor moves away and a neighbor timeout occurs.

    unsigned int latestDestSeqNum = helloMessage->getDestSeqNum();
    simtime_t newLifeTime = simTime() + allowedHelloLoss * helloInterval;

    if (!routeHelloOriginator || routeHelloOriginator->getSource() != this)
        createRoute(helloOriginatorAddr, helloOriginatorAddr, 1, true, latestDestSeqNum, true, newLifeTime);
    else {
        AODVRouteData *routeData = check_and_cast<AODVRouteData *>(routeHelloOriginator->getProtocolData());
        simtime_t lifeTime = routeData->getLifeTime();
        updateRoutingTable(routeHelloOriginator, helloOriginatorAddr, 1, true, latestDestSeqNum, true, std::max(lifeTime, newLifeTime));
    }

    // TODO: This feature has not implemented yet.
    // A node MAY determine connectivity by listening for packets from its
    // set of neighbors.  If, within the past DELETE_PERIOD, it has received
    // a Hello message from a neighbor, and then for that neighbor does not
    // receive any packets (Hello messages or otherwise) for more than
    // ALLOWED_HELLO_LOSS * HELLO_INTERVAL milliseconds, the node SHOULD
    // assume that the link to this neighbor is currently lost.  When this
    // happens, the node SHOULD proceed as in Section 6.11.
}

void inet::AODVRouting::handleLinkBreakSendRERR ( const L3Address &  unreachableAddr )

protected

Referenced by receiveSignal().

{
    // For case (i), the node first makes a list of unreachable destinations
    // consisting of the unreachable neighbor and any additional
    // destinations (or subnets, see section 7) in the local routing table
    // that use the unreachable neighbor as the next hop.

    // Just before transmitting the RERR, certain updates are made on the
    // routing table that may affect the destination sequence numbers for
    // the unreachable destinations.  For each one of these destinations,
    // the corresponding routing table entry is updated as follows:
    //
    // 1. The destination sequence number of this routing entry, if it
    //    exists and is valid, is incremented for cases (i) and (ii) above,
    //    and copied from the incoming RERR in case (iii) above.
    //
    // 2. The entry is invalidated by marking the route entry as invalid
    //
    // 3. The Lifetime field is updated to current time plus DELETE_PERIOD.
    //    Before this time, the entry SHOULD NOT be deleted.

    IRoute *unreachableRoute = routingTable->findBestMatchingRoute(unreachableAddr);

    if (!unreachableRoute || unreachableRoute->getSource() != this)
        return;

    std::vector<UnreachableNode> unreachableNodes;
    AODVRouteData *unreachableRouteData = check_and_cast<AODVRouteData *>(unreachableRoute->getProtocolData());

    if (unreachableRouteData->isActive()) {
        UnreachableNode node;
        node.addr = unreachableAddr;
        node.seqNum = unreachableRouteData->getDestSeqNum();
        unreachableNodes.push_back(node);
    }

    // For case (i), the node first makes a list of unreachable destinations
    // consisting of the unreachable neighbor and any additional destinations
    // (or subnets, see section 7) in the local routing table that use the
    // unreachable neighbor as the next hop.

    for (int i = 0; i < routingTable->getNumRoutes(); i++) {
        IRoute *route = routingTable->getRoute(i);

        AODVRouteData *routeData = dynamic_cast<AODVRouteData *>(route->getProtocolData());
        if (routeData && routeData->isActive() && route->getNextHopAsGeneric() == unreachableAddr) {
            if (routeData->hasValidDestNum())
                routeData->setDestSeqNum(routeData->getDestSeqNum() + 1);

            EV_DETAIL << "Marking route to " << route->getDestinationAsGeneric() << " as inactive" << endl;

            routeData->setIsActive(false);
            routeData->setLifeTime(simTime() + deletePeriod);
            scheduleExpungeRoutes();

            UnreachableNode node;
            node.addr = route->getDestinationAsGeneric();
            node.seqNum = routeData->getDestSeqNum();
            unreachableNodes.push_back(node);
        }
    }

    // The neighboring node(s) that should receive the RERR are all those
    // that belong to a precursor list of at least one of the unreachable
    // destination(s) in the newly created RERR.  In case there is only one
    // unique neighbor that needs to receive the RERR, the RERR SHOULD be
    // unicast toward that neighbor.  Otherwise the RERR is typically sent
    // to the local broadcast address (Destination IP == 255.255.255.255,
    // TTL == 1) with the unreachable destinations, and their corresponding
    // destination sequence numbers, included in the packet.

    if (rerrCount >= rerrRatelimit) {
        EV_WARN << "A node should not generate more than RERR_RATELIMIT RERR messages per second. Canceling sending RERR" << endl;
        return;
    }

    if (unreachableNodes.empty())
        return;

    AODVRERR *rerr = createRERR(unreachableNodes);
    rerrCount++;

    // broadcast
    EV_INFO << "Broadcasting Route Error message with TTL=1" << endl;
    sendAODVPacket(rerr, addressType->getBroadcastAddress(), 1, jitterPar->doubleValue());
}

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

overrideprotected

{
    if (!isOperational) {
        if (msg->isSelfMessage())
            throw cRuntimeError("Model error: self msg '%s' received when isOperational is false", msg->getName());

        EV_ERROR << "Application is turned off, dropping '" << msg->getName() << "' message\n";
        delete msg;
        return;
    }

    if (msg->isSelfMessage()) {
        if (dynamic_cast<WaitForRREP *>(msg))
            handleWaitForRREP((WaitForRREP *)msg);
        else if (msg == helloMsgTimer)
            sendHelloMessagesIfNeeded();
        else if (msg == expungeTimer)
            expungeRoutes();
        else if (msg == counterTimer) {
            rreqCount = rerrCount = 0;
            scheduleAt(simTime() + 1, counterTimer);
        }
        else if (msg == rrepAckTimer)
            handleRREPACKTimer();
        else if (msg == blacklistTimer)
            handleBlackListTimer();
        else
            throw cRuntimeError("Unknown self message");
    }
    else if (ICMPMessage *icmpPacket = dynamic_cast<ICMPMessage *>(msg)) {
        // ICMP packet arrived, dropped
        delete icmpPacket;
    }
    else {
        UDPPacket *udpPacket = check_and_cast<UDPPacket *>(msg);
        AODVControlPacket *ctrlPacket = check_and_cast<AODVControlPacket *>(udpPacket->decapsulate());
        INetworkProtocolControlInfo *udpProtocolCtrlInfo = check_and_cast<INetworkProtocolControlInfo *>(udpPacket->getControlInfo());
        L3Address sourceAddr = udpProtocolCtrlInfo->getSourceAddress();
        unsigned int arrivalPacketTTL = udpProtocolCtrlInfo->getHopLimit();

        switch (ctrlPacket->getPacketType()) {
            case RREQ:
                handleRREQ(check_and_cast<AODVRREQ *>(ctrlPacket), sourceAddr, arrivalPacketTTL);
                break;

            case RREP:
                handleRREP(check_and_cast<AODVRREP *>(ctrlPacket), sourceAddr);
                break;

            case RERR:
                handleRERR(check_and_cast<AODVRERR *>(ctrlPacket), sourceAddr);
                break;

            case RREPACK:
                handleRREPACK(check_and_cast<AODVRREPACK *>(ctrlPacket), sourceAddr);
                break;

            default:
                throw cRuntimeError("AODV Control Packet arrived with undefined packet type: %d", ctrlPacket->getPacketType());
        }
        delete udpPacket;
    }
}

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

overrideprotectedvirtual

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.

{
    Enter_Method_Silent();
    if (dynamic_cast<NodeStartOperation *>(operation)) {
        if ((NodeStartOperation::Stage)stage == NodeStartOperation::STAGE_APPLICATION_LAYER) {
            isOperational = true;
            rebootTime = simTime();

            if (useHelloMessages)
                scheduleAt(simTime() + helloInterval - periodicJitter->doubleValue(), helloMsgTimer);

            scheduleAt(simTime() + 1, counterTimer);
        }
    }
    else if (dynamic_cast<NodeShutdownOperation *>(operation)) {
        if ((NodeShutdownOperation::Stage)stage == NodeShutdownOperation::STAGE_APPLICATION_LAYER) {
            isOperational = false;
            clearState();
        }
    }
    else if (dynamic_cast<NodeCrashOperation *>(operation)) {
        if ((NodeCrashOperation::Stage)stage == NodeCrashOperation::STAGE_CRASH) {
            isOperational = false;
            clearState();
        }
    }
    else
        throw cRuntimeError("Unsupported lifecycle operation '%s'", operation->getClassName());

    return true;
}

void inet::AODVRouting::handleRERR ( AODVRERR *  rerr, const L3Address &  sourceAddr  )

protected

Referenced by handleMessage().

{
    EV_INFO << "AODV Route Error arrived with source addr: " << sourceAddr << endl;

    // A node initiates processing for a RERR message in three situations:
    // (iii)   if it receives a RERR from a neighbor for one or more
    //         active routes.
    unsigned int unreachableArraySize = rerr->getUnreachableNodesArraySize();
    std::vector<UnreachableNode> unreachableNeighbors;

    for (int i = 0; i < routingTable->getNumRoutes(); i++) {
        IRoute *route = routingTable->getRoute(i);
        AODVRouteData *routeData = route ? dynamic_cast<AODVRouteData *>(route->getProtocolData()) : nullptr;

        if (!routeData)
            continue;

        // For case (iii), the list should consist of those destinations in the RERR
        // for which there exists a corresponding entry in the local routing
        // table that has the transmitter of the received RERR as the next hop.

        if (routeData->isActive() && route->getNextHopAsGeneric() == sourceAddr) {
            for (unsigned int j = 0; j < unreachableArraySize; j++) {
                if (route->getDestinationAsGeneric() == rerr->getUnreachableNodes(j).addr) {
                    // 1. The destination sequence number of this routing entry, if it
                    // exists and is valid, is incremented for cases (i) and (ii) above,
                    // ! and copied from the incoming RERR in case (iii) above.

                    routeData->setDestSeqNum(rerr->getUnreachableNodes(j).seqNum);
                    routeData->setIsActive(false);    // it means invalid, see 3. AODV Terminology p.3. in RFC 3561
                    routeData->setLifeTime(simTime() + deletePeriod);

                    // The RERR should contain those destinations that are part of
                    // the created list of unreachable destinations and have a non-empty
                    // precursor list.

                    if (routeData->getPrecursorList().size() > 0) {
                        UnreachableNode node;
                        node.addr = route->getDestinationAsGeneric();
                        node.seqNum = routeData->getDestSeqNum();
                        unreachableNeighbors.push_back(node);
                    }
                    scheduleExpungeRoutes();
                }
            }
        }
    }

    if (rerrCount >= rerrRatelimit) {
        EV_WARN << "A node should not generate more than RERR_RATELIMIT RERR messages per second. Canceling sending RERR" << endl;
        delete rerr;
        return;
    }

    if (unreachableNeighbors.size() > 0 && (simTime() > rebootTime + deletePeriod || rebootTime == 0)) {
        EV_INFO << "Sending RERR to inform our neighbors about link breaks." << endl;
        AODVRERR *newRERR = createRERR(unreachableNeighbors);
        sendAODVPacket(newRERR, addressType->getBroadcastAddress(), 1, 0);
        rerrCount++;
    }
    delete rerr;
}

void inet::AODVRouting::handleRREP ( AODVRREP *  rrep, const L3Address &  sourceAddr  )

protected

Referenced by handleMessage().

{
    EV_INFO << "AODV Route Reply arrived with source addr: " << sourceAddr << " originator addr: " << rrep->getOriginatorAddr()
            << " destination addr: " << rrep->getDestAddr() << endl;

    if (rrep->getOriginatorAddr().isUnspecified()) {
        EV_INFO << "This Route Reply is a Hello Message" << endl;
        handleHelloMessage(rrep);
        delete rrep;
        return;
    }
    // When a node receives a RREP message, it searches (using longest-
    // prefix matching) for a route to the previous hop.

    // If needed, a route is created for the previous hop,
    // but without a valid sequence number (see section 6.2)

    IRoute *previousHopRoute = routingTable->findBestMatchingRoute(sourceAddr);

    if (!previousHopRoute || previousHopRoute->getSource() != this) {
        // create without valid sequence number
        previousHopRoute = createRoute(sourceAddr, sourceAddr, 1, false, rrep->getOriginatorSeqNum(), true, simTime() + activeRouteTimeout);
    }
    else
        updateRoutingTable(previousHopRoute, sourceAddr, 1, false, rrep->getOriginatorSeqNum(), true, simTime() + activeRouteTimeout);

    // Next, the node then increments the hop count value in the RREP by one,
    // to account for the new hop through the intermediate node
    unsigned int newHopCount = rrep->getHopCount() + 1;
    rrep->setHopCount(newHopCount);

    // Then the forward route for this destination is created if it does not
    // already exist.

    IRoute *destRoute = routingTable->findBestMatchingRoute(rrep->getDestAddr());
    AODVRouteData *destRouteData = nullptr;
    simtime_t lifeTime = rrep->getLifeTime();
    unsigned int destSeqNum = rrep->getDestSeqNum();

    if (destRoute && destRoute->getSource() == this) {    // already exists
        destRouteData = check_and_cast<AODVRouteData *>(destRoute->getProtocolData());
        // Upon comparison, the existing entry is updated only in the following circumstances:

        // (i) the sequence number in the routing table is marked as
        //     invalid in route table entry.

        if (!destRouteData->hasValidDestNum()) {
            updateRoutingTable(destRoute, sourceAddr, newHopCount, true, destSeqNum, true, simTime() + lifeTime);

            // If the route table entry to the destination is created or updated,
            // then the following actions occur:
            //
            // -  the route is marked as active,
            //
            // -  the destination sequence number is marked as valid,
            //
            // -  the next hop in the route entry is assigned to be the node from
            //    which the RREP is received, which is indicated by the source IP
            //    address field in the IP header,
            //
            // -  the hop count is set to the value of the New Hop Count,
            //
            // -  the expiry time is set to the current time plus the value of the
            //    Lifetime in the RREP message,
            //
            // -  and the destination sequence number is the Destination Sequence
            //    Number in the RREP message.
        }
        // (ii) the Destination Sequence Number in the RREP is greater than
        //      the node's copy of the destination sequence number and the
        //      known value is valid, or
        else if (destSeqNum > destRouteData->getDestSeqNum()) {
            updateRoutingTable(destRoute, sourceAddr, newHopCount, true, destSeqNum, true, simTime() + lifeTime);
        }
        else {
            // (iii) the sequence numbers are the same, but the route is
            //       marked as inactive, or
            if (destSeqNum == destRouteData->getDestSeqNum() && !destRouteData->isActive()) {
                updateRoutingTable(destRoute, sourceAddr, newHopCount, true, destSeqNum, true, simTime() + lifeTime);
            }
            // (iv) the sequence numbers are the same, and the New Hop Count is
            //      smaller than the hop count in route table entry.
            else if (destSeqNum == destRouteData->getDestSeqNum() && newHopCount < (unsigned int)destRoute->getMetric()) {
                updateRoutingTable(destRoute, sourceAddr, newHopCount, true, destSeqNum, true, simTime() + lifeTime);
            }
        }
    }
    else {    // create forward route for the destination: this path will be used by the originator to send data packets
        destRoute = createRoute(rrep->getDestAddr(), sourceAddr, newHopCount, true, destSeqNum, true, simTime() + lifeTime);
        destRouteData = check_and_cast<AODVRouteData *>(destRoute->getProtocolData());
    }

    // If the current node is not the node indicated by the Originator IP
    // Address in the RREP message AND a forward route has been created or
    // updated as described above, the node consults its route table entry
    // for the originating node to determine the next hop for the RREP
    // packet, and then forwards the RREP towards the originator using the
    // information in that route table entry.

    IRoute *originatorRoute = routingTable->findBestMatchingRoute(rrep->getOriginatorAddr());
    if (getSelfIPAddress() != rrep->getOriginatorAddr()) {
        // If a node forwards a RREP over a link that is likely to have errors or
        // be unidirectional, the node SHOULD set the 'A' flag to require that the
        // recipient of the RREP acknowledge receipt of the RREP by sending a RREP-ACK
        // message back (see section 6.8).

        if (originatorRoute && originatorRoute->getSource() == this) {
            AODVRouteData *originatorRouteData = check_and_cast<AODVRouteData *>(originatorRoute->getProtocolData());

            // Also, at each node the (reverse) route used to forward a
            // RREP has its lifetime changed to be the maximum of (existing-
            // lifetime, (current time + ACTIVE_ROUTE_TIMEOUT).

            simtime_t existingLifeTime = originatorRouteData->getLifeTime();
            originatorRouteData->setLifeTime(std::max(simTime() + activeRouteTimeout, existingLifeTime));

            if (simTime() > rebootTime + deletePeriod || rebootTime == 0) {
                // If a node forwards a RREP over a link that is likely to have errors
                // or be unidirectional, the node SHOULD set the 'A' flag to require that
                // the recipient of the RREP acknowledge receipt of the RREP by sending a
                // RREP-ACK message back (see section 6.8).

                if (rrep->getAckRequiredFlag()) {
                    AODVRREPACK *rrepACK = createRREPACK();
                    sendRREPACK(rrepACK, sourceAddr);
                    rrep->setAckRequiredFlag(false);
                }

                // When any node transmits a RREP, the precursor list for the
                // corresponding destination node is updated by adding to it
                // the next hop node to which the RREP is forwarded.

                destRouteData->addPrecursor(originatorRoute->getNextHopAsGeneric());

                // Finally, the precursor list for the next hop towards the
                // destination is updated to contain the next hop towards the
                // source (originator).

                IRoute *nextHopToDestRoute = routingTable->findBestMatchingRoute(destRoute->getNextHopAsGeneric());
                if (nextHopToDestRoute && nextHopToDestRoute->getSource() == this) {
                    AODVRouteData *nextHopToDestRouteData = check_and_cast<AODVRouteData *>(nextHopToDestRoute->getProtocolData());
                    nextHopToDestRouteData->addPrecursor(originatorRoute->getNextHopAsGeneric());
                }
                AODVRREP *outgoingRREP = rrep->dup();
                forwardRREP(outgoingRREP, originatorRoute->getNextHopAsGeneric(), 100);
            }
        }
        else
            EV_ERROR << "Reverse route doesn't exist. Dropping the RREP message" << endl;
    }
    else {
        if (hasOngoingRouteDiscovery(rrep->getDestAddr())) {
            EV_INFO << "The Route Reply has arrived for our Route Request to node " << rrep->getDestAddr() << endl;
            updateRoutingTable(destRoute, sourceAddr, newHopCount, true, destSeqNum, true, simTime() + lifeTime);
            completeRouteDiscovery(rrep->getDestAddr());
        }
    }

    delete rrep;
}

void inet::AODVRouting::handleRREPACK ( AODVRREPACK *  rrepACK, const L3Address &  neighborAddr  )

protected

Referenced by handleMessage().

{
    // Note that the RREP-ACK packet does not contain any information about
    // which RREP it is acknowledging.  The time at which the RREP-ACK is
    // received will likely come just after the time when the RREP was sent
    // with the 'A' bit.
    if (rrepAckTimer->isScheduled()) {
        EV_INFO << "RREP-ACK arrived from " << neighborAddr << endl;

        IRoute *route = routingTable->findBestMatchingRoute(neighborAddr);
        if (route && route->getSource() == this) {
            EV_DETAIL << "Marking route " << route << " as active" << endl;
            AODVRouteData *routeData = check_and_cast<AODVRouteData *>(route->getProtocolData());
            routeData->setIsActive(true);
            cancelEvent(rrepAckTimer);
        }
    }
    delete rrepACK;
}

void inet::AODVRouting::handleRREPACKTimer ( )

protected

Referenced by handleMessage().

{
    // when a node detects that its transmission of a RREP message has failed,
    // it remembers the next-hop of the failed RREP in a "blacklist" set.

    EV_INFO << "RREP-ACK didn't arrived within timeout. Adding " << failedNextHop << " to the blacklist" << endl;

    blacklist[failedNextHop] = simTime() + blacklistTimeout;    // lifetime

    if (!blacklistTimer->isScheduled())
        scheduleAt(simTime() + blacklistTimeout, blacklistTimer);
}

void inet::AODVRouting::handleRREQ ( AODVRREQ *  rreq, const L3Address &  sourceAddr, unsigned int  timeToLive  )

protected

Referenced by handleMessage().

{
    EV_INFO << "AODV Route Request arrived with source addr: " << sourceAddr << " originator addr: " << rreq->getOriginatorAddr()
            << " destination addr: " << rreq->getDestAddr() << endl;

    // A node ignores all RREQs received from any node in its blacklist set.

    auto blackListIt = blacklist.find(sourceAddr);
    if (blackListIt != blacklist.end()) {
        EV_INFO << "The sender node " << sourceAddr << " is in our blacklist. Ignoring the Route Request" << endl;
        delete rreq;
        return;
    }

    // When a node receives a RREQ, it first creates or updates a route to
    // the previous hop without a valid sequence number (see section 6.2).

    IRoute *previousHopRoute = routingTable->findBestMatchingRoute(sourceAddr);

    if (!previousHopRoute || previousHopRoute->getSource() != this) {
        // create without valid sequence number
        previousHopRoute = createRoute(sourceAddr, sourceAddr, 1, false, rreq->getOriginatorSeqNum(), true, simTime() + activeRouteTimeout);
    }
    else
        updateRoutingTable(previousHopRoute, sourceAddr, 1, false, rreq->getOriginatorSeqNum(), true, simTime() + activeRouteTimeout);

    // then checks to determine whether it has received a RREQ with the same
    // Originator IP Address and RREQ ID within at least the last PATH_DISCOVERY_TIME.
    // If such a RREQ has been received, the node silently discards the newly received RREQ.

    RREQIdentifier rreqIdentifier(rreq->getOriginatorAddr(), rreq->getRreqId());
    auto checkRREQArrivalTime = rreqsArrivalTime.find(rreqIdentifier);
    if (checkRREQArrivalTime != rreqsArrivalTime.end() && simTime() - checkRREQArrivalTime->second <= pathDiscoveryTime) {
        EV_WARN << "The same packet has arrived within PATH_DISCOVERY_TIME= " << pathDiscoveryTime << ". Discarding it" << endl;
        delete rreq;
        return;
    }

    // update or create
    rreqsArrivalTime[rreqIdentifier] = simTime();

    // First, it first increments the hop count value in the RREQ by one, to
    // account for the new hop through the intermediate node.

    rreq->setHopCount(rreq->getHopCount() + 1);

    // Then the node searches for a reverse route to the Originator IP Address (see
    // section 6.2), using longest-prefix matching.

    IRoute *reverseRoute = routingTable->findBestMatchingRoute(rreq->getOriginatorAddr());

    // If need be, the route is created, or updated using the Originator Sequence Number from the
    // RREQ in its routing table.
    //
    // When the reverse route is created or updated, the following actions on
    // the route are also carried out:
    //
    //   1. the Originator Sequence Number from the RREQ is compared to the
    //      corresponding destination sequence number in the route table entry
    //      and copied if greater than the existing value there
    //
    //   2. the valid sequence number field is set to true;
    //
    //   3. the next hop in the routing table becomes the node from which the
    //      RREQ was received (it is obtained from the source IP address in
    //      the IP header and is often not equal to the Originator IP Address
    //      field in the RREQ message);
    //
    //   4. the hop count is copied from the Hop Count in the RREQ message;
    //
    //   Whenever a RREQ message is received, the Lifetime of the reverse
    //   route entry for the Originator IP address is set to be the maximum of
    //   (ExistingLifetime, MinimalLifetime), where
    //
    //   MinimalLifetime = (current time + 2*NET_TRAVERSAL_TIME - 2*HopCount*NODE_TRAVERSAL_TIME).

    unsigned int hopCount = rreq->getHopCount();
    simtime_t minimalLifeTime = simTime() + 2 * netTraversalTime - 2 * hopCount * nodeTraversalTime;
    simtime_t newLifeTime = std::max(simTime(), minimalLifeTime);
    int rreqSeqNum = rreq->getOriginatorSeqNum();
    if (!reverseRoute || reverseRoute->getSource() != this) {    // create
        // This reverse route will be needed if the node receives a RREP back to the
        // node that originated the RREQ (identified by the Originator IP Address).
        reverseRoute = createRoute(rreq->getOriginatorAddr(), sourceAddr, hopCount, true, rreqSeqNum, true, newLifeTime);
    }
    else {
        AODVRouteData *routeData = check_and_cast<AODVRouteData *>(reverseRoute->getProtocolData());
        int routeSeqNum = routeData->getDestSeqNum();
        int newSeqNum = std::max(routeSeqNum, rreqSeqNum);
        int newHopCount = rreq->getHopCount();    // Note: already incremented by 1.
        int routeHopCount = reverseRoute->getMetric();
        // The route is only updated if the new sequence number is either
        //
        //   (i)       higher than the destination sequence number in the route
        //             table, or
        //
        //   (ii)      the sequence numbers are equal, but the hop count (of the
        //             new information) plus one, is smaller than the existing hop
        //             count in the routing table, or
        //
        //   (iii)     the sequence number is unknown.

        if (rreqSeqNum > routeSeqNum ||
            (rreqSeqNum == routeSeqNum && newHopCount < routeHopCount) ||
            rreq->getUnknownSeqNumFlag())
        {
            updateRoutingTable(reverseRoute, sourceAddr, hopCount, true, newSeqNum, true, newLifeTime);
        }
    }

    // A node generates a RREP if either:
    //
    // (i)       it is itself the destination, or
    //
    // (ii)      it has an active route to the destination, the destination
    //           sequence number in the node's existing route table entry
    //           for the destination is valid and greater than or equal to
    //           the Destination Sequence Number of the RREQ (comparison
    //           using signed 32-bit arithmetic), and the "destination only"
    //           ('D') flag is NOT set.

    // After a node receives a RREQ and responds with a RREP, it discards
    // the RREQ.  If the RREQ has the 'G' flag set, and the intermediate
    // node returns a RREP to the originating node, it MUST also unicast a
    // gratuitous RREP to the destination node.

    IRoute *destRoute = routingTable->findBestMatchingRoute(rreq->getDestAddr());
    AODVRouteData *destRouteData = destRoute ? dynamic_cast<AODVRouteData *>(destRoute->getProtocolData()) : nullptr;

    // check (i)
    if (rreq->getDestAddr() == getSelfIPAddress()) {
        EV_INFO << "I am the destination node for which the route was requested" << endl;

        // create RREP
        AODVRREP *rrep = createRREP(rreq, destRoute, reverseRoute, sourceAddr);

        // send to the originator
        sendRREP(rrep, rreq->getOriginatorAddr(), 255);

        delete rreq;
        return;    // discard RREQ, in this case, we do not forward it.
    }

    // check (ii)
    if (destRouteData && destRouteData->isActive() && destRouteData->hasValidDestNum() &&
        destRouteData->getDestSeqNum() >= rreq->getDestSeqNum())
    {
        EV_INFO << "I am an intermediate node who has information about a route to " << rreq->getDestAddr() << endl;

        if (destRoute->getNextHopAsGeneric() == sourceAddr) {
            EV_WARN << "This RREP would make a loop. Dropping it" << endl;

            delete rreq;
            return;
        }

        // create RREP
        AODVRREP *rrep = createRREP(rreq, destRoute, reverseRoute, sourceAddr);

        // send to the originator
        sendRREP(rrep, rreq->getOriginatorAddr(), 255);

        if (rreq->getGratuitousRREPFlag()) {
            // The gratuitous RREP is then sent to the next hop along the path to
            // the destination node, just as if the destination node had already
            // issued a RREQ for the originating node and this RREP was produced in
            // response to that (fictitious) RREQ.

            IRoute *originatorRoute = routingTable->findBestMatchingRoute(rreq->getOriginatorAddr());
            AODVRREP *grrep = createGratuitousRREP(rreq, originatorRoute);
            sendGRREP(grrep, rreq->getDestAddr(), 100);
        }

        delete rreq;
        return;    // discard RREQ, in this case, we also do not forward it.
    }
    // If a node does not generate a RREP (following the processing rules in
    // section 6.6), and if the incoming IP header has TTL larger than 1,
    // the node updates and broadcasts the RREQ to address 255.255.255.255
    // on each of its configured interfaces (see section 6.14).  To update
    // the RREQ, the TTL or hop limit field in the outgoing IP header is
    // decreased by one, and the Hop Count field in the RREQ message is
    // incremented by one, to account for the new hop through the
    // intermediate node. (!) Lastly, the Destination Sequence number for the
    // requested destination is set to the maximum of the corresponding
    // value received in the RREQ message, and the destination sequence
    // value currently maintained by the node for the requested destination.
    // However, the forwarding node MUST NOT modify its maintained value for
    // the destination sequence number, even if the value received in the
    // incoming RREQ is larger than the value currently maintained by the
    // forwarding node.

    if (timeToLive > 0 && (simTime() > rebootTime + deletePeriod || rebootTime == 0)) {
        if (destRouteData)
            rreq->setDestSeqNum(std::max(destRouteData->getDestSeqNum(), rreq->getDestSeqNum()));
        rreq->setUnknownSeqNumFlag(false);

        AODVRREQ *outgoingRREQ = rreq->dup();
        forwardRREQ(outgoingRREQ, timeToLive);
    }
    else
        EV_WARN << "Can't forward the RREQ because of its small (<= 1) TTL: " << timeToLive << " or the AODV reboot has not completed yet" << endl;

    delete rreq;
}

void inet::AODVRouting::handleWaitForRREP ( WaitForRREP *  rrepTimer )

protected

Referenced by handleMessage().

{
    EV_INFO << "We didn't get any Route Reply within RREP timeout" << endl;
    L3Address destAddr = rrepTimer->getDestAddr();

    ASSERT(addressToRreqRetries.find(destAddr) != addressToRreqRetries.end());
    if (addressToRreqRetries[destAddr] == rreqRetries) {
        cancelRouteDiscovery(destAddr);
        EV_WARN << "Re-discovery attempts for node " << destAddr << " reached RREQ_RETRIES= " << rreqRetries << " limit. Stop sending RREQ." << endl;
        return;
    }

    AODVRREQ *rreq = createRREQ(destAddr);

    // the node MAY try again to discover a route by broadcasting another
    // RREQ, up to a maximum of RREQ_RETRIES times at the maximum TTL value.
    if (rrepTimer->getLastTTL() == netDiameter) // netDiameter is the maximum TTL value
        addressToRreqRetries[destAddr]++;

    sendRREQ(rreq, addressType->getBroadcastAddress(), 0);
}

bool inet::AODVRouting::hasOngoingRouteDiscovery ( const L3Address &  destAddr )

protected

Referenced by cancelRouteDiscovery(), completeRouteDiscovery(), ensureRouteForDatagram(), expungeRoutes(), handleRREP(), sendRREQ(), and startRouteDiscovery().

{
    return waitForRREPTimers.find(target) != waitForRREPTimers.end();
}

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

overrideprotected

{
    if (stage == INITSTAGE_LOCAL) {
        lastBroadcastTime = SIMTIME_ZERO;
        rebootTime = SIMTIME_ZERO;
        rreqId = sequenceNum = 0;
        rreqCount = rerrCount = 0;
        host = getContainingNode(this);
        routingTable = getModuleFromPar<IRoutingTable>(par("routingTableModule"), this);
        interfaceTable = getModuleFromPar<IInterfaceTable>(par("interfaceTableModule"), this);
        networkProtocol = getModuleFromPar<INetfilter>(par("networkProtocolModule"), this);

        aodvUDPPort = par("udpPort");
        askGratuitousRREP = par("askGratuitousRREP");
        useHelloMessages = par("useHelloMessages");
        activeRouteTimeout = par("activeRouteTimeout");
        helloInterval = par("helloInterval");
        allowedHelloLoss = par("allowedHelloLoss");
        netDiameter = par("netDiameter");
        nodeTraversalTime = par("nodeTraversalTime");
        rerrRatelimit = par("rerrRatelimit");
        rreqRetries = par("rreqRetries");
        rreqRatelimit = par("rreqRatelimit");
        timeoutBuffer = par("timeoutBuffer");
        ttlStart = par("ttlStart");
        ttlIncrement = par("ttlIncrement");
        ttlThreshold = par("ttlThreshold");
        localAddTTL = par("localAddTTL");
        jitterPar = &par("jitter");
        periodicJitter = &par("periodicJitter");

        myRouteTimeout = par("myRouteTimeout");
        deletePeriod = par("deletePeriod");
        blacklistTimeout = par("blacklistTimeout");
        netTraversalTime = par("netTraversalTime");
        nextHopWait = par("nextHopWait");
        pathDiscoveryTime = par("pathDiscoveryTime");
    }
    else if (stage == INITSTAGE_ROUTING_PROTOCOLS) {
        NodeStatus *nodeStatus = dynamic_cast<NodeStatus *>(host->getSubmodule("status"));
        isOperational = !nodeStatus || nodeStatus->getState() == NodeStatus::UP;

        addressType = getSelfIPAddress().getAddressType();
        IPSocket socket(gate("ipOut"));
        socket.registerProtocol(IP_PROT_MANET);
        networkProtocol->registerHook(0, this);
        host->subscribe(NF_LINK_BREAK, this);

        if (useHelloMessages) {
            helloMsgTimer = new cMessage("HelloMsgTimer");

            // RFC 5148:
            // Jitter SHOULD be applied by reducing this delay by a random amount, so that
            // the delay between consecutive transmissions of messages of the same type is
            // equal to (MESSAGE_INTERVAL - jitter), where jitter is the random value.
            if (isOperational)
                scheduleAt(simTime() + helloInterval - periodicJitter->doubleValue(), helloMsgTimer);
        }

        expungeTimer = new cMessage("ExpungeTimer");
        counterTimer = new cMessage("CounterTimer");
        rrepAckTimer = new cMessage("RREPACKTimer");
        blacklistTimer = new cMessage("BlackListTimer");

        if (isOperational)
            scheduleAt(simTime() + 1, counterTimer);
    }
}

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

inlineoverrideprotectedvirtual

{ return NUM_INIT_STAGES; }

void inet::AODVRouting::receiveSignal ( cComponent *  source, simsignal_t  signalID, cObject *  obj, cObject *  details  )

overrideprotectedvirtual

{
    Enter_Method("receiveChangeNotification");
    if (signalID == NF_LINK_BREAK) {
        EV_DETAIL << "Received link break signal" << endl;
        // XXX: This is a hack for supporting both IdealMac and Ieee80211Mac. etc
        cPacket *frame = check_and_cast<cPacket *>(obj);
        INetworkDatagram *datagram = nullptr;
        if (false
#ifdef WITH_IEEE80211
            || dynamic_cast<ieee80211::Ieee80211Frame *>(frame)
#endif // ifdef WITH_IEEE80211
#ifdef WITH_IDEALWIRELESS
            || dynamic_cast<IdealMacFrame *>(frame)
#endif // ifdef WITH_IDEALWIRELESS
#ifdef WITH_CSMA
            || dynamic_cast<CSMAFrame *>(frame)
#endif // ifdef WITH_CSMA
#ifdef WITH_CSMACA
            || dynamic_cast<CsmaCaMacFrame *>(frame)
#endif // ifdef WITH_CSMACA
#ifdef WITH_LMAC
            || dynamic_cast<LMacFrame *>(frame)
#endif // ifdef WITH_LMAC
#ifdef WITH_BMAC
            || dynamic_cast<BMacFrame *>(frame)
#endif // ifdef WITH_BMAC
            )
            datagram = dynamic_cast<INetworkDatagram *>(frame->getEncapsulatedPacket());
        else
            throw cRuntimeError("Unknown packet type in NF_LINK_BREAK signal");
        if (datagram) {
            L3Address unreachableAddr = datagram->getDestinationAddress();
            if (unreachableAddr.getAddressType() == addressType) {
                // A node initiates processing for a RERR message in three situations:
                //
                //   (i)     if it detects a link break for the next hop of an active
                //           route in its routing table while transmitting data (and
                //           route repair, if attempted, was unsuccessful), or

                // TODO: Implement: local repair

                IRoute *route = routingTable->findBestMatchingRoute(unreachableAddr);

                if (route && route->getSource() == this)
                    handleLinkBreakSendRERR(route->getNextHopAsGeneric());
            }
        }
    }
}

void inet::AODVRouting::scheduleExpungeRoutes ( )

protected

Referenced by createRoute(), expungeRoutes(), handleLinkBreakSendRERR(), handleRERR(), and updateRoutingTable().

{
    simtime_t nextExpungeTime = SimTime::getMaxTime();
    for (int i = 0; i < routingTable->getNumRoutes(); i++) {
        IRoute *route = routingTable->getRoute(i);

        if (route->getSource() == this) {
            AODVRouteData *routeData = check_and_cast<AODVRouteData *>(route->getProtocolData());
            ASSERT(routeData != nullptr);

            if (routeData->getLifeTime() < nextExpungeTime)
                nextExpungeTime = routeData->getLifeTime();
        }
    }
    if (nextExpungeTime == SimTime::getMaxTime()) {
        if (expungeTimer->isScheduled())
            cancelEvent(expungeTimer);
    }
    else {
        if (!expungeTimer->isScheduled())
            scheduleAt(nextExpungeTime, expungeTimer);
        else {
            if (expungeTimer->getArrivalTime() != nextExpungeTime) {
                cancelEvent(expungeTimer);
                scheduleAt(nextExpungeTime, expungeTimer);
            }
        }
    }
}

void inet::AODVRouting::sendAODVPacket ( AODVControlPacket *  packet, const L3Address &  destAddr, unsigned int  timeToLive, double  delay  )

protected

Referenced by forwardRREP(), forwardRREQ(), handleLinkBreakSendRERR(), handleRERR(), sendGRREP(), sendHelloMessagesIfNeeded(), sendRERRWhenNoRouteToForward(), sendRREP(), sendRREPACK(), and sendRREQ().

{
    ASSERT(timeToLive != 0);

    INetworkProtocolControlInfo *networkProtocolControlInfo = addressType->createNetworkProtocolControlInfo();

    networkProtocolControlInfo->setHopLimit(timeToLive);

    networkProtocolControlInfo->setTransportProtocol(IP_PROT_MANET);
    networkProtocolControlInfo->setDestinationAddress(destAddr);
    networkProtocolControlInfo->setSourceAddress(getSelfIPAddress());

    // TODO: Implement: support for multiple interfaces
    InterfaceEntry *ifEntry = interfaceTable->getInterfaceByName("wlan0");
    networkProtocolControlInfo->setInterfaceId(ifEntry->getInterfaceId());

    UDPPacket *udpPacket = new UDPPacket(packet->getName());
    udpPacket->encapsulate(packet);
    udpPacket->setSourcePort(aodvUDPPort);
    udpPacket->setDestinationPort(aodvUDPPort);
    udpPacket->setControlInfo(dynamic_cast<cObject *>(networkProtocolControlInfo));

    if (destAddr.isBroadcast())
        lastBroadcastTime = simTime();

    if (delay == 0)
        send(udpPacket, "ipOut");
    else
        sendDelayed(udpPacket, delay, "ipOut");
}

void inet::AODVRouting::sendGRREP ( AODVRREP *  grrep, const L3Address &  destAddr, unsigned int  timeToLive  )

protected

Referenced by handleRREQ().

{
    EV_INFO << "Sending gratuitous Route Reply to " << destAddr << endl;

    IRoute *destRoute = routingTable->findBestMatchingRoute(destAddr);
    const L3Address& nextHop = destRoute->getNextHopAsGeneric();

    sendAODVPacket(grrep, nextHop, timeToLive, 0);
}

void inet::AODVRouting::sendHelloMessagesIfNeeded ( )

protected

Referenced by handleMessage().

{
    ASSERT(useHelloMessages);
    // Every HELLO_INTERVAL milliseconds, the node checks whether it has
    // sent a broadcast (e.g., a RREQ or an appropriate layer 2 message)
    // within the last HELLO_INTERVAL.  If it has not, it MAY broadcast
    // a RREP with TTL = 1

    // A node SHOULD only use hello messages if it is part of an
    // active route.
    bool hasActiveRoute = false;

    for (int i = 0; i < routingTable->getNumRoutes(); i++) {
        IRoute *route = routingTable->getRoute(i);
        if (route->getSource() == this) {
            AODVRouteData *routeData = check_and_cast<AODVRouteData *>(route->getProtocolData());
            if (routeData->isActive()) {
                hasActiveRoute = true;
                break;
            }
        }
    }

    if (hasActiveRoute && (lastBroadcastTime == 0 || simTime() - lastBroadcastTime > helloInterval)) {
        EV_INFO << "It is hello time, broadcasting Hello Messages with TTL=1" << endl;
        AODVRREP *helloMessage = createHelloMessage();
        sendAODVPacket(helloMessage, addressType->getBroadcastAddress(), 1, 0);
    }

    scheduleAt(simTime() + helloInterval - periodicJitter->doubleValue(), helloMsgTimer);
}

void inet::AODVRouting::sendRERRWhenNoRouteToForward ( const L3Address &  unreachableAddr )

protected

Referenced by datagramForwardHook().

{
    if (rerrCount >= rerrRatelimit) {
        EV_WARN << "A node should not generate more than RERR_RATELIMIT RERR messages per second. Canceling sending RERR" << endl;
        return;
    }
    std::vector<UnreachableNode> unreachableNodes;
    UnreachableNode node;
    node.addr = unreachableAddr;

    IRoute *unreachableRoute = routingTable->findBestMatchingRoute(unreachableAddr);
    AODVRouteData *unreachableRouteData = unreachableRoute ? dynamic_cast<AODVRouteData *>(unreachableRoute->getProtocolData()) : nullptr;

    if (unreachableRouteData && unreachableRouteData->hasValidDestNum())
        node.seqNum = unreachableRouteData->getDestSeqNum();
    else
        node.seqNum = 0;

    unreachableNodes.push_back(node);
    AODVRERR *rerr = createRERR(unreachableNodes);

    rerrCount++;
    EV_INFO << "Broadcasting Route Error message with TTL=1" << endl;
    sendAODVPacket(rerr, addressType->getBroadcastAddress(), 1, jitterPar->doubleValue());    // TODO: unicast if there exists a route to the source
}

void inet::AODVRouting::sendRREP ( AODVRREP *  rrep, const L3Address &  destAddr, unsigned int  timeToLive  )

protected

Referenced by handleRREQ().

{
    EV_INFO << "Sending Route Reply to " << destAddr << endl;

    // When any node transmits a RREP, the precursor list for the
    // corresponding destination node is updated by adding to it
    // the next hop node to which the RREP is forwarded.

    IRoute *destRoute = routingTable->findBestMatchingRoute(destAddr);
    const L3Address& nextHop = destRoute->getNextHopAsGeneric();
    AODVRouteData *destRouteData = check_and_cast<AODVRouteData *>(destRoute->getProtocolData());
    destRouteData->addPrecursor(nextHop);

    // The node we received the Route Request for is our neighbor,
    // it is probably an unidirectional link
    if (destRoute->getMetric() == 1) {
        // It is possible that a RREP transmission may fail, especially if the
        // RREQ transmission triggering the RREP occurs over a unidirectional
        // link.

        rrep->setAckRequiredFlag(true);

        // when a node detects that its transmission of a RREP message has failed,
        // it remembers the next-hop of the failed RREP in a "blacklist" set.

        failedNextHop = nextHop;

        if (rrepAckTimer->isScheduled())
            cancelEvent(rrepAckTimer);

        scheduleAt(simTime() + nextHopWait, rrepAckTimer);
    }
    sendAODVPacket(rrep, nextHop, timeToLive, 0);
}

void inet::AODVRouting::sendRREPACK ( AODVRREPACK *  rrepACK, const L3Address &  destAddr  )

protected

Referenced by handleRREP().

{
    EV_INFO << "Sending Route Reply ACK to " << destAddr << endl;
    sendAODVPacket(rrepACK, destAddr, 100, 0);
}

void inet::AODVRouting::sendRREQ ( AODVRREQ *  rreq, const L3Address &  destAddr, unsigned int  timeToLive  )

protected

Referenced by handleWaitForRREP(), and startRouteDiscovery().

{
    // In an expanding ring search, the originating node initially uses a TTL =
    // TTL_START in the RREQ packet IP header and sets the timeout for
    // receiving a RREP to RING_TRAVERSAL_TIME milliseconds.
    // RING_TRAVERSAL_TIME is calculated as described in section 10.  The
    // TTL_VALUE used in calculating RING_TRAVERSAL_TIME is set equal to the
    // value of the TTL field in the IP header.  If the RREQ times out
    // without a corresponding RREP, the originator broadcasts the RREQ
    // again with the TTL incremented by TTL_INCREMENT.  This continues
    // until the TTL set in the RREQ reaches TTL_THRESHOLD, beyond which a
    // TTL = NET_DIAMETER is used for each attempt.

    if (rreqCount >= rreqRatelimit) {
        EV_WARN << "A node should not originate more than RREQ_RATELIMIT RREQ messages per second. Canceling sending RREQ" << endl;
        delete rreq;
        return;
    }

    auto rrepTimer = waitForRREPTimers.find(rreq->getDestAddr());
    WaitForRREP *rrepTimerMsg = nullptr;
    if (rrepTimer != waitForRREPTimers.end()) {
        rrepTimerMsg = rrepTimer->second;
        unsigned int lastTTL = rrepTimerMsg->getLastTTL();
        rrepTimerMsg->setDestAddr(rreq->getDestAddr());

        // The Hop Count stored in an invalid routing table entry indicates the
        // last known hop count to that destination in the routing table.  When
        // a new route to the same destination is required at a later time
        // (e.g., upon route loss), the TTL in the RREQ IP header is initially
        // set to the Hop Count plus TTL_INCREMENT.  Thereafter, following each
        // timeout the TTL is incremented by TTL_INCREMENT until TTL =
        // TTL_THRESHOLD is reached.  Beyond this TTL = NET_DIAMETER is used.
        // Once TTL = NET_DIAMETER, the timeout for waiting for the RREP is set
        // to NET_TRAVERSAL_TIME, as specified in section 6.3.

        if (timeToLive != 0) {
            rrepTimerMsg->setLastTTL(timeToLive);
            rrepTimerMsg->setFromInvalidEntry(true);
            cancelEvent(rrepTimerMsg);
        }
        else if (lastTTL + ttlIncrement < ttlThreshold) {
            ASSERT(!rrepTimerMsg->isScheduled());
            timeToLive = lastTTL + ttlIncrement;
            rrepTimerMsg->setLastTTL(lastTTL + ttlIncrement);
        }
        else {
            ASSERT(!rrepTimerMsg->isScheduled());
            timeToLive = netDiameter;
            rrepTimerMsg->setLastTTL(netDiameter);
        }
    }
    else {
        rrepTimerMsg = new WaitForRREP();
        waitForRREPTimers[rreq->getDestAddr()] = rrepTimerMsg;
        ASSERT(hasOngoingRouteDiscovery(rreq->getDestAddr()));

        timeToLive = ttlStart;
        rrepTimerMsg->setLastTTL(ttlStart);
        rrepTimerMsg->setFromInvalidEntry(false);
        rrepTimerMsg->setDestAddr(rreq->getDestAddr());
    }

    // Each time, the timeout for receiving a RREP is RING_TRAVERSAL_TIME.
    simtime_t ringTraversalTime = 2.0 * nodeTraversalTime * (timeToLive + timeoutBuffer);
    scheduleAt(simTime() + ringTraversalTime, rrepTimerMsg);

    EV_INFO << "Sending a Route Request with target " << rreq->getDestAddr() << " and TTL= " << timeToLive << endl;
    sendAODVPacket(rreq, destAddr, timeToLive, jitterPar->doubleValue());
    rreqCount++;
}

void inet::AODVRouting::startRouteDiscovery ( const L3Address &  target, unsigned int  timeToLive = 0  )

protected

Referenced by ensureRouteForDatagram().

{
    EV_INFO << "Starting route discovery with originator " << getSelfIPAddress() << " and destination " << target << endl;
    ASSERT(!hasOngoingRouteDiscovery(target));
    AODVRREQ *rreq = createRREQ(target);
    addressToRreqRetries[target] = 0;
    sendRREQ(rreq, addressType->getBroadcastAddress(), timeToLive);
}

void inet::AODVRouting::updateRoutingTable ( IRoute *  route, const L3Address &  nextHop, unsigned int  hopCount, bool  hasValidDestNum, unsigned int  destSeqNum, bool  isActive, simtime_t  lifeTime  )

protected

Referenced by handleHelloMessage(), handleRREP(), and handleRREQ().

{
    EV_DETAIL << "Updating existing route: " << route << endl;

    route->setNextHop(nextHop);
    route->setMetric(hopCount);

    AODVRouteData *routingData = check_and_cast<AODVRouteData *>(route->getProtocolData());
    ASSERT(routingData != nullptr);

    routingData->setLifeTime(lifeTime);
    routingData->setDestSeqNum(destSeqNum);
    routingData->setIsActive(isActive);
    routingData->setHasValidDestNum(hasValidDestNum);

    EV_DETAIL << "Route updated: " << route << endl;

    scheduleExpungeRoutes();
}

bool inet::AODVRouting::updateValidRouteLifeTime ( const L3Address &  destAddr, simtime_t  lifetime  )

protected

Referenced by datagramForwardHook(), and ensureRouteForDatagram().

{
    IRoute *route = routingTable->findBestMatchingRoute(destAddr);
    if (route && route->getSource() == this) {
        AODVRouteData *routeData = check_and_cast<AODVRouteData *>(route->getProtocolData());
        if (routeData->isActive()) {
            simtime_t newLifeTime = std::max(routeData->getLifeTime(), lifetime);
            EV_DETAIL << "Updating " << route << " lifetime to " << newLifeTime << endl;
            routeData->setLifeTime(newLifeTime);
            return true;
        }
    }
    return false;
}

Member Data Documentation

simtime_t inet::AODVRouting::activeRouteTimeout

protected

Referenced by datagramForwardHook(), ensureRouteForDatagram(), handleRREP(), handleRREQ(), and initialize().

std::map<L3Address, unsigned int> inet::AODVRouting::addressToRreqRetries

protected

Referenced by clearState(), handleWaitForRREP(), and startRouteDiscovery().

IL3AddressType* inet::AODVRouting::addressType = nullptr

protected

Referenced by createRoute(), forwardRREQ(), handleLinkBreakSendRERR(), handleRERR(), handleWaitForRREP(), initialize(), receiveSignal(), sendAODVPacket(), sendHelloMessagesIfNeeded(), sendRERRWhenNoRouteToForward(), and startRouteDiscovery().

unsigned int inet::AODVRouting::allowedHelloLoss = 0

protected

Referenced by createHelloMessage(), handleHelloMessage(), and initialize().

unsigned int inet::AODVRouting::aodvUDPPort = 0

protected

Referenced by initialize(), and sendAODVPacket().

bool inet::AODVRouting::askGratuitousRREP = false

protected

Referenced by createRREQ(), and initialize().

std::map<L3Address, simtime_t> inet::AODVRouting::blacklist

protected

Referenced by handleBlackListTimer(), handleRREPACKTimer(), and handleRREQ().

simtime_t inet::AODVRouting::blacklistTimeout

protected

Referenced by handleRREPACKTimer(), and initialize().

cMessage* inet::AODVRouting::blacklistTimer = nullptr

protected

Referenced by clearState(), handleBlackListTimer(), handleMessage(), handleRREPACKTimer(), initialize(), and ~AODVRouting().

cMessage* inet::AODVRouting::counterTimer = nullptr

protected

Referenced by clearState(), handleMessage(), handleOperationStage(), initialize(), and ~AODVRouting().

simtime_t inet::AODVRouting::deletePeriod

protected

Referenced by datagramForwardHook(), expungeRoutes(), handleLinkBreakSendRERR(), handleRERR(), handleRREP(), handleRREQ(), and initialize().

cMessage* inet::AODVRouting::expungeTimer = nullptr

protected

Referenced by clearState(), handleMessage(), initialize(), scheduleExpungeRoutes(), and ~AODVRouting().

L3Address inet::AODVRouting::failedNextHop

protected

Referenced by handleRREPACKTimer(), and sendRREP().

simtime_t inet::AODVRouting::helloInterval

protected

Referenced by createHelloMessage(), handleHelloMessage(), handleOperationStage(), initialize(), and sendHelloMessagesIfNeeded().

cMessage* inet::AODVRouting::helloMsgTimer = nullptr

protected

Referenced by clearState(), handleMessage(), handleOperationStage(), initialize(), sendHelloMessagesIfNeeded(), and ~AODVRouting().

cModule* inet::AODVRouting::host = nullptr

protected

Referenced by initialize().

IInterfaceTable* inet::AODVRouting::interfaceTable = nullptr

protected

Referenced by createRoute(), initialize(), and sendAODVPacket().

bool inet::AODVRouting::isOperational = false

protected

Referenced by handleMessage(), handleOperationStage(), and initialize().

cPar* inet::AODVRouting::jitterPar = nullptr

protected

Referenced by forwardRREP(), forwardRREQ(), handleLinkBreakSendRERR(), initialize(), sendRERRWhenNoRouteToForward(), and sendRREQ().

simtime_t inet::AODVRouting::lastBroadcastTime

protected

Referenced by initialize(), sendAODVPacket(), and sendHelloMessagesIfNeeded().

unsigned int inet::AODVRouting::localAddTTL = 0

protected

Referenced by initialize().

simtime_t inet::AODVRouting::maxJitter

protected

simtime_t inet::AODVRouting::myRouteTimeout

protected

Referenced by createRREP(), and initialize().

unsigned int inet::AODVRouting::netDiameter = 0

protected

Referenced by handleWaitForRREP(), initialize(), and sendRREQ().

simtime_t inet::AODVRouting::netTraversalTime

protected

Referenced by expungeRoutes(), handleRREQ(), and initialize().

INetfilter* inet::AODVRouting::networkProtocol = nullptr

protected

Referenced by cancelRouteDiscovery(), completeRouteDiscovery(), and initialize().

simtime_t inet::AODVRouting::nextHopWait

protected

Referenced by initialize(), and sendRREP().

simtime_t inet::AODVRouting::nodeTraversalTime

protected

Referenced by handleRREQ(), initialize(), and sendRREQ().

simtime_t inet::AODVRouting::pathDiscoveryTime

protected

Referenced by handleRREQ(), and initialize().

cPar* inet::AODVRouting::periodicJitter = nullptr

protected

Referenced by handleOperationStage(), initialize(), and sendHelloMessagesIfNeeded().

simtime_t inet::AODVRouting::rebootTime

protected

Referenced by handleOperationStage(), handleRERR(), handleRREP(), handleRREQ(), and initialize().

unsigned int inet::AODVRouting::rerrCount = 0

protected

Referenced by clearState(), handleLinkBreakSendRERR(), handleMessage(), handleRERR(), initialize(), and sendRERRWhenNoRouteToForward().

unsigned int inet::AODVRouting::rerrRatelimit = 0

protected

Referenced by handleLinkBreakSendRERR(), handleRERR(), initialize(), and sendRERRWhenNoRouteToForward().

IRoutingTable* inet::AODVRouting::routingTable = nullptr

protected

Referenced by createRoute(), createRREQ(), datagramForwardHook(), ensureRouteForDatagram(), expungeRoutes(), getSelfIPAddress(), handleHelloMessage(), handleLinkBreakSendRERR(), handleRERR(), handleRREP(), handleRREPACK(), handleRREQ(), initialize(), receiveSignal(), scheduleExpungeRoutes(), sendGRREP(), sendHelloMessagesIfNeeded(), sendRERRWhenNoRouteToForward(), sendRREP(), and updateValidRouteLifeTime().

cMessage* inet::AODVRouting::rrepAckTimer = nullptr

protected

Referenced by clearState(), handleMessage(), handleRREPACK(), initialize(), sendRREP(), and ~AODVRouting().

unsigned int inet::AODVRouting::rreqCount = 0

protected

Referenced by clearState(), handleMessage(), initialize(), and sendRREQ().

unsigned int inet::AODVRouting::rreqId = 0

protected

Referenced by clearState(), createRREQ(), and initialize().

unsigned int inet::AODVRouting::rreqRatelimit = 0

protected

Referenced by initialize(), and sendRREQ().

unsigned int inet::AODVRouting::rreqRetries = 0

protected

Referenced by handleWaitForRREP(), and initialize().

std::map<RREQIdentifier, simtime_t, RREQIdentifierCompare> inet::AODVRouting::rreqsArrivalTime

protected

Referenced by clearState(), createRREQ(), and handleRREQ().

unsigned int inet::AODVRouting::sequenceNum = 0

protected

Referenced by clearState(), createHelloMessage(), createRREP(), createRREQ(), and initialize().

std::multimap<L3Address, INetworkDatagram *> inet::AODVRouting::targetAddressToDelayedPackets

protected

Referenced by cancelRouteDiscovery(), clearState(), completeRouteDiscovery(), and delayDatagram().

unsigned int inet::AODVRouting::timeoutBuffer = 0

protected

Referenced by initialize(), and sendRREQ().

unsigned int inet::AODVRouting::ttlIncrement = 0

protected

Referenced by ensureRouteForDatagram(), initialize(), and sendRREQ().

unsigned int inet::AODVRouting::ttlStart = 0

protected

Referenced by initialize(), and sendRREQ().

unsigned int inet::AODVRouting::ttlThreshold = 0

protected

Referenced by initialize(), and sendRREQ().

bool inet::AODVRouting::useHelloMessages = false

protected

Referenced by clearState(), handleOperationStage(), initialize(), and sendHelloMessagesIfNeeded().

std::map<L3Address, WaitForRREP *> inet::AODVRouting::waitForRREPTimers

protected

Referenced by cancelRouteDiscovery(), clearState(), completeRouteDiscovery(), hasOngoingRouteDiscovery(), and sendRREQ().

---

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

• AODVRouting.h
• AODVRouting.cc