inet::tcp::Tcp Class Reference

Implements the Tcp protocol. More...

#include <Tcp.h>

Inheritance diagram for inet::tcp::Tcp:

Classes
struct	SockPair

Public Types
enum	PortRange { EPHEMERAL_PORTRANGE_START = 1024, EPHEMERAL_PORTRANGE_END = 5000 }

Public Member Functions
	Tcp ()
virtual	~Tcp ()
virtual void	addSockPair (TcpConnection *conn, L3Address localAddr, L3Address remoteAddr, int localPort, int remotePort)
	To be called from TcpConnection when a new connection gets created, during processing of OPEN_ACTIVE or OPEN_PASSIVE. More...
virtual void	removeConnection (TcpConnection *conn)
virtual void	sendFromConn (cMessage *msg, const char *gatename, int gateindex=-1)
virtual void	updateSockPair (TcpConnection *conn, L3Address localAddr, L3Address remoteAddr, int localPort, int remotePort)
	To be called from TcpConnection when socket pair (key for TcpConnMap) changes (e.g. More...
virtual void	addForkedConnection (TcpConnection *conn, TcpConnection *newConn, L3Address localAddr, L3Address remoteAddr, int localPort, int remotePort)
	Update conn's socket pair, and register newConn (which'll keep LISTENing). More...
virtual ushort	getEphemeralPort ()
	To be called from TcpConnection: reserves an ephemeral port for the connection. More...
virtual TcpSendQueue *	createSendQueue ()
	To be called from TcpConnection: create a new send queue. More...
virtual TcpReceiveQueue *	createReceiveQueue ()
	To be called from TcpConnection: create a new receive queue. More...
virtual void	handleStartOperation (LifecycleOperation *operation) override
virtual void	handleStopOperation (LifecycleOperation *operation) override
virtual void	handleCrashOperation (LifecycleOperation *operation) override
virtual void	reset ()
bool	checkCrc (Packet *pk)
int	getMsl ()
Public Member Functions inherited from inet::TransportProtocolBase
	TransportProtocolBase ()
Public Member Functions inherited from inet::OperationalMixin< cSimpleModule >
virtual	~OperationalMixin ()
	}@ More...
Public Member Functions inherited from inet::ILifecycle
virtual	~ILifecycle ()

Public Attributes
bool	useDataNotification = false
CrcMode	crcMode = CRC_MODE_UNDEFINED
int	msl

Static Public Attributes
static simsignal_t	tcpConnectionAddedSignal = registerSignal("tcpConnectionAdded")
static simsignal_t	tcpConnectionRemovedSignal = registerSignal("tcpConnectionRemoved")

Protected Types
typedef std::map< int, TcpConnection * >	TcpAppConnMap
typedef std::map< SockPair, TcpConnection * >	TcpConnMap
Protected Types inherited from inet::OperationalMixin< cSimpleModule >
enum	State

Protected Member Functions
virtual TcpConnection *	createConnection (int socketId)
	Factory method; may be overriden for customizing Tcp. More...
virtual TcpConnection *	findConnForSegment (const Ptr< const TcpHeader > &tcpHeader, L3Address srcAddr, L3Address destAddr)
virtual TcpConnection *	findConnForApp (int socketId)
virtual void	segmentArrivalWhileClosed (Packet *tcpSegment, const Ptr< const TcpHeader > &tcpHeader, L3Address src, L3Address dest)
virtual void	refreshDisplay () const override
virtual void	initialize (int stage) override
virtual int	numInitStages () const override
virtual void	finish () override
virtual void	handleSelfMessage (cMessage *message) override
virtual void	handleUpperCommand (cMessage *message) override
virtual void	handleUpperPacket (Packet *packet) override
virtual void	handleLowerPacket (Packet *packet) override
Protected Member Functions inherited from inet::TransportProtocolBase
virtual bool	isUpperMessage (cMessage *message) const override
virtual bool	isLowerMessage (cMessage *message) const override
virtual bool	isInitializeStage (int stage) const override
virtual bool	isModuleStartStage (int stage) const override
virtual bool	isModuleStopStage (int stage) const override
Protected Member Functions inherited from inet::LayeredProtocolBase
virtual void	handleMessageWhenUp (cMessage *message) override
virtual void	handleUpperMessage (cMessage *message)
virtual void	handleLowerMessage (cMessage *message)
virtual void	handleLowerCommand (cMessage *message)
Protected Member Functions inherited from inet::OperationalMixin< cSimpleModule >
virtual int	numInitStages () const override
virtual void	refreshDisplay () const override
virtual void	handleMessage (cMessage *msg) override
virtual void	handleMessageWhenDown (cMessage *msg)
virtual bool	handleOperationStage (LifecycleOperation *operation, IDoneCallback *doneCallback) override
	Perform one stage of a lifecycle operation. More...
virtual State	getInitialOperationalState () const
	Returns initial operational state: OPERATING or NOT_OPERATING. More...
virtual void	handleActiveOperationTimeout (cMessage *message)
virtual bool	isUp () const
	utility functions More...
virtual bool	isDown () const
virtual void	setOperationalState (State newState)
virtual void	scheduleOperationTimeout (simtime_t timeout)
virtual void	setupActiveOperation (LifecycleOperation *operation, IDoneCallback *doneCallback, State)
virtual void	delayActiveOperationFinish (simtime_t timeout)
virtual void	startActiveOperationExtraTime (simtime_t delay=SIMTIME_ZERO)
virtual void	startActiveOperationExtraTimeOrFinish (simtime_t extraTime)
virtual void	finishActiveOperation ()

Protected Attributes
TcpAppConnMap	tcpAppConnMap
TcpConnMap	tcpConnMap
ushort	lastEphemeralPort = static_cast<ushort>(-1)
std::multiset< ushort >	usedEphemeralPorts
Protected Attributes inherited from inet::OperationalMixin< cSimpleModule >
State	operationalState
simtime_t	lastChange
Operation	activeOperation
cMessage *	activeOperationTimeout
cMessage *	activeOperationExtraTimer

Detailed Description

Implements the Tcp protocol.

This section describes the internal architecture of the Tcp model.

Usage and compliance with various RFCs are discussed in the corresponding NED documentation for Tcp. Also, you may want to check the TcpSocket class which makes it easier to use Tcp from applications.

The Tcp protocol implementation is composed of several classes (discussion follows below):

• Tcp: the module class
• TcpConnection: manages a connection
• TcpSendQueue, TcpReceiveQueue: abstract base classes for various types of send and receive queues
• TCPVirtualDataSendQueue and TCPVirtualDataRcvQueue which implement queues with "virtual" bytes (byte counts only)
• TcpAlgorithm: abstract base class for Tcp algorithms, and subclasses: DumbTcp, TcpBaseAlg, TcpTahoeRenoFamily, TcpTahoe, TcpReno, TcpNewReno.

Tcp subclassed from cSimpleModule. It manages socketpair-to-connection mapping, and dispatches segments and user commands to the appropriate TcpConnection object.

TcpConnection manages the connection, with the help of other objects. TcpConnection itself implements the basic Tcp "machinery": takes care of the state machine, stores the state variables (TCB), sends/receives SYN, FIN, RST, ACKs, etc.

TcpConnection internally relies on 3 objects. The first two are subclassed from TcpSendQueue and TcpReceiveQueue. They manage the actual data stream, so TcpConnection itself only works with sequence number variables. This makes it possible to easily accomodate need for various types of simulated data transfer: real byte stream, "virtual" bytes (byte counts only), and sequence of cMessage objects (where every message object is mapped to a Tcp sequence number range).

Currently implemented send queue and receive queue classes are TCPVirtualDataSendQueue and TCPVirtualDataRcvQueue which implement queues with "virtual" bytes (byte counts only).

The third object is subclassed from TcpAlgorithm. Control over retransmissions, congestion control and ACK sending are "outsourced" from TcpConnection into TcpAlgorithm: delayed acks, slow start, fast rexmit, etc. are all implemented in TcpAlgorithm subclasses. This simplifies the design of TcpConnection and makes it a lot easier to implement new Tcp variations such as NewReno, Vegas or LinuxTcp as TcpAlgorithm subclasses.

Currently implemented TcpAlgorithm classes are TcpReno, TcpTahoe, TcpNewReno, TcpNoCongestionControl and DumbTcp.

The concrete TcpAlgorithm class to use can be chosen per connection (in OPEN) or in a module parameter.

Member Typedef Documentation

TcpAppConnMap

typedef std::map<int , TcpConnection *> inet::tcp::Tcp::TcpAppConnMap

protected

TcpConnMap

typedef std::map<SockPair, TcpConnection *> inet::tcp::Tcp::TcpConnMap

protected

Member Enumeration Documentation

PortRange

enum inet::tcp::Tcp::PortRange

Enumerator
EPHEMERAL_PORTRANGE_START
EPHEMERAL_PORTRANGE_END

                   {
        EPHEMERAL_PORTRANGE_START = 1024,
        EPHEMERAL_PORTRANGE_END   = 5000
    };

Constructor & Destructor Documentation

Tcp()

inet::tcp::Tcp::Tcp ( )

inline

{}

~Tcp()

inet::tcp::Tcp::~Tcp ( )

virtual

{
}

Member Function Documentation

addForkedConnection()

void inet::tcp::Tcp::addForkedConnection ( TcpConnection *  conn, TcpConnection *  newConn, L3Address  localAddr, L3Address  remoteAddr, int  localPort, int  remotePort  )

virtual

Update conn's socket pair, and register newConn (which'll keep LISTENing).

Also, conn will get a new socketId (and newConn will live on with its old socketId).

{
    // update conn's socket pair, and register newConn
    addSockPair(newConn, localAddr, remoteAddr, localPort, remotePort);
 
    // newConn will live on with the new socketId
    tcpAppConnMap[newConn->socketId] = newConn;
}

Referenced by inet::tcp::TcpConnection::processSegmentInListen().

addSockPair()

void inet::tcp::Tcp::addSockPair ( TcpConnection *  conn, L3Address  localAddr, L3Address  remoteAddr, int  localPort, int  remotePort  )

virtual

To be called from TcpConnection when a new connection gets created, during processing of OPEN_ACTIVE or OPEN_PASSIVE.

{
    // update addresses/ports in TcpConnection
    SockPair key;
    key.localAddr = conn->localAddr = localAddr;
    key.remoteAddr = conn->remoteAddr = remoteAddr;
    key.localPort = conn->localPort = localPort;
    key.remotePort = conn->remotePort = remotePort;
 
    // make sure connection is unique
    auto it = tcpConnMap.find(key);
    if (it != tcpConnMap.end()) {
        // throw "address already in use" error
        if (remoteAddr.isUnspecified() && remotePort == -1)
            throw cRuntimeError("Address already in use: there is already a connection listening on %s:%d",
                    localAddr.str().c_str(), localPort);
        else
            throw cRuntimeError("Address already in use: there is already a connection %s:%d to %s:%d",
                    localAddr.str().c_str(), localPort, remoteAddr.str().c_str(), remotePort);
    }
 
    // then insert it into tcpConnMap
    tcpConnMap[key] = conn;
 
    // mark port as used
    if (localPort >= EPHEMERAL_PORTRANGE_START && localPort < EPHEMERAL_PORTRANGE_END)
        usedEphemeralPorts.insert(localPort);
}

Referenced by addForkedConnection(), inet::tcp::TcpConnection::process_OPEN_ACTIVE(), and inet::tcp::TcpConnection::process_OPEN_PASSIVE().

checkCrc()

bool inet::tcp::Tcp::checkCrc

(

Packet *

pk

)

{
    auto tcpHeader = tcpSegment->peekAtFront<TcpHeader>();
 
    switch (tcpHeader->getCrcMode()) {
        case CRC_COMPUTED: {
            // check CRC:
            auto networkProtocol = tcpSegment->getTag<NetworkProtocolInd>()->getProtocol();
            const std::vector<uint8_t> tcpBytes = tcpSegment->peekDataAsBytes()->getBytes();
            auto pseudoHeader = makeShared<TransportPseudoHeader>();
            L3Address srcAddr = tcpSegment->getTag<L3AddressInd>()->getSrcAddress();
            L3Address destAddr = tcpSegment->getTag<L3AddressInd>()->getDestAddress();
            pseudoHeader->setSrcAddress(srcAddr);
            pseudoHeader->setDestAddress(destAddr);
            ASSERT(networkProtocol);
            pseudoHeader->setNetworkProtocolId(networkProtocol->getId());
            pseudoHeader->setProtocolId(IP_PROT_TCP);
            pseudoHeader->setPacketLength(B(tcpBytes.size()));
            // pseudoHeader length: ipv4: 12 bytes, ipv6: 40 bytes, generic: ???
            if (networkProtocol == &Protocol::ipv4)
                pseudoHeader->setChunkLength(B(12));
            else if (networkProtocol == &Protocol::ipv6)
                pseudoHeader->setChunkLength(B(40));
            else
                throw cRuntimeError("Unknown network protocol: %s", networkProtocol->getName());
            MemoryOutputStream stream;
            Chunk::serialize(stream, pseudoHeader);
            Chunk::serialize(stream, tcpSegment->peekData());
            uint16_t crc = TcpIpChecksum::checksum(stream.getData());
            return crc == 0;
        }
        case CRC_DECLARED_CORRECT:
            return true;
        case CRC_DECLARED_INCORRECT:
            return false;
        default:
            break;
    }
    throw cRuntimeError("unknown CRC mode: %d", tcpHeader->getCrcMode());
}

Referenced by handleLowerPacket().

createConnection()

TcpConnection * inet::tcp::Tcp::createConnection ( int  socketId )

protectedvirtual

Factory method; may be overriden for customizing Tcp.

{
    auto moduleType = cModuleType::get("inet.transportlayer.tcp.TcpConnection");
    char submoduleName[24];
    sprintf(submoduleName, "conn-%d", socketId);
    auto module = check_and_cast<TcpConnection *>(moduleType->createScheduleInit(submoduleName, this));
    module->initConnection(this, socketId);
    return module;
}

Referenced by handleUpperCommand().

createReceiveQueue()

TcpReceiveQueue * inet::tcp::Tcp::createReceiveQueue ( )

virtual

To be called from TcpConnection: create a new receive queue.

{
    return new TcpReceiveQueue();
}

Referenced by inet::tcp::TcpConnection::initConnection().

createSendQueue()

TcpSendQueue * inet::tcp::Tcp::createSendQueue ( )

virtual

To be called from TcpConnection: create a new send queue.

{
    return new TcpSendQueue();
}

Referenced by inet::tcp::TcpConnection::initConnection().

findConnForApp()

TcpConnection * inet::tcp::Tcp::findConnForApp ( int  socketId )

protectedvirtual

{
    auto i = tcpAppConnMap.find(socketId);
    return i == tcpAppConnMap.end() ? nullptr : i->second;
}

Referenced by handleUpperCommand().

findConnForSegment()

TcpConnection * inet::tcp::Tcp::findConnForSegment ( const Ptr< const TcpHeader > &  tcpHeader, L3Address  srcAddr, L3Address  destAddr  )

protectedvirtual

{
    SockPair key;
    key.localAddr = destAddr;
    key.remoteAddr = srcAddr;
    key.localPort = tcpHeader->getDestPort();
    key.remotePort = tcpHeader->getSrcPort();
    SockPair save = key;
 
    // try with fully qualified SockPair
    auto i = tcpConnMap.find(key);
    if (i != tcpConnMap.end())
        return i->second;
 
    // try with localAddr missing (only localPort specified in passive/active open)
    key.localAddr = L3Address();
    i = tcpConnMap.find(key);
 
    if (i != tcpConnMap.end())
        return i->second;
 
    // try fully qualified local socket + blank remote socket (for incoming SYN)
    key = save;
    key.remoteAddr = L3Address();
    key.remotePort = -1;
    i = tcpConnMap.find(key);
 
    if (i != tcpConnMap.end())
        return i->second;
 
    // try with blank remote socket, and localAddr missing (for incoming SYN)
    key.localAddr = L3Address();
    i = tcpConnMap.find(key);
 
    if (i != tcpConnMap.end())
        return i->second;
 
    // given up
    return nullptr;
}

Referenced by handleLowerPacket().

finish()

void inet::tcp::Tcp::finish ( )

overrideprotectedvirtual

{
    EV_INFO << getFullPath() << ": finishing with " << tcpConnMap.size() << " connections open.\n";
}

getEphemeralPort()

ushort inet::tcp::Tcp::getEphemeralPort ( )

virtual

To be called from TcpConnection: reserves an ephemeral port for the connection.

{
    // start at the last allocated port number + 1, and search for an unused one
    ushort searchUntil = lastEphemeralPort++;
    if (lastEphemeralPort == EPHEMERAL_PORTRANGE_END) // wrap
        lastEphemeralPort = EPHEMERAL_PORTRANGE_START;
 
    while (usedEphemeralPorts.find(lastEphemeralPort) != usedEphemeralPorts.end()) {
        if (lastEphemeralPort == searchUntil) // got back to starting point?
            throw cRuntimeError("Ephemeral port range %d..%d exhausted, all ports occupied", EPHEMERAL_PORTRANGE_START, EPHEMERAL_PORTRANGE_END);
 
        lastEphemeralPort++;
 
        if (lastEphemeralPort == EPHEMERAL_PORTRANGE_END) // wrap
            lastEphemeralPort = EPHEMERAL_PORTRANGE_START;
    }
 
    // found a free one, return it
    return lastEphemeralPort;
}

Referenced by inet::tcp::TcpConnection::process_OPEN_ACTIVE().

getMsl()

int inet::tcp::Tcp::getMsl ( )

inline

{ return msl; }

Referenced by inet::tcp::TcpConnection::processSegment1stThru8th().

handleCrashOperation()

void inet::tcp::Tcp::handleCrashOperation ( LifecycleOperation *  operation )

overridevirtual

Implements inet::OperationalMixin< cSimpleModule >.

{
    reset();
}

handleLowerPacket()

void inet::tcp::Tcp::handleLowerPacket ( Packet *  packet )

overrideprotectedvirtual

Reimplemented from inet::LayeredProtocolBase.

{
    auto protocol = packet->getTag<PacketProtocolTag>()->getProtocol();
    if (protocol == &Protocol::tcp) {
        if (!checkCrc(packet)) {
            EV_WARN << "Tcp segment has wrong CRC, dropped\n";
            PacketDropDetails details;
            details.setReason(INCORRECTLY_RECEIVED);
            emit(packetDroppedSignal, packet, &details);
            delete packet;
            return;
        }
 
        // must be a TcpHeader
        auto tcpHeader = packet->peekAtFront<TcpHeader>();
 
        // get src/dest addresses
        L3Address srcAddr, destAddr;
        srcAddr = packet->getTag<L3AddressInd>()->getSrcAddress();
        destAddr = packet->getTag<L3AddressInd>()->getDestAddress();
        int ecn = 0;
        if (auto ecnTag = packet->findTag<EcnInd>())
            ecn = ecnTag->getExplicitCongestionNotification();
        ASSERT(ecn != -1);
 
        // process segment
        TcpConnection *conn = findConnForSegment(tcpHeader, srcAddr, destAddr);
        if (conn) {
            TcpStateVariables *state = conn->getState();
            if (state && state->ect) {
                // This may be true only in receiver side. According to RFC 3168, page 20:
                // pure acknowledgement packets (e.g., packets that do not contain
                // any accompanying data) MUST be sent with the not-ECT codepoint.
                state->gotCeIndication = (ecn == 3);
            }
 
            bool ret = conn->processTCPSegment(packet, tcpHeader, srcAddr, destAddr);
            if (!ret)
                removeConnection(conn);
        }
        else {
            segmentArrivalWhileClosed(packet, tcpHeader, srcAddr, destAddr);
        }
    }
    else if (protocol == &Protocol::icmpv4 || protocol == &Protocol::icmpv6) {
        EV_DETAIL << "ICMP error received -- discarding\n"; // FIXME can ICMP packets really make it up to Tcp???
        delete packet;
    }
    else
        throw cRuntimeError("Unknown protocol: '%s'", (protocol != nullptr ? protocol->getName() : "<nullptr>"));
}

handleSelfMessage()

void inet::tcp::Tcp::handleSelfMessage ( cMessage *  message )

overrideprotectedvirtual

Reimplemented from inet::LayeredProtocolBase.

{
    throw cRuntimeError("model error: should schedule timers on connection");
}

handleStartOperation()

void inet::tcp::Tcp::handleStartOperation ( LifecycleOperation *  operation )

overridevirtual

Implements inet::OperationalMixin< cSimpleModule >.

{
    // FIXME implementation
}

handleStopOperation()

void inet::tcp::Tcp::handleStopOperation ( LifecycleOperation *  operation )

overridevirtual

Implements inet::OperationalMixin< cSimpleModule >.

{
    // FIXME close connections??? yes, because the applications may not close them!!!
    reset();
    delayActiveOperationFinish(par("stopOperationTimeout"));
    startActiveOperationExtraTimeOrFinish(par("stopOperationExtraTime"));
}

handleUpperCommand()

void inet::tcp::Tcp::handleUpperCommand ( cMessage *  message )

overrideprotectedvirtual

Reimplemented from inet::LayeredProtocolBase.

{
    int socketId = check_and_cast<ITaggedObject *>(msg)->getTags().getTag<SocketReq>()->getSocketId();
    TcpConnection *conn = findConnForApp(socketId);
 
    if (!conn) {
        conn = createConnection(socketId);
 
        // add into appConnMap here; it'll be added to connMap during processing
        // the OPEN command in TcpConnection's processAppCommand().
        tcpAppConnMap[socketId] = conn;
 
        EV_INFO << "Tcp connection created for " << msg << "\n";
    }
 
    if (!conn->processAppCommand(msg))
        removeConnection(conn);
}

Referenced by handleUpperPacket().

handleUpperPacket()

void inet::tcp::Tcp::handleUpperPacket ( Packet *  packet )

overrideprotectedvirtual

Reimplemented from inet::LayeredProtocolBase.

{
    handleUpperCommand(packet);
}

initialize()

void inet::tcp::Tcp::initialize ( int  stage )

overrideprotectedvirtual

Reimplemented from inet::OperationalMixin< cSimpleModule >.

{
    OperationalBase::initialize(stage);
 
    if (stage == INITSTAGE_LOCAL) {
        const char *crcModeString = par("crcMode");
        crcMode = parseCrcMode(crcModeString, false);
 
        lastEphemeralPort = EPHEMERAL_PORTRANGE_START;
 
        msl = par("msl");
        useDataNotification = par("useDataNotification");
 
        WATCH(lastEphemeralPort);
        WATCH_PTRMAP(tcpConnMap);
        WATCH_PTRMAP(tcpAppConnMap);
    }
    else if (stage == INITSTAGE_TRANSPORT_LAYER) {
        registerService(Protocol::tcp, gate("appIn"), gate("appOut"));
        registerProtocol(Protocol::tcp, gate("ipOut"), gate("ipIn"));
        if (crcMode == CRC_COMPUTED) {
            cModuleType *moduleType = cModuleType::get("inet.transportlayer.tcp_common.TcpCrcInsertionHook");
            auto crcInsertion = check_and_cast<TcpCrcInsertionHook *>(moduleType->create("crcInsertion", this));
            crcInsertion->finalizeParameters();
            crcInsertion->callInitialize();
 
#ifdef INET_WITH_IPv4
            auto ipv4 = dynamic_cast<INetfilter *>(findModuleByPath("^.ipv4.ip"));
            if (ipv4 != nullptr)
                ipv4->registerHook(0, crcInsertion);
#endif
#ifdef INET_WITH_IPv6
            auto ipv6 = dynamic_cast<INetfilter *>(findModuleByPath("^.ipv6.ipv6"));
            if (ipv6 != nullptr)
                ipv6->registerHook(0, crcInsertion);
#endif
        }
    }
}

numInitStages()

virtual int inet::tcp::Tcp::numInitStages ( ) const

inlineoverrideprotectedvirtual

{ return NUM_INIT_STAGES; }

refreshDisplay()

void inet::tcp::Tcp::refreshDisplay ( ) const

overrideprotectedvirtual

{
    OperationalBase::refreshDisplay();
 
    if (getEnvir()->isExpressMode()) {
        // in express mode, we don't bother to update the display
        // (std::map's iteration is not very fast if map is large)
        getDisplayString().setTagArg("t", 0, "");
        return;
    }
 
    int numINIT = 0, numCLOSED = 0, numLISTEN = 0, numSYN_SENT = 0, numSYN_RCVD = 0,
        numESTABLISHED = 0, numCLOSE_WAIT = 0, numLAST_ACK = 0, numFIN_WAIT_1 = 0,
        numFIN_WAIT_2 = 0, numCLOSING = 0, numTIME_WAIT = 0;
 
    for (auto& elem : tcpAppConnMap) {
        int state = (elem).second->getFsmState();
 
        switch (state) {
            case TCP_S_INIT:
                numINIT++;
                break;
 
            case TCP_S_CLOSED:
                numCLOSED++;
                break;
 
            case TCP_S_LISTEN:
                numLISTEN++;
                break;
 
            case TCP_S_SYN_SENT:
                numSYN_SENT++;
                break;
 
            case TCP_S_SYN_RCVD:
                numSYN_RCVD++;
                break;
 
            case TCP_S_ESTABLISHED:
                numESTABLISHED++;
                break;
 
            case TCP_S_CLOSE_WAIT:
                numCLOSE_WAIT++;
                break;
 
            case TCP_S_LAST_ACK:
                numLAST_ACK++;
                break;
 
            case TCP_S_FIN_WAIT_1:
                numFIN_WAIT_1++;
                break;
 
            case TCP_S_FIN_WAIT_2:
                numFIN_WAIT_2++;
                break;
 
            case TCP_S_CLOSING:
                numCLOSING++;
                break;
 
            case TCP_S_TIME_WAIT:
                numTIME_WAIT++;
                break;
        }
    }
 
    char buf2[200];
    buf2[0] = '\0';
 
    if (numINIT > 0)
        sprintf(buf2 + strlen(buf2), "init:%d ", numINIT);
    if (numCLOSED > 0)
        sprintf(buf2 + strlen(buf2), "closed:%d ", numCLOSED);
    if (numLISTEN > 0)
        sprintf(buf2 + strlen(buf2), "listen:%d ", numLISTEN);
    if (numSYN_SENT > 0)
        sprintf(buf2 + strlen(buf2), "syn_sent:%d ", numSYN_SENT);
    if (numSYN_RCVD > 0)
        sprintf(buf2 + strlen(buf2), "syn_rcvd:%d ", numSYN_RCVD);
    if (numESTABLISHED > 0)
        sprintf(buf2 + strlen(buf2), "estab:%d ", numESTABLISHED);
    if (numCLOSE_WAIT > 0)
        sprintf(buf2 + strlen(buf2), "close_wait:%d ", numCLOSE_WAIT);
    if (numLAST_ACK > 0)
        sprintf(buf2 + strlen(buf2), "last_ack:%d ", numLAST_ACK);
    if (numFIN_WAIT_1 > 0)
        sprintf(buf2 + strlen(buf2), "fin_wait_1:%d ", numFIN_WAIT_1);
    if (numFIN_WAIT_2 > 0)
        sprintf(buf2 + strlen(buf2), "fin_wait_2:%d ", numFIN_WAIT_2);
    if (numCLOSING > 0)
        sprintf(buf2 + strlen(buf2), "closing:%d ", numCLOSING);
    if (numTIME_WAIT > 0)
        sprintf(buf2 + strlen(buf2), "time_wait:%d ", numTIME_WAIT);
 
    getDisplayString().setTagArg("t", 0, buf2);
}

removeConnection()

void inet::tcp::Tcp::removeConnection ( TcpConnection *  conn )

virtual

{
    EV_INFO << "Deleting Tcp connection\n";
 
    tcpAppConnMap.erase(conn->socketId);
 
    SockPair key2;
    key2.localAddr = conn->localAddr;
    key2.remoteAddr = conn->remoteAddr;
    key2.localPort = conn->localPort;
    key2.remotePort = conn->remotePort;
    tcpConnMap.erase(key2);
 
    // IMPORTANT: usedEphemeralPorts.erase(conn->localPort) is NOT GOOD because it
    // deletes ALL occurrences of the port from the multiset.
    auto it = usedEphemeralPorts.find(conn->localPort);
 
    if (it != usedEphemeralPorts.end())
        usedEphemeralPorts.erase(it);
 
    emit(tcpConnectionRemovedSignal, conn);
    conn->deleteModule();
}

Referenced by handleLowerPacket(), inet::tcp::TcpConnection::handleMessage(), and handleUpperCommand().

reset()

void inet::tcp::Tcp::reset ( )

virtual

{
    for (auto& elem : tcpAppConnMap)
        elem.second->deleteModule();
    tcpAppConnMap.clear();
    tcpConnMap.clear();
    usedEphemeralPorts.clear();
    lastEphemeralPort = EPHEMERAL_PORTRANGE_START;
}

Referenced by handleCrashOperation(), and handleStopOperation().

segmentArrivalWhileClosed()

void inet::tcp::Tcp::segmentArrivalWhileClosed ( Packet *  tcpSegment, const Ptr< const TcpHeader > &  tcpHeader, L3Address  src, L3Address  dest  )

protectedvirtual

{
    auto moduleType = cModuleType::get("inet.transportlayer.tcp.TcpConnection");
    const char *submoduleName = "conn-temp";
    auto module = check_and_cast<TcpConnection *>(moduleType->createScheduleInit(submoduleName, this));
    module->initConnection(this, -1);
    module->segmentArrivalWhileClosed(tcpSegment, tcpHeader, srcAddr, destAddr);
    module->deleteModule();
    delete tcpSegment;
}

Referenced by handleLowerPacket().

sendFromConn()

void inet::tcp::Tcp::sendFromConn ( cMessage *  msg, const char *  gatename, int  gateindex = -1  )

virtual

{
    Enter_Method("sendFromConn");
    take(msg);
    send(msg, gatename, gateindex);
}

Referenced by inet::tcp::TcpConnection::sendToApp(), and inet::tcp::TcpConnection::sendToIP().

updateSockPair()

void inet::tcp::Tcp::updateSockPair ( TcpConnection *  conn, L3Address  localAddr, L3Address  remoteAddr, int  localPort, int  remotePort  )

virtual

To be called from TcpConnection when socket pair (key for TcpConnMap) changes (e.g.

becomes fully qualified).

{
    // find with existing address/port pair...
    SockPair key;
    key.localAddr = conn->localAddr;
    key.remoteAddr = conn->remoteAddr;
    key.localPort = conn->localPort;
    key.remotePort = conn->remotePort;
    auto it = tcpConnMap.find(key);
 
    ASSERT(it != tcpConnMap.end() && it->second == conn);
 
    // ...and remove from the old place in tcpConnMap
    tcpConnMap.erase(it);
 
    // then update addresses/ports, and re-insert it with new key into tcpConnMap
    key.localAddr = conn->localAddr = localAddr;
    key.remoteAddr = conn->remoteAddr = remoteAddr;
    ASSERT(conn->localPort == localPort);
    key.remotePort = conn->remotePort = remotePort;
    tcpConnMap[key] = conn;
 
    // localPort doesn't change (see ASSERT above), so there's no need to update usedEphemeralPorts[].
}

Referenced by inet::tcp::TcpConnection::processSegmentInListen(), and inet::tcp::TcpConnection::processSegmentInSynSent().

Member Data Documentation

crcMode

CrcMode inet::tcp::Tcp::crcMode = CRC_MODE_UNDEFINED

Referenced by initialize(), inet::tcp::TcpConnection::sendRst(), inet::tcp::TcpConnection::sendRstAck(), and inet::tcp::TcpConnection::sendToIP().

lastEphemeralPort

ushort inet::tcp::Tcp::lastEphemeralPort = static_cast<ushort>(-1)

protected

Referenced by getEphemeralPort(), initialize(), and reset().

msl

int inet::tcp::Tcp::msl

Referenced by initialize().

tcpAppConnMap

TcpAppConnMap inet::tcp::Tcp::tcpAppConnMap

protected

Referenced by addForkedConnection(), findConnForApp(), handleUpperCommand(), initialize(), refreshDisplay(), removeConnection(), and reset().

tcpConnectionAddedSignal

simsignal_t inet::tcp::Tcp::tcpConnectionAddedSignal = registerSignal("tcpConnectionAdded")

static

Referenced by inet::tcp::TcpConnection::processSegmentInSynSent(), inet::visualizer::TransportConnectionVisualizerBase::receiveSignal(), inet::visualizer::TransportConnectionVisualizerBase::subscribe(), and inet::visualizer::TransportConnectionVisualizerBase::unsubscribe().

tcpConnectionRemovedSignal

simsignal_t inet::tcp::Tcp::tcpConnectionRemovedSignal = registerSignal("tcpConnectionRemoved")

static

Referenced by removeConnection().

tcpConnMap

TcpConnMap inet::tcp::Tcp::tcpConnMap

protected

Referenced by addSockPair(), findConnForSegment(), finish(), initialize(), removeConnection(), reset(), and updateSockPair().

useDataNotification

bool inet::tcp::Tcp::useDataNotification = false

Referenced by initialize(), and inet::tcp::TcpConnection::sendAvailableDataToApp().

usedEphemeralPorts

std::multiset<ushort> inet::tcp::Tcp::usedEphemeralPorts

protected

Referenced by addSockPair(), getEphemeralPort(), removeConnection(), and reset().

---

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

• Tcp.h
• Tcp.cc