A Discrete-Event Network Simulator
API
ipv4-static-routing-test-suite.cc
Go to the documentation of this file.
1 /* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
2 /*
3  * This program is free software; you can redistribute it and/or modify
4  * it under the terms of the GNU General Public License version 2 as
5  * published by the Free Software Foundation;
6  *
7  * This program is distributed in the hope that it will be useful,
8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
10  * GNU General Public License for more details.
11  *
12  * You should have received a copy of the GNU General Public License
13  * along with this program; if not, write to the Free Software
14  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
15  */
16 
17 // End-to-end tests for Ipv4 static routing
18 
19 #include "ns3/boolean.h"
20 #include "ns3/config.h"
21 #include "ns3/inet-socket-address.h"
22 #include "ns3/internet-stack-helper.h"
23 #include "ns3/ipv4-address-helper.h"
24 #include "ns3/ipv4-static-routing-helper.h"
25 #include "ns3/node.h"
26 #include "ns3/node-container.h"
27 #include "ns3/packet.h"
28 #include "ns3/pointer.h"
29 #include "ns3/simulator.h"
30 #include "ns3/string.h"
31 #include "ns3/test.h"
32 #include "ns3/uinteger.h"
33 #include "ns3/simple-net-device.h"
34 #include "ns3/simple-channel.h"
35 #include "ns3/simple-net-device-helper.h"
36 #include "ns3/socket-factory.h"
37 #include "ns3/udp-socket-factory.h"
38 
39 using namespace ns3;
40 
48 {
49 public:
52 
54 
60  void DoSendData (Ptr<Socket> socket, std::string to);
66  void SendData (Ptr<Socket> socket, std::string to);
67 
72  void ReceivePkt (Ptr<Socket> socket);
73 
74 private:
75  virtual void DoRun (void);
76 };
77 
78 // Add some help text to this case to describe what it is intended to test
80  : TestCase ("Slash 32 static routing example")
81 {
82 }
83 
85 {
86 }
87 
88 void
90 {
91  uint32_t availableData;
92  availableData = socket->GetRxAvailable ();
94  NS_ASSERT (availableData == m_receivedPacket->GetSize ());
95  //cast availableData to void, to suppress 'availableData' set but not used
96  //compiler warning
97  (void) availableData;
98 }
99 
100 void
102 {
103  Address realTo = InetSocketAddress (Ipv4Address (to.c_str ()), 1234);
104  NS_TEST_EXPECT_MSG_EQ (socket->SendTo (Create<Packet> (123), 0, realTo),
105  123, "100");
106 }
107 
108 void
110 {
111  m_receivedPacket = Create<Packet> ();
112  Simulator::ScheduleWithContext (socket->GetNode ()->GetId (), Seconds (60),
114  Simulator::Stop (Seconds (66));
115  Simulator::Run ();
116 }
117 
118 // Test program for this 3-router scenario, using static routing
119 //
120 // (a.a.a.a/32)A<--x.x.x.0/30-->B<--y.y.y.0/30-->C(c.c.c.c/32)
121 //
122 void
124 {
125  Ptr<Node> nA = CreateObject<Node> ();
126  Ptr<Node> nB = CreateObject<Node> ();
127  Ptr<Node> nC = CreateObject<Node> ();
128 
129  NodeContainer c = NodeContainer (nA, nB, nC);
130 
131  InternetStackHelper internet;
132  internet.Install (c);
133 
134  // simple links
135  NodeContainer nAnB = NodeContainer (nA, nB);
136  NodeContainer nBnC = NodeContainer (nB, nC);
137 
138  SimpleNetDeviceHelper devHelper;
139 
140  Ptr<SimpleNetDevice> deviceA = CreateObject<SimpleNetDevice> ();
141  deviceA->SetAddress (Mac48Address::Allocate ());
142  nA->AddDevice (deviceA);
143 
144  NetDeviceContainer dAdB = devHelper.Install (nAnB);
145  NetDeviceContainer dBdC = devHelper.Install (nBnC);
146 
147  Ptr<SimpleNetDevice> deviceC = CreateObject<SimpleNetDevice> ();
148  deviceC->SetAddress (Mac48Address::Allocate ());
149  nC->AddDevice (deviceC);
150 
151  // Later, we add IP addresses.
152  Ipv4AddressHelper ipv4;
153  ipv4.SetBase ("10.1.1.0", "255.255.255.252");
154  Ipv4InterfaceContainer iAiB = ipv4.Assign (dAdB);
155 
156  ipv4.SetBase ("10.1.1.4", "255.255.255.252");
157  Ipv4InterfaceContainer iBiC = ipv4.Assign (dBdC);
158 
159  Ptr<Ipv4> ipv4A = nA->GetObject<Ipv4> ();
160  Ptr<Ipv4> ipv4B = nB->GetObject<Ipv4> ();
161  Ptr<Ipv4> ipv4C = nC->GetObject<Ipv4> ();
162 
163  int32_t ifIndexA = ipv4A->AddInterface (deviceA);
164  int32_t ifIndexC = ipv4C->AddInterface (deviceC);
165 
166  Ipv4InterfaceAddress ifInAddrA = Ipv4InterfaceAddress (Ipv4Address ("172.16.1.1"), Ipv4Mask ("/32"));
167  ipv4A->AddAddress (ifIndexA, ifInAddrA);
168  ipv4A->SetMetric (ifIndexA, 1);
169  ipv4A->SetUp (ifIndexA);
170 
171  Ipv4InterfaceAddress ifInAddrC = Ipv4InterfaceAddress (Ipv4Address ("192.168.1.1"), Ipv4Mask ("/32"));
172  ipv4C->AddAddress (ifIndexC, ifInAddrC);
173  ipv4C->SetMetric (ifIndexC, 1);
174  ipv4C->SetUp (ifIndexC);
175 
176  Ipv4StaticRoutingHelper ipv4RoutingHelper;
177  // Create static routes from A to C
178  Ptr<Ipv4StaticRouting> staticRoutingA = ipv4RoutingHelper.GetStaticRouting (ipv4A);
179  // The ifIndex for this outbound route is 1; the first p2p link added
180  staticRoutingA->AddHostRouteTo (Ipv4Address ("192.168.1.1"), Ipv4Address ("10.1.1.2"), 1);
181  Ptr<Ipv4StaticRouting> staticRoutingB = ipv4RoutingHelper.GetStaticRouting (ipv4B);
182  // The ifIndex we want on node B is 2; 0 corresponds to loopback, and 1 to the first point to point link
183  staticRoutingB->AddHostRouteTo (Ipv4Address ("192.168.1.1"), Ipv4Address ("10.1.1.6"), 2);
184 
185  // Create the UDP sockets
186  Ptr<SocketFactory> rxSocketFactory = nC->GetObject<UdpSocketFactory> ();
187  Ptr<Socket> rxSocket = rxSocketFactory->CreateSocket ();
188  NS_TEST_EXPECT_MSG_EQ (rxSocket->Bind (InetSocketAddress (Ipv4Address ("192.168.1.1"), 1234)), 0, "trivial");
189  rxSocket->SetRecvCallback (MakeCallback (&Ipv4StaticRoutingSlash32TestCase::ReceivePkt, this));
190 
191  Ptr<SocketFactory> txSocketFactory = nA->GetObject<UdpSocketFactory> ();
192  Ptr<Socket> txSocket = txSocketFactory->CreateSocket ();
193  txSocket->SetAllowBroadcast (true);
194 
195  // ------ Now the tests ------------
196 
197  // Unicast test
198  SendData (txSocket, "192.168.1.1");
199  NS_TEST_EXPECT_MSG_EQ (m_receivedPacket->GetSize (), 123, "Static routing with /32 did not deliver all packets.");
200 
201  Simulator::Destroy ();
202 }
203 
211 {
212 public:
214 };
215 
217  : TestSuite ("ipv4-static-routing", UNIT)
218 {
219  AddTestCase (new Ipv4StaticRoutingSlash32TestCase, TestCase::QUICK);
220 }
221 
virtual uint32_t AddInterface(Ptr< NetDevice > device)=0
an Inet address class
uint32_t GetId(void) const
Definition: node.cc:107
static Ipv4StaticRoutingTestSuite ipv4StaticRoutingTestSuite
Static variable for test initialization.
holds a vector of std::pair of Ptr<Ipv4> and interface index.
uint32_t GetSize(void) const
Returns the the size in bytes of the packet (including the zero-filled initial payload).
Definition: packet.h:852
virtual bool SetAllowBroadcast(bool allowBroadcast)=0
Configure whether broadcast datagram transmissions are allowed.
a class to represent an Ipv4 address mask
Definition: ipv4-address.h:263
A suite of tests to run.
Definition: test.h:1342
Ptr< Packet > m_receivedPacket
Received packet.
void DoSendData(Ptr< Socket > socket, std::string to)
Send data.
#define NS_ASSERT(condition)
At runtime, in debugging builds, if this condition is not true, the program prints the source file...
Definition: assert.h:67
aggregate IP/TCP/UDP functionality to existing Nodes.
#define NS_TEST_EXPECT_MSG_EQ(actual, limit, msg)
Test that an actual and expected (limit) value are equal and report if not.
Definition: test.h:285
virtual Ptr< Socket > CreateSocket(void)=0
encapsulates test code
Definition: test.h:1155
void AddHostRouteTo(Ipv4Address dest, Ipv4Address nextHop, uint32_t interface, uint32_t metric=0)
Add a host route to the static routing table.
a polymophic address class
Definition: address.h:90
#define max(a, b)
Definition: 80211b.c:43
void AddTestCase(TestCase *testCase, TestDuration duration=QUICK)
Add an individual child TestCase to this test suite.
Definition: test.cc:299
virtual void SetUp(uint32_t interface)=0
void ReceivePkt(Ptr< Socket > socket)
Receive data.
holds a vector of ns3::NetDevice pointers
Callback< R > MakeCallback(R(T::*memPtr)(void), OBJ objPtr)
Definition: callback.h:1489
Access to the IPv4 forwarding table, interfaces, and configuration.
Definition: ipv4.h:76
Ptr< T > GetObject(void) const
Get a pointer to the requested aggregated Object.
Definition: object.h:459
virtual void DoRun(void)
Implementation to actually run this TestCase.
Every class exported by the ns3 library is enclosed in the ns3 namespace.
void SendData(Ptr< Socket > socket, std::string to)
Send data.
keep track of a set of node pointers.
virtual Ptr< Packet > Recv(uint32_t maxSize, uint32_t flags)=0
Read data from the socket.
void Install(std::string nodeName) const
Aggregate implementations of the ns3::Ipv4, ns3::Ipv6, ns3::Udp, and ns3::Tcp classes onto the provid...
Ipv4 addresses are stored in host order in this class.
Definition: ipv4-address.h:41
Ipv4InterfaceContainer Assign(const NetDeviceContainer &c)
Assign IP addresses to the net devices specified in the container based on the current network prefix...
uint32_t AddDevice(Ptr< NetDevice > device)
Associate a NetDevice to this node.
Definition: node.cc:128
a class to store IPv4 address information on an interface
Helper class that adds ns3::Ipv4StaticRouting objects.
virtual Ptr< Node > GetNode(void) const =0
Return the node this socket is associated with.
virtual void SetAddress(Address address)
Set the address of this interface.
Time Seconds(double value)
Construct a Time in the indicated unit.
Definition: nstime.h:1062
virtual void SetMetric(uint32_t interface, uint16_t metric)=0
virtual bool AddAddress(uint32_t interface, Ipv4InterfaceAddress address)=0
virtual int SendTo(Ptr< Packet > p, uint32_t flags, const Address &toAddress)=0
Send data to a specified peer.
A helper class to make life easier while doing simple IPv4 address assignment in scripts.
API to create UDP socket instances.
build a set of SimpleNetDevice objects
NetDeviceContainer Install(Ptr< Node > node) const
This method creates an ns3::SimpleChannel with the attributes configured by SimpleNetDeviceHelper::Se...
Ptr< Ipv4StaticRouting > GetStaticRouting(Ptr< Ipv4 > ipv4) const
Try and find the static routing protocol as either the main routing protocol or in the list of routin...
void SetBase(Ipv4Address network, Ipv4Mask mask, Ipv4Address base="0.0.0.1")
Set the base network number, network mask and base address.
IPv4 StaticRouting /32 TestSuite.
virtual uint32_t GetRxAvailable(void) const =0
Return number of bytes which can be returned from one or multiple calls to Recv.