inet::SctpSocket Class Reference

#include <SctpSocket.h>

Inheritance diagram for inet::SctpSocket:

Classes
class	ICallback
	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...
void *	getUserData () const
void	setUserData (void *userData)
int	getSocketId () const override
	Returns the internal connection Id. More...
int	getState () const
	Returns the socket state, one of NOT_BOUND, CLOSED, LISTENING, CONNECTING, CONNECTED, etc. More...
Getter functions
AddressVector	getLocalAddresses () const
int	getLocalPort () const
AddressVector	getRemoteAddresses () const
int	getRemotePort () const
L3Address	getRemoteAddr () const
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_t stream, uint32_t 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 (SocketOptions *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_t requests=0, uint32_t messagesToPush=0)
	Initiates passive OPEN. More...
void	listen (uint32_t requests=0, bool fork=false, uint32_t messagesToPush=0, bool options=false, int32_t fd=-1)
void	accept (int socketId)
void	connect (L3Address remoteAddress, int32_t remotePort, bool streamReset=false, int32_t prMethod=0, uint32_t numRequests=0)
	Active OPEN to the given remote socket. More...
void	connect (int32_t fd, L3Address remoteAddress, int32_t remotePort, uint32_t numRequests, bool options=false)
void	connectx (AddressVector remoteAddresses, int32_t remotePort, bool streamReset=false, int32_t prMethod=0, uint32_t numRequests=0)
	Active OPEN to the given remote socket. More...
void	accept (int32_t assocId, int32_t fd)
void	acceptSocket (int newSockId)
virtual void	send (Packet *packet) override
	Send data message. More...
void	sendNotification (cMessage *msg)
	Send notification. More...
void	sendRequest (cMessage *msg)
	Send request. More...
void	close (int id)
	Closes the local end of the connection. More...
virtual void	close () override
	Close the socket. 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...
Handling of messages arriving from SCTP
virtual bool	belongsToSocket (cMessage *msg) const override
	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	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 SctpMain), updates socket state, and if there is a callback object installed (see setCallback(), class CallbackInterface), dispatches to the appropriate method. More...
void	setState (int state)
void	setTunInterface (int id)
int	getTunInterface ()
virtual void	destroy () override
	Notify the protocol that the owner of ISocket has destroyed the socket. More...
virtual bool	isOpen () const override
Public Member Functions inherited from inet::ISocket
virtual	~ISocket ()

Static Public Member Functions
static int32_t	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
int	interfaceIdToTun = -1

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
ICallback *	cb
void *	userData

Static Protected Attributes
static int32_t	nextAssocId = 0

Member Enumeration Documentation

State

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

SctpSocket() [1/2]

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;
    userData = 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) << "  assocId=" << assocId << "\n";
}

SctpSocket() [2/2]

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.

{
    auto& tags = check_and_cast<ITaggedObject *>(msg)->getTags();
    if (tags.getNumTags() == 0)
        throw cRuntimeError("SctpSocket::SctpSocket(cMessage *): no SctpCommandReq in message (not from SCTP?)");
 
    assocId = tags.getTag<SocketInd>()->getSocketId();
    sockstate = CONNECTED;
 
    localPrt = remotePrt = -1;
    sOptions = new SocketOptions();
    appOptions = new AppSocketOptions();
    appOptions->inboundStreams = -1;
    appOptions->outboundStreams = -1;
    appLimited = false;
    cb = nullptr;
    userData = nullptr;
    gateToSctp = nullptr;
    lastStream = -1;
    oneToOne = true;
 
    if (msg->getKind() == SCTP_I_AVAILABLE) {
        const auto& connectInfo = tags.findTag<SctpAvailableReq>();
        assocId = connectInfo->getNewSocketId();
        localAddr = connectInfo->getLocalAddr();
        remoteAddr = connectInfo->getRemoteAddr();
        localPrt = connectInfo->getLocalPort();
        remotePrt = connectInfo->getRemotePort();
    }
    else 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.
 
        const auto& connectInfo = tags.findTag<SctpConnectReq>();
        localAddr = connectInfo->getLocalAddr();
        remoteAddr = connectInfo->getRemoteAddr();
        localPrt = connectInfo->getLocalPort();
        remotePrt = connectInfo->getRemotePort();
        fsmStatus = connectInfo->getStatus();
        appOptions->inboundStreams = connectInfo->getInboundStreams();
        appOptions->outboundStreams = connectInfo->getOutboundStreams();
    }
}

~SctpSocket()

inet::SctpSocket::~SctpSocket

(

)

Destructor.

{
    delete sOptions;
    delete appOptions;
    if (cb) {
        cb->socketDeleted(this);
    }
}

Member Function Documentation

abort()

void inet::SctpSocket::abort

(

)

Aborts the association.

{
    if (sockstate != NOT_BOUND && sockstate != CLOSED && sockstate != SOCKERROR) {
        Request *msg = new Request("ABORT", SCTP_C_ABORT);
        auto cmd = msg->addTag<SctpCommandReq>();
        cmd->setSocketId(assocId);
        sendToSctp(msg);
    }
    sockstate = CLOSED;
}

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

accept() [1/2]

void inet::SctpSocket::accept

(

int

socketId

)

accept() [2/2]

void inet::SctpSocket::accept	(	int32_t	assocId,
		int32_t	fd
	)

{
    Request *cmsg = new Request("Accept", SCTP_C_ACCEPT);
    auto cmd = cmsg->addTag<SctpCommandReq>();
    cmd->setLocalPort(localPrt);
    cmd->setRemoteAddr(remoteAddr);
    cmd->setRemotePort(remotePrt);
    cmd->setSocketId(assId);
    cmd->setFd(fd);
    sendToSctp(cmsg);
}

acceptSocket()

void inet::SctpSocket::acceptSocket

(

int

newSockId

)

{
    Request *cmsg = new Request("SCTP_C_ACCEPT_SOCKET_ID", SCTP_C_ACCEPT_SOCKET_ID);
    cmsg->addTag<SctpAvailableReq>()->setSocketId(newSockId);
    cmsg->addTag<DispatchProtocolReq>()->setProtocol(&Protocol::sctp);
    cmsg->addTag<SocketReq>()->setSocketId(newSockId);
    check_and_cast<cSimpleModule *>(gateToSctp->getOwnerModule())->send(cmsg, gateToSctp);
}

Referenced by processMessage().

addAddress()

void inet::SctpSocket::addAddress

(

L3Address

addr

)

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

belongsToSocket()

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

overridevirtual

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

Implements inet::ISocket.

{
    bool ret = (check_and_cast<Indication *>(msg)->getTag<SocketInd>()->getSocketId() == assocId);
    return ret;
}

bind() [1/2]

void inet::SctpSocket::bind

(

int

localPort

)

Bind the socket to a local port number.

{
    if (sockstate != NOT_BOUND)
        throw cRuntimeError("SctpSocket::bind(): socket already bound");
 
    localAddresses.push_back(L3Address()); // Unspecified address
    localPrt = lPort;
    sockstate = CLOSED;
    getSocketOptions();
}

Referenced by connect(), inet::NetPerfMeter::createAndBindSocket(), inet::SctpClient::initialize(), inet::SctpServer::initialize(), and inet::SctpPeer::initialize().

bind() [2/2]

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

bindx()

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

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

Referenced by inet::SctpClient::initialize(), inet::SctpServer::initialize(), and inet::SctpPeer::initialize().

close() [1/2]

virtual void inet::SctpSocket::close ( )

inlineoverridevirtual

Close the socket.

Implements inet::ISocket.

{ close(-1); }

Referenced by close().

close() [2/2]

void inet::SctpSocket::close

(

int

id

)

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)

{
    EV_INFO << "SctpSocket::close()\n";
 
    Request *msg = new Request("CLOSE", SCTP_C_CLOSE);
    auto cmd = msg->addTag<SctpCommandReq>();
    if (id == -1)
        cmd->setSocketId(assocId);
    else
        cmd->setFd(id);
    sendToSctp(msg);
    sockstate = (sockstate == CONNECTED) ? LOCALLY_CLOSED : CLOSED;
}

Referenced by inet::SctpClient::close(), inet::SctpClient::handleTimer(), inet::NetPerfMeter::handleTimer(), inet::SctpPeer::socketDataArrived(), inet::SctpPeer::socketPeerClosed(), and inet::NetPerfMeter::teardownConnection().

connect() [1/2]

void inet::SctpSocket::connect	(	int32_t	fd,
		L3Address	remoteAddress,
		int32_t	remotePort,
		uint32_t	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;
 
    Request *cmsg = new Request("Associate", SCTP_C_ASSOCIATE);
    auto openCmd = cmsg->addTag<SctpOpenReq>();
    if (oneToOne)
        openCmd->setSocketId(assocId);
    else
        openCmd->setSocketId(getNewAssocId());
    EV_INFO << "Socket connect. Assoc=" << openCmd->getSocketId() << ", 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);
 
    if (options) {
        cmsg->setContextPointer((void *)sOptions);
    }
    sendToSctp(cmsg);
 
    if (oneToOne)
        sockstate = CONNECTING;
}

connect() [2/2]

void inet::SctpSocket::connect	(	L3Address	remoteAddress,
		int32_t	remotePort,
		bool	streamReset = false,
		int32_t	prMethod = 0,
		uint32_t	numRequests = 0
	)

Active OPEN to the given remote socket.

{
    EV_INFO << "Socket connect. Assoc=" << assocId << ", sockstate=" << stateName(sockstate) << "\n";
 
    if (oneToOne && sockstate == NOT_BOUND) {
        EV_INFO << "Connect: call bind first\n";
        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;
 
    Request *cmsg = new Request("Associate", SCTP_C_ASSOCIATE);
    auto openCmd = cmsg->addTag<SctpOpenReq>();
 
    if (oneToOne)
        openCmd->setSocketId(assocId);
    else
        openCmd->setSocketId(getNewAssocId());
    EV_INFO << "Socket connect. Assoc=" << openCmd->getSocketId() << ", 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);
 
    sendToSctp(cmsg);
 
    if (oneToOne)
        sockstate = CONNECTING;
}

Referenced by inet::SctpClient::connect(), inet::SctpPeer::connect(), and connectx().

connectx()

void inet::SctpSocket::connectx	(	AddressVector	remoteAddresses,
		int32_t	remotePort,
		bool	streamReset = false,
		int32_t	prMethod = 0,
		uint32_t	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.

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

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

destroy()

void inet::SctpSocket::destroy ( )

overridevirtual

Notify the protocol that the owner of ISocket has destroyed the socket.

Typically used when the owner of ISocket has crashed.

Implements inet::ISocket.

{
    EV << "SctpSocket::destroy()\n";
 
    Request *msg = new Request("DESTROY", SCTP_C_DESTROY);
    auto cmd = msg->addTag<SctpCommandReq>();
    cmd->setSocketId(assocId);
    sendToSctp(msg);
}

getAssocMaxRtx()

int inet::SctpSocket::getAssocMaxRtx ( )

inline

{ return sOptions->assocMaxRtx; };

getFragPoint()

int inet::SctpSocket::getFragPoint ( )

inline

{ return sOptions->fragPoint; };

getInboundStreams()

int inet::SctpSocket::getInboundStreams ( )

inline

{ return appOptions->inboundStreams; };

getLastStream()

int inet::SctpSocket::getLastStream ( )

inline

{ return lastStream; };

getLocalAddresses()

AddressVector inet::SctpSocket::getLocalAddresses ( ) const

inline

{ return localAddresses; }

getLocalPort()

int inet::SctpSocket::getLocalPort ( ) const

inline

{ return localPrt; }

getMaxBurst()

int inet::SctpSocket::getMaxBurst ( )

inline

{ return sOptions->maxBurst; };

getMaxInitRetrans()

int inet::SctpSocket::getMaxInitRetrans ( )

inline

{ return sOptions->maxInitRetrans; };

getMaxInitRetransTimeout()

int inet::SctpSocket::getMaxInitRetransTimeout ( )

inline

{ return sOptions->maxInitRetransTimeout; };

getNewAssocId()

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

{ return getEnvir()->getUniqueNumber(); }

Referenced by inet::sctp::Sctp::addForkedAssociation(), connect(), listen(), and SctpSocket().

getOutboundStreams()

int inet::SctpSocket::getOutboundStreams ( )

inline

{ return appOptions->outboundStreams; };

getRemoteAddr()

L3Address inet::SctpSocket::getRemoteAddr ( ) const

inline

{ return remoteAddr; }

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

getRemoteAddresses()

AddressVector inet::SctpSocket::getRemoteAddresses ( ) const

inline

{ return remoteAddresses; }

getRemotePort()

int inet::SctpSocket::getRemotePort ( ) const

inline

{ return remotePrt; }

getRtoInitial()

double inet::SctpSocket::getRtoInitial ( )

inline

{ return sOptions->rtoInitial; };

getSocketId()

int inet::SctpSocket::getSocketId ( ) const

inlineoverridevirtual

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

Implements inet::ISocket.

{ return assocId; }

Referenced by belongsToSocket(), inet::SctpPeer::connect(), processMessage(), SctpSocket(), inet::SctpClient::sendQueueRequest(), inet::SctpPeer::sendQueueRequest(), inet::SctpClient::sendStreamResetNotification(), inet::SctpClient::setPrimaryPath(), inet::SctpClient::shutdownReceivedArrived(), inet::SctpPeer::shutdownReceivedArrived(), and inet::SctpNatPeer::shutdownReceivedArrived().

getSocketOptions()

void inet::SctpSocket::getSocketOptions

(

)

{
    EV_INFO << "getSocketOptions\n";
    Request *cmsg = new Request("GetSocketOptions", SCTP_C_GETSOCKETOPTIONS);
    auto sctpSendReq = cmsg->addTag<SctpSendReq>();
    sctpSendReq->setSocketId(assocId);
    sctpSendReq->setSid(0);
    sendToSctp(cmsg);
}

Referenced by bind(), and bindx().

getState()

int inet::SctpSocket::getState ( ) const

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.

{ return sockstate; }

Referenced by inet::SctpPeer::handleMessage(), inet::SctpClient::refreshDisplay(), inet::SctpClient::socketPeerClosed(), and inet::SctpPeer::socketPeerClosed().

getStreamReset()

bool inet::SctpSocket::getStreamReset ( )

inline

{ return appOptions->streamReset; }

getTunInterface()

int inet::SctpSocket::getTunInterface ( )

inline

{ return interfaceIdToTun; };

getUserData()

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

inline

{ return userData; }

isOpen()

bool inet::SctpSocket::isOpen ( ) const

overridevirtual

Implements inet::ISocket.

{
    switch (sockstate) {
        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 SctpSocket state: %d", sockstate);
    }
}

listen() [1/2]

void inet::SctpSocket::listen	(	bool	fork = true,
		bool	streamReset = false,
		uint32_t	requests = 0,
		uint32_t	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.

{
    if (sockstate != CLOSED)
        throw cRuntimeError(sockstate == NOT_BOUND ?
                "SctpSocket::listen(): must call bind() before listen()" :
                "SctpSocket::listen(): connect() or listen() already called");
 
    Request *cmsg = new Request("PassiveOPEN", SCTP_C_OPEN_PASSIVE);
    auto openCmd = cmsg->addTag<SctpOpenReq>();
    openCmd->setLocalAddresses(localAddresses);
    openCmd->setLocalPort(localPrt);
    if (oneToOne)
        openCmd->setSocketId(assocId);
    else
        openCmd->setSocketId(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->getSocketId() << ": PassiveOPEN to SCTP from SctpSocket:listen()\n";
    sendToSctp(cmsg);
    sockstate = LISTENING;
}

Referenced by inet::NetPerfMeter::createAndBindSocket(), inet::SctpServer::initialize(), and inet::SctpPeer::initialize().

listen() [2/2]

void inet::SctpSocket::listen	(	uint32_t	requests = 0,
		bool	fork = false,
		uint32_t	messagesToPush = 0,
		bool	options = false,
		int32_t	fd = -1
	)

{
    if (sockstate != CLOSED)
        throw cRuntimeError(sockstate == NOT_BOUND ?
                "SctpSocket::listen(): must call bind() before listen()" :
                "SctpSocket::listen(): connect() or listen() already called");
 
    Request *cmsg = new Request("PassiveOPEN", SCTP_C_OPEN_PASSIVE);
    auto openCmd = cmsg->addTag<SctpOpenReq>();
    openCmd->setLocalAddresses(localAddresses);
    openCmd->setLocalPort(localPrt);
    if (oneToOne)
        openCmd->setSocketId(assocId);
    else
        openCmd->setSocketId(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->getSocketId() << ": PassiveOPEN to SCTP from SctpSocket:listen2()\n";
    if (options)
        cmsg->setContextPointer((void *)sOptions);
    sendToSctp(cmsg);
    sockstate = LISTENING;
}

processMessage()

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

overridevirtual

Examines the message (which should have arrived from SctpMain), updates socket state, and if there is a callback object installed (see setCallback(), class CallbackInterface), 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 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!

Implements inet::ISocket.

{
    switch (msg->getKind()) {
        case SCTP_I_DATA:
            EV_INFO << "SCTP_I_DATA\n";
            if (cb) {
                cb->socketDataArrived(this, check_and_cast<Packet *>(msg), false);
                msg = nullptr;
            }
            break;
 
        case SCTP_I_DATA_NOTIFICATION:
            EV_INFO << "SCTP_I_NOTIFICATION\n";
            if (cb) {
                cb->socketDataNotificationArrived(this, check_and_cast<Message *>(msg));
            }
            break;
 
        case SCTP_I_SEND_MSG:
            if (cb) {
                cb->sendRequestArrived(this);
            }
            break;
 
        case SCTP_I_AVAILABLE: {
            auto indication = check_and_cast<Indication *>(msg);
            if (cb)
                cb->socketAvailable(this, indication);
            else {
                int newSocketId = indication->getTag<SctpAvailableReq>()->getNewSocketId();
                acceptSocket(newSocketId);
            }
            delete msg;
            break;
        }
 
        case SCTP_I_ESTABLISHED: {
            EV_INFO << "SCTP_I_ESTABLISHED\n";
            if (oneToOne)
                sockstate = CONNECTED;
            auto indication = check_and_cast<Indication *>(msg);
            auto connectInfo = indication->getTag<SctpConnectReq>();
            localAddr = connectInfo->getLocalAddr();
            remoteAddr = connectInfo->getRemoteAddr();
            localPrt = connectInfo->getLocalPort();
            remotePrt = connectInfo->getRemotePort();
            fsmStatus = connectInfo->getStatus();
            appOptions->inboundStreams = connectInfo->getInboundStreams();
            appOptions->outboundStreams = connectInfo->getOutboundStreams();
            assocId = indication->getTag<SocketInd>()->getSocketId();
 
            if (cb) {
                cb->socketEstablished(this, connectInfo->getNumMsgs());
            }
            delete msg;
            break;
        }
 
        case SCTP_I_PEER_CLOSED:
            EV_INFO << "peer closed\n";
            if (oneToOne)
                sockstate = (sockstate == CONNECTED) ? PEER_CLOSED : CLOSED;
 
            if (cb) {
                cb->socketPeerClosed(this);
            }
            delete msg;
            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(this);
            }
            delete msg;
            break;
 
        case SCTP_I_CONNECTION_REFUSED:
        case SCTP_I_CONNECTION_RESET:
        case SCTP_I_TIMED_OUT:
            sockstate = SOCKERROR;
            if (cb) {
                cb->socketFailure(this, msg->getKind());
            }
            break;
 
        case SCTP_I_STATUS: {
            auto *message = check_and_cast<Indication *>(msg);
            auto status = message->getTagForUpdate<SctpStatusReq>();
            if (cb) {
                cb->socketStatusArrived(this, status.get());
            }
            break;
        }
 
        case SCTP_I_ABANDONED:
            if (cb) {
                cb->msgAbandonedArrived(this);
            }
            delete msg;
            break;
 
        case SCTP_I_SHUTDOWN_RECEIVED:
            EV_INFO << "SCTP_I_SHUTDOWN_RECEIVED\n";
            if (cb) {
                cb->shutdownReceivedArrived(this);
            }
            delete msg;
            break;
 
        case SCTP_I_SENDQUEUE_FULL:
            if (cb) {
                cb->sendqueueFullArrived(this);
            }
            break;
 
        case SCTP_I_SENDQUEUE_ABATED: {
            auto& tags = check_and_cast<ITaggedObject *>(msg)->getTags();
            auto cmd = tags.getTag<SctpCommandReq>();
            if (cb) {
                cb->sendqueueAbatedArrived(this, cmd->getNumMsgs());
            }
            break;
        }
 
        case SCTP_I_RCV_STREAMS_RESETTED:
        case SCTP_I_SEND_STREAMS_RESETTED:
        case SCTP_I_RESET_REQUEST_FAILED:
            delete msg;
            break;
        case SCTP_I_SENDSOCKETOPTIONS: {
            auto *indication = check_and_cast<Indication *>(msg);
            if (cb)
                cb->socketOptionsArrived(this, indication);
            else
                delete indication;
            break;
        }
 
        case SCTP_I_ADDRESS_ADDED: {
            EV_INFO << "SCTP_I_ADDRESS_ADDED\n";
            auto& tags = check_and_cast<ITaggedObject *>(msg)->getTags();
            auto cmd = tags.getTag<SctpCommandReq>();
            if (cb) {
                cb->addressAddedArrived(this, 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());
        }
    }
}

Referenced by inet::SctpClient::handleMessage(), and inet::SctpPeer::handleMessage().

requestStatus()

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.

{
    Request *msg = new Request("STATUS", SCTP_C_STATUS);
    auto cmd = msg->addTag<SctpCommandReq>();
    cmd->setSocketId(assocId);
    sendToSctp(msg);
}

send()

void inet::SctpSocket::send ( Packet *  packet )

overridevirtual

Send data message.

Implements inet::ISocket.

{
    auto sendReq = packet->findTagForUpdate<SctpSendReq>();
    if (sendReq) {
        if (sendReq->getSid() == -1) {
            lastStream = (lastStream + 1) % appOptions->outboundStreams;
            sendReq->setSid(lastStream);
        }
        if (sendReq->getSocketId() == -1) {
            sendReq->setSocketId(assocId);
        }
    }
    else {
        auto sctpReq = packet->addTagIfAbsent<SctpSendReq>();
        sctpReq->setSocketId(assocId);
        lastStream = (lastStream + 1) % appOptions->outboundStreams;
        sctpReq->setSid(lastStream);
    }
    packet->setKind(SCTP_C_SEND);
    sendToSctp(packet);
}

Referenced by inet::SctpClient::sendRequest(), inet::SctpPeer::sendRequest(), inet::SctpClient::socketDataArrived(), and inet::SctpPeer::socketDataArrived().

sendNotification()

void inet::SctpSocket::sendNotification

(

cMessage *

msg

)

Send notification.

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

Referenced by inet::SctpClient::sendStreamResetNotification(), inet::SctpClient::setPrimaryPath(), inet::SctpClient::shutdownReceivedArrived(), inet::SctpPeer::shutdownReceivedArrived(), inet::SctpClient::socketDataNotificationArrived(), and inet::SctpPeer::socketDataNotificationArrived().

sendRequest()

void inet::SctpSocket::sendRequest

(

cMessage *

msg

)

Send request.

{
    sendToSctp(msg);
}

Referenced by inet::SctpClient::sendQueueRequest(), inet::SctpPeer::sendQueueRequest(), and inet::NetPerfMeter::sendSCTPQueueRequest().

sendToSctp()

void inet::SctpSocket::sendToSctp ( cMessage *  msg )

protected

{
    if (!gateToSctp)
        throw cRuntimeError("SctpSocket::sendToSctp(): setOutputGate() must be invoked before socket can be used");
    EV_INFO << "sendToSctp SocketId is set to " << assocId << endl;
    auto& tags = check_and_cast<ITaggedObject *>(msg)->getTags();
    tags.addTagIfAbsent<DispatchProtocolReq>()->setProtocol(&Protocol::sctp);
    tags.addTagIfAbsent<SocketReq>()->setSocketId(assocId == -1 ? this->assocId : assocId);
    if (interfaceIdToTun != -1) {
        tags.addTagIfAbsent<InterfaceReq>()->setInterfaceId(interfaceIdToTun);
    }
    check_and_cast<cSimpleModule *>(gateToSctp->getOwnerModule())->send(msg, gateToSctp);
}

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

setAppLimited()

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

inline

{ appLimited = option; }

setAssocMaxRtx()

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

inline

{ sOptions->assocMaxRtx = option; }

setCallback()

void inet::SctpSocket::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 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.

{
    cb = callback;
}

Referenced by inet::SctpClient::initialize(), and inet::SctpPeer::initialize().

setEnableHeartbeats()

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

inline

{ sOptions->enableHeartbeats = option; }

setFragPoint()

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

inline

{ sOptions->fragPoint = option; }

setHbInterval()

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

inline

{ sOptions->hbInterval = option; }

setInboundStreams()

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

inline

{ appOptions->inboundStreams = streams; }

Referenced by inet::SctpClient::connect(), inet::NetPerfMeter::createAndBindSocket(), inet::SctpServer::initialize(), and inet::SctpPeer::initialize().

setMaxBurst()

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

inline

{ sOptions->maxBurst = option; }

setMaxInitRetrans()

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

inline

{ sOptions->maxInitRetrans = option; }

setMaxInitRetransTimeout()

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

inline

{ sOptions->maxInitRetransTimeout = option; }

setNagle()

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

inline

{ sOptions->nagle = option; }

setOutboundStreams()

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

inline

Setter and getter methods for socket and API Parameters.

{ appOptions->outboundStreams = streams; }

Referenced by inet::SctpClient::connect(), inet::SctpPeer::connect(), inet::NetPerfMeter::createAndBindSocket(), inet::SctpServer::initialize(), and inet::SctpPeer::initialize().

setOutputGate()

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

{ gateToSctp = toSctp; }

Referenced by inet::NetPerfMeter::createAndBindSocket(), inet::SctpClient::initialize(), inet::SctpServer::initialize(), inet::SctpPeer::initialize(), and inet::NetPerfMeter::successfullyEstablishedConnection().

setPathMaxRetrans()

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

inline

{ sOptions->pathMaxRetrans = option; }

setRtoInfo()

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

{
    sOptions->rtoInitial = initial;
    sOptions->rtoMax = max;
    sOptions->rtoMin = min;
    if (sockstate == CONNECTED) {
        Request *msg = new Request("RtoInfo", SCTP_C_SET_RTO_INFO);
        auto cmd = msg->addTag<SctpRtoReq>();
        cmd->setSocketId(assocId);
        cmd->setRtoInitial(initial);
        cmd->setRtoMin(min);
        cmd->setRtoMax(max);
        sendToSctp(msg);
    }
}

setRtoInitial()

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

inline

{ sOptions->rtoInitial = option; }

setRtoMax()

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

inline

{ sOptions->rtoMax = option; }

setRtoMin()

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

inline

{ sOptions->rtoMin = option; }

setSackFrequency()

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

inline

{ sOptions->sackFrequency = option; }

setSackPeriod()

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

inline

{ sOptions->sackPeriod = option; }

setState()

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

inline

{ sockstate = state; }

setStreamPriority()

void inet::SctpSocket::setStreamPriority	(	uint32_t	stream,
		uint32_t	priority
	)

{
    Request *msg = new Request("SET_STREAM_PRIO", SCTP_C_SET_STREAM_PRIO);
    auto cmd = msg->addTag<SctpSendReq>();
    cmd->setSocketId(assocId);
    cmd->setSid(stream);
    cmd->setPpid(priority);
    sendToSctp(msg);
}

Referenced by inet::SctpPeer::connect(), and inet::SctpServer::initialize().

setStreamReset()

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

inline

{ appOptions->streamReset = option; }

setTunInterface()

void inet::SctpSocket::setTunInterface ( int  id )

inline

{ interfaceIdToTun = id; }

setUserData()

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

inline

{ this->userData = userData; }

setUserOptions()

void inet::SctpSocket::setUserOptions ( SocketOptions *  msg )

inline

{ delete sOptions; sOptions = msg; }

shutdown()

void inet::SctpSocket::shutdown

(

int

id = -1

)

{
    EV << "SctpSocket::shutdown()\n";
 
    Request *msg = new Request("SHUTDOWN", SCTP_C_SHUTDOWN);
    auto cmd = msg->addTag<SctpCommandReq>();
    if (id == -1)
        cmd->setSocketId(assocId);
    else
        cmd->setFd(id);
    sendToSctp(msg);
}

Referenced by inet::SctpClient::handleTimer(), inet::SctpClient::sendqueueAbatedArrived(), inet::SctpClient::sendRequestArrived(), inet::SctpPeer::sendRequestArrived(), inet::SctpClient::socketEstablished(), and inet::SctpPeer::socketEstablished().

stateName()

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

static

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

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

Referenced by connect(), connectx(), inet::SctpClient::refreshDisplay(), and SctpSocket().

Member Data Documentation

appLimited

bool inet::SctpSocket::appLimited

protected

Referenced by connect(), and SctpSocket().

appOptions

AppSocketOptions* inet::SctpSocket::appOptions

protected

Referenced by connect(), listen(), processMessage(), SctpSocket(), send(), and ~SctpSocket().

assocId

int inet::SctpSocket::assocId

protected

Referenced by abort(), belongsToSocket(), close(), connect(), destroy(), getSocketOptions(), listen(), processMessage(), requestStatus(), SctpSocket(), send(), sendToSctp(), setRtoInfo(), setStreamPriority(), and shutdown().

cb

ICallback* inet::SctpSocket::cb

protected

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

fsmStatus

int inet::SctpSocket::fsmStatus

protected

Referenced by processMessage(), and SctpSocket().

gateToSctp

cGate* inet::SctpSocket::gateToSctp

Referenced by acceptSocket(), SctpSocket(), and sendToSctp().

interfaceIdToTun

int inet::SctpSocket::interfaceIdToTun = -1

Referenced by sendToSctp().

lastStream

int inet::SctpSocket::lastStream

protected

Referenced by SctpSocket(), and send().

localAddr

L3Address inet::SctpSocket::localAddr

protected

Referenced by processMessage(), and SctpSocket().

localAddresses

AddressVector inet::SctpSocket::localAddresses

protected

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

localPrt

int inet::SctpSocket::localPrt

protected

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

nextAssocId

int32_t inet::SctpSocket::nextAssocId = 0

staticprotected

oneToOne

bool inet::SctpSocket::oneToOne

protected

Referenced by connect(), listen(), processMessage(), SctpSocket(), and sendNotification().

remoteAddr

L3Address inet::SctpSocket::remoteAddr

protected

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

remoteAddresses

AddressVector inet::SctpSocket::remoteAddresses

protected

Referenced by connectx().

remotePrt

int inet::SctpSocket::remotePrt

protected

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

sockstate

int inet::SctpSocket::sockstate

protected

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

sOptions

SocketOptions* inet::SctpSocket::sOptions

protected

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

userData

void* inet::SctpSocket::userData

protected

Referenced by SctpSocket().

---

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

• SctpSocket.h
• SctpSocket.cc