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>

Inheritance diagram for inet::TcpSocket:

Classes
class	ICallback
	Callback interface for TCP sockets, see setCallback() and processMessage() for more info. More...
class	ReceiveQueueBasedCallback

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 (TcpAvailableInfo *availableInfo)
	Constructor, to be used with forked sockets (see listen()). More...
	~TcpSocket ()
	Destructor. More...
int	getSocketId () const override
	Returns the internal connection Id. More...
ChunkQueue *	getReceiveQueue ()
void *	getUserData () const
void	setUserData (void *userData)
TcpSocket::State	getState () const
	Returns the socket state, one of NOT_BOUND, CLOSED, LISTENING, CONNECTING, CONNECTED, etc. More...
void	setState (TcpSocket::State state)
Getter functions
L3Address	getLocalAddress () const
int	getLocalPort () const
L3Address	getRemoteAddress () const
int	getRemotePort () const
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...
const char *	getTCPAlgorithmClass () const
	Returns the current tcpAlgorithmClass parameter. 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	accept (int socketId)
	Accepts a new incoming connection reported as available. More...
void	connect (L3Address remoteAddr, int remotePort)
	Active OPEN to the given remote socket. More...
virtual void	send (Packet *msg) override
	Sends data packet. More...
void	sendCommand (Request *msg)
	Sends command. More...
void	close () override
	Closes the local end of the connection. More...
void	abort ()
	Aborts the connection. More...
virtual void	destroy () override
	Destroy the connection. More...
void	requestStatus ()
	Causes TCP to reply with a fresh TcpStatusInfo, attached to a dummy message as getControlInfo(). More...
void	setTimeToLive (int ttl)
	Set the TTL (Ipv6: Hop Limit) field on sent packets. More...
void	setDscp (short dscp)
	Sets the Ipv4 / Ipv6 dscp fields of packets sent from the TCP socket. More...
void	setTos (short tos)
	Sets the Ipv4 Type of Service / Ipv6 Traffic Class fields of packets sent from the TCP socket. More...
void	renewSocket ()
	Required to re-connect with a "used" TcpSocket object. More...
virtual bool	isOpen () const override
Handling of messages arriving from TCP
virtual bool	belongsToSocket (cMessage *msg) const override
	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	setCallback (ICallback *cb)
	Sets a callback object, to be used with processMessage(). More...
void	processMessage (cMessage *msg) override
	Examines the message (which should have arrived from TCP), updates socket state, and if there is a callback object installed (see setCallback(), class ICallback), dispatches to the appropriate method. More...
Public Member Functions inherited from inet::ISocket
virtual	~ISocket ()

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

Protected Member Functions
void	sendToTcp (cMessage *msg, int c=-1)
void	listen (bool fork)

Protected Attributes
int	connId = -1
State	sockstate = NOT_BOUND
L3Address	localAddr
int	localPrt = -1
L3Address	remoteAddr
int	remotePrt = -1
ICallback *	cb = nullptr
void *	userData = nullptr
cGate *	gateToTcp = nullptr
std::string	tcpAlgorithmClass
ChunkQueue *	receiveQueue = nullptr

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::ICallback)., 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::ICallback
{
    TcpSocket socket;
    virtual void socketDataArrived(TcpSocket *tcpSocket, cPacket *msg, bool urgent);
    virtual void socketFailure(int connId, int code);
    ...
};

void MyModule::initialize() {
    socket.setCallback(this);
}

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

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

void MyModule::socketFailure(TcpSocket *tcpSocket, 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 SocketMap class may be useful. The following code fragment to handle incoming connections is from the Ldp module:

TcpSocket *socket = check_and_cast_nullable<TcpSocket*>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->setCallback(this);
    socketMap.addSocket(socket);
}
// dispatch to socketEstablished(), socketDataArrived(), socketPeerClosed()
// or socketFailure()
socket->processMessage(msg);

See also

TcpSocketMap

Member Enumeration Documentation

State

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

TcpSocket() [1/3]

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

TcpSocket() [2/3]

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.

{
    connId = check_and_cast<Indication *>(msg)->getTag<SocketInd>()->getSocketId();
    sockstate = CONNECTED;
 
    if (msg->getKind() == TCP_I_AVAILABLE) {
        TcpAvailableInfo *availableInfo = check_and_cast<TcpAvailableInfo *>(msg->getControlInfo());
        connId = availableInfo->getNewSocketId();
        localAddr = availableInfo->getLocalAddr();
        remoteAddr = availableInfo->getRemoteAddr();
        localPrt = availableInfo->getLocalPort();
        remotePrt = availableInfo->getRemotePort();
    }
    else 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();
    }
}

TcpSocket() [3/3]

inet::TcpSocket::TcpSocket

(

TcpAvailableInfo *

availableInfo

)

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

{
    connId = availableInfo->getNewSocketId();
    sockstate = CONNECTED;
    localAddr = availableInfo->getLocalAddr();
    remoteAddr = availableInfo->getRemoteAddr();
    localPrt = availableInfo->getLocalPort();
    remotePrt = availableInfo->getRemotePort();
}

~TcpSocket()

inet::TcpSocket::~TcpSocket

(

)

Destructor.

{
    if (cb) {
        cb->socketDeleted(this);
        cb = nullptr;
    }
    delete receiveQueue;
}

Member Function Documentation

abort()

void inet::TcpSocket::abort

(

)

Aborts the connection.

{
    if (sockstate != NOT_BOUND && sockstate != BOUND && sockstate != CLOSED && sockstate != SOCKERROR) {
        auto request = new Request("ABORT", TCP_C_ABORT);
        TcpCommand *cmd = new TcpCommand();
        request->setControlInfo(cmd);
        sendToTcp(request);
    }
    sockstate = CLOSED;
}

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

accept()

void inet::TcpSocket::accept

(

int

socketId

)

Accepts a new incoming connection reported as available.

{
    auto request = new Request("ACCEPT", TCP_C_ACCEPT);
    TcpAcceptCommand *acceptCmd = new TcpAcceptCommand();
    request->setControlInfo(acceptCmd);
    sendToTcp(request, socketId);
}

Referenced by inet::TcpServerSocketIo::acceptSocket(), processMessage(), inet::TcpServerHostApp::socketAvailable(), inet::TcpAppBase::socketAvailable(), inet::TcpServerThreadBase::socketAvailable(), inet::bgp::BgpRouter::socketAvailable(), and inet::Ldp::socketAvailable().

belongsToSocket()

bool inet::TcpSocket::belongsToSocket ( cMessage *  msg ) const

overridevirtual

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

Implements inet::ISocket.

{
    auto& tags = check_and_cast<ITaggedObject *>(msg)->getTags();
    const auto& socketInd = tags.findTag<SocketInd>();
    return socketInd != nullptr && socketInd->getSocketId() == connId;
}

Referenced by inet::TcpClientSocketIo::handleMessage(), inet::TcpServerSocketIo::handleMessage(), inet::TcpServerListener::handleMessageWhenUp(), inet::TcpServerHostApp::handleMessageWhenUp(), inet::Ldp::handleMessageWhenUp(), and processMessage().

bind() [1/2]

void inet::TcpSocket::bind

(

int

localPort

)

Bind the socket to a local port number.

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

Referenced by inet::TcpAppBase::connect(), inet::NetPerfMeter::createAndBindSocket(), inet::TcpServerListener::handleStartOperation(), inet::TcpServerHostApp::handleStartOperation(), inet::TcpAppBase::initialize(), inet::TcpGenericServerApp::initialize(), inet::Ldp::initialize(), inet::TcpClientSocketIo::open(), inet::bgp::BgpRouter::openTCPConnectionToPeer(), and inet::Ldp::openTCPConnectionToPeer().

bind() [2/2]

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

close()

void inet::TcpSocket::close ( )

overridevirtual

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)

Implements inet::ISocket.

{
    if (sockstate != CONNECTED && sockstate != PEER_CLOSED && sockstate != CONNECTING && sockstate != LISTENING) {
//        throw cRuntimeError("TcpSocket::close(): not connected or close() already called (sockstate=%s)", stateName(sockstate));
    }
    else {
        auto request = new Request("CLOSE", TCP_C_CLOSE);
        TcpCommand *cmd = new TcpCommand();
        request->setControlInfo(cmd);
        sendToTcp(request);
        sockstate = (sockstate == CONNECTED) ? LOCALLY_CLOSED : CLOSED;
    }
}

Referenced by inet::TcpAppBase::close(), inet::TcpGenericServerThread::dataArrived(), inet::TcpServerListener::handleStopOperation(), inet::TcpServerHostApp::handleStopOperation(), inet::Ldp::handleStopOperation(), inet::NetPerfMeter::handleTimer(), inet::bgp::BgpRouter::processMessageFromTCP(), and inet::Ldp::socketAvailable().

connect()

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

Active OPEN to the given remote socket.

{
    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);
 
    auto request = new Request("ActiveOPEN", TCP_C_OPEN_ACTIVE);
 
    remoteAddr = remoteAddress;
    remotePrt = remotePort;
 
    TcpOpenCommand *openCmd = new TcpOpenCommand();
    openCmd->setLocalAddr(localAddr);
    openCmd->setLocalPort(localPrt);
    openCmd->setRemoteAddr(remoteAddr);
    openCmd->setRemotePort(remotePrt);
    openCmd->setTcpAlgorithmClass(tcpAlgorithmClass.c_str());
 
    request->setControlInfo(openCmd);
    sendToTcp(request);
    sockstate = CONNECTING;
}

Referenced by inet::TcpAppBase::connect(), inet::NetPerfMeter::establishConnection(), inet::TcpClientSocketIo::open(), inet::bgp::BgpRouter::openTCPConnectionToPeer(), and inet::Ldp::openTCPConnectionToPeer().

destroy()

void inet::TcpSocket::destroy ( )

overridevirtual

Destroy the connection.

Implements inet::ISocket.

{
    auto request = new Request("DESTROY", TCP_C_DESTROY);
    TcpCommand *cmd = new TcpCommand();
    request->setControlInfo(cmd);
    sendToTcp(request);
    sockstate = CLOSED;
}

Referenced by inet::TcpServerListener::handleCrashOperation(), inet::TelnetApp::handleCrashOperation(), inet::TcpBasicClientApp::handleCrashOperation(), inet::TcpSessionApp::handleCrashOperation(), inet::TcpServerHostApp::handleCrashOperation(), and inet::Ldp::handleCrashOperation().

getLocalAddress()

L3Address inet::TcpSocket::getLocalAddress ( ) const

inline

{ return localAddr; }

Referenced by inet::operator<<(), and inet::bgp::BgpSession::sendOpenMessage().

getLocalPort()

int inet::TcpSocket::getLocalPort ( ) const

inline

{ return localPrt; }

Referenced by inet::operator<<().

getReceiveQueue()

ChunkQueue* inet::TcpSocket::getReceiveQueue ( )

inline

{ if (receiveQueue == nullptr) receiveQueue = new ChunkQueue(); return receiveQueue; }

Referenced by inet::bgp::BgpRouter::socketDataArrived(), inet::TcpSocket::ReceiveQueueBasedCallback::socketDataArrived(), and inet::Ldp::socketDataArrived().

getRemoteAddress()

L3Address inet::TcpSocket::getRemoteAddress ( ) const

inline

{ return remoteAddr; }

Referenced by inet::operator<<(), inet::bgp::BgpRouter::processMessageFromTCP(), and inet::Ldp::socketAvailable().

getRemotePort()

int inet::TcpSocket::getRemotePort ( ) const

inline

{ return remotePrt; }

Referenced by inet::operator<<().

getSocketId()

int inet::TcpSocket::getSocketId ( ) const

inlineoverridevirtual

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

Implements inet::ISocket.

{ return connId; }

Referenced by inet::bgp::BgpRouter::findIdFromSocketConnId(), inet::operator<<(), inet::TcpServerHostApp::socketAvailable(), inet::bgp::BgpRouter::socketDataArrived(), inet::bgp::BgpRouter::socketEstablished(), inet::bgp::BgpRouter::socketFailure(), and TcpSocket().

getState()

TcpSocket::State 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.

{ return sockstate; }

Referenced by inet::TcpEchoAppThread::dataArrived(), inet::TcpBasicClientApp::handleStopOperation(), inet::bgp::BgpRouter::openTCPConnectionToPeer(), inet::operator<<(), inet::TcpAppBase::refreshDisplay(), inet::TcpSinkAppThread::refreshDisplay(), inet::TcpSessionApp::refreshDisplay(), inet::TcpServerThreadBase::refreshDisplay(), inet::TcpBasicClientApp::socketDataArrived(), and inet::TcpAppBase::socketPeerClosed().

getTCPAlgorithmClass()

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

inline

Returns the current tcpAlgorithmClass parameter.

{ return tcpAlgorithmClass.c_str(); }

getUserData()

void* inet::TcpSocket::getUserData ( ) const

inline

{ return userData; }

Referenced by inet::Ldp::socketClosed(), inet::Ldp::socketDataArrived(), inet::Ldp::socketEstablished(), inet::Ldp::socketFailure(), and inet::Ldp::socketPeerClosed().

isOpen()

bool inet::TcpSocket::isOpen ( ) const

overridevirtual

Implements inet::ISocket.

{
    switch (sockstate) {
        case BOUND:
        case LISTENING:
        case CONNECTING:
        case CONNECTED:
        case PEER_CLOSED:
        case LOCALLY_CLOSED:
        case SOCKERROR: // TODO check SOCKERROR is opened or is closed socket
            return true;
        case NOT_BOUND:
        case CLOSED:
            return false;
        default:
            throw cRuntimeError("invalid TcpSocket state: %d", sockstate);
    }
}

Referenced by inet::Ldp::handleMessageWhenUp(), inet::TelnetApp::handleStopOperation(), inet::TcpSessionApp::handleStopOperation(), inet::TelnetApp::socketClosed(), inet::TcpServerListener::socketClosed(), inet::TcpServerHostApp::socketClosed(), and inet::TcpSessionApp::socketClosed().

listen() [1/2]

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 TcpServerHostApp shows how to put it all together. See also TcpOpenCommand documentation (neddoc) for more info.

{ listen(true); }

Referenced by listen().

listen() [2/2]

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

protected

{
    if (sockstate != BOUND)
        throw cRuntimeError(sockstate == NOT_BOUND ? "TcpSocket: must call bind() before listen()"
                : "TcpSocket::listen(): connect() or listen() already called");
 
    auto request = new Request("PassiveOPEN", TCP_C_OPEN_PASSIVE);
 
    TcpOpenCommand *openCmd = new TcpOpenCommand();
    openCmd->setLocalAddr(localAddr);
    openCmd->setLocalPort(localPrt);
    openCmd->setFork(fork);
    openCmd->setTcpAlgorithmClass(tcpAlgorithmClass.c_str());
 
    request->setControlInfo(openCmd);
    sendToTcp(request);
    sockstate = LISTENING;
}

Referenced by inet::NetPerfMeter::createAndBindSocket(), inet::TcpServerListener::handleStartOperation(), inet::TcpServerHostApp::handleStartOperation(), inet::TcpGenericServerApp::initialize(), and inet::Ldp::initialize().

listenOnce()

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

processMessage()

void inet::TcpSocket::processMessage ( cMessage *  msg )

overridevirtual

Examines the message (which should have arrived from TCP), updates socket state, and if there is a callback object installed (see setCallback(), class ICallback), dispatches to the appropriate method.

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!

Implements inet::ISocket.

{
    ASSERT(belongsToSocket(msg));
 
    TcpStatusInfo *status;
    TcpAvailableInfo *availableInfo;
    TcpConnectInfo *connectInfo;
 
    switch (msg->getKind()) {
        case TCP_I_DATA:
            if (cb)
                cb->socketDataArrived(this, check_and_cast<Packet *>(msg), false);
            else
                delete msg;
            break;
 
        case TCP_I_URGENT_DATA:
            if (cb)
                cb->socketDataArrived(this, check_and_cast<Packet *>(msg), true);
            else
                delete msg;
            break;
 
        case TCP_I_AVAILABLE:
            availableInfo = check_and_cast<TcpAvailableInfo *>(msg->getControlInfo());
            if (cb)
                cb->socketAvailable(this, availableInfo);
            else
                accept(availableInfo->getNewSocketId());
            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();
            if (cb)
                cb->socketEstablished(this);
            delete msg;
            break;
 
        case TCP_I_PEER_CLOSED:
            sockstate = PEER_CLOSED;
            if (cb)
                cb->socketPeerClosed(this);
            delete msg;
            break;
 
        case TCP_I_CLOSED:
            sockstate = CLOSED;
            if (cb)
                cb->socketClosed(this);
            delete msg;
            break;
 
        case TCP_I_CONNECTION_REFUSED:
        case TCP_I_CONNECTION_RESET:
        case TCP_I_TIMED_OUT:
            sockstate = SOCKERROR;
            if (cb)
                cb->socketFailure(this, msg->getKind());
            delete msg;
            break;
 
        case TCP_I_STATUS:
            status = check_and_cast<TcpStatusInfo *>(msg->getControlInfo());
            if (cb)
                cb->socketStatusArrived(this, status);
            delete msg;
            break;
 
        default:
            throw cRuntimeError("TcpSocket: invalid msg kind %d, one of the TCP_I_xxx constants expected", msg->getKind());
    }
}

Referenced by inet::TcpClientSocketIo::handleMessage(), inet::TcpServerSocketIo::handleMessage(), inet::TcpGenericServerApp::handleMessage(), inet::TcpServerListener::handleMessageWhenUp(), inet::TcpServerHostApp::handleMessageWhenUp(), inet::TcpAppBase::handleMessageWhenUp(), inet::Ldp::handleMessageWhenUp(), and inet::bgp::BgpRouter::processMessageFromTCP().

renewSocket()

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.

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

Referenced by inet::TcpAppBase::connect(), inet::NetPerfMeter::establishConnection(), and inet::bgp::BgpRouter::openTCPConnectionToPeer().

requestStatus()

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.

{
    auto request = new Request("STATUS", TCP_C_STATUS);
    TcpCommand *cmd = new TcpCommand();
    request->setControlInfo(cmd);
    sendToTcp(request);
}

send()

void inet::TcpSocket::send ( Packet *  msg )

overridevirtual

Sends data packet.

Implements inet::ISocket.

{
    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);
    sendToTcp(msg);
}

Referenced by inet::TcpGenericServerThread::dataArrived(), inet::TcpClientSocketIo::handleMessage(), inet::TcpServerSocketIo::handleMessage(), inet::bgp::BgpSession::sendKeepAliveMessage(), inet::bgp::BgpSession::sendOpenMessage(), inet::TcpAppBase::sendPacket(), inet::Ldp::sendToPeer(), inet::bgp::BgpSession::sendUpdateMessage(), and inet::NetPerfMeter::transmitFrame().

sendCommand()

void inet::TcpSocket::sendCommand

(

Request *

msg

)

Sends command.

{
    sendToTcp(msg);
}

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

sendToTcp()

void inet::TcpSocket::sendToTcp ( cMessage *  msg, int  c = -1  )

protected

{
    if (!gateToTcp)
        throw cRuntimeError("TcpSocket: setOutputGate() must be invoked before socket can be used");
 
    auto& tags = check_and_cast<ITaggedObject *>(msg)->getTags();
    tags.addTagIfAbsent<DispatchProtocolReq>()->setProtocol(&Protocol::tcp);
    tags.addTagIfAbsent<SocketReq>()->setSocketId(connId == -1 ? this->connId : connId);
    check_and_cast<cSimpleModule *>(gateToTcp->getOwnerModule())->send(msg, gateToTcp);
}

Referenced by abort(), accept(), close(), connect(), destroy(), listen(), requestStatus(), send(), sendCommand(), setDscp(), setTimeToLive(), and setTos().

setCallback()

void inet::TcpSocket::setCallback

(

ICallback *

cb

)

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

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

class MyAppModule : public cSimpleModule, public TcpSocket::ICallback

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.

{
    cb = callback;
}

Referenced by inet::TcpServerSocketIo::acceptSocket(), inet::TcpServerListener::handleStartOperation(), inet::TcpServerHostApp::handleStartOperation(), inet::TcpAppBase::initialize(), inet::TcpClientSocketIo::open(), inet::bgp::BgpRouter::openTCPConnectionToPeer(), inet::Ldp::openTCPConnectionToPeer(), inet::bgp::BgpRouter::processMessageFromTCP(), inet::TcpServerHostApp::socketAvailable(), and inet::Ldp::socketAvailable().

setDscp()

void inet::TcpSocket::setDscp

(

short

dscp

)

Sets the Ipv4 / Ipv6 dscp fields of packets sent from the TCP socket.

{
    auto request = new Request("setDscp", TCP_C_SETOPTION);
    auto *cmd = new TcpSetDscpCommand();
    cmd->setDscp(dscp);
    request->setControlInfo(cmd);
    sendToTcp(request);
}

Referenced by inet::TcpAppBase::connect().

setOutputGate()

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

{ gateToTcp = toTcp; }

Referenced by inet::TcpServerSocketIo::acceptSocket(), inet::NetPerfMeter::createAndBindSocket(), inet::TcpServerListener::handleStartOperation(), inet::TcpServerHostApp::handleStartOperation(), inet::TcpAppBase::initialize(), inet::TcpGenericServerApp::initialize(), inet::Ldp::initialize(), inet::TcpClientSocketIo::open(), inet::bgp::BgpRouter::openTCPConnectionToPeer(), inet::Ldp::openTCPConnectionToPeer(), inet::bgp::BgpRouter::processMessageFromTCP(), inet::TcpServerHostApp::socketAvailable(), inet::Ldp::socketAvailable(), and inet::NetPerfMeter::successfullyEstablishedConnection().

setState()

void inet::TcpSocket::setState ( TcpSocket::State  state )

inline

{ sockstate = state; }

setTCPAlgorithmClass()

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

inline

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

{ this->tcpAlgorithmClass = tcpAlgorithmClass; }

setTimeToLive()

void inet::TcpSocket::setTimeToLive

(

int

ttl

)

Set the TTL (Ipv6: Hop Limit) field on sent packets.

{
    auto request = new Request("setTTL", TCP_C_SETOPTION);
    TcpSetTimeToLiveCommand *cmd = new TcpSetTimeToLiveCommand();
    cmd->setTtl(ttl);
    request->setControlInfo(cmd);
    sendToTcp(request);
}

Referenced by inet::TcpAppBase::connect(), and inet::bgp::BgpRouter::openTCPConnectionToPeer().

setTos()

void inet::TcpSocket::setTos

(

short

tos

)

Sets the Ipv4 Type of Service / Ipv6 Traffic Class fields of packets sent from the TCP socket.

{
    auto request = new Request("setTOS", TCP_C_SETOPTION);
    auto *cmd = new TcpSetTosCommand();
    cmd->setTos(dscp);
    request->setControlInfo(cmd);
    sendToTcp(request);
}

Referenced by inet::TcpAppBase::connect().

setUserData()

void inet::TcpSocket::setUserData ( void *  userData )

inline

{ this->userData = userData; }

Referenced by inet::bgp::BgpRouter::openTCPConnectionToPeer(), inet::Ldp::openTCPConnectionToPeer(), inet::bgp::BgpRouter::processMessageFromTCP(), and inet::Ldp::socketAvailable().

stateName()

const char * inet::TcpSocket::stateName ( TcpSocket::State  state )

static

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

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

Referenced by inet::operator<<(), inet::TcpAppBase::refreshDisplay(), inet::TcpSinkAppThread::refreshDisplay(), inet::TcpSessionApp::refreshDisplay(), inet::TcpServerThreadBase::refreshDisplay(), and send().

Member Data Documentation

cb

ICallback* inet::TcpSocket::cb = nullptr

protected

Referenced by processMessage(), setCallback(), and ~TcpSocket().

connId

int inet::TcpSocket::connId = -1

protected

Referenced by belongsToSocket(), renewSocket(), sendToTcp(), and TcpSocket().

gateToTcp

cGate* inet::TcpSocket::gateToTcp = nullptr

protected

Referenced by sendToTcp().

localAddr

L3Address inet::TcpSocket::localAddr

protected

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

localPrt

int inet::TcpSocket::localPrt = -1

protected

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

receiveQueue

ChunkQueue* inet::TcpSocket::receiveQueue = nullptr

protected

Referenced by ~TcpSocket().

remoteAddr

L3Address inet::TcpSocket::remoteAddr

protected

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

remotePrt

int inet::TcpSocket::remotePrt = -1

protected

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

sockstate

State inet::TcpSocket::sockstate = NOT_BOUND

protected

Referenced by abort(), bind(), close(), connect(), destroy(), isOpen(), listen(), processMessage(), renewSocket(), send(), and TcpSocket().

tcpAlgorithmClass

std::string inet::TcpSocket::tcpAlgorithmClass

protected

Referenced by connect(), and listen().

userData

void* inet::TcpSocket::userData = nullptr

protected

---

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

• TcpSocket.h
• TcpSocket.cc