protected:

protected:

  /**

  /**

   *

   *

   * This method is invoked once all member attributes have been 

   * This method is invoked once all member attributes have been 

   * initialized. Subclasses can override this method to be notified

   * initialized. Subclasses can override this method to be notified

  // Check for exit condition of fast recovery

  // Check for exit condition of fast recovery

  if (m_inFastRec && seq < m_recover)

  if (m_inFastRec && seq < m_recover)

    { // Partial ACK, partial window deflation (RFC2582 sec.3 bullet #5 paragraph 3)

    { // Partial ACK, partial window deflation (RFC2582 sec.3 bullet #5 paragraph 3)

      NS_LOG_INFO ("Partial ACK for seq " << seq << " in fast recovery: cwnd set to " << m_cWnd);

      NS_LOG_INFO ("Partial ACK for seq " << seq << " in fast recovery: cwnd set to " << m_cWnd);

      DoRetransmit (); // Assume the next seq is lost. Retransmit lost packet

      DoRetransmit (); // Assume the next seq is lost. Retransmit lost packet

      TcpSocketBase::NewAck (seq); // update m_nextTxSequence and send new data if allowed by window

      TcpSocketBase::NewAck (seq); // update m_nextTxSequence and send new data if allowed by window

      return;

      return;

      NS_LOG_INFO ("Dupack in fast recovery mode. Increase cwnd to " << m_cWnd);

      NS_LOG_INFO ("Dupack in fast recovery mode. Increase cwnd to " << m_cWnd);

      SendPendingData (m_connected);

      SendPendingData (m_connected);

    }

    }

    { // RFC3042 Limited transmit: Send a new packet for each duplicated ACK before fast retransmit

    { // RFC3042 Limited transmit: Send a new packet for each duplicated ACK before fast retransmit

      NS_LOG_INFO ("Limited transmit");

      NS_LOG_INFO ("Limited transmit");

      uint32_t sz = SendDataPacket (m_nextTxSequence, m_segmentSize, true);

      uint32_t sz = SendDataPacket (m_nextTxSequence, m_segmentSize, true);

  // If erroneous timeout in closed/timed-wait state, just return

  // If erroneous timeout in closed/timed-wait state, just return

  if (m_state == CLOSED || m_state == TIME_WAIT) return;

  if (m_state == CLOSED || m_state == TIME_WAIT) return;

  // If all data are received (non-closing socket and nothing to send), just return

  // If all data are received (non-closing socket and nothing to send), just return

  // According to RFC2581 sec.3.1, upon RTO, ssthresh is set to half of flight

  // According to RFC2581 sec.3.1, upon RTO, ssthresh is set to half of flight

  // size and cwnd is set to 1*MSS, then the lost packet is retransmitted and

  // size and cwnd is set to 1*MSS, then the lost packet is retransmitted and

  // TCP back to slow start

  // TCP back to slow start

  m_ssThresh = std::max (2 * m_segmentSize, BytesInFlight () / 2);

  m_ssThresh = std::max (2 * m_segmentSize, BytesInFlight () / 2);

  m_cWnd = m_segmentSize;

  m_cWnd = m_segmentSize;

  NS_LOG_INFO ("RTO. Reset cwnd to " << m_cWnd <<

  NS_LOG_INFO ("RTO. Reset cwnd to " << m_cWnd <<

               ", ssthresh to " << m_ssThresh << ", restart from seqnum " << m_nextTxSequence);

               ", ssthresh to " << m_ssThresh << ", restart from seqnum " << m_nextTxSequence);

  DoRetransmit ();                          // Retransmit the packet

  DoRetransmit ();                          // Retransmit the packet

  // If erroneous timeout in closed/timed-wait state, just return

  // If erroneous timeout in closed/timed-wait state, just return

  if (m_state == CLOSED || m_state == TIME_WAIT) return;

  if (m_state == CLOSED || m_state == TIME_WAIT) return;

  // If all data are received (non-closing socket and nothing to send), just return

  // If all data are received (non-closing socket and nothing to send), just return

  // According to RFC2581 sec.3.1, upon RTO, ssthresh is set to half of flight

  // According to RFC2581 sec.3.1, upon RTO, ssthresh is set to half of flight

  // size and cwnd is set to 1*MSS, then the lost packet is retransmitted and

  // size and cwnd is set to 1*MSS, then the lost packet is retransmitted and

  // TCP back to slow start

  // TCP back to slow start

  m_ssThresh = std::max (2 * m_segmentSize, BytesInFlight () / 2);

  m_ssThresh = std::max (2 * m_segmentSize, BytesInFlight () / 2);

  m_cWnd = m_segmentSize;

  m_cWnd = m_segmentSize;

  NS_LOG_INFO ("RTO. Reset cwnd to " << m_cWnd <<

  NS_LOG_INFO ("RTO. Reset cwnd to " << m_cWnd <<

               ", ssthresh to " << m_ssThresh << ", restart from seqnum " << m_nextTxSequence);

               ", ssthresh to " << m_ssThresh << ", restart from seqnum " << m_nextTxSequence);

  DoRetransmit ();                          // Retransmit the packet

  DoRetransmit ();                          // Retransmit the packet

#include "ns3/packet.h"

#include "ns3/packet.h"

#include "ns3/uinteger.h"

#include "ns3/uinteger.h"

#include "ns3/double.h"

#include "ns3/double.h"

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

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

#include "tcp-socket-base.h"

#include "tcp-socket-base.h"

#include "tcp-l4-protocol.h"

#include "tcp-l4-protocol.h"

                   MakeTimeAccessor (&TcpSocketBase::SetClockGranularity,

                   MakeTimeAccessor (&TcpSocketBase::SetClockGranularity,

                                     &TcpSocketBase::GetClockGranularity),

                                     &TcpSocketBase::GetClockGranularity),

                                     MakeTimeChecker ())

                                     MakeTimeChecker ())

    .AddTraceSource ("RTO",

    .AddTraceSource ("RTO",

                     "Retransmission timeout",

                     "Retransmission timeout",

                     MakeTraceSourceAccessor (&TcpSocketBase::m_rto),

                     MakeTraceSourceAccessor (&TcpSocketBase::m_rto),

{

{

  NS_LOG_FUNCTION (this);

  NS_LOG_FUNCTION (this);

}

}

TcpSocketBase::TcpSocketBase (const TcpSocketBase& sock)

TcpSocketBase::TcpSocketBase (const TcpSocketBase& sock)

    m_rtt (0),

    m_rtt (0),

    m_nextTxSequence (sock.m_nextTxSequence),

    m_nextTxSequence (sock.m_nextTxSequence),

    m_highTxMark (sock.m_highTxMark),

    m_highTxMark (sock.m_highTxMark),

    m_state (sock.m_state),

    m_state (sock.m_state),

    m_errno (sock.m_errno),

    m_errno (sock.m_errno),

    m_closeNotified (sock.m_closeNotified),

    m_closeNotified (sock.m_closeNotified),

  SetDataSentCallback (vPSUI);

  SetDataSentCallback (vPSUI);

  SetSendCallback (vPSUI);

  SetSendCallback (vPSUI);

  SetRecvCallback (vPS);

  SetRecvCallback (vPS);

}

}

TcpSocketBase::~TcpSocketBase (void)

TcpSocketBase::~TcpSocketBase (void)

  /// \internal

  /// \internal

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

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

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

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

    {

    {

      NS_LOG_INFO ("Socket " << this << " << unread rx data during close.  Sending reset");

      NS_LOG_INFO ("Socket " << this << " << unread rx data during close.  Sending reset");

      SendRST ();

      SendRST ();

      return 0;

      return 0;

    }

    }

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

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

      if (m_closeOnEmpty == false)

      if (m_closeOnEmpty == false)

        {

        {

  m_closeOnEmpty = true;

  m_closeOnEmpty = true;

  //if buffer is already empty, send a fin now

  //if buffer is already empty, send a fin now

  //otherwise fin will go when buffer empties.

  //otherwise fin will go when buffer empties.

    {

    {

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

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

        {

        {

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

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

    {

    {

      // Store the packet into Tx buffer

      // Store the packet into Tx buffer

        { // TxBuffer overflow, send failed

        { // TxBuffer overflow, send failed

          m_errno = ERROR_MSGSIZE;

          m_errno = ERROR_MSGSIZE;

          return -1;

          return -1;

          return -1;

          return -1;

        }

        }

      // Submit the data to lower layers

      // Submit the data to lower layers

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

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

        { // Try to send the data out

        { // Try to send the data out

          SendPendingData (m_connected);

          SendPendingData (m_connected);

{

{

  NS_LOG_FUNCTION (this);

  NS_LOG_FUNCTION (this);

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

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

    {

    {

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

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

    }

    }

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

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

    {

    {

      SocketAddressTag tag;

      SocketAddressTag tag;

TcpSocketBase::GetTxAvailable (void) const

TcpSocketBase::GetTxAvailable (void) const

{

{

  NS_LOG_FUNCTION (this);

  NS_LOG_FUNCTION (this);

}

}

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

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

TcpSocketBase::GetRxAvailable (void) const

TcpSocketBase::GetRxAvailable (void) const

{

{

  NS_LOG_FUNCTION (this);

  NS_LOG_FUNCTION (this);

}

}

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

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

    }

    }

  if (m_state == LAST_ACK || m_state == CLOSING || m_state == CLOSE_WAIT)

  if (m_state == LAST_ACK || m_state == CLOSING || m_state == CLOSE_WAIT)

    { // In LAST_ACK and CLOSING states, it only wait for an ACK and the

    { // In LAST_ACK and CLOSING states, it only wait for an ACK and the

    }

    }

  // In all other cases, check if the sequence number is in range

  // In all other cases, check if the sequence number is in range

}

}

/* Function called by the L3 protocol when it received a packet to pass on to

/* Function called by the L3 protocol when it received a packet to pass on to

      NS_LOG_LOGIC ("At state " << TcpStateName[m_state] <<

      NS_LOG_LOGIC ("At state " << TcpStateName[m_state] <<

                    " received packet of seq [" << tcpHeader.GetSequenceNumber () <<

                    " received packet of seq [" << tcpHeader.GetSequenceNumber () <<

                    ":" << tcpHeader.GetSequenceNumber () + packet->GetSize () <<

                    ":" << tcpHeader.GetSequenceNumber () + packet->GetSize () <<

      // Acknowledgement should be sent for all unacceptable packets (RFC793, p.69)

      // Acknowledgement should be sent for all unacceptable packets (RFC793, p.69)

      if (m_state == ESTABLISHED && !(tcpHeader.GetFlags () & TcpHeader::RST))

      if (m_state == ESTABLISHED && !(tcpHeader.GetFlags () & TcpHeader::RST))

        {

        {

          TcpHeader h;

          TcpHeader h;

          h.SetFlags (TcpHeader::RST);

          h.SetFlags (TcpHeader::RST);

          h.SetSequenceNumber (m_nextTxSequence);

          h.SetSequenceNumber (m_nextTxSequence);

          h.SetSourcePort (tcpHeader.GetDestinationPort ());

          h.SetSourcePort (tcpHeader.GetDestinationPort ());

          h.SetDestinationPort (tcpHeader.GetSourcePort ());

          h.SetDestinationPort (tcpHeader.GetSourcePort ());

          h.SetWindowSize (AdvertisedWindowSize ());

          h.SetWindowSize (AdvertisedWindowSize ());

      NS_LOG_LOGIC ("At state " << TcpStateName[m_state] <<

      NS_LOG_LOGIC ("At state " << TcpStateName[m_state] <<

                    " received packet of seq [" << tcpHeader.GetSequenceNumber () <<

                    " received packet of seq [" << tcpHeader.GetSequenceNumber () <<

                    ":" << tcpHeader.GetSequenceNumber () + packet->GetSize () <<

                    ":" << tcpHeader.GetSequenceNumber () + packet->GetSize () <<

      // Acknowledgement should be sent for all unacceptable packets (RFC793, p.69)

      // Acknowledgement should be sent for all unacceptable packets (RFC793, p.69)

      if (m_state == ESTABLISHED && !(tcpHeader.GetFlags () & TcpHeader::RST))

      if (m_state == ESTABLISHED && !(tcpHeader.GetFlags () & TcpHeader::RST))

        {

        {

          TcpHeader h;

          TcpHeader h;

          h.SetFlags (TcpHeader::RST);

          h.SetFlags (TcpHeader::RST);

          h.SetSequenceNumber (m_nextTxSequence);

          h.SetSequenceNumber (m_nextTxSequence);

          h.SetSourcePort (tcpHeader.GetDestinationPort ());

          h.SetSourcePort (tcpHeader.GetDestinationPort ());

          h.SetDestinationPort (tcpHeader.GetSourcePort ());

          h.SetDestinationPort (tcpHeader.GetSourcePort ());

          h.SetWindowSize (AdvertisedWindowSize ());

          h.SetWindowSize (AdvertisedWindowSize ());

  else if (tcpflags == 0)

  else if (tcpflags == 0)

    { // No flags means there is only data

    { // No flags means there is only data

      ReceivedData (packet, tcpHeader);

      ReceivedData (packet, tcpHeader);

        {

        {

          PeerClose (packet, tcpHeader);

          PeerClose (packet, tcpHeader);

        }

        }

  if (0 == (tcpHeader.GetFlags () & TcpHeader::ACK))

  if (0 == (tcpHeader.GetFlags () & TcpHeader::ACK))

    { // Ignore if no ACK flag

    { // Ignore if no ACK flag

    }

    }

    { // Case 1: Old ACK, ignored.

    { // Case 1: Old ACK, ignored.

      NS_LOG_LOGIC ("Ignored ack of " << tcpHeader.GetAckNumber ());

      NS_LOG_LOGIC ("Ignored ack of " << tcpHeader.GetAckNumber ());

    }

    }

    { // Case 2: Potentially a duplicated ACK

    { // Case 2: Potentially a duplicated ACK

      if (tcpHeader.GetAckNumber () < m_nextTxSequence && packet->GetSize() == 0)

      if (tcpHeader.GetAckNumber () < m_nextTxSequence && packet->GetSize() == 0)

        {

        {

      // otherwise, the ACK is precisely equal to the nextTxSequence

      // otherwise, the ACK is precisely equal to the nextTxSequence

      NS_ASSERT (tcpHeader.GetAckNumber () <= m_nextTxSequence);

      NS_ASSERT (tcpHeader.GetAckNumber () <= m_nextTxSequence);

    }

    }

    { // Case 3: New ACK, reset m_dupAckCount and update m_txBuffer

    { // Case 3: New ACK, reset m_dupAckCount and update m_txBuffer

      NS_LOG_LOGIC ("New ack of " << tcpHeader.GetAckNumber ());

      NS_LOG_LOGIC ("New ack of " << tcpHeader.GetAckNumber ());

      NewAck (tcpHeader.GetAckNumber ());

      NewAck (tcpHeader.GetAckNumber ());

      NS_LOG_INFO ("SYN_SENT -> SYN_RCVD");

      NS_LOG_INFO ("SYN_SENT -> SYN_RCVD");

      m_state = SYN_RCVD;

      m_state = SYN_RCVD;

      m_cnCount = m_cnRetries;

      m_cnCount = m_cnRetries;

      SendEmptyPacket (TcpHeader::SYN | TcpHeader::ACK);

      SendEmptyPacket (TcpHeader::SYN | TcpHeader::ACK);

    }

    }

  else if (tcpflags == (TcpHeader::SYN | TcpHeader::ACK)

  else if (tcpflags == (TcpHeader::SYN | TcpHeader::ACK)

      m_state = ESTABLISHED;

      m_state = ESTABLISHED;

      m_connected = true;

      m_connected = true;

      m_retxEvent.Cancel ();

      m_retxEvent.Cancel ();

      m_highTxMark = ++m_nextTxSequence;

      m_highTxMark = ++m_nextTxSequence;

      SendEmptyPacket (TcpHeader::ACK);

      SendEmptyPacket (TcpHeader::ACK);

      SendPendingData (m_connected);

      SendPendingData (m_connected);

      Simulator::ScheduleNow (&TcpSocketBase::ConnectionSucceeded, this);

      Simulator::ScheduleNow (&TcpSocketBase::ConnectionSucceeded, this);

      m_connected = true;

      m_connected = true;

      m_retxEvent.Cancel ();

      m_retxEvent.Cancel ();

      m_highTxMark = ++m_nextTxSequence;

      m_highTxMark = ++m_nextTxSequence;

      if (m_endPoint)

      if (m_endPoint)

        {

        {

          m_endPoint->SetPeer (InetSocketAddress::ConvertFrom (fromAddress).GetIpv4 (),

          m_endPoint->SetPeer (InetSocketAddress::ConvertFrom (fromAddress).GetIpv4 (),

    }

    }

  else if (tcpflags == TcpHeader::SYN)

  else if (tcpflags == TcpHeader::SYN)

    { // Probably the peer lost my SYN+ACK

    { // Probably the peer lost my SYN+ACK

      SendEmptyPacket (TcpHeader::SYN | TcpHeader::ACK);

      SendEmptyPacket (TcpHeader::SYN | TcpHeader::ACK);

    }

    }

  else if (tcpflags == (TcpHeader::FIN | TcpHeader::ACK))

  else if (tcpflags == (TcpHeader::FIN | TcpHeader::ACK))

    {

    {

        { // In-sequence FIN before connection complete. Set up connection and close.

        { // In-sequence FIN before connection complete. Set up connection and close.

          m_connected = true;

          m_connected = true;

          m_retxEvent.Cancel ();

          m_retxEvent.Cancel ();

          m_highTxMark = ++m_nextTxSequence;

          m_highTxMark = ++m_nextTxSequence;

          if (m_endPoint)

          if (m_endPoint)

            {

            {

              m_endPoint->SetPeer (InetSocketAddress::ConvertFrom (fromAddress).GetIpv4 (),

              m_endPoint->SetPeer (InetSocketAddress::ConvertFrom (fromAddress).GetIpv4 (),

  else if (tcpflags == TcpHeader::ACK)

  else if (tcpflags == TcpHeader::ACK)

    { // Process the ACK, and if in FIN_WAIT_1, conditionally move to FIN_WAIT_2

    { // Process the ACK, and if in FIN_WAIT_1, conditionally move to FIN_WAIT_2

      ReceivedAck (packet, tcpHeader);

      ReceivedAck (packet, tcpHeader);

          && tcpHeader.GetAckNumber () == m_highTxMark + SequenceNumber32 (1))

          && tcpHeader.GetAckNumber () == m_highTxMark + SequenceNumber32 (1))

        { // This ACK corresponds to the FIN sent

        { // This ACK corresponds to the FIN sent

          NS_LOG_INFO ("FIN_WAIT_1 -> FIN_WAIT_2");

          NS_LOG_INFO ("FIN_WAIT_1 -> FIN_WAIT_2");

        { // Process the ACK first

        { // Process the ACK first

          ReceivedAck (packet, tcpHeader);

          ReceivedAck (packet, tcpHeader);

        }

        }

    }

    }

  else if (tcpflags == TcpHeader::SYN || tcpflags == (TcpHeader::SYN | TcpHeader::ACK))

  else if (tcpflags == TcpHeader::SYN || tcpflags == (TcpHeader::SYN | TcpHeader::ACK))

    { // Duplicated SYN or SYN+ACK, possibly due to spurious retransmission

    { // Duplicated SYN or SYN+ACK, possibly due to spurious retransmission

    }

    }

  // Check if the close responder sent an in-sequence FIN, if so, respond ACK

  // Check if the close responder sent an in-sequence FIN, if so, respond ACK

    {

    {

      if (m_state == FIN_WAIT_1)

      if (m_state == FIN_WAIT_1)

        {

        {

          NS_LOG_INFO ("FIN_WAIT_1 -> CLOSING");

          NS_LOG_INFO ("FIN_WAIT_1 -> CLOSING");

          m_state = CLOSING;

          m_state = CLOSING;

              && tcpHeader.GetAckNumber () == m_highTxMark + SequenceNumber32 (1))

              && tcpHeader.GetAckNumber () == m_highTxMark + SequenceNumber32 (1))

            { // This ACK corresponds to the FIN sent

            { // This ACK corresponds to the FIN sent

              TimeWait ();

              TimeWait ();

  if (tcpflags == TcpHeader::ACK)

  if (tcpflags == TcpHeader::ACK)

    {

    {

        { // This ACK corresponds to the FIN sent

        { // This ACK corresponds to the FIN sent

          TimeWait ();

          TimeWait ();

        }

        }

    }

    }

  else if (tcpflags == TcpHeader::ACK)

  else if (tcpflags == TcpHeader::ACK)

    {

    {

        { // This ACK corresponds to the FIN sent. This socket closed peacefully.

        { // This ACK corresponds to the FIN sent. This socket closed peacefully.

          CloseAndNotify ();

          CloseAndNotify ();

        }

        }

  NS_LOG_FUNCTION (this << tcpHeader);

  NS_LOG_FUNCTION (this << tcpHeader);

  // Ignore all out of range packets

  // Ignore all out of range packets

    {

    {

      return;

      return;

    }

    }

  // For any case, remember the FIN position in rx buffer first

  // For any case, remember the FIN position in rx buffer first

  NS_LOG_LOGIC ("Accepted FIN at seq " << tcpHeader.GetSequenceNumber () + SequenceNumber32 (p->GetSize ()));

  NS_LOG_LOGIC ("Accepted FIN at seq " << tcpHeader.GetSequenceNumber () + SequenceNumber32 (p->GetSize ()));

  // If there is any piggybacked data, process it

  // If there is any piggybacked data, process it

  if (p->GetSize ())

  if (p->GetSize ())

      ReceivedData (p, tcpHeader);

      ReceivedData (p, tcpHeader);

    }

    }

  // Return if FIN is out of sequence, otherwise move to CLOSE_WAIT state by DoPeerClose

  // Return if FIN is out of sequence, otherwise move to CLOSE_WAIT state by DoPeerClose

    {

    {

      return;

      return;

    }

    }

  header.SetFlags (flags);

  header.SetFlags (flags);

  header.SetSequenceNumber (s);

  header.SetSequenceNumber (s);

  if (m_endPoint != 0)

  if (m_endPoint != 0)

    {

    {

      header.SetSourcePort (m_endPoint->GetLocalPort ());

      header.SetSourcePort (m_endPoint->GetLocalPort ());

  m_cnCount = m_cnRetries;

  m_cnCount = m_cnRetries;

  SetupCallback ();

  SetupCallback ();

  // Set the sequence number and send SYN+ACK

  // Set the sequence number and send SYN+ACK

  SendEmptyPacket (TcpHeader::SYN | TcpHeader::ACK);

  SendEmptyPacket (TcpHeader::SYN | TcpHeader::ACK);

}

}

  NS_LOG_FUNCTION (this << seq << maxSize << withAck);

  NS_LOG_FUNCTION (this << seq << maxSize << withAck);

  bool isRetransmission = false;

  bool isRetransmission = false;

    {

    {

      isRetransmission = true;

      isRetransmission = true;

    }

    }

  uint32_t sz = p->GetSize (); // Size of packet

  uint32_t sz = p->GetSize (); // Size of packet

  uint8_t flags = withAck ? TcpHeader::ACK : 0;

  uint8_t flags = withAck ? TcpHeader::ACK : 0;

  /*

  /*

   * Add tags for each socket option.

   * Add tags for each socket option.

  TcpHeader header;

  TcpHeader header;

  header.SetFlags (flags);

  header.SetFlags (flags);

  header.SetSequenceNumber (seq);

  header.SetSequenceNumber (seq);

  if (m_endPoint)

  if (m_endPoint)

    {

    {

      header.SetSourcePort (m_endPoint->GetLocalPort ());

      header.SetSourcePort (m_endPoint->GetLocalPort ());

TcpSocketBase::SendPendingData (bool withAck)

TcpSocketBase::SendPendingData (bool withAck)

{

{

  NS_LOG_FUNCTION (this << withAck);

  NS_LOG_FUNCTION (this << withAck);

    {

    {

      return false;                           // Nothing to send

      return false;                           // Nothing to send

      return false; // Is this the right way to handle this condition?

      return false; // Is this the right way to handle this condition?

    }

    }

  uint32_t nPacketsSent = 0;

  uint32_t nPacketsSent = 0;

    {

    {

      uint32_t w = AvailableWindow (); // Get available window size

      uint32_t w = AvailableWindow (); // Get available window size

      NS_LOG_LOGIC ("TcpSocketBase " << this << " SendPendingData" <<

      NS_LOG_LOGIC ("TcpSocketBase " << this << " SendPendingData" <<

                    " rxwin " << m_rWnd <<

                    " rxwin " << m_rWnd <<

                    " segsize " << m_segmentSize <<

                    " segsize " << m_segmentSize <<

                    " nextTxSeq " << m_nextTxSequence <<

                    " nextTxSeq " << m_nextTxSequence <<

      // Stop sending if we need to wait for a larger Tx window (prevent silly window syndrome)

      // Stop sending if we need to wait for a larger Tx window (prevent silly window syndrome)

        {

        {

          break; // No more

          break; // No more

        }

        }

      // Nagle's algorithm (RFC896): Hold off sending if there is unacked data

      // Nagle's algorithm (RFC896): Hold off sending if there is unacked data

      // in the buffer and the amount of data to send is less than one segment

      // in the buffer and the amount of data to send is less than one segment

      if (!m_noDelay && UnAckDataCount () > 0

      if (!m_noDelay && UnAckDataCount () > 0

        {

        {

          NS_LOG_LOGIC ("Invoking Nagle's algorithm. Wait to send.");

          NS_LOG_LOGIC ("Invoking Nagle's algorithm. Wait to send.");

          break;

          break;

TcpSocketBase::UnAckDataCount ()

TcpSocketBase::UnAckDataCount ()

{

{

  NS_LOG_FUNCTION (this);

  NS_LOG_FUNCTION (this);

}

}

uint32_t

uint32_t

TcpSocketBase::BytesInFlight ()

TcpSocketBase::BytesInFlight ()

{

{

  NS_LOG_FUNCTION (this);

  NS_LOG_FUNCTION (this);

}

}

uint32_t

uint32_t

uint16_t

uint16_t

TcpSocketBase::AdvertisedWindowSize ()

TcpSocketBase::AdvertisedWindowSize ()

{

{

  w >>= m_sndScaleFactor;

  w >>= m_sndScaleFactor;

                " pkt size " << p->GetSize () );

                " pkt size " << p->GetSize () );

  // Put into Rx buffer

  // Put into Rx buffer

    { // Insert failed: No data or RX buffer full

    { // Insert failed: No data or RX buffer full

      SendEmptyPacket (TcpHeader::ACK);

      SendEmptyPacket (TcpHeader::ACK);

      return;

      return;

    }

    }

  // Now send a new ACK packet acknowledging all received and delivered data

  // Now send a new ACK packet acknowledging all received and delivered data

    { // A gap exists in the buffer, or we filled a gap: Always ACK

    { // A gap exists in the buffer, or we filled a gap: Always ACK

      SendEmptyPacket (TcpHeader::ACK);

      SendEmptyPacket (TcpHeader::ACK);

    }

    }

        }

        }

    }

    }

  // Notify app to receive if necessary

  // Notify app to receive if necessary

    { // NextRxSeq advanced, we have something to send to the app

    { // NextRxSeq advanced, we have something to send to the app

      if (!m_shutdownRecv)

      if (!m_shutdownRecv)

        {

        {

        }

        }

      // If we received FIN before and now completed all "holes" in rx buffer,

      // If we received FIN before and now completed all "holes" in rx buffer,

      // invoke peer close procedure

      // invoke peer close procedure

        {

        {

          DoPeerClose ();

          DoPeerClose ();

        }

        }

    }

    }

  // Note the highest ACK and tell app to send more

  // Note the highest ACK and tell app to send more

  NS_LOG_LOGIC ("TCP " << this << " NewAck " << ack <<

  NS_LOG_LOGIC ("TCP " << this << " NewAck " << ack <<

  if (GetTxAvailable () > 0)

  if (GetTxAvailable () > 0)

    {

    {

      NotifySend (GetTxAvailable ());

      NotifySend (GetTxAvailable ());

    {

    {

      m_nextTxSequence = ack; // If advanced

      m_nextTxSequence = ack; // If advanced

    }

    }

    { // No retransmit timer if no data to retransmit

    { // No retransmit timer if no data to retransmit

      NS_LOG_LOGIC (this << " Cancelled ReTxTimeout event which was set to expire at " <<

      NS_LOG_LOGIC (this << " Cancelled ReTxTimeout event which was set to expire at " <<

                    (Simulator::Now () + Simulator::GetDelayLeft (m_retxEvent)).GetSeconds ());

                    (Simulator::Now () + Simulator::GetDelayLeft (m_retxEvent)).GetSeconds ());

      return;

      return;

    }

    }

  // If all data are received (non-closing socket and nothing to send), just return

  // If all data are received (non-closing socket and nothing to send), just return

    {

    {

      return;

      return;

    }

    }

{

{

  NS_LOG_LOGIC ("PersistTimeout expired at " << Simulator::Now ().GetSeconds ());

  NS_LOG_LOGIC ("PersistTimeout expired at " << Simulator::Now ().GetSeconds ());

  m_persistTimeout = std::min (Seconds (60), Time (2 * m_persistTimeout)); // max persist timeout = 60s

  m_persistTimeout = std::min (Seconds (60), Time (2 * m_persistTimeout)); // max persist timeout = 60s

  TcpHeader tcpHeader;

  TcpHeader tcpHeader;

  tcpHeader.SetSequenceNumber (m_nextTxSequence);

  tcpHeader.SetSequenceNumber (m_nextTxSequence);

  tcpHeader.SetWindowSize (AdvertisedWindowSize ());

  tcpHeader.SetWindowSize (AdvertisedWindowSize ());

  if (m_endPoint != 0)

  if (m_endPoint != 0)

    {

    {

void

void

TcpSocketBase::Retransmit ()

TcpSocketBase::Retransmit ()

{

{

  m_dupAckCount = 0;

  m_dupAckCount = 0;

  DoRetransmit (); // Retransmit the packet

  DoRetransmit (); // Retransmit the packet

}

}

      return;

      return;

    }

    }

  // Retransmit non-data packet: Only if in FIN_WAIT_1 or CLOSING state

  // Retransmit non-data packet: Only if in FIN_WAIT_1 or CLOSING state

    {

    {

      if (m_state == FIN_WAIT_1 || m_state == CLOSING)

      if (m_state == FIN_WAIT_1 || m_state == CLOSING)

        { // Must have lost FIN, re-send

        { // Must have lost FIN, re-send

      return;

      return;

    }

    }

  // Retransmit a data packet: Call SendDataPacket

  // Retransmit a data packet: Call SendDataPacket

  // In case of RTO, advance m_nextTxSequence

  // In case of RTO, advance m_nextTxSequence

}

}

void

void

TcpSocketBase::SetSndBufSize (uint32_t size)

TcpSocketBase::SetSndBufSize (uint32_t size)

{

{

}

}

uint32_t

uint32_t

TcpSocketBase::GetSndBufSize (void) const

TcpSocketBase::GetSndBufSize (void) const

{

{

}

}

void

void

TcpSocketBase::SetRcvBufSize (uint32_t size)

TcpSocketBase::SetRcvBufSize (uint32_t size)

{

{

}

}

uint32_t

uint32_t

TcpSocketBase::GetRcvBufSize (void) const

TcpSocketBase::GetRcvBufSize (void) const

{

{

}

}

void

void

TcpSocketBase::CalculateWScale () const

TcpSocketBase::CalculateWScale () const

{

{

  NS_LOG_FUNCTION (this);

  NS_LOG_FUNCTION (this);

  uint8_t scale = 0;

  uint8_t scale = 0;

  while (maxSpace > m_maxWinSize)

  while (maxSpace > m_maxWinSize)

    }

    }

  NS_LOG_INFO ("Node " << m_node->GetId () << " calculated wscale factor of " <<

  NS_LOG_INFO ("Node " << m_node->GetId () << " calculated wscale factor of " <<

  return scale;

  return scale;

}

}

  return m_clockGranularity;

  return m_clockGranularity;

}

}

//RttHistory methods

//RttHistory methods

RttHistory::RttHistory (SequenceNumber32 s, uint32_t c, Time t)

RttHistory::RttHistory (SequenceNumber32 s, uint32_t c, Time t)

  : seq (s), count (c), time (t), retx (false)

  : seq (s), count (c), time (t), retx (false)

   */

   */

  Time GetClockGranularity (void) const;

  Time GetClockGranularity (void) const;

  // Necessary implementations of null functions from ns3::Socket

  // Necessary implementations of null functions from ns3::Socket

  virtual enum SocketErrno GetErrno (void) const;    // returns m_errno

  virtual enum SocketErrno GetErrno (void) const;    // returns m_errno

  // Rx and Tx buffer management

  // Rx and Tx buffer management

  TracedValue<SequenceNumber32> m_nextTxSequence; //!< Next seqnum to be sent (SND.NXT), ReTx pushes it back

  TracedValue<SequenceNumber32> m_nextTxSequence; //!< Next seqnum to be sent (SND.NXT), ReTx pushes it back

  TracedValue<SequenceNumber32> m_highTxMark;     //!< Highest seqno ever sent, regardless of ReTx

  TracedValue<SequenceNumber32> m_highTxMark;     //!< Highest seqno ever sent, regardless of ReTx

  // State-related attributes

  // State-related attributes

  TracedValue<TcpStates_t> m_state;         //!< TCP state

  TracedValue<TcpStates_t> m_state;         //!< TCP state

      // (Fall & Floyd 1996, sec.1)

      // (Fall & Floyd 1996, sec.1)

      m_ssThresh = std::max (static_cast<unsigned> (m_cWnd / 2), m_segmentSize * 2);  // Half ssthresh

      m_ssThresh = std::max (static_cast<unsigned> (m_cWnd / 2), m_segmentSize * 2);  // Half ssthresh

      m_cWnd = m_segmentSize; // Run slow start again

      m_cWnd = m_segmentSize; // Run slow start again

      NS_LOG_INFO ("Triple Dup Ack: new ssthresh " << m_ssThresh << " cwnd " << m_cWnd);

      NS_LOG_INFO ("Triple Dup Ack: new ssthresh " << m_ssThresh << " cwnd " << m_cWnd);

      NS_LOG_LOGIC ("Triple Dup Ack: retransmit missing segment at " << Simulator::Now ().GetSeconds ());

      NS_LOG_LOGIC ("Triple Dup Ack: retransmit missing segment at " << Simulator::Now ().GetSeconds ());

      DoRetransmit ();

      DoRetransmit ();

  // If erroneous timeout in closed/timed-wait state, just return

  // If erroneous timeout in closed/timed-wait state, just return

  if (m_state == CLOSED || m_state == TIME_WAIT) return;

  if (m_state == CLOSED || m_state == TIME_WAIT) return;

  // If all data are received (non-closing socket and nothing to send), just return

  // If all data are received (non-closing socket and nothing to send), just return

  m_ssThresh = std::max (static_cast<unsigned> (m_cWnd / 2), m_segmentSize * 2);  // Half ssthresh

  m_ssThresh = std::max (static_cast<unsigned> (m_cWnd / 2), m_segmentSize * 2);  // Half ssthresh

  m_cWnd = m_segmentSize;                   // Set cwnd to 1 segSize (RFC2001, sec.2)

  m_cWnd = m_segmentSize;                   // Set cwnd to 1 segSize (RFC2001, sec.2)

  DoRetransmit ();                          // Retransmit the packet

  DoRetransmit ();                          // Retransmit the packet

}

}

  if (m_state == CLOSED || m_state == TIME_WAIT)

  if (m_state == CLOSED || m_state == TIME_WAIT)

    return;

    return;

  // If all data are received, just return

  // If all data are received, just return

    return;

    return;

  // Upon an RTO, adjust cwnd and ssthresh based on the estimated BW

  // Upon an RTO, adjust cwnd and ssthresh based on the estimated BW

  m_cWnd = m_segmentSize;

  m_cWnd = m_segmentSize;

  // Restart from highest ACK

  // Restart from highest ACK

  NS_LOG_INFO ("RTO. Reset cwnd to " << m_cWnd <<

  NS_LOG_INFO ("RTO. Reset cwnd to " << m_cWnd <<

      ", ssthresh to " << m_ssThresh << ", restart from seqnum " << m_nextTxSequence);

      ", ssthresh to " << m_ssThresh << ", restart from seqnum " << m_nextTxSequence);

      break;

      break;

    }

    }

  uint16_t port = 50000;

  uint16_t port = 50000;

  InetSocketAddress serverlocaladdr (Ipv4Address::GetAny (), port);

  InetSocketAddress serverlocaladdr (Ipv4Address::GetAny (), port);