-
Notifications
You must be signed in to change notification settings - Fork 0
/
aodv-weep-routing-protocol.h
483 lines (457 loc) · 16 KB
/
aodv-weep-routing-protocol.h
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
#ifndef AODV_WEEP_ROUTINGPROTOCOL_H
#define AODV_WEEP_ROUTINGPROTOCOL_H
#include "aodv-weep-rtable.h"
#include "aodv-weep-sendbuffer.h"
#include "aodv-weep-packet.h"
#include "aodv-weep-neighbor.h"
#include "aodv-weep-dpd.h"
#include "ns3/ipv4-address.h"
#include "ns3/ipv4-route.h"
#include "packet-scheduler-base.h"
#include "ns3/node.h"
#include "ns3/random-variable-stream.h"
#include "ns3/output-stream-wrapper.h"
#include "ns3/ipv4-routing-protocol.h"
#include "ns3/ipv4-interface.h"
#include "ns3/ipv4-l3-protocol.h"
#include <map>
namespace ns3 {
class WifiMacQueueItem;
enum WifiMacDropReason : uint8_t; // opaque enum declaration
namespace weep {
/**
* \ingroup weep
*
* \brief AODV routing protocol
*/
class AodvWeepRoutingProtocol : public Ipv4RoutingProtocol
{
public:
/**
* \brief Get the type ID.
* \return the object TypeId
*/
static TypeId GetTypeId (void);
static const uint32_t AODV_WEEP_PORT;
/// constructor
AodvWeepRoutingProtocol ();
virtual ~AodvWeepRoutingProtocol ();
virtual void DoDispose ();
// Inherited from Ipv4RoutingProtocol
Ptr<Ipv4Route> RouteOutput (Ptr<Packet> p, const Ipv4Header &header, Ptr<NetDevice> oif, Socket::SocketErrno &sockerr);
bool RouteInput (Ptr<const Packet> p, const Ipv4Header &header, Ptr<const NetDevice> idev,
UnicastForwardCallback ucb, MulticastForwardCallback mcb,
LocalDeliverCallback lcb, ErrorCallback ecb);
virtual void NotifyInterfaceUp (uint32_t interface);
virtual void NotifyInterfaceDown (uint32_t interface);
virtual void NotifyAddAddress (uint32_t interface, Ipv4InterfaceAddress address);
virtual void NotifyRemoveAddress (uint32_t interface, Ipv4InterfaceAddress address);
virtual void SetIpv4 (Ptr<Ipv4> ipv4);
virtual void PrintRoutingTable (Ptr<OutputStreamWrapper> stream, Time::Unit unit = Time::S) const;
// Handle protocol parameters
/**
* Get maximum queue time
* \returns the maximum queue time
*/
Time GetMaxQueueTime () const
{
return m_maxQueueTime;
}
/**
* Set the maximum queue time
* \param t the maximum queue time
*/
void SetMaxQueueTime (Time t);
/**
* Get the maximum queue length
* \returns the maximum queue length
*/
uint32_t GetMaxQueueLen () const
{
return m_maxQueueLen;
}
/**
* Set the maximum queue length
* \param len the maximum queue length
*/
void SetMaxQueueLen (uint32_t len);
/**
* Get destination only flag
* \returns the destination only flag
*/
bool GetDestinationOnlyFlag () const
{
return m_destinationOnly;
}
/**
* Set destination only flag
* \param f the destination only flag
*/
void SetDestinationOnlyFlag (bool f)
{
m_destinationOnly = f;
}
/**
* Get pointer to scheduler
*
*/
Ptr<PacketScheduler> GetScheduler()
{
return m_packetScheduler;
}
/**
* Get gratuitous reply flag
* \returns the gratuitous reply flag
*/
bool GetGratuitousReplyFlag () const
{
return m_gratuitousReply;
}
/**
* Set gratuitous reply flag
* \param f the gratuitous reply flag
*/
void SetGratuitousReplyFlag (bool f)
{
m_gratuitousReply = f;
}
/**
* Set hello enable
* \param f the hello enable flag
*/
void SetHelloEnable (bool f)
{
m_enableHello = f;
}
/**
* Get hello enable flag
* \returns the enable hello flag
*/
bool GetHelloEnable () const
{
return m_enableHello;
}
/**
* Set broadcast enable flag
* \param f enable broadcast flag
*/
void SetBroadcastEnable (bool f)
{
m_enableBroadcast = f;
}
/**
* Get broadcast enable flag
* \returns the broadcast enable flag
*/
bool GetBroadcastEnable () const
{
return m_enableBroadcast;
}
/**
* Assign a fixed random variable stream number to the random variables
* used by this model. Return the number of streams (possibly zero) that
* have been assigned.
*
* \param stream first stream index to use
* \return the number of stream indices assigned by this model
*/
int64_t AssignStreams (int64_t stream);
/**
* Inject WEEP metadata tags into the packet
*
* \param packet the packet
*/
void InjectMetadata (Ptr<Packet> &packet, Ipv4Address destination, RoutingTableEntry rt = RoutingTableEntry());
/**
* Copy WEEP metadata from packet to packet
*
* \param fromPacket the packet to copy from
* \param toPacket the packet to copy to
*/
void CopyMetadata (Ptr<Packet> &fromPacket, Ptr<Packet> &toPacket);
/**
* Extract WEEP metadata tags from the packet
*
* \param packet the packet
*/
void ExtractMetadata (Ptr<Packet> &packet);
protected:
virtual void DoInitialize (void);
private:
/**
* Notify that an MPDU was dropped.
*
* \param reason the reason why the MPDU was dropped
* \param mpdu the dropped MPDU
*/
void NotifyTxError (WifiMacDropReason reason, Ptr<const WifiMacQueueItem> mpdu);
// Protocol parameters.
uint32_t m_rreqRetries; ///< Maximum number of retransmissions of RREQ with TTL = NetDiameter to discover a route
uint16_t m_ttlStart; ///< Initial TTL value for RREQ.
uint16_t m_ttlIncrement; ///< TTL increment for each attempt using the expanding ring search for RREQ dissemination.
uint16_t m_ttlThreshold; ///< Maximum TTL value for expanding ring search, TTL = NetDiameter is used beyond this value.
uint16_t m_timeoutBuffer; ///< Provide a buffer for the timeout.
uint16_t m_rreqRateLimit; ///< Maximum number of RREQ per second.
uint16_t m_rerrRateLimit; ///< Maximum number of REER per second.
Time m_activeRouteTimeout; ///< Period of time during which the route is considered to be valid.
uint32_t m_netDiameter; ///< Net diameter measures the maximum possible number of hops between two nodes in the network
/**
* NodeTraversalTime is a conservative estimate of the average one hop traversal time for packets
* and should include queuing delays, interrupt processing times and transfer times.
*/
Time m_nodeTraversalTime;
Time m_netTraversalTime; ///< Estimate of the average net traversal time.
Time m_pathDiscoveryTime; ///< Estimate of maximum time needed to find route in network.
Time m_myRouteTimeout; ///< Value of lifetime field in RREP generating by this node.
/**
* Every HelloInterval the node checks whether it has sent a broadcast within the last HelloInterval.
* If it has not, it MAY broadcast a Hello message
*/
Time m_helloInterval;
uint32_t m_allowedHelloLoss; ///< Number of hello messages which may be loss for valid link
/**
* DeletePeriod is intended to provide an upper bound on the time for which an upstream node A
* can have a neighbor B as an active next hop for destination D, while B has invalidated the route to D.
*/
Time m_deletePeriod;
Time m_nextHopWait; ///< Period of our waiting for the neighbour's RREP_ACK
Time m_blackListTimeout; ///< Time for which the node is put into the blacklist
uint32_t m_maxQueueLen; ///< The maximum number of packets that we allow a routing protocol to buffer.
Time m_maxQueueTime; ///< The maximum period of time that a routing protocol is allowed to buffer a packet for.
bool m_destinationOnly; ///< Indicates only the destination may respond to this RREQ.
bool m_gratuitousReply; ///< Indicates whether a gratuitous RREP should be unicast to the node originated route discovery.
bool m_enableHello; ///< Indicates whether a hello messages enable
bool m_enableBroadcast; ///< Indicates whether a a broadcast data packets forwarding enable
//\}
/// IP protocol
Ptr<Ipv4> m_ipv4;
/// Raw unicast socket per each IP interface, map socket -> iface address (IP + mask)
std::map< Ptr<Socket>, Ipv4InterfaceAddress > m_socketAddresses;
/// Raw subnet directed broadcast socket per each IP interface, map socket -> iface address (IP + mask)
std::map< Ptr<Socket>, Ipv4InterfaceAddress > m_socketSubnetBroadcastAddresses;
/// Loopback device used to defer RREQ until packet will be fully formed
Ptr<NetDevice> m_lo;
/// Routing table
RoutingTable m_routingTable;
/// A "drop-front" queue used by the routing layer to buffer packets to which it does not have a route.
AodvSendBuffer m_sendBuffer;
/// Broadcast ID
uint32_t m_requestId;
/// Request sequence number
uint32_t m_seqNo;
/// Handle duplicated RREQ
IdCache m_rreqIdCache;
/// Handle duplicated broadcast/multicast packets
DuplicatePacketDetection m_dpd;
/// Handle neighbors
Neighbors m_nb;
/// Number of RREQs used for RREQ rate control
uint16_t m_rreqCount;
/// Number of RERRs used for RERR rate control
uint16_t m_rerrCount;
private:
/// Start protocol operation
void Start ();
/**
* Queue packet and send route request
*
* \param p the packet to route
* \param header the IP header
* \param ucb the UnicastForwardCallback function
* \param ecb the ErrorCallback function
*/
void DeferredRouteOutput (Ptr<const Packet> p, const Ipv4Header & header, UnicastForwardCallback ucb, ErrorCallback ecb);
/**
* If route exists and is valid, forward packet.
*
* \param p the packet to route
* \param header the IP header
* \param ucb the UnicastForwardCallback function
* \param ecb the ErrorCallback function
* \returns true if forwarded
*/
bool Forwarding (Ptr<const Packet> p, const Ipv4Header & header, UnicastForwardCallback ucb, ErrorCallback ecb);
/**
* Repeated attempts by a source node at route discovery for a single destination
* use the expanding ring search technique.
* \param dst the destination IP address
*/
void ScheduleRreqRetry (Ipv4Address dst);
/**
* Set lifetime field in routing table entry to the maximum of existing lifetime and lt, if the entry exists
* \param addr - destination address
* \param lt - proposed time for lifetime field in routing table entry for destination with address addr.
* \return true if route to destination address addr exist
*/
bool UpdateRouteLifeTime (Ipv4Address addr, Time lt);
/**
* Update neighbor record.
* \param receiver is supposed to be my interface
* \param sender is supposed to be IP address of my neighbor.
*/
void UpdateRouteToNeighbor (Ipv4Address sender, Ipv4Address receiver);
/**
* Test whether the provided address is assigned to an interface on this node
* \param src the source IP address
* \returns true if the IP address is the node's IP address
*/
bool IsMyOwnAddress (Ipv4Address src);
/**
* Find unicast socket with local interface address iface
*
* \param iface the interface
* \returns the socket associated with the interface
*/
Ptr<Socket> FindSocketWithInterfaceAddress (Ipv4InterfaceAddress iface) const;
/**
* Find subnet directed broadcast socket with local interface address iface
*
* \param iface the interface
* \returns the socket associated with the interface
*/
Ptr<Socket> FindSubnetBroadcastSocketWithInterfaceAddress (Ipv4InterfaceAddress iface) const;
/**
* Process hello message
*
* \param rrepHeader RREP message header
* \param receiverIfaceAddr receiver interface IP address
*/
void ProcessHello (RrepHeader const & rrepHeader, Ipv4Address receiverIfaceAddr);
/**
* Create loopback route for given header
*
* \param header the IP header
* \param oif the output interface net device
* \returns the route
*/
Ptr<Ipv4Route> LoopbackRoute (const Ipv4Header & header, Ptr<NetDevice> oif) const;
///\name Receive control packets
//\{
/**
* Receive and process control packet
* \param socket input socket
*/
void RecvAodv (Ptr<Socket> socket);
/**
* Receive RREQ
* \param p packet
* \param receiver receiver address
* \param src sender address
*/
void RecvRequest (Ptr<Packet> p, Ipv4Address receiver, Ipv4Address src);
/**
* Receive RREP
* \param p packet
* \param my destination address
* \param src sender address
*/
void RecvReply (Ptr<Packet> p, Ipv4Address my, Ipv4Address src);
/**
* Receive RREP_ACK
* \param neighbor neighbor address
*/
void RecvReplyAck (Ipv4Address neighbor);
/**
* Receive RERR
* \param p packet
* \param src sender address
*/
/// Receive from node with address src
void RecvError (Ptr<Packet> p, Ipv4Address src);
//\}
///\name Send
//\{
/** Forward packet from route request queue
* \param dst destination address
* \param routingTableEntry routing table entry
*/
void SendPacketFromQueue (Ipv4Address dst, RoutingTableEntry routingTableEntry);
/// Send hello
void SendHello ();
/** Send RREQ
* \param dst destination address
*/
void SendRequest (Ipv4Address dst);
/** Send RREP
* \param rreqHeader route request header
* \param toOrigin routing table entry to originator
*/
void SendReply (RreqHeader const & rreqHeader, RoutingTableEntry const & toOrigin);
/** Send RREP by intermediate node
* \param p packet received by intermediate node
* \param toDst routing table entry to destination
* \param toOrigin routing table entry to originator
* \param gratRep indicates whether a gratuitous RREP should be unicast to destination
*/
void SendReplyByIntermediateNode (Ptr<Packet> p, RoutingTableEntry & toDst, RoutingTableEntry & toOrigin, bool gratRep);
/** Send RREP_ACK
* \param neighbor neighbor address
*/
void SendReplyAck (Ipv4Address neighbor);
/** Initiate RERR
* \param nextHop next hop address
*/
void SendRerrWhenBreaksLinkToNextHop (Ipv4Address nextHop);
/** Forward RERR
* \param packet packet
* \param precursors list of addresses of the visited nodes
*/
void SendRerrMessage (Ptr<Packet> packet, std::vector<Ipv4Address> precursors);
/**
* Send RERR message when no route to forward input packet. Unicast if there is reverse route to originating node, broadcast otherwise.
* \param dst - destination node IP address
* \param dstSeqNo - destination node sequence number
* \param origin - originating node IP address
*/
void SendRerrWhenNoRouteToForward (Ipv4Address dst, uint32_t dstSeqNo, Ipv4Address origin);
/// @}
/**
* Send packet to destination scoket
* \param socket - destination node socket
* \param packet - packet to send
* \param destination - destination node IP address
*/
void SendTo (Ptr<Socket> socket, Ptr<Packet> packet, Ipv4Address destination);
/// Hello timer
Timer m_htimer;
/// Schedule next send of hello message
void HelloTimerExpire ();
/// RREQ rate limit timer
Timer m_rreqRateLimitTimer;
/// Reset RREQ count and schedule RREQ rate limit timer with delay 1 sec.
void RreqRateLimitTimerExpire ();
/// RERR rate limit timer
Timer m_rerrRateLimitTimer;
/// Reset RERR count and schedule RERR rate limit timer with delay 1 sec.
void RerrRateLimitTimerExpire ();
/// Map IP address + RREQ timer.
std::map<Ipv4Address, Timer> m_addressReqTimer;
/**
* Handle route discovery process
* \param dst the destination IP address
*/
void RouteRequestTimerExpire (Ipv4Address dst);
/**
* Mark link to neighbor node as unidirectional for blacklistTimeout
*
* \param neighbor the IP address of the neightbor node
* \param blacklistTimeout the black list timeout time
*/
void AckTimerExpire (Ipv4Address neighbor, Time blacklistTimeout);
/// Scheduler
Ptr<PacketScheduler> m_packetScheduler;
/// Provides uniform random variables.
Ptr<UniformRandomVariable> m_uniformRandomVariable;
/// Keep track of the last bcast time
Time m_lastBcastTime;
/// Store maximum energies of destination nodes
std::map<int, double> m_maximumEnergies;
/// Store current residual energies of destination nodes
std::map<int, double> m_currentResidualEnergies;
/// Keep track of the last energy update time
std::map<int, Time> m_lastEnergyUpdateTimes;
};
} //namespace weep
} //namespace ns3
#endif /* AODV_WEEP_ROUTINGPROTOCOL_H */