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 SetDelAckMaxCount (SocketWho who, uint32_t count);
601 
608  void SetUseEcn (SocketWho who, TcpSocketState::UseEcn_t useEcn);
609 
616  void SetPacingStatus (SocketWho who, bool pacing);
617 
624  void SetPaceInitialWindow (SocketWho who, bool paceWindow);
625 
632  void SetInitialSsThresh (SocketWho who, uint32_t initialSsThresh);
633 
641  void SetAppPktSize (uint32_t pktSize) { m_pktSize = pktSize; }
642 
650  void SetAppPktCount (uint32_t pktCount) { m_pktCount = pktCount; }
651 
657  void SetAppPktInterval (Time pktInterval) { m_interPacketInterval = pktInterval; }
658 
664  void SetPropagationDelay (Time propDelay) { m_propagationDelay = propDelay; }
665 
672 
678  void SetCongestionControl (TypeId congControl) { m_congControlTypeId = congControl; }
679 
685  void SetRecoveryAlgorithm (TypeId recovery) { m_recoveryTypeId = recovery; }
686 
692  void SetMTU (uint32_t mtu) { m_mtu = mtu; }
693 
699  virtual void CongStateTrace (const TcpSocketState::TcpCongState_t oldValue,
700  const TcpSocketState::TcpCongState_t newValue)
701  {
702  NS_UNUSED (oldValue);
703  NS_UNUSED (newValue);
704  }
705 
712  virtual void CWndTrace (uint32_t oldValue, uint32_t newValue)
713  {
714  NS_UNUSED (oldValue);
715  NS_UNUSED (newValue);
716  }
717 
724  virtual void CWndInflTrace (uint32_t oldValue, uint32_t newValue)
725  {
726  NS_UNUSED (oldValue);
727  NS_UNUSED (newValue);
728  }
729 
738  virtual void RttTrace (Time oldTime, Time newTime)
739  {
740  NS_UNUSED (oldTime);
741  NS_UNUSED (newTime);
742  }
743 
752  virtual void SsThreshTrace (uint32_t oldValue, uint32_t newValue)
753  {
754  NS_UNUSED (oldValue);
755  NS_UNUSED (newValue);
756  }
757 
766  virtual void BytesInFlightTrace (uint32_t oldValue, uint32_t newValue)
767  {
768  NS_UNUSED (oldValue);
769  NS_UNUSED (newValue);
770  }
771 
780  virtual void RtoTrace (Time oldValue, Time newValue)
781  {
782  NS_UNUSED (oldValue);
783  NS_UNUSED (newValue);
784  }
785 
794  virtual void NextTxSeqTrace (SequenceNumber32 oldValue, SequenceNumber32 newValue)
795  {
796  NS_UNUSED (oldValue);
797  NS_UNUSED (newValue);
798  }
799 
808  virtual void HighestTxSeqTrace (SequenceNumber32 oldValue, SequenceNumber32 newValue)
809  {
810  NS_UNUSED (oldValue);
811  NS_UNUSED (newValue);
812  }
813 
819  {
820  NS_UNUSED (rate);
821  }
822 
828  {
829  NS_UNUSED (sample);
830  }
831 
836  virtual void NormalClose (SocketWho who)
837  {
838  NS_UNUSED (who);
839  }
840 
846  virtual void ErrorClose (SocketWho who)
847  {
849  NS_UNUSED (who);
850  }
851 
856  virtual void QueueDrop (SocketWho who)
857  {
858  NS_UNUSED (who);
859  }
860 
865  virtual void PhyDrop (SocketWho who)
866  {
867  NS_UNUSED (who);
868  }
869 
879  virtual void RcvAck (const Ptr<const TcpSocketState> tcb,
880  const TcpHeader& h, SocketWho who)
881  {
882  NS_UNUSED (tcb);
883  NS_UNUSED (h);
884  NS_UNUSED (who);
885  }
886 
896  virtual void ProcessedAck (const Ptr<const TcpSocketState> tcb,
897  const TcpHeader& h, SocketWho who)
898  {
899  NS_UNUSED (tcb);
900  NS_UNUSED (h);
901  NS_UNUSED (who);
902  }
903 
911  virtual void Tx (const Ptr<const Packet> p, const TcpHeader&h, SocketWho who);
912 
920  virtual void Rx (const Ptr<const Packet> p, const TcpHeader&h, SocketWho who);
921 
929  {
930  NS_UNUSED (tcb);
931  NS_UNUSED (who);
932  }
933 
941  {
942  NS_UNUSED (tcb);
943  NS_UNUSED (who);
944  }
945 
953  virtual void UpdatedRttHistory (const SequenceNumber32 & seq, uint32_t sz,
954  bool isRetransmission, SocketWho who)
955  {
956  NS_UNUSED (seq);
957  NS_UNUSED (sz);
958  NS_UNUSED (isRetransmission);
959  NS_UNUSED (who);
960  }
961 
968  virtual void DataSent (uint32_t size, SocketWho who)
969  {
970  NS_UNUSED (size);
971  NS_UNUSED (who);
972  }
973 
977  virtual void FinalChecks ()
978  {
979  }
980 
986  {
987  return m_propagationDelay;
988  }
989 
995  {
996  return m_startTime;
997  }
998 
1003  uint32_t GetMtu () const
1004  {
1005  return m_mtu;
1006  }
1007 
1012  uint32_t GetPktSize () const
1013  {
1014  return m_pktSize;
1015  }
1016 
1021  uint32_t GetPktCount () const
1022  {
1023  return m_pktCount;
1024  }
1025 
1032  {
1033  return m_interPacketInterval;
1034  }
1035 
1038 
1039 private:
1040  // Member variables, accessible through getters
1041  // giving write access to subclass can be dangerous
1043 
1045  uint32_t m_mtu;
1046 
1047  uint32_t m_pktSize;
1048  uint32_t m_pktCount;
1050 
1053 
1054 private:
1055  // De-multiplexing callbacks.
1056 
1061  void NormalCloseCb (Ptr<Socket> socket);
1066  void ErrorCloseCb (Ptr<Socket> socket);
1072  void QueueDropCb (std::string context, Ptr<const Packet> p);
1078  void PhyDropCb (std::string context, Ptr<const Packet> p);
1085  void RcvAckCb (Ptr<const Packet> p, const TcpHeader& h,
1093  void ProcessedAckCb (Ptr<const Packet> p, const TcpHeader& h,
1101  void TxPacketCb (const Ptr<const Packet> p, const TcpHeader& h,
1102  const Ptr<const TcpSocketBase> tcp);
1109  void RxPacketCb (const Ptr<const Packet> p, const TcpHeader& h,
1110  const Ptr<const TcpSocketBase> tcp);
1116  void RtoExpiredCb (const Ptr<const TcpSocketState> tcb,
1117  const Ptr<const TcpSocketBase> tcp);
1126  uint32_t sz, bool isRetransmission);
1127 
1134  const Ptr<const TcpSocketBase> tcp);
1135 
1142  const Ptr<const TcpSocketBase> tcp);
1143 
1149  void DataSentCb (Ptr<Socket> socket, uint32_t size);
1154  void ForkCb (Ptr<TcpSocketMsgBase> tcp);
1160  void HandleAccept (Ptr<Socket> socket, const Address& from);
1161 
1163 };
1164 
1174 static inline TcpSocketState::TcpCongState_t
1176 {
1177  return tcb->m_congState.Get ();
1178 }
1179 
1180 } // namespace ns3
1181 
1182 #endif // TCPGENERALTEST_H
1183 
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:103
an Inet address class
UseEcn_t
Parameter value related to ECN enable/disable functionality similar to sysctl for tcp_ecn...
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:1278
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.
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.
uint32_t segmentSize
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.
void SetPaceInitialWindow(SocketWho who, bool paceWindow)
Enable or disable pacing of the initial window.
encapsulates test code
Definition: test.h:1153
void SetRecoveryAlgorithm(TypeId recovery)
recovery algorithm of the sender socket
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:133
TypeId m_recoveryTypeId
Recovery.
void SetDelAckMaxCount(SocketWho who, uint32_t count)
Forcefully set the delayed acknowledgement count.
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.
void SetPacingStatus(SocketWho who, bool pacing)
Enable or disable pacing in the TCP socket.
A base class for implementation of a stream socket using TCP.
void SetInitialSsThresh(SocketWho who, uint32_t initialSsThresh)
Forcefully set the initial ssthresh.
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.
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:162
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:229
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 SetUseEcn(SocketWho who, TcpSocketState::UseEcn_t useEcn)
Forcefully set the ECN mode of use.
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 pktSize
packet size used for the simulation (in bytes)
Definition: wifi-bianchi.cc:83
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.