#include <DumbTCP.h>
Inheritance diagram for DumbTCP:
Public Member Functions | |
DumbTCP () | |
virtual | ~DumbTCP () |
virtual void | initialize () |
virtual void | established (bool active) |
virtual void | connectionClosed () |
virtual void | processTimer (cMessage *timer, TCPEventCode &event) |
virtual void | sendCommandInvoked () |
virtual void | receivedOutOfOrderSegment () |
virtual void | receiveSeqChanged () |
virtual void | receivedDataAck (uint32 firstSeqAcked) |
virtual void | receivedDuplicateAck () |
virtual void | receivedAckForDataNotYetSent (uint32 seq) |
virtual void | ackSent () |
virtual void | dataSent (uint32 fromseq) |
Protected Member Functions | |
virtual TCPStateVariables * | createStateVariables () |
Protected Attributes | |
DumbTCPStateVariables *& | state |
cMessage * | rexmitTimer |
|
Ctor 00029 : TCPAlgorithm(), 00030 state((DumbTCPStateVariables *&)TCPAlgorithm::state) 00031 { 00032 rexmitTimer = NULL; 00033 }
|
|
00036 { 00037 // cancel and delete timers 00038 if (rexmitTimer) 00039 delete conn->getTcpMain()->cancelEvent(rexmitTimer); 00040 }
|
|
Called after we sent an ACK. This hook can be used to cancel the delayed-ACK timer. Implements TCPAlgorithm. 00113 { 00114 }
|
|
Called when the connection closes, it should cancel all running timers. Implements TCPAlgorithm. 00061 { 00062 conn->getTcpMain()->cancelEvent(rexmitTimer); 00063 }
|
|
Creates and returns a DumbTCPStateVariables object. Implements TCPAlgorithm. 00052 { 00053 return new DumbTCPStateVariables(); 00054 }
|
|
Called after we sent data. This hook can be used to schedule the retransmission timer, to start round-trip time measurement, etc. The argument is the seqno of the first byte sent. Implements TCPAlgorithm. 00117 { 00118 if (rexmitTimer->isScheduled()) 00119 conn->getTcpMain()->cancelEvent(rexmitTimer); 00120 conn->scheduleTimeout(rexmitTimer, REXMIT_TIMEOUT); 00121 }
|
|
Called when the connection is going to ESTABLISHED from SYN_SENT or SYN_RCVD. This is a place to initialize some variables (e.g. set cwnd to the MSS learned during connection setup). If we are on the active side, here we also have to finish the 3-way connection setup procedure by sending an ACK, possibly piggybacked on data. Implements TCPAlgorithm. 00050 { 00051 if (active) 00052 { 00053 // finish connection setup with ACK (possibly piggybacked on data) 00054 tcpEV << "Completing connection setup by sending ACK (possibly piggybacked on data)\n"; 00055 if (!conn->sendData(false)) 00056 conn->sendAck(); 00057 } 00058 }
|
|
Should be redefined to initialize the object: create timers, etc. This method is necessary because the TCPConnection ptr is not available in the constructor yet. Reimplemented from TCPAlgorithm. 00043 { 00044 TCPAlgorithm::initialize(); 00045 00046 rexmitTimer = new cMessage("REXMIT"); 00047 }
|
|
Place to process timers specific to this TCPAlgorithm class. TCPConnection will invoke this method on any timer (self-message) it doesn't recognize (that is, any timer other than the 2MSL, CONN-ESTAB and FIN-WAIT-2 timers). Method may also change the event code (by default set to TCP_E_IGNORE) to cause the state transition of TCP FSM. Implements TCPAlgorithm. 00066 {
00067 if (timer!=rexmitTimer)
00068 throw new cException(timer, "unrecognized timer");
00069
00070 conn->retransmitData();
00071 conn->scheduleTimeout(rexmitTimer, REXMIT_TIMEOUT);
00072 }
|
|
Called after we received an ACK for data not yet sent. According to RFC 793 this function should send an ACK. Implements TCPAlgorithm. 00107 { 00108 tcpEV << "ACK acks something not yet sent, sending immediate ACK\n"; 00109 conn->sendAck(); 00110 }
|
|
Called after we received an ACK which acked some data (that is, we could advance snd_una). At this point the state variables (snd_una, snd_wnd) have already been updated. The argument firstSeqAcked is the previous snd_una value, that is, the number of bytes acked is (snd_una-firstSeqAcked). The dupack counter still reflects the old value (needed for Reno and NewReno); it'll be reset to 0 after this call returns. Implements TCPAlgorithm. 00095 { 00096 // ack may have freed up some room in the window, try sending. 00097 // small segments also OK (Nagle off) 00098 conn->sendData(false); 00099 }
|
|
Called after we received a duplicate ACK (that is: ackNo==snd_una, no data in segment, segment doesn't carry window update, and also, we have unacked data). The dupack counter got already updated when calling this method (i.e. dupack==1 on first duplicate ACK.) Implements TCPAlgorithm.
|
|
Called after receiving data which are in the window, but not at its left edge (seq!=rcv_nxt). This indicates that either segments got re-ordered in the way, or one segment was lost. RFC1122 and RFC2001 recommend sending an immediate ACK here (Fast Retransmit relies on that). Implements TCPAlgorithm. 00081 { 00082 tcpEV << "Out-of-order segment, sending immediate ACK\n"; 00083 conn->sendAck(); 00084 }
|
|
Called after rcv_nxt got advanced, either because we received in-sequence data ("text" in RFC 793 lingo) or a FIN. At this point, rcv_nxt has already been updated. This method should take care to send or schedule an ACK some time. Implements TCPAlgorithm. 00087 { 00088 // new data received, ACK immediately (more sophisticated algs should 00089 // wait a little to see if piggybacking is possible) 00090 tcpEV << "rcv_nxt changed to " << state->rcv_nxt << ", sending immediate ACK\n"; 00091 conn->sendAck(); 00092 }
|
|
Called after user sent TCP_C_SEND command to us. Implements TCPAlgorithm.
|
|
|
|
Reimplemented from TCPAlgorithm. |