ns-3.24: comparison src/internet/model/tcp-socket-base.cc

equal deleted inserted replaced

-:46b6e53e8dbc
+:0c5e9bfa1b48
 #include "ns3/simulation-singleton.h"
 #include "ns3/simulator.h"
 #include "ns3/packet.h"
 #include "ns3/uinteger.h"
 #include "ns3/double.h"
+#include "ns3/pointer.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"
 "Clock Granularity used in RTO calculations",
 TimeValue (MilliSeconds (1)), // RFC6298 suggest to use fine clock granularity
 MakeTimeAccessor (&TcpSocketBase::SetClockGranularity,
 &TcpSocketBase::GetClockGranularity),
 MakeTimeChecker ())
+.AddAttribute ("TxBuffer",
+"TCP Tx buffer",
+PointerValue (),
+MakePointerAccessor (&TcpSocketBase::GetTxBuffer),
+MakePointerChecker<TcpTxBuffer> ())
+.AddAttribute ("RxBuffer",
+"TCP Rx buffer",
+PointerValue (),
+MakePointerAccessor (&TcpSocketBase::GetRxBuffer),
+MakePointerChecker<TcpRxBuffer> ())
 .AddTraceSource ("RTO",
 "Retransmission timeout",
 MakeTraceSourceAccessor (&TcpSocketBase::m_rto),
 "ns3::Time::TracedValueCallback")
 .AddTraceSource ("RTT",
 m_timestampEnabled (true),
 m_timestampToEcho (0)
 {
 NS_LOG_FUNCTION (this);
+m_rxBuffer = CreateObject<TcpRxBuffer> ();
+m_txBuffer = CreateObject<TcpTxBuffer> ();
 }
 TcpSocketBase::TcpSocketBase (const TcpSocketBase& sock)
 : TcpSocket (sock),
 //copy object::m_tid and socket::callbacks
 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),
 Callback<void, Ptr<Socket>, uint32_t> vPSUI = MakeNullCallback<void, Ptr<Socket>, uint32_t> ();
 SetConnectCallback (vPS, vPS);
 SetDataSentCallback (vPSUI);
 SetSendCallback (vPSUI);
 SetRecvCallback (vPS);
+m_txBuffer = CopyObject (sock.m_txBuffer);
+m_rxBuffer = CopyObject (sock.m_rxBuffer);
 }
 TcpSocketBase::~TcpSocketBase (void)
 {
 NS_LOG_FUNCTION (this);
 {
 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.
-if (m_rxBuffer.Size () != 0)
+if (m_rxBuffer->Size () != 0)
 {
 NS_LOG_INFO ("Socket " << this << " << unread rx data during close.  Sending reset");
 SendRST ();
 return 0;
 }
-if (m_txBuffer.SizeFromSequence (m_nextTxSequence) > 0)
+if (m_txBuffer->SizeFromSequence (m_nextTxSequence) > 0)
 { // App close with pending data must wait until all data transmitted
 if (m_closeOnEmpty == false)
 {
 m_closeOnEmpty = true;
 NS_LOG_INFO ("Socket " << this << " deferring close, state " << TcpStateName[m_state]);
 //this prevents data from being added to the buffer
 m_shutdownSend = true;
 m_closeOnEmpty = true;
 //if buffer is already empty, send a fin now
 //otherwise fin will go when buffer empties.
-if (m_txBuffer.Size () == 0)
+if (m_txBuffer->Size () == 0)
 {
 if (m_state == ESTABLISHED || m_state == CLOSE_WAIT)
 {
 NS_LOG_INFO("Emtpy tx buffer, send fin");
 SendEmptyPacket (TcpHeader::FIN);
 NS_LOG_FUNCTION (this << p);
 NS_ABORT_MSG_IF (flags, "use of flags is not supported in TcpSocketBase::Send()");
 if (m_state == ESTABLISHED || m_state == SYN_SENT || m_state == CLOSE_WAIT)
 {
 // Store the packet into Tx buffer
-if (!m_txBuffer.Add (p))
+if (!m_txBuffer->Add (p))
 { // TxBuffer overflow, send failed
 m_errno = ERROR_MSGSIZE;
 return -1;
 }
 if (m_shutdownSend)
 {
 m_errno = ERROR_SHUTDOWN;
 return -1;
 }
 // Submit the data to lower layers
-NS_LOG_LOGIC ("txBufSize=" << m_txBuffer.Size () << " state " << TcpStateName[m_state]);
+NS_LOG_LOGIC ("txBufSize=" << m_txBuffer->Size () << " state " << TcpStateName[m_state]);
 if (m_state == ESTABLISHED || m_state == CLOSE_WAIT)
 { // Try to send the data out
 SendPendingData (m_connected);
 }
 return p->GetSize ();
 Ptr<Packet>
 TcpSocketBase::Recv (uint32_t maxSize, uint32_t flags)
 {
 NS_LOG_FUNCTION (this);
 NS_ABORT_MSG_IF (flags, "use of flags is not supported in TcpSocketBase::Recv()");
-if (m_rxBuffer.Size () == 0 && m_state == CLOSE_WAIT)
+if (m_rxBuffer->Size () == 0 && m_state == CLOSE_WAIT)
 {
 return Create<Packet> (); // Send EOF on connection close
 }
-Ptr<Packet> outPacket = m_rxBuffer.Extract (maxSize);
+Ptr<Packet> outPacket = m_rxBuffer->Extract (maxSize);
 if (outPacket != 0 && outPacket->GetSize () != 0)
 {
 SocketAddressTag tag;
 if (m_endPoint != 0)
 {
 /* Inherit from Socket class: Get the max number of bytes an app can send */
 uint32_t
 TcpSocketBase::GetTxAvailable (void) const
 {
 NS_LOG_FUNCTION (this);
-return m_txBuffer.Available ();
+return m_txBuffer->Available ();
 }
 /* Inherit from Socket class: Get the max number of bytes an app can read */
 uint32_t
 TcpSocketBase::GetRxAvailable (void) const
 {
 NS_LOG_FUNCTION (this);
-return m_rxBuffer.Available ();
+return m_rxBuffer->Available ();
 }
 /* Inherit from Socket class: Return local address:port */
 int
 TcpSocketBase::GetSockName (Address &address) const
 { // Rx buffer in these states are not initialized.
 return false;
 }
 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
-// sequence number must equals to m_rxBuffer.NextRxSequence ()
+// sequence number must equals to m_rxBuffer->NextRxSequence ()
-return (m_rxBuffer.NextRxSequence () != head);
+return (m_rxBuffer->NextRxSequence () != head);
 }
 // In all other cases, check if the sequence number is in range
-return (tail < m_rxBuffer.NextRxSequence () || m_rxBuffer.MaxRxSequence () <= head);
+return (tail < m_rxBuffer->NextRxSequence () || m_rxBuffer->MaxRxSequence () <= head);
 }
 /* Function called by the L3 protocol when it received a packet to pass on to
 the TCP. This function is registered as the "RxCallback" function in
 SetupCallback(), which invoked by Bind(), and CompleteFork() */
 && OutOfRange (tcpHeader.GetSequenceNumber (), tcpHeader.GetSequenceNumber () + packet->GetSize ()))
 {
 NS_LOG_LOGIC ("At state " << TcpStateName[m_state] <<
 " received packet of seq [" << tcpHeader.GetSequenceNumber () <<
 ":" << tcpHeader.GetSequenceNumber () + packet->GetSize () <<
-") out of range [" << m_rxBuffer.NextRxSequence () << ":" <<
+") out of range [" << m_rxBuffer->NextRxSequence () << ":" <<
-m_rxBuffer.MaxRxSequence () << ")");
+m_rxBuffer->MaxRxSequence () << ")");
 // Acknowledgement should be sent for all unacceptable packets (RFC793, p.69)
 if (m_state == ESTABLISHED && !(tcpHeader.GetFlags () & TcpHeader::RST))
 {
 SendEmptyPacket (TcpHeader::ACK);
 }
 if ((tcpHeader.GetFlags () & ~(TcpHeader::PSH | TcpHeader::URG)) != TcpHeader::RST)
 { // Since m_endPoint is not configured yet, we cannot use SendRST here
 TcpHeader h;
 h.SetFlags (TcpHeader::RST);
 h.SetSequenceNumber (m_nextTxSequence);
-h.SetAckNumber (m_rxBuffer.NextRxSequence ());
+h.SetAckNumber (m_rxBuffer->NextRxSequence ());
 h.SetSourcePort (tcpHeader.GetDestinationPort ());
 h.SetDestinationPort (tcpHeader.GetSourcePort ());
 h.SetWindowSize (AdvertisedWindowSize ());
 AddOptions (h);
 m_tcp->SendPacket (Create<Packet> (), h, header.GetDestination (), header.GetSource (), m_boundnetdevice);
 && OutOfRange (tcpHeader.GetSequenceNumber (), tcpHeader.GetSequenceNumber () + packet->GetSize ()))
 {
 NS_LOG_LOGIC ("At state " << TcpStateName[m_state] <<
 " received packet of seq [" << tcpHeader.GetSequenceNumber () <<
 ":" << tcpHeader.GetSequenceNumber () + packet->GetSize () <<
-") out of range [" << m_rxBuffer.NextRxSequence () << ":" <<
+") out of range [" << m_rxBuffer->NextRxSequence () << ":" <<
-m_rxBuffer.MaxRxSequence () << ")");
+m_rxBuffer->MaxRxSequence () << ")");
 // Acknowledgement should be sent for all unacceptable packets (RFC793, p.69)
 if (m_state == ESTABLISHED && !(tcpHeader.GetFlags () & TcpHeader::RST))
 {
 SendEmptyPacket (TcpHeader::ACK);
 }
 if ((tcpHeader.GetFlags () & ~(TcpHeader::PSH | TcpHeader::URG)) != TcpHeader::RST)
 { // Since m_endPoint is not configured yet, we cannot use SendRST here
 TcpHeader h;
 h.SetFlags (TcpHeader::RST);
 h.SetSequenceNumber (m_nextTxSequence);
-h.SetAckNumber (m_rxBuffer.NextRxSequence ());
+h.SetAckNumber (m_rxBuffer->NextRxSequence ());
 h.SetSourcePort (tcpHeader.GetDestinationPort ());
 h.SetDestinationPort (tcpHeader.GetSourcePort ());
 h.SetWindowSize (AdvertisedWindowSize ());
 AddOptions (h);
 m_tcp->SendPacket (Create<Packet> (), h, header.GetDestinationAddress (), header.GetSourceAddress (), m_boundnetdevice);
 PeerClose (packet, tcpHeader);
 }
 else if (tcpflags == 0)
 { // No flags means there is only data
 ReceivedData (packet, tcpHeader);
-if (m_rxBuffer.Finished ())
+if (m_rxBuffer->Finished ())
 {
 PeerClose (packet, tcpHeader);
 }
 }
 else
 // Received ACK. Compare the ACK number against highest unacked seqno
 if (0 == (tcpHeader.GetFlags () & TcpHeader::ACK))
 { // Ignore if no ACK flag
 }
-else if (tcpHeader.GetAckNumber () < m_txBuffer.HeadSequence ())
+else if (tcpHeader.GetAckNumber () < m_txBuffer->HeadSequence ())
 { // Case 1: Old ACK, ignored.
 NS_LOG_LOGIC ("Ignored ack of " << tcpHeader.GetAckNumber ());
 }
-else if (tcpHeader.GetAckNumber () == m_txBuffer.HeadSequence ())
+else if (tcpHeader.GetAckNumber () == m_txBuffer->HeadSequence ())
 { // Case 2: Potentially a duplicated ACK
 if (tcpHeader.GetAckNumber () < m_nextTxSequence && packet->GetSize() == 0)
 {
 NS_LOG_LOGIC ("Dupack of " << tcpHeader.GetAckNumber ());
 DupAck (tcpHeader, ++m_dupAckCount);
 }
 // otherwise, the ACK is precisely equal to the nextTxSequence
 NS_ASSERT (tcpHeader.GetAckNumber () <= m_nextTxSequence);
 }
-else if (tcpHeader.GetAckNumber () > m_txBuffer.HeadSequence ())
+else if (tcpHeader.GetAckNumber () > m_txBuffer->HeadSequence ())
 { // Case 3: New ACK, reset m_dupAckCount and update m_txBuffer
 NS_LOG_LOGIC ("New ack of " << tcpHeader.GetAckNumber ());
 NewAck (tcpHeader.GetAckNumber ());
 m_dupAckCount = 0;
 }
 else if (tcpflags == TcpHeader::SYN)
 { // Received SYN, move to SYN_RCVD state and respond with SYN+ACK
 NS_LOG_INFO ("SYN_SENT -> SYN_RCVD");
 m_state = SYN_RCVD;
 m_cnCount = m_cnRetries;
-m_rxBuffer.SetNextRxSequence (tcpHeader.GetSequenceNumber () + SequenceNumber32 (1));
+m_rxBuffer->SetNextRxSequence (tcpHeader.GetSequenceNumber () + SequenceNumber32 (1));
 SendEmptyPacket (TcpHeader::SYN | TcpHeader::ACK);
 }
 else if (tcpflags == (TcpHeader::SYN | TcpHeader::ACK)
 && m_nextTxSequence + SequenceNumber32 (1) == tcpHeader.GetAckNumber ())
 { // Handshake completed
 NS_LOG_INFO ("SYN_SENT -> ESTABLISHED");
 m_state = ESTABLISHED;
 m_connected = true;
 m_retxEvent.Cancel ();
-m_rxBuffer.SetNextRxSequence (tcpHeader.GetSequenceNumber () + SequenceNumber32 (1));
+m_rxBuffer->SetNextRxSequence (tcpHeader.GetSequenceNumber () + SequenceNumber32 (1));
 m_highTxMark = ++m_nextTxSequence;
-m_txBuffer.SetHeadSequence (m_nextTxSequence);
+m_txBuffer->SetHeadSequence (m_nextTxSequence);
 SendEmptyPacket (TcpHeader::ACK);
 SendPendingData (m_connected);
 Simulator::ScheduleNow (&TcpSocketBase::ConnectionSucceeded, this);
 // Always respond to first data packet to speed up the connection.
 // Remove to get the behaviour of old NS-3 code.
 NS_LOG_INFO ("SYN_RCVD -> ESTABLISHED");
 m_state = ESTABLISHED;
 m_connected = true;
 m_retxEvent.Cancel ();
 m_highTxMark = ++m_nextTxSequence;
-m_txBuffer.SetHeadSequence (m_nextTxSequence);
+m_txBuffer->SetHeadSequence (m_nextTxSequence);
 if (m_endPoint)
 {
 m_endPoint->SetPeer (InetSocketAddress::ConvertFrom (fromAddress).GetIpv4 (),
 InetSocketAddress::ConvertFrom (fromAddress).GetPort ());
 }
 NotifySend (GetTxAvailable ());
 }
 }
 else if (tcpflags == TcpHeader::SYN)
 { // Probably the peer lost my SYN+ACK
-m_rxBuffer.SetNextRxSequence (tcpHeader.GetSequenceNumber () + SequenceNumber32 (1));
+m_rxBuffer->SetNextRxSequence (tcpHeader.GetSequenceNumber () + SequenceNumber32 (1));
 SendEmptyPacket (TcpHeader::SYN | TcpHeader::ACK);
 }
 else if (tcpflags == (TcpHeader::FIN | TcpHeader::ACK))
 {
-if (tcpHeader.GetSequenceNumber () == m_rxBuffer.NextRxSequence ())
+if (tcpHeader.GetSequenceNumber () == m_rxBuffer->NextRxSequence ())
 { // In-sequence FIN before connection complete. Set up connection and close.
 m_connected = true;
 m_retxEvent.Cancel ();
 m_highTxMark = ++m_nextTxSequence;
-m_txBuffer.SetHeadSequence (m_nextTxSequence);
+m_txBuffer->SetHeadSequence (m_nextTxSequence);
 if (m_endPoint)
 {
 m_endPoint->SetPeer (InetSocketAddress::ConvertFrom (fromAddress).GetIpv4 (),
 InetSocketAddress::ConvertFrom (fromAddress).GetPort ());
 }
 ReceivedData (packet, tcpHeader);
 }
 else if (tcpflags == TcpHeader::ACK)
 { // Process the ACK, and if in FIN_WAIT_1, conditionally move to FIN_WAIT_2
 ReceivedAck (packet, tcpHeader);
-if (m_state == FIN_WAIT_1 && m_txBuffer.Size () == 0
+if (m_state == FIN_WAIT_1 && m_txBuffer->Size () == 0
 && tcpHeader.GetAckNumber () == m_highTxMark + SequenceNumber32 (1))
 { // This ACK corresponds to the FIN sent
 NS_LOG_INFO ("FIN_WAIT_1 -> FIN_WAIT_2");
 m_state = FIN_WAIT_2;
 }
 { // Got FIN, respond with ACK and move to next state
 if (tcpflags & TcpHeader::ACK)
 { // Process the ACK first
 ReceivedAck (packet, tcpHeader);
 }
-m_rxBuffer.SetFinSequence (tcpHeader.GetSequenceNumber ());
+m_rxBuffer->SetFinSequence (tcpHeader.GetSequenceNumber ());
 }
 else if (tcpflags == TcpHeader::SYN || tcpflags == (TcpHeader::SYN | TcpHeader::ACK))
 { // Duplicated SYN or SYN+ACK, possibly due to spurious retransmission
 return;
 }
 CloseAndNotify ();
 return;
 }
 // Check if the close responder sent an in-sequence FIN, if so, respond ACK
-if ((m_state == FIN_WAIT_1 || m_state == FIN_WAIT_2) && m_rxBuffer.Finished ())
+if ((m_state == FIN_WAIT_1 || m_state == FIN_WAIT_2) && m_rxBuffer->Finished ())
 {
 if (m_state == FIN_WAIT_1)
 {
 NS_LOG_INFO ("FIN_WAIT_1 -> CLOSING");
 m_state = CLOSING;
-if (m_txBuffer.Size () == 0
+if (m_txBuffer->Size () == 0
 && tcpHeader.GetAckNumber () == m_highTxMark + SequenceNumber32 (1))
 { // This ACK corresponds to the FIN sent
 TimeWait ();
 }
 }
 // Extract the flags. PSH and URG are not honoured.
 uint8_t tcpflags = tcpHeader.GetFlags () & ~(TcpHeader::PSH | TcpHeader::URG);
 if (tcpflags == TcpHeader::ACK)
 {
-if (tcpHeader.GetSequenceNumber () == m_rxBuffer.NextRxSequence ())
+if (tcpHeader.GetSequenceNumber () == m_rxBuffer->NextRxSequence ())
 { // This ACK corresponds to the FIN sent
 TimeWait ();
 }
 }
 else
 {
 ReceivedData (packet, tcpHeader);
 }
 else if (tcpflags == TcpHeader::ACK)
 {
-if (tcpHeader.GetSequenceNumber () == m_rxBuffer.NextRxSequence ())
+if (tcpHeader.GetSequenceNumber () == m_rxBuffer->NextRxSequence ())
 { // This ACK corresponds to the FIN sent. This socket closed peacefully.
 CloseAndNotify ();
 }
 }
 else if (tcpflags == TcpHeader::FIN)
 TcpSocketBase::PeerClose (Ptr<Packet> p, const TcpHeader& tcpHeader)
 {
 NS_LOG_FUNCTION (this << tcpHeader);
 // Ignore all out of range packets
-if (tcpHeader.GetSequenceNumber () < m_rxBuffer.NextRxSequence ()
+if (tcpHeader.GetSequenceNumber () < m_rxBuffer->NextRxSequence ()
-|| tcpHeader.GetSequenceNumber () > m_rxBuffer.MaxRxSequence ())
+|| tcpHeader.GetSequenceNumber () > m_rxBuffer->MaxRxSequence ())
 {
 return;
 }
 // For any case, remember the FIN position in rx buffer first
-m_rxBuffer.SetFinSequence (tcpHeader.GetSequenceNumber () + SequenceNumber32 (p->GetSize ()));
+m_rxBuffer->SetFinSequence (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 (p->GetSize ())
 {
 ReceivedData (p, tcpHeader);
 }
 // Return if FIN is out of sequence, otherwise move to CLOSE_WAIT state by DoPeerClose
-if (!m_rxBuffer.Finished ())
+if (!m_rxBuffer->Finished ())
 {
 return;
 }
 // Simultaneous close: Application invoked Close() when we are processing this FIN packet
 ++s;
 }
 header.SetFlags (flags);
 header.SetSequenceNumber (s);
-header.SetAckNumber (m_rxBuffer.NextRxSequence ());
+header.SetAckNumber (m_rxBuffer->NextRxSequence ());
 if (m_endPoint != 0)
 {
 header.SetSourcePort (m_endPoint->GetLocalPort ());
 header.SetDestinationPort (m_endPoint->GetPeerPort ());
 }
 NS_LOG_INFO ("LISTEN -> SYN_RCVD");
 m_state = SYN_RCVD;
 m_cnCount = m_cnRetries;
 SetupCallback ();
 // Set the sequence number and send SYN+ACK
-m_rxBuffer.SetNextRxSequence (h.GetSequenceNumber () + SequenceNumber32 (1));
+m_rxBuffer->SetNextRxSequence (h.GetSequenceNumber () + SequenceNumber32 (1));
 SendEmptyPacket (TcpHeader::SYN | TcpHeader::ACK);
 }
 void
 TcpSocketBase::SendDataPacket (SequenceNumber32 seq, uint32_t maxSize, bool withAck)
 {
 NS_LOG_FUNCTION (this << seq << maxSize << withAck);
 bool isRetransmission = false;
-if ( seq == m_txBuffer.HeadSequence () )
+if ( seq == m_txBuffer->HeadSequence () )
 {
 isRetransmission = true;
 }
-Ptr<Packet> p = m_txBuffer.CopyFromSequence (maxSize, seq);
+Ptr<Packet> p = m_txBuffer->CopyFromSequence (maxSize, seq);
 uint32_t sz = p->GetSize (); // Size of packet
 uint8_t flags = withAck ? TcpHeader::ACK : 0;
-uint32_t remainingData = m_txBuffer.SizeFromSequence (seq + SequenceNumber32 (sz));
+uint32_t remainingData = m_txBuffer->SizeFromSequence (seq + SequenceNumber32 (sz));
 /*
 * Add tags for each socket option.
 * Note that currently the socket adds both IPv4 tag and IPv6 tag
 * if both options are set. Once the packet got to layer three, only
 }
 }
 TcpHeader header;
 header.SetFlags (flags);
 header.SetSequenceNumber (seq);
-header.SetAckNumber (m_rxBuffer.NextRxSequence ());
+header.SetAckNumber (m_rxBuffer->NextRxSequence ());
 if (m_endPoint)
 {
 header.SetSourcePort (m_endPoint->GetLocalPort ());
 header.SetDestinationPort (m_endPoint->GetPeerPort ());
 }
 */
 bool
 TcpSocketBase::SendPendingData (bool withAck)
 {
 NS_LOG_FUNCTION (this << withAck);
-if (m_txBuffer.Size () == 0)
+if (m_txBuffer->Size () == 0)
 {
 return false;                           // Nothing to send
 }
 if (m_endPoint == 0 && m_endPoint6 == 0)
 {
 NS_LOG_INFO ("TcpSocketBase::SendPendingData: No endpoint; m_shutdownSend=" << m_shutdownSend);
 return false; // Is this the right way to handle this condition?
 }
 uint32_t nPacketsSent = 0;
-while (m_txBuffer.SizeFromSequence (m_nextTxSequence))
+while (m_txBuffer->SizeFromSequence (m_nextTxSequence))
 {
 uint32_t w = AvailableWindow (); // Get available window size
 NS_LOG_LOGIC ("TcpSocketBase " << this << " SendPendingData" <<
 " w " << w <<
 " rxwin " << m_rWnd <<
 " segsize " << m_segmentSize <<
 " nextTxSeq " << m_nextTxSequence <<
-" highestRxAck " << m_txBuffer.HeadSequence () <<
+" highestRxAck " << m_txBuffer->HeadSequence () <<
-" pd->Size " << m_txBuffer.Size () <<
+" pd->Size " << m_txBuffer->Size () <<
-" pd->SFS " << m_txBuffer.SizeFromSequence (m_nextTxSequence));
+" pd->SFS " << m_txBuffer->SizeFromSequence (m_nextTxSequence));
 // Stop sending if we need to wait for a larger Tx window (prevent silly window syndrome)
-if (w < m_segmentSize && m_txBuffer.SizeFromSequence (m_nextTxSequence) > w)
+if (w < m_segmentSize && m_txBuffer->SizeFromSequence (m_nextTxSequence) > w)
 {
 break; // No more
 }
 // 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
 if (!m_noDelay && UnAckDataCount () > 0
-&& m_txBuffer.SizeFromSequence (m_nextTxSequence) < m_segmentSize)
+&& m_txBuffer->SizeFromSequence (m_nextTxSequence) < m_segmentSize)
 {
 NS_LOG_LOGIC ("Invoking Nagle's algorithm. Wait to send.");
 break;
 }
 uint32_t s = std::min (w, m_segmentSize);  // Send no more than window
 uint32_t
 TcpSocketBase::UnAckDataCount ()
 {
 NS_LOG_FUNCTION (this);
-return m_nextTxSequence.Get () - m_txBuffer.HeadSequence ();
+return m_nextTxSequence.Get () - m_txBuffer->HeadSequence ();
 }
 uint32_t
 TcpSocketBase::BytesInFlight ()
 {
 NS_LOG_FUNCTION (this);
-return m_highTxMark.Get () - m_txBuffer.HeadSequence ();
+return m_highTxMark.Get () - m_txBuffer->HeadSequence ();
 }
 uint32_t
 TcpSocketBase::Window ()
 {
 }
 uint16_t
 TcpSocketBase::AdvertisedWindowSize ()
 {
-uint32_t w = m_rxBuffer.MaxBufferSize () - m_rxBuffer.Size ();
+uint32_t w = m_rxBuffer->MaxBufferSize () - m_rxBuffer->Size ();
 w >>= m_sndScaleFactor;
 if (w > m_maxWinSize)
 {
 NS_LOG_LOGIC ("seq " << tcpHeader.GetSequenceNumber () <<
 " ack " << tcpHeader.GetAckNumber () <<
 " pkt size " << p->GetSize () );
 // Put into Rx buffer
-SequenceNumber32 expectedSeq = m_rxBuffer.NextRxSequence ();
+SequenceNumber32 expectedSeq = m_rxBuffer->NextRxSequence ();
-if (!m_rxBuffer.Add (p, tcpHeader))
+if (!m_rxBuffer->Add (p, tcpHeader))
 { // Insert failed: No data or RX buffer full
 SendEmptyPacket (TcpHeader::ACK);
 return;
 }
 // Now send a new ACK packet acknowledging all received and delivered data
-if (m_rxBuffer.Size () > m_rxBuffer.Available () || m_rxBuffer.NextRxSequence () > expectedSeq + p->GetSize ())
+if (m_rxBuffer->Size () > m_rxBuffer->Available () || m_rxBuffer->NextRxSequence () > expectedSeq + p->GetSize ())
 { // A gap exists in the buffer, or we filled a gap: Always ACK
 SendEmptyPacket (TcpHeader::ACK);
 }
 else
 { // In-sequence packet: ACK if delayed ack count allows
 &TcpSocketBase::DelAckTimeout, this);
 NS_LOG_LOGIC (this << " scheduled delayed ACK at " << (Simulator::Now () + Simulator::GetDelayLeft (m_delAckEvent)).GetSeconds ());
 }
 }
 // Notify app to receive if necessary
-if (expectedSeq < m_rxBuffer.NextRxSequence ())
+if (expectedSeq < m_rxBuffer->NextRxSequence ())
 { // NextRxSeq advanced, we have something to send to the app
 if (!m_shutdownRecv)
 {
 NotifyDataRecv ();
 }
 {
 NS_LOG_WARN ("Why TCP " << this << " got data after close notification?");
 }
 // If we received FIN before and now completed all "holes" in rx buffer,
 // invoke peer close procedure
-if (m_rxBuffer.Finished () && (tcpHeader.GetFlags () & TcpHeader::FIN) == 0)
+if (m_rxBuffer->Finished () && (tcpHeader.GetFlags () & TcpHeader::FIN) == 0)
 {
 DoPeerClose ();
 }
 }
 }
 m_persistEvent = Simulator::Schedule (m_persistTimeout, &TcpSocketBase::PersistTimeout, this);
 NS_ASSERT (m_persistTimeout == Simulator::GetDelayLeft (m_persistEvent));
 }
 // Note the highest ACK and tell app to send more
 NS_LOG_LOGIC ("TCP " << this << " NewAck " << ack <<
-" numberAck " << (ack - m_txBuffer.HeadSequence ())); // Number bytes ack'ed
+" numberAck " << (ack - m_txBuffer->HeadSequence ())); // Number bytes ack'ed
-m_txBuffer.DiscardUpTo (ack);
+m_txBuffer->DiscardUpTo (ack);
 if (GetTxAvailable () > 0)
 {
 NotifySend (GetTxAvailable ());
 }
 if (ack > m_nextTxSequence)
 {
 m_nextTxSequence = ack; // If advanced
 }
-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
 NS_LOG_LOGIC (this << " Cancelled ReTxTimeout event which was set to expire at " <<
 (Simulator::Now () + Simulator::GetDelayLeft (m_retxEvent)).GetSeconds ());
 m_retxEvent.Cancel ();
 }
 if (m_state == CLOSED || m_state == TIME_WAIT)
 {
 return;
 }
 // If all data are received (non-closing socket and nothing to send), just return
-if (m_state <= ESTABLISHED && m_txBuffer.HeadSequence () >= m_highTxMark)
+if (m_state <= ESTABLISHED && m_txBuffer->HeadSequence () >= m_highTxMark)
 {
 return;
 }
 Retransmit ();
 void
 TcpSocketBase::PersistTimeout ()
 {
 NS_LOG_LOGIC ("PersistTimeout expired at " << Simulator::Now ().GetSeconds ());
 m_persistTimeout = std::min (Seconds (60), Time (2 * m_persistTimeout)); // max persist timeout = 60s
-Ptr<Packet> p = m_txBuffer.CopyFromSequence (1, m_nextTxSequence);
+Ptr<Packet> p = m_txBuffer->CopyFromSequence (1, m_nextTxSequence);
 TcpHeader tcpHeader;
 tcpHeader.SetSequenceNumber (m_nextTxSequence);
-tcpHeader.SetAckNumber (m_rxBuffer.NextRxSequence ());
+tcpHeader.SetAckNumber (m_rxBuffer->NextRxSequence ());
 tcpHeader.SetWindowSize (AdvertisedWindowSize ());
 if (m_endPoint != 0)
 {
 tcpHeader.SetSourcePort (m_endPoint->GetLocalPort ());
 tcpHeader.SetDestinationPort (m_endPoint->GetPeerPort ());
 }
 void
 TcpSocketBase::Retransmit ()
 {
-m_nextTxSequence = m_txBuffer.HeadSequence (); // Start from highest Ack
+m_nextTxSequence = m_txBuffer->HeadSequence (); // Start from highest Ack
 m_dupAckCount = 0;
 DoRetransmit (); // Retransmit the packet
 }
 void
 NotifyConnectionFailed ();
 }
 return;
 }
 // Retransmit non-data packet: Only if in FIN_WAIT_1 or CLOSING state
-if (m_txBuffer.Size () == 0)
+if (m_txBuffer->Size () == 0)
 {
 if (m_state == FIN_WAIT_1 || m_state == CLOSING)
 { // Must have lost FIN, re-send
 SendEmptyPacket (TcpHeader::FIN);
 }
 return;
 }
 // Retransmit a data packet: Call SendDataPacket
-NS_LOG_LOGIC ("TcpSocketBase " << this << " retxing seq " << m_txBuffer.HeadSequence ());
+NS_LOG_LOGIC ("TcpSocketBase " << this << " retxing seq " << m_txBuffer->HeadSequence ());
-uint32_t sz = SendDataPacket (m_txBuffer.HeadSequence (), m_segmentSize, true);
+uint32_t sz = SendDataPacket (m_txBuffer->HeadSequence (), m_segmentSize, true);
 // In case of RTO, advance m_nextTxSequence
-m_nextTxSequence = std::max (m_nextTxSequence.Get (), m_txBuffer.HeadSequence () + sz);
+m_nextTxSequence = std::max (m_nextTxSequence.Get (), m_txBuffer->HeadSequence () + sz);
 }
 void
 TcpSocketBase::CancelAllTimers ()
 /* Below are the attribute get/set functions */
 void
 TcpSocketBase::SetSndBufSize (uint32_t size)
 {
-m_txBuffer.SetMaxBufferSize (size);
+m_txBuffer->SetMaxBufferSize (size);
 }
 uint32_t
 TcpSocketBase::GetSndBufSize (void) const
 {
-return m_txBuffer.MaxBufferSize ();
+return m_txBuffer->MaxBufferSize ();
 }
 void
 TcpSocketBase::SetRcvBufSize (uint32_t size)
 {
-m_rxBuffer.SetMaxBufferSize (size);
+m_rxBuffer->SetMaxBufferSize (size);
 }
 uint32_t
 TcpSocketBase::GetRcvBufSize (void) const
 {
-return m_rxBuffer.MaxBufferSize ();
+return m_rxBuffer->MaxBufferSize ();
 }
 void
 TcpSocketBase::SetSegSize (uint32_t size)
 {
 uint8_t
 TcpSocketBase::CalculateWScale () const
 {
 NS_LOG_FUNCTION (this);
-uint32_t maxSpace = m_rxBuffer.MaxBufferSize ();
+uint32_t maxSpace = m_rxBuffer->MaxBufferSize ();
 uint8_t scale = 0;
 while (maxSpace > m_maxWinSize)
 {
 maxSpace = maxSpace >> 1;
 NS_LOG_WARN ("Possible error; scale exceeds 14: " << scale);
 scale = 14;
 }
 NS_LOG_INFO ("Node " << m_node->GetId () << " calculated wscale factor of " <<
-static_cast<int> (scale) << " for buffer size " << m_rxBuffer.MaxBufferSize ());
+static_cast<int> (scale) << " for buffer size " << m_rxBuffer->MaxBufferSize ());
 return scale;
 }
 void
 TcpSocketBase::AddOptionWScale (TcpHeader &header)
 TcpSocketBase::GetClockGranularity (void) const
 {
 return m_clockGranularity;
 }
+Ptr<TcpTxBuffer>
+TcpSocketBase::GetTxBuffer (void) const
+{
+return m_txBuffer;
+}
+Ptr<TcpRxBuffer>
+TcpSocketBase::GetRxBuffer (void) const
+{
+return m_rxBuffer;
+}
 //RttHistory methods
 RttHistory::RttHistory (SequenceNumber32 s, uint32_t c, Time t)
 : seq (s), count (c), time (t), retx (false)
 {
 }

changeset 11195	0c5e9bfa1b48
parent 11193	f35b8f7e50f1
child 11202	6286a5dc3f64