A Discrete-Event Network Simulator
API
tcp-general-test.h
Go to the documentation of this file.
1 /* -*- Mode: C++; c-file-style: "gnu"; indent-tabs-mode:nil; -*- */
2 /*
3  * Copyright (c) 2015 Natale Patriciello <natale.patriciello@gmail.com>
4  *
5  * This program is free software; you can redistribute it and/or modify
6  * it under the terms of the GNU General Public License version 2 as
7  * published by the Free Software Foundation;
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software
16  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17  *
18  */
19 #ifndef TCPGENERALTEST_H
20 #define TCPGENERALTEST_H
21 
22 #include "ns3/simple-net-device.h"
23 #include "ns3/error-model.h"
24 #include "ns3/tcp-socket-base.h"
25 #include "ns3/tcp-congestion-ops.h"
26 #include "ns3/tcp-recovery-ops.h"
27 #include "ns3/tcp-rate-ops.h"
28 #include "ns3/test.h"
29 
30 namespace ns3 {
31 
53 {
54 public:
59  static TypeId GetTypeId (void);
60 
62  {
63  }
64 
70  {
71  m_rcvAckCb = other.m_rcvAckCb;
75  m_forkCb = other.m_forkCb;
77  }
78 
87  uint32_t, bool> UpdateRttCallback;
88 
95  void SetRcvAckCb (AckManagementCb cb);
96 
104 
110  void SetAfterRetransmitCb (RetrCb cb);
111 
117  void SetBeforeRetransmitCb (RetrCb cb);
118 
123  void SetForkCb (Callback<void, Ptr<TcpSocketMsgBase> > cb);
124 
131 
132 protected:
133  virtual void ReceivedAck (Ptr<Packet> packet, const TcpHeader& tcpHeader);
134  virtual void ReTxTimeout (void);
135  virtual Ptr<TcpSocketBase> Fork (void);
136  virtual void CompleteFork (Ptr<Packet> p, const TcpHeader& tcpHeader,
137  const Address& fromAddress, const Address& toAddress);
138  virtual void UpdateRttHistory (const SequenceNumber32 &seq, uint32_t sz,
139  bool isRetransmission);
140 
141 private:
148 };
149 
150 
169 {
170 public:
175  static TypeId GetTypeId (void);
176 
178  : TcpSocketMsgBase (),
179  m_bytesToAck (125),
181  m_lastAckedSeq (1)
182  {
183  }
184 
190  : TcpSocketMsgBase (other),
191  m_bytesToAck (other.m_bytesToAck),
194  {
195  }
196 
201  void SetBytesToAck (uint32_t bytes)
202  {
203  m_bytesToAck = bytes;
204  }
205 
206 protected:
207  virtual void SendEmptyPacket (uint8_t flags);
208  Ptr<TcpSocketBase> Fork (void);
209 
210  uint32_t m_bytesToAck;
213 };
214 
256 class TcpGeneralTest : public TestCase
257 {
258 public:
267  TcpGeneralTest (const std::string &desc);
268  ~TcpGeneralTest ();
269 
275  {
278  };
279 
280 protected:
287 
294 
301 
308 
315 
324  virtual Ptr<TcpSocketMsgBase> CreateSocket (Ptr<Node> node, TypeId socketType,
325  TypeId congControl);
326 
336  virtual Ptr<TcpSocketMsgBase> CreateSocket (Ptr<Node> node, TypeId socketType,
337  TypeId congControl, TypeId recoveryAlgorithm);
338 
344  {
345  return m_senderSocket;
346  }
347 
353  {
354  return m_receiverSocket;
355  }
356 
373  virtual void DoRun (void);
374 
378  virtual void ConfigureEnvironment (void);
379 
383  virtual void ConfigureProperties (void);
384 
388  virtual void DoTeardown (void);
389 
393  void DoConnect ();
394 
401  virtual void ReceivePacket (Ptr<Socket> socket);
402 
411  void SendPacket (Ptr<Socket> socket, uint32_t pktSize,
412  uint32_t pktCount, Time pktInterval);
413 
421  uint32_t GetSegSize (SocketWho who);
422 
431 
437  uint32_t GetReTxThreshold (SocketWho who);
438 
444  uint32_t GetInitialSsThresh (SocketWho who);
445 
451  uint32_t GetInitialCwnd (SocketWho who);
452 
458  uint32_t GetDupAckCount (SocketWho who);
459 
465  uint32_t GetDelAckCount (SocketWho who);
466 
473 
480  Time GetRto (SocketWho who);
481 
488  Time GetMinRto (SocketWho who);
489 
497 
505 
513 
521 
529 
537 
545 
552  uint32_t GetRWnd (SocketWho who);
553 
561 
569 
576  void SetRcvBufSize (SocketWho who, uint32_t size);
577 
584  void SetSegmentSize (SocketWho who, uint32_t segmentSize);
585 
592  void SetInitialCwnd (SocketWho who, uint32_t initialCwnd);
593 
600  void SetEcn (SocketWho who, TcpSocketBase::EcnMode_t ecnMode);
601 
608  void SetInitialSsThresh (SocketWho who, uint32_t initialSsThresh);
609 
617  void SetAppPktSize (uint32_t pktSize) { m_pktSize = pktSize; }
618 
626  void SetAppPktCount (uint32_t pktCount) { m_pktCount = pktCount; }
627 
633  void SetAppPktInterval (Time pktInterval) { m_interPacketInterval = pktInterval; }
634 
640  void SetPropagationDelay (Time propDelay) { m_propagationDelay = propDelay; }
641 
648 
654  void SetCongestionControl (TypeId congControl) { m_congControlTypeId = congControl; }
655 
661  void SetRecoveryAlgorithm (TypeId reccovery) { m_recoveryTypeId = reccovery; }
662 
668  void SetMTU (uint32_t mtu) { m_mtu = mtu; }
669 
675  virtual void CongStateTrace (const TcpSocketState::TcpCongState_t oldValue,
676  const TcpSocketState::TcpCongState_t newValue)
677  {
678  NS_UNUSED (oldValue);
679  NS_UNUSED (newValue);
680  }
681 
688  virtual void CWndTrace (uint32_t oldValue, uint32_t newValue)
689  {
690  NS_UNUSED (oldValue);
691  NS_UNUSED (newValue);
692  }
693 
700  virtual void CWndInflTrace (uint32_t oldValue, uint32_t newValue)
701  {
702  NS_UNUSED (oldValue);
703  NS_UNUSED (newValue);
704  }
705 
714  virtual void RttTrace (Time oldTime, Time newTime)
715  {
716  NS_UNUSED (oldTime);
717  NS_UNUSED (newTime);
718  }
719 
728  virtual void SsThreshTrace (uint32_t oldValue, uint32_t newValue)
729  {
730  NS_UNUSED (oldValue);
731  NS_UNUSED (newValue);
732  }
733 
742  virtual void BytesInFlightTrace (uint32_t oldValue, uint32_t newValue)
743  {
744  NS_UNUSED (oldValue);
745  NS_UNUSED (newValue);
746  }
747 
756  virtual void RtoTrace (Time oldValue, Time newValue)
757  {
758  NS_UNUSED (oldValue);
759  NS_UNUSED (newValue);
760  }
761 
770  virtual void NextTxSeqTrace (SequenceNumber32 oldValue, SequenceNumber32 newValue)
771  {
772  NS_UNUSED (oldValue);
773  NS_UNUSED (newValue);
774  }
775 
784  virtual void HighestTxSeqTrace (SequenceNumber32 oldValue, SequenceNumber32 newValue)
785  {
786  NS_UNUSED (oldValue);
787  NS_UNUSED (newValue);
788  }
789 
795  {
796  NS_UNUSED (rate);
797  }
798 
804  {
805  NS_UNUSED (sample);
806  }
807 
812  virtual void NormalClose (SocketWho who)
813  {
814  NS_UNUSED (who);
815  }
816 
822  virtual void ErrorClose (SocketWho who)
823  {
825  NS_UNUSED (who);
826  }
827 
832  virtual void QueueDrop (SocketWho who)
833  {
834  NS_UNUSED (who);
835  }
836 
841  virtual void PhyDrop (SocketWho who)
842  {
843  NS_UNUSED (who);
844  }
845 
855  virtual void RcvAck (const Ptr<const TcpSocketState> tcb,
856  const TcpHeader& h, SocketWho who)
857  {
858  NS_UNUSED (tcb);
859  NS_UNUSED (h);
860  NS_UNUSED (who);
861  }
862 
872  virtual void ProcessedAck (const Ptr<const TcpSocketState> tcb,
873  const TcpHeader& h, SocketWho who)
874  {
875  NS_UNUSED (tcb);
876  NS_UNUSED (h);
877  NS_UNUSED (who);
878  }
879 
887  virtual void Tx (const Ptr<const Packet> p, const TcpHeader&h, SocketWho who);
888 
896  virtual void Rx (const Ptr<const Packet> p, const TcpHeader&h, SocketWho who);
897 
905  {
906  NS_UNUSED (tcb);
907  NS_UNUSED (who);
908  }
909 
917  {
918  NS_UNUSED (tcb);
919  NS_UNUSED (who);
920  }
921 
929  virtual void UpdatedRttHistory (const SequenceNumber32 & seq, uint32_t sz,
930  bool isRetransmission, SocketWho who)
931  {
932  NS_UNUSED (seq);
933  NS_UNUSED (sz);
934  NS_UNUSED (isRetransmission);
935  NS_UNUSED (who);
936  }
937 
944  virtual void DataSent (uint32_t size, SocketWho who)
945  {
946  NS_UNUSED (size);
947  NS_UNUSED (who);
948  }
949 
953  virtual void FinalChecks ()
954  {
955  }
956 
962  {
963  return m_propagationDelay;
964  }
965 
971  {
972  return m_startTime;
973  }
974 
979  uint32_t GetMtu () const
980  {
981  return m_mtu;
982  }
983 
988  uint32_t GetPktSize () const
989  {
990  return m_pktSize;
991  }
992 
997  uint32_t GetPktCount () const
998  {
999  return m_pktCount;
1000  }
1001 
1008  {
1009  return m_interPacketInterval;
1010  }
1011 
1014 
1015 private:
1016  // Member variables, accessible through getters
1017  // giving write access to subclass can be dangerous
1019 
1021  uint32_t m_mtu;
1022 
1023  uint32_t m_pktSize;
1024  uint32_t m_pktCount;
1026 
1029 
1030 private:
1031  // De-multiplexing callbacks.
1032 
1037  void NormalCloseCb (Ptr<Socket> socket);
1042  void ErrorCloseCb (Ptr<Socket> socket);
1048  void QueueDropCb (std::string context, Ptr<const Packet> p);
1054  void PhyDropCb (std::string context, Ptr<const Packet> p);
1061  void RcvAckCb (Ptr<const Packet> p, const TcpHeader& h,
1069  void ProcessedAckCb (Ptr<const Packet> p, const TcpHeader& h,
1077  void TxPacketCb (const Ptr<const Packet> p, const TcpHeader& h,
1078  const Ptr<const TcpSocketBase> tcp);
1085  void RxPacketCb (const Ptr<const Packet> p, const TcpHeader& h,
1086  const Ptr<const TcpSocketBase> tcp);
1092  void RtoExpiredCb (const Ptr<const TcpSocketState> tcb,
1093  const Ptr<const TcpSocketBase> tcp);
1102  uint32_t sz, bool isRetransmission);
1103 
1110  const Ptr<const TcpSocketBase> tcp);
1111 
1118  const Ptr<const TcpSocketBase> tcp);
1119 
1125  void DataSentCb (Ptr<Socket> socket, uint32_t size);
1130  void ForkCb (Ptr<TcpSocketMsgBase> tcp);
1136  void HandleAccept (Ptr<Socket> socket, const Address& from);
1137 
1139 };
1140 
1150 static inline TcpSocketState::TcpCongState_t
1152 {
1153  return tcb->m_congState.Get ();
1154 }
1155 
1156 } // namespace ns3
1157 
1158 #endif // TCPGENERALTEST_H
1159 
virtual void ProcessedAck(const Ptr< const TcpSocketState > tcb, const TcpHeader &h, SocketWho who)
Processed ack.
void TxPacketCb(const Ptr< const Packet > p, const TcpHeader &h, const Ptr< const TcpSocketBase > tcp)
Tx packet Callback.
virtual void Rx(const Ptr< const Packet > p, const TcpHeader &h, SocketWho who)
Packet received from IP layer.
uint32_t GetReTxThreshold(SocketWho who)
Get the retransmission threshold.
virtual void RtoTrace(Time oldValue, Time newValue)
RTO changes.
Simulation virtual time values and global simulation resolution.
Definition: nstime.h:102
an Inet address class
Smart pointer class similar to boost::intrusive_ptr.
Definition: ptr.h:73
Ptr< TcpSocketMsgBase > m_senderSocket
Pointer to sender socket.
void SetSegmentSize(SocketWho who, uint32_t segmentSize)
Forcefully set the segment size.
Time m_propagationDelay
Propagation delay of the channel.
Callback template class.
Definition: callback.h:1176
RetrCb m_afterRetrCallback
After retransmission callback.
Class for inserting callbacks special points of the flow of TCP sockets.
virtual void DoTeardown(void)
Teardown the TCP test.
void SetProcessedAckCb(AckManagementCb cb)
Set the callback invoked when an ACK is received and processed (at the end of the processing) ...
AckManagementCb m_rcvAckCb
Receive ACK callback.
Ptr< TcpSocketMsgBase > GetSenderSocket()
Get the pointer to a previously created sender socket.
virtual Ptr< ErrorModel > CreateReceiverErrorModel()
Create and return the error model to install in the receiver node.
uint32_t GetRWnd(SocketWho who)
Get the rWnd of the selected socket.
void SetCongestionControl(TypeId congControl)
Congestion control of the sender socket.
void SetRecoveryAlgorithm(TypeId reccovery)
recovery algorithm of the sender socket
virtual void PhyDrop(SocketWho who)
Link drop.
virtual void DataSent(uint32_t size, SocketWho who)
Notifying application for sent data.
void DoConnect()
Scheduled at 0.0, SENDER starts the connection to RECEIVER.
virtual void ErrorClose(SocketWho who)
Socket closed with an error.
Callback< void, Ptr< const TcpSocketState >, Ptr< const TcpSocketBase > > RetrCb
Callback for the packet retransmission management.
void SetBytesToAck(uint32_t bytes)
Set the bytes to be ACKed.
virtual void FinalChecks()
Performs the (eventual) final checks through test asserts.
void SetAppPktSize(uint32_t pktSize)
Set app packet size.
void ErrorCloseCb(Ptr< Socket > socket)
Error Close Callback.
#define NS_UNUSED(x)
Mark a local variable as unused.
Definition: unused.h:36
static TcpSocketState::TcpCongState_t GetCongStateFrom(Ptr< const TcpSocketState > tcb)
Convenience function to retrieve the ACK state from a TCB.
virtual void Tx(const Ptr< const Packet > p, const TcpHeader &h, SocketWho who)
Packet transmitted down to IP layer.
void SetTransmitStart(Time startTime)
Set the initial time at which the application sends the first data packet.
void ForkCb(Ptr< TcpSocketMsgBase > tcp)
Fork Callback.
Time GetMinRto(SocketWho who)
Get the minimum RTO attribute.
virtual void SsThreshTrace(uint32_t oldValue, uint32_t newValue)
Slow start threshold changes.
encapsulates test code
Definition: test.h:1155
virtual void ConfigureProperties(void)
Change the configuration of the socket properties.
uint32_t GetDelAckCount(SocketWho who)
Get the number of delayed ack (if present)
virtual void CWndInflTrace(uint32_t oldValue, uint32_t newValue)
Tracks the inflated congestion window changes.
Time GetPropagationDelay() const
Get the channel Propagation Delay.
virtual void ReceivedAck(Ptr< Packet > packet, const TcpHeader &tcpHeader)
Received an ACK packet.
void SetAfterRetransmitCb(RetrCb cb)
Set the callback invoked after the processing of a retransmit timeout.
virtual Ptr< ErrorModel > CreateSenderErrorModel()
Create and return the error model to install in the sender node.
void UpdateRttHistoryCb(Ptr< const TcpSocketBase > tcp, const SequenceNumber32 &seq, uint32_t sz, bool isRetransmission)
Update RTT with new data.
a polymophic address class
Definition: address.h:90
Time GetStartTime() const
Get the data start time.
SequenceNumber32 GetHighestTxMark(SocketWho who)
Get the highest tx mark of the node specified.
void SetUpdateRttHistoryCb(UpdateRttCallback cb)
Set the callback invoked when we update rtt history.
virtual Ptr< TcpSocketBase > Fork(void)
Call CopyObject<> to clone me.
void BeforeRetransmitCb(const Ptr< const TcpSocketState > tcb, const Ptr< const TcpSocketBase > tcp)
Invoked before a retransmit event.
virtual void SendEmptyPacket(uint8_t flags)
Send a empty packet that carries a flag, e.g., ACK.
Rate Sample structure.
Definition: tcp-rate-ops.h:131
TypeId m_recoveryTypeId
Recovery.
void SetForkCb(Callback< void, Ptr< TcpSocketMsgBase > > cb)
Set the callback invoked after the forking.
TcpSocketMsgBase(const TcpSocketMsgBase &other)
Constructor.
TcpSocket::TcpStates_t GetTcpState(SocketWho who)
Get the state of the TCP state machine.
void SetMTU(uint32_t mtu)
MTU of the bottleneck link.
double startTime
virtual void NextTxSeqTrace(SequenceNumber32 oldValue, SequenceNumber32 newValue)
Next tx seq changes.
uint32_t GetInitialSsThresh(SocketWho who)
Get the initial slow start threshold.
static TypeId GetTypeId(void)
Get the type ID.
virtual void ReceivePacket(Ptr< Socket > socket)
Packet received.
uint32_t m_pktCount
Count of the application packet.
Time m_interPacketInterval
Time between sending application packet down to tcp socket.
virtual void RateSampleUpdatedTrace(const TcpRateLinux::TcpRateSample &sample)
Track the rate sample value of TcpRateLinux.
A base class for implementation of a stream socket using TCP.
void SetInitialSsThresh(SocketWho who, uint32_t initialSsThresh)
Forcefully set the initial ssth.
Ptr< TcpSocketState > GetTcb(SocketWho who)
Get the TCB from selected socket.
void DataSentCb(Ptr< Socket > socket, uint32_t size)
Data sent Callback.
virtual Ptr< SimpleChannel > CreateChannel()
Create and return the channel installed between the two socket.
virtual void RcvAck(const Ptr< const TcpSocketState > tcb, const TcpHeader &h, SocketWho who)
Received ack.
TcpCongState_t
Definition of the Congestion state machine.
void ProcessedAckCb(Ptr< const Packet > p, const TcpHeader &h, Ptr< const TcpSocketBase > tcp)
ACK processed Callback.
virtual Ptr< TcpSocketMsgBase > CreateSocket(Ptr< Node > node, TypeId socketType, TypeId congControl)
Create a socket.
uint32_t GetPktSize() const
Get the application packet size.
void SetEcn(SocketWho who, TcpSocketBase::EcnMode_t ecnMode)
Forcefully set the ecn mode on.
virtual void UpdateRttHistory(const SequenceNumber32 &seq, uint32_t sz, bool isRetransmission)
Update the RTT history, when we send TCP segments.
static TypeId GetTypeId(void)
Get the type ID.
AckManagementCb m_processedAckCb
Processed ACK callback.
Ptr< TcpSocketMsgBase > m_receiverSocket
Pointer to receiver socket.
Every class exported by the ns3 library is enclosed in the ns3 namespace.
Time GetClockGranularity(SocketWho who)
Get the clock granularity attribute.
uint32_t GetSegSize(SocketWho who)
Get the segment size of the node specified.
virtual void QueueDrop(SocketWho who)
Drop on the queue.
TracedValue< TcpCongState_t > m_congState
State in the Congestion state machine.
Header for the Transmission Control Protocol.
Definition: tcp-header.h:44
uint32_t GetDupAckCount(SocketWho who)
Get the number of dupack received.
void HandleAccept(Ptr< Socket > socket, const Address &from)
Handle an accept connection.
void NormalCloseCb(Ptr< Socket > socket)
Normal Close Callback.
void SetAppPktCount(uint32_t pktCount)
Set app packet count.
void SetAppPktInterval(Time pktInterval)
Interval between app-generated packet.
EventId GetPersistentEvent(SocketWho who)
Get the persistent event of the selected socket.
uint32_t GetPktCount() const
Get the number of application packets.
TcpGeneralTest(const std::string &desc)
TcpGeneralTest constructor.
TcpSocketSmallAcks(const TcpSocketSmallAcks &other)
Constructor.
void SetRcvBufSize(SocketWho who, uint32_t size)
Forcefully set a defined size for rx buffer.
virtual Ptr< TcpSocketMsgBase > CreateReceiverSocket(Ptr< Node > node)
Create and install the socket to install on the receiver.
virtual void ReTxTimeout(void)
An RTO event happened.
Time GetDelAckTimeout(SocketWho who)
Get the timeout of delayed ack (if present)
virtual void RateUpdatedTrace(const TcpRateLinux::TcpRateConnection &rate)
Track the rate value of TcpRateLinux.
virtual void CongStateTrace(const TcpSocketState::TcpCongState_t oldValue, const TcpSocketState::TcpCongState_t newValue)
State on Ack state machine changes.
virtual void ConfigureEnvironment(void)
Change the configuration of the environment.
Information about the connection rate.
Definition: tcp-rate-ops.h:160
virtual void CompleteFork(Ptr< Packet > p, const TcpHeader &tcpHeader, const Address &fromAddress, const Address &toAddress)
Complete a connection by forking the socket.
SocketWho
Used as parameter of methods, specifies on what node the caller is interested (e.g.
UpdateRttCallback m_updateRttCb
Update RTT callback.
TcpStates_t
Names of the 11 TCP states.
Definition: tcp-socket.h:65
virtual Ptr< TcpSocketMsgBase > CreateSenderSocket(Ptr< Node > node)
Create and install the socket to install on the sender.
virtual void NormalClose(SocketWho who)
Socket closed normally.
General infrastructure for TCP testing.
uint32_t GetMtu() const
Get the MTU of the environment.
An identifier for simulation events.
Definition: event-id.h:53
void PhyDropCb(std::string context, Ptr< const Packet > p)
Drop at Phy layer Callback.
Ptr< TcpSocketMsgBase > GetReceiverSocket()
Get the pointer to a previously created receiver socket.
T Get(void) const
Get the underlying value.
Definition: traced-value.h:218
uint32_t GetInitialCwnd(SocketWho who)
Get the initial congestion window.
void AfterRetransmitCb(const Ptr< const TcpSocketState > tcb, const Ptr< const TcpSocketBase > tcp)
Invoked after a retransmit event.
void SetInitialCwnd(SocketWho who, uint32_t initialCwnd)
Forcefully set the initial cwnd.
virtual void BytesInFlightTrace(uint32_t oldValue, uint32_t newValue)
Bytes in flight changes.
void RtoExpiredCb(const Ptr< const TcpSocketState > tcb, const Ptr< const TcpSocketBase > tcp)
RTO expired Callback.
void SendPacket(Ptr< Socket > socket, uint32_t pktSize, uint32_t pktCount, Time pktInterval)
Send packets to other endpoint.
uint32_t m_mtu
MTU of the environment.
Callback< void, Ptr< TcpSocketMsgBase > > m_forkCb
Fork callback.
virtual void UpdatedRttHistory(const SequenceNumber32 &seq, uint32_t sz, bool isRetransmission, SocketWho who)
Updated the Rtt history.
virtual void HighestTxSeqTrace(SequenceNumber32 oldValue, SequenceNumber32 newValue)
Highest tx seq changes.
RetrCb m_beforeRetrCallback
Before retransmission callback.
Time GetPktInterval() const
Get the interval to wait for each packet sent down from application to TCP.
A TCP socket which sends ACKs smaller than the segment received.
Ptr< TcpSocketBase > Fork(void)
Call CopyObject<> to clone me.
virtual void RttTrace(Time oldTime, Time newTime)
Rtt changes.
Ptr< TcpRxBuffer > GetRxBuffer(SocketWho who)
Get the Rx buffer from selected socket.
void QueueDropCb(std::string context, Ptr< const Packet > p)
Queue Drop Callback.
uint32_t m_bytesLeftToBeAcked
Number of bytes to be ACKed left.
Time GetPersistentTimeout(SocketWho who)
Get the persistent timeout of the selected socket.
Ptr< TcpTxBuffer > GetTxBuffer(SocketWho who)
Get the Tx buffer from selected socket.
SequenceNumber32 m_lastAckedSeq
Last sequence number ACKed.
void SetRcvAckCb(AckManagementCb cb)
Set the callback invoked when an ACK is received (at the beginning of the processing) ...
InetSocketAddress m_remoteAddr
Remote peer address.
void RxPacketCb(const Ptr< const Packet > p, const TcpHeader &h, const Ptr< const TcpSocketBase > tcp)
Rx packet Callback.
Time GetConnTimeout(SocketWho who)
Get the retransmission time for the SYN segments.
virtual void BeforeRTOExpired(const Ptr< const TcpSocketState > tcb, SocketWho who)
Rto has expired.
void SetBeforeRetransmitCb(RetrCb cb)
Set the callback invoked before the processing of a retransmit timeout.
uint32_t m_bytesToAck
Number of bytes to be ACKed.
Callback< void, Ptr< const Packet >, const TcpHeader &, Ptr< const TcpSocketBase > > AckManagementCb
Callback for the ACK management.
Ptr< RttEstimator > GetRttEstimator(SocketWho who)
Get the Rtt estimator of the socket.
a unique identifier for an interface.
Definition: type-id.h:58
virtual void CWndTrace(uint32_t oldValue, uint32_t newValue)
Tracks the congestion window changes.
virtual void DoRun(void)
Execute the tcp test.
uint32_t m_pktSize
Size of the application packet.
void RcvAckCb(Ptr< const Packet > p, const TcpHeader &h, Ptr< const TcpSocketBase > tcp)
Receive ACK Callback.
Time m_startTime
Data transmission time.
void SetPropagationDelay(Time propDelay)
Propagation delay of the bottleneck link.
virtual void AfterRTOExpired(const Ptr< const TcpSocketState > tcb, SocketWho who)
Rto has expired.
TypeId m_congControlTypeId
Congestion control.
Time GetRto(SocketWho who)
Get the retransmission time.
Callback< void, Ptr< const TcpSocketBase >, const SequenceNumber32 &, uint32_t, bool > UpdateRttCallback
Callback for the RTT update management.