d5/d91/tcp-test_8cc_source.html

 /*

  * Copyright (c) 2007 Georgia Tech Research Corporation

  * Copyright (c) 2009 INRIA

  *

  * This program is free software; you can redistribute it and/or modify

  * it under the terms of the GNU General Public License version 2 as

  * published by the Free Software Foundation;

  *

  * This program is distributed in the hope that it will be useful,

  * but WITHOUT ANY WARRANTY; without even the implied warranty of

  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

  * GNU General Public License for more details.

  *

  * You should have received a copy of the GNU General Public License

  * along with this program; if not, write to the Free Software

  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

  *

  * Authors: Mathieu Lacage <mathieu.lacage@sophia.inria.fr>

  *          Raj Bhattacharjea <raj.b@gatech.edu>

  */


 #include "ns3/arp-l3-protocol.h"

 #include "ns3/config.h"

 #include "ns3/icmpv4-l4-protocol.h"

 #include "ns3/icmpv6-l4-protocol.h"

 #include "ns3/inet-socket-address.h"

 #include "ns3/inet6-socket-address.h"

 #include "ns3/ipv4-l3-protocol.h"

 #include "ns3/ipv4-list-routing.h"

 #include "ns3/ipv4-static-routing.h"

 #include "ns3/ipv6-l3-protocol.h"

 #include "ns3/ipv6-list-routing.h"

 #include "ns3/ipv6-static-routing.h"

 #include "ns3/log.h"

 #include "ns3/node.h"

 #include "ns3/simple-channel.h"

 #include "ns3/simple-net-device.h"

 #include "ns3/simulator.h"

 #include "ns3/socket-factory.h"

 #include "ns3/tcp-l4-protocol.h"

 #include "ns3/tcp-socket-factory.h"

 #include "ns3/test.h"

 #include "ns3/traffic-control-layer.h"

 #include "ns3/udp-l4-protocol.h"

 #include "ns3/uinteger.h"


 #include <string>


 using namespace ns3;


 NS_LOG_COMPONENT_DEFINE("TcpTestSuite");


 class TcpTestCase : public TestCase

 {

   public:

     TcpTestCase(uint32_t totalStreamSize,

                 uint32_t sourceWriteSize,

                 uint32_t sourceReadSize,

                 uint32_t serverWriteSize,

                 uint32_t serverReadSize,

                 bool useIpv6);


   private:

     void DoRun() override;

     void DoTeardown() override;


     void SetupDefaultSim();

     void SetupDefaultSim6();


     Ptr<Node> CreateInternetNode();

     Ptr<Node> CreateInternetNode6();


     Ptr<SimpleNetDevice> AddSimpleNetDevice(Ptr<Node> node,

                                             const char* ipaddr,

                                             const char* netmask);

     Ptr<SimpleNetDevice> AddSimpleNetDevice6(Ptr<Node> node, Ipv6Address ipaddr, Ipv6Prefix prefix);


     void ServerHandleConnectionCreated(Ptr<Socket> s, const Address& addr);

     void ServerHandleRecv(Ptr<Socket> sock);

     void ServerHandleSend(Ptr<Socket> sock, uint32_t available);

     void SourceHandleSend(Ptr<Socket> sock, uint32_t available);

     void SourceHandleRecv(Ptr<Socket> sock);


     uint32_t m_totalBytes;

     uint32_t m_sourceWriteSize;

     uint32_t m_sourceReadSize;

     uint32_t m_serverWriteSize;

     uint32_t m_serverReadSize;

     uint32_t m_currentSourceTxBytes;

     uint32_t m_currentSourceRxBytes;

     uint32_t m_currentServerRxBytes;

     uint32_t m_currentServerTxBytes;

     uint8_t* m_sourceTxPayload;

     uint8_t* m_sourceRxPayload;

     uint8_t* m_serverRxPayload;


     bool m_useIpv6;

 };


 static std::string

 Name(std::string str,

      uint32_t totalStreamSize,

      uint32_t sourceWriteSize,

      uint32_t serverReadSize,

      uint32_t serverWriteSize,

      uint32_t sourceReadSize,

      bool useIpv6)

 {

     std::ostringstream oss;

     oss << str << " total=" << totalStreamSize << " sourceWrite=" << sourceWriteSize

         << " sourceRead=" << sourceReadSize << " serverRead=" << serverReadSize

         << " serverWrite=" << serverWriteSize << " useIpv6=" << useIpv6;

     return oss.str();

 }


 static inline std::string

 GetString(Ptr<Packet> p)

 {

     std::ostringstream oss;

     p->CopyData(&oss, p->GetSize());

     return oss.str();

 }


 TcpTestCase::TcpTestCase(uint32_t totalStreamSize,

                          uint32_t sourceWriteSize,

                          uint32_t sourceReadSize,

                          uint32_t serverWriteSize,

                          uint32_t serverReadSize,

                          bool useIpv6)

     : TestCase(Name("Send string data from client to server and back",

                     totalStreamSize,

                     sourceWriteSize,

                     serverReadSize,

                     serverWriteSize,

                     sourceReadSize,

                     useIpv6)),

       m_totalBytes(totalStreamSize),

       m_sourceWriteSize(sourceWriteSize),

       m_sourceReadSize(sourceReadSize),

       m_serverWriteSize(serverWriteSize),

       m_serverReadSize(serverReadSize),

       m_useIpv6(useIpv6)

 {

 }


 void

 TcpTestCase::DoRun()

 {

     m_currentSourceTxBytes = 0;

     m_currentSourceRxBytes = 0;

     m_currentServerRxBytes = 0;

     m_currentServerTxBytes = 0;

     m_sourceTxPayload = new uint8_t[m_totalBytes];

     m_sourceRxPayload = new uint8_t[m_totalBytes];

     m_serverRxPayload = new uint8_t[m_totalBytes];

     for (uint32_t i = 0; i < m_totalBytes; ++i)

     {

         auto m = (uint8_t)(97 + (i % 26));

         m_sourceTxPayload[i] = m;

     }

     memset(m_sourceRxPayload, 0, m_totalBytes);

     memset(m_serverRxPayload, 0, m_totalBytes);


     if (m_useIpv6)

     {

         SetupDefaultSim6();

     }

     else

     {

         SetupDefaultSim();

     }


     Simulator::Run();


     NS_TEST_EXPECT_MSG_EQ(m_currentSourceTxBytes, m_totalBytes, "Source sent all bytes");

     NS_TEST_EXPECT_MSG_EQ(m_currentServerRxBytes, m_totalBytes, "Server received all bytes");

     NS_TEST_EXPECT_MSG_EQ(m_currentSourceRxBytes, m_totalBytes, "Source received all bytes");

     NS_TEST_EXPECT_MSG_EQ(memcmp(m_sourceTxPayload, m_serverRxPayload, m_totalBytes),

                           0,

                           "Server received expected data buffers");

     NS_TEST_EXPECT_MSG_EQ(memcmp(m_sourceTxPayload, m_sourceRxPayload, m_totalBytes),

                           0,

                           "Source received back expected data buffers");

 }


 void

 TcpTestCase::DoTeardown()

 {

     delete[] m_sourceTxPayload;

     delete[] m_sourceRxPayload;

     delete[] m_serverRxPayload;

     Simulator::Destroy();

 }


 void

 TcpTestCase::ServerHandleConnectionCreated(Ptr<Socket> s, const Address& addr)

 {

     s->SetRecvCallback(MakeCallback(&TcpTestCase::ServerHandleRecv, this));

     s->SetSendCallback(MakeCallback(&TcpTestCase::ServerHandleSend, this));

 }


 void

 TcpTestCase::ServerHandleRecv(Ptr<Socket> sock)

 {

     while (sock->GetRxAvailable() > 0)

     {

         uint32_t toRead = std::min(m_serverReadSize, sock->GetRxAvailable());

         Ptr<Packet> p = sock->Recv(toRead, 0);

         if (!p && sock->GetErrno() != Socket::ERROR_NOTERROR)

         {

             NS_FATAL_ERROR("Server could not read stream at byte " << m_currentServerRxBytes);

         }

         NS_TEST_EXPECT_MSG_EQ((m_currentServerRxBytes + p->GetSize() <= m_totalBytes),

                               true,

                               "Server received too many bytes");

         NS_LOG_DEBUG("Server recv data=\"" << GetString(p) << "\"");

         p->CopyData(&m_serverRxPayload[m_currentServerRxBytes], p->GetSize());

         m_currentServerRxBytes += p->GetSize();

         ServerHandleSend(sock, sock->GetTxAvailable());

     }

 }


 void

 TcpTestCase::ServerHandleSend(Ptr<Socket> sock, uint32_t available)

 {

     while (sock->GetTxAvailable() > 0 && m_currentServerTxBytes < m_currentServerRxBytes)

     {

         uint32_t left = m_currentServerRxBytes - m_currentServerTxBytes;

         uint32_t toSend = std::min(left, sock->GetTxAvailable());

         toSend = std::min(toSend, m_serverWriteSize);

         Ptr<Packet> p = Create<Packet>(&m_serverRxPayload[m_currentServerTxBytes], toSend);

         NS_LOG_DEBUG("Server send data=\"" << GetString(p) << "\"");

         int sent = sock->Send(p);

         NS_TEST_EXPECT_MSG_EQ((sent != -1), true, "Server error during send ?");

         m_currentServerTxBytes += sent;

     }

     if (m_currentServerTxBytes == m_totalBytes)

     {

         sock->Close();

     }

 }


 void

 TcpTestCase::SourceHandleSend(Ptr<Socket> sock, uint32_t available)

 {

     while (sock->GetTxAvailable() > 0 && m_currentSourceTxBytes < m_totalBytes)

     {

         uint32_t left = m_totalBytes - m_currentSourceTxBytes;

         uint32_t toSend = std::min(left, sock->GetTxAvailable());

         toSend = std::min(toSend, m_sourceWriteSize);

         Ptr<Packet> p = Create<Packet>(&m_sourceTxPayload[m_currentSourceTxBytes], toSend);

         NS_LOG_DEBUG("Source send data=\"" << GetString(p) << "\"");

         int sent = sock->Send(p);

         NS_TEST_EXPECT_MSG_EQ((sent != -1), true, "Error during send ?");

         m_currentSourceTxBytes += sent;

     }

 }


 void

 TcpTestCase::SourceHandleRecv(Ptr<Socket> sock)

 {

     while (sock->GetRxAvailable() > 0 && m_currentSourceRxBytes < m_totalBytes)

     {

         uint32_t toRead = std::min(m_sourceReadSize, sock->GetRxAvailable());

         Ptr<Packet> p = sock->Recv(toRead, 0);

         if (!p && sock->GetErrno() != Socket::ERROR_NOTERROR)

         {

             NS_FATAL_ERROR("Source could not read stream at byte " << m_currentSourceRxBytes);

         }

         NS_TEST_EXPECT_MSG_EQ((m_currentSourceRxBytes + p->GetSize() <= m_totalBytes),

                               true,

                               "Source received too many bytes");

         NS_LOG_DEBUG("Source recv data=\"" << GetString(p) << "\"");

         p->CopyData(&m_sourceRxPayload[m_currentSourceRxBytes], p->GetSize());

         m_currentSourceRxBytes += p->GetSize();

     }

     if (m_currentSourceRxBytes == m_totalBytes)

     {

         sock->Close();

     }

 }


 Ptr<Node>

 TcpTestCase::CreateInternetNode()

 {

     Ptr<Node> node = CreateObject<Node>();

     // Traffic Control

     Ptr<TrafficControlLayer> tc = CreateObject<TrafficControlLayer>();

     node->AggregateObject(tc);

     // ARP

     Ptr<ArpL3Protocol> arp = CreateObject<ArpL3Protocol>();

     node->AggregateObject(arp);

     arp->SetTrafficControl(tc);

     // IPV4

     Ptr<Ipv4L3Protocol> ipv4 = CreateObject<Ipv4L3Protocol>();

     // Routing for Ipv4

     Ptr<Ipv4ListRouting> ipv4Routing = CreateObject<Ipv4ListRouting>();

     ipv4->SetRoutingProtocol(ipv4Routing);

     Ptr<Ipv4StaticRouting> ipv4staticRouting = CreateObject<Ipv4StaticRouting>();

     ipv4Routing->AddRoutingProtocol(ipv4staticRouting, 0);

     node->AggregateObject(ipv4);

     // ICMP

     Ptr<Icmpv4L4Protocol> icmp = CreateObject<Icmpv4L4Protocol>();

     node->AggregateObject(icmp);

     // UDP

     Ptr<UdpL4Protocol> udp = CreateObject<UdpL4Protocol>();

     node->AggregateObject(udp);

     // TCP

     Ptr<TcpL4Protocol> tcp = CreateObject<TcpL4Protocol>();

     node->AggregateObject(tcp);

     return node;

 }


 Ptr<SimpleNetDevice>

 TcpTestCase::AddSimpleNetDevice(Ptr<Node> node, const char* ipaddr, const char* netmask)

 {

     Ptr<SimpleNetDevice> dev = CreateObject<SimpleNetDevice>();

     dev->SetAddress(Mac48Address::ConvertFrom(Mac48Address::Allocate()));

     node->AddDevice(dev);

     Ptr<Ipv4> ipv4 = node->GetObject<Ipv4>();

     uint32_t ndid = ipv4->AddInterface(dev);

     Ipv4InterfaceAddress ipv4Addr = Ipv4InterfaceAddress(Ipv4Address(ipaddr), Ipv4Mask(netmask));

     ipv4->AddAddress(ndid, ipv4Addr);

     ipv4->SetUp(ndid);

     return dev;

 }


 void

 TcpTestCase::SetupDefaultSim()

 {

     const char* netmask = "255.255.255.0";

     const char* ipaddr0 = "192.168.1.1";

     const char* ipaddr1 = "192.168.1.2";

     Ptr<Node> node0 = CreateInternetNode();

     Ptr<Node> node1 = CreateInternetNode();

     Ptr<SimpleNetDevice> dev0 = AddSimpleNetDevice(node0, ipaddr0, netmask);

     Ptr<SimpleNetDevice> dev1 = AddSimpleNetDevice(node1, ipaddr1, netmask);


     Ptr<SimpleChannel> channel = CreateObject<SimpleChannel>();

     dev0->SetChannel(channel);

     dev1->SetChannel(channel);


     Ptr<SocketFactory> sockFactory0 = node0->GetObject<TcpSocketFactory>();

     Ptr<SocketFactory> sockFactory1 = node1->GetObject<TcpSocketFactory>();


     Ptr<Socket> server = sockFactory0->CreateSocket();

     Ptr<Socket> source = sockFactory1->CreateSocket();


     uint16_t port = 50000;

     InetSocketAddress serverlocaladdr(Ipv4Address::GetAny(), port);

     InetSocketAddress serverremoteaddr(Ipv4Address(ipaddr0), port);


     server->Bind(serverlocaladdr);

     server->Listen();

     server->SetAcceptCallback(MakeNullCallback<bool, Ptr<Socket>, const Address&>(),

                               MakeCallback(&TcpTestCase::ServerHandleConnectionCreated, this));


     source->SetRecvCallback(MakeCallback(&TcpTestCase::SourceHandleRecv, this));

     source->SetSendCallback(MakeCallback(&TcpTestCase::SourceHandleSend, this));


     Address peerAddress;

     int err = source->GetPeerName(peerAddress);

     NS_TEST_EXPECT_MSG_EQ(err, -1, "socket GetPeerName() should fail when socket is not connected");

     NS_TEST_EXPECT_MSG_EQ(source->GetErrno(),

                           Socket::ERROR_NOTCONN,

                           "socket error code should be ERROR_NOTCONN");


     err = source->Connect(serverremoteaddr);

     NS_TEST_EXPECT_MSG_EQ(err, 0, "socket Connect() should succeed");


     err = source->GetPeerName(peerAddress);

     NS_TEST_EXPECT_MSG_EQ(err, 0, "socket GetPeerName() should succeed when socket is connected");

     NS_TEST_EXPECT_MSG_EQ(peerAddress,

                           serverremoteaddr,

                           "address from socket GetPeerName() should equal the connected address");

 }


 void

 TcpTestCase::SetupDefaultSim6()

 {

     Ipv6Prefix prefix = Ipv6Prefix(64);

     Ipv6Address ipaddr0 = Ipv6Address("2001:0100:f00d:cafe::1");

     Ipv6Address ipaddr1 = Ipv6Address("2001:0100:f00d:cafe::2");

     Ptr<Node> node0 = CreateInternetNode6();

     Ptr<Node> node1 = CreateInternetNode6();

     Ptr<SimpleNetDevice> dev0 = AddSimpleNetDevice6(node0, ipaddr0, prefix);

     Ptr<SimpleNetDevice> dev1 = AddSimpleNetDevice6(node1, ipaddr1, prefix);


     Ptr<SimpleChannel> channel = CreateObject<SimpleChannel>();

     dev0->SetChannel(channel);

     dev1->SetChannel(channel);


     Ptr<SocketFactory> sockFactory0 = node0->GetObject<TcpSocketFactory>();

     Ptr<SocketFactory> sockFactory1 = node1->GetObject<TcpSocketFactory>();


     Ptr<Socket> server = sockFactory0->CreateSocket();

     Ptr<Socket> source = sockFactory1->CreateSocket();


     uint16_t port = 50000;

     Inet6SocketAddress serverlocaladdr(Ipv6Address::GetAny(), port);

     Inet6SocketAddress serverremoteaddr(ipaddr0, port);


     server->Bind(serverlocaladdr);

     server->Listen();

     server->SetAcceptCallback(MakeNullCallback<bool, Ptr<Socket>, const Address&>(),

                               MakeCallback(&TcpTestCase::ServerHandleConnectionCreated, this));


     source->SetRecvCallback(MakeCallback(&TcpTestCase::SourceHandleRecv, this));

     source->SetSendCallback(MakeCallback(&TcpTestCase::SourceHandleSend, this));


     Address peerAddress;

     int err = source->GetPeerName(peerAddress);

     NS_TEST_EXPECT_MSG_EQ(err, -1, "socket GetPeerName() should fail when socket is not connected");

     NS_TEST_EXPECT_MSG_EQ(source->GetErrno(),

                           Socket::ERROR_NOTCONN,

                           "socket error code should be ERROR_NOTCONN");


     err = source->Connect(serverremoteaddr);

     NS_TEST_EXPECT_MSG_EQ(err, 0, "socket Connect() should succeed");


     err = source->GetPeerName(peerAddress);

     NS_TEST_EXPECT_MSG_EQ(err, 0, "socket GetPeerName() should succeed when socket is connected");

     NS_TEST_EXPECT_MSG_EQ(peerAddress,

                           serverremoteaddr,

                           "address from socket GetPeerName() should equal the connected address");

 }


 Ptr<Node>

 TcpTestCase::CreateInternetNode6()

 {

     Ptr<Node> node = CreateObject<Node>();

     // IPV6

     Ptr<Ipv6L3Protocol> ipv6 = CreateObject<Ipv6L3Protocol>();

     // Routing for Ipv6

     Ptr<Ipv6ListRouting> ipv6Routing = CreateObject<Ipv6ListRouting>();

     ipv6->SetRoutingProtocol(ipv6Routing);

     Ptr<Ipv6StaticRouting> ipv6staticRouting = CreateObject<Ipv6StaticRouting>();

     ipv6Routing->AddRoutingProtocol(ipv6staticRouting, 0);

     node->AggregateObject(ipv6);

     // ICMP

     Ptr<Icmpv6L4Protocol> icmp = CreateObject<Icmpv6L4Protocol>();

     node->AggregateObject(icmp);

     // Ipv6 Extensions

     ipv6->RegisterExtensions();

     ipv6->RegisterOptions();

     // UDP

     Ptr<UdpL4Protocol> udp = CreateObject<UdpL4Protocol>();

     node->AggregateObject(udp);

     // TCP

     Ptr<TcpL4Protocol> tcp = CreateObject<TcpL4Protocol>();

     node->AggregateObject(tcp);

     // Traffic Control

     Ptr<TrafficControlLayer> tc = CreateObject<TrafficControlLayer>();

     node->AggregateObject(tc);

     return node;

 }


 Ptr<SimpleNetDevice>

 TcpTestCase::AddSimpleNetDevice6(Ptr<Node> node, Ipv6Address ipaddr, Ipv6Prefix prefix)

 {

     Ptr<SimpleNetDevice> dev = CreateObject<SimpleNetDevice>();

     dev->SetAddress(Mac48Address::ConvertFrom(Mac48Address::Allocate()));

     node->AddDevice(dev);

     Ptr<Ipv6> ipv6 = node->GetObject<Ipv6>();

     uint32_t ndid = ipv6->AddInterface(dev);

     Ipv6InterfaceAddress ipv6Addr = Ipv6InterfaceAddress(ipaddr, prefix);

     ipv6->AddAddress(ndid, ipv6Addr);

     ipv6->SetUp(ndid);

     return dev;

 }


 class TcpTestSuite : public TestSuite

 {

   public:

     TcpTestSuite()

         : TestSuite("tcp", UNIT)

     {

         // Arguments to these test cases are 1) totalStreamSize,

         // 2) source write size, 3) source read size

         // 4) server write size, and 5) server read size

         // with units of bytes

         AddTestCase(new TcpTestCase(13, 200, 200, 200, 200, false), TestCase::QUICK);

         AddTestCase(new TcpTestCase(13, 1, 1, 1, 1, false), TestCase::QUICK);

         AddTestCase(new TcpTestCase(100000, 100, 50, 100, 20, false), TestCase::QUICK);


         AddTestCase(new TcpTestCase(13, 200, 200, 200, 200, true), TestCase::QUICK);

         AddTestCase(new TcpTestCase(13, 1, 1, 1, 1, true), TestCase::QUICK);

         AddTestCase(new TcpTestCase(100000, 100, 50, 100, 20, true), TestCase::QUICK);

     }

 };


 static TcpTestSuite g_tcpTestSuite;

min
#define min(a, b)
Definition: 80211b.c:41

TcpTestCase
TCP Test - send string data from client to server and back.
Definition: tcp-test.cc:59

TcpTestCase::m_serverReadSize
uint32_t m_serverReadSize
Server data size when receiving.
Definition: tcp-test.cc:153

TcpTestCase::m_sourceTxPayload
uint8_t * m_sourceTxPayload
Client Tx payload.
Definition: tcp-test.cc:158

TcpTestCase::AddSimpleNetDevice
Ptr< SimpleNetDevice > AddSimpleNetDevice(Ptr< Node > node, const char *ipaddr, const char *netmask)
Add a SimpleNetDevice to a node (IPv4 version).
Definition: tcp-test.cc:380

TcpTestCase::m_useIpv6
bool m_useIpv6
Use IPv6 instead of IPv4.
Definition: tcp-test.cc:162

TcpTestCase::ServerHandleSend
void ServerHandleSend(Ptr< Socket > sock, uint32_t available)
Server: Send data.
Definition: tcp-test.cc:289

TcpTestCase::m_currentServerTxBytes
uint32_t m_currentServerTxBytes
Server Rx bytes.
Definition: tcp-test.cc:157

TcpTestCase::DoRun
void DoRun() override
Implementation to actually run this TestCase.
Definition: tcp-test.cc:212

TcpTestCase::m_currentSourceTxBytes
uint32_t m_currentSourceTxBytes
Client Tx bytes.
Definition: tcp-test.cc:154

TcpTestCase::ServerHandleRecv
void ServerHandleRecv(Ptr< Socket > sock)
Server: Receive data.
Definition: tcp-test.cc:268

TcpTestCase::AddSimpleNetDevice6
Ptr< SimpleNetDevice > AddSimpleNetDevice6(Ptr< Node > node, Ipv6Address ipaddr, Ipv6Prefix prefix)
Add a SimpleNetDevice to a node (IPv6 version).
Definition: tcp-test.cc:524

TcpTestCase::CreateInternetNode
Ptr< Node > CreateInternetNode()
Create a node with the Internet stack (IPv4 version).
Definition: tcp-test.cc:349

TcpTestCase::CreateInternetNode6
Ptr< Node > CreateInternetNode6()
Create a node with the Internet stack (IPv6 version).
Definition: tcp-test.cc:494

TcpTestCase::SourceHandleRecv
void SourceHandleRecv(Ptr< Socket > sock)
Client: Receive data.
Definition: tcp-test.cc:325

TcpTestCase::ServerHandleConnectionCreated
void ServerHandleConnectionCreated(Ptr< Socket > s, const Address &addr)
Server: Handle connection created.
Definition: tcp-test.cc:261

TcpTestCase::TcpTestCase
TcpTestCase(uint32_t totalStreamSize, uint32_t sourceWriteSize, uint32_t sourceReadSize, uint32_t serverWriteSize, uint32_t serverReadSize, bool useIpv6)
Constructor.
Definition: tcp-test.cc:189

TcpTestCase::m_currentSourceRxBytes
uint32_t m_currentSourceRxBytes
Client Rx bytes.
Definition: tcp-test.cc:155

TcpTestCase::m_totalBytes
uint32_t m_totalBytes
Total stream size (in bytes).
Definition: tcp-test.cc:149

TcpTestCase::m_sourceReadSize
uint32_t m_sourceReadSize
Client data size when receiving.
Definition: tcp-test.cc:151

TcpTestCase::SetupDefaultSim6
void SetupDefaultSim6()
Setup the test (IPv6 version).
Definition: tcp-test.cc:444

TcpTestCase::m_sourceRxPayload
uint8_t * m_sourceRxPayload
Client Rx payload.
Definition: tcp-test.cc:159

TcpTestCase::m_serverWriteSize
uint32_t m_serverWriteSize
Server data size when sending.
Definition: tcp-test.cc:152

TcpTestCase::SourceHandleSend
void SourceHandleSend(Ptr< Socket > sock, uint32_t available)
Client: Send data.
Definition: tcp-test.cc:309

TcpTestCase::SetupDefaultSim
void SetupDefaultSim()
Setup the test (IPv4 version).
Definition: tcp-test.cc:394

TcpTestCase::m_currentServerRxBytes
uint32_t m_currentServerRxBytes
Server Tx bytes.
Definition: tcp-test.cc:156

TcpTestCase::m_serverRxPayload
uint8_t * m_serverRxPayload
Server Rx payload.
Definition: tcp-test.cc:160

TcpTestCase::m_sourceWriteSize
uint32_t m_sourceWriteSize
Client data size when sending.
Definition: tcp-test.cc:150

TcpTestCase::DoTeardown
void DoTeardown() override
Implementation to do any local setup required for this TestCase.
Definition: tcp-test.cc:252

TcpTestSuite
TCP TestSuite - send string data from client to server and back.
Definition: tcp-test.cc:543

TcpTestSuite::TcpTestSuite
TcpTestSuite()
Definition: tcp-test.cc:545

ns3::Address
a polymophic address class
Definition: address.h:101

ns3::Inet6SocketAddress
An Inet6 address class.
Definition: inet6-socket-address.h:38

ns3::InetSocketAddress
an Inet address class
Definition: inet-socket-address.h:42

ns3::Ipv4Address
Ipv4 addresses are stored in host order in this class.
Definition: ipv4-address.h:42

ns3::Ipv4
Access to the IPv4 forwarding table, interfaces, and configuration.
Definition: ipv4.h:80

ns3::Ipv4InterfaceAddress
a class to store IPv4 address information on an interface
Definition: ipv4-interface-address.h:45

ns3::Ipv4Mask
a class to represent an Ipv4 address mask
Definition: ipv4-address.h:257

ns3::Ipv6Address
Describes an IPv6 address.
Definition: ipv6-address.h:49

ns3::Ipv6
Access to the IPv6 forwarding table, interfaces, and configuration.
Definition: ipv6.h:82

ns3::Ipv6InterfaceAddress
IPv6 address associated with an interface.
Definition: ipv6-interface-address.h:37

ns3::Ipv6Prefix
Describes an IPv6 prefix.
Definition: ipv6-address.h:455

ns3::Node::AddDevice
uint32_t AddDevice(Ptr< NetDevice > device)
Associate a NetDevice to this node.
Definition: node.cc:138

ns3::Object::GetObject
Ptr< T > GetObject() const
Get a pointer to the requested aggregated Object.
Definition: object.h:471

ns3::Object::AggregateObject
void AggregateObject(Ptr< Object > other)
Aggregate two Objects together.
Definition: object.cc:259

ns3::Packet::GetSize
uint32_t GetSize() const
Returns the the size in bytes of the packet (including the zero-filled initial payload).
Definition: packet.h:861

ns3::Packet::CopyData
uint32_t CopyData(uint8_t *buffer, uint32_t size) const
Copy the packet contents to a byte buffer.
Definition: packet.cc:400

ns3::Ptr< Node >

ns3::Socket::Send
virtual int Send(Ptr< Packet > p, uint32_t flags)=0
Send data (or dummy data) to the remote host.

ns3::Socket::GetErrno
virtual Socket::SocketErrno GetErrno() const =0
Get last error number.

ns3::Socket::GetRxAvailable
virtual uint32_t GetRxAvailable() const =0
Return number of bytes which can be returned from one or multiple calls to Recv.

ns3::Socket::SetRecvCallback
void SetRecvCallback(Callback< void, Ptr< Socket >> receivedData)
Notify application when new data is available to be read.
Definition: socket.cc:128

ns3::Socket::GetPeerName
virtual int GetPeerName(Address &address) const =0
Get the peer address of a connected socket.

ns3::Socket::SetSendCallback
void SetSendCallback(Callback< void, Ptr< Socket >, uint32_t > sendCb)
Notify application when space in transmit buffer is added.
Definition: socket.cc:121

ns3::Socket::Recv
virtual Ptr< Packet > Recv(uint32_t maxSize, uint32_t flags)=0
Read data from the socket.

ns3::Socket::Connect
virtual int Connect(const Address &address)=0
Initiate a connection to a remote host.

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:72

ns3::Socket::Close
virtual int Close()=0
Close a socket.

ns3::Socket::GetTxAvailable
virtual uint32_t GetTxAvailable() const =0
Returns the number of bytes which can be sent in a single call to Send.

ns3::TcpSocketFactory
API to create TCP socket instances.
Definition: tcp-socket-factory.h:48

ns3::TestCase
encapsulates test code
Definition: test.h:1060

ns3::TestCase::AddTestCase
void AddTestCase(TestCase *testCase, TestDuration duration=QUICK)
Add an individual child TestCase to this test suite.
Definition: test.cc:301

ns3::TestSuite
A suite of tests to run.
Definition: test.h:1256

ns3::TestSuite::UNIT
@ UNIT
This test suite implements a Unit Test.
Definition: test.h:1265

port
uint16_t port
Definition: dsdv-manet.cc:44

ns3::MakeNullCallback
Callback< R, Args... > MakeNullCallback()
Definition: callback.h:747

NS_FATAL_ERROR
#define NS_FATAL_ERROR(msg)
Report a fatal error with a message and terminate.
Definition: fatal-error.h:179

NS_LOG_COMPONENT_DEFINE
#define NS_LOG_COMPONENT_DEFINE(name)
Define a Log component with a specific name.
Definition: log.h:202

NS_LOG_DEBUG
#define NS_LOG_DEBUG(msg)
Use NS_LOG to output a message of level LOG_DEBUG.
Definition: log.h:268

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:251

AddSimpleNetDevice
Ptr< SimpleNetDevice > AddSimpleNetDevice(Ptr< Node > node, Ipv4Address v4Addr, Ipv4Mask v4Mask, Ipv6Address v6Addr, Ipv6Prefix v6Prefix)
Definition: ipv6-dual-stack-test-suite.cc:173

brite-generic-example.server
server
Definition: brite-generic-example.py:62

ns3
Every class exported by the ns3 library is enclosed in the ns3 namespace.

ns3::MakeCallback
Callback< R, Args... > MakeCallback(R(T::*memPtr)(Args...), OBJ objPtr)
Build Callbacks for class method members which take varying numbers of arguments and potentially retu...
Definition: callback.h:704

nsclick-simple-lan.ipv4
ipv4
Definition: nsclick-simple-lan.py:57

third.channel
channel
Definition: third.py:88

two-ray-to-three-gpp-ch-calibration.m
m
Definition: two-ray-to-three-gpp-ch-calibration.py:591

g_tcpTestSuite
static TcpTestSuite g_tcpTestSuite
Static variable for test initialization.
Definition: tcp-test.cc:562

Name
static std::string Name(std::string str, uint32_t totalStreamSize, uint32_t sourceWriteSize, uint32_t serverReadSize, uint32_t serverWriteSize, uint32_t sourceReadSize, bool useIpv6)
Definition: tcp-test.cc:166

GetString
static std::string GetString(Ptr< Packet > p)
Definition: tcp-test.cc:182