Attachment #2233 for bug #2262

View | Details | Raw Unified | Return to bug 2262
Collapse All | Expand All




  m_highRxAckMark (0),
  m_bytesAckedNotProcessed (0),
  m_winScalingEnabled (false),
  m_rcvWindShift (0),
  m_sndWindShift (0),
  m_timestampEnabled (true),
  m_timestampToEcho (0),
  m_sendPendingDataEvent (),

  m_highRxAckMark (sock.m_highRxAckMark),
  m_bytesAckedNotProcessed (sock.m_bytesAckedNotProcessed),
  m_winScalingEnabled (sock.m_winScalingEnabled),
  m_rcvWindShift (sock.m_rcvWindShift),
  m_sndWindShift (sock.m_sndWindShift),
  m_timestampEnabled (sock.m_timestampEnabled),
  m_timestampToEcho (sock.m_timestampToEcho),
  m_recover (sock.m_recover),

}

void
TcpSocketBase::InitializeCwnd (void)
{
  m_tcb->m_cWnd = GetInitialCwnd () * GetSegSize ();
  m_tcb->m_ssThresh = GetInitialSSThresh ();
}

void
TcpSocketBase::SetInitialSSThresh (uint32_t threshold)
{
  NS_ABORT_MSG_UNLESS ( (m_state == CLOSED) || threshold == m_tcb->m_initialSsThresh,

  return m_tcb->m_initialCWnd;
}

void
TcpSocketBase::ScaleSsThresh (uint8_t scaleFactor)
{
  m_tcb->m_ssThresh <<= scaleFactor;
}

/* Inherit from Socket class: Initiate connection to a remote address:port */
int
TcpSocketBase::Connect (const Address & address)
{
  NS_LOG_FUNCTION (this << address);

  InitializeCwnd ();

  // If haven't do so, Bind() this socket first
  if (InetSocketAddress::IsMatchingType (address) && m_endPoint6 == 0)
    {

{
  NS_LOG_FUNCTION (this);

  InitializeCwnd ();

  // Linux quits EINVAL if we're not in CLOSED state, so match what they do
  if (m_state != CLOSED)
    {


  ReadOptions (tcpHeader);

  if (tcpHeader.GetFlags () & TcpHeader::SYN)
    {
      EstimateRtt (tcpHeader);
    }

  // Update Rx window size, i.e. the flow control window
  if (tcpHeader.GetFlags () & TcpHeader::ACK)
    {
      UpdateWindowSize (tcpHeader);
    }
  else if (tcpHeader.GetFlags () & TcpHeader::SYN)
    {
      /* The window field in a segment where the SYN bit is set (i.e., a <SYN>
       * or <SYN,ACK>) MUST NOT be scaled (from RFC 7323 page 9). But should be
       * saved anyway..
       */
      m_rWnd = tcpHeader.GetWindowSize ();

      if (m_tcb->m_initialSsThresh == UINT32_MAX)
        {
          m_tcb->m_initialSsThresh = m_rWnd << m_sndWindShift;
        }

      m_tcb->m_cWnd = GetInitialCwnd () * GetSegSize ();
      m_tcb->m_ssThresh = GetInitialSSThresh ();
    }
  else if (tcpHeader.GetFlags () & TcpHeader::ACK)
    {
      EstimateRtt (tcpHeader);
      UpdateWindowSize (tcpHeader);
    }


  if (m_rWnd.Get () == 0 && m_persistEvent.IsExpired ())
    { // Zero window: Enter persist state to send 1 byte to probe

{
  uint32_t w = m_rxBuffer->MaxBufferSize ();

  w >>= m_rcvWindShift;

  if (w > m_maxWinSize)
    {

            {
              m_winScalingEnabled = true;
              ProcessOptionWScale (header.GetOption (TcpOption::WINSCALE));
              ScaleSsThresh (m_sndScaleFactor);
            }
        }
    }


  // In naming, we do the contrary of RFC 1323. The received scaling factor
  // is Rcv.Wind.Scale (and not Snd.Wind.Scale)
  m_sndWindShift = ws->GetScale ();

  if (m_sndWindShift > 14)
    {
      NS_LOG_WARN ("Possible error; m_sndWindShift exceeds 14: " << m_sndWindShift);
      m_sndWindShift = 14;
    }

  NS_LOG_INFO (m_node->GetId () << " Received a scale factor of " <<
               static_cast<int> (m_sndWindShift));
}

uint8_t

  // In naming, we do the contrary of RFC 1323. The sended scaling factor
  // is Snd.Wind.Scale (and not Rcv.Wind.Scale)

  m_rcvWindShift = CalculateWScale ();
  option->SetScale (m_rcvWindShift);

  header.AppendOption (option);

  NS_LOG_INFO (m_node->GetId () << " Send a scaling factor of " <<
               static_cast<int> (m_rcvWindShift));
}

void

  //  If the connection is not established, the window size is always
  //  updated
  uint32_t receivedWindow = header.GetWindowSize ();
  receivedWindow <<= m_sndWindShift;
  NS_LOG_INFO ("Received (scaled) window is " << receivedWindow << " bytes");
  if (m_state < ESTABLISHED)
    {




   */
  void AddOptionTimestamp (TcpHeader& header);

  /**
   * \brief Scale the initial SsThresh value to the correct one
   *
   * Set the initial SsThresh to the largest possible advertised window
   * according to the sender scale factor.
   *
   * \param scaleFactor the sender scale factor
   */
  virtual void ScaleSsThresh (uint8_t scaleFactor);

  /**
   * \brief Initialize congestion window
   *
   * Default cWnd to 1 MSS (RFC2001, sec.1) and must
   * not be larger than 2 MSS (RFC2581, sec.3.1). Both m_initiaCWnd and
   * m_segmentSize are set by the attribute system in ns3::TcpSocket.
   */
  virtual void InitializeCwnd ();

protected:
  // Counters and events
  EventId           m_retxEvent;       //!< Retransmission event

  uint32_t                      m_bytesAckedNotProcessed;  //!< Bytes acked, but not processed

  // Options
  bool    m_winScalingEnabled; //!< Window Scale option enabled (RFC 7323)
  uint8_t m_rcvWindShift;      //!< Window shift to apply to outgoing segments
  uint8_t m_sndWindShift;      //!< Window shift to apply to incoming segments

  bool     m_timestampEnabled;    //!< Timestamp option enabled
  uint32_t m_timestampToEcho;     //!< Timestamp to echo

(-)a/src/internet/model/tcp-socket.cc (-1 / +1 lines)

Lines 65-71 TcpSocket::GetTypeId (void)	Link Here

                   MakeUintegerChecker<uint32_t> ())

                   MakeUintegerChecker<uint32_t> ())

    .AddAttribute ("InitialSlowStartThreshold",

    .AddAttribute ("InitialSlowStartThreshold",

                   "TCP initial slow start threshold (bytes)",

                   "TCP initial slow start threshold (bytes)",

                   UintegerValue (0xffff),

                   UintegerValue (UINT32_MAX),

                   MakeUintegerAccessor (&TcpSocket::GetInitialSSThresh,

                   MakeUintegerAccessor (&TcpSocket::GetInitialSSThresh,

                                         &TcpSocket::SetInitialSSThresh),

                                         &TcpSocket::SetInitialSSThresh),

                   MakeUintegerChecker<uint32_t> ())

                   MakeUintegerChecker<uint32_t> ())

Return to bug 2262