inet::tcp::TCP Class Reference

Implements the TCP protocol. More...

#include <TCP.h>

Inheritance diagram for inet::tcp::TCP:

Classes
struct	AppConnKey
struct	SockPair

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	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 (TCPDataTransferMode transferModeP)
	To be called from TCPConnection: create a new send queue. More...
virtual TCPReceiveQueue *	createReceiveQueue (TCPDataTransferMode transferModeP)
	To be called from TCPConnection: create a new receive queue. More...
virtual bool	handleOperationStage (LifecycleOperation *operation, int stage, IDoneCallback *doneCallback) override
	Perform one stage of a lifecycle operation. More...
virtual void	reset ()
Public Member Functions inherited from inet::ILifecycle
virtual	~ILifecycle ()

Public Attributes
bool	recordStatistics = false
bool	isOperational = false
bool	useDataNotification = false

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

Protected Types
typedef std::map< AppConnKey, TCPConnection * >	TcpAppConnMap
typedef std::map< SockPair, TCPConnection * >	TcpConnMap

Protected Member Functions
virtual TCPConnection *	createConnection (int appGateIndex, int connId)
	Factory method; may be overriden for customizing TCP. More...
virtual TCPConnection *	findConnForSegment (TCPSegment *tcpseg, L3Address srcAddr, L3Address destAddr)
virtual TCPConnection *	findConnForApp (int appGateIndex, int connId)
virtual void	segmentArrivalWhileClosed (TCPSegment *tcpseg, L3Address src, L3Address dest)
virtual void	removeConnection (TCPConnection *conn)
virtual void	refreshDisplay () const override
virtual void	initialize (int stage) override
virtual int	numInitStages () const override
virtual void	handleMessage (cMessage *msg) override
virtual void	finish () override

Protected Attributes
TcpAppConnMap	tcpAppConnMap
TcpConnMap	tcpConnMap
ushort	lastEphemeralPort = (ushort)-1
std::multiset< ushort >	usedEphemeralPorts

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

typedef std::map<AppConnKey, TCPConnection *> inet::tcp::TCP::TcpAppConnMap

protected

typedef std::map<SockPair, TCPConnection *> inet::tcp::TCP::TcpConnMap

protected

Constructor & Destructor Documentation

inet::tcp::TCP::TCP ( )

inline

{}

inet::tcp::TCP::~TCP ( )

virtual

{
    while (!tcpAppConnMap.empty()) {
        auto i = tcpAppConnMap.begin();
        delete i->second;
        tcpAppConnMap.erase(i);
    }
}

Member Function Documentation

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 connId (and newConn will live on with its old connId).

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

{
    // update conn's socket pair, and register newConn (which'll keep LISTENing)
    updateSockPair(conn, localAddr, remoteAddr, localPort, remotePort);
    addSockPair(newConn, newConn->localAddr, newConn->remoteAddr, newConn->localPort, newConn->remotePort);

    // conn will get a new connId...
    AppConnKey key;
    key.appGateIndex = conn->appGateIndex;
    key.connId = conn->connId;
    tcpAppConnMap.erase(key);
    key.connId = conn->connId = getEnvir()->getUniqueNumber();
    tcpAppConnMap[key] = conn;

    // ...and newConn will live on with the old connId
    key.appGateIndex = newConn->appGateIndex;
    key.connId = newConn->connId;
    tcpAppConnMap[key] = newConn;
}

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.

Referenced by addForkedConnection(), inet::tcp::TCPConnection::process_OPEN_ACTIVE(), and inet::tcp::TCPConnection::process_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);
}

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

protectedvirtual

Factory method; may be overriden for customizing TCP.

Referenced by handleMessage().

{
    return new TCPConnection(this, appGateIndex, connId);
}

TCPReceiveQueue * inet::tcp::TCP::createReceiveQueue ( TCPDataTransferMode  transferModeP )

virtual

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

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

{
    switch (transferModeP) {
        case TCP_TRANSFER_BYTECOUNT:
            return new TCPVirtualDataRcvQueue();

        case TCP_TRANSFER_OBJECT:
            return new TCPMsgBasedRcvQueue();

        case TCP_TRANSFER_BYTESTREAM:
            return new TCPByteStreamRcvQueue();

        default:
            throw cRuntimeError("Invalid TCP data transfer mode: %d", transferModeP);
    }
}

TCPSendQueue * inet::tcp::TCP::createSendQueue ( TCPDataTransferMode  transferModeP )

virtual

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

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

{
    switch (transferModeP) {
        case TCP_TRANSFER_BYTECOUNT:
            return new TCPVirtualDataSendQueue();

        case TCP_TRANSFER_OBJECT:
            return new TCPMsgBasedSendQueue();

        case TCP_TRANSFER_BYTESTREAM:
            return new TCPByteStreamSendQueue();

        default:
            throw cRuntimeError("Invalid TCP data transfer mode: %d", transferModeP);
    }
}

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

protectedvirtual

Referenced by handleMessage().

{
    AppConnKey key;
    key.appGateIndex = appGateIndex;
    key.connId = connId;

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

TCPConnection * inet::tcp::TCP::findConnForSegment ( TCPSegment *  tcpseg, L3Address  srcAddr, L3Address  destAddr  )

protectedvirtual

Referenced by handleMessage().

{
    SockPair key;
    key.localAddr = destAddr;
    key.remoteAddr = srcAddr;
    key.localPort = tcpseg->getDestPort();
    key.remotePort = tcpseg->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;
}

void inet::tcp::TCP::finish ( )

overrideprotectedvirtual

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

ushort inet::tcp::TCP::getEphemeralPort ( )

virtual

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

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

{
    // 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;
}

void inet::tcp::TCP::handleMessage ( cMessage *  msg )

overrideprotectedvirtual

{
    if (!isOperational) {
        if (msg->isSelfMessage())
            throw cRuntimeError("Model error: self msg '%s' received when isOperational is false", msg->getName());
        EV_ERROR << "TCP is turned off, dropping '" << msg->getName() << "' message\n";
        delete msg;
    }
    else if (msg->isSelfMessage()) {
        TCPConnection *conn = (TCPConnection *)msg->getContextPointer();
        bool ret = conn->processTimer(msg);
        if (!ret)
            removeConnection(conn);
    }
    else if (msg->arrivedOn("ipIn")) {
        if (false
#ifdef WITH_IPv4
            || dynamic_cast<ICMPMessage *>(msg)
#endif // ifdef WITH_IPv4
#ifdef WITH_IPv6
            || dynamic_cast<ICMPv6Message *>(msg)
#endif // ifdef WITH_IPv6
            )
        {
            EV_DETAIL << "ICMP error received -- discarding\n";    // FIXME can ICMP packets really make it up to TCP???
            delete msg;
        }
        else {
            // must be a TCPSegment
            TCPSegment *tcpseg = check_and_cast<TCPSegment *>(msg);

            // get src/dest addresses
            L3Address srcAddr, destAddr;

            cObject *ctrl = tcpseg->removeControlInfo();
            if (!ctrl)
                throw cRuntimeError("(%s)%s arrived without control info", tcpseg->getClassName(), tcpseg->getName());

            INetworkProtocolControlInfo *controlInfo = check_and_cast<INetworkProtocolControlInfo *>(ctrl);
            srcAddr = controlInfo->getSourceAddress();
            destAddr = controlInfo->getDestinationAddress();
            //interfaceId = controlInfo->getInterfaceId();
            delete ctrl;

            // process segment
            TCPConnection *conn = findConnForSegment(tcpseg, srcAddr, destAddr);
            if (conn) {
                bool ret = conn->processTCPSegment(tcpseg, srcAddr, destAddr);
                if (!ret)
                    removeConnection(conn);
            }
            else {
                segmentArrivalWhileClosed(tcpseg, srcAddr, destAddr);
            }
        }
    }
    else {    // must be from app
        TCPCommand *controlInfo = check_and_cast<TCPCommand *>(msg->getControlInfo());
        int appGateIndex = msg->getArrivalGate()->getIndex();
        int connId = controlInfo->getConnId();

        TCPConnection *conn = findConnForApp(appGateIndex, connId);

        if (!conn) {
            conn = createConnection(appGateIndex, connId);

            // add into appConnMap here; it'll be added to connMap during processing
            // the OPEN command in TCPConnection's processAppCommand().
            AppConnKey key;
            key.appGateIndex = appGateIndex;
            key.connId = connId;
            tcpAppConnMap[key] = conn;

            EV_INFO << "TCP connection created for " << msg << "\n";
        }
        bool ret = conn->processAppCommand(msg);
        if (!ret)
            removeConnection(conn);
    }
}

bool inet::tcp::TCP::handleOperationStage ( LifecycleOperation *  operation, int  stage, IDoneCallback *  doneCallback  )

overridevirtual

Perform one stage of a lifecycle operation.

Processing may be done entirely within this method, or may be a longer process that involves nonzero simulation time or several events, and is triggered by this method call.

Return value: true = "done"; false = "not yet done, will invoke doneCallback when done"

Implements inet::ILifecycle.

{
    Enter_Method_Silent();

    if (dynamic_cast<NodeStartOperation *>(operation)) {
        if ((NodeStartOperation::Stage)stage == NodeStartOperation::STAGE_TRANSPORT_LAYER) {
            //FIXME implementation
            isOperational = true;
        }
    }
    else if (dynamic_cast<NodeShutdownOperation *>(operation)) {
        if ((NodeShutdownOperation::Stage)stage == NodeShutdownOperation::STAGE_TRANSPORT_LAYER) {
            //FIXME close connections???
            reset();
            isOperational = false;
        }
    }
    else if (dynamic_cast<NodeCrashOperation *>(operation)) {
        if ((NodeCrashOperation::Stage)stage == NodeCrashOperation::STAGE_CRASH) {
            //FIXME implementation
            reset();
            isOperational = false;
        }
    }
    else {
        throw cRuntimeError("Unsupported operation '%s'", operation->getClassName());
    }

    return true;
}

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

overrideprotectedvirtual

{
    cSimpleModule::initialize(stage);

    if (stage == INITSTAGE_LOCAL) {
        const char *q;
        q = par("sendQueueClass");
        if (*q != '\0')
            throw cRuntimeError("Don't use obsolete sendQueueClass = \"%s\" parameter", q);

        q = par("receiveQueueClass");
        if (*q != '\0')
            throw cRuntimeError("Don't use obsolete receiveQueueClass = \"%s\" parameter", q);

        lastEphemeralPort = EPHEMERAL_PORTRANGE_START;
        WATCH(lastEphemeralPort);

        WATCH_PTRMAP(tcpConnMap);
        WATCH_PTRMAP(tcpAppConnMap);

        recordStatistics = par("recordStats");
        useDataNotification = par("useDataNotification");
    }
    else if (stage == INITSTAGE_TRANSPORT_LAYER) {
        cModule *host = findContainingNode(this);
        NodeStatus *nodeStatus = check_and_cast_nullable<NodeStatus *>(host ? host->getSubmodule("status") : nullptr);
        isOperational = (!nodeStatus) || nodeStatus->getState() == NodeStatus::UP;
        IPSocket ipSocket(gate("ipOut"));
        ipSocket.registerProtocol(IP_PROT_TCP);
    }
}

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

inlineoverrideprotectedvirtual

{ return NUM_INIT_STAGES; }

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

overrideprotectedvirtual

{
    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;
    }

    //char buf[40];
    //sprintf(buf,"%d conns", tcpAppConnMap.size());
    //getDisplayString().setTagArg("t",0,buf);
    if (isOperational)
        getDisplayString().removeTag("i2");
    else
        getDisplayString().setTagArg("i2", 0, "status/cross");

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

void inet::tcp::TCP::removeConnection ( TCPConnection *  conn )

protectedvirtual

Referenced by handleMessage().

{
    EV_INFO << "Deleting TCP connection\n";

    AppConnKey key;
    key.appGateIndex = conn->appGateIndex;
    key.connId = conn->connId;
    tcpAppConnMap.erase(key);

    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);
    delete conn;
}

void inet::tcp::TCP::reset ( )

virtual

Referenced by handleOperationStage().

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

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

protectedvirtual

Referenced by handleMessage().

{
    TCPConnection *tmp = new TCPConnection();
    tmp->segmentArrivalWhileClosed(tcpseg, srcAddr, destAddr);
    delete tmp;
    delete tcpseg;
}

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

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

{
    // 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[].
}

Member Data Documentation

bool inet::tcp::TCP::isOperational = false

Referenced by handleMessage(), handleOperationStage(), initialize(), and refreshDisplay().

ushort inet::tcp::TCP::lastEphemeralPort = (ushort)-1

protected

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

bool inet::tcp::TCP::logverbose

static

bool inet::tcp::TCP::recordStatistics = false

Referenced by initialize(), and inet::tcp::TCPBaseAlg::initialize().

TcpAppConnMap inet::tcp::TCP::tcpAppConnMap

protected

Referenced by addForkedConnection(), findConnForApp(), handleMessage(), initialize(), refreshDisplay(), removeConnection(), reset(), and ~TCP().

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().

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

static

Referenced by removeConnection().

TcpConnMap inet::tcp::TCP::tcpConnMap

protected

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

bool inet::tcp::TCP::testing

static

bool inet::tcp::TCP::useDataNotification = false

Referenced by initialize(), and inet::tcp::TCPConnection::processSegment1stThru8th().

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