NS_LOG_FUNCTION (this);

  NS_LOG_FUNCTION (this);

  // Increment nextRxSeq is valid only if we don't have any data buffered,

  // Increment nextRxSeq is valid only if we don't have any data buffered,

  // this is supposed to be called only during the three-way handshake

  // this is supposed to be called only during the three-way handshake

  m_nextRxSeq++;

  m_nextRxSeq++;

}

}

}

}

bool

bool

{

{

  uint32_t pktSize = p->GetSize ();

  uint32_t pktSize = p->GetSize ();

  SequenceNumber32 tailSeq = headSeq + SequenceNumber32 (pktSize);

  SequenceNumber32 tailSeq = headSeq + SequenceNumber32 (pktSize);

  NS_LOG_LOGIC ("Add pkt " << p << " len=" << pktSize << " seq=" << headSeq

  NS_LOG_LOGIC ("Add pkt " << p << " len=" << pktSize << " seq=" << headSeq

                           << ", when NextRxSeq=" << m_nextRxSeq << ", buffsize=" << m_size);

                           << ", when NextRxSeq=" << m_nextRxSeq << ", buffsize=" << m_size);

    }

    }

  else

  else

    {

    {

      uint32_t length = tailSeq - headSeq;

      uint32_t length = tailSeq - headSeq;

      p = p->CreateFragment (start, length);

      p = p->CreateFragment (start, length);

      NS_ASSERT (length == p->GetSize ());

      NS_ASSERT (length == p->GetSize ());

  // Accessors

  // Accessors

  /**

  /**

   * \returns Next Rx Sequence number

   * \returns Next Rx Sequence number

   */

   */

  SequenceNumber32 NextRxSequence (void) const;

  SequenceNumber32 NextRxSequence (void) const;

   */

   */

  void SetFinSequence (const SequenceNumber32& s);

  void SetFinSequence (const SequenceNumber32& s);

  /**

  /**

   * \returns the Maximum buffer size

   * \returns the Maximum buffer size

   */

   */

  uint32_t MaxBufferSize (void) const;

  uint32_t MaxBufferSize (void) const;

  /**

  /**

   * \param s the Maximum buffer size

   * \param s the Maximum buffer size

   */

   */

  void SetMaxBufferSize (uint32_t s);

  void SetMaxBufferSize (uint32_t s);

   * \param tcph packet's TCP header

   * \param tcph packet's TCP header

   * \return True when success, false otherwise.

   * \return True when success, false otherwise.

   */

   */

  /**

  /**

   * Extract data from the head of the buffer as indicated by nextRxSeq.

   * Extract data from the head of the buffer as indicated by nextRxSeq.

                     "Receive tcp packet from IP protocol",

                     "Receive tcp packet from IP protocol",

                     MakeTraceSourceAccessor (&TcpSocketBase::m_rxTrace),

                     MakeTraceSourceAccessor (&TcpSocketBase::m_rxTrace),

                     "ns3::TcpSocketBase::TcpTxRxTracedCallback")

                     "ns3::TcpSocketBase::TcpTxRxTracedCallback")

  ;

  ;

  return tid;

  return tid;

}

}

TypeId

TypeId

TcpSocketState::GetTypeId (void)

TcpSocketState::GetTypeId (void)

{

{

    m_endPoint6 (0),

    m_endPoint6 (0),

    m_node (sock.m_node),

    m_node (sock.m_node),

    m_tcp (sock.m_tcp),

    m_tcp (sock.m_tcp),

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

  return m_node;

  return m_node;

}

}

/* Inherit from Socket class: Bind socket to an end-point in TcpL4Protocol */

/* Inherit from Socket class: Bind socket to an end-point in TcpL4Protocol */

int

int

TcpSocketBase::Bind (void)

TcpSocketBase::Bind (void)

void

void

TcpSocketBase::InitializeCwnd (void)

TcpSocketBase::InitializeCwnd (void)

{

{

}

}

void

void

TcpSocketBase::SetInitialSSThresh (uint32_t threshold)

TcpSocketBase::SetInitialSSThresh (uint32_t threshold)

{

{

    "TcpSocketBase::SetSSThresh() cannot change initial ssThresh after connection started.");

    "TcpSocketBase::SetSSThresh() cannot change initial ssThresh after connection started.");

  m_tcb->m_initialSsThresh = threshold;

  m_tcb->m_initialSsThresh = threshold;

void

void

TcpSocketBase::SetInitialCwnd (uint32_t cwnd)

TcpSocketBase::SetInitialCwnd (uint32_t cwnd)

{

{

    "TcpSocketBase::SetInitialCwnd() cannot change initial cwnd after connection started.");

    "TcpSocketBase::SetInitialCwnd() cannot change initial cwnd after connection started.");

  m_tcb->m_initialCWnd = cwnd;

  m_tcb->m_initialCWnd = cwnd;

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

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

      if (SetupEndpoint () != 0)

      if (SetupEndpoint () != 0)

          return -1;

          return -1;

        }

        }

    }

    }

  // Different flags are different events

  // Different flags are different events

  if (tcpflags == TcpHeader::ACK)

  if (tcpflags == TcpHeader::ACK)

    {

    {

        {

        {

          // Case 1:  If the ACK is a duplicate (SEG.ACK < SND.UNA), it can be ignored.

          // Case 1:  If the ACK is a duplicate (SEG.ACK < SND.UNA), it can be ignored.

          // Pag. 72 RFC 793

          // Pag. 72 RFC 793

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

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

          // TODO: RFC 5961 5.2 [Blind Data Injection Attack].[Mitigation]

          // TODO: RFC 5961 5.2 [Blind Data Injection Attack].[Mitigation]

        }

        }

    }

    }

}

}

/* Process the newly received ACK */

/* Process the newly received ACK */

void

void

{

{

  NS_ASSERT (m_tcb->m_segmentSize > 0);

  NS_ASSERT (m_tcb->m_segmentSize > 0);

  uint32_t segsAcked  = bytesAcked / m_tcb->m_segmentSize;

  uint32_t segsAcked  = bytesAcked / m_tcb->m_segmentSize;

  m_bytesAckedNotProcessed += bytesAcked % m_tcb->m_segmentSize;

  m_bytesAckedNotProcessed += bytesAcked % m_tcb->m_segmentSize;

                " Segments acked: " << segsAcked <<

                " Segments acked: " << segsAcked <<

                " bytes left: " << m_bytesAckedNotProcessed);

                " bytes left: " << m_bytesAckedNotProcessed);

                " SND.NXT=" << m_nextTxSequence);

                " SND.NXT=" << m_nextTxSequence);

      packet->GetSize () == 0)

      packet->GetSize () == 0)

    {

    {

      // There is a DupAck

      // There is a DupAck

      // Artificially call PktsAcked. After all, one segment has been ACKed.

      // Artificially call PktsAcked. After all, one segment has been ACKed.

      m_congestionControl->PktsAcked (m_tcb, 1, m_lastRtt);

      m_congestionControl->PktsAcked (m_tcb, 1, m_lastRtt);

    }

    }

    {

    {

      // Dupack, but the ACK is precisely equal to the nextTxSequence

      // Dupack, but the ACK is precisely equal to the nextTxSequence

    }

    }

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

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

      bool callCongestionControl = true;

      bool callCongestionControl = true;

      bool resetRTO = true;

      bool resetRTO = true;

        }

        }

      else if (m_tcb->m_congState == TcpSocketState::CA_RECOVERY)

      else if (m_tcb->m_congState == TcpSocketState::CA_RECOVERY)

        {

        {

            {

            {

              /* Partial ACK.

              /* Partial ACK.

               * In case of partial ACK, retransmit the first unacknowledged

               * In case of partial ACK, retransmit the first unacknowledged

              callCongestionControl = false; // No congestion control on cWnd show be invoked

              callCongestionControl = false; // No congestion control on cWnd show be invoked

              m_dupAckCount -= segsAcked;    // Update the dupAckCount

              m_dupAckCount -= segsAcked;    // Update the dupAckCount

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

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

              if (m_isFirstPartialAck)

              if (m_isFirstPartialAck)

               */

               */

              m_congestionControl->PktsAcked (m_tcb, 1, m_lastRtt);

              m_congestionControl->PktsAcked (m_tcb, 1, m_lastRtt);

                           " in fast recovery: cwnd set to " << m_tcb->m_cWnd <<

                           " in fast recovery: cwnd set to " << m_tcb->m_cWnd <<

                           " recover seq: " << m_recover <<

                           " recover seq: " << m_recover <<

                           " dupAck count: " << m_dupAckCount);

                           " dupAck count: " << m_dupAckCount);

            }

            }

            {// Full ACK (RFC2582 sec.3 bullet #5 paragraph 2, option 1)

            {// Full ACK (RFC2582 sec.3 bullet #5 paragraph 2, option 1)

              m_tcb->m_cWnd = std::min (m_tcb->m_ssThresh.Get (),

              m_tcb->m_cWnd = std::min (m_tcb->m_ssThresh.Get (),

                                        BytesInFlight () + m_tcb->m_segmentSize);

                                        BytesInFlight () + m_tcb->m_segmentSize);

               * except the (maybe) new ACKs which come from a new window

               * except the (maybe) new ACKs which come from a new window

               */

               */

              m_congestionControl->PktsAcked (m_tcb, segsAcked, m_lastRtt);

              m_congestionControl->PktsAcked (m_tcb, segsAcked, m_lastRtt);

              m_tcb->m_congState = TcpSocketState::CA_OPEN;

              m_tcb->m_congState = TcpSocketState::CA_OPEN;

                           ". Leaving fast recovery with cwnd set to " << m_tcb->m_cWnd);

                           ". Leaving fast recovery with cwnd set to " << m_tcb->m_cWnd);

              NS_LOG_DEBUG ("RECOVERY -> OPEN");

              NS_LOG_DEBUG ("RECOVERY -> OPEN");

            }

            }

          NS_ASSERT (m_tcb->m_congState == TcpSocketState::CA_RECOVERY);

          NS_ASSERT (m_tcb->m_congState == TcpSocketState::CA_RECOVERY);

        }

        }

      // Try to send more data

      // Try to send more data

      if (!m_sendPendingDataEvent.IsRunning ())

      if (!m_sendPendingDataEvent.IsRunning ())

                                                        this, m_connected);

                                                        this, m_connected);

        }

        }

    }

    }

}

}

/* Received a packet upon LISTEN state. */

/* Received a packet upon LISTEN state. */

      m_rxBuffer->SetNextRxSequence (tcpHeader.GetSequenceNumber () + SequenceNumber32 (1));

      m_rxBuffer->SetNextRxSequence (tcpHeader.GetSequenceNumber () + SequenceNumber32 (1));

      m_highTxMark = ++m_nextTxSequence;

      m_highTxMark = ++m_nextTxSequence;

      m_txBuffer->SetHeadSequence (m_nextTxSequence);

      m_txBuffer->SetHeadSequence (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_retxEvent.Cancel ();

      m_retxEvent.Cancel ();

      m_highTxMark = ++m_nextTxSequence;

      m_highTxMark = ++m_nextTxSequence;

      m_txBuffer->SetHeadSequence (m_nextTxSequence);

      m_txBuffer->SetHeadSequence (m_nextTxSequence);

      if (m_endPoint)

      if (m_endPoint)

        {

        {

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

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

          m_retxEvent.Cancel ();

          m_retxEvent.Cancel ();

          m_highTxMark = ++m_nextTxSequence;

          m_highTxMark = ++m_nextTxSequence;

          m_txBuffer->SetHeadSequence (m_nextTxSequence);

          m_txBuffer->SetHeadSequence (m_nextTxSequence);

          if (m_endPoint)

          if (m_endPoint)

            {

            {

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

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

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

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

  bool isRetransmission = false;

  bool isRetransmission = false;

    {

    {

      isRetransmission = true;

      isRetransmission = true;

    }

    }

                    " rxwin " << m_rWnd <<

                    " rxwin " << m_rWnd <<

                    " segsize " << m_tcb->m_segmentSize <<

                    " segsize " << m_tcb->m_segmentSize <<

                    " nextTxSeq " << m_nextTxSequence <<

                    " nextTxSeq " << m_nextTxSequence <<

      uint32_t s = std::min (w, m_tcb->m_segmentSize);  // Send no more than window

      uint32_t s = std::min (w, m_tcb->m_segmentSize);  // Send no more than window

      uint32_t sz = SendDataPacket (m_nextTxSequence, s, withAck);

      uint32_t sz = SendDataPacket (m_nextTxSequence, s, withAck);

      nPacketsSent++;                             // Count sent this loop

      nPacketsSent++;                             // Count sent this loop

TcpSocketBase::UnAckDataCount () const

TcpSocketBase::UnAckDataCount () const

{

{

  NS_LOG_FUNCTION (this);

  NS_LOG_FUNCTION (this);

}

}

uint32_t

uint32_t

TcpSocketBase::BytesInFlight () const

TcpSocketBase::BytesInFlight () const

{

{

  NS_LOG_FUNCTION (this);

  NS_LOG_FUNCTION (this);

}

}

uint32_t

uint32_t

  // Put into Rx buffer

  // Put into Rx buffer

  SequenceNumber32 expectedSeq = m_rxBuffer->NextRxSequence ();

  SequenceNumber32 expectedSeq = m_rxBuffer->NextRxSequence ();

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

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

      SendEmptyPacket (TcpHeader::ACK);

      SendEmptyPacket (TcpHeader::ACK);

      return;

      return;

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

    }

    }

  if (ack > m_nextTxSequence)

  if (ack > m_nextTxSequence)

    {

    {

    }

    }

  if (m_txBuffer->Size () == 0 && m_state != FIN_WAIT_1 && m_state != CLOSING)

  if (m_txBuffer->Size () == 0 && m_state != FIN_WAIT_1 && m_state != CLOSING)

    { // No retransmit timer if no data to retransmit

    { // No retransmit timer if no data to retransmit

    }

    }

}

}

// Retransmit timeout

// Retransmit timeout

void

void

TcpSocketBase::ReTxTimeout ()

TcpSocketBase::ReTxTimeout ()

      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;

    }

    }

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

  /*

  /*

   * When a TCP sender detects segment loss using the retransmission timer

   * When a TCP sender detects segment loss using the retransmission timer

   * are not able to retransmit anything because of local congestion.

   * are not able to retransmit anything because of local congestion.

   */

   */

  m_dupAckCount = 0;

  m_dupAckCount = 0;

  if (m_tcb->m_congState != TcpSocketState::CA_LOSS)

  if (m_tcb->m_congState != TcpSocketState::CA_LOSS)

    }

    }

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

void

void

TcpSocketBase::SetSegSize (uint32_t size)

TcpSocketBase::SetSegSize (uint32_t size)

{

{

  m_tcb->m_segmentSize = size;

  m_tcb->m_segmentSize = size;

}

}

uint32_t

uint32_t

               option->GetTimestamp () << " echo=" << m_timestampToEcho);

               option->GetTimestamp () << " echo=" << m_timestampToEcho);

}

}

{

{

  NS_LOG_FUNCTION (this << header);

  NS_LOG_FUNCTION (this << header);

  //  If the connection is not established, the window size is always

  //  If the connection is not established, the window size is always

    {

    {

      m_rWnd = receivedWindow;

      m_rWnd = receivedWindow;

      NS_LOG_LOGIC ("State less than ESTABLISHED; updating rWnd to " << m_rWnd);

      NS_LOG_LOGIC ("State less than ESTABLISHED; updating rWnd to " << m_rWnd);

    }

    }

  // Test for conditions that allow updating of the window

  // Test for conditions that allow updating of the window

      m_rWnd = receivedWindow;

      m_rWnd = receivedWindow;

      NS_LOG_LOGIC ("updating rWnd to " << m_rWnd);

      NS_LOG_LOGIC ("updating rWnd to " << m_rWnd);

    }

    }

}

}

void

void

  static TypeId GetTypeId (void);

  static TypeId GetTypeId (void);

  friend class TcpGeneralTest;

  friend class TcpGeneralTest;

  /**

  /**

   * Create an unbound TCP socket

   * Create an unbound TCP socket

   */

   */

  virtual void SetRtt (Ptr<RttEstimator> rtt);

  virtual void SetRtt (Ptr<RttEstimator> rtt);

  /**

  /**

   * \brief Sets the Minimum RTO.

   * \brief Sets the Minimum RTO.

   * \param minRto The minimum RTO.

   * \param minRto The minimum RTO.

  typedef void (* TcpTxRxTracedCallback)

  typedef void (* TcpTxRxTracedCallback)

    (const Ptr<const Packet> packet, const TcpHeader& header,

    (const Ptr<const Packet> packet, const TcpHeader& header,

     const Ptr<const TcpSocketBase> socket);

     const Ptr<const TcpSocketBase> socket);

protected:

protected:

  // Implementing ns3::TcpSocket -- Attribute get/set

  // Implementing ns3::TcpSocket -- Attribute get/set

  // inherited, no need to doc

  // inherited, no need to doc

  virtual void     SetSndBufSize (uint32_t size);

  virtual void     SetSndBufSize (uint32_t size);

  virtual void     SetRcvBufSize (uint32_t size);

  virtual void     SetRcvBufSize (uint32_t size);

  virtual void     SetSegSize (uint32_t size);

  virtual void     SetSegSize (uint32_t size);

  virtual void     SetInitialSSThresh (uint32_t threshold);

  virtual void     SetInitialSSThresh (uint32_t threshold);

  virtual void     SetInitialCwnd (uint32_t cwnd);

  virtual void     SetInitialCwnd (uint32_t cwnd);

  virtual void     SetConnTimeout (Time timeout);

  virtual void     SetConnTimeout (Time timeout);

  virtual void     SetSynRetries (uint32_t count);

  virtual void     SetSynRetries (uint32_t count);

  virtual void     SetDataRetries (uint32_t retries);

  virtual void     SetDataRetries (uint32_t retries);

  virtual void     SetDelAckTimeout (Time timeout);

  virtual void     SetDelAckTimeout (Time timeout);

  virtual void     SetDelAckMaxCount (uint32_t count);

  virtual void     SetDelAckMaxCount (uint32_t count);

  virtual void     SetTcpNoDelay (bool noDelay);

  virtual void     SetTcpNoDelay (bool noDelay);

  virtual void     SetPersistTimeout (Time timeout);

  virtual void     SetPersistTimeout (Time timeout);

  virtual bool     SetAllowBroadcast (bool allowBroadcast);

  virtual bool     SetAllowBroadcast (bool allowBroadcast);

  /**

  /**

   * \brief Send reset and tear down this socket

   * \brief Send reset and tear down this socket

   */

   */

  /**

  /**

   * \brief Check if a sequence number range is within the rx window

   * \brief Check if a sequence number range is within the rx window

   * \param tail end of the Sequence window

   * \param tail end of the Sequence window

   * \returns true if it is in range

   * \returns true if it is in range

   */

   */

  // Helper functions: Connection close

  // Helper functions: Connection close

   *

   *

   * \returns 0 on success

   * \returns 0 on success

   */

   */

  /**

  /**

   * \brief Peacefully close the socket by notifying the upper layer and deallocate end point

   * \brief Peacefully close the socket by notifying the upper layer and deallocate end point

   */

   */

  /**

  /**

   * \brief Kill this socket by zeroing its attributes (IPv4)

   * \brief Kill this socket by zeroing its attributes (IPv4)

   * This is a callback function configured to m_endpoint in

   * This is a callback function configured to m_endpoint in

   * SetupCallback(), invoked when the endpoint is destroyed.

   * SetupCallback(), invoked when the endpoint is destroyed.

   */

   */

  /**

  /**

   * \brief Kill this socket by zeroing its attributes (IPv6)

   * \brief Kill this socket by zeroing its attributes (IPv6)

   * This is a callback function configured to m_endpoint in

   * This is a callback function configured to m_endpoint in

   * SetupCallback(), invoked when the endpoint is destroyed.

   * SetupCallback(), invoked when the endpoint is destroyed.

   */

   */

  /**

  /**

   * \brief Deallocate m_endPoint and m_endPoint6

   * \brief Deallocate m_endPoint and m_endPoint6

   */

   */

  /**

  /**

   * \brief Received a FIN from peer, notify rx buffer

   * \brief Received a FIN from peer, notify rx buffer

   * \param p the packet

   * \param p the packet

   * \param tcpHeader the packet's TCP header

   * \param tcpHeader the packet's TCP header

   */

   */

  /**

  /**

   * \brief FIN is in sequence, notify app and respond with a FIN

   * \brief FIN is in sequence, notify app and respond with a FIN

   */

   */

  /**

  /**

   * \brief Cancel all timer when endpoint is deleted

   * \brief Cancel all timer when endpoint is deleted

   */

   */

  /**

  /**

   * \brief Move from CLOSING or FIN_WAIT_2 to TIME_WAIT state

   * \brief Move from CLOSING or FIN_WAIT_2 to TIME_WAIT state

   */

   */

  // State transition functions

  // State transition functions

   * \param packet the packet

   * \param packet the packet

   * \param tcpHeader the packet's TCP header

   * \param tcpHeader the packet's TCP header

   */

   */

  /**

  /**

   * \brief Received a packet upon LISTEN state.

   * \brief Received a packet upon LISTEN state.

   * \param fromAddress the source address

   * \param fromAddress the source address

   * \param toAddress the destination address

   * \param toAddress the destination address

   */

   */

                      const Address& fromAddress, const Address& toAddress);

                      const Address& fromAddress, const Address& toAddress);

  /**

  /**

   * \param packet the packet

   * \param packet the packet

   * \param tcpHeader the packet's TCP header

   * \param tcpHeader the packet's TCP header

   */

   */

  /**

  /**

   * \brief Received a packet upon SYN_RCVD.

   * \brief Received a packet upon SYN_RCVD.

   * \param fromAddress the source address

   * \param fromAddress the source address

   * \param toAddress the destination address

   * \param toAddress the destination address

   */

   */

                       const Address& fromAddress, const Address& toAddress);

                       const Address& fromAddress, const Address& toAddress);

  /**

  /**

   * \param packet the packet

   * \param packet the packet

   * \param tcpHeader the packet's TCP header

   * \param tcpHeader the packet's TCP header

   */

   */

  /**

  /**

   * \brief Received a packet upon CLOSING

   * \brief Received a packet upon CLOSING

   * \param packet the packet

   * \param packet the packet

   * \param tcpHeader the packet's TCP header

   * \param tcpHeader the packet's TCP header

   */

   */

  /**

  /**

   * \brief Received a packet upon LAST_ACK

   * \brief Received a packet upon LAST_ACK

   * \param packet the packet

   * \param packet the packet

   * \param tcpHeader the packet's TCP header

   * \param tcpHeader the packet's TCP header

   */

   */

  // Window management

  // Window management

   * or 3) the advertised window is larger than the current send window

   * or 3) the advertised window is larger than the current send window

   *

   *

   * \param header TcpHeader from which to extract the new window value

   * \param header TcpHeader from which to extract the new window value

   */

   */

  // Manage data tx/rx

  // Manage data tx/rx

   * \param tcpHeader the packet's TCP header

   * \param tcpHeader the packet's TCP header

   */

   */

  virtual void ReceivedAck (Ptr<Packet> packet, const TcpHeader& tcpHeader);

  virtual void ReceivedAck (Ptr<Packet> packet, const TcpHeader& tcpHeader);

  /**

  /**

   * \brief Recv of a data, put into buffer, call L7 to get it if necessary

   * \brief Recv of a data, put into buffer, call L7 to get it if necessary

  virtual void Retransmit (void);

  virtual void Retransmit (void);

  /**

  /**

   * \brief Action upon delay ACK timeout, i.e. send an ACK

   * \brief Action upon delay ACK timeout, i.e. send an ACK

   */

   */

  virtual void DelAckTimeout (void);

  virtual void DelAckTimeout (void);

  Ptr<RttEstimator> m_rtt; //!< Round trip time estimator

  Ptr<RttEstimator> m_rtt; //!< Round trip time estimator

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

  Ptr<TcpRxBuffer>              m_rxBuffer;       //!< Rx buffer (reordering buffer)

  Ptr<TcpRxBuffer>              m_rxBuffer;       //!< Rx buffer (reordering buffer)

        }

        }

      count += pktSize;

      count += pktSize;

    }

    }

  NS_ASSERT (outPacket->GetSize () == s);

  NS_ASSERT (outPacket->GetSize () == s);

  return outPacket;

  return outPacket;

}

}

  uint32_t &readLen)

  uint32_t &readLen)

{

{

  NS_LOG_FUNCTION (this << &data <<maxBytes << tsSec << tsUsec << inclLen << origLen << readLen);

  NS_LOG_FUNCTION (this << &data <<maxBytes << tsSec << tsUsec << inclLen << origLen << readLen);

  PcapRecordHeader header;

  PcapRecordHeader header;