A Discrete-Event Network Simulator
API
Loading...
Searching...
No Matches
hwmp-protocol.h
Go to the documentation of this file.
1/*
2 * Copyright (c) 2008,2009 IITP RAS
3 *
4 * SPDX-License-Identifier: GPL-2.0-only
5 *
6 * Authors: Kirill Andreev <andreev@iitp.ru>
7 */
8
9#ifndef HWMP_PROTOCOL_H
10#define HWMP_PROTOCOL_H
11
12#include "ns3/event-id.h"
13#include "ns3/mesh-l2-routing-protocol.h"
14#include "ns3/nstime.h"
15#include "ns3/traced-value.h"
16
17#include <map>
18#include <vector>
19
20namespace ns3
21{
22class MeshPointDevice;
23class Packet;
24class Mac48Address;
25class UniformRandomVariable;
26class RandomVariableStream;
27
28namespace dot11s
29{
30class HwmpProtocolMac;
31class HwmpRtable;
32class IePerr;
33class IePreq;
34class IePrep;
35
36/**
37 * Structure to encapsulate route change information
38 */
40{
41 std::string type; ///< type of change
42 Mac48Address destination; ///< route destination
43 Mac48Address retransmitter; ///< route source
44 uint32_t interface; ///< interface index
45 uint32_t metric; ///< metric of route
46 Time lifetime; ///< lifetime of route
47 uint32_t seqnum; ///< sequence number of route
48};
49
50/**
51 * \ingroup dot11s
52 *
53 * \brief Hybrid wireless mesh protocol -- a mesh routing protocol defined
54 * in IEEE 802.11-2012 standard.
55 */
57{
58 public:
59 /**
60 * \brief Get the type ID.
61 * \return the object TypeId
62 */
63 static TypeId GetTypeId();
64
66 ~HwmpProtocol() override;
67
68 // Delete copy constructor and assignment operator to avoid misuse
69 HwmpProtocol(const HwmpProtocol&) = delete;
71
72 void DoDispose() override;
73
74 /**
75 * \brief structure of unreachable destination - address and sequence number
76 */
78 {
79 Mac48Address destination; ///< destination address
80 uint32_t seqnum; ///< sequence number
81 };
82
83 /**
84 * Route request, inherited from MeshL2RoutingProtocol
85 *
86 * \param sourceIface the source interface
87 * \param source the source address
88 * \param destination the destination address
89 * \param packet the packet to route
90 * \param protocolType the protocol type
91 * \param routeReply the route reply
92 * \returns true if route exists
93 */
94 bool RequestRoute(uint32_t sourceIface,
95 const Mac48Address source,
96 const Mac48Address destination,
97 Ptr<const Packet> packet,
98 uint16_t protocolType,
99 RouteReplyCallback routeReply) override;
100 /**
101 * Clean HWMP packet tag from packet; only the packet parameter is used
102 *
103 * \param fromIface the from interface
104 * \param source the source address
105 * \param destination the destination address
106 * \param packet the packet to route
107 * \param protocolType the protocol type
108 * \returns true if successful
109 */
110 bool RemoveRoutingStuff(uint32_t fromIface,
111 const Mac48Address source,
112 const Mac48Address destination,
113 Ptr<Packet> packet,
114 uint16_t& protocolType) override;
115 /**
116 * \brief Install HWMP on given mesh point.
117 * \param mp the MeshPointDevice
118 * \returns true if successful
119 *
120 * Installing protocol causes installation of its interface MAC plugins.
121 *
122 * Also MP aggregates all installed protocols, HWMP protocol can be accessed
123 * via MeshPointDevice::GetObject<dot11s::HwmpProtocol>();
124 */
126 /**
127 * Peer link status function
128 * \param meshPointAddress The MAC address of the mesh point
129 * \param peerAddress The MAC address of the peer
130 * \param interface The interface number
131 * \param status The status of the peer link
132 */
133 void PeerLinkStatus(Mac48Address meshPointAddress,
134 Mac48Address peerAddress,
135 uint32_t interface,
136 bool status);
137 /**
138 * \brief This callback is used to obtain active neighbours on a given interface
139 * \param cb is a callback, which returns a list of addresses on given interface (uint32_t)
140 */
141 void SetNeighboursCallback(Callback<std::vector<Mac48Address>, uint32_t> cb);
142 /// \name Proactive PREQ mechanism:
143 ///@{
144 /// Set the current node as root
145 void SetRoot();
146 /// Unset the current node as root
147 void UnsetRoot();
148 ///@}
149
150 /// \brief Statistics:
151 ///@{
152 /**
153 * Print statistics counters
154 * \param os the output stream
155 */
156 void Report(std::ostream& os) const;
157 /// \brief Reset Statistics:
158 void ResetStats();
159 ///@}
160
161 /**
162 * Assign a fixed random variable stream number to the random variables
163 * used by this model. Return the number of streams (possibly zero) that
164 * have been assigned.
165 *
166 * \param stream first stream index to use
167 * \return the number of stream indices assigned by this model
168 */
169 int64_t AssignStreams(int64_t stream);
170
171 /**
172 * \brief Get pointer to HWMP routing table
173 * \return pointer to routing table
174 */
176
177 private:
178 /// allow HwmpProtocolMac class friend access
179 friend class HwmpProtocolMac;
180
181 void DoInitialize() override;
182
183 /**
184 * \brief Structure of path error: IePerr and list of receivers:
185 * interfaces and MAC address
186 */
188 {
189 std::vector<FailedDestination>
190 destinations; ///< destination list: Mac48Address and sequence number
191 std::vector<std::pair<uint32_t, Mac48Address>>
192 receivers; ///< list of PathError receivers (in case of unicast PERR)
193 };
194
195 /// Packet waiting its routing information
197 {
198 Ptr<Packet> pkt; ///< the packet
199 Mac48Address src; ///< src address
200 Mac48Address dst; ///< dst address
201 uint16_t protocol; ///< protocol number
202 uint32_t inInterface; ///< incoming device interface ID. (if packet has come from upper
203 ///< layers, this is Mesh point ID)
204 RouteReplyCallback reply; ///< how to reply
205
206 QueuedPacket();
207 };
208
209 typedef std::map<uint32_t, Ptr<HwmpProtocolMac>>
210 HwmpProtocolMacMap; ///< HwmpProtocolMacMap typedef
211 /**
212 * Like RequestRoute, but for unicast packets
213 *
214 * \param sourceIface the source interface
215 * \param source the source address
216 * \param destination the destination address
217 * \param packet the packet to route
218 * \param protocolType the protocol type
219 * \param routeReply the route reply callback
220 * \param ttl the TTL
221 * \returns true if forwarded
222 */
223 bool ForwardUnicast(uint32_t sourceIface,
224 const Mac48Address source,
225 const Mac48Address destination,
226 Ptr<Packet> packet,
227 uint16_t protocolType,
228 RouteReplyCallback routeReply,
229 uint32_t ttl);
230
231 /// \name Interaction with HWMP MAC plugin
232 ///@{
233 /**
234 * \brief Handler for receiving Path Request
235 *
236 * \param preq the IE preq
237 * \param from the from address
238 * \param interface the interface
239 * \param fromMp the 'from MP' address
240 * \param metric the metric
241 */
242 void ReceivePreq(IePreq preq,
243 Mac48Address from,
244 uint32_t interface,
245 Mac48Address fromMp,
246 uint32_t metric);
247 /**
248 * \brief Handler for receiving Path Reply
249 *
250 * \param prep the IE prep
251 * \param from the from address
252 * \param interface the interface
253 * \param fromMp the 'from MP' address
254 * \param metric the metric
255 */
256 void ReceivePrep(IePrep prep,
257 Mac48Address from,
258 uint32_t interface,
259 Mac48Address fromMp,
260 uint32_t metric);
261 /**
262 * \brief Handler for receiving Path Error
263 *
264 * \param destinations the list of failed destinations
265 * \param from the from address
266 * \param interface the interface
267 * \param fromMp the from MP address
268 */
269 void ReceivePerr(std::vector<FailedDestination> destinations,
270 Mac48Address from,
271 uint32_t interface,
272 Mac48Address fromMp);
273 /**
274 * \brief Send Path Reply
275 * \param src the source address
276 * \param dst the destination address
277 * \param retransmitter the retransmitter address
278 * \param initMetric the initial metric
279 * \param originatorDsn the originator DSN
280 * \param destinationSN the destination DSN
281 * \param lifetime the lifetime
282 * \param interface the interface
283 */
284 void SendPrep(Mac48Address src,
285 Mac48Address dst,
286 Mac48Address retransmitter,
287 uint32_t initMetric,
288 uint32_t originatorDsn,
289 uint32_t destinationSN,
290 uint32_t lifetime,
291 uint32_t interface);
292 /**
293 * \brief forms a path error information element when list of destination fails on a given
294 * interface \attention removes all entries from routing table!
295 *
296 * \param destinations vector of failed destinations
297 * \return PathError
298 */
299 PathError MakePathError(std::vector<FailedDestination> destinations);
300 /**
301 * \brief Forwards a received path error
302 * \param perr the path error
303 */
304 void ForwardPathError(PathError perr);
305 /**
306 * \brief Passes a self-generated PERR to interface-plugin
307 * \param perr the path error
308 */
309 void InitiatePathError(PathError perr);
310 /**
311 * Get PERR receivers
312 *
313 * \param failedDest
314 * \return list of addresses where a PERR should be sent to
315 */
316 std::vector<std::pair<uint32_t, Mac48Address>> GetPerrReceivers(
317 std::vector<FailedDestination> failedDest);
318
319 /**
320 * Get PREQ receivers
321 *
322 * \param interface
323 * \return list of addresses where a PREQ should be sent to
324 */
325 std::vector<Mac48Address> GetPreqReceivers(uint32_t interface);
326 /**
327 * Get broadcast receivers
328 *
329 * \param interface
330 * \return list of addresses where a broadcast should be retransmitted
331 */
332 std::vector<Mac48Address> GetBroadcastReceivers(uint32_t interface);
333 /**
334 * \brief MAC-plugin asks whether the frame can be dropped. Protocol automatically updates
335 * seqno.
336 *
337 * \return true if frame can be dropped
338 * \param seqno is the sequence number of source
339 * \param source is the source address
340 */
341 bool DropDataFrame(uint32_t seqno, Mac48Address source);
342 ///@}
343
344 /// Route discovery time:
346 /// RouteChangeTracedCallback typedef
348 /// Route change trace source
350
351 // /\name Methods related to Queue/Dequeue procedures
352 ///@{
353 /**
354 * Queue a packet
355 * \param packet the packet to be queued
356 * \return true on success
357 */
358 bool QueuePacket(QueuedPacket packet);
359 /**
360 * Dequeue the first packet for a given destination
361 * \param dst the destination
362 * \return the dequeued packet
363 */
365 /**
366 * Dequeue the first packet in the queue
367 * \return the dequeued packet
368 */
370 /**
371 * Signal the protocol that the reactive path toward a destination is now available
372 * \param dst the destination
373 */
375 /**
376 * Signal the protocol that the proactive path is now available
377 */
379 ///@}
380
381 /// \name Methods responsible for path discovery retry procedure:
382 ///@{
383 /**
384 * \brief checks when the last path discovery procedure was started for a given destination.
385 * \return true if should send PREQ
386 * \param dst is the destination address
387 *
388 * If the retry counter has not achieved the maximum level - preq should not be sent
389 */
391
392 /**
393 * \brief Generates PREQ retry when retry timeout has expired and route is still unresolved.
394 * \param dst is the destination address
395 * \param numOfRetry is the number of retries
396 *
397 * When PREQ retry has achieved the maximum level - retry mechanism should be canceled
398 */
399 void RetryPathDiscovery(Mac48Address dst, uint8_t numOfRetry);
400 /// Proactive Preq routines:
401 void SendProactivePreq();
402 ///@}
403
404 /// \return address of MeshPointDevice
406 /// \name Methods needed by HwmpMacLugin to access protocol parameters:
407 ///@{
408 /**
409 * Get do flag function
410 * \returns DO flag
411 */
412 bool GetDoFlag() const;
413 /**
414 * Get rf flag function
415 * \returns the RF flag
416 */
417 bool GetRfFlag() const;
418 /**
419 * Get PREQ minimum interval function
420 * \returns the PREQ
421 */
423 /**
424 * Get PERR minimum interval function
425 * \returns the PERR minimum interval
426 */
428 /**
429 * Get maximum TTL function
430 * \returns the maximum TTL
431 */
432 uint8_t GetMaxTtl() const;
433 /**
434 * Get next period function
435 * \returns the next period
436 */
438 /**
439 * Get next HWMP sequence no function
440 * \returns the next HWMP sequence number
441 */
443 /**
444 * Get active path lifetime function
445 * \returns the active path lifetime
446 */
448 /**
449 * Get unicast PERR threshold function
450 * \returns the unicast PERR threshold
451 */
452 uint8_t GetUnicastPerrThreshold() const;
453 ///@}
454
455 private:
456 /// Statistics structure
458 {
459 uint16_t txUnicast; ///< transmit unicast
460 uint16_t txBroadcast; ///< transmit broadcast
461 uint32_t txBytes; ///< transmit bytes
462 uint16_t droppedTtl; ///< dropped TTL
463 uint16_t totalQueued; ///< total queued
464 uint16_t totalDropped; ///< total dropped
465 uint16_t initiatedPreq; ///< initiated PREQ
466 uint16_t initiatedPrep; ///< initiated PREP
467 uint16_t initiatedPerr; ///< initiated PERR
468
469 /**
470 * Print function
471 * \param os The output stream
472 */
473 void Print(std::ostream& os) const;
474 /// constructor
475 Statistics();
476 };
477
478 Statistics m_stats; ///< statistics
479
482 uint32_t m_dataSeqno; ///< data sequence no
483 uint32_t m_hwmpSeqno; ///< HWMP sequence no
484 uint32_t m_preqId; ///< PREQ ID
485 /// \name Sequence number filters
486 ///@{
487 /// Data sequence number database
488 std::map<Mac48Address, uint32_t> m_lastDataSeqno;
489 /// keeps HWMP seqno (first in pair) and HWMP metric (second in pair) for each address
490 std::map<Mac48Address, std::pair<uint32_t, uint32_t>> m_hwmpSeqnoMetricDatabase;
491 ///@}
492
493 /// Routing table
495
496 /// PreqEvent structure
498 {
499 EventId preqTimeout; ///< PREQ timeout
500 Time whenScheduled; ///< scheduled time
501 };
502
503 std::map<Mac48Address, PreqEvent> m_preqTimeouts; ///< PREQ timeouts
504 EventId m_proactivePreqTimer; ///< proactive PREQ timer
505 /// Random start in Proactive PREQ propagation
507 /// Packet Queue
508 std::vector<QueuedPacket> m_rqueue;
509
510 /// \name HWMP-protocol parameters
511 /// These are all Attributes
512 ///@{
513 uint16_t m_maxQueueSize; //!< Maximum number of packets we can store when resolving route
514 uint8_t m_dot11MeshHWMPmaxPREQretries; //!< Maximum number of retries before we suppose the
515 //!< destination to be unreachable
516 Time m_dot11MeshHWMPnetDiameterTraversalTime; //!< Time we suppose the packet to go from one
517 //!< edge of the network to another
518 Time m_dot11MeshHWMPpreqMinInterval; //!< Minimal interval between to successive PREQs
519 Time m_dot11MeshHWMPperrMinInterval; //!< Minimal interval between to successive PREQs
520 Time m_dot11MeshHWMPactiveRootTimeout; //!< Lifetime of proactive routing information
521 Time m_dot11MeshHWMPactivePathTimeout; //!< Lifetime of reactive routing information
522 Time m_dot11MeshHWMPpathToRootInterval; //!< Interval between two successive proactive PREQs
523 Time m_dot11MeshHWMPrannInterval; //!< Lifetime of proactive routing information
524 bool m_isRoot; //!< True if the node is a root
525 uint8_t m_maxTtl; //!< Initial value of Time To Live field
526 uint8_t m_unicastPerrThreshold; //!< Maximum number of PERR receivers, when we send a PERR as a
527 //!< chain of unicasts
528 uint8_t m_unicastPreqThreshold; //!< Maximum number of PREQ receivers, when we send a PREQ as a
529 //!< chain of unicasts
530 uint8_t m_unicastDataThreshold; //!< Maximum number of broadcast receivers, when we send a
531 //!< broadcast as a chain of unicasts
532 bool m_doFlag; //!< Destination only HWMP flag
533 bool m_rfFlag; //!< Reply and forward flag
534 ///@}
535
536 /// Random variable for random start time
539};
540} // namespace dot11s
541} // namespace ns3
542#endif
Callback template class.
Definition callback.h:422
An identifier for simulation events.
Definition event-id.h:45
an EUI-48 address
Interface for L2 mesh routing protocol and mesh point communication.
Smart pointer class similar to boost::intrusive_ptr.
Simulation virtual time values and global simulation resolution.
Definition nstime.h:94
Forward calls to a chain of Callback.
a unique identifier for an interface.
Definition type-id.h:48
Hybrid wireless mesh protocol – a mesh routing protocol defined in IEEE 802.11-2012 standard.
std::vector< Mac48Address > GetPreqReceivers(uint32_t interface)
Get PREQ receivers.
void PeerLinkStatus(Mac48Address meshPointAddress, Mac48Address peerAddress, uint32_t interface, bool status)
Peer link status function.
QueuedPacket DequeueFirstPacket()
Dequeue the first packet in the queue.
Ptr< HwmpRtable > m_rtable
Routing table.
uint8_t m_unicastDataThreshold
Maximum number of broadcast receivers, when we send a broadcast as a chain of unicasts.
void ReceivePrep(IePrep prep, Mac48Address from, uint32_t interface, Mac48Address fromMp, uint32_t metric)
Handler for receiving Path Reply.
void Report(std::ostream &os) const
Statistics:
uint32_t GetNextHwmpSeqno()
Get next HWMP sequence no function.
TracedCallback< RouteChange > m_routeChangeTraceSource
Route change trace source.
PathError MakePathError(std::vector< FailedDestination > destinations)
forms a path error information element when list of destination fails on a given interface
Time m_dot11MeshHWMPrannInterval
Lifetime of proactive routing information.
Time GetPerrMinInterval()
Get PERR minimum interval function.
Ptr< HwmpRtable > GetRoutingTable() const
Get pointer to HWMP routing table.
uint8_t m_unicastPreqThreshold
Maximum number of PREQ receivers, when we send a PREQ as a chain of unicasts.
void UnsetRoot()
Unset the current node as root.
uint32_t m_dataSeqno
data sequence no
Time m_dot11MeshHWMPnetDiameterTraversalTime
Time we suppose the packet to go from one edge of the network to another.
Time m_dot11MeshHWMPactivePathTimeout
Lifetime of reactive routing information.
bool QueuePacket(QueuedPacket packet)
Queue a packet.
bool m_isRoot
True if the node is a root.
Statistics m_stats
statistics
uint32_t m_hwmpSeqno
HWMP sequence no.
uint8_t GetMaxTtl() const
Get maximum TTL function.
Time m_randomStart
Random start in Proactive PREQ propagation.
void SendPrep(Mac48Address src, Mac48Address dst, Mac48Address retransmitter, uint32_t initMetric, uint32_t originatorDsn, uint32_t destinationSN, uint32_t lifetime, uint32_t interface)
Send Path Reply.
int64_t AssignStreams(int64_t stream)
Assign a fixed random variable stream number to the random variables used by this model.
bool GetDoFlag() const
Get do flag function.
TracedCallback< Time > m_routeDiscoveryTimeCallback
Route discovery time:
static TypeId GetTypeId()
Get the type ID.
bool ShouldSendPreq(Mac48Address dst)
checks when the last path discovery procedure was started for a given destination.
void ReceivePerr(std::vector< FailedDestination > destinations, Mac48Address from, uint32_t interface, Mac48Address fromMp)
Handler for receiving Path Error.
std::map< Mac48Address, PreqEvent > m_preqTimeouts
PREQ timeouts.
Time m_dot11MeshHWMPperrMinInterval
Minimal interval between to successive PREQs.
bool m_rfFlag
Reply and forward flag.
bool RequestRoute(uint32_t sourceIface, const Mac48Address source, const Mac48Address destination, Ptr< const Packet > packet, uint16_t protocolType, RouteReplyCallback routeReply) override
Route request, inherited from MeshL2RoutingProtocol.
Time GetPreqMinInterval()
Get PREQ minimum interval function.
QueuedPacket DequeueFirstPacketByDst(Mac48Address dst)
Dequeue the first packet for a given destination.
HwmpProtocol(const HwmpProtocol &)=delete
EventId m_proactivePreqTimer
proactive PREQ timer
Ptr< UniformRandomVariable > m_coefficient
Random variable for random start time.
uint32_t GetNextPreqId()
Get next period function.
void InitiatePathError(PathError perr)
Passes a self-generated PERR to interface-plugin.
void SendProactivePreq()
Proactive Preq routines:
void ForwardPathError(PathError perr)
Forwards a received path error.
Time m_dot11MeshHWMPpathToRootInterval
Interval between two successive proactive PREQs.
void RetryPathDiscovery(Mac48Address dst, uint8_t numOfRetry)
Generates PREQ retry when retry timeout has expired and route is still unresolved.
bool RemoveRoutingStuff(uint32_t fromIface, const Mac48Address source, const Mac48Address destination, Ptr< Packet > packet, uint16_t &protocolType) override
Clean HWMP packet tag from packet; only the packet parameter is used.
bool m_doFlag
Destination only HWMP flag.
Mac48Address m_address
address
void DoInitialize() override
Initialize() implementation.
Time m_dot11MeshHWMPactiveRootTimeout
Lifetime of proactive routing information.
void DoDispose() override
Destructor implementation.
void ReceivePreq(IePreq preq, Mac48Address from, uint32_t interface, Mac48Address fromMp, uint32_t metric)
Handler for receiving Path Request.
Time m_dot11MeshHWMPpreqMinInterval
Minimal interval between to successive PREQs.
uint8_t GetUnicastPerrThreshold() const
Get unicast PERR threshold function.
void ReactivePathResolved(Mac48Address dst)
Signal the protocol that the reactive path toward a destination is now available.
std::vector< Mac48Address > GetBroadcastReceivers(uint32_t interface)
Get broadcast receivers.
bool GetRfFlag() const
Get rf flag function.
bool Install(Ptr< MeshPointDevice > mp)
Install HWMP on given mesh point.
uint32_t GetActivePathLifetime()
Get active path lifetime function.
bool ForwardUnicast(uint32_t sourceIface, const Mac48Address source, const Mac48Address destination, Ptr< Packet > packet, uint16_t protocolType, RouteReplyCallback routeReply, uint32_t ttl)
Like RequestRoute, but for unicast packets.
void ProactivePathResolved()
Signal the protocol that the proactive path is now available.
void SetNeighboursCallback(Callback< std::vector< Mac48Address >, uint32_t > cb)
This callback is used to obtain active neighbours on a given interface.
std::vector< QueuedPacket > m_rqueue
Packet Queue.
Callback< std::vector< Mac48Address >, uint32_t > m_neighboursCallback
neighbors callback
std::vector< std::pair< uint32_t, Mac48Address > > GetPerrReceivers(std::vector< FailedDestination > failedDest)
Get PERR receivers.
HwmpProtocol & operator=(const HwmpProtocol &)=delete
HwmpProtocolMacMap m_interfaces
interfaces
uint16_t m_maxQueueSize
Maximum number of packets we can store when resolving route.
uint8_t m_maxTtl
Initial value of Time To Live field.
std::map< Mac48Address, uint32_t > m_lastDataSeqno
void ResetStats()
Reset Statistics:
bool DropDataFrame(uint32_t seqno, Mac48Address source)
MAC-plugin asks whether the frame can be dropped.
uint8_t m_unicastPerrThreshold
Maximum number of PERR receivers, when we send a PERR as a chain of unicasts.
uint32_t m_preqId
PREQ ID.
uint8_t m_dot11MeshHWMPmaxPREQretries
Maximum number of retries before we suppose the destination to be unreachable.
std::map< Mac48Address, std::pair< uint32_t, uint32_t > > m_hwmpSeqnoMetricDatabase
keeps HWMP seqno (first in pair) and HWMP metric (second in pair) for each address
TracedCallback< RouteChange > RouteChangeTracedCallback
RouteChangeTracedCallback typedef.
std::map< uint32_t, Ptr< HwmpProtocolMac > > HwmpProtocolMacMap
HwmpProtocolMacMap typedef.
Interface MAC plugin for HWMP – 802.11s routing protocol.
See 7.3.2.97 of 802.11s draft 2.07.
See 7.3.2.96 of 802.11s draft 2.07.
Every class exported by the ns3 library is enclosed in the ns3 namespace.
structure of unreachable destination - address and sequence number
Mac48Address destination
destination address
Structure of path error: IePerr and list of receivers: interfaces and MAC address.
std::vector< FailedDestination > destinations
destination list: Mac48Address and sequence number
std::vector< std::pair< uint32_t, Mac48Address > > receivers
list of PathError receivers (in case of unicast PERR)
Packet waiting its routing information.
RouteReplyCallback reply
how to reply
uint32_t inInterface
incoming device interface ID.
void Print(std::ostream &os) const
Print function.
uint16_t txBroadcast
transmit broadcast
uint16_t txUnicast
transmit unicast
Structure to encapsulate route change information.
Time lifetime
lifetime of route
Mac48Address retransmitter
route source
uint32_t seqnum
sequence number of route
uint32_t metric
metric of route
Mac48Address destination
route destination
std::string type
type of change
uint32_t interface
interface index