c_cpp triple_tcp.cc

Posted 2021-05-14

/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
 * 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
 *
 */

/* Test program for multi-interface host, static routing

   n0------------n1-----------------n2
*/

#include <iostream>
#include <fstream>
#include <string>
#include <cassert>

#include "ns3/core-module.h"
#include "ns3/network-module.h"
#include "ns3/internet-module.h"
#include "ns3/point-to-point-module.h"
#include "ns3/applications-module.h"
#include "ns3/ipv4-static-routing-helper.h"
#include "ns3/ipv4-list-routing-helper.h"

using namespace ns3;

NS_LOG_COMPONENT_DEFINE ("TripleTcp");

static const uint32_t totalTxBytes = 20000;
static uint32_t currentTxBytes = 0;
static const uint32_t writeSize = 1040;
uint8_t data[writeSize];

void StartFlow (Ptr<Socket>, Ipv4Address, uint16_t);
void WriteUntilBufferFull (Ptr<Socket>, uint32_t);

void SendStuff (Ptr<Socket> sock, Ipv4Address dstaddr, uint16_t port);
void BindSock (Ptr<Socket> sock, Ptr<NetDevice> netdev);
void srcSocketRecv (Ptr<Socket> socket);
void dstSocketRecv (Ptr<Socket> socket);
void HandleAccept (Ptr<Socket> s, const Address& from);
void SendStuffAddNewTag (Ptr<Socket> sock, Ipv4Address dstaddr, uint16_t port);

int 
main (int argc, char *argv[])
{

  // Allow the user to override any of the defaults and the above
  // DefaultValue::Bind ()s at run-time, via command-line arguments
  CommandLine cmd;
  cmd.Parse (argc, argv);

  Ptr<Node> n0= CreateObject<Node> ();
  Ptr<Node> n1= CreateObject<Node> ();
  Ptr<Node> n2= CreateObject<Node> ();

  // Point-to-point links
  NodeContainer nc= NodeContainer (n0,n1,n2);

  InternetStackHelper internet;
  internet.Install (nc);

  NodeContainer nc1= NodeContainer (n0,n1);
  NodeContainer nc2= NodeContainer (n1,n2);

  // We create the channels first without any IP addressing information
  PointToPointHelper p2p;
  p2p.SetDeviceAttribute ("DataRate", StringValue ("5Mbps"));
  p2p.SetChannelAttribute ("Delay", StringValue ("2ms"));
  NetDeviceContainer nd1= p2p.Install (nc1);
  NetDeviceContainer nd2= p2p.Install (nc2);

  // Later, we add IP addresses.
  Ipv4AddressHelper ipv4;
  ipv4.SetBase ("10.1.1.0", "255.255.255.0");
  Ipv4InterfaceContainer interface1= ipv4.Assign (nd1);
  ipv4.NewNetwork();
  Ipv4InterfaceContainer interface2= ipv4.Assign (nd2);

  uint16_t dstport = 12345;
  Ipv4Address dstaddr ("10.1.1.2");

  Ptr<Socket> srcSocket1 = Socket::CreateSocket (n0, TypeId::LookupByName ("ns3::TcpSocketFactory"));
  // srcSocket1->Bind();

  //-------------------------------------

   InetSocketAddress dst = InetSocketAddress (Ipv4Address::GetAny(), dstport);

   Ptr<Socket> midSocket = Socket::CreateSocket (n1, TypeId::LookupByName ("ns3::TcpSocketFactory"));
   midSocket->Bind (dst);
   midSocket->Listen();
   midSocket->SetAcceptCallback (
       MakeNullCallback<bool, Ptr<Socket>, const Address &> (),
       MakeCallback (&HandleAccept));

   Ptr<Socket> finSocket = Socket::CreateSocket (n2, TypeId::LookupByName ("ns3::TcpSocketFactory"));
   finSocket->Bind (dst);
   finSocket->Listen();

  // PacketSinkHelper sink ("ns3::TcpSocketFactory", InetSocketAddress (Ipv4Address::GetAny (), dstport));
  // ApplicationContainer apps = sink.Install (n1);
  // apps.Start (Seconds (0.0));
  // apps.Stop (Seconds (10.0));
  // //-------------------------------------

  // AsciiTraceHelper ascii;
  // p2p.EnableAsciiAll (ascii.CreateFileStream ("socket-bound-tcp-static-routing.tr"));
  p2p.EnablePcapAll ("socket-bound-tcp-static-routing");

  LogComponentEnableAll (LOG_PREFIX_TIME);
  LogComponentEnable ("TripleTcp", LOG_LEVEL_INFO);

  // First packet as normal (goes via Rtr1)
  NS_LOG_INFO ("Simulation start");
  Simulator::Schedule (Seconds (0.1),&SendStuffAddNewTag, srcSocket1, dstaddr, dstport);
  // Second via Rtr1 explicitly
  // Simulator::Schedule (Seconds (1.0),&BindSock, srcSocket2, SrcToRtr1);
  // Simulator::Schedule (Seconds (1.1),&StartFlow, srcSocket2, dstaddr, dstport);
  // Third via Rtr2 explicitly
  // Simulator::Schedule (Seconds (2.0),&BindSock, srcSocket3, SrcToRtr2);
  // Simulator::Schedule (Seconds (2.1),&StartFlow, srcSocket3, dstaddr, dstport);
  // Fourth again as normal (goes via Rtr1)
  // Simulator::Schedule (Seconds (3.0),&BindSock, srcSocket4, Ptr<NetDevice>(0));
  // Simulator::Schedule (Seconds (3.1),&StartFlow, srcSocket4, dstaddr, dstport);
  // If you uncomment what's below, it results in ASSERT failing since you can't 
  // bind to a socket not existing on a node
  // Simulator::Schedule(Seconds(4.0),&BindSock, srcSocket, dDstRtrdDst.Get(0)); 
  Simulator::Run ();
  Simulator::Destroy ();

  return 0;
} 

void HandleAccept (Ptr<Socket> s, const Address& from)
 {
    NS_LOG_INFO("HandleAccept");
    s->SetRecvCallback (MakeCallback (&dstSocketRecv));
  }

void BindSock (Ptr<Socket> sock, Ptr<NetDevice> netdev)
{
  sock->BindToNetDevice (netdev);
  return;
}

void SendStuffAddNewTag (Ptr<Socket> sock, Ipv4Address dstaddr, uint16_t port)
{
  NS_LOG_INFO ("SendStuffAddNewTag");
  Ptr<Packet> p = Create<Packet> ();
  p->AddPaddingAtEnd (100);
  // TimestampTag timestamp;
  // timestamp.SetTimestamp (Simulator::Now ());
  // p->AddByteTag (timestamp);
  sock->Connect (InetSocketAddress (dstaddr,port)); //connect
  sock->SendTo (p, 0, InetSocketAddress (dstaddr,port));
  // sock->Close();

  return;
}

void StartFlow (Ptr<Socket> localSocket,
                Ipv4Address servAddress,
                uint16_t servPort)
{
  NS_LOG_INFO ("Starting flow at time " <<  Simulator::Now ().GetSeconds ());
  currentTxBytes = 0;
  localSocket->Bind ();
  localSocket->Connect (InetSocketAddress (servAddress, servPort)); //connect

  // tell the tcp implementation to call WriteUntilBufferFull again
  // if we blocked and new tx buffer space becomes available
  localSocket->SetSendCallback (MakeCallback (&WriteUntilBufferFull));
  WriteUntilBufferFull (localSocket, localSocket->GetTxAvailable ());
}

void dstSocketRecv (Ptr<Socket> socket)
{
  // Address from;
  // Ptr<Packet> packet = socket->RecvFrom (from);
  // uint32_t id=socket->GetNode()->GetId();

  // ByteTagIterator it=packet-> GetByteTagIterator() ;
  // TimestampTag tag;
  // it.Next().GetTag(tag);

  // std::vector<TimestampTag> tagvector=tagmp.find(id)->second;
  // for(unsigned int i=0;i<tagvector.size();i++){
  //     if(tag.Compare(tagvector[i])==0){
  //           NS_LOG_INFO("The "<<id<<" node receive a packet with an old timestamptag");
  //           return;
  //         }
  //   }
  // NS_LOG_INFO("The "<<id<<" node receive a packet with a NEW timestamptag");
  // tagmp[id].push_back(tag);

  // std::vector<Ipv4Address> v=ipv4mp.find(id)->second;
  // for(unsigned int i=0;i<v.size();i++){
  //   NS_LOG_INFO ("The "<<id<<" node send the "<<i<<" th"<<std::endl);
  //   SendStuffWithOldTag (socket,v[i] ,12345, tag);
  // }
  
  Ptr<Node> n=socket->GetNode();
  Ptr<Socket> socket1 = Socket::CreateSocket (n, TypeId::LookupByName ("ns3::TcpSocketFactory"));
  Ipv4Address finaddr ("10.1.2.2");
  SendStuffAddNewTag(socket1,finaddr,12345);

}

void WriteUntilBufferFull (Ptr<Socket> localSocket, uint32_t txSpace)
{
  while (currentTxBytes < totalTxBytes && localSocket->GetTxAvailable () > 0)
    {
      uint32_t left = totalTxBytes - currentTxBytes;
      uint32_t dataOffset = currentTxBytes % writeSize;
      uint32_t toWrite = writeSize - dataOffset;
      toWrite = std::min (toWrite, left);
      toWrite = std::min (toWrite, localSocket->GetTxAvailable ());
      int amountSent = localSocket->Send (&data[dataOffset], toWrite, 0);
      if(amountSent < 0)
        {
          // we will be called again when new tx space becomes available.
          return;
        }
      currentTxBytes += amountSent;
    }
  localSocket->Close ();
}