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::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< 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)
void	sendOrSchedule (Message *msg)
void	sendOrSchedule (Packet *pkt)
Message *	makeAbortNotification (const SctpCommandReq *msg)
Message *	makeReceiveRequest (cMessage *msg)
Message *	makeDefaultReceive ()
void	generateAndSend ()

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

BytesPerAssoc

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

protected

EndToEndDelay

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

protected

ServerAssocStatMap

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

protected

Constructor & Destructor Documentation

~SctpServer()

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

SctpServer()

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

finish()

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

generateAndSend()

void inet::SctpServer::generateAndSend ( )

protected

{
    auto applicationPacket = new Packet("ApplicationPacket");
    auto applicationData = makeShared<BytesChunk>();
    int numBytes = par("requestLength");
    std::vector<uint8_t> vec;
    vec.resize(numBytes);
    for (int i = 0; i < numBytes; i++)
        vec[i] = (bytesSent + i) & 0xFF;
    applicationData->setBytes(vec);
    applicationData->addTag<CreationTimeTag>()->setCreationTime(simTime());
    applicationPacket->insertAtBack(applicationData);
    auto sctpSendReq = applicationPacket->addTag<SctpSendReq>();
    if (queueSize > 0 && numRequestsToSend > 0 && count < queueSize * 2)
        sctpSendReq->setLast(false);
    else
        sctpSendReq->setLast(true);
    sctpSendReq->setPrMethod(par("prMethod"));
    sctpSendReq->setPrValue(par("prValue"));
    lastStream = (lastStream + 1) % outboundStreams;
    sctpSendReq->setSid(lastStream);
    sctpSendReq->setSocketId(assocId);
    applicationPacket->setKind(ordered ? SCTP_C_SEND_ORDERED : SCTP_C_SEND_UNORDERED);
    applicationPacket->addTag<SocketReq>()->setSocketId(assocId);
    applicationPacket->addTag<DispatchProtocolReq>()->setProtocol(&Protocol::sctp);
    bytesSent += numBytes;
    packetsSent++;
    sendOrSchedule(applicationPacket);
}

Referenced by handleMessage(), and handleTimer().

handleMessage()

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

overrideprotectedvirtual

{
    // TODO there is another memory leak somewhere...
    int id = 0;
    EV_INFO << "SctpServer::handleMessage\n";
    if (msg->isSelfMessage())
        handleTimer(msg);
    else {
        switch (msg->getKind()) {
            case SCTP_I_PEER_CLOSED:
            case SCTP_I_ABORT: {
                Message *message = check_and_cast<Message *>(msg);
                assocId = message->getTag<SocketInd>()->getSocketId();
                const auto& command = message->findTag<SctpCommandReq>();
                serverAssocStatMap[assocId].peerClosed = true;
                if (par("numPacketsToReceivePerClient").intValue() == 0) {
                    if (serverAssocStatMap[assocId].abortSent == false) {
                        sendOrSchedule(makeAbortNotification(command->dup()));
                        serverAssocStatMap[assocId].abortSent = true;
                    }
                }
                else {
                    if (serverAssocStatMap[assocId].rcvdPackets == static_cast<unsigned long 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 msg;
                break;
            }
            case SCTP_I_AVAILABLE: {
                EV_INFO << "SCTP_I_AVAILABLE arrived at server\n";
                Message *message = check_and_cast<Message *>(msg);
                int newSockId = message->getTag<SctpAvailableReq>()->getNewSocketId();
                EV_INFO << "new socket id = " << newSockId << endl;
                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);
                EV_INFO << "Sending accept socket id request ..." << endl;
                delete msg;
                send(cmsg, "socketOut");
                break;
            }
            case SCTP_I_ESTABLISHED: {
                count = 0;
                Message *message = check_and_cast<Message *>(msg);
                auto& connectInfo = message->getTag<SctpConnectReq>();
                numSessions++;
                assocId = connectInfo->getSocketId();
                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 msg;
                if (par("numPacketsToSendPerClient").intValue() > 0) {
                    auto i = serverAssocStatMap.find(assocId);
                    numRequestsToSend = i->second.sentPackets;
                    if (par("thinkTime").doubleValue() > 0) {
                        generateAndSend();
                        timeoutMsg->setKind(SCTP_C_SEND);
                        scheduleAfter(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;
                            }
 
                            Request *cmsg = new Request("SCTP_C_QUEUE_MSGS_LIMIT", SCTP_C_QUEUE_MSGS_LIMIT);
                            auto& qinfo = cmsg->addTag<SctpInfoReq>();
                            qinfo->setText(queueSize);
                            qinfo->setSocketId(id);
                            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, SCTP_I_ABORT);
                            scheduleAfter(par("waitToClose"), abortMsg);
                        }
                        else {
                            EV_INFO << "no more packets to send, call shutdown for assoc " << assocId << "\n";
                            Request *cmsg = new Request("ShutdownRequest", SCTP_C_SHUTDOWN);
                            auto& cmd = cmsg->addTag<SctpCommandReq>();
                            cmd->setSocketId(assocId);
                            sendOrSchedule(cmsg);
                        }
                    }
                }
                break;
            }
 
            case SCTP_I_DATA_NOTIFICATION: {
                notificationsReceived++;
                Message *cmsg;
                if (schedule == false) {
                    if (delayFirstRead > 0 && !delayFirstReadTimer->isScheduled()) {
                        cmsg = makeReceiveRequest(msg);
                        scheduleAfter(delayFirstRead, cmsg);
                        scheduleAfter(delayFirstRead, delayFirstReadTimer);
                    }
                    else if (readInt && firstData) {
                        firstData = false;
                        cmsg = makeReceiveRequest(msg);
                        scheduleAfter(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";
                Packet *message = check_and_cast<Packet *>(msg);
                auto& tags = message->getTags();
                const auto& ind = tags.findTag<SctpRcvReq>();
                id = ind->getSocketId();
                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").intValue() > 0) {
                        j->second.rcvdPackets--;
 
                        auto m = endToEndDelay.find(id);
                        for (auto& region : message->peekData()->getAllTags<CreationTimeTag>())
                            m->second->record(simTime() - region.getTag()->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.get()));
                                serverAssocStatMap[assocId].abortSent = true;
                                j->second.stop = simTime();
                                j->second.lifeTime = j->second.stop - j->second.start;
                                break;
                            }
                            else {
                                Request *cmsg = new Request("SCTP_C_NO_OUTSTANDING", SCTP_C_NO_OUTSTANDING);
                                auto& qinfo = cmsg->addTag<SctpCommandReq>();
                                qinfo->setSocketId(id);
                                sendOrSchedule(cmsg);
                                j->second.stop = simTime();
                                j->second.lifeTime = j->second.stop - j->second.start;
                            }
                        }
                    }
                }
                else {
                    auto m = endToEndDelay.find(id);
                    const auto& smsg = message->peekData();
 
                    for (auto& region : smsg->getAllTags<CreationTimeTag>())
                        m->second->record(simTime() - region.getTag()->getCreationTime());
 
                    auto cmsg = new Packet("ApplicationPacket");
                    cmsg->insertAtBack(smsg);
                    auto cmd = cmsg->addTag<SctpSendReq>();
                    lastStream = (lastStream + 1) % outboundStreams;
                    cmd->setLast(true);
                    cmd->setSocketId(id);
                    cmd->setPrValue(0);
                    cmd->setSid(lastStream);
                    cmsg->setKind(cmd->getSendUnordered() ? SCTP_C_SEND_UNORDERED : SCTP_C_SEND_ORDERED);
                    bytesSent += B(smsg->getChunkLength()).get();
                    packetsSent++;
                    sendOrSchedule(cmsg);
                }
                delete msg;
                break;
            }
 
            case SCTP_I_SHUTDOWN_RECEIVED: {
                Message *message = check_and_cast<Message *>(msg);
                id = message->getTag<SocketInd>()->getSocketId();
                EV_INFO << "server: SCTP_I_SHUTDOWN_RECEIVED for assoc " << id << "\n";
                auto i = serverAssocStatMap.find(id);
                if (i->second.sentPackets == 0 || par("numPacketsToSendPerClient").intValue() == 0) {
                    Request *cmsg = new Request("SCTP_C_NO_OUTSTANDING", SCTP_C_NO_OUTSTANDING);
                    auto& qinfo = cmsg->addTag<SctpCommandReq>();
                    qinfo->setSocketId(id);
                    sendOrSchedule(cmsg);
                    i->second.stop = simTime();
                    i->second.lifeTime = i->second.stop - i->second.start;
                }
                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: {
                Message *message = check_and_cast<Message *>(msg);
                id = message->getTag<SocketInd>()->getSocketId();
                EV_INFO << "server: SCTP_I_CLOSED for assoc " << id << endl;
                auto 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 msg;
                break;
            }
 
            default:
                delete msg;
                break;
        }
    }
}

handleTimer()

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

protected

{
    if (msg == delayTimer) {
        if (delayFirstRead == 0) {
            sendOrSchedule(makeDefaultReceive());
            scheduleAfter(par("readingInterval"), delayTimer);
        }
        return;
    }
    else if (msg == delayFirstReadTimer) {
        delayFirstRead = 0;
        if (readInt && !delayTimer->isScheduled()) {
            simtime_t tempInterval = par("readingInterval");
            scheduleAfter(tempInterval, delayTimer);
            scheduleAfter(tempInterval, makeDefaultReceive());
        }
        return;
    }
 
    switch (msg->getKind()) {
        case SCTP_C_SEND:
            if (numRequestsToSend > 0) {
                generateAndSend();
                if (par("thinkTime").doubleValue() > 0)
                    scheduleAfter(par("thinkTime"), timeoutMsg);
                numRequestsToSend--;
            }
            break;
 
        case SCTP_I_ABORT: {
            Request *cmsg = new Request("SCTP_C_CLOSE", SCTP_C_CLOSE);
            auto& cmd = cmsg->addTag<SctpCommandReq>();
            int id = atoi(msg->getName());
            cmd->setSocketId(id);
            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;
    }
}

Referenced by handleMessage().

initialize()

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");
 
        inboundStreams = par("inboundStreams");
        outboundStreams = par("outboundStreams");
        ordered = par("ordered");
        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() && delT->doubleValue() == 0) // FIXME why used the isNumeric() ?
            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("socketOut"));
        socket->setInboundStreams(inboundStreams);
        socket->setOutboundStreams(outboundStreams);
 
        if (addresses.size() == 0)
            socket->bind(port);
        else
            socket->bindx(addresses, port);
 
        socket->listen(true, par("streamReset"), par("numPacketsToSendPerClient"), messagesToPush);
        EV_INFO << "SctpServer::initialized listen port=" << port << "\n";
        cStringTokenizer tokenizer(par("streamPriorities"));
        for (unsigned int streamNum = 0; tokenizer.hasMoreTokens(); streamNum++) {
            const char *token = tokenizer.nextToken();
            socket->setStreamPriority(streamNum, (unsigned int)atoi(token));
        }
 
        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");
    }
}

makeAbortNotification()

Message * inet::SctpServer::makeAbortNotification ( const SctpCommandReq *  msg )

protected

{
    Request *cmsg = new Request("SCTP_C_ABORT", SCTP_C_ABORT);
    auto& cmd = cmsg->addTag<SctpSendReq>();
    assocId = msg->getSocketId();
    cmd->setSocketId(assocId);
    cmd->setSid(msg->getSid());
    cmd->setNumMsgs(msg->getNumMsgs());
    return cmsg;
}

Referenced by handleMessage().

makeDefaultReceive()

Message * inet::SctpServer::makeDefaultReceive ( )

protected

{
    Request *cmsg = new Request("DefaultReceive", SCTP_C_RECEIVE);
    auto& cmd = cmsg->addTag<SctpCommandReq>();
    cmd->setSocketId(assocId);
    cmd->setSid(0);
    cmd->setNumMsgs(1);
    return cmsg;
}

Referenced by handleTimer().

makeReceiveRequest()

Message * inet::SctpServer::makeReceiveRequest ( cMessage *  msg )

protected

{
    Message *message = check_and_cast<Message *>(msg);
    auto& intags = message->getTags();
    const auto& ind = intags.findTag<SctpCommandReq>();
    Request *cmsg = new Request("ReceiveRequest", SCTP_C_RECEIVE);
    auto cmd = cmsg->addTag<SctpSendReq>();
    cmd->setSocketId(ind->getSocketId());
    cmd->setSid(ind->getSid());
    cmd->setNumMsgs(ind->getNumMsgs());
    return cmsg;
}

Referenced by handleMessage().

numInitStages()

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

inlineoverrideprotectedvirtual

{ return NUM_INIT_STAGES; }

sendOrSchedule() [1/3]

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

protected

{
    if (delay == 0)
        send(msg, "socketOut");
    else
        scheduleAfter(delay, msg);
}

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

sendOrSchedule() [2/3]

void inet::SctpServer::sendOrSchedule ( Message *  msg )

protected

{
    msg->addTagIfAbsent<DispatchProtocolReq>()->setProtocol(&Protocol::sctp);
    msg->addTagIfAbsent<SocketReq>()->setSocketId(assocId);
    if (delay == 0)
        send(msg, "socketOut");
    else
        scheduleAfter(delay, msg);
}

sendOrSchedule() [3/3]

void inet::SctpServer::sendOrSchedule ( Packet *  pkt )

protected

{
    pkt->addTagIfAbsent<DispatchProtocolReq>()->setProtocol(&Protocol::sctp);
    pkt->addTagIfAbsent<SocketReq>()->setSocketId(assocId);
    if (delay == 0)
        send(pkt, "socketOut");
    else
        scheduleAfter(delay, pkt);
}

Member Data Documentation

abortSent

bool inet::SctpServer::abortSent

protected

Referenced by handleMessage(), and SctpServer().

assocId

int inet::SctpServer::assocId

protected

Referenced by generateAndSend(), handleMessage(), makeAbortNotification(), makeDefaultReceive(), SctpServer(), and sendOrSchedule().

bytesPerAssoc

BytesPerAssoc inet::SctpServer::bytesPerAssoc

protected

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

bytesSent

unsigned long int inet::SctpServer::bytesSent

protected

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

count

int inet::SctpServer::count

protected

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

delay

double inet::SctpServer::delay

protected

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

delayFirstRead

double inet::SctpServer::delayFirstRead

protected

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

delayFirstReadTimer

cMessage* inet::SctpServer::delayFirstReadTimer

protected

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

delayTimer

cMessage* inet::SctpServer::delayTimer

protected

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

echo

bool inet::SctpServer::echo

protected

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

endToEndDelay

EndToEndDelay inet::SctpServer::endToEndDelay

protected

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

finishEndsSimulation

bool inet::SctpServer::finishEndsSimulation

protected

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

firstData

bool inet::SctpServer::firstData

protected

Referenced by handleMessage(), and SctpServer().

inboundStreams

int inet::SctpServer::inboundStreams

protected

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

lastStream

int inet::SctpServer::lastStream

protected

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

notificationsReceived

int inet::SctpServer::notificationsReceived

protected

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

numRequestsToSend

unsigned long int inet::SctpServer::numRequestsToSend

protected

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

numSessions

int inet::SctpServer::numSessions

protected

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

ordered

bool inet::SctpServer::ordered

protected

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

outboundStreams

int inet::SctpServer::outboundStreams

protected

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

packetsRcvd

unsigned long int inet::SctpServer::packetsRcvd

protected

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

packetsSent

unsigned long int inet::SctpServer::packetsSent

protected

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

queueSize

int inet::SctpServer::queueSize

protected

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

readInt

bool inet::SctpServer::readInt

protected

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

schedule

bool inet::SctpServer::schedule

protected

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

serverAssocStatMap

ServerAssocStatMap inet::SctpServer::serverAssocStatMap

protected

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

shutdownReceived

bool inet::SctpServer::shutdownReceived

protected

Referenced by handleMessage(), and SctpServer().

socket

SctpSocket* inet::SctpServer::socket

protected

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

timeoutMsg

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