/* -*- 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/inet6-socket-address.h"

#include "ns3/log.h"

#include "ns3/ipv4.h"

#include "ns3/ipv6.h"

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

#include "ns3/ipv4-route.h"

#include "ns3/ipv6-route.h"

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

#include "ns3/ipv6-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 "ipv6-end-point.h"

#include "ipv6-l3-protocol.h"

#include "tcp-header.h"

#include "tcp-option-winscale.h"

#include "tcp-option-ts.h"

#include "rtt-estimator.h"

#include <math.h>

#include <algorithm>

namespace ns3 {

NS_LOG_COMPONENT_DEFINE ("TcpSocketBase");

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

    .AddAttribute ("IcmpCallback", "Callback invoked whenever an icmp error is received on this socket.",

                   CallbackValue (),

                   MakeCallbackAccessor (&TcpSocketBase::m_icmpCallback),

                   MakeCallbackChecker ())

    .AddAttribute ("IcmpCallback6", "Callback invoked whenever an icmpv6 error is received on this socket.",

                   CallbackValue (),

                   MakeCallbackAccessor (&TcpSocketBase::m_icmpCallback6),

                   MakeCallbackChecker ())

    .AddAttribute ("WindowScaling", "Enable or disable Window Scaling option",

                   BooleanValue (true),

                   MakeBooleanAccessor (&TcpSocketBase::m_winScalingEnabled),

                   MakeBooleanChecker ())

    .AddAttribute ("Timestamp", "Enable or disable Timestamp option",

                   BooleanValue (true),

                   MakeBooleanAccessor (&TcpSocketBase::m_timestampEnabled),

                   MakeBooleanChecker ())

    .AddAttribute ("MinRto",

                   "Minimum retransmit timeout value",

                   TimeValue (Seconds (0.2)), // RFC2988 says min RTO=1 sec, but Linux uses 200ms. See http://www.postel.org/pipermail/end2end-interest/2004-November/004402.html

                   MakeTimeAccessor (&TcpSocketBase::SetMinRto,

                                     &TcpSocketBase::GetMinRto),

                                     MakeTimeChecker ())

    .AddAttribute ("ClockGranularity",

                   "Clock Granularity used in RTO calculations",

                   TimeValue (MilliSeconds (1)), // RFC6298 suggest to use fine clock granularity

                   MakeTimeAccessor (&TcpSocketBase::SetClockGranularity,

                                     &TcpSocketBase::GetClockGranularity),

                                     MakeTimeChecker ())

    .AddTraceSource ("RTO",

                     "Retransmission timeout",

                     MakeTraceSourceAccessor (&TcpSocketBase::m_rto),

                     "ns3::Time::TracedValueCallback")

    .AddTraceSource ("RTT",

                     "Last RTT sample",

                     MakeTraceSourceAccessor (&TcpSocketBase::m_lastRtt),

                     "ns3::Time::TracedValueCallback")

    .AddTraceSource ("NextTxSequence",

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

                     MakeTraceSourceAccessor (&TcpSocketBase::m_nextTxSequence),

                     "ns3::SequenceNumber32TracedValueCallback")

    .AddTraceSource ("HighestSequence",

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

                     MakeTraceSourceAccessor (&TcpSocketBase::m_highTxMark),

                     "ns3::SequenceNumber32TracedValueCallback")

    .AddTraceSource ("State",

                     "TCP state",

                     MakeTraceSourceAccessor (&TcpSocketBase::m_state),

                     "ns3::TcpStatesTracedValueCallback")

    .AddTraceSource ("RWND",

                     "Remote side's flow control window",

                     MakeTraceSourceAccessor (&TcpSocketBase::m_rWnd),

                     "ns3::TracedValue::Uint32Callback")

  ;

  return tid;

}

TcpSocketBase::TcpSocketBase (void)

  : m_dupAckCount (0),

    m_delAckCount (0),

    m_endPoint (0),

    m_endPoint6 (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),

    m_sndScaleFactor (0),

    m_rcvScaleFactor (0),

    m_timestampEnabled (true),

    m_timestampToEcho (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_noDelay (sock.m_noDelay),

    m_cnRetries (sock.m_cnRetries),

    m_delAckTimeout (sock.m_delAckTimeout),

    m_persistTimeout (sock.m_persistTimeout),

    m_cnTimeout (sock.m_cnTimeout),

    m_endPoint (0),

    m_endPoint6 (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),

    m_winScalingEnabled (sock.m_winScalingEnabled),

    m_sndScaleFactor (sock.m_sndScaleFactor),

    m_rcvScaleFactor (sock.m_rcvScaleFactor),

    m_timestampEnabled (sock.m_timestampEnabled),

    m_timestampToEcho (sock.m_timestampToEcho)

{

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

    }

  if (m_endPoint6 != 0)

    {

      NS_ASSERT (m_tcp != 0);

      NS_ASSERT (m_endPoint6 != 0);

      m_tcp->DeAllocate (m_endPoint6);

      NS_ASSERT (m_endPoint6 == 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 (this);

  m_endPoint = m_tcp->Allocate ();

  if (0 == m_endPoint)

    {

      m_errno = ERROR_ADDRNOTAVAIL;

      return -1;

    }

  if (std::find(m_tcp->m_sockets.begin(), m_tcp->m_sockets.end(), this) == m_tcp->m_sockets.end())

    {

      m_tcp->m_sockets.push_back (this);

    }

  return SetupCallback ();

}

int

TcpSocketBase::Bind6 (void)

{

  NS_LOG_FUNCTION (this);

  m_endPoint6 = m_tcp->Allocate6 ();

  if (0 == m_endPoint6)

    {

      m_errno = ERROR_ADDRNOTAVAIL;

      return -1;

    }

  if (std::find(m_tcp->m_sockets.begin(), m_tcp->m_sockets.end(), this) == m_tcp->m_sockets.end())

    {

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

    {

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

        }

      if (0 == m_endPoint)

        {

          m_errno = port ? ERROR_ADDRINUSE : ERROR_ADDRNOTAVAIL;

          return -1;

        }

    }

  else if (Inet6SocketAddress::IsMatchingType (address))

    {

      Inet6SocketAddress transport = Inet6SocketAddress::ConvertFrom (address);

      Ipv6Address ipv6 = transport.GetIpv6 ();

      uint16_t port = transport.GetPort ();

      if (ipv6 == Ipv6Address::GetAny () && port == 0)

        {

          m_endPoint6 = m_tcp->Allocate6 ();

        }

      else if (ipv6 == Ipv6Address::GetAny () && port != 0)

        {

          m_endPoint6 = m_tcp->Allocate6 (port);

        }

      else if (ipv6 != Ipv6Address::GetAny () && port == 0)

        {

          m_endPoint6 = m_tcp->Allocate6 (ipv6);

        }

      else if (ipv6 != Ipv6Address::GetAny () && port != 0)

        {

          m_endPoint6 = m_tcp->Allocate6 (ipv6, port);

        }

      if (0 == m_endPoint6)

        {

          m_errno = port ? ERROR_ADDRINUSE : ERROR_ADDRNOTAVAIL;

          return -1;

        }

    }

  else

    {

      m_errno = ERROR_INVAL;

      return -1;

    }

  if (std::find(m_tcp->m_sockets.begin(), m_tcp->m_sockets.end(), this) == m_tcp->m_sockets.end())

    {

      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 (InetSocketAddress::IsMatchingType (address) && m_endPoint6 == 0)

    {

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

      m_endPoint6 = 0;

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

        }

    }

  else if (Inet6SocketAddress::IsMatchingType (address)  && m_endPoint == 0)

    {

      // If we are operating on a v4-mapped address, translate the address to

      // a v4 address and re-call this function

      Inet6SocketAddress transport = Inet6SocketAddress::ConvertFrom (address);

      Ipv6Address v6Addr = transport.GetIpv6 ();

      if (v6Addr.IsIpv4MappedAddress () == true)

        {

          Ipv4Address v4Addr = v6Addr.GetIpv4MappedAddress ();

          return Connect (InetSocketAddress (v4Addr, transport.GetPort ()));

        }

      if (m_endPoint6 == 0)

        {

          if (Bind6 () == -1)

            {

              NS_ASSERT (m_endPoint6 == 0);

              return -1; // Bind() failed

            }

          NS_ASSERT (m_endPoint6 != 0);

        }

      m_endPoint6->SetPeer (v6Addr, transport.GetPort ());

      m_endPoint = 0;

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

      if (SetupEndpoint6 () != 0)

        { // Route to destination does not exist

          return -1;

        }

    }

  else

    {

      m_errno = ERROR_INVAL;

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

  /// \internal

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

  /// \bugid{426} claims we should send reset in this case.