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::ICallback
virtual	~ICallback ()
virtual void	socketOptionsArrived (SctpSocket *socket, Indication *indication)
virtual void	socketDeleted (SctpSocket *socket)
virtual void	sendqueueFullArrived (SctpSocket *socket)
virtual void	addressAddedArrived (SctpSocket *socket, L3Address localAddr, L3Address remoteAddr)
Public Member Functions inherited from inet::LifecycleUnsupported
virtual bool	handleOperationStage (LifecycleOperation *operation, IDoneCallback *doneCallback) override
	Perform one stage of a lifecycle operation. More...
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)
virtual void	socketAvailable (SctpSocket *socket, Indication *indication) override
void	socketEstablished (SctpSocket *socket, unsigned long int buffer) override
void	socketDataArrived (SctpSocket *socket, Packet *msg, bool urgent) override
void	socketDataNotificationArrived (SctpSocket *socket, Message *msg) override
void	socketPeerClosed (SctpSocket *socket) override
void	socketClosed (SctpSocket *socket) override
void	socketFailure (SctpSocket *socket, int code) override
void	socketStatusArrived (SctpSocket *socket, SctpStatusReq *status) override
void	setPrimaryPath (const char *addr)
void	sendRequestArrived (SctpSocket *socket) override
void	sendQueueRequest ()
void	shutdownReceivedArrived (SctpSocket *socket) override
void	sendqueueAbatedArrived (SctpSocket *socket, unsigned long int buffer) override
void	msgAbandonedArrived (SctpSocket *socket) override
void	sendStreamResetNotification ()
void	sendRequest (bool last=true)

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_t	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	echoedPkSignal = registerSignal("echoedPk")

Detailed Description

Implements the SctpClient simple module.

See the NED file for more info.

Member Typedef Documentation

SctpPathStatus

typedef std::map<L3Address, PathStatus> inet::SctpClient::SctpPathStatus

protected

Constructor & Destructor Documentation

SctpClient()

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

~SctpClient()

inet::SctpClient::~SctpClient ( )

virtual

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

Member Function Documentation

close()

void inet::SctpClient::close ( )

protected

{
    socket.close();
}

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

connect()

void inet::SctpClient::connect ( )

protected

{
    const char *connectAddress = par("connectAddress");
    int connectPort = par("connectPort");
    inStreams = par("inboundStreams");
    outStreams = par("outboundStreams");
    socket.setInboundStreams(inStreams);
    socket.setOutboundStreams(outStreams);
    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, par("prMethod"), (unsigned int)par("numRequestsPerSession"));
    }
 
    if (streamReset) {
        cMessage *cmsg = new cMessage("StreamReset", MSGKIND_RESET);
        EV_INFO << "StreamReset Timer scheduled at " << simTime() + par("streamRequestTime") << "\n";
        scheduleAfter(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"));
    while (ratioTokenizer.hasMoreTokens()) {
        const char *token = ratioTokenizer.nextToken();
        streamRequestRatioMap[streamNum] = atoi(token);
        streamRequestRatioSendMap[streamNum] = atoi(token);
 
        streamNum++;
    }
 
    numSessions++;
}

Referenced by handleTimer().

finish()

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

handleMessage()

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

overrideprotectedvirtual

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

handleTimer()

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

protected

{
    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)
                    scheduleAfter(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:
            sendStreamResetNotification();
            delete msg;
            break;
 
        case MSGKIND_STOP:
            numRequestsToSend = 0;
            sendAllowed = false;
            socket.abort();
            socket.close();
 
            if (timeMsg->isScheduled())
                cancelEvent(timeMsg);
 
            if (finishEndsSimulation) {
                endSimulation();
            }
            break;
 
        default:
            throw cRuntimeError("unknown selfmessage kind = %d ", msg->getKind());
            break;
    }
}

Referenced by handleMessage().

initialize()

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");
        ordered = par("ordered");
        finishEndsSimulation = par("finishEndsSimulation");
        queueSize = par("queueSize");
        WATCH(numRequestsToSend);
        recordScalar("ums", par("requestLength").intValue());
 
        timeMsg = new cMessage("CliAppTimer", 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) {
        cModule *node = findContainingNode(this);
        NodeStatus *nodeStatus = node ? check_and_cast_nullable<NodeStatus *>(node->getSubmodule("status")) : nullptr;
        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("socketOut"));
        socket.setCallback(this);
 
        if (addresses.size() == 0) {
            EV_INFO << "Call socket bind\n";
            socket.bind(port);
            EV_INFO << "Nach socket bind\n";
        }
        else {
            socket.bindx(addresses, port);
        }
 
        simtime_t stopTime = par("stopTime");
        if (stopTime >= SIMTIME_ZERO) {
            stopTimer = new cMessage("StopTimer", MSGKIND_STOP);
            scheduleAt(par("stopTime"), stopTimer);
            timer = true;
        }
 
        simtime_t primaryTime = par("primaryTime");
        if (primaryTime != SIMTIME_ZERO) {
            primaryChangeTimer = new cMessage("PrimaryTime", MSGKIND_PRIMARY);
            scheduleAt(primaryTime, primaryChangeTimer);
        }
    }
}

msgAbandonedArrived()

void inet::SctpClient::msgAbandonedArrived ( SctpSocket *  socket )

overrideprotectedvirtual

Reimplemented from inet::SctpSocket::ICallback.

{
    chunksAbandoned++;
}

numInitStages()

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

inlineoverrideprotectedvirtual

{ return NUM_INIT_STAGES; }

refreshDisplay()

void inet::SctpClient::refreshDisplay ( ) const

overrideprotectedvirtual

{
    getDisplayString().setTagArg("t", 0, SctpSocket::stateName(socket.getState()));
}

sendqueueAbatedArrived()

void inet::SctpClient::sendqueueAbatedArrived ( SctpSocket *  socket, unsigned long int  buffer  )

overrideprotectedvirtual

Reimplemented from inet::SctpSocket::ICallback.

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

sendQueueRequest()

void inet::SctpClient::sendQueueRequest ( )

protected

{
    Request *cmsg = new Request("SCTP_C_QUEUE_MSGS_LIMIT", SCTP_C_QUEUE_MSGS_LIMIT);
    auto qinfo = cmsg->addTag<SctpInfoReq>();
    qinfo->setText(queueSize);
    qinfo->setSocketId(socket.getSocketId());
    socket.sendRequest(cmsg);
}

Referenced by socketEstablished().

sendRequest()

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

protected

{
    // 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;
 
    auto applicationPacket = new Packet("ApplicationPacket");
    auto applicationData = makeShared<BytesChunk>();
    std::vector<uint8_t> vec;
    vec.resize(sendBytes);
    for (uint32_t i = 0; i < sendBytes; i++)
        vec[i] = (bytesSent + i) & 0xFF;
    applicationData->setBytes(vec);
    applicationData->addTag<CreationTimeTag>()->setCreationTime(simTime());
    applicationPacket->insertAtBack(applicationData);
    auto sctpSendReq = applicationPacket->addTag<SctpSendReq>();
    sctpSendReq->setLast(last);
    sctpSendReq->setPrMethod(par("prMethod"));
    sctpSendReq->setPrValue(par("prValue"));
    sctpSendReq->setSid(nextStream);
    applicationPacket->setKind(ordered ? SCTP_C_SEND_ORDERED : SCTP_C_SEND_UNORDERED);
    emit(packetSentSignal, applicationPacket);
    socket.send(applicationPacket);
 
    bytesSent += sendBytes;
}

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

sendRequestArrived()

void inet::SctpClient::sendRequestArrived ( SctpSocket *  socket )

overrideprotectedvirtual

Reimplemented from inet::SctpSocket::ICallback.

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

sendStreamResetNotification()

void inet::SctpClient::sendStreamResetNotification ( )

protected

{
    unsigned short int type = par("streamResetType");
    if (type >= 6 && type <= 9) {
        Message *cmsg = new Message("SCTP_C_STREAM_RESET", SCTP_C_STREAM_RESET);
        auto rinfo = cmsg->addTag<SctpResetReq>();
        rinfo->setSocketId(socket.getSocketId());
        rinfo->setRemoteAddr(socket.getRemoteAddr());
        rinfo->setRequestType(type);
        rinfo->setStreamsArraySize(1);
        rinfo->setStreams(0, par("streamToReset"));
        socket.sendNotification(cmsg);
    }
}

Referenced by handleTimer().

setPrimaryPath()

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

protected

{
    Request *cmsg = new Request("SCTP_C_PRIMARY", SCTP_C_PRIMARY);
    auto pinfo = cmsg->addTag<SctpPathInfoReq>();
 
    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->setSocketId(socket.getSocketId());
    socket.sendNotification(cmsg);
}

Referenced by handleTimer().

shutdownReceivedArrived()

void inet::SctpClient::shutdownReceivedArrived ( SctpSocket *  socket )

overrideprotectedvirtual

Reimplemented from inet::SctpSocket::ICallback.

{
    if (numRequestsToSend == 0) {
        Message *cmsg = new Message("SCTP_C_NO_OUTSTANDING", SCTP_C_NO_OUTSTANDING);
        auto qinfo = cmsg->addTag<SctpCommandReq>();
        qinfo->setSocketId(socket->getSocketId());
        socket->sendNotification(cmsg);
    }
}

socketAvailable()

virtual void inet::SctpClient::socketAvailable ( SctpSocket *  socket, Indication *  indication  )

inlineoverrideprotectedvirtual

Implements inet::SctpSocket::ICallback.

{ throw cRuntimeError("Model error, this module doesn't use any listener SCTP sockets"); }

socketClosed()

void inet::SctpClient::socketClosed ( SctpSocket *  socket )

overrideprotectedvirtual

Reimplemented from inet::SctpSocket::ICallback.

{
    // *redefine* to start another session etc.
    EV_INFO << "connection closed\n";
 
    if (primaryChangeTimer) {
        cancelEvent(primaryChangeTimer);
        delete primaryChangeTimer;
        primaryChangeTimer = nullptr;
    }
}

socketDataArrived()

void inet::SctpClient::socketDataArrived ( SctpSocket *  socket, Packet *  msg, bool  urgent  )

overrideprotectedvirtual

Implements inet::SctpSocket::ICallback.

{
    packetsRcvd++;
 
    EV_INFO << "Client received packet Nr " << packetsRcvd << " from SCTP\n";
    auto ind = msg->getTag<SctpRcvReq>();
    emit(packetReceivedSignal, msg);
    bytesRcvd += msg->getByteLength();
 
    if (echo) {
        const auto& smsg = msg->peekData();
        auto cmsg = new Packet("ApplicationPacket");
        cmsg->insertAtBack(smsg);
        auto cmd = cmsg->addTag<SctpSendReq>();
        cmd->setLast(true);
        cmd->setSocketId(ind->getSocketId());
        cmd->setPrValue(0);
        cmd->setSid(ind->getSid());
        cmsg->setKind(ind->getSendUnordered() ? SCTP_C_SEND_UNORDERED : SCTP_C_SEND_ORDERED);
        packetsSent++;
        socket->send(cmsg);
    }
 
    if (par("numPacketsToReceive").intValue() > 0) {
        numPacketsToReceive--;
        if (numPacketsToReceive == 0)
            close();
    }
 
    delete msg;
}

socketDataNotificationArrived()

void inet::SctpClient::socketDataNotificationArrived ( SctpSocket *  socket, Message *  msg  )

overrideprotectedvirtual

Implements inet::SctpSocket::ICallback.

{
    Message *message = check_and_cast<Message *>(msg);
    auto& ind = message->findTag<SctpCommandReq>();
    Request *cmesg = new Request("SCTP_C_RECEIVE", SCTP_C_RECEIVE);
    auto cmd = cmesg->addTag<SctpSendReq>();
    cmd->setSocketId(ind->getSocketId());
    cmd->setSid(ind->getSid());
    cmd->setNumMsgs(ind->getNumMsgs());
    delete msg;
    socket->sendNotification(cmesg);
}

socketEstablished()

void inet::SctpClient::socketEstablished ( SctpSocket *  socket, unsigned long int  buffer  )

overrideprotectedvirtual

Reimplemented from inet::SctpSocket::ICallback.

{
    int count = 0;
    EV_INFO << "SctpClient: connected\n";
    bufferSize = buffer;
    // determine number of requests in this session
    numRequestsToSend = par("numRequestsPerSession");
    numPacketsToReceive = par("numPacketsToReceive");
    if (numRequestsToSend == 0) {
        sendAllowed = false;
    }
 
    if (numRequestsToSend < 1)
        numRequestsToSend = 0;
 
    EV_INFO << "SctpClient:numRequestsToSend=" << numRequestsToSend << " queueSize= " << queueSize << "\n";
 
    if (queueSize > 0) {
        sendQueueRequest();
    }
 
    // 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);
            scheduleAfter(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;
                    }
                }
            }
            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);
            scheduleAfter(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();
            }
        }
    }
}

socketFailure()

void inet::SctpClient::socketFailure ( SctpSocket *  socket, int  code  )

overrideprotectedvirtual

Reimplemented from inet::SctpSocket::ICallback.

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

socketPeerClosed()

void inet::SctpClient::socketPeerClosed ( SctpSocket *  socket )

overrideprotectedvirtual

Reimplemented from inet::SctpSocket::ICallback.

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

socketStatusArrived()

void inet::SctpClient::socketStatusArrived ( SctpSocket *  socket, SctpStatusReq *  status  )

overrideprotectedvirtual

Reimplemented from inet::SctpSocket::ICallback.

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

Member Data Documentation

bufferSize

int64_t inet::SctpClient::bufferSize

protected

Referenced by SctpClient(), sendqueueAbatedArrived(), and socketEstablished().

bytesRcvd

unsigned long int inet::SctpClient::bytesRcvd

protected

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

bytesSent

unsigned long int inet::SctpClient::bytesSent

protected

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

chunksAbandoned

int inet::SctpClient::chunksAbandoned

protected

Referenced by msgAbandonedArrived(), and SctpClient().

echo

bool inet::SctpClient::echo

protected

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

echoedBytesSent

unsigned long int inet::SctpClient::echoedBytesSent

protected

Referenced by SctpClient().

echoedPkSignal

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

staticprotected

finishEndsSimulation

bool inet::SctpClient::finishEndsSimulation

protected

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

inStreams

unsigned int inet::SctpClient::inStreams

protected

Referenced by connect(), and SctpClient().

numBroken

int inet::SctpClient::numBroken

protected

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

numPacketsToReceive

unsigned long int inet::SctpClient::numPacketsToReceive

protected

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

numRequestsToSend

unsigned long int inet::SctpClient::numRequestsToSend

protected

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

numSessions

int inet::SctpClient::numSessions

protected

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

ordered

bool inet::SctpClient::ordered

protected

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

outStreams

unsigned int inet::SctpClient::outStreams

protected

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

packetsRcvd

unsigned long int inet::SctpClient::packetsRcvd

protected

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

packetsSent

unsigned long int inet::SctpClient::packetsSent

protected

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

primaryChangeTimer

cMessage* inet::SctpClient::primaryChangeTimer

protected

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

queueSize

int inet::SctpClient::queueSize

protected

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

sctpPathStatus

SctpPathStatus inet::SctpClient::sctpPathStatus

protected

Referenced by socketStatusArrived().

sendAllowed

bool inet::SctpClient::sendAllowed

protected

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

socket

SctpSocket inet::SctpClient::socket

protected

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

stateNameStr

const char* inet::SctpClient::stateNameStr

protected

stopTimer

cMessage* inet::SctpClient::stopTimer

protected

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

streamRequestLengthMap

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

protected

Referenced by connect(), and sendRequest().

streamRequestRatioMap

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

protected

Referenced by connect(), and sendRequest().

streamRequestRatioSendMap

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

protected

Referenced by connect(), and sendRequest().

timeMsg

cMessage* inet::SctpClient::timeMsg

protected

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

timer

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