A Discrete-Event Network Simulator
API
Loading...
Searching...
No Matches
aodv-routing-protocol.h
Go to the documentation of this file.
1/*
2 * Copyright (c) 2009 IITP RAS
3 *
4 * SPDX-License-Identifier: GPL-2.0-only
5 *
6 * Based on
7 * NS-2 AODV model developed by the CMU/MONARCH group and optimized and
8 * tuned by Samir Das and Mahesh Marina, University of Cincinnati;
9 *
10 * AODV-UU implementation by Erik Nordström of Uppsala University
11 * https://web.archive.org/web/20100527072022/http://core.it.uu.se/core/index.php/AODV-UU
12 *
13 * Authors: Elena Buchatskaia <borovkovaes@iitp.ru>
14 * Pavel Boyko <boyko@iitp.ru>
15 */
16#ifndef AODVROUTINGPROTOCOL_H
17#define AODVROUTINGPROTOCOL_H
18
19#include "aodv-dpd.h"
20#include "aodv-neighbor.h"
21#include "aodv-packet.h"
22#include "aodv-rqueue.h"
23#include "aodv-rtable.h"
24
25#include "ns3/ipv4-interface.h"
26#include "ns3/ipv4-l3-protocol.h"
27#include "ns3/ipv4-routing-protocol.h"
28#include "ns3/node.h"
29#include "ns3/output-stream-wrapper.h"
30#include "ns3/random-variable-stream.h"
31
32#include <map>
33
34namespace ns3
35{
36
37class WifiMpdu;
38enum WifiMacDropReason : uint8_t; // opaque enum declaration
39
40namespace aodv
41{
42/**
43 * \ingroup aodv
44 *
45 * \brief AODV routing protocol
46 */
48{
49 public:
50 /**
51 * \brief Get the type ID.
52 * \return the object TypeId
53 */
54 static TypeId GetTypeId();
55 static const uint32_t AODV_PORT;
56
57 /// constructor
59 ~RoutingProtocol() override;
60 void DoDispose() override;
61
62 // Inherited from Ipv4RoutingProtocol
64 const Ipv4Header& header,
66 Socket::SocketErrno& sockerr) override;
68 const Ipv4Header& header,
70 const UnicastForwardCallback& ucb,
71 const MulticastForwardCallback& mcb,
72 const LocalDeliverCallback& lcb,
73 const ErrorCallback& ecb) override;
74 void NotifyInterfaceUp(uint32_t interface) override;
75 void NotifyInterfaceDown(uint32_t interface) override;
76 void NotifyAddAddress(uint32_t interface, Ipv4InterfaceAddress address) override;
77 void NotifyRemoveAddress(uint32_t interface, Ipv4InterfaceAddress address) override;
78 void SetIpv4(Ptr<Ipv4> ipv4) override;
80 Time::Unit unit = Time::S) const override;
81
82 // Handle protocol parameters
83 /**
84 * Get maximum queue time
85 * \returns the maximum queue time
86 */
88 {
89 return m_maxQueueTime;
90 }
91
92 /**
93 * Set the maximum queue time
94 * \param t the maximum queue time
95 */
96 void SetMaxQueueTime(Time t);
97
98 /**
99 * Get the maximum queue length
100 * \returns the maximum queue length
101 */
103 {
104 return m_maxQueueLen;
105 }
106
107 /**
108 * Set the maximum queue length
109 * \param len the maximum queue length
110 */
111 void SetMaxQueueLen(uint32_t len);
112
113 /**
114 * Get destination only flag
115 * \returns the destination only flag
116 */
118 {
119 return m_destinationOnly;
120 }
121
122 /**
123 * Set destination only flag
124 * \param f the destination only flag
125 */
127 {
129 }
130
131 /**
132 * Get gratuitous reply flag
133 * \returns the gratuitous reply flag
134 */
136 {
137 return m_gratuitousReply;
138 }
139
140 /**
141 * Set gratuitous reply flag
142 * \param f the gratuitous reply flag
143 */
145 {
147 }
148
149 /**
150 * Set hello enable
151 * \param f the hello enable flag
152 */
153 void SetHelloEnable(bool f)
154 {
155 m_enableHello = f;
156 }
157
158 /**
159 * Get hello enable flag
160 * \returns the enable hello flag
161 */
162 bool GetHelloEnable() const
163 {
164 return m_enableHello;
165 }
166
167 /**
168 * Set broadcast enable flag
169 * \param f enable broadcast flag
170 */
172 {
174 }
175
176 /**
177 * Get broadcast enable flag
178 * \returns the broadcast enable flag
179 */
181 {
182 return m_enableBroadcast;
183 }
184
185 /**
186 * Assign a fixed random variable stream number to the random variables
187 * used by this model. Return the number of streams (possibly zero) that
188 * have been assigned.
189 *
190 * \param stream first stream index to use
191 * \return the number of stream indices assigned by this model
192 */
193 int64_t AssignStreams(int64_t stream);
194
195 protected:
196 void DoInitialize() override;
197
198 private:
199 /**
200 * Notify that an MPDU was dropped.
201 *
202 * \param reason the reason why the MPDU was dropped
203 * \param mpdu the dropped MPDU
204 */
206
207 // Protocol parameters.
208 uint32_t m_rreqRetries; ///< Maximum number of retransmissions of RREQ with TTL = NetDiameter to
209 ///< discover a route
210 uint16_t m_ttlStart; ///< Initial TTL value for RREQ.
211 uint16_t m_ttlIncrement; ///< TTL increment for each attempt using the expanding ring search for
212 ///< RREQ dissemination.
213 uint16_t m_ttlThreshold; ///< Maximum TTL value for expanding ring search, TTL = NetDiameter is
214 ///< used beyond this value.
215 uint16_t m_timeoutBuffer; ///< Provide a buffer for the timeout.
216 uint16_t m_rreqRateLimit; ///< Maximum number of RREQ per second.
217 uint16_t m_rerrRateLimit; ///< Maximum number of REER per second.
218 Time m_activeRouteTimeout; ///< Period of time during which the route is considered to be valid.
219 uint32_t m_netDiameter; ///< Net diameter measures the maximum possible number of hops between
220 ///< two nodes in the network
221 /**
222 * NodeTraversalTime is a conservative estimate of the average one hop traversal time for
223 * packets and should include queuing delays, interrupt processing times and transfer times.
224 */
226 Time m_netTraversalTime; ///< Estimate of the average net traversal time.
227 Time m_pathDiscoveryTime; ///< Estimate of maximum time needed to find route in network.
228 Time m_myRouteTimeout; ///< Value of lifetime field in RREP generating by this node.
229 /**
230 * Every HelloInterval the node checks whether it has sent a broadcast within the last
231 * HelloInterval. If it has not, it MAY broadcast a Hello message
232 */
234 uint32_t m_allowedHelloLoss; ///< Number of hello messages which may be loss for valid link
235 /**
236 * DeletePeriod is intended to provide an upper bound on the time for which an upstream node A
237 * can have a neighbor B as an active next hop for destination D, while B has invalidated the
238 * route to D.
239 */
241 Time m_nextHopWait; ///< Period of our waiting for the neighbour's RREP_ACK
242 Time m_blackListTimeout; ///< Time for which the node is put into the blacklist
243 uint32_t m_maxQueueLen; ///< The maximum number of packets that we allow a routing protocol to
244 ///< buffer.
245 Time m_maxQueueTime; ///< The maximum period of time that a routing protocol is allowed to
246 ///< buffer a packet for.
247 bool m_destinationOnly; ///< Indicates only the destination may respond to this RREQ.
248 bool m_gratuitousReply; ///< Indicates whether a gratuitous RREP should be unicast to the node
249 ///< originated route discovery.
250 bool m_enableHello; ///< Indicates whether a hello messages enable
251 bool m_enableBroadcast; ///< Indicates whether a a broadcast data packets forwarding enable
252
253 /// IP protocol
255 /// Raw unicast socket per each IP interface, map socket -> iface address (IP + mask)
257 /// Raw subnet directed broadcast socket per each IP interface, map socket -> iface address (IP
258 /// + mask)
260 /// Loopback device used to defer RREQ until packet will be fully formed
262
263 /// Routing table
265 /// A "drop-front" queue used by the routing layer to buffer packets to which it does not have a
266 /// route.
268 /// Broadcast ID
270 /// Request sequence number
272 /// Handle duplicated RREQ
274 /// Handle duplicated broadcast/multicast packets
276 /// Handle neighbors
278 /// Number of RREQs used for RREQ rate control
279 uint16_t m_rreqCount;
280 /// Number of RERRs used for RERR rate control
281 uint16_t m_rerrCount;
282
283 private:
284 /// Start protocol operation
285 void Start();
286 /**
287 * Queue packet and send route request
288 *
289 * \param p the packet to route
290 * \param header the IP header
291 * \param ucb the UnicastForwardCallback function
292 * \param ecb the ErrorCallback function
293 */
295 const Ipv4Header& header,
297 ErrorCallback ecb);
298 /**
299 * If route exists and is valid, forward packet.
300 *
301 * \param p the packet to route
302 * \param header the IP header
303 * \param ucb the UnicastForwardCallback function
304 * \param ecb the ErrorCallback function
305 * \returns true if forwarded
306 */
308 const Ipv4Header& header,
310 ErrorCallback ecb);
311 /**
312 * Repeated attempts by a source node at route discovery for a single destination
313 * use the expanding ring search technique.
314 * \param dst the destination IP address
315 */
317 /**
318 * Set lifetime field in routing table entry to the maximum of existing lifetime and lt, if the
319 * entry exists
320 * \param addr destination address
321 * \param lt proposed time for lifetime field in routing table entry for destination with
322 * address addr.
323 * \return true if route to destination address addr exist
324 */
325 bool UpdateRouteLifeTime(Ipv4Address addr, Time lt);
326 /**
327 * Update neighbor record.
328 * \param receiver is supposed to be my interface
329 * \param sender is supposed to be IP address of my neighbor.
330 */
331 void UpdateRouteToNeighbor(Ipv4Address sender, Ipv4Address receiver);
332 /**
333 * Test whether the provided address is assigned to an interface on this node
334 * \param src the source IP address
335 * \returns true if the IP address is the node's IP address
336 */
337 bool IsMyOwnAddress(Ipv4Address src);
338 /**
339 * Find unicast socket with local interface address iface
340 *
341 * \param iface the interface
342 * \returns the socket associated with the interface
343 */
345 /**
346 * Find subnet directed broadcast socket with local interface address iface
347 *
348 * \param iface the interface
349 * \returns the socket associated with the interface
350 */
352 /**
353 * Process hello message
354 *
355 * \param rrepHeader RREP message header
356 * \param receiverIfaceAddr receiver interface IP address
357 */
358 void ProcessHello(const RrepHeader& rrepHeader, Ipv4Address receiverIfaceAddr);
359 /**
360 * Create loopback route for given header
361 *
362 * \param header the IP header
363 * \param oif the output interface net device
364 * \returns the route
365 */
366 Ptr<Ipv4Route> LoopbackRoute(const Ipv4Header& header, Ptr<NetDevice> oif) const;
367
368 /**
369 * \name Receive control packets
370 * @{
371 */
372 /**
373 * Receive and process control packet
374 * \param socket input socket
375 */
376 void RecvAodv(Ptr<Socket> socket);
377 /**
378 * Receive RREQ
379 * \param p packet
380 * \param receiver receiver address
381 * \param src sender address
382 */
383 void RecvRequest(Ptr<Packet> p, Ipv4Address receiver, Ipv4Address src);
384 /**
385 * Receive RREP
386 * \param p packet
387 * \param my destination address
388 * \param src sender address
389 */
391 /**
392 * Receive RREP_ACK
393 * \param neighbor neighbor address
394 */
395 void RecvReplyAck(Ipv4Address neighbor);
396 /**
397 * Receive RERR
398 * \param p packet
399 * \param src sender address
400 */
401 /// Receive from node with address src
402 void RecvError(Ptr<Packet> p, Ipv4Address src);
403 /** @} */
404
405 /**
406 * \name Send
407 * @{
408 */
409 /** Forward packet from route request queue
410 * \param dst destination address
411 * \param route route to use
412 */
414 /// Send hello
415 void SendHello();
416 /** Send RREQ
417 * \param dst destination address
418 */
419 void SendRequest(Ipv4Address dst);
420 /** Send RREP
421 * \param rreqHeader route request header
422 * \param toOrigin routing table entry to originator
423 */
424 void SendReply(const RreqHeader& rreqHeader, const RoutingTableEntry& toOrigin);
425 /** Send RREP by intermediate node
426 * \param toDst routing table entry to destination
427 * \param toOrigin routing table entry to originator
428 * \param gratRep indicates whether a gratuitous RREP should be unicast to destination
429 */
431 RoutingTableEntry& toOrigin,
432 bool gratRep);
433 /** Send RREP_ACK
434 * \param neighbor neighbor address
435 */
436 void SendReplyAck(Ipv4Address neighbor);
437 /** Initiate RERR
438 * \param nextHop next hop address
439 */
441 /** Forward RERR
442 * \param packet packet
443 * \param precursors list of addresses of the visited nodes
444 */
445 void SendRerrMessage(Ptr<Packet> packet, std::vector<Ipv4Address> precursors);
446 /**
447 * Send RERR message when no route to forward input packet. Unicast if there is reverse route to
448 * originating node, broadcast otherwise.
449 * \param dst destination node IP address
450 * \param dstSeqNo destination node sequence number
451 * \param origin originating node IP address
452 */
454 /** @} */
455
456 /**
457 * Send packet to destination socket
458 * \param socket destination node socket
459 * \param packet packet to send
460 * \param destination destination node IP address
461 */
462 void SendTo(Ptr<Socket> socket, Ptr<Packet> packet, Ipv4Address destination);
463
464 /// Hello timer
466 /// Schedule next send of hello message
467 void HelloTimerExpire();
468 /// RREQ rate limit timer
470 /// Reset RREQ count and schedule RREQ rate limit timer with delay 1 sec.
472 /// RERR rate limit timer
474 /// Reset RERR count and schedule RERR rate limit timer with delay 1 sec.
476 /// Map IP address + RREQ timer.
477 std::map<Ipv4Address, Timer> m_addressReqTimer;
478 /**
479 * Handle route discovery process
480 * \param dst the destination IP address
481 */
483 /**
484 * Mark link to neighbor node as unidirectional for blacklistTimeout
485 *
486 * \param neighbor the IP address of the neighbor node
487 * \param blacklistTimeout the black list timeout time
488 */
489 void AckTimerExpire(Ipv4Address neighbor, Time blacklistTimeout);
490
491 /// Provides uniform random variables.
493 /// Keep track of the last bcast time
495};
496
497} // namespace aodv
498} // namespace ns3
499
500#endif /* AODVROUTINGPROTOCOL_H */
Ipv4 addresses are stored in host order in this class.
Packet header for IPv4.
Definition ipv4-header.h:23
a class to store IPv4 address information on an interface
Abstract base class for IPv4 routing protocols.
Smart pointer class similar to boost::intrusive_ptr.
SocketErrno
Enumeration of the possible errors returned by a socket.
Definition socket.h:73
Simulation virtual time values and global simulation resolution.
Definition nstime.h:94
Unit
The unit to use to interpret a number representing time.
Definition nstime.h:100
@ S
second
Definition nstime.h:105
A simple virtual Timer class.
Definition timer.h:67
a unique identifier for an interface.
Definition type-id.h:48
Helper class used to remember already seen packets and detect duplicates.
Definition aodv-dpd.h:34
Unique packets identification cache used for simple duplicate detection.
maintain list of active neighbors
AODV route request queue.
Ptr< Ipv4Route > LoopbackRoute(const Ipv4Header &header, Ptr< NetDevice > oif) const
Create loopback route for given header.
uint32_t m_requestId
Broadcast ID.
void RecvAodv(Ptr< Socket > socket)
Receive and process control packet.
void UpdateRouteToNeighbor(Ipv4Address sender, Ipv4Address receiver)
Update neighbor record.
Timer m_rerrRateLimitTimer
RERR rate limit timer.
Time m_lastBcastTime
Keep track of the last bcast time.
void RecvReply(Ptr< Packet > p, Ipv4Address my, Ipv4Address src)
Receive RREP.
bool m_enableBroadcast
Indicates whether a a broadcast data packets forwarding enable.
bool GetBroadcastEnable() const
Get broadcast enable flag.
bool UpdateRouteLifeTime(Ipv4Address addr, Time lt)
Set lifetime field in routing table entry to the maximum of existing lifetime and lt,...
void RerrRateLimitTimerExpire()
Reset RERR count and schedule RERR rate limit timer with delay 1 sec.
Time m_blackListTimeout
Time for which the node is put into the blacklist.
void RecvReplyAck(Ipv4Address neighbor)
Receive RREP_ACK.
std::map< Ptr< Socket >, Ipv4InterfaceAddress > m_socketSubnetBroadcastAddresses
Raw subnet directed broadcast socket per each IP interface, map socket -> iface address (IP.
Time m_maxQueueTime
The maximum period of time that a routing protocol is allowed to buffer a packet for.
Time m_activeRouteTimeout
Period of time during which the route is considered to be valid.
std::map< Ipv4Address, Timer > m_addressReqTimer
Map IP address + RREQ timer.
uint32_t GetMaxQueueLen() const
Get the maximum queue length.
void DeferredRouteOutput(Ptr< const Packet > p, const Ipv4Header &header, UnicastForwardCallback ucb, ErrorCallback ecb)
Queue packet and send route request.
void SendTo(Ptr< Socket > socket, Ptr< Packet > packet, Ipv4Address destination)
Send packet to destination socket.
DuplicatePacketDetection m_dpd
Handle duplicated broadcast/multicast packets.
Time m_netTraversalTime
Estimate of the average net traversal time.
void DoDispose() override
Destructor implementation.
void SendRequest(Ipv4Address dst)
Send RREQ.
Time m_pathDiscoveryTime
Estimate of maximum time needed to find route in network.
bool m_gratuitousReply
Indicates whether a gratuitous RREP should be unicast to the node originated route discovery.
uint16_t m_rerrCount
Number of RERRs used for RERR rate control.
void HelloTimerExpire()
Schedule next send of hello message.
void NotifyTxError(WifiMacDropReason reason, Ptr< const WifiMpdu > mpdu)
Notify that an MPDU was dropped.
RoutingTable m_routingTable
Routing table.
uint16_t m_rreqRateLimit
Maximum number of RREQ per second.
Ptr< NetDevice > m_lo
Loopback device used to defer RREQ until packet will be fully formed.
uint32_t m_netDiameter
Net diameter measures the maximum possible number of hops between two nodes in the network.
uint32_t m_maxQueueLen
The maximum number of packets that we allow a routing protocol to buffer.
uint16_t m_ttlThreshold
Maximum TTL value for expanding ring search, TTL = NetDiameter is used beyond this value.
Ptr< UniformRandomVariable > m_uniformRandomVariable
Provides uniform random variables.
void SetMaxQueueTime(Time t)
Set the maximum queue time.
uint16_t m_ttlIncrement
TTL increment for each attempt using the expanding ring search for RREQ dissemination.
Time m_myRouteTimeout
Value of lifetime field in RREP generating by this node.
uint16_t m_timeoutBuffer
Provide a buffer for the timeout.
void PrintRoutingTable(Ptr< OutputStreamWrapper > stream, Time::Unit unit=Time::S) const override
Print the Routing Table entries.
Ptr< Socket > FindSocketWithInterfaceAddress(Ipv4InterfaceAddress iface) const
Find unicast socket with local interface address iface.
void NotifyInterfaceDown(uint32_t interface) override
void SetBroadcastEnable(bool f)
Set broadcast enable flag.
void SendPacketFromQueue(Ipv4Address dst, Ptr< Ipv4Route > route)
Forward packet from route request queue.
uint32_t m_allowedHelloLoss
Number of hello messages which may be loss for valid link.
bool IsMyOwnAddress(Ipv4Address src)
Test whether the provided address is assigned to an interface on this node.
void SetMaxQueueLen(uint32_t len)
Set the maximum queue length.
void ScheduleRreqRetry(Ipv4Address dst)
Repeated attempts by a source node at route discovery for a single destination use the expanding ring...
void SendReplyByIntermediateNode(RoutingTableEntry &toDst, RoutingTableEntry &toOrigin, bool gratRep)
Send RREP by intermediate node.
std::map< Ptr< Socket >, Ipv4InterfaceAddress > m_socketAddresses
Raw unicast socket per each IP interface, map socket -> iface address (IP + mask)
void SetGratuitousReplyFlag(bool f)
Set gratuitous reply flag.
bool RouteInput(Ptr< const Packet > p, const Ipv4Header &header, Ptr< const NetDevice > idev, const UnicastForwardCallback &ucb, const MulticastForwardCallback &mcb, const LocalDeliverCallback &lcb, const ErrorCallback &ecb) override
Route an input packet (to be forwarded or locally delivered)
void Start()
Start protocol operation.
uint16_t m_rreqCount
Number of RREQs used for RREQ rate control.
IdCache m_rreqIdCache
Handle duplicated RREQ.
Time m_deletePeriod
DeletePeriod is intended to provide an upper bound on the time for which an upstream node A can have ...
void NotifyRemoveAddress(uint32_t interface, Ipv4InterfaceAddress address) override
void SendRerrWhenNoRouteToForward(Ipv4Address dst, uint32_t dstSeqNo, Ipv4Address origin)
Send RERR message when no route to forward input packet.
Time m_helloInterval
Every HelloInterval the node checks whether it has sent a broadcast within the last HelloInterval.
void AckTimerExpire(Ipv4Address neighbor, Time blacklistTimeout)
Mark link to neighbor node as unidirectional for blacklistTimeout.
void SetHelloEnable(bool f)
Set hello enable.
bool m_destinationOnly
Indicates only the destination may respond to this RREQ.
void SetIpv4(Ptr< Ipv4 > ipv4) override
static TypeId GetTypeId()
Get the type ID.
void SetDestinationOnlyFlag(bool f)
Set destination only flag.
bool GetDestinationOnlyFlag() const
Get destination only flag.
void SendRerrMessage(Ptr< Packet > packet, std::vector< Ipv4Address > precursors)
Forward RERR.
uint16_t m_ttlStart
Initial TTL value for RREQ.
uint32_t m_rreqRetries
Maximum number of retransmissions of RREQ with TTL = NetDiameter to discover a route.
uint32_t m_seqNo
Request sequence number.
bool m_enableHello
Indicates whether a hello messages enable.
Neighbors m_nb
Handle neighbors.
bool Forwarding(Ptr< const Packet > p, const Ipv4Header &header, UnicastForwardCallback ucb, ErrorCallback ecb)
If route exists and is valid, forward packet.
int64_t AssignStreams(int64_t stream)
Assign a fixed random variable stream number to the random variables used by this model.
static const uint32_t AODV_PORT
UDP Port for AODV control traffic.
Timer m_rreqRateLimitTimer
RREQ rate limit timer.
Time GetMaxQueueTime() const
Get maximum queue time.
void NotifyAddAddress(uint32_t interface, Ipv4InterfaceAddress address) override
Time m_nodeTraversalTime
NodeTraversalTime is a conservative estimate of the average one hop traversal time for packets and sh...
uint16_t m_rerrRateLimit
Maximum number of REER per second.
void RecvRequest(Ptr< Packet > p, Ipv4Address receiver, Ipv4Address src)
Receive RREQ.
Ptr< Socket > FindSubnetBroadcastSocketWithInterfaceAddress(Ipv4InterfaceAddress iface) const
Find subnet directed broadcast socket with local interface address iface.
void DoInitialize() override
Initialize() implementation.
bool GetHelloEnable() const
Get hello enable flag.
void SendRerrWhenBreaksLinkToNextHop(Ipv4Address nextHop)
Initiate RERR.
void RouteRequestTimerExpire(Ipv4Address dst)
Handle route discovery process.
void NotifyInterfaceUp(uint32_t interface) override
bool GetGratuitousReplyFlag() const
Get gratuitous reply flag.
void RecvError(Ptr< Packet > p, Ipv4Address src)
Receive RERR.
Ptr< Ipv4Route > RouteOutput(Ptr< Packet > p, const Ipv4Header &header, Ptr< NetDevice > oif, Socket::SocketErrno &sockerr) override
Query routing cache for an existing route, for an outbound packet.
Time m_nextHopWait
Period of our waiting for the neighbour's RREP_ACK.
void SendReplyAck(Ipv4Address neighbor)
Send RREP_ACK.
Ptr< Ipv4 > m_ipv4
IP protocol.
void RreqRateLimitTimerExpire()
Reset RREQ count and schedule RREQ rate limit timer with delay 1 sec.
void ProcessHello(const RrepHeader &rrepHeader, Ipv4Address receiverIfaceAddr)
Process hello message.
void SendReply(const RreqHeader &rreqHeader, const RoutingTableEntry &toOrigin)
Send RREP.
RequestQueue m_queue
A "drop-front" queue used by the routing layer to buffer packets to which it does not have a route.
Routing table entry.
Definition aodv-rtable.h:51
The Routing table used by AODV protocol.
Route Reply (RREP) Message Format.
Route Request (RREQ) Message Format.
WifiMacDropReason
The reason why an MPDU was dropped.
Definition wifi-mac.h:70
Every class exported by the ns3 library is enclosed in the ns3 namespace.