#include <Aodv.h>

Inheritance diagram for inet::aodv::Aodv:

Classes
class	RreqIdentifier

class	RreqIdentifierCompare

Public Member Functions
	Aodv ()

virtual	~Aodv ()

Public Member Functions inherited from inet::RoutingProtocolBase
	RoutingProtocolBase ()

Public Member Functions inherited from inet::OperationalMixin< cSimpleModule >
virtual	~OperationalMixin ()
	}@ More...

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

Public Member Functions inherited from inet::NetfilterBase::HookBase
virtual	~HookBase ()

void	registeredTo (INetfilter *nf)

void	unregisteredFrom (INetfilter *nf)

bool	isRegisteredHook (INetfilter *nf)

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

Public Member Functions inherited from inet::UdpSocket::ICallback
virtual	~ICallback ()

Protected Member Functions
void	handleMessageWhenUp (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 ()

const Ptr< RrepAck >	createRREPACK ()

const Ptr< Rrep >	createHelloMessage ()

const Ptr< Rreq >	createRREQ (const L3Address &destAddr)

const Ptr< Rrep >	createRREP (const Ptr< Rreq > &rreq, IRoute destRoute, IRoute originatorRoute, const L3Address &sourceAddr)

const Ptr< Rrep >	createGratuitousRREP (const Ptr< Rreq > &rreq, IRoute *originatorRoute)

const Ptr< Rerr >	createRERR (const std::vector< UnreachableNode > &unreachableNodes)

void	handleRREP (const Ptr< Rrep > &rrep, const L3Address &sourceAddr)

void	handleRREQ (const Ptr< Rreq > &rreq, const L3Address &sourceAddr, unsigned int timeToLive)

void	handleRERR (const Ptr< const Rerr > &rerr, const L3Address &sourceAddr)

void	handleHelloMessage (const Ptr< Rrep > &helloMessage)

void	handleRREPACK (const Ptr< const RrepAck > &rrepACK, const L3Address &neighborAddr)

void	sendRREQ (const Ptr< Rreq > &rreq, const L3Address &destAddr, unsigned int timeToLive)

void	sendRREPACK (const Ptr< RrepAck > &rrepACK, const L3Address &destAddr)

void	sendRREP (const Ptr< Rrep > &rrep, const L3Address &destAddr, unsigned int timeToLive)

void	sendGRREP (const Ptr< Rrep > &grrep, const L3Address &destAddr, unsigned int timeToLive)

void	forwardRREP (const Ptr< Rrep > &rrep, const L3Address &destAddr, unsigned int timeToLive)

void	forwardRREQ (const Ptr< Rreq > &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 (Packet *datagram)

virtual Result	datagramPreRoutingHook (Packet *datagram) 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 (Packet *datagram) override
	This is the second hook called by the network protocol before it sends a datagram to the lower layer. More...

virtual Result	datagramPostRoutingHook (Packet *datagram) override
	This is the last hook called by the network protocol before it sends a datagram to the lower layer. More...

virtual Result	datagramLocalInHook (Packet *datagram) override
	This is the last hook called by the network protocol before it sends a datagram to the upper layer. More...

virtual Result	datagramLocalOutHook (Packet *datagram) 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 (Packet *datagram)

L3Address	getSelfIPAddress () const

void	sendAODVPacket (const Ptr< AodvControlPacket > &packet, const L3Address &destAddr, unsigned int timeToLive, double delay)

void	processPacket (Packet *pk)

void	clearState ()

void	checkIpVersionAndPacketTypeCompatibility (AodvControlPacketType packetType)

virtual void	socketDataArrived (UdpSocket socket, Packet packet) override
	Notifies about data arrival, packet ownership is transferred to the callee. More...

virtual void	socketErrorArrived (UdpSocket socket, Indication indication) override
	Notifies about error indication arrival, indication ownership is transferred to the callee. More...

virtual void	socketClosed (UdpSocket *socket) override
	Notifies about socket closed, indication ownership is transferred to the callee. More...

virtual void	handleStartOperation (LifecycleOperation *operation) override

virtual void	handleStopOperation (LifecycleOperation *operation) override

virtual void	handleCrashOperation (LifecycleOperation *operation) override

Protected Member Functions inherited from inet::RoutingProtocolBase
virtual bool	isInitializeStage (int stage) const override

virtual bool	isModuleStartStage (int stage) const override

virtual bool	isModuleStopStage (int stage) const override

Protected Member Functions inherited from inet::OperationalMixin< cSimpleModule >
virtual int	numInitStages () const override

virtual void	refreshDisplay () const override

virtual void	handleMessage (cMessage *msg) override

virtual void	handleMessageWhenDown (cMessage *msg)

virtual bool	handleOperationStage (LifecycleOperation operation, IDoneCallback doneCallback) override
	Perform one stage of a lifecycle operation. More...

virtual State	getInitialOperationalState () const
	Returns initial operational state: OPERATING or NOT_OPERATING. More...

virtual void	handleActiveOperationTimeout (cMessage *message)

virtual bool	isUp () const
	utility functions More...

virtual bool	isDown () const

virtual void	setOperationalState (State newState)

virtual void	scheduleOperationTimeout (simtime_t timeout)

virtual void	setupActiveOperation (LifecycleOperation operation, IDoneCallback doneCallback, State)

virtual void	delayActiveOperationFinish (simtime_t timeout)

virtual void	startActiveOperationExtraTime (simtime_t delay=SIMTIME_ZERO)

virtual void	startActiveOperationExtraTimeOrFinish (simtime_t extraTime)

virtual void	finishActiveOperation ()

Protected Attributes
IL3AddressType *	addressType = nullptr

cModule *	host = nullptr

ModuleRefByPar< IRoutingTable >	routingTable

ModuleRefByPar< IInterfaceTable >	interfaceTable

ModuleRefByPar< INetfilter >	networkProtocol

UdpSocket	socket

bool	usingIpv6 = false

unsigned int	rerrRatelimit = 0

unsigned int	aodvUDPPort = 0

bool	askGratuitousRREP = false

bool	useHelloMessages = false

bool	destinationOnlyFlag = 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

std::multimap< L3Address, Packet * >	targetAddressToDelayedPackets

Protected Attributes inherited from inet::OperationalMixin< cSimpleModule >
State	operationalState

simtime_t	lastChange

Operation	activeOperation

cMessage *	activeOperationTimeout

cMessage *	activeOperationExtraTimer

Protected Attributes inherited from inet::NetfilterBase::HookBase
std::vector< INetfilter * >	netfilters

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

enum	Result { ACCEPT, DROP, QUEUE, STOLEN }

Protected Types inherited from inet::OperationalMixin< cSimpleModule >
enum	State

Constructor & Destructor Documentation

◆ Aodv()

inet::aodv::Aodv::Aodv ( )

241 {

242 }

◆ ~Aodv()

inet::aodv::Aodv::~Aodv ( )

virtual

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

Member Function Documentation

◆ cancelRouteDiscovery()

void inet::aodv::Aodv::cancelRouteDiscovery ( const L3Address & destAddr )

protected

 {
     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 Packet *>(it->second));
  
     targetAddressToDelayedPackets.erase(lt, ut);
  
     auto waitRREPIter = waitForRREPTimers.find(destAddr);
     ASSERT(waitRREPIter != waitForRREPTimers.end());
     cancelAndDelete(waitRREPIter->second);
     waitForRREPTimers.erase(waitRREPIter);
 }

Referenced by handleWaitForRREP().

◆ checkIpVersionAndPacketTypeCompatibility()

void inet::aodv::Aodv::checkIpVersionAndPacketTypeCompatibility ( AodvControlPacketType packetType )

protected

 {
     switch (packetType) {
         case RREQ:
         case RREP:
         case RERR:
         case RREPACK:
             if (usingIpv6)
                 throw cRuntimeError("AODV Control Packet arrived with non-IPv6 packet type %d, but AODV configured for IPv6 routing", packetType);
             break;
  
         case RREQ_IPv6:
         case RREP_IPv6:
         case RERR_IPv6:
         case RREPACK_IPv6:
             if (!usingIpv6)
                 throw cRuntimeError("AODV Control Packet arrived with IPv6 packet type %d, but AODV configured for non-IPv6 routing", packetType);
             break;
  
         default:
             throw cRuntimeError("AODV Control Packet arrived with undefined packet type: %d", packetType);
     }
 }

Referenced by processPacket().

◆ clearState()

void inet::aodv::Aodv::clearState ( )

protected

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

Referenced by handleCrashOperation(), handleStopOperation(), and ~Aodv().

◆ completeRouteDiscovery()

void inet::aodv::Aodv::completeRouteDiscovery ( const L3Address & target )

protected

 {
     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++) {
         Packet *datagram = it->second;
         const auto& networkHeader = getNetworkProtocolHeader(datagram);
         EV_DETAIL << "Sending queued datagram: source " << networkHeader->getSourceAddress() << ", destination " << networkHeader->getDestinationAddress() << endl;
         networkProtocol->reinjectQueuedDatagram(const_cast<const Packet *>(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);
 }

Referenced by handleRREP().

◆ createGratuitousRREP()

const Ptr< Rrep > inet::aodv::Aodv::createGratuitousRREP	(	const Ptr< Rreq > &	rreq,
		IRoute *	originatorRoute
	)

protected

 {
     ASSERT(originatorRoute != nullptr);
     auto grrep = makeShared<Rrep>(); // TODO "AODV-GRREP");
     grrep->setPacketType(usingIpv6 ? RREP_IPv6 : RREP);
     grrep->setChunkLength(usingIpv6 ? B(44) : B(20));
  
     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->setHopCount(originatorRoute->getMetric());
     grrep->setDestAddr(rreq->getOriginatorAddr());
     grrep->setDestSeqNum(rreq->getOriginatorSeqNum());
     grrep->setOriginatorAddr(rreq->getDestAddr());
     grrep->setLifeTime(routeData->getLifeTime());
     return grrep;
 }

Referenced by handleRREQ().

◆ createHelloMessage()

const Ptr< Rrep > inet::aodv::Aodv::createHelloMessage ( )

protected

 {
     // 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
  
     auto helloMessage = makeShared<Rrep>(); // TODO "AODV-HelloMsg");
     helloMessage->setPacketType(usingIpv6 ? RREP_IPv6 : RREP);
     helloMessage->setChunkLength(usingIpv6 ? B(44) : B(20));
  
     helloMessage->setDestAddr(getSelfIPAddress());
     helloMessage->setDestSeqNum(sequenceNum);
     helloMessage->setHopCount(0);
     helloMessage->setLifeTime(allowedHelloLoss * helloInterval);
  
     return helloMessage;
 }

Referenced by sendHelloMessagesIfNeeded().

◆ createRERR()

const Ptr< Rerr > inet::aodv::Aodv::createRERR ( const std::vector< UnreachableNode > & unreachableNodes )

protected

 {
     auto rerr = makeShared<Rerr>(); // TODO "AODV-RERR");
     rerr->setPacketType(usingIpv6 ? RERR_IPv6 : RERR);
  
     unsigned int destCount = unreachableNodes.size();
     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->setChunkLength(B(4 + destCount * (usingIpv6 ? (4 + 16) : (4 + 4))));
  
     return rerr;
 }

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

◆ createRoute()

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

protected

 {
     // create a new route
     IRoute *newRoute = routingTable->createRoute();
  
     // adding generic fields
     newRoute->setDestination(destAddr);
     newRoute->setNextHop(nextHop);
     newRoute->setPrefixLength(addressType->getMaxPrefixLength()); // TODO
     newRoute->setMetric(hopCount);
     NetworkInterface *ifEntry = interfaceTable->findInterfaceByName(par("interface")); // TODO IMPLEMENT: multiple interfaces
     if (ifEntry)
         newRoute->setInterface(ifEntry);
     newRoute->setSourceType(IRoute::AODV);
     newRoute->setSource(this);
  
     // 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.
  
     // adding protocol-specific fields
     AodvRouteData *newProtocolData = new AodvRouteData();
     newProtocolData->setIsActive(isActive);
     newProtocolData->setHasValidDestNum(hasValidDestNum);
     newProtocolData->setDestSeqNum(destSeqNum);
     newProtocolData->setLifeTime(lifeTime);
     newRoute->setProtocolData(newProtocolData);
  
     EV_DETAIL << "Adding new route " << newRoute << endl;
     routingTable->addRoute(newRoute);
  
     scheduleExpungeRoutes();
     return newRoute;
 }

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

◆ createRREP()

const Ptr< Rrep > inet::aodv::Aodv::createRREP	(	const Ptr< Rreq > &	rreq,
		IRoute *	destRoute,
		IRoute *	originatorRoute,
		const L3Address &	sourceAddr
	)

protected

 {
     auto rrep = makeShared<Rrep>(); // TODO "AODV-RREP");
     rrep->setPacketType(usingIpv6 ? RREP_IPv6 : RREP);
     rrep->setChunkLength(usingIpv6 ? B(44) : B(20));
  
     // 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());
  
     // 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
         // 6.6.1. Route Reply Generation by the 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.trunc(SIMTIME_MS));
     }
     else { // intermediate node
         // 6.6.2. Route Reply Generation by an 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()).trunc(SIMTIME_MS));
     }
  
     return rrep;
 }

Referenced by handleRREQ().

◆ createRREPACK()

const Ptr< RrepAck > inet::aodv::Aodv::createRREPACK ( )

protected

 {
     auto rrepAck = makeShared<RrepAck>(); // TODO "AODV-RREPACK");
     rrepAck->setPacketType(usingIpv6 ? RREPACK_IPv6 : RREPACK);
     return rrepAck;
 }

Referenced by handleRREP().

◆ createRREQ()

const Ptr< Rreq > inet::aodv::Aodv::createRREQ ( const L3Address & destAddr )

protected

 {
     auto rreqPacket = makeShared<Rreq>(); // TODO "AODV-RREQ");
     rreqPacket->setPacketType(usingIpv6 ? RREQ_IPv6 : RREQ);
     rreqPacket->setChunkLength(usingIpv6 ? B(48) : B(24));
  
     rreqPacket->setGratuitousRREPFlag(askGratuitousRREP);
     IRoute *lastKnownRoute = routingTable->findBestMatchingRoute(destAddr);
  
     // 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);
  
     // Destination only flag (D) indicates that only the
     // destination may respond to this RREQ.
     rreqPacket->setDestOnlyFlag(destinationOnlyFlag);
  
     // 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();
     return rreqPacket;
 }

Referenced by handleWaitForRREP(), and startRouteDiscovery().

◆ datagramForwardHook()

INetfilter::IHook::Result inet::aodv::Aodv::datagramForwardHook ( Packet * datagram )

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 auto& networkHeader = getNetworkProtocolHeader(datagram);
     const L3Address& destAddr = networkHeader->getDestinationAddress();
     const L3Address& sourceAddr = networkHeader->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;
 }

◆ datagramLocalInHook()

virtual Result inet::aodv::Aodv::datagramLocalInHook ( Packet * datagram )

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.

189 { return ACCEPT; }

◆ datagramLocalOutHook()

virtual Result inet::aodv::Aodv::datagramLocalOutHook ( Packet * datagram )

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 outputNetworkInterface is a nullptr. After this is done

Implements inet::INetfilter::IHook.

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

◆ datagramPostRoutingHook()

virtual Result inet::aodv::Aodv::datagramPostRoutingHook ( Packet * datagram )

inlineoverrideprotectedvirtual

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

Implements inet::INetfilter::IHook.

188 { return ACCEPT; }

◆ datagramPreRoutingHook()

virtual Result inet::aodv::Aodv::datagramPreRoutingHook ( Packet * datagram )

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 outputNetworkInterface is nullptr.

Implements inet::INetfilter::IHook.

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

◆ delayDatagram()

void inet::aodv::Aodv::delayDatagram ( Packet * datagram )

protected

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

Referenced by ensureRouteForDatagram().

◆ ensureRouteForDatagram()

INetfilter::IHook::Result inet::aodv::Aodv::ensureRouteForDatagram ( Packet * datagram )

protected

 {
     const auto& networkHeader = getNetworkProtocolHeader(datagram);
     const L3Address& destAddr = networkHeader->getDestinationAddress();
     const L3Address& sourceAddr = networkHeader->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 {
             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;
         }
     }
 }

◆ expungeRoutes()

void inet::aodv::Aodv::expungeRoutes ( )

protected

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

Referenced by handleMessageWhenUp().

◆ forwardRREP()

void inet::aodv::Aodv::forwardRREP	(	const Ptr< Rrep > &	rrep,
		const L3Address &	destAddr,
		unsigned int	timeToLive
	)

protected

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

Referenced by handleRREP().

◆ forwardRREQ()

void inet::aodv::Aodv::forwardRREQ	(	const Ptr< Rreq > &	rreq,
		unsigned int	timeToLive
	)

protected

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

Referenced by handleRREQ().

◆ getSelfIPAddress()

L3Address inet::aodv::Aodv::getSelfIPAddress ( ) const

protected

 {
     return routingTable->getRouterIdAsGeneric();
 }

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

◆ handleBlackListTimer()

void inet::aodv::Aodv::handleBlackListTimer ( )

protected

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

Referenced by handleMessageWhenUp().

◆ handleCrashOperation()

void inet::aodv::Aodv::handleCrashOperation ( LifecycleOperation * operation )

overrideprotectedvirtual

Implements inet::OperationalMixin< cSimpleModule >.

 {
     socket.destroy();
     clearState();
 }

◆ handleHelloMessage()

void inet::aodv::Aodv::handleHelloMessage ( const Ptr< Rrep > & helloMessage )

protected

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

Referenced by handleRREP().

◆ handleLinkBreakSendRERR()

void inet::aodv::Aodv::handleLinkBreakSendRERR ( const L3Address & unreachableAddr )

protected

 {
     // 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;
  
     auto rerr = createRERR(unreachableNodes);
     rerrCount++;
  
     // broadcast
     EV_INFO << "Broadcasting Route Error message with TTL=1" << endl;
     sendAODVPacket(rerr, addressType->getBroadcastAddress(), 1, *jitterPar);
 }

Referenced by receiveSignal().

◆ handleMessageWhenUp()

void inet::aodv::Aodv::handleMessageWhenUp ( cMessage * msg )

overrideprotectedvirtual

Implements inet::OperationalMixin< cSimpleModule >.

 {
     if (msg->isSelfMessage()) {
         if (auto waitForRrep = dynamic_cast<WaitForRrep *>(msg))
             handleWaitForRREP(waitForRrep);
         else if (msg == helloMsgTimer)
             sendHelloMessagesIfNeeded();
         else if (msg == expungeTimer)
             expungeRoutes();
         else if (msg == counterTimer) {
             rreqCount = rerrCount = 0;
             scheduleAfter(1, counterTimer);
         }
         else if (msg == rrepAckTimer)
             handleRREPACKTimer();
         else if (msg == blacklistTimer)
             handleBlackListTimer();
         else if (msg->getKind() == KIND_DELAYEDSEND) {
             auto timer = check_and_cast<PacketHolderMessage *>(msg);
             socket.send(timer->removeOwnedPacket());
             delete timer;
         }
         else
             throw cRuntimeError("Unknown self message");
     }
     else
         socket.processMessage(msg);
 }

◆ handleRERR()

void inet::aodv::Aodv::handleRERR	(	const Ptr< const Rerr > &	rerr,
		const L3Address &	sourceAddr
	)

protected

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

Referenced by processPacket().

◆ handleRREP()

void inet::aodv::Aodv::handleRREP	(	const Ptr< Rrep > &	rrep,
		const L3Address &	sourceAddr
	)

protected

 {
     // 6.7. Receiving and Forwarding Route Replies
  
     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);
         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->getDestSeqNum(), true, simTime() + activeRouteTimeout);
     }
     else
         updateRoutingTable(previousHopRoute, sourceAddr, 1, false, rrep->getDestSeqNum(), 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()) {
                     auto 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());
                 }
                 auto outgoingRREP = dynamicPtrCast<Rrep>(rrep->dupShared());
                 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());
         }
     }
 }

Referenced by processPacket().

◆ handleRREPACK()

void inet::aodv::Aodv::handleRREPACK	(	const Ptr< const RrepAck > &	rrepACK,
		const L3Address &	neighborAddr
	)

protected

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

Referenced by processPacket().

◆ handleRREPACKTimer()

void inet::aodv::Aodv::handleRREPACKTimer ( )

protected

 {
     // 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())
         scheduleAfter(blacklistTimeout, blacklistTimer);
 }

Referenced by handleMessageWhenUp().

◆ handleRREQ()

void inet::aodv::Aodv::handleRREQ	(	const Ptr< Rreq > &	rreq,
		const L3Address &	sourceAddr,
		unsigned int	timeToLive
	)

protected

 {
     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.
  
     if (containsKey(blacklist, sourceAddr)) {
         EV_INFO << "The sender node " << sourceAddr << " is in our blacklist. Ignoring the Route Request" << endl;
         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;
         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
         auto rrep = createRREP(rreq, destRoute, reverseRoute, sourceAddr);
  
         // send to the originator
         sendRREP(rrep, rreq->getOriginatorAddr(), 255);
  
         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;
             return;
         }
  
         // we respond to the RREQ, if the D (destination only) flag is not set
         if (!rreq->getDestOnlyFlag()) {
             // create RREP
             auto 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());
                 auto grrep = createGratuitousRREP(rreq, originatorRoute);
                 sendGRREP(grrep, rreq->getDestAddr(), 100);
             }
  
             return; // discard RREQ, in this case, we also do not forward it.
         }
         else
             EV_INFO << "The originator indicated that only the destination may respond to this RREQ (D flag is set). Forwarding ..." << endl;
     }
  
     // 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);
  
         auto outgoingRREQ = dynamicPtrCast<Rreq>(rreq->dupShared());
         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;
 }

Referenced by processPacket().

◆ handleStartOperation()

void inet::aodv::Aodv::handleStartOperation ( LifecycleOperation * operation )

overrideprotectedvirtual

Implements inet::OperationalMixin< cSimpleModule >.

 {
     rebootTime = simTime();
  
     socket.setOutputGate(gate("socketOut"));
     socket.setCallback(this);
     socket.bind(L3Address(), aodvUDPPort);
     socket.setBroadcast(true);
  
     // 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 (useHelloMessages)
         scheduleAfter(helloInterval - *periodicJitter, helloMsgTimer);
  
     scheduleAfter(1, counterTimer);
 }

◆ handleStopOperation()

void inet::aodv::Aodv::handleStopOperation ( LifecycleOperation * operation )

overrideprotectedvirtual

Implements inet::OperationalMixin< cSimpleModule >.

 {
     socket.close();
     clearState();
 }

◆ handleWaitForRREP()

void inet::aodv::Aodv::handleWaitForRREP ( WaitForRrep * rrepTimer )

protected

 {
     EV_INFO << "We didn't get any Route Reply within RREP timeout" << endl;
     L3Address destAddr = rrepTimer->getDestAddr();
  
     ASSERT(containsKey(addressToRreqRetries, destAddr));
     if (addressToRreqRetries[destAddr] == rreqRetries) {
         cancelRouteDiscovery(destAddr);
         EV_WARN << "Re-discovery attempts for node " << destAddr << " reached RREQ_RETRIES= " << rreqRetries << " limit. Stop sending RREQ." << endl;
         return;
     }
  
     auto 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);
 }

Referenced by handleMessageWhenUp().

◆ hasOngoingRouteDiscovery()

bool inet::aodv::Aodv::hasOngoingRouteDiscovery ( const L3Address & destAddr )

protected

 {
     return containsKey(waitForRREPTimers, target);
 }

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

◆ initialize()

void inet::aodv::Aodv::initialize ( int stage )

overrideprotectedvirtual

Reimplemented from inet::OperationalMixin< cSimpleModule >.

 {
     if (stage == INITSTAGE_ROUTING_PROTOCOLS)
         addressType = getSelfIPAddress().getAddressType(); // needed for handleStartOperation()
  
     RoutingProtocolBase::initialize(stage);
  
     if (stage == INITSTAGE_LOCAL) {
         lastBroadcastTime = SIMTIME_ZERO;
         rebootTime = SIMTIME_ZERO;
         rreqId = sequenceNum = 0;
         rreqCount = rerrCount = 0;
         host = getContainingNode(this);
         routingTable.reference(this, "routingTableModule", true);
         interfaceTable.reference(this, "interfaceTableModule", true);
         networkProtocol.reference(this, "networkProtocolModule", true);
  
         aodvUDPPort = par("udpPort");
         askGratuitousRREP = par("askGratuitousRREP");
         useHelloMessages = par("useHelloMessages");
         destinationOnlyFlag = par("destinationOnlyFlag");
         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");
         expungeTimer = new cMessage("ExpungeTimer");
         counterTimer = new cMessage("CounterTimer");
         rrepAckTimer = new cMessage("RrepAckTimer");
         blacklistTimer = new cMessage("BlackListTimer");
         if (useHelloMessages)
             helloMsgTimer = new cMessage("HelloMsgTimer");
     }
     else if (stage == INITSTAGE_ROUTING_PROTOCOLS) {
         networkProtocol->registerHook(0, this);
         host->subscribe(linkBrokenSignal, this);
         usingIpv6 = (routingTable->getRouterIdAsGeneric().getType() == L3Address::IPv6);
     }
 }

◆ numInitStages()

virtual int inet::aodv::Aodv::numInitStages ( ) const

inlineoverrideprotectedvirtual

133 { return NUM_INIT_STAGES; }

◆ processPacket()

void inet::aodv::Aodv::processPacket ( Packet * pk )

protected

 {
     L3Address sourceAddr = packet->getTag<L3AddressInd>()->getSrcAddress();
     // KLUDGE I added this -1 after TTL decrement has been moved in Ipv4
     unsigned int arrivalPacketTTL = packet->getTag<HopLimitInd>()->getHopLimit() - 1;
     const auto& aodvPacket = packet->popAtFront<AodvControlPacket>();
     // TODO aodvPacket->copyTags(*udpPacket);
  
     auto packetType = aodvPacket->getPacketType();
     switch (packetType) {
         case RREQ:
         case RREQ_IPv6:
             checkIpVersionAndPacketTypeCompatibility(packetType);
             handleRREQ(CHK(dynamicPtrCast<Rreq>(aodvPacket->dupShared())), sourceAddr, arrivalPacketTTL);
             delete packet;
             return;
  
         case RREP:
         case RREP_IPv6:
             checkIpVersionAndPacketTypeCompatibility(packetType);
             handleRREP(CHK(dynamicPtrCast<Rrep>(aodvPacket->dupShared())), sourceAddr);
             delete packet;
             return;
  
         case RERR:
         case RERR_IPv6:
             checkIpVersionAndPacketTypeCompatibility(packetType);
             handleRERR(CHK(dynamicPtrCast<const Rerr>(aodvPacket)), sourceAddr);
             delete packet;
             return;
  
         case RREPACK:
         case RREPACK_IPv6:
             checkIpVersionAndPacketTypeCompatibility(packetType);
             handleRREPACK(CHK(dynamicPtrCast<const RrepAck>(aodvPacket)), sourceAddr);
             delete packet;
             return;
  
         default:
             throw cRuntimeError("AODV Control Packet arrived with undefined packet type: %d", packetType);
     }
 }

Referenced by socketDataArrived().

◆ receiveSignal()

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

overrideprotectedvirtual

 {
     Enter_Method("%s", cComponent::getSignalName(signalID));
  
     if (signalID == linkBrokenSignal) {
         EV_DETAIL << "Received link break signal" << endl;
         Packet *datagram = check_and_cast<Packet *>(obj);
         const auto& networkHeader = findNetworkProtocolHeader(datagram);
         if (networkHeader != nullptr) {
             L3Address unreachableAddr = networkHeader->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());
             }
         }
     }
 }

◆ scheduleExpungeRoutes()

void inet::aodv::Aodv::scheduleExpungeRoutes ( )

protected

 {
     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) {
                 rescheduleAt(nextExpungeTime, expungeTimer);
             }
         }
     }
 }

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

◆ sendAODVPacket()

void inet::aodv::Aodv::sendAODVPacket	(	const Ptr< AodvControlPacket > &	packet,
		const L3Address &	destAddr,
		unsigned int	timeToLive,
		double	delay
	)

protected

 {
     ASSERT(timeToLive != 0);
  
     const char *className = aodvPacket->getClassName();
     Packet *packet = new Packet(!strncmp("inet::", className, 6) ? className + 6 : className);
     packet->insertAtBack(aodvPacket);
  
     int interfaceId = CHK(interfaceTable->findInterfaceByName(par("interface")))->getInterfaceId(); // TODO Implement: support for multiple interfaces
     packet->addTag<InterfaceReq>()->setInterfaceId(interfaceId);
     packet->addTag<HopLimitReq>()->setHopLimit(timeToLive);
     packet->addTag<L3AddressReq>()->setDestAddress(destAddr);
     packet->addTag<L4PortReq>()->setDestPort(aodvUDPPort);
  
     if (destAddr.isBroadcast())
         lastBroadcastTime = simTime();
  
     if (delay == 0)
         socket.send(packet);
     else {
         auto *timer = new PacketHolderMessage("aodv-send-jitter", KIND_DELAYEDSEND);
         timer->setOwnedPacket(packet);
         scheduleAfter(delay, timer);
     }
 }

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

◆ sendGRREP()

void inet::aodv::Aodv::sendGRREP	(	const Ptr< Rrep > &	grrep,
		const L3Address &	destAddr,
		unsigned int	timeToLive
	)

protected

 {
     EV_INFO << "Sending gratuitous Route Reply to " << destAddr << endl;
  
     IRoute *destRoute = routingTable->findBestMatchingRoute(destAddr);
     const L3Address& nextHop = destRoute->getNextHopAsGeneric();
  
     sendAODVPacket(grrep, nextHop, timeToLive, 0);
 }

Referenced by handleRREQ().

◆ sendHelloMessagesIfNeeded()

void inet::aodv::Aodv::sendHelloMessagesIfNeeded ( )

protected

 {
     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;
         auto helloMessage = createHelloMessage();
         sendAODVPacket(helloMessage, addressType->getBroadcastAddress(), 1, 0);
     }
  
     scheduleAfter(helloInterval - *periodicJitter, helloMsgTimer);
 }

Referenced by handleMessageWhenUp().

◆ sendRERRWhenNoRouteToForward()

void inet::aodv::Aodv::sendRERRWhenNoRouteToForward ( const L3Address & unreachableAddr )

protected

 {
     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);
     auto rerr = createRERR(unreachableNodes);
  
     rerrCount++;
     EV_INFO << "Broadcasting Route Error message with TTL=1" << endl;
     sendAODVPacket(rerr, addressType->getBroadcastAddress(), 1, *jitterPar); // TODO unicast if there exists a route to the source
 }

Referenced by datagramForwardHook().

◆ sendRREP()

void inet::aodv::Aodv::sendRREP	(	const Ptr< Rrep > &	rrep,
		const L3Address &	destAddr,
		unsigned int	timeToLive
	)

protected

 {
     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;
  
         rescheduleAfter(nextHopWait, rrepAckTimer);
     }
     sendAODVPacket(rrep, nextHop, timeToLive, 0);
 }

Referenced by handleRREQ().

◆ sendRREPACK()

void inet::aodv::Aodv::sendRREPACK	(	const Ptr< RrepAck > &	rrepACK,
		const L3Address &	destAddr
	)

protected

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

Referenced by handleRREP().

◆ sendRREQ()

void inet::aodv::Aodv::sendRREQ	(	const Ptr< Rreq > &	rreq,
		const L3Address &	destAddr,
		unsigned int	timeToLive
	)

protected

 {
     // 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;
         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);
     scheduleAfter(ringTraversalTime, rrepTimerMsg);
  
     EV_INFO << "Sending a Route Request with target " << rreq->getDestAddr() << " and TTL= " << timeToLive << endl;
     sendAODVPacket(rreq, destAddr, timeToLive, *jitterPar);
     rreqCount++;
 }

Referenced by handleWaitForRREP(), and startRouteDiscovery().

◆ socketClosed()

void inet::aodv::Aodv::socketClosed ( UdpSocket * socket )

overrideprotectedvirtual

Notifies about socket closed, indication ownership is transferred to the callee.

Implements inet::UdpSocket::ICallback.

 {
     if (operationalState == State::STOPPING_OPERATION)
         startActiveOperationExtraTimeOrFinish(par("stopOperationExtraTime"));
 }

◆ socketDataArrived()

void inet::aodv::Aodv::socketDataArrived	(	UdpSocket *	socket,
		Packet *	packet
	)

overrideprotectedvirtual

Notifies about data arrival, packet ownership is transferred to the callee.

Implements inet::UdpSocket::ICallback.

 {
     // process incoming packet
     processPacket(packet);
 }

◆ socketErrorArrived()

void inet::aodv::Aodv::socketErrorArrived	(	UdpSocket *	socket,
		Indication *	indication
	)

overrideprotectedvirtual

Notifies about error indication arrival, indication ownership is transferred to the callee.

Implements inet::UdpSocket::ICallback.

 {
     EV_WARN << "Ignoring UDP error report " << indication->getName() << endl;
     delete indication;
 }

◆ startRouteDiscovery()

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

protected

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

Referenced by ensureRouteForDatagram().

◆ updateRoutingTable()

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

protected

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

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

◆ updateValidRouteLifeTime()

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

protected

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

Referenced by datagramForwardHook(), and ensureRouteForDatagram().

Member Data Documentation

◆ activeRouteTimeout

simtime_t inet::aodv::Aodv::activeRouteTimeout

protected

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

◆ addressToRreqRetries

std::map<L3Address, unsigned int> inet::aodv::Aodv::addressToRreqRetries

protected

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

◆ addressType

IL3AddressType* inet::aodv::Aodv::addressType = nullptr

protected

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

◆ allowedHelloLoss

unsigned int inet::aodv::Aodv::allowedHelloLoss = 0

protected

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

◆ aodvUDPPort

unsigned int inet::aodv::Aodv::aodvUDPPort = 0

protected

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

◆ askGratuitousRREP

bool inet::aodv::Aodv::askGratuitousRREP = false

protected

Referenced by createRREQ(), and initialize().

◆ blacklist

std::map<L3Address, simtime_t> inet::aodv::Aodv::blacklist

protected

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

◆ blacklistTimeout

simtime_t inet::aodv::Aodv::blacklistTimeout

protected

Referenced by handleRREPACKTimer(), and initialize().

◆ blacklistTimer

cMessage* inet::aodv::Aodv::blacklistTimer = nullptr

protected

Referenced by clearState(), handleBlackListTimer(), handleMessageWhenUp(), handleRREPACKTimer(), initialize(), and ~Aodv().

◆ counterTimer

cMessage* inet::aodv::Aodv::counterTimer = nullptr

protected

Referenced by clearState(), handleMessageWhenUp(), handleStartOperation(), initialize(), and ~Aodv().

◆ deletePeriod

simtime_t inet::aodv::Aodv::deletePeriod

protected

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

◆ destinationOnlyFlag

bool inet::aodv::Aodv::destinationOnlyFlag = false

protected

Referenced by createRREQ(), and initialize().

◆ expungeTimer

cMessage* inet::aodv::Aodv::expungeTimer = nullptr

protected

Referenced by clearState(), handleMessageWhenUp(), initialize(), scheduleExpungeRoutes(), and ~Aodv().

◆ failedNextHop

L3Address inet::aodv::Aodv::failedNextHop

protected

Referenced by handleRREPACKTimer(), and sendRREP().

◆ helloInterval

simtime_t inet::aodv::Aodv::helloInterval

protected

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

◆ helloMsgTimer

cMessage* inet::aodv::Aodv::helloMsgTimer = nullptr

protected

Referenced by clearState(), handleMessageWhenUp(), handleStartOperation(), initialize(), sendHelloMessagesIfNeeded(), and ~Aodv().

◆ host

cModule* inet::aodv::Aodv::host = nullptr

protected

Referenced by initialize().

◆ interfaceTable

ModuleRefByPar<IInterfaceTable> inet::aodv::Aodv::interfaceTable

protected

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

◆ jitterPar

cPar* inet::aodv::Aodv::jitterPar = nullptr

protected

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

◆ lastBroadcastTime

simtime_t inet::aodv::Aodv::lastBroadcastTime

protected

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

◆ localAddTTL

unsigned int inet::aodv::Aodv::localAddTTL = 0

protected

Referenced by initialize().

◆ maxJitter

simtime_t inet::aodv::Aodv::maxJitter

protected

◆ myRouteTimeout

simtime_t inet::aodv::Aodv::myRouteTimeout

protected

Referenced by createRREP(), and initialize().

◆ netDiameter

unsigned int inet::aodv::Aodv::netDiameter = 0

protected

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

◆ netTraversalTime

simtime_t inet::aodv::Aodv::netTraversalTime

protected

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

◆ networkProtocol

ModuleRefByPar<INetfilter> inet::aodv::Aodv::networkProtocol

protected

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

◆ nextHopWait

simtime_t inet::aodv::Aodv::nextHopWait

protected

Referenced by initialize(), and sendRREP().

◆ nodeTraversalTime

simtime_t inet::aodv::Aodv::nodeTraversalTime

protected

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

◆ pathDiscoveryTime

simtime_t inet::aodv::Aodv::pathDiscoveryTime

protected

Referenced by handleRREQ(), and initialize().

◆ periodicJitter

cPar* inet::aodv::Aodv::periodicJitter = nullptr

protected

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

◆ rebootTime

simtime_t inet::aodv::Aodv::rebootTime

protected

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

◆ rerrCount

unsigned int inet::aodv::Aodv::rerrCount = 0

protected

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

◆ rerrRatelimit

unsigned int inet::aodv::Aodv::rerrRatelimit = 0

protected

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

◆ routingTable

ModuleRefByPar<IRoutingTable> inet::aodv::Aodv::routingTable

protected

◆ rrepAckTimer

cMessage* inet::aodv::Aodv::rrepAckTimer = nullptr

protected

Referenced by clearState(), handleMessageWhenUp(), handleRREPACK(), initialize(), sendRREP(), and ~Aodv().

◆ rreqCount

unsigned int inet::aodv::Aodv::rreqCount = 0

protected

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

◆ rreqId

unsigned int inet::aodv::Aodv::rreqId = 0

protected

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

◆ rreqRatelimit

unsigned int inet::aodv::Aodv::rreqRatelimit = 0

protected

Referenced by initialize(), and sendRREQ().

◆ rreqRetries

unsigned int inet::aodv::Aodv::rreqRetries = 0

protected

Referenced by handleWaitForRREP(), and initialize().

◆ rreqsArrivalTime

std::map<RreqIdentifier, simtime_t, RreqIdentifierCompare> inet::aodv::Aodv::rreqsArrivalTime

protected

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

◆ sequenceNum

unsigned int inet::aodv::Aodv::sequenceNum = 0

protected

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

◆ socket

UdpSocket inet::aodv::Aodv::socket

protected

Referenced by handleCrashOperation(), handleMessageWhenUp(), handleStartOperation(), handleStopOperation(), and sendAODVPacket().

◆ targetAddressToDelayedPackets

std::multimap<L3Address, Packet *> inet::aodv::Aodv::targetAddressToDelayedPackets

protected

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

◆ timeoutBuffer

unsigned int inet::aodv::Aodv::timeoutBuffer = 0

protected

Referenced by initialize(), and sendRREQ().

◆ ttlIncrement

unsigned int inet::aodv::Aodv::ttlIncrement = 0

protected

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

◆ ttlStart

unsigned int inet::aodv::Aodv::ttlStart = 0

protected

Referenced by initialize(), and sendRREQ().

◆ ttlThreshold

unsigned int inet::aodv::Aodv::ttlThreshold = 0

protected

Referenced by initialize(), and sendRREQ().

◆ useHelloMessages

bool inet::aodv::Aodv::useHelloMessages = false

protected

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

◆ usingIpv6

bool inet::aodv::Aodv::usingIpv6 = false

protected

Referenced by checkIpVersionAndPacketTypeCompatibility(), createGratuitousRREP(), createHelloMessage(), createRERR(), createRREP(), createRREPACK(), createRREQ(), and initialize().

◆ waitForRREPTimers

std::map<L3Address, WaitForRrep *> inet::aodv::Aodv::waitForRREPTimers

protected

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

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

Classes

Public Member Functions

Protected Member Functions

Protected Attributes

Additional Inherited Members

Constructor & Destructor Documentation

◆ Aodv()

◆ ~Aodv()

Member Function Documentation

◆ cancelRouteDiscovery()

◆ checkIpVersionAndPacketTypeCompatibility()

◆ clearState()

◆ completeRouteDiscovery()

◆ createGratuitousRREP()

◆ createHelloMessage()

◆ createRERR()

◆ createRoute()

◆ createRREP()

◆ createRREPACK()

◆ createRREQ()

◆ datagramForwardHook()

◆ datagramLocalInHook()

◆ datagramLocalOutHook()

◆ datagramPostRoutingHook()

◆ datagramPreRoutingHook()

◆ delayDatagram()

◆ ensureRouteForDatagram()

◆ expungeRoutes()

◆ forwardRREP()

◆ forwardRREQ()

◆ getSelfIPAddress()

◆ handleBlackListTimer()

◆ handleCrashOperation()

◆ handleHelloMessage()

◆ handleLinkBreakSendRERR()

◆ handleMessageWhenUp()

◆ handleRERR()

◆ handleRREP()

◆ handleRREPACK()

◆ handleRREPACKTimer()

◆ handleRREQ()

◆ handleStartOperation()

◆ handleStopOperation()

◆ handleWaitForRREP()

◆ hasOngoingRouteDiscovery()

◆ initialize()

◆ numInitStages()

◆ processPacket()

◆ receiveSignal()

◆ scheduleExpungeRoutes()

◆ sendAODVPacket()

◆ sendGRREP()

◆ sendHelloMessagesIfNeeded()

◆ sendRERRWhenNoRouteToForward()

◆ sendRREP()

◆ sendRREPACK()

◆ sendRREQ()

◆ socketClosed()

◆ socketDataArrived()

◆ socketErrorArrived()

◆ startRouteDiscovery()

◆ updateRoutingTable()

◆ updateValidRouteLifeTime()

Member Data Documentation

◆ activeRouteTimeout

◆ addressToRreqRetries

◆ addressType

◆ allowedHelloLoss

◆ aodvUDPPort

◆ askGratuitousRREP

◆ blacklist

◆ blacklistTimeout

◆ blacklistTimer

◆ counterTimer

◆ deletePeriod

◆ destinationOnlyFlag

◆ expungeTimer

◆ failedNextHop

◆ helloInterval

◆ helloMsgTimer