inet::tcp::DumbTCP Class Reference

A very-very basic TCPAlgorithm implementation, with hardcoded retransmission timeout and no other sophistication. More...

#include <DumbTCP.h>

Inheritance diagram for inet::tcp::DumbTCP:

Public Member Functions
	DumbTCP ()
	Ctor. More...
virtual	~DumbTCP ()
virtual void	initialize () override
	Should be redefined to initialize the object: create timers, etc. More...
virtual void	established (bool active) override
	Called when the connection is going to ESTABLISHED from SYN_SENT or SYN_RCVD. More...
virtual void	connectionClosed () override
	Called when the connection closes, it should cancel all running timers. More...
virtual void	processTimer (cMessage *timer, TCPEventCode &event) override
	Place to process timers specific to this TCPAlgorithm class. More...
virtual void	sendCommandInvoked () override
	Called after user sent TCP_C_SEND command to us. More...
virtual void	receivedOutOfOrderSegment () override
	Called after receiving data which are in the window, but not at its left edge (seq != rcv_nxt). More...
virtual void	receiveSeqChanged () override
	Called after rcv_nxt got advanced, either because we received in-sequence data ("text" in RFC 793 lingo) or a FIN. More...
virtual void	receivedDataAck (uint32 firstSeqAcked) override
	Called after we received an ACK which acked some data (that is, we could advance snd_una). More...
virtual void	receivedDuplicateAck () override
	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). More...
virtual void	receivedAckForDataNotYetSent (uint32 seq) override
	Called after we received an ACK for data not yet sent. More...
virtual void	ackSent () override
	Called after we sent an ACK. More...
virtual void	dataSent (uint32 fromseq) override
	Called after we sent data. More...
virtual void	segmentRetransmitted (uint32 fromseq, uint32 toseq) override
	Called after we retransmitted segment. More...
virtual void	restartRexmitTimer () override
	Restart REXMIT timer. More...
virtual void	rttMeasurementCompleteUsingTS (uint32 echoedTS) override
	Converting uint32 echoedTS to simtime_t and calling rttMeasurementComplete() to update state vars with new measured RTT value. More...
Public Member Functions inherited from inet::tcp::TCPAlgorithm
	TCPAlgorithm ()
	Ctor. More...
virtual	~TCPAlgorithm ()
	Virtual dtor. More...
void	setConnection (TCPConnection *_conn)
	Assign this object to a TCPConnection. More...
TCPStateVariables *	getStateVariables ()
	Creates and returns the TCP state variables. More...

Protected Member Functions
virtual TCPStateVariables *	createStateVariables () override
	Creates and returns a DumbTCPStateVariables object. More...

Protected Attributes
DumbTCPStateVariables *&	state
cMessage *	rexmitTimer
Protected Attributes inherited from inet::tcp::TCPAlgorithm
TCPConnection *	conn
TCPStateVariables *	state

Detailed Description

A very-very basic TCPAlgorithm implementation, with hardcoded retransmission timeout and no other sophistication.

It can be used to demonstrate what happened if there was no adaptive timeout calculation, delayed acks, silly window avoidance, congestion control, etc.

Constructor & Destructor Documentation

inet::tcp::DumbTCP::DumbTCP

(

)

Ctor.

                 : TCPAlgorithm(),
    state((DumbTCPStateVariables *&)TCPAlgorithm::state)
{
    rexmitTimer = nullptr;
}

inet::tcp::DumbTCP::~DumbTCP ( )

virtual

{
    // cancel and delete timers
    if (rexmitTimer)
        delete conn->getTcpMain()->cancelEvent(rexmitTimer);
}

Member Function Documentation

void inet::tcp::DumbTCP::ackSent ( )

overridevirtual

Called after we sent an ACK.

This hook can be used to cancel the delayed-ACK timer.

Implements inet::tcp::TCPAlgorithm.

{
}

void inet::tcp::DumbTCP::connectionClosed ( )

overridevirtual

Called when the connection closes, it should cancel all running timers.

Implements inet::tcp::TCPAlgorithm.

{
    conn->getTcpMain()->cancelEvent(rexmitTimer);
}

virtual TCPStateVariables* inet::tcp::DumbTCP::createStateVariables ( )

inlineoverrideprotectedvirtual

Creates and returns a DumbTCPStateVariables object.

Implements inet::tcp::TCPAlgorithm.

    {
        return new DumbTCPStateVariables();
    }

void inet::tcp::DumbTCP::dataSent ( uint32  fromseq )

overridevirtual

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 inet::tcp::TCPAlgorithm.

{
    if (rexmitTimer->isScheduled())
        conn->getTcpMain()->cancelEvent(rexmitTimer);

    conn->scheduleTimeout(rexmitTimer, REXMIT_TIMEOUT);
}

void inet::tcp::DumbTCP::established ( bool  active )

overridevirtual

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 inet::tcp::TCPAlgorithm.

{
    if (active) {
        // finish connection setup with ACK (possibly piggybacked on data)
        EV_INFO << "Completing connection setup by sending ACK (possibly piggybacked on data)\n";

        if (!conn->sendData(false, 65535))
            conn->sendAck();
    }
}

void inet::tcp::DumbTCP::initialize ( )

overridevirtual

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 inet::tcp::TCPAlgorithm.

{
    TCPAlgorithm::initialize();

    rexmitTimer = new cMessage("REXMIT");
    rexmitTimer->setContextPointer(conn);
}

void inet::tcp::DumbTCP::processTimer ( cMessage *  timer, TCPEventCode &  event  )

overridevirtual

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 inet::tcp::TCPAlgorithm.

{
    if (timer != rexmitTimer)
        throw cRuntimeError(timer, "unrecognized timer");

    conn->retransmitData();
    conn->scheduleTimeout(rexmitTimer, REXMIT_TIMEOUT);
}

void inet::tcp::DumbTCP::receivedAckForDataNotYetSent ( uint32  seq )

overridevirtual

Called after we received an ACK for data not yet sent.

According to RFC 793 this function should send an ACK.

Implements inet::tcp::TCPAlgorithm.

{
    EV_INFO << "ACK acks something not yet sent, sending immediate ACK\n";
    conn->sendAck();
}

void inet::tcp::DumbTCP::receivedDataAck ( uint32  firstSeqAcked )

overridevirtual

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 inet::tcp::TCPAlgorithm.

{
    // ack may have freed up some room in the window, try sending.
    // small segments also OK (Nagle off)
    conn->sendData(false, 65535);
}

void inet::tcp::DumbTCP::receivedDuplicateAck ( )

overridevirtual

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. dupacks == 1 on first duplicate ACK.)

Implements inet::tcp::TCPAlgorithm.

{
    EV_INFO << "Duplicate ACK #" << state->dupacks << "\n";
}

void inet::tcp::DumbTCP::receivedOutOfOrderSegment ( )

overridevirtual

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. RFC 1122 and RFC 2001 recommend sending an immediate ACK here (Fast Retransmit relies on that).

Implements inet::tcp::TCPAlgorithm.

{
    EV_INFO << "Out-of-order segment, sending immediate ACK\n";
    conn->sendAck();
}

void inet::tcp::DumbTCP::receiveSeqChanged ( )

overridevirtual

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 inet::tcp::TCPAlgorithm.

{
    // new data received, ACK immediately (more sophisticated algs should
    // wait a little to see if piggybacking is possible)
    EV_INFO << "rcv_nxt changed to " << state->rcv_nxt << ", sending immediate ACK\n";
    conn->sendAck();
}

void inet::tcp::DumbTCP::restartRexmitTimer ( )

overridevirtual

Restart REXMIT timer.

Implements inet::tcp::TCPAlgorithm.

{
}

void inet::tcp::DumbTCP::rttMeasurementCompleteUsingTS ( uint32  echoedTS )

overridevirtual

Converting uint32 echoedTS to simtime_t and calling rttMeasurementComplete() to update state vars with new measured RTT value.

Implements inet::tcp::TCPAlgorithm.

{
}

void inet::tcp::DumbTCP::segmentRetransmitted ( uint32  fromseq, uint32  toseq  )

overridevirtual

Called after we retransmitted segment.

The argument fromseq is the seqno of the first byte sent. The argument toseq is the seqno of the last byte sent+1.

Implements inet::tcp::TCPAlgorithm.

{
}

void inet::tcp::DumbTCP::sendCommandInvoked ( )

overridevirtual

Called after user sent TCP_C_SEND command to us.

Implements inet::tcp::TCPAlgorithm.

{
    // start sending
    conn->sendData(false, 65535);
}

Member Data Documentation

cMessage* inet::tcp::DumbTCP::rexmitTimer

protected

Referenced by connectionClosed(), dataSent(), DumbTCP(), initialize(), processTimer(), and ~DumbTCP().

DumbTCPStateVariables*& inet::tcp::DumbTCP::state

protected

Referenced by receivedDuplicateAck(), and receiveSeqChanged().

---

The documentation for this class was generated from the following files:

• DumbTCP.h
• DumbTCP.cc