inet::SCTPServer Class Reference

Implements the SCTPServer simple module. More...

#include <SCTPServer.h>

Inheritance diagram for inet::SCTPServer:

Classes
struct	ServerAssocStat

Public Member Functions
virtual	~SCTPServer ()
	SCTPServer ()
Public Member Functions inherited from inet::ILifecycle
virtual	~ILifecycle ()

Protected Types
typedef std::map< int, ServerAssocStat >	ServerAssocStatMap
typedef std::map< int, cOutVector * >	BytesPerAssoc
typedef std::map< int, cOutVector * >	EndToEndDelay

Protected Member Functions
virtual void	initialize (int stage) override
virtual int	numInitStages () const override
virtual void	handleMessage (cMessage *msg) override
virtual void	finish () override
void	handleTimer (cMessage *msg)
void	sendOrSchedule (cMessage *msg)
cMessage *	makeAbortNotification (SCTPCommand *msg)
cMessage *	makeReceiveRequest (cMessage *msg)
cMessage *	makeDefaultReceive ()
void	generateAndSend ()
virtual bool	handleOperationStage (LifecycleOperation *operation, int stage, IDoneCallback *doneCallback) override
	Perform one stage of a lifecycle operation. More...

Protected Attributes
int	inboundStreams
int	outboundStreams
int	queueSize
double	delay
double	delayFirstRead
bool	finishEndsSimulation
bool	echo
bool	ordered
SCTPSocket *	socket
cMessage *	timeoutMsg
cMessage *	delayTimer
cMessage *	delayFirstReadTimer
int	lastStream
int	assocId
bool	readInt
bool	schedule
bool	firstData
bool	shutdownReceived
bool	abortSent
EndToEndDelay	endToEndDelay
int	numSessions
int	count
int	notificationsReceived
unsigned long int	bytesSent
unsigned long int	packetsSent
unsigned long int	packetsRcvd
unsigned long int	numRequestsToSend
BytesPerAssoc	bytesPerAssoc
ServerAssocStatMap	serverAssocStatMap

Detailed Description

Implements the SCTPServer simple module.

See the NED file for more info.

Member Typedef Documentation

typedef std::map<int, cOutVector *> inet::SCTPServer::BytesPerAssoc

protected

typedef std::map<int, cOutVector *> inet::SCTPServer::EndToEndDelay

protected

typedef std::map<int, ServerAssocStat> inet::SCTPServer::ServerAssocStatMap

protected

Constructor & Destructor Documentation

inet::SCTPServer::~SCTPServer ( )

virtual

{
    for (auto & elem : bytesPerAssoc)
        delete elem.second;

    for (auto & elem : endToEndDelay)
        delete elem.second;

    bytesPerAssoc.clear();
    endToEndDelay.clear();
    serverAssocStatMap.clear();
    delete socket;
    cancelAndDelete(timeoutMsg);
    cancelAndDelete(delayTimer);
    cancelAndDelete(delayFirstReadTimer);
}

inet::SCTPServer::SCTPServer

(

)

{
    timeoutMsg = nullptr;
    socket = nullptr;
    delayFirstReadTimer = nullptr;
    delayTimer = nullptr;
    numSessions = 0;
    packetsSent = 0;
    packetsRcvd = 0;
    bytesSent = 0;
    notificationsReceived = 0;
    inboundStreams = 17;
    outboundStreams = 1;
    queueSize = 0;
    delay = 0;
    delayFirstRead = 0;
    finishEndsSimulation = true;
    echo = false;
    ordered = true;
    lastStream = 0;
    assocId = 0;
    readInt = false;
    schedule = false;
    firstData = true;
    shutdownReceived = false;
    abortSent = false;
    count = 0;
    numRequestsToSend = 0;
}

Member Function Documentation

void inet::SCTPServer::finish ( )

overrideprotectedvirtual

{
    EV_INFO << getFullPath() << ": opened " << numSessions << " sessions\n";
    EV_INFO << getFullPath() << ": sent " << bytesSent << " bytes in " << packetsSent << " packets\n";
    for (auto & elem : serverAssocStatMap) {
        EV_DETAIL << getFullPath() << " Assoc: " << elem.first << "\n";
        EV_DETAIL << "\tstart time: " << elem.second.start << "\n";
        EV_DETAIL << "\tstop time: " << elem.second.stop << "\n";
        EV_DETAIL << "\tlife time: " << elem.second.lifeTime << "\n";
        EV_DETAIL << "\treceived bytes:" << elem.second.rcvdBytes << "\n";
        EV_DETAIL << "\tthroughput: " << (elem.second.rcvdBytes / elem.second.lifeTime.dbl()) * 8 << " bit/sec\n";
        recordScalar("bytes rcvd", elem.second.rcvdBytes);
        recordScalar("throughput", (elem.second.rcvdBytes / elem.second.lifeTime.dbl()) * 8);
    }
    EV_INFO << getFullPath() << "Over all " << packetsRcvd << " packets received\n ";
    EV_INFO << getFullPath() << "Over all " << notificationsReceived << " notifications received\n ";
    EV_INFO << "Server finished\n";
}

void inet::SCTPServer::generateAndSend ( )

protected

Referenced by handleMessage(), and handleTimer().

{
    cPacket *cmsg = new cPacket("SCTP_C_SEND");
    SCTPSimpleMessage *msg = new SCTPSimpleMessage("Server");
    int numBytes = par("requestLength");
    msg->setDataArraySize(numBytes);

    for (int i = 0; i < numBytes; i++)
        msg->setData(i, 's');

    msg->setDataLen(numBytes);
    msg->setEncaps(false);
    msg->setBitLength(numBytes * 8);
    cmsg->encapsulate(msg);
    SCTPSendInfo *cmd = new SCTPSendInfo("Send1");
    cmd->setAssocId(assocId);
    cmd->setSendUnordered(ordered ? COMPLETE_MESG_ORDERED : COMPLETE_MESG_UNORDERED);
    lastStream = (lastStream + 1) % outboundStreams;
    cmd->setSid(lastStream);
    cmd->setPrValue(par("prValue"));
    cmd->setPrMethod(par("prMethod"));

    if (queueSize > 0 && numRequestsToSend > 0 && count < queueSize * 2)
        cmd->setLast(false);
    else
        cmd->setLast(true);

    cmsg->setKind(SCTP_C_SEND);
    cmsg->setControlInfo(cmd);
    packetsSent++;
    bytesSent += msg->getBitLength() / 8;
    sendOrSchedule(cmsg);
}

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

overrideprotectedvirtual

{
    // TODO: there is another memory leak somewhere...
    int id = 0;
    cMessage *cmsg;
    if (msg->isSelfMessage())
        handleTimer(msg);
    else {
        switch (msg->getKind()) {
            case SCTP_I_PEER_CLOSED:
            case SCTP_I_ABORT: {
                SCTPCommand *command = check_and_cast<SCTPCommand *>(msg->removeControlInfo());
                assocId = command->getAssocId();
                serverAssocStatMap[assocId].peerClosed = true;
                if (par("numPacketsToReceivePerClient").longValue() == 0) {
                    if (serverAssocStatMap[assocId].abortSent == false) {
                        sendOrSchedule(makeAbortNotification(command->dup()));
                        serverAssocStatMap[assocId].abortSent = true;
                    }
                }
                else {
                    if (serverAssocStatMap[assocId].rcvdPackets == (unsigned int)par("numPacketsToReceivePerClient")
                        && serverAssocStatMap[assocId].abortSent == false)
                    {
                        sendOrSchedule(makeAbortNotification(command->dup()));
                        serverAssocStatMap[assocId].abortSent = true;
                    }
                }
                if (delayTimer->isScheduled())
                    cancelEvent(delayTimer);
                if (delayFirstReadTimer->isScheduled())
                    cancelEvent(delayFirstReadTimer);
                delete command;
                delete msg;
                break;
            }

            case SCTP_I_ESTABLISHED: {
                count = 0;
                SCTPConnectInfo *connectInfo = check_and_cast<SCTPConnectInfo *>(msg->removeControlInfo());
                numSessions++;
                assocId = connectInfo->getAssocId();
                inboundStreams = connectInfo->getInboundStreams();
                outboundStreams = connectInfo->getOutboundStreams();
                serverAssocStatMap[assocId].rcvdPackets = par("numPacketsToReceivePerClient");
                serverAssocStatMap[assocId].sentPackets = par("numPacketsToSendPerClient");
                serverAssocStatMap[assocId].rcvdBytes = 0;
                serverAssocStatMap[assocId].start = 0;
                serverAssocStatMap[assocId].stop = 0;
                serverAssocStatMap[assocId].lifeTime = 0;
                serverAssocStatMap[assocId].abortSent = false;
                serverAssocStatMap[assocId].peerClosed = false;
                char text[50];
                sprintf(text, "App: Received Bytes of assoc %d", assocId);
                bytesPerAssoc[assocId] = new cOutVector(text);
                sprintf(text, "App: EndToEndDelay of assoc %d", assocId);
                endToEndDelay[assocId] = new cOutVector(text);

                delete connectInfo;
                delete msg;
                if (par("numPacketsToSendPerClient").longValue() > 0) {
                    auto i = serverAssocStatMap.find(assocId);
                    numRequestsToSend = i->second.sentPackets;
                    if (par("thinkTime").doubleValue() > 0) {
                        generateAndSend();
                        timeoutMsg->setKind(SCTP_C_SEND);
                        scheduleAt(simTime() + par("thinkTime"), timeoutMsg);
                        numRequestsToSend--;
                        i->second.sentPackets = numRequestsToSend;
                    }
                    else {
                        if (queueSize == 0) {
                            while (numRequestsToSend > 0) {
                                generateAndSend();
                                numRequestsToSend--;
                                i->second.sentPackets = numRequestsToSend;
                            }
                        }
                        else if (queueSize > 0) {
                            while (numRequestsToSend > 0 && count++ < queueSize * 2) {
                                generateAndSend();
                                numRequestsToSend--;
                                i->second.sentPackets = numRequestsToSend;
                            }

                            cMessage *cmsg = new cMessage("SCTP_C_QUEUE_MSGS_LIMIT");
                            SCTPInfo *qinfo = new SCTPInfo("Info1");
                            qinfo->setText(queueSize);
                            cmsg->setKind(SCTP_C_QUEUE_MSGS_LIMIT);
                            qinfo->setAssocId(id);
                            cmsg->setControlInfo(qinfo);
                            sendOrSchedule(cmsg);
                        }
                        auto j = serverAssocStatMap.find(assocId);
                        if (j->second.rcvdPackets == 0 && par("waitToClose").doubleValue() > 0) {
                            char as[5];
                            sprintf(as, "%d", assocId);
                            cMessage *abortMsg = new cMessage(as);
                            abortMsg->setKind(SCTP_I_ABORT);
                            scheduleAt(simTime() + par("waitToClose"), abortMsg);
                        }
                        else {
                            EV_INFO << "no more packets to send, call shutdown for assoc " << assocId << "\n";
                            cMessage *cmsg = new cMessage("ShutdownRequest");
                            SCTPCommand *cmd = new SCTPCommand("Send5");
                            cmsg->setKind(SCTP_C_SHUTDOWN);
                            cmd->setAssocId(assocId);
                            cmsg->setControlInfo(cmd);
                            sendOrSchedule(cmsg);
                        }
                    }
                }
                break;
            }

            case SCTP_I_DATA_NOTIFICATION: {
                notificationsReceived++;

                if (schedule == false) {
                    if (delayFirstRead > 0 && !delayFirstReadTimer->isScheduled()) {
                        cmsg = makeReceiveRequest(msg);
                        scheduleAt(simTime() + delayFirstRead, cmsg);
                        scheduleAt(simTime() + delayFirstRead, delayFirstReadTimer);
                    }
                    else if (readInt && firstData) {
                        firstData = false;
                        cmsg = makeReceiveRequest(msg);
                        scheduleAt(simTime() + par("readingInterval"), delayTimer);
                        sendOrSchedule(cmsg);
                    }
                    else if (delayFirstRead == 0 && readInt == false) {
                        cmsg = makeReceiveRequest(msg);
                        sendOrSchedule(cmsg);
                    }
                }
                else {
                    EV_INFO << simTime() << " makeReceiveRequest\n";
                    cmsg = makeReceiveRequest(msg);
                    sendOrSchedule(cmsg);
                }
                delete msg;
                break;
            }

            case SCTP_I_DATA: {
                notificationsReceived--;
                packetsRcvd++;
                EV_INFO << simTime() << " server: data arrived. " << packetsRcvd << " Packets received now\n";
                SCTPRcvInfo *ind = check_and_cast<SCTPRcvInfo *>(msg->removeControlInfo());
                id = ind->getAssocId();
                auto j = serverAssocStatMap.find(id);
                auto k = bytesPerAssoc.find(id);
                if (j->second.rcvdBytes == 0)
                    j->second.start = simTime();

                j->second.rcvdBytes += PK(msg)->getByteLength();
                k->second->record(j->second.rcvdBytes);

                if (!echo) {
                    if (par("numPacketsToReceivePerClient").longValue() > 0) {
                        j->second.rcvdPackets--;
                        SCTPSimpleMessage *smsg = check_and_cast<SCTPSimpleMessage *>(msg);
                        auto m = endToEndDelay.find(id);
                        m->second->record(simTime() - smsg->getCreationTime());
                        EV_INFO << "server: Data received. Left packets to receive=" << j->second.rcvdPackets << "\n";

                        if (j->second.rcvdPackets == 0) {
                            if (serverAssocStatMap[assocId].peerClosed == true && serverAssocStatMap[assocId].abortSent == false) {
                                sendOrSchedule(makeAbortNotification(ind));
                                serverAssocStatMap[assocId].abortSent = true;
                                j->second.stop = simTime();
                                j->second.lifeTime = j->second.stop - j->second.start;
                                delete msg;
                                break;
                            }
                            else {
                                cMessage *cmsg = new cMessage("SCTP_C_NO_OUTSTANDING");
                                SCTPInfo *qinfo = new SCTPInfo("Info2");
                                cmsg->setKind(SCTP_C_NO_OUTSTANDING);
                                qinfo->setAssocId(id);
                                cmsg->setControlInfo(qinfo);
                                sendOrSchedule(cmsg);
                                j->second.stop = simTime();
                                j->second.lifeTime = j->second.stop - j->second.start;
                            }
                        }
                    }
                    delete msg;
                }
                else {
                    SCTPSendInfo *cmd = new SCTPSendInfo("SCTP_C_SEND");
                    cmd->setAssocId(id);
                    SCTPSimpleMessage *smsg = check_and_cast<SCTPSimpleMessage *>(msg);
                    auto n = endToEndDelay.find(id);
                    n->second->record(simTime() - smsg->getCreationTime());
                    cPacket *cmsg = new cPacket("SCTP_C_SEND");
                    bytesSent += smsg->getBitLength() / 8;
                    cmd->setSendUnordered(cmd->getSendUnordered());
                    lastStream = (lastStream + 1) % outboundStreams;
                    cmd->setPrValue(0);
                    cmd->setSid(lastStream);
                    cmd->setLast(true);
                    cmsg->encapsulate(smsg);
                    cmsg->setKind(SCTP_C_SEND);
                    cmsg->setControlInfo(cmd);
                    packetsSent++;
                    sendOrSchedule(cmsg);
                }
                delete ind;
                break;
            }

            case SCTP_I_SHUTDOWN_RECEIVED: {
                SCTPCommand *command = check_and_cast<SCTPCommand *>(msg->removeControlInfo());
                id = command->getAssocId();
                EV_INFO << "server: SCTP_I_SHUTDOWN_RECEIVED for assoc " << id << "\n";
                auto i = serverAssocStatMap.find(id);
                if (i->second.sentPackets == 0 || par("numPacketsToSendPerClient").longValue() == 0) {
                    cMessage *cmsg = new cMessage("SCTP_C_NO_OUTSTANDING");
                    SCTPInfo *qinfo = new SCTPInfo("Info3");
                    cmsg->setKind(SCTP_C_NO_OUTSTANDING);
                    qinfo->setAssocId(id);
                    cmsg->setControlInfo(qinfo);
                    sendOrSchedule(cmsg);
                    i->second.stop = simTime();
                    i->second.lifeTime = i->second.stop - i->second.start;
                }
                delete command;
                shutdownReceived = true;
                delete msg;
                break;
            }

            case SCTP_I_SEND_STREAMS_RESETTED:
            case SCTP_I_RCV_STREAMS_RESETTED: {
                EV_INFO << "Streams have been resetted\n";
                delete msg;
                break;
            }

            case SCTP_I_CLOSED: {
                SCTPCommand *command = check_and_cast<SCTPCommand *>(msg->removeControlInfo());
                id = command->getAssocId();
                EV_INFO << "server: SCTP_I_CLOSED for assoc "  << id << endl;
                ServerAssocStatMap::iterator i = serverAssocStatMap.find(id);
                i->second.stop = simTime();
                i->second.lifeTime = i->second.stop - i->second.start;
                if (delayTimer->isScheduled())
                    cancelEvent(delayTimer);
                if (finishEndsSimulation)
                    endSimulation();
                delete command;
                delete msg;
                break;
            }

            default:
                delete msg;
                break;
        }
    }
}

virtual bool inet::SCTPServer::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::SCTPServer::handleTimer ( cMessage *  msg )

protected

Referenced by handleMessage().

{
    if (msg == delayTimer) {
        EV_INFO << simTime() << " delayTimer expired\n";
        sendOrSchedule(makeDefaultReceive());
        scheduleAt(simTime() + par("readingInterval"), delayTimer);
        return;
    }
    else if (msg == delayFirstReadTimer) {
        delayFirstRead = 0;

        if (readInt && !delayTimer->isScheduled()) {
            double tempInterval = par("readingInterval");
            scheduleAt(simTime() + (simtime_t)tempInterval, delayTimer);
            scheduleAt(simTime() + (simtime_t)tempInterval, makeDefaultReceive());
        }
        return;
    }

    switch (msg->getKind()) {
        case SCTP_C_SEND:
            if (numRequestsToSend > 0) {
                generateAndSend();
                if (par("thinkTime").doubleValue() > 0)
                    scheduleAt(simTime() + par("thinkTime"), timeoutMsg);
                numRequestsToSend--;
            }
            break;

        case SCTP_I_ABORT: {
            cMessage *cmsg = new cMessage("SCTP_C_CLOSE", SCTP_C_CLOSE);
            SCTPCommand *cmd = new SCTPCommand("Send6");
            int id = atoi(msg->getName());
            cmd->setAssocId(id);
            cmsg->setControlInfo(cmd);
            sendOrSchedule(cmsg);
        }
        break;

        case SCTP_C_RECEIVE:
            EV_INFO << simTime() << " SCTPServer:SCTP_C_RECEIVE\n";
            if (readInt || delayFirstRead > 0)
                schedule = false;
            else
                schedule = true;
            sendOrSchedule(msg);
            break;

        default:
            EV_INFO << "MsgKind =" << msg->getKind() << " unknown\n";
            break;
    }
}

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

overrideprotectedvirtual

{
    EV_DEBUG << "initialize SCTP Server stage " << stage << endl;

    cSimpleModule::initialize(stage);

    if (stage == INITSTAGE_LOCAL) {
        WATCH(numSessions);
        WATCH(packetsSent);
        WATCH(packetsRcvd);
        WATCH(bytesSent);
        WATCH(numRequestsToSend);

        // parameters
        finishEndsSimulation = par("finishEndsSimulation").boolValue();

        inboundStreams = par("inboundStreams");
        outboundStreams = par("outboundStreams");
        ordered = par("ordered").boolValue();
        queueSize = par("queueSize");
        timeoutMsg = new cMessage("SrvAppTimer");
        delayTimer = new cMessage("delayTimer");
        delayTimer->setContextPointer(this);
        delayFirstReadTimer = new cMessage("delayFirstReadTimer");

        echo = par("echo");
        delay = par("echoDelay");
        delayFirstRead = par("delayFirstRead");
        cPar *delT = &par("readingInterval");
        if (delT->isNumeric() && (double)*delT == 0)
            readInt = false;
        else
            readInt = true;
    }
    else if (stage == INITSTAGE_APPLICATION_LAYER) {
        const char *addressesString = par("localAddress");
        AddressVector addresses = L3AddressResolver().resolve(cStringTokenizer(addressesString).asVector());
        int port = par("localPort");
        int messagesToPush = par("messagesToPush");

        socket = new SCTPSocket();
        socket->setOutputGate(gate("sctpOut"));
        socket->setInboundStreams(inboundStreams);
        socket->setOutboundStreams(outboundStreams);

        if (addresses.size() == 0)
            socket->bind(port);
        else
            socket->bindx(addresses, port);

        socket->listen(true, par("streamReset").boolValue(), par("numPacketsToSendPerClient").longValue(), messagesToPush);
        EV_INFO << "SCTPServer::initialized listen port=" << port << "\n";
        cStringTokenizer tokenizer(par("streamPriorities").stringValue());
        for (unsigned int streamNum = 0; tokenizer.hasMoreTokens(); streamNum++) {
            const char *token = tokenizer.nextToken();
            socket->setStreamPriority(streamNum, (unsigned int)atoi(token));
        }

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

cMessage * inet::SCTPServer::makeAbortNotification ( SCTPCommand *  msg )

protected

Referenced by handleMessage().

{
    SCTPCommand *ind = check_and_cast<SCTPCommand *>(msg);
    cMessage *cmsg = new cMessage("SCTP_C_ABORT");
    SCTPSendInfo *cmd = new SCTPSendInfo("Send4");
    assocId = ind->getAssocId();
    cmd->setAssocId(assocId);
    cmd->setSid(ind->getSid());
    cmd->setNumMsgs(ind->getNumMsgs());
    cmsg->setControlInfo(cmd);
    delete ind;
    cmsg->setKind(SCTP_C_ABORT);
    return cmsg;
}

cMessage * inet::SCTPServer::makeDefaultReceive ( )

protected

Referenced by handleTimer().

{
    cMessage *cmsg = new cMessage("DefaultReceive");
    SCTPSendInfo *cmd = new SCTPSendInfo("Send3");
    cmd->setAssocId(assocId);
    cmd->setSid(0);
    cmd->setNumMsgs(1);
    cmsg->setKind(SCTP_C_RECEIVE);
    cmsg->setControlInfo(cmd);
    return cmsg;
}

cMessage * inet::SCTPServer::makeReceiveRequest ( cMessage *  msg )

protected

Referenced by handleMessage().

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

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

inlineoverrideprotectedvirtual

{ return NUM_INIT_STAGES; }

void inet::SCTPServer::sendOrSchedule ( cMessage *  msg )

protected

Referenced by generateAndSend(), handleMessage(), and handleTimer().

{
    if (delay == 0)
        send(msg, "sctpOut");
    else
        scheduleAt(simTime() + delay, msg);
}

Member Data Documentation

bool inet::SCTPServer::abortSent

protected

Referenced by handleMessage(), and SCTPServer().

int inet::SCTPServer::assocId

protected

Referenced by generateAndSend(), handleMessage(), makeAbortNotification(), makeDefaultReceive(), and SCTPServer().

BytesPerAssoc inet::SCTPServer::bytesPerAssoc

protected

Referenced by handleMessage(), and ~SCTPServer().

unsigned long int inet::SCTPServer::bytesSent

protected

Referenced by finish(), generateAndSend(), handleMessage(), initialize(), and SCTPServer().

int inet::SCTPServer::count

protected

Referenced by generateAndSend(), handleMessage(), and SCTPServer().

double inet::SCTPServer::delay

protected

Referenced by initialize(), SCTPServer(), and sendOrSchedule().

double inet::SCTPServer::delayFirstRead

protected

Referenced by handleMessage(), handleTimer(), initialize(), and SCTPServer().

cMessage* inet::SCTPServer::delayFirstReadTimer

protected

Referenced by handleMessage(), handleTimer(), initialize(), SCTPServer(), and ~SCTPServer().

cMessage* inet::SCTPServer::delayTimer

protected

Referenced by handleMessage(), handleTimer(), initialize(), SCTPServer(), and ~SCTPServer().

bool inet::SCTPServer::echo

protected

Referenced by handleMessage(), initialize(), and SCTPServer().

EndToEndDelay inet::SCTPServer::endToEndDelay

protected

Referenced by handleMessage(), and ~SCTPServer().

bool inet::SCTPServer::finishEndsSimulation

protected

Referenced by handleMessage(), initialize(), and SCTPServer().

bool inet::SCTPServer::firstData

protected

Referenced by handleMessage(), and SCTPServer().

int inet::SCTPServer::inboundStreams

protected

Referenced by handleMessage(), initialize(), and SCTPServer().

int inet::SCTPServer::lastStream

protected

Referenced by generateAndSend(), handleMessage(), and SCTPServer().

int inet::SCTPServer::notificationsReceived

protected

Referenced by finish(), handleMessage(), and SCTPServer().

unsigned long int inet::SCTPServer::numRequestsToSend

protected

Referenced by generateAndSend(), handleMessage(), handleTimer(), initialize(), and SCTPServer().

int inet::SCTPServer::numSessions

protected

Referenced by finish(), handleMessage(), initialize(), and SCTPServer().

bool inet::SCTPServer::ordered

protected

Referenced by generateAndSend(), initialize(), and SCTPServer().

int inet::SCTPServer::outboundStreams

protected

Referenced by generateAndSend(), handleMessage(), initialize(), and SCTPServer().

unsigned long int inet::SCTPServer::packetsRcvd

protected

Referenced by finish(), handleMessage(), initialize(), and SCTPServer().

unsigned long int inet::SCTPServer::packetsSent

protected

Referenced by finish(), generateAndSend(), handleMessage(), initialize(), and SCTPServer().

int inet::SCTPServer::queueSize

protected

Referenced by generateAndSend(), handleMessage(), initialize(), and SCTPServer().

bool inet::SCTPServer::readInt

protected

Referenced by handleMessage(), handleTimer(), initialize(), and SCTPServer().

bool inet::SCTPServer::schedule

protected

Referenced by handleMessage(), handleTimer(), and SCTPServer().

ServerAssocStatMap inet::SCTPServer::serverAssocStatMap

protected

Referenced by finish(), handleMessage(), and ~SCTPServer().

bool inet::SCTPServer::shutdownReceived

protected

Referenced by handleMessage(), and SCTPServer().

SCTPSocket* inet::SCTPServer::socket

protected

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

cMessage* inet::SCTPServer::timeoutMsg

protected

Referenced by handleMessage(), handleTimer(), initialize(), SCTPServer(), and ~SCTPServer().

---

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

• SCTPServer.h
• SCTPServer.cc