/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */

/*

 * Copyright (c) 2010 Adrian Sai-wah Tam

 *

 * 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

 *

 * Author: Adrian Sai-wah Tam <adrian.sw.tam@gmail.com>

 */

#define NS_LOG_APPEND_CONTEXT \

  if (m_node) { std::clog << Simulator::Now ().GetSeconds () << " [node " << m_node->GetId () << "] "; }

#include "ns3/abort.h"

#include "ns3/node.h"

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

#include "ns3/log.h"

#include "ns3/ipv4.h"

#include "ns3/ipv4-interface-address.h"

#include "ns3/ipv4-route.h"

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

#include "ns3/simulation-singleton.h"

#include "ns3/simulator.h"

#include "ns3/packet.h"

#include "ns3/uinteger.h"

#include "ns3/trace-source-accessor.h"

#include "tcp-socket-base.h"

#include "tcp-l4-protocol.h"

#include "ipv4-end-point.h"

#include "tcp-header.h"

#include "rtt-estimator.h"

#include <algorithm>

NS_LOG_COMPONENT_DEFINE ("TcpSocketBase");

namespace ns3 {

NS_OBJECT_ENSURE_REGISTERED (TcpSocketBase);

TypeId

TcpSocketBase::GetTypeId (void)

{

  static TypeId tid = TypeId ("ns3::TcpSocketBase")

    .SetParent<TcpSocket> ()

//    .AddAttribute ("TcpState", "State in TCP state machine",

//                   TypeId::ATTR_GET,

//                   EnumValue (CLOSED),

//                   MakeEnumAccessor (&TcpSocketBase::m_state),

//                   MakeEnumChecker (CLOSED, "Closed"))

    .AddTraceSource ("RTO",

                     "Retransmission timeout",

                     MakeTraceSourceAccessor (&TcpSocketBase::m_rto))

    .AddTraceSource ("RTT",

                     "Last RTT sample",

                     MakeTraceSourceAccessor (&TcpSocketBase::m_lastRtt))

    .AddTraceSource ("NextTxSequence",

                     "Next sequence number to send (SND.NXT)",

                     MakeTraceSourceAccessor (&TcpSocketBase::m_nextTxSequence))

    .AddTraceSource ("HighestSequence",

                     "Highest sequence number ever sent in socket's life time",

                     MakeTraceSourceAccessor (&TcpSocketBase::m_highTxMark))

    .AddTraceSource ("State",

                     "TCP state",

                     MakeTraceSourceAccessor (&TcpSocketBase::m_state))

    .AddTraceSource ("RWND",

                     "Remote side's flow control window",

                     MakeTraceSourceAccessor (&TcpSocketBase::m_rWnd))

  ;

  return tid;

}

TcpSocketBase::TcpSocketBase (void)

  : m_dupAckCount (0),

    m_delAckCount (0),

    m_endPoint (0),

    m_node (0),

    m_tcp (0),

    m_rtt (0),

    m_nextTxSequence (0),       // Change this for non-zero initial sequence number

    m_highTxMark (0),

    m_rxBuffer (0),

    m_txBuffer (0),

    m_state (CLOSED),

    m_errno (ERROR_NOTERROR),

    m_closeNotified (false),

    m_closeOnEmpty (false),

    m_shutdownSend (false),

    m_shutdownRecv (false),

    m_connected (false),

    m_segmentSize (0),          // For attribute initialization consistency (quiet valgrind)

    m_rWnd (0)

{

  NS_LOG_FUNCTION (this);

}

TcpSocketBase::TcpSocketBase (const TcpSocketBase& sock)

  : TcpSocket (sock), //copy object::m_tid and socket::callbacks

    m_dupAckCount (sock.m_dupAckCount),

    m_delAckCount (0),

    m_delAckMaxCount (sock.m_delAckMaxCount),

    m_cnCount (sock.m_cnCount),

    m_delAckTimeout (sock.m_delAckTimeout),

    m_persistTimeout (sock.m_persistTimeout),

    m_cnTimeout (sock.m_cnTimeout),

    m_endPoint (0),

    m_node (sock.m_node),

    m_tcp (sock.m_tcp),

    m_rtt (0),

    m_nextTxSequence (sock.m_nextTxSequence),

    m_highTxMark (sock.m_highTxMark),

    m_rxBuffer (sock.m_rxBuffer),

    m_txBuffer (sock.m_txBuffer),

    m_state (sock.m_state),

    m_errno (sock.m_errno),

    m_closeNotified (sock.m_closeNotified),

    m_closeOnEmpty (sock.m_closeOnEmpty),

    m_shutdownSend (sock.m_shutdownSend),

    m_shutdownRecv (sock.m_shutdownRecv),

    m_connected (sock.m_connected),

    m_segmentSize (sock.m_segmentSize),

    m_rWnd (sock.m_rWnd)

{

  NS_LOG_FUNCTION (this);

  NS_LOG_LOGIC ("Invoked the copy constructor");

  // Copy the rtt estimator if it is set

  if (sock.m_rtt)

    {

      m_rtt = sock.m_rtt->Copy ();

    }

  // Reset all callbacks to null

  Callback<void, Ptr< Socket > > vPS = MakeNullCallback<void, Ptr<Socket> > ();

  Callback<void, Ptr<Socket>, const Address &> vPSA = MakeNullCallback<void, Ptr<Socket>, const Address &> ();

  Callback<void, Ptr<Socket>, uint32_t> vPSUI = MakeNullCallback<void, Ptr<Socket>, uint32_t> ();

  SetConnectCallback (vPS, vPS);

  SetDataSentCallback (vPSUI);

  SetSendCallback (vPSUI);

  SetRecvCallback (vPS);

}

TcpSocketBase::~TcpSocketBase (void)

{

  NS_LOG_FUNCTION (this);

  m_node = 0;

  if (m_endPoint != 0)

    {

      NS_ASSERT (m_tcp != 0);

      /*

       * Upon Bind, an Ipv4Endpoint is allocated and set to m_endPoint, and

       * DestroyCallback is set to TcpSocketBase::Destroy. If we called

       * m_tcp->DeAllocate, it wil destroy its Ipv4EndpointDemux::DeAllocate,

       * which in turn destroys my m_endPoint, and in turn invokes

       * TcpSocketBase::Destroy to nullify m_node, m_endPoint, and m_tcp.

       */

      NS_ASSERT (m_endPoint != 0);

      m_tcp->DeAllocate (m_endPoint);

      NS_ASSERT (m_endPoint == 0);

    }

  m_tcp = 0;

  CancelAllTimers ();

}

/** Associate a node with this TCP socket */

void

TcpSocketBase::SetNode (Ptr<Node> node)

{

  m_node = node;

}

/** Associate the L4 protocol (e.g. mux/demux) with this socket */

void

TcpSocketBase::SetTcp (Ptr<TcpL4Protocol> tcp)

{

  m_tcp = tcp;

}

/** Set an RTT estimator with this socket */

void

TcpSocketBase::SetRtt (Ptr<RttEstimator> rtt)

{

  m_rtt = rtt;

}

/** Inherit from Socket class: Returns error code */

enum Socket::SocketErrno

TcpSocketBase::GetErrno (void) const

{

  return m_errno;

}

/** Inherit from Socket class: Returns socket type, NS3_SOCK_STREAM */

enum Socket::SocketType

TcpSocketBase::GetSocketType (void) const

{

  return NS3_SOCK_STREAM;

}

/** Inherit from Socket class: Returns associated node */

Ptr<Node>

TcpSocketBase::GetNode (void) const

{

  NS_LOG_FUNCTION_NOARGS ();

  return m_node;

}

/** Inherit from Socket class: Bind socket to an end-point in TcpL4Protocol */

int

TcpSocketBase::Bind (void)

{

  NS_LOG_FUNCTION_NOARGS ();

  m_endPoint = m_tcp->Allocate ();

  return SetupCallback ();

}

/** Inherit from Socket class: Bind socket (with specific address) to an end-point in TcpL4Protocol */

int

TcpSocketBase::Bind (const Address &address)

{

  NS_LOG_FUNCTION (this << address);

  if (!InetSocketAddress::IsMatchingType (address))

    {

      m_errno = ERROR_INVAL;

      return -1;

    }

  InetSocketAddress transport = InetSocketAddress::ConvertFrom (address);

  Ipv4Address ipv4 = transport.GetIpv4 ();

  uint16_t port = transport.GetPort ();

  if (ipv4 == Ipv4Address::GetAny () && port == 0)

    {

      m_endPoint = m_tcp->Allocate ();

    }

  else if (ipv4 == Ipv4Address::GetAny () && port != 0)

    {

      m_endPoint = m_tcp->Allocate (port);

    }

  else if (ipv4 != Ipv4Address::GetAny () && port == 0)

    {

      m_endPoint = m_tcp->Allocate (ipv4);

    }

  else if (ipv4 != Ipv4Address::GetAny () && port != 0)

    {

      m_endPoint = m_tcp->Allocate (ipv4, port);

    }

  NS_LOG_LOGIC ("TcpSocketBase " << this << " got an endpoint: " << m_endPoint);

  return SetupCallback ();

}

/** Inherit from Socket class: Initiate connection to a remote address:port */

int

TcpSocketBase::Connect (const Address & address)

{

  NS_LOG_FUNCTION (this << address);

  // If haven't do so, Bind() this socket first

  if (m_endPoint == 0)

    {

      if (Bind () == -1)

        {

          NS_ASSERT (m_endPoint == 0);

          return -1; // Bind() failed

        }

      NS_ASSERT (m_endPoint != 0);

    }

  InetSocketAddress transport = InetSocketAddress::ConvertFrom (address);

  m_endPoint->SetPeer (transport.GetIpv4 (), transport.GetPort ());

  // Get the appropriate local address and port number from the routing protocol and set up endpoint

  if (SetupEndpoint () != 0)

    { // Route to destination does not exist

      return -1;

    }

  // DoConnect() will do state-checking and send a SYN packet

  return DoConnect ();

}

/** Inherit from Socket class: Listen on the endpoint for an incoming connection */

int

TcpSocketBase::Listen (void)

{

  NS_LOG_FUNCTION (this);

  // Linux quits EINVAL if we're not in CLOSED state, so match what they do

  if (m_state != CLOSED)

    {

      m_errno = ERROR_INVAL;

      return -1;

    }

  // In other cases, set the state to LISTEN and done

  NS_LOG_INFO ("CLOSED -> LISTEN");

  m_state = LISTEN;

  return 0;

}

/** Inherit from Socket class: Kill this socket and signal the peer (if any) */

int

TcpSocketBase::Close (void)

{

  NS_LOG_FUNCTION (this);

  // First we check to see if there is any unread rx data

  // Bug number 426 claims we should send reset in this case.

  if (m_rxBuffer.Size () != 0)

    {

      SendRST ();

      return 0;

    }

  if (m_txBuffer.SizeFromSequence (m_nextTxSequence) > 0)

    { // App close with pending data must wait until all data transmitted

      if (m_closeOnEmpty == false)

        {

          m_closeOnEmpty = true;

          NS_LOG_INFO ("Socket " << this << " deferring close, state " << TcpStateName[m_state]);

        }

      return 0;

    }

  return DoClose ();

}

/** Inherit from Socket class: Signal a termination of send */

int

TcpSocketBase::ShutdownSend (void)

{

  NS_LOG_FUNCTION (this);

  m_shutdownSend = true;

  return 0;

}

/** Inherit from Socket class: Signal a termination of receive */

int

TcpSocketBase::ShutdownRecv (void)

{

  NS_LOG_FUNCTION (this);

  m_shutdownRecv = true;

  return 0;

}

/** Inherit from Socket class: Send a packet. Parameter flags is not used.

    Packet has no TCP header. Invoked by upper-layer application */

int

TcpSocketBase::Send (Ptr<Packet> p, uint32_t flags)

{

  NS_LOG_FUNCTION (this << p);

  NS_ABORT_MSG_IF (flags, "use of flags is not supported in TcpSocketBase::Send()");

  if (m_state == ESTABLISHED || m_state == SYN_SENT || m_state == CLOSE_WAIT)

    {

      // Store the packet into Tx buffer

      if (!m_txBuffer.Add (p))

        { // TxBuffer overflow, send failed

          m_errno = ERROR_MSGSIZE;

          return -1;

        }

      // Submit the data to lower layers

      NS_LOG_LOGIC ("txBufSize=" << m_txBuffer.Size () << " state " << TcpStateName[m_state]);

      if (m_state == ESTABLISHED || m_state == CLOSE_WAIT)

        { // Try to send the data out

          SendPendingData (m_connected);

        }

      return p->GetSize ();

    }

  else

    { // Connection not established yet

      m_errno = ERROR_NOTCONN;

      return -1; // Send failure

    }

}

/** Inherit from Socket class: In TcpSocketBase, it is same as Send() call */

int

TcpSocketBase::SendTo (Ptr<Packet> p, uint32_t flags, const Address &address)

{

  return Send (p, flags); // SendTo() and Send() are the same

}

/** Inherit from Socket class: Return data to upper-layer application. Parameter flags

    is not used. Data is returned as a packet of size no larger than maxSize */

Ptr<Packet>

TcpSocketBase::Recv (uint32_t maxSize, uint32_t flags)

{

  NS_LOG_FUNCTION (this);

  NS_ABORT_MSG_IF (flags, "use of flags is not supported in TcpSocketBase::Recv()");

  if (m_rxBuffer.Size () == 0 && m_state == CLOSE_WAIT)

    {

      return Create<Packet> (); // Send EOF on connection close

    }

  Ptr<Packet> outPacket = m_rxBuffer.Extract (maxSize);

  if (outPacket != 0 && outPacket->GetSize () != 0)

    {

      SocketAddressTag tag;

      tag.SetAddress (InetSocketAddress (m_endPoint->GetPeerAddress (), m_endPoint->GetPeerPort ()));

      outPacket->AddPacketTag (tag);

    }

  return outPacket;

}

/** Inherit from Socket class: Recv and return the remote's address */

Ptr<Packet>

TcpSocketBase::RecvFrom (uint32_t maxSize, uint32_t flags, Address &fromAddress)

{

  NS_LOG_FUNCTION (this << maxSize << flags);

  Ptr<Packet> packet = Recv (maxSize, flags);

  // Null packet means no data to read, and an empty packet indicates EOF

  if (packet != 0 && packet->GetSize () != 0)

    {

      SocketAddressTag tag;

      bool found;

      found = packet->PeekPacketTag (tag);

      NS_ASSERT (found);

      //cast found to void , to suppress 'found' set but not used compiler warning

      //in optimized builds

      (void) found;

      fromAddress = tag.GetAddress ();

    }

  return packet;

}

/** Inherit from Socket class: Get the max number of bytes an app can send */

uint32_t

TcpSocketBase::GetTxAvailable (void) const

{

  NS_LOG_FUNCTION (this);

  return m_txBuffer.Available ();

}

/** Inherit from Socket class: Get the max number of bytes an app can read */

uint32_t

TcpSocketBase::GetRxAvailable (void) const

{

  NS_LOG_FUNCTION (this);

  return m_rxBuffer.Available ();

}

/** Inherit from Socket class: Return local address:port */

int

TcpSocketBase::GetSockName (Address &address) const

{

  NS_LOG_FUNCTION (this);

  if (m_endPoint != 0)

    {

      address = InetSocketAddress (m_endPoint->GetLocalAddress (), m_endPoint->GetLocalPort ());

    }

  else

    { // It is possible to call this method on a socket without a name

      // in which case, behavior is unspecified

      address = InetSocketAddress (Ipv4Address::GetZero (), 0);

    }

  return 0;

}

/** Inherit from Socket class: Bind this socket to the specified NetDevice */

void

TcpSocketBase::BindToNetDevice (Ptr<NetDevice> netdevice)

{

  NS_LOG_FUNCTION (netdevice);

  Socket::BindToNetDevice (netdevice); // Includes sanity check

  if (m_endPoint == 0)

    {

      if (Bind () == -1)

        {

          NS_ASSERT (m_endPoint == 0);

          return;

        }

      NS_ASSERT (m_endPoint != 0);

    }

  m_endPoint->BindToNetDevice (netdevice);

  return;

}

/** Clean up after Bind. Set up callback functions in the end-point. */

int

TcpSocketBase::SetupCallback (void)

{

  NS_LOG_FUNCTION (this);

  if (m_endPoint == 0)

    {

      return -1;

    }

  m_endPoint->SetRxCallback (MakeCallback (&TcpSocketBase::ForwardUp, Ptr<TcpSocketBase> (this)));

  m_endPoint->SetDestroyCallback (MakeCallback (&TcpSocketBase::Destroy, Ptr<TcpSocketBase> (this)));

  return 0;

}

/** Perform the real connection tasks: Send SYN if allowed, RST if invalid */

int

TcpSocketBase::DoConnect (void)

{

  NS_LOG_FUNCTION (this);

  // A new connection is allowed only if this socket does not have a connection

  if (m_state == CLOSED || m_state == LISTEN || m_state == SYN_SENT || m_state == LAST_ACK || m_state == CLOSE_WAIT)

    { // send a SYN packet and change state into SYN_SENT

      SendEmptyPacket (TcpHeader::SYN);

      NS_LOG_INFO (TcpStateName[m_state] << " -> SYN_SENT");

      m_state = SYN_SENT;

    }

  else if (m_state != TIME_WAIT)

    { // In states SYN_RCVD, ESTABLISHED, FIN_WAIT_1, FIN_WAIT_2, and CLOSING, an connection

      // exists. We send RST, tear down everything, and close this socket.

      CloseAndNotify ();

      SendRST ();

    }

  return 0;

}

/** Do the action to close the socket. Usually send a packet with appropriate

    flags depended on the current m_state. */

int