TCPConnection.h

Go to the documentation of this file.

//
// Copyright (C) 2004 Andras Varga
// Copyright (C) 2009-2010 Thomas Reschka
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public License
// as published by the Free Software Foundation; either version 2
// of the License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with this program; if not, see <http://www.gnu.org/licenses/>.
//

#ifndef __INET_TCPCONNECTION_H
#define __INET_TCPCONNECTION_H

#include <omnetpp.h>
#include "INETDefs.h"
#include "IPvXAddress.h"
#include "TCP.h"
#include "TCPSegment.h"

class TCPSegment;
class TCPCommand;
class TCPOpenCommand;
class TCPSendQueue;
class TCPSACKRexmitQueue;
class TCPReceiveQueue;
class TCPAlgorithm;


//
// TCP FSM states
//
// Brief descriptions (cf RFC 793, page 20):
//
// LISTEN - waiting for a connection request
// SYN-SENT - part of 3-way handshake (waiting for peer's SYN+ACK or SYN)
// SYN-RECEIVED - part of 3-way handshake (we sent SYN too, waiting for it to be acked)
// ESTABLISHED - normal data transfer
// FIN-WAIT-1 - FIN sent, waiting for its ACK (or peer's FIN)
// FIN-WAIT-2 - our side of the connection closed (our FIN acked), waiting for peer's FIN
// CLOSE-WAIT - FIN received and acked, waiting for local user to close
// LAST-ACK - remote side closed, FIN sent, waiting for its ACK
// CLOSING - simultaneous close: sent FIN, then got peer's FIN
// TIME-WAIT - both FIN's acked, waiting for some time to be sure remote TCP received our ACK
// CLOSED - represents no connection state at all.
//
// Note: FIN-WAIT-1, FIN-WAIT-2, CLOSING, TIME-WAIT represents active close (that is,
// local user closes first), and CLOSE-WAIT and LAST-ACK represents passive close.
//
enum TcpState
{
    TCP_S_INIT        = 0,
    TCP_S_CLOSED      = FSM_Steady(1),
    TCP_S_LISTEN      = FSM_Steady(2),
    TCP_S_SYN_SENT    = FSM_Steady(3),
    TCP_S_SYN_RCVD    = FSM_Steady(4),
    TCP_S_ESTABLISHED = FSM_Steady(5),
    TCP_S_CLOSE_WAIT  = FSM_Steady(6),
    TCP_S_LAST_ACK    = FSM_Steady(7),
    TCP_S_FIN_WAIT_1  = FSM_Steady(8),
    TCP_S_FIN_WAIT_2  = FSM_Steady(9),
    TCP_S_CLOSING     = FSM_Steady(10),
    TCP_S_TIME_WAIT   = FSM_Steady(11)
};


//
// Event, strictly for the FSM state transition purposes.
// DO NOT USE outside performStateTransition()!
//
enum TCPEventCode
{
    TCP_E_IGNORE,

    // app commands
    // (Note: no RECEIVE command, data are automatically passed up)
    TCP_E_OPEN_ACTIVE,
    TCP_E_OPEN_PASSIVE,
    TCP_E_SEND,
    TCP_E_CLOSE,
    TCP_E_ABORT,
    TCP_E_STATUS,

    // TPDU types
    TCP_E_RCV_DATA,
    TCP_E_RCV_ACK,
    TCP_E_RCV_SYN,
    TCP_E_RCV_SYN_ACK,
    TCP_E_RCV_FIN,
    TCP_E_RCV_FIN_ACK,
    TCP_E_RCV_RST, // covers RST+ACK too

    TCP_E_RCV_UNEXP_SYN, // unexpected SYN

    // timers
    TCP_E_TIMEOUT_2MSL,     // RFC 793, a.k.a. TIME-WAIT timer
    TCP_E_TIMEOUT_CONN_ESTAB,
    TCP_E_TIMEOUT_FIN_WAIT_2,

    // All other timers (REXMT, PERSIST, DELAYED-ACK, KEEP-ALIVE, etc.),
    // are handled in TCPAlgorithm.
};


#define TCP_TIMEOUT_CONN_ESTAB    75    // 75 seconds
#define TCP_TIMEOUT_FIN_WAIT_2   600    // 10 minutes
#define TCP_TIMEOUT_2MSL         240    // 2 * 2 minutes
#define TCP_TIMEOUT_SYN_REXMIT     3    // initially 3 seconds
#define TCP_TIMEOUT_SYN_REXMIT_MAX 240  // 4 mins (will only be used with SYN+ACK: with SYN CONN_ESTAB occurs sooner)


#define MAX_SYN_REXMIT_COUNT     12     // will only be used with SYN+ACK: with SYN CONN_ESTAB occurs sooner

#define MAX_SACK_BLOCKS           60    // will only be used with SACK
#define DUPTHRESH                  3    // used for TCPTahoe, TCPReno and SACK (RFC 3517)

#define TCP_MAX_WIN            65535    // largest value (16 bit) for (unscaled) window size

#define PAWS_IDLE_TIME_THRESH 24*24*3600 // 24 days in seconds (RFC 1323)

#define TCP_OPTION_TS_SIZE  12

class INET_API TCPStateVariables : public cPolymorphic
{
  public:
    TCPStateVariables();
    virtual std::string info() const;
    virtual std::string detailedInfo() const;
  public:
    bool active;         // set if the connection was initiated by an active open
    bool fork;           // if passive and in LISTEN: whether to fork on an incoming connection

    uint32 snd_mss;      // sender maximum segment size (without headers, i.e. only segment text); see RFC 2581, page 1.
                         // This will be set to the minimum of the local smss parameter and the value specified in the
                         // MSS option received during connection setup.

    // send sequence number variables (see RFC 793, "3.2. Terminology")
    uint32 snd_una;      // send unacknowledged
    uint32 snd_nxt;      // send next (drops back on retransmission)
    uint32 snd_max;      // max seq number sent (needed because snd_nxt is re-set on retransmission)
    uint32 snd_wnd;      // send window
    uint32 snd_up;       // send urgent pointer
    uint32 snd_wl1;      // segment sequence number used for last window update
    uint32 snd_wl2;      // segment ack. number used for last window update
    uint32 iss;          // initial sequence number (ISS)

    // receive sequence number variables
    uint32 rcv_nxt;      // receive next
    uint32 rcv_wnd;      // receive window
    uint32 rcv_up;       // receive urgent pointer;
    uint32 irs;          // initial receive sequence number
    uint32 rcv_adv;      // advertised window

    // SYN, SYN+ACK retransmission variables (handled separately
    // because normal rexmit belongs to TCPAlgorithm)
    int syn_rexmit_count; // number of SYN/SYN+ACK retransmissions (=1 after first rexmit)
    simtime_t syn_rexmit_timeout; // current SYN/SYN+ACK retransmission timeout

    // whether ACK of our FIN has been received. Needed in FIN bit processing
    // to decide between transition to TIME-WAIT and CLOSING (set event code
    // TCP_E_RCV_FIN or TCP_E_RCV_FIN_ACK).
    bool fin_ack_rcvd;

    bool send_fin;       // true if a user CLOSE command has been "queued"
    uint32 snd_fin_seq;  // if send_fin==true: FIN should be sent just before this sequence number

    bool fin_rcvd;       // whether FIN received or not
    uint32 rcv_fin_seq;  // if fin_rcvd: sequence number of received FIN

    uint32 sentBytes;    // amount of user data (in bytes) sent in last segment

    bool nagle_enabled;         // set if Nagle's algorithm (RFC 896) is enabled
    bool delayed_acks_enabled;  // set if delayed ACK algorithm (RFC 1122) is enabled
    bool limited_transmit_enabled; // set if Limited Transmit algorithm (RFC 3042) is enabled
    bool increased_IW_enabled;  // set if Increased Initial Window (RFC 3390) is enabled

    uint32 full_sized_segment_counter; // this counter is needed for delayed ACK
    bool ack_now;               // send ACK immediately, needed if delayed_acks_enabled is set
                                // Based on [Stevens, W.R.: TCP/IP Illustrated, Volume 2, page 861].
                                // ack_now should be set when:
                                //   - delayed ACK timer expires
                                //   - an out-of-order segment is received
                                //   - SYN is received during the three-way handshake
                                //   - a persist probe is received
                                //   - FIN is received

    bool afterRto;              // set at RTO, reset when snd_nxt == snd_max or snd_una == snd_max

    // WINDOW_SCALE related variables
    bool ws_support;         // set if the host supports Window Scale (header option) (RFC 1322)
    bool ws_enabled;         // set if the connection uses Window Scale (header option)
    bool snd_ws;             // set if initial WINDOW_SCALE has been sent
    bool rcv_ws;             // set if initial WINDOW_SCALE has been received
    uint rcv_wnd_scale;      // RFC 1323, page 31: "Receive window scale power"
    uint snd_wnd_scale;      // RFC 1323, page 31: "Send window scale power"

    // TIMESTAMP related variables
    bool ts_support;         // set if the host supports Timestamps (header option) (RFC 1322)
    bool ts_enabled;         // set if the connection uses Window Scale (header option)
    bool snd_initial_ts;     // set if initial TIMESTAMP has been sent
    bool rcv_initial_ts;     // set if initial TIMESTAMP has been received
    uint32 ts_recent;        // RFC 1323, page 31: "Latest received Timestamp"
    uint32 last_ack_sent;    // RFC 1323, page 31: "Last ACK field sent"
    simtime_t time_last_data_sent; // time at which the last data segment was sent (needed to compute the IDLE time for PAWS)

    // SACK related variables
    bool sack_support;       // set if the host supports selective acknowledgment (header option) (RFC 2018, 2883, 3517)
    bool sack_enabled;       // set if the connection uses selective acknowledgment (header option)
    bool snd_sack_perm;      // set if SACK_PERMITTED has been sent
    bool rcv_sack_perm;      // set if SACK_PERMITTED has been received
    uint32 start_seqno;      // start sequence number of last received out-of-order segment
    uint32 end_seqno;        // end sequence number of last received out-of-order segment
    bool snd_sack;           // set if received vaild out-of-order segment or rcv_nxt changed, but receivedQueue is not empty
    bool snd_dsack;          // set if received duplicated segment (sequenceNo+PLength < rcv_nxt) or (segment is not acceptable)
    Sack sacks_array[MAX_SACK_BLOCKS]; // MAX_SACK_BLOCKS is set to 60
    uint32 highRxt;          // RFC 3517, page 3: ""HighRxt" is the highest sequence number which has been retransmitted during the current loss recovery phase."
    uint32 pipe;             // RFC 3517, page 3: ""Pipe" is a sender's estimate of the number of bytes outstanding in the network."
    uint32 recoveryPoint;    // RFC 3517
    uint32 sackedBytes;      // number of sackedBytes
    uint32 sackedBytes_old;  // old number of sackedBytes - needed for RFC 3042 to check if last dupAck contained new sack information
    bool lossRecovery;       // indicates if algorithm is in loss recovery phase

    // those counters would logically belong to TCPAlgorithm, but it's a lot easier to manage them here
    uint32 dupacks;          // current number of received consecutive duplicate ACKs
    uint32 snd_sacks;        // number of sent sacks
    uint32 rcv_sacks;        // number of received sacks
    uint32 rcv_oooseg;       // number of received out-of-order segments

    // receiver buffer / receiver queue related variables
    uint32 maxRcvBuffer;     // maximal amount of bytes in tcp receive queue
    uint32 usedRcvBuffer;    // current amount of used bytes in tcp receive queue
    uint32 freeRcvBuffer;    // current amount of free bytes in tcp receive queue
    uint32 tcpRcvQueueDrops; // number of drops in tcp receive queue
};



class INET_API TCPConnection
{
  public:
    // connection identification by apps: appgateIndex+connId
    int appGateIndex; // application gate index
    int connId;       // identifies connection within the app

    // socket pair
    IPvXAddress localAddr;
    IPvXAddress remoteAddr;
    int localPort;
    int remotePort;

  protected:
    TCP *tcpMain; // TCP module

    // TCP state machine
    cFSM fsm;

    // variables associated with TCP state
    TCPStateVariables *state;

    // TCP queues
    TCPSendQueue *sendQueue;
    TCPReceiveQueue *receiveQueue;
 public:

    TCPSACKRexmitQueue *rexmitQueue;

 protected:
    // TCP behavior in data transfer state
    TCPAlgorithm *tcpAlgorithm;

    // timers
    cMessage *the2MSLTimer;
    cMessage *connEstabTimer;
    cMessage *finWait2Timer;
    cMessage *synRexmitTimer; // for retransmitting SYN and SYN+ACK

    // statistics
    cOutVector *sndWndVector;   // snd_wnd
    cOutVector *rcvWndVector;   // rcv_wnd
    cOutVector *rcvAdvVector;   // current advertised window (=rcv_avd)
    cOutVector *sndNxtVector;   // sent seqNo
    cOutVector *sndAckVector;   // sent ackNo
    cOutVector *rcvSeqVector;   // received seqNo
    cOutVector *rcvAckVector;   // received ackNo (= snd_una)
    cOutVector *unackedVector;  // number of bytes unacknowledged

    cOutVector *dupAcksVector;   // current number of received dupAcks
    cOutVector *pipeVector;      // current sender's estimate of bytes outstanding in the network
    cOutVector *sndSacksVector;  // number of sent Sacks
    cOutVector *rcvSacksVector;  // number of received Sacks
    cOutVector *rcvOooSegVector; // number of received out-of-order segments

    cOutVector *sackedBytesVector;        // current number of received sacked bytes
    cOutVector *tcpRcvQueueBytesVector;   // current amount of used bytes in tcp receive queue
    cOutVector *tcpRcvQueueDropsVector;   // number of drops in tcp receive queue

  protected:
    virtual TCPEventCode preanalyseAppCommandEvent(int commandCode);
    virtual bool performStateTransition(const TCPEventCode& event);
    virtual void stateEntered(int state);

    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 bool tryFastRoute(TCPSegment *tcpseg);
    virtual TCPEventCode process_RCV_SEGMENT(TCPSegment *tcpseg, IPvXAddress src, IPvXAddress dest);
    virtual TCPEventCode processSegmentInListen(TCPSegment *tcpseg, IPvXAddress src, IPvXAddress dest);
    virtual TCPEventCode processSegmentInSynSent(TCPSegment *tcpseg, IPvXAddress src, IPvXAddress dest);
    virtual TCPEventCode processSegment1stThru8th(TCPSegment *tcpseg);
    virtual TCPEventCode processRstInSynReceived(TCPSegment *tcpseg);
    virtual bool processAckInEstabEtc(TCPSegment *tcpseg);

    virtual bool processMSSOption(TCPSegment *tcpseg, const TCPOption& option);
    virtual bool processWSOption(TCPSegment *tcpseg, const TCPOption& option);
    virtual bool processSACKPermittedOption(TCPSegment *tcpseg, const TCPOption& option);
    virtual bool processSACKOption(TCPSegment *tcpseg, const TCPOption& option);
    virtual bool processTSOption(TCPSegment *tcpseg, const TCPOption& option);

    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);

    virtual TCPConnection *cloneListeningConnection();

    virtual void initConnection(TCPOpenCommand *openCmd);

    virtual void configureStateVariables();

    virtual void selectInitialSeqNum();

    virtual bool isSegmentAcceptable(TCPSegment *tcpseg);

    virtual void sendSyn();

    virtual void sendSynAck();

    virtual void readHeaderOptions(TCPSegment *tcpseg);

    virtual TCPSegment writeHeaderOptions(TCPSegment *tcpseg);

    virtual TCPSegment addSacks(TCPSegment *tcpseg);

    virtual uint32 getTSval(TCPSegment *tcpseg);

    virtual uint32 getTSecr(TCPSegment *tcpseg);
  public:
    virtual void sendAck();

    virtual bool sendData(bool fullSegmentsOnly, uint32 congestionWindow);

    virtual bool sendProbe();

    virtual void retransmitOneSegment(bool called_at_rto);

    virtual void retransmitData();

    virtual void sendRst(uint32 seqNo);
    virtual void sendRst(uint32 seq, IPvXAddress src, IPvXAddress dest, int srcPort, int destPort);
    virtual void sendRstAck(uint32 seq, uint32 ack, IPvXAddress src, IPvXAddress dest, int srcPort, int destPort);

    virtual void sendFin();

    virtual void sendSegment(uint32 bytes);

    virtual void sendToIP(TCPSegment *tcpseg);

    virtual TCPSegment *createTCPSegment(const char *name);

    virtual void startSynRexmitTimer();

    virtual void signalConnectionTimeout();

    void scheduleTimeout(cMessage *msg, simtime_t timeout)
        {tcpMain->scheduleAt(simTime()+timeout, msg);}

  protected:
    cMessage *cancelEvent(cMessage *msg) {return tcpMain->cancelEvent(msg);}

    static void sendToIP(TCPSegment *tcpseg, IPvXAddress src, IPvXAddress dest);

    virtual void sendToApp(cMessage *msg);

    virtual void sendIndicationToApp(int code);

    virtual void sendEstabIndicationToApp();

  public:
    virtual void printConnBrief();
    static void printSegmentBrief(TCPSegment *tcpseg);
    static const char *stateName(int state);
    static const char *eventName(int event);
    static const char *indicationName(int code);
    static const char *optionName(int option);
    virtual void updateRcvQueueVars();

    virtual unsigned short updateRcvWnd();

    virtual void updateWndInfo(TCPSegment *tcpseg, bool doAlways=false);

  public:
    TCPConnection(TCP *mod, int appGateIndex, int connId);

    TCPConnection();

    virtual ~TCPConnection();

    virtual void segmentArrivalWhileClosed(TCPSegment *tcpseg, IPvXAddress src, IPvXAddress dest);

    int getFsmState() const {return fsm.getState();}
    TCPStateVariables *getState() {return state;}
    TCPSendQueue *getSendQueue() {return sendQueue;}
    TCPSACKRexmitQueue *getRexmitQueue() {return rexmitQueue;}
    TCPReceiveQueue *getReceiveQueue() {return receiveQueue;}
    TCPAlgorithm *getTcpAlgorithm() {return tcpAlgorithm;}
    TCP *getTcpMain() {return tcpMain;}

    virtual bool processTimer(cMessage *msg);

    virtual bool processTCPSegment(TCPSegment *tcpSeg, IPvXAddress srcAddr, IPvXAddress destAddr);

    virtual bool processAppCommand(cMessage *msg);

    virtual bool isLost(uint32 seqNum);

    virtual void setPipe();

    virtual uint32 nextSeg();

    virtual void sendDataDuringLossRecoveryPhase(uint32 congestionWindow);

    virtual void sendSegmentDuringLossRecoveryPhase(uint32 seqNum);

    virtual void sendOneNewSegment(bool fullSegmentsOnly, uint32 congestionWindow);

    virtual uint32 convertSimtimeToTS(simtime_t simtime);

    virtual simtime_t convertTSToSimtime(uint32 timestamp);

    virtual bool isSendQueueEmpty();

};

#endif