A Discrete-Event Network Simulator
API
ipv6-dual-stack-test-suite.cc
Go to the documentation of this file.
1 /* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
2 /*
3  * Copyright (c) 2007 Georgia Tech Research Corporation
4  * Copyright (c) 2009 INRIA
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License version 2 as
8  * published by the Free Software Foundation;
9  *
10  * This program is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13  * GNU General Public License for more details.
14  *
15  * You should have received a copy of the GNU General Public License
16  * along with this program; if not, write to the Free Software
17  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18  *
19  * Authors: Ken Renard <kenneth.d.renard.ctr@mail.mil>
20  *
21  */
22 
23 #include "ns3/test.h"
24 #include "ns3/socket-factory.h"
25 #include "ns3/tcp-socket-factory.h"
26 #include "ns3/simulator.h"
27 #include "ns3/simple-channel.h"
28 #include "ns3/simple-net-device.h"
29 #include "ns3/config.h"
30 #include "ns3/ipv4-static-routing.h"
31 #include "ns3/ipv4-list-routing.h"
32 #include "ns3/ipv6-static-routing.h"
33 #include "ns3/ipv6-list-routing.h"
34 #include "ns3/node.h"
35 #include "ns3/inet-socket-address.h"
36 #include "ns3/inet6-socket-address.h"
37 #include "ns3/uinteger.h"
38 #include "ns3/log.h"
39 
40 #include "ns3/arp-l3-protocol.h"
41 #include "ns3/ipv4-l3-protocol.h"
42 #include "ns3/ipv6-l3-protocol.h"
43 #include "ns3/icmpv4-l4-protocol.h"
44 #include "ns3/icmpv6-l4-protocol.h"
45 #include "ns3/udp-l4-protocol.h"
46 #include "ns3/tcp-l4-protocol.h"
47 #include "ns3/traffic-control-layer.h"
48 
49 #include <string>
50 
51 using namespace ns3;
52 
53 NS_LOG_COMPONENT_DEFINE ("Ipv6DualStackTestSuite");
54 
61 class DualStackTestCase : public TestCase
62 {
63 public:
64  DualStackTestCase ();
65 private:
66  virtual void DoRun (void);
67  virtual void DoTeardown (void);
68 
72  void SetUpSim ();
73 
74  Ptr<Node> node0;
75  Ptr<Node> node1;
76 
82  void ServerHandleConnectionCreated1 (Ptr<Socket> s, const Address & addr);
88  void ServerHandleConnectionCreated2 (Ptr<Socket> s, const Address & addr);
94  void ServerHandleConnectionCreated3 (Ptr<Socket> s, const Address & addr);
100  void ServerHandleConnectionCreated4 (Ptr<Socket> s, const Address & addr);
101 
102  Ptr<Socket> server1;
103  Ptr<Socket> server2;
104  Ptr<Socket> server3;
105  Ptr<Socket> server4;
106 
107  Ptr<Socket> source1;
108  Ptr<Socket> source2;
109  Ptr<Socket> source3;
110  Ptr<Socket> source4;
111 
112  Address receivedAddr1;
113  Address receivedAddr2;
114  Address receivedAddr3;
115  Address receivedAddr4;
116 };
117 
118 Ptr<Node>
119 CreateDualStackNode ()
120 {
121  Ptr<Node> node = CreateObject<Node> ();
122 
123  // Traffic Control
124  Ptr<TrafficControlLayer> tc = CreateObject<TrafficControlLayer> ();
125  node->AggregateObject (tc);
126 
127  //ARP
128  Ptr<ArpL3Protocol> arp = CreateObject<ArpL3Protocol> ();
129  node->AggregateObject (arp);
130  arp->SetTrafficControl (tc);
131 
132  //IPV4
133  Ptr<Ipv4L3Protocol> ipv4 = CreateObject<Ipv4L3Protocol> ();
134  //Routing for Ipv4
135  Ptr<Ipv4ListRouting> ipv4Routing = CreateObject<Ipv4ListRouting> ();
136  ipv4->SetRoutingProtocol (ipv4Routing);
137  Ptr<Ipv4StaticRouting> ipv4staticRouting = CreateObject<Ipv4StaticRouting> ();
138  ipv4Routing->AddRoutingProtocol (ipv4staticRouting, 0);
139  node->AggregateObject (ipv4);
140 
141  //ICMPv4
142  Ptr<Icmpv4L4Protocol> icmp = CreateObject<Icmpv4L4Protocol> ();
143  node->AggregateObject (icmp);
144 
145  //UDP
146  Ptr<UdpL4Protocol> udp = CreateObject<UdpL4Protocol> ();
147  node->AggregateObject (udp);
148 
149  //TCP
150  Ptr<TcpL4Protocol> tcp = CreateObject<TcpL4Protocol> ();
151  node->AggregateObject (tcp);
152 
153  //IPV6
154  Ptr<Ipv6L3Protocol> ipv6 = CreateObject<Ipv6L3Protocol> ();
155 
156  //Routing for Ipv6
157  Ptr<Ipv6ListRouting> ipv6Routing = CreateObject<Ipv6ListRouting> ();
158  ipv6->SetRoutingProtocol (ipv6Routing);
159  Ptr<Ipv6StaticRouting> ipv6staticRouting = CreateObject<Ipv6StaticRouting> ();
160  ipv6Routing->AddRoutingProtocol (ipv6staticRouting, 0);
161  node->AggregateObject (ipv6);
162 
163  //ICMPv6
164  Ptr<Icmpv6L4Protocol> icmp6 = CreateObject<Icmpv6L4Protocol> ();
165  node->AggregateObject (icmp6);
166 
167  //Ipv6 Extensions
168  ipv6->RegisterExtensions ();
169  ipv6->RegisterOptions ();
170 
171  return node;
172 }
173 
174 Ptr<SimpleNetDevice>
175 AddSimpleNetDevice (Ptr<Node> node, Ipv4Address v4Addr, Ipv4Mask v4Mask,
176  Ipv6Address v6Addr, Ipv6Prefix v6Prefix)
177 {
178  Ptr<SimpleNetDevice> dev = CreateObject<SimpleNetDevice> ();
179  dev->SetAddress (Mac48Address::ConvertFrom (Mac48Address::Allocate ()));
180  node->AddDevice (dev);
181 
182  Ptr<Ipv4> ipv4 = node->GetObject<Ipv4> ();
183  uint32_t ndid = ipv4->AddInterface (dev);
184  Ipv4InterfaceAddress ipv4Addr = Ipv4InterfaceAddress (v4Addr, v4Mask);
185  ipv4->AddAddress (ndid, ipv4Addr);
186  ipv4->SetUp (ndid);
187 
188  Ptr<Ipv6> ipv6 = node->GetObject<Ipv6> ();
189  ndid = ipv6->AddInterface (dev);
190  Ipv6InterfaceAddress ipv6Addr = Ipv6InterfaceAddress (v6Addr, v6Prefix);
191  ipv6->AddAddress (ndid, ipv6Addr);
192  ipv6->SetUp (ndid);
193 
194  return dev;
195 }
196 
197 void
198 DualStackTestCase::SetUpSim ()
199 {
200  node0 = CreateDualStackNode ();
201  node1 = CreateDualStackNode ();
202 
203  Ptr<SimpleNetDevice> dev0 = AddSimpleNetDevice(node0, Ipv4Address("10.0.0.1"),
204  Ipv4Mask(0xffffff00), Ipv6Address("2001::1"), Ipv6Prefix(64));
205  Ptr<SimpleNetDevice> dev1 = AddSimpleNetDevice(node1, Ipv4Address("10.0.0.2"),
206  Ipv4Mask(0xffffff00), Ipv6Address("2001::2"), Ipv6Prefix(64));
207 
208  Ptr<SimpleChannel> channel = CreateObject<SimpleChannel> ();
209  dev0->SetChannel (channel);
210  dev1->SetChannel (channel);
211 
212  Ptr<SocketFactory> sockFactory0 = node0->GetObject<TcpSocketFactory> ();
213  Ptr<SocketFactory> sockFactory1 = node1->GetObject<TcpSocketFactory> ();
214 
215  server1 = sockFactory0->CreateSocket ();
216  server2 = sockFactory0->CreateSocket ();
217  server3 = sockFactory0->CreateSocket ();
218  server4 = sockFactory0->CreateSocket ();
219 
220  source1 = sockFactory1->CreateSocket ();
221  source2 = sockFactory1->CreateSocket ();
222  source3 = sockFactory1->CreateSocket ();
223  source4 = sockFactory1->CreateSocket ();
224 
225  return;
226 }
227 
228 void
229 DualStackTestCase::ServerHandleConnectionCreated1 (Ptr<Socket> s, const Address & addr)
230 {
231  receivedAddr1 = addr;
232  return;
233 }
234 
235 void
236 DualStackTestCase::ServerHandleConnectionCreated2 (Ptr<Socket> s, const Address & addr)
237 {
238  receivedAddr2 = addr;
239  return;
240 }
241 
242 void
243 DualStackTestCase::ServerHandleConnectionCreated3 (Ptr<Socket> s, const Address & addr)
244 {
245  receivedAddr3 = addr;
246  return;
247 }
248 
249 void
250 DualStackTestCase::ServerHandleConnectionCreated4 (Ptr<Socket> s, const Address & addr)
251 {
252  receivedAddr4 = addr;
253  return;
254 }
255 
256 
257 DualStackTestCase::DualStackTestCase ()
258  : TestCase ("DualStackTestCase")
259 {
260  receivedAddr1 = Address ();
261  receivedAddr2 = Address ();
262  receivedAddr3 = Address ();
263  receivedAddr4 = Address ();
264 }
265 
266 void
267 DualStackTestCase::DoRun (void)
268 {
269  SetUpSim ();
270 
271  uint16_t port1 = 5000;
272  uint16_t port2 = 5001;
273  uint16_t port3 = 5002;
274  uint16_t port4 = 5003;
275 
276  /* Server 1: listen on 0.0.0.0 for IPv4 connection */
277  server1->Bind (InetSocketAddress(Ipv4Address::GetAny(), port1));
278  server1->Listen ();
279  server1->SetAcceptCallback (MakeNullCallback<bool, Ptr< Socket >, const Address &> (),
280  MakeCallback (&DualStackTestCase::ServerHandleConnectionCreated1, this));
281 
282  /* Server 2: listen on 0.0.0.0 for IPv4 connection - should reject IPv6 */
283  server2->Bind (InetSocketAddress(Ipv4Address::GetAny(), port2));
284  server2->Listen ();
285  server2->SetAcceptCallback (MakeNullCallback<bool, Ptr< Socket >, const Address &> (),
286  MakeCallback (&DualStackTestCase::ServerHandleConnectionCreated2, this));
287 
288  /* Server 3: listen on :: for IPv4 (mapped into IPv6 address) connection */
289  server3->Bind (Inet6SocketAddress(Ipv6Address::GetAny(), port3));
290  server3->Listen ();
291  server3->SetAcceptCallback (MakeNullCallback<bool, Ptr< Socket >, const Address &> (),
292  MakeCallback (&DualStackTestCase::ServerHandleConnectionCreated3, this));
293 
294  /* Server 4: listen on :: for IPv6 connection */
295  server4->Bind (Inet6SocketAddress(Ipv6Address::GetAny(), port4));
296  server4->Listen ();
297  server4->SetAcceptCallback (MakeNullCallback<bool, Ptr< Socket >, const Address &> (),
298  MakeCallback (&DualStackTestCase::ServerHandleConnectionCreated4, this));
299 
300 
301  /* Source 1: connect to server 1 via IPv4 */
302  source1->Connect(InetSocketAddress(Ipv4Address("10.0.0.1"), port1));
303 
304  /* Source 2: connect to server 2 via IPv6 */
305  source2->Connect(Inet6SocketAddress(Ipv6Address("2001::1"), port2));
306 
307  /* Source 3: connect to server 3 via IPv4 */
308  source3->Connect(InetSocketAddress(Ipv4Address("10.0.0.1"), port3));
309 
310  /* Source 4: connect to server 4 via IPv6 */
311  source4->Connect(Inet6SocketAddress(Ipv6Address("2001::1"), port4));
312 
313  Simulator::Run();
314 
315  /* Server 1: should have connection from Ipv4 address of Node 1 */
316  NS_TEST_EXPECT_MSG_EQ (InetSocketAddress::IsMatchingType(receivedAddr1), true, "Accepted address is of proper type");
317  NS_TEST_EXPECT_MSG_EQ(InetSocketAddress::ConvertFrom(receivedAddr1).GetIpv4 (), Ipv4Address("10.0.0.2"), "Accepted address is correct");
318 
319  /* Server 2: should have no connection */
320  NS_TEST_EXPECT_MSG_EQ(receivedAddr2.IsInvalid(), true, "IPv4 socket correctly ignored IPv6 connection");
321 
322  /* Server 3: should have connection from Ipv4-mapped IPv6 address of Node 1 */
323  NS_TEST_EXPECT_MSG_EQ (Inet6SocketAddress::IsMatchingType(receivedAddr3), true, "Accepted address is of proper type");
324  NS_TEST_EXPECT_MSG_EQ(Inet6SocketAddress::ConvertFrom(receivedAddr3).GetIpv6 (), Ipv6Address("::ffff:0a00:0002"), "Accepted address is correct");
325 
326  /* Server 4: should have connection from IPv6 address of Node 1 */
327  NS_TEST_EXPECT_MSG_EQ (Inet6SocketAddress::IsMatchingType(receivedAddr4), true, "Accepted address is of proper type");
328  NS_TEST_EXPECT_MSG_EQ(Inet6SocketAddress::ConvertFrom(receivedAddr4).GetIpv6 (), Ipv6Address("2001::2"), "Accepted address is correct");
329 }
330 
331 void
332 DualStackTestCase::DoTeardown (void)
333 {
334  Simulator::Destroy ();
335 }
336 
343 class Ipv6DualStackTestSuite : public TestSuite
344 {
345 public:
346  Ipv6DualStackTestSuite ()
347  : TestSuite ("ipv6-dual-stack", UNIT)
348  {
349  AddTestCase (new DualStackTestCase(), TestCase::QUICK);
350  }
351 };
352 
353 static Ipv6DualStackTestSuite g_ipv6DualStackTestSuite;
DualStackTestCase::ServerHandleConnectionCreated4
void ServerHandleConnectionCreated4(Ptr< Socket > s, const Address &addr)
Handle connection created (4).
Definition: ipv6-dual-stack-test-suite.cc:250
NS_LOG_COMPONENT_DEFINE
#define NS_LOG_COMPONENT_DEFINE(name)
Define a Log component with a specific name.
Definition: log.h:205
ns3::InetSocketAddress
an Inet address class
Definition: inet-socket-address.h:41
DualStackTestCase::server1
Ptr< Socket > server1
Server socket (1).
Definition: ipv6-dual-stack-test-suite.cc:102
ns3::Ipv6InterfaceAddress
IPv6 address associated with an interface.
Definition: ipv6-interface-address.h:38
DualStackTestCase::source2
Ptr< Socket > source2
Sending socket (2).
Definition: ipv6-dual-stack-test-suite.cc:108
ns3::TestCase::AddTestCase
void AddTestCase(TestCase *testCase, TestDuration duration=QUICK)
Add an individual child TestCase to this test suite.
Definition: test.cc:299
ns3::Ipv4ListRouting::AddRoutingProtocol
virtual void AddRoutingProtocol(Ptr< Ipv4RoutingProtocol > routingProtocol, int16_t priority)
Register a new routing protocol to be used in this IPv4 stack.
Definition: ipv4-list-routing.cc:253
DualStackTestCase::DualStackTestCase
DualStackTestCase()
Definition: ipv6-dual-stack-test-suite.cc:257
g_ipv6DualStackTestSuite
static Ipv6DualStackTestSuite g_ipv6DualStackTestSuite
Static variable for test initialization.
Definition: ipv6-dual-stack-test-suite.cc:353
ns3::Socket::Bind
virtual int Bind(const Address &address)=0
Allocate a local endpoint for this socket.
DualStackTestCase::receivedAddr2
Address receivedAddr2
Received address (2).
Definition: ipv6-dual-stack-test-suite.cc:113
ns3::Ipv6L3Protocol::RegisterOptions
virtual void RegisterOptions()
Register the IPv6 Options.
Definition: ipv6-l3-protocol.cc:1499
ns3
Every class exported by the ns3 library is enclosed in the ns3 namespace.
ns3::Ipv6::AddInterface
virtual uint32_t AddInterface(Ptr< NetDevice > device)=0
Add a NetDevice interface.
DualStackTestCase::source3
Ptr< Socket > source3
Sending socket (3).
Definition: ipv6-dual-stack-test-suite.cc:109
DualStackTestCase::source1
Ptr< Socket > source1
Sending socket (1).
Definition: ipv6-dual-stack-test-suite.cc:107
ns3::Ipv4::SetUp
virtual void SetUp(uint32_t interface)=0
DualStackTestCase::DoTeardown
virtual void DoTeardown(void)
Implementation to do any local setup required for this TestCase.
Definition: ipv6-dual-stack-test-suite.cc:332
ns3::Ipv4L3Protocol::SetRoutingProtocol
void SetRoutingProtocol(Ptr< Ipv4RoutingProtocol > routingProtocol)
Register a new routing protocol to be used by this Ipv4 stack.
Definition: ipv4-l3-protocol.cc:291
ns3::Object::GetObject
Ptr< T > GetObject(void) const
Get a pointer to the requested aggregated Object.
Definition: object.h:470
third.channel
channel
Definition: third.py:92
DualStackTestCase::receivedAddr3
Address receivedAddr3
Received address (3).
Definition: ipv6-dual-stack-test-suite.cc:114
ns3::Socket::SetAcceptCallback
void SetAcceptCallback(Callback< bool, Ptr< Socket >, const Address & > connectionRequest, Callback< void, Ptr< Socket >, const Address & > newConnectionCreated)
Accept connection requests from remote hosts.
Definition: socket.cc:104
DualStackTestCase::SetUpSim
void SetUpSim()
Setup the test.
Definition: ipv6-dual-stack-test-suite.cc:198
ns3::Ipv4Address
Ipv4 addresses are stored in host order in this class.
Definition: ipv4-address.h:41
ns3::Ipv6Address
Describes an IPv6 address.
Definition: ipv6-address.h:50
ns3::SimpleNetDevice::SetChannel
void SetChannel(Ptr< SimpleChannel > channel)
Attach a channel to this net device.
Definition: simple-net-device.cc:274
ns3::TcpSocketFactory
API to create TCP socket instances.
Definition: tcp-socket-factory.h:48
ns3::Ipv6::AddAddress
virtual bool AddAddress(uint32_t interface, Ipv6InterfaceAddress address, bool addOnLinkRoute=true)=0
Add an address on the specified IPv6 interface.
DualStackTestCase::ServerHandleConnectionCreated1
void ServerHandleConnectionCreated1(Ptr< Socket > s, const Address &addr)
Handle connection created (1).
Definition: ipv6-dual-stack-test-suite.cc:229
ns3::SimpleNetDevice::SetAddress
virtual void SetAddress(Address address)
Set the address of this interface.
Definition: simple-net-device.cc:323
ns3::Ipv6L3Protocol::RegisterExtensions
virtual void RegisterExtensions()
Register the IPv6 Extensions.
Definition: ipv6-l3-protocol.cc:1466
ns3::MakeNullCallback
Callback< R, Ts... > MakeNullCallback(void)
Definition: callback.h:1682
ns3::Ipv6L3Protocol::SetRoutingProtocol
void SetRoutingProtocol(Ptr< Ipv6RoutingProtocol > routingProtocol)
Set routing protocol for this stack.
Definition: ipv6-l3-protocol.cc:182
ns3::TestCase
encapsulates test code
Definition: test.h:1154
DualStackTestCase::receivedAddr4
Address receivedAddr4
Received address (4).
Definition: ipv6-dual-stack-test-suite.cc:115
ns3::Ipv4
Access to the IPv4 forwarding table, interfaces, and configuration.
Definition: ipv4.h:77
ns3::Ptr< Node >
ns3::Ipv4::AddInterface
virtual uint32_t AddInterface(Ptr< NetDevice > device)=0
Ipv6DualStackTestSuite::Ipv6DualStackTestSuite
Ipv6DualStackTestSuite()
Definition: ipv6-dual-stack-test-suite.cc:346
DualStackTestCase
IPv6 dual stack Test.
Definition: ipv6-dual-stack-test-suite.cc:62
DualStackTestCase::server2
Ptr< Socket > server2
Server socket (2).
Definition: ipv6-dual-stack-test-suite.cc:103
ns3::Address
a polymophic address class
Definition: address.h:91
ns3::Ipv4InterfaceAddress
a class to store IPv4 address information on an interface
Definition: ipv4-interface-address.h:44
DualStackTestCase::node0
Ptr< Node > node0
Node 0.
Definition: ipv6-dual-stack-test-suite.cc:74
ns3::Mac48Address::ConvertFrom
static Mac48Address ConvertFrom(const Address &address)
Definition: mac48-address.cc:126
ns3::Mac48Address::Allocate
static Mac48Address Allocate(void)
Allocate a new Mac48Address.
Definition: mac48-address.cc:135
ns3::Object::AggregateObject
void AggregateObject(Ptr< Object > other)
Aggregate two Objects together.
Definition: object.cc:252
ns3::Ipv6::SetUp
virtual void SetUp(uint32_t interface)=0
Set the interface into the "up" state.
NS_TEST_EXPECT_MSG_EQ
#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:283
ns3::Ipv6ListRouting::AddRoutingProtocol
virtual void AddRoutingProtocol(Ptr< Ipv6RoutingProtocol > routingProtocol, int16_t priority)
Register a new routing protocol to be used in this IPv4 stack.
Definition: ipv6-list-routing.cc:245
CreateDualStackNode
Ptr< Node > CreateDualStackNode()
Definition: ipv6-dual-stack-test-suite.cc:119
ns3::Node::AddDevice
uint32_t AddDevice(Ptr< NetDevice > device)
Associate a NetDevice to this node.
Definition: node.cc:130
ns3::SocketFactory::CreateSocket
virtual Ptr< Socket > CreateSocket(void)=0
ns3::MakeCallback
Callback< R, Ts... > MakeCallback(R(T::*memPtr)(Ts...), OBJ objPtr)
Build Callbacks for class method members which take varying numbers of arguments and potentially retu...
Definition: callback.h:1642
AddSimpleNetDevice
Ptr< SimpleNetDevice > AddSimpleNetDevice(Ptr< Node > node, Ipv4Address v4Addr, Ipv4Mask v4Mask, Ipv6Address v6Addr, Ipv6Prefix v6Prefix)
Definition: ipv6-dual-stack-test-suite.cc:175
ns3::TestSuite
A suite of tests to run.
Definition: test.h:1344
ns3::Socket::Listen
virtual int Listen(void)=0
Listen for incoming connections.
DualStackTestCase::ServerHandleConnectionCreated3
void ServerHandleConnectionCreated3(Ptr< Socket > s, const Address &addr)
Handle connection created (3).
Definition: ipv6-dual-stack-test-suite.cc:243
DualStackTestCase::server3
Ptr< Socket > server3
Server socket (3).
Definition: ipv6-dual-stack-test-suite.cc:104
DualStackTestCase::server4
Ptr< Socket > server4
Server socket (4).
Definition: ipv6-dual-stack-test-suite.cc:105
ns3::Socket::Connect
virtual int Connect(const Address &address)=0
Initiate a connection to a remote host.
ns3::TestSuite::UNIT
@ UNIT
This test suite implements a Unit Test.
Definition: test.h:1353
ns3::Address::IsInvalid
bool IsInvalid(void) const
Definition: address.cc:68
ns3::Inet6SocketAddress
An Inet6 address class.
Definition: inet6-socket-address.h:37
ns3::ArpL3Protocol::SetTrafficControl
void SetTrafficControl(Ptr< TrafficControlLayer > tc)
Set the TrafficControlLayer.
Definition: arp-l3-protocol.cc:102
ns3::Ipv4Mask
a class to represent an Ipv4 address mask
Definition: ipv4-address.h:256
Ipv6DualStackTestSuite
IPv6 dual stack TestSuite.
Definition: ipv6-dual-stack-test-suite.cc:344
ns3::Ipv6
Access to the IPv6 forwarding table, interfaces, and configuration.
Definition: ipv6.h:82
DualStackTestCase::source4
Ptr< Socket > source4
Sending socket (4).
Definition: ipv6-dual-stack-test-suite.cc:110
ns3::Socket::CreateSocket
static Ptr< Socket > CreateSocket(Ptr< Node > node, TypeId tid)
This method wraps the creation of sockets that is performed on a given node by a SocketFactory specif...
Definition: socket.cc:71
DualStackTestCase::node1
Ptr< Node > node1
Node 1.
Definition: ipv6-dual-stack-test-suite.cc:75
DualStackTestCase::DoRun
virtual void DoRun(void)
Implementation to actually run this TestCase.
Definition: ipv6-dual-stack-test-suite.cc:267
ns3::Ipv6Prefix
Describes an IPv6 prefix.
Definition: ipv6-address.h:456
DualStackTestCase::ServerHandleConnectionCreated2
void ServerHandleConnectionCreated2(Ptr< Socket > s, const Address &addr)
Handle connection created (2).
Definition: ipv6-dual-stack-test-suite.cc:236
ns3::Ipv4::AddAddress
virtual bool AddAddress(uint32_t interface, Ipv4InterfaceAddress address)=0
DualStackTestCase::receivedAddr1
Address receivedAddr1
Received address (1).
Definition: ipv6-dual-stack-test-suite.cc:112