A Discrete-Event Network Simulator
API
Loading...
Searching...
No Matches
dsr-routing.h
Go to the documentation of this file.
1/*
2 * Copyright (c) 2011 Yufei Cheng
3 *
4 * SPDX-License-Identifier: GPL-2.0-only
5 *
6 * Author: Yufei Cheng <yfcheng@ittc.ku.edu>
7 *
8 * James P.G. Sterbenz <jpgs@ittc.ku.edu>, director
9 * ResiliNets Research Group https://resilinets.org/
10 * Information and Telecommunication Technology Center (ITTC)
11 * and Department of Electrical Engineering and Computer Science
12 * The University of Kansas Lawrence, KS USA.
13 *
14 * Work supported in part by NSF FIND (Future Internet Design) Program
15 * under grant CNS-0626918 (Postmodern Internet Architecture),
16 * NSF grant CNS-1050226 (Multilayer Network Resilience Analysis and Experimentation on GENI),
17 * US Department of Defense (DoD), and ITTC at The University of Kansas.
18 */
19
20#ifndef DSR_ROUTING_H
21#define DSR_ROUTING_H
22
23#include "dsr-errorbuff.h"
24#include "dsr-fs-header.h"
26#include "dsr-maintain-buff.h"
27#include "dsr-network-queue.h"
28#include "dsr-option-header.h"
29#include "dsr-passive-buff.h"
30#include "dsr-rcache.h"
31#include "dsr-rreq-table.h"
32#include "dsr-rsendbuff.h"
33
34#include "ns3/buffer.h"
35#include "ns3/callback.h"
36#include "ns3/event-garbage-collector.h"
37#include "ns3/icmpv4-l4-protocol.h"
38#include "ns3/ip-l4-protocol.h"
39#include "ns3/ipv4-address.h"
40#include "ns3/ipv4-header.h"
41#include "ns3/ipv4-interface.h"
42#include "ns3/ipv4-l3-protocol.h"
43#include "ns3/ipv4-route.h"
44#include "ns3/ipv4.h"
45#include "ns3/net-device.h"
46#include "ns3/node.h"
47#include "ns3/object.h"
48#include "ns3/output-stream-wrapper.h"
49#include "ns3/packet.h"
50#include "ns3/ptr.h"
51#include "ns3/random-variable-stream.h"
52#include "ns3/socket.h"
53#include "ns3/test.h"
54#include "ns3/timer.h"
55#include "ns3/traced-callback.h"
56#include "ns3/wifi-mac.h"
57
58#include <cassert>
59#include <list>
60#include <map>
61#include <stdint.h>
62#include <sys/types.h>
63#include <vector>
64
65namespace ns3
66{
67
68class Packet;
69class Node;
70class Ipv4;
71class Ipv4Address;
72class Ipv4Header;
73class Ipv4Interface;
74class Ipv4L3Protocol;
75class Time;
76
77namespace dsr
78{
79
80class DsrOptions;
81
82/**
83 * \class DsrRouting
84 * \brief Dsr Routing base
85 */
87{
88 public:
89 /**
90 * \brief Get the type identificator.
91 * \return type identificator
92 */
93 static TypeId GetTypeId();
94 /**
95 * \brief Define the dsr protocol number.
96 */
97 static const uint8_t PROT_NUMBER;
98 /**
99 * \brief Constructor.
100 */
101 DsrRouting();
102 /**
103 * \brief Destructor.
104 */
105 ~DsrRouting() override;
106 /**
107 * \brief Get the node.
108 * \return the node
109 */
110 Ptr<Node> GetNode() const;
111 /**
112 * \brief Set the node.
113 * \param node the node to set
114 */
115 void SetNode(Ptr<Node> node);
116 /**
117 * \brief Set the route cache.
118 * \param r the route cache to set
119 */
121 /**
122 * \brief Get the route cache.
123 * \return the route cache
124 */
126 /**
127 * \brief Set the node.
128 * \param r the request table to set
129 */
131 /**
132 * \brief Get the request table.
133 * \return the request table
134 */
136 /**
137 * \brief Set the node.
138 * \param r the passive buffer to set
139 */
141 /**
142 * \brief Get the passive buffer
143 * \return the passive buffer
144 */
146
147 /**
148 * \brief Checks if the link is cached in the route cache
149 * See also DsrRouteCache::IsLinkCache
150 *
151 * \return true if the link is cached
152 */
153 bool IsLinkCache();
154
155 /**
156 * \brief Extends the lifetime of a route cache entry.
157 * See also DsrRouteCache::UseExtends
158 *
159 * \param rt the route to extend
160 */
162
163 /**
164 * \brief Lookup route cache entry with destination address dst
165 * See also DsrRouteCache::LookupRoute
166 *
167 * \param id destination address
168 * \param rt entry with destination address id, if exists
169 * \return true on success
170 */
172
173 /**
174 * \brief dd route link to cache
175 * See also DsrRouteCache::AddRoute_Link
176 *
177 * \param nodelist vector of nodes
178 * \param source ip address of node to add
179 * \return true if the link is cached
180 */
182
183 /**
184 * \brief Add route cache entry if it doesn't yet exist in route cache
185 * See also DsrRouteCache::AddRoute
186 *
187 * \param rt route cache entry
188 * \return true on success
189 */
191
192 /**
193 * \brief Delete all the routes which includes the link from next hop address that has just been
194 * notified as unreachable. See also DsrRouteCache::DeleteAllRoutesIncludeLink
195 *
196 * \param errorSrc The error source address
197 * \param unreachNode The unreachable node
198 * \param node This node's ip address
199 */
201 Ipv4Address unreachNode,
202 Ipv4Address node);
203
204 /**
205 * \brief Update route cache entry if it has been recently used and successfully delivered the
206 * data packet. See also DsrRouteCache::UpdateRouteEntry
207 *
208 * \param dst destination address of the route
209 * \return true in success
210 */
212
213 /**
214 * Find the source request entry in the route request queue, return false if not found.
215 * See also DsrRreqTable::FindSourceEntry
216 *
217 * \param src the source address we just received the source request
218 * \param dst the destination address the request is targeted at
219 * \param id the identification number for this request
220 * \return true if found, false otherwise
221 */
222 bool FindSourceEntry(Ipv4Address src, Ipv4Address dst, uint16_t id);
223
224 /**
225 * \brief Get the netdevice from the context.
226 * \param context context
227 * \return the netdevice we are looking for
228 */
229 Ptr<NetDevice> GetNetDeviceFromContext(std::string context);
230 /**
231 * \brief Get the elements from the tracing context.
232 * \param context context
233 * \return the elements we are looking for
234 */
235 std::vector<std::string> GetElementsFromContext(std::string context);
236 /**
237 * \brief Get the node id from ip address.
238 * \param address IPv4 address
239 * \return the node id
240 */
241 uint16_t GetIDfromIP(Ipv4Address address);
242 /**
243 * \brief Get the ip address from id.
244 * \param id unique ID
245 * \return the ip address for the id
246 */
247 Ipv4Address GetIPfromID(uint16_t id);
248 /**
249 * \brief Get the Ip address from mac address.
250 * \param address Mac48Address
251 * \return the ip address
252 */
254 /**
255 * \brief Get the node with give ip address.
256 * \param ipv4Address IPv4 address
257 * \return the node associated with the ip address
258 */
260 /**
261 * \brief Print the route vector.
262 * \param vec the vector to print.
263 */
264 void PrintVector(std::vector<Ipv4Address>& vec);
265 /**
266 * \brief Get the next hop of the route.
267 * \param ipv4Address
268 * \param vec Route
269 * \return the next hop address of the route
270 */
271 Ipv4Address SearchNextHop(Ipv4Address ipv4Address, std::vector<Ipv4Address>& vec);
272 /**
273 * \brief Get the dsr protocol number.
274 * \return protocol number
275 */
276 int GetProtocolNumber() const override;
277 /**
278 * \brief The send buffer timer expire.
279 */
280 void SendBuffTimerExpire();
281 /**
282 * \brief Check the send buffer of packets with route when send buffer timer expire.
283 */
284 void CheckSendBuffer();
285 /**
286 * \brief When route vector corrupted, originate a new packet, normally not happening.
287 * \param packet to route
288 * \param source address
289 * \param destination address
290 * \param protocol number
291 */
292 void PacketNewRoute(Ptr<Packet> packet,
293 Ipv4Address source,
294 Ipv4Address destination,
295 uint8_t protocol);
296 /**
297 * \brief Set the route to use for data packets,
298 * used by the option headers when sending data/control packets
299 * \param nextHop next hop IPv4 address
300 * \param srcAddress IPv4 address of the source
301 * \return the route
302 */
303 Ptr<Ipv4Route> SetRoute(Ipv4Address nextHop, Ipv4Address srcAddress);
304 /**
305 * \brief Set the priority of the packet in network queue
306 * \param messageType Message type
307 * \return the priority value
308 */
310 /**
311 * \brief This function is responsible for sending error packets in case of break link to next
312 * hop
313 * \param unreachNode unreachable node
314 * \param destination address
315 * \param originalDst address
316 * \param salvage packet flag
317 * \param protocol number
318 */
319 void SendUnreachError(Ipv4Address unreachNode,
320 Ipv4Address destination,
321 Ipv4Address originalDst,
322 uint8_t salvage,
323 uint8_t protocol);
324
325 /**
326 * \brief This function is responsible for forwarding error packets along the route
327 * \param rerr unreachable header
328 * \param sourceRoute source routing header
329 * \param nextHop IP address of next hop
330 * \param protocol number
331 * \param route IP route
332 */
334 DsrOptionSRHeader& sourceRoute,
335 Ipv4Address nextHop,
336 uint8_t protocol,
337 Ptr<Ipv4Route> route);
338 /**
339 * \brief This function is called by higher layer protocol when sending packets
340 * \param packet to send
341 * \param source IP address
342 * \param destination IP address
343 * \param protocol number
344 * \param route IP route
345 */
346 void Send(Ptr<Packet> packet,
347 Ipv4Address source,
348 Ipv4Address destination,
349 uint8_t protocol,
350 Ptr<Ipv4Route> route);
351 /**
352 * \brief This function is called to add ack request header for network acknowledgement
353 * \param packet for ack req
354 * \param nextHop IP address of the next hop
355 * \return ack ID
356 */
357 uint16_t AddAckReqHeader(Ptr<Packet>& packet, Ipv4Address nextHop);
358 /**
359 * \brief This function is called by when really sending out the packet
360 * \param packet to send
361 * \param source IP address
362 * \param nextHop IP address
363 * \param protocol number
364 */
365 void SendPacket(Ptr<Packet> packet, Ipv4Address source, Ipv4Address nextHop, uint8_t protocol);
366 /**
367 * \brief This function is called to schedule sending packets from the network queue
368 * \param priority for sending
369 */
370 void Scheduler(uint32_t priority);
371 /**
372 * \brief This function is called to schedule sending packets from the network queue by priority
373 * \param priority schedule
374 * \param continueWithFirst use all priorities
375 */
376 void PriorityScheduler(uint32_t priority, bool continueWithFirst);
377 /**
378 * \brief This function is called to increase the retransmission timer for data packet in the
379 * network queue
380 */
382 /**
383 * \brief This function is called to send packets down stack
384 * \param newEntry queue entry
385 * \return true if success
386 */
387 bool SendRealDown(DsrNetworkQueueEntry& newEntry);
388 /**
389 * \brief This function is responsible for sending out data packets when have route, if no route
390 * found, it will cache the packet and send out route requests
391 * \param sourceRoute source route
392 * \param nextHop next hop IP address
393 * \param protocol number
394 */
395 void SendPacketFromBuffer(const DsrOptionSRHeader& sourceRoute,
396 Ipv4Address nextHop,
397 uint8_t protocol);
398 /**
399 * \brief Find the same passive entry
400 * \param packet to process
401 * \param source IP address
402 * \param destination IP address
403 * \param segsLeft segments left
404 * \param fragmentOffset
405 * \param identification
406 * \param saveEntry
407 * \return true if passive buffer entry
408 */
409 bool PassiveEntryCheck(Ptr<Packet> packet,
410 Ipv4Address source,
411 Ipv4Address destination,
412 uint8_t segsLeft,
413 uint16_t fragmentOffset,
414 uint16_t identification,
415 bool saveEntry);
416
417 /**
418 * \brief Cancel all the packet timers
419 * \param mb maintain buffer entry
420 */
422 /**
423 * \brief Cancel the passive timer
424 * \param packet to process
425 * \param source IP address
426 * \param destination IP address
427 * \param segsLeft segments left
428 * \return
429 */
431 Ipv4Address source,
432 Ipv4Address destination,
433 uint8_t segsLeft);
434 /**
435 * \brief Call the cancel packet retransmission timer function
436 * \param ackId acknowledge ID
437 * \param ipv4Header header
438 * \param realSrc source IP address
439 * \param realDst destination IP address
440 */
441 void CallCancelPacketTimer(uint16_t ackId,
442 const Ipv4Header& ipv4Header,
443 Ipv4Address realSrc,
444 Ipv4Address realDst);
445 /**
446 * \brief Cancel the network packet retransmission timer for a specific maintenance entry
447 * \param mb maintain buffer entry
448 */
450 /**
451 * \brief Cancel the passive packet retransmission timer for a specific maintenance entry
452 * \param mb maintain buffer entry
453 */
455 /**
456 * \brief Cancel the link packet retransmission timer for a specific maintenance entry
457 * \param mb maintain buffer entry
458 */
460 /**
461 * \brief Cancel the packet retransmission timer for a all maintenance entries with nextHop
462 * address
463 * \param nextHop next hop IP address
464 * \param protocol number
465 */
466 void CancelPacketTimerNextHop(Ipv4Address nextHop, uint8_t protocol);
467 /**
468 * \brief Salvage the packet which has been transmitted for 3 times
469 * \param packet to process
470 * \param source IP address
471 * \param dst destination IP address
472 * \param protocol number
473 */
475 Ipv4Address source,
476 Ipv4Address dst,
477 uint8_t protocol);
478 /**
479 * \brief Schedule the packet retransmission based on link-layer acknowledgment
480 * \param mb maintenance buffer entry
481 * \param protocol the protocol number
482 */
483 void ScheduleLinkPacketRetry(DsrMaintainBuffEntry& mb, uint8_t protocol);
484 /**
485 * \brief Schedule the packet retransmission based on passive acknowledgment
486 * \param mb maintenance buffer entry
487 * \param protocol the protocol number
488 */
489 void SchedulePassivePacketRetry(DsrMaintainBuffEntry& mb, uint8_t protocol);
490 /**
491 * \brief Schedule the packet retransmission based on network layer acknowledgment
492 * \param mb maintenance buffer entry
493 * \param isFirst see if this is the first packet retry or not
494 * \param protocol the protocol number
495 */
496 void ScheduleNetworkPacketRetry(DsrMaintainBuffEntry& mb, bool isFirst, uint8_t protocol);
497 /**
498 * \brief This function deals with packet retransmission timer expire using link acknowledgment
499 * \param mb maintenance buffer entry
500 * \param protocol the protocol number
501 */
502 void LinkScheduleTimerExpire(DsrMaintainBuffEntry& mb, uint8_t protocol);
503 /**
504 * \brief This function deals with packet retransmission timer expire using network
505 * acknowledgment
506 * \param mb maintenance buffer entry
507 * \param protocol the protocol number
508 */
509 void NetworkScheduleTimerExpire(DsrMaintainBuffEntry& mb, uint8_t protocol);
510 /**
511 * \brief This function deals with packet retransmission timer expire using passive
512 * acknowledgment
513 * \param mb maintenance buffer entry
514 * \param protocol the protocol number
515 */
516 void PassiveScheduleTimerExpire(DsrMaintainBuffEntry& mb, uint8_t protocol);
517 /**
518 * \brief Forward the packet using the route saved in the source route option header
519 * \param packet The packet
520 * \param sourceRoute Source route saved in option header
521 * \param ipv4Header IPv4 Header
522 * \param source source address
523 * \param destination destination address
524 * \param targetAddress target address
525 * \param protocol protocol number
526 * \param route route
527 */
529 DsrOptionSRHeader& sourceRoute,
530 const Ipv4Header& ipv4Header,
531 Ipv4Address source,
532 Ipv4Address destination,
533 Ipv4Address targetAddress,
534 uint8_t protocol,
535 Ptr<Ipv4Route> route);
536 /**
537 * \brief Broadcast the route request packet in subnet
538 * \param source source address
539 * \param destination destination address
540 * \param protocol protocol number
541 */
542 void SendInitialRequest(Ipv4Address source, Ipv4Address destination, uint8_t protocol);
543 /**
544 * \brief Send the error request packet
545 * \param rerr the route error header
546 * \param protocol the protocol number
547 */
548 void SendErrorRequest(DsrOptionRerrUnreachHeader& rerr, uint8_t protocol);
549 /**
550 * \brief Forward the route request if the node is not the destination
551 * \param packet the original packet
552 * \param source address
553 */
554 void SendRequest(Ptr<Packet> packet, Ipv4Address source);
555 /**
556 * \brief Schedule the intermediate route request
557 * \param packet the original packet
558 */
560 /**
561 * \brief Send the gratuitous reply
562 * \param replyTo The destination address to send the reply to
563 * \param replyFrom The source address sending the reply
564 * \param nodeList Route
565 * \param protocol the protocol number
566 */
567 void SendGratuitousReply(Ipv4Address replyTo,
568 Ipv4Address replyFrom,
569 std::vector<Ipv4Address>& nodeList,
570 uint8_t protocol);
571 /**
572 * Send the route reply back to the request originator with the cumulated route
573 *
574 * \param packet the original packet
575 * \param source IPv4 address of the source (i.e. request originator)
576 * \param nextHop IPv4 address of the next hop
577 * \param route Route
578 */
579 void SendReply(Ptr<Packet> packet,
580 Ipv4Address source,
581 Ipv4Address nextHop,
582 Ptr<Ipv4Route> route);
583 /**
584 * this is a generating the initial route reply from the destination address, a random delay
585 * time [0, m_broadcastJitter] is used before unicasting back the route reply packet
586 *
587 * \param packet the original packet
588 * \param source IPv4 address of the source (i.e. request originator)
589 * \param nextHop IPv4 address of the next hop
590 * \param route Route
591 */
593 Ipv4Address source,
594 Ipv4Address nextHop,
595 Ptr<Ipv4Route> route);
596 /**
597 * Schedule the cached reply to a random start time to avoid possible route reply storm
598 *
599 * \param packet the original packet
600 * \param source IPv4 address of the source (i.e. request originator)
601 * \param destination IPv4 address of the destination
602 * \param route Route
603 * \param hops number of hops
604 */
606 Ipv4Address source,
607 Ipv4Address destination,
608 Ptr<Ipv4Route> route,
609 double hops);
610 /**
611 * Send network layer acknowledgment back to the earlier hop to notify the receipt of data
612 * packet
613 *
614 * \param ackId ACK ID
615 * \param destination IPv4 address of the immediate ACK receiver
616 * \param realSrc IPv4 address of the real source
617 * \param realDst IPv4 address of the real destination
618 * \param protocol the protocol number
619 * \param route Route
620 */
621 void SendAck(uint16_t ackId,
622 Ipv4Address destination,
623 Ipv4Address realSrc,
624 Ipv4Address realDst,
625 uint8_t protocol,
626 Ptr<Ipv4Route> route);
627 /**
628 * \param p packet to forward up
629 * \param header IPv4 Header information
630 * \param incomingInterface the Ipv4Interface on which the packet arrived
631 * \return receive status
632 *
633 * Called from lower-level layers to send the packet up
634 * in the stack.
635 */
637 const Ipv4Header& header,
638 Ptr<Ipv4Interface> incomingInterface) override;
639
640 /**
641 * \param p packet to forward up
642 * \param header IPv6 Header information
643 * \param incomingInterface the Ipv6Interface on which the packet arrived
644 * \return receive status
645 *
646 * Called from lower-level layers to send the packet up
647 * in the stack. Not implemented (IPv6).
648 */
650 const Ipv6Header& header,
651 Ptr<Ipv6Interface> incomingInterface) override;
652
653 void SetDownTarget(IpL4Protocol::DownTargetCallback callback) override;
657 /**
658 * \brief Process method
659 * Called from Ipv4L3Protocol::Receive.
660 *
661 * \param packet the packet
662 * \param ipv4Header IPv4 header of the packet
663 * \param dst destination address of the packet received (i.e. us)
664 * \param nextHeader the next header
665 * \param protocol the protocol number
666 * \param isDropped if the packet must be dropped
667 * \return the size processed
668 */
669 uint8_t Process(Ptr<Packet>& packet,
670 const Ipv4Header& ipv4Header,
671 Ipv4Address dst,
672 uint8_t* nextHeader,
673 uint8_t protocol,
674 bool& isDropped);
675 /**
676 * \brief Insert a new Dsr Option.
677 * \param option the option to insert
678 */
679 void Insert(Ptr<dsr::DsrOptions> option);
680 /**
681 * \brief Get the option corresponding to optionNumber.
682 * \param optionNumber the option number of the option to retrieve
683 * \return a matching Dsr option
684 */
685 Ptr<dsr::DsrOptions> GetOption(int optionNumber);
686 /**
687 * \brief Cancel the route request timer.
688 * \param dst The dst address of the route request timer
689 * \param isRemove whether to remove the route request entry or not
690 */
691 void CancelRreqTimer(Ipv4Address dst, bool isRemove);
692 /**
693 * \brief Schedule the route request retry.
694 * \param packet the original packet
695 * \param address List of IPv4 addresses
696 * \param nonProp flag if RREQ is non-propagating
697 * \param requestId Unique request ID
698 * \param protocol the protocol number
699 */
700 void ScheduleRreqRetry(Ptr<Packet> packet,
701 std::vector<Ipv4Address> address,
702 bool nonProp,
703 uint32_t requestId,
704 uint8_t protocol);
705 /**
706 * Handle route discovery timer
707 *
708 * \param packet the original packet
709 * \param address List of IPv4 addresses
710 * \param requestId Unique request ID
711 * \param protocol the protocol number
712 */
714 std::vector<Ipv4Address> address,
715 uint32_t requestId,
716 uint8_t protocol);
717
718 /**
719 * Assign a fixed random variable stream number to the random variables
720 * used by this model. Return the number of streams (possibly zero) that
721 * have been assigned.
722 *
723 * \param stream first stream index to use
724 * \return the number of stream indices assigned by this model
725 */
726 int64_t AssignStreams(int64_t stream);
727
728 protected:
729 /*
730 * * This function will notify other components connected to the node that a new stack member
731 * is now connected
732 * * This will be used to notify Layer 3 protocol of layer 4 protocol stack to connect
733 * them together.
734 * */
735 void NotifyNewAggregate() override;
736 /**
737 * \brief Drop trace callback.
738 */
739 void DoDispose() override;
740 /**
741 * The trace for drop, receive and send data packets
742 */
743 TracedCallback<Ptr<const Packet>> m_dropTrace; ///< packet drop trace callback
745
746 private:
747 void Start();
748 /**
749 * \brief Send the route error message when the link breaks to the next hop.
750 * \param nextHop next hop address
751 * \param protocol protocol number
752 */
753 void SendRerrWhenBreaksLinkToNextHop(Ipv4Address nextHop, uint8_t protocol);
754 /**
755 * \brief Promiscuous receive data packets destined to some other node.
756 * \param device The network device
757 * \param packet Data packet we just received
758 * \param protocol The protocol we receive, need to verify it is dsr protocol
759 * \param from The from address we received the packet
760 * \param to The address this packet is destined for
761 * \param packetType The dsr packet type, 0 is for control packet, 1 for data packet
762 * \return true if the packet was processed, false otherwise
763 */
764 bool PromiscReceive(Ptr<NetDevice> device,
765 Ptr<const Packet> packet,
766 uint16_t protocol,
767 const Address& from,
768 const Address& to,
769 NetDevice::PacketType packetType);
770 /**
771 * \brief Define the list to hold DSR options.
772 */
773 typedef std::list<Ptr<DsrOptions>> DsrOptionList_t;
774 /**
775 * \brief List of DSR Options supported.
776 */
778
779 Ptr<Ipv4L3Protocol> m_ipv4; ///< Ipv4l3Protocol
780
782
783 Ptr<Ipv4> m_ip; ///< The ip ptr
784
785 Ptr<Node> m_node; ///< The node ptr
786
787 Ipv4Address m_mainAddress; ///< Our own Ip address
788
789 uint8_t segsLeft; ///< The segment left value from SR header
790
791 IpL4Protocol::DownTargetCallback m_downTarget; ///< The callback for down layer
792
793 uint32_t m_maxNetworkSize; ///< Maximum network queue size
794
795 Time m_maxNetworkDelay; ///< Maximum network delay
796
797 uint32_t m_discoveryHopLimit; ///< Maximum hops to go for route request
798
799 uint8_t m_maxSalvageCount; ///< Maximum # times to salvage a packet
800
801 Time m_requestPeriod; ///< The base time interval between route requests
802
803 Time m_nonpropRequestTimeout; ///< The non-propagation request timeout
804
805 uint32_t m_sendRetries; ///< # of retries have been sent for network acknowledgment
806
807 uint32_t m_passiveRetries; ///< # of retries have been sent for passive acknowledgment
808
809 uint32_t m_linkRetries; ///< # of retries have been sent for link acknowledgment
810
811 uint32_t m_rreqRetries; ///< Maximum number of retransmissions of RREQ with TTL = NetDiameter to
812 ///< discover a route
813
814 uint32_t m_maxMaintRexmt; ///< Maximum number of retransmissions of data packets
815
816 Time m_nodeTraversalTime; ///< Time estimated for packet to travel between two nodes
817
818 uint32_t m_maxSendBuffLen; ///< The maximum number of packets that we allow a routing protocol
819 ///< to buffer.
820
821 Time m_sendBufferTimeout; ///< The maximum period of time that a routing protocol is allowed to
822 ///< buffer a packet for.
823
824 DsrSendBuffer m_sendBuffer; ///< The send buffer
825
826 DsrErrorBuffer m_errorBuffer; ///< The error buffer to save the error messages
827
828 uint32_t m_maxMaintainLen; ///< Max # of entries for maintenance buffer
829
830 Time m_maxMaintainTime; ///< Time out for maintenance buffer
831
832 uint32_t m_maxCacheLen; ///< Max # of cache entries for route cache
833
834 Time m_maxCacheTime; ///< Max time for caching the route cache entry
835
836 Time m_maxRreqTime; ///< Max time for caching the route request entry
837
838 uint32_t m_maxEntriesEachDst; ///< Max number of route entries to save for each destination
839
840 DsrMaintainBuffer m_maintainBuffer; ///< The declaration of maintain buffer
841
842 uint32_t m_requestId; ///< The id assigned to each route request
843
844 uint16_t m_ackId; ///< The ack id assigned to each acknowledge
845
846 uint32_t m_requestTableSize; ///< The max size of the request table size
847
848 uint32_t m_requestTableIds; ///< The request table identifiers
849
850 uint32_t m_maxRreqId; ///< The max number of request ids for a single destination
851
852 Time m_blacklistTimeout; ///< The black list time out
853
854 Ipv4Address m_broadcast; ///< The broadcast IP address
855
856 uint32_t m_broadcastJitter; ///< The max time to delay route request broadcast.
857
858 Time m_passiveAckTimeout; ///< The timeout value for passive acknowledge
859
861 m_tryPassiveAcks; ///< Maximum number of packet transmission using passive acknowledgment
862
863 Time m_linkAckTimeout; ///< The timeout value for link acknowledge
864
865 uint32_t m_tryLinkAcks; ///< Maximum number of packet transmission using link acknowledgment
866
867 Timer m_sendBuffTimer; ///< The send buffer timer
868
869 Time m_sendBuffInterval; ///< how often to check send buffer
870
871 Time m_gratReplyHoldoff; ///< The max gratuitous reply hold off time
872
873 Time m_maxRequestPeriod; ///< The max request period
874
875 uint32_t m_graReplyTableSize; ///< Set the gratuitous reply table size
876
877 std::string m_cacheType; ///< The type of route cache
878
879 std::string m_routeSortType; ///< The type of route sort methods
880
881 uint32_t m_stabilityDecrFactor; ///< The initial decrease factor for link cache
882
883 uint32_t m_stabilityIncrFactor; ///< The initial increase factor for link cache
884
885 Time m_initStability; ///< The initial stability value for link cache
886
887 Time m_minLifeTime; ///< The min life time
888
889 Time m_useExtends; ///< The use extension of the life time for link cache
890
891 bool m_subRoute; ///< Whether to save sub route or not
892
893 Time m_retransIncr; ///< the increase time for retransmission timer when face network congestion
894
895 std::vector<Ipv4Address> m_finalRoute; ///< The route cache
896
897 std::map<Ipv4Address, Timer> m_addressReqTimer; ///< Map IP address + RREQ timer.
898
899 std::map<Ipv4Address, Timer> m_nonPropReqTimer; ///< Map IP address + RREQ timer.
900
901 std::map<NetworkKey, Timer> m_addressForwardTimer; ///< Map network key + forward timer.
902
903 std::map<NetworkKey, uint32_t> m_addressForwardCnt; ///< Map network key + forward counts.
904
905 std::map<PassiveKey, uint32_t> m_passiveCnt; ///< Map packet key + passive forward counts.
906
907 std::map<PassiveKey, Timer> m_passiveAckTimer; ///< The timer for passive acknowledgment
908
909 std::map<LinkKey, uint32_t> m_linkCnt; ///< Map packet key + link forward counts.
910
911 std::map<LinkKey, Timer> m_linkAckTimer; ///< The timer for link acknowledgment
912
914 m_routeCache; ///< A "drop-front" queue used by the routing layer to cache routes found.
915
916 Ptr<dsr::DsrRreqTable> m_rreqTable; ///< A "drop-front" queue used by the routing layer to cache
917 ///< route request sent.
918
919 Ptr<dsr::DsrPassiveBuffer> m_passiveBuffer; ///< A "drop-front" queue used by the routing layer
920 ///< to cache route request sent.
921
922 uint32_t m_numPriorityQueues; ///< The number of priority queues used
923
924 bool m_linkAck; ///< define if we use link acknowledgement or not
925
926 std::map<uint32_t, Ptr<dsr::DsrNetworkQueue>> m_priorityQueue; ///< priority queues
927
928 DsrGraReply m_graReply; ///< The gratuitous route reply.
929
930 DsrNetworkQueue m_networkQueue; ///< The network queue.
931
932 std::vector<Ipv4Address> m_clearList; ///< The node that is clear to send packet to
933
934 std::vector<Ipv4Address> m_addresses; ///< The bind ipv4 addresses with next hop, src,
935 ///< destination address in sequence
936
937 std::map<std::string, uint32_t> m_macToNodeIdMap; ///< The map of mac address to node id
938
939 Ptr<UniformRandomVariable> m_uniformRandomVariable; ///< Provides uniform random variables.
940};
941} /* namespace dsr */
942} /* namespace ns3 */
943
944#endif /* DSR_ROUTING_H */
a polymophic address class
Definition address.h:90
L4 Protocol abstract base class.
RxStatus
Rx status codes.
Ipv4 addresses are stored in host order in this class.
Packet header for IPv4.
Definition ipv4-header.h:23
Packet header for IPv6.
Definition ipv6-header.h:24
an EUI-48 address
PacketType
Packet types are used as they are in Linux.
Definition net-device.h:289
Smart pointer class similar to boost::intrusive_ptr.
Simulation virtual time values and global simulation resolution.
Definition nstime.h:94
A simple virtual Timer class.
Definition timer.h:67
Forward calls to a chain of Callback.
a unique identifier for an interface.
Definition type-id.h:48
maintain the gratuitous reply
DSR Maintain Buffer Entry.
DSR Network Queue Entry.
Route Error (RERR) Unreachable node address option Message Format.
Header of Dsr Option Source Route.
DsrRouteCacheEntry class for entries in the route cache.
Definition dsr-rcache.h:218
std::vector< Ipv4Address > IP_VECTOR
Define the vector to hold Ip address.
Definition dsr-rcache.h:220
Dsr Routing base.
Definition dsr-routing.h:87
Ptr< dsr::DsrRreqTable > GetRequestTable() const
Get the request table.
std::string m_routeSortType
The type of route sort methods.
void ScheduleInterRequest(Ptr< Packet > packet)
Schedule the intermediate route request.
void CheckSendBuffer()
Check the send buffer of packets with route when send buffer timer expire.
Ptr< Ipv4 > m_ip
The ip ptr.
void ScheduleRreqRetry(Ptr< Packet > packet, std::vector< Ipv4Address > address, bool nonProp, uint32_t requestId, uint8_t protocol)
Schedule the route request retry.
void NotifyNewAggregate() override
Notify all Objects aggregated to this one of a new Object being aggregated.
Time m_blacklistTimeout
The black list time out.
void SendRerrWhenBreaksLinkToNextHop(Ipv4Address nextHop, uint8_t protocol)
Send the route error message when the link breaks to the next hop.
std::string m_cacheType
The type of route cache.
std::map< Ipv4Address, Timer > m_nonPropReqTimer
Map IP address + RREQ timer.
IpL4Protocol::DownTargetCallback GetDownTarget() const override
This method allows a caller to get the current down target callback set for this L4 protocol (IPv4 ca...
void SetNode(Ptr< Node > node)
Set the node.
void SendBuffTimerExpire()
The send buffer timer expire.
void SetPassiveBuffer(Ptr< dsr::DsrPassiveBuffer > r)
Set the node.
std::vector< std::string > GetElementsFromContext(std::string context)
Get the elements from the tracing context.
void UseExtends(DsrRouteCacheEntry::IP_VECTOR rt)
Extends the lifetime of a route cache entry.
uint32_t m_maxRreqId
The max number of request ids for a single destination.
bool SendRealDown(DsrNetworkQueueEntry &newEntry)
This function is called to send packets down stack.
Time m_sendBufferTimeout
The maximum period of time that a routing protocol is allowed to buffer a packet for.
uint8_t segsLeft
The segment left value from SR header.
void SendRequest(Ptr< Packet > packet, Ipv4Address source)
Forward the route request if the node is not the destination.
void CancelPacketTimerNextHop(Ipv4Address nextHop, uint8_t protocol)
Cancel the packet retransmission timer for a all maintenance entries with nextHop address.
bool m_linkAck
define if we use link acknowledgement or not
void PrintVector(std::vector< Ipv4Address > &vec)
Print the route vector.
Ptr< UniformRandomVariable > m_uniformRandomVariable
Provides uniform random variables.
void ForwardErrPacket(DsrOptionRerrUnreachHeader &rerr, DsrOptionSRHeader &sourceRoute, Ipv4Address nextHop, uint8_t protocol, Ptr< Ipv4Route > route)
This function is responsible for forwarding error packets along the route.
bool CancelPassiveTimer(Ptr< Packet > packet, Ipv4Address source, Ipv4Address destination, uint8_t segsLeft)
Cancel the passive timer.
IpL4Protocol::RxStatus Receive(Ptr< Packet > p, const Ipv4Header &header, Ptr< Ipv4Interface > incomingInterface) override
void PassiveScheduleTimerExpire(DsrMaintainBuffEntry &mb, uint8_t protocol)
This function deals with packet retransmission timer expire using passive acknowledgment.
std::vector< Ipv4Address > m_addresses
The bind ipv4 addresses with next hop, src, destination address in sequence.
bool AddRoute_Link(DsrRouteCacheEntry::IP_VECTOR nodelist, Ipv4Address source)
dd route link to cache See also DsrRouteCache::AddRoute_Link
uint16_t m_ackId
The ack id assigned to each acknowledge.
DsrRouting()
Constructor.
void CancelLinkPacketTimer(DsrMaintainBuffEntry &mb)
Cancel the link packet retransmission timer for a specific maintenance entry.
Time m_nonpropRequestTimeout
The non-propagation request timeout.
Time m_gratReplyHoldoff
The max gratuitous reply hold off time.
std::list< Ptr< DsrOptions > > DsrOptionList_t
Define the list to hold DSR options.
uint16_t GetIDfromIP(Ipv4Address address)
Get the node id from ip address.
std::map< uint32_t, Ptr< dsr::DsrNetworkQueue > > m_priorityQueue
priority queues
uint32_t m_maxEntriesEachDst
Max number of route entries to save for each destination.
std::map< Ipv4Address, Timer > m_addressReqTimer
Map IP address + RREQ timer.
Time m_retransIncr
the increase time for retransmission timer when face network congestion
std::map< NetworkKey, Timer > m_addressForwardTimer
Map network key + forward timer.
DsrNetworkQueue m_networkQueue
The network queue.
uint32_t m_stabilityDecrFactor
The initial decrease factor for link cache.
Time m_nodeTraversalTime
Time estimated for packet to travel between two nodes.
uint32_t m_requestId
The id assigned to each route request.
std::map< NetworkKey, uint32_t > m_addressForwardCnt
Map network key + forward counts.
Ptr< NetDevice > GetNetDeviceFromContext(std::string context)
Get the netdevice from the context.
bool FindSourceEntry(Ipv4Address src, Ipv4Address dst, uint16_t id)
Find the source request entry in the route request queue, return false if not found.
Ipv4Address m_broadcast
The broadcast IP address.
Ptr< dsr::DsrPassiveBuffer > GetPassiveBuffer() const
Get the passive buffer.
Ipv4Address GetIPfromMAC(Mac48Address address)
Get the Ip address from mac address.
Ptr< dsr::DsrRouteCache > GetRouteCache() const
Get the route cache.
Time m_maxNetworkDelay
Maximum network delay.
Ptr< dsr::DsrOptions > GetOption(int optionNumber)
Get the option corresponding to optionNumber.
uint32_t m_maxSendBuffLen
The maximum number of packets that we allow a routing protocol to buffer.
Time m_passiveAckTimeout
The timeout value for passive acknowledge.
void SetRequestTable(Ptr< dsr::DsrRreqTable > r)
Set the node.
uint32_t m_maxMaintainLen
Max # of entries for maintenance buffer.
static const uint8_t PROT_NUMBER
Define the dsr protocol number.
Definition dsr-routing.h:97
uint32_t GetPriority(DsrMessageType messageType)
Set the priority of the packet in network queue.
void SendReply(Ptr< Packet > packet, Ipv4Address source, Ipv4Address nextHop, Ptr< Ipv4Route > route)
Send the route reply back to the request originator with the cumulated route.
void ScheduleNetworkPacketRetry(DsrMaintainBuffEntry &mb, bool isFirst, uint8_t protocol)
Schedule the packet retransmission based on network layer acknowledgment.
Ipv4Address m_mainAddress
Our own Ip address.
void SendInitialRequest(Ipv4Address source, Ipv4Address destination, uint8_t protocol)
Broadcast the route request packet in subnet.
uint8_t Process(Ptr< Packet > &packet, const Ipv4Header &ipv4Header, Ipv4Address dst, uint8_t *nextHeader, uint8_t protocol, bool &isDropped)
Process method Called from Ipv4L3Protocol::Receive.
Timer m_sendBuffTimer
The send buffer timer.
Time m_maxCacheTime
Max time for caching the route cache entry.
void SendGratuitousReply(Ipv4Address replyTo, Ipv4Address replyFrom, std::vector< Ipv4Address > &nodeList, uint8_t protocol)
Send the gratuitous reply.
void DeleteAllRoutesIncludeLink(Ipv4Address errorSrc, Ipv4Address unreachNode, Ipv4Address node)
Delete all the routes which includes the link from next hop address that has just been notified as un...
DsrOptionList_t m_options
List of DSR Options supported.
std::map< PassiveKey, uint32_t > m_passiveCnt
Map packet key + passive forward counts.
DsrErrorBuffer m_errorBuffer
The error buffer to save the error messages.
void SalvagePacket(Ptr< const Packet > packet, Ipv4Address source, Ipv4Address dst, uint8_t protocol)
Salvage the packet which has been transmitted for 3 times.
bool m_subRoute
Whether to save sub route or not.
void SendPacket(Ptr< Packet > packet, Ipv4Address source, Ipv4Address nextHop, uint8_t protocol)
This function is called by when really sending out the packet.
void SetDownTarget(IpL4Protocol::DownTargetCallback callback) override
This method allows a caller to set the current down target callback set for this L4 protocol (IPv4 ca...
bool IsLinkCache()
Checks if the link is cached in the route cache See also DsrRouteCache::IsLinkCache.
std::map< LinkKey, uint32_t > m_linkCnt
Map packet key + link forward counts.
~DsrRouting() override
Destructor.
DsrSendBuffer m_sendBuffer
The send buffer.
uint32_t m_rreqRetries
Maximum number of retransmissions of RREQ with TTL = NetDiameter to discover a route.
uint8_t m_maxSalvageCount
Maximum # times to salvage a packet.
Ptr< Ipv4Route > SetRoute(Ipv4Address nextHop, Ipv4Address srcAddress)
Set the route to use for data packets, used by the option headers when sending data/control packets.
uint16_t AddAckReqHeader(Ptr< Packet > &packet, Ipv4Address nextHop)
This function is called to add ack request header for network acknowledgement.
Time m_maxRreqTime
Max time for caching the route request entry.
uint32_t m_requestTableSize
The max size of the request table size.
DsrGraReply m_graReply
The gratuitous route reply.
void ScheduleLinkPacketRetry(DsrMaintainBuffEntry &mb, uint8_t protocol)
Schedule the packet retransmission based on link-layer acknowledgment.
bool PromiscReceive(Ptr< NetDevice > device, Ptr< const Packet > packet, uint16_t protocol, const Address &from, const Address &to, NetDevice::PacketType packetType)
Promiscuous receive data packets destined to some other node.
Time m_sendBuffInterval
how often to check send buffer
TracedCallback< const DsrOptionSRHeader & > m_txPacketTrace
packet trace callback
void ScheduleInitialReply(Ptr< Packet > packet, Ipv4Address source, Ipv4Address nextHop, Ptr< Ipv4Route > route)
this is a generating the initial route reply from the destination address, a random delay time [0,...
bool LookupRoute(Ipv4Address id, DsrRouteCacheEntry &rt)
Lookup route cache entry with destination address dst See also DsrRouteCache::LookupRoute.
Time m_initStability
The initial stability value for link cache.
uint32_t m_stabilityIncrFactor
The initial increase factor for link cache.
void SetDownTarget6(IpL4Protocol::DownTargetCallback6 callback) override
This method allows a caller to set the current down target callback set for this L4 protocol (IPv6 ca...
Time m_useExtends
The use extension of the life time for link cache.
uint32_t m_numPriorityQueues
The number of priority queues used.
Ipv4Address SearchNextHop(Ipv4Address ipv4Address, std::vector< Ipv4Address > &vec)
Get the next hop of the route.
IpL4Protocol::DownTargetCallback m_downTarget
The callback for down layer.
uint32_t m_graReplyTableSize
Set the gratuitous reply table size.
bool PassiveEntryCheck(Ptr< Packet > packet, Ipv4Address source, Ipv4Address destination, uint8_t segsLeft, uint16_t fragmentOffset, uint16_t identification, bool saveEntry)
Find the same passive entry.
Ptr< Node > GetNodeWithAddress(Ipv4Address ipv4Address)
Get the node with give ip address.
Ptr< Ipv4L3Protocol > m_ipv4
Ipv4l3Protocol.
void Scheduler(uint32_t priority)
This function is called to schedule sending packets from the network queue.
void RouteRequestTimerExpire(Ptr< Packet > packet, std::vector< Ipv4Address > address, uint32_t requestId, uint8_t protocol)
Handle route discovery timer.
void NetworkScheduleTimerExpire(DsrMaintainBuffEntry &mb, uint8_t protocol)
This function deals with packet retransmission timer expire using network acknowledgment.
uint32_t m_requestTableIds
The request table identifiers.
TracedCallback< Ptr< const Packet > > m_dropTrace
The trace for drop, receive and send data packets.
void SendPacketFromBuffer(const DsrOptionSRHeader &sourceRoute, Ipv4Address nextHop, uint8_t protocol)
This function is responsible for sending out data packets when have route, if no route found,...
uint32_t m_tryPassiveAcks
Maximum number of packet transmission using passive acknowledgment.
std::map< std::string, uint32_t > m_macToNodeIdMap
The map of mac address to node id.
void LinkScheduleTimerExpire(DsrMaintainBuffEntry &mb, uint8_t protocol)
This function deals with packet retransmission timer expire using link acknowledgment.
bool UpdateRouteEntry(Ipv4Address dst)
Update route cache entry if it has been recently used and successfully delivered the data packet.
uint32_t m_maxNetworkSize
Maximum network queue size.
Ptr< Ipv4Route > m_ipv4Route
Ipv4 Route.
Ptr< Node > GetNode() const
Get the node.
Ipv4Address GetIPfromID(uint16_t id)
Get the ip address from id.
Time m_maxRequestPeriod
The max request period.
void SchedulePassivePacketRetry(DsrMaintainBuffEntry &mb, uint8_t protocol)
Schedule the packet retransmission based on passive acknowledgment.
Ptr< dsr::DsrPassiveBuffer > m_passiveBuffer
A "drop-front" queue used by the routing layer to cache route request sent.
Ptr< Node > m_node
The node ptr.
Ptr< dsr::DsrRouteCache > m_routeCache
A "drop-front" queue used by the routing layer to cache routes found.
std::map< PassiveKey, Timer > m_passiveAckTimer
The timer for passive acknowledgment.
bool AddRoute(DsrRouteCacheEntry &rt)
Add route cache entry if it doesn't yet exist in route cache See also DsrRouteCache::AddRoute.
Time m_maxMaintainTime
Time out for maintenance buffer.
DsrMaintainBuffer m_maintainBuffer
The declaration of maintain buffer.
uint32_t m_maxMaintRexmt
Maximum number of retransmissions of data packets.
void CallCancelPacketTimer(uint16_t ackId, const Ipv4Header &ipv4Header, Ipv4Address realSrc, Ipv4Address realDst)
Call the cancel packet retransmission timer function.
Time m_requestPeriod
The base time interval between route requests.
Time m_linkAckTimeout
The timeout value for link acknowledge.
void SendUnreachError(Ipv4Address unreachNode, Ipv4Address destination, Ipv4Address originalDst, uint8_t salvage, uint8_t protocol)
This function is responsible for sending error packets in case of break link to next hop.
uint32_t m_tryLinkAcks
Maximum number of packet transmission using link acknowledgment.
uint32_t m_discoveryHopLimit
Maximum hops to go for route request.
void CancelRreqTimer(Ipv4Address dst, bool isRemove)
Cancel the route request timer.
std::map< LinkKey, Timer > m_linkAckTimer
The timer for link acknowledgment.
IpL4Protocol::DownTargetCallback6 GetDownTarget6() const override
This method allows a caller to get the current down target callback set for this L4 protocol (IPv6 ca...
Time m_minLifeTime
The min life time.
void ForwardPacket(Ptr< const Packet > packet, DsrOptionSRHeader &sourceRoute, const Ipv4Header &ipv4Header, Ipv4Address source, Ipv4Address destination, Ipv4Address targetAddress, uint8_t protocol, Ptr< Ipv4Route > route)
Forward the packet using the route saved in the source route option header.
static TypeId GetTypeId()
Get the type identificator.
std::vector< Ipv4Address > m_clearList
The node that is clear to send packet to.
void SendErrorRequest(DsrOptionRerrUnreachHeader &rerr, uint8_t protocol)
Send the error request packet.
void DoDispose() override
Drop trace callback.
int GetProtocolNumber() const override
Get the dsr protocol number.
void PacketNewRoute(Ptr< Packet > packet, Ipv4Address source, Ipv4Address destination, uint8_t protocol)
When route vector corrupted, originate a new packet, normally not happening.
Ptr< dsr::DsrRreqTable > m_rreqTable
A "drop-front" queue used by the routing layer to cache route request sent.
int64_t AssignStreams(int64_t stream)
Assign a fixed random variable stream number to the random variables used by this model.
void IncreaseRetransTimer()
This function is called to increase the retransmission timer for data packet in the network queue.
void CancelPassivePacketTimer(DsrMaintainBuffEntry &mb)
Cancel the passive packet retransmission timer for a specific maintenance entry.
void CancelNetworkPacketTimer(DsrMaintainBuffEntry &mb)
Cancel the network packet retransmission timer for a specific maintenance entry.
void PriorityScheduler(uint32_t priority, bool continueWithFirst)
This function is called to schedule sending packets from the network queue by priority.
void ScheduleCachedReply(Ptr< Packet > packet, Ipv4Address source, Ipv4Address destination, Ptr< Ipv4Route > route, double hops)
Schedule the cached reply to a random start time to avoid possible route reply storm.
void SendAck(uint16_t ackId, Ipv4Address destination, Ipv4Address realSrc, Ipv4Address realDst, uint8_t protocol, Ptr< Ipv4Route > route)
Send network layer acknowledgment back to the earlier hop to notify the receipt of data packet.
void SetRouteCache(Ptr< dsr::DsrRouteCache > r)
Set the route cache.
void Send(Ptr< Packet > packet, Ipv4Address source, Ipv4Address destination, uint8_t protocol, Ptr< Ipv4Route > route)
This function is called by higher layer protocol when sending packets.
void Insert(Ptr< dsr::DsrOptions > option)
Insert a new Dsr Option.
std::vector< Ipv4Address > m_finalRoute
The route cache.
void CancelPacketAllTimer(DsrMaintainBuffEntry &mb)
Cancel all the packet timers.
uint32_t m_broadcastJitter
The max time to delay route request broadcast.
uint32_t m_maxCacheLen
Max # of cache entries for route cache.
void(* Time)(Time oldValue, Time newValue)
TracedValue callback signature for Time.
Definition nstime.h:828
Every class exported by the ns3 library is enclosed in the ns3 namespace.