inet::SCTPSocket Class Reference

#include <SCTPSocket.h>

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

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

Public Member Functions
	SCTPSocket (bool type=true)
	Constructor. More...
	SCTPSocket (cMessage *msg)
	Constructor, to be used with forked sockets (see listen()). More...
	~SCTPSocket ()
	Destructor. More...
int	getConnectionId () const
	Returns the internal connection Id. More...
int	getState ()
	Returns the socket state, one of NOT_BOUND, CLOSED, LISTENING, CONNECTING, CONNECTED, etc. More...
void	setState (int state)
Getter functions
AddressVector	getLocalAddresses ()
int	getLocalPort ()
AddressVector	getRemoteAddresses ()
int	getRemotePort ()
L3Address	getRemoteAddr ()
Opening and closing connections, sending data
void	setOutputGate (cGate *toSctp)
	Sets the gate on which to send to SCTP. More...
void	setOutboundStreams (int streams)
	Setter and getter methods for socket and API Parameters. More...
void	setInboundStreams (int streams)
void	setAppLimited (bool option)
void	setStreamReset (int option)
void	setStreamPriority (uint32 stream, uint32 priority)
void	setMaxInitRetrans (int option)
void	setMaxInitRetransTimeout (int option)
void	setRtoInitial (double option)
void	setRtoMin (double option)
void	setRtoMax (double option)
void	setSackFrequency (int option)
void	setSackPeriod (double option)
void	setMaxBurst (int option)
void	setFragPoint (int option)
void	setNagle (int option)
void	setPathMaxRetrans (int option)
void	setEnableHeartbeats (bool option)
void	setHbInterval (double option)
void	setRtoInfo (double initial, double max, double min)
void	setAssocMaxRtx (int option)
void	setUserOptions (void *msg)
int	getOutboundStreams ()
int	getInboundStreams ()
bool	getStreamReset ()
int	getLastStream ()
double	getRtoInitial ()
int	getMaxInitRetransTimeout ()
int	getMaxInitRetrans ()
int	getMaxBurst ()
int	getFragPoint ()
int	getAssocMaxRtx ()
void	getSocketOptions ()
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...
void	bindx (AddressVector localAddr, int localPort)
void	addAddress (L3Address addr)
void	listen (bool fork=true, bool streamReset=false, uint32 requests=0, uint32 messagesToPush=0)
	Initiates passive OPEN. More...
void	listen (uint32 requests=0, bool fork=false, uint32 messagesToPush=0, bool options=false, int32 fd=-1)
void	connect (L3Address remoteAddress, int32 remotePort, bool streamReset=false, int32 prMethod=0, uint32 numRequests=0)
	Active OPEN to the given remote socket. More...
void	connect (int32 fd, L3Address remoteAddress, int32 remotePort, uint32 numRequests, bool options=false)
void	connectx (AddressVector remoteAddresses, int32 remotePort, bool streamReset=false, int32 prMethod=0, uint32 numRequests=0)
	Active OPEN to the given remote socket. More...
void	accept (int32 assocId, int32 fd)
void	send (SCTPSimpleMessage *msg, int prMethod=0, double prValue=0.0, int32 streamId=0, bool last=true, bool primary=true)
	Send data message. More...
void	sendMsg (cMessage *cmsg)
	Send data message (provided within control message). More...
void	sendNotification (cMessage *msg)
	Send notification. More...
void	sendRequest (cMessage *msg)
	Send request. More...
void	close (int id=-1)
	Closes the local end of the connection. More...
void	abort ()
	Aborts the association. More...
void	shutdown (int id=-1)
void	requestStatus ()
	Causes SCTP to reply with a fresh SCTPStatusInfo, attached to a dummy message as controlInfo(). More...

Static Public Member Functions
static int32	getNewAssocId ()
	Generates a new integer, to be used as assocId. More...
static const char *	stateName (int state)
	Returns name of socket state code returned by state(). More...

Public Attributes
cGate *	gateToSctp

Protected Member Functions
void	sendToSCTP (cMessage *msg)

Protected Attributes
int	assocId
int	sockstate
bool	oneToOne
bool	appLimited
L3Address	localAddr
AddressVector	localAddresses
int	localPrt
L3Address	remoteAddr
AddressVector	remoteAddresses
int	remotePrt
int	fsmStatus
int	lastStream
SocketOptions *	sOptions
AppSocketOptions *	appOptions
CallbackInterface *	cb
void *	yourPtr

Static Protected Attributes
static int32	nextAssocId = 0

Handling of messages arriving from SCTP
bool	belongsToSocket (cMessage *msg)
	Returns true if the message belongs to this socket instance (message has a SCTPCommand as controlInfo(), and the assocId 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 SCTPMain), 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	belongsToAnySCTPSocket (cMessage *msg)
	Returns true if the message belongs to any SCTPSocket instance. More...

Member Enumeration Documentation

enum inet::SCTPSocket::State

Enumerator
NOT_BOUND
CLOSED
LISTENING
CONNECTING
CONNECTED
PEER_CLOSED
LOCALLY_CLOSED
SOCKERROR

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

Constructor & Destructor Documentation

inet::SCTPSocket::SCTPSocket

(

bool

type = true

)

Constructor.

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

{
    sockstate = NOT_BOUND;
    localPrt = remotePrt = 0;
    fsmStatus = -1;
    cb = nullptr;
    yourPtr = nullptr;
    gateToSctp = nullptr;
    lastStream = -1;
    oneToOne = type;
    sOptions = new SocketOptions();
    appOptions = new AppSocketOptions();
    appOptions->inboundStreams = -1;
    appOptions->outboundStreams = -1;
    appOptions->streamReset = 0;
    appLimited = false;
    if (oneToOne)
        assocId = getNewAssocId();
    else
        assocId = 0;
    EV_INFO << "sockstate=" << stateName(sockstate) << "\n";
}

inet::SCTPSocket::SCTPSocket

(

cMessage *

msg

)

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

The assocId will be picked up from the message: it should have arrived from SCTPMain and contain SCTPCommmand control info.

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

    if (!ind)
        throw cRuntimeError("SCTPSocket::SCTPSocket(cMessage *): no SCTPCommand control info in message (not from SCTP?)");

    assocId = ind->getAssocId();
    sockstate = CONNECTED;

    localPrt = remotePrt = -1;
    sOptions = new SocketOptions();
    appOptions = new AppSocketOptions();
    appOptions->inboundStreams = -1;
    appOptions->outboundStreams = -1;
    appLimited = false;
    cb = nullptr;
    yourPtr = nullptr;
    gateToSctp = nullptr;
    lastStream = -1;
    oneToOne = true;

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

        SCTPConnectInfo *connectInfo = check_and_cast<SCTPConnectInfo *>(msg->getControlInfo());
        localAddr = connectInfo->getLocalAddr();
        remoteAddr = connectInfo->getRemoteAddr();
        localPrt = connectInfo->getLocalPort();
        remotePrt = connectInfo->getRemotePort();
        fsmStatus = connectInfo->getStatus();
        appOptions->inboundStreams = connectInfo->getInboundStreams();
        appOptions->outboundStreams = connectInfo->getOutboundStreams();
   }
}

inet::SCTPSocket::~SCTPSocket

(

)

Destructor.

{
    delete sOptions;
    delete appOptions;
    if (cb) {
        cb->socketDeleted(assocId, yourPtr);
    }
}

Member Function Documentation

void inet::SCTPSocket::abort

(

)

Aborts the association.

Referenced by inet::SCTPClient::handleTimer(), and inet::NetPerfMeter::successfullyEstablishedConnection().

{
    if (sockstate != NOT_BOUND && sockstate != CLOSED && sockstate != SOCKERROR) {
        cMessage *msg = new cMessage("ABORT", SCTP_C_ABORT);
        SCTPCommand *cmd = new SCTPCommand();
        cmd->setAssocId(assocId);
        msg->setControlInfo(cmd);
        sendToSCTP(msg);
    }
    sockstate = CLOSED;
}

void inet::SCTPSocket::accept	(	int32	assocId,
		int32	fd
	)

{
    SCTPCommand *cmd = new SCTPCommand();
    cmd->setLocalPort(localPrt);
    cmd->setRemoteAddr(remoteAddr);
    cmd->setRemotePort(remotePrt);
    cmd->setAssocId(assId);
    cmd->setFd(fd);
    cMessage *cmsg = new cMessage("Accept", SCTP_C_ACCEPT);
    cmsg->setControlInfo(cmd);
    sendToSCTP(cmsg);
}

void inet::SCTPSocket::addAddress

(

L3Address

addr

)

{
    EV_INFO << "add address " << addr << "\n";
    localAddresses.push_back(addr);
}

bool inet::SCTPSocket::belongsToAnySCTPSocket ( cMessage *  msg )

static

Returns true if the message belongs to any SCTPSocket instance.

(This basically checks if the message has a SCTPCommand attached to it as controlInfo().)

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

bool inet::SCTPSocket::belongsToSocket

(

cMessage *

msg

)

Returns true if the message belongs to this socket instance (message has a SCTPCommand as controlInfo(), and the assocId in it matches that of the socket.)

{
    bool ret = dynamic_cast<SCTPCommand *>(msg->getControlInfo()) &&
        ((SCTPCommand *)(msg->getControlInfo()))->getAssocId() == assocId;
    EV_INFO << "assoc=" << ((SCTPCommand *)(msg->getControlInfo()))->getAssocId() << "\n";
    return ret;
}

void inet::SCTPSocket::bind

(

int

localPort

)

Bind the socket to a local port number.

Referenced by connect(), inet::NetPerfMeter::createAndBindSocket(), inet::SCTPServer::initialize(), inet::SCTPClient::initialize(), and inet::SCTPPeer::initialize().

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

    localAddresses.push_back(L3Address());    // Unspecified address
    localPrt = lPort;
    sockstate = CLOSED;
    getSocketOptions();
}

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

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

{
    EV_INFO << "bind address " << lAddr << "\n";
    if (sockstate != NOT_BOUND)
        throw cRuntimeError("SCTPSocket::bind(): socket already bound");

    localAddresses.push_back(lAddr);
    localPrt = lPort;
    sockstate = CLOSED;
    getSocketOptions();
}

void inet::SCTPSocket::bindx	(	AddressVector	localAddr,
		int	localPort
	)

Referenced by inet::SCTPServer::initialize(), inet::SCTPClient::initialize(), and inet::SCTPPeer::initialize().

{
    L3Address lAddr;
    for (auto & lAddresse : lAddresses) {
        EV << "bindx: bind address " << (lAddresse) << "\n";
        localAddresses.push_back((lAddresse));
    }
    localPrt = lPort;
    sockstate = CLOSED;
    getSocketOptions();
}

void inet::SCTPSocket::close

(

int

id = -1

)

Closes the local end of the connection.

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

Referenced by inet::SCTPClient::close(), inet::NetPerfMeter::handleTimer(), inet::SCTPPeer::socketDataArrived(), inet::SCTPPeer::socketPeerClosed(), and inet::NetPerfMeter::teardownConnection().

{
    EV_INFO << "SCTPSocket::close()\n";

    cMessage *msg = new cMessage("CLOSE", SCTP_C_CLOSE);
    SCTPCommand *cmd = new SCTPCommand();
    if (id == -1)
        cmd->setAssocId(assocId);
    else
        cmd->setFd(id);
    msg->setControlInfo(cmd);
    sendToSCTP(msg);
    sockstate = (sockstate == CONNECTED) ? LOCALLY_CLOSED : CLOSED;
}

void inet::SCTPSocket::connect	(	L3Address	remoteAddress,
		int32	remotePort,
		bool	streamReset = false,
		int32	prMethod = 0,
		uint32	numRequests = 0
	)

Active OPEN to the given remote socket.

Referenced by inet::SCTPClient::connect(), inet::SCTPPeer::connect(), and connectx().

{
    EV_INFO << "Socket connect. Assoc=" << assocId << ", sockstate=" << stateName(sockstate) << "\n";

    if (oneToOne && sockstate == NOT_BOUND)
       bind(0);

    if (oneToOne && sockstate != CLOSED)
        throw cRuntimeError("SCTPSocket::connect(): connect() or listen() already called");

    if (!oneToOne && sockstate != LISTENING)
        throw cRuntimeError("SCTPSocket::connect(): one-to-many style socket must be listening");

    remoteAddr = remoteAddress;
    remotePrt = remotePort;

    SCTPOpenCommand *openCmd = new SCTPOpenCommand();
    if (oneToOne)
        openCmd->setAssocId(assocId);
    else
        openCmd->setAssocId(getNewAssocId());
    EV_INFO << "Socket connect. Assoc=" << openCmd->getAssocId() << ", sockstate=" << stateName(sockstate) << "\n";
    openCmd->setLocalAddresses(localAddresses);
    openCmd->setLocalPort(localPrt);
    openCmd->setRemoteAddr(remoteAddr);
    openCmd->setRemotePort(remotePrt);
    openCmd->setOutboundStreams(appOptions->outboundStreams);
    openCmd->setInboundStreams(appOptions->inboundStreams);
    appOptions->streamReset = streamReset;
    openCmd->setNumRequests(numRequests);
    openCmd->setPrMethod(prMethod);
    openCmd->setStreamReset(streamReset);

    cMessage *cmsg = new cMessage("Associate", SCTP_C_ASSOCIATE);
    cmsg->setControlInfo(openCmd);
    sendToSCTP(cmsg);

    if (oneToOne)
        sockstate = CONNECTING;
}

void inet::SCTPSocket::connect	(	int32	fd,
		L3Address	remoteAddress,
		int32	remotePort,
		uint32	numRequests,
		bool	options = false
	)

{
    EV_INFO << "Socket connect. Assoc=" << assocId << ", sockstate=" << stateName(sockstate) << "\n";

    if (oneToOne && sockstate == NOT_BOUND)
       bind(0);

    if (oneToOne && sockstate != CLOSED)
        throw cRuntimeError("SCTPSocket::connect(): connect() or listen() already called");

    if (!oneToOne && sockstate != LISTENING)
        throw cRuntimeError("SCTPSocket::connect(): one-to-many style socket must be listening");

    remoteAddr = remoteAddress;
    remotePrt = remotePort;

    SCTPOpenCommand *openCmd = new SCTPOpenCommand();
    if (oneToOne)
        openCmd->setAssocId(assocId);
    else
        openCmd->setAssocId(getNewAssocId());
    EV_INFO << "Socket connect. Assoc=" << openCmd->getAssocId() << ", sockstate=" << stateName(sockstate) << "\n";
    openCmd->setLocalAddresses(localAddresses);
    openCmd->setLocalPort(localPrt);
    openCmd->setRemoteAddr(remoteAddr);
    openCmd->setRemotePort(remotePrt);
    openCmd->setOutboundStreams(appOptions->outboundStreams);
    openCmd->setInboundStreams(appOptions->inboundStreams);
    openCmd->setStreamReset(appOptions->streamReset);
    openCmd->setNumRequests(numRequests);
    openCmd->setFd(fd);
    openCmd->setAppLimited(appLimited);

    cMessage *cmsg = new cMessage("Associate", SCTP_C_ASSOCIATE);
    cmsg->setControlInfo(openCmd);
    if (options) {
        cmsg->setContextPointer((void*) sOptions);
    }
    sendToSCTP(cmsg);

    if (oneToOne)
        sockstate = CONNECTING;
}

void inet::SCTPSocket::connectx	(	AddressVector	remoteAddresses,
		int32	remotePort,
		bool	streamReset = false,
		int32	prMethod = 0,
		uint32	numRequests = 0
	)

Active OPEN to the given remote socket.

The current implementation just calls connect() with the first address of the given list. This behaviour may be improved in the future.

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

{
    EV_INFO << "Socket connectx.  sockstate=" << stateName(sockstate) << "\n";
    remoteAddresses = remoteAddressList;
    connect(remoteAddressList.front(), remotePort, streamReset, prMethod, numRequests);
}

int inet::SCTPSocket::getAssocMaxRtx ( )

inline

{ return sOptions->assocMaxRtx; };

int inet::SCTPSocket::getConnectionId ( ) const

inline

Returns the internal connection Id.

SCTP uses the (gate index, assocId) pair to identify the connection when it receives a command from the application (or SCTPSocket).

Referenced by inet::SCTPSocketMap::addSocket(), inet::SCTPPeer::connect(), inet::SCTPSocketMap::removeSocket(), inet::SCTPClient::sendQueueRequest(), inet::SCTPPeer::sendQueueRequest(), inet::SCTPClient::sendStreamResetNotification(), and inet::SCTPClient::setPrimaryPath().

{ return assocId; }

int inet::SCTPSocket::getFragPoint ( )

inline

{ return sOptions->fragPoint; };

int inet::SCTPSocket::getInboundStreams ( )

inline

{ return appOptions->inboundStreams; };

int inet::SCTPSocket::getLastStream ( )

inline

{ return lastStream; };

AddressVector inet::SCTPSocket::getLocalAddresses ( )

inline

{ return localAddresses; }

int inet::SCTPSocket::getLocalPort ( )

inline

{ return localPrt; }

int inet::SCTPSocket::getMaxBurst ( )

inline

{ return sOptions->maxBurst; };

int inet::SCTPSocket::getMaxInitRetrans ( )

inline

{ return sOptions->maxInitRetrans; };

int inet::SCTPSocket::getMaxInitRetransTimeout ( )

inline

{ return sOptions->maxInitRetransTimeout; };

static int32 inet::SCTPSocket::getNewAssocId ( )

inlinestatic

Generates a new integer, to be used as assocId.

(assocId is part of the key which associates connections with their apps).

Referenced by inet::sctp::SCTP::addForkedAssociation(), connect(), listen(), and SCTPSocket().

{ return ++nextAssocId; }

int inet::SCTPSocket::getOutboundStreams ( )

inline

{ return appOptions->outboundStreams; };

L3Address inet::SCTPSocket::getRemoteAddr ( )

inline

Referenced by inet::SCTPClient::sendStreamResetNotification().

{ return remoteAddr; }

AddressVector inet::SCTPSocket::getRemoteAddresses ( )

inline

{ return remoteAddresses; }

int inet::SCTPSocket::getRemotePort ( )

inline

{ return remotePrt; }

double inet::SCTPSocket::getRtoInitial ( )

inline

{ return sOptions->rtoInitial; };

void inet::SCTPSocket::getSocketOptions

(

)

Referenced by bind(), and bindx().

{
    cPacket* cmsg = new cPacket("GetSocketOptions", SCTP_C_GETSOCKETOPTIONS);
    SCTPSendInfo *cmd = new SCTPSendInfo("getOptions");
    cmd->setAssocId(assocId);
    cmd->setSid(0);
    cmsg->setControlInfo(cmd);
    sendToSCTP(cmsg);
}

int inet::SCTPSocket::getState ( )

inline

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

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

Referenced by inet::SCTPPeer::handleMessage(), inet::SCTPClient::socketPeerClosed(), and inet::SCTPPeer::socketPeerClosed().

{ return sockstate; }

bool inet::SCTPSocket::getStreamReset ( )

inline

{ return appOptions->streamReset; }

void inet::SCTPSocket::listen	(	bool	fork = true,
		bool	streamReset = false,
		uint32	requests = 0,
		uint32	messagesToPush = 0
	)

Initiates passive OPEN.

If fork=true, you'll have to create a new SCTPSocket object for each incoming connection, and this socket will keep listening on the port. If fork=false, the first incoming connection will be accepted, and SCTP will refuse subsequent ones. See SCTPOpenCommand documentation (neddoc) for more info.

Referenced by inet::NetPerfMeter::createAndBindSocket(), inet::SCTPServer::initialize(), and inet::SCTPPeer::initialize().

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

    SCTPOpenCommand *openCmd = new SCTPOpenCommand();
    openCmd->setLocalAddresses(localAddresses);
    openCmd->setLocalPort(localPrt);
    if (oneToOne)
        openCmd->setAssocId(assocId);
    else
        openCmd->setAssocId(getNewAssocId());
    openCmd->setFork(fork);
    openCmd->setOutboundStreams(appOptions->outboundStreams);
    openCmd->setInboundStreams(appOptions->inboundStreams);
    appOptions->streamReset = reset;
    openCmd->setNumRequests(requests);
    openCmd->setStreamReset(reset);
    openCmd->setMessagesToPush(messagesToPush);

    EV_INFO << "Assoc " << openCmd->getAssocId() << ": PassiveOPEN to SCTP from SCTPSocket:listen()\n";
    cMessage *cmsg = new cMessage("PassiveOPEN", SCTP_C_OPEN_PASSIVE);
    cmsg->setControlInfo(openCmd);
    sendToSCTP(cmsg);
    sockstate = LISTENING;
}

void inet::SCTPSocket::listen	(	uint32	requests = 0,
		bool	fork = false,
		uint32	messagesToPush = 0,
		bool	options = false,
		int32	fd = -1
	)

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

    SCTPOpenCommand *openCmd = new SCTPOpenCommand();
    openCmd->setLocalAddresses(localAddresses);
    openCmd->setLocalPort(localPrt);
    if (oneToOne)
        openCmd->setAssocId(assocId);
    else
        openCmd->setAssocId(getNewAssocId());
    openCmd->setFork(fork);
    openCmd->setFd(fd);
    openCmd->setInboundStreams(appOptions->inboundStreams);
    openCmd->setOutboundStreams(appOptions->outboundStreams);
    openCmd->setNumRequests(requests);
    openCmd->setMessagesToPush(messagesToPush);
    openCmd->setStreamReset(appOptions->streamReset);

    EV_INFO << "Assoc " << openCmd->getAssocId() << ": PassiveOPEN to SCTP from SCTPSocket:listen()\n";
    cMessage *cmsg = new cMessage("PassiveOPEN", SCTP_C_OPEN_PASSIVE);
    cmsg->setControlInfo(openCmd);
    if (options)
        cmsg->setContextPointer((void*) sOptions);
    sendToSCTP(cmsg);
    sockstate = LISTENING;
}

void inet::SCTPSocket::processMessage

(

cMessage *

msg

)

Examines the message (which should have arrived from SCTPMain), 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 SCTP_I_DATA or SCTP_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::SCTPClient::handleMessage(), and inet::SCTPPeer::handleMessage().

{
    SCTPStatusInfo *status;
    switch (msg->getKind()) {
        case SCTP_I_DATA:
            EV_INFO << "SCTP_I_DATA\n";
            if (cb) {
                cb->socketDataArrived(assocId, yourPtr, PK(msg), false);
                msg = nullptr;
            }
            break;

        case SCTP_I_DATA_NOTIFICATION:
            EV_INFO << "SCTP_I_NOTIFICATION\n";
            if (cb) {
                cb->socketDataNotificationArrived(assocId, yourPtr, PK(msg));
            }
            break;

        case SCTP_I_SEND_MSG:
            if (cb) {
                cb->sendRequestArrived();
            }
            break;

        case SCTP_I_ESTABLISHED: {
            if (oneToOne)
                sockstate = CONNECTED;
            SCTPConnectInfo *connectInfo = check_and_cast<SCTPConnectInfo *>(msg->removeControlInfo());
            localAddr = connectInfo->getLocalAddr();
            remoteAddr = connectInfo->getRemoteAddr();
            localPrt = connectInfo->getLocalPort();
            remotePrt = connectInfo->getRemotePort();
            fsmStatus = connectInfo->getStatus();
            appOptions->inboundStreams = connectInfo->getInboundStreams();
            appOptions->outboundStreams = connectInfo->getOutboundStreams();

            if (cb) {
                cb->socketEstablished(assocId, yourPtr, connectInfo->getNumMsgs());
            }
            delete connectInfo;
            break;
        }

        case SCTP_I_PEER_CLOSED:
            EV_INFO << "peer closed\n";
            if (oneToOne)
                sockstate = (sockstate == CONNECTED) ? PEER_CLOSED : CLOSED;

            if (cb) {
                cb->socketPeerClosed(assocId, yourPtr);
            }
            break;

        case SCTP_I_ABORT:
        case SCTP_I_CONN_LOST:
        case SCTP_I_CLOSED:
            EV_INFO << "SCTP_I_CLOSED called\n";
            sockstate = CLOSED;
            if (cb) {
                cb->socketClosed(assocId, yourPtr);
            }
            break;

        case SCTP_I_CONNECTION_REFUSED:
        case SCTP_I_CONNECTION_RESET:
        case SCTP_I_TIMED_OUT:
            sockstate = SOCKERROR;
            if (cb) {
                cb->socketFailure(assocId, yourPtr, msg->getKind());
            }
            break;

        case SCTP_I_STATUS:
            status = check_and_cast<SCTPStatusInfo *>(msg->removeControlInfo());
            if (cb) {
                cb->socketStatusArrived(assocId, yourPtr, status);
            }
            break;

        case SCTP_I_ABANDONED:
            if (cb) {
                cb->msgAbandonedArrived(assocId);
            }
            break;

        case SCTP_I_SHUTDOWN_RECEIVED:
            EV_INFO << "SCTP_I_SHUTDOWN_RECEIVED\n";
            if (cb) {
                cb->shutdownReceivedArrived(assocId);
            }
            break;

        case SCTP_I_SENDQUEUE_FULL:
            if (cb) {
                cb->sendqueueFullArrived(assocId);
            }
            break;

        case SCTP_I_SENDQUEUE_ABATED: {
            SCTPCommand *cmd = check_and_cast<SCTPCommand *>(msg->removeControlInfo());
            if (cb) {
                cb->sendqueueAbatedArrived(assocId, cmd->getNumMsgs());
            }
            delete cmd;
            break;
        }

        case SCTP_I_RCV_STREAMS_RESETTED:
        case SCTP_I_SEND_STREAMS_RESETTED:
        case SCTP_I_RESET_REQUEST_FAILED:
        case SCTP_I_SENDSOCKETOPTIONS:
            break;

        case SCTP_I_ADDRESS_ADDED: {
            SCTPCommand *cmd = check_and_cast<SCTPCommand *>(msg->removeControlInfo());
            if (cb) {
                cb->addressAddedArrived(assocId, cmd->getLocalAddr(), remoteAddr);
            }
            delete cmd;
            break;
        }

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

    if (msg != nullptr) {
        delete msg;
    }
}

void inet::SCTPSocket::requestStatus

(

)

Causes SCTP to reply with a fresh SCTPStatusInfo, attached to a dummy message as controlInfo().

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

{
    cMessage *msg = new cMessage("STATUS", SCTP_C_STATUS);
    SCTPCommand *cmd = new SCTPCommand();
    cmd->setAssocId(assocId);
    msg->setControlInfo(cmd);
    sendToSCTP(msg);
}

void inet::SCTPSocket::send	(	SCTPSimpleMessage *	msg,
		int	prMethod = 0,
		double	prValue = 0.0,
		int32	streamId = 0,
		bool	last = true,
		bool	primary = true
	)

Send data message.

Referenced by sendToSCTP().

{
    if (oneToOne && sockstate != CONNECTED && sockstate != CONNECTING && sockstate != PEER_CLOSED) {
        throw cRuntimeError("SCTPSocket::send(): not connected or connecting");
    }
    else if (!oneToOne && sockstate != LISTENING) {
        throw cRuntimeError("SCTPSocket::send(): one-to-many style socket must be listening");
    }

    SCTPSendInfo *sendCommand = new SCTPSendInfo();
    sendCommand->setAssocId(assocId);
    sendCommand->setSid(streamId);
    sendCommand->setPrValue(prValue);
    sendCommand->setPrMethod(prMethod);
    sendCommand->setLast(last);
    sendCommand->setPrimary(primary);
    sendCommand->setSendUnordered( (msg->getKind() == SCTP_C_SEND_UNORDERED) ?
                                   COMPLETE_MESG_UNORDERED : COMPLETE_MESG_ORDERED );

    cPacket* cmsg = new cPacket("SCTP_C_SEND");
    cmsg->setKind(SCTP_C_SEND);
    cmsg->encapsulate(msg);
    cmsg->setControlInfo(sendCommand);

    sendToSCTP(cmsg);
}

void inet::SCTPSocket::sendMsg

(

cMessage *

cmsg

)

Send data message (provided within control message).

Referenced by inet::SCTPPeer::sendRequest(), inet::SCTPClient::sendRequest(), inet::SCTPClient::socketDataArrived(), and inet::SCTPPeer::socketDataArrived().

{
    SCTPSendInfo *sendCommand;

    if (cmsg->getControlInfo()) {
        sendCommand = check_and_cast<SCTPSendInfo *>(cmsg->removeControlInfo());
        if (sendCommand->getSid() == -1) {
            lastStream = (lastStream + 1) % appOptions->outboundStreams;
            sendCommand->setSid(lastStream);
        }
        if (sendCommand->getAssocId() == -1)
            sendCommand->setAssocId(assocId);
        cmsg->setControlInfo(sendCommand);
    } else {
        sendCommand = new SCTPSendInfo();
        sendCommand->setAssocId(assocId);
        lastStream = (lastStream + 1) % appOptions->outboundStreams;
        sendCommand->setSid(lastStream);
        cmsg->setControlInfo(sendCommand);
    }
    cmsg->setKind(SCTP_C_SEND);
    sendToSCTP(cmsg);
}

void inet::SCTPSocket::sendNotification

(

cMessage *

msg

)

Send notification.

Referenced by inet::SCTPClient::sendStreamResetNotification(), inet::SCTPClient::setPrimaryPath(), inet::SCTPClient::shutdownReceivedArrived(), inet::SCTPPeer::shutdownReceivedArrived(), inet::SCTPClient::socketDataNotificationArrived(), and inet::SCTPPeer::socketDataNotificationArrived().

{
    if (oneToOne && sockstate != CONNECTED && sockstate != CONNECTING && sockstate != PEER_CLOSED) {
        throw cRuntimeError("SCTPSocket::sendNotification(%s): not connected or connecting", msg->getName());
    }
    else if (!oneToOne && sockstate != LISTENING) {
        throw cRuntimeError("SCTPSocket::sendNotification(%s): one-to-many style socket must be listening", msg->getName());
    }

    sendToSCTP(msg);
}

void inet::SCTPSocket::sendRequest

(

cMessage *

msg

)

Send request.

Referenced by inet::SCTPClient::sendQueueRequest(), inet::SCTPPeer::sendQueueRequest(), and inet::NetPerfMeter::sendSCTPQueueRequest().

{
    sendToSCTP(msg);
}

void inet::SCTPSocket::sendToSCTP ( cMessage *  msg )

protected

Referenced by abort(), accept(), close(), connect(), getSocketOptions(), listen(), requestStatus(), send(), sendMsg(), sendNotification(), sendRequest(), setRtoInfo(), setStreamPriority(), and shutdown().

{
    if (!gateToSctp)
        throw cRuntimeError("SCTPSocket::sendToSCTP(): setOutputGate() must be invoked before socket can be used");

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

void inet::SCTPSocket::setAppLimited ( bool  option )

inline

{ appLimited = option; };

void inet::SCTPSocket::setAssocMaxRtx ( int  option )

inline

{ sOptions->assocMaxRtx = option; };

void inet::SCTPSocket::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 SCTPSocket::CallbackInterface

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

SCTPSocket 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 – SCTPSocket 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 assocId in the callbacks, you can have it passed to you as yourPtr.

Referenced by inet::SCTPClient::initialize(), and inet::SCTPPeer::initialize().

{
    cb = callback;
    yourPtr = yourPointer;
}

void inet::SCTPSocket::setEnableHeartbeats ( bool  option )

inline

{ sOptions->enableHeartbeats = option; printf("enableHeartbeats set to %d\n", sOptions->enableHeartbeats);};

void inet::SCTPSocket::setFragPoint ( int  option )

inline

{ sOptions->fragPoint = option; };

void inet::SCTPSocket::setHbInterval ( double  option )

inline

{ sOptions->hbInterval = option; };

void inet::SCTPSocket::setInboundStreams ( int  streams )

inline

Referenced by inet::SCTPClient::connect(), inet::NetPerfMeter::createAndBindSocket(), inet::SCTPServer::initialize(), and inet::SCTPPeer::initialize().

{ appOptions->inboundStreams = streams; };

void inet::SCTPSocket::setMaxBurst ( int  option )

inline

{ sOptions->maxBurst = option; };

void inet::SCTPSocket::setMaxInitRetrans ( int  option )

inline

{ sOptions->maxInitRetrans = option; };

void inet::SCTPSocket::setMaxInitRetransTimeout ( int  option )

inline

{ sOptions->maxInitRetransTimeout = option; };

void inet::SCTPSocket::setNagle ( int  option )

inline

{ sOptions->nagle = option; };

void inet::SCTPSocket::setOutboundStreams ( int  streams )

inline

Setter and getter methods for socket and API Parameters.

Referenced by inet::SCTPClient::connect(), inet::SCTPPeer::connect(), inet::NetPerfMeter::createAndBindSocket(), inet::SCTPServer::initialize(), and inet::SCTPPeer::initialize().

{ appOptions->outboundStreams = streams; };

void inet::SCTPSocket::setOutputGate ( cGate *  toSctp )

inline

Sets the gate on which to send to SCTP.

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

Referenced by inet::NetPerfMeter::createAndBindSocket(), inet::SCTPServer::initialize(), inet::SCTPClient::initialize(), inet::SCTPPeer::initialize(), and inet::NetPerfMeter::successfullyEstablishedConnection().

{ gateToSctp = toSctp; };

void inet::SCTPSocket::setPathMaxRetrans ( int  option )

inline

{ sOptions->pathMaxRetrans = option; };

void inet::SCTPSocket::setRtoInfo	(	double	initial,
		double	max,
		double	min
	)

{
    sOptions->rtoInitial = initial;
    sOptions->rtoMax = max;
    sOptions->rtoMin = min;
    if (sockstate == CONNECTED) {
        cMessage *msg = new cMessage("RtoInfo", SCTP_C_SET_RTO_INFO);
        SCTPRtoInfo *cmd = new SCTPRtoInfo();
        cmd->setAssocId(assocId);
        cmd->setRtoInitial(initial);
        cmd->setRtoMin(min);
        cmd->setRtoMax(max);
        msg->setControlInfo(cmd);
        sendToSCTP(msg);
    }
}

void inet::SCTPSocket::setRtoInitial ( double  option )

inline

{ sOptions->rtoInitial = option; };

void inet::SCTPSocket::setRtoMax ( double  option )

inline

{ sOptions->rtoMax = option; };

void inet::SCTPSocket::setRtoMin ( double  option )

inline

{ sOptions->rtoMin = option; };

void inet::SCTPSocket::setSackFrequency ( int  option )

inline

{ sOptions->sackFrequency = option; };

void inet::SCTPSocket::setSackPeriod ( double  option )

inline

{ sOptions->sackPeriod = option; };

void inet::SCTPSocket::setState ( int  state )

inline

{ sockstate = state; };

void inet::SCTPSocket::setStreamPriority	(	uint32	stream,
		uint32	priority
	)

Referenced by inet::SCTPPeer::connect(), and inet::SCTPServer::initialize().

{
    cMessage *msg = new cMessage("SET_STREAM_PRIO", SCTP_C_SET_STREAM_PRIO);
    SCTPSendInfo *cmd = new SCTPSendInfo();
    cmd->setAssocId(assocId);
    cmd->setSid(stream);
    cmd->setPpid(priority);
    msg->setControlInfo(cmd);
    sendToSCTP(msg);
}

void inet::SCTPSocket::setStreamReset ( int  option )

inline

{ appOptions->streamReset = option; };

void inet::SCTPSocket::setUserOptions ( void *  msg )

inline

{ delete sOptions; sOptions = (SocketOptions*) msg; };

void inet::SCTPSocket::shutdown

(

int

id = -1

)

Referenced by inet::SCTPClient::handleTimer(), inet::SCTPClient::sendqueueAbatedArrived(), inet::SCTPClient::sendRequestArrived(), inet::SCTPPeer::sendRequestArrived(), inet::SCTPClient::socketEstablished(), and inet::SCTPPeer::socketEstablished().

{
    EV << "SCTPSocket::shutdown()\n";

    cMessage *msg = new cMessage("SHUTDOWN", SCTP_C_SHUTDOWN);
    SCTPCommand *cmd = new SCTPCommand();
    if (id == -1)
        cmd->setAssocId(assocId);
    else
        cmd->setFd(id);
    msg->setControlInfo(cmd);
    sendToSCTP(msg);
}

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

static

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

Referenced by connect(), connectx(), and SCTPSocket().

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

Member Data Documentation

bool inet::SCTPSocket::appLimited

protected

Referenced by connect(), and SCTPSocket().

AppSocketOptions* inet::SCTPSocket::appOptions

protected

Referenced by connect(), listen(), processMessage(), SCTPSocket(), sendMsg(), and ~SCTPSocket().

int inet::SCTPSocket::assocId

protected

Referenced by abort(), belongsToSocket(), close(), connect(), getSocketOptions(), listen(), processMessage(), requestStatus(), SCTPSocket(), send(), sendMsg(), setRtoInfo(), setStreamPriority(), shutdown(), and ~SCTPSocket().

CallbackInterface* inet::SCTPSocket::cb

protected

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

int inet::SCTPSocket::fsmStatus

protected

Referenced by processMessage(), and SCTPSocket().

cGate* inet::SCTPSocket::gateToSctp

Referenced by SCTPSocket(), and sendToSCTP().

int inet::SCTPSocket::lastStream

protected

Referenced by SCTPSocket(), and sendMsg().

L3Address inet::SCTPSocket::localAddr

protected

Referenced by processMessage(), and SCTPSocket().

AddressVector inet::SCTPSocket::localAddresses

protected

Referenced by addAddress(), bind(), bindx(), connect(), and listen().

int inet::SCTPSocket::localPrt

protected

Referenced by accept(), bind(), bindx(), connect(), listen(), processMessage(), and SCTPSocket().

int32 inet::SCTPSocket::nextAssocId = 0

staticprotected

bool inet::SCTPSocket::oneToOne

protected

Referenced by connect(), listen(), processMessage(), SCTPSocket(), send(), and sendNotification().

L3Address inet::SCTPSocket::remoteAddr

protected

Referenced by accept(), connect(), processMessage(), and SCTPSocket().

AddressVector inet::SCTPSocket::remoteAddresses

protected

Referenced by connectx().

int inet::SCTPSocket::remotePrt

protected

Referenced by accept(), connect(), processMessage(), and SCTPSocket().

int inet::SCTPSocket::sockstate

protected

Referenced by abort(), bind(), bindx(), close(), connect(), connectx(), listen(), processMessage(), SCTPSocket(), send(), sendNotification(), and setRtoInfo().

SocketOptions* inet::SCTPSocket::sOptions

protected

Referenced by connect(), listen(), SCTPSocket(), setRtoInfo(), and ~SCTPSocket().

void* inet::SCTPSocket::yourPtr

protected

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

---

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

• SCTPSocket.h
• SCTPSocket.cc