//   "tcp-large-transfer.pcap-$n-$i" where n and i represent node and interface numbers respectively

//   "tcp-large-transfer-$n-$i.pcap" where n and i represent node and interface

// numbers respectively

void 

// The number of bytes to send in this simulation.

ApplicationTraceSink (Ptr<const Packet> packet,

static uint32_t txBytes = 2000000;

                      const Address &addr)

{

// These are for starting the writing process, and handling the sending 

// g_log is not declared in optimized builds

// socket's notification upcalls (events).  These two together more or less

// should convert this to use of some other flag than the logging system

// implement a sending "Application", although not a proper ns3::Application

#ifdef NS3_LOG_ENABLE

// subclass.

  if (!g_log.IsNoneEnabled ()) {

    if (InetSocketAddress::IsMatchingType (addr) )

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

      {

      InetSocketAddress address = InetSocketAddress::ConvertFrom (addr);

        std::cout << "PacketSink received size " << 

        packet->GetSize () << " at time " << 

        Simulator::Now ().GetSeconds () << " from address: " << 

        address.GetIpv4 () << std::endl;

        char buf[2000]; 

        memcpy(buf, packet->PeekData (), packet->GetSize ());

        for (uint32_t i=0; i < packet->GetSize (); i++)

          {

            std::cout << buf[i];

            if (i && i % 60 == 0) 

              std::cout << std::endl; 

          }

        std::cout << std::endl << std::endl;

    }

  }

#endif

}

void CloseConnection (Ptr<Socket> localSocket);

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

  // Here, we will explicitly create three nodes. 

  // Here, we will explicitly create three nodes.  The first container contains

  NodeContainer c0;

  // nodes 0 and 1 from the diagram above, and the second one contains nodes

  c0.Create (2);

  // 1 and 2.  This reflects the channel connectivity, and will be used to

  // install the network interfaces and connect them with a channel.

  NodeContainer c1;

  NodeContainer n0n1;

  c1.Add (c0.Get (1));

  n0n1.Create (2);

  c1.Create (1);

  NodeContainer n1n2;

  n1n2.Add (n0n1.Get (1));

  n1n2.Create (1);

  NetDeviceContainer dev0 = p2p.Install (c0);

  NetDeviceContainer dev1 = p2p.Install (c1);

  // And then install devices and channels connecting our topology.

  NetDeviceContainer dev0 = p2p.Install (n0n1);

  // add ip/tcp stack to nodes.

  NetDeviceContainer dev1 = p2p.Install (n1n2);

  NodeContainer c = NodeContainer (c0, c1.Get (1));

  // Now add ip/tcp stack to all nodes.

  NodeContainer allNodes = NodeContainer (n0n1, n1n2.Get (1));

  internet.Install (c);

  internet.Install (allNodes);

  // Later, we add IP addresses.  

  // Later, we add IP addresses.

  // 

  //

  // Should observe SYN exchange, a lot of data segments, and FIN exchange

  // Should observe SYN exchange, a lot of data segments and ACKS, and FIN 

  // exchange.  FIN exchange isn't quite compliant with TCP spec (see release

  // notes for more info)

  // Create a packet sink to receive these packets

  // Create a packet sink to receive these packets on n2...

  ApplicationContainer apps = sink.Install (c1.Get (1));

  ApplicationContainer apps = sink.Install (n1n2.Get (1));

  // and generate traffic to remote sink.

  // Create a source to send packets from n0.  Instead of a full Application

  //TypeId tid = TypeId::LookupByName ("ns3::TcpSocketFactory");

  // and the helper APIs you might see in other example files, this example

  Ptr<Socket> localSocket = Socket::CreateSocket (c0.Get (0), TcpSocketFactory::GetTypeId ());

  // will use sockets directly and register some socket callbacks as a sending

  // "Application".

  // Create and bind the socket...

  Ptr<Socket> localSocket =

      Socket::CreateSocket (n0n1.Get (0), TcpSocketFactory::GetTypeId ());

  Simulator::ScheduleNow (&StartFlow, localSocket, nBytes,

  // ...and schedule the sending "Application"; This is similar to what an 

  // ns3::Application subclass would do internally.

  Simulator::ScheduleNow (&StartFlow, localSocket,

  Config::ConnectWithoutContext ("/NodeList/*/ApplicationList/*/Rx", 

  // One can toggle the comment for the following line on or off to see the

                   MakeCallback (&ApplicationTraceSink));

  // effects of finite send buffer modelling.  One can also change the size of

  // said buffer.

  //localSocket->SetAttribute("SndBufSize", UintegerValue(4096));

  //Ask for ASCII and pcap traces of network traffic

void CloseConnection (Ptr<Socket> localSocket)

{

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

  localSocket->Close ();

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

}

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

//begin implementation of sending "Application"

void StartFlow(Ptr<Socket> localSocket, uint32_t nBytes, 

void StartFlow(Ptr<Socket> localSocket,

 // NS_LOG_LOGIC("Starting flow at time " <<  Simulator::Now ().GetSeconds ());

  NS_LOG_LOGIC("Starting flow at time " <<  Simulator::Now ().GetSeconds ());

  localSocket->SetConnectCallback (MakeCallback (&CloseConnection),

                                   Callback<void, Ptr<Socket> > ());

  // tell the tcp implementation to call WriteUntilBufferFull again

  //we want to close as soon as the connection is established

  // if we blocked and new tx buffer space becomes available

  //the tcp state machine and outgoing buffer will assure that

  //all of the data is delivered

  WriteUntilBufferFull (localSocket, nBytes);

  WriteUntilBufferFull (localSocket, txBytes);

}

}

void WriteUntilBufferFull (Ptr<Socket> localSocket, uint32_t nBytes)

void WriteUntilBufferFull (Ptr<Socket> localSocket, uint32_t txSpace)

  while (nBytes > 0) {

    uint32_t curSize= nBytes > writeSize ? writeSize : nBytes;

  while (txBytes > 0) {

    uint32_t curSize= txBytes > writeSize ? writeSize : txBytes;

    if (curSize > txSpace)

      curSize = txSpace;

    uint32_t amountSent = localSocket->Send (data, curSize, 0);

    int amountSent = localSocket->Send (data, curSize, 0);

    if(amountSent < curSize)

    if(amountSent < 0)

        std::cout << "Socket blocking, returning" << std::endl;

        // we will be called again when new tx space becomes available.

        std::cout << "Socket blocking, " << txBytes << " left to write, returning" << std::endl;

    nBytes -= curSize;

    txBytes -= curSize;

    if (amountSent != (int)curSize)

      {

        std::cout << "Short Write, returning" << std::endl;

        return;

      }

}

  localSocket->Close ();

}