inet::TcpSessionApp Class Reference

Single-connection TCP application. More...

#include <TcpSessionApp.h>

Inheritance diagram for inet::TcpSessionApp:

Classes
struct	Command

Public Member Functions
	TcpSessionApp ()
virtual	~TcpSessionApp ()
Public Member Functions inherited from inet::ApplicationBase
	ApplicationBase ()
Public Member Functions inherited from inet::OperationalMixin< cSimpleModule >
virtual	~OperationalMixin ()
	}@ More...
Public Member Functions inherited from inet::ILifecycle
virtual	~ILifecycle ()
Public Member Functions inherited from inet::TcpSocket::ICallback
virtual	~ICallback ()

Protected Types
typedef std::vector< Command >	CommandVector
Protected Types inherited from inet::OperationalMixin< cSimpleModule >
enum	State

Protected Member Functions
virtual void	handleStartOperation (LifecycleOperation *operation) override
virtual void	handleStopOperation (LifecycleOperation *operation) override
virtual void	handleCrashOperation (LifecycleOperation *operation) override
virtual int	numInitStages () const override
virtual void	initialize (int stage) override
virtual void	finish () override
virtual void	refreshDisplay () const override
virtual void	parseScript (const char *script)
virtual Packet *	createDataPacket (long sendBytes)
virtual void	sendData ()
virtual void	handleTimer (cMessage *msg) override
virtual void	socketEstablished (TcpSocket *socket) override
virtual void	socketDataArrived (TcpSocket *socket, Packet *msg, bool urgent) override
	Notifies about data arrival, packet ownership is transferred to the callee. More...
virtual void	socketClosed (TcpSocket *socket) override
virtual void	socketFailure (TcpSocket *socket, int code) override
Protected Member Functions inherited from inet::TcpAppBase
virtual void	handleMessageWhenUp (cMessage *msg) override
virtual void	connect ()
virtual void	close ()
virtual void	sendPacket (Packet *pkt)
virtual void	socketAvailable (TcpSocket *socket, TcpAvailableInfo *availableInfo) override
virtual void	socketPeerClosed (TcpSocket *socket) override
virtual void	socketStatusArrived (TcpSocket *socket, TcpStatusInfo *status) override
virtual void	socketDeleted (TcpSocket *socket) override
Protected Member Functions inherited from inet::ApplicationBase
virtual bool	isInitializeStage (int stage) const override
virtual bool	isModuleStartStage (int stage) const override
virtual bool	isModuleStopStage (int stage) const override
Protected Member Functions inherited from inet::OperationalMixin< cSimpleModule >
virtual int	numInitStages () const override
virtual void	refreshDisplay () const override
virtual void	handleMessage (cMessage *msg) override
virtual void	handleMessageWhenDown (cMessage *msg)
virtual bool	handleOperationStage (LifecycleOperation *operation, IDoneCallback *doneCallback) override
	Perform one stage of a lifecycle operation. More...
virtual State	getInitialOperationalState () const
	Returns initial operational state: OPERATING or NOT_OPERATING. More...
virtual void	handleActiveOperationTimeout (cMessage *message)
virtual bool	isUp () const
	utility functions More...
virtual bool	isDown () const
virtual void	setOperationalState (State newState)
virtual void	scheduleOperationTimeout (simtime_t timeout)
virtual void	setupActiveOperation (LifecycleOperation *operation, IDoneCallback *doneCallback, State)
virtual void	delayActiveOperationFinish (simtime_t timeout)
virtual void	startActiveOperationExtraTime (simtime_t delay=SIMTIME_ZERO)
virtual void	startActiveOperationExtraTimeOrFinish (simtime_t extraTime)
virtual void	finishActiveOperation ()

Protected Attributes
CommandVector	commands
bool	activeOpen = false
simtime_t	tOpen
simtime_t	tSend
simtime_t	tClose
int	sendBytes = 0
int	commandIndex = -1
cMessage *	timeoutMsg = nullptr
Protected Attributes inherited from inet::TcpAppBase
TcpSocket	socket
int	numSessions
int	numBroken
int	packetsSent
int	packetsRcvd
int	bytesSent
int	bytesRcvd
Protected Attributes inherited from inet::OperationalMixin< cSimpleModule >
State	operationalState
simtime_t	lastChange
Operation	activeOperation
cMessage *	activeOperationTimeout
cMessage *	activeOperationExtraTimer

Additional Inherited Members
Static Protected Attributes inherited from inet::TcpAppBase
static simsignal_t	connectSignal = registerSignal("connect")

Detailed Description

Single-connection TCP application.

Member Typedef Documentation

CommandVector

typedef std::vector<Command> inet::TcpSessionApp::CommandVector

protected

Constructor & Destructor Documentation

TcpSessionApp()

inet::TcpSessionApp::TcpSessionApp ( )

inline

{}

~TcpSessionApp()

inet::TcpSessionApp::~TcpSessionApp ( )

virtual

{
    cancelAndDelete(timeoutMsg);
}

Member Function Documentation

createDataPacket()

Packet * inet::TcpSessionApp::createDataPacket ( long  sendBytes )

protectedvirtual

{
    const char *dataTransferMode = par("dataTransferMode");
    Ptr<Chunk> payload;
    if (!strcmp(dataTransferMode, "bytecount")) {
        payload = makeShared<ByteCountChunk>(B(sendBytes));
    }
    else if (!strcmp(dataTransferMode, "object")) {
        const auto& applicationPacket = makeShared<ApplicationPacket>();
        applicationPacket->setChunkLength(B(sendBytes));
        payload = applicationPacket;
    }
    else if (!strcmp(dataTransferMode, "bytestream")) {
        const auto& bytesChunk = makeShared<BytesChunk>();
        std::vector<uint8_t> vec;
        vec.resize(sendBytes);
        for (int i = 0; i < sendBytes; i++)
            vec[i] = (bytesSent + i) & 0xFF;
        bytesChunk->setBytes(vec);
        payload = bytesChunk;
    }
    else
        throw cRuntimeError("Invalid data transfer mode: %s", dataTransferMode);
    payload->addTag<CreationTimeTag>()->setCreationTime(simTime());
    Packet *packet = new Packet("data1");
    packet->insertAtBack(payload);
    return packet;
}

Referenced by sendData().

finish()

void inet::TcpSessionApp::finish ( )

overrideprotectedvirtual

Reimplemented from inet::TcpAppBase.

{
    EV << getFullPath() << ": received " << bytesRcvd << " bytes in " << packetsRcvd << " packets\n";
    recordScalar("bytesRcvd", bytesRcvd);
    recordScalar("bytesSent", bytesSent);
}

handleCrashOperation()

void inet::TcpSessionApp::handleCrashOperation ( LifecycleOperation *  operation )

overrideprotectedvirtual

Implements inet::OperationalMixin< cSimpleModule >.

{
    cancelEvent(timeoutMsg);
    if (operation->getRootModule() != getContainingNode(this))
        socket.destroy();
}

handleStartOperation()

void inet::TcpSessionApp::handleStartOperation ( LifecycleOperation *  operation )

overrideprotectedvirtual

Implements inet::OperationalMixin< cSimpleModule >.

{
    if (simTime() <= tOpen) {
        timeoutMsg->setKind(MSGKIND_CONNECT);
        scheduleAt(tOpen, timeoutMsg);
    }
}

handleStopOperation()

void inet::TcpSessionApp::handleStopOperation ( LifecycleOperation *  operation )

overrideprotectedvirtual

Implements inet::OperationalMixin< cSimpleModule >.

{
    cancelEvent(timeoutMsg);
    if (socket.isOpen())
        close();
    delayActiveOperationFinish(par("stopOperationTimeout"));
}

handleTimer()

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

overrideprotectedvirtual

Implements inet::TcpAppBase.

{
    switch (msg->getKind()) {
        case MSGKIND_CONNECT:
            if (activeOpen)
                connect(); // sending will be scheduled from socketEstablished()
            else
                throw cRuntimeError("TODO");
            break;
 
        case MSGKIND_SEND:
            sendData();
            break;
 
        case MSGKIND_CLOSE:
            close();
            break;
 
        default:
            throw cRuntimeError("Invalid timer msg: kind=%d", msg->getKind());
    }
}

initialize()

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

overrideprotectedvirtual

Reimplemented from inet::TcpAppBase.

{
    TcpAppBase::initialize(stage);
    if (stage == INITSTAGE_LOCAL) {
        activeOpen = par("active");
        tOpen = par("tOpen");
        tSend = par("tSend");
        tClose = par("tClose");
        sendBytes = par("sendBytes");
        commandIndex = 0;
 
        const char *script = par("sendScript");
        parseScript(script);
 
        if (sendBytes > 0 && commands.size() > 0)
            throw cRuntimeError("Cannot use both sendScript and tSend+sendBytes");
        if (sendBytes > 0)
            commands.push_back(Command(tSend, sendBytes));
        if (commands.size() == 0)
            throw cRuntimeError("sendScript is empty");
        timeoutMsg = new cMessage("timer");
    }
}

numInitStages()

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

inlineoverrideprotectedvirtual

Reimplemented from inet::TcpAppBase.

{ return NUM_INIT_STAGES; }

parseScript()

void inet::TcpSessionApp::parseScript ( const char *  script )

protectedvirtual

{
    const char *s = script;
 
    EV_DEBUG << "parse script \"" << script << "\"\n";
    while (*s) {
        // parse time
        while (isspace(*s))
            s++;
 
        if (!*s || *s == ';')
            break;
 
        const char *s0 = s;
        simtime_t tSend = strtod(s, &const_cast<char *&>(s));
 
        if (s == s0)
            throw cRuntimeError("Syntax error in script: simulation time expected");
 
        // parse number of bytes
        while (isspace(*s))
            s++;
 
        if (!isdigit(*s))
            throw cRuntimeError("Syntax error in script: number of bytes expected");
 
        long numBytes = strtol(s, nullptr, 10);
 
        while (isdigit(*s))
            s++;
 
        // add command
        EV_DEBUG << " add command (" << tSend << "s, " << numBytes << "B)\n";
        commands.push_back(Command(tSend, numBytes));
 
        // skip delimiter
        while (isspace(*s))
            s++;
 
        if (!*s)
            break;
 
        if (*s != ';')
            throw cRuntimeError("Syntax error in script: separator ';' missing");
 
        s++;
 
        while (isspace(*s))
            s++;
    }
    EV_DEBUG << "parser finished\n";
}

Referenced by initialize().

refreshDisplay()

void inet::TcpSessionApp::refreshDisplay ( ) const

overrideprotectedvirtual

Reimplemented from inet::TcpAppBase.

{
    TcpAppBase::refreshDisplay();
 
    std::ostringstream os;
    os << TcpSocket::stateName(socket.getState()) << "\nsent: " << bytesSent << " bytes\nrcvd: " << bytesRcvd << " bytes";
    getDisplayString().setTagArg("t", 0, os.str().c_str());
}

sendData()

void inet::TcpSessionApp::sendData ( )

protectedvirtual

{
    long numBytes = commands[commandIndex].numBytes;
    EV_INFO << "sending data with " << numBytes << " bytes\n";
    sendPacket(createDataPacket(numBytes));
 
    if (++commandIndex < (int)commands.size()) {
        simtime_t tSend = commands[commandIndex].tSend;
        scheduleAt(std::max(tSend, simTime()), timeoutMsg);
    }
    else {
        timeoutMsg->setKind(MSGKIND_CLOSE);
        scheduleAt(std::max(tClose, simTime()), timeoutMsg);
    }
}

Referenced by handleTimer().

socketClosed()

void inet::TcpSessionApp::socketClosed ( TcpSocket *  socket )

overrideprotectedvirtual

Reimplemented from inet::TcpAppBase.

{
    TcpAppBase::socketClosed(socket);
    cancelEvent(timeoutMsg);
    if (operationalState == State::STOPPING_OPERATION && !this->socket.isOpen())
        startActiveOperationExtraTimeOrFinish(par("stopOperationExtraTime"));
}

socketDataArrived()

void inet::TcpSessionApp::socketDataArrived ( TcpSocket *  socket, Packet *  packet, bool  urgent  )

overrideprotectedvirtual

Notifies about data arrival, packet ownership is transferred to the callee.

Reimplemented from inet::TcpAppBase.

{
    TcpAppBase::socketDataArrived(socket, msg, urgent);
}

socketEstablished()

void inet::TcpSessionApp::socketEstablished ( TcpSocket *  socket )

overrideprotectedvirtual

Reimplemented from inet::TcpAppBase.

{
    TcpAppBase::socketEstablished(socket);
 
    ASSERT(commandIndex == 0);
    timeoutMsg->setKind(MSGKIND_SEND);
    simtime_t tSend = commands[commandIndex].tSend;
    scheduleAt(std::max(tSend, simTime()), timeoutMsg);
}

socketFailure()

void inet::TcpSessionApp::socketFailure ( TcpSocket *  socket, int  code  )

overrideprotectedvirtual

Reimplemented from inet::TcpAppBase.

{
    TcpAppBase::socketFailure(socket, code);
    cancelEvent(timeoutMsg);
}

Member Data Documentation

activeOpen

bool inet::TcpSessionApp::activeOpen = false

protected

Referenced by handleTimer(), and initialize().

commandIndex

int inet::TcpSessionApp::commandIndex = -1

protected

Referenced by initialize(), sendData(), and socketEstablished().

commands

CommandVector inet::TcpSessionApp::commands

protected

Referenced by initialize(), parseScript(), sendData(), and socketEstablished().

sendBytes

int inet::TcpSessionApp::sendBytes = 0

protected

Referenced by createDataPacket(), and initialize().

tClose

simtime_t inet::TcpSessionApp::tClose

protected

Referenced by initialize(), and sendData().

timeoutMsg

cMessage* inet::TcpSessionApp::timeoutMsg = nullptr

protected

Referenced by handleCrashOperation(), handleStartOperation(), handleStopOperation(), initialize(), sendData(), socketClosed(), socketEstablished(), socketFailure(), and ~TcpSessionApp().

tOpen

simtime_t inet::TcpSessionApp::tOpen

protected

Referenced by handleStartOperation(), and initialize().

tSend

simtime_t inet::TcpSessionApp::tSend

protected

Referenced by initialize(), parseScript(), sendData(), and socketEstablished().

---

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

• TcpSessionApp.h
• TcpSessionApp.cc