inet::TcpGenericServerApp Class Reference

Generic server application. More...

#include <TcpGenericServerApp.h>

Inheritance diagram for inet::TcpGenericServerApp:

Protected Member Functions
virtual void	sendBack (cMessage *msg)
virtual void	sendOrSchedule (cMessage *msg, simtime_t delay)
virtual void	initialize (int stage) override
virtual int	numInitStages () const override
virtual void	handleMessage (cMessage *msg) override
virtual void	finish () override
virtual void	refreshDisplay () const override

Protected Attributes
TcpSocket	socket
simtime_t	delay
simtime_t	maxMsgDelay
long	msgsRcvd
long	msgsSent
long	bytesRcvd
long	bytesSent
std::map< int, ChunkQueue >	socketQueue

Additional Inherited Members
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 ()

Detailed Description

Generic server application.

It serves requests coming in GenericAppMsg request messages. Clients are usually subclassed from TcpAppBase.

See also

GenericAppMsg, TcpAppBase

Member Function Documentation

finish()

void inet::TcpGenericServerApp::finish ( )

overrideprotectedvirtual

{
    EV_INFO << getFullPath() << ": sent " << bytesSent << " bytes in " << msgsSent << " packets\n";
    EV_INFO << getFullPath() << ": received " << bytesRcvd << " bytes in " << msgsRcvd << " packets\n";
}

handleMessage()

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

overrideprotectedvirtual

{
    if (msg->isSelfMessage()) {
        sendBack(msg);
    }
    else if (msg->getKind() == TCP_I_PEER_CLOSED) {
        // we'll close too, but only after there's surely no message
        // pending to be sent back in this connection
        int connId = check_and_cast<Indication *>(msg)->getTag<SocketInd>()->getSocketId();
        delete msg;
        auto request = new Request("close", TCP_C_CLOSE);
        request->addTag<SocketReq>()->setSocketId(connId);
        sendOrSchedule(request, delay + maxMsgDelay);
    }
    else if (msg->getKind() == TCP_I_DATA || msg->getKind() == TCP_I_URGENT_DATA) {
        Packet *packet = check_and_cast<Packet *>(msg);
        int connId = packet->getTag<SocketInd>()->getSocketId();
        ChunkQueue& queue = socketQueue[connId];
        auto chunk = packet->peekDataAt(B(0), packet->getTotalLength());
        queue.push(chunk);
        emit(packetReceivedSignal, packet);
 
        bool doClose = false;
        while (const auto& appmsg = queue.pop<GenericAppMsg>(b(-1), Chunk::PF_ALLOW_NULLPTR)) {
            msgsRcvd++;
            bytesRcvd += B(appmsg->getChunkLength()).get();
            B requestedBytes = appmsg->getExpectedReplyLength();
            simtime_t msgDelay = appmsg->getReplyDelay();
            if (msgDelay > maxMsgDelay)
                maxMsgDelay = msgDelay;
 
            if (requestedBytes > B(0)) {
                Packet *outPacket = new Packet(msg->getName(), TCP_C_SEND);
                outPacket->addTag<SocketReq>()->setSocketId(connId);
                const auto& payload = makeShared<GenericAppMsg>();
                payload->setChunkLength(requestedBytes);
                payload->setExpectedReplyLength(B(0));
                payload->setReplyDelay(0);
                payload->addTag<CreationTimeTag>()->setCreationTime(simTime());
                outPacket->insertAtBack(payload);
                sendOrSchedule(outPacket, delay + msgDelay);
            }
            if (appmsg->getServerClose()) {
                doClose = true;
                break;
            }
        }
        delete msg;
 
        if (doClose) {
            auto request = new Request("close", TCP_C_CLOSE);
            TcpCommand *cmd = new TcpCommand();
            request->addTag<SocketReq>()->setSocketId(connId);
            request->setControlInfo(cmd);
            sendOrSchedule(request, delay + maxMsgDelay);
        }
    }
    else if (msg->getKind() == TCP_I_AVAILABLE)
        socket.processMessage(msg);
    else {
        // some indication -- ignore
        EV_WARN << "drop msg: " << msg->getName() << ", kind:" << msg->getKind() << "(" << cEnum::get("inet::TcpStatusInd")->getStringFor(msg->getKind()) << ")\n";
        delete msg;
    }
}

initialize()

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

overrideprotectedvirtual

{
    cSimpleModule::initialize(stage);
 
    if (stage == INITSTAGE_LOCAL) {
        delay = par("replyDelay");
        maxMsgDelay = 0;
 
        // statistics
        msgsRcvd = msgsSent = bytesRcvd = bytesSent = 0;
 
        WATCH(msgsRcvd);
        WATCH(msgsSent);
        WATCH(bytesRcvd);
        WATCH(bytesSent);
    }
    else if (stage == INITSTAGE_APPLICATION_LAYER) {
        const char *localAddress = par("localAddress");
        int localPort = par("localPort");
        socket.setOutputGate(gate("socketOut"));
        socket.bind(localAddress[0] ? L3AddressResolver().resolve(localAddress) : L3Address(), localPort);
        socket.listen();
 
        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");
    }
}

numInitStages()

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

inlineoverrideprotectedvirtual

{ return NUM_INIT_STAGES; }

refreshDisplay()

void inet::TcpGenericServerApp::refreshDisplay ( ) const

overrideprotectedvirtual

{
    char buf[64];
    sprintf(buf, "rcvd: %ld pks %ld bytes\nsent: %ld pks %ld bytes", msgsRcvd, bytesRcvd, msgsSent, bytesSent);
    getDisplayString().setTagArg("t", 0, buf);
}

sendBack()

void inet::TcpGenericServerApp::sendBack ( cMessage *  msg )

protectedvirtual

{
    Packet *packet = dynamic_cast<Packet *>(msg);
 
    if (packet) {
        msgsSent++;
        bytesSent += packet->getByteLength();
        emit(packetSentSignal, packet);
 
        EV_INFO << "sending \"" << packet->getName() << "\" to TCP, " << packet->getByteLength() << " bytes\n";
    }
    else {
        EV_INFO << "sending \"" << msg->getName() << "\" to TCP\n";
    }
 
    auto& tags = check_and_cast<ITaggedObject *>(msg)->getTags();
    tags.addTagIfAbsent<DispatchProtocolReq>()->setProtocol(&Protocol::tcp);
    send(msg, "socketOut");
}

Referenced by handleMessage(), and sendOrSchedule().

sendOrSchedule()

void inet::TcpGenericServerApp::sendOrSchedule ( cMessage *  msg, simtime_t  delay  )

protectedvirtual

{
    if (delay == 0)
        sendBack(msg);
    else
        scheduleAfter(delay, msg);
}

Referenced by handleMessage().

Member Data Documentation

bytesRcvd

long inet::TcpGenericServerApp::bytesRcvd

protected

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

bytesSent

long inet::TcpGenericServerApp::bytesSent

protected

Referenced by finish(), initialize(), refreshDisplay(), and sendBack().

delay

simtime_t inet::TcpGenericServerApp::delay

protected

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

maxMsgDelay

simtime_t inet::TcpGenericServerApp::maxMsgDelay

protected

Referenced by handleMessage(), and initialize().

msgsRcvd

long inet::TcpGenericServerApp::msgsRcvd

protected

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

msgsSent

long inet::TcpGenericServerApp::msgsSent

protected

Referenced by finish(), initialize(), refreshDisplay(), and sendBack().

socket

TcpSocket inet::TcpGenericServerApp::socket

protected

Referenced by handleMessage(), and initialize().

socketQueue

std::map<int, ChunkQueue> inet::TcpGenericServerApp::socketQueue

protected

Referenced by handleMessage().

---

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

• TcpGenericServerApp.h
• TcpGenericServerApp.cc