inet::SCTPClient Class Reference

Implements the SCTPClient simple module. More...

#include <SCTPClient.h>

Inheritance diagram for inet::SCTPClient:

Classes
struct	PathStatus

Public Member Functions
	SCTPClient ()
virtual	~SCTPClient ()
Public Member Functions inherited from inet::SCTPSocket::CallbackInterface
virtual	~CallbackInterface ()
virtual void	socketDeleted (int assocId, void *yourPtr)
virtual void	sendqueueFullArrived (int connId)
virtual void	addressAddedArrived (int assocId, L3Address localAddr, L3Address remoteAddr)
Public Member Functions inherited from inet::ILifecycle
virtual	~ILifecycle ()

Protected Types
typedef std::map< L3Address, PathStatus >	SCTPPathStatus

Protected Member Functions
virtual int	numInitStages () const override
virtual void	initialize (int stage) override
virtual void	handleMessage (cMessage *msg) override
virtual void	finish () override
virtual void	refreshDisplay () const override
void	connect ()
void	close ()
void	handleTimer (cMessage *msg)
void	socketEstablished (int connId, void *yourPtr, unsigned long int buffer) override
void	socketDataArrived (int connId, void *yourPtr, cPacket *msg, bool urgent) override
void	socketDataNotificationArrived (int connId, void *yourPtr, cPacket *msg) override
void	socketPeerClosed (int connId, void *yourPtr) override
void	socketClosed (int connId, void *yourPtr) override
void	socketFailure (int connId, void *yourPtr, int code) override
void	socketStatusArrived (int connId, void *yourPtr, SCTPStatusInfo *status) override
void	setPrimaryPath (const char *addr)
void	sendRequestArrived () override
void	sendQueueRequest ()
void	shutdownReceivedArrived (int connId) override
void	sendqueueAbatedArrived (int connId, unsigned long int buffer) override
void	msgAbandonedArrived (int assocId) override
void	sendStreamResetNotification ()
void	sendRequest (bool last=true)
virtual bool	handleOperationStage (LifecycleOperation *operation, int stage, IDoneCallback *doneCallback) override
	Perform one stage of a lifecycle operation. More...

Protected Attributes
std::map< unsigned int, unsigned int >	streamRequestLengthMap
std::map< unsigned int, unsigned int >	streamRequestRatioMap
std::map< unsigned int, unsigned int >	streamRequestRatioSendMap
int	queueSize
unsigned int	outStreams
unsigned int	inStreams
bool	echo
bool	ordered
bool	finishEndsSimulation
SCTPSocket	socket
SCTPPathStatus	sctpPathStatus
cMessage *	timeMsg
cMessage *	stopTimer
cMessage *	primaryChangeTimer
int64	bufferSize
bool	timer
bool	sendAllowed
const char *	stateNameStr
unsigned long int	packetsSent
unsigned long int	packetsRcvd
unsigned long int	bytesSent
unsigned long int	echoedBytesSent
unsigned long int	bytesRcvd
unsigned long int	numRequestsToSend
unsigned long int	numPacketsToReceive
int	numSessions
int	numBroken
int	chunksAbandoned

Static Protected Attributes
static simsignal_t	sentPkSignal = registerSignal("sentPk")
static simsignal_t	rcvdPkSignal = registerSignal("rcvdPk")
static simsignal_t	echoedPkSignal = registerSignal("echoedPk")

Detailed Description

Implements the SCTPClient simple module.

See the NED file for more info.

Member Typedef Documentation

typedef std::map<L3Address, PathStatus> inet::SCTPClient::SCTPPathStatus

protected

Constructor & Destructor Documentation

inet::SCTPClient::SCTPClient

(

)

{
    timeMsg = nullptr;
    stopTimer = nullptr;
    primaryChangeTimer = nullptr;
    numSessions = 0;
    numBroken = 0;
    packetsSent = 0;
    packetsRcvd = 0;
    bytesSent = 0;
    echoedBytesSent = 0;
    bytesRcvd = 0;
    queueSize = 0;
    outStreams = 1;
    inStreams = 17;
    echo = false;
    ordered = true;
    finishEndsSimulation = false;
    bufferSize = 0;
    timer = false;
    sendAllowed = true;
    numRequestsToSend = 0;    // requests to send in this session
    numPacketsToReceive = 0;
    chunksAbandoned = 0;
    stateNameStr = "unknown";
}

inet::SCTPClient::~SCTPClient ( )

virtual

{
    cancelAndDelete(timeMsg);
    cancelAndDelete(stopTimer);
    cancelAndDelete(primaryChangeTimer);
}

Member Function Documentation

void inet::SCTPClient::close ( )

protected

Referenced by handleTimer(), socketDataArrived(), and socketPeerClosed().

{
    stateNameStr = "closing";
    socket.close();
}

void inet::SCTPClient::connect ( )

protected

Referenced by handleTimer().

{
    const char *connectAddress = par("connectAddress");
    int connectPort = par("connectPort");
    inStreams = par("inboundStreams");
    outStreams = par("outboundStreams");
    socket.setInboundStreams(inStreams);
    socket.setOutboundStreams(outStreams);
    stateNameStr = "connecting";
    EV_INFO << "issuing OPEN command, connect to address " << connectAddress << "\n";
    bool streamReset = par("streamReset");
    L3Address destination;
    L3AddressResolver().tryResolve(connectAddress, destination);
    if (destination.isUnspecified())
        EV << "cannot resolve destination address: " << connectAddress << endl;
    else {
        socket.connect(destination, connectPort, streamReset, (int)par("prMethod"), (unsigned int)par("numRequestsPerSession"));
    }

    if (streamReset) {
        cMessage *cmsg = new cMessage("StreamReset");
        cmsg->setKind(MSGKIND_RESET);
        EV_INFO << "StreamReset Timer scheduled at " << simTime() << "\n";
        scheduleAt(simTime() + par("streamRequestTime"), cmsg);
    }

    for (unsigned int i = 0; i < outStreams; i++) {
        streamRequestLengthMap[i] = par("requestLength");
        streamRequestRatioMap[i] = 1;
        streamRequestRatioSendMap[i] = 1;
    }

    unsigned int streamNum = 0;
    cStringTokenizer ratioTokenizer(par("streamRequestRatio").stringValue());
    while (ratioTokenizer.hasMoreTokens()) {
        const char *token = ratioTokenizer.nextToken();
        streamRequestRatioMap[streamNum] = atoi(token);
        streamRequestRatioSendMap[streamNum] = atoi(token);

        streamNum++;
    }

    numSessions++;
}

void inet::SCTPClient::finish ( )

overrideprotectedvirtual

{
    EV_INFO << getFullPath() << ": opened " << numSessions << " sessions\n";
    EV_INFO << getFullPath() << ": sent " << bytesSent << " bytes in " << packetsSent << " packets\n";
    EV_INFO << getFullPath() << ": received " << bytesRcvd << " bytes in " << packetsRcvd << " packets\n";
    EV_INFO << "Client finished\n";
}

void inet::SCTPClient::handleMessage ( cMessage *  msg )

overrideprotectedvirtual

{
    if (msg->isSelfMessage()) {
        handleTimer(msg);
    }
    else {
        socket.processMessage(msg);
    }
}

virtual bool inet::SCTPClient::handleOperationStage ( LifecycleOperation *  operation, int  stage, IDoneCallback *  doneCallback  )

inlineoverrideprotectedvirtual

Perform one stage of a lifecycle operation.

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

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

Implements inet::ILifecycle.

    { Enter_Method_Silent(); throw cRuntimeError("Unsupported lifecycle operation '%s'", operation->getClassName()); return true; }

void inet::SCTPClient::handleTimer ( cMessage *  msg )

protected

Referenced by handleMessage().

{
    switch (msg->getKind()) {
        case MSGKIND_CONNECT:
            EV_DEBUG << "starting session call connect\n";
            connect();
            break;

        case MSGKIND_SEND:
            if (((!timer && numRequestsToSend > 0) || timer)) {
                if (sendAllowed) {
                    sendRequest();
                    if (!timer)
                        numRequestsToSend--;
                }
                if (par("thinkTime").doubleValue() > 0)
                    scheduleAt(simTime() + par("thinkTime"), timeMsg);

                if ((!timer && numRequestsToSend == 0) && par("waitToClose").doubleValue() == 0) {
                    socket.shutdown();
                    if (timeMsg->isScheduled())
                        cancelEvent(timeMsg);

                    if (finishEndsSimulation) {
                        endSimulation();
                    }
                }
            }
            else if ((!timer && numRequestsToSend == 0) && par("waitToClose").doubleValue() == 0) {
                socket.shutdown();
                if (timeMsg->isScheduled())
                    cancelEvent(timeMsg);

                if (finishEndsSimulation) {
                    endSimulation();
                }
            }
            break;

        case MSGKIND_ABORT:
            close();
            break;

        case MSGKIND_PRIMARY:
            setPrimaryPath(par("newPrimary"));
            break;

        case MSGKIND_RESET:
            EV_INFO << "StreamReset Timer expired at Client at " << simTime() << "...send notification\n";
            sendStreamResetNotification();
            delete msg;
            break;

        case MSGKIND_STOP:
            numRequestsToSend = 0;
            sendAllowed = false;
            printf("time is over: send abort\n");
            socket.abort();

            if (timeMsg->isScheduled())
                cancelEvent(timeMsg);

            if (finishEndsSimulation) {
                endSimulation();
            }
            break;

        default:
            throw cRuntimeError("unknown selfmessage kind = %d ", msg->getKind());
            break;
    }
}

void inet::SCTPClient::initialize ( int  stage )

overrideprotectedvirtual

{
    cSimpleModule::initialize(stage);

    EV_DEBUG << "initialize SCTP Client stage " << stage << endl;
    if (stage == INITSTAGE_LOCAL) {
        echo = par("echo").boolValue();
        ordered = par("ordered").boolValue();
        finishEndsSimulation = par("finishEndsSimulation").boolValue();
        queueSize = par("queueSize");
        WATCH(numRequestsToSend);
        recordScalar("ums", (int)par("requestLength"));

        timeMsg = new cMessage("CliAppTimer");
        timeMsg->setKind(MSGKIND_CONNECT);
        scheduleAt(par("startTime"), timeMsg);

        stopTimer = nullptr;
        primaryChangeTimer = nullptr;

        WATCH(numSessions);
        WATCH(numBroken);
        WATCH(packetsSent);
        WATCH(packetsRcvd);
        WATCH(bytesSent);
        WATCH(bytesRcvd);
    }
    else if (stage == INITSTAGE_APPLICATION_LAYER) {
        NodeStatus *nodeStatus = dynamic_cast<NodeStatus *>(findContainingNode(this)->getSubmodule("status"));
        bool isOperational = (!nodeStatus) || nodeStatus->getState() == NodeStatus::UP;
        if (!isOperational)
            throw cRuntimeError("This module doesn't support starting in node DOWN state");

        // parameters
        const char *addressesString = par("localAddress");
        AddressVector addresses = L3AddressResolver().resolve(cStringTokenizer(addressesString).asVector());
        int port = par("localPort");
        socket.setOutputGate(gate("sctpOut"));
        if (addresses.size() == 0)
            socket.bind(port);
        else
            socket.bindx(addresses, port);

        socket.setCallbackObject(this);

        stateNameStr = "waiting";

        simtime_t stopTime = par("stopTime");
        if (stopTime >= SIMTIME_ZERO) {
            stopTimer = new cMessage("StopTimer");
            stopTimer->setKind(MSGKIND_STOP);
            scheduleAt(par("stopTime"), stopTimer);
            timer = true;
        }

        simtime_t primaryTime = par("primaryTime");
        if (primaryTime != SIMTIME_ZERO) {
            primaryChangeTimer = new cMessage("PrimaryTime");
            primaryChangeTimer->setKind(MSGKIND_PRIMARY);
            scheduleAt(primaryTime, primaryChangeTimer);
        }
    }
}

void inet::SCTPClient::msgAbandonedArrived ( int  assocId )

overrideprotectedvirtual

Reimplemented from inet::SCTPSocket::CallbackInterface.

{
    chunksAbandoned++;
}

virtual int inet::SCTPClient::numInitStages ( ) const

inlineoverrideprotectedvirtual

{ return NUM_INIT_STAGES; }

void inet::SCTPClient::refreshDisplay ( ) const

overrideprotectedvirtual

{
    getDisplayString().setTagArg("t", 0, stateNameStr);
}

void inet::SCTPClient::sendqueueAbatedArrived ( int  connId, unsigned long int  buffer  )

overrideprotectedvirtual

Reimplemented from inet::SCTPSocket::CallbackInterface.

{
    bufferSize = buffer;
    sendAllowed = true;

    while ((((!timer && numRequestsToSend > 0) || timer) && sendAllowed && bufferSize > 0) ||
           (((!timer && numRequestsToSend > 0) || timer) && sendAllowed && buffer == 0))
    {
        if (!timer && numRequestsToSend == 1)
            sendRequest(true);
        else
            sendRequest(false);

        if (!timer && (--numRequestsToSend == 0))
            sendAllowed = false;
    }

    if ((!timer && numRequestsToSend == 0) && par("waitToClose").doubleValue() == 0) {
        EV_INFO << "socketEstablished:no more packets to send, call shutdown\n";
        socket.shutdown();

        if (timeMsg->isScheduled())
            cancelEvent(timeMsg);

        if (finishEndsSimulation) {
            endSimulation();
        }
    }
}

void inet::SCTPClient::sendQueueRequest ( )

protected

Referenced by socketEstablished().

{
    cMessage *cmsg = new cMessage("SCTP_C_QUEUE_MSGS_LIMIT");
    SCTPInfo *qinfo = new SCTPInfo();
    qinfo->setText(queueSize);
    cmsg->setKind(SCTP_C_QUEUE_MSGS_LIMIT);
    qinfo->setAssocId(socket.getConnectionId());
    cmsg->setControlInfo(qinfo);
    EV_INFO << "Sending queue request ..." << endl;
    socket.sendRequest(cmsg);
}

void inet::SCTPClient::sendRequest ( bool  last = true )

protected

Referenced by handleTimer(), sendqueueAbatedArrived(), sendRequestArrived(), and socketEstablished().

{
    // find next stream
    unsigned int nextStream = 0;
    for (unsigned int i = 0; i < outStreams; i++) {
        if (streamRequestRatioSendMap[i] > streamRequestRatioSendMap[nextStream])
            nextStream = i;
    }

    // no stream left, reset map
    if (nextStream == 0 && streamRequestRatioSendMap[nextStream] == 0) {
        for (unsigned int i = 0; i < outStreams; i++) {
            streamRequestRatioSendMap[i] = streamRequestRatioMap[i];
            if (streamRequestRatioSendMap[i] > streamRequestRatioSendMap[nextStream])
                nextStream = i;
        }
    }

    if (nextStream == 0 && streamRequestRatioSendMap[nextStream] == 0) {
        throw cRuntimeError("Invalid setting of streamRequestRatio: only 0 weightings");
    }

    unsigned int sendBytes = streamRequestLengthMap[nextStream];
    streamRequestRatioSendMap[nextStream]--;

    if (sendBytes < 1)
        sendBytes = 1;

    cPacket *cmsg = new cPacket("SCTP_C_SEND");
    SCTPSimpleMessage *msg = new SCTPSimpleMessage("data");

    msg->setDataArraySize(sendBytes);

    for (unsigned int i = 0; i < sendBytes; i++)
        msg->setData(i, 'a');

    msg->setDataLen(sendBytes);
    msg->setEncaps(false);
    msg->setByteLength(sendBytes);
    msg->setCreationTime(simTime());
    cmsg->encapsulate(msg);
    cmsg->setKind(ordered ? SCTP_C_SEND_ORDERED : SCTP_C_SEND_UNORDERED);

    // send SCTPMessage with SCTPSimpleMessage enclosed
    EV_INFO << "Sending request ..." << endl;
    bufferSize -= sendBytes;

    if (bufferSize < 0)
        last = true;

    SCTPSendInfo* sendCommand = new SCTPSendInfo;
    sendCommand->setLast(last);
    sendCommand->setPrMethod(par("prMethod"));
    sendCommand->setPrValue(par("prValue"));
    sendCommand->setSid(nextStream);
    cmsg->setControlInfo(sendCommand);

    emit(sentPkSignal, msg);
    socket.sendMsg(cmsg);
    bytesSent += sendBytes;
}

void inet::SCTPClient::sendRequestArrived ( )

overrideprotectedvirtual

Reimplemented from inet::SCTPSocket::CallbackInterface.

{
    int count = 0;

    EV_INFO << "sendRequestArrived numRequestsToSend=" << numRequestsToSend << "\n";

    while (((!timer && numRequestsToSend > 0) || timer) && count++ < queueSize && sendAllowed) {
        sendRequest(count == queueSize);

        if (!timer)
            numRequestsToSend--;

        if ((!timer && numRequestsToSend == 0)) {
            EV_INFO << "no more packets to send, call shutdown\n";
            socket.shutdown();

            if (timeMsg->isScheduled())
                cancelEvent(timeMsg);

            if (finishEndsSimulation)
                endSimulation();
        }
    }
}

void inet::SCTPClient::sendStreamResetNotification ( )

protected

Referenced by handleTimer().

{
    unsigned int type = par("streamResetType");
    if (type >= 6 && type <= 9) {
        cMessage *cmsg = new cMessage("SCTP_C_STREAM_RESET");
        SCTPResetInfo *rinfo = new SCTPResetInfo();
        rinfo->setAssocId(socket.getConnectionId());
        rinfo->setRemoteAddr(socket.getRemoteAddr());
        rinfo->setRequestType((unsigned short int)type);
        cmsg->setKind(SCTP_C_STREAM_RESET);
        cmsg->setControlInfo(rinfo);
        socket.sendNotification(cmsg);
    }
}

void inet::SCTPClient::setPrimaryPath ( const char *  addr )

protected

Referenced by handleTimer().

{
    cMessage *cmsg = new cMessage("SCTP_C_PRIMARY");
    SCTPPathInfo *pinfo = new SCTPPathInfo();

    if (strcmp(str, "") != 0) {
        pinfo->setRemoteAddress(L3Address(str));
    }
    else {
        str = par("newPrimary");
        if (strcmp(str, "") != 0)
            pinfo->setRemoteAddress(L3Address(str));
        else {
            str = par("connectAddress");
            pinfo->setRemoteAddress(L3Address(str));
        }
    }

    pinfo->setAssocId(socket.getConnectionId());
    cmsg->setKind(SCTP_C_PRIMARY);
    cmsg->setControlInfo(pinfo);
    socket.sendNotification(cmsg);
}

void inet::SCTPClient::shutdownReceivedArrived ( int  connId )

overrideprotectedvirtual

Reimplemented from inet::SCTPSocket::CallbackInterface.

{
    if (numRequestsToSend == 0) {
        cMessage *cmsg = new cMessage("SCTP_C_NO_OUTSTANDING");
        SCTPInfo *qinfo = new SCTPInfo();
        cmsg->setKind(SCTP_C_NO_OUTSTANDING);
        qinfo->setAssocId(connId);
        cmsg->setControlInfo(qinfo);
        socket.sendNotification(cmsg);
    }
}

void inet::SCTPClient::socketClosed ( int  connId, void *  yourPtr  )

overrideprotectedvirtual

Reimplemented from inet::SCTPSocket::CallbackInterface.

{
    // *redefine* to start another session etc.
    EV_INFO << "connection closed\n";
    stateNameStr = "closed";

    if (primaryChangeTimer) {
        cancelEvent(primaryChangeTimer);
        delete primaryChangeTimer;
        primaryChangeTimer = nullptr;
    }
}

void inet::SCTPClient::socketDataArrived ( int  connId, void *  yourPtr, cPacket *  msg, bool  urgent  )

overrideprotectedvirtual

Implements inet::SCTPSocket::CallbackInterface.

{
    packetsRcvd++;

    EV_INFO << "Client received packet Nr " << packetsRcvd << " from SCTP\n";
    SCTPCommand *ind = check_and_cast<SCTPCommand *>(msg->removeControlInfo());
    emit(rcvdPkSignal, msg);
    bytesRcvd += msg->getByteLength();

    if (echo) {
        SCTPSimpleMessage *smsg = check_and_cast<SCTPSimpleMessage *>(msg);
        cPacket *cmsg = new cPacket("SCTP_C_SEND");
        echoedBytesSent += smsg->getByteLength();
        emit(echoedPkSignal, smsg);
        cmsg->encapsulate(smsg);
        cmsg->setKind(ind->getSendUnordered() ? SCTP_C_SEND_UNORDERED : SCTP_C_SEND_ORDERED);
        packetsSent++;
        socket.sendMsg(cmsg);
    }

    if (par("numPacketsToReceive").longValue() > 0) {
        numPacketsToReceive--;
        if (numPacketsToReceive == 0)
            close();
    }

    delete ind;
}

void inet::SCTPClient::socketDataNotificationArrived ( int  connId, void *  yourPtr, cPacket *  msg  )

overrideprotectedvirtual

Implements inet::SCTPSocket::CallbackInterface.

{
    SCTPCommand *ind = check_and_cast<SCTPCommand *>(msg->removeControlInfo());
    cMessage *cmsg = new cMessage("SCTP_C_RECEIVE");
    SCTPSendInfo *cmd = new SCTPSendInfo();
    cmd->setAssocId(ind->getAssocId());
    cmd->setSid(ind->getSid());
    cmd->setNumMsgs(ind->getNumMsgs());
    cmsg->setKind(SCTP_C_RECEIVE);
    cmsg->setControlInfo(cmd);
    delete ind;
    socket.sendNotification(cmsg);
}

void inet::SCTPClient::socketEstablished ( int  connId, void *  yourPtr, unsigned long int  buffer  )

overrideprotectedvirtual

Reimplemented from inet::SCTPSocket::CallbackInterface.

{
    int count = 0;
    EV_INFO << "SCTPClient: connected\n";
    stateNameStr = "connected";
    bufferSize = buffer;
    // determine number of requests in this session
    numRequestsToSend = par("numRequestsPerSession");
    numPacketsToReceive = par("numPacketsToReceive");

    if (numRequestsToSend < 1)
        numRequestsToSend = 0;

    EV_INFO << "SCTPClient:numRequestsToSend=" << numRequestsToSend << "\n";

    // perform first request (next one will be sent when reply arrives)
    if ((numRequestsToSend > 0 && !timer) || timer) {
        if (par("thinkTime").doubleValue() > 0) {
            if (sendAllowed) {
                sendRequest();

                if (!timer)
                    numRequestsToSend--;
            }

            timeMsg->setKind(MSGKIND_SEND);
            scheduleAt(simTime() + par("thinkTime"), timeMsg);
        }
        else {
            if (queueSize > 0) {
                while (((!timer && numRequestsToSend > 0) || timer) && count++ < queueSize * 2 && sendAllowed) {
                    if (count == queueSize * 2)
                        sendRequest();
                    else
                        sendRequest(false);

                    if (!timer) {
                        if (--numRequestsToSend == 0)
                            sendAllowed = false;
                    }
                }

                if (((!timer && numRequestsToSend > 0) || timer) && sendAllowed)
                    sendQueueRequest();
            }
            else {
                while ((((!timer && numRequestsToSend > 0) || timer) && sendAllowed && bufferSize > 0) ||
                       (((!timer && numRequestsToSend > 0) || timer) && sendAllowed && buffer == 0))
                {
                    if (!timer && numRequestsToSend == 1)
                        sendRequest(true);
                    else
                        sendRequest(false);

                    if (!timer && (--numRequestsToSend == 0))
                        sendAllowed = false;
                }
            }
        }

        if ((!timer && numPacketsToReceive == 0) && par("waitToClose").doubleValue() > 0) {
            timeMsg->setKind(MSGKIND_ABORT);
            scheduleAt(simTime() + par("waitToClose"), timeMsg);
        }

        if ((!timer && numRequestsToSend == 0) && par("waitToClose").doubleValue() == 0) {
            EV_INFO << "socketEstablished:no more packets to send, call shutdown\n";
            socket.shutdown();

            if (timeMsg->isScheduled())
                cancelEvent(timeMsg);

            if (finishEndsSimulation) {
                endSimulation();
            }
        }
    }
}

void inet::SCTPClient::socketFailure ( int  connId, void *  yourPtr, int  code  )

overrideprotectedvirtual

Reimplemented from inet::SCTPSocket::CallbackInterface.

{
    // subclasses may override this function, and add code try to reconnect after a delay.
    EV_WARN << "connection broken\n";
    stateNameStr = "broken";
    numBroken++;
    // reconnect after a delay
    timeMsg->setKind(MSGKIND_CONNECT);
    scheduleAt(simTime() + par("reconnectInterval"), timeMsg);
}

void inet::SCTPClient::socketPeerClosed ( int  connId, void *  yourPtr  )

overrideprotectedvirtual

Reimplemented from inet::SCTPSocket::CallbackInterface.

{
    // close the connection (if not already closed)
    if (socket.getState() == SCTPSocket::PEER_CLOSED) {
        EV_INFO << "remote SCTP closed, closing here as well\n";
        close();
    }
}

void inet::SCTPClient::socketStatusArrived ( int  connId, void *  yourPtr, SCTPStatusInfo *  status  )

overrideprotectedvirtual

Reimplemented from inet::SCTPSocket::CallbackInterface.

{
    struct PathStatus ps;
    auto i = sctpPathStatus.find(status->getPathId());

    if (i != sctpPathStatus.end()) {
        ps = i->second;
        ps.active = status->getActive();
    }
    else {
        ps.active = status->getActive();
        ps.pid = status->getPathId();
        ps.primaryPath = false;
        sctpPathStatus[ps.pid] = ps;
    }
    delete status;
}

Member Data Documentation

int64 inet::SCTPClient::bufferSize

protected

Referenced by SCTPClient(), sendqueueAbatedArrived(), sendRequest(), and socketEstablished().

unsigned long int inet::SCTPClient::bytesRcvd

protected

Referenced by finish(), initialize(), SCTPClient(), and socketDataArrived().

unsigned long int inet::SCTPClient::bytesSent

protected

Referenced by finish(), initialize(), SCTPClient(), and sendRequest().

int inet::SCTPClient::chunksAbandoned

protected

Referenced by msgAbandonedArrived(), and SCTPClient().

bool inet::SCTPClient::echo

protected

Referenced by initialize(), SCTPClient(), and socketDataArrived().

unsigned long int inet::SCTPClient::echoedBytesSent

protected

Referenced by SCTPClient(), and socketDataArrived().

simsignal_t inet::SCTPClient::echoedPkSignal = registerSignal("echoedPk")

staticprotected

Referenced by socketDataArrived().

bool inet::SCTPClient::finishEndsSimulation

protected

Referenced by handleTimer(), initialize(), SCTPClient(), sendqueueAbatedArrived(), sendRequestArrived(), and socketEstablished().

unsigned int inet::SCTPClient::inStreams

protected

Referenced by connect(), and SCTPClient().

int inet::SCTPClient::numBroken

protected

Referenced by initialize(), SCTPClient(), and socketFailure().

unsigned long int inet::SCTPClient::numPacketsToReceive

protected

Referenced by SCTPClient(), socketDataArrived(), and socketEstablished().

unsigned long int inet::SCTPClient::numRequestsToSend

protected

Referenced by handleTimer(), initialize(), SCTPClient(), sendqueueAbatedArrived(), sendRequestArrived(), shutdownReceivedArrived(), and socketEstablished().

int inet::SCTPClient::numSessions

protected

Referenced by connect(), finish(), initialize(), and SCTPClient().

bool inet::SCTPClient::ordered

protected

Referenced by initialize(), SCTPClient(), and sendRequest().

unsigned int inet::SCTPClient::outStreams

protected

Referenced by connect(), SCTPClient(), and sendRequest().

unsigned long int inet::SCTPClient::packetsRcvd

protected

Referenced by finish(), initialize(), SCTPClient(), and socketDataArrived().

unsigned long int inet::SCTPClient::packetsSent

protected

Referenced by finish(), initialize(), SCTPClient(), and socketDataArrived().

cMessage* inet::SCTPClient::primaryChangeTimer

protected

Referenced by initialize(), SCTPClient(), socketClosed(), and ~SCTPClient().

int inet::SCTPClient::queueSize

protected

Referenced by initialize(), SCTPClient(), sendQueueRequest(), sendRequestArrived(), and socketEstablished().

simsignal_t inet::SCTPClient::rcvdPkSignal = registerSignal("rcvdPk")

staticprotected

Referenced by socketDataArrived().

SCTPPathStatus inet::SCTPClient::sctpPathStatus

protected

Referenced by socketStatusArrived().

bool inet::SCTPClient::sendAllowed

protected

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

simsignal_t inet::SCTPClient::sentPkSignal = registerSignal("sentPk")

staticprotected

Referenced by sendRequest().

SCTPSocket inet::SCTPClient::socket

protected

Referenced by close(), connect(), handleMessage(), handleTimer(), initialize(), sendqueueAbatedArrived(), sendQueueRequest(), sendRequest(), sendRequestArrived(), sendStreamResetNotification(), setPrimaryPath(), shutdownReceivedArrived(), socketDataArrived(), socketDataNotificationArrived(), socketEstablished(), and socketPeerClosed().

const char* inet::SCTPClient::stateNameStr

protected

Referenced by close(), connect(), initialize(), refreshDisplay(), SCTPClient(), socketClosed(), socketEstablished(), and socketFailure().

cMessage* inet::SCTPClient::stopTimer

protected

Referenced by initialize(), SCTPClient(), and ~SCTPClient().

std::map<unsigned int, unsigned int> inet::SCTPClient::streamRequestLengthMap

protected

Referenced by connect(), and sendRequest().

std::map<unsigned int, unsigned int> inet::SCTPClient::streamRequestRatioMap

protected

Referenced by connect(), and sendRequest().

std::map<unsigned int, unsigned int> inet::SCTPClient::streamRequestRatioSendMap

protected

Referenced by connect(), and sendRequest().

cMessage* inet::SCTPClient::timeMsg

protected

Referenced by handleTimer(), initialize(), SCTPClient(), sendqueueAbatedArrived(), sendRequestArrived(), socketEstablished(), socketFailure(), and ~SCTPClient().

bool inet::SCTPClient::timer

protected

Referenced by handleTimer(), initialize(), SCTPClient(), sendqueueAbatedArrived(), sendRequestArrived(), and socketEstablished().

---

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

• SCTPClient.h
• SCTPClient.cc