A Discrete-Event Network Simulator
API
ripng-simple-network.cc
Go to the documentation of this file.
1 /* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
2 /*
3  * Copyright (c) 2014 Universita' di Firenze, Italy
4  *
5  * This program is free software; you can redistribute it and/or modify
6  * it under the terms of the GNU General Public License version 2 as
7  * published by the Free Software Foundation;
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software
16  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17  *
18  * Author: Tommaso Pecorella <tommaso.pecorella@unifi.it>
19  */
20 
21 // Network topology
22 //
23 // SRC
24 // |<=== source network
25 // A-----B
26 // \ / \ all networks have cost 1, except
27 // \ / | for the direct link from C to D, which
28 // C / has cost 10
29 // | /
30 // |/
31 // D
32 // |<=== target network
33 // DST
34 //
35 //
36 // A, B, C and D are RIPng routers.
37 // A and D are configured with static addresses.
38 // SRC and DST will exchange packets.
39 //
40 // After about 3 seconds, the topology is built, and Echo Reply will be received.
41 // After 40 seconds, the link between B and D will break, causing a route failure.
42 // After 44 seconds from the failure, the routers will recovery from the failure.
43 // Split Horizoning should affect the recovery time, but it is not. See the manual
44 // for an explanation of this effect.
45 //
46 // If "showPings" is enabled, the user will see:
47 // 1) if the ping has been acknowledged
48 // 2) if a Destination Unreachable has been received by the sender
49 // 3) nothing, when the Echo Request has been received by the destination but
50 // the Echo Reply is unable to reach the sender.
51 // Examining the .pcap files with Wireshark can confirm this effect.
52 
53 
54 #include <fstream>
55 #include "ns3/core-module.h"
56 #include "ns3/internet-module.h"
57 #include "ns3/csma-module.h"
58 #include "ns3/internet-apps-module.h"
59 #include "ns3/ipv6-static-routing-helper.h"
60 #include "ns3/ipv6-routing-table-entry.h"
61 
62 using namespace ns3;
63 
64 NS_LOG_COMPONENT_DEFINE ("RipNgSimpleRouting");
65 
66 void TearDownLink (Ptr<Node> nodeA, Ptr<Node> nodeB, uint32_t interfaceA, uint32_t interfaceB)
67 {
68  nodeA->GetObject<Ipv6> ()->SetDown (interfaceA);
69  nodeB->GetObject<Ipv6> ()->SetDown (interfaceB);
70 }
71 
72 int main (int argc, char **argv)
73 {
74  bool verbose = false;
75  bool printRoutingTables = false;
76  bool showPings = false;
77  std::string SplitHorizon ("PoisonReverse");
78 
79  CommandLine cmd (__FILE__);
80  cmd.AddValue ("verbose", "turn on log components", verbose);
81  cmd.AddValue ("printRoutingTables", "Print routing tables at 30, 60 and 90 seconds", printRoutingTables);
82  cmd.AddValue ("showPings", "Show Ping6 reception", showPings);
83  cmd.AddValue ("splitHorizonStrategy", "Split Horizon strategy to use (NoSplitHorizon, SplitHorizon, PoisonReverse)", SplitHorizon);
84  cmd.Parse (argc, argv);
85 
86  if (verbose)
87  {
88  LogComponentEnable ("RipNgSimpleRouting", LOG_LEVEL_INFO);
89  LogComponentEnable ("RipNg", LOG_LEVEL_ALL);
90  LogComponentEnable ("Icmpv6L4Protocol", LOG_LEVEL_INFO);
91  LogComponentEnable ("Ipv6Interface", LOG_LEVEL_ALL);
92  LogComponentEnable ("Icmpv6L4Protocol", LOG_LEVEL_ALL);
93  LogComponentEnable ("NdiscCache", LOG_LEVEL_ALL);
94  LogComponentEnable ("Ping6Application", LOG_LEVEL_ALL);
95  }
96 
97  if (showPings)
98  {
99  LogComponentEnable ("Ping6Application", LOG_LEVEL_INFO);
100  }
101 
102  if (SplitHorizon == "NoSplitHorizon")
103  {
104  Config::SetDefault ("ns3::RipNg::SplitHorizon", EnumValue (RipNg::NO_SPLIT_HORIZON));
105  }
106  else if (SplitHorizon == "SplitHorizon")
107  {
108  Config::SetDefault ("ns3::RipNg::SplitHorizon", EnumValue (RipNg::SPLIT_HORIZON));
109  }
110  else
111  {
112  Config::SetDefault ("ns3::RipNg::SplitHorizon", EnumValue (RipNg::POISON_REVERSE));
113  }
114 
115  NS_LOG_INFO ("Create nodes.");
116  Ptr<Node> src = CreateObject<Node> ();
117  Names::Add ("SrcNode", src);
118  Ptr<Node> dst = CreateObject<Node> ();
119  Names::Add ("DstNode", dst);
120  Ptr<Node> a = CreateObject<Node> ();
121  Names::Add ("RouterA", a);
122  Ptr<Node> b = CreateObject<Node> ();
123  Names::Add ("RouterB", b);
124  Ptr<Node> c = CreateObject<Node> ();
125  Names::Add ("RouterC", c);
126  Ptr<Node> d = CreateObject<Node> ();
127  Names::Add ("RouterD", d);
128  NodeContainer net1 (src, a);
129  NodeContainer net2 (a, b);
130  NodeContainer net3 (a, c);
131  NodeContainer net4 (b, c);
132  NodeContainer net5 (c, d);
133  NodeContainer net6 (b, d);
134  NodeContainer net7 (d, dst);
135  NodeContainer routers (a, b, c, d);
136  NodeContainer nodes (src, dst);
137 
138 
139  NS_LOG_INFO ("Create channels.");
140  CsmaHelper csma;
141  csma.SetChannelAttribute ("DataRate", DataRateValue (5000000));
142  csma.SetChannelAttribute ("Delay", TimeValue (MilliSeconds (2)));
143  NetDeviceContainer ndc1 = csma.Install (net1);
144  NetDeviceContainer ndc2 = csma.Install (net2);
145  NetDeviceContainer ndc3 = csma.Install (net3);
146  NetDeviceContainer ndc4 = csma.Install (net4);
147  NetDeviceContainer ndc5 = csma.Install (net5);
148  NetDeviceContainer ndc6 = csma.Install (net6);
149  NetDeviceContainer ndc7 = csma.Install (net7);
150 
151  NS_LOG_INFO ("Create IPv6 and routing");
152  RipNgHelper ripNgRouting;
153 
154  // Rule of thumb:
155  // Interfaces are added sequentially, starting from 0
156  // However, interface 0 is always the loopback...
157  ripNgRouting.ExcludeInterface (a, 1);
158  ripNgRouting.ExcludeInterface (d, 3);
159 
160  ripNgRouting.SetInterfaceMetric (c, 3, 10);
161  ripNgRouting.SetInterfaceMetric (d, 1, 10);
162 
163  Ipv6ListRoutingHelper listRH;
164  listRH.Add (ripNgRouting, 0);
165  Ipv6StaticRoutingHelper staticRh;
166  listRH.Add (staticRh, 5);
167 
168  InternetStackHelper internetv6;
169  internetv6.SetIpv4StackInstall (false);
170  internetv6.SetRoutingHelper (listRH);
171  internetv6.Install (routers);
172 
173  InternetStackHelper internetv6Nodes;
174  internetv6Nodes.SetIpv4StackInstall (false);
175  internetv6Nodes.Install (nodes);
176 
177  // Assign addresses.
178  // The source and destination networks have global addresses
179  // The "core" network just needs link-local addresses for routing.
180  // We assign global addresses to the routers as well to receive
181  // ICMPv6 errors.
182  NS_LOG_INFO ("Assign IPv6 Addresses.");
183  Ipv6AddressHelper ipv6;
184 
185  ipv6.SetBase (Ipv6Address ("2001:1::"), Ipv6Prefix (64));
186  Ipv6InterfaceContainer iic1 = ipv6.Assign (ndc1);
187  iic1.SetForwarding (1, true);
188  iic1.SetDefaultRouteInAllNodes (1);
189 
190  ipv6.SetBase (Ipv6Address ("2001:0:1::"), Ipv6Prefix (64));
191  Ipv6InterfaceContainer iic2 = ipv6.Assign (ndc2);
192  iic2.SetForwarding (0, true);
193  iic2.SetForwarding (1, true);
194 
195  ipv6.SetBase (Ipv6Address ("2001:0:2::"), Ipv6Prefix (64));
196  Ipv6InterfaceContainer iic3 = ipv6.Assign (ndc3);
197  iic3.SetForwarding (0, true);
198  iic3.SetForwarding (1, true);
199 
200  ipv6.SetBase (Ipv6Address ("2001:0:3::"), Ipv6Prefix (64));
201  Ipv6InterfaceContainer iic4 = ipv6.Assign (ndc4);
202  iic4.SetForwarding (0, true);
203  iic4.SetForwarding (1, true);
204 
205  ipv6.SetBase (Ipv6Address ("2001:0:4::"), Ipv6Prefix (64));
206  Ipv6InterfaceContainer iic5 = ipv6.Assign (ndc5);
207  iic5.SetForwarding (0, true);
208  iic5.SetForwarding (1, true);
209 
210  ipv6.SetBase (Ipv6Address ("2001:0:5::"), Ipv6Prefix (64));
211  Ipv6InterfaceContainer iic6 = ipv6.Assign (ndc6);
212  iic6.SetForwarding (0, true);
213  iic6.SetForwarding (1, true);
214 
215  ipv6.SetBase (Ipv6Address ("2001:2::"), Ipv6Prefix (64));
216  Ipv6InterfaceContainer iic7 = ipv6.Assign (ndc7);
217  iic7.SetForwarding (0, true);
218  iic7.SetDefaultRouteInAllNodes (0);
219 
220  if (printRoutingTables)
221  {
222  RipNgHelper routingHelper;
223 
224  Ptr<OutputStreamWrapper> routingStream = Create<OutputStreamWrapper> (&std::cout);
225 
226  routingHelper.PrintRoutingTableAt (Seconds (30.0), a, routingStream);
227  routingHelper.PrintRoutingTableAt (Seconds (30.0), b, routingStream);
228  routingHelper.PrintRoutingTableAt (Seconds (30.0), c, routingStream);
229  routingHelper.PrintRoutingTableAt (Seconds (30.0), d, routingStream);
230 
231  routingHelper.PrintRoutingTableAt (Seconds (60.0), a, routingStream);
232  routingHelper.PrintRoutingTableAt (Seconds (60.0), b, routingStream);
233  routingHelper.PrintRoutingTableAt (Seconds (60.0), c, routingStream);
234  routingHelper.PrintRoutingTableAt (Seconds (60.0), d, routingStream);
235 
236  routingHelper.PrintRoutingTableAt (Seconds (90.0), a, routingStream);
237  routingHelper.PrintRoutingTableAt (Seconds (90.0), b, routingStream);
238  routingHelper.PrintRoutingTableAt (Seconds (90.0), c, routingStream);
239  routingHelper.PrintRoutingTableAt (Seconds (90.0), d, routingStream);
240  }
241 
242  NS_LOG_INFO ("Create Applications.");
243  uint32_t packetSize = 1024;
244  uint32_t maxPacketCount = 100;
245  Time interPacketInterval = Seconds (1.0);
246  Ping6Helper ping6;
247 
248  ping6.SetLocal (iic1.GetAddress (0, 1));
249  ping6.SetRemote (iic7.GetAddress (1, 1));
250  ping6.SetAttribute ("MaxPackets", UintegerValue (maxPacketCount));
251  ping6.SetAttribute ("Interval", TimeValue (interPacketInterval));
252  ping6.SetAttribute ("PacketSize", UintegerValue (packetSize));
253  ApplicationContainer apps = ping6.Install (src);
254  apps.Start (Seconds (1.0));
255  apps.Stop (Seconds (110.0));
256 
257  AsciiTraceHelper ascii;
258  csma.EnableAsciiAll (ascii.CreateFileStream ("ripng-simple-routing.tr"));
259  csma.EnablePcapAll ("ripng-simple-routing", true);
260 
261  Simulator::Schedule (Seconds (40), &TearDownLink, b, d, 3, 2);
262 
263  /* Now, do the actual simulation. */
264  NS_LOG_INFO ("Run Simulation.");
265  Simulator::Stop (Seconds (120));
266  Simulator::Run ();
267  Simulator::Destroy ();
268  NS_LOG_INFO ("Done.");
269 }
270 
ns3::NetDeviceContainer
holds a vector of ns3::NetDevice pointers
Definition: net-device-container.h:42
NS_LOG_COMPONENT_DEFINE
#define NS_LOG_COMPONENT_DEFINE(name)
Define a Log component with a specific name.
Definition: log.h:205
ns3::DataRateValue
AttributeValue implementation for DataRate.
Definition: data-rate.h:298
ns3::CommandLine
Parse command-line arguments.
Definition: command-line.h:228
ns3::LOG_LEVEL_INFO
@ LOG_LEVEL_INFO
LOG_INFO and above.
Definition: log.h:107
ns3::Ipv6ListRoutingHelper::Add
void Add(const Ipv6RoutingHelper &routing, int16_t priority)
Definition: ipv6-list-routing-helper.cc:56
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:59
ns3
Every class exported by the ns3 library is enclosed in the ns3 namespace.
ns3::ApplicationContainer::Stop
void Stop(Time stop)
Arrange for all of the Applications in this container to Stop() at the Time given as a parameter.
Definition: application-container.cc:107
ns3::Ipv6InterfaceContainer::SetForwarding
void SetForwarding(uint32_t i, bool state)
Set the state of the stack (act as a router or as an host) for the specified index.
Definition: ipv6-interface-container.cc:83
ns3::Ipv6ListRoutingHelper
Helper class that adds ns3::Ipv6ListRouting objects.
Definition: ipv6-list-routing-helper.h:40
ns3::Object::GetObject
Ptr< T > GetObject(void) const
Get a pointer to the requested aggregated Object.
Definition: object.h:470
ns3::Ping6Helper::SetLocal
void SetLocal(Ipv6Address ip)
Set the local IPv6 address.
Definition: ping6-helper.cc:35
ns3::LOG_LEVEL_ALL
@ LOG_LEVEL_ALL
Print everything.
Definition: log.h:116
ns3::LogComponentEnable
void LogComponentEnable(char const *name, enum LogLevel level)
Enable the logging output associated with that log component.
Definition: log.cc:361
ns3::RipNg::POISON_REVERSE
@ POISON_REVERSE
Poison Reverse Split Horizon.
Definition: ripng.h:210
ns3::Ipv6Address
Describes an IPv6 address.
Definition: ipv6-address.h:50
ns3::RipNgHelper::ExcludeInterface
void ExcludeInterface(Ptr< Node > node, uint32_t interface)
Exclude an interface from RIPng protocol.
Definition: ripng-helper.cc:159
ns3::Ipv6AddressHelper::SetBase
void SetBase(Ipv6Address network, Ipv6Prefix prefix, Ipv6Address base=Ipv6Address("::1"))
Set the base network number, network prefix, and base interface ID.
Definition: ipv6-address-helper.cc:69
ns3::Ipv6InterfaceContainer::SetDefaultRouteInAllNodes
void SetDefaultRouteInAllNodes(uint32_t router)
Set the default route for all the devices (except the router itself).
Definition: ipv6-interface-container.cc:89
ns3::RipNg::NO_SPLIT_HORIZON
@ NO_SPLIT_HORIZON
No Split Horizon.
Definition: ripng.h:208
ns3::Simulator::Schedule
static EventId Schedule(Time const &delay, FUNC f, Ts &&... args)
Schedule an event to expire after delay.
Definition: simulator.h:557
ns3::Ipv6AddressHelper
Helper class to auto-assign global IPv6 unicast addresses.
Definition: ipv6-address-helper.h:83
ns3::Ping6Helper::Install
ApplicationContainer Install(NodeContainer c)
Install the application in Nodes.
Definition: ping6-helper.cc:50
ns3::EnumValue
Hold variables of type enum.
Definition: enum.h:55
ns3::CsmaHelper
build a set of CsmaNetDevice objects
Definition: csma-helper.h:47
first.nodes
nodes
Definition: first.py:32
ns3::Ipv6AddressHelper::Assign
Ipv6InterfaceContainer Assign(const NetDeviceContainer &c)
Allocate an Ipv6InterfaceContainer with auto-assigned addresses.
Definition: ipv6-address-helper.cc:210
ns3::Ptr< Node >
ns3::Ping6Helper::SetRemote
void SetRemote(Ipv6Address ip)
Set the remote IPv6 address.
Definition: ping6-helper.cc:40
ns3::Simulator::Stop
static void Stop(void)
Tell the Simulator the calling event should be the last one executed.
Definition: simulator.cc:180
ns3::InternetStackHelper::Install
void Install(std::string nodeName) const
Aggregate implementations of the ns3::Ipv4, ns3::Ipv6, ns3::Udp, and ns3::Tcp classes onto the provid...
Definition: internet-stack-helper.cc:366
NS_LOG_INFO
#define NS_LOG_INFO(msg)
Use NS_LOG to output a message of level LOG_INFO.
Definition: log.h:281
ns3::AsciiTraceHelper::CreateFileStream
Ptr< OutputStreamWrapper > CreateFileStream(std::string filename, std::ios::openmode filemode=std::ios::out)
Create and initialize an output stream object we'll use to write the traced bits.
Definition: trace-helper.cc:191
TearDownLink
void TearDownLink(Ptr< Node > nodeA, Ptr< Node > nodeB, uint32_t interfaceA, uint32_t interfaceB)
Definition: ripng-simple-network.cc:66
ns3::MilliSeconds
Time MilliSeconds(uint64_t value)
Construct a Time in the indicated unit.
Definition: nstime.h:1297
ns3::Ipv6InterfaceContainer::GetAddress
Ipv6Address GetAddress(uint32_t i, uint32_t j) const
Get the address for the specified index.
Definition: ipv6-interface-container.cc:57
ns3::Ipv6InterfaceContainer
Keep track of a set of IPv6 interfaces.
Definition: ipv6-interface-container.h:42
ns3::Ping6Helper
Ping6 application helper.
Definition: ping6-helper.h:39
verbose
bool verbose
Definition: openflow-switch.cc:50
ns3::Time
Simulation virtual time values and global simulation resolution.
Definition: nstime.h:104
ns3::Ipv6StaticRoutingHelper
Helper class that adds ns3::Ipv6StaticRouting objects.
Definition: ipv6-static-routing-helper.h:44
second.cmd
cmd
Definition: second.py:35
ns3::Simulator::Run
static void Run(void)
Run the simulation.
Definition: simulator.cc:172
ns3::AsciiTraceHelper
Manage ASCII trace files for device models.
Definition: trace-helper.h:163
ns3::RipNg::SPLIT_HORIZON
@ SPLIT_HORIZON
Split Horizon.
Definition: ripng.h:209
packetSize
static const uint32_t packetSize
Definition: wifi-power-adaptation-distance.cc:113
ns3::ApplicationContainer::Start
void Start(Time start)
Arrange for all of the Applications in this container to Start() at the Time given as a parameter.
Definition: application-container.cc:87
ns3::Seconds
Time Seconds(double value)
Construct a Time in the indicated unit.
Definition: nstime.h:1289
ns3::InternetStackHelper::SetRoutingHelper
void SetRoutingHelper(const Ipv4RoutingHelper &routing)
Definition: internet-stack-helper.cc:175
ns3::Ping6Helper::SetAttribute
void SetAttribute(std::string name, const AttributeValue &value)
Set some attributes.
Definition: ping6-helper.cc:45
ns3::Simulator::Destroy
static void Destroy(void)
Execute the events scheduled with ScheduleDestroy().
Definition: simulator.cc:136
ns3::ApplicationContainer
holds a vector of ns3::Application pointers.
Definition: application-container.h:43
ns3::TimeValue
AttributeValue implementation for Time.
Definition: nstime.h:1353
ns3::NodeContainer
keep track of a set of node pointers.
Definition: node-container.h:39
ns3::Ipv6
Access to the IPv6 forwarding table, interfaces, and configuration.
Definition: ipv6.h:82
ns3::InternetStackHelper::SetIpv4StackInstall
void SetIpv4StackInstall(bool enable)
Enable/disable IPv4 stack install.
Definition: internet-stack-helper.cc:189
ns3::UintegerValue
Hold an unsigned integer type.
Definition: uinteger.h:44
ns3::Config::SetDefault
void SetDefault(std::string name, const AttributeValue &value)
Definition: config.cc:849
ns3::Ipv6Prefix
Describes an IPv6 prefix.
Definition: ipv6-address.h:456
ns3::InternetStackHelper
aggregate IP/TCP/UDP functionality to existing Nodes.
Definition: internet-stack-helper.h:88
ns3::RipNgHelper::SetInterfaceMetric
void SetInterfaceMetric(Ptr< Node > node, uint32_t interface, uint8_t metric)
Set a metric for an interface.
Definition: ripng-helper.cc:176
ns3::Names::Add
static void Add(std::string name, Ptr< Object > object)
Add the association between the string "name" and the Ptr<Object> obj.
Definition: names.cc:768
second.csma
csma
Definition: second.py:63
ns3::RipNgHelper
Helper class that adds RIPng routing to nodes.
Definition: ripng-helper.h:41