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

/*

 * Copyright (c) 2007 Georgia Tech Research Corporation

 * 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/double.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"))

    .AddAttribute ("MaxSegLifetime",

                   "Maximum segment lifetime in seconds, use for TIME_WAIT state transition to CLOSED state",

                   DoubleValue (120), /* RFC793 says MSL=2 minutes*/

                   MakeDoubleAccessor (&TcpSocketBase::m_msl),

                   MakeDoubleChecker<double> (0))

    .AddAttribute ("MaxWindowSize", "Max size of advertised window",

                   UintegerValue (65535),

                   MakeUintegerAccessor (&TcpSocketBase::m_maxWinSize),

                   MakeUintegerChecker<uint16_t> ())

    .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_cnRetries (sock.m_cnRetries),

    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_msl (sock.m_msl),

    m_segmentSize (sock.m_segmentSize),

    m_maxWinSize (sock.m_maxWinSize),

    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 ();

  if (0 == m_endPoint)

    {

      m_errno = ERROR_ADDRNOTAVAIL;

      return -1;

    }

  m_tcp->m_sockets.push_back (this);

  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 ();

      if (0 == m_endPoint)

        {

          m_errno = ERROR_ADDRNOTAVAIL;

          return -1;

        }

    }

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

    {

      m_endPoint = m_tcp->Allocate (port);

      if (0 == m_endPoint)

        {

          m_errno = ERROR_ADDRINUSE;

          return -1;

        }

    }

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

    {

      m_endPoint = m_tcp->Allocate (ipv4);

      if (0 == m_endPoint)

        {

          m_errno = ERROR_ADDRNOTAVAIL;

          return -1;

        }

    }

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

    {

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

      if (0 == m_endPoint)

        {

          m_errno = ERROR_ADDRINUSE;

          return -1;

        }

    }

  m_tcp->m_sockets.push_back (this);

  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;

    }

  // Re-initialize parameters in case this socket is being reused after CLOSE

  m_rtt->Reset ();

  m_cnCount = m_cnRetries;

  // 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)

    {

      if (m_endPoint != 0)

        {

          fromAddress = InetSocketAddress (m_endPoint->GetPeerAddress (), m_endPoint->GetPeerPort ());

        }

      else

        {

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

        }

    }

  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;

}