A Discrete-Event Network Simulator
API
ns3tcp-state-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) 2010 University of Washington
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 
19 #include <iomanip>
20 #include <string>
21 
22 #include "ns3/log.h"
23 #include "ns3/abort.h"
24 #include "ns3/test.h"
25 #include "ns3/pcap-file.h"
26 #include "ns3/config.h"
27 #include "ns3/string.h"
28 #include "ns3/uinteger.h"
29 #include "ns3/boolean.h"
30 #include "ns3/data-rate.h"
31 #include "ns3/inet-socket-address.h"
32 #include "ns3/point-to-point-helper.h"
33 #include "ns3/internet-stack-helper.h"
34 #include "ns3/ipv4-global-routing-helper.h"
35 #include "ns3/ipv4-address-helper.h"
36 #include "ns3/packet-sink-helper.h"
37 #include "ns3/tcp-socket-factory.h"
38 #include "ns3/node-container.h"
39 #include "ns3/simulator.h"
40 #include "ns3/error-model.h"
41 #include "ns3/pointer.h"
42 #include "ns3tcp-socket-writer.h"
43 #include "ns3/tcp-header.h"
44 
45 using namespace ns3;
46 
47 NS_LOG_COMPONENT_DEFINE ("Ns3TcpStateTest");
48 
49 // The below boolean constants should only be changed to 'true'
50 // during test debugging (i.e. do not commit the value 'true')
51 
52 // set to 'true' to have the test suite overwrite the response vectors
53 // stored in the test directory. This should only be done if you are
54 // convinced through other means (e.g. pcap tracing or logging) that the
55 // revised vectors are the correct ones. In other words, don't simply
56 // enable this to true to clear a failing test without looking at the
57 // results closely.
58 const bool WRITE_VECTORS = false; // set to true to write response vectors
59 const bool WRITE_PCAP = false; // set to true to write out pcap
60 const bool WRITE_LOGGING = false; // set to true to write logging
61 const uint32_t PCAP_LINK_TYPE = 1187373554; // Some large random number -- we use to verify data was written by this program
62 const uint32_t PCAP_SNAPLEN = 64; // Don't bother to save much data
63 
64 // ===========================================================================
65 // Tests of TCP implementation state machine behavior
66 // ===========================================================================
67 //
68 
70 {
71 public:
73  Ns3TcpStateTestCase (uint32_t testCase);
75  {
76  }
77 
78 private:
79  virtual void DoSetup (void);
80  virtual void DoRun (void);
81  virtual void DoTeardown (void);
82 
83  std::string m_pcapFilename;
85  uint32_t m_testCase;
86  uint32_t m_totalTxBytes;
87  uint32_t m_currentTxBytes;
92 
93  void Ipv4L3Tx (std::string context, Ptr<const Packet> packet, Ptr<Ipv4> ipv4, uint32_t interface);
94  void Ipv4L3Rx (std::string context, Ptr<const Packet> packet, Ptr<Ipv4> ipv4, uint32_t interface);
95  void WriteUntilBufferFull (Ptr<Socket> localSocket, uint32_t txSpace);
96  void StartFlow (Ptr<Socket> localSocket,
97  Ipv4Address servAddress,
98  uint16_t servPort);
99 
100 };
101 
103  : TestCase ("Check the operation of the TCP state machine for several cases"),
104  m_testCase (0),
105  m_totalTxBytes (20000),
106  m_currentTxBytes (0),
107  m_writeVectors (WRITE_VECTORS),
108  m_writeResults (WRITE_PCAP),
109  m_writeLogging (WRITE_LOGGING),
110  m_needToClose (true)
111 {
112 }
113 
115  : TestCase ("Check the operation of the TCP state machine for several cases"),
116  m_testCase (testCase),
117  m_totalTxBytes (20000),
118  m_currentTxBytes (0),
122  m_needToClose (true)
123 {
124 }
125 
126 void
128 {
129  //
130  // We expect there to be a file called ns3tcp-state-response-vectors.pcap in
131  // the data directory
132  //
133  std::ostringstream oss;
134  oss << "ns3tcp-state" << m_testCase << "-response-vectors.pcap";
135  m_pcapFilename = CreateDataDirFilename (oss.str ());
136  NS_LOG_INFO ("m_pcapFilename=" << m_pcapFilename);
137 
138  if (m_writeVectors)
139  {
140  m_pcapFile.Open (m_pcapFilename, std::ios::out | std::ios::binary);
142  }
143  else
144  {
145  m_pcapFile.Open (m_pcapFilename, std::ios::in | std::ios::binary);
147  "Wrong response vectors in directory: opening " <<
149  }
150 }
151 
152 void
154 {
155  m_pcapFile.Close ();
156 }
157 
158 void
159 Ns3TcpStateTestCase::Ipv4L3Rx (std::string context, Ptr<const Packet> packet, Ptr<Ipv4> ipv4, uint32_t interface)
160 {
161  Ptr<Packet> received = packet->Copy ();
162  Ipv4Header ipHeader;
163  TcpHeader tcpHeader;
164  received->RemoveHeader (ipHeader);
165  received->RemoveHeader (tcpHeader);
166 
167  NS_LOG_DEBUG ("Received: " << tcpHeader);
168 }
169 
170 void
171 Ns3TcpStateTestCase::Ipv4L3Tx (std::string context, Ptr<const Packet> packet, Ptr<Ipv4> ipv4, uint32_t interface)
172 {
173  //
174  // We're not testing IP so remove and toss the header. In order to do this,
175  // though, we need to copy the packet since we have a const version.
176  //
177  Ptr<Packet> received = packet->Copy ();
178  Ipv4Header ipHeader;
179  received->RemoveHeader (ipHeader);
180 
181  //
182  // What is left is the TCP header and any data that may be sent. We aren't
183  // sending any TCP data, so we expect what remains is only TCP header, which
184  // is a small thing to save.
185  //
186  if (m_writeVectors)
187  {
188  //
189  // Save the TCP under test response for later testing.
190  //
191  Time tNow = Simulator::Now ();
192  int64_t tMicroSeconds = tNow.GetMicroSeconds ();
193 
194  m_pcapFile.Write (uint32_t (tMicroSeconds / 1000000),
195  uint32_t (tMicroSeconds % 1000000),
196  received);
197  }
198  else
199  {
200  //
201  // Read the TCP under test expected response from the expected vector
202  // file and see if it still does the right thing.
203  //
204  uint8_t expectedBuffer[PCAP_SNAPLEN];
205  uint32_t tsSec, tsUsec, inclLen, origLen, readLen;
206  m_pcapFile.Read (expectedBuffer, sizeof(expectedBuffer), tsSec, tsUsec, inclLen, origLen, readLen);
207 
208  NS_LOG_INFO ("read " << readLen << " bytes");
209 
210  uint8_t *actual = new uint8_t[readLen];
211  received->CopyData (actual, readLen);
212 
213  int result = memcmp (actual, expectedBuffer, readLen);
214 
215  TcpHeader expectedHeader, receivedHeader;
216  Ptr<Packet> expected = Create<Packet> (expectedBuffer, readLen);
217 
218  expected->RemoveHeader (expectedHeader);
219  received->RemoveHeader (receivedHeader);
220 
221  NS_LOG_DEBUG ("Expected " << expectedHeader << " received: " << receivedHeader);
222 
223  delete [] actual;
224 
225  //
226  // Avoid streams of errors -- only report the first.
227  //
228  if (IsStatusSuccess ())
229  {
230  NS_TEST_EXPECT_MSG_EQ (result, 0, "Expected data comparison error");
231  }
232  }
233 }
234 
236 // Implementing an "application" to send bytes over a TCP connection
237 void
239 {
241  {
242  uint32_t left = m_totalTxBytes - m_currentTxBytes;
243  uint32_t dataOffset = m_currentTxBytes % 1040;
244  uint32_t toWrite = 1040 - dataOffset;
245  uint32_t txAvail = localSocket->GetTxAvailable ();
246  toWrite = std::min (toWrite, left);
247  toWrite = std::min (toWrite, txAvail);
248  if (txAvail == 0)
249  {
250  return;
251  }
252  if (m_writeLogging)
253  {
254  std::clog << "Submitting "
255  << toWrite << " bytes to TCP socket" << std::endl;
256  }
257  int amountSent = localSocket->Send (0, toWrite, 0);
258  NS_ASSERT (amountSent > 0); // Given GetTxAvailable() non-zero, amountSent should not be zero
259  m_currentTxBytes += amountSent;
260  }
261  if (m_needToClose)
262  {
263  if (m_writeLogging)
264  {
265  std::clog << "Close socket at "
266  << Simulator::Now ().GetSeconds ()
267  << std::endl;
268  }
269  localSocket->Close ();
270  m_needToClose = false;
271  }
272 }
273 
274 void
276  Ipv4Address servAddress,
277  uint16_t servPort)
278 {
279  if (m_writeLogging)
280  {
281  std::clog << "Starting flow at time "
282  << Simulator::Now ().GetSeconds ()
283  << std::endl;
284  }
285 
286  localSocket->Connect (InetSocketAddress (servAddress, servPort)); // connect
287 
288  // tell the tcp implementation to call WriteUntilBufferFull again
289  // if we blocked and new tx buffer space becomes available
290  localSocket->SetSendCallback (MakeCallback
292  this));
293  WriteUntilBufferFull (localSocket, localSocket->GetTxAvailable ());
294 }
295 
296 void
298 {
299  // Network topology
300  //
301  // 10Mb/s, 0.1ms 10Mb/s, 0.1ms
302  // n0-----------------n1-----------------n2
303 
304  std::string tcpModel ("ns3::TcpNewReno");
305 
306  Config::SetDefault ("ns3::TcpSocketBase::Sack", BooleanValue (false));
307  Config::SetDefault ("ns3::TcpL4Protocol::SocketType", StringValue (tcpModel));
308  Config::SetDefault ("ns3::TcpSocket::SegmentSize", UintegerValue (1000));
309  Config::SetDefault ("ns3::TcpSocket::DelAckCount", UintegerValue (1));
310  Config::SetDefault ("ns3::QueueBase::MaxSize", StringValue ("20p"));
311  Config::SetDefault ("ns3::TcpSocketBase::Timestamp", BooleanValue (false));
312 
313  if (m_writeLogging)
314  {
316  LogComponentEnable ("ErrorModel", LOG_LEVEL_DEBUG);
317  LogComponentEnable ("Ns3TcpStateTest", LOG_LEVEL_DEBUG);
318  LogComponentEnable ("TcpCongestionOps", LOG_LEVEL_INFO);
319  LogComponentEnable ("TcpSocketBase", LOG_LEVEL_INFO);
320  }
321 
323  // Topology construction
324  //
325 
326  // Create three nodes
327  NodeContainer n0n1;
328  n0n1.Create (2);
329 
331  n1n2.Add (n0n1.Get (1));
332  n1n2.Create (1);
333 
334  // Set up TCP/IP stack to all nodes (and create loopback device at device 0)
335  InternetStackHelper internet;
336  internet.InstallAll ();
337 
338  // Connect the nodes
339  PointToPointHelper p2p;
340  p2p.SetDeviceAttribute ("DataRate", DataRateValue (DataRate (1000000)));
341  p2p.SetChannelAttribute ("Delay", TimeValue (Seconds (0.0001)));
342  NetDeviceContainer dev0 = p2p.Install (n0n1);
343  NetDeviceContainer dev1 = p2p.Install (n1n2);
344 
345  // Add IP addresses to each network interfaces
346  Ipv4AddressHelper ipv4;
347  ipv4.SetBase ("10.1.3.0", "255.255.255.0");
348  ipv4.Assign (dev0);
349  ipv4.SetBase ("10.1.2.0", "255.255.255.0");
350  Ipv4InterfaceContainer ipInterfs = ipv4.Assign (dev1);
351 
352  // Set up routes to all nodes
353  Ipv4GlobalRoutingHelper::PopulateRoutingTables ();
354 
356  // A flow from node n0 to node n2
357  //
358 
359  // Create a packet sink to receive packets on node n2
360  uint16_t servPort = 50000; // Destination port number
361  PacketSinkHelper sink ("ns3::TcpSocketFactory", InetSocketAddress (Ipv4Address::GetAny (), servPort));
362  ApplicationContainer sinkApps = sink.Install (n1n2.Get (1));
363  sinkApps.Start (Seconds (0.0));
364  sinkApps.Stop (Seconds (100.0));
365 
366  // Create a data source to send packets on node n0
367  // Instead of full application, here use the socket directly by
368  // registering callbacks in function StarFlow().
369  Ptr<Socket> localSocket = Socket::CreateSocket (n0n1.Get (0),
370  TcpSocketFactory::GetTypeId ());
371  localSocket->Bind ();
372  Simulator::ScheduleNow (&Ns3TcpStateTestCase::StartFlow, this,
373  localSocket, ipInterfs.GetAddress (1), servPort);
374 
375  Config::Connect ("/NodeList/0/$ns3::Ipv4L3Protocol/Tx",
377 
378  Config::Connect ("/NodeList/0/$ns3::Ipv4L3Protocol/Rx",
380 
382  // Set up different test cases: Lost model at node n1, different file size
383  //
384 
385  std::list<uint32_t> dropListN0;
386  std::list<uint32_t> dropListN1;
387  std::string caseDescription;
388  switch (m_testCase)
389  {
390  case 0:
391  m_totalTxBytes = 1000;
392  caseDescription = "Verify connection establishment";
393  break;
394  case 1:
395  m_totalTxBytes = 100 * 1000;
396  caseDescription = "Verify a bigger (100 pkts) transfer: Sliding window operation, etc.";
397  break;
398  case 2:
399  m_totalTxBytes = 1000;
400  caseDescription = "Survive a SYN lost";
401  dropListN0.push_back (0);
402  break;
403  case 3:
404  m_totalTxBytes = 2000;
405  caseDescription = "Survive a SYN+ACK lost";
406  dropListN1.push_back (0);
407  break;
408  case 4:
409  m_totalTxBytes = 2000;
410  caseDescription = "Survive a ACK (last packet in 3-way handshake) lost";
411  dropListN0.push_back (1);
412  break;
413  case 5:
414  m_totalTxBytes = 0;
415  caseDescription = "Immediate FIN upon SYN_RCVD";
416  m_needToClose = false;
417  dropListN0.push_back (1); // Hide the ACK in 3WHS
418  Simulator::Schedule (Seconds (0.002), &Socket::Close, localSocket);
419  break;
420  case 6:
421  m_totalTxBytes = 5000;
422  caseDescription = "Simulated simultaneous close";
423  dropListN1.push_back (5); // Hide the ACK-to-FIN from n2
424  break;
425  case 7:
426  m_totalTxBytes = 5000;
427  caseDescription = "FIN check 1: Loss of initiator's FIN. Wait until app close";
428  m_needToClose = false;
429  dropListN0.push_back (7); // Hide the FIN from n0
430  Simulator::Schedule (Seconds (0.04), &Socket::Close, localSocket);
431  break;
432  case 8:
433  m_totalTxBytes = 5000;
434  caseDescription = "FIN check 2: Loss responder's FIN. FIN will be resent after last ack timeout";
435  dropListN1.push_back (6); // Hide the FIN from n2
436  break;
437  default:
438  NS_FATAL_ERROR ("Program fatal error: specified test case not supported: "
439  << m_testCase);
440  break;
441  }
442 
443  Ptr<ReceiveListErrorModel> errN0 = CreateObject<ReceiveListErrorModel> ();
444  errN0->SetList (dropListN0);
445  dev0.Get (1)->SetAttribute ("ReceiveErrorModel", PointerValue (errN0));
446 
447  Ptr<ReceiveListErrorModel> errN1 = CreateObject<ReceiveListErrorModel> ();
448  errN1->SetList (dropListN1);
449  dev1.Get (0)->SetAttribute ("ReceiveErrorModel", PointerValue (errN1));
450 
451  std::ostringstream oss;
452  oss << "tcp-state" << m_testCase << "-test-case";
453  if (m_writeResults)
454  {
455  p2p.EnablePcapAll (oss.str ());
456  p2p.EnableAsciiAll (oss.str ());
457  }
458 
459  if (m_writeLogging)
460  {
461  Ptr<OutputStreamWrapper> osw = Create<OutputStreamWrapper> (&std::clog);
462  *(osw->GetStream ()) << std::setprecision (9) << std::fixed;
463  p2p.EnableAsciiAll (osw);
464 
465  std::clog << std::endl << "Running TCP test-case " << m_testCase << ": "
466  << caseDescription << std::endl;
467  }
468 
469  // Finally, set up the simulator to run. The 1000 second hard limit is a
470  // failsafe in case some change above causes the simulation to never end
471  Simulator::Stop (Seconds (1000));
472  Simulator::Run ();
473  Simulator::Destroy ();
474 }
475 
477 {
478 public:
480 };
481 
483  : TestSuite ("ns3-tcp-state", SYSTEM)
484 {
485  // We can't use NS_TEST_SOURCEDIR variable here because we use subdirectories
486  SetDataDir ("src/test/ns3tcp/response-vectors");
487  Packet::EnablePrinting (); // Enable packet metadata for all test cases
488 
489  AddTestCase (new Ns3TcpStateTestCase (0), TestCase::QUICK);
490  AddTestCase (new Ns3TcpStateTestCase (1), TestCase::QUICK);
491  AddTestCase (new Ns3TcpStateTestCase (2), TestCase::QUICK);
492  AddTestCase (new Ns3TcpStateTestCase (3), TestCase::QUICK);
493  AddTestCase (new Ns3TcpStateTestCase (4), TestCase::QUICK);
494  AddTestCase (new Ns3TcpStateTestCase (5), TestCase::QUICK);
495  AddTestCase (new Ns3TcpStateTestCase (6), TestCase::QUICK);
496  AddTestCase (new Ns3TcpStateTestCase (7), TestCase::QUICK);
497  AddTestCase (new Ns3TcpStateTestCase (8), TestCase::QUICK);
498 }
499 
uint32_t RemoveHeader(Header &header)
Deserialize and remove the header from the internal buffer.
Definition: packet.cc:280
Ptr< PacketSink > sink
Definition: wifi-tcp.cc:56
holds a vector of ns3::Application pointers.
Simulation virtual time values and global simulation resolution.
Definition: nstime.h:102
an Inet address class
AttributeValue implementation for Boolean.
Definition: boolean.h:36
holds a vector of std::pair of Ptr<Ipv4> and interface index.
Hold variables of type string.
Definition: string.h:41
Ptr< NetDevice > Get(uint32_t i) const
Get the Ptr<NetDevice> stored in this container at a given index.
#define min(a, b)
Definition: 80211b.c:42
NetDeviceContainer Install(NodeContainer c)
A suite of tests to run.
Definition: test.h:1342
void Init(uint32_t dataLinkType, uint32_t snapLen=SNAPLEN_DEFAULT, int32_t timeZoneCorrection=ZONE_DEFAULT, bool swapMode=false, bool nanosecMode=false)
Initialize the pcap file associated with this object.
Definition: pcap-file.cc:345
#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
#define NS_LOG_COMPONENT_DEFINE(name)
Define a Log component with a specific name.
Definition: log.h:202
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
#define NS_LOG_INFO(msg)
Use NS_LOG to output a message of level LOG_INFO.
Definition: log.h:278
#define NS_FATAL_ERROR(msg)
Report a fatal error with a message and terminate.
Definition: fatal-error.h:162
A helper to make it easier to instantiate an ns3::PacketSinkApplication on a set of nodes...
Build a set of PointToPointNetDevice objects.
encapsulates test code
Definition: test.h:1155
void StartFlow(Ptr< Socket > localSocket, Ipv4Address servAddress, uint16_t servPort)
void SetDeviceAttribute(std::string name, const AttributeValue &value)
Set an attribute value to be propagated to each NetDevice created by the helper.
void StartFlow(Ptr< Socket >, Ipv4Address, uint16_t)
void WriteUntilBufferFull(Ptr< Socket > localSocket, uint32_t txSpace)
Class for representing data rates.
Definition: data-rate.h:88
Packet header for IPv4.
Definition: ipv4-header.h:33
double GetSeconds(void) const
Get an approximation of the time stored in this instance in the indicated unit.
Definition: nstime.h:355
void LogComponentEnable(char const *name, enum LogLevel level)
Enable the logging output associated with that log component.
Definition: log.cc:369
void Ipv4L3Rx(std::string context, Ptr< const Packet > packet, Ptr< Ipv4 > ipv4, uint32_t interface)
void EnablePcapAll(std::string prefix, bool promiscuous=false)
Enable pcap output on each device (which is of the appropriate type) in the set of all nodes created ...
int64_t GetMicroSeconds(void) const
Get an approximation of the time stored in this instance in the indicated unit.
Definition: nstime.h:363
void InstallAll(void) const
Aggregate IPv4, IPv6, UDP, and TCP stacks to all nodes in the simulation.
AttributeValue implementation for Time.
Definition: nstime.h:1069
A class representing a pcap file.
Definition: pcap-file.h:42
void AddTestCase(TestCase *testCase, TestDuration duration=QUICK)
Add an individual child TestCase to this test suite.
Definition: test.cc:299
void Read(uint8_t *const data, uint32_t maxBytes, uint32_t &tsSec, uint32_t &tsUsec, uint32_t &inclLen, uint32_t &origLen, uint32_t &readLen)
Read next packet from file.
Definition: pcap-file.cc:469
Hold an unsigned integer type.
Definition: uinteger.h:44
LOG_INFO and above.
Definition: log.h:104
holds a vector of ns3::NetDevice pointers
Callback< R > MakeCallback(R(T::*memPtr)(void), OBJ objPtr)
Definition: callback.h:1489
void Start(Time start)
Arrange for all of the Applications in this container to Start() at the Time given as a parameter...
void Connect(std::string path, const CallbackBase &cb)
Definition: config.cc:843
virtual void DoRun(void)
Implementation to actually run this TestCase.
virtual void DoTeardown(void)
Implementation to do any local setup required for this TestCase.
virtual int Connect(const Address &address)=0
Initiate a connection to a remote host.
Ptr< Packet > Copy(void) const
performs a COW copy of the packet.
Definition: packet.cc:121
void LogComponentEnableAll(enum LogLevel level)
Enable the logging output for all registered log components.
Definition: log.cc:393
virtual int Bind(const Address &address)=0
Allocate a local endpoint for this socket.
Every class exported by the ns3 library is enclosed in the ns3 namespace.
keep track of a set of node pointers.
Hold objects of type Ptr<T>.
Definition: pointer.h:36
std::string CreateDataDirFilename(std::string filename)
Construct the full path to a file in the data directory.
Definition: test.cc:412
Header for the Transmission Control Protocol.
Definition: tcp-header.h:44
void WriteUntilBufferFull(Ptr< Socket >, uint32_t)
void SetList(const std::list< uint32_t > &packetlist)
Definition: error-model.cc:520
const uint32_t PCAP_LINK_TYPE
virtual void DoSetup(void)
Implementation to do any local setup required for this TestCase.
void Close(void)
Close the underlying file.
Definition: pcap-file.cc:88
void SetSendCallback(Callback< void, Ptr< Socket >, uint32_t > sendCb)
Notify application when space in transmit buffer is added.
Definition: socket.cc:121
static Ns3TcpStateTestSuite ns3TcpLossTestSuite
bool IsStatusSuccess(void) const
Check if all tests passed.
Definition: test.cc:458
void Open(std::string const &filename, std::ios::openmode mode)
Create a new pcap file or open an existing pcap file.
Definition: pcap-file.cc:325
const bool WRITE_LOGGING
void SetChannelAttribute(std::string name, const AttributeValue &value)
Set an attribute value to be propagated to each Channel created by the helper.
Ipv4 addresses are stored in host order in this class.
Definition: ipv4-address.h:40
void Stop(Time stop)
Arrange for all of the Applications in this container to Stop() at the Time given as a parameter...
Ipv4InterfaceContainer Assign(const NetDeviceContainer &c)
Assign IP addresses to the net devices specified in the container based on the current network prefix...
LOG_DEBUG and above.
Definition: log.h:101
void Add(NodeContainer other)
Append the contents of another NodeContainer to the end of this container.
#define NS_ABORT_MSG_UNLESS(cond, msg)
Abnormal program termination if a condition is false, with a message.
Definition: abort.h:144
AttributeValue implementation for DataRate.
Definition: data-rate.h:242
Prefix all trace prints with function.
Definition: log.h:115
Ptr< Node > Get(uint32_t i) const
Get the Ptr<Node> stored in this container at a given index.
#define NS_LOG_DEBUG(msg)
Use NS_LOG to output a message of level LOG_DEBUG.
Definition: log.h:270
Time Seconds(double value)
Construct a Time in the indicated unit.
Definition: nstime.h:1007
void SetDefault(std::string name, const AttributeValue &value)
Definition: config.cc:782
void SetDataDir(std::string directory)
Set the data directory where reference trace files can be found.
Definition: test.cc:465
uint32_t CopyData(uint8_t *buffer, uint32_t size) const
Copy the packet contents to a byte buffer.
Definition: packet.cc:378
ApplicationContainer Install(NodeContainer c) const
Install an ns3::PacketSinkApplication on each node of the input container configured with all the att...
A helper class to make life easier while doing simple IPv4 address assignment in scripts.
Time Now(void)
create an ns3::Time instance which contains the current simulation time.
Definition: simulator.cc:365
void EnableAsciiAll(std::string prefix)
Enable ascii trace output on each device (which is of the appropriate type) in the set of all nodes c...
void Create(uint32_t n)
Create n nodes and append pointers to them to the end of this NodeContainer.
uint32_t GetDataLinkType(void)
Returns the data link type field of the pcap file as defined by the network field in the pcap global ...
Definition: pcap-file.cc:137
const bool WRITE_PCAP
void Write(uint32_t tsSec, uint32_t tsUsec, uint8_t const *const data, uint32_t totalLen)
Write next packet to file.
Definition: pcap-file.cc:434
virtual int Send(Ptr< Packet > p, uint32_t flags)=0
Send data (or dummy data) to the remote host.
virtual int Close(void)=0
Close a socket.
virtual uint32_t GetTxAvailable(void) const =0
Returns the number of bytes which can be sent in a single call to Send.
void Ipv4L3Tx(std::string context, Ptr< const Packet > packet, Ptr< Ipv4 > ipv4, uint32_t interface)
NodeContainer n1n2
std::ostream * GetStream(void)
Return a pointer to an ostream previously set in the wrapper.
void SetBase(Ipv4Address network, Ipv4Mask mask, Ipv4Address base="0.0.0.1")
Set the base network number, network mask and base address.
const bool WRITE_VECTORS
Ipv4Address GetAddress(uint32_t i, uint32_t j=0) const
const uint32_t PCAP_SNAPLEN