A Discrete-Event Network Simulator
API
Loading...
Searching...
No Matches
ipv6-routing-helper.cc
Go to the documentation of this file.
1/*
2 * Copyright (c) 2008 INRIA
3 *
4 * SPDX-License-Identifier: GPL-2.0-only
5 *
6 * Author: Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
7 */
8
9#include "ipv6-routing-helper.h"
10
11#include "ns3/ipv6-interface.h"
12#include "ns3/ipv6-l3-protocol.h"
13#include "ns3/ipv6-list-routing.h"
14#include "ns3/ipv6-routing-protocol.h"
15#include "ns3/names.h"
16#include "ns3/ndisc-cache.h"
17#include "ns3/node-list.h"
18#include "ns3/node.h"
19#include "ns3/simulator.h"
20
21namespace ns3
22{
23
27
28void
29Ipv6RoutingHelper::PrintRoutingTableAllAt(Time printTime,
30 Ptr<OutputStreamWrapper> stream,
31 Time::Unit unit)
32{
33 for (uint32_t i = 0; i < NodeList::GetNNodes(); i++)
34 {
35 Ptr<Node> node = NodeList::GetNode(i);
36 Simulator::Schedule(printTime, &Ipv6RoutingHelper::Print, node, stream, unit);
37 }
38}
39
40void
41Ipv6RoutingHelper::PrintRoutingTableAllEvery(Time printInterval,
42 Ptr<OutputStreamWrapper> stream,
43 Time::Unit unit)
44{
45 for (uint32_t i = 0; i < NodeList::GetNNodes(); i++)
46 {
47 Ptr<Node> node = NodeList::GetNode(i);
48 Simulator::Schedule(printInterval,
49 &Ipv6RoutingHelper::PrintEvery,
50 printInterval,
51 node,
52 stream,
53 unit);
54 }
55}
56
57void
58Ipv6RoutingHelper::PrintRoutingTableAt(Time printTime,
59 Ptr<Node> node,
60 Ptr<OutputStreamWrapper> stream,
61 Time::Unit unit)
62{
63 Simulator::Schedule(printTime, &Ipv6RoutingHelper::Print, node, stream, unit);
64}
65
66void
67Ipv6RoutingHelper::PrintRoutingTableEvery(Time printInterval,
68 Ptr<Node> node,
69 Ptr<OutputStreamWrapper> stream,
70 Time::Unit unit)
71{
72 Simulator::Schedule(printInterval,
73 &Ipv6RoutingHelper::PrintEvery,
74 printInterval,
75 node,
76 stream,
77 unit);
78}
79
80void
81Ipv6RoutingHelper::Print(Ptr<Node> node, Ptr<OutputStreamWrapper> stream, Time::Unit unit)
82{
83 Ptr<Ipv6> ipv6 = node->GetObject<Ipv6>();
84 if (ipv6)
85 {
86 Ptr<Ipv6RoutingProtocol> rp = ipv6->GetRoutingProtocol();
87 NS_ASSERT(rp);
88 rp->PrintRoutingTable(stream, unit);
89 }
90}
91
92void
93Ipv6RoutingHelper::PrintEvery(Time printInterval,
94 Ptr<Node> node,
95 Ptr<OutputStreamWrapper> stream,
96 Time::Unit unit)
97{
98 Ptr<Ipv6> ipv6 = node->GetObject<Ipv6>();
99 if (ipv6)
100 {
101 Ptr<Ipv6RoutingProtocol> rp = ipv6->GetRoutingProtocol();
102 NS_ASSERT(rp);
103 rp->PrintRoutingTable(stream, unit);
104 Simulator::Schedule(printInterval,
105 &Ipv6RoutingHelper::PrintEvery,
106 printInterval,
107 node,
108 stream,
109 unit);
110 }
111}
112
113void
114Ipv6RoutingHelper::PrintNeighborCacheAllAt(Time printTime,
115 Ptr<OutputStreamWrapper> stream,
116 Time::Unit unit /* = Time::S */)
117{
118 for (uint32_t i = 0; i < NodeList::GetNNodes(); i++)
119 {
120 Ptr<Node> node = NodeList::GetNode(i);
121 Simulator::Schedule(printTime, &Ipv6RoutingHelper::PrintNdiscCache, node, stream, unit);
122 }
123}
124
125void
126Ipv6RoutingHelper::PrintNeighborCacheAllEvery(Time printInterval,
127 Ptr<OutputStreamWrapper> stream,
128 Time::Unit unit /* = Time::S */)
129{
130 for (uint32_t i = 0; i < NodeList::GetNNodes(); i++)
131 {
132 Ptr<Node> node = NodeList::GetNode(i);
133 Simulator::Schedule(printInterval,
134 &Ipv6RoutingHelper::PrintNdiscCacheEvery,
135 printInterval,
136 node,
137 stream,
138 unit);
139 }
140}
141
142void
143Ipv6RoutingHelper::PrintNeighborCacheAt(Time printTime,
144 Ptr<Node> node,
145 Ptr<OutputStreamWrapper> stream,
146 Time::Unit unit /* = Time::S */)
147{
148 Simulator::Schedule(printTime, &Ipv6RoutingHelper::PrintNdiscCache, node, stream, unit);
149}
150
151void
152Ipv6RoutingHelper::PrintNeighborCacheEvery(Time printInterval,
153 Ptr<Node> node,
154 Ptr<OutputStreamWrapper> stream,
155 Time::Unit unit /* = Time::S */)
156{
157 Simulator::Schedule(printInterval,
158 &Ipv6RoutingHelper::PrintNdiscCacheEvery,
159 printInterval,
160 node,
161 stream,
162 unit);
163}
164
165void
166Ipv6RoutingHelper::PrintNdiscCache(Ptr<Node> node,
167 Ptr<OutputStreamWrapper> stream,
168 Time::Unit unit /* = Time::S */)
169{
170 Ptr<Ipv6L3Protocol> ipv6 = node->GetObject<Ipv6L3Protocol>();
171 if (ipv6)
172 {
173 std::ostream* os = stream->GetStream();
174
175 *os << "NDISC Cache of node ";
176 std::string found = Names::FindName(node);
177 if (!Names::FindName(node).empty())
178 {
179 *os << found;
180 }
181 else
182 {
183 *os << static_cast<int>(node->GetId());
184 }
185 *os << " at time " << Simulator::Now().As(unit) << "\n";
186
187 for (uint32_t i = 0; i < ipv6->GetNInterfaces(); i++)
188 {
189 Ptr<NdiscCache> ndiscCache = ipv6->GetInterface(i)->GetNdiscCache();
190 if (ndiscCache)
191 {
192 ndiscCache->PrintNdiscCache(stream);
193 }
194 }
195 }
196}
197
198void
199Ipv6RoutingHelper::PrintNdiscCacheEvery(Time printInterval,
200 Ptr<Node> node,
201 Ptr<OutputStreamWrapper> stream,
202 Time::Unit unit /* = Time::S */)
203{
204 Ptr<Ipv6L3Protocol> ipv6 = node->GetObject<Ipv6L3Protocol>();
205 if (ipv6)
206 {
207 std::ostream* os = stream->GetStream();
208
209 *os << "NDISC Cache of node ";
210 std::string found = Names::FindName(node);
211 if (!Names::FindName(node).empty())
212 {
213 *os << found;
214 }
215 else
216 {
217 *os << static_cast<int>(node->GetId());
218 }
219 *os << " at time " << Simulator::Now().As(unit) << "\n";
220
221 for (uint32_t i = 0; i < ipv6->GetNInterfaces(); i++)
222 {
223 Ptr<NdiscCache> ndiscCache = ipv6->GetInterface(i)->GetNdiscCache();
224 if (ndiscCache)
225 {
226 ndiscCache->PrintNdiscCache(stream);
227 }
228 }
229 Simulator::Schedule(printInterval,
230 &Ipv6RoutingHelper::PrintNdiscCacheEvery,
231 printInterval,
232 node,
233 stream,
234 unit);
235 }
236}
237
238} // namespace ns3
ns3::Ipv6
Access to the IPv6 forwarding table, interfaces, and configuration.
Definition ipv6.h:71
ns3::Ipv6L3Protocol
IPv6 layer implementation.
Definition ipv6-l3-protocol.h:53
ns3::Ipv6RoutingHelper::PrintRoutingTableAllAt
static void PrintRoutingTableAllAt(Time printTime, Ptr< OutputStreamWrapper > stream, Time::Unit unit=Time::S)
prints the routing tables of all nodes at a particular time.
Definition ipv6-routing-helper.cc:29
ns3::Ipv6RoutingHelper::PrintNdiscCacheEvery
static void PrintNdiscCacheEvery(Time printInterval, Ptr< Node > node, Ptr< OutputStreamWrapper > stream, Time::Unit unit=Time::S)
prints the neighbor cache of a node at regular intervals specified by user.
Definition ipv6-routing-helper.cc:199
ns3::Ipv6RoutingHelper::PrintNeighborCacheAllAt
static void PrintNeighborCacheAllAt(Time printTime, Ptr< OutputStreamWrapper > stream, Time::Unit unit=Time::S)
prints the neighbor cache of all nodes at a particular time.
Definition ipv6-routing-helper.cc:114
ns3::Ipv6RoutingHelper::PrintNdiscCache
static void PrintNdiscCache(Ptr< Node > node, Ptr< OutputStreamWrapper > stream, Time::Unit unit=Time::S)
prints the neighbor cache of a node.
Definition ipv6-routing-helper.cc:166
ns3::Ipv6RoutingHelper::PrintNeighborCacheAllEvery
static void PrintNeighborCacheAllEvery(Time printInterval, Ptr< OutputStreamWrapper > stream, Time::Unit unit=Time::S)
prints the neighbor cache of all nodes at regular intervals specified by user.
Definition ipv6-routing-helper.cc:126
ns3::Ipv6RoutingHelper::PrintRoutingTableAt
static void PrintRoutingTableAt(Time printTime, Ptr< Node > node, Ptr< OutputStreamWrapper > stream, Time::Unit unit=Time::S)
prints the routing tables of a node at a particular time.
Definition ipv6-routing-helper.cc:58
ns3::Ipv6RoutingHelper::PrintRoutingTableAllEvery
static void PrintRoutingTableAllEvery(Time printInterval, Ptr< OutputStreamWrapper > stream, Time::Unit unit=Time::S)
prints the routing tables of all nodes at regular intervals specified by user.
Definition ipv6-routing-helper.cc:41
ns3::Ipv6RoutingHelper::PrintNeighborCacheEvery
static void PrintNeighborCacheEvery(Time printInterval, Ptr< Node > node, Ptr< OutputStreamWrapper > stream, Time::Unit unit=Time::S)
prints the neighbor cache of a node at regular intervals specified by user.
Definition ipv6-routing-helper.cc:152
ns3::Ipv6RoutingHelper::PrintRoutingTableEvery
static void PrintRoutingTableEvery(Time printInterval, Ptr< Node > node, Ptr< OutputStreamWrapper > stream, Time::Unit unit=Time::S)
prints the routing tables of a node at regular intervals specified by user.
Definition ipv6-routing-helper.cc:67
ns3::Ipv6RoutingHelper::~Ipv6RoutingHelper
virtual ~Ipv6RoutingHelper()
Destroy an Ipv6 Ipv6RoutingHelper.
Definition ipv6-routing-helper.cc:24
ns3::Ipv6RoutingHelper::Print
static void Print(Ptr< Node > node, Ptr< OutputStreamWrapper > stream, Time::Unit unit)
prints the routing tables of a node.
Definition ipv6-routing-helper.cc:81
ns3::Ipv6RoutingHelper::PrintNeighborCacheAt
static void PrintNeighborCacheAt(Time printTime, Ptr< Node > node, Ptr< OutputStreamWrapper > stream, Time::Unit unit=Time::S)
prints the neighbor cache of a node at a particular time.
Definition ipv6-routing-helper.cc:143
ns3::Ipv6RoutingHelper::PrintEvery
static void PrintEvery(Time printInterval, Ptr< Node > node, Ptr< OutputStreamWrapper > stream, Time::Unit unit)
prints the routing tables of a node at regular intervals specified by user.
Definition ipv6-routing-helper.cc:93
ns3::Names::FindName
static std::string FindName(Ptr< Object > object)
Given a pointer to an object, look to see if that object has a name associated with it and,...
Definition names.cc:818
ns3::NodeList::GetNNodes
static uint32_t GetNNodes()
Definition node-list.cc:247
ns3::NodeList::GetNode
static Ptr< Node > GetNode(uint32_t n)
Definition node-list.cc:240
ns3::Ptr
Smart pointer class similar to boost::intrusive_ptr.
Definition ptr.h:67
ns3::Simulator::Schedule
static EventId Schedule(const Time &delay, FUNC f, Ts &&... args)
Schedule an event to expire after delay.
Definition simulator.h:561
ns3::Simulator::Now
static Time Now()
Return the current simulation virtual time.
Definition simulator.cc:197
ns3::Time
Simulation virtual time values and global simulation resolution.
Definition nstime.h:96
ns3::Time::As
TimeWithUnit As(const Unit unit=Time::AUTO) const
Attach a unit to a Time, to facilitate output in a specific unit.
Definition time.cc:409
ns3::Time::Unit
Unit
The unit to use to interpret a number representing time.
Definition nstime.h:102
uint32_t
NS_ASSERT
#define NS_ASSERT(condition)
At runtime, in debugging builds, if this condition is not true, the program prints the source file,...
Definition assert.h:55
ns3
Every class exported by the ns3 library is enclosed in the ns3 namespace.