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/traffic-control-helper.h"
35 #include "ns3/ipv4-global-routing-helper.h"
36 #include "ns3/ipv4-address-helper.h"
37 #include "ns3/packet-sink-helper.h"
38 #include "ns3/tcp-socket-factory.h"
39 #include "ns3/node-container.h"
40 #include "ns3/simulator.h"
41 #include "ns3/error-model.h"
42 #include "ns3/pointer.h"
43 #include "ns3tcp-socket-writer.h"
44 #include "ns3/tcp-header.h"
45 
46 using namespace ns3;
47 
48 NS_LOG_COMPONENT_DEFINE ("Ns3TcpStateTest");
49 
50 // The below boolean constants should only be changed to 'true'
51 // during test debugging (i.e. do not commit the value 'true')
52 
53 // set to 'true' to have the test suite overwrite the response vectors
54 // stored in the test directory. This should only be done if you are
55 // convinced through other means (e.g. pcap tracing or logging) that the
56 // revised vectors are the correct ones. In other words, don't simply
57 // enable this to true to clear a failing test without looking at the
58 // results closely.
59 const bool WRITE_VECTORS = false; // set to true to write response vectors
60 const bool WRITE_PCAP = false; // set to true to write out pcap
61 const bool WRITE_LOGGING = false; // set to true to write logging
62 const uint32_t PCAP_LINK_TYPE = 1187373554; // Some large random number -- we use to verify data was written by this program
63 const uint32_t PCAP_SNAPLEN = 64; // Don't bother to save much data
64 
65 // ===========================================================================
66 // Tests of TCP implementation state machine behavior
67 // ===========================================================================
68 //
69 
71 {
72 public:
74  Ns3TcpStateTestCase (uint32_t testCase);
76  {
77  }
78 
79 private:
80  virtual void DoSetup (void);
81  virtual void DoRun (void);
82  virtual void DoTeardown (void);
83 
84  std::string m_pcapFilename;
86  uint32_t m_testCase;
87  uint32_t m_totalTxBytes;
88  uint32_t m_currentTxBytes;
93 
94  void Ipv4L3Tx (std::string context, Ptr<const Packet> packet, Ptr<Ipv4> ipv4, uint32_t interface);
95  void Ipv4L3Rx (std::string context, Ptr<const Packet> packet, Ptr<Ipv4> ipv4, uint32_t interface);
96  void WriteUntilBufferFull (Ptr<Socket> localSocket, uint32_t txSpace);
97  void StartFlow (Ptr<Socket> localSocket,
98  Ipv4Address servAddress,
99  uint16_t servPort);
100 
101 };
102 
104  : TestCase ("Check the operation of the TCP state machine for several cases"),
105  m_testCase (0),
106  m_totalTxBytes (20000),
107  m_currentTxBytes (0),
108  m_writeVectors (WRITE_VECTORS),
109  m_writeResults (WRITE_PCAP),
110  m_writeLogging (WRITE_LOGGING),
111  m_needToClose (true)
112 {
113 }
114 
116  : TestCase ("Check the operation of the TCP state machine for several cases"),
117  m_testCase (testCase),
118  m_totalTxBytes (20000),
119  m_currentTxBytes (0),
120  m_writeVectors (WRITE_VECTORS),
121  m_writeResults (WRITE_PCAP),
122  m_writeLogging (WRITE_LOGGING),
123  m_needToClose (true)
124 {
125 }
126 
127 void
129 {
130  //
131  // We expect there to be a file called ns3tcp-state-response-vectors.pcap in
132  // the data directory
133  //
134  std::ostringstream oss;
135  oss << "ns3tcp-state" << m_testCase << "-response-vectors.pcap";
136  m_pcapFilename = CreateDataDirFilename (oss.str ());
137  NS_LOG_INFO ("m_pcapFilename=" << m_pcapFilename);
138 
139  if (m_writeVectors)
140  {
141  m_pcapFile.Open (m_pcapFilename, std::ios::out | std::ios::binary);
143  }
144  else
145  {
146  m_pcapFile.Open (m_pcapFilename, std::ios::in | std::ios::binary);
148  "Wrong response vectors in directory: opening " <<
150  }
151 }
152 
153 void
155 {
156  m_pcapFile.Close ();
157 }
158 
159 void
160 Ns3TcpStateTestCase::Ipv4L3Rx (std::string context, Ptr<const Packet> packet, Ptr<Ipv4> ipv4, uint32_t interface)
161 {
162  Ptr<Packet> received = packet->Copy ();
163  Ipv4Header ipHeader;
164  TcpHeader tcpHeader;
165  received->RemoveHeader (ipHeader);
166  received->RemoveHeader (tcpHeader);
167 
168  NS_LOG_DEBUG ("Received: " << tcpHeader);
169 }
170 
171 void
172 Ns3TcpStateTestCase::Ipv4L3Tx (std::string context, Ptr<const Packet> packet, Ptr<Ipv4> ipv4, uint32_t interface)
173 {
174  //
175  // We're not testing IP so remove and toss the header. In order to do this,
176  // though, we need to copy the packet since we have a const version.
177  //
178  Ptr<Packet> received = packet->Copy ();
179  Ipv4Header ipHeader;
180  received->RemoveHeader (ipHeader);
181 
182  //
183  // What is left is the TCP header and any data that may be sent. We aren't
184  // sending any TCP data, so we expect what remains is only TCP header, which
185  // is a small thing to save.
186  //
187  if (m_writeVectors)
188  {
189  //
190  // Save the TCP under test response for later testing.
191  //
192  Time tNow = Simulator::Now ();
193  int64_t tMicroSeconds = tNow.GetMicroSeconds ();
194 
195  m_pcapFile.Write (uint32_t (tMicroSeconds / 1000000),
196  uint32_t (tMicroSeconds % 1000000),
197  received);
198  }
199  else
200  {
201  //
202  // Read the TCP under test expected response from the expected vector
203  // file and see if it still does the right thing.
204  //
205  uint8_t expectedBuffer[PCAP_SNAPLEN];
206  uint32_t tsSec, tsUsec, inclLen, origLen, readLen;
207  m_pcapFile.Read (expectedBuffer, sizeof(expectedBuffer), tsSec, tsUsec, inclLen, origLen, readLen);
208 
209  NS_LOG_INFO ("read " << readLen << " bytes");
210 
211  uint8_t *actual = new uint8_t[readLen];
212  received->CopyData (actual, readLen);
213 
214  int result = memcmp (actual, expectedBuffer, readLen);
215 
216  TcpHeader expectedHeader, receivedHeader;
217  Ptr<Packet> expected = Create<Packet> (expectedBuffer, readLen);
218 
219  expected->RemoveHeader (expectedHeader);
220  received->RemoveHeader (receivedHeader);
221 
222  NS_LOG_DEBUG ("Expected " << expectedHeader << " received: " << receivedHeader);
223 
224  delete [] actual;
225 
226  //
227  // Avoid streams of errors -- only report the first.
228  //
229  if (IsStatusSuccess ())
230  {
231  NS_TEST_EXPECT_MSG_EQ (result, 0, "Expected data comparison error");
232  }
233  }
234 }
235 
237 // Implementing an "application" to send bytes over a TCP connection
238 void
240 {
242  {
243  uint32_t left = m_totalTxBytes - m_currentTxBytes;
244  uint32_t dataOffset = m_currentTxBytes % 1040;
245  uint32_t toWrite = 1040 - dataOffset;
246  uint32_t txAvail = localSocket->GetTxAvailable ();
247  toWrite = std::min (toWrite, left);
248  toWrite = std::min (toWrite, txAvail);
249  if (txAvail == 0)
250  {
251  return;
252  }
253  if (m_writeLogging)
254  {
255  std::clog << "Submitting "
256  << toWrite << " bytes to TCP socket" << std::endl;
257  }
258  int amountSent = localSocket->Send (0, toWrite, 0);
259  NS_ASSERT (amountSent > 0); // Given GetTxAvailable() non-zero, amountSent should not be zero
260  m_currentTxBytes += amountSent;
261  }
262  if (m_needToClose)
263  {
264  if (m_writeLogging)
265  {
266  std::clog << "Close socket at "
267  << Simulator::Now ().GetSeconds ()
268  << std::endl;
269  }
270  localSocket->Close ();
271  m_needToClose = false;
272  }
273 }
274 
275 void
277  Ipv4Address servAddress,
278  uint16_t servPort)
279 {
280  if (m_writeLogging)
281  {
282  std::clog << "Starting flow at time "
283  << Simulator::Now ().GetSeconds ()
284  << std::endl;
285  }
286 
287  localSocket->Connect (InetSocketAddress (servAddress, servPort)); // connect
288 
289  // tell the tcp implementation to call WriteUntilBufferFull again
290  // if we blocked and new tx buffer space becomes available
291  localSocket->SetSendCallback (MakeCallback
293  this));
294  WriteUntilBufferFull (localSocket, localSocket->GetTxAvailable ());
295 }
296 
297 void
299 {
300  // Network topology
301  //
302  // 10Mb/s, 0.1ms 10Mb/s, 0.1ms
303  // n0-----------------n1-----------------n2
304 
305  std::string tcpModel ("ns3::TcpNewReno");
306 
307  Config::SetDefault ("ns3::TcpSocketBase::Sack", BooleanValue (false));
308  Config::SetDefault ("ns3::TcpL4Protocol::SocketType", StringValue (tcpModel));
309  Config::SetDefault ("ns3::TcpSocket::SegmentSize", UintegerValue (1000));
310  Config::SetDefault ("ns3::TcpSocket::DelAckCount", UintegerValue (1));
311  Config::SetDefault ("ns3::DropTailQueue<Packet>::MaxSize", StringValue ("20p"));
312  Config::SetDefault ("ns3::TcpSocketBase::Timestamp", BooleanValue (false));
313 
314  if (m_writeLogging)
315  {
317  LogComponentEnable ("ErrorModel", LOG_LEVEL_DEBUG);
318  LogComponentEnable ("Ns3TcpStateTest", LOG_LEVEL_DEBUG);
319  LogComponentEnable ("TcpCongestionOps", LOG_LEVEL_INFO);
320  LogComponentEnable ("TcpSocketBase", LOG_LEVEL_INFO);
321  }
322 
324  // Topology construction
325  //
326 
327  // Create three nodes
328  NodeContainer n0n1;
329  n0n1.Create (2);
330 
332  n1n2.Add (n0n1.Get (1));
333  n1n2.Create (1);
334 
335  // Set up TCP/IP stack to all nodes (and create loopback device at device 0)
336  InternetStackHelper internet;
337  internet.InstallAll ();
338 
339  // Connect the nodes
340  PointToPointHelper p2p;
341  p2p.SetDeviceAttribute ("DataRate", DataRateValue (DataRate (1000000)));
342  p2p.SetChannelAttribute ("Delay", TimeValue (Seconds (0.0001)));
343  NetDeviceContainer dev0 = p2p.Install (n0n1);
344  NetDeviceContainer dev1 = p2p.Install (n1n2);
345 
346  // Use PfifoFast queue disc
348  tch.SetRootQueueDisc ("ns3::PfifoFastQueueDisc");
349  tch.Install (dev0);
350  tch.Install (dev1);
351 
352  // Add IP addresses to each network interfaces
353  Ipv4AddressHelper ipv4;
354  ipv4.SetBase ("10.1.3.0", "255.255.255.0");
355  ipv4.Assign (dev0);
356  ipv4.SetBase ("10.1.2.0", "255.255.255.0");
357  Ipv4InterfaceContainer ipInterfs = ipv4.Assign (dev1);
358 
359  // Set up routes to all nodes
360  Ipv4GlobalRoutingHelper::PopulateRoutingTables ();
361 
363  // A flow from node n0 to node n2
364  //
365 
366  // Create a packet sink to receive packets on node n2
367  uint16_t servPort = 50000; // Destination port number
368  PacketSinkHelper sink ("ns3::TcpSocketFactory", InetSocketAddress (Ipv4Address::GetAny (), servPort));
369  ApplicationContainer sinkApps = sink.Install (n1n2.Get (1));
370  sinkApps.Start (Seconds (0.0));
371  sinkApps.Stop (Seconds (100.0));
372 
373  // Create a data source to send packets on node n0
374  // Instead of full application, here use the socket directly by
375  // registering callbacks in function StarFlow().
376  Ptr<Socket> localSocket = Socket::CreateSocket (n0n1.Get (0),
377  TcpSocketFactory::GetTypeId ());
378  localSocket->Bind ();
379  Simulator::ScheduleNow (&Ns3TcpStateTestCase::StartFlow, this,
380  localSocket, ipInterfs.GetAddress (1), servPort);
381 
382  Config::Connect ("/NodeList/0/$ns3::Ipv4L3Protocol/Tx",
384 
385  Config::Connect ("/NodeList/0/$ns3::Ipv4L3Protocol/Rx",
387 
389  // Set up different test cases: Lost model at node n1, different file size
390  //
391 
392  std::list<uint32_t> dropListN0;
393  std::list<uint32_t> dropListN1;
394  std::string caseDescription;
395  switch (m_testCase)
396  {
397  case 0:
398  m_totalTxBytes = 1000;
399  caseDescription = "Verify connection establishment";
400  break;
401  case 1:
402  m_totalTxBytes = 100 * 1000;
403  caseDescription = "Verify a bigger (100 pkts) transfer: Sliding window operation, etc.";
404  break;
405  case 2:
406  m_totalTxBytes = 1000;
407  caseDescription = "Survive a SYN lost";
408  dropListN0.push_back (0);
409  break;
410  case 3:
411  m_totalTxBytes = 2000;
412  caseDescription = "Survive a SYN+ACK lost";
413  dropListN1.push_back (0);
414  break;
415  case 4:
416  m_totalTxBytes = 2000;
417  caseDescription = "Survive a ACK (last packet in 3-way handshake) lost";
418  dropListN0.push_back (1);
419  break;
420  case 5:
421  m_totalTxBytes = 0;
422  caseDescription = "Immediate FIN upon SYN_RCVD";
423  m_needToClose = false;
424  dropListN0.push_back (1); // Hide the ACK in 3WHS
425  Simulator::Schedule (Seconds (0.002), &Socket::Close, localSocket);
426  break;
427  case 6:
428  m_totalTxBytes = 5000;
429  caseDescription = "Simulated simultaneous close";
430  dropListN1.push_back (5); // Hide the ACK-to-FIN from n2
431  break;
432  case 7:
433  m_totalTxBytes = 5000;
434  caseDescription = "FIN check 1: Loss of initiator's FIN. Wait until app close";
435  m_needToClose = false;
436  dropListN0.push_back (7); // Hide the FIN from n0
437  Simulator::Schedule (Seconds (0.04), &Socket::Close, localSocket);
438  break;
439  case 8:
440  m_totalTxBytes = 5000;
441  caseDescription = "FIN check 2: Loss responder's FIN. FIN will be resent after last ack timeout";
442  dropListN1.push_back (6); // Hide the FIN from n2
443  break;
444  default:
445  NS_FATAL_ERROR ("Program fatal error: specified test case not supported: "
446  << m_testCase);
447  break;
448  }
449 
450  Ptr<ReceiveListErrorModel> errN0 = CreateObject<ReceiveListErrorModel> ();
451  errN0->SetList (dropListN0);
452  dev0.Get (1)->SetAttribute ("ReceiveErrorModel", PointerValue (errN0));
453 
454  Ptr<ReceiveListErrorModel> errN1 = CreateObject<ReceiveListErrorModel> ();
455  errN1->SetList (dropListN1);
456  dev1.Get (0)->SetAttribute ("ReceiveErrorModel", PointerValue (errN1));
457 
458  std::ostringstream oss;
459  oss << "tcp-state" << m_testCase << "-test-case";
460  if (m_writeResults)
461  {
462  p2p.EnablePcapAll (oss.str ());
463  p2p.EnableAsciiAll (oss.str ());
464  }
465 
466  if (m_writeLogging)
467  {
468  Ptr<OutputStreamWrapper> osw = Create<OutputStreamWrapper> (&std::clog);
469  *(osw->GetStream ()) << std::setprecision (9) << std::fixed;
470  p2p.EnableAsciiAll (osw);
471 
472  std::clog << std::endl << "Running TCP test-case " << m_testCase << ": "
473  << caseDescription << std::endl;
474  }
475 
476  // Finally, set up the simulator to run. The 1000 second hard limit is a
477  // failsafe in case some change above causes the simulation to never end
478  Simulator::Stop (Seconds (1000));
479  Simulator::Run ();
480  Simulator::Destroy ();
481 }
482 
484 {
485 public:
487 };
488 
490  : TestSuite ("ns3-tcp-state", SYSTEM)
491 {
492  // We can't use NS_TEST_SOURCEDIR variable here because we use subdirectories
493  SetDataDir ("src/test/ns3tcp/response-vectors");
494  Packet::EnablePrinting (); // Enable packet metadata for all test cases
495 
496  AddTestCase (new Ns3TcpStateTestCase (0), TestCase::QUICK);
497  AddTestCase (new Ns3TcpStateTestCase (1), TestCase::QUICK);
498  AddTestCase (new Ns3TcpStateTestCase (2), TestCase::QUICK);
499  AddTestCase (new Ns3TcpStateTestCase (3), TestCase::QUICK);
500  AddTestCase (new Ns3TcpStateTestCase (4), TestCase::QUICK);
501  AddTestCase (new Ns3TcpStateTestCase (5), TestCase::QUICK);
502  AddTestCase (new Ns3TcpStateTestCase (6), TestCase::QUICK);
503  AddTestCase (new Ns3TcpStateTestCase (7), TestCase::QUICK);
504  AddTestCase (new Ns3TcpStateTestCase (8), TestCase::QUICK);
505 }
506 
uint32_t RemoveHeader(Header &header)
Deserialize and remove the header from the internal buffer.
Definition: packet.cc:280
void InstallAll(void) const
Aggregate IPv4, IPv6, UDP, and TCP stacks to all nodes in the simulation.
Ptr< PacketSink > sink
Definition: wifi-tcp.cc:56
holds a vector of ns3::Application pointers.
Ptr< NetDevice > Get(uint32_t i) const
Get the Ptr<NetDevice> stored in this container at a given index.
Simulation virtual time values and global simulation resolution.
Definition: nstime.h:102
an Inet address class
AttributeValue implementation for Boolean.
Definition: boolean.h:36
QueueDiscContainer Install(NetDeviceContainer c)
holds a vector of std::pair of Ptr<Ipv4> and interface index.
Hold variables of type string.
Definition: string.h:41
#define min(a, b)
Definition: 80211b.c:42
NetDeviceContainer Install(NodeContainer c)
A suite of tests to run.
Definition: test.h:1343
double GetSeconds(void) const
Get an approximation of the time stored in this instance in the indicated unit.
Definition: nstime.h:361
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:205
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:283
#define NS_LOG_INFO(msg)
Use NS_LOG to output a message of level LOG_INFO.
Definition: log.h:281
#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:1153
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)
bool IsStatusSuccess(void) const
Check if all tests passed.
Definition: test.cc:458
Class for representing data rates.
Definition: data-rate.h:88
Packet header for IPv4.
Definition: ipv4-header.h:33
void LogComponentEnable(char const *name, enum LogLevel level)
Enable the logging output associated with that log component.
Definition: log.cc:370
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 ...
AttributeValue implementation for Time.
Definition: nstime.h:1132
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
Ipv4Address GetAddress(uint32_t i, uint32_t j=0) const
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:107
holds a vector of ns3::NetDevice pointers
Callback< R > MakeCallback(R(T::*memPtr)(void), OBJ objPtr)
Definition: callback.h:1610
Build a set of QueueDisc objects.
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:873
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.
int64_t GetMicroSeconds(void) const
Get an approximation of the time stored in this instance in the indicated unit.
Definition: nstime.h:369
void LogComponentEnableAll(enum LogLevel level)
Enable the logging output for all registered log components.
Definition: log.cc:394
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
uint16_t SetRootQueueDisc(std::string type, std::string n01="", const AttributeValue &v01=EmptyAttributeValue(), std::string n02="", const AttributeValue &v02=EmptyAttributeValue(), std::string n03="", const AttributeValue &v03=EmptyAttributeValue(), std::string n04="", const AttributeValue &v04=EmptyAttributeValue(), std::string n05="", const AttributeValue &v05=EmptyAttributeValue(), std::string n06="", const AttributeValue &v06=EmptyAttributeValue(), std::string n07="", const AttributeValue &v07=EmptyAttributeValue(), std::string n08="", const AttributeValue &v08=EmptyAttributeValue(), std::string n09="", const AttributeValue &v09=EmptyAttributeValue(), std::string n10="", const AttributeValue &v10=EmptyAttributeValue(), std::string n11="", const AttributeValue &v11=EmptyAttributeValue(), std::string n12="", const AttributeValue &v12=EmptyAttributeValue(), std::string n13="", const AttributeValue &v13=EmptyAttributeValue(), std::string n14="", const AttributeValue &v14=EmptyAttributeValue(), std::string n15="", const AttributeValue &v15=EmptyAttributeValue())
Helper function used to set a root queue disc of the given type and with the given attributes...
Header for the Transmission Control Protocol.
Definition: tcp-header.h:44
void WriteUntilBufferFull(Ptr< Socket >, uint32_t)
Ptr< Packet > Copy(void) const
performs a COW copy of the packet.
Definition: packet.cc:121
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
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:41
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:104
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:118
uint32_t CopyData(uint8_t *buffer, uint32_t size) const
Copy the packet contents to a byte buffer.
Definition: packet.cc:378
#define NS_LOG_DEBUG(msg)
Use NS_LOG to output a message of level LOG_DEBUG.
Definition: log.h:273
Time Seconds(double value)
Construct a Time in the indicated unit.
Definition: nstime.h:1070
void SetDefault(std::string name, const AttributeValue &value)
Definition: config.cc:812
void SetDataDir(std::string directory)
Set the data directory where reference trace files can be found.
Definition: test.cc:465
Ptr< Node > Get(uint32_t i) const
Get the Ptr<Node> stored in this container at a given index.
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:309
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
const uint32_t PCAP_SNAPLEN