inet::TCPSocket Class Reference

TCPSocket is a convenience class, to make it easier to manage TCP connections from your application models. More...

#include <TCPSocket.h>

Classes
class	CallbackInterface
	Abstract base class for your callback objects. More...

Public Types
enum	State {   NOT_BOUND, BOUND, LISTENING, CONNECTING,   CONNECTED, PEER_CLOSED, LOCALLY_CLOSED, CLOSED,   SOCKERROR }

Public Member Functions
	TCPSocket ()
	Constructor. More...
	TCPSocket (cMessage *msg)
	Constructor, to be used with forked sockets (see listen()). More...
	~TCPSocket ()
	Destructor. More...
int	getConnectionId () const
	Returns the internal connection Id. More...
int	getState () const
	Returns the socket state, one of NOT_BOUND, CLOSED, LISTENING, CONNECTING, CONNECTED, etc. More...
void	setState (enum State state)
Getter functions
L3Address	getLocalAddress ()
int	getLocalPort ()
L3Address	getRemoteAddress ()
int	getRemotePort ()

Static Public Member Functions
static const char *	stateName (int state)
	Returns name of socket state code returned by getState(). More...

Protected Member Functions
void	sendToTCP (cMessage *msg)
void	listen (bool fork)

Protected Attributes
int	connId
int	sockstate
L3Address	localAddr
int	localPrt
L3Address	remoteAddr
int	remotePrt
CallbackInterface *	cb
void *	yourPtr
cGate *	gateToTcp
TCPDataTransferMode	dataTransferMode
std::string	tcpAlgorithmClass

Opening and closing connections, sending data
void	setOutputGate (cGate *toTcp)
	Sets the gate on which to send to TCP. More...
void	bind (int localPort)
	Bind the socket to a local port number. More...
void	bind (L3Address localAddr, int localPort)
	Bind the socket to a local port number and IP address (useful with multi-homing). More...
TCPDataTransferMode	getDataTransferMode () const
	Returns the current dataTransferMode parameter. More...
const char *	getTCPAlgorithmClass () const
	Returns the current tcpAlgorithmClass parameter. More...
void	setDataTransferMode (TCPDataTransferMode transferMode)
	Sets the dataTransferMode parameter of the subsequent connect() or listen() calls. More...
void	readDataTransferModePar (cComponent &component)
	Read "dataTransferMode" parameter from ini/ned, and set dataTransferMode member value. More...
void	setTCPAlgorithmClass (const char *tcpAlgorithmClass)
	Sets the tcpAlgorithmClass parameter of the next connect() or listen() call. More...
void	listen ()
	Initiates passive OPEN, creating a "forking" connection that will listen on the port you bound the socket to. More...
void	listenOnce ()
	Initiates passive OPEN to create a non-forking listening connection. More...
void	connect (L3Address remoteAddr, int remotePort)
	Active OPEN to the given remote socket. More...
void	send (cMessage *msg)
	Sends data packet. More...
void	sendCommand (cMessage *msg)
	Sends command. More...
void	close ()
	Closes the local end of the connection. More...
void	abort ()
	Aborts the connection. More...
void	requestStatus ()
	Causes TCP to reply with a fresh TCPStatusInfo, attached to a dummy message as getControlInfo(). More...
void	renewSocket ()
	Required to re-connect with a "used" TCPSocket object. More...
static TCPDataTransferMode	convertStringToDataTransferMode (const char *transferMode)
	Convert a string to TCPDataTransferMode enum. More...

Handling of messages arriving from TCP
bool	belongsToSocket (cMessage *msg)
	Returns true if the message belongs to this socket instance (message has a TCPCommand as getControlInfo(), and the connId in it matches that of the socket.) More...
void	setCallbackObject (CallbackInterface *cb, void *yourPtr=nullptr)
	Sets a callback object, to be used with processMessage(). More...
void	processMessage (cMessage *msg)
	Examines the message (which should have arrived from TCP), updates socket state, and if there is a callback object installed (see setCallbackObject(), class CallbackInterface), dispatches to the appropriate method of it with the same yourPtr that you gave in the setCallbackObject() call. More...
static bool	belongsToAnyTCPSocket (cMessage *msg)
	Returns true if the message belongs to any TCPSocket instance. More...

Detailed Description

TCPSocket is a convenience class, to make it easier to manage TCP connections from your application models.

You'd have one (or more) TCPSocket object(s) in your application simple module class, and call its member functions (bind(), listen(), connect(), etc.) to open, close or abort a TCP connection.

TCPSocket chooses and remembers the connId for you, assembles and sends command packets (such as OPEN_ACTIVE, OPEN_PASSIVE, CLOSE, ABORT, etc.) to TCP, and can also help you deal with packets and notification messages arriving from TCP.

A session which opens a connection from local port 1000 to 10.0.0.2:2000, sends 16K of data and closes the connection may be as simple as this (the code can be placed in your handleMessage() or activity()):

  TCPSocket socket;
  socket.connect(Address("10.0.0.2"), 2000);

  msg = new cMessage("data1");
  msg->setByteLength(16*1024);  // 16K
  socket.send(msg);

  socket.close();

Dealing with packets and notification messages coming from TCP is somewhat more cumbersome. Basically you have two choices: you either process those messages yourself, or let TCPSocket do part of the job. For the latter, you give TCPSocket a callback object on which it'll invoke the appropriate member functions: socketEstablished(), socketDataArrived(), socketFailure(), socketPeerClosed(), etc (these are methods of TCPSocket::CallbackInterface)., The callback object can be your simple module class too.

This code skeleton example shows how to set up a TCPSocket to use the module itself as callback object:

class MyModule : public cSimpleModule, public TCPSocket::CallbackInterface
{
    TCPSocket socket;
    virtual void socketDataArrived(int connId, void *yourPtr, cPacket *msg, bool urgent);
    virtual void socketFailure(int connId, void *yourPtr, int code);
    ...
};

void MyModule::initialize() {
    socket.setCallbackObject(this,nullptr);
}

void MyModule::handleMessage(cMessage *msg) {
    if (socket.belongsToSocket(msg))
        socket.processMessage(msg); // dispatch to socketXXXX() methods
    else
        ...
}

void MyModule::socketDataArrived(int, void *, cPacket *msg, bool) {
    EV << "Received TCP data, " << msg->getByteLength() << " bytes\\n";
    delete msg;
}

void MyModule::socketFailure(int, void *, int code) {
    if (code==TCP_I_CONNECTION_RESET)
        EV << "Connection reset!\\n";
    else if (code==TCP_I_CONNECTION_REFUSED)
        EV << "Connection refused!\\n";
    else if (code==TCP_I_TIMEOUT)
        EV << "Connection timed out!\\n";
}

If you need to manage a large number of sockets (e.g. in a server application which handles multiple incoming connections), the TCPSocketMap class may be useful. The following code fragment to handle incoming connections is from the LDP module:

TCPSocket *socket = socketMap.findSocketFor(msg);
if (!socket)
{
    // not yet in socketMap, must be new incoming connection: add to socketMap
    socket = new TCPSocket(msg);
    socket->setOutputGate(gate("tcpOut"));
    socket->setCallbackObject(this, nullptr);
    socketMap.addSocket(socket);
}
// dispatch to socketEstablished(), socketDataArrived(), socketPeerClosed()
// or socketFailure()
socket->processMessage(msg);

See also

TCPSocketMap

Member Enumeration Documentation

enum inet::TCPSocket::State

Enumerator
NOT_BOUND
BOUND
LISTENING
CONNECTING
CONNECTED
PEER_CLOSED
LOCALLY_CLOSED
CLOSED
SOCKERROR

{ NOT_BOUND, BOUND, LISTENING, CONNECTING, CONNECTED, PEER_CLOSED, LOCALLY_CLOSED, CLOSED, SOCKERROR };

Constructor & Destructor Documentation

inet::TCPSocket::TCPSocket

(

)

Constructor.

The getConnectionId() method returns a valid Id right after constructor call.

{
    // don't allow user-specified connIds because they may conflict with
    // automatically assigned ones.
    connId = getEnvir()->getUniqueNumber();
    sockstate = NOT_BOUND;

    localPrt = remotePrt = -1;
    cb = nullptr;
    yourPtr = nullptr;

    gateToTcp = nullptr;
    dataTransferMode = TCP_TRANSFER_UNDEFINED;
}

inet::TCPSocket::TCPSocket

(

cMessage *

msg

)

Constructor, to be used with forked sockets (see listen()).

The new connId will be picked up from the message: it should have arrived from TCP and contain TCPCommmand control info.

{
    TCPCommand *ind = dynamic_cast<TCPCommand *>(msg->getControlInfo());

    if (!ind)
        throw cRuntimeError("TCPSocket::TCPSocket(cMessage *): no TCPCommand control info in message (not from TCP?)");

    connId = ind->getConnId();
    sockstate = CONNECTED;

    localPrt = remotePrt = -1;
    cb = nullptr;
    yourPtr = nullptr;
    dataTransferMode = TCP_TRANSFER_UNDEFINED;    // FIXME set dataTransferMode
    gateToTcp = nullptr;

    if (msg->getKind() == TCP_I_ESTABLISHED) {
        // management of stockstate is left to processMessage() so we always
        // set it to CONNECTED in the ctor, whatever TCP_I_xxx arrives.
        // However, for convenience we extract TCPConnectInfo already here, so that
        // remote address/port can be read already after the ctor call.

        TCPConnectInfo *connectInfo = check_and_cast<TCPConnectInfo *>(msg->getControlInfo());
        localAddr = connectInfo->getLocalAddr();
        remoteAddr = connectInfo->getRemoteAddr();
        localPrt = connectInfo->getLocalPort();
        remotePrt = connectInfo->getRemotePort();
    }
}

inet::TCPSocket::~TCPSocket

(

)

Destructor.

{
    if (cb)
        cb->socketDeleted(connId, yourPtr);
}

Member Function Documentation

void inet::TCPSocket::abort

(

)

Aborts the connection.

Referenced by inet::bgp::BGPRouting::openTCPConnectionToPeer(), and inet::NetPerfMeter::teardownConnection().

{
    if (sockstate != NOT_BOUND && sockstate != BOUND && sockstate != CLOSED && sockstate != SOCKERROR) {
        cMessage *msg = new cMessage("ABORT", TCP_C_ABORT);
        TCPCommand *cmd = new TCPCommand();
        cmd->setConnId(connId);
        msg->setControlInfo(cmd);
        sendToTCP(msg);
    }
    sockstate = CLOSED;
}

bool inet::TCPSocket::belongsToAnyTCPSocket ( cMessage *  msg )

static

Returns true if the message belongs to any TCPSocket instance.

(This basically checks if the message has a TCPCommand attached to it as getControlInfo().)

{
    return dynamic_cast<TCPCommand *>(msg->getControlInfo());
}

bool inet::TCPSocket::belongsToSocket

(

cMessage *

msg

)

Returns true if the message belongs to this socket instance (message has a TCPCommand as getControlInfo(), and the connId in it matches that of the socket.)

Referenced by processMessage().

{
    return dynamic_cast<TCPCommand *>(msg->getControlInfo()) &&
           ((TCPCommand *)(msg->getControlInfo()))->getConnId() == connId;
}

void inet::TCPSocket::bind

(

int

localPort

)

Bind the socket to a local port number.

Referenced by inet::NetPerfMeter::createAndBindSocket(), inet::TCPSinkApp::initialize(), inet::TCPSrvHostApp::initialize(), inet::httptools::HttpServer::initialize(), inet::TCPAppBase::initialize(), inet::TCPGenericSrvApp::initialize(), inet::LDP::initialize(), inet::bgp::BGPRouting::openTCPConnectionToPeer(), inet::LDP::openTCPConnectionToPeer(), and inet::TCPEchoApp::startListening().

{
    if (sockstate != NOT_BOUND)
        throw cRuntimeError("TCPSocket::bind(): socket already bound");

    if (lPort < 0 || lPort > 65535)
        throw cRuntimeError("TCPSocket::bind(): invalid port number %d", lPort);

    localPrt = lPort;
    sockstate = BOUND;
}

void inet::TCPSocket::bind	(	L3Address	localAddr,
		int	localPort
	)

Bind the socket to a local port number and IP address (useful with multi-homing).

{
    if (sockstate != NOT_BOUND)
        throw cRuntimeError("TCPSocket::bind(): socket already bound");

    // allow -1 here, to make it possible to specify address only
    if ((lPort < 0 || lPort > 65535) && lPort != -1)
        throw cRuntimeError("TCPSocket::bind(): invalid port number %d", lPort);

    localAddr = lAddr;
    localPrt = lPort;
    sockstate = BOUND;
}

void inet::TCPSocket::close

(

)

Closes the local end of the connection.

With TCP, a CLOSE operation means "I have no more data to send", and thus results in a one-way connection until the remote TCP closes too (or the FIN_WAIT_1 timeout expires)

Referenced by inet::TCPAppBase::close(), inet::TCPGenericSrvThread::dataArrived(), inet::NetPerfMeter::handleTimer(), inet::bgp::BGPRouting::processMessageFromTCP(), inet::httptools::HttpBrowser::socketDataArrived(), inet::httptools::HttpBrowser::socketEstablished(), inet::httptools::HttpServer::socketPeerClosed(), inet::httptools::HttpBrowser::socketPeerClosed(), and inet::TCPEchoApp::stopListening().

{
    if (sockstate != CONNECTED && sockstate != PEER_CLOSED && sockstate != CONNECTING && sockstate != LISTENING)
        throw cRuntimeError("TCPSocket::close(): not connected or close() already called (sockstate=%s)", stateName(sockstate));

    cMessage *msg = new cMessage("CLOSE", TCP_C_CLOSE);
    TCPCommand *cmd = new TCPCommand();
    cmd->setConnId(connId);
    msg->setControlInfo(cmd);
    sendToTCP(msg);
    sockstate = (sockstate == CONNECTED) ? LOCALLY_CLOSED : CLOSED;
}

void inet::TCPSocket::connect	(	L3Address	remoteAddr,
		int	remotePort
	)

Active OPEN to the given remote socket.

Referenced by inet::TCPAppBase::connect(), inet::NetPerfMeter::establishConnection(), inet::bgp::BGPRouting::openTCPConnectionToPeer(), inet::LDP::openTCPConnectionToPeer(), and inet::httptools::HttpBrowser::submitToSocket().

{
    if (sockstate != NOT_BOUND && sockstate != BOUND)
        throw cRuntimeError("TCPSocket::connect(): connect() or listen() already called (need renewSocket()?)");

    if (remotePort < 0 || remotePort > 65535)
        throw cRuntimeError("TCPSocket::connect(): invalid remote port number %d", remotePort);

    cMessage *msg = new cMessage("ActiveOPEN", TCP_C_OPEN_ACTIVE);

    remoteAddr = remoteAddress;
    remotePrt = remotePort;

    TCPOpenCommand *openCmd = new TCPOpenCommand();
    openCmd->setConnId(connId);
    openCmd->setLocalAddr(localAddr);
    openCmd->setLocalPort(localPrt);
    openCmd->setRemoteAddr(remoteAddr);
    openCmd->setRemotePort(remotePrt);
    openCmd->setDataTransferMode(dataTransferMode);
    openCmd->setTcpAlgorithmClass(tcpAlgorithmClass.c_str());

    msg->setControlInfo(openCmd);
    sendToTCP(msg);
    sockstate = CONNECTING;
}

TCPDataTransferMode inet::TCPSocket::convertStringToDataTransferMode ( const char *  transferMode )

static

Convert a string to TCPDataTransferMode enum.

Returns TCP_TRANSFER_UNDEFINED when string has an invalid value Generate runtime error, when string is nullptr;

Referenced by readDataTransferModePar().

{
    if (nullptr == transferMode || 0 == transferMode[0])
        return TCP_TRANSFER_UNDEFINED;

    if (0 == strcmp(transferMode, "bytecount"))
        return TCP_TRANSFER_BYTECOUNT;

    if (0 == strcmp(transferMode, "object"))
        return TCP_TRANSFER_OBJECT;

    if (0 == strcmp(transferMode, "bytestream"))
        return TCP_TRANSFER_BYTESTREAM;

    return TCP_TRANSFER_UNDEFINED;
}

int inet::TCPSocket::getConnectionId ( ) const

inline

Returns the internal connection Id.

TCP uses the (gate index, connId) pair to identify the connection when it receives a command from the application (or TCPSocket).

Referenced by inet::TCPSocketMap::addSocket(), inet::bgp::BGPRouting::findIdFromSocketConnId(), inet::TCPSocketMap::removeSocket(), and inet::httptools::HttpBrowser::socketDeleted().

{ return connId; }

TCPDataTransferMode inet::TCPSocket::getDataTransferMode ( ) const

inline

Returns the current dataTransferMode parameter.

See also

TCPCommand

Referenced by inet::TCPSessionApp::createDataPacket().

{ return dataTransferMode; }

L3Address inet::TCPSocket::getLocalAddress ( )

inline

Referenced by inet::bgp::BGPSession::sendOpenMessage().

{ return localAddr; }

int inet::TCPSocket::getLocalPort ( )

inline

{ return localPrt; }

L3Address inet::TCPSocket::getRemoteAddress ( )

inline

Referenced by inet::bgp::BGPRouting::processMessageFromTCP(), and inet::LDP::processMessageFromTCP().

{ return remoteAddr; }

int inet::TCPSocket::getRemotePort ( )

inline

{ return remotePrt; }

int inet::TCPSocket::getState ( ) const

inline

Returns the socket state, one of NOT_BOUND, CLOSED, LISTENING, CONNECTING, CONNECTED, etc.

Messages received from TCP must be routed through processMessage() in order to keep socket state up-to-date.

Referenced by inet::TelnetApp::handleOperationStage(), inet::TCPBasicClientApp::handleOperationStage(), inet::TCPSessionApp::handleOperationStage(), inet::bgp::BGPRouting::openTCPConnectionToPeer(), inet::operator<<(), inet::TCPSinkApp::refreshDisplay(), inet::TCPAppBase::refreshDisplay(), inet::TCPSessionApp::refreshDisplay(), inet::TCPBasicClientApp::socketDataArrived(), inet::httptools::HttpServer::socketPeerClosed(), inet::TCPAppBase::socketPeerClosed(), and inet::httptools::HttpBrowser::socketPeerClosed().

{ return sockstate; }

const char* inet::TCPSocket::getTCPAlgorithmClass ( ) const

inline

Returns the current tcpAlgorithmClass parameter.

{ return tcpAlgorithmClass.c_str(); }

void inet::TCPSocket::listen ( bool  fork )

protected

Referenced by inet::NetPerfMeter::createAndBindSocket(), inet::TCPSinkApp::initialize(), inet::TCPSrvHostApp::initialize(), inet::httptools::HttpServer::initialize(), inet::TCPGenericSrvApp::initialize(), inet::LDP::initialize(), and inet::TCPEchoApp::startListening().

{
    if (sockstate != BOUND)
        throw cRuntimeError(sockstate == NOT_BOUND ? "TCPSocket: must call bind() before listen()"
                : "TCPSocket::listen(): connect() or listen() already called");

    cMessage *msg = new cMessage("PassiveOPEN", TCP_C_OPEN_PASSIVE);

    TCPOpenCommand *openCmd = new TCPOpenCommand();
    openCmd->setLocalAddr(localAddr);
    openCmd->setLocalPort(localPrt);
    openCmd->setConnId(connId);
    openCmd->setFork(fork);
    openCmd->setDataTransferMode(dataTransferMode);
    openCmd->setTcpAlgorithmClass(tcpAlgorithmClass.c_str());

    msg->setControlInfo(openCmd);
    sendToTCP(msg);
    sockstate = LISTENING;
}

void inet::TCPSocket::listen ( )

inline

Initiates passive OPEN, creating a "forking" connection that will listen on the port you bound the socket to.

Every incoming connection will get a new connId (and thus, must be handled with a new TCPSocket object), while the original connection (original connId) will keep listening on the port. The new TCPSocket object must be created with the TCPSocket(cMessage *msg) constructor.

If you need to handle multiple incoming connections, the TCPSocketMap class can also be useful, and TCPSrvHostApp shows how to put it all together. See also TCPOpenCommand documentation (neddoc) for more info.

Referenced by listen().

{ listen(true); }

void inet::TCPSocket::listenOnce ( )

inline

Initiates passive OPEN to create a non-forking listening connection.

Non-forking means that TCP will accept the first incoming connection, and refuse subsequent ones.

See TCPOpenCommand documentation (neddoc) for more info.

{ listen(false); }

void inet::TCPSocket::processMessage

(

cMessage *

msg

)

Examines the message (which should have arrived from TCP), updates socket state, and if there is a callback object installed (see setCallbackObject(), class CallbackInterface), dispatches to the appropriate method of it with the same yourPtr that you gave in the setCallbackObject() call.

The method deletes the message, unless (1) there is a callback object installed AND (2) the message is payload (message kind TCP_I_DATA or TCP_I_URGENT_DATA) when the responsibility of destruction is on the socketDataArrived() callback method.

IMPORTANT: for performance reasons, this method doesn't check that the message belongs to this socket, i.e. belongsToSocket(msg) would return true!

Referenced by inet::TCPSrvHostApp::handleMessage(), inet::httptools::HttpServer::handleMessage(), inet::TCPAppBase::handleMessage(), inet::httptools::HttpBrowser::handleMessage(), inet::bgp::BGPRouting::processMessageFromTCP(), and inet::LDP::processMessageFromTCP().

{
    ASSERT(belongsToSocket(msg));

    TCPStatusInfo *status;
    TCPConnectInfo *connectInfo;

    switch (msg->getKind()) {
        case TCP_I_DATA:
            if (cb)
                cb->socketDataArrived(connId, yourPtr, PK(msg), false);
            else
                delete msg;

            break;

        case TCP_I_URGENT_DATA:
            if (cb)
                cb->socketDataArrived(connId, yourPtr, PK(msg), true);
            else
                delete msg;

            break;

        case TCP_I_ESTABLISHED:
            // Note: this code is only for sockets doing active open, and nonforking
            // listening sockets. For a forking listening sockets, TCP_I_ESTABLISHED
            // carries a new connId which won't match the connId of this TCPSocket,
            // so you won't get here. Rather, when you see TCP_I_ESTABLISHED, you'll
            // want to create a new TCPSocket object via new TCPSocket(msg).
            sockstate = CONNECTED;
            connectInfo = check_and_cast<TCPConnectInfo *>(msg->getControlInfo());
            localAddr = connectInfo->getLocalAddr();
            remoteAddr = connectInfo->getRemoteAddr();
            localPrt = connectInfo->getLocalPort();
            remotePrt = connectInfo->getRemotePort();
            delete msg;

            if (cb)
                cb->socketEstablished(connId, yourPtr);

            break;

        case TCP_I_PEER_CLOSED:
            sockstate = PEER_CLOSED;
            delete msg;

            if (cb)
                cb->socketPeerClosed(connId, yourPtr);

            break;

        case TCP_I_CLOSED:
            sockstate = CLOSED;
            delete msg;

            if (cb)
                cb->socketClosed(connId, yourPtr);

            break;

        case TCP_I_CONNECTION_REFUSED:
        case TCP_I_CONNECTION_RESET:
        case TCP_I_TIMED_OUT:
            sockstate = SOCKERROR;

            if (cb)
                cb->socketFailure(connId, yourPtr, msg->getKind());

            delete msg;
            break;

        case TCP_I_STATUS:
            status = check_and_cast<TCPStatusInfo *>(msg->removeControlInfo());
            delete msg;

            if (cb)
                cb->socketStatusArrived(connId, yourPtr, status);

            break;

        default:
            throw cRuntimeError("TCPSocket: invalid msg kind %d, one of the TCP_I_xxx constants expected",
                msg->getKind());
    }
}

void inet::TCPSocket::readDataTransferModePar

(

cComponent &

component

)

Read "dataTransferMode" parameter from ini/ned, and set dataTransferMode member value.

Generate runtime error when parameter is missing or value is invalid.

Referenced by inet::NetPerfMeter::createAndBindSocket(), inet::TCPSinkApp::initialize(), inet::TCPSrvHostApp::initialize(), inet::TCPAppBase::initialize(), inet::TCPEchoApp::initialize(), inet::TCPSessionApp::initialize(), inet::LDP::initialize(), inet::bgp::BGPRouting::openTCPConnectionToPeer(), inet::LDP::openTCPConnectionToPeer(), inet::bgp::BGPRouting::processMessageFromTCP(), inet::LDP::processMessageFromTCP(), and inet::NetPerfMeter::successfullyEstablishedConnection().

{
    const char *transferMode = component.par("dataTransferMode");

    if (nullptr == transferMode)
        throw cRuntimeError("Missing dataTransferMode parameter at %s.",
                component.getFullPath().c_str());

    TCPDataTransferMode x = convertStringToDataTransferMode(transferMode);

    if (x == TCP_TRANSFER_UNDEFINED)
        throw cRuntimeError("Invalid '%s' dataTransferMode parameter at %s.",
                transferMode, component.getFullPath().c_str());

    dataTransferMode = x;
}

void inet::TCPSocket::renewSocket

(

)

Required to re-connect with a "used" TCPSocket object.

By default, a TCPSocket object is tied to a single TCP connection, via the connectionId. When the connection gets closed or aborted, you cannot use the socket to connect again (by connect() or listen()) unless you obtain a new connectionId by calling this method.

BEWARE if you use TCPSocketMap! TCPSocketMap uses connectionId to find TCPSockets, so after calling this method you have to remove the socket from your TCPSocketMap, and re-add it. Otherwise TCPSocketMap will get confused.

The reason why one must obtain a new connectionId is that TCP still has to maintain the connection data structure (identified by the old connectionId) internally for a while (2 maximum segment lifetimes = 240s) after it reported "connection closed" to us.

Referenced by inet::TCPAppBase::connect(), inet::NetPerfMeter::establishConnection(), inet::bgp::BGPRouting::openTCPConnectionToPeer(), and inet::TCPEchoApp::startListening().

{
    connId = getEnvir()->getUniqueNumber();
    remoteAddr = localAddr = L3Address();
    remotePrt = localPrt = -1;
    sockstate = NOT_BOUND;
}

void inet::TCPSocket::requestStatus

(

)

Causes TCP to reply with a fresh TCPStatusInfo, attached to a dummy message as getControlInfo().

The reply message can be recognized by its message kind TCP_I_STATUS, or (if a callback object is used) the socketStatusArrived() method of the callback object will be called.

{
    cMessage *msg = new cMessage("STATUS", TCP_C_STATUS);
    TCPCommand *cmd = new TCPCommand();
    cmd->setConnId(connId);
    msg->setControlInfo(cmd);
    sendToTCP(msg);
}

void inet::TCPSocket::send

(

cMessage *

msg

)

Sends data packet.

Referenced by inet::TCPGenericSrvThread::dataArrived(), inet::bgp::BGPSession::sendKeepAliveMessage(), inet::bgp::BGPSession::sendOpenMessage(), inet::TCPAppBase::sendPacket(), inet::LDP::sendToPeer(), sendToTCP(), inet::httptools::HttpServer::socketDataArrived(), inet::httptools::HttpBrowser::socketEstablished(), and inet::NetPerfMeter::transmitFrame().

{
    if (sockstate != CONNECTED && sockstate != CONNECTING && sockstate != PEER_CLOSED)
        throw cRuntimeError("TCPSocket::send(): socket not connected or connecting, state is %s", stateName(sockstate));

    msg->setKind(TCP_C_SEND);
    TCPSendCommand *cmd = new TCPSendCommand();
    cmd->setConnId(connId);
    msg->setControlInfo(cmd);
    sendToTCP(msg);
}

void inet::TCPSocket::sendCommand

(

cMessage *

msg

)

Sends command.

Referenced by inet::NetPerfMeter::sendTCPQueueRequest().

{
    sendToTCP(msg);
}

void inet::TCPSocket::sendToTCP ( cMessage *  msg )

protected

Referenced by abort(), close(), connect(), listen(), requestStatus(), send(), and sendCommand().

{
    if (!gateToTcp)
        throw cRuntimeError("TCPSocket: setOutputGate() must be invoked before socket can be used");

    check_and_cast<cSimpleModule *>(gateToTcp->getOwnerModule())->send(msg, gateToTcp);
}

void inet::TCPSocket::setCallbackObject	(	CallbackInterface *	cb,
		void *	yourPtr = nullptr
	)

Sets a callback object, to be used with processMessage().

This callback object may be your simple module itself (if it multiply inherits from CallbackInterface too, that is you declared it as

class MyAppModule : public cSimpleModule, public TCPSocket::CallbackInterface

and redefined the necessary virtual functions; or you may use dedicated class (and objects) for this purpose.

TCPSocket doesn't delete the callback object in the destructor or on any other occasion.

YourPtr is an optional pointer. It may contain any value you wish – TCPSocket will not look at it or do anything with it except passing it back to you in the CallbackInterface calls. You may find it useful if you maintain additional per-connection information: in that case you don't have to look it up by connId in the callbacks, you can have it passed to you as yourPtr.

Referenced by inet::TCPSrvHostApp::handleMessage(), inet::httptools::HttpServer::handleMessage(), inet::httptools::HttpServer::initialize(), inet::TCPAppBase::initialize(), inet::bgp::BGPRouting::openTCPConnectionToPeer(), inet::LDP::openTCPConnectionToPeer(), inet::bgp::BGPRouting::processMessageFromTCP(), and inet::httptools::HttpBrowser::submitToSocket().

{
    cb = callback;
    yourPtr = yourPointer;
}

void inet::TCPSocket::setDataTransferMode ( TCPDataTransferMode  transferMode )

inline

Sets the dataTransferMode parameter of the subsequent connect() or listen() calls.

See also

TCPCommand

Referenced by inet::httptools::HttpServer::handleMessage(), inet::httptools::HttpServer::initialize(), inet::TCPGenericSrvApp::initialize(), and inet::httptools::HttpBrowser::submitToSocket().

{ dataTransferMode = transferMode; }

void inet::TCPSocket::setOutputGate ( cGate *  toTcp )

inline

Sets the gate on which to send to TCP.

Must be invoked before socket can be used. Example: socket.setOutputGate(gate("tcpOut"));

Referenced by inet::NetPerfMeter::createAndBindSocket(), inet::TCPSrvHostApp::handleMessage(), inet::httptools::HttpServer::handleMessage(), inet::TCPSinkApp::initialize(), inet::TCPSrvHostApp::initialize(), inet::httptools::HttpServer::initialize(), inet::TCPAppBase::initialize(), inet::TCPGenericSrvApp::initialize(), inet::TCPEchoApp::initialize(), inet::LDP::initialize(), inet::bgp::BGPRouting::openTCPConnectionToPeer(), inet::LDP::openTCPConnectionToPeer(), inet::bgp::BGPRouting::processMessageFromTCP(), inet::LDP::processMessageFromTCP(), inet::httptools::HttpBrowser::submitToSocket(), and inet::NetPerfMeter::successfullyEstablishedConnection().

{ gateToTcp = toTcp; }

void inet::TCPSocket::setState ( enum State  state )

inline

{ sockstate = state; };

void inet::TCPSocket::setTCPAlgorithmClass ( const char *  tcpAlgorithmClass )

inline

Sets the tcpAlgorithmClass parameter of the next connect() or listen() call.

{ this->tcpAlgorithmClass = tcpAlgorithmClass; }

const char * inet::TCPSocket::stateName ( int  state )

static

Returns name of socket state code returned by getState().

Referenced by close(), inet::operator<<(), inet::TCPSinkApp::refreshDisplay(), inet::TCPAppBase::refreshDisplay(), inet::TCPSessionApp::refreshDisplay(), and send().

{
#define CASE(x)    case x: \
        s = #x; break
    const char *s = "unknown";
    switch (state) {
        CASE(NOT_BOUND);
        CASE(BOUND);
        CASE(LISTENING);
        CASE(CONNECTING);
        CASE(CONNECTED);
        CASE(PEER_CLOSED);
        CASE(LOCALLY_CLOSED);
        CASE(CLOSED);
        CASE(SOCKERROR);
    }
    return s;
#undef CASE
}

Member Data Documentation

CallbackInterface* inet::TCPSocket::cb

protected

Referenced by processMessage(), setCallbackObject(), TCPSocket(), and ~TCPSocket().

int inet::TCPSocket::connId

protected

Referenced by abort(), belongsToSocket(), close(), connect(), listen(), processMessage(), renewSocket(), requestStatus(), send(), TCPSocket(), and ~TCPSocket().

TCPDataTransferMode inet::TCPSocket::dataTransferMode

protected

Referenced by connect(), listen(), readDataTransferModePar(), and TCPSocket().

cGate* inet::TCPSocket::gateToTcp

protected

Referenced by sendToTCP(), and TCPSocket().

L3Address inet::TCPSocket::localAddr

protected

Referenced by bind(), connect(), listen(), processMessage(), renewSocket(), and TCPSocket().

int inet::TCPSocket::localPrt

protected

Referenced by bind(), connect(), listen(), processMessage(), renewSocket(), and TCPSocket().

L3Address inet::TCPSocket::remoteAddr

protected

Referenced by connect(), processMessage(), renewSocket(), and TCPSocket().

int inet::TCPSocket::remotePrt

protected

Referenced by connect(), processMessage(), renewSocket(), and TCPSocket().

int inet::TCPSocket::sockstate

protected

Referenced by abort(), bind(), close(), connect(), listen(), processMessage(), renewSocket(), send(), and TCPSocket().

std::string inet::TCPSocket::tcpAlgorithmClass

protected

Referenced by connect(), and listen().

void* inet::TCPSocket::yourPtr

protected

Referenced by processMessage(), setCallbackObject(), TCPSocket(), and ~TCPSocket().

---

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

• TCPSocket.h
• TCPSocket.cc