inet::tcp::TCPConnection Class Reference

Manages a TCP connection. More...

#include <TCPConnection.h>

Inheritance diagram for inet::tcp::TCPConnection:

Public Member Functions
virtual void	sendAck ()
	Utility: send ACK. More...
virtual bool	sendData (bool fullSegmentsOnly, uint32 congestionWindow)
	Utility: Send data from sendQueue, at most congestionWindow. More...
virtual bool	sendProbe ()
	Utility: sends 1 bytes as "probe", called by the "persist" mechanism. More...
virtual void	retransmitOneSegment (bool called_at_rto)
	Utility: retransmit one segment from snd_una. More...
virtual void	retransmitData ()
	Utility: retransmit all from snd_una to snd_max. More...
virtual void	sendRst (uint32 seqNo)
	Utility: sends RST. More...
virtual void	sendRst (uint32 seq, L3Address src, L3Address dest, int srcPort, int destPort)
	Utility: sends RST; does not use connection state. More...
virtual void	sendRstAck (uint32 seq, uint32 ack, L3Address src, L3Address dest, int srcPort, int destPort)
	Utility: sends RST+ACK; does not use connection state. More...
virtual void	sendFin ()
	Utility: sends FIN. More...
virtual void	sendSegment (uint32 bytes)
	Utility: sends one segment of 'bytes' bytes from snd_nxt, and advances snd_nxt. More...
virtual void	sendToIP (TCPSegment *tcpseg)
	Utility: adds control info to segment and sends it to IP. More...
virtual TCPSegment *	createTCPSegment (const char *name)
	Utility: This factory method gets invoked throughout the TCP model to create a TCPSegment. More...
virtual void	startSynRexmitTimer ()
	Utility: start SYN-REXMIT timer. More...
virtual void	signalConnectionTimeout ()
	Utility: signal to user that connection timed out. More...
void	scheduleTimeout (cMessage *msg, simtime_t timeout)
	Utility: start a timer. More...
virtual void	printConnBrief () const
	Utility: prints local/remote addr/port and app gate index/connId. More...
virtual void	updateRcvQueueVars ()
	Utility: update receiver queue related variables and statistics - called before setting rcv_wnd. More...
virtual bool	hasEnoughSpaceForSegmentInReceiveQueue (TCPSegment *tcpseg)
	Utility: returns true when receive queue has enough space for store the tcpseg. More...
virtual unsigned short	updateRcvWnd ()
	Utility: update receive window (rcv_wnd), and calculate scaled value if window scaling enabled. More...
virtual void	updateWndInfo (TCPSegment *tcpseg, bool doAlways=false)
	Utility: update window information (snd_wnd, snd_wl1, snd_wl2) More...
	TCPConnection (TCP *mod, int appGateIndex, int connId)
	The "normal" constructor. More...
	TCPConnection ()
	Note: this default ctor is NOT used to create live connections, only temporary ones so that TCPMain can invoke their segmentArrivalWhileClosed(). More...
virtual	~TCPConnection ()
	Destructor. More...
int	getLocalPort () const
L3Address	getLocalAddress () const
int	getRemotePort () const
L3Address	getRemoteAddress () const
virtual void	segmentArrivalWhileClosed (TCPSegment *tcpseg, L3Address src, L3Address dest)
	This method gets invoked from TCP when a segment arrives which doesn't belong to an existing connection. More...
virtual bool	processTimer (cMessage *msg)
	Process self-messages (timers). More...
virtual bool	processTCPSegment (TCPSegment *tcpSeg, L3Address srcAddr, L3Address destAddr)
	Process incoming TCP segment. More...
virtual bool	processAppCommand (cMessage *msg)
	Process commands from the application. More...
virtual bool	isLost (uint32 seqNum)
	For SACK TCP. More...
virtual void	setPipe ()
	For SACK TCP. More...
virtual bool	nextSeg (uint32 &seqNum)
	For SACK TCP. More...
virtual void	sendDataDuringLossRecoveryPhase (uint32 congestionWindow)
	Utility: send data during Loss Recovery phase (if SACK is enabled). More...
virtual void	sendSegmentDuringLossRecoveryPhase (uint32 seqNum)
	Utility: send segment during Loss Recovery phase (if SACK is enabled). More...
virtual void	sendOneNewSegment (bool fullSegmentsOnly, uint32 congestionWindow)
	Utility: send one new segment from snd_max if allowed (RFC 3042). More...
virtual bool	isSendQueueEmpty ()
	Utility: checks if send queue is empty (no data to send). More...
Various getters
int	getFsmState () const
TCPStateVariables *	getState ()
TCPSendQueue *	getSendQueue ()
TCPSACKRexmitQueue *	getRexmitQueue ()
TCPReceiveQueue *	getReceiveQueue ()
TCPAlgorithm *	getTcpAlgorithm ()
TCP *	getTcpMain ()

Static Public Member Functions
static void	printSegmentBrief (TCPSegment *tcpseg)
	Utility: prints important header fields. More...
static const char *	stateName (int state)
	Utility: returns name of TCP_S_xxx constants. More...
static const char *	eventName (int event)
	Utility: returns name of TCP_E_xxx constants. More...
static const char *	indicationName (int code)
	Utility: returns name of TCP_I_xxx constants. More...
static const char *	optionName (int option)
	Utility: returns name of TCPOPTION_xxx constants. More...
static uint32	convertSimtimeToTS (simtime_t simtime)
	Utility: converts a given simtime to a timestamp (TS). More...
static simtime_t	convertTSToSimtime (uint32 timestamp)
	Utility: converts a given timestamp (TS) to a simtime. More...

Public Attributes
int	appGateIndex = -1
int	connId = -1
L3Address	localAddr
L3Address	remoteAddr
int	localPort = -1
int	remotePort = -1
TCPSACKRexmitQueue *	rexmitQueue = nullptr

Protected Member Functions
virtual TCPConnection *	cloneListeningConnection ()
	Utility: clone a listening connection. More...
virtual void	initConnection (TCPOpenCommand *openCmd)
	Utility: creates send/receive queues and tcpAlgorithm. More...
virtual void	configureStateVariables ()
	Utility: set snd_mss, rcv_wnd and sack in newly created state variables block. More...
virtual void	selectInitialSeqNum ()
	Utility: generates ISS and initializes corresponding state variables. More...
virtual bool	isSegmentAcceptable (TCPSegment *tcpseg) const
	Utility: check if segment is acceptable (all bytes are in receive window) More...
virtual void	sendSyn ()
	Utility: send SYN. More...
virtual void	sendSynAck ()
	Utility: send SYN+ACK. More...
virtual void	readHeaderOptions (TCPSegment *tcpseg)
	Utility: readHeaderOptions (Currently only EOL, NOP, MSS, WS, SACK_PERMITTED, SACK and TS are implemented) More...
virtual TCPSegment	writeHeaderOptions (TCPSegment *tcpseg)
	Utility: writeHeaderOptions (Currently only EOL, NOP, MSS, WS, SACK_PERMITTED, SACK and TS are implemented) More...
virtual TCPSegment	addSacks (TCPSegment *tcpseg)
	Utility: adds SACKs to segments header options field. More...
virtual uint32	getTSval (TCPSegment *tcpseg) const
	Utility: get TSval from segments TS header option. More...
virtual uint32	getTSecr (TCPSegment *tcpseg) const
	Utility: get TSecr from segments TS header option. More...
cMessage *	cancelEvent (cMessage *msg)
	Utility: cancel a timer. More...
virtual void	sendToApp (cMessage *msg)
	Utility: sends packet to application. More...
virtual void	sendIndicationToApp (int code, const int id=0)
	Utility: sends status indication (TCP_I_xxx) to application. More...
virtual void	sendEstabIndicationToApp ()
	Utility: sends TCP_I_ESTABLISHED indication with TCPConnectInfo to application. More...
FSM transitions: analysing events and executing state transitions
virtual TCPEventCode	preanalyseAppCommandEvent (int commandCode)
	Maps app command codes (msg kind of app command msgs) to TCP_E_xxx event codes. More...
virtual bool	performStateTransition (const TCPEventCode &event)
	Implemements the pure TCP state machine. More...
virtual void	stateEntered (int state, int oldState, TCPEventCode event)
	Perform cleanup necessary when entering a new state, e.g. More...
Processing app commands. Invoked from processAppCommand().
virtual void	process_OPEN_ACTIVE (TCPEventCode &event, TCPCommand *tcpCommand, cMessage *msg)
virtual void	process_OPEN_PASSIVE (TCPEventCode &event, TCPCommand *tcpCommand, cMessage *msg)
virtual void	process_SEND (TCPEventCode &event, TCPCommand *tcpCommand, cMessage *msg)
virtual void	process_CLOSE (TCPEventCode &event, TCPCommand *tcpCommand, cMessage *msg)
virtual void	process_ABORT (TCPEventCode &event, TCPCommand *tcpCommand, cMessage *msg)
virtual void	process_STATUS (TCPEventCode &event, TCPCommand *tcpCommand, cMessage *msg)
virtual void	process_QUEUE_BYTES_LIMIT (TCPEventCode &event, TCPCommand *tcpCommand, cMessage *msg)
virtual void	process_READ_REQUEST (TCPEventCode &event, TCPCommand *tcpCommand, cMessage *msg)
Processing TCP segment arrivals. Invoked from processTCPSegment().
virtual bool	tryFastRoute (TCPSegment *tcpseg)
	Shortcut to process most common case as fast as possible. More...
virtual TCPEventCode	process_RCV_SEGMENT (TCPSegment *tcpseg, L3Address src, L3Address dest)
	Process incoming TCP segment. More...
virtual TCPEventCode	processSegmentInListen (TCPSegment *tcpseg, L3Address src, L3Address dest)
virtual TCPEventCode	processSegmentInSynSent (TCPSegment *tcpseg, L3Address src, L3Address dest)
virtual TCPEventCode	processSegment1stThru8th (TCPSegment *tcpseg)
virtual TCPEventCode	processRstInSynReceived (TCPSegment *tcpseg)
virtual bool	processAckInEstabEtc (TCPSegment *tcpseg)
Processing of TCP options. Invoked from readHeaderOptions(). Return value indicates whether the option was valid.
virtual bool	processMSSOption (TCPSegment *tcpseg, const TCPOptionMaxSegmentSize &option)
virtual bool	processWSOption (TCPSegment *tcpseg, const TCPOptionWindowScale &option)
virtual bool	processSACKPermittedOption (TCPSegment *tcpseg, const TCPOptionSackPermitted &option)
virtual bool	processSACKOption (TCPSegment *tcpseg, const TCPOptionSack &option)
virtual bool	processTSOption (TCPSegment *tcpseg, const TCPOptionTimestamp &option)
Processing timeouts. Invoked from processTimer().
virtual void	process_TIMEOUT_2MSL ()
virtual void	process_TIMEOUT_CONN_ESTAB ()
virtual void	process_TIMEOUT_FIN_WAIT_2 ()
virtual void	process_TIMEOUT_SYN_REXMIT (TCPEventCode &event)

Static Protected Member Functions
static void	sendToIP (TCPSegment *tcpseg, L3Address src, L3Address dest)
	Utility: send IP packet. More...

Protected Attributes
TCP *	tcpMain = nullptr
cFSM	fsm
TCPStateVariables *	state = nullptr
TCPSendQueue *	sendQueue = nullptr
TCPReceiveQueue *	receiveQueue = nullptr
TCPDataTransferMode	transferMode = TCP_TRANSFER_UNDEFINED
TCPAlgorithm *	tcpAlgorithm = nullptr
cMessage *	the2MSLTimer = nullptr
cMessage *	connEstabTimer = nullptr
cMessage *	finWait2Timer = nullptr
cMessage *	synRexmitTimer = nullptr
cOutVector *	sndWndVector = nullptr
cOutVector *	rcvWndVector = nullptr
cOutVector *	rcvAdvVector = nullptr
cOutVector *	sndNxtVector = nullptr
cOutVector *	sndAckVector = nullptr
cOutVector *	rcvSeqVector = nullptr
cOutVector *	rcvAckVector = nullptr
cOutVector *	unackedVector = nullptr
cOutVector *	dupAcksVector = nullptr
cOutVector *	pipeVector = nullptr
cOutVector *	sndSacksVector = nullptr
cOutVector *	rcvSacksVector = nullptr
cOutVector *	rcvOooSegVector = nullptr
cOutVector *	rcvNASegVector = nullptr
cOutVector *	sackedBytesVector = nullptr
cOutVector *	tcpRcvQueueBytesVector = nullptr
cOutVector *	tcpRcvQueueDropsVector = nullptr

Detailed Description

Manages a TCP connection.

This class itself implements the TCP state machine as well as handling control PDUs (SYN, SYN+ACK, RST, FIN, etc.), timers (2MSL, CONN-ESTAB, FIN-WAIT-2) and events (OPEN, SEND, etc) associated with TCP state changes.

The implementation largely follows the functional specification at the end of RFC 793. Code comments extensively quote RFC 793 to make it easier to understand.

TCPConnection objects are not used alone – they are instantiated and managed by a TCP module.

TCPConnection "outsources" several tasks to objects subclassed from TCPSendQueue, TCPReceiveQueue and TCPAlgorithm; see overview of this with TCP documentation.

Connection variables (TCB) are kept in TCPStateVariables. TCPAlgorithm implementations can extend TCPStateVariables to add their own stuff (see TCPAlgorithm::createStateVariables() factory method.)

The "entry points" of TCPConnnection from TCP are:

• processTimer(cMessage *msg): handle self-messages which belong to the connection
• processTCPSegment(TCPSegment *tcpSeg, Address srcAddr, Address destAddr): handle segment arrivals
• processAppCommand(cMessage *msg): process commands which arrive from the application (TCP_C_xxx)

All three methods follow a common structure:

1. dispatch to specific methods. For example, processAppCommand() invokes one of process_OPEN_ACTIVE(), process_OPEN_PASSIVE() or process_SEND(), etc., and processTCPSegment() dispatches to processSegmentInListen(), processSegmentInSynSent() or processSegment1stThru8th(). Those methods will do the REAL JOB.
2. after they return, we'll know the state machine event (TCPEventCode, TCP_E_xxx) for sure, so we can:
3. invoke performStateTransition() which executes the necessary state transition (for example, TCP_E_RCV_SYN will take the state machine from TCP_S_LISTEN to TCP_S_SYN_RCVD). No other actions are taken in this step.
4. if there was a state change (for example, we entered the TCP_S_ESTABLISHED state), performStateTransition() invokes stateEntered(), which performs some necessary housekeeping (cancel the CONN-ESTAB timer).

When the CLOSED state is reached, TCP will delete the TCPConnection object.

Constructor & Destructor Documentation

inet::tcp::TCPConnection::TCPConnection	(	TCP *	mod,
		int	appGateIndex,
		int	connId
	)

The "normal" constructor.

{
    tcpMain = _mod;
    appGateIndex = _appGateIndex;
    connId = _connId;

    char fsmname[24];
    sprintf(fsmname, "fsm-%d", connId);
    fsm.setName(fsmname);
    fsm.setState(TCP_S_INIT);

    // queues and algorithm will be created on active or passive open

    the2MSLTimer = new cMessage("2MSL");
    connEstabTimer = new cMessage("CONN-ESTAB");
    finWait2Timer = new cMessage("FIN-WAIT-2");
    synRexmitTimer = new cMessage("SYN-REXMIT");

    the2MSLTimer->setContextPointer(this);
    connEstabTimer->setContextPointer(this);
    finWait2Timer->setContextPointer(this);
    synRexmitTimer->setContextPointer(this);

    // statistics
    if (getTcpMain()->recordStatistics) {
        sndWndVector = new cOutVector("send window");
        rcvWndVector = new cOutVector("receive window");
        rcvAdvVector = new cOutVector("advertised window");
        sndNxtVector = new cOutVector("sent seq");
        sndAckVector = new cOutVector("sent ack");
        rcvSeqVector = new cOutVector("rcvd seq");
        rcvAckVector = new cOutVector("rcvd ack");
        unackedVector = new cOutVector("unacked bytes");
        dupAcksVector = new cOutVector("rcvd dupAcks");
        pipeVector = new cOutVector("pipe");
        sndSacksVector = new cOutVector("sent sacks");
        rcvSacksVector = new cOutVector("rcvd sacks");
        rcvOooSegVector = new cOutVector("rcvd oooseg");
        rcvNASegVector = new cOutVector("rcvd naseg");
        sackedBytesVector = new cOutVector("rcvd sackedBytes");
        tcpRcvQueueBytesVector = new cOutVector("tcpRcvQueueBytes");
        tcpRcvQueueDropsVector = new cOutVector("tcpRcvQueueDrops");
    }
}

inet::tcp::TCPConnection::TCPConnection

(

)

Note: this default ctor is NOT used to create live connections, only temporary ones so that TCPMain can invoke their segmentArrivalWhileClosed().

Referenced by cloneListeningConnection().

{
    // Note: this ctor is NOT used to create live connections, only
    // temporary ones to invoke segmentArrivalWhileClosed() on
    transferMode = TCP_TRANSFER_BYTECOUNT;
}

inet::tcp::TCPConnection::~TCPConnection ( )

virtual

Destructor.

{
    delete sendQueue;
    delete rexmitQueue;
    delete receiveQueue;
    delete tcpAlgorithm;
    delete state;

    if (the2MSLTimer)
        delete cancelEvent(the2MSLTimer);
    if (connEstabTimer)
        delete cancelEvent(connEstabTimer);
    if (finWait2Timer)
        delete cancelEvent(finWait2Timer);
    if (synRexmitTimer)
        delete cancelEvent(synRexmitTimer);

    // statistics
    delete sndWndVector;
    delete rcvWndVector;
    delete rcvAdvVector;
    delete sndNxtVector;
    delete sndAckVector;
    delete rcvSeqVector;
    delete rcvAckVector;
    delete unackedVector;
    delete dupAcksVector;
    delete sndSacksVector;
    delete rcvSacksVector;
    delete rcvOooSegVector;
    delete rcvNASegVector;
    delete tcpRcvQueueBytesVector;
    delete tcpRcvQueueDropsVector;
    delete pipeVector;
    delete sackedBytesVector;
}

Member Function Documentation

TCPSegment inet::tcp::TCPConnection::addSacks ( TCPSegment *  tcpseg )

protectedvirtual

Utility: adds SACKs to segments header options field.

Referenced by writeHeaderOptions().

{
    uint options_len = 0;
    uint used_options_len = tcpseg->getHeaderOptionArrayLength();
    bool dsack_inserted = false;    // set if dsack is subsets of a bigger sack block recently reported

    uint32 start = state->start_seqno;
    uint32 end = state->end_seqno;

    // delete old sacks (below rcv_nxt), delete duplicates and print previous status of sacks_array:
    auto it = state->sacks_array.begin();
    EV_INFO << "Previous status of sacks_array: \n" << ((it != state->sacks_array.end()) ? "" : "\t EMPTY\n");

    while (it != state->sacks_array.end()) {
        if (seqLE(it->getEnd(), state->rcv_nxt) || it->empty()) {
            EV_DETAIL << "\t SACK in sacks_array: " << " " << it->str() << " delete now\n";
            it = state->sacks_array.erase(it);
        }
        else {
            EV_DETAIL << "\t SACK in sacks_array: " << " " << it->str() << endl;

            ASSERT(seqGE(it->getStart(), state->rcv_nxt));

            it++;
        }
    }

    if (used_options_len > TCP_OPTIONS_MAX_SIZE - TCP_OPTION_SACK_MIN_SIZE) {
        EV_ERROR << "ERROR: Failed to addSacks - at least 10 free bytes needed for SACK - used_options_len=" << used_options_len << endl;

        //reset flags:
        state->snd_sack = false;
        state->snd_dsack = false;
        state->start_seqno = 0;
        state->end_seqno = 0;
        return *tcpseg;
    }

    if (start != end) {
        if (state->snd_dsack) {    // SequenceNo < rcv_nxt
            // RFC 2883, page 3:
            // "(3) The left edge of the D-SACK block specifies the first sequence
            // number of the duplicate contiguous sequence, and the right edge of
            // the D-SACK block specifies the sequence number immediately following
            // the last sequence in the duplicate contiguous sequence."
            if (seqLess(start, state->rcv_nxt) && seqLess(state->rcv_nxt, end))
                end = state->rcv_nxt;

            dsack_inserted = true;
            Sack nSack(start, end);
            state->sacks_array.push_front(nSack);
            EV_DETAIL << "inserted DSACK entry: " << nSack.str() << "\n";
        }
        else {
            uint32 contStart = receiveQueue->getLE(start);
            uint32 contEnd = receiveQueue->getRE(end);

            Sack newSack(contStart, contEnd);
            state->sacks_array.push_front(newSack);
            EV_DETAIL << "Inserted SACK entry: " << newSack.str() << "\n";
        }

        // RFC 2883, page 3:
        // "(3) The left edge of the D-SACK block specifies the first sequence
        // number of the duplicate contiguous sequence, and the right edge of
        // the D-SACK block specifies the sequence number immediately following
        // the last sequence in the duplicate contiguous sequence."

        // RFC 2018, page 4:
        // "* The first SACK block (i.e., the one immediately following the
        // kind and length fields in the option) MUST specify the contiguous
        // block of data containing the segment which triggered this ACK,
        // unless that segment advanced the Acknowledgment Number field in
        // the header.  This assures that the ACK with the SACK option
        // reflects the most recent change in the data receiver's buffer
        // queue."

        // RFC 2018, page 4:
        // "* The first SACK block (i.e., the one immediately following the
        // kind and length fields in the option) MUST specify the contiguous
        // block of data containing the segment which triggered this ACK,"

        // RFC 2883, page 3:
        // "(4) If the D-SACK block reports a duplicate contiguous sequence from
        // a (possibly larger) block of data in the receiver's data queue above
        // the cumulative acknowledgement, then the second SACK block in that
        // SACK option should specify that (possibly larger) block of data.
        //
        // (5) Following the SACK blocks described above for reporting duplicate
        // segments, additional SACK blocks can be used for reporting additional
        // blocks of data, as specified in RFC 2018."

        // RFC 2018, page 4:
        // "* The SACK option SHOULD be filled out by repeating the most
        // recently reported SACK blocks (based on first SACK blocks in
        // previous SACK options) that are not subsets of a SACK block
        // already included in the SACK option being constructed."

        it = state->sacks_array.begin();
        if (dsack_inserted)
            it++;

        for ( ; it != state->sacks_array.end(); it++) {
            ASSERT(!it->empty());

            auto it2 = it;
            it2++;
            while (it2 != state->sacks_array.end()) {
                if (it->contains(*it2)) {
                    EV_DETAIL << "sack matched, delete contained : a=" << it->str() << ", b=" << it2->str() << endl;
                    it2 = state->sacks_array.erase(it2);
                }
                else
                    it2++;
            }
        }
    }

    uint n = state->sacks_array.size();

    uint maxnode = ((TCP_OPTIONS_MAX_SIZE - used_options_len) - 2) / 8;    // 2: option header, 8: size of one sack entry

    if (n > maxnode)
        n = maxnode;

    if (n == 0) {
        if (dsack_inserted)
            state->sacks_array.pop_front(); // delete DSACK entry

        // reset flags:
        state->snd_sack = false;
        state->snd_dsack = false;
        state->start_seqno = 0;
        state->end_seqno = 0;

        return *tcpseg;
    }

    uint optArrSize = tcpseg->getHeaderOptionArraySize();

    uint optArrSizeAligned = optArrSize;

    while (used_options_len % 4 != 2) {
        used_options_len++;
        optArrSizeAligned++;
    }

    while (optArrSize < optArrSizeAligned) {
        tcpseg->addHeaderOption(new TCPOptionNop());
        optArrSize++;
    }

    ASSERT(used_options_len % 4 == 2);

    TCPOptionSack *option = new TCPOptionSack();
    option->setLength(8 * n + 2);
    option->setSackItemArraySize(n);

    // write sacks from sacks_array to options
    uint counter = 0;

    for (it = state->sacks_array.begin(); it != state->sacks_array.end() && counter < n; it++) {
        ASSERT(it->getStart() != it->getEnd());
        option->setSackItem(counter++, *it);
    }

    // independent of "n" we always need 2 padding bytes (NOP) to make: (used_options_len % 4 == 0)
    options_len = used_options_len + 8 * n + 2;    // 8 bytes for each SACK (n) + 2 bytes for kind&length

    ASSERT(options_len <= TCP_OPTIONS_MAX_SIZE);    // Options length allowed? - maximum: 40 Bytes

    tcpseg->addHeaderOption(option);

    // update number of sent sacks
    state->snd_sacks += n;

    if (sndSacksVector)
        sndSacksVector->record(state->snd_sacks);

    EV_INFO << n << " SACK(s) added to header:\n";

    for (uint t = 0; t < n; t++) {
        EV_INFO << t << ". SACK:" << " [" << option->getSackItem(t).getStart() << ".." << option->getSackItem(t).getEnd() << ")";

        if (t == 0) {
            if (state->snd_dsack)
                EV_INFO << " (D-SACK)";
            else if (seqLE(option->getSackItem(t).getEnd(), state->rcv_nxt)) {
                EV_INFO << " (received segment filled out a gap)";
                state->snd_dsack = true;    // Note: Set snd_dsack to delete first sack from sacks_array
            }
        }

        EV_INFO << endl;
    }

    // RFC 2883, page 3:
    // "(1) A D-SACK block is only used to report a duplicate contiguous
    // sequence of data received by the receiver in the most recent packet.
    //
    // (2) Each duplicate contiguous sequence of data received is reported
    // in at most one D-SACK block.  (I.e., the receiver sends two identical
    // D-SACK blocks in subsequent packets only if the receiver receives two
    // duplicate segments.)//
    //
    // In case of d-sack: delete first sack (d-sack) and move old sacks by one to the left
    if (dsack_inserted)
        state->sacks_array.pop_front(); // delete DSACK entry

    // reset flags:
    state->snd_sack = false;
    state->snd_dsack = false;
    state->start_seqno = 0;
    state->end_seqno = 0;

    return *tcpseg;
}

cMessage* inet::tcp::TCPConnection::cancelEvent ( cMessage *  msg )

inlineprotected

Utility: cancel a timer.

Referenced by processSegment1stThru8th(), and startSynRexmitTimer().

{ return tcpMain->cancelEvent(msg); }

TCPConnection * inet::tcp::TCPConnection::cloneListeningConnection ( )

protectedvirtual

Utility: clone a listening connection.

Used for forking.

Referenced by processSegmentInListen().

{
    TCPConnection *conn = new TCPConnection(tcpMain, appGateIndex, connId);

    conn->transferMode = transferMode;
    // following code to be kept consistent with initConnection()
    const char *sendQueueClass = sendQueue->getClassName();
    conn->sendQueue = check_and_cast<TCPSendQueue *>(inet::utils::createOne(sendQueueClass));
    conn->sendQueue->setConnection(conn);

    const char *receiveQueueClass = receiveQueue->getClassName();
    conn->receiveQueue = check_and_cast<TCPReceiveQueue *>(inet::utils::createOne(receiveQueueClass));
    conn->receiveQueue->setConnection(conn);

    // create SACK retransmit queue
    conn->rexmitQueue = new TCPSACKRexmitQueue();
    conn->rexmitQueue->setConnection(this);

    const char *tcpAlgorithmClass = tcpAlgorithm->getClassName();
    conn->tcpAlgorithm = check_and_cast<TCPAlgorithm *>(inet::utils::createOne(tcpAlgorithmClass));
    conn->tcpAlgorithm->setConnection(conn);

    conn->state = conn->tcpAlgorithm->getStateVariables();
    configureStateVariables();
    conn->tcpAlgorithm->initialize();

    // put it into LISTEN, with our localAddr/localPort
    conn->state->active = false;
    conn->state->fork = true;
    conn->localAddr = localAddr;
    conn->localPort = localPort;
    FSM_Goto(conn->fsm, TCP_S_LISTEN);

    return conn;
}

void inet::tcp::TCPConnection::configureStateVariables ( )

protectedvirtual

Utility: set snd_mss, rcv_wnd and sack in newly created state variables block.

Referenced by cloneListeningConnection(), and initConnection().

{
    long advertisedWindowPar = tcpMain->par("advertisedWindow").longValue();
    state->ws_support = tcpMain->par("windowScalingSupport");    // if set, this means that current host supports WS (RFC 1323)
    state->ws_manual_scale = tcpMain->par("windowScalingFactor"); // scaling factor (set manually) to help for TCP validation
    if (!state->ws_support && (advertisedWindowPar > TCP_MAX_WIN || advertisedWindowPar <= 0))
        throw cRuntimeError("Invalid advertisedWindow parameter: %ld", advertisedWindowPar);

    state->rcv_wnd = advertisedWindowPar;
    state->rcv_adv = advertisedWindowPar;

    if (state->ws_support && advertisedWindowPar > TCP_MAX_WIN) {
        state->rcv_wnd = TCP_MAX_WIN;    // we cannot to guarantee that the other end is also supporting the Window Scale (header option) (RFC 1322)
        state->rcv_adv = TCP_MAX_WIN;    // therefore TCP_MAX_WIN is used as initial value for rcv_wnd and rcv_adv
    }

    state->maxRcvBuffer = advertisedWindowPar;
    state->delayed_acks_enabled = tcpMain->par("delayedAcksEnabled");    // delayed ACK algorithm (RFC 1122) enabled/disabled
    state->nagle_enabled = tcpMain->par("nagleEnabled");    // Nagle's algorithm (RFC 896) enabled/disabled
    state->limited_transmit_enabled = tcpMain->par("limitedTransmitEnabled");    // Limited Transmit algorithm (RFC 3042) enabled/disabled
    state->increased_IW_enabled = tcpMain->par("increasedIWEnabled");    // Increased Initial Window (RFC 3390) enabled/disabled
    state->snd_mss = tcpMain->par("mss").longValue();    // Maximum Segment Size (RFC 793)
    state->ts_support = tcpMain->par("timestampSupport");    // if set, this means that current host supports TS (RFC 1323)
    state->sack_support = tcpMain->par("sackSupport");    // if set, this means that current host supports SACK (RFC 2018, 2883, 3517)

    if (state->sack_support) {
        std::string algorithmName1 = "TCPReno";
        std::string algorithmName2 = tcpMain->par("tcpAlgorithmClass");

        if (algorithmName1 != algorithmName2) {    // TODO add additional checks for new SACK supporting algorithms here once they are implemented
            EV_DEBUG << "If you want to use TCP SACK please set tcpAlgorithmClass to TCPReno\n";

            ASSERT(false);
        }
    }
}

uint32 inet::tcp::TCPConnection::convertSimtimeToTS ( simtime_t  simtime )

static

Utility: converts a given simtime to a timestamp (TS).

Referenced by inet::tcp::TCPBaseAlg::rttMeasurementCompleteUsingTS(), and writeHeaderOptions().

{
    ASSERT(SimTime::getScaleExp() <= -3);

    uint32 timestamp = (uint32)(simtime.inUnit(SIMTIME_MS));
    return timestamp;
}

simtime_t inet::tcp::TCPConnection::convertTSToSimtime ( uint32  timestamp )

static

Utility: converts a given timestamp (TS) to a simtime.

Referenced by inet::tcp::TCPBaseAlg::rttMeasurementCompleteUsingTS().

{
    ASSERT(SimTime::getScaleExp() <= -3);

    simtime_t simtime(timestamp, SIMTIME_MS);
    return simtime;
}

TCPSegment * inet::tcp::TCPConnection::createTCPSegment ( const char *  name )

virtual

Utility: This factory method gets invoked throughout the TCP model to create a TCPSegment.

Override it if you need to subclass TCPSegment.

Referenced by inet::tcp::TCPVirtualDataSendQueue::createSegmentWithBytes(), sendAck(), sendFin(), sendRst(), sendRstAck(), sendSegment(), sendSyn(), and sendSynAck().

{
    return new TCPSegment(name);
}

const char * inet::tcp::TCPConnection::eventName ( int  event )

static

Utility: returns name of TCP_E_xxx constants.

{
#define CASE(x)    case x: \
        s = #x + 6; break
    const char *s = "unknown";
    switch (event) {
        CASE(TCP_E_IGNORE);
        CASE(TCP_E_OPEN_ACTIVE);
        CASE(TCP_E_OPEN_PASSIVE);
        CASE(TCP_E_SEND);
        CASE(TCP_E_CLOSE);
        CASE(TCP_E_ABORT);
        CASE(TCP_E_STATUS);
        CASE(TCP_E_QUEUE_BYTES_LIMIT);
        CASE(TCP_E_RCV_DATA);
        CASE(TCP_E_RCV_ACK);
        CASE(TCP_E_RCV_SYN);
        CASE(TCP_E_RCV_SYN_ACK);
        CASE(TCP_E_RCV_FIN);
        CASE(TCP_E_RCV_FIN_ACK);
        CASE(TCP_E_RCV_RST);
        CASE(TCP_E_RCV_UNEXP_SYN);
        CASE(TCP_E_TIMEOUT_2MSL);
        CASE(TCP_E_TIMEOUT_CONN_ESTAB);
        CASE(TCP_E_TIMEOUT_FIN_WAIT_2);
    }
    return s;
#undef CASE
}

int inet::tcp::TCPConnection::getFsmState ( ) const

inline

{ return fsm.getState(); }

L3Address inet::tcp::TCPConnection::getLocalAddress ( ) const

inline

{ return localAddr; }

int inet::tcp::TCPConnection::getLocalPort ( ) const

inline

{ return localPort; }

TCPReceiveQueue* inet::tcp::TCPConnection::getReceiveQueue ( )

inline

{ return receiveQueue; }

L3Address inet::tcp::TCPConnection::getRemoteAddress ( ) const

inline

{ return remoteAddr; }

int inet::tcp::TCPConnection::getRemotePort ( ) const

inline

{ return remotePort; }

TCPSACKRexmitQueue* inet::tcp::TCPConnection::getRexmitQueue ( )

inline

{ return rexmitQueue; }

TCPSendQueue* inet::tcp::TCPConnection::getSendQueue ( )

inline

{ return sendQueue; }

TCPStateVariables* inet::tcp::TCPConnection::getState ( )

inline

{ return state; }

TCPAlgorithm* inet::tcp::TCPConnection::getTcpAlgorithm ( )

inline

{ return tcpAlgorithm; }

TCP* inet::tcp::TCPConnection::getTcpMain ( )

inline

Referenced by inet::tcp::DumbTCP::connectionClosed(), inet::tcp::DumbTCP::dataSent(), inet::tcp::TCPBaseAlg::initialize(), and inet::tcp::DumbTCP::~DumbTCP().

{ return tcpMain; }

uint32 inet::tcp::TCPConnection::getTSecr ( TCPSegment *  tcpseg ) const

protectedvirtual

Utility: get TSecr from segments TS header option.

Referenced by processAckInEstabEtc().

{
    for (uint i = 0; i < tcpseg->getHeaderOptionArraySize(); i++) {
        const TCPOption *option = tcpseg->getHeaderOption(i);
        if (option->getKind() == TCPOPTION_TIMESTAMP)
            return check_and_cast<const TCPOptionTimestamp *>(option)->getEchoedTimestamp();
    }

    return 0;
}

uint32 inet::tcp::TCPConnection::getTSval ( TCPSegment *  tcpseg ) const

protectedvirtual

Utility: get TSval from segments TS header option.

Referenced by processSegment1stThru8th().

{
    for (uint i = 0; i < tcpseg->getHeaderOptionArraySize(); i++) {
        const TCPOption *option = tcpseg->getHeaderOption(i);
        if (option->getKind() == TCPOPTION_TIMESTAMP)
            return check_and_cast<const TCPOptionTimestamp *>(option)->getSenderTimestamp();
    }

    return 0;
}

bool inet::tcp::TCPConnection::hasEnoughSpaceForSegmentInReceiveQueue ( TCPSegment *  tcpseg )

virtual

Utility: returns true when receive queue has enough space for store the tcpseg.

Referenced by processSegment1stThru8th(), processSegmentInListen(), and processSegmentInSynSent().

{
    //TODO must rewrite it
    //return (state->freeRcvBuffer >= tcpseg->getPayloadLength()); // enough freeRcvBuffer in rcvQueue for new segment?

    uint32 firstSeq = receiveQueue->getFirstSeqNo();
    return seqLE(firstSeq, tcpseg->getSequenceNo()) && seqLE(tcpseg->getSequenceNo() + tcpseg->getPayloadLength(), firstSeq + state->maxRcvBuffer);
}

const char * inet::tcp::TCPConnection::indicationName ( int  code )

static

Utility: returns name of TCP_I_xxx constants.

Referenced by sendEstabIndicationToApp(), and sendIndicationToApp().

{
#define CASE(x)    case x: \
        s = #x + 6; break
    const char *s = "unknown";
    switch (code) {
        CASE(TCP_I_DATA);
        CASE(TCP_I_URGENT_DATA);
        CASE(TCP_I_ESTABLISHED);
        CASE(TCP_I_PEER_CLOSED);
        CASE(TCP_I_CLOSED);
        CASE(TCP_I_CONNECTION_REFUSED);
        CASE(TCP_I_CONNECTION_RESET);
        CASE(TCP_I_TIMED_OUT);
        CASE(TCP_I_STATUS);
        CASE(TCP_I_SEND_MSG);
    }
    return s;
#undef CASE
}

void inet::tcp::TCPConnection::initConnection ( TCPOpenCommand *  openCmd )

protectedvirtual

Utility: creates send/receive queues and tcpAlgorithm.

Referenced by process_OPEN_ACTIVE(), and process_OPEN_PASSIVE().

{
    transferMode = (TCPDataTransferMode)(openCmd->getDataTransferMode());
    // create send queue
    sendQueue = tcpMain->createSendQueue(transferMode);
    sendQueue->setConnection(this);

    // create receive queue
    receiveQueue = tcpMain->createReceiveQueue(transferMode);
    receiveQueue->setConnection(this);

    // create SACK retransmit queue
    rexmitQueue = new TCPSACKRexmitQueue();
    rexmitQueue->setConnection(this);

    // create algorithm
    const char *tcpAlgorithmClass = openCmd->getTcpAlgorithmClass();

    if (!tcpAlgorithmClass || !tcpAlgorithmClass[0])
        tcpAlgorithmClass = tcpMain->par("tcpAlgorithmClass");

    tcpAlgorithm = check_and_cast<TCPAlgorithm *>(inet::utils::createOne(tcpAlgorithmClass));
    tcpAlgorithm->setConnection(this);

    // create state block
    state = tcpAlgorithm->getStateVariables();
    configureStateVariables();
    tcpAlgorithm->initialize();
}

bool inet::tcp::TCPConnection::isLost ( uint32  seqNum )

virtual

For SACK TCP.

RFC 3517, page 3: "This routine returns whether the given sequence number is considered to be lost. The routine returns true when either DupThresh discontiguous SACKed sequences have arrived above 'SeqNum' or (DupThresh * SMSS) bytes with sequence numbers greater than 'SeqNum' have been SACKed. Otherwise, the routine returns false."

Referenced by nextSeg(), and setPipe().

{
    ASSERT(state->sack_enabled);

    // RFC 3517, page 3: "This routine returns whether the given sequence number is
    // considered to be lost.  The routine returns true when either
    // DupThresh discontiguous SACKed sequences have arrived above
    // 'SeqNum' or (DupThresh * SMSS) bytes with sequence numbers greater
    // than 'SeqNum' have been SACKed.  Otherwise, the routine returns
    // false."
    ASSERT(seqGE(seqNum, state->snd_una));    // HighAck = snd_una

    bool isLost = (rexmitQueue->getNumOfDiscontiguousSacks(seqNum) >= DUPTHRESH    // DUPTHRESH = 3
                   || rexmitQueue->getAmountOfSackedBytes(seqNum) >= (DUPTHRESH * state->snd_mss));

    return isLost;
}

bool inet::tcp::TCPConnection::isSegmentAcceptable ( TCPSegment *  tcpseg ) const

protectedvirtual

Utility: check if segment is acceptable (all bytes are in receive window)

Referenced by processSegment1stThru8th().

{
    // check that segment entirely falls in receive window
    // RFC 793, page 69:
    // "There are four cases for the acceptability test for an incoming segment:
    //    Segment Receive  Test
    //    Length  Window
    //    ------- -------  -------------------------------------------
    //       0       0     SEG.SEQ = RCV.NXT
    //       0      >0     RCV.NXT =< SEG.SEQ < RCV.NXT+RCV.WND
    //      >0       0     not acceptable
    //      >0      >0     RCV.NXT =< SEG.SEQ < RCV.NXT+RCV.WND
    //                  or RCV.NXT =< SEG.SEQ+SEG.LEN-1 < RCV.NXT+RCV.WND"
    uint32 len = tcpseg->getPayloadLength();
    uint32 seqNo = tcpseg->getSequenceNo();
    uint32 ackNo = tcpseg->getAckNo();
    uint32 rcvWndEnd = state->rcv_nxt + state->rcv_wnd;
    bool ret;

    if (len == 0) {
        if (state->rcv_wnd == 0)
            ret = (seqNo == state->rcv_nxt);
        else // rcv_wnd > 0
//            ret = seqLE(state->rcv_nxt, seqNo) && seqLess(seqNo, rcvWndEnd);
            ret = seqLE(state->rcv_nxt, seqNo) && seqLE(seqNo, rcvWndEnd); // Accept an ACK on end of window
    }
    else {    // len > 0
        if (state->rcv_wnd == 0)
            ret = false;
        else // rcv_wnd > 0
            ret = (seqLE(state->rcv_nxt, seqNo) && seqLess(seqNo, rcvWndEnd))
                || (seqLess(state->rcv_nxt, seqNo + len) && seqLE(seqNo + len, rcvWndEnd)); // Accept an ACK on end of window
    }

    // RFC 793, page 25:
    // "A new acknowledgment (called an "acceptable ack"), is one for which
    // the inequality below holds:
    //    SND.UNA < SEG.ACK =< SND.NXT"
    if (!ret && len == 0) {
        if (!state->afterRto)
            ret = (seqLess(state->snd_una, ackNo) && seqLE(ackNo, state->snd_nxt));
        else
            ret = (seqLess(state->snd_una, ackNo) && seqLE(ackNo, state->snd_max)); // after RTO snd_nxt is reduced therefore we need to use snd_max instead of snd_nxt here
    }

    if (!ret)
        EV_WARN << "Not Acceptable segment. seqNo=" << seqNo << " ackNo=" << ackNo << " len=" << len << " rcv_nxt="
                << state->rcv_nxt << " rcv_wnd=" << state->rcv_wnd << " afterRto=" << state->afterRto << "\n";

    return ret;
}

bool inet::tcp::TCPConnection::isSendQueueEmpty ( )

virtual

Utility: checks if send queue is empty (no data to send).

Referenced by inet::tcp::TCPBaseAlg::sendData().

{
    return sendQueue->getBytesAvailable(state->snd_nxt) == 0;
}

bool inet::tcp::TCPConnection::nextSeg ( uint32 &  seqNum )

virtual

For SACK TCP.

RFC 3517, page 3: "This routine uses the scoreboard data structure maintained by the Update() function to determine what to transmit based on the SACK information that has arrived from the data receiver (and hence been marked in the scoreboard). NextSeg () MUST return the sequence number range of the next segment that is to be transmitted..." Returns true if a valid sequence number (for the next segment) is found and returns false if no segment should be send.

Referenced by sendDataDuringLossRecoveryPhase().

{
    ASSERT(state->sack_enabled);

    // RFC 3517, page 5: "This routine uses the scoreboard data structure maintained by the
    // Update() function to determine what to transmit based on the SACK
    // information that has arrived from the data receiver (and hence
    // been marked in the scoreboard).  NextSeg () MUST return the
    // sequence number range of the next segment that is to be
    // transmitted, per the following rules:"

    state->highRxt = rexmitQueue->getHighestRexmittedSeqNum();
    uint32 highestSackedSeqNum = rexmitQueue->getHighestSackedSeqNum();
    uint32 shift = state->snd_mss;
    bool sacked = false;    // required for rexmitQueue->checkSackBlock()
    bool rexmitted = false;    // required for rexmitQueue->checkSackBlock()

    seqNum = 0;

    if (state->ts_enabled)
        shift -= TCP_OPTION_TS_SIZE;

    // RFC 3517, page 5: "(1) If there exists a smallest unSACKed sequence number 'S2' that
    // meets the following three criteria for determining loss, the
    // sequence range of one segment of up to SMSS octets starting
    // with S2 MUST be returned.
    //
    // (1.a) S2 is greater than HighRxt.
    //
    // (1.b) S2 is less than the highest octet covered by any
    //       received SACK.
    //
    // (1.c) IsLost (S2) returns true."

    // Note: state->highRxt == RFC.HighRxt + 1
    for (uint32 s2 = state->highRxt;
         seqLess(s2, state->snd_max) && seqLess(s2, highestSackedSeqNum);
         s2 += shift
         )
    {
        rexmitQueue->checkSackBlock(s2, shift, sacked, rexmitted);

        if (!sacked) {
            if (isLost(s2)) {    // 1.a and 1.b are true, see above "for" statement
                seqNum = s2;

                return true;
            }

            break;    // !isLost(x) --> !isLost(x + d)
        }
    }

    // RFC 3517, page 5: "(2) If no sequence number 'S2' per rule (1) exists but there
    // exists available unsent data and the receiver's advertised
    // window allows, the sequence range of one segment of up to SMSS
    // octets of previously unsent data starting with sequence number
    // HighData+1 MUST be returned."
    {
        // check how many unsent bytes we have
        ulong buffered = sendQueue->getBytesAvailable(state->snd_max);
        ulong maxWindow = state->snd_wnd;
        // effectiveWindow: number of bytes we're allowed to send now
        ulong effectiveWin = maxWindow - state->pipe;

        if (buffered > 0 && effectiveWin >= state->snd_mss) {
            seqNum = state->snd_max;    // HighData = snd_max

            return true;
        }
    }

    // RFC 3517, pages 5 and 6: "(3) If the conditions for rules (1) and (2) fail, but there exists
    // an unSACKed sequence number 'S3' that meets the criteria for
    // detecting loss given in steps (1.a) and (1.b) above
    // (specifically excluding step (1.c)) then one segment of up to
    // SMSS octets starting with S3 MAY be returned.
    //
    // Note that rule (3) is a sort of retransmission "last resort".
    // It allows for retransmission of sequence numbers even when the
    // sender has less certainty a segment has been lost than as with
    // rule (1).  Retransmitting segments via rule (3) will help
    // sustain TCP's ACK clock and therefore can potentially help
    // avoid retransmission timeouts.  However, in sending these
    // segments the sender has two copies of the same data considered
    // to be in the network (and also in the Pipe estimate).  When an
    // ACK or SACK arrives covering this retransmitted segment, the
    // sender cannot be sure exactly how much data left the network
    // (one of the two transmissions of the packet or both
    // transmissions of the packet).  Therefore the sender may
    // underestimate Pipe by considering both segments to have left
    // the network when it is possible that only one of the two has.
    //
    // We believe that the triggering of rule (3) will be rare and
    // that the implications are likely limited to corner cases
    // relative to the entire recovery algorithm.  Therefore we leave
    // the decision of whether or not to use rule (3) to
    // implementors."
    {
        for (uint32 s3 = state->highRxt;
             seqLess(s3, state->snd_max) && seqLess(s3, highestSackedSeqNum);
             s3 += shift
             )
        {
            rexmitQueue->checkSackBlock(s3, shift, sacked, rexmitted);

            if (!sacked) {
                // 1.a and 1.b are true, see above "for" statement
                seqNum = s3;

                return true;
            }
        }
    }

    // RFC 3517, page 6: "(4) If the conditions for each of (1), (2), and (3) are not met,
    // then NextSeg () MUST indicate failure, and no segment is
    // returned."
    seqNum = 0;

    return false;
}

const char * inet::tcp::TCPConnection::optionName ( int  option )

static

Utility: returns name of TCPOPTION_xxx constants.

Referenced by printSegmentBrief(), and readHeaderOptions().

{
    switch (option) {
        case TCPOPTION_END_OF_OPTION_LIST:
            return "EOL";

        case TCPOPTION_NO_OPERATION:
            return "NOP";

        case TCPOPTION_MAXIMUM_SEGMENT_SIZE:
            return "MSS";

        case TCPOPTION_WINDOW_SCALE:
            return "WS";

        case TCPOPTION_SACK_PERMITTED:
            return "SACK_PERMITTED";

        case TCPOPTION_SACK:
            return "SACK";

        case TCPOPTION_TIMESTAMP:
            return "TS";

        default:
            return "unknown";
    }
}

bool inet::tcp::TCPConnection::performStateTransition ( const TCPEventCode &  event )

protectedvirtual

Implemements the pure TCP state machine.

{
    ASSERT(fsm.getState() != TCP_S_CLOSED);    // closed connections should be deleted immediately

    if (event == TCP_E_IGNORE) {    // e.g. discarded segment
        EV_DETAIL << "Staying in state: " << stateName(fsm.getState()) << " (no FSM event)\n";
        return true;
    }

    // state machine
    // TBD add handling of connection timeout event (KEEP-ALIVE), with transition to CLOSED
    // Note: empty "default:" lines are for gcc's benefit which would otherwise spit warnings
    int oldState = fsm.getState();

    switch (fsm.getState()) {
        case TCP_S_INIT:
            switch (event) {
                case TCP_E_OPEN_PASSIVE:
                    FSM_Goto(fsm, TCP_S_LISTEN);
                    break;

                case TCP_E_OPEN_ACTIVE:
                    FSM_Goto(fsm, TCP_S_SYN_SENT);
                    break;

                default:
                    break;
            }
            break;

        case TCP_S_LISTEN:
            switch (event) {
                case TCP_E_OPEN_ACTIVE:
                    FSM_Goto(fsm, TCP_S_SYN_SENT);
                    break;

                case TCP_E_SEND:
                    FSM_Goto(fsm, TCP_S_SYN_SENT);
                    break;

                case TCP_E_CLOSE:
                    FSM_Goto(fsm, TCP_S_CLOSED);
                    break;

                case TCP_E_ABORT:
                    FSM_Goto(fsm, TCP_S_CLOSED);
                    break;

                case TCP_E_RCV_SYN:
                    FSM_Goto(fsm, TCP_S_SYN_RCVD);
                    break;

                default:
                    break;
            }
            break;

        case TCP_S_SYN_RCVD:
            switch (event) {
                case TCP_E_CLOSE:
                    FSM_Goto(fsm, TCP_S_FIN_WAIT_1);
                    break;

                case TCP_E_ABORT:
                    FSM_Goto(fsm, TCP_S_CLOSED);
                    break;

                case TCP_E_TIMEOUT_CONN_ESTAB:
                    FSM_Goto(fsm, state->active ? TCP_S_CLOSED : TCP_S_LISTEN);
                    break;

                case TCP_E_RCV_RST:
                    FSM_Goto(fsm, state->active ? TCP_S_CLOSED : TCP_S_LISTEN);
                    break;

                case TCP_E_RCV_ACK:
                    FSM_Goto(fsm, TCP_S_ESTABLISHED);
                    break;

                case TCP_E_RCV_FIN:
                    FSM_Goto(fsm, TCP_S_CLOSE_WAIT);
                    break;

                case TCP_E_RCV_UNEXP_SYN:
                    FSM_Goto(fsm, TCP_S_CLOSED);
                    break;

                default:
                    break;
            }
            break;

        case TCP_S_SYN_SENT:
            switch (event) {
                case TCP_E_CLOSE:
                    FSM_Goto(fsm, TCP_S_CLOSED);
                    break;

                case TCP_E_ABORT:
                    FSM_Goto(fsm, TCP_S_CLOSED);
                    break;

                case TCP_E_TIMEOUT_CONN_ESTAB:
                    FSM_Goto(fsm, TCP_S_CLOSED);
                    break;

                case TCP_E_RCV_RST:
                    FSM_Goto(fsm, TCP_S_CLOSED);
                    break;

                case TCP_E_RCV_SYN_ACK:
                    FSM_Goto(fsm, TCP_S_ESTABLISHED);
                    break;

                case TCP_E_RCV_SYN:
                    FSM_Goto(fsm, TCP_S_SYN_RCVD);
                    break;

                default:
                    break;
            }
            break;

        case TCP_S_ESTABLISHED:
            switch (event) {
                case TCP_E_CLOSE:
                    FSM_Goto(fsm, TCP_S_FIN_WAIT_1);
                    break;

                case TCP_E_ABORT:
                    FSM_Goto(fsm, TCP_S_CLOSED);
                    break;

                case TCP_E_RCV_FIN:
                    FSM_Goto(fsm, TCP_S_CLOSE_WAIT);
                    break;

                case TCP_E_RCV_RST:
                    FSM_Goto(fsm, TCP_S_CLOSED);
                    break;

                case TCP_E_RCV_UNEXP_SYN:
                    FSM_Goto(fsm, TCP_S_CLOSED);
                    break;

                default:
                    break;
            }
            break;

        case TCP_S_CLOSE_WAIT:
            switch (event) {
                case TCP_E_CLOSE:
                    FSM_Goto(fsm, TCP_S_LAST_ACK);
                    break;

                case TCP_E_ABORT:
                    FSM_Goto(fsm, TCP_S_CLOSED);
                    break;

                case TCP_E_RCV_RST:
                    FSM_Goto(fsm, TCP_S_CLOSED);
                    break;

                case TCP_E_RCV_UNEXP_SYN:
                    FSM_Goto(fsm, TCP_S_CLOSED);
                    break;

                default:
                    break;
            }
            break;

        case TCP_S_LAST_ACK:
            switch (event) {
                case TCP_E_ABORT:
                    FSM_Goto(fsm, TCP_S_CLOSED);
                    break;

                case TCP_E_RCV_ACK:
                    FSM_Goto(fsm, TCP_S_CLOSED);
                    break;

                case TCP_E_RCV_RST:
                    FSM_Goto(fsm, TCP_S_CLOSED);
                    break;

                case TCP_E_RCV_UNEXP_SYN:
                    FSM_Goto(fsm, TCP_S_CLOSED);
                    break;

                default:
                    break;
            }
            break;

        case TCP_S_FIN_WAIT_1:
            switch (event) {
                case TCP_E_ABORT:
                    FSM_Goto(fsm, TCP_S_CLOSED);
                    break;

                case TCP_E_RCV_FIN:
                    FSM_Goto(fsm, TCP_S_CLOSING);
                    break;

                case TCP_E_RCV_ACK:
                    FSM_Goto(fsm, TCP_S_FIN_WAIT_2);
                    break;

                case TCP_E_RCV_FIN_ACK:
                    FSM_Goto(fsm, TCP_S_TIME_WAIT);
                    break;

                case TCP_E_RCV_RST:
                    FSM_Goto(fsm, TCP_S_CLOSED);
                    break;

                case TCP_E_RCV_UNEXP_SYN:
                    FSM_Goto(fsm, TCP_S_CLOSED);
                    break;

                default:
                    break;
            }
            break;

        case TCP_S_FIN_WAIT_2:
            switch (event) {
                case TCP_E_ABORT:
                    FSM_Goto(fsm, TCP_S_CLOSED);
                    break;

                case TCP_E_RCV_FIN:
                    FSM_Goto(fsm, TCP_S_TIME_WAIT);
                    break;

                case TCP_E_TIMEOUT_FIN_WAIT_2:
                    FSM_Goto(fsm, TCP_S_CLOSED);
                    break;

                case TCP_E_RCV_RST:
                    FSM_Goto(fsm, TCP_S_CLOSED);
                    break;

                case TCP_E_RCV_UNEXP_SYN:
                    FSM_Goto(fsm, TCP_S_CLOSED);
                    break;

                default:
                    break;
            }
            break;

        case TCP_S_CLOSING:
            switch (event) {
                case TCP_E_ABORT:
                    FSM_Goto(fsm, TCP_S_CLOSED);
                    break;

                case TCP_E_RCV_ACK:
                    FSM_Goto(fsm, TCP_S_TIME_WAIT);
                    break;

                case TCP_E_RCV_RST:
                    FSM_Goto(fsm, TCP_S_CLOSED);
                    break;

                case TCP_E_RCV_UNEXP_SYN:
                    FSM_Goto(fsm, TCP_S_CLOSED);
                    break;

                default:
                    break;
            }
            break;

        case TCP_S_TIME_WAIT:
            switch (event) {
                case TCP_E_ABORT:
                    FSM_Goto(fsm, TCP_S_CLOSED);
                    break;

                case TCP_E_TIMEOUT_2MSL:
                    FSM_Goto(fsm, TCP_S_CLOSED);
                    break;

                case TCP_E_RCV_RST:
                    FSM_Goto(fsm, TCP_S_CLOSED);
                    break;

                case TCP_E_RCV_UNEXP_SYN:
                    FSM_Goto(fsm, TCP_S_CLOSED);
                    break;

                default:
                    break;
            }
            break;

        case TCP_S_CLOSED:
            break;
    }

    if (oldState != fsm.getState()) {
        EV_INFO << "Transition: " << stateName(oldState) << " --> " << stateName(fsm.getState()) << "  (event was: " << eventName(event) << ")\n";
        EV_DEBUG_C("testing") << tcpMain->getName() << ": " << stateName(oldState) << " --> " << stateName(fsm.getState()) << "  (on " << eventName(event) << ")\n";

        // cancel timers, etc.
        stateEntered(fsm.getState(), oldState, event);
    }
    else {
        EV_DETAIL << "Staying in state: " << stateName(fsm.getState()) << " (event was: " << eventName(event) << ")\n";
    }

    return fsm.getState() != TCP_S_CLOSED;
}

TCPEventCode inet::tcp::TCPConnection::preanalyseAppCommandEvent ( int  commandCode )

protectedvirtual

Maps app command codes (msg kind of app command msgs) to TCP_E_xxx event codes.

{
    switch (commandCode) {
        case TCP_C_OPEN_ACTIVE:
            return TCP_E_OPEN_ACTIVE;

        case TCP_C_OPEN_PASSIVE:
            return TCP_E_OPEN_PASSIVE;

        case TCP_C_SEND:
            return TCP_E_SEND;

        case TCP_C_CLOSE:
            return TCP_E_CLOSE;

        case TCP_C_ABORT:
            return TCP_E_ABORT;

        case TCP_C_STATUS:
            return TCP_E_STATUS;

        case TCP_C_QUEUE_BYTES_LIMIT:
            return TCP_E_QUEUE_BYTES_LIMIT;

        case TCP_C_READ:
            return TCP_E_READ;

        default:
            throw cRuntimeError(tcpMain, "Unknown message kind in app command");
    }
}

void inet::tcp::TCPConnection::printConnBrief ( ) const

virtual

Utility: prints local/remote addr/port and app gate index/connId.

{
    EV_DETAIL << "Connection "
              << localAddr << ":" << localPort << " to " << remoteAddr << ":" << remotePort
              << "  on app[" << appGateIndex << "], connId=" << connId
              << "  in " << stateName(fsm.getState())
              << "\n";
}

void inet::tcp::TCPConnection::printSegmentBrief ( TCPSegment *  tcpseg )

static

Utility: prints important header fields.

Referenced by process_RCV_SEGMENT(), segmentArrivalWhileClosed(), and sendToIP().

{
    EV_STATICCONTEXT;
    EV_INFO << "." << tcpseg->getSrcPort() << " > ";
    EV_INFO << "." << tcpseg->getDestPort() << ": ";

    if (tcpseg->getSynBit())
        EV_INFO << (tcpseg->getAckBit() ? "SYN+ACK " : "SYN ");

    if (tcpseg->getFinBit())
        EV_INFO << "FIN(+ACK) ";

    if (tcpseg->getRstBit())
        EV_INFO << (tcpseg->getAckBit() ? "RST+ACK " : "RST ");

    if (tcpseg->getPshBit())
        EV_INFO << "PSH ";

    if (tcpseg->getPayloadLength() > 0 || tcpseg->getSynBit()) {
        EV_INFO << "[" << tcpseg->getSequenceNo() << ".." << (tcpseg->getSequenceNo() + tcpseg->getPayloadLength()) << ") ";
        EV_INFO << "(l=" << tcpseg->getPayloadLength() << ") ";
    }

    if (tcpseg->getAckBit())
        EV_INFO << "ack " << tcpseg->getAckNo() << " ";

    EV_INFO << "win " << tcpseg->getWindow() << " ";

    if (tcpseg->getUrgBit())
        EV_INFO << "urg " << tcpseg->getUrgentPointer() << " ";

    if (tcpseg->getHeaderLength() > TCP_HEADER_OCTETS) {    // Header options present? TCP_HEADER_OCTETS = 20
        EV_INFO << "options ";

        for (uint i = 0; i < tcpseg->getHeaderOptionArraySize(); i++) {
            const TCPOption *option = tcpseg->getHeaderOption(i);
            short kind = option->getKind();
            EV_INFO << optionName(kind) << " ";
        }
    }
    EV_INFO << "\n";
}

void inet::tcp::TCPConnection::process_ABORT ( TCPEventCode &  event, TCPCommand *  tcpCommand, cMessage *  msg  )

protectedvirtual

{
    delete tcpCommand;
    delete msg;

    //
    // The ABORT event will automatically take the connection to the CLOSED
    // state, flush queues etc -- no need to do it here. Also, we don't need to
    // send notification to the user, they know what's going on.
    //
    switch (fsm.getState()) {
        case TCP_S_INIT:
            throw cRuntimeError("Error processing command ABORT: connection not open");

        case TCP_S_SYN_RCVD:
        case TCP_S_ESTABLISHED:
        case TCP_S_FIN_WAIT_1:
        case TCP_S_FIN_WAIT_2:
        case TCP_S_CLOSE_WAIT:
            //"
            // Send a reset segment:
            //
            //   <SEQ=SND.NXT><CTL=RST>
            //"
            sendRst(state->snd_nxt);
            break;
    }
}

void inet::tcp::TCPConnection::process_CLOSE ( TCPEventCode &  event, TCPCommand *  tcpCommand, cMessage *  msg  )

protectedvirtual

{
    delete tcpCommand;
    delete msg;

    switch (fsm.getState()) {
        case TCP_S_INIT:
            throw cRuntimeError(tcpMain, "Error processing command CLOSE: connection not open");

        case TCP_S_LISTEN:
            // Nothing to do here
            break;

        case TCP_S_SYN_SENT:
            // Delete the TCB and return "error:  closing" responses to any
            // queued SENDs, or RECEIVEs.
            break;

        case TCP_S_SYN_RCVD:
        case TCP_S_ESTABLISHED:
        case TCP_S_CLOSE_WAIT:
            //
            // SYN_RCVD processing (ESTABLISHED and CLOSE_WAIT are similar):
            //"
            // If no SENDs have been issued and there is no pending data to send,
            // then form a FIN segment and send it, and enter FIN-WAIT-1 state;
            // otherwise queue for processing after entering ESTABLISHED state.
            //"
            if (state->snd_max == sendQueue->getBufferEndSeq()) {
                EV_DETAIL << "No outstanding SENDs, sending FIN right away, advancing snd_nxt over the FIN\n";
                state->snd_nxt = state->snd_max;
                sendFin();
                tcpAlgorithm->restartRexmitTimer();
                state->snd_max = ++state->snd_nxt;

                if (unackedVector)
                    unackedVector->record(state->snd_max - state->snd_una);

                // state transition will automatically take us to FIN_WAIT_1 (or LAST_ACK)
            }
            else {
                EV_DETAIL << "SEND of " << (sendQueue->getBufferEndSeq() - state->snd_max)
                          << " bytes pending, deferring sending of FIN\n";
                event = TCP_E_IGNORE;
            }
            state->send_fin = true;
            state->snd_fin_seq = sendQueue->getBufferEndSeq();
            break;

        case TCP_S_FIN_WAIT_1:
        case TCP_S_FIN_WAIT_2:
        case TCP_S_CLOSING:
        case TCP_S_LAST_ACK:
        case TCP_S_TIME_WAIT:
            // RFC 793 is not entirely clear on how to handle a duplicate close request.
            // Here we treat it as an error.
            throw cRuntimeError(tcpMain, "Duplicate CLOSE command: connection already closing");
    }
}

void inet::tcp::TCPConnection::process_OPEN_ACTIVE ( TCPEventCode &  event, TCPCommand *  tcpCommand, cMessage *  msg  )

protectedvirtual

{
    TCPOpenCommand *openCmd = check_and_cast<TCPOpenCommand *>(tcpCommand);
    L3Address localAddr, remoteAddr;
    int localPort, remotePort;

    switch (fsm.getState()) {
        case TCP_S_INIT:
            initConnection(openCmd);

            // store local/remote socket
            state->active = true;
            localAddr = openCmd->getLocalAddr();
            remoteAddr = openCmd->getRemoteAddr();
            localPort = openCmd->getLocalPort();
            remotePort = openCmd->getRemotePort();

            if (remoteAddr.isUnspecified() || remotePort == -1)
                throw cRuntimeError(tcpMain, "Error processing command OPEN_ACTIVE: remote address and port must be specified");

            if (localPort == -1) {
                localPort = tcpMain->getEphemeralPort();
                EV_DETAIL << "Assigned ephemeral port " << localPort << "\n";
            }

            EV_DETAIL << "OPEN: " << localAddr << ":" << localPort << " --> " << remoteAddr << ":" << remotePort << "\n";

            tcpMain->addSockPair(this, localAddr, remoteAddr, localPort, remotePort);

            // send initial SYN
            selectInitialSeqNum();
            sendSyn();
            startSynRexmitTimer();
            scheduleTimeout(connEstabTimer, TCP_TIMEOUT_CONN_ESTAB);
            break;

        default:
            throw cRuntimeError(tcpMain, "Error processing command OPEN_ACTIVE: connection already exists");
    }

    delete openCmd;
    delete msg;
}

void inet::tcp::TCPConnection::process_OPEN_PASSIVE ( TCPEventCode &  event, TCPCommand *  tcpCommand, cMessage *  msg  )

protectedvirtual

{
    TCPOpenCommand *openCmd = check_and_cast<TCPOpenCommand *>(tcpCommand);
    L3Address localAddr;
    int localPort;

    switch (fsm.getState()) {
        case TCP_S_INIT:
            initConnection(openCmd);

            // store local/remote socket
            state->active = false;
            state->fork = openCmd->getFork();
            localAddr = openCmd->getLocalAddr();
            localPort = openCmd->getLocalPort();

            if (localPort == -1)
                throw cRuntimeError(tcpMain, "Error processing command OPEN_PASSIVE: local port must be specified");

            EV_DETAIL << "Starting to listen on: " << localAddr << ":" << localPort << "\n";

            tcpMain->addSockPair(this, localAddr, L3Address(), localPort, -1);
            break;

        default:
            throw cRuntimeError(tcpMain, "Error processing command OPEN_PASSIVE: connection already exists");
    }

    delete openCmd;
    delete msg;
}

void inet::tcp::TCPConnection::process_QUEUE_BYTES_LIMIT ( TCPEventCode &  event, TCPCommand *  tcpCommand, cMessage *  msg  )

protectedvirtual

{
    if (state == nullptr)
        throw cRuntimeError("Called process_QUEUE_BYTES_LIMIT on uninitialized TCPConnection!");

    state->sendQueueLimit = tcpCommand->getUserId();    // Set queue size limit
    EV << "state->sendQueueLimit set to " << state->sendQueueLimit << "\n";
    delete msg;
    delete tcpCommand;
}

TCPEventCode inet::tcp::TCPConnection::process_RCV_SEGMENT ( TCPSegment *  tcpseg, L3Address  src, L3Address  dest  )

protectedvirtual

Process incoming TCP segment.

Returns a specific event code (e.g. TCP_E_RCV_SYN) which will drive the state machine.

{
    EV_INFO << "Seg arrived: ";
    printSegmentBrief(tcpseg);
    EV_DETAIL << "TCB: " << state->info() << "\n";

    if (rcvSeqVector)
        rcvSeqVector->record(tcpseg->getSequenceNo());

    if (rcvAckVector)
        rcvAckVector->record(tcpseg->getAckNo());

    //
    // Note: this code is organized exactly as RFC 793, section "3.9 Event
    // Processing", subsection "SEGMENT ARRIVES".
    //
    TCPEventCode event;

    if (fsm.getState() == TCP_S_LISTEN) {
        event = processSegmentInListen(tcpseg, src, dest);
    }
    else if (fsm.getState() == TCP_S_SYN_SENT) {
        event = processSegmentInSynSent(tcpseg, src, dest);
    }
    else {
        // RFC 793 steps "first check sequence number", "second check the RST bit", etc
        event = processSegment1stThru8th(tcpseg);
    }

    delete tcpseg;
    return event;
}

void inet::tcp::TCPConnection::process_READ_REQUEST ( TCPEventCode &  event, TCPCommand *  tcpCommand, cMessage *  msg  )

protectedvirtual

{
    delete msg;
    cMessage *dataMsg;
    while ((dataMsg = receiveQueue->extractBytesUpTo(state->rcv_nxt)) != nullptr)
    {
        dataMsg->setKind(TCP_I_DATA);
        TCPCommand *cmd = new TCPCommand();
        cmd->setConnId(connId);
        dataMsg->setControlInfo(cmd);
        sendToApp(dataMsg);
    }
}

void inet::tcp::TCPConnection::process_SEND ( TCPEventCode &  event, TCPCommand *  tcpCommand, cMessage *  msg  )

protectedvirtual

{
    TCPSendCommand *sendCommand = check_and_cast<TCPSendCommand *>(tcpCommand);

    // FIXME how to support PUSH? One option is to treat each SEND as a unit of data,
    // and set PSH at SEND boundaries
    switch (fsm.getState()) {
        case TCP_S_INIT:
            throw cRuntimeError(tcpMain, "Error processing command SEND: connection not open");

        case TCP_S_LISTEN:
            EV_DETAIL << "SEND command turns passive open into active open, sending initial SYN\n";
            state->active = true;
            selectInitialSeqNum();
            sendSyn();
            startSynRexmitTimer();
            scheduleTimeout(connEstabTimer, TCP_TIMEOUT_CONN_ESTAB);
            sendQueue->enqueueAppData(PK(msg));    // queue up for later
            EV_DETAIL << sendQueue->getBytesAvailable(state->snd_una) << " bytes in queue\n";
            break;

        case TCP_S_SYN_RCVD:
        case TCP_S_SYN_SENT:
            EV_DETAIL << "Queueing up data for sending later.\n";
            sendQueue->enqueueAppData(PK(msg));    // queue up for later
            EV_DETAIL << sendQueue->getBytesAvailable(state->snd_una) << " bytes in queue\n";
            break;

        case TCP_S_ESTABLISHED:
        case TCP_S_CLOSE_WAIT:
            sendQueue->enqueueAppData(PK(msg));
            EV_DETAIL << sendQueue->getBytesAvailable(state->snd_una) << " bytes in queue, plus "
                      << (state->snd_max - state->snd_una) << " bytes unacknowledged\n";
            tcpAlgorithm->sendCommandInvoked();
            break;

        case TCP_S_LAST_ACK:
        case TCP_S_FIN_WAIT_1:
        case TCP_S_FIN_WAIT_2:
        case TCP_S_CLOSING:
        case TCP_S_TIME_WAIT:
            throw cRuntimeError(tcpMain, "Error processing command SEND: connection closing");
    }

    if ((state->sendQueueLimit > 0) && (sendQueue->getBytesAvailable(state->snd_una) > state->sendQueueLimit))
        state->queueUpdate = false;

    delete sendCommand;    // msg itself has been taken by the sendQueue
}

void inet::tcp::TCPConnection::process_STATUS ( TCPEventCode &  event, TCPCommand *  tcpCommand, cMessage *  msg  )

protectedvirtual

{
    delete tcpCommand;    // but reuse msg for reply

    if (fsm.getState() == TCP_S_INIT)
        throw cRuntimeError("Error processing command STATUS: connection not open");

    TCPStatusInfo *statusInfo = new TCPStatusInfo();

    statusInfo->setState(fsm.getState());
    statusInfo->setStateName(stateName(fsm.getState()));

    statusInfo->setLocalAddr(localAddr);
    statusInfo->setRemoteAddr(remoteAddr);
    statusInfo->setLocalPort(localPort);
    statusInfo->setRemotePort(remotePort);

    statusInfo->setSnd_mss(state->snd_mss);
    statusInfo->setSnd_una(state->snd_una);
    statusInfo->setSnd_nxt(state->snd_nxt);
    statusInfo->setSnd_max(state->snd_max);
    statusInfo->setSnd_wnd(state->snd_wnd);
    statusInfo->setSnd_up(state->snd_up);
    statusInfo->setSnd_wl1(state->snd_wl1);
    statusInfo->setSnd_wl2(state->snd_wl2);
    statusInfo->setIss(state->iss);
    statusInfo->setRcv_nxt(state->rcv_nxt);
    statusInfo->setRcv_wnd(state->rcv_wnd);
    statusInfo->setRcv_up(state->rcv_up);
    statusInfo->setIrs(state->irs);
    statusInfo->setFin_ack_rcvd(state->fin_ack_rcvd);

    msg->setControlInfo(statusInfo);
    msg->setKind(TCP_I_STATUS);
    sendToApp(msg);
}

void inet::tcp::TCPConnection::process_TIMEOUT_2MSL ( )

protectedvirtual

{
    //"
    // If the time-wait timeout expires on a connection delete the TCB,
    // enter the CLOSED state and return.
    //"
    switch (fsm.getState()) {
        case TCP_S_TIME_WAIT:
            // Nothing to do here. The TIMEOUT_2MSL event will automatically take
            // the connection to CLOSED. We already notified the user
            // (TCP_I_CLOSED) when we entered the TIME_WAIT state from CLOSING,
            // FIN_WAIT_1 or FIN_WAIT_2.
            break;

        default:
            // We should not receive this timeout in this state.
            throw cRuntimeError(tcpMain,
                "Internal error: received time-wait (2MSL) timeout in state %s",
                stateName(fsm.getState()));
    }
}

void inet::tcp::TCPConnection::process_TIMEOUT_CONN_ESTAB ( )

protectedvirtual

{
    switch (fsm.getState()) {
        case TCP_S_SYN_RCVD:
        case TCP_S_SYN_SENT:
            // Nothing to do here. TIMEOUT_CONN_ESTAB event will automatically
            // take the connection to LISTEN or CLOSED, and cancel SYN-REXMIT timer.
            if (state->active) {
                // notify user if we're on the active side
                sendIndicationToApp(TCP_I_TIMED_OUT);
            }
            break;

        default:
            // We should not receive this timeout in this state.
            throw cRuntimeError(tcpMain, "Internal error: received CONN_ESTAB timeout in state %s",
                stateName(fsm.getState()));
    }
}

void inet::tcp::TCPConnection::process_TIMEOUT_FIN_WAIT_2 ( )

protectedvirtual

{
    switch (fsm.getState()) {
        case TCP_S_FIN_WAIT_2:
            // Nothing to do here. The TIMEOUT_FIN_WAIT_2 event will automatically take
            // the connection to CLOSED.
            break;

        default:
            // We should not receive this timeout in this state.
            throw cRuntimeError(tcpMain, "Internal error: received FIN_WAIT_2 timeout in state %s",
                stateName(fsm.getState()));
    }
}

void inet::tcp::TCPConnection::process_TIMEOUT_SYN_REXMIT ( TCPEventCode &  event )

protectedvirtual

{
    if (++state->syn_rexmit_count > MAX_SYN_REXMIT_COUNT) {
        EV_INFO << "Retransmission count during connection setup exceeds " << MAX_SYN_REXMIT_COUNT << ", giving up\n";
        // Note ABORT will take the connection to closed, and cancel CONN-ESTAB timer as well
        event = TCP_E_ABORT;
        return;
    }

    EV_INFO << "Performing retransmission #" << state->syn_rexmit_count << "\n";

    // resend what's needed
    switch (fsm.getState()) {
        case TCP_S_SYN_SENT:
            sendSyn();
            break;

        case TCP_S_SYN_RCVD:
            sendSynAck();
            break;

        default:
            throw cRuntimeError(tcpMain, "Internal error: SYN-REXMIT timer expired while in state %s",
                stateName(fsm.getState()));
    }

    // reschedule timer
    state->syn_rexmit_timeout *= 2;

    if (state->syn_rexmit_timeout > TCP_TIMEOUT_SYN_REXMIT_MAX)
        state->syn_rexmit_timeout = TCP_TIMEOUT_SYN_REXMIT_MAX;

    scheduleTimeout(synRexmitTimer, state->syn_rexmit_timeout);
}

bool inet::tcp::TCPConnection::processAckInEstabEtc ( TCPSegment *  tcpseg )

protectedvirtual

Referenced by processSegment1stThru8th().

{
    EV_DETAIL << "Processing ACK in a data transfer state\n";

    //
    //"
    //  If SND.UNA < SEG.ACK =< SND.NXT then, set SND.UNA <- SEG.ACK.
    //  Any segments on the retransmission queue which are thereby
    //  entirely acknowledged are removed.  Users should receive
    //  positive acknowledgments for buffers which have been SENT and
    //  fully acknowledged (i.e., SEND buffer should be returned with
    //  "ok" response).  If the ACK is a duplicate
    //  (SEG.ACK < SND.UNA), it can be ignored.  If the ACK acks
    //  something not yet sent (SEG.ACK > SND.NXT) then send an ACK,
    //  drop the segment, and return.
    //
    //  If SND.UNA < SEG.ACK =< SND.NXT, the send window should be
    //  updated.  If (SND.WL1 < SEG.SEQ or (SND.WL1 = SEG.SEQ and
    //  SND.WL2 =< SEG.ACK)), set SND.WND <- SEG.WND, set
    //  SND.WL1 <- SEG.SEQ, and set SND.WL2 <- SEG.ACK.
    //
    //  Note that SND.WND is an offset from SND.UNA, that SND.WL1
    //  records the sequence number of the last segment used to update
    //  SND.WND, and that SND.WL2 records the acknowledgment number of
    //  the last segment used to update SND.WND.  The check here
    //  prevents using old segments to update the window.
    //"
    // Note: should use SND.MAX instead of SND.NXT in above checks
    //
    if (seqGE(state->snd_una, tcpseg->getAckNo())) {
        //
        // duplicate ACK? A received TCP segment is a duplicate ACK if all of
        // the following apply:
        //    (1) snd_una == ackNo
        //    (2) segment contains no data
        //    (3) there's unacked data (snd_una != snd_max)
        //
        // Note: ssfnet uses additional constraint "window is the same as last
        // received (not an update)" -- we don't do that because window updates
        // are ignored anyway if neither seqNo nor ackNo has changed.
        //
        if (state->snd_una == tcpseg->getAckNo() && tcpseg->getPayloadLength() == 0 && state->snd_una != state->snd_max) {
            state->dupacks++;

            if (dupAcksVector)
                dupAcksVector->record(state->dupacks);

            // we need to update send window even if the ACK is a dupACK, because rcv win
            // could have been changed if faulty data receiver is not respecting the "do not shrink window" rule
            updateWndInfo(tcpseg);

            tcpAlgorithm->receivedDuplicateAck();
        }
        else {
            // if doesn't qualify as duplicate ACK, just ignore it.
            if (tcpseg->getPayloadLength() == 0) {
                if (state->snd_una != tcpseg->getAckNo())
                    EV_DETAIL << "Old ACK: ackNo < snd_una\n";
                else if (state->snd_una == state->snd_max)
                    EV_DETAIL << "ACK looks duplicate but we have currently no unacked data (snd_una == snd_max)\n";
            }

            // reset counter
            state->dupacks = 0;

            if (dupAcksVector)
                dupAcksVector->record(state->dupacks);
        }
    }
    else if (seqLE(tcpseg->getAckNo(), state->snd_max)) {
        // ack in window.
        uint32 old_snd_una = state->snd_una;
        state->snd_una = tcpseg->getAckNo();

        if (unackedVector)
            unackedVector->record(state->snd_max - state->snd_una);

        // after retransmitting a lost segment, we may get an ack well ahead of snd_nxt
        if (seqLess(state->snd_nxt, state->snd_una))
            state->snd_nxt = state->snd_una;

        // RFC 1323, page 36:
        // "If SND.UNA < SEG.ACK =< SND.NXT then, set SND.UNA <- SEG.ACK.
        // Also compute a new estimate of round-trip time.  If Snd.TS.OK
        // bit is on, use my.TSclock - SEG.TSecr; otherwise use the
        // elapsed time since the first segment in the retransmission
        // queue was sent.  Any segments on the retransmission queue
        // which are thereby entirely acknowledged."
        if (state->ts_enabled)
            tcpAlgorithm->rttMeasurementCompleteUsingTS(getTSecr(tcpseg));
        // Note: If TS is disabled the RTT measurement is completed in TCPBaseAlg::receivedDataAck()

        uint32 discardUpToSeq = state->snd_una;

        // our FIN acked?
        if (state->send_fin && tcpseg->getAckNo() == state->snd_fin_seq + 1) {
            // set flag that our FIN has been acked
            EV_DETAIL << "ACK acks our FIN\n";
            state->fin_ack_rcvd = true;
            discardUpToSeq--;    // the FIN sequence number is not real data
        }

        // acked data no longer needed in send queue
        sendQueue->discardUpTo(discardUpToSeq);

        // acked data no longer needed in rexmit queue
        if (state->sack_enabled)
            rexmitQueue->discardUpTo(discardUpToSeq);

        updateWndInfo(tcpseg);

        // if segment contains data, wait until data has been forwarded to app before sending ACK,
        // otherwise we would use an old ACKNo
        if (tcpseg->getPayloadLength() == 0 && fsm.getState() != TCP_S_SYN_RCVD) {
            // notify
            tcpAlgorithm->receivedDataAck(old_snd_una);

            // in the receivedDataAck we need the old value
            state->dupacks = 0;

            if (dupAcksVector)
                dupAcksVector->record(state->dupacks);
        }
    }
    else {
        ASSERT(seqGreater(tcpseg->getAckNo(), state->snd_max));    // from if-ladder

        // send an ACK, drop the segment, and return.
        tcpAlgorithm->receivedAckForDataNotYetSent(tcpseg->getAckNo());
        state->dupacks = 0;

        if (dupAcksVector)
            dupAcksVector->record(state->dupacks);

        return false;    // means "drop"
    }

    return true;
}

bool inet::tcp::TCPConnection::processAppCommand ( cMessage *  msg )

virtual

Process commands from the application.

Normally returns true. A return value of false means that the connection structure must be deleted by the caller (TCP).

Referenced by inet::tcp::TCP::handleMessage().

{
    printConnBrief();

    // first do actions
    TCPCommand *tcpCommand = (TCPCommand *)(msg->removeControlInfo());
    TCPEventCode event = preanalyseAppCommandEvent(msg->getKind());
    EV_INFO << "App command: " << eventName(event) << "\n";

    switch (event) {
        case TCP_E_OPEN_ACTIVE:
            process_OPEN_ACTIVE(event, tcpCommand, msg);
            break;

        case TCP_E_OPEN_PASSIVE:
            process_OPEN_PASSIVE(event, tcpCommand, msg);
            break;

        case TCP_E_SEND:
            process_SEND(event, tcpCommand, msg);
            break;

        case TCP_E_CLOSE:
            process_CLOSE(event, tcpCommand, msg);
            break;

        case TCP_E_ABORT:
            process_ABORT(event, tcpCommand, msg);
            break;

        case TCP_E_STATUS:
            process_STATUS(event, tcpCommand, msg);
            break;

        case TCP_E_QUEUE_BYTES_LIMIT:
            process_QUEUE_BYTES_LIMIT(event, tcpCommand, msg);
            break;

        case TCP_E_READ:
            process_READ_REQUEST(event, tcpCommand, msg);
            break;

        default:
            throw cRuntimeError(tcpMain, "wrong event code");
    }

    // then state transitions
    return performStateTransition(event);
}

bool inet::tcp::TCPConnection::processMSSOption ( TCPSegment *  tcpseg, const TCPOptionMaxSegmentSize &  option  )

protectedvirtual

Referenced by readHeaderOptions().

{
    if (option.getLength() != 4) {
        EV_ERROR << "ERROR: MSS option length incorrect\n";
        return false;
    }

    if (fsm.getState() != TCP_S_LISTEN && fsm.getState() != TCP_S_SYN_SENT) {
        EV_ERROR << "ERROR: TCP Header Option MSS received, but in unexpected state\n";
        return false;
    }

    // RFC 2581, page 1:
    // "The SMSS is the size of the largest segment that the sender can transmit.
    // This value can be based on the maximum transmission unit of the network,
    // the path MTU discovery [MD90] algorithm, RMSS (see next item), or other
    // factors.  The size does not include the TCP/IP headers and options."
    //
    // "The RMSS is the size of the largest segment the receiver is willing to accept.
    // This is the value specified in the MSS option sent by the receiver during
    // connection startup.  Or, if the MSS option is not used, 536 bytes [Bra89].
    // The size does not include the TCP/IP headers and options."
    //
    //
    // The value of snd_mss (SMSS) is set to the minimum of snd_mss (local parameter) and
    // the value specified in the MSS option received during connection startup.
    state->snd_mss = std::min(state->snd_mss, (uint32)option.getMaxSegmentSize());

    if (state->snd_mss == 0)
        state->snd_mss = 536;

    EV_INFO << "TCP Header Option MSS(=" << option.getMaxSegmentSize() << ") received, SMSS is set to " << state->snd_mss << "\n";
    return true;
}

TCPEventCode inet::tcp::TCPConnection::processRstInSynReceived ( TCPSegment *  tcpseg )

protectedvirtual

Referenced by processSegment1stThru8th().

{
    EV_DETAIL << "Processing RST in SYN_RCVD\n";

    //"
    // If this connection was initiated with a passive OPEN (i.e.,
    // came from the LISTEN state), then return this connection to
    // LISTEN state and return.  The user need not be informed.  If
    // this connection was initiated with an active OPEN (i.e., came
    // from SYN-SENT state) then the connection was refused, signal
    // the user "connection refused".  In either case, all segments
    // on the retransmission queue should be removed.  And in the
    // active OPEN case, enter the CLOSED state and delete the TCB,
    // and return.
    //"

    sendQueue->discardUpTo(sendQueue->getBufferEndSeq());    // flush send queue

    if (state->sack_enabled)
        rexmitQueue->discardUpTo(rexmitQueue->getBufferEndSeq()); // flush rexmit queue

    if (state->active) {
        // signal "connection refused"
        sendIndicationToApp(TCP_I_CONNECTION_REFUSED);
    }

    // on RCV_RST, FSM will go either to LISTEN or to CLOSED, depending on state->active
    // FIXME if this was a forked connection, it should rather close than go back to listening (otherwise we'd now have two listening connections with the original one!)
    return TCP_E_RCV_RST;
}

bool inet::tcp::TCPConnection::processSACKOption ( TCPSegment *  tcpseg, const TCPOptionSack &  option  )

protectedvirtual

Referenced by readHeaderOptions().

{
    if (option.getLength() % 8 != 2) {
        EV_ERROR << "ERROR: option length incorrect\n";
        return false;
    }

    uint n = option.getSackItemArraySize();
    ASSERT(option.getLength() == 2 + n*8);

    if (!state->sack_enabled) {
        EV_ERROR << "ERROR: " << n << " SACK(s) received, but sack_enabled is set to false\n";
        return false;
    }

    if (fsm.getState() != TCP_S_SYN_RCVD && fsm.getState() != TCP_S_ESTABLISHED
        && fsm.getState() != TCP_S_FIN_WAIT_1 && fsm.getState() != TCP_S_FIN_WAIT_2)
    {
        EV_ERROR << "ERROR: TCP Header Option SACK received, but in unexpected state\n";
        return false;
    }

    if (n > 0) {    // sacks present?
        EV_INFO << n << " SACK(s) received:\n";
        for (uint i = 0; i < n; i++) {
            Sack tmp;
            tmp.setStart(option.getSackItem(i).getStart());
            tmp.setEnd(option.getSackItem(i).getEnd());

            EV_INFO << (i + 1) << ". SACK: " << tmp.str() << endl;

            // check for D-SACK
            if (i == 0 && seqLE(tmp.getEnd(), tcpseg->getAckNo())) {
                // RFC 2883, page 8:
                // "In order for the sender to check that the first (D)SACK block of an
                // acknowledgement in fact acknowledges duplicate data, the sender
                // should compare the sequence space in the first SACK block to the
                // cumulative ACK which is carried IN THE SAME PACKET.  If the SACK
                // sequence space is less than this cumulative ACK, it is an indication
                // that the segment identified by the SACK block has been received more
                // than once by the receiver.  An implementation MUST NOT compare the
                // sequence space in the SACK block to the TCP state variable snd.una
                // (which carries the total cumulative ACK), as this may result in the
                // wrong conclusion if ACK packets are reordered."
                EV_DETAIL << "Received D-SACK below cumulative ACK=" << tcpseg->getAckNo()
                          << " D-SACK: " << tmp.str() << endl;
                // Note: RFC 2883 does not specify what should be done in this case.
                // RFC 2883, page 9:
                // "5. Detection of Duplicate Packets
                // (...) This document does not specify what action a TCP implementation should
                // take in these cases. The extension to the SACK option simply enables
                // the sender to detect each of these cases.(...)"
            }
            else if (i == 0 && n > 1 && seqGreater(tmp.getEnd(), tcpseg->getAckNo())) {
                // RFC 2883, page 8:
                // "If the sequence space in the first SACK block is greater than the
                // cumulative ACK, then the sender next compares the sequence space in
                // the first SACK block with the sequence space in the second SACK
                // block, if there is one.  This comparison can determine if the first
                // SACK block is reporting duplicate data that lies above the cumulative
                // ACK."
                Sack tmp2(option.getSackItem(1).getStart(), option.getSackItem(1).getEnd());

                if (tmp2.contains(tmp)) {
                    EV_DETAIL << "Received D-SACK above cumulative ACK=" << tcpseg->getAckNo()
                              << " D-SACK: " << tmp.str()
                              << ", SACK: " << tmp2.str() << endl;
                    // Note: RFC 2883 does not specify what should be done in this case.
                    // RFC 2883, page 9:
                    // "5. Detection of Duplicate Packets
                    // (...) This document does not specify what action a TCP implementation should
                    // take in these cases. The extension to the SACK option simply enables
                    // the sender to detect each of these cases.(...)"
                }
            }

            if (seqGreater(tmp.getEnd(), tcpseg->getAckNo()) && seqGreater(tmp.getEnd(), state->snd_una))
                rexmitQueue->setSackedBit(tmp.getStart(), tmp.getEnd());
            else
                EV_DETAIL << "Received SACK below total cumulative ACK snd_una=" << state->snd_una << "\n";
        }
        state->rcv_sacks += n;    // total counter, no current number

        if (rcvSacksVector)
            rcvSacksVector->record(state->rcv_sacks);

        // update scoreboard
        state->sackedBytes_old = state->sackedBytes;    // needed for RFC 3042 to check if last dupAck contained new sack information
        state->sackedBytes = rexmitQueue->getTotalAmountOfSackedBytes();

        if (sackedBytesVector)
            sackedBytesVector->record(state->sackedBytes);
    }
    return true;
}

bool inet::tcp::TCPConnection::processSACKPermittedOption ( TCPSegment *  tcpseg, const TCPOptionSackPermitted &  option  )

protectedvirtual

Referenced by readHeaderOptions().

{
    if (option.getLength() != 2) {
        EV_ERROR << "ERROR: length incorrect\n";
        return false;
    }

    if (fsm.getState() != TCP_S_LISTEN && fsm.getState() != TCP_S_SYN_SENT) {
        EV_ERROR << "ERROR: TCP Header Option SACK_PERMITTED received, but in unexpected state\n";
        return false;
    }

    state->rcv_sack_perm = true;
    state->sack_enabled = state->sack_support && state->snd_sack_perm && state->rcv_sack_perm;
    EV_INFO << "TCP Header Option SACK_PERMITTED received, SACK (sack_enabled) is set to " << state->sack_enabled << "\n";
    return true;
}

TCPEventCode inet::tcp::TCPConnection::processSegment1stThru8th ( TCPSegment *  tcpseg )

protectedvirtual

Referenced by process_RCV_SEGMENT().

{
    //
    // RFC 793: first check sequence number
    //

    bool acceptable = true;

    if (tcpseg->getHeaderLength() > TCP_HEADER_OCTETS) {    // Header options present? TCP_HEADER_OCTETS = 20
        // PAWS
        if (state->ts_enabled) {
            uint32 tsval = getTSval(tcpseg);
            if (tsval != 0 && seqLess(tsval, state->ts_recent) &&
                (simTime() - state->time_last_data_sent) > PAWS_IDLE_TIME_THRESH)    // PAWS_IDLE_TIME_THRESH = 24 days
            {
                EV_DETAIL << "PAWS: Segment is not acceptable, TSval=" << tsval << " in "
                          << stateName(fsm.getState()) << " state received: dropping segment\n";
                acceptable = false;
            }
        }

        readHeaderOptions(tcpseg);
    }

    if (acceptable)
        acceptable = isSegmentAcceptable(tcpseg);

    if (!acceptable) {
        //"
        // If an incoming segment is not acceptable, an acknowledgment
        // should be sent in reply (unless the RST bit is set, if so drop
        // the segment and return):
        //
        //  <SEQ=SND.NXT><ACK=RCV.NXT><CTL=ACK>
        //"
        if (tcpseg->getRstBit()) {
            EV_DETAIL << "RST with unacceptable seqNum: dropping\n";
        }
        else {
            if (tcpseg->getSynBit()) {
                EV_DETAIL << "SYN with unacceptable seqNum in " << stateName(fsm.getState()) << " state received (SYN duplicat?)\n";
            }
            else if (tcpseg->getPayloadLength() > 0 && state->sack_enabled && seqLess((tcpseg->getSequenceNo() + tcpseg->getPayloadLength()), state->rcv_nxt)) {
                state->start_seqno = tcpseg->getSequenceNo();
                state->end_seqno = tcpseg->getSequenceNo() + tcpseg->getPayloadLength();
                state->snd_dsack = true;
                EV_DETAIL << "SND_D-SACK SET (dupseg rcvd)\n";
            }

            EV_DETAIL << "Segment seqNum not acceptable, sending ACK with current receive seq\n";
            // RFC 2018, page 4:
            // "The receiver SHOULD send an ACK for every valid segment that arrives
            // containing new data, and each of these "duplicate" ACKs SHOULD bear a
            // SACK option."
            //
            // The received segment is not "valid" therefore the ACK will not bear a SACK option, if snd_dsack (D-SACK) is not set.
            sendAck();
        }

        state->rcv_naseg++;

        if (rcvNASegVector)
            rcvNASegVector->record(state->rcv_naseg);

        return TCP_E_IGNORE;
    }

    //
    // RFC 793: second check the RST bit,
    //
    if (tcpseg->getRstBit()) {
        // Note: if we come from LISTEN, processSegmentInListen() has already handled RST.
        switch (fsm.getState()) {
            case TCP_S_SYN_RCVD:
                //"
                // If this connection was initiated with a passive OPEN (i.e.,
                // came from the LISTEN state), then return this connection to
                // LISTEN state and return.  The user need not be informed.  If
                // this connection was initiated with an active OPEN (i.e., came
                // from SYN-SENT state) then the connection was refused, signal
                // the user "connection refused".  In either case, all segments
                // on the retransmission queue should be removed.  And in the
                // active OPEN case, enter the CLOSED state and delete the TCB,
                // and return.
                //"
                return processRstInSynReceived(tcpseg);

            case TCP_S_ESTABLISHED:
            case TCP_S_FIN_WAIT_1:
            case TCP_S_FIN_WAIT_2:
            case TCP_S_CLOSE_WAIT:
                //"
                // If the RST bit is set then, any outstanding RECEIVEs and SEND
                // should receive "reset" responses.  All segment queues should be
                // flushed.  Users should also receive an unsolicited general
                // "connection reset" signal.
                //
                // Enter the CLOSED state, delete the TCB, and return.
                //"
                EV_DETAIL << "RST: performing connection reset, closing connection\n";
                sendIndicationToApp(TCP_I_CONNECTION_RESET);
                return TCP_E_RCV_RST;    // this will trigger state transition

            case TCP_S_CLOSING:
            case TCP_S_LAST_ACK:
            case TCP_S_TIME_WAIT:
                //"
                // enter the CLOSED state, delete the TCB, and return.
                //"
                EV_DETAIL << "RST: closing connection\n";
                return TCP_E_RCV_RST;    // this will trigger state transition

            default:
                ASSERT(0);
                break;
        }
    }

    // RFC 793: third check security and precedence
    // This step is ignored.

    //
    // RFC 793: fourth, check the SYN bit,
    //
    if (tcpseg->getSynBit()) {
        //"
        // If the SYN is in the window it is an error, send a reset, any
        // outstanding RECEIVEs and SEND should receive "reset" responses,
        // all segment queues should be flushed, the user should also
        // receive an unsolicited general "connection reset" signal, enter
        // the CLOSED state, delete the TCB, and return.
        //
        // If the SYN is not in the window this step would not be reached
        // and an ack would have been sent in the first step (sequence
        // number check).
        //"

        ASSERT(isSegmentAcceptable(tcpseg));    // assert SYN is in the window
        EV_DETAIL << "SYN is in the window: performing connection reset, closing connection\n";
        sendIndicationToApp(TCP_I_CONNECTION_RESET);
        return TCP_E_RCV_UNEXP_SYN;
    }

    //
    // RFC 793: fifth check the ACK field,
    //
    if (!tcpseg->getAckBit()) {
        // if the ACK bit is off drop the segment and return
        EV_INFO << "ACK not set, dropping segment\n";
        return TCP_E_IGNORE;
    }

    uint32 old_snd_una = state->snd_una;

    TCPEventCode event = TCP_E_IGNORE;

    if (fsm.getState() == TCP_S_SYN_RCVD) {
        //"
        // If SND.UNA =< SEG.ACK =< SND.NXT then enter ESTABLISHED state
        // and continue processing.
        //
        // If the segment acknowledgment is not acceptable, form a
        // reset segment,
        //
        //  <SEQ=SEG.ACK><CTL=RST>
        //
        // and send it.
        //"
        if (!seqLE(state->snd_una, tcpseg->getAckNo()) || !seqLE(tcpseg->getAckNo(), state->snd_nxt)) {
            sendRst(tcpseg->getAckNo());
            return TCP_E_IGNORE;
        }

        // notify tcpAlgorithm and app layer
        tcpAlgorithm->established(false);
        sendEstabIndicationToApp();

        // This will trigger transition to ESTABLISHED. Timers and notifying
        // app will be taken care of in stateEntered().
        event = TCP_E_RCV_ACK;
    }

    uint32 old_snd_nxt = state->snd_nxt;    // later we'll need to see if snd_nxt changed
    // Note: If one of the last data segments is lost while already in LAST-ACK state (e.g. if using TCPEchoApps)
    // TCP must be able to process acceptable acknowledgments, however please note RFC 793, page 73:
    // "LAST-ACK STATE
    //    The only thing that can arrive in this state is an
    //    acknowledgment of our FIN.  If our FIN is now acknowledged,
    //    delete the TCB, enter the CLOSED state, and return."
    if (fsm.getState() == TCP_S_SYN_RCVD || fsm.getState() == TCP_S_ESTABLISHED ||
        fsm.getState() == TCP_S_FIN_WAIT_1 || fsm.getState() == TCP_S_FIN_WAIT_2 ||
        fsm.getState() == TCP_S_CLOSE_WAIT || fsm.getState() == TCP_S_CLOSING ||
        fsm.getState() == TCP_S_LAST_ACK)
    {
        //
        // ESTABLISHED processing:
        //"
        //  If SND.UNA < SEG.ACK =< SND.NXT then, set SND.UNA <- SEG.ACK.
        //  Any segments on the retransmission queue which are thereby
        //  entirely acknowledged are removed.  Users should receive
        //  positive acknowledgments for buffers which have been SENT and
        //  fully acknowledged (i.e., SEND buffer should be returned with
        //  "ok" response).  If the ACK is a duplicate
        //  (SEG.ACK < SND.UNA), it can be ignored.  If the ACK acks
        //  something not yet sent (SEG.ACK > SND.NXT) then send an ACK,
        //  drop the segment, and return.
        //
        //  If SND.UNA < SEG.ACK =< SND.NXT, the send window should be
        //  updated.  If (SND.WL1 < SEG.SEQ or (SND.WL1 = SEG.SEQ and
        //  SND.WL2 =< SEG.ACK)), set SND.WND <- SEG.WND, set
        //  SND.WL1 <- SEG.SEQ, and set SND.WL2 <- SEG.ACK.
        //
        //  Note that SND.WND is an offset from SND.UNA, that SND.WL1
        //  records the sequence number of the last segment used to update
        //  SND.WND, and that SND.WL2 records the acknowledgment number of
        //  the last segment used to update SND.WND.  The check here
        //  prevents using old segments to update the window.
        //"
        bool ok = processAckInEstabEtc(tcpseg);

        if (!ok)
            return TCP_E_IGNORE; // if acks something not yet sent, drop it
    }

    if ((fsm.getState() == TCP_S_FIN_WAIT_1 && state->fin_ack_rcvd)) {
        //"
        // FIN-WAIT-1 STATE
        //   In addition to the processing for the ESTABLISHED state, if
        //   our FIN is now acknowledged then enter FIN-WAIT-2 and continue
        //   processing in that state.
        //"
        event = TCP_E_RCV_ACK;    // will trigger transition to FIN-WAIT-2
    }

    if (fsm.getState() == TCP_S_FIN_WAIT_2) {
        //"
        // FIN-WAIT-2 STATE
        //  In addition to the processing for the ESTABLISHED state, if
        //  the retransmission queue is empty, the user's CLOSE can be
        //  acknowledged ("ok") but do not delete the TCB.
        //"
        // nothing to do here (in our model, used commands don't need to be
        // acknowledged)
    }

    if (fsm.getState() == TCP_S_CLOSING) {
        //"
        // In addition to the processing for the ESTABLISHED state, if
        // the ACK acknowledges our FIN then enter the TIME-WAIT state,
        // otherwise ignore the segment.
        //"
        if (state->fin_ack_rcvd) {
            EV_INFO << "Our FIN acked -- can go to TIME_WAIT now\n";
            event = TCP_E_RCV_ACK;    // will trigger transition to TIME-WAIT
            scheduleTimeout(the2MSLTimer, TCP_TIMEOUT_2MSL);    // start timer

            // we're entering TIME_WAIT, so we can signal CLOSED the user
            // (the only thing left to do is wait until the 2MSL timer expires)
        }
    }

    if (fsm.getState() == TCP_S_LAST_ACK) {
        //"
        // The only thing that can arrive in this state is an
        // acknowledgment of our FIN.  If our FIN is now acknowledged,
        // delete the TCB, enter the CLOSED state, and return.
        //"
        if (state->send_fin && tcpseg->getAckNo() == state->snd_fin_seq + 1) {
            EV_INFO << "Last ACK arrived\n";
            return TCP_E_RCV_ACK;    // will trigger transition to CLOSED
        }
    }

    if (fsm.getState() == TCP_S_TIME_WAIT) {
        //"
        // The only thing that can arrive in this state is a
        // retransmission of the remote FIN.  Acknowledge it, and restart
        // the 2 MSL timeout.
        //"
        // And we are staying in the TIME_WAIT state.
        //
        sendAck();
        cancelEvent(the2MSLTimer);
        scheduleTimeout(the2MSLTimer, TCP_TIMEOUT_2MSL);
    }

    //
    // RFC 793: sixth, check the URG bit,
    //
    if (tcpseg->getUrgBit() && (fsm.getState() == TCP_S_ESTABLISHED ||
                                fsm.getState() == TCP_S_FIN_WAIT_1 || fsm.getState() == TCP_S_FIN_WAIT_2))
    {
        //"
        // If the URG bit is set, RCV.UP <- max(RCV.UP,SEG.UP), and signal
        // the user that the remote side has urgent data if the urgent
        // pointer (RCV.UP) is in advance of the data consumed.  If the
        // user has already been signaled (or is still in the "urgent
        // mode") for this continuous sequence of urgent data, do not
        // signal the user again.
        //"

        // TBD: URG currently not supported
    }

    //
    // RFC 793: seventh, process the segment text,
    //
    uint32 old_rcv_nxt = state->rcv_nxt;    // if rcv_nxt changes, we need to send/schedule an ACK

    if (fsm.getState() == TCP_S_SYN_RCVD || fsm.getState() == TCP_S_ESTABLISHED ||
        fsm.getState() == TCP_S_FIN_WAIT_1 || fsm.getState() == TCP_S_FIN_WAIT_2)
    {
        //"
        // Once in the ESTABLISHED state, it is possible to deliver segment
        // text to user RECEIVE buffers.  Text from segments can be moved
        // into buffers until either the buffer is full or the segment is
        // empty.  If the segment empties and carries an PUSH flag, then
        // the user is informed, when the buffer is returned, that a PUSH
        // has been received.
        //
        // When the TCP takes responsibility for delivering the data to the
        // user it must also acknowledge the receipt of the data.
        //
        // Once the TCP takes responsibility for the data it advances
        // RCV.NXT over the data accepted, and adjusts RCV.WND as
        // apporopriate to the current buffer availability.  The total of
        // RCV.NXT and RCV.WND should not be reduced.
        //
        // Please note the window management suggestions in section 3.7.
        //
        // Send an acknowledgment of the form:
        //
        //   <SEQ=SND.NXT><ACK=RCV.NXT><CTL=ACK>
        //
        // This acknowledgment should be piggybacked on a segment being
        // transmitted if possible without incurring undue delay.
        //"

        if (tcpseg->getPayloadLength() > 0) {
            // check for full sized segment
            if (tcpseg->getPayloadLength() == state->snd_mss || tcpseg->getPayloadLength() + tcpseg->getHeaderLength() - TCP_HEADER_OCTETS == state->snd_mss)
                state->full_sized_segment_counter++;

            // check for persist probe
            if (tcpseg->getPayloadLength() == 1)
                state->ack_now = true; // TODO how to check if it is really a persist probe?

            tcpseg->truncateSegment(state->rcv_nxt, state->rcv_nxt + state->rcv_wnd);

            updateRcvQueueVars();

            if (hasEnoughSpaceForSegmentInReceiveQueue(tcpseg)) {    // enough freeRcvBuffer in rcvQueue for new segment?
                EV_DETAIL << "Processing segment text in a data transfer state\n";

                // insert into receive buffers. If this segment is contiguous with
                // previously received ones (seqNo == rcv_nxt), rcv_nxt can be increased;
                // otherwise it stays the same but the data must be cached nevertheless
                // (to avoid "Failure to retain above-sequence data" problem, RFC 2525
                // section 2.5).

                uint32 old_usedRcvBuffer = state->usedRcvBuffer;
                state->rcv_nxt = receiveQueue->insertBytesFromSegment(tcpseg);

                if (seqGreater(state->snd_una, old_snd_una)) {
                    // notify
                    tcpAlgorithm->receivedDataAck(old_snd_una);

                    // in the receivedDataAck we need the old value
                    state->dupacks = 0;

                    if (dupAcksVector)
                        dupAcksVector->record(state->dupacks);
                }

                // out-of-order segment?
                if (old_rcv_nxt == state->rcv_nxt) {
                    state->rcv_oooseg++;

                    if (rcvOooSegVector)
                        rcvOooSegVector->record(state->rcv_oooseg);

                    // RFC 2018, page 4:
                    // "The receiver SHOULD send an ACK for every valid segment that arrives
                    // containing new data, and each of these "duplicate" ACKs SHOULD bear a
                    // SACK option."
                    if (state->sack_enabled) {
                        // store start and end sequence numbers of current oooseg in state variables
                        state->start_seqno = tcpseg->getSequenceNo();
                        state->end_seqno = tcpseg->getSequenceNo() + tcpseg->getPayloadLength();

                        if (old_usedRcvBuffer == receiveQueue->getAmountOfBufferedBytes()) {    // D-SACK
                            state->snd_dsack = true;
                            EV_DETAIL << "SND_D-SACK SET (old_rcv_nxt == rcv_nxt duplicated oooseg rcvd)\n";
                        }
                        else {    // SACK
                            state->snd_sack = true;
                            EV_DETAIL << "SND_SACK SET (old_rcv_nxt == rcv_nxt oooseg rcvd)\n";
                        }
                    }

                    tcpAlgorithm->receivedOutOfOrderSegment();
                }
                else {
                    // forward data to app
                    //
                    // FIXME observe PSH bit
                    //
                    // FIXME we should implement socket READ command, and pass up only
                    // as many bytes as requested. rcv_wnd should be decreased
                    // accordingly!
                    //
                    cMessage *msg = nullptr;

                    if (tcpMain->useDataNotification) {
                        msg = new cMessage("Data Notification");
                        msg->setKind(TCP_I_DATA_NOTIFICATION);  // TBD currently we never send TCP_I_URGENT_DATA
                        TCPCommand *cmd = new TCPCommand();
                        cmd->setConnId(connId);
                        msg->setControlInfo(cmd);
                        sendToApp(msg);
                    } else {
                        while ((msg = receiveQueue->extractBytesUpTo(state->rcv_nxt)) != nullptr) {
                            msg->setKind(TCP_I_DATA);    // TBD currently we never send TCP_I_URGENT_DATA
                            TCPCommand *cmd = new TCPCommand();
                            cmd->setConnId(connId);
                            msg->setControlInfo(cmd);
                            sendToApp(msg);
                        }
                    }

                    // if this segment "filled the gap" until the previously arrived segment
                    // that carried a FIN (i.e.rcv_nxt == rcv_fin_seq), we have to advance
                    // rcv_nxt over the FIN.
                    if (state->fin_rcvd && state->rcv_nxt == state->rcv_fin_seq) {
                        state->ack_now = true;    // although not mentioned in [Stevens, W.R.: TCP/IP Illustrated, Volume 2, page 861] seems like we have to set ack_now
                        EV_DETAIL << "All segments arrived up to the FIN segment, advancing rcv_nxt over the FIN\n";
                        state->rcv_nxt = state->rcv_fin_seq + 1;
                        // state transitions will be done in the state machine, here we just set
                        // the proper event code (TCP_E_RCV_FIN or TCP_E_RCV_FIN_ACK)
                        event = TCP_E_RCV_FIN;

                        switch (fsm.getState()) {
                            case TCP_S_FIN_WAIT_1:
                                if (state->fin_ack_rcvd) {
                                    event = TCP_E_RCV_FIN_ACK;
                                    // start the time-wait timer, turn off the other timers
                                    cancelEvent(finWait2Timer);
                                    scheduleTimeout(the2MSLTimer, TCP_TIMEOUT_2MSL);

                                    // we're entering TIME_WAIT, so we can signal CLOSED the user
                                    // (the only thing left to do is wait until the 2MSL timer expires)
                                }
                                break;

                            case TCP_S_FIN_WAIT_2:
                                // Start the time-wait timer, turn off the other timers.
                                cancelEvent(finWait2Timer);
                                scheduleTimeout(the2MSLTimer, TCP_TIMEOUT_2MSL);

                                // we're entering TIME_WAIT, so we can signal CLOSED the user
                                // (the only thing left to do is wait until the 2MSL timer expires)
                                break;

                            case TCP_S_TIME_WAIT:
                                // Restart the 2 MSL time-wait timeout.
                                cancelEvent(the2MSLTimer);
                                scheduleTimeout(the2MSLTimer, TCP_TIMEOUT_2MSL);
                                break;

                            default:
                                break;
                        }
                    }
                }
            }
            else {    // not enough freeRcvBuffer in rcvQueue for new segment
                state->tcpRcvQueueDrops++;    // update current number of tcp receive queue drops

                if (tcpRcvQueueDropsVector)
                    tcpRcvQueueDropsVector->record(state->tcpRcvQueueDrops);

                // if the ACK bit is off drop the segment and return
                EV_WARN << "RcvQueueBuffer has run out, dropping segment\n";
                return TCP_E_IGNORE;
            }
        }
    }

    //
    // RFC 793: eighth, check the FIN bit,
    //
    if (tcpseg->getFinBit()) {
        state->ack_now = true;

        //"
        // If the FIN bit is set, signal the user "connection closing" and
        // return any pending RECEIVEs with same message, advance RCV.NXT
        // over the FIN, and send an acknowledgment for the FIN.  Note that
        // FIN implies PUSH for any segment text not yet delivered to the
        // user.
        //"

        // Note: seems like RFC 793 is not entirely correct here: if the
        // segment is "above sequence" (ie. RCV.NXT < SEG.SEQ), we cannot
        // advance RCV.NXT over the FIN. Instead we remember this sequence
        // number and do it later.
        uint32 fin_seq = (uint32)tcpseg->getSequenceNo() + (uint32)tcpseg->getPayloadLength();

        if (state->rcv_nxt == fin_seq) {
            // advance rcv_nxt over FIN now
            EV_INFO << "FIN arrived, advancing rcv_nxt over the FIN\n";
            state->rcv_nxt++;
            // state transitions will be done in the state machine, here we just set
            // the proper event code (TCP_E_RCV_FIN or TCP_E_RCV_FIN_ACK)
            event = TCP_E_RCV_FIN;

            switch (fsm.getState()) {
                case TCP_S_FIN_WAIT_1:
                    if (state->fin_ack_rcvd) {
                        event = TCP_E_RCV_FIN_ACK;
                        // start the time-wait timer, turn off the other timers
                        cancelEvent(finWait2Timer);
                        scheduleTimeout(the2MSLTimer, TCP_TIMEOUT_2MSL);

                        // we're entering TIME_WAIT, so we can signal CLOSED the user
                        // (the only thing left to do is wait until the 2MSL timer expires)
                    }
                    break;

                case TCP_S_FIN_WAIT_2:
                    // Start the time-wait timer, turn off the other timers.
                    cancelEvent(finWait2Timer);
                    scheduleTimeout(the2MSLTimer, TCP_TIMEOUT_2MSL);

                    // we're entering TIME_WAIT, so we can signal CLOSED the user
                    // (the only thing left to do is wait until the 2MSL timer expires)
                    break;

                case TCP_S_TIME_WAIT:
                    // Restart the 2 MSL time-wait timeout.
                    cancelEvent(the2MSLTimer);
                    scheduleTimeout(the2MSLTimer, TCP_TIMEOUT_2MSL);
                    break;

                default:
                    break;
            }
        }
        else {
            // we'll have to do it later (when an arriving segment "fills the gap")
            EV_DETAIL << "FIN segment above sequence, storing sequence number of FIN\n";
            state->fin_rcvd = true;
            state->rcv_fin_seq = fin_seq;
        }

        // TBD do PUSH stuff
    }

    if (old_rcv_nxt != state->rcv_nxt) {
        // if rcv_nxt changed, either because we received segment text or we
        // received a FIN that needs to be acked (or both), we need to send or
        // schedule an ACK.
        if (state->sack_enabled) {
            if (receiveQueue->getQueueLength() != 0) {
                // RFC 2018, page 4:
                // "If sent at all, SACK options SHOULD be included in all ACKs which do
                // not ACK the highest sequence number in the data receiver's queue."
                state->start_seqno = tcpseg->getSequenceNo();
                state->end_seqno = tcpseg->getSequenceNo() + tcpseg->getPayloadLength();
                state->snd_sack = true;
                EV_DETAIL << "SND_SACK SET (rcv_nxt changed, but receiveQ is not empty)\n";
                state->ack_now = true;    // although not mentioned in [Stevens, W.R.: TCP/IP Illustrated, Volume 2, page 861] seems like we have to set ack_now
            }
        }

        // tcpAlgorithm decides when and how to do ACKs
        tcpAlgorithm->receiveSeqChanged();
    }

    if ((fsm.getState() == TCP_S_ESTABLISHED || fsm.getState() == TCP_S_SYN_RCVD) &&
        state->send_fin && state->snd_nxt == state->snd_fin_seq + 1)
    {
        // if the user issued the CLOSE command a long time ago and we've just
        // managed to send off FIN, we simulate a CLOSE command now (we had to
        // defer it at that time because we still had data in the send queue.)
        // This CLOSE will take us into the FIN_WAIT_1 state.
        EV_DETAIL << "Now we can do the CLOSE which was deferred a while ago\n";
        event = TCP_E_CLOSE;
    }

    if (fsm.getState() == TCP_S_CLOSE_WAIT && state->send_fin &&
        state->snd_nxt == state->snd_fin_seq + 1 && old_snd_nxt != state->snd_nxt)
    {
        // if we're in CLOSE_WAIT and we just got to sent our long-pending FIN,
        // we simulate a CLOSE command now (we had to defer it at that time because
        // we still had data in the send queue.) This CLOSE will take us into the
        // LAST_ACK state.
        EV_DETAIL << "Now we can do the CLOSE which was deferred a while ago\n";
        event = TCP_E_CLOSE;
    }

    return event;
}

TCPEventCode inet::tcp::TCPConnection::processSegmentInListen ( TCPSegment *  tcpseg, L3Address  src, L3Address  dest  )

protectedvirtual

Referenced by process_RCV_SEGMENT().

{
    EV_DETAIL << "Processing segment in LISTEN\n";

    //"
    // first check for an RST
    //   An incoming RST should be ignored.  Return.
    //"
    if (tcpseg->getRstBit()) {
        EV_INFO << "RST bit set: dropping segment\n";
        return TCP_E_IGNORE;
    }

    //"
    // second check for an ACK
    //    Any acknowledgment is bad if it arrives on a connection still in
    //    the LISTEN state.  An acceptable reset segment should be formed
    //    for any arriving ACK-bearing segment.  The RST should be
    //    formatted as follows:
    //
    //      <SEQ=SEG.ACK><CTL=RST>
    //
    //    Return.
    //"
    if (tcpseg->getAckBit()) {
        EV_INFO << "ACK bit set: dropping segment and sending RST\n";
        sendRst(tcpseg->getAckNo(), destAddr, srcAddr, tcpseg->getDestPort(), tcpseg->getSrcPort());
        return TCP_E_IGNORE;
    }

    //"
    // third check for a SYN
    //"
    if (tcpseg->getSynBit()) {
        if (tcpseg->getFinBit()) {
            // Looks like implementations vary on how to react to SYN+FIN.
            // Some treat it as plain SYN (and reply with SYN+ACK), some send RST+ACK.
            // Let's just do the former here.
            EV_INFO << "SYN+FIN received: ignoring FIN\n";
        }

        EV_DETAIL << "SYN bit set: filling in foreign socket and sending SYN+ACK\n";

        //"
        // If the listen was not fully specified (i.e., the foreign socket was not
        // fully specified), then the unspecified fields should be filled in now.
        //"
        //
        // Also, we may need to fork, in order to leave another connection
        // LISTENing on the port. Note: forking will change our connId.
        //
        if (state->fork) {
            TCPConnection *conn = cloneListeningConnection();    // "conn" is the clone which will stay LISTENing, while "this" gets updated with the remote address
            tcpMain->addForkedConnection(this, conn, destAddr, srcAddr, tcpseg->getDestPort(), tcpseg->getSrcPort());
            EV_DETAIL << "Connection forked: this connection got new connId=" << connId << ", "
                                                                                           "spinoff keeps LISTENing with connId=" << conn->connId << "\n";
        }
        else {
            tcpMain->updateSockPair(this, destAddr, srcAddr, tcpseg->getDestPort(), tcpseg->getSrcPort());
        }

        //"
        //  Set RCV.NXT to SEG.SEQ+1, IRS is set to SEG.SEQ and any other
        //  control or text should be queued for processing later.  ISS
        //  should be selected and a SYN segment sent of the form:
        //
        //    <SEQ=ISS><ACK=RCV.NXT><CTL=SYN,ACK>
        //
        //  SND.NXT is set to ISS+1 and SND.UNA to ISS.  The connection
        //  state should be changed to SYN-RECEIVED.
        //"
        state->rcv_nxt = tcpseg->getSequenceNo() + 1;
        state->rcv_adv = state->rcv_nxt + state->rcv_wnd;

        if (rcvAdvVector)
            rcvAdvVector->record(state->rcv_adv);

        state->irs = tcpseg->getSequenceNo();
        receiveQueue->init(state->rcv_nxt);    // FIXME may init twice...
        selectInitialSeqNum();

        // although not mentioned in RFC 793, seems like we have to pick up
        // initial snd_wnd from the segment here.
        updateWndInfo(tcpseg, true);

        if (tcpseg->getHeaderLength() > TCP_HEADER_OCTETS) // Header options present? TCP_HEADER_OCTETS = 20
            readHeaderOptions(tcpseg);

        state->ack_now = true;
        sendSynAck();
        startSynRexmitTimer();

        if (!connEstabTimer->isScheduled())
            scheduleTimeout(connEstabTimer, TCP_TIMEOUT_CONN_ESTAB);

        //"
        // Note that any other incoming control or data (combined with SYN)
        // will be processed in the SYN-RECEIVED state, but processing of SYN
        // and ACK should not be repeated.
        //"
        // We don't send text in SYN or SYN+ACK, but accept it. Otherwise
        // there isn't much left to do: RST, SYN, ACK, FIN got processed already,
        // so there's only URG and PSH left to handle.
        //
        if (tcpseg->getPayloadLength() > 0) {
            updateRcvQueueVars();

            if (hasEnoughSpaceForSegmentInReceiveQueue(tcpseg)) {    // enough freeRcvBuffer in rcvQueue for new segment?
                receiveQueue->insertBytesFromSegment(tcpseg);
            }
            else {    // not enough freeRcvBuffer in rcvQueue for new segment
                state->tcpRcvQueueDrops++;    // update current number of tcp receive queue drops

                if (tcpRcvQueueDropsVector)
                    tcpRcvQueueDropsVector->record(state->tcpRcvQueueDrops);

                EV_WARN << "RcvQueueBuffer has run out, dropping segment\n";
                return TCP_E_IGNORE;
            }
        }

        if (tcpseg->getUrgBit() || tcpseg->getPshBit())
            EV_DETAIL << "Ignoring URG and PSH bits in SYN\n"; // TBD

        return TCP_E_RCV_SYN;    // this will take us to SYN_RCVD
    }

    //"
    //  fourth other text or control
    //   So you are unlikely to get here, but if you do, drop the segment, and return.
    //"
    EV_WARN << "Unexpected segment: dropping it\n";
    return TCP_E_IGNORE;
}

TCPEventCode inet::tcp::TCPConnection::processSegmentInSynSent ( TCPSegment *  tcpseg, L3Address  src, L3Address  dest  )

protectedvirtual

Referenced by process_RCV_SEGMENT().

{
    EV_DETAIL << "Processing segment in SYN_SENT\n";

    //"
    // first check the ACK bit
    //
    //   If the ACK bit is set
    //
    //     If SEG.ACK =< ISS, or SEG.ACK > SND.NXT, send a reset (unless
    //     the RST bit is set, if so drop the segment and return)
    //
    //       <SEQ=SEG.ACK><CTL=RST>
    //
    //     and discard the segment.  Return.
    //
    //     If SND.UNA =< SEG.ACK =< SND.NXT then the ACK is acceptable.
    //"
    if (tcpseg->getAckBit()) {
        if (seqLE(tcpseg->getAckNo(), state->iss) || seqGreater(tcpseg->getAckNo(), state->snd_nxt)) {
            if (tcpseg->getRstBit())
                EV_DETAIL << "ACK+RST bit set but wrong AckNo, ignored\n";
            else {
                EV_DETAIL << "ACK bit set but wrong AckNo, sending RST\n";
                sendRst(tcpseg->getAckNo(), destAddr, srcAddr, tcpseg->getDestPort(), tcpseg->getSrcPort());
            }
            return TCP_E_IGNORE;
        }

        EV_DETAIL << "ACK bit set, AckNo acceptable\n";
    }

    //"
    // second check the RST bit
    //
    //   If the RST bit is set
    //
    //     If the ACK was acceptable then signal the user "error:
    //     connection reset", drop the segment, enter CLOSED state,
    //     delete TCB, and return.  Otherwise (no ACK) drop the segment
    //     and return.
    //"
    if (tcpseg->getRstBit()) {
        if (tcpseg->getAckBit()) {
            EV_DETAIL << "RST+ACK: performing connection reset\n";
            sendIndicationToApp(TCP_I_CONNECTION_RESET);

            return TCP_E_RCV_RST;
        }
        else {
            EV_DETAIL << "RST without ACK: dropping segment\n";

            return TCP_E_IGNORE;
        }
    }

    //"
    // third check the security and precedence -- not done
    //
    // fourth check the SYN bit
    //
    //   This step should be reached only if the ACK is ok, or there is
    //   no ACK, and it the segment did not contain a RST.
    //
    //   If the SYN bit is on and the security/compartment and precedence
    //   are acceptable then,
    //"
    if (tcpseg->getSynBit()) {
        //
        //   RCV.NXT is set to SEG.SEQ+1, IRS is set to
        //   SEG.SEQ.  SND.UNA should be advanced to equal SEG.ACK (if there
        //   is an ACK), and any segments on the retransmission queue which
        //   are thereby acknowledged should be removed.
        //
        state->rcv_nxt = tcpseg->getSequenceNo() + 1;
        state->rcv_adv = state->rcv_nxt + state->rcv_wnd;

        if (rcvAdvVector)
            rcvAdvVector->record(state->rcv_adv);

        state->irs = tcpseg->getSequenceNo();
        receiveQueue->init(state->rcv_nxt);

        if (tcpseg->getAckBit()) {
            state->snd_una = tcpseg->getAckNo();
            sendQueue->discardUpTo(state->snd_una);

            if (state->sack_enabled)
                rexmitQueue->discardUpTo(state->snd_una);

            // although not mentioned in RFC 793, seems like we have to pick up
            // initial snd_wnd from the segment here.
            updateWndInfo(tcpseg, true);
        }

        // this also seems to be a good time to learn our local IP address
        // (was probably unspecified at connection open)
        tcpMain->updateSockPair(this, destAddr, srcAddr, tcpseg->getDestPort(), tcpseg->getSrcPort());

        //"
        //   If SND.UNA > ISS (our SYN has been ACKed), change the connection
        //   state to ESTABLISHED, form an ACK segment
        //
        //     <SEQ=SND.NXT><ACK=RCV.NXT><CTL=ACK>
        //
        //   and send it.  Data or controls which were queued for
        //   transmission may be included.  If there are other controls or
        //   text in the segment then continue processing at the sixth step
        //   below where the URG bit is checked, otherwise return.
        //"
        if (seqGreater(state->snd_una, state->iss)) {
            EV_INFO << "SYN+ACK bits set, connection established.\n";

            // RFC says "continue processing at the sixth step below where
            // the URG bit is checked". Those steps deal with: URG, segment text
            // (and PSH), and FIN.
            // Now: URG and PSH we don't support yet; in SYN+FIN we ignore FIN;
            // with segment text we just take it easy and put it in the receiveQueue
            // -- we'll forward it to the user when more data arrives.
            if (tcpseg->getFinBit())
                EV_DETAIL << "SYN+ACK+FIN received: ignoring FIN\n";

            if (tcpseg->getPayloadLength() > 0) {
                updateRcvQueueVars();

                if (hasEnoughSpaceForSegmentInReceiveQueue(tcpseg)) {    // enough freeRcvBuffer in rcvQueue for new segment?
                    receiveQueue->insertBytesFromSegment(tcpseg);    // TBD forward to app, etc.
                }
                else {    // not enough freeRcvBuffer in rcvQueue for new segment
                    state->tcpRcvQueueDrops++;    // update current number of tcp receive queue drops

                    if (tcpRcvQueueDropsVector)
                        tcpRcvQueueDropsVector->record(state->tcpRcvQueueDrops);

                    EV_WARN << "RcvQueueBuffer has run out, dropping segment\n";
                    return TCP_E_IGNORE;
                }
            }

            if (tcpseg->getUrgBit() || tcpseg->getPshBit())
                EV_DETAIL << "Ignoring URG and PSH bits in SYN+ACK\n"; // TBD

            if (tcpseg->getHeaderLength() > TCP_HEADER_OCTETS) // Header options present? TCP_HEADER_OCTETS = 20
                readHeaderOptions(tcpseg);

            // notify tcpAlgorithm (it has to send ACK of SYN) and app layer
            state->ack_now = true;
            tcpAlgorithm->established(true);
            tcpMain->emit(TCP::tcpConnectionAddedSignal, this);
            sendEstabIndicationToApp();

            // This will trigger transition to ESTABLISHED. Timers and notifying
            // app will be taken care of in stateEntered().
            return TCP_E_RCV_SYN_ACK;
        }

        //"
        //   Otherwise enter SYN-RECEIVED, form a SYN,ACK segment
        //
        //     <SEQ=ISS><ACK=RCV.NXT><CTL=SYN,ACK>
        //
        //   and send it.  If there are other controls or text in the
        //   segment, queue them for processing after the ESTABLISHED state
        //   has been reached, return.
        //"
        EV_INFO << "SYN bit set: sending SYN+ACK\n";
        state->snd_max = state->snd_nxt = state->iss;
        sendSynAck();
        startSynRexmitTimer();

        // Note: code below is similar to processing SYN in LISTEN.

        // For consistency with that code, we ignore SYN+FIN here
        if (tcpseg->getFinBit())
            EV_DETAIL << "SYN+FIN received: ignoring FIN\n";

        // We don't send text in SYN or SYN+ACK, but accept it. Otherwise
        // there isn't much left to do: RST, SYN, ACK, FIN got processed already,
        // so there's only URG and PSH left to handle.
        if (tcpseg->getPayloadLength() > 0) {
            updateRcvQueueVars();

            if (hasEnoughSpaceForSegmentInReceiveQueue(tcpseg)) {    // enough freeRcvBuffer in rcvQueue for new segment?
                receiveQueue->insertBytesFromSegment(tcpseg);    // TBD forward to app, etc.
            }
            else {    // not enough freeRcvBuffer in rcvQueue for new segment
                state->tcpRcvQueueDrops++;    // update current number of tcp receive queue drops

                if (tcpRcvQueueDropsVector)
                    tcpRcvQueueDropsVector->record(state->tcpRcvQueueDrops);

                EV_WARN << "RcvQueueBuffer has run out, dropping segment\n";
                return TCP_E_IGNORE;
            }
        }

        if (tcpseg->getUrgBit() || tcpseg->getPshBit())
            EV_DETAIL << "Ignoring URG and PSH bits in SYN\n"; // TBD

        return TCP_E_RCV_SYN;
    }

    //"
    // fifth, if neither of the SYN or RST bits is set then drop the
    // segment and return.
    //"
    return TCP_E_IGNORE;
}

bool inet::tcp::TCPConnection::processTCPSegment ( TCPSegment *  tcpSeg, L3Address  srcAddr, L3Address  destAddr  )

virtual

Process incoming TCP segment.

Normally returns true. A return value of false means that the connection structure must be deleted by the caller (TCP).

Referenced by inet::tcp::TCP::handleMessage().

{
    printConnBrief();
    if (!localAddr.isUnspecified()) {
        ASSERT(localAddr == segDestAddr);
        ASSERT(localPort == tcpseg->getDestPort());
    }

    if (!remoteAddr.isUnspecified()) {
        ASSERT(remoteAddr == segSrcAddr);
        ASSERT(remotePort == tcpseg->getSrcPort());
    }

    if (tryFastRoute(tcpseg))
        return true;

    // first do actions
    TCPEventCode event = process_RCV_SEGMENT(tcpseg, segSrcAddr, segDestAddr);

    // then state transitions
    return performStateTransition(event);
}

bool inet::tcp::TCPConnection::processTimer ( cMessage *  msg )

virtual

Process self-messages (timers).

Normally returns true. A return value of false means that the connection structure must be deleted by the caller (TCP).

Referenced by inet::tcp::TCP::handleMessage().

{
    printConnBrief();
    EV_DETAIL << msg->getName() << " timer expired\n";

    // first do actions
    TCPEventCode event;

    if (msg == the2MSLTimer) {
        event = TCP_E_TIMEOUT_2MSL;
        process_TIMEOUT_2MSL();
    }
    else if (msg == connEstabTimer) {
        event = TCP_E_TIMEOUT_CONN_ESTAB;
        process_TIMEOUT_CONN_ESTAB();
    }
    else if (msg == finWait2Timer) {
        event = TCP_E_TIMEOUT_FIN_WAIT_2;
        process_TIMEOUT_FIN_WAIT_2();
    }
    else if (msg == synRexmitTimer) {
        event = TCP_E_IGNORE;
        process_TIMEOUT_SYN_REXMIT(event);
    }
    else {
        event = TCP_E_IGNORE;
        tcpAlgorithm->processTimer(msg, event);
    }

    // then state transitions
    return performStateTransition(event);
}

bool inet::tcp::TCPConnection::processTSOption ( TCPSegment *  tcpseg, const TCPOptionTimestamp &  option  )

protectedvirtual

Referenced by readHeaderOptions().

{
    if (option.getLength() != 10) {
        EV_ERROR << "ERROR: length incorrect\n";
        return false;
    }

    if ((!state->ts_enabled && fsm.getState() != TCP_S_LISTEN && fsm.getState() != TCP_S_SYN_SENT) ||
        (state->ts_enabled && fsm.getState() != TCP_S_SYN_RCVD && fsm.getState() != TCP_S_ESTABLISHED &&
         fsm.getState() != TCP_S_FIN_WAIT_1 && fsm.getState() != TCP_S_FIN_WAIT_2))
    {
        EV_ERROR << "ERROR: TCP Header Option TS received, but in unexpected state\n";
        return false;
    }

    if (!state->ts_enabled) {
        state->rcv_initial_ts = true;
        state->ts_enabled = state->ts_support && state->snd_initial_ts && state->rcv_initial_ts;
        EV_INFO << "TCP Header Option TS(TSval=" << option.getSenderTimestamp() << ", TSecr=" << option.getEchoedTimestamp() << ") received, TS (ts_enabled) is set to " << state->ts_enabled << "\n";
    }
    else
        EV_INFO << "TCP Header Option TS(TSval=" << option.getSenderTimestamp() << ", TSecr=" << option.getEchoedTimestamp() << ") received\n";

    // RFC 1323, page 35:
    // "Check whether the segment contains a Timestamps option and bit
    // Snd.TS.OK is on.  If so:
    //   If SEG.TSval < TS.Recent, then test whether connection has
    //   been idle less than 24 days; if both are true, then the
    //   segment is not acceptable; follow steps below for an
    //   unacceptable segment.
    //   If SEG.SEQ is equal to Last.ACK.sent, then save SEG.[TSval] in
    //   variable TS.Recent."
    if (state->ts_enabled) {
        if (seqLess(option.getSenderTimestamp(), state->ts_recent)) {
            if ((simTime() - state->time_last_data_sent) > PAWS_IDLE_TIME_THRESH) {    // PAWS_IDLE_TIME_THRESH = 24 days
                EV_DETAIL << "PAWS: Segment is not acceptable, TSval=" << option.getSenderTimestamp() << " in " << stateName(fsm.getState()) << " state received: dropping segment\n";
                return false;
            }
        }
        else if (seqLE(tcpseg->getSequenceNo(), state->last_ack_sent)) {    // Note: test is modified according to the latest proposal of the [email protected] list (Braden 1993/04/26)
            state->ts_recent = option.getSenderTimestamp();
            EV_DETAIL << "Updating ts_recent from segment: new ts_recent=" << state->ts_recent << "\n";
        }
    }

    return true;
}

bool inet::tcp::TCPConnection::processWSOption ( TCPSegment *  tcpseg, const TCPOptionWindowScale &  option  )

protectedvirtual

Referenced by readHeaderOptions().

{
    if (option.getLength() != 3) {
        EV_ERROR << "ERROR: length incorrect\n";
        return false;
    }

    if (fsm.getState() != TCP_S_LISTEN && fsm.getState() != TCP_S_SYN_SENT) {
        EV_ERROR << "ERROR: TCP Header Option WS received, but in unexpected state\n";
        return false;
    }

    state->rcv_ws = true;
    state->ws_enabled = state->ws_support && state->snd_ws && state->rcv_ws;
    state->snd_wnd_scale = option.getWindowScale();
    EV_INFO << "TCP Header Option WS(=" << state->snd_wnd_scale << ") received, WS (ws_enabled) is set to " << state->ws_enabled << "\n";

    if (state->snd_wnd_scale > 14) {    // RFC 1323, page 11: "the shift count must be limited to 14"
        EV_ERROR << "ERROR: TCP Header Option WS received but shift count value is exceeding 14\n";
        state->snd_wnd_scale = 14;
    }

    return true;
}

void inet::tcp::TCPConnection::readHeaderOptions ( TCPSegment *  tcpseg )

protectedvirtual

Utility: readHeaderOptions (Currently only EOL, NOP, MSS, WS, SACK_PERMITTED, SACK and TS are implemented)

Referenced by processSegment1stThru8th(), processSegmentInListen(), and processSegmentInSynSent().

{
    EV_INFO << "TCP Header Option(s) received:\n";

    for (uint i = 0; i < tcpseg->getHeaderOptionArraySize(); i++) {
        const TCPOption *option = tcpseg->getHeaderOption(i);
        short kind = option->getKind();
        short length = option->getLength();
        bool ok = true;

        EV_DETAIL << "Option type " << kind << " (" << optionName(kind) << "), length " << length << "\n";

        switch (kind) {
            case TCPOPTION_END_OF_OPTION_LIST:    // EOL=0
            case TCPOPTION_NO_OPERATION:    // NOP=1
                if (length != 1) {
                    EV_ERROR << "ERROR: option length incorrect\n";
                    ok = false;
                }
                break;

            case TCPOPTION_MAXIMUM_SEGMENT_SIZE:    // MSS=2
                ok = processMSSOption(tcpseg, *check_and_cast<const TCPOptionMaxSegmentSize *>(option));
                break;

            case TCPOPTION_WINDOW_SCALE:    // WS=3
                ok = processWSOption(tcpseg, *check_and_cast<const TCPOptionWindowScale *>(option));
                break;

            case TCPOPTION_SACK_PERMITTED:    // SACK_PERMITTED=4
                ok = processSACKPermittedOption(tcpseg, *check_and_cast<const TCPOptionSackPermitted *>(option));
                break;

            case TCPOPTION_SACK:    // SACK=5
                ok = processSACKOption(tcpseg, *check_and_cast<const TCPOptionSack *>(option));
                break;

            case TCPOPTION_TIMESTAMP:    // TS=8
                ok = processTSOption(tcpseg, *check_and_cast<const TCPOptionTimestamp *>(option));
                break;

            // TODO add new TCPOptions here once they are implemented
            // TODO delegate to TCPAlgorithm as well -- it may want to recognized additional options

            default:
                EV_ERROR << "ERROR: Unsupported TCP option kind " << kind << "\n";
                break;
        }
        (void)ok;    // unused
    }
}

void inet::tcp::TCPConnection::retransmitData ( )

virtual

Utility: retransmit all from snd_una to snd_max.

Referenced by inet::tcp::DumbTCP::processTimer().

{
    // retransmit everything from snd_una
    state->snd_nxt = state->snd_una;

    uint32 bytesToSend = state->snd_max - state->snd_nxt;

    // FIN (without user data) needs to be resent
    if (bytesToSend == 0 && state->send_fin && state->snd_fin_seq == sendQueue->getBufferEndSeq()) {
        state->snd_max = sendQueue->getBufferEndSeq();
        EV_DETAIL << "No outstanding DATA, resending FIN, advancing snd_nxt over the FIN\n";
        state->snd_nxt = state->snd_max;
        sendFin();
        state->snd_max = ++state->snd_nxt;

        if (unackedVector)
            unackedVector->record(state->snd_max - state->snd_una);
        return;
    }

    ASSERT(bytesToSend != 0);

    // TBD - avoid to send more than allowed - check cwnd and rwnd before retransmitting data!
    while (bytesToSend > 0) {
        uint32 bytes = std::min(bytesToSend, state->snd_mss);
        bytes = std::min(bytes, (uint32)(sendQueue->getBytesAvailable(state->snd_nxt)));
        sendSegment(bytes);

        // Do not send packets after the FIN.
        // fixes bug that occurs in examples/inet/bulktransfer at event #64043  T=13.861159213744
        if (state->send_fin && state->snd_nxt == state->snd_fin_seq + 1)
            break;

        bytesToSend -= state->sentBytes;
    }
    tcpAlgorithm->segmentRetransmitted(state->snd_una, state->snd_nxt);
}

void inet::tcp::TCPConnection::retransmitOneSegment ( bool  called_at_rto )

virtual

Utility: retransmit one segment from snd_una.

Referenced by inet::tcp::TCPNoCongestionControl::processRexmitTimer(), inet::tcp::TCPNewReno::processRexmitTimer(), inet::tcp::TCPReno::processRexmitTimer(), inet::tcp::TCPTahoe::processRexmitTimer(), inet::tcp::TCPWestwood::processRexmitTimer(), inet::tcp::TCPVegas::processRexmitTimer(), inet::tcp::TCPNewReno::receivedDataAck(), inet::tcp::TCPVegas::receivedDataAck(), inet::tcp::TCPReno::receivedDuplicateAck(), inet::tcp::TCPNewReno::receivedDuplicateAck(), inet::tcp::TCPTahoe::receivedDuplicateAck(), inet::tcp::TCPWestwood::receivedDuplicateAck(), and inet::tcp::TCPVegas::receivedDuplicateAck().

{
    uint32 old_snd_nxt = state->snd_nxt;

    // retransmit one segment at snd_una, and set snd_nxt accordingly (if not called at RTO)
    state->snd_nxt = state->snd_una;

    // When FIN sent the snd_max - snd_nxt larger than bytes available in queue
    ulong bytes = std::min((ulong)std::min(state->snd_mss, state->snd_max - state->snd_nxt),
                sendQueue->getBytesAvailable(state->snd_nxt));

    // FIN (without user data) needs to be resent
    if (bytes == 0 && state->send_fin && state->snd_fin_seq == sendQueue->getBufferEndSeq()) {
        state->snd_max = sendQueue->getBufferEndSeq();
        EV_DETAIL << "No outstanding DATA, resending FIN, advancing snd_nxt over the FIN\n";
        state->snd_nxt = state->snd_max;
        sendFin();
        tcpAlgorithm->segmentRetransmitted(state->snd_nxt, state->snd_nxt + 1);
        state->snd_max = ++state->snd_nxt;

        if (unackedVector)
            unackedVector->record(state->snd_max - state->snd_una);
    }
    else {
        ASSERT(bytes != 0);

        sendSegment(bytes);
        tcpAlgorithm->segmentRetransmitted(state->snd_una, state->snd_nxt);

        if (!called_at_rto) {
            if (seqGreater(old_snd_nxt, state->snd_nxt))
                state->snd_nxt = old_snd_nxt;
        }

        // notify
        tcpAlgorithm->ackSent();

        if (state->sack_enabled) {
            // RFC 3517, page 7: "(3) Retransmit the first data segment presumed dropped -- the segment
            // starting with sequence number HighACK + 1.  To prevent repeated
            // retransmission of the same data, set HighRxt to the highest
            // sequence number in the retransmitted segment."
            state->highRxt = rexmitQueue->getHighestRexmittedSeqNum();
        }
    }
}

void inet::tcp::TCPConnection::scheduleTimeout ( cMessage *  msg, simtime_t  timeout  )

inline

Utility: start a timer.

Referenced by inet::tcp::DumbTCP::dataSent(), process_OPEN_ACTIVE(), process_SEND(), process_TIMEOUT_SYN_REXMIT(), inet::tcp::TCPBaseAlg::processPersistTimer(), inet::tcp::TCPBaseAlg::processRexmitTimer(), processSegment1stThru8th(), processSegmentInListen(), inet::tcp::DumbTCP::processTimer(), inet::tcp::TCPBaseAlg::receivedDataAck(), inet::tcp::TCPBaseAlg::receiveSeqChanged(), inet::tcp::TCPBaseAlg::startRexmitTimer(), and startSynRexmitTimer().

    { tcpMain->scheduleAt(simTime() + timeout, msg); }

void inet::tcp::TCPConnection::segmentArrivalWhileClosed ( TCPSegment *  tcpseg, L3Address  src, L3Address  dest  )

virtual

This method gets invoked from TCP when a segment arrives which doesn't belong to an existing connection.

TCP creates a temporary connection object so that it can call this method, then immediately deletes it.

Referenced by inet::tcp::TCP::segmentArrivalWhileClosed().

{
    EV_INFO << "Seg arrived: ";
    printSegmentBrief(tcpseg);

    // This segment doesn't belong to any connection, so this object
    // must be a temp object created solely for the purpose of calling us

    ASSERT(state == nullptr);

    EV_INFO << "Segment doesn't belong to any existing connection\n";

    // RFC 793:
    //"
    // all data in the incoming segment is discarded.  An incoming
    // segment containing a RST is discarded.  An incoming segment not
    // containing a RST causes a RST to be sent in response.  The
    // acknowledgment and sequence field values are selected to make the
    // reset sequence acceptable to the TCP that sent the offending
    // segment.
    //
    // If the ACK bit is off, sequence number zero is used,
    //
    //    <SEQ=0><ACK=SEG.SEQ+SEG.LEN><CTL=RST,ACK>
    //
    // If the ACK bit is on,
    //
    //    <SEQ=SEG.ACK><CTL=RST>
    //
    // ...
    //
    //    SEG.LEN = the number of octets occupied by the data in the segment
    //              (counting SYN and FIN)
    //"
    if (tcpseg->getRstBit()) {
        EV_DETAIL << "RST bit set: dropping segment\n";
        return;
    }

    if (!tcpseg->getAckBit()) {
        EV_DETAIL << "ACK bit not set: sending RST+ACK\n";
        uint32 ackNo = tcpseg->getSequenceNo() + tcpseg->getSegLen();
        sendRstAck(0, ackNo, destAddr, srcAddr, tcpseg->getDestPort(), tcpseg->getSrcPort());
    }
    else {
        EV_DETAIL << "ACK bit set: sending RST\n";
        sendRst(tcpseg->getAckNo(), destAddr, srcAddr, tcpseg->getDestPort(), tcpseg->getSrcPort());
    }
}

void inet::tcp::TCPConnection::selectInitialSeqNum ( )

protectedvirtual

Utility: generates ISS and initializes corresponding state variables.

Referenced by process_OPEN_ACTIVE(), process_SEND(), and processSegmentInListen().

{
    // set the initial send sequence number
    state->iss = (unsigned long)fmod(SIMTIME_DBL(simTime()) * 250000.0, 1.0 + (double)(unsigned)0xffffffffUL) & 0xffffffffUL;

    state->snd_una = state->snd_nxt = state->snd_max = state->iss;

    sendQueue->init(state->iss + 1);    // + 1 is for SYN
    rexmitQueue->init(state->iss + 1);    // + 1 is for SYN
}

void inet::tcp::TCPConnection::sendAck ( )

virtual

Utility: send ACK.

Referenced by inet::tcp::DumbTCP::established(), inet::tcp::TCPBaseAlg::established(), inet::tcp::TCPBaseAlg::processDelayedAckTimer(), processSegment1stThru8th(), inet::tcp::DumbTCP::receivedAckForDataNotYetSent(), inet::tcp::TCPBaseAlg::receivedAckForDataNotYetSent(), inet::tcp::DumbTCP::receivedOutOfOrderSegment(), inet::tcp::TCPBaseAlg::receivedOutOfOrderSegment(), inet::tcp::DumbTCP::receiveSeqChanged(), and inet::tcp::TCPBaseAlg::receiveSeqChanged().

{
    TCPSegment *tcpseg = createTCPSegment("ACK");

    tcpseg->setAckBit(true);
    tcpseg->setSequenceNo(state->snd_nxt);
    tcpseg->setAckNo(state->rcv_nxt);
    tcpseg->setWindow(updateRcvWnd());

    // write header options
    writeHeaderOptions(tcpseg);

    // send it
    sendToIP(tcpseg);

    // notify
    tcpAlgorithm->ackSent();
}

bool inet::tcp::TCPConnection::sendData ( bool  fullSegmentsOnly, uint32  congestionWindow  )

virtual

Utility: Send data from sendQueue, at most congestionWindow.

If fullSegmentsOnly is set, don't send segments smaller than SMSS (needed for Nagle). Returns true if some data was actually sent.

Referenced by inet::tcp::DumbTCP::established(), inet::tcp::DumbTCP::receivedDataAck(), inet::tcp::DumbTCP::sendCommandInvoked(), and inet::tcp::TCPBaseAlg::sendData().

{
    // we'll start sending from snd_max, if not after RTO
    if (!state->afterRto)
        state->snd_nxt = state->snd_max;

    uint32 old_highRxt = 0;

    if (state->sack_enabled)
        old_highRxt = rexmitQueue->getHighestRexmittedSeqNum();

    // check how many bytes we have
    ulong buffered = sendQueue->getBytesAvailable(state->snd_nxt);

    if (buffered == 0)
        return false;

    // maxWindow is minimum of snd_wnd and congestionWindow (snd_cwnd)
    ulong maxWindow = std::min(state->snd_wnd, congestionWindow);

    // effectiveWindow: number of bytes we're allowed to send now
    long effectiveWin = maxWindow - (state->snd_nxt - state->snd_una);

    if (effectiveWin <= 0) {
        EV_WARN << "Effective window is zero (advertised window " << state->snd_wnd
                << ", congestion window " << congestionWindow << "), cannot send.\n";
        return false;
    }

    ulong bytesToSend = effectiveWin;

    if (bytesToSend > buffered)
        bytesToSend = buffered;

    uint32 effectiveMaxBytesSend = state->snd_mss;

    if (state->ts_enabled)
        effectiveMaxBytesSend -= TCP_OPTION_TS_SIZE;

    // last segment could be less than state->snd_mss (or less than snd_mss - TCP_OPTION_TS_SIZE if using TS option)
    if (fullSegmentsOnly && (bytesToSend < (effectiveMaxBytesSend))) {
        EV_WARN << "Cannot send, not enough data for a full segment (SMSS=" << state->snd_mss
                << ", effectiveWindow=" << effectiveWin << ", bytesToSend=" << bytesToSend << ", in buffer " << buffered << ")\n";
        return false;
    }

    // start sending 'bytesToSend' bytes
    EV_INFO << "Will send " << bytesToSend << " bytes (effectiveWindow " << effectiveWin
            << ", in buffer " << buffered << " bytes)\n";

    uint32 old_snd_nxt = state->snd_nxt;

    ASSERT(bytesToSend > 0);

#ifdef TCP_SENDFRAGMENTS    /* normally undefined */
    // make agressive use of the window until the last byte
    while (bytesToSend > 0) {
        ulong bytes = std::min(bytesToSend, state->snd_mss);
        sendSegment(bytes);
        bytesToSend -= state->sentBytes;
    }
#else // ifdef TCP_SENDFRAGMENTS
      // send < MSS segments only if it's the only segment we can send now
      // Note: if (bytesToSend == 1010 && MSS == 1012 && ts_enabled == true) => we may send
      // 2 segments (1000 payload + 12 optionsHeader and 10 payload + 12 optionsHeader)
      // FIXME this should probably obey Nagle's alg -- to be checked
    if (bytesToSend <= state->snd_mss) {
        sendSegment(bytesToSend);
        bytesToSend -= state->sentBytes;
    }
    else {    // send whole segments only (nagle_enabled)
        while (bytesToSend >= effectiveMaxBytesSend) {
            sendSegment(state->snd_mss);
            bytesToSend -= state->sentBytes;
        }
    }

    // check how many bytes we have - last segment could be less than state->snd_mss
    buffered = sendQueue->getBytesAvailable(state->snd_nxt);

    if (bytesToSend == buffered && buffered != 0) // last segment?
        sendSegment(bytesToSend);
    else if (bytesToSend > 0)
        EV_DETAIL << bytesToSend << " bytes of space left in effectiveWindow\n";
#endif // ifdef TCP_SENDFRAGMENTS

    // remember highest seq sent (snd_nxt may be set back on retransmission,
    // but we'll need snd_max to check validity of ACKs -- they must ack
    // something we really sent)
    if (seqGreater(state->snd_nxt, state->snd_max))
        state->snd_max = state->snd_nxt;

    if (unackedVector)
        unackedVector->record(state->snd_max - state->snd_una);

    // notify (once is enough)
    tcpAlgorithm->ackSent();

    if (state->sack_enabled && state->lossRecovery && old_highRxt != state->highRxt) {
        // Note: Restart of REXMIT timer on retransmission is not part of RFC 2581, however optional in RFC 3517 if sent during recovery.
        EV_DETAIL << "Retransmission sent during recovery, restarting REXMIT timer.\n";
        tcpAlgorithm->restartRexmitTimer();
    }
    else // don't measure RTT for retransmitted packets
        tcpAlgorithm->dataSent(old_snd_nxt);

    return true;
}

void inet::tcp::TCPConnection::sendDataDuringLossRecoveryPhase ( uint32  congestionWindow )

virtual

Utility: send data during Loss Recovery phase (if SACK is enabled).

Referenced by inet::tcp::TCPReno::receivedDataAck(), and inet::tcp::TCPReno::receivedDuplicateAck().

{
    ASSERT(state->sack_enabled && state->lossRecovery);

    // RFC 3517 pages 7 and 8: "(5) In order to take advantage of potential additional available
    // cwnd, proceed to step (C) below.
    // (...)
    // (C) If cwnd - pipe >= 1 SMSS the sender SHOULD transmit one or more
    // segments as follows:
    // (...)
    // (C.5) If cwnd - pipe >= 1 SMSS, return to (C.1)"
    while (((int)congestionWindow - (int)state->pipe) >= (int)state->snd_mss) {    // Note: Typecast needed to avoid prohibited transmissions
        // RFC 3517 pages 7 and 8: "(C.1) The scoreboard MUST be queried via NextSeg () for the
        // sequence number range of the next segment to transmit (if any),
        // and the given segment sent.  If NextSeg () returns failure (no
        // data to send) return without sending anything (i.e., terminate
        // steps C.1 -- C.5)."

        uint32 seqNum;

        if (!nextSeg(seqNum)) // if nextSeg() returns false (=failure): terminate steps C.1 -- C.5
            break;

        sendSegmentDuringLossRecoveryPhase(seqNum);
        // RFC 3517 page 8: "(C.4) The estimate of the amount of data outstanding in the
        // network must be updated by incrementing pipe by the number of
        // octets transmitted in (C.1)."
        state->pipe += state->sentBytes;
    }
}

void inet::tcp::TCPConnection::sendEstabIndicationToApp ( )

protectedvirtual

Utility: sends TCP_I_ESTABLISHED indication with TCPConnectInfo to application.

Referenced by processSegment1stThru8th(), and processSegmentInSynSent().

{
    EV_INFO << "Notifying app: " << indicationName(TCP_I_ESTABLISHED) << "\n";
    cMessage *msg = new cMessage(indicationName(TCP_I_ESTABLISHED));
    msg->setKind(TCP_I_ESTABLISHED);

    TCPConnectInfo *ind = new TCPConnectInfo();
    ind->setConnId(connId);
    ind->setLocalAddr(localAddr);
    ind->setRemoteAddr(remoteAddr);
    ind->setLocalPort(localPort);
    ind->setRemotePort(remotePort);

    msg->setControlInfo(ind);
    sendToApp(msg);
}

void inet::tcp::TCPConnection::sendFin ( )

virtual

Utility: sends FIN.

Referenced by process_CLOSE(), retransmitData(), and retransmitOneSegment().

{
    TCPSegment *tcpseg = createTCPSegment("FIN");

    // Note: ACK bit *must* be set for both FIN and FIN+ACK. What makes
    // the difference for FIN+ACK is that its ackNo acks the remote TCP's FIN.
    tcpseg->setFinBit(true);
    tcpseg->setAckBit(true);
    tcpseg->setAckNo(state->rcv_nxt);
    tcpseg->setSequenceNo(state->snd_nxt);
    tcpseg->setWindow(updateRcvWnd());

    // send it
    sendToIP(tcpseg);

    // notify
    tcpAlgorithm->ackSent();
}

void inet::tcp::TCPConnection::sendIndicationToApp ( int  code, const int  id = 0  )

protectedvirtual

Utility: sends status indication (TCP_I_xxx) to application.

Referenced by process_TIMEOUT_CONN_ESTAB(), processRstInSynReceived(), processSegment1stThru8th(), processSegmentInSynSent(), sendSegment(), and signalConnectionTimeout().

{
    EV_INFO << "Notifying app: " << indicationName(code) << "\n";
    cMessage *msg = new cMessage(indicationName(code));
    msg->setKind(code);
    TCPCommand *ind = new TCPCommand();
    ind->setConnId(connId);
    ind->setUserId(id);
    msg->setControlInfo(ind);
    sendToApp(msg);
}

void inet::tcp::TCPConnection::sendOneNewSegment ( bool  fullSegmentsOnly, uint32  congestionWindow  )

virtual

Utility: send one new segment from snd_max if allowed (RFC 3042).

Referenced by inet::tcp::TCPBaseAlg::receivedDuplicateAck().

{
    ASSERT(state->limited_transmit_enabled);

    // RFC 3042, page 3:
    // "When a TCP sender has previously unsent data queued for transmission
    // it SHOULD use the Limited Transmit algorithm, which calls for a TCP
    // sender to transmit new data upon the arrival of the first two
    // consecutive duplicate ACKs when the following conditions are
    // satisfied:
    //
    //  * The receiver's advertised window allows the transmission of the
    //  segment.
    //
    //  * The amount of outstanding data would remain less than or equal
    //  to the congestion window plus 2 segments.  In other words, the
    //  sender can only send two segments beyond the congestion window
    //  (cwnd).
    //
    // The congestion window (cwnd) MUST NOT be changed when these new
    // segments are transmitted.  Assuming that these new segments and the
    // corresponding ACKs are not dropped, this procedure allows the sender
    // to infer loss using the standard Fast Retransmit threshold of three
    // duplicate ACKs [RFC2581].  This is more robust to reordered packets
    // than if an old packet were retransmitted on the first or second
    // duplicate ACK.
    //
    // Note: If the connection is using selective acknowledgments [RFC2018],
    // the data sender MUST NOT send new segments in response to duplicate
    // ACKs that contain no new SACK information, as a misbehaving receiver
    // can generate such ACKs to trigger inappropriate transmission of data
    // segments.  See [SCWA99] for a discussion of attacks by misbehaving
    // receivers."
    if (!state->sack_enabled || (state->sack_enabled && state->sackedBytes_old != state->sackedBytes)) {
        // check how many bytes we have
        ulong buffered = sendQueue->getBytesAvailable(state->snd_max);

        if (buffered >= state->snd_mss || (!fullSegmentsOnly && buffered > 0)) {
            ulong outstandingData = state->snd_max - state->snd_una;

            // check conditions from RFC 3042
            if (outstandingData + state->snd_mss <= state->snd_wnd &&
                outstandingData + state->snd_mss <= congestionWindow + 2 * state->snd_mss)
            {
                // RFC 3042, page 3: "(...)the sender can only send two segments beyond the congestion window (cwnd)."
                uint32 effectiveWin = std::min(state->snd_wnd, congestionWindow) - outstandingData + 2 * state->snd_mss;

                // bytes: number of bytes we're allowed to send now
                uint32 bytes = std::min(effectiveWin, state->snd_mss);

                if (bytes >= state->snd_mss || (!fullSegmentsOnly && bytes > 0)) {
                    uint32 old_snd_nxt = state->snd_nxt;
                    // we'll start sending from snd_max
                    state->snd_nxt = state->snd_max;

                    EV_DETAIL << "Limited Transmit algorithm enabled. Sending one new segment.\n";
                    sendSegment(bytes);

                    if (seqGreater(state->snd_nxt, state->snd_max))
                        state->snd_max = state->snd_nxt;

                    if (unackedVector)
                        unackedVector->record(state->snd_max - state->snd_una);

                    // reset snd_nxt if needed
                    if (state->afterRto)
                        state->snd_nxt = old_snd_nxt + state->sentBytes;

                    // notify
                    tcpAlgorithm->ackSent();
                    tcpAlgorithm->dataSent(old_snd_nxt);
                }
            }
        }
    }
}

bool inet::tcp::TCPConnection::sendProbe ( )

virtual

Utility: sends 1 bytes as "probe", called by the "persist" mechanism.

Referenced by inet::tcp::TCPBaseAlg::processPersistTimer().

{
    // we'll start sending from snd_max
    state->snd_nxt = state->snd_max;

    // check we have 1 byte to send
    if (sendQueue->getBytesAvailable(state->snd_nxt) == 0) {
        EV_WARN << "Cannot send probe because send buffer is empty\n";
        return false;
    }

    uint32 old_snd_nxt = state->snd_nxt;

    EV_INFO << "Sending 1 byte as probe, with seq=" << state->snd_nxt << "\n";
    sendSegment(1);

    // remember highest seq sent (snd_nxt may be set back on retransmission,
    // but we'll need snd_max to check validity of ACKs -- they must ack
    // something we really sent)
    state->snd_max = state->snd_nxt;

    if (unackedVector)
        unackedVector->record(state->snd_max - state->snd_una);

    // notify
    tcpAlgorithm->ackSent();
    tcpAlgorithm->dataSent(old_snd_nxt);

    return true;
}

void inet::tcp::TCPConnection::sendRst ( uint32  seqNo )

virtual

Utility: sends RST.

Referenced by process_ABORT(), processSegment1stThru8th(), processSegmentInListen(), processSegmentInSynSent(), and segmentArrivalWhileClosed().

{
    sendRst(seqNo, localAddr, remoteAddr, localPort, remotePort);
}

void inet::tcp::TCPConnection::sendRst ( uint32  seq, L3Address  src, L3Address  dest, int  srcPort, int  destPort  )

virtual

Utility: sends RST; does not use connection state.

{
    TCPSegment *tcpseg = createTCPSegment("RST");

    tcpseg->setSrcPort(srcPort);
    tcpseg->setDestPort(destPort);

    tcpseg->setRstBit(true);
    tcpseg->setSequenceNo(seq);

    // send it
    sendToIP(tcpseg, src, dest);
}

void inet::tcp::TCPConnection::sendRstAck ( uint32  seq, uint32  ack, L3Address  src, L3Address  dest, int  srcPort, int  destPort  )

virtual

Utility: sends RST+ACK; does not use connection state.

Referenced by segmentArrivalWhileClosed().

{
    TCPSegment *tcpseg = createTCPSegment("RST+ACK");

    tcpseg->setSrcPort(srcPort);
    tcpseg->setDestPort(destPort);

    tcpseg->setRstBit(true);
    tcpseg->setAckBit(true);
    tcpseg->setSequenceNo(seq);
    tcpseg->setAckNo(ack);

    // send it
    sendToIP(tcpseg, src, dest);

    // notify
    if (tcpAlgorithm)
        tcpAlgorithm->ackSent();
}

void inet::tcp::TCPConnection::sendSegment ( uint32  bytes )

virtual

Utility: sends one segment of 'bytes' bytes from snd_nxt, and advances snd_nxt.

sendData(), sendProbe() and retransmitData() internally all rely on this one.

Referenced by retransmitData(), retransmitOneSegment(), sendData(), sendOneNewSegment(), sendProbe(), and sendSegmentDuringLossRecoveryPhase().

{
    if (state->sack_enabled && state->afterRto) {
        // check rexmitQ and try to forward snd_nxt before sending new data
        uint32 forward = rexmitQueue->checkRexmitQueueForSackedOrRexmittedSegments(state->snd_nxt);

        if (forward > 0) {
            EV_INFO << "sendSegment(" << bytes << ") forwarded " << forward << " bytes of snd_nxt from " << state->snd_nxt;
            state->snd_nxt += forward;
            EV_INFO << " to " << state->snd_nxt << endl;
            rexmitQueue->info();
        }
    }

    ulong buffered = sendQueue->getBytesAvailable(state->snd_nxt);

    if (bytes > buffered) // last segment?
        bytes = buffered;

    // if header options will be added, this could reduce the number of data bytes allowed for this segment,
    // because following condition must to be respected:
    //     bytes + options_len <= snd_mss
    TCPSegment *tcpseg_temp = createTCPSegment(nullptr);
    tcpseg_temp->setAckBit(true);    // needed for TS option, otherwise TSecr will be set to 0
    writeHeaderOptions(tcpseg_temp);
    uint options_len = tcpseg_temp->getHeaderLength() - TCP_HEADER_OCTETS;    // TCP_HEADER_OCTETS = 20

    ASSERT(options_len < state->snd_mss);

    if (bytes + options_len > state->snd_mss)
        bytes = state->snd_mss - options_len;

    state->sentBytes = bytes;

    // send one segment of 'bytes' bytes from snd_nxt, and advance snd_nxt
    TCPSegment *tcpseg = sendQueue->createSegmentWithBytes(state->snd_nxt, bytes);

    // if sack_enabled copy region of tcpseg to rexmitQueue
    if (state->sack_enabled)
        rexmitQueue->enqueueSentData(state->snd_nxt, state->snd_nxt + bytes);

    tcpseg->setAckNo(state->rcv_nxt);
    tcpseg->setAckBit(true);
    tcpseg->setWindow(updateRcvWnd());

    // TBD when to set PSH bit?
    // TBD set URG bit if needed
    ASSERT(bytes == tcpseg->getPayloadLength());

    state->snd_nxt += bytes;

    // check if afterRto bit can be reset
    if (state->afterRto && seqGE(state->snd_nxt, state->snd_max))
        state->afterRto = false;

    if (state->send_fin && state->snd_nxt == state->snd_fin_seq) {
        EV_DETAIL << "Setting FIN on segment\n";
        tcpseg->setFinBit(true);
        state->snd_nxt = state->snd_fin_seq + 1;
    }

    // add header options and update header length (from tcpseg_temp)
    for (uint i = 0; i < tcpseg_temp->getHeaderOptionArraySize(); i++)
        tcpseg->addHeaderOption(tcpseg_temp->getHeaderOption(i)->dup());

    tcpseg->setHeaderLength(tcpseg_temp->getHeaderLength());
    delete tcpseg_temp;

    // send it
    sendToIP(tcpseg);

    // let application fill queue again, if there is space
    const uint32 alreadyQueued = sendQueue->getBytesAvailable(sendQueue->getBufferStartSeq());
    const uint32 abated = (state->sendQueueLimit > alreadyQueued) ? state->sendQueueLimit - alreadyQueued : 0;
    if ((state->sendQueueLimit > 0) && !state->queueUpdate && (abated >= state->snd_mss)) {    // request more data if space >= 1 MSS
        // Tell upper layer readiness to accept more data
        sendIndicationToApp(TCP_I_SEND_MSG, abated);
        state->queueUpdate = true;
    }
}

void inet::tcp::TCPConnection::sendSegmentDuringLossRecoveryPhase ( uint32  seqNum )

virtual

Utility: send segment during Loss Recovery phase (if SACK is enabled).

Referenced by sendDataDuringLossRecoveryPhase().

{
    ASSERT(state->sack_enabled && state->lossRecovery);

    // start sending from seqNum
    state->snd_nxt = seqNum;

    uint32 old_highRxt = rexmitQueue->getHighestRexmittedSeqNum();

    // no need to check cwnd and rwnd - has already be done before
    // no need to check nagle - sending mss bytes
    sendSegment(state->snd_mss);

    uint32 sentSeqNum = seqNum + state->sentBytes;

    ASSERT(seqLE(state->snd_nxt, sentSeqNum + 1));    // +1 for FIN, if sent

    // RFC 3517 page 8: "(C.2) If any of the data octets sent in (C.1) are below HighData,
    // HighRxt MUST be set to the highest sequence number of the
    // retransmitted segment."
    if (seqLess(seqNum, state->snd_max)) {    // HighData = snd_max
        state->highRxt = rexmitQueue->getHighestRexmittedSeqNum();
    }

    // RFC 3517 page 8: "(C.3) If any of the data octets sent in (C.1) are above HighData,
    // HighData must be updated to reflect the transmission of
    // previously unsent data."
    if (seqGreater(sentSeqNum, state->snd_max)) // HighData = snd_max
        state->snd_max = sentSeqNum;

    if (unackedVector)
        unackedVector->record(state->snd_max - state->snd_una);

    // RFC 3517, page 9: "6   Managing the RTO Timer
    //
    // The standard TCP RTO estimator is defined in [RFC2988].  Due to the
    // fact that the SACK algorithm in this document can have an impact on
    // the behavior of the estimator, implementers may wish to consider how
    // the timer is managed.  [RFC2988] calls for the RTO timer to be
    // re-armed each time an ACK arrives that advances the cumulative ACK
    // point.  Because the algorithm presented in this document can keep the
    // ACK clock going through a fairly significant loss event,
    // (comparatively longer than the algorithm described in [RFC2581]), on
    // some networks the loss event could last longer than the RTO.  In this
    // case the RTO timer would expire prematurely and a segment that need
    // not be retransmitted would be resent.
    //
    // Therefore we give implementers the latitude to use the standard
    // [RFC2988] style RTO management or, optionally, a more careful variant
    // that re-arms the RTO timer on each retransmission that is sent during
    // recovery MAY be used.  This provides a more conservative timer than
    // specified in [RFC2988], and so may not always be an attractive
    // alternative.  However, in some cases it may prevent needless
    // retransmissions, go-back-N transmission and further reduction of the
    // congestion window."
    tcpAlgorithm->ackSent();

    if (old_highRxt != state->highRxt) {
        // Note: Restart of REXMIT timer on retransmission is not part of RFC 2581, however optional in RFC 3517 if sent during recovery.
        EV_INFO << "Retransmission sent during recovery, restarting REXMIT timer.\n";
        tcpAlgorithm->restartRexmitTimer();
    }
    else // don't measure RTT for retransmitted packets
        tcpAlgorithm->dataSent(seqNum); // seqNum = old_snd_nxt
}

void inet::tcp::TCPConnection::sendSyn ( )

protectedvirtual

Utility: send SYN.

Referenced by process_OPEN_ACTIVE(), process_SEND(), and process_TIMEOUT_SYN_REXMIT().

{
    if (remoteAddr.isUnspecified() || remotePort == -1)
        throw cRuntimeError(tcpMain, "Error processing command OPEN_ACTIVE: foreign socket unspecified");

    if (localPort == -1)
        throw cRuntimeError(tcpMain, "Error processing command OPEN_ACTIVE: local port unspecified");

    // create segment
    TCPSegment *tcpseg = createTCPSegment("SYN");
    tcpseg->setSequenceNo(state->iss);
    tcpseg->setSynBit(true);
    updateRcvWnd();
    tcpseg->setWindow(state->rcv_wnd);

    state->snd_max = state->snd_nxt = state->iss + 1;

    // write header options
    writeHeaderOptions(tcpseg);

    // send it
    sendToIP(tcpseg);
}

void inet::tcp::TCPConnection::sendSynAck ( )

protectedvirtual

Utility: send SYN+ACK.

Referenced by process_TIMEOUT_SYN_REXMIT(), processSegmentInListen(), and processSegmentInSynSent().

{
    // create segment
    TCPSegment *tcpseg = createTCPSegment("SYN+ACK");
    tcpseg->setSequenceNo(state->iss);
    tcpseg->setAckNo(state->rcv_nxt);
    tcpseg->setSynBit(true);
    tcpseg->setAckBit(true);
    updateRcvWnd();
    tcpseg->setWindow(state->rcv_wnd);

    state->snd_max = state->snd_nxt = state->iss + 1;

    // write header options
    writeHeaderOptions(tcpseg);

    // send it
    sendToIP(tcpseg);

    // notify
    tcpAlgorithm->ackSent();
}

void inet::tcp::TCPConnection::sendToApp ( cMessage *  msg )

protectedvirtual

Utility: sends packet to application.

Referenced by process_READ_REQUEST(), process_STATUS(), processSegment1stThru8th(), sendEstabIndicationToApp(), and sendIndicationToApp().

{
    tcpMain->send(msg, "appOut", appGateIndex);
}

void inet::tcp::TCPConnection::sendToIP ( TCPSegment *  tcpseg )

virtual

Utility: adds control info to segment and sends it to IP.

Referenced by sendAck(), sendFin(), sendRst(), sendRstAck(), sendSegment(), sendSyn(), and sendSynAck().

{
    // record seq (only if we do send data) and ackno
    if (sndNxtVector && tcpseg->getPayloadLength() != 0)
        sndNxtVector->record(tcpseg->getSequenceNo());

    if (sndAckVector)
        sndAckVector->record(tcpseg->getAckNo());

    // final touches on the segment before sending
    tcpseg->setSrcPort(localPort);
    tcpseg->setDestPort(remotePort);
    ASSERT(tcpseg->getHeaderLength() >= TCP_HEADER_OCTETS);    // TCP_HEADER_OCTETS = 20 (without options)
    ASSERT(tcpseg->getHeaderLength() <= TCP_MAX_HEADER_OCTETS);    // TCP_MAX_HEADER_OCTETS = 60
    tcpseg->setByteLength(tcpseg->getHeaderLength() + tcpseg->getPayloadLength());
    state->sentBytes = tcpseg->getPayloadLength();    // resetting sentBytes to 0 if sending a segment without data (e.g. ACK)

    EV_INFO << "Sending: ";
    printSegmentBrief(tcpseg);

    // TBD reuse next function for sending

    IL3AddressType *addressType = remoteAddr.getAddressType();
    INetworkProtocolControlInfo *controlInfo = addressType->createNetworkProtocolControlInfo();
    controlInfo->setTransportProtocol(IP_PROT_TCP);
    controlInfo->setSourceAddress(localAddr);
    controlInfo->setDestinationAddress(remoteAddr);
    tcpseg->setControlInfo(check_and_cast<cObject *>(controlInfo));
    tcpMain->send(tcpseg, "ipOut");
}

void inet::tcp::TCPConnection::sendToIP ( TCPSegment *  tcpseg, L3Address  src, L3Address  dest  )

staticprotected

Utility: send IP packet.

{
    EV_STATICCONTEXT;
    EV_INFO << "Sending: ";
    printSegmentBrief(tcpseg);

    IL3AddressType *addressType = dest.getAddressType();
    INetworkProtocolControlInfo *controlInfo = addressType->createNetworkProtocolControlInfo();
    controlInfo->setTransportProtocol(IP_PROT_TCP);
    controlInfo->setSourceAddress(src);
    controlInfo->setDestinationAddress(dest);
    tcpseg->setControlInfo(check_and_cast<cObject *>(controlInfo));
    tcpseg->setByteLength(tcpseg->getHeaderLength() + tcpseg->getPayloadLength());
    check_and_cast<TCP *>(getSimulation()->getContextModule())->send(tcpseg, "ipOut");
}

void inet::tcp::TCPConnection::setPipe ( )

virtual

For SACK TCP.

RFC 3517, page 3: "This routine traverses the sequence space from HighACK to HighData and MUST set the "pipe" variable to an estimate of the number of octets that are currently in transit between the TCP sender and the TCP receiver."

Referenced by inet::tcp::TCPReno::receivedDataAck(), and inet::tcp::TCPReno::receivedDuplicateAck().

{
    ASSERT(state->sack_enabled);

    // RFC 3517, pages 1 and 2: "
    // "HighACK" is the sequence number of the highest byte of data that
    // has been cumulatively ACKed at a given point.
    //
    // "HighData" is the highest sequence number transmitted at a given
    // point.
    //
    // "HighRxt" is the highest sequence number which has been
    // retransmitted during the current loss recovery phase.
    //
    // "Pipe" is a sender's estimate of the number of bytes outstanding
    // in the network.  This is used during recovery for limiting the
    // sender's sending rate.  The pipe variable allows TCP to use a
    // fundamentally different congestion control than specified in
    // [RFC2581].  The algorithm is often referred to as the "pipe
    // algorithm"."
    // HighAck = snd_una
    // HighData = snd_max

    state->highRxt = rexmitQueue->getHighestRexmittedSeqNum();
    state->pipe = 0;
    uint32 length = 0;    // required for rexmitQueue->checkSackBlock()
    bool sacked;    // required for rexmitQueue->checkSackBlock()
    bool rexmitted;    // required for rexmitQueue->checkSackBlock()

    // RFC 3517, page 3: "This routine traverses the sequence space from HighACK to HighData
    // and MUST set the "pipe" variable to an estimate of the number of
    // octets that are currently in transit between the TCP sender and
    // the TCP receiver.  After initializing pipe to zero the following
    // steps are taken for each octet 'S1' in the sequence space between
    // HighACK and HighData that has not been SACKed:"
    for (uint32 s1 = state->snd_una; seqLess(s1, state->snd_max); s1 += length) {
        rexmitQueue->checkSackBlock(s1, length, sacked, rexmitted);

        if (!sacked) {
            // RFC 3517, page 3: "(a) If IsLost (S1) returns false:
            //
            //     Pipe is incremented by 1 octet.
            //
            //     The effect of this condition is that pipe is incremented for
            //     packets that have not been SACKed and have not been determined
            //     to have been lost (i.e., those segments that are still assumed
            //     to be in the network)."
            if (isLost(s1) == false)
                state->pipe += length;

            // RFC 3517, pages 3 and 4: "(b) If S1 <= HighRxt:
            //
            //     Pipe is incremented by 1 octet.
            //
            //     The effect of this condition is that pipe is incremented for
            //     the retransmission of the octet.
            //
            //  Note that octets retransmitted without being considered lost are
            //  counted twice by the above mechanism."
            if (seqLess(s1, state->highRxt))
                state->pipe += length;
        }
    }

    if (pipeVector)
        pipeVector->record(state->pipe);
}

void inet::tcp::TCPConnection::signalConnectionTimeout ( )

virtual

Utility: signal to user that connection timed out.

Referenced by inet::tcp::TCPBaseAlg::processRexmitTimer().

{
    sendIndicationToApp(TCP_I_TIMED_OUT);
}

void inet::tcp::TCPConnection::startSynRexmitTimer ( )

virtual

Utility: start SYN-REXMIT timer.

Referenced by process_OPEN_ACTIVE(), process_SEND(), processSegmentInListen(), and processSegmentInSynSent().

{
    state->syn_rexmit_count = 0;
    state->syn_rexmit_timeout = TCP_TIMEOUT_SYN_REXMIT;

    if (synRexmitTimer->isScheduled())
        cancelEvent(synRexmitTimer);

    scheduleTimeout(synRexmitTimer, state->syn_rexmit_timeout);
}

void inet::tcp::TCPConnection::stateEntered ( int  state, int  oldState, TCPEventCode  event  )

protectedvirtual

Perform cleanup necessary when entering a new state, e.g.

cancelling timers

{
    // cancel timers
    switch (state) {
        case TCP_S_INIT:
            // we'll never get back to INIT
            break;

        case TCP_S_LISTEN:
            // we may get back to LISTEN from SYN_RCVD
            ASSERT(connEstabTimer && synRexmitTimer);
            cancelEvent(connEstabTimer);
            cancelEvent(synRexmitTimer);
            break;

        case TCP_S_SYN_RCVD:
        case TCP_S_SYN_SENT:
            break;

        case TCP_S_ESTABLISHED:
            // we're in ESTABLISHED, these timers are no longer needed
            delete cancelEvent(connEstabTimer);
            delete cancelEvent(synRexmitTimer);
            connEstabTimer = synRexmitTimer = nullptr;
            // TCP_I_ESTAB notification moved inside event processing
            break;

        case TCP_S_CLOSE_WAIT:
        case TCP_S_LAST_ACK:
        case TCP_S_FIN_WAIT_1:
        case TCP_S_FIN_WAIT_2:
        case TCP_S_CLOSING:
            if (state == TCP_S_CLOSE_WAIT)
                sendIndicationToApp(TCP_I_PEER_CLOSED);
            // whether connection setup succeeded (ESTABLISHED) or not (others),
            // cancel these timers
            if (connEstabTimer)
                cancelEvent(connEstabTimer);
            if (synRexmitTimer)
                cancelEvent(synRexmitTimer);
            break;

        case TCP_S_TIME_WAIT:
            sendIndicationToApp(TCP_I_CLOSED);
            break;

        case TCP_S_CLOSED:
            if (oldState != TCP_S_TIME_WAIT && event != TCP_E_ABORT)
                sendIndicationToApp(TCP_I_CLOSED);
            // all timers need to be cancelled
            if (the2MSLTimer)
                cancelEvent(the2MSLTimer);
            if (connEstabTimer)
                cancelEvent(connEstabTimer);
            if (finWait2Timer)
                cancelEvent(finWait2Timer);
            if (synRexmitTimer)
                cancelEvent(synRexmitTimer);
            tcpAlgorithm->connectionClosed();
            break;
    }
}

const char * inet::tcp::TCPConnection::stateName ( int  state )

static

Utility: returns name of TCP_S_xxx constants.

Referenced by printConnBrief(), process_STATUS(), process_TIMEOUT_2MSL(), process_TIMEOUT_CONN_ESTAB(), process_TIMEOUT_FIN_WAIT_2(), process_TIMEOUT_SYN_REXMIT(), processSegment1stThru8th(), and processTSOption().

{
#define CASE(x)    case x: \
        s = #x + 6; break
    const char *s = "unknown";
    switch (state) {
        CASE(TCP_S_INIT);
        CASE(TCP_S_CLOSED);
        CASE(TCP_S_LISTEN);
        CASE(TCP_S_SYN_SENT);
        CASE(TCP_S_SYN_RCVD);
        CASE(TCP_S_ESTABLISHED);
        CASE(TCP_S_CLOSE_WAIT);
        CASE(TCP_S_LAST_ACK);
        CASE(TCP_S_FIN_WAIT_1);
        CASE(TCP_S_FIN_WAIT_2);
        CASE(TCP_S_CLOSING);
        CASE(TCP_S_TIME_WAIT);
    }
    return s;
#undef CASE
}

bool inet::tcp::TCPConnection::tryFastRoute ( TCPSegment *  tcpseg )

protectedvirtual

Shortcut to process most common case as fast as possible.

Returns false if segment requires normal (slow) route.

{
    // fast route processing not yet implemented
    return false;
}

void inet::tcp::TCPConnection::updateRcvQueueVars ( )

virtual

Utility: update receiver queue related variables and statistics - called before setting rcv_wnd.

Referenced by processSegment1stThru8th(), processSegmentInListen(), processSegmentInSynSent(), and updateRcvWnd().

{
    // update receive queue related state variables
    state->freeRcvBuffer = receiveQueue->getAmountOfFreeBytes(state->maxRcvBuffer);
    state->usedRcvBuffer = state->maxRcvBuffer - state->freeRcvBuffer;

    // update receive queue related statistics
    if (tcpRcvQueueBytesVector)
        tcpRcvQueueBytesVector->record(state->usedRcvBuffer);

//    tcpEV << "receiveQ: receiveQLength=" << receiveQueue->getQueueLength() << " maxRcvBuffer=" << state->maxRcvBuffer << " usedRcvBuffer=" << state->usedRcvBuffer << " freeRcvBuffer=" << state->freeRcvBuffer << "\n";
}

unsigned short inet::tcp::TCPConnection::updateRcvWnd ( )

virtual

Utility: update receive window (rcv_wnd), and calculate scaled value if window scaling enabled.

Returns the (scaled) receive window size.

Referenced by sendAck(), sendFin(), sendSegment(), sendSyn(), and sendSynAck().

{
    uint32 win = 0;

    // update receive queue related state variables and statistics
    updateRcvQueueVars();
    win = state->freeRcvBuffer;

    // Following lines are based on [Stevens, W.R.: TCP/IP Illustrated, Volume 2, chapter 26.7, pages 878-879]:
    // Don't advertise less than one full-sized segment to avoid SWS
    if (win < (state->maxRcvBuffer / 4) && win < state->snd_mss)
        win = 0;

    // Do not shrink window
    // (rcv_adv minus rcv_nxt) is the amount of space still available to the sender that was previously advertised
    if (win < state->rcv_adv - state->rcv_nxt)
        win = state->rcv_adv - state->rcv_nxt;

    // Observe upper limit for advertised window on this connection
    if (win > TCP_MAX_WIN && !state->ws_enabled) // TCP_MAX_WIN = 65535 (16 bit)
        win = TCP_MAX_WIN; // Note: The window size is limited to a 16 bit value in the TCP header if WINDOW SCALE option (RFC 1323) is not used

    // Note: The order of the "Do not shrink window" and "Observe upper limit" parts has been changed to the order used in FreeBSD Release 7.1

    // update rcv_adv if needed
    if (win > 0 && seqGE(state->rcv_nxt + win, state->rcv_adv)) {
        state->rcv_adv = state->rcv_nxt + win;

        if (rcvAdvVector)
            rcvAdvVector->record(state->rcv_adv);
    }

    state->rcv_wnd = win;

    if (rcvWndVector)
        rcvWndVector->record(state->rcv_wnd);

    // scale rcv_wnd:
    uint32 scaled_rcv_wnd = state->rcv_wnd;
    if (state->ws_enabled && state->rcv_wnd_scale) {
        ASSERT(state->rcv_wnd_scale <= 14);   // RFC 1323, page 11: "the shift count must be limited to 14"
        scaled_rcv_wnd = scaled_rcv_wnd >> state->rcv_wnd_scale;
    }

    ASSERT(scaled_rcv_wnd == (unsigned short)scaled_rcv_wnd);

    return (unsigned short)scaled_rcv_wnd;
}

void inet::tcp::TCPConnection::updateWndInfo ( TCPSegment *  tcpseg, bool  doAlways = false  )

virtual

Utility: update window information (snd_wnd, snd_wl1, snd_wl2)

Referenced by processAckInEstabEtc(), processSegmentInListen(), and processSegmentInSynSent().

{
    uint32 true_window = tcpseg->getWindow();
    // RFC 1323, page 10:
    // "The window field (SEG.WND) in the header of every incoming
    // segment, with the exception of SYN segments, is left-shifted
    // by Snd.Wind.Scale bits before updating SND.WND:
    //    SND.WND = SEG.WND << Snd.Wind.Scale"
    if (state->ws_enabled && !tcpseg->getSynBit())
        true_window = tcpseg->getWindow() << state->snd_wnd_scale;

    // Following lines are based on [Stevens, W.R.: TCP/IP Illustrated, Volume 2, page 982]:
    if (doAlways || (tcpseg->getAckBit()
                     && (seqLess(state->snd_wl1, tcpseg->getSequenceNo()) ||
                         (state->snd_wl1 == tcpseg->getSequenceNo() && seqLE(state->snd_wl2, tcpseg->getAckNo())) ||
                         (state->snd_wl2 == tcpseg->getAckNo() && true_window > state->snd_wnd))))
    {
        // send window should be updated
        state->snd_wnd = true_window;
        EV_INFO << "Updating send window from segment: new wnd=" << state->snd_wnd << "\n";
        state->snd_wl1 = tcpseg->getSequenceNo();
        state->snd_wl2 = tcpseg->getAckNo();

        if (sndWndVector)
            sndWndVector->record(state->snd_wnd);
    }
}

TCPSegment inet::tcp::TCPConnection::writeHeaderOptions ( TCPSegment *  tcpseg )

protectedvirtual

Utility: writeHeaderOptions (Currently only EOL, NOP, MSS, WS, SACK_PERMITTED, SACK and TS are implemented)

Referenced by sendAck(), sendSegment(), sendSyn(), and sendSynAck().

{
    // SYN flag set and connetion in INIT or LISTEN state (or after synRexmit timeout)
    if (tcpseg->getSynBit() && (fsm.getState() == TCP_S_INIT || fsm.getState() == TCP_S_LISTEN
                                || ((fsm.getState() == TCP_S_SYN_SENT || fsm.getState() == TCP_S_SYN_RCVD)
                                    && state->syn_rexmit_count > 0)))
    {
        // MSS header option
        if (state->snd_mss > 0) {
            TCPOptionMaxSegmentSize *option = new TCPOptionMaxSegmentSize();
            option->setMaxSegmentSize(state->snd_mss);
            tcpseg->addHeaderOption(option);
            EV_INFO << "TCP Header Option MSS(=" << state->snd_mss << ") sent\n";
        }

        // WS header option
        if (state->ws_support && (state->rcv_ws || (fsm.getState() == TCP_S_INIT
                                                    || (fsm.getState() == TCP_S_SYN_SENT && state->syn_rexmit_count > 0))))
        {
            // 1 padding byte
            tcpseg->addHeaderOption(new TCPOptionNop());    // NOP

            // Update WS variables
            if (state->ws_manual_scale > -1) {
                state->rcv_wnd_scale = state->ws_manual_scale;
            } else {
                ulong scaled_rcv_wnd = receiveQueue->getFirstSeqNo() + state->maxRcvBuffer - state->rcv_nxt;
                state->rcv_wnd_scale = 0;

                while (scaled_rcv_wnd > TCP_MAX_WIN && state->rcv_wnd_scale < 14) {    // RFC 1323, page 11: "the shift count must be limited to 14"
                    scaled_rcv_wnd = scaled_rcv_wnd >> 1;
                    state->rcv_wnd_scale++;
                }
            }

            TCPOptionWindowScale *option = new TCPOptionWindowScale();
            option->setWindowScale(state->rcv_wnd_scale);    // rcv_wnd_scale is also set in scaleRcvWnd()
            state->snd_ws = true;
            state->ws_enabled = state->ws_support && state->snd_ws && state->rcv_ws;
            EV_INFO << "TCP Header Option WS(=" << option->getWindowScale() << ") sent, WS (ws_enabled) is set to " << state->ws_enabled << "\n";
            tcpseg->addHeaderOption(option);
        }

        // SACK_PERMITTED header option
        if (state->sack_support && (state->rcv_sack_perm || (fsm.getState() == TCP_S_INIT
                                                             || (fsm.getState() == TCP_S_SYN_SENT && state->syn_rexmit_count > 0))))
        {
            if (!state->ts_support) {    // if TS is supported by host, do not add NOPs to this segment
                // 2 padding bytes
                tcpseg->addHeaderOption(new TCPOptionNop());    // NOP
                tcpseg->addHeaderOption(new TCPOptionNop());    // NOP
            }

            tcpseg->addHeaderOption(new TCPOptionSackPermitted());

            // Update SACK variables
            state->snd_sack_perm = true;
            state->sack_enabled = state->sack_support && state->snd_sack_perm && state->rcv_sack_perm;
            EV_INFO << "TCP Header Option SACK_PERMITTED sent, SACK (sack_enabled) is set to " << state->sack_enabled << "\n";
        }

        // TS header option
        if (state->ts_support && (state->rcv_initial_ts || (fsm.getState() == TCP_S_INIT
                                                            || (fsm.getState() == TCP_S_SYN_SENT && state->syn_rexmit_count > 0))))
        {
            if (!state->sack_support) {    // if SACK is supported by host, do not add NOPs to this segment
                // 2 padding bytes
                tcpseg->addHeaderOption(new TCPOptionNop());    // NOP
                tcpseg->addHeaderOption(new TCPOptionNop());    // NOP
            }

            TCPOptionTimestamp *option = new TCPOptionTimestamp();

            // Update TS variables
            // RFC 1323, page 13: "The Timestamp Value field (TSval) contains the current value of the timestamp clock of the TCP sending the option."
            option->setSenderTimestamp(convertSimtimeToTS(simTime()));

            // RFC 1323, page 16: "(3) When a TSopt is sent, its TSecr field is set to the current TS.Recent value."
            // RFC 1323, page 13:
            // "The Timestamp Echo Reply field (TSecr) is only valid if the ACK
            // bit is set in the TCP header; if it is valid, it echos a times-
            // tamp value that was sent by the remote TCP in the TSval field
            // of a Timestamps option.  When TSecr is not valid, its value
            // must be zero."
            option->setEchoedTimestamp(tcpseg->getAckBit() ? state->ts_recent : 0);

            state->snd_initial_ts = true;
            state->ts_enabled = state->ts_support && state->snd_initial_ts && state->rcv_initial_ts;
            EV_INFO << "TCP Header Option TS(TSval=" << option->getSenderTimestamp() << ", TSecr=" << option->getEchoedTimestamp() << ") sent, TS (ts_enabled) is set to " << state->ts_enabled << "\n";
            tcpseg->addHeaderOption(option);
        }

        // TODO add new TCPOptions here once they are implemented
    }
    else if (fsm.getState() == TCP_S_SYN_SENT || fsm.getState() == TCP_S_SYN_RCVD
             || fsm.getState() == TCP_S_ESTABLISHED || fsm.getState() == TCP_S_FIN_WAIT_1
             || fsm.getState() == TCP_S_FIN_WAIT_2)    // connetion is not in INIT or LISTEN state
    {
        // TS header option
        if (state->ts_enabled) {    // Is TS enabled?
            if (!(state->sack_enabled && (state->snd_sack || state->snd_dsack))) {    // if SACK is enabled and SACKs need to be added, do not add NOPs to this segment
                // 2 padding bytes
                tcpseg->addHeaderOption(new TCPOptionNop());    // NOP
                tcpseg->addHeaderOption(new TCPOptionNop());    // NOP
            }

            TCPOptionTimestamp *option = new TCPOptionTimestamp();

            // Update TS variables
            // RFC 1323, page 13: "The Timestamp Value field (TSval) contains the current value of the timestamp clock of the TCP sending the option."
            option->setSenderTimestamp(convertSimtimeToTS(simTime()));

            // RFC 1323, page 16: "(3) When a TSopt is sent, its TSecr field is set to the current TS.Recent value."
            // RFC 1323, page 13:
            // "The Timestamp Echo Reply field (TSecr) is only valid if the ACK
            // bit is set in the TCP header; if it is valid, it echos a times-
            // tamp value that was sent by the remote TCP in the TSval field
            // of a Timestamps option.  When TSecr is not valid, its value
            // must be zero."
            option->setEchoedTimestamp(tcpseg->getAckBit() ? state->ts_recent : 0);

            EV_INFO << "TCP Header Option TS(TSval=" << option->getSenderTimestamp() << ", TSecr=" << option->getEchoedTimestamp() << ") sent\n";
            tcpseg->addHeaderOption(option);
        }

        // SACK header option

        // RFC 2018, page 4:
        // "If sent at all, SACK options SHOULD be included in all ACKs which do
        // not ACK the highest sequence number in the data receiver's queue.  In
        // this situation the network has lost or mis-ordered data, such that
        // the receiver holds non-contiguous data in its queue.  RFC 1122,
        // Section 4.2.2.21, discusses the reasons for the receiver to send ACKs
        // in response to additional segments received in this state.  The
        // receiver SHOULD send an ACK for every valid segment that arrives
        // containing new data, and each of these "duplicate" ACKs SHOULD bear a
        // SACK option."
        if (state->sack_enabled && (state->snd_sack || state->snd_dsack)) {
            addSacks(tcpseg);
        }

        // TODO add new TCPOptions here once they are implemented
        // TODO delegate to TCPAlgorithm as well -- it may want to append additional options
    }

    if (tcpseg->getHeaderOptionArraySize() != 0) {
        uint options_len = tcpseg->getHeaderOptionArrayLength();

        if (options_len <= TCP_OPTIONS_MAX_SIZE) // Options length allowed? - maximum: 40 Bytes
            tcpseg->setHeaderLength(TCP_HEADER_OCTETS + options_len); // TCP_HEADER_OCTETS = 20
        else {
            tcpseg->setHeaderLength(TCP_HEADER_OCTETS);    // TCP_HEADER_OCTETS = 20
            tcpseg->dropHeaderOptions();    // drop all options
            EV_ERROR << "ERROR: Options length exceeded! Segment will be sent without options" << "\n";
        }
    }

    return *tcpseg;
}

Member Data Documentation

int inet::tcp::TCPConnection::appGateIndex = -1

Referenced by inet::tcp::TCP::addForkedConnection(), cloneListeningConnection(), printConnBrief(), inet::tcp::TCP::removeConnection(), and sendToApp().

cMessage* inet::tcp::TCPConnection::connEstabTimer = nullptr

protected

Referenced by process_OPEN_ACTIVE(), process_SEND(), and processSegmentInListen().

int inet::tcp::TCPConnection::connId = -1

Referenced by inet::tcp::TCP::addForkedConnection(), cloneListeningConnection(), printConnBrief(), process_READ_REQUEST(), processSegment1stThru8th(), processSegmentInListen(), inet::tcp::TCP::removeConnection(), sendEstabIndicationToApp(), and sendIndicationToApp().

cOutVector* inet::tcp::TCPConnection::dupAcksVector = nullptr

protected

Referenced by processAckInEstabEtc(), and processSegment1stThru8th().

cMessage* inet::tcp::TCPConnection::finWait2Timer = nullptr

protected

Referenced by processSegment1stThru8th().

cFSM inet::tcp::TCPConnection::fsm

protected

Referenced by cloneListeningConnection(), printConnBrief(), process_ABORT(), process_CLOSE(), process_OPEN_ACTIVE(), process_OPEN_PASSIVE(), process_RCV_SEGMENT(), process_SEND(), process_STATUS(), process_TIMEOUT_2MSL(), process_TIMEOUT_CONN_ESTAB(), process_TIMEOUT_FIN_WAIT_2(), process_TIMEOUT_SYN_REXMIT(), processAckInEstabEtc(), processMSSOption(), processSACKOption(), processSACKPermittedOption(), processSegment1stThru8th(), processTSOption(), processWSOption(), and writeHeaderOptions().

L3Address inet::tcp::TCPConnection::localAddr

Referenced by inet::tcp::TCP::addForkedConnection(), inet::tcp::TCP::addSockPair(), cloneListeningConnection(), printConnBrief(), process_OPEN_ACTIVE(), process_OPEN_PASSIVE(), process_STATUS(), inet::tcp::TCP::removeConnection(), sendEstabIndicationToApp(), sendRst(), sendToIP(), and inet::tcp::TCP::updateSockPair().

int inet::tcp::TCPConnection::localPort = -1

Referenced by inet::tcp::TCP::addForkedConnection(), inet::tcp::TCP::addSockPair(), cloneListeningConnection(), printConnBrief(), process_OPEN_ACTIVE(), process_OPEN_PASSIVE(), process_STATUS(), inet::tcp::TCP::removeConnection(), sendEstabIndicationToApp(), sendRst(), sendSyn(), sendToIP(), and inet::tcp::TCP::updateSockPair().

cOutVector* inet::tcp::TCPConnection::pipeVector = nullptr

protected

Referenced by setPipe().

cOutVector* inet::tcp::TCPConnection::rcvAckVector = nullptr

protected

Referenced by process_RCV_SEGMENT().

cOutVector* inet::tcp::TCPConnection::rcvAdvVector = nullptr

protected

Referenced by processSegmentInListen(), processSegmentInSynSent(), and updateRcvWnd().

cOutVector* inet::tcp::TCPConnection::rcvNASegVector = nullptr

protected

Referenced by processSegment1stThru8th().

cOutVector* inet::tcp::TCPConnection::rcvOooSegVector = nullptr

protected

Referenced by processSegment1stThru8th().

cOutVector* inet::tcp::TCPConnection::rcvSacksVector = nullptr

protected

Referenced by processSACKOption().

cOutVector* inet::tcp::TCPConnection::rcvSeqVector = nullptr

protected

Referenced by process_RCV_SEGMENT().

cOutVector* inet::tcp::TCPConnection::rcvWndVector = nullptr

protected

Referenced by updateRcvWnd().

TCPReceiveQueue* inet::tcp::TCPConnection::receiveQueue = nullptr

protected

Referenced by addSacks(), cloneListeningConnection(), hasEnoughSpaceForSegmentInReceiveQueue(), initConnection(), process_READ_REQUEST(), processSegment1stThru8th(), processSegmentInListen(), processSegmentInSynSent(), updateRcvQueueVars(), and writeHeaderOptions().

L3Address inet::tcp::TCPConnection::remoteAddr

Referenced by inet::tcp::TCP::addForkedConnection(), inet::tcp::TCP::addSockPair(), printConnBrief(), process_OPEN_ACTIVE(), process_STATUS(), inet::tcp::TCP::removeConnection(), sendEstabIndicationToApp(), sendRst(), sendSyn(), sendToIP(), and inet::tcp::TCP::updateSockPair().

int inet::tcp::TCPConnection::remotePort = -1

Referenced by inet::tcp::TCP::addForkedConnection(), inet::tcp::TCP::addSockPair(), printConnBrief(), process_OPEN_ACTIVE(), process_STATUS(), inet::tcp::TCP::removeConnection(), sendEstabIndicationToApp(), sendRst(), sendSyn(), sendToIP(), and inet::tcp::TCP::updateSockPair().

TCPSACKRexmitQueue* inet::tcp::TCPConnection::rexmitQueue = nullptr

Referenced by cloneListeningConnection(), initConnection(), isLost(), nextSeg(), processAckInEstabEtc(), inet::tcp::TCPBaseAlg::processRexmitTimer(), processRstInSynReceived(), processSACKOption(), processSegmentInSynSent(), retransmitOneSegment(), selectInitialSeqNum(), sendData(), sendSegment(), sendSegmentDuringLossRecoveryPhase(), and setPipe().

cOutVector* inet::tcp::TCPConnection::sackedBytesVector = nullptr

protected

Referenced by processSACKOption().

TCPSendQueue* inet::tcp::TCPConnection::sendQueue = nullptr

protected

Referenced by cloneListeningConnection(), initConnection(), isSendQueueEmpty(), nextSeg(), process_CLOSE(), process_SEND(), processAckInEstabEtc(), processRstInSynReceived(), processSegmentInSynSent(), retransmitData(), retransmitOneSegment(), selectInitialSeqNum(), sendData(), sendOneNewSegment(), sendProbe(), and sendSegment().

cOutVector* inet::tcp::TCPConnection::sndAckVector = nullptr

protected

Referenced by sendToIP().

cOutVector* inet::tcp::TCPConnection::sndNxtVector = nullptr

protected

Referenced by sendToIP().

cOutVector* inet::tcp::TCPConnection::sndSacksVector = nullptr

protected

Referenced by addSacks().

cOutVector* inet::tcp::TCPConnection::sndWndVector = nullptr

protected

Referenced by updateWndInfo().

TCPStateVariables* inet::tcp::TCPConnection::state = nullptr

protected

Referenced by addSacks(), cloneListeningConnection(), configureStateVariables(), hasEnoughSpaceForSegmentInReceiveQueue(), initConnection(), isLost(), isSegmentAcceptable(), isSendQueueEmpty(), nextSeg(), process_ABORT(), process_CLOSE(), process_OPEN_ACTIVE(), process_OPEN_PASSIVE(), process_QUEUE_BYTES_LIMIT(), process_RCV_SEGMENT(), process_READ_REQUEST(), process_SEND(), process_STATUS(), process_TIMEOUT_CONN_ESTAB(), process_TIMEOUT_SYN_REXMIT(), processAckInEstabEtc(), processMSSOption(), processRstInSynReceived(), processSACKOption(), processSACKPermittedOption(), processSegment1stThru8th(), processSegmentInListen(), processSegmentInSynSent(), processTSOption(), processWSOption(), retransmitData(), retransmitOneSegment(), segmentArrivalWhileClosed(), selectInitialSeqNum(), sendAck(), sendData(), sendDataDuringLossRecoveryPhase(), sendFin(), sendOneNewSegment(), sendProbe(), sendSegment(), sendSegmentDuringLossRecoveryPhase(), sendSyn(), sendSynAck(), sendToIP(), setPipe(), startSynRexmitTimer(), updateRcvQueueVars(), updateRcvWnd(), updateWndInfo(), and writeHeaderOptions().

cMessage* inet::tcp::TCPConnection::synRexmitTimer = nullptr

protected

Referenced by process_TIMEOUT_SYN_REXMIT(), and startSynRexmitTimer().

TCPAlgorithm* inet::tcp::TCPConnection::tcpAlgorithm = nullptr

protected

Referenced by cloneListeningConnection(), initConnection(), process_CLOSE(), process_SEND(), processAckInEstabEtc(), processSegment1stThru8th(), processSegmentInSynSent(), retransmitData(), retransmitOneSegment(), sendAck(), sendData(), sendFin(), sendOneNewSegment(), sendProbe(), sendRstAck(), sendSegmentDuringLossRecoveryPhase(), and sendSynAck().

TCP* inet::tcp::TCPConnection::tcpMain = nullptr

protected

Referenced by cloneListeningConnection(), configureStateVariables(), initConnection(), process_CLOSE(), process_OPEN_ACTIVE(), process_OPEN_PASSIVE(), process_SEND(), process_TIMEOUT_2MSL(), process_TIMEOUT_CONN_ESTAB(), process_TIMEOUT_FIN_WAIT_2(), process_TIMEOUT_SYN_REXMIT(), processSegment1stThru8th(), processSegmentInListen(), processSegmentInSynSent(), sendSyn(), sendToApp(), and sendToIP().

cOutVector* inet::tcp::TCPConnection::tcpRcvQueueBytesVector = nullptr

protected

Referenced by updateRcvQueueVars().

cOutVector* inet::tcp::TCPConnection::tcpRcvQueueDropsVector = nullptr

protected

Referenced by processSegment1stThru8th(), processSegmentInListen(), and processSegmentInSynSent().

cMessage* inet::tcp::TCPConnection::the2MSLTimer = nullptr

protected

Referenced by processSegment1stThru8th().

TCPDataTransferMode inet::tcp::TCPConnection::transferMode = TCP_TRANSFER_UNDEFINED

protected

Referenced by cloneListeningConnection(), and initConnection().

cOutVector* inet::tcp::TCPConnection::unackedVector = nullptr

protected

Referenced by process_CLOSE(), processAckInEstabEtc(), retransmitData(), retransmitOneSegment(), sendData(), sendOneNewSegment(), sendProbe(), and sendSegmentDuringLossRecoveryPhase().

---

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

• TCPConnection.h
• TCPConnectionBase.cc
• TCPConnectionEventProc.cc
• TCPConnectionRcvSegment.cc
• TCPConnectionSackUtil.cc
• TCPConnectionUtil.cc