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::TCPSocket::CallbackInterface
virtual	~CallbackInterface ()
virtual void	socketDeleted (int connId, void *yourPtr)

Protected Types
typedef std::vector< Command >	CommandVector

Protected Member Functions
virtual bool	isNodeUp ()
virtual bool	handleOperationStage (LifecycleOperation *operation, int stage, IDoneCallback *doneCallback)
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 cPacket *	createDataPacket (long sendBytes)
virtual void	sendData ()
virtual void	handleTimer (cMessage *msg) override
virtual void	socketEstablished (int connId, void *yourPtr) override
virtual void	socketDataArrived (int connId, void *yourPtr, cPacket *msg, bool urgent) override
virtual void	socketClosed (int connId, void *yourPtr) override
virtual void	socketFailure (int connId, void *yourPtr, int code) override
Protected Member Functions inherited from inet::TCPAppBase
virtual void	handleMessage (cMessage *msg) override
virtual void	connect ()
virtual void	close ()
virtual void	sendPacket (cPacket *pkt)
virtual void	socketPeerClosed (int connId, void *yourPtr) override
virtual void	socketStatusArrived (int connId, void *yourPtr, TCPStatusInfo *status) override

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
NodeStatus *	nodeStatus = nullptr
Protected Attributes inherited from inet::TCPAppBase
TCPSocket	socket
int	numSessions
int	numBroken
int	packetsSent
int	packetsRcvd
int	bytesSent
int	bytesRcvd

Additional Inherited Members
Static Protected Attributes inherited from inet::TCPAppBase
static simsignal_t	connectSignal = registerSignal("connect")
static simsignal_t	rcvdPkSignal = registerSignal("rcvdPk")
static simsignal_t	sentPkSignal = registerSignal("sentPk")

Detailed Description

Single-connection TCP application.

Member Typedef Documentation

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

protected

Constructor & Destructor Documentation

inet::TCPSessionApp::TCPSessionApp ( )

inline

{}

inet::TCPSessionApp::~TCPSessionApp ( )

virtual

{
    cancelAndDelete(timeoutMsg);
}

Member Function Documentation

cPacket * inet::TCPSessionApp::createDataPacket ( long  sendBytes )

protectedvirtual

Referenced by sendData().

{
    switch (socket.getDataTransferMode()) {
        case TCP_TRANSFER_BYTECOUNT:
        case TCP_TRANSFER_OBJECT: {
            cPacket *msg = nullptr;
            msg = new cPacket("data1");
            msg->setByteLength(sendBytes);
            return msg;
        }

        case TCP_TRANSFER_BYTESTREAM: {
            RawPacket *msg = new RawPacket("data1");
            unsigned char *ptr = new unsigned char[sendBytes];

            for (int i = 0; i < sendBytes; i++)
                ptr[i] = (bytesSent + i) & 0xFF;

            msg->getByteArray().assignBuffer(ptr, sendBytes);
            msg->setByteLength(sendBytes);
            return msg;
        }

        default:
            throw cRuntimeError("Invalid TCP data transfer mode: %d", socket.getDataTransferMode());
    }
}

void inet::TCPSessionApp::finish ( )

overrideprotectedvirtual

Reimplemented from inet::TCPAppBase.

Reimplemented in inet::PacketDrillApp.

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

bool inet::TCPSessionApp::handleOperationStage ( LifecycleOperation *  operation, int  stage, IDoneCallback *  doneCallback  )

protectedvirtual

Reimplemented in inet::PacketDrillApp.

{
    Enter_Method_Silent();
    if (dynamic_cast<NodeStartOperation *>(operation)) {
        if ((NodeStartOperation::Stage)stage == NodeStartOperation::STAGE_APPLICATION_LAYER) {
            if (simTime() <= tOpen) {
                timeoutMsg->setKind(MSGKIND_CONNECT);
                scheduleAt(tOpen, timeoutMsg);
            }
        }
    }
    else if (dynamic_cast<NodeShutdownOperation *>(operation)) {
        if ((NodeShutdownOperation::Stage)stage == NodeShutdownOperation::STAGE_APPLICATION_LAYER) {
            cancelEvent(timeoutMsg);
            if (socket.getState() == TCPSocket::CONNECTED || socket.getState() == TCPSocket::CONNECTING || socket.getState() == TCPSocket::PEER_CLOSED)
                close();
            // TODO: wait until socket is closed
        }
    }
    else if (dynamic_cast<NodeCrashOperation *>(operation)) {
        if ((NodeCrashOperation::Stage)stage == NodeCrashOperation::STAGE_CRASH)
            cancelEvent(timeoutMsg);
    }
    else
        throw cRuntimeError("Unsupported lifecycle operation '%s'", operation->getClassName());
    return true;
}

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

overrideprotectedvirtual

Implements inet::TCPAppBase.

Reimplemented in inet::PacketDrillApp.

{
    switch (msg->getKind()) {
        case MSGKIND_CONNECT:
            if (activeOpen)
                connect(); // sending will be scheduled from socketEstablished()
            else
                ; //TODO
            break;

        case MSGKIND_SEND:
            sendData();
            break;

        case MSGKIND_CLOSE:
            close();
            break;

        default:
            throw cRuntimeError("Invalid timer msg: kind=%d", msg->getKind());
    }
}

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

overrideprotectedvirtual

Reimplemented from inet::TCPAppBase.

Reimplemented in inet::PacketDrillApp.

{
    TCPAppBase::initialize(stage);
    if (stage == INITSTAGE_LOCAL) {
        activeOpen = par("active");
        tOpen = par("tOpen");
        tSend = par("tSend");
        tClose = par("tClose");
        sendBytes = par("sendBytes");
        commandIndex = 0;

        socket.readDataTransferModePar(*this);

        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");
    }
    else if (stage == INITSTAGE_APPLICATION_LAYER) {
        timeoutMsg = new cMessage("timer");
        nodeStatus = dynamic_cast<NodeStatus *>(findContainingNode(this)->getSubmodule("status"));

        if (isNodeUp()) {
            timeoutMsg->setKind(MSGKIND_CONNECT);
            scheduleAt(tOpen, timeoutMsg);
        }
    }
}

bool inet::TCPSessionApp::isNodeUp ( )

protectedvirtual

Referenced by initialize().

{
    return !nodeStatus || nodeStatus->getState() == NodeStatus::UP;
}

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

inlineoverrideprotectedvirtual

Reimplemented from inet::TCPAppBase.

Reimplemented in inet::PacketDrillApp.

{ return NUM_INIT_STAGES; }

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

protectedvirtual

Referenced by initialize().

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

void inet::TCPSessionApp::refreshDisplay ( ) const

overrideprotectedvirtual

Reimplemented from inet::TCPAppBase.

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

void inet::TCPSessionApp::sendData ( )

protectedvirtual

Referenced by handleTimer().

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

void inet::TCPSessionApp::socketClosed ( int  connId, void *  yourPtr  )

overrideprotectedvirtual

Reimplemented from inet::TCPAppBase.

{
    TCPAppBase::socketClosed(connId, ptr);
    cancelEvent(timeoutMsg);
}

void inet::TCPSessionApp::socketDataArrived ( int  connId, void *  yourPtr, cPacket *  msg, bool  urgent  )

overrideprotectedvirtual

Reimplemented from inet::TCPAppBase.

{
    TCPAppBase::socketDataArrived(connId, ptr, msg, urgent);
}

void inet::TCPSessionApp::socketEstablished ( int  connId, void *  yourPtr  )

overrideprotectedvirtual

Reimplemented from inet::TCPAppBase.

{
    TCPAppBase::socketEstablished(connId, ptr);

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

void inet::TCPSessionApp::socketFailure ( int  connId, void *  yourPtr, int  code  )

overrideprotectedvirtual

Reimplemented from inet::TCPAppBase.

{
    TCPAppBase::socketFailure(connId, ptr, code);
    cancelEvent(timeoutMsg);
}

Member Data Documentation

bool inet::TCPSessionApp::activeOpen = false

protected

Referenced by handleTimer(), and initialize().

int inet::TCPSessionApp::commandIndex = -1

protected

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

CommandVector inet::TCPSessionApp::commands

protected

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

NodeStatus* inet::TCPSessionApp::nodeStatus = nullptr

protected

Referenced by initialize(), and isNodeUp().

int inet::TCPSessionApp::sendBytes = 0

protected

Referenced by createDataPacket(), and initialize().

simtime_t inet::TCPSessionApp::tClose

protected

Referenced by initialize(), and sendData().

cMessage* inet::TCPSessionApp::timeoutMsg = nullptr

protected

Referenced by handleOperationStage(), initialize(), sendData(), socketClosed(), socketEstablished(), socketFailure(), and ~TCPSessionApp().

simtime_t inet::TCPSessionApp::tOpen

protected

Referenced by handleOperationStage(), and initialize().

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