Attachment #2234 for bug #2068

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




                   MakeCallbackChecker ())
    .AddAttribute ("WindowScaling", "Enable or disable Window Scaling option",
                   BooleanValue (true),
                   MakeBooleanAccessor (&TcpSocketBase::EnableWSOption,
                                        &TcpSocketBase::GetWSOptionEnabled),
                   MakeBooleanChecker ())
    .AddAttribute ("Timestamp", "Enable or disable Timestamp option",
                   BooleanValue (true),

  m_highRxMark (0),
  m_highRxAckMark (0),
  m_bytesAckedNotProcessed (0),
  m_winScalingEnabled (0),
  m_rcvWindShift (0),
  m_sndWindShift (0),
  m_timestampEnabled (true),


  m_rxTrace (packet, tcpHeader, this);

  ReadOptions (tcpHeader);

  if (tcpHeader.GetFlags () & TcpHeader::SYN)
    {
      /* The window field in a segment where the SYN bit is set (i.e., a <SYN>

       */
      m_rWnd = tcpHeader.GetWindowSize ();

      /* RFC 7323, Section 2.2
       *
       * "If a Window Scale option was received in the initial <SYN> segment,
       * then this option MAY be sent in the <SYN,ACK> segment."
       *
       * RFC 7323, Section 2.3
       *
       * "If a TCP receives a <SYN> segment containing a Window Scale
       * option, it SHOULD send its own Window Scale option in the
       * <SYN,ACK> segment."
       *
       * RFC is incostistent in case a <SYN> contains WS option, but the
       * user disabled it through Attributes.
       * As choice, we use the latter approach, enabling WS but advertising
       * 1 as shift, regardless of the buffer size (and doing so we pratically
       * disable the window scale, keeping the send of the option)
       */
      if (tcpHeader.HasOption (TcpOption::WINSCALE))
        {
          ProcessOptionWScale (tcpHeader.GetOption (TcpOption::WINSCALE));

          if (tcpHeader.GetFlags () == TcpHeader::SYN && m_winScalingEnabled == 0)
            {
              // This is a plain <SYN> with WS enabled, but users choice is
              // to disable our WS side. <SYN-ACK> will have WS option with shift = 1
              m_winScalingEnabled = 2;
            }

          if (m_tcb->m_initialSsThresh == UINT32_MAX)
            {
              m_tcb->m_initialSsThresh = m_rWnd << m_sndWindShift;
            }
        }
      else
        {
          // Disable window scaling at all; our peer does not support it.
          m_winScalingEnabled = 0;
        }

      // When receiving a <SYN> or <SYN-ACK> we should adapt TS to the other end
      if (tcpHeader.HasOption (TcpOption::TS) && m_timestampEnabled)
        {
          ProcessOptionTimestamp (tcpHeader.GetOption (TcpOption::TS));
        }
      else
        {
          m_timestampEnabled = false;
        }

      // Initialize cWnd and ssThresh
      m_tcb->m_cWnd = GetInitialCwnd () * GetSegSize ();
      m_tcb->m_ssThresh = GetInitialSSThresh ();
    }
  else if (tcpHeader.GetFlags () & TcpHeader::ACK)
    {
      if (m_timestampEnabled)
        {
          if (tcpHeader.HasOption (TcpOption::TS))
            {
              ProcessOptionTimestamp (tcpHeader.GetOption (TcpOption::TS));
            }
          else
            {
              NS_LOG_LOGIC ("At state " << TcpStateName[m_state] <<
                            " received packet of seq [" << seq <<
                            ":" << seq + packet->GetSize () <<
                            ") without TS option. Silently discard it");
              return;
            }
        }

      EstimateRtt (tcpHeader);
      UpdateWindowSize (tcpHeader);
    }


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

}

void
TcpSocketBase::ReadOptions (const TcpHeader& header)
{
  NS_LOG_FUNCTION (this << header);

  if ((header.GetFlags () & TcpHeader::SYN))
    {
      if (m_winScalingEnabled)
        {
          m_winScalingEnabled = false;

          if (header.HasOption (TcpOption::WINSCALE))
            {
              m_winScalingEnabled = true;
              ProcessOptionWScale (header.GetOption (TcpOption::WINSCALE));
            }
        }
    }

  bool timestampAttribute = m_timestampEnabled;
  m_timestampEnabled = false;

  if (header.HasOption (TcpOption::TS) && timestampAttribute)
    {
      m_timestampEnabled = true;
      ProcessOptionTimestamp (header.GetOption (TcpOption::TS));
    }
}

void
TcpSocketBase::AddOptions (TcpHeader& header)
{
  NS_LOG_FUNCTION (this << header);

  // The window scaling option is set only on SYN packets
  if ((header.GetFlags () & TcpHeader::SYN) && m_winScalingEnabled > 0)
    {
      AddOptionWScale (header);
    }

}

void
TcpSocketBase::EnableWSOption (bool enable)
{
  if (enable)
    {
      m_winScalingEnabled = 1;
    }
  else
    {
      m_winScalingEnabled = 0;
    }
}

bool
TcpSocketBase::GetWSOptionEnabled (void) const
{
  return m_winScalingEnabled == 1;
}

void
TcpSocketBase::AddOptionWScale (TcpHeader &header)
{
  NS_LOG_FUNCTION (this << header);


  Ptr<TcpOptionWinScale> option = CreateObject<TcpOptionWinScale> ();

  if (m_winScalingEnabled == 2)
    {
      m_rcvWindShift = 1;
    }
  else
    {
      m_rcvWindShift = CalculateWScale ();
    }

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

  header.AppendOption (option);




   */
  virtual void DoRetransmit (void);

  /**
   * \brief Read TCP options from incoming packets
   *
   * This method sequentially checks each kind of option, and if it
   * is present in the header, starts its processing.
   *
   * To deal with hosts which don't have the option enabled (or
   * implemented) we disable all options, and then re-enable them
   * if in the packet there is the option itself.
   *
   * \param tcpHeader the packet's TCP header
   */
  virtual void ReadOptions (const TcpHeader& tcpHeader);

  /** \brief Add options to TcpHeader
   *
   * Test each option, and if it is enabled on our side, add it

   */
  uint8_t CalculateWScale () const;

  /**
   * \brief Enable the window scale option
   *
   * \param enable true to enable ws option
   */
  void EnableWSOption (bool enable);

  /**
   * \brief Return true if the window scale option is enabled
   *
   * \return true if the window scale option is enabled
   */
  bool GetWSOptionEnabled (void) const;

  /** \brief Process the timestamp option from other side
   *
   * Get the timestamp and the echo, then save timestamp (which will

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

  // Options
  uint8_t m_winScalingEnabled; /**!< Window Scale option enabled (RFC 7323).
                                 *   0 = disabled
                                 *   1 = enabled
                                 *   2 = partially enabled (enabled but forcing shift = 1)
                                 *
                                 * \see DoForwardUp
                                 */

  uint8_t m_rcvWindShift;      //!< Window shift to apply to outgoing segments
  uint8_t m_sndWindShift;      //!< Window shift to apply to incoming segments


(-)a/src/internet/test/tcp-wscaling-test.cc (-2 / +2 lines)

Lines 162-169 WScalingTestCase::Tx (const Ptr<const Packet> p, const TcpHeader &h, SocketWho w	Link Here

162

163

          else if (m_configuration == ENABLED_SENDER)

163

          else if (m_configuration == ENABLED_SENDER)

164

165

              NS_TEST_ASSERT_MSG_EQ (h.HasOption (TcpOption::WINSCALE), false,

165

              NS_TEST_ASSERT_MSG_EQ (h.HasOption (TcpOption::WINSCALE), true,

166

                                     "receiver has not ws enabled but sent anyway");

166

                                     "receiver should have ws enabled with shift = 1");

167

168

169

Return to bug 2068